feat: ajouter le keepalive SSH et la reconnexion automatique
- Session gagne keepalive_enabled/interval/count_max (actif par defaut : ne fait qu'envoyer des paquets de maintien, sans risque pour les sessions existantes) et reconnect_enabled/initial_delay/max_attempts (desactive par defaut : change reellement le comportement en cas de coupure, donc a activer explicitement). - SSHConnection._keepalive_loop() : thread dedie qui envoie "keepalive@openssh.com" (comme OpenSSH) avec accuse de reception toutes les `keepalive_interval` secondes. Un serveur conforme repond immediatement (meme en echec), ce qui confirme que le transport est vivant. Apres `keepalive_count_max` echecs consecutifs (aucune reponse), le canal est ferme pour que la boucle de lecture principale s'en apercoive et emette `disconnected` avec une raison explicite. - SessionTabWidget programme une reconnexion (QTimer, jamais de blocage de l'interface) quand la session l'autorise et que la deconnexion n'est pas volontaire (_closing) : delai en backoff exponentiel plafonne (app.services.reconnect.compute_backoff_delay), compte a rebours affiche ("Connexion perdue (...). Reconnexion dans Ns... (Tentative X/Y)"), abandon au-dela de reconnect_max_attempts (0 = illimite), compteur remis a zero des qu'une connexion reussit. Ne se declenche jamais sur une simple erreur d'authentification (seul un `disconnected` apres connexion reussie declenche une reconnexion, pas un `error` de connexion initiale - sinon un mot de passe errone entrainerait des tentatives repetees). - BaseTerminalTab : les signaux connected/disconnected/error d'une connexion sont desormais associes a la generation de connexion en cours au moment ou ils sont cables ; un signal parvenant apres qu'une reconnexion (manuelle ou automatique) ait deja demarre une nouvelle connexion est ignore. Necessaire ici : les signaux Qt entre threads sont mis en file et ne sont livres qu'apres le retour de reconnect() a la boucle d'evenements, alors qu'une nouvelle connexion est deja en place. - SessionDialog : sections "Keepalive" et "Reconnexion automatique". tests/test_keepalive.py (paramiko entierement mocke), test_reconnect_backoff.py (fonction pure) et test_auto_reconnect.py (SSHConnection.start() neutralisee : la programmation de la reconnexion ne depend d'aucune connexion reseau reelle). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Florian
125
tests/test_auto_reconnect.py
Normal file
125
tests/test_auto_reconnect.py
Normal file
@@ -0,0 +1,125 @@
|
||||
"""Reconnexion automatique de SessionTabWidget : programmation du delai (avec
|
||||
backoff), plafond de tentatives, remise a zero apres succes, et absence de
|
||||
reconnexion sur une fermeture volontaire de l'onglet.
|
||||
|
||||
Pilote directement _on_disconnected()/_on_connected() plutot que d'attendre une
|
||||
vraie coupure reseau (la detection elle-meme est testee dans test_keepalive.py).
|
||||
SSHConnection.start() est neutralisee : ce module teste uniquement la logique
|
||||
de programmation du cote de l'onglet, qui n'a besoin d'aucune connexion reseau
|
||||
reelle - cela evite aussi qu'un thread reste bloque dans un connect() lent et
|
||||
ne bloque la fin du script.
|
||||
"""
|
||||
import sys, pathlib
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
|
||||
|
||||
import time
|
||||
from unittest.mock import patch
|
||||
|
||||
from PySide6.QtWidgets import QApplication
|
||||
|
||||
from app.session_manager import Session
|
||||
from app.ssh_connection import SSHConnection
|
||||
from app.ui.tabs import SessionTabWidget
|
||||
|
||||
app = QApplication.instance() or QApplication([])
|
||||
|
||||
|
||||
def pump(seconds: float) -> None:
|
||||
deadline = time.time() + seconds
|
||||
while time.time() < deadline:
|
||||
app.processEvents()
|
||||
time.sleep(0.01)
|
||||
|
||||
|
||||
def make_session(**overrides) -> Session:
|
||||
session = Session(name="t", host="10.0.0.1", port=22, username="root")
|
||||
for key, value in overrides.items():
|
||||
setattr(session, key, value)
|
||||
return session
|
||||
|
||||
|
||||
no_real_thread = patch.object(SSHConnection, "start", lambda self: None)
|
||||
no_real_thread.start()
|
||||
|
||||
print("=== 1. Reconnexion desactivee par defaut : aucune programmation ===")
|
||||
session = make_session()
|
||||
assert session.reconnect_enabled is False
|
||||
tab = SessionTabWidget(session, "")
|
||||
tab._on_disconnected("test")
|
||||
assert not tab._reconnect_timer.isActive()
|
||||
tab.close_connection()
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 2. Reconnexion activee : programmation avec le delai initial exact ===")
|
||||
session2 = make_session(reconnect_enabled=True, reconnect_initial_delay=1, reconnect_max_attempts=3)
|
||||
tab2 = SessionTabWidget(session2, "")
|
||||
tab2._on_disconnected("connexion perdue")
|
||||
print(" statut:", tab2.status_label.text())
|
||||
assert tab2._reconnect_timer.isActive()
|
||||
assert tab2._reconnect_attempt == 1
|
||||
assert tab2._reconnect_seconds_left == 1 # compute_backoff_delay(1, 1) == 1
|
||||
assert "Tentative 1/3" in tab2.status_label.text()
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 3. Le timer se declenche reellement et relance une connexion ===")
|
||||
pump(1.5)
|
||||
print(" countdown actif apres ~1.5s:", tab2._reconnect_countdown_timer.isActive())
|
||||
assert not tab2._reconnect_countdown_timer.isActive(), "le cycle doit s'etre declenche et avoir tout arrete"
|
||||
tab2.close_connection()
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 4. Plafond de tentatives : abandon au-dela de max_attempts ===")
|
||||
session3 = make_session(reconnect_enabled=True, reconnect_initial_delay=100, reconnect_max_attempts=2)
|
||||
tab3 = SessionTabWidget(session3, "")
|
||||
tab3._on_disconnected("r1")
|
||||
assert tab3._reconnect_attempt == 1 and tab3._reconnect_timer.isActive()
|
||||
tab3._cancel_reconnect_timers() # simule le declenchement du timer sans attendre 100s
|
||||
tab3._on_disconnected("r2")
|
||||
assert tab3._reconnect_attempt == 2 and tab3._reconnect_timer.isActive()
|
||||
tab3._cancel_reconnect_timers()
|
||||
tab3._on_disconnected("r3")
|
||||
print(" apres 3 echecs (max=2):", tab3.status_label.text())
|
||||
assert tab3._reconnect_attempt == 3
|
||||
assert not tab3._reconnect_timer.isActive(), "au-dela du plafond, plus de nouvelle tentative programmee"
|
||||
assert "Abandon" in tab3.status_label.text()
|
||||
tab3.close_connection()
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 5. Une connexion reussie remet le compteur de tentatives a zero ===")
|
||||
session4 = make_session(reconnect_enabled=True)
|
||||
tab4 = SessionTabWidget(session4, "")
|
||||
tab4._reconnect_attempt = 5
|
||||
tab4._on_connected()
|
||||
assert tab4._reconnect_attempt == 0
|
||||
tab4.close_connection()
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 6. Fermeture volontaire de l'onglet : jamais de reconnexion programmee ===")
|
||||
session5 = make_session(reconnect_enabled=True)
|
||||
tab5 = SessionTabWidget(session5, "")
|
||||
tab5.close_connection() # fermeture "pour de vrai" -> _closing = True
|
||||
tab5._on_disconnected("apres fermeture")
|
||||
assert not tab5._reconnect_timer.isActive()
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 7. Reconnexion manuelle (bouton) annule un compte a rebours en cours ===")
|
||||
session6 = make_session(reconnect_enabled=True, reconnect_initial_delay=100)
|
||||
tab6 = SessionTabWidget(session6, "")
|
||||
tab6._on_disconnected("r1")
|
||||
assert tab6._reconnect_timer.isActive()
|
||||
tab6.reconnect()
|
||||
assert not tab6._reconnect_timer.isActive()
|
||||
assert not tab6._reconnect_countdown_timer.isActive()
|
||||
tab6.close_connection()
|
||||
print(" OK")
|
||||
|
||||
no_real_thread.stop()
|
||||
|
||||
print()
|
||||
print("RECONNEXION AUTOMATIQUE : TOUS LES TESTS OK")
|
||||
112
tests/test_keepalive.py
Normal file
112
tests/test_keepalive.py
Normal file
@@ -0,0 +1,112 @@
|
||||
"""Keepalive de SSHConnection : verifie l'envoi periodique et l'abandon apres
|
||||
`keepalive_count_max` echecs consecutifs, avec un transport paramiko mocke
|
||||
(aucune connexion reseau reelle)."""
|
||||
import sys, pathlib
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
|
||||
|
||||
import threading
|
||||
import time
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
from PySide6.QtWidgets import QApplication
|
||||
|
||||
from app.ssh_connection import SSHConnection
|
||||
|
||||
app = QApplication.instance() or QApplication([])
|
||||
|
||||
|
||||
def make_connection(interval=0.05, count_max=3):
|
||||
conn = SSHConnection(
|
||||
host="10.0.0.1", port=22, username="root", auth_type="auto",
|
||||
keepalive_enabled=True, keepalive_interval=1, keepalive_count_max=count_max,
|
||||
)
|
||||
# keepalive_interval est borne a >= 1 dans __init__ (secondes reelles) : pour un
|
||||
# test rapide, on contourne ensuite l'attribut directement (le code ne relit
|
||||
# l'intervalle qu'a chaque iteration, une valeur fractionnaire est acceptee par
|
||||
# threading.Event.wait()).
|
||||
conn.keepalive_interval = interval
|
||||
return conn
|
||||
|
||||
|
||||
print("=== 1. Requetes reussies : le compteur d'echecs ne progresse jamais ===")
|
||||
conn = make_connection()
|
||||
transport = MagicMock()
|
||||
transport.is_active.return_value = True
|
||||
conn.client = MagicMock()
|
||||
conn.client.get_transport.return_value = transport
|
||||
|
||||
thread = threading.Thread(target=conn._keepalive_loop, daemon=True)
|
||||
thread.start()
|
||||
time.sleep(0.35)
|
||||
conn._stop.set()
|
||||
thread.join(timeout=2)
|
||||
|
||||
calls = transport.global_request.call_count
|
||||
print(f" requetes envoyees en ~0.35s (intervalle 0.05s): {calls}")
|
||||
assert calls >= 3, calls
|
||||
assert conn._disconnect_reason == "Connexion fermee" # jamais modifie : aucun echec
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 2. N echecs consecutifs -> abandon, canal ferme, raison mise a jour ===")
|
||||
conn2 = make_connection(count_max=3)
|
||||
transport2 = MagicMock()
|
||||
transport2.is_active.return_value = True
|
||||
transport2.global_request.side_effect = OSError("reseau injoignable")
|
||||
conn2.client = MagicMock()
|
||||
conn2.client.get_transport.return_value = transport2
|
||||
fake_channel = MagicMock()
|
||||
conn2.channel = fake_channel
|
||||
|
||||
thread2 = threading.Thread(target=conn2._keepalive_loop, daemon=True)
|
||||
thread2.start()
|
||||
thread2.join(timeout=3)
|
||||
|
||||
print(f" requetes tentees avant abandon: {transport2.global_request.call_count}")
|
||||
assert transport2.global_request.call_count == 3, transport2.global_request.call_count
|
||||
assert conn2._stop.is_set(), "la connexion doit etre marquee pour arret"
|
||||
assert fake_channel.close.called, "le canal doit etre ferme pour reveiller la boucle de lecture"
|
||||
print(" raison de deconnexion:", conn2._disconnect_reason)
|
||||
assert "keepalive" in conn2._disconnect_reason.lower()
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 3. Une reponse reussie apres des echecs repart de zero ===")
|
||||
conn3 = make_connection(count_max=3)
|
||||
transport3 = MagicMock()
|
||||
transport3.is_active.return_value = True
|
||||
_calls = {"n": 0}
|
||||
|
||||
|
||||
def _flaky_then_ok(*_a, **_k):
|
||||
_calls["n"] += 1
|
||||
if _calls["n"] <= 2:
|
||||
raise OSError("timeout")
|
||||
return None
|
||||
|
||||
|
||||
transport3.global_request.side_effect = _flaky_then_ok
|
||||
conn3.client = MagicMock()
|
||||
conn3.client.get_transport.return_value = transport3
|
||||
|
||||
thread3 = threading.Thread(target=conn3._keepalive_loop, daemon=True)
|
||||
thread3.start()
|
||||
time.sleep(0.35)
|
||||
conn3._stop.set()
|
||||
thread3.join(timeout=2)
|
||||
|
||||
print(f" requetes envoyees: {transport3.global_request.call_count} (jamais 3 echecs consecutifs)")
|
||||
# la connexion ne doit pas avoir ete abandonnee malgre 2 echecs, puisqu'un succes
|
||||
# est intervenu avant le 3e (le compteur d'echecs consecutifs est remis a zero) :
|
||||
assert conn3._disconnect_reason == "Connexion fermee"
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 4. Keepalive desactive : aucun thread demarre ===")
|
||||
conn4 = SSHConnection(host="10.0.0.1", port=22, username="root", auth_type="auto", keepalive_enabled=False)
|
||||
conn4._start_keepalive()
|
||||
assert conn4._keepalive_thread is None
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("KEEPALIVE : TOUS LES TESTS OK")
|
||||
32
tests/test_reconnect_backoff.py
Normal file
32
tests/test_reconnect_backoff.py
Normal file
@@ -0,0 +1,32 @@
|
||||
"""Calcul du delai de reconnexion automatique (backoff exponentiel plafonne)."""
|
||||
import sys, pathlib
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
|
||||
|
||||
from app.services.reconnect import compute_backoff_delay
|
||||
|
||||
print("=== 1. Progression exponentielle ===")
|
||||
delays = [compute_backoff_delay(n, initial_delay=5) for n in range(1, 6)]
|
||||
print(" delais:", delays)
|
||||
assert delays == [5, 10, 20, 40, 60], delays # le 5e (80s) est plafonne a 60s
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 2. Plafond respecte au-dela ===")
|
||||
assert compute_backoff_delay(10, initial_delay=5, max_delay=60) == 60
|
||||
assert compute_backoff_delay(20, initial_delay=5, max_delay=120) == 120
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 3. Tentative < 1 traitee comme la premiere ===")
|
||||
assert compute_backoff_delay(0, initial_delay=5) == 5
|
||||
assert compute_backoff_delay(-3, initial_delay=5) == 5
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("=== 4. Delai initial personnalise ===")
|
||||
assert compute_backoff_delay(1, initial_delay=10) == 10
|
||||
assert compute_backoff_delay(2, initial_delay=10) == 20
|
||||
print(" OK")
|
||||
|
||||
print()
|
||||
print("BACKOFF DE RECONNEXION : TOUS LES TESTS OK")
|
||||
Reference in New Issue
Block a user