Merge branch 'refactor-device-service-singleton' into feature/network-settings

Signed-off-by: Jan Zachmann <50990105+JanZachmann@users.noreply.github.com>

Author: JanZachmann

Cargo.lock

@@ -18,7 +18,7 @@ actix-multipart = { version = "0.7", default-features = false, features = [
   "derive"
 ] }
 actix-server = { version = "2.6", default-features = false }
-actix-session = { version = "0.10", features = ["cookie-session"] }
+actix-session = { version = "0.11", features = ["cookie-session"] }
 actix-web = { version = "4.11", default-features = false, features = [
   "macros",
   "rustls-0_23",
@@ -53,7 +53,7 @@ serde_json = { version = "1.0", default-features = false, features = [
   "raw_value",
 ] }
 serde_repr = { version = "0.1", default-features = false }
-serde_valid = { version = "1.0", default-features = false }
+serde_valid = { version = "2.0", default-features = false }
 tokio = { version = "1.45", default-features = false, features = [
   "macros",
   "net",

Cargo.toml

@@ -16,7 +16,6 @@ use argon2::{
 };
 use log::{debug, error};
 use serde::Deserialize;
-use serde_valid::Validate;
 use std::{
     fs::{self, File},
     io::Write,
@@ -284,22 +283,10 @@ where
     ) -> impl Responder {
         debug!("set_network_config() called");
 
-        if let Err(e) = network_config.validate() {
-            error!("set_network_config() failed: {e:#}");
-            return HttpResponse::BadRequest().body(format!("{e:#}"));
-        }
-
-        if let Err(e) =
-            NetworkConfigService::apply_network_config(&api.service_client, &network_config).await
-        {
-            error!("set_network_config() failed: {e:#}");
-            if let Err(err) = NetworkConfigService::rollback_network_config(&network_config) {
-                error!("Failed to restore network config: {err:#}");
-            }
-            return HttpResponse::InternalServerError().body(format!("{e:#}"));
-        }
-
-        HttpResponse::Ok().finish()
+        Self::handle_service_result(
+            NetworkConfigService::set_network_config(&api.service_client, &network_config).await,
+            "set_network_config",
+        )
     }
 
     async fn validate_token_and_claims(&self, token: &str) -> Result<()> {

src/api.rs

@@ -46,7 +46,7 @@ impl TokenManager {
         self.inner
             .key
             .authenticate(claims)
-            .map_err(|e| anyhow::anyhow!("failed to create token: {}", e))
+            .map_err(|e| anyhow::anyhow!("failed to create token: {e:#}"))
     }
 
     /// Verify a token and check if it's valid

src/auth/token.rs

@@ -1,17 +1,16 @@
 #![cfg_attr(feature = "mock", allow(dead_code, unused_imports))]
 
-use crate::{
-    common::handle_http_response, http_client, omnect_device_service_client::DeviceServiceClient,
-};
+use crate::{common::handle_http_response, http_client};
 use anyhow::{Context, Result};
 use log::info;
 use serde::{Deserialize, Serialize};
 use std::{fs::File, io::Write};
 
-#[derive(Serialize)]
-struct CreateCertPayload {
+// Public payload for passing to certificate creation
+#[derive(Debug, Serialize)]
+pub struct CreateCertPayload {
     #[serde(rename = "commonName")]
-    common_name: String,
+    pub common_name: String,
 }
 
 #[derive(Debug, Deserialize)]
@@ -40,20 +39,13 @@ pub fn key_path() -> String {
 }
 
 #[cfg(feature = "mock")]
-pub async fn create_module_certificate<T>(_service_client: &T) -> Result<()>
-where
-    T: DeviceServiceClient,
-{
+pub async fn create_module_certificate(_payload: CreateCertPayload) -> Result<()> {
     Ok(())
 }
 
 #[cfg(not(feature = "mock"))]
-pub async fn create_module_certificate<T>(service_client: &T) -> Result<()>
-where
-    T: DeviceServiceClient,
-{
+pub async fn create_module_certificate(payload: CreateCertPayload) -> Result<()> {
     info!("create module certificate");
-
     let id = std::env::var("IOTEDGE_MODULEID")
         .context("failed to read IOTEDGE_MODULEID environment variable")?;
     let gen_id = std::env::var("IOTEDGE_MODULEGENERATIONID")
@@ -63,17 +55,13 @@ where
     let workload_uri = std::env::var("IOTEDGE_WORKLOADURI")
         .context("failed to read IOTEDGE_WORKLOADURI environment variable")?;
 
-    let payload = CreateCertPayload {
-        common_name: service_client.ip_address().await?,
-    };
-
-    let path = format!("/modules/{id}/genid/{gen_id}/certificate/server?api-version={api_version}");
+    let path = format!("modules/{id}/genid/{gen_id}/certificate/server?api-version={api_version}");
 
     // Create a client for the IoT Edge workload socket
     let client = http_client::unix_socket_client(&workload_uri)?;
 
-    let url = format!("http://localhost{}", path);
-    info!("POST {url} (IoT Edge workload API)");
+    let url = format!("http://localhost/{path}");
+    info!("POST {url} (IoT Edge workload API) with payload: {payload:?}");
 
     let res = client
         .post(&url)

src/certificate.rs

@@ -33,6 +33,23 @@ pub fn centrifugo_config() -> Arc<CentrifugoConfig> {
         .clone()
 }
 
+pub fn centrifugo_publish_endpoint() -> crate::omnect_device_service_client::PublishEndpoint {
+    let cfg = centrifugo_config();
+    crate::omnect_device_service_client::PublishEndpoint {
+        url: format!("https://localhost:{}/api/publish", cfg.port),
+        headers: vec![
+            crate::omnect_device_service_client::HeaderKeyValue {
+                name: String::from("Content-Type"),
+                value: String::from("application/json"),
+            },
+            crate::omnect_device_service_client::HeaderKeyValue {
+                name: String::from("X-API-Key"),
+                value: cfg.api_key.clone(),
+            },
+        ],
+    }
+}
+
 macro_rules! config_path {
     () => {
         std::path::Path::new(
@@ -109,10 +126,7 @@ pub async fn handle_http_response(res: Response, context_msg: &str) -> Result<St
 
     ensure!(
         status.is_success(),
-        "{} failed with status {} and body: {}",
-        context_msg,
-        status,
-        body
+        "{context_msg} failed with status {status} and body: {body}"
     );
 
     Ok(body)