ConnectError::Sasl about ntex-amqp HOT 6 CLOSED

// Azure Iot Hub
pub struct Client{
    // The azure client
}
impl Client{
    // The client methods
}

pub enum GenSasTokenException{
    DECODEBASE64,
    INVALIDKEYLENGTH,
}

pub fn hostname(iot_hub_name: String) -> String{
    format!("{}.azure-devices.net", iot_hub_name)
}

pub fn generate_sas_token(key: String, device_id: String, hub_name: String, validity_days: i64) -> Result<String, GenSasTokenException>{
    // Generate a VALID SAS token
    // Recoded from the rust azure SDK (mqtt) and the generate_sas_token function (Python SDK)
    let b64_key = base64::decode(&key);
    if b64_key.is_err(){
        // Failed to decode
        trace!("Failed to decode base64 key.");
        return Err(GenSasTokenException::DECODEBASE64)
    }
    // Continue
    // Is the key the right length?
    let check_hmac = Hmac::<Sha256>::new_from_slice(&b64_key.unwrap());
    if check_hmac.is_err(){
        // Failed the length
        trace!("The length of the key is invalid.");
        return Err(GenSasTokenException::INVALIDKEYLENGTH)
    }
    // Continue
    // Create the expire date.
    let mut time_now = chrono::offset::Utc::now();
    // Add the amount of days
    let mut add_days = Duration::days(validity_days);
    let mut time_now_plus_day = time_now.add(add_days);
    // Now lets generate the token.
    let expiry_timestamp = time_now_plus_day.timestamp();
    let hub_url = format!("{}.azure-devices.net%2Fdevices%2F{}", hub_name, device_id);
    //  Coded to_sign
    let to_sign = format!("{}\n{}", &hub_url, &expiry_timestamp);
    println!("{}", to_sign);
    // Safe to unwrap --> Check before
    let unwrapped_key = base64::decode(&key).unwrap();
    // Start generation
    let mut mac  = Hmac::<Sha256>::new_from_slice(&unwrapped_key).unwrap();
    // SIGN GEN
    mac.update(to_sign.as_bytes());
    let mac_result = mac.finalize();
    let signature = base64::encode(mac_result.into_bytes());
    let pairs = &vec![("sig", signature)];
    let token_result = serde_urlencoded::to_string(pairs).unwrap();
    // Build up token signature
    let full_token = format!(
        "SharedAccessSignature sr={}.azure-devices.net%2Fdevices%2F{}&{}&se={}&skn={}",
        hub_name,
        device_id,
        token_result,
        expiry_timestamp,
        device_id
    );
    return Ok(full_token)
}

#[test]
fn gen_token(){
    let token = generate_sas_token(String::from("PrimairyKeyHere"),
                       String::from("devicename"),
                       String::from("hubname"), 365);
    if token.is_err(){
        println!("Failed");
        exit(1);
    }
    else {
        println!("Token: {}", token.unwrap_or(String::from("")));
    }
}

let mut driver = client::Connector::new()
    .connector(RustlsConnector::new(Arc::new(tls_config)));
driver.hostname(hostname);
let result = driver.connect_sasl(address, auth).await;