style: cargo-fmt fixes

Author: empwilli

src/auth.rs

@@ -4,13 +4,12 @@ use tokio::sync::{mpsc, oneshot};
 
 use anyhow::Result;
 
-use actix_web::{error, get, web, App, HttpServer};
+use actix_web::{App, HttpServer, error, get, web};
 use serde::Deserialize;
 
-use oauth2::basic::BasicClient;
 use oauth2::{
     AuthUrl, AuthorizationCode, ClientId, CsrfToken, PkceCodeChallenge, RedirectUrl, TokenResponse,
-    TokenUrl,
+    TokenUrl, basic::BasicClient,
 };
 
 #[derive(Deserialize)]

src/device_update.rs

@@ -1,7 +1,7 @@
 use anyhow::{Context, Result};
 use azure_identity::{ClientSecretCredential, TokenCredentialOptions};
 use azure_iot_deviceupdate::DeviceUpdateClient;
-use azure_storage::{shared_access_signature::service_sas::BlobSasPermissions, StorageCredentials};
+use azure_storage::{StorageCredentials, shared_access_signature::service_sas::BlobSasPermissions};
 use azure_storage_blobs::prelude::{BlobServiceClient, ContainerClient};
 use base64::prelude::*;
 use log::{debug, info};

src/file/mod.rs

@@ -2,15 +2,17 @@ pub mod compression;
 pub mod functions;
 use super::validators::{
     device_update,
-    identity::{validate_identity, IdentityConfig, IdentityType},
+    identity::{IdentityConfig, IdentityType, validate_identity},
     ssh::validate_ssh_pub_key,
 };
 use crate::file::functions::{FileCopyFromParams, FileCopyToParams, Partition};
 use anyhow::{Context, Result};
 use log::warn;
 use regex::Regex;
