fmt: format

apps/nxmesh-agent/src/service/nginx_handler/message_handler.rs

@@ -107,7 +107,9 @@ impl OnConfigUpdateHandler for NginxMasterMessageHandlerImpl {
         // apply reload on the root config
         self.command_handler.reload(Some(&root_config_path)).await?;
         // persist deployment path so Reload/Test commands survive agent restarts
-        self.fs_handler.save_last_deployment(&root_config_path).await?;
+        self.fs_handler
+            .save_last_deployment(&root_config_path)
+            .await?;
         info!("Persisted last deployment path: {}", root_config_path);
         // Reply the master to confirm the config update is successful
         self.master_handler

apps/nxmesh-master/src/routes/api/agents/mod.rs

@@ -54,7 +54,9 @@ mod tests {
             proxy_setting_service: Arc::new(proxy_setting::MockProxySettingService::new()),
             rewrite_rule_service: Arc::new(rewrite_rule::MockRewriteRuleService::new()),
             ssl_certificate_service: Arc::new(ssl_certificate::MockSslCertificateService::new()),
-            config_inheritance_service: Arc::new(config_inheritance::MockConfigInheritanceService::new()),
+            config_inheritance_service: Arc::new(
+                config_inheritance::MockConfigInheritanceService::new(),
+            ),
         });
         get_router().await.with_state(state)
     }

apps/nxmesh-master/src/routes/api/proxy/access_rules.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::access_rule::{
     AccessRuleService, CreateAccessRuleParams, UpdateAccessRuleParams,
 };
@@ -151,10 +151,7 @@ pub(super) fn routes() -> ApiRouter {
             "/locations/{location_id}/access-rules",
             axum::routing::get(list_access_rules_by_location),
         )
