Avant changements

app/Logs.py

@@ -0,0 +1,225 @@
+# Logs.py
+# Visualiseur de logs SSH ultra-simplifié (Streamlit)
+# - Lecture de la config via .env uniquement
+# - Connexion SSH via clé (chemin) ou mot de passe
+# - Liste des fichiers, tail dernier N, recherche, téléchargement
+
+import os
+import time
+import stat
+import paramiko
+import streamlit as st
+from dotenv import load_dotenv
+from typing import Optional, Tuple
+
+# ================
+#   CONFIG .env
+# ================
+load_dotenv()  # cherche automatiquement un .env dans le dossier courant
+
+VPS_HOST = os.getenv("SSH_HOST", "").strip()
+VPS_PORT = int(os.getenv("SSH_PORT", 22))
+VPS_USER = os.getenv("SSH_USER", "").strip()
+VPS_PASSWORD = os.getenv("SSH_PASSWORD", "")
+VPS_KEY_PATH = os.getenv("SSH_KEY_PATH", "").strip()
+VPS_LOG_DIR = os.getenv("SSH_LOG_DIR", "/home/debian/Gestion_sondes/Logs").rstrip("/")
+
+# ================
+#   UTILITAIRES
+# ================
+# --- Connexion strictement au MOT DE PASSE ---
+@st.cache_resource(show_spinner=False)
+def get_ssh_client_password_only() -> paramiko.SSHClient:
+    host = os.getenv("SSH_HOST", "").strip()
+    user = os.getenv("SSH_USER", "").strip()
+    port = int(os.getenv("SSH_PORT", 22))
+    pwd  = os.getenv("SSH_PASSWORD", "")
+
+    if not host or not user or not pwd:
+        raise RuntimeError("SSH_HOST / SSH_USER / SSH_PASSWORD manquant(s) dans .env")
+
+    client = paramiko.SSHClient()
+    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+    # IMPORTANT : on force l’usage du mot de passe, aucune clé n’est chargée
+    try:
+        client.connect(
+            hostname=host, port=port, username=user,
+            password=pwd, timeout=10, allow_agent=False, look_for_keys=False
+        )
+        # vérifie que le transport est bien up
+        t = client.get_transport()
+        if not t or not t.is_active():
+            raise RuntimeError("Transport SSH inactif après connexion.")
+        return client
+    except Exception as e:
+        raise RuntimeError(f"Échec connexion SSH par mot de passe : {e}") from e
+
+# --- Ouverture SFTP sûre ---
+try:
+    client = get_ssh_client_password_only()
+except Exception as e:
+    st.error(str(e))
+    st.stop()
+
+try:
+    sftp = client.open_sftp()
+except Exception as e:
+    st.error(f"Erreur ouverture SFTP : {e}")
+    try: client.close()
+    except: pass
+    st.stop()
+
+def list_remote_files(sftp: paramiko.SFTPClient, directory: str) -> list[Tuple[str, int, float]]:
+    """
+    Retourne [(nom, taille_bytes, mtime_epoch), ...] triés par mtime desc.
+    """
+    items = []
+    try:
+        for entry in sftp.listdir_attr(directory):
+            mode = entry.st_mode
+            if stat.S_ISREG(mode):
+                items.append((entry.filename, entry.st_size, entry.st_mtime))
+    except FileNotFoundError:
+        st.error(f"❌ Dossier introuvable côté serveur : {directory}")
+        return []
+    except Exception as e:
+        st.error(f"❌ Impossible de lister {directory} : {e}")
+        return []
+    items.sort(key=lambda t: t[2], reverse=True)
+    return items
+
+
+def read_remote_text_tail(
+    client: paramiko.SSHClient, path: str, lines: int = 500, grep: str | None = None
+) -> str:
+    """
+    Lit côté serveur les N dernières lignes (tail -n),
+    compatible .gz via zcat si nécessaire, avec grep optionnel (insensible à la casse).
+    """
+    safe_path = path.replace('"', '\\"')
+    if path.endswith(".gz"):
+        base_cmd = f'zcat "{safe_path}"'
+    else:
+        base_cmd = f'tail -n {max(1, lines)} "{safe_path}" && exit 0 || head -n {max(1, lines)} "{safe_path}"'
+
+    if grep:
+        # -i insensible à la casse ; on passe par grep après la commande de base
+        grep_safe = grep.replace('"', '\\"')  # échappe juste les guillemets
+        base_cmd = f'{base_cmd} | grep -i "{grep_safe}" || true'
+
+    stdin, stdout, stderr = client.exec_command(base_cmd, timeout=20)
+    out = stdout.read()
+    err = stderr.read()
+    text = (out or b"").decode("utf-8", errors="replace")
+    # Si zcat sans grep et sans tail (gros fichiers), on limite côté client pour éviter d'assommer Streamlit
+    if path.endswith(".gz") and not grep:
+        lines_list = text.splitlines()
+        text = "\n".join(lines_list[-max(1, lines):])
+    if err and not text:
+        # Afficher l'erreur seulement si rien en sortie
+        text = (b"[stderr] " + err).decode("utf-8", errors="replace")
+    return text
+
+
+def download_remote_file(sftp: paramiko.SFTPClient, path: str) -> bytes:
+    """Télécharge le fichier distant (binaire) en mémoire."""
+    with sftp.file(path, "rb") as f:
+        return f.read()
+
+
+# ================
+#   UI STREAMLIT
+# ================
+
+st.set_page_config(page_title="Visualiseur de Logs", layout="wide")
+st.title("📜 Visualiseur de logs (SSH)")
+
+with st.expander("Configuration (lecture seule)", expanded=False):
+    st.code(
+        f"HOST={VPS_HOST}\nUSER={VPS_USER}\nPORT={VPS_PORT}\n"
+        f"KEY_PATH={VPS_KEY_PATH or '-'}\nLOG_DIR={VPS_LOG_DIR}",
+        language="bash"
+    )
+
+client = _get_ssh_client()
+if client is None:
+    st.stop()
+
+try:
+    sftp = client.open_sftp()
+except Exception as e:
+    st.error(f"Erreur ouverture SFTP : {e}")
+    try:
+        client.close()
+    except Exception:
+        pass
+    st.stop()
+
+with st.sidebar:
+    st.header("🔎 Options")
+    refresh = st.button("🔄 Rafraîchir la liste")
+    default_tail = st.number_input("Dernières lignes (tail)", min_value=50, max_value=100_000, value=500, step=50)
+    search_term = st.text_input("Recherche (grep -i)", value="", placeholder="ex: ERROR | Timeout | sonde")
+    st.caption("Astuce : la recherche applique un grep insensible à la casse sur le résultat.")
+
+# Rafraîchissement simple : on rejoue listdir si bouton cliqué
+if refresh:
+    time.sleep(0.2)
+
+files = list_remote_files(sftp, VPS_LOG_DIR)
+if not files:
+    sftp.close()
+    client.close()
+    st.stop()
+
+# Tableau simple (nom, taille, date)
+col1, col2 = st.columns([2, 1])
+with col1:
+    names = [f[0] for f in files]
+    choice = st.selectbox("Fichiers disponibles (triés par date desc.)", names, index=0)
+with col2:
+    # Infos du fichier choisi
+    chosen = next((f for f in files if f[0] == choice), None)
+    if chosen:
+        size_kb = chosen[1] / 1024
+        mtime_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(chosen[2]))
+        st.metric("Taille (KB)", f"{size_kb:,.0f}".replace(",", " "))
+        st.metric("Modifié le", mtime_str)
+
+full_path = f"{VPS_LOG_DIR}/{choice}"
+
+# Actions
+place1, place2, place3 = st.columns([1, 1, 6])
+with place1:
+    do_show = st.button("👁️ Afficher")
+with place2:
+    do_dl = st.button("⬇️ Télécharger")
+
+# Affichage
+if do_show:
+    with st.spinner("Lecture du fichier distant..."):
+        text = read_remote_text_tail(
+            client,
+            full_path,
+            lines=int(default_tail),
+            grep=(search_term or None)
+        )
+    st.text_area(f"Contenu : {choice}", text, height=600)
+
+# Téléchargement
+if do_dl:
+    try:
+        data = download_remote_file(sftp, full_path)
+        st.download_button(
+            label=f"Télécharger {choice}",
+            data=data,
+            file_name=choice,
+            mime="application/octet-stream"
+        )
+    except Exception as e:
+        st.error(f"❌ Échec du téléchargement : {e}")
+
+# Fermeture propre
+sftp.close()
+client.close()