add src path

src/load_orchestrator.py

@@ -0,0 +1,120 @@
+#!.venv/bin/python
+
+# Import necessary libraries
+import logging
+import importlib
+import asyncio
+
+# Import custom modules for configuration and database connection
+from utils.config import loader_load_data as setting
+from utils.database import WorkflowFlags
+from utils.csv.loaders import get_next_csv_atomic
+from utils.orchestrator_utils import run_orchestrator, worker_context
+
+# Initialize the logger for this module
+logger = logging.getLogger()
+
+# Delay tra un processamento CSV e il successivo (in secondi)
+CSV_PROCESSING_DELAY = 0.2
+# Tempo di attesa se non ci sono record da elaborare
+NO_RECORD_SLEEP = 60
+
+async def worker(worker_id: int, cfg: object, pool: object) -> None:
+    """Esegue il ciclo di lavoro per l'elaborazione dei file CSV.
+
+    Il worker preleva un record CSV dal database, ne elabora il contenuto
+    e attende prima di iniziare un nuovo ciclo.
+
+    Args:
+        worker_id (int): L'ID univoco del worker.
+        cfg (object): L'oggetto di configurazione.
+        pool (object): Il pool di connessioni al database.
+    """
+    # Imposta il context per questo worker
+    worker_context.set(f"W{worker_id:02d}")
+
+    logger.info("Avviato")
+
+    while True:
+        try:
+            logger.info("Inizio elaborazione")
+
+            record = await get_next_csv_atomic(pool, cfg.dbrectable, WorkflowFlags.CSV_RECEIVED, WorkflowFlags.DATA_LOADED)
+
+            if record:
+                success = await load_csv(record, cfg, pool)
+                if not success:
+                    logger.error("Errore durante l'elaborazione")
+                await asyncio.sleep(CSV_PROCESSING_DELAY)
+            else:
+                logger.info("Nessun record disponibile")
+                await asyncio.sleep(NO_RECORD_SLEEP)
+
+        except Exception as e:
+            logger.error(f"Errore durante l'esecuzione: {e}", exc_info=1)
+            await asyncio.sleep(1)
+
+
+async def load_csv(record: tuple, cfg: object, pool: object) -> bool:
+    """Carica ed elabora un record CSV utilizzando il modulo di parsing appropriato.
+
+    Args:
+        record: Una tupla contenente i dettagli del record CSV da elaborare (id, unit_type, tool_type, unit_name, tool_name).
+        cfg: L'oggetto di configurazione contenente i parametri del sistema.
+        pool (object): Il pool di connessioni al database.
+
+    Returns:
+        True se l'elaborazione del CSV è avvenuta con successo, False altrimenti.
+    """
+
+    debug_mode = logging.getLogger().getEffectiveLevel() == logging.DEBUG
+    logger.debug("Inizio ricerca nuovo CSV da elaborare")
+
+    id, unit_type, tool_type, unit_name, tool_name = [
+        x.lower().replace(" ", "_") if isinstance(x, str) else x for x in record
+    ]
+    logger.info(
+        f"Trovato CSV da elaborare: ID={id}, Tipo={unit_type}_{tool_type}, Nome={unit_name}_{tool_name}"
+    )
+
+    # Costruisce il nome del modulo da caricare dinamicamente
+    module_names = [
+        f"utils.parsers.by_name.{unit_name}_{tool_name}",
+        f"utils.parsers.by_name.{unit_name}_{tool_type}",
+        f"utils.parsers.by_name.{unit_name}_all",
+        f"utils.parsers.by_type.{unit_type}_{tool_type}",
+    ]
+    modulo = None
+    for module_name in module_names:
+        try:
+            logger.debug(f"Caricamento dinamico del modulo: {module_name}")
+            modulo = importlib.import_module(module_name)
+            logger.info(f"Funzione 'main_loader' caricata dal modulo {module_name}")
+            break
+        except (ImportError, AttributeError) as e:
+            logger.debug(
+                f"Modulo {module_name} non presente o non valido. {e}",
+                exc_info=debug_mode,
+            )
+
+    if not modulo:
+        logger.error(f"Nessun modulo trovato {module_names}")
+        return False
+
+    # Ottiene la funzione 'main_loader' dal modulo
+    funzione = getattr(modulo, "main_loader")
+
+    # Esegui la funzione
+    logger.info(f"Elaborazione con modulo {modulo} per ID={id}")
+    await funzione(cfg, id, pool)
+    logger.info(f"Elaborazione completata per ID={id}")
+    return True
+
+
+async def main():
+    """Funzione principale che avvia il load_orchestrator."""
+    await run_orchestrator(setting.Config, worker)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())