melhorando desempenho dos scripts de indexação e inserindo mais projetos

scripts/handler/main.py

@@ -3,71 +3,368 @@
 import os
 import shutil
 import subprocess
+import multiprocessing
+import logging
+import time
+import platform
+from datetime import datetime
+
+# Importando seus módulos
+from generate_manifest import generate_manifests
 from file_parser import parse_mmp_file
 from file_saver import save_to_json, save_to_yaml
-from utils import create_folders_if_not_exist
+from dependency_checker import check_dependencies
+from utils import (
+    create_folders_if_not_exist,
+    BASE_PATH,
+    DATA_FOLDER,
+    METADATA_FOLDER,
+    WAV_FOLDER,
+    MMPZ_FOLDER,
+    MMP_FOLDER,
+)
 
-def process_mmps_in_folder(folder_path):
-    mmp_files = [f for f in os.listdir(folder_path) if f.endswith('.mmp') or f.endswith('.mmpz')]
-    all_data = []
 
-    mmpz_folder = os.path.join(folder_path, '/nethome/jotachina/projetos/mmpSearch/mmp/mmpz')
-    wav_folder = os.path.join(folder_path, '/nethome/jotachina/projetos/mmpSearch/mmp/wav')
-    metadata_folder = os.path.join(folder_path, '/nethome/jotachina/projetos/mmpSearch/metadata')
-    data_folder = os.path.join(folder_path, '/nethome/jotachina/projetos/mmpSearch/_data')
+# Caminho para os Logs
+# Assumindo que este script roda dentro de scripts/handler/
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+LOG_FOLDER = os.path.join(CURRENT_DIR, "logs")
 
-    create_folders_if_not_exist([mmpz_folder, wav_folder, metadata_folder, data_folder])
 
-    for file in mmp_files:
-        file_path = os.path.join(folder_path, file)
-        print(f'Processando arquivo: {file_path}')
+def get_linux_mem_info():
+    """Lê /proc/meminfo para obter memória total de forma nativa no Linux."""
+    try:
+        with open("/proc/meminfo", "r") as f:
+            for line in f:
+                if "MemTotal" in line:
+                    # Ex: MemTotal:        16303032 kB
+                    kb_value = int(line.split()[1])
+                    return kb_value / (1024 * 1024)  # Retorna em GB
+    except:
+        return 0
 
-        if file.endswith('.mmpz'):
-            destination_path = os.path.join(mmpz_folder, file)
-            shutil.move(file_path, destination_path)
-            print(f'Movido para: {destination_path}')
 
