Initial commit with RGSX project files

network.py

@@ -0,0 +1,381 @@
+import requests
+import subprocess
+import re
+import os
+import threading
+import pygame
+import zipfile
+import json
+from urllib.parse import urljoin, unquote
+import asyncio
+import config
+from utils import sanitize_filename
+import logging
+
+logger = logging.getLogger(__name__)
+
+JSON_EXTENSIONS = "/userdata/roms/ports/RGSX/rom_extensions.json"
+
+def test_internet():
+    logger.debug("Test de connexion Internet")
+    try:
+        result = subprocess.run(['ping', '-c', '4', '8.8.8.8'], capture_output=True, text=True, timeout=5)
+        if result.returncode == 0:
+            logger.debug("Connexion Internet OK")
+            return True
+        else:
+            logger.debug("Échec ping 8.8.8.8")
+            return False
+    except Exception as e:
+        logger.debug(f"Erreur test Internet: {str(e)}")
+        return False
+
+def load_extensions_json():
+    """Charge le fichier JSON contenant les extensions supportées."""
+    try:
+        with open(JSON_EXTENSIONS, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception as e:
+        logger.error(f"Erreur lors de la lecture de {JSON_EXTENSIONS}: {e}")
+        return []
+
+def is_extension_supported(filename, platform, extensions_data):
+    """Vérifie si l'extension du fichier est supportée pour la plateforme donnée."""
+    extension = os.path.splitext(filename)[1].lower()
+    dest_dir = None
+    for platform_dict in config.platform_dicts:
+        if platform_dict["platform"] == platform:
+            dest_dir = platform_dict.get("folder")
+            break
+    if not dest_dir:
+        logger.warning(f"Aucun dossier 'folder' trouvé pour la plateforme {platform}")
+        dest_dir = os.path.join("/userdata/roms", platform)
+    for system in extensions_data:
+        if system["folder"] == dest_dir:
+            return extension in system["extensions"]
+    logger.warning(f"Aucun système trouvé pour le dossier {dest_dir}")
+    return False
+
+def extract_zip(zip_path, dest_dir, url):
+    """Extrait le contenu du fichier ZIP dans le dossier cible avec un suivi progressif de la progression."""
+    try:
+        lock = threading.Lock()
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            total_size = sum(info.file_size for info in zip_ref.infolist() if not info.is_dir())
+            logger.info(f"Taille totale à extraire: {total_size} octets")
+            if total_size == 0:
+                logger.warning("ZIP vide ou ne contenant que des dossiers")
+                return True, "ZIP vide extrait avec succès"
+
+            extracted_size = 0
+            os.makedirs(dest_dir, exist_ok=True)
+            chunk_size = 8192
+            for info in zip_ref.infolist():
+                if info.is_dir():
+                    continue
+                file_path = os.path.join(dest_dir, info.filename)
+                os.makedirs(os.path.dirname(file_path), exist_ok=True)
+                with zip_ref.open(info) as source, open(file_path, 'wb') as dest:
+                    file_size = info.file_size
+                    file_extracted = 0
+                    while True:
+                        chunk = source.read(chunk_size)
+                        if not chunk:
+                            break
+                        dest.write(chunk)
+                        file_extracted += len(chunk)
+                        extracted_size += len(chunk)
+                        with lock:
+                            config.download_progress[url]["downloaded_size"] = extracted_size
+                            config.download_progress[url]["total_size"] = total_size
+                            config.download_progress[url]["status"] = "Extracting"
+                            config.download_progress[url]["progress_percent"] = (extracted_size / total_size * 100) if total_size > 0 else 0
+                            config.needs_redraw = True  # Forcer le redraw
+                        logger.debug(f"Extraction {info.filename}, chunk: {len(chunk)}, file_extracted: {file_extracted}/{file_size}, total_extracted: {extracted_size}/{total_size}, progression: {(extracted_size/total_size*100):.1f}%")
+                os.chmod(file_path, 0o644)
+
+        for root, dirs, _ in os.walk(dest_dir):
+            for dir_name in dirs:
+                os.chmod(os.path.join(root, dir_name), 0o755)
+
+        os.remove(zip_path)
+        logger.info(f"Fichier ZIP {zip_path} extrait dans {dest_dir} et supprimé")
+        return True, "ZIP extrait avec succès"
+    except Exception as e:
+        logger.error(f"Erreur lors de l'extraction de {zip_path}: {e}")
+        return False, str(e)
+
+def extract_rar(rar_path, dest_dir, url):
+    """Extrait le contenu du fichier RAR dans le dossier cible, préservant la structure des dossiers."""
+    try:
+        lock = threading.Lock()
+        os.makedirs(dest_dir, exist_ok=True)
+        
+        result = subprocess.run(['unrar'], capture_output=True, text=True)
+        if result.returncode not in [0, 1]:
+            logger.error("Commande unrar non disponible")
+            return False, "Commande unrar non disponible"
+
+        result = subprocess.run(['unrar', 'l', '-v', rar_path], capture_output=True, text=True)
+        if result.returncode != 0:
+            error_msg = result.stderr.strip()
+            logger.error(f"Erreur lors de la liste des fichiers RAR: {error_msg}")
+            return False, f"Échec de la liste des fichiers RAR: {error_msg}"
+
+        logger.debug(f"Sortie brute de 'unrar l -v {rar_path}':\n{result.stdout}")
+
+        total_size = 0
+        files_to_extract = []
+        root_dirs = set()
+        lines = result.stdout.splitlines()
+        in_file_list = False
+        for line in lines:
+            if line.startswith("----"):
+                in_file_list = not in_file_list
+                continue
+            if in_file_list:
+                match = re.match(r'^\s*(\S+)\s+(\d+)\s+\d*\s*(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2})\s+(.+)$', line)
+                if match:
+                    attrs = match.group(1)
+                    file_size = int(match.group(2))
+                    file_date = match.group(3)
+                    file_name = match.group(4).strip()
+                    if 'D' not in attrs:
+                        files_to_extract.append((file_name, file_size))
+                        total_size += file_size
+                        root_dir = file_name.split('/')[0] if '/' in file_name else ''
+                        if root_dir:
+                            root_dirs.add(root_dir)
+                        logger.debug(f"Ligne parsée: {file_name}, taille: {file_size}, date: {file_date}")
+                    else:
+                        logger.debug(f"Dossier ignoré: {file_name}")
+                else:
+                    logger.debug(f"Ligne ignorée (format inattendu): {line}")
+
+        logger.info(f"Taille totale à extraire (RAR): {total_size} octets")
+        logger.debug(f"Fichiers à extraire: {files_to_extract}")
+        logger.debug(f"Dossiers racines détectés: {root_dirs}")
+        if total_size == 0:
+            logger.warning("RAR vide, ne contenant que des dossiers, ou erreur de parsing")
+            return False, "RAR vide ou erreur lors de la liste des fichiers"
+
+        with lock:
+            config.download_progress[url]["downloaded_size"] = 0
+            config.download_progress[url]["total_size"] = total_size
+            config.download_progress[url]["status"] = "Extracting"
+            config.download_progress[url]["progress_percent"] = 0
+            config.needs_redraw = True  # Forcer le redraw
+
+        escaped_rar_path = rar_path.replace(" ", "\\ ")
+        escaped_dest_dir = dest_dir.replace(" ", "\\ ")
+        process = subprocess.Popen(['unrar', 'x', '-y', escaped_rar_path, escaped_dest_dir], 
+                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        stdout, stderr = process.communicate()
+
+        if process.returncode != 0:
+            logger.error(f"Erreur lors de l'extraction de {rar_path}: {stderr}")
+            return False, f"Erreur lors de l'extraction: {stderr}"
+
+        extracted_size = 0
+        extracted_files = []
+        for root, _, files in os.walk(dest_dir):
+            for file in files:
+                file_path = os.path.join(root, file)
+                rel_path = os.path.relpath(file_path, dest_dir).replace(os.sep, '/')
+                for expected_file, file_size in files_to_extract:
+                    if rel_path == expected_file:
+                        extracted_size += file_size
+                        extracted_files.append(expected_file)
+                        os.chmod(file_path, 0o644)
+                        logger.debug(f"Fichier extrait: {expected_file}, taille: {file_size}, chemin: {file_path}")
+                        break
+
+        missing_files = [f for f, _ in files_to_extract if f not in extracted_files]
+        if missing_files:
+            logger.warning(f"Fichiers non extraits: {', '.join(missing_files)}")
+            return False, f"Fichiers non extraits: {', '.join(missing_files)}"
+
+        with lock:
+            config.download_progress[url]["downloaded_size"] = extracted_size
+            config.download_progress[url]["total_size"] = total_size
+            config.download_progress[url]["status"] = "Extracting"
+            config.download_progress[url]["progress_percent"] = 100 if total_size > 0 else 0
+            config.needs_redraw = True  # Forcer le redraw
+
+        if dest_dir == "/userdata/roms/ps3" and len(root_dirs) == 1:
+            root_dir = root_dirs.pop()
+            old_path = os.path.join(dest_dir, root_dir)
+            new_path = os.path.join(dest_dir, f"{root_dir}.ps3")
+            if os.path.isdir(old_path):
+                try:
+                    os.rename(old_path, new_path)
+                    logger.info(f"Dossier renommé: {old_path} -> {new_path}")
+                except Exception as e:
+                    logger.error(f"Erreur lors du renommage de {old_path} en {new_path}: {str(e)}")
+                    return False, f"Erreur lors du renommage du dossier: {str(e)}"
+            else:
+                logger.warning(f"Dossier racine {old_path} non trouvé après extraction")
+        elif dest_dir == "/userdata/roms/ps3" and len(root_dirs) > 1:
+            logger.warning(f"Plusieurs dossiers racines détectés dans l'archive: {root_dirs}. Aucun renommage effectué.")
+
+        for root, dirs, _ in os.walk(dest_dir):
+            for dir_name in dirs:
+                os.chmod(os.path.join(root, dir_name), 0o755)
+
+        os.remove(rar_path)
+        logger.info(f"Fichier RAR {rar_path} extrait dans {dest_dir} et supprimé")
+        return True, "RAR extrait avec succès"
+    except Exception as e:
+        logger.error(f"Erreur lors de l'extraction de {rar_path}: {str(e)}")
+        return False, str(e)
+    finally:
+        if os.path.exists(rar_path):
+            try:
+                os.remove(rar_path)
+                logger.info(f"Fichier RAR {rar_path} supprimé après échec de l'extraction")
+            except Exception as e:
+                logger.error(f"Erreur lors de la suppression de {rar_path}: {str(e)}")
+
+async def download_rom(url, platform, game_name, is_zip_non_supported=False):
+    logger.debug(f"Début téléchargement: {game_name} depuis {url}, is_zip_non_supported={is_zip_non_supported}")
+    result = [None, None]
+    
+    def download_thread():
+        logger.debug(f"Thread téléchargement démarré pour {url}")
+        try:
+            dest_dir = None
+            for platform_dict in config.platform_dicts:
+                if platform_dict["platform"] == platform:
+                    dest_dir = platform_dict.get("folder")
+                    break
+            if not dest_dir:
+                logger.warning(f"Aucun dossier 'folder' trouvé pour la plateforme {platform}")
+                dest_dir = os.path.join("/userdata/roms", platform)
+            
+            logger.debug(f"Vérification répertoire destination: {dest_dir}")
+            os.makedirs(dest_dir, exist_ok=True)
+            if not os.access(dest_dir, os.W_OK):
+                raise PermissionError(f"Pas de permission d'écriture dans {dest_dir}")
+                
+            sanitized_name = sanitize_filename(game_name)
+            dest_path = os.path.join(dest_dir, f"{sanitized_name}")
+            logger.debug(f"Chemin destination: {dest_path}")
+            
+            lock = threading.Lock()
+            with lock:
+                config.download_progress[url] = {
+                    "downloaded_size": 0,
+                    "total_size": 0,
+                    "status": "Téléchargement",
+                    "progress_percent": 0,
+                    "game_name": game_name
+                }
+                config.needs_redraw = True  # Forcer le redraw
+            logger.debug(f"Progression initialisée pour {url}")
+            
+            headers = {'User-Agent': 'Mozilla/5.0'}
+            logger.debug(f"Envoi requête GET à {url}")
+            response = requests.get(url, stream=True, headers=headers, timeout=30)
+            logger.debug(f"Réponse reçue, status: {response.status_code}")
+            response.raise_for_status()
+            
+            total_size = int(response.headers.get('content-length', 0))
+            logger.debug(f"Taille totale: {total_size} octets")
+            with lock:
+                config.download_progress[url]["total_size"] = total_size
+                config.needs_redraw = True  # Forcer le redraw
+            
+            downloaded = 0
+            with open(dest_path, 'wb') as f:
+                logger.debug(f"Ouverture fichier: {dest_path}")
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        with lock:
+                            config.download_progress[url]["downloaded_size"] = downloaded
+                            config.download_progress[url]["status"] = "Téléchargement"
+                            config.download_progress[url]["progress_percent"] = (downloaded / total_size * 100) if total_size > 0 else 0
+                            config.needs_redraw = True  # Forcer le redraw
+                        logger.debug(f"Progression: {downloaded}/{total_size} octets, {config.download_progress[url]['progress_percent']:.1f}%")
+            
+            if is_zip_non_supported:
+                with lock:
+                    config.download_progress[url]["downloaded_size"] = 0
+                    config.download_progress[url]["total_size"] = 0
+                    config.download_progress[url]["status"] = "Extracting"
+                    config.download_progress[url]["progress_percent"] = 0
+                    config.needs_redraw = True  # Forcer le redraw
+                extension = os.path.splitext(dest_path)[1].lower()
+                if extension == ".zip":
+                    success, msg = extract_zip(dest_path, dest_dir, url)
+                elif extension == ".rar":
+                    success, msg = extract_rar(dest_path, dest_dir, url)
+                else:
+                    raise Exception(f"Type d'archive non supporté: {extension}")
+                if not success:
+                    raise Exception(f"Échec de l'extraction de l'archive: {msg}")
+                result[0] = True
+                result[1] = f"Téléchargé et extrait : {game_name}"
+            else:
+                os.chmod(dest_path, 0o644)
+                logger.debug(f"Téléchargement terminé: {dest_path}")
+                result[0] = True
+                result[1] = f"Téléchargé : {game_name}"
+        except Exception as e:
+            logger.error(f"Erreur téléchargement {url}: {str(e)}")
+            if url in config.download_progress:
+                with lock:
+                    del config.download_progress[url]
+            if os.path.exists(dest_path):
+                os.remove(dest_path)
+            result[0] = False
+            result[1] = str(e)
+        finally:
+            logger.debug(f"Thread téléchargement terminé pour {url}")
+            with lock:
+                config.needs_redraw = True  # Forcer le redraw
+
+    thread = threading.Thread(target=download_thread)
+    logger.debug(f"Démarrage thread pour {url}")
+    thread.start()
+    while thread.is_alive():
+        pygame.event.pump()
+        await asyncio.sleep(0.1)
+    thread.join()
+    logger.debug(f"Thread rejoint pour {url}")
+    
+    with threading.Lock():
+        config.download_result_message = result[1]
+        config.download_result_error = not result[0]
+        config.download_result_start_time = pygame.time.get_ticks()
+        config.menu_state = "download_result"
+        config.needs_redraw = True  # Forcer le redraw
+    logger.debug(f"Transition vers download_result, message={result[1]}, erreur={not result[0]}")
+    return result[0], result[1]
+
+def check_extension_before_download(url, platform, game_name):
+    """Vérifie l'extension avant de lancer le téléchargement."""
+    try:
+        sanitized_name = sanitize_filename(game_name)
+        extensions_data = load_extensions_json()
+        if not extensions_data:
+            logger.error(f"Fichier {JSON_EXTENSIONS} vide ou introuvable")
+            return False, "Fichier de configuration des extensions introuvable", False
+        
+        is_supported = is_extension_supported(sanitized_name, platform, extensions_data)
+        extension = os.path.splitext(sanitized_name)[1].lower()
+        is_archive = extension in (".zip", ".rar")
+        
+        if is_supported:
+            logger.debug(f"L'extension de {sanitized_name} est supportée pour {platform}")
+            return True, "", False
+        else:
+            if is_archive:
+                logger.debug(f"Fichier {extension.upper()} détecté pour {sanitized_name}, extraction automatique prévue")
+                return False, f"Fichiers {extension.upper()} non supportés par cette plateforme, extraction automatique après le téléchargement.", True
+            logger.debug(f"L'extension de {sanitized_name} n'est pas supportée pour {platform}")
+            return False, f"L'extension de {sanitized_name} n'est pas supportée pour {platform}", False
+    except Exception as e:
+        logger.error(f"Erreur vérification extension {url}: {str(e)}")
+        return False, str(e), False