youcaport 0.1.0__py3-none-any.whl

youcaport/__init__.py

@@ -0,0 +1,23 @@
+"""YoucaPort — gestionnaire de ports en ligne de commande."""
+
+from __future__ import annotations
+
+import tomllib
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+
+def _version() -> str:
+    """Renvoie la version du paquet (source de vérité : pyproject.toml)."""
+    try:
+        return version("youcaport")
+    except PackageNotFoundError:
+        chemin_pyproject = Path(__file__).resolve().parents[2] / "pyproject.toml"
+        with chemin_pyproject.open("rb") as fichier:
+            projet = tomllib.load(fichier)
+        return str(projet["project"]["version"])
+
+
+__version__ = _version()
+
+__all__ = ["__version__"]

youcaport/cli.py

@@ -0,0 +1,415 @@
+"""Points d'entrée CLI de YoucaPort (Typer)."""
+
+from __future__ import annotations
+
+from typing import NoReturn
+
+import typer
+
+from youcaport import __version__
+from youcaport import dashboard as module_dashboard
+from youcaport.core import (
+    docker_manager,
+    port_manager,
+    privileges,
+    process_manager,
+    profiles,
+    project_manager,
+    suggester,
+)
+from youcaport.core.port_manager import LIBRE, OCCUPE, InfoPort, PortSansProcessusError
+from youcaport.core.process_manager import Processus, ProcessusIntrouvableError
+from youcaport.core.profiles import ProfilInexistantError
+from youcaport.core.validator import valider_port
+from youcaport.menu import lancer_menu
+from youcaport.utils import terminal
+
+app = typer.Typer(
+    add_completion=False,
+    rich_markup_mode="rich",
+    help="**YoucaPort** : lister, vérifier et libérer les ports utilisés localement.",
+    no_args_is_help=False,
+    epilog=(
+        "Documentation : https://github.com/Fitiafenohaja/YoucaPort\n"
+        "Astuce : sous Linux, ajoutez `--sudo` pour identifier puis arrêter "
+        "aussi les ports protégés (root/docker)."
+    ),
+)
+
+app_profile = typer.Typer(help="Gère les profils de projets (association ports ↔ projets).")
+app.add_typer(app_profile, name="profile")
+
+app_docker = typer.Typer(help="Gère les conteneurs Docker qui publient des ports (V6).")
+app.add_typer(app_docker, name="docker")
+
+
+def _callback_version(valeur: bool) -> None:
+    """Affiche la version puis quitte lorsque --version est fourni."""
+    if valeur:
+        typer.echo(f"youcaport {__version__}")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def principal(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Affiche la version et quitte.",
+        is_eager=True,
+        callback=_callback_version,
+    ),
+) -> None:
+    """YoucaPort : gestion simple des ports réseau locaux."""
+    if ctx.invoked_subcommand is None:
+        try:
+            lancer_menu()
+        except KeyboardInterrupt:
+            terminal.afficher_information("À bientôt !")
+
+
+@app.command()
+def status(
+    sudo: bool = typer.Option(
+        False,
+        "--sudo",
+        help="Identifie aussi les ports protégés (root/docker). Mot de passe demandé si besoin.",
+    ),
+) -> None:
+    """Affiche les ports actuellement utilisés."""
+    try:
+        infos = port_manager.lister_ports_utilises()
+        if sudo:
+            infos = _enrichir_sudo(infos)
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    if not infos:
+        terminal.afficher_information("Aucun port en écoute actuellement.")
+        return
+
+    terminal.afficher_ports(infos)
+    terminal.afficher_resume_ports(infos)
+
+
+@app.command()
+def check(
+    port: str,
+    sudo: bool = typer.Option(
+        False,
+        "--sudo",
+        help="Identifie le processus même s'il est protégé (root/docker).",
+    ),
+) -> None:
+    """Vérifie si un port est libre ou occupé."""
+    try:
+        info = port_manager.verifier_port(port)
+        if sudo:
+            infos = _enrichir_sudo([info])
+            info = infos[0]
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    if info.etat == LIBRE:
+        terminal.afficher_port_libre(info)
+    else:
+        terminal.afficher_port_occupe(info)
+        if info.processus is None and not sudo and privileges.sudo_disponible():
+            terminal.afficher_information(
+                f"Astuce : `youcaport check {info.port} --sudo` identifie ce processus protégé."
+            )
+        terminal.afficher_suggestions(suggester.suggerer_ports_libres(info.port))
+
+
+@app.command()
+def free(
+    port: str,
+    sudo: bool = typer.Option(
+        False,
+        "--sudo",
+        help="Autorise l'arrêt des processus protégés (root/docker) via sudo.",
+    ),
+) -> None:
+    """Libère un port en arrêtant le processus qui l'occupe."""
+    try:
+        info = port_manager.verifier_port(port)
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    if info.etat == LIBRE:
+        terminal.afficher_erreur(f"Aucun processus trouvé sur le port {info.port}.")
+        raise typer.Exit(code=1)
+
+    mapping: dict[int, dict] = {}
+    if info.processus is None:
+        if not sudo:
+            if privileges.sudo_disponible():
+                terminal.afficher_information(
+                    f"Astuce : `youcaport free --sudo {info.port}` arrête aussi "
+                    "les processus protégés (root/docker)."
+                )
+            _sortie_erreur(
+                PortSansProcessusError(
+                    f"Le port {info.port} est occupé mais aucun processus n'y est associé."
+                )
+            )
+        try:
+            mapping = privileges.connexions_privilegiees(interactif=True)
+        except privileges.SudoNonDisponibleError as exc:
+            _sortie_erreur(exc)
+        donnees = mapping.get(info.port)
+        if donnees is None:
+            _sortie_erreur(
+                PortSansProcessusError(
+                    f"Le port {info.port} est occupé mais aucun processus n'y est associé."
+                )
+            )
+        info = InfoPort(
+            port=info.port,
+            processus=Processus(
+                pid=donnees["pid"],
+                nom=donnees["nom"],
+                executable="",
+                commande=donnees["nom"],
+                etat=donnees["etat"],
+            ),
+            etat=OCCUPE,
+        )
+
+    terminal.afficher_resume_processus(info)
+    if mapping:
+        terminal.afficher_information(
+            "Ce processus est protégé (root/docker) : il sera arrêté via sudo."
+        )
+    _prevenir_arret_immediat()
+    if not terminal.demander_confirmation():
+        terminal.afficher_information("Arrêt annulé, aucun processus arrêté.")
+        return
+
+    terminal.afficher_information("Arrêt du processus...")
+    try:
+        if mapping:
+            port_manager.liberer_port_privilegie(info.port, mapping)
+        else:
+            port_manager.liberer_port(info.port)
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    terminal.afficher_succes("Processus arrêté.")
+    terminal.afficher_succes(f"Port {info.port} libéré.")
+
+
+def _prevenir_arret_immediat() -> None:
+    """Prévient que l'arrêt est immédiat sur Windows (pas de fermeture gracieuse)."""
+    if not process_manager.ARRET_DOUX:
+        terminal.afficher_information(
+            "Remarque : sur Windows, l'arrêt du processus est immédiat "
+            "(aucune fermeture gracieuse n'est possible)."
+        )
+
+
+def _enrichir_sudo(infos: list[InfoPort]) -> list[InfoPort]:
+    """Tente d'enrichir les ports non identifiés avec les données privilégiées."""
+    try:
+        mapping = privileges.connexions_privilegiees(interactif=True)
+    except privileges.SudoNonDisponibleError as exc:
+        terminal.afficher_information(str(exc))
+        return infos
+    return port_manager.enrichir_privilegies(infos, mapping)
+
+
+@app.command()
+def suggest(
+    port: str,
+    count: int = typer.Option(
+        3,
+        "--count",
+        min=1,
+        max=10,
+        help="Nombre de ports libres à suggérer (1-10).",
+    ),
+) -> None:
+    """Suggère des ports libres proches d'un port donné (Auto Port)."""
+    try:
+        candidats = suggester.suggerer_ports_libres(port, count)
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    if not candidats:
+        terminal.afficher_information("Aucun port libre trouvé après ce port.")
+        return
+
+    terminal.afficher_suggestions(candidats)
+
+
+@app.command()
+def project(
+    chemin: str = typer.Argument(".", help="Dossier du projet à analyser."),
+) -> None:
+    """Affiche les ports utilisés par un projet."""
+    try:
+        infos = project_manager.lister_ports_projet(chemin)
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    if not infos:
+        terminal.afficher_information("Aucun port en écoute détecté pour ce projet.")
+        return
+
+    terminal.afficher_ports(infos)
+
+
+@app.command()
+def dashboard(
+    port: int = typer.Option(
+        8421,
+        "--port",
+        help="Port sur lequel écoute l'interface web locale.",
+    ),
+    no_browser: bool = typer.Option(
+        False,
+        "--no-browser",
+        help="N'ouvre pas automatiquement le navigateur.",
+    ),
+    sudo: bool = typer.Option(
+        False,
+        "--sudo",
+        help="Identifie les ports protégés (uniquement si sudo est déjà authentifié).",
+    ),
+) -> None:
+    """Démarre une interface web locale pour visualiser les ports."""
+    try:
+        valider_port(port)
+        module_dashboard.lancer_dashboard(port, ouvrir_navigateur=not no_browser, avec_sudo=sudo)
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+
+@app_docker.command("list")
+def docker_liste() -> None:
+    """Liste les conteneurs Docker en cours d'exécution et leurs ports hôtes."""
+    try:
+        conteneurs = docker_manager.lister_conteneurs()
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    if not conteneurs:
+        terminal.afficher_information("Aucun conteneur Docker en cours d'exécution.")
+        return
+
+    terminal.afficher_conteneurs(conteneurs)
+
+
+@app_docker.command("show")
+def docker_affichage(port: str) -> None:
+    """Affiche le conteneur Docker qui publie un port hôte donné."""
+    try:
+        numero = valider_port(port)
+        conteneur = docker_manager.conteneur_pour_port(numero)
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    if conteneur is None:
+        _sortie_erreur(
+            docker_manager.ConteneurIntrouvableError(f"Aucun conteneur ne publie le port {numero}.")
+        )
+
+    terminal.afficher_conteneur(conteneur, numero)
+
+
+@app_docker.command("stop")
+def docker_stop(port: str) -> None:
+    """Arrête le conteneur Docker qui publie un port (confirmation obligatoire)."""
+    try:
+        numero = valider_port(port)
+        conteneur = docker_manager.conteneur_pour_port(numero)
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    if conteneur is None:
+        _sortie_erreur(
+            docker_manager.ConteneurIntrouvableError(f"Aucun conteneur ne publie le port {numero}.")
+        )
+
+    terminal.afficher_conteneur(conteneur, numero)
+    if not terminal.demander_confirmation(f"Arrêter le conteneur '{conteneur.nom}' ?"):
+        terminal.afficher_information("Arrêt annulé, aucun conteneur arrêté.")
+        return
+
+    terminal.afficher_information("Arrêt du conteneur...")
+    try:
+        docker_manager.arreter_conteneur(conteneur)
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    terminal.afficher_succes(f"Conteneur '{conteneur.nom}' arrêté.")
+
+
+@app_profile.command("list")
+def profile_liste() -> None:
+    """Liste les profils enregistrés."""
+    try:
+        profils = profiles.lister_profils()
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    if not profils:
+        terminal.afficher_information("Aucun profil enregistré.")
+        return
+
+    terminal.afficher_profils(profils)
+
+
+@app_profile.command("add")
+def profile_ajout(nom: str, port: str) -> None:
+    """Associe un port à un profil de projet."""
+    try:
+        profiles.ajouter_profil(nom, port)
+        profils = profiles.lister_profils()
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    terminal.afficher_succes(f"Profil '{nom}' : ports {', '.join(map(str, profils[nom]))}.")
+
+
+@app_profile.command("show")
+def profile_affichage(nom: str) -> None:
+    """Affiche l'état des ports d'un profil."""
+    try:
+        profils = profiles.lister_profils()
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    if nom not in profils:
+        _sortie_erreur(ProfilInexistantError(f"Le profil '{nom}' n'existe pas."))
+
+    try:
+        infos = [port_manager.verifier_port(numero) for numero in profils[nom]]
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    terminal.afficher_ports(infos)
+
+
+@app_profile.command("remove")
+def profile_suppression(nom: str) -> None:
+    """Supprime un profil complet."""
+    try:
+        profiles.supprimer_profil(nom)
+    except Exception as exc:
+        _sortie_erreur(exc)
+
+    terminal.afficher_succes(f"Profil '{nom}' supprimé.")
+
+
+def _sortie_erreur(exc: Exception) -> NoReturn:
+    """Affiche une erreur compréhensible puis quitte proprement (code 1)."""
+    terminal.afficher_exception(exc)
+    code = 0 if isinstance(exc, ProcessusIntrouvableError) else 1
+    raise typer.Exit(code=code)
+
+
+if __name__ == "__main__":
+    app()