-            mmp_name = os.path.splitext(file)[0] + ".mmp"
-            output_mmp_path = os.path.join(folder_path, mmp_name)
+def get_cpu_model_name():
+    """Lê /proc/cpuinfo para pegar o nome real do processador."""
+    try:
+        with open("/proc/cpuinfo", "r") as f:
+            for line in f:
+                if "model name" in line:
+                    return line.split(":")[1].strip()
+    except:
+        return platform.processor()
+
+
+def log_system_info():
+    """
+    Registra informações do hardware usando apenas bibliotecas nativas do Python.
+    """
+    try:
+        logging.info("=" * 30)
+        logging.info("AUDITORIA DE AMBIENTE (HARDWARE)")
+        logging.info("=" * 30)
+
+        # 1. Sistema Operacional
+        uname = platform.uname()
+        logging.info(f"Sistema: {uname.system} {uname.release}")
+        logging.info(f"Kernel:  {uname.version}")
+        logging.info(
+            f"Node:    {uname.node}"
+        )  # Nome do servidor (provavelmente 'alice')
+
+        # 2. CPU (Processamento)
+        cpu_model = get_cpu_model_name()
+        cores_logical = multiprocessing.cpu_count()
+        # os.sched_getaffinity pega os cores que o processo PODE usar (útil em cluster compartilhado)
+        try:
+            cores_available = len(os.sched_getaffinity(0))
+        except AttributeError:
+            cores_available = cores_logical
+
+        logging.info(f"CPU Modelo:   {cpu_model}")
+        logging.info(f"Núcleos (Log): {cores_logical}")
+        logging.info(f"Núcleos (Disp): {cores_available} (Alocados para este script)")
+
+        # 3. Memória RAM
+        mem_total_gb = get_linux_mem_info()
+        logging.info(f"Memória Total: {mem_total_gb:.2f} GB")
+
+        # 4. Armazenamento (Disco onde o script está rodando)
+        # Pega o uso do disco no diretório atual (.)
+        total, used, free = shutil.disk_usage(".")
+        logging.info(f"Disco (Total): {total // (2**30)} GB")
+        logging.info(f"Disco (Livre): {free // (2**30)} GB")
+
+        logging.info("=" * 30)
+
+    except Exception as e:
+        logging.warning(f"Falha ao coletar info do sistema: {e}")
+
+
+def setup_logger():
+    """
+    Configura o logger para escrever no terminal e em arquivo simultaneamente.
+    """
+    # Cria pasta de logs se não existir
+    os.makedirs(LOG_FOLDER, exist_ok=True)
+
+    # Nome do arquivo com Timestamp
+    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    log_filename = os.path.join(LOG_FOLDER, f"execucao_{timestamp}.log")
+
+    # Configuração do Logger
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+
+    # Formato da mensagem
+    formatter = logging.Formatter(
+        "%(asctime)s [%(levelname)s] %(message)s", datefmt="%d/%m/%Y %H:%M:%S"
+    )
+
+    # Handler Arquivo
+    file_handler = logging.FileHandler(log_filename, encoding="utf-8")
+    file_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+
+    # Handler Terminal (Console)
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+    return logger, log_filename
+
+
+def process_single_file(file_name):
+    """
+    Worker: Processa um arquivo. Retorna um dict com status de sucesso/erro.
+    """
+    file_path = os.path.join(MMP_FOLDER, file_name)
+    pid = os.getpid()
+
+    # Resultado padrão
+    result = {"success": False, "file": file_name, "data": None, "error": None}
+
+    try:
+        logging.info(f"[PID {pid}] Processando: {file_name}")
+
+        mmp_data = None
+
+        if file_name.endswith(".mmpz"):
+            destination_path = os.path.join(MMPZ_FOLDER, file_name)
+
+            # Movimentação de arquivo
+            if not os.path.exists(destination_path):
+                shutil.move(file_path, destination_path)
+                logging.info(f"[PID {pid}] Movido para: {destination_path}")
+            else:
+                logging.info(
+                    f"[PID {pid}] Arquivo já existe em {destination_path}, usando existente."
+                )
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+
+            mmp_name = os.path.splitext(file_name)[0] + ".mmp"
+            output_mmp_path = os.path.join(MMP_FOLDER, mmp_name)
+
+            # Ambiente para LMMS Headless
+            env = os.environ.copy()
+            env["QT_QPA_PLATFORM"] = "offscreen"
+
+            # Conversão MMPZ -> MMP
             convert_cmd = f'lmms --dump "{destination_path}" > "{output_mmp_path}"'
+            try:
+                # capture_output=True permite jogar o log do LMMS para o nosso arquivo de log
+                subprocess.run(
+                    convert_cmd,
+                    shell=True,
+                    check=True,
+                    env=env,
+                    capture_output=True,
+                    text=True,
+                )
+                logging.info(f"[PID {pid}] {file_name}: Convertido para .mmp")
+            except subprocess.CalledProcessError as e:
+                error_msg = f"Erro conversão .mmp (LMMS): {e.stderr}"
+                logging.error(f"[PID {pid}] {file_name}: {error_msg}")
+                result["error"] = error_msg
+                return result
+
+            # Conversão -> WAV
+            wav_output_path = os.path.join(WAV_FOLDER, os.path.splitext(file_name)[0])
+            wav_convert_cmd = (
+                f'lmms -r "{destination_path}" -o "{wav_output_path}" -f wav'
+            )
 
             try:
