nullgate 1.2.6__tar.gz → 1.2.8__tar.gz

{nullgate-1.2.6/src/nullgate.egg-info → nullgate-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nullgate
-Version: 1.2.6
+Version: 1.2.8
 Summary: Disposable SSH gateway into confined directory workspaces
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

nullgate-1.2.8/src/nullgate/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.2.8"

{nullgate-1.2.6 → nullgate-1.2.8}/src/nullgate/ingress.py

@@ -2,9 +2,11 @@
 """srv.us reverse tunnel for the Nullgate srvus transport.
 
 Holds one AsyncSSH connection to srv.us with a remote port forward pointing back
-at the local SSH server. AsyncSSH is already required by the server, so speaking
-SSH in-process here removes the OpenSSH client and ssh-keygen from the host's
-requirements; the tunnel then works on stripped images that ship neither.
+at the local SSH server, reconnecting with backoff whenever the server drops it
+(srv.us documents wrapping the tunnel in a reconnect loop). AsyncSSH is already
+required by the server, so speaking SSH in-process here removes the OpenSSH
+client and ssh-keygen from the host's requirements; the tunnel then works on
+stripped images that ship neither.
 
 Launch with asyncssh available, e.g.:
   python -m nullgate.ingress --local-port 4822 --slot 1
@@ -30,6 +32,9 @@ from nullgate.account import current_username, ensure_username_environment
 
 IDENTITY_SEED_ENV = "NULLGATE_IDENTITY_SEED"
 
+RECONNECT_MIN = 1.0
+RECONNECT_MAX = 30.0
+
 
 class TunnelClient(asyncssh.SSHClient):
     """Surface srv.us protocol messages in the tunnel log.
@@ -96,37 +101,19 @@ async def pump(reader: asyncssh.SSHReader, writer) -> None:
         writer.flush()
 
 
-async def run(
-    host: str,
-    port: int,
+async def serve_connection(
+    connection: asyncssh.SSHClientConnection,
     local_host: str,
     local_port: int,
     slot: int,
-    key: Path,
-    username: str,
-) -> int:
-    ensure_username_environment(username)
-    ensure_key(key)
-
-    stopped = asyncio.Event()
-    loop = asyncio.get_running_loop()
-    for signum in (signal.SIGINT, signal.SIGTERM):
-        with contextlib.suppress(NotImplementedError):
-            loop.add_signal_handler(signum, stopped.set)
-
-    # known_hosts=None matches the connection commands this project prints: the
-    # ingress is disposable and only carries bytes, so it is not authenticated.
-    connection = await asyncssh.connect(
-        host,
-        port=port,
-        username=username,
-        client_keys=[str(key)],
-        known_hosts=None,
-        client_factory=TunnelClient,
-        keepalive_interval=30,
-        keepalive_count_max=3,
-    )
+    stopped: asyncio.Event,
+) -> bool:
+    """Hold one tunnel connection until it closes or a stop is requested.
 
+    Opens the session channel and the remote port forward, then waits. Returns
+    True when ``stopped`` was set (clean shutdown), False when the server
+    dropped the connection and the caller should reconnect.
+    """
     process = None
     listener = None
     tasks: list[asyncio.Task] = []
@@ -156,9 +143,9 @@ async def run(
         tasks.extend((closed, requested))
         await asyncio.wait((closed, requested), return_when=asyncio.FIRST_COMPLETED)
         if requested.done():
-            return 0
+            return True
         print("nullgate-ingress: connection closed by the server", flush=True)
-        return 1
+        return False
     finally:
         if listener is not None:
             listener.close()
@@ -172,6 +159,74 @@ async def run(
             await asyncio.gather(*tasks, return_exceptions=True)
 
 
+async def backoff(stopped: asyncio.Event, delay: float) -> None:
+    """Wait out a reconnect delay, returning early on a requested stop."""
+    with contextlib.suppress(asyncio.TimeoutError):
+        await asyncio.wait_for(stopped.wait(), timeout=delay)
+
+
+async def run(
+    host: str,
+    port: int,
+    local_host: str,
+    local_port: int,
+    slot: int,
+    key: Path,
+    username: str,
+) -> int:
+    ensure_username_environment(username)
+    ensure_key(key)
+
+    stopped = asyncio.Event()
+    loop = asyncio.get_running_loop()
+    for signum in (signal.SIGINT, signal.SIGTERM):
+        with contextlib.suppress(NotImplementedError):
+            loop.add_signal_handler(signum, stopped.set)
+
+    # Retry forever: srv.us documents wrapping the tunnel in a reconnect loop,
+    # and a disposable gateway must survive transient server-side flaps.
+    delay = RECONNECT_MIN
+    attempt = 0
+    while not stopped.is_set():
+        try:
+            # known_hosts=None matches the connection commands this project
+            # prints: the ingress is disposable and only carries bytes, so it
+            # is not authenticated.
+            connection = await asyncssh.connect(
+                host,
+                port=port,
+                username=username,
+                client_keys=[str(key)],
+                known_hosts=None,
+                client_factory=TunnelClient,
+                keepalive_interval=30,
+                keepalive_count_max=3,
+            )
+            if attempt:
+                print("nullgate-ingress: reconnected", flush=True)
+                attempt = 0
+                delay = RECONNECT_MIN
+            clean = await serve_connection(
+                connection, local_host, local_port, slot, stopped
+            )
+        except (OSError, asyncssh.Error) as error:
+            print(f"nullgate-ingress: {error}", flush=True)
+            clean = False
+        if clean:
+            return 0
+        attempt += 1
+        if stopped.is_set():
+            break
+        delay = min(delay, RECONNECT_MAX)
+        print(
+            f"nullgate-ingress: reconnecting in {delay:g}s (attempt {attempt})",
+            flush=True,
+        )
+        await backoff(stopped, delay)
+        delay *= 2
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--host", default="srv.us", help="tunnel host")

{nullgate-1.2.6 → nullgate-1.2.8}/src/nullgate/runtime.py

@@ -78,6 +78,17 @@ def _identity_of(pid_file: Path) -> str | None:
     return None
 
 
+def _process_state(pid: int) -> str | None:
+    """Return the Linux process state letter, when procfs exposes it."""
+    proc_stat = Path("/proc") / str(pid) / "stat"
+    try:
+        if proc_stat.is_file():
+            return proc_stat.read_text().rsplit(")", 1)[1].split()[0]
+    except (OSError, IndexError):
+        pass
+    return None
+
+
 def is_running(pid_file: Path) -> bool:
     """True when the recorded pid is alive and still matches its identity."""
     pid = read_pid(pid_file)
@@ -87,10 +98,20 @@ def is_running(pid_file: Path) -> bool:
         os.kill(pid, 0)
     except OSError:
         return False
+    if _process_state(pid) == "Z":
+        return False
     identity = process_identity(pid)
     return identity is not None and identity == _identity_of(pid_file)
 
 
+def reap_child(pid: int | None) -> None:
+    """Reap a dead direct child without blocking; ignore unrelated processes."""
+    if pid is None:
+        return
+    with contextlib.suppress(ChildProcessError, OSError):
+        os.waitpid(pid, os.WNOHANG)
+
+
 def write_pid(pid_file: Path, pid: int) -> bool:
     """Record ``pid IDENTITY``; fails rather than track an unidentifiable pid."""
     identity = process_identity(pid)