Migrate more Python functions to Rust

myfsio-engine/crates/myfsio-server/src/state.rs

@@ -1,11 +1,17 @@
 use std::sync::Arc;
+use std::time::Duration;
 
 use crate::config::ServerConfig;
+use crate::session::SessionStore;
+use crate::templates::TemplateEngine;
 use crate::services::gc::GcService;
 use crate::services::integrity::IntegrityService;
 use crate::services::metrics::MetricsService;
+use crate::services::replication::ReplicationManager;
 use crate::services::site_registry::SiteRegistry;
+use crate::services::site_sync::SiteSyncWorker;
 use crate::services::website_domains::WebsiteDomainStore;
+use crate::stores::connections::ConnectionStore;
 use myfsio_auth::iam::IamService;
 use myfsio_crypto::encryption::EncryptionService;
 use myfsio_crypto::kms::KmsService;
@@ -23,6 +29,11 @@ pub struct AppState {
     pub metrics: Option<Arc<MetricsService>>,
     pub site_registry: Option<Arc<SiteRegistry>>,
     pub website_domains: Option<Arc<WebsiteDomainStore>>,
+    pub connections: Arc<ConnectionStore>,
+    pub replication: Arc<ReplicationManager>,
+    pub site_sync: Option<Arc<SiteSyncWorker>>,
+    pub templates: Option<Arc<TemplateEngine>>,
+    pub sessions: Arc<SessionStore>,
 }
 
 impl AppState {
@@ -69,6 +80,37 @@ impl AppState {
             None
         };
 
+        let connections = Arc::new(ConnectionStore::new(&config.storage_root));
+
+        let replication = Arc::new(ReplicationManager::new(
+            storage.clone(),
+            connections.clone(),
+            &config.storage_root,
+            Duration::from_secs(config.replication_connect_timeout_secs),
+            Duration::from_secs(config.replication_read_timeout_secs),
+            config.replication_max_retries,
+            config.replication_streaming_threshold_bytes,
+            config.replication_max_failures_per_bucket,
+        ));
+
+        let site_sync = if config.site_sync_enabled {
+            Some(Arc::new(SiteSyncWorker::new(
+                storage.clone(),
+                connections.clone(),
+                replication.clone(),
+                config.storage_root.clone(),
+                config.site_sync_interval_secs,
+                config.site_sync_batch_size,
+                Duration::from_secs(config.site_sync_connect_timeout_secs),
+                Duration::from_secs(config.site_sync_read_timeout_secs),
+                config.site_sync_max_retries,
+                config.site_sync_clock_skew_tolerance,
+            )))
+        } else {
+            None
+        };
+
+        let templates = init_templates(&config.templates_dir);
         Self {
             config,
             storage,
@@ -80,6 +122,11 @@ impl AppState {
             metrics,
             site_registry,
             website_domains,
+            connections,
+            replication,
+            site_sync,
+            templates,
+            sessions: Arc::new(SessionStore::new(Duration::from_secs(60 * 60 * 12))),
         }
     }
 
@@ -119,3 +166,17 @@ impl AppState {
         state
     }
 }
+
+fn init_templates(templates_dir: &std::path::Path) -> Option<Arc<TemplateEngine>> {
+    let glob = format!("{}/*.html", templates_dir.display()).replace('\\', "/");
+    match TemplateEngine::new(&glob) {
+        Ok(engine) => {
+            crate::handlers::ui_pages::register_ui_endpoints(&engine);
+            Some(Arc::new(engine))
+        }
+        Err(e) => {
+            tracing::error!("Template engine init failed: {}", e);
+            None
+        }
+    }
+}