-                os.environ['QT_QPA_PLATFORM'] = 'offscreen'
-                subprocess.run(convert_cmd, shell=True, check=True)
-                print("Convertido para .mmp com sucesso!")
+                subprocess.run(
+                    wav_convert_cmd,
+                    shell=True,
+                    check=True,
+                    env=env,
+                    capture_output=True,
+                    text=True,
+                )
+                logging.info(f"[PID {pid}] {file_name}: Convertido para .wav")
             except subprocess.CalledProcessError as e:
-                print(f"Erro ao converter .mmpz para .mmp: {e}")
+                # Erro no WAV não para o processo de indexação, apenas loga
+                logging.warning(
+                    f"[PID {pid}] {file_name}: Falha no render WAV: {e.stderr}"
+                )
 
-            wav_output_path = os.path.join(wav_folder, os.path.splitext(file)[0])
-            wav_convert_cmd = f'lmms -r "{destination_path}" -o "{wav_output_path}" -f wav'
+            if os.path.exists(output_mmp_path):
+                mmp_data = parse_mmp_file(output_mmp_path)
+            else:
+                result["error"] = "Arquivo .mmp não foi gerado após dump."
+                return result
 
-            try:
-                subprocess.run(wav_convert_cmd, shell=True, check=True)
-                print("Convertido para .wav com sucesso!")
-            except subprocess.CalledProcessError as e:
-                print(f"Erro ao converter .wav: {e}")
-
-            mmp_data = parse_mmp_file(output_mmp_path)
-
-        elif file.endswith('.mmp'):
+        elif file_name.endswith(".mmp"):
             mmp_data = parse_mmp_file(file_path)
 
+        # Salvamento Individual
         if mmp_data:
-            all_data.append(mmp_data)
-
-            json_file_path = os.path.join(metadata_folder, os.path.splitext(file)[0] + ".json")
-            yaml_file_path = os.path.join(data_folder, os.path.splitext(file)[0] + ".yml")
+            json_file_path = os.path.join(
+                METADATA_FOLDER, os.path.splitext(file_name)[0] + ".json"
+            )
+            yaml_file_path = os.path.join(
+                DATA_FOLDER, os.path.splitext(file_name)[0] + ".yml"
+            )
 
             save_to_yaml(mmp_data, yaml_file_path)
             save_to_json(mmp_data, json_file_path)
 
-            print(f"Dados salvos: {json_file_path}, {yaml_file_path}")
+            result["success"] = True
+            result["data"] = mmp_data
+            return result
+        else:
+            result["error"] = "Parser retornou dados vazios."
+            return result
 
-    return all_data
+    except Exception as e:
+        error_msg = f"Exceção não tratada: {str(e)}"
+        logging.error(f"[PID {pid}] {file_name}: {error_msg}")
+        result["error"] = error_msg
+        return result
 
-mmp_folder_path = '/nethome/jotachina/projetos/mmpSearch/mmp'
-processed_data = process_mmps_in_folder(mmp_folder_path)
-save_to_json(processed_data, '/nethome/jotachina/projetos/mmpSearch/metadata/all.json')
-save_to_yaml(processed_data, '/nethome/jotachina/projetos/mmpSearch/_data/all.yml')
 