-use std::fs;
-use std::path::{Path, PathBuf};
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
 
 pub fn set_iotedge_gateway_config(
     config_file: &Path,

src/image.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 
-use crate::file::functions::read_file_from_image;
 use crate::file::functions::Partition;
+use crate::file::functions::read_file_from_image;
 use anyhow::{Context, Result};
 use regex::Regex;
 use std::sync::LazyLock;

src/lib.rs

@@ -251,17 +251,14 @@ pub fn run() -> Result<()> {
             generate_bmap,
             compress_image,
         }) => {
-            let cert_info = create_image_cert(
-                &image,
-                CertificateOptions {
-                    intermediate_full_chain_cert: &intermediate_full_chain_cert,
-                    intermediate_key: &intermediate_key,
-                    target_cert: "device_cert_path.pem",
-                    target_key: "device_key_path.key.pem",
-                    subject: &device_id,
-                    validity_days: days,
-                },
-            )
+            let cert_info = create_image_cert(&image, CertificateOptions {
+                intermediate_full_chain_cert: &intermediate_full_chain_cert,
+                intermediate_key: &intermediate_key,
+                target_cert: "device_cert_path.pem",
+                target_key: "device_key_path.key.pem",
+                subject: &device_id,
+                validity_days: days,
+            })
             .context("set_device_certificate: could not create certificate")?;
 
             run_image_command(image, generate_bmap, compress_image, |img| {
@@ -282,17 +279,14 @@ pub fn run() -> Result<()> {
             generate_bmap,
             compress_image,
         }) => {
-            let cert_info = create_image_cert(
-                &image,
-                CertificateOptions {
-                    intermediate_full_chain_cert: &intermediate_full_chain_cert,
-                    intermediate_key: &intermediate_key,
-                    target_cert: "edge_ca_cert_path.pem",
-                    target_key: "edge_ca_key_path.key.pem",
-                    subject: &device_id,
-                    validity_days: days,
-                },
-            )
+            let cert_info = create_image_cert(&image, CertificateOptions {
+                intermediate_full_chain_cert: &intermediate_full_chain_cert,
+                intermediate_key: &intermediate_key,
+                target_cert: "edge_ca_cert_path.pem",
+                target_key: "edge_ca_key_path.key.pem",
+                subject: &device_id,
+                validity_days: days,
+            })
             .context("set_edge_ca_certificate: could not create certificate")?;
 
             run_image_command(image, generate_bmap, compress_image, |img| {

src/ssh.rs

@@ -1,17 +1,14 @@
 use std::convert::AsRef;
 use std::fs;
-use std::io::prelude::*;
-use std::io::BufWriter;
+use std::io::{BufWriter, prelude::*};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::str;
 
-use anyhow::anyhow;
-use anyhow::{Context, Result};
+use anyhow::{Context, Result, anyhow};
 use directories::ProjectDirs;
 use oauth2::AccessToken;
-use serde::de::DeserializeOwned;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use url::Url;
 
 static BACKEND_API_ENDPOINT: &str = "/api/devices/prepareSSHConnection";
@@ -192,9 +189,11 @@ async fn unpack_response<T: DeserializeOwned>(response: reqwest::Response) -> Re
             internal_message: String,
         }
 
-        anyhow::bail!(serde_json::from_str::<ErrorMessage>(&body)
-            .map(|err| err.internal_message)
-            .unwrap_or_else(|_| "unknown error type".to_string()))
+        anyhow::bail!(
+            serde_json::from_str::<ErrorMessage>(&body)
+                .map(|err| err.internal_message)
+                .unwrap_or_else(|_| "unknown error type".to_string())
+        )
     } else {
         serde_json::from_str(&body).map_err(|_| anyhow!("unsupported reply."))
     }

src/validators/identity.rs

@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use log::debug;
 use regex::Regex;
 use serde::Deserialize;
@@ -189,19 +189,15 @@ const PAYLOAD_FILEPATH: &str = "file:///etc/omnect/dps-payload.json";
 const WARN_MISSING_PROVISIONING: &str = "A provisioning section should be specified.";
 const WARN_MISSING_DPS_PARAMS: &str =
     "For provisioning source dps, global_endpoint and id_scope should be specified.";
-const WARN_MISSING_MANUAL_PARAMS: &str =
-    "For provisioning source manual, either connection_string or iothub_hostname and device_id are required.";
-const WARN_MISSING_AUTHENTICATION: &str =
-    "For provisioning source manual, an authentication section should be present in the provisioning section.";
-const WARN_MISSING_ATTESTATION: &str =
-    "For provisioning source dps an attestation section should be present in the provisioning section.";
+const WARN_MISSING_MANUAL_PARAMS: &str = "For provisioning source manual, either connection_string or iothub_hostname and device_id are required.";
+const WARN_MISSING_AUTHENTICATION: &str = "For provisioning source manual, an authentication section should be present in the provisioning section.";
+const WARN_MISSING_ATTESTATION: &str = "For provisioning source dps an attestation section should be present in the provisioning section.";
 const WARN_ATTESTATION_VALID_METHOD_EXPECTED: &str =
     "The attestation method should be tpm, x509 or symmetric_key.";
 const WARN_INVALID_SOURCE: &str = "The provisioning source should be dps or manual.";
 const WARN_AUTHENTICATION_VALID_METHOD_EXPECTED: &str = "The authentication method should be sas.";
 const WARN_UNEXPECTED_PATH: &str = "Unexpected path found.";
-const WARN_UNEQUAL_COMMON_NAME_AND_REGISTRATION_ID: &str =
-    "provisioning.attestation.registration_id is not equal to provisioning.attestation.identity_cert.common_name";
+const WARN_UNEQUAL_COMMON_NAME_AND_REGISTRATION_ID: &str = "provisioning.attestation.registration_id is not equal to provisioning.attestation.identity_cert.common_name";
 const WARN_PAYLOAD_FILEPATH_MISSING: &str = "Payload file is configred but file is missing.";
 const WARN_PAYLOAD_CONFIG_MISSING: &str = "Payload file is passed but not configred.";
 
@@ -375,12 +371,14 @@ mod tests {
     #[test]
     fn identity_config_hostname_valid() {
         LazyLock::force(&LOG);
-        assert!(validate_identity(
-            IdentityType::Standalone,
-            Path::new("testfiles/identity_config_hostname_valid.toml"),
-            &None,
-        )
-        .is_ok());
+        assert!(
+            validate_identity(
+                IdentityType::Standalone,
+                Path::new("testfiles/identity_config_hostname_valid.toml"),
+                &None,
+            )
+            .is_ok()
+        );
     }
 
     #[test]

tests/common/mod.rs

@@ -1,9 +1,7 @@
 use data_encoding::HEXUPPER;
 use env_logger::{Builder, Env};
 use ring::digest::{Context, SHA256};
-use std::fs::copy;
-use std::fs::File;
-use std::fs::{create_dir_all, remove_dir_all};
+use std::fs::{File, copy, create_dir_all, remove_dir_all};
 use std::io::{BufReader, Read};
 use std::path::PathBuf;
 use std::sync::LazyLock;

tests/integration_tests.rs

@@ -108,17 +108,23 @@ fn check_set_identity_gateway_config() {
         edge_device_identity_key_file_path.to_str().unwrap(),
         edge_device_identity_key_file_out_path
     ));
-    assert!(std::path::Path::new(hosts_file_out_path)
-        .try_exists()
-        .is_ok_and(|exists| exists));
+    assert!(
+        std::path::Path::new(hosts_file_out_path)
+            .try_exists()
+            .is_ok_and(|exists| exists)
+    );
 
-    assert!(std::fs::read_to_string(hosts_file_out_path)
-        .unwrap()
-        .contains("127.0.1.1 my-omnect-iotedge-gateway-device"));
+    assert!(
+        std::fs::read_to_string(hosts_file_out_path)
+            .unwrap()
+            .contains("127.0.1.1 my-omnect-iotedge-gateway-device")
+    );
 
-    assert!(std::fs::read_to_string(hostname_file_out_path)
-        .unwrap()
-        .contains("my-omnect-iotedge-gateway-device"));
+    assert!(
+        std::fs::read_to_string(hostname_file_out_path)
+            .unwrap()
+            .contains("my-omnect-iotedge-gateway-device")
+    );
 }
 
 #[test]
@@ -185,13 +191,17 @@ fn check_set_identity_leaf_config() {
         root_ca_file_out_path
     ));
 
-    assert!(std::fs::read_to_string(hosts_file_out_path)
-        .unwrap()
-        .contains("127.0.1.1 my-omnect-iot-leaf-device"));
+    assert!(
+        std::fs::read_to_string(hosts_file_out_path)
+            .unwrap()
+            .contains("127.0.1.1 my-omnect-iot-leaf-device")
+    );
 
-    assert!(std::fs::read_to_string(hostname_file_out_path)
-        .unwrap()
-        .contains("my-omnect-iot-leaf-device"));
+    assert!(
+        std::fs::read_to_string(hostname_file_out_path)
+            .unwrap()
+            .contains("my-omnect-iot-leaf-device")
+    );
 }
 
 #[test]