youcaport/core/docker_manager.py

@@ -0,0 +1,124 @@
+"""Gestion des conteneurs Docker qui publient des ports (V6).
+
+Interagit avec le CLI `docker ps` / `docker stop` ; aucun accès direct à
+l'API Docker ni à la socket.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+
+from youcaport.core.validator import YoucaPortError
+
+_FORMAT_PS = "{{.ID}}\t{{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}"
+
+
+class DockerNonDisponibleError(YoucaPortError):
+    """docker est introuvable ou n'a pas pu s'exécuter."""
+
+
+class ConteneurIntrouvableError(YoucaPortError):
+    """Aucun conteneur ne publie le port demandé."""
+
+
+@dataclass(frozen=True)
+class Conteneur:
+    """Description d'un conteneur Docker et de ses ports publics publiés."""
+
+    identifiant: str
+    nom: str
+    image: str
+    statut: str
+    ports: frozenset[int]
+
+
+def docker_disponible() -> bool:
+    """Indique si le CLI docker est exécutable sur le système."""
+    return shutil.which("docker") is not None
+
+
+def lister_conteneurs() -> list[Conteneur]:
+    """Liste les conteneurs en cours d'exécution et leurs ports publics.
+
+    Lève DockerNonDisponibleError si docker est absent ou a échoué.
+    """
+    if not docker_disponible():
+        raise DockerNonDisponibleError("Docker n'est pas installé ou absent du PATH.")
+
+    try:
+        resultat = subprocess.run(
+            ["docker", "ps", "--format", _FORMAT_PS],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise DockerNonDisponibleError("Le délai de réponse de Docker est dépassé.") from exc
+
+    if resultat.returncode != 0:
+        message = (resultat.stderr or "Docker n'a pas pu être interrogé.").strip()
+        raise DockerNonDisponibleError(message)
+
+    return _parser_ps(resultat.stdout)
+
+
+def conteneur_pour_port(port: int) -> Conteneur | None:
+    """Retourne le conteneur publiant un port hôte donné, sinon None."""
+    for conteneur in lister_conteneurs():
+        if port in conteneur.ports:
+            return conteneur
+    return None
+
+
+def arreter_conteneur(conteneur: Conteneur) -> None:
+    """Arrête proprement un conteneur (`docker stop`).
+
+    Lève DockerNonDisponibleError en cas d'échec.
+    """
+    if not docker_disponible():
+        raise DockerNonDisponibleError("Docker n'est pas installé ou absent du PATH.")
+
+    resultat = subprocess.run(
+        ["docker", "stop", conteneur.nom],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    if resultat.returncode != 0:
+        message = (resultat.stderr or "docker stop a échoué.").strip()
+        raise DockerNonDisponibleError(message)
+
+
+def _parser_ps(texte: str) -> list[Conteneur]:
+    """Convertit la sortie `docker ps` (format tabulé) en Conteneur."""
+    conteneurs: list[Conteneur] = []
+    for ligne in texte.splitlines():
+        champs = ligne.split("\t")
+        if len(champs) != 5:
+            continue
+        identifiant, nom, image, statut, ports = champs
+        conteneurs.append(
+            Conteneur(
+                identifiant=identifiant,
+                nom=nom,
+                image=image,
+                statut=statut,
+                ports=_parser_ports(ports),
+            )
+        )
+    return conteneurs
+
+
+def _parser_ports(texte: str) -> frozenset[int]:
+    """Extrait les ports publics publiés d'un champ « Ports » de `docker ps`."""
+    ports: set[int] = set()
+    for liaison in texte.split(","):
+        liaison = liaison.strip()
+        if "->" not in liaison:
+            continue
+        publique = liaison.split("->", 1)[0].rsplit(":", 1)[-1]
+        if publique.isdigit() and 1 <= int(publique) <= 65535:
+            ports.add(int(publique))
+    return frozenset(ports)

youcaport/core/port_manager.py

@@ -0,0 +1,129 @@
+"""Coordination de la gestion des ports et de leurs processus."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from youcaport.core import privileges, process_manager
+from youcaport.core.process_manager import Processus, ProcessusArretImpossibleError
+from youcaport.core.validator import YoucaPortError, valider_port
+
+OCCUPE = "OCCUPE"
+LIBRE = "LIBRE"
+
+
+class PortNonOccupeError(YoucaPortError):
+    """Le port demandé n'est utilisé par aucun processus."""
+
+
+class PortSansProcessusError(YoucaPortError):
+    """Le port est occupé mais aucun processus n'a pu être identifié."""
+
+
+@dataclass(frozen=True)
+class InfoPort:
+    """État d'un port et, le cas échéant, le processus qui l'occupe."""
+
+    port: int
+    processus: Processus | None
+    etat: str
+
+
+def lister_ports_utilises() -> list[InfoPort]:
+    """Liste les ports actuellement en écoute, triés par numéro.
+
+    Lève PermissionSystemeError si les connexions réseau sont inaccessibles.
+    """
+    infos: dict[tuple[int, int], InfoPort] = {}
+    for port, pid in process_manager.lister_connexions_ecoute():
+        processus = process_manager.construire_processus(pid) if pid != -1 else None
+        infos[(port, pid)] = InfoPort(port=port, processus=processus, etat=OCCUPE)
+
+    return [infos[cle] for cle in sorted(infos)]
+
+
+def verifier_port(port: int | str) -> InfoPort:
+    """Retourne l'état courant d'un port et son processus éventuel."""
+    numero = valider_port(port)
+    processus = process_manager.rechercher_premier_processus(numero)
+
+    if processus is not None:
+        return InfoPort(port=numero, processus=processus, etat=OCCUPE)
+
+    if process_manager.port_en_ecoute(numero):
+        return InfoPort(port=numero, processus=None, etat=OCCUPE)
+
+    return InfoPort(port=numero, processus=None, etat=LIBRE)
+
+
+def liberer_port(port: int | str) -> InfoPort:
+    """Arrête le processus occupant le port puis retourne le nouvel état.
+
+    Lève PortNonOccupeError si le port est déjà libre,
+    ProcessusIntrouvableError si le processus est déjà arrêté,
+    PermissionSystemeError ou ProcessusArretImpossibleError selon l'échec.
+    """
+    numero = valider_port(port)
+    processus = process_manager.rechercher_premier_processus(numero)
+
+    if processus is None:
+        if process_manager.port_en_ecoute(numero):
+            raise PortSansProcessusError(
+                f"Le port {numero} est occupé mais aucun processus n'y est associé."
+            )
+        raise PortNonOccupeError(f"Aucun processus trouvé sur le port {numero}.")
+
+    process_manager.arreter_processus(processus.pid)
+
+    apres = verifier_port(numero)
+    if apres.etat != LIBRE:
+        raise ProcessusArretImpossibleError(
+            f"Le processus a été arrêté mais le port {numero} est toujours utilisé."
+        )
+
+    return apres
+
+
+def enrichir_privilegies(infos: list[InfoPort], mapping: dict[int, dict]) -> list[InfoPort]:
+    """Remplace les ports sans processus par les données privilégiées (sudo)."""
+    retour: list[InfoPort] = []
+    for info in infos:
+        donnees = mapping.get(info.port) if info.processus is None else None
+        if donnees is None:
+            retour.append(info)
+            continue
+
+        retour.append(
+            InfoPort(
+                port=info.port,
+                processus=Processus(
+                    pid=donnees["pid"],
+                    nom=donnees["nom"],
+                    executable="",
+                    commande=donnees["nom"],
+                    etat=donnees["etat"],
+                ),
+                etat=info.etat,
+            )
+        )
+    return retour
+
+
+def liberer_port_privilegie(port: int | str, mapping: dict[int, dict]) -> InfoPort:
+    """Libère via sudo un port protégé dont le processus vient du mapping privilégié."""
+    numero = valider_port(port)
+    donnees = mapping.get(numero)
+    if donnees is None:
+        raise PortSansProcessusError(
+            f"Le port {numero} est occupé mais aucun processus n'y est associé."
+        )
+
+    privileges.arreter_privilegie(donnees["pid"])
+
+    apres = verifier_port(numero)
+    if apres.etat != LIBRE:
+        raise ProcessusArretImpossibleError(
+            f"Le processus a été arrêté mais le port {numero} est toujours utilisé."
+        )
+
+    return apres