model-compose 0.4.46__tar.gz → 0.4.47__tar.gz

{model_compose-0.4.46/src/model_compose.egg-info → model_compose-0.4.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.46
+Version: 0.4.47
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.4.46 → model_compose-0.4.47}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.46"
+version = "0.4.47"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.4.46 → model_compose-0.4.47}/src/mindor/core/gateway/services/ssh_tunnel.py

@@ -1,5 +1,4 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
 
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Iterator, Any
 from mindor.dsl.schema.gateway import SshTunnelGatewayConfig, SshConnectionConfig, SshAuthConfig
@@ -23,28 +22,69 @@ class SshTunnelGateway(GatewayService):
 
     def get_context(self, port: int) -> Optional[Dict[str, Any]]:
         remote_port = self.ports.get(port)
+ 
         if remote_port is not None:
             return {
                 "public_address": f"{self.config.connection.host}:{remote_port}"
             }
+ 
         return None
 
     def serves_port(self, port: int) -> bool:
         return port in self.ports
 
     async def _serve(self) -> None:
-        """Establish SSH tunnel and start remote port forwarding"""
-        logging.info(
-            f"Establishing SSH tunnel to {self.config.connection.host}:{self.config.connection.port}"
-        )
+        watch_interval = parse_duration(self.config.connection.watch_interval).total_seconds()
+        retry_interval = parse_duration(self.config.connection.retry_interval).total_seconds()
 
         self._shutdown_event = asyncio.Event()
+        retry_count = 0
+
+        while not self._shutdown_event.is_set():
+            try:
+                await self._establish_tunnel(self.config.connection, self.config.port)
+                retry_count = 0
+
+                while not self._shutdown_event.is_set():
+                    if not self.client or not self.client.is_connected():
+                        raise ConnectionError("SSH connection lost")
+
+                    await self._wait_for_shutdown(self._shutdown_event, timeout=watch_interval)
+            except Exception as e:
+                if self._shutdown_event.is_set():
+                    break
+
+                await self._reset_connection()
+                retry_count += 1
+
+                if self.config.connection.max_retry_count > 0 and retry_count > self.config.connection.max_retry_count:
+                    logging.error(f"SSH max retry count ({self.config.connection.max_retry_count}) reached. Giving up.")
+                    break
+
+                logging.warning(f"SSH connection lost: {e}. Reconnecting in {retry_interval}s... (attempt {retry_count})")
+
+                if await self._wait_for_shutdown(self._shutdown_event, retry_interval):
+                    break
+
+    async def _shutdown(self) -> None:
+        if self._shutdown_event:
+            self._shutdown_event.set()
 
-        self.client = SshClient(self._build_connection_params(self.config.connection))
+        if self.client:
+            logging.info(f"Stopping SSH tunnel to {self.config.connection.host}:{self.config.connection.port}")
+            await self.client.close()
+
+        self.client = None
+        self.ports = {}
+
+    async def _establish_tunnel(self, connection: SshConnectionConfig, forwards: List[List[Union[int, str]]]) -> None:
+        logging.info(f"Establishing SSH tunnel to {connection.host}:{connection.port}")
+
+        self.client = SshClient(self._build_connection_params(connection))
         await self.client.connect()
 
         # Start remote port forwarding for each port mapping