@@ -247,13 +257,17 @@ fn check_set_identity_config_est_template() {
         config_file_out_path
     ));
 
-    assert!(std::fs::read_to_string(hosts_file_out_path)
-        .unwrap()
-        .contains("127.0.1.1 test-omnect-est"));
+    assert!(
+        std::fs::read_to_string(hosts_file_out_path)
+            .unwrap()
+            .contains("127.0.1.1 test-omnect-est")
+    );
 
-    assert!(std::fs::read_to_string(hostname_file_out_path)
-        .unwrap()
-        .contains("test-omnect-est"));
+    assert!(
+        std::fs::read_to_string(hostname_file_out_path)
+            .unwrap()
+            .contains("test-omnect-est")
+    );
 }
 
 #[test]
@@ -323,13 +337,17 @@ fn check_set_identity_config_payload_template() {
         payload_out_path
     ));
 
-    assert!(std::fs::read_to_string(hosts_file_out_path)
-        .unwrap()
-        .contains("127.0.1.1 test-omnect-est-with-payload"));
+    assert!(
+        std::fs::read_to_string(hosts_file_out_path)
+            .unwrap()
+            .contains("127.0.1.1 test-omnect-est-with-payload")
+    );
 
-    assert!(std::fs::read_to_string(hostname_file_out_path)
-        .unwrap()
-        .contains("test-omnect-est-with-payload"));
+    assert!(
+        std::fs::read_to_string(hostname_file_out_path)
+            .unwrap()
+            .contains("test-omnect-est-with-payload")
+    );
 }
 
 #[test]
@@ -385,13 +403,17 @@ fn check_set_identity_config_tpm_template() {
         config_file_out_path
     ));
 
-    assert!(std::fs::read_to_string(hosts_file_out_path)
-        .unwrap()
-        .contains("127.0.1.1 test-omnect-tpm"));
+    assert!(
+        std::fs::read_to_string(hosts_file_out_path)
+            .unwrap()
+            .contains("127.0.1.1 test-omnect-tpm")
+    );
 
-    assert!(std::fs::read_to_string(hostname_file_out_path)
-        .unwrap()
-        .contains("test-omnect-tpm"));
+    assert!(
+        std::fs::read_to_string(hostname_file_out_path)
+            .unwrap()
+            .contains("test-omnect-tpm")
+    );
 }
 
 #[test]
@@ -1009,31 +1031,36 @@ async fn check_ssh_tunnel_setup() {
         .await
         .unwrap();
 
-    assert!(tr
-        .pathbuf()
-        .join("config")
-        .try_exists()
-        .is_ok_and(|exists| exists));
-    assert!(tr
-        .pathbuf()
-        .join("id_ed25519")
-        .try_exists()
-        .is_ok_and(|exists| exists));
-    assert!(tr
-        .pathbuf()
-        .join("id_ed25519.pub")
-        .try_exists()
-        .is_ok_and(|exists| exists));
-    assert!(tr
-        .pathbuf()
-        .join("bastion-cert.pub")
-        .try_exists()
-        .is_ok_and(|exists| exists));
-    assert!(tr
-        .pathbuf()
-        .join("device-cert.pub")
-        .try_exists()
-        .is_ok_and(|exists| exists));
+    assert!(
+        tr.pathbuf()
+            .join("config")
+            .try_exists()
+            .is_ok_and(|exists| exists)
+    );
+    assert!(
+        tr.pathbuf()
+            .join("id_ed25519")
+            .try_exists()
+            .is_ok_and(|exists| exists)
+    );
+    assert!(
+        tr.pathbuf()
+            .join("id_ed25519.pub")
+            .try_exists()
+            .is_ok_and(|exists| exists)
+    );
+    assert!(
+        tr.pathbuf()
+            .join("bastion-cert.pub")
+            .try_exists()
+            .is_ok_and(|exists| exists)
+    );
+    assert!(
+        tr.pathbuf()
+            .join("device-cert.pub")
+            .try_exists()
+            .is_ok_and(|exists| exists)
+    );
 
     let ssh_config = std::fs::read_to_string(tr.pathbuf().join("config")).unwrap();
     let expected_config = format!(