-        .route(
+        .route("/access-rules", axum::routing::post(create_access_rule))
-            "/access-rules",
-            axum::routing::post(create_access_rule),
-        )
         .route(
             "/access-rules/{id}",
             axum::routing::get(get_access_rule)

apps/nxmesh-master/src/routes/api/proxy/agents.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::{ProxyServiceTrait, types::AgentConfigBinding};
 
 use super::configs::ProxyConfigResponse;
@@ -56,7 +56,10 @@ async fn bind_agent(
     Json(body): Json<BindAgentRequest>,
 ) -> Result<impl IntoResponse, AppError> {
     let binding = svc.bind_agent(agent_id, body.config_id).await?;
-    Ok((StatusCode::CREATED, Json(AgentConfigResponse::from(binding))))
+    Ok((
+        StatusCode::CREATED,
+        Json(AgentConfigResponse::from(binding)),
+    ))
 }
 
 async fn unbind_agent(
@@ -72,8 +75,7 @@ async fn unbind_agent(
 }
 
 pub(super) fn routes() -> ApiRouter {
-    ApiRouter::new()
+    ApiRouter::new().route(
-        .route(
         "/agents/{agent_id}/config",
         axum::routing::get(get_active_agent_config)
             .post(bind_agent)

apps/nxmesh-master/src/routes/api/proxy/cache_zones.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::cache_zone::{
     CacheZoneService, CreateCacheZoneParams, UpdateCacheZoneParams,
 };

apps/nxmesh-master/src/routes/api/proxy/config_inheritance.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::config_inheritance::{
     AddInheritanceParams, ConfigInheritanceRecord, ConfigInheritanceService,
 };
@@ -100,8 +100,5 @@ pub(super) fn routes() -> ApiRouter {
             "/configs/{id}/parents/{parent_id}",
             axum::routing::delete(remove_parent),
         )
-        .route(
+        .route("/configs/{id}/children", axum::routing::get(list_children))
-            "/configs/{id}/children",
-            axum::routing::get(list_children),
-        )
 }

apps/nxmesh-master/src/routes/api/proxy/configs.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::{
     ProxyServiceTrait,
     types::{CreateProxyConfigParams, ProxyConfigSummary, UpdateProxyConfigParams},
@@ -136,7 +136,10 @@ async fn render_config(
 
 pub(super) fn routes() -> ApiRouter {
     ApiRouter::new()
-        .route("/configs", axum::routing::get(list_configs).post(create_config))
+        .route(
+            "/configs",
+            axum::routing::get(list_configs).post(create_config),
+        )
         .route(
             "/configs/{id}",
             axum::routing::get(get_config)

apps/nxmesh-master/src/routes/api/proxy/limit_rules.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::limit_rule::{
     CreateLimitRuleParams, LimitRuleService, UpdateLimitRuleParams,
 };
@@ -131,10 +131,7 @@ pub(super) fn routes() -> ApiRouter {
             "/locations/{location_id}/limit-rules",
             axum::routing::get(list_limit_rules_by_location),
         )
-        .route(
+        .route("/limit-rules", axum::routing::post(create_limit_rule))
-            "/limit-rules",
-            axum::routing::post(create_limit_rule),
-        )
         .route(
             "/limit-rules/{id}",
             axum::routing::get(get_limit_rule)

apps/nxmesh-master/src/routes/api/proxy/limit_zones.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::limit_zone::{
     CreateLimitZoneParams, LimitZoneService, UpdateLimitZoneParams,
 };

apps/nxmesh-master/src/routes/api/proxy/locations.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::location_block::{
     CreateLocationBlockParams, LocationBlockService, UpdateLocationBlockParams,
 };
@@ -95,7 +95,10 @@ async fn create_location(
     let mut params = CreateLocationBlockParams::from(body);
     params.server_id = server_id;
     let location = svc.create(params).await?;
-    Ok((StatusCode::CREATED, Json(LocationBlockResponse::from(location))))
+    Ok((
+        StatusCode::CREATED,
+        Json(LocationBlockResponse::from(location)),
+    ))
 }
 
 async fn get_location(

apps/nxmesh-master/src/routes/api/proxy/log_settings.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::log_setting::{
     CreateLogSettingParams, LogSettingService, UpdateLogSettingParams,
 };

apps/nxmesh-master/src/routes/api/proxy/proxy_settings.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::proxy_setting::{
     CreateProxySettingParams, ProxySettingService, UpdateProxySettingParams,
 };
@@ -107,7 +107,10 @@ async fn create_proxy_setting(
     let mut params = CreateProxySettingParams::from(body);
     params.location_id = location_id;
     let setting = svc.create(params).await?;
-    Ok((StatusCode::CREATED, Json(ProxySettingResponse::from(setting))))
+    Ok((
+        StatusCode::CREATED,
+        Json(ProxySettingResponse::from(setting)),
+    ))
 }
 
 async fn get_proxy_setting(

apps/nxmesh-master/src/routes/api/proxy/rewrite_rules.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::rewrite_rule::{
     CreateRewriteRuleParams, RewriteRuleService, UpdateRewriteRuleParams,
 };

apps/nxmesh-master/src/routes/api/proxy/server_blocks.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::server_block::{
     CreateServerBlockParams, ServerBlockService, UpdateServerBlockParams,
 };

apps/nxmesh-master/src/routes/api/proxy/ssl_certificates.rs

@@ -9,7 +9,7 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::ssl_certificate::{
     CreateSslCertificateParams, SslCertificateService, UpdateSslCertificateParams,
 };
@@ -86,7 +86,10 @@ async fn create_ssl_certificate(
     Json(body): Json<CreateSslCertificateRequest>,
 ) -> Result<impl IntoResponse, AppError> {
     let cert = svc.create(body.into()).await?;
-    Ok((StatusCode::CREATED, Json(SslCertificateResponse::from(cert))))
+    Ok((
+        StatusCode::CREATED,
+        Json(SslCertificateResponse::from(cert)),
+    ))
 }
 
 async fn get_ssl_certificate(

apps/nxmesh-master/src/routes/api/proxy/test_builder.rs

@@ -5,18 +5,12 @@ use axum_test::TestServer;
 use crate::routes::api::{ApiState, LocalApiState};
 use crate::service::proxy::*;
 use crate::service::proxy::{
-    access_rule::MockAccessRuleService,
+    access_rule::MockAccessRuleService, cache_zone::MockCacheZoneService,
-    cache_zone::MockCacheZoneService,
+    config_inheritance::MockConfigInheritanceService, limit_rule::MockLimitRuleService,
-    config_inheritance::MockConfigInheritanceService,
+    limit_zone::MockLimitZoneService, location_block::MockLocationBlockService,
-    limit_rule::MockLimitRuleService,
+    log_setting::MockLogSettingService, proxy_setting::MockProxySettingService,
-    limit_zone::MockLimitZoneService,
+    rewrite_rule::MockRewriteRuleService, server_block::MockServerBlockService,
-    location_block::MockLocationBlockService,
+    ssl_certificate::MockSslCertificateService, upstream::MockUpstreamService,
-    log_setting::MockLogSettingService,
-    proxy_setting::MockProxySettingService,
-    rewrite_rule::MockRewriteRuleService,
-    server_block::MockServerBlockService,
-    ssl_certificate::MockSslCertificateService,
-    upstream::MockUpstreamService,
 };
 
 pub(crate) struct TestProxyApiBuilder {
@@ -121,31 +115,41 @@ impl TestProxyApiBuilder {
 
     pub async fn build(self) -> TestServer {
         let state = ApiState {
-            proxy_service: Arc::new(self.proxy_service.unwrap_or_else(MockProxyServiceTrait::new)),
+            proxy_service: Arc::new(
+                self.proxy_service
+                    .unwrap_or_else(MockProxyServiceTrait::new),
+            ),
             server_block_service: Arc::new(
-                self.server_block_service.unwrap_or_else(MockServerBlockService::new),
+                self.server_block_service
+                    .unwrap_or_else(MockServerBlockService::new),
             ),
             upstream_service: Arc::new(
-                self.upstream_service.unwrap_or_else(MockUpstreamService::new),
+                self.upstream_service
+                    .unwrap_or_else(MockUpstreamService::new),
             ),
             location_block_service: Arc::new(
                 self.location_block_service
                     .unwrap_or_else(MockLocationBlockService::new),
             ),
             access_rule_service: Arc::new(
-                self.access_rule_service.unwrap_or_else(MockAccessRuleService::new),
+                self.access_rule_service
+                    .unwrap_or_else(MockAccessRuleService::new),
             ),
             cache_zone_service: Arc::new(
-                self.cache_zone_service.unwrap_or_else(MockCacheZoneService::new),
+                self.cache_zone_service
+                    .unwrap_or_else(MockCacheZoneService::new),
             ),
             limit_rule_service: Arc::new(
-                self.limit_rule_service.unwrap_or_else(MockLimitRuleService::new),
+                self.limit_rule_service
+                    .unwrap_or_else(MockLimitRuleService::new),
             ),
             limit_zone_service: Arc::new(
-                self.limit_zone_service.unwrap_or_else(MockLimitZoneService::new),
+                self.limit_zone_service
+                    .unwrap_or_else(MockLimitZoneService::new),
             ),
             log_setting_service: Arc::new(
-                self.log_setting_service.unwrap_or_else(MockLogSettingService::new),
+                self.log_setting_service
+                    .unwrap_or_else(MockLogSettingService::new),
             ),
             proxy_setting_service: Arc::new(
                 self.proxy_setting_service

apps/nxmesh-master/src/routes/api/proxy/upstreams.rs

@@ -9,10 +9,10 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::routes::api::{AppError, ApiRouter};
+use crate::routes::api::{ApiRouter, AppError};
 use crate::service::proxy::types::UpstreamConfig;
 use crate::service::proxy::upstream::{
-    CreateUpstreamParams, UpstreamService, UpdateUpstreamParams,
+    CreateUpstreamParams, UpdateUpstreamParams, UpstreamService,
 };
 
 #[derive(Serialize)]

apps/nxmesh-master/src/routes/mod.rs

@@ -36,7 +36,9 @@ mod tests {
             proxy_setting_service: Arc::new(proxy_setting::MockProxySettingService::new()),
             rewrite_rule_service: Arc::new(rewrite_rule::MockRewriteRuleService::new()),
             ssl_certificate_service: Arc::new(ssl_certificate::MockSslCertificateService::new()),
-            config_inheritance_service: Arc::new(config_inheritance::MockConfigInheritanceService::new()),
+            config_inheritance_service: Arc::new(
+                config_inheritance::MockConfigInheritanceService::new(),
+            ),
         });
         let router = get_root_router(state).await;
         let server = TestServer::new(router);
@@ -61,7 +63,9 @@ mod tests {
             proxy_setting_service: Arc::new(proxy_setting::MockProxySettingService::new()),
             rewrite_rule_service: Arc::new(rewrite_rule::MockRewriteRuleService::new()),
             ssl_certificate_service: Arc::new(ssl_certificate::MockSslCertificateService::new()),
-            config_inheritance_service: Arc::new(config_inheritance::MockConfigInheritanceService::new()),
+            config_inheritance_service: Arc::new(
+                config_inheritance::MockConfigInheritanceService::new(),
+            ),
         });
         let router = get_root_router(state).await;
         let server = TestServer::new(router);

apps/nxmesh-master/src/service/mod.rs

@@ -60,22 +60,18 @@ pub async fn start_master_server(
             db_connection.clone(),
         )),
         server_block_service: Arc::new(
-            crate::service::proxy::server_block::ServerBlockServiceImpl::new(
+            crate::service::proxy::server_block::ServerBlockServiceImpl::new(db_connection.clone()),
+        ),
+        upstream_service: Arc::new(crate::service::proxy::upstream::UpstreamServiceImpl::new(
             db_connection.clone(),
-            ),
+        )),
-        ),
-        upstream_service: Arc::new(
-            crate::service::proxy::upstream::UpstreamServiceImpl::new(db_connection.clone()),
-        ),
         location_block_service: Arc::new(
             crate::service::proxy::location_block::LocationBlockServiceImpl::new(
                 db_connection.clone(),
             ),
         ),
         access_rule_service: Arc::new(
-            crate::service::proxy::access_rule::AccessRuleServiceImpl::new(
+            crate::service::proxy::access_rule::AccessRuleServiceImpl::new(db_connection.clone()),
-                db_connection.clone(),
-            ),
         ),
         cache_zone_service: Arc::new(
             crate::service::proxy::cache_zone::CacheZoneServiceImpl::new(db_connection.clone()),
@@ -87,9 +83,7 @@ pub async fn start_master_server(
             crate::service::proxy::limit_zone::LimitZoneServiceImpl::new(db_connection.clone()),
         ),
         log_setting_service: Arc::new(
-            crate::service::proxy::log_setting::LogSettingServiceImpl::new(
+            crate::service::proxy::log_setting::LogSettingServiceImpl::new(db_connection.clone()),
-                db_connection.clone(),
-            ),
         ),
         proxy_setting_service: Arc::new(
             crate::service::proxy::proxy_setting::ProxySettingServiceImpl::new(
@@ -97,9 +91,7 @@ pub async fn start_master_server(
             ),
         ),
         rewrite_rule_service: Arc::new(
-            crate::service::proxy::rewrite_rule::RewriteRuleServiceImpl::new(
+            crate::service::proxy::rewrite_rule::RewriteRuleServiceImpl::new(db_connection.clone()),
-                db_connection.clone(),
-            ),
         ),
         ssl_certificate_service: Arc::new(
             crate::service::proxy::ssl_certificate::SslCertificateServiceImpl::new(

apps/nxmesh-master/src/service/proxy/upstream/mod.rs

@@ -1,9 +1,7 @@
 use sea_orm::{ActiveModelTrait, ActiveValue::Set, DatabaseConnection, EntityTrait, prelude::*};
 use uuid::Uuid;
 
-use crate::service::proxy::types::{
+use crate::service::proxy::types::{ProxyServiceError, ProxyServiceResult, UpstreamConfig};
-    ProxyServiceError, ProxyServiceResult, UpstreamConfig,
-};
 
 pub struct CreateUpstreamParams {
     pub config_id: Uuid,