added atomic writer action for ctr c abort

src/main.rs

@@ -1,13 +1,9 @@
 // src/main.rs
 
-mod config;
-mod corporate;
-mod economic;
-mod util;
-mod scraper;
+use web_scraper::{*, scraper, economic, corporate};
 
 use anyhow::Result;
-use config::Config;
+use web_scraper::config::Config;
 use scraper::docker_vpn_proxy::{DockerVpnProxyPool, cleanup_all_proxy_containers};
 use scraper::webdriver::ChromeDriverPool;
 use util::directories::DataPaths;
@@ -34,13 +30,41 @@ async fn main() -> Result<()> {
     
     cleanup_all_proxy_containers().await.ok();
 
-
-    let config = Config::load().map_err(|err| {
-        eprintln!("Failed to load config: {}", err);
-        err
-    })?;
+    let config = match Config::load() {
+        Ok(cfg) => cfg,
+        Err(_) => {
+            eprintln!("Using default configuration");
+            Config::default()
+        }
+    };
 
     let paths = DataPaths::new(".")?;
+
+    // Initialize monitoring system
+    let config_snapshot = ConfigSnapshot {
+        max_parallel_instances: config.max_parallel_instances,
+        max_tasks_per_instance: config.max_tasks_per_instance,
+        enable_vpn_rotation: config.enable_vpn_rotation,
+        max_requests_per_session: config.max_requests_per_session,
+        min_request_interval_ms: config.min_request_interval_ms,
+        max_retry_attempts: config.max_retry_attempts,
+    };
+
+    let (monitoring_handle, _monitoring_task) = init_monitoring(
+        config_snapshot,
+        paths.logs_dir().to_path_buf(),
+        3030, // Dashboard port
+    ).await?;
+
+    // Emit pool initialization event
+    monitoring_handle.emit(monitoring::MonitoringEvent::PoolInitialized {
+        pool_size: config.max_parallel_instances,
+        with_proxy: config.enable_vpn_rotation,
+        with_rotation: config.max_tasks_per_instance > 0,
+    });
+
+    logger::log_info("Monitoring dashboard available at http://localhost:3030").await;
+
     logger::init_debug_logger(paths.logs_dir()).await.ok();
     logger::log_info("=== Event Backtest Engine Started ===").await;
     logger::log_info(&format!(
@@ -56,7 +80,8 @@ async fn main() -> Result<()> {
     // === Step 1: Fetch VPNBook configs ===
     let proxy_pool: Option<Arc<DockerVpnProxyPool>> = if config.enable_vpn_rotation {
         logger::log_info("VPN Rotation Enabled – Fetching latest VPNBook configs").await;
-        let temp_pool = Arc::new(ChromeDriverPool::new_with_proxy_and_task_limit(config.max_parallel_instances, None, 1).await?);
+        let temp_pool = Arc::new(ChromeDriverPool::new_with_proxy_and_task_limit(None, &config, Some(monitoring_handle.clone())).await?);
+
         let (username, password, _files) = opnv::fetch_vpnbook_configs(&temp_pool, paths.cache_dir()).await?;
         logger::log_info(&format!("VPNBook credentials → User: {}", username)).await;
 
@@ -72,6 +97,16 @@ async fn main() -> Result<()> {
             let pp = Arc::new(DockerVpnProxyPool::new(paths.cache_openvpn_dir(), username, password).await?);
 
             logger::log_info(&format!("All {} Docker proxy containers started and ready", pp.num_proxies())).await;
+            for i in 0..pp.num_proxies() {
+                if let Some(proxy_info) = pp.get_proxy_info(i) {
+                    monitoring_handle.emit(monitoring::MonitoringEvent::ProxyConnected {
+                        container_name: proxy_info.container_name.clone(),
+                        ip_address: proxy_info.ip_address.clone(),
+                        port: proxy_info.port,
+                    });
+                }
+            }
+
             Some(pp)
         }
     } else {
@@ -87,9 +122,9 @@ async fn main() -> Result<()> {
     
     let pool = Arc::new(
         if task_limit > 0 {
-            ChromeDriverPool::new_with_proxy_and_task_limit(pool_size, proxy_pool.clone(), task_limit).await?
+            ChromeDriverPool::new_with_proxy_and_task_limit(proxy_pool.clone(), &config, Some(monitoring_handle.clone())).await?
         } else {
-            ChromeDriverPool::new_with_proxy(pool_size, proxy_pool.clone()).await?
+            ChromeDriverPool::new_with_proxy_and_task_limit(proxy_pool.clone(), &config, Some(monitoring_handle.clone())).await?
         }
     );