Merge branch 'main' into fix-index-generation-workflow

Author: mangelajo

.github/workflows/build.yaml

@@ -5,6 +5,8 @@ on:
     branches:
       - main
       - release-*
+    tags:
+      - v*
   merge_group:
 
 env:

docs/multiversion.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euox pipefail
 
-declare -a BRANCHES=("main" "release-0.5" "release-0.6")
+declare -a BRANCHES=("main" "release-0.5" "release-0.6" "release-0.7")
 
 # https://stackoverflow.com/a/246128
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )

packages/jumpstarter-cli/jumpstarter_cli/run.py

@@ -12,6 +12,34 @@
 logger = logging.getLogger(__name__)
 
 
+def _handle_exporter_exceptions(excgroup):
+    """Handle exceptions from exporter serving."""
+    from jumpstarter_cli_common.exceptions import leaf_exceptions
+    for exc in leaf_exceptions(excgroup):
+        if not isinstance(exc, anyio.get_cancelled_exc_class()):
+            click.echo(
+                f"Exception while serving on the exporter: {type(exc).__name__}: {exc}",
+                err=True,
+            )
+
+
+def _reap_zombie_processes(capture_child=None):
+    """Reap zombie processes when running as PID 1."""
+    try:
+        while True:
+            try:
+                pid, status = os.waitpid(-1, os.WNOHANG)
+                if pid == 0:
+                    break # No more children
+                if capture_child and pid == capture_child['pid']:
+                    capture_child['status'] = status
+                logger.debug(f"PARENT: Reaped zombie process {pid} with status {status}")
+            except ChildProcessError:
+                break # No more children
+    except Exception as e:
+        logger.warning(f"PARENT: Error during zombie reaping: {e}")
+
+
 def _handle_child(config):
     """Handle child process with graceful shutdown."""
     async def serve_with_graceful_shutdown():
@@ -28,6 +56,7 @@ async def signal_handler():
                         continue  # Ignore duplicate signals
                     received_signal = sig
                     logger.info("CHILD: Received %d (%s)", received_signal, signal.Signals(received_signal).name)
+
                     if exporter:
                         # Terminate exporter. SIGHUP waits until current lease is let go. Later SIGTERM still overrides
                         if received_signal != signal.SIGHUP:
@@ -45,13 +74,7 @@ async def signal_handler():
                 try:
                     await exporter.serve()
                 except* Exception as excgroup:
-                    from jumpstarter_cli_common.exceptions import leaf_exceptions
-                    for exc in leaf_exceptions(excgroup):
-                        if not isinstance(exc, anyio.get_cancelled_exc_class()):
-                            click.echo(
-                                f"Exception while serving on the exporter: {type(exc).__name__}: {exc}",
-                                err=True,
-                            )
+                    _handle_exporter_exceptions(excgroup)
 
             # Cancel the signal handler after exporter completes
             signal_tg.cancel_scope.cancel()
@@ -62,21 +85,38 @@ async def signal_handler():
     sys.exit(anyio.run(serve_with_graceful_shutdown))
 
 
+def _wait_for_child(pid, child_info):
+    """Wait for child process, get status from signal handler if reaped."""
+    try:
+        _, status = os.waitpid(pid, 0)
+    except ChildProcessError:
+        status = child_info['status']
+    return status
+
+
 def _handle_parent(pid):
     """Handle parent process waiting for child and signal forwarding."""
+    child_info = {'pid': pid, 'status': None}
+
     def parent_signal_handler(signum, _):
-        logger.info("PARENT: Received %d (%s), forwarding to child PID %d", signum, signal.Signals(signum).name, pid)
-        if pid and pid > 0:
-            try:
-                os.kill(pid, signum)
-            except ProcessLookupError:
-                pass
+        if signum == signal.SIGCHLD and os.getpid() == 1:
+            _reap_zombie_processes(capture_child=child_info) # capture our own direct child if reaped
+        elif signum != signal.SIGCHLD:
+            logger.info("PARENT: Got %d (%s), forwarding to child PG %d", signum, signal.Signals(signum).name, pid)
+            if pid > 0:
+                try:
+                    os.killpg(pid, signum)
+                except (ProcessLookupError, OSError):
+                    pass
 
     # Set up signal handlers after fork
-    for sig in (signal.SIGINT, signal.SIGTERM, signal.SIGHUP, signal.SIGQUIT):
+    for sig in (signal.SIGINT, signal.SIGTERM, signal.SIGHUP, signal.SIGQUIT, signal.SIGCHLD):
         signal.signal(sig, parent_signal_handler)
 
-    _, status = os.waitpid(pid, 0)
+    status = _wait_for_child(pid, child_info)
+    if status is None:
+        return None
+
     if os.WIFEXITED(status):
         # Interpret child exit code
         child_exit_code = os.WEXITSTATUS(status)
@@ -100,6 +140,7 @@ def _serve_with_exc_handling(config):
             if (exit_code := _handle_parent(pid)) is not None:
                 return exit_code
         else:
+            os.setsid() # Become group leader so all spawned subprocesses are reached by parent's signals
             _handle_child(config)
             sys.exit(1) # should never happen
 

packages/jumpstarter-driver-network/README.md

@@ -1,7 +1,8 @@
 # Network drivers
 
 `jumpstarter-driver-network` provides functionality for interacting with network
-servers and connections.
+servers and connections, redirecting DUT network services to the client handling
+the lease.
 
 ## Installation
 
@@ -19,9 +20,19 @@ export:
   network:
     type: jumpstarter_driver_network.driver.TcpNetwork
     config:
-      # Add required parameters here
+      host: 192.168.1.2
+      port: 5201
+      enable_address: true
 ```
 
+### Config parameters
+
+| Parameter     | Description                                         | Type  | Required | Default            |
+| ------------- | --------------------------------------------------- | ----- | -------- | ------------------ |
+| host          | Hostname or IP address of the DUT                   | str   | yes      |                    |
+| port          | Port number of the DUT service to connect to        | int   | yes      |                    |
+| enable_address | Whether to enable address mode (reporting the address of the client) | bool  | no | true   |
+
 ## API Reference
 
 Network driver classes:

packages/jumpstarter-driver-network/jumpstarter_driver_network/client.py

@@ -2,17 +2,23 @@
 from contextlib import contextmanager
 from ipaddress import IPv6Address, ip_address
 from threading import Event
-from typing import Any
+from typing import Any, Tuple
+from urllib.parse import urlparse
 
 import click
 from anyio import ContextManagerMixin
 
 from .adapters import DbusAdapter, TcpPortforwardAdapter, UnixPortforwardAdapter
 from .driver import DbusNetwork
 from jumpstarter.client import DriverClient
+from jumpstarter.client.core import DriverMethodNotImplemented
 
 
 class NetworkClient(DriverClient):
+
+    def address(self):
+        return self.call("address")
+
     def cli(self):
         @click.group
         def base():
@@ -62,9 +68,35 @@ def forward_unix(path: str | None):
 
                 Event().wait()
 
-        return base
+        @base.command()
+        @click.option("--host", is_flag=True)
+        @click.option("--port", is_flag=True)
+        def address(host, port):
+            """
+            Direct TCP connection to remote network
+            """
+            try:
+                addr = self.address()
+                if not host and not port or host and port:
+                    # Strip any URL scheme for clean display
+                    clean_addr = _strip_scheme(addr)
+                    click.echo(clean_addr)
+                else:
+                    # Parse address safely to handle IPv6
+                    parsed_host, parsed_port = _parse_address(addr)
+                    click.echo(parsed_host if host else parsed_port)
+            except ValueError as e:
+                raise click.ClickException(
+                    f"enable_address mode is not true in the exporter configuration: {e}"
+                ) from e
+            except DriverMethodNotImplemented as e:
+                raise click.ClickException(
+                    "This exporter does not support direct connection yet, update exporter to 0.7.1 or later"
+                ) from e
 
 
+        return base
+
 class DbusNetworkClient(NetworkClient, ContextManagerMixin):
     @contextmanager
     def __contextmanager__(self) -> Generator[Any]:
@@ -74,3 +106,57 @@ def __contextmanager__(self) -> Generator[Any]:
     @property
     def kind(self):
         return self.labels[DbusNetwork.KIND_LABEL]
+
+
+def _parse_address(addr: str) -> Tuple[str, str]:
+    """Parse a host:port address string, handling IPv6 addresses correctly.
+
+    Uses urllib.parse.urlparse for robust parsing of network addresses.
+
+    Returns:
+        Tuple of (host, port) as strings
+
+    Examples:
+        "127.0.0.1:8080" -> ("127.0.0.1", "8080")
+        "[::1]:8080" -> ("::1", "8080")
+        "localhost:8080" -> ("localhost", "8080")
+    """
+    # Add a dummy scheme to make it a valid URL for urlparse
+    if not addr.startswith(("http://", "https://", "tcp://", "udp://")):
+        addr = f"tcp://{addr}"
+
+    parsed = urlparse(addr)
+    host = parsed.hostname or ""
+    port = str(parsed.port) if parsed.port else ""
+
+    return host, port
+
+
+def _strip_scheme(addr: str) -> str:
+    """Remove URL scheme from address string for clean display.
+
+    Uses urllib.parse.urlparse to properly handle various URL formats.
+
+    Returns:
+        Address string without scheme prefix
+
+    Examples:
+        "tcp://127.0.0.1:8080" -> "127.0.0.1:8080"
+        "udp://[::1]:8080" -> "[::1]:8080"
+        "127.0.0.1:8080" -> "127.0.0.1:8080"
+    """
+    # Handle IPv6 addresses in brackets specially
+    if "://[" in addr and "]" in addr:
+        # Find the scheme separator and the closing bracket
+        scheme_end = addr.find("://")
+        if scheme_end != -1:
+            # Extract everything after "://"
+            return addr[scheme_end + 3:]
+
+    # For other cases, use urlparse
+    parsed = urlparse(addr)
+    # Reconstruct the address without scheme
+    if parsed.port:
+        return f"{parsed.hostname}:{parsed.port}"
+    else:
+        return parsed.hostname or addr