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.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
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::init_server_restart_channel,
     omnect_device_service_client::{DeviceServiceClient, OmnectDeviceServiceClient},
 };
 use actix_cors::Cors;
@@ -180,7 +180,9 @@ async fn run_server() -> (
     tokio::spawn({
         let service_client = service_client.clone();
         async move {
-            if let Err(e) = network_config::process_pending_rollback(&service_client).await {
+            if let Err(e) =
+                network::NetworkConfigService::process_pending_rollback(&service_client).await
+            {
                 error!("failed to check pending rollback: {e:#}");
             }
         }

src/network_config.rs src/network.rssrc/network_config.rs renamed to src/network.rs

@@ -113,69 +113,97 @@ struct PendingRollback {
 }
 
 // ============================================================================
-// Public Functions
+// Service
 // ============================================================================
 
-pub fn rollback_network_config(network: &NetworkConfig) -> Result<()> {
-    let config_file = network_config_file!(network.name);
-    let backup_file = network_backup_file!(network.name);
+/// Service for network configuration management operations
+pub struct NetworkConfigService;
+
+impl NetworkConfigService {
+    /// Rollback network configuration to the previous backup
+    ///
+    /// # Arguments
+    /// * `network` - Network configuration to rollback
+    ///
+    /// # Returns
+    /// Result indicating success or failure
+    pub fn rollback_network_config(network: &NetworkConfig) -> Result<()> {
+        let config_file = network_config_file!(network.name);
+        let backup_file = network_backup_file!(network.name);
+
+        if !backup_file.exists() {
+            return Ok(());
+        }
 
-    if !backup_file.exists() {
-        return Ok(());
-    }
+        fs::copy(&backup_file, &config_file).context(format!(
+            "failed to restore {} from {}",
+            config_file.display(),
+            backup_file.display()
+        ))?;
 
-    fs::copy(&backup_file, &config_file).context(format!(
-        "failed to restore {} from {}",
-        config_file.display(),
-        backup_file.display()
-    ))?;
+        let _ = fs::remove_file(&backup_file);
 
-    let _ = fs::remove_file(&backup_file);
+        Ok(())
+    }
 
-    Ok(())
-}
+    /// Apply network configuration to systemd-networkd
+    ///
+    /// # Arguments
+    /// * `service_client` - Device service client for network reload
+    /// * `network` - Network configuration to apply
+    ///
+    /// # Returns
+    /// Result indicating success or failure
+    pub async fn apply_network_config<T>(service_client: &T, network: &NetworkConfig) -> Result<()>
+    where
+        T: DeviceServiceClient,
+    {
+        backup_current_network_config(service_client, network).await?;
+        write_network_config(network)?;
+        service_client.reload_network().await?;
 
-pub async fn apply_network_config<T>(service_client: &T, network: &NetworkConfig) -> Result<()>
-where
-    T: DeviceServiceClient,
-{
-    backup_current_network_config(service_client, network).await?;
-    write_network_config(network)?;
-    service_client.reload_network().await?;
+        if network.is_server_addr && network.ip_changed {
+            schedule_server_restart_with_certificate(network).await?;
+        }
 
-    if network.is_server_addr && network.ip_changed {
-        schedule_server_restart_with_certificate(network).await?;
+        Ok(())
     }
 
-    Ok(())
-}
-
-pub async fn process_pending_rollback<T>(service_client: &T) -> Result<()>
-where
-    T: DeviceServiceClient,
-{
-    if let Some(pending) = load_rollback!() {
-        let now = SystemTime::now();
-
-        if now >= pending.rollback_time {
-            execute_rollback(service_client, &pending.network_config, "pending").await;
-            clear_rollback!();
-        } else if let Ok(remaining_time) = pending.rollback_time.duration_since(now) {
-            sleep(remaining_time).await;
+    /// Process any pending network configuration rollback
+    ///
+    /// # Arguments
+    /// * `service_client` - Device service client for rollback operations
+    ///
+    /// # Returns
+    /// Result indicating success or failure
+    pub async fn process_pending_rollback<T>(service_client: &T) -> Result<()>
+    where
+        T: DeviceServiceClient,
+    {
+        if let Some(pending) = load_rollback!() {
+            let now = SystemTime::now();
 
-            if load_rollback!().is_some() {
-                execute_rollback(service_client, &pending.network_config, "scheduled").await;
+            if now >= pending.rollback_time {
+                execute_rollback(service_client, &pending.network_config, "pending").await;
                 clear_rollback!();
+            } else if let Ok(remaining_time) = pending.rollback_time.duration_since(now) {
+                sleep(remaining_time).await;
+
+                if load_rollback!().is_some() {
+                    execute_rollback(service_client, &pending.network_config, "scheduled").await;
+                    clear_rollback!();
+                }
             }
         }
+        Ok(())
     }
-    Ok(())
-}
 
-pub fn cancel_rollback() {
-    if load_rollback!().is_some() {
-        clear_rollback!();
-        info!("pending network rollback cancelled");
+    /// Cancel any pending network configuration rollback
+    pub fn cancel_rollback() {
+        if load_rollback!().is_some() {
+            clear_rollback!();
+            info!("pending network rollback cancelled");
+        }
     }
 }
 
@@ -230,7 +258,7 @@ async fn rollback_network_and_renew_certificate<T>(
 where
     T: DeviceServiceClient,
 {
-    rollback_network_config(network)?;
+    NetworkConfigService::rollback_network_config(network)?;
     service_client.reload_network().await?;
     trigger_server_restart();