kaos-cli 0.7.4__tar.gz → 0.7.7__tar.gz

{kaos_cli-0.7.4 → kaos_cli-0.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaos-cli
-Version: 0.7.4
+Version: 0.7.7
 Summary: CLI for KAOS (K8s Agent Orchestration System)
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{kaos_cli-0.7.4 → kaos_cli-0.7.7}/kaos_cli/__init__.py

@@ -5,4 +5,4 @@ try:
 
     __version__ = version("kaos-cli")
 except Exception:
-    __version__ = "0.7.4.dev0"
+    __version__ = "0.7.5.dev0"

{kaos_cli-0.7.4 → kaos_cli-0.7.7}/kaos_cli/agent/deploy.py

@@ -7,6 +7,8 @@ import tempfile
 from pathlib import Path
 import typer
 
+from kaos_cli.utils.wait import wait_for_deployment_available
+
 
 AGENT_TEMPLATE = """apiVersion: kaos.tools/v1alpha1
 kind: Agent
@@ -184,16 +186,9 @@ def deploy_agent(
         # Wait for deployment if requested
         if wait:
             typer.echo("⏳ Waiting for deployment to be available...")
-            wait_args = [
-                "kubectl",
-                "wait",
-                f"deployment/agent-{name}",
-                "--for=condition=available",
-                f"--timeout={wait_timeout}s",
-            ]
-            if namespace:
-                wait_args.extend(["-n", namespace])
-            wait_result = subprocess.run(wait_args, capture_output=True, text=True)
+            wait_result = wait_for_deployment_available(
+                f"agent-{name}", namespace, wait_timeout
+            )
             if wait_result.returncode != 0:
                 typer.echo(wait_result.stderr or wait_result.stdout, err=True)
                 sys.exit(wait_result.returncode)

{kaos_cli-0.7.4 → kaos_cli-0.7.7}/kaos_cli/modelapi/deploy.py

@@ -8,6 +8,8 @@ import tempfile
 from pathlib import Path
 import typer
 
+from kaos_cli.utils.wait import wait_for_deployment_available
+
 
 DEFAULT_WAIT_TIMEOUT = 120
 
@@ -174,16 +176,9 @@ spec:
         # Wait for deployment if requested
         if wait:
             typer.echo("⏳ Waiting for deployment to be available...")
-            wait_args = [
-                "kubectl",
-                "wait",
-                f"deployment/modelapi-{name}",
-                "--for=condition=available",
-                f"--timeout={wait_timeout}s",
-            ]
-            if namespace:
-                wait_args.extend(["-n", namespace])
-            wait_result = subprocess.run(wait_args, capture_output=True, text=True)
+            wait_result = wait_for_deployment_available(
+                f"modelapi-{name}", namespace, wait_timeout
+            )
             if wait_result.returncode != 0:
                 typer.echo(wait_result.stderr or wait_result.stdout, err=True)
                 sys.exit(wait_result.returncode)

kaos_cli-0.7.7/kaos_cli/utils/wait.py

@@ -0,0 +1,56 @@
+"""Wait helpers for resources the operator creates asynchronously."""
+
+import subprocess
+import time
+
+
+NOT_FOUND_POLL_INTERVAL = 2
+
+
+def _is_not_found(result: subprocess.CompletedProcess) -> bool:
+    """Return True when kubectl failed only because the object does not exist yet."""
+    message = f"{result.stderr}{result.stdout}".lower()
+    return "notfound" in message or "not found" in message
+
+
+def wait_for_deployment_available(
+    deployment: str,
+    namespace: str | None,
+    timeout: int,
+) -> subprocess.CompletedProcess:
+    """Wait for a Deployment to exist and report condition=available.
+
+    `kubectl wait` resolves the object once, up front: if it is not there yet the
+    command fails immediately with NotFound, and --timeout only bounds waiting for
+    the condition on an object that already exists. The Deployments waited on here
+    are created by the operator in response to a custom resource, so calling
+    `kubectl wait` straight after `kubectl apply` races the operator's first
+    reconcile and loses whenever the reconcile lands a moment later.
+
+    Retry while the Deployment is still absent, and let `kubectl wait` handle the
+    condition itself once it appears. `timeout` bounds the whole operation, so a
+    Deployment that never appears fails after the same total wait as one that
+    appears but never becomes available.
+    """
+    deadline = time.monotonic() + timeout
+    while True:
+        remaining = deadline - time.monotonic()
+        args = [
+            "kubectl",
+            "wait",
+            f"deployment/{deployment}",
+            "--for=condition=available",
+            f"--timeout={max(1, int(remaining))}s",
+        ]
+        if namespace:
+            args.extend(["-n", namespace])
+        result = subprocess.run(args, capture_output=True, text=True)
+
+        if result.returncode == 0 or not _is_not_found(result):
+            return result
+
+        # The Deployment has not been created yet. Retry until the deadline.
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return result
+        time.sleep(min(NOT_FOUND_POLL_INTERVAL, remaining))

{kaos_cli-0.7.4 → kaos_cli-0.7.7}/kaos_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaos-cli
-Version: 0.7.4
+Version: 0.7.7
 Summary: CLI for KAOS (K8s Agent Orchestration System)
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{kaos_cli-0.7.4 → kaos_cli-0.7.7}/kaos_cli.egg-info/SOURCES.txt

@@ -61,10 +61,12 @@ kaos_cli/system/status.py
 kaos_cli/utils/__init__.py
 kaos_cli/utils/crud.py
 kaos_cli/utils/port_forward.py
+kaos_cli/utils/wait.py
 tests/test_agent_invoke.py
 tests/test_agent_tools.py
 tests/test_auth_cli.py
 tests/test_cli_integration.py
 tests/test_config_cli.py
+tests/test_deploy_wait.py
 tests/test_install_surface.py
 tests/test_memory_cli.py

{kaos_cli-0.7.4 → kaos_cli-0.7.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kaos-cli"
-version = "0.7.4"
+version = "0.7.7"
 description = "CLI for KAOS (K8s Agent Orchestration System)"
 readme = "README.md"
 requires-python = ">=3.12"

kaos_cli-0.7.7/tests/test_deploy_wait.py

@@ -0,0 +1,103 @@
+"""Tests for the deploy wait helper.
+
+Regression cover for the create-then-wait race that failed the v0.7.5 and v0.7.6
+release pipelines: `kubectl wait` returns NotFound immediately when the operator
+has not created the Deployment yet, which aborted `kaos modelapi deploy --wait`.
+"""
+
+import subprocess
+from unittest.mock import patch
+
+from kaos_cli.utils.wait import wait_for_deployment_available
+
+
+def _result(returncode: int, stderr: str = "", stdout: str = ""):
+    return subprocess.CompletedProcess(
+        args=["kubectl"], returncode=returncode, stdout=stdout, stderr=stderr
+    )
+
+
+NOT_FOUND = _result(
+    1, stderr='Error from server (NotFound): deployments.apps "modelapi-x" not found\n'
+)
+AVAILABLE = _result(0, stdout="deployment.apps/modelapi-x condition met\n")
+TIMED_OUT = _result(1, stderr="error: timed out waiting for the condition\n")
+
+
+def test_retries_while_deployment_does_not_exist_yet():
+    """The operator creating the Deployment late must not fail the command."""
+    responses = [NOT_FOUND, NOT_FOUND, AVAILABLE]
+    with patch("subprocess.run", side_effect=responses) as run:
+        with patch("time.sleep"):
+            result = wait_for_deployment_available("modelapi-x", "ns", 120)
+
+    assert result.returncode == 0
+    assert run.call_count == 3
+
+
+def test_returns_immediately_once_available():
+    with patch("subprocess.run", return_value=AVAILABLE) as run:
+        result = wait_for_deployment_available("modelapi-x", "ns", 120)
+
+    assert result.returncode == 0
+    assert run.call_count == 1
+
+
+def test_does_not_retry_on_a_real_condition_timeout():
+    """A Deployment that exists but never goes available is a genuine failure."""
+    with patch("subprocess.run", return_value=TIMED_OUT) as run:
+        result = wait_for_deployment_available("modelapi-x", "ns", 120)
+
+    assert result.returncode == 1
+    assert run.call_count == 1
+
+
+def test_gives_up_when_deployment_never_appears():
+    """A Deployment that never shows up still fails, bounded by the timeout."""
+    with patch("subprocess.run", return_value=NOT_FOUND) as run:
+        with patch("time.sleep"):
+            result = wait_for_deployment_available("modelapi-x", "ns", 0)
+
+    assert result.returncode == 1
+    assert "not found" in result.stderr
+    assert run.call_count == 1
+
+
+def test_passes_namespace_when_given():
+    with patch("subprocess.run", return_value=AVAILABLE) as run:
+        wait_for_deployment_available("modelapi-x", "my-ns", 120)
+
+    args = run.call_args[0][0]
+    assert args[:3] == ["kubectl", "wait", "deployment/modelapi-x"]
+    assert "--for=condition=available" in args
+    assert args[-2:] == ["-n", "my-ns"]
+
+
+def test_omits_namespace_when_not_given():
+    with patch("subprocess.run", return_value=AVAILABLE) as run:
+        wait_for_deployment_available("modelapi-x", None, 120)
+
+    assert "-n" not in run.call_args[0][0]
+
+
+def test_timeout_shrinks_across_retries():
+    """Each retry must pass kubectl the time that is actually left, never the full
+    budget again, or the total wait could run to timeout x attempts."""
+    clock = {"t": 0.0}
+
+    def fake_monotonic():
+        return clock["t"]
+
+    def fake_sleep(seconds):
+        clock["t"] += seconds
+
+    with patch("subprocess.run", side_effect=[NOT_FOUND, NOT_FOUND, AVAILABLE]) as run:
+        with patch("time.monotonic", side_effect=fake_monotonic):
+            with patch("time.sleep", side_effect=fake_sleep):
+                wait_for_deployment_available("modelapi-x", "ns", 100)
+
+    timeouts = [
+        next(a for a in call[0][0] if a.startswith("--timeout="))
+        for call in run.call_args_list
+    ]
+    assert timeouts == ["--timeout=100s", "--timeout=98s", "--timeout=96s"]