refactor: introduce NetworkConfigService pattern

- Rename network_config.rs to network.rs for consistency
- Wrap network configuration functions in NetworkConfigService struct
- Apply consistent service pattern with static methods
- Update all imports to use NetworkConfigService
- Add conditional compilation for mock feature in main.rs

This refactoring improves code organization by applying the same
service pattern used throughout the codebase.

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

Author: JanZachmann

src/api.rs

@@ -5,7 +5,7 @@ use crate::{
     },
     keycloak_client::SingleSignOnProvider,
     middleware::TOKEN_EXPIRE_HOURS,
-    network_config::{self, NetworkConfig},
+    network::{NetworkConfig, NetworkConfigService},
     omnect_device_service_client::{DeviceServiceClient, FactoryReset, LoadUpdate, RunUpdate},
 };
 use actix_files::NamedFile;
@@ -163,7 +163,7 @@ where
     pub async fn token(session: Session) -> impl Responder {
         debug!("token() called");
 
-        network_config::cancel_rollback();
+        NetworkConfigService::cancel_rollback();
         Self::session_token(session)
     }
 
@@ -304,10 +304,10 @@ where
         }
 
         if let Err(e) =
-            network_config::apply_network_config(&api.service_client, &network_config).await
+            NetworkConfigService::apply_network_config(&api.service_client, &network_config).await
         {
             error!("set_network_config() failed: {e:#}");
-            if let Err(err) = network_config::rollback_network_config(&network_config) {
+            if let Err(err) = NetworkConfigService::rollback_network_config(&network_config) {
                 error!("Failed to restore network config: {err:#}");
             }
             return HttpResponse::InternalServerError().body(format!("{e:#}"));

src/certificate.rs

@@ -1,9 +1,8 @@
 #![cfg_attr(feature = "mock", allow(dead_code, unused_imports))]
 
 use crate::{
-    common::handle_http_response,
-    http_client::HttpClientFactory,
-    omnect_device_service_client::{DeviceServiceClient},
+    common::handle_http_response, http_client::HttpClientFactory,
+    omnect_device_service_client::DeviceServiceClient,
 };
 use anyhow::{Context, Result};
 use log::info;
@@ -42,7 +41,10 @@ pub fn key_path() -> String {
 }
 
 #[cfg(feature = "mock")]
-pub async fn create_module_certificate() -> Result<()> {
+pub async fn create_module_certificate<T>(_service_client: &T) -> Result<()>
+where
+    T: DeviceServiceClient,
+{
     Ok(())
 }
 

src/lib.rs

@@ -5,5 +5,5 @@ pub mod common;
 pub mod http_client;
 pub mod keycloak_client;
 pub mod middleware;
-pub mod network_config;
+pub mod network;
 pub mod omnect_device_service_client;

src/main.rs

@@ -5,15 +5,15 @@ mod common;
 mod http_client;
 mod keycloak_client;
 mod middleware;
-mod network_config;
+mod network;
 mod omnect_device_service_client;
 
 use crate::{
     api::Api,
     certificate::create_module_certificate,
     common::{centrifugo_config, config_path},
     keycloak_client::KeycloakProvider,
-    network_config::init_server_restart_channel,
+    network::NetworkConfigService,
     omnect_device_service_client::{DeviceServiceClient, OmnectDeviceServiceClient},
 };
 use actix_cors::Cors;
@@ -74,7 +74,7 @@ async fn main() {
 
     // Create restart signal channel
     let (restart_tx, mut restart_rx) = broadcast::channel(1);
-    init_server_restart_channel(restart_tx).expect("failed to set restart channel");
+    NetworkConfigService::init_server_restart_channel(restart_tx).expect("failed to set restart channel");
 
     let mut sigterm = signal(SignalKind::terminate()).expect("failed to install SIGTERM handler");
 
@@ -177,14 +177,10 @@ async fn run_server() -> (
         .await
         .expect("failed to create module certificate");
 
-    tokio::spawn({
-        let service_client = service_client.clone();
-        async move {
-            if let Err(e) = network_config::process_pending_rollback(&service_client).await {
-                error!("failed to check pending rollback: {e:#}");
-            }
-        }
-    });
+    if let Err(e) = network::NetworkConfigService::process_pending_rollback(&service_client).await
+    {
+        error!("failed to check pending rollback: {e:#}");
+    }
 
     let mut tls_certs = std::io::BufReader::new(
         std::fs::File::open(certificate::cert_path()).expect("failed to read certificate file"),