-print("Processamento concluído.")
+def main_parallel():
+    # 1. Configura Logger e Timer
+    logger, log_file_path = setup_logger()
+    start_time = time.time()
+
+    # Informações do PC/S.O
+    log_system_info()
+
+    logging.info("=== Iniciando Pipeline de Indexação Paralela ===")
+    logging.info(f"Log sendo salvo em: {log_file_path}")
+
+    # 2. Criação de Pastas
+    create_folders_if_not_exist([MMPZ_FOLDER, WAV_FOLDER, METADATA_FOLDER, DATA_FOLDER])
+
+    # 3. Listagem
+    if not os.path.exists(MMP_FOLDER):
+        logging.critical(f"Pasta {MMP_FOLDER} não encontrada.")
+        return
+
+    all_files = [
+        f for f in os.listdir(MMP_FOLDER) if f.endswith(".mmp") or f.endswith(".mmpz")
+    ]
+    total_files = len(all_files)
+
+    if total_files == 0:
+        logging.warning("Nenhum arquivo .mmp ou .mmpz encontrado para processar.")
+        return
+
+    logging.info(f"Iniciando processamento de {total_files} arquivos.")
+
+    # 4. Pool Paralelo (ETAPA 1: Processamento Pesado)
+    num_cores = multiprocessing.cpu_count()
+    logging.info(f"Utilizando {num_cores} núcleos de CPU.")
+
+    with multiprocessing.Pool(processes=num_cores) as pool:
+        results = pool.map(process_single_file, all_files)
+
+    # 5. Processamento dos Resultados
+    successful_data = []
+    failed_files = []
+
+    for res in results:
+        if res["success"]:
+            successful_data.append(res["data"])
+        else:
+            failed_files.append(res)
+
+    # 6. Salvamento Consolidado
+    if successful_data:
+        save_to_json(successful_data, os.path.join(METADATA_FOLDER, "all.json"))
+        save_to_yaml(successful_data, os.path.join(DATA_FOLDER, "all.yml"))
+        logging.info("Arquivos 'all.json' e 'all.yml' gerados com sucesso.")
+
+    # >>> ETAPA 2: Geração de Manifestos <<<
+    manifest_report = {"generated": [], "failed": []}
+    try:
+        # Capturamos o relatório retornado pela função
+        manifest_report = generate_manifests(BASE_PATH)
+    except Exception as e:
+        logging.error(f"Falha crítica no gerador de manifestos: {e}")
+
+    # 7. Relatório Final Completo
+    end_time = time.time()
+    duration = end_time - start_time
+
+    logging.info("=" * 60)
+    logging.info(
+        f"RELATÓRIO DE EXECUÇÃO - {datetime.now().strftime('%d/%m/%Y %H:%M:%S')}"
+    )
+    logging.info("=" * 60)
+
+    logging.info(f"Tempo Total do Pipeline: {duration:.2f} segundos")
+
+    # Seção 1: Processamento Paralelo (Arquivos MMP)
+    logging.info("-" * 20)
+    logging.info("[1] Indexação Paralela (Arquivos .mmp/.mmpz)")
+    logging.info(f"    Total Encontrado:  {total_files}")
+    logging.info(f"    Sucessos:          {len(successful_data)}")
+    logging.info(f"    Falhas:            {len(failed_files)}")
+
+    if failed_files:
+        for fail in failed_files:
+            logging.error(f"    -> FALHA: {fail['file']} | Erro: {fail['error']}")
+
+    # Seção 2: Geração de Manifestos
+    logging.info("-" * 20)
+    logging.info("[2] Geração de Manifestos (Frontend)")
+
+    if manifest_report["generated"]:
+        for item in manifest_report["generated"]:
+            logging.info(f"    [OK] {item}")
+
+    if manifest_report["failed"]:
+        for item in manifest_report["failed"]:
+            logging.error(f"    [X]  {item}")
+
+    if not manifest_report["generated"] and not manifest_report["failed"]:
+        logging.warning("    [!] Nenhum manifesto foi processado.")
+
+    logging.info("=" * 60)
+    logging.info("Pipeline finalizado.")
+
+    # >>> ETAPA 3: Análise de Integridade (NOVO) <<<
+    try:
+        # Caminhos (ajuste conforme sua estrutura real)
+        PROJECTS_DB = os.path.join(METADATA_FOLDER, "all.json")
+        SAMPLES_MANIFEST = os.path.join(METADATA_FOLDER, "samples-manifest.json")
+        REPORT_FILE = os.path.join(METADATA_FOLDER, "dependency_report.json")
+
+        if os.path.exists(PROJECTS_DB) and os.path.exists(SAMPLES_MANIFEST):
+            check_dependencies(PROJECTS_DB, SAMPLES_MANIFEST, REPORT_FILE)
+        else:
+            logging.warning(
+                "Arquivos necessários para verificação de dependência não encontrados."
+            )
+
+    except Exception as e:
+        logging.error(f"Erro na verificação de dependências: {e}")
+
+
+if __name__ == "__main__":
+    main_parallel()