-        for remote_port, local_host, local_port in self.config.port:
+        for remote_port, local_host, local_port in forwards:
             actual_remote_port = await self.client.start_remote_port_forwarding(
                 remote_port=remote_port,
                 local_port=local_port,
@@ -53,12 +93,7 @@ class SshTunnelGateway(GatewayService):
 
             self.ports[local_port] = actual_remote_port
 
-            logging.info(
-                f"Remote port forwarding started: {self.config.connection.host}:{remote_port} -> {local_host}:{local_port}"
-            )
-
-        # Keep the SSH connection alive until shutdown event is set
-        await self._shutdown_event.wait()
+            logging.info(f"Remote port forwarding started: {connection.host}:{remote_port} -> {local_host}:{local_port}")
 
     def _build_connection_params(self, config: SshConnectionConfig) -> SshConnectionParams:
         return SshConnectionParams(
@@ -83,18 +118,19 @@ class SshTunnelGateway(GatewayService):
 
         raise ValueError(f"Unknown SSH auth type: {config.type}")
 
-    async def _shutdown(self) -> None:
-        """Stop SSH tunnel and cleanup"""
-        # Signal the _serve task to stop
-        if self._shutdown_event:
-            self._shutdown_event.set()
+    async def _wait_for_shutdown(self, shutdown_event: asyncio.Event, timeout: float) -> bool:
+        try:
+            await asyncio.wait_for(shutdown_event.wait(), timeout=timeout)
+            return True
+        except asyncio.TimeoutError:
+            return False
 
+    async def _reset_connection(self) -> None:
         if self.client:
-            logging.info(
-                f"Stopping SSH tunnel to {self.config.connection.host}:{self.config.connection.port}"
-            )
+            try:
+                await self.client.close()
+            except Exception as e:
+                logging.debug(f"Error closing SSH connection during reset: {e}")
 
-            await self.client.close()
-            self.client = None
-            self.ports = {}
-            self._shutdown_event = None
+        self.client = None
+        self.ports = {}

{model_compose-0.4.46 → model_compose-0.4.47}/src/mindor/dsl/schema/gateway/impl/ssh_tunnel.py

@@ -12,29 +12,37 @@ class SshTunnelGatewayConfig(CommonGatewayConfig):
     @model_validator(mode="before")
     def normalize_port(cls, values):
         port = values.get("port", 8090)  # Default to 8090 if not specified
-        if not isinstance(port, list):
+        if isinstance(port, list):
             port = [ port ]
-        values["port"] = [ cls.normalize_single_port(value) for value in port ]
+
+        forwards = []
+        for value in port:
+            forward = cls.parse_port_forward(value)
+            if forward is None:
+                raise ValueError(f"Invalid SSH tunnel port configuration: {value}")
+            forwards.append(forward)
+
+        values["port"] = forwards
         return values
 
     @classmethod
-    def normalize_single_port(cls, value) -> Optional[List[Union[int, str]]]:
+    def parse_port_forward(cls, value) -> Optional[List[Union[int, str]]]:
         if isinstance(value, str):
             parts = value.split(":")
 
             if len(parts) == 2 and parts[0].isdigit():
                 if parts[1].isdigit():  # "8080:3000" (port:port)
-                    return [int(parts[0]), "localhost", int(parts[1])]
+                    return [ int(parts[0]), "localhost", int(parts[1]) ]
                 else:  # "8080:192.168.1.107" or "8080:example.com" (port:host)
-                    return [int(parts[0]), parts[1], int(parts[0])]
+                    return [ int(parts[0]), parts[1], int(parts[0]) ]
 
-            if len(parts) == 3:  # "8080:192.168.1.107:3000" (port:host:port)
-                return [int(parts[0]), parts[1], int(parts[2])]
+            if len(parts) == 3 and parts[0].isdigit() and parts[2].isdigit():  # "8080:192.168.1.107:3000" (port:host:port)
+                return [ int(parts[0]), parts[1], int(parts[2]) ]
 
             return None
 
         if isinstance(value, int):
-            return [value, "localhost", value]
+            return [ value, "localhost", value ]
 
         if isinstance(value, list):
             return value

{model_compose-0.4.46 → model_compose-0.4.47}/src/mindor/dsl/schema/transport/ssh.py

@@ -32,3 +32,6 @@ class SshConnectionConfig(BaseModel):
     port: int = Field(default=22, ge=1, le=65535, description="Port number used to connect to the SSH server.")
     auth: SshAuthConfig = Field(..., description="SSH authentication configuration.")
     keepalive_interval: str = Field(default="10s", description="SSH keepalive interval. Set to '0s' to disable keepalive.")
+    watch_interval: str = Field(default="5s", description="Interval between SSH connection health checks.")
+    retry_interval: str = Field(default="5s", description="Interval between reconnection attempts.")
+    max_retry_count: int = Field(default=0, ge=0, description="Maximum number of reconnection attempts. 0 for unlimited.")

{model_compose-0.4.46 → model_compose-0.4.47/src/model_compose.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.46
+Version: 0.4.47
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT