Merge branch 'main' into trial/coredns-rock

Author: addyess

.github/ARCHITECTURE.md

@@ -133,30 +133,7 @@ jobs:
       - name: Verify Cluster Health
         shell: bash
         run: |
-          echo "Verifying cluster health..."
-
-          # For no-CNI manifests, skip node ready check (nodes will be NotReady without CNI)
-          if [[ "${{ matrix.manifest-file }}" == *"no-cni"* ]]; then
-            echo "⚠️  Skipping node ready check for no-CNI manifest (expected behavior)"
-            echo "Verifying control plane components are running..."
-
-            # Wait for core system pods to be running
-            kubectl wait --for=condition=Ready pod -l component=kube-apiserver -n kube-system --timeout=5m || true
-            kubectl wait --for=condition=Ready pod -l component=etcd -n kube-system --timeout=5m || true
-            kubectl wait --for=condition=Ready pod -l component=kube-controller-manager -n kube-system --timeout=5m || true
-            kubectl wait --for=condition=Ready pod -l component=kube-scheduler -n kube-system --timeout=5m || true
-          else
-            echo "Waiting for nodes to be Ready..."
-            kubectl wait --for=condition=Ready node --all --timeout=5m
-            kubectl wait --for=condition=Ready pod --all -n kube-system --timeout=5m
-          fi
-
-          # Get cluster info
-          kubectl cluster-info
-          kubectl get nodes -o wide
-          kubectl get pods -A -o wide
-
-          echo "✅ Cluster is healthy"
+          kube-galaxy status --wait --timeout 300
 
       - name: Run Spread Tests
         id: run-tests

.github/workflows/test-baseline-clusters.yml

@@ -92,9 +92,21 @@ def setup_cmd(
 
 
 @app.command(name="status")
-def status_cmd() -> None:
-    """Display project status and dependency information."""
-    status.status()
+def status_cmd(
+    wait: bool = typer.Option(
+        False,
+        "--wait",
+        help="Wait for cluster nodes and kube-system pods to become Ready",
+    ),
+    timeout: int = typer.Option(
+        300,
+        "--timeout",
+        min=1,
+        help="Readiness wait timeout in seconds (used with --wait)",
+    ),
+) -> None:
+    """Display project status and optional cluster health verification."""
+    status.status(wait=wait, timeout=timeout)
 
 
 def main() -> None:

src/kube_galaxy/cli.py

@@ -1,111 +1,114 @@
 """Status command handler."""
 
 import shutil
-import subprocess
-from pathlib import Path
+from collections.abc import Callable
 
-from kube_galaxy.pkg.utils.logging import info, print_dict, section
+import typer
 
+from kube_galaxy.pkg.utils.client import (
+    get_cluster_info,
+    get_context,
+    get_nodes,
+    get_pods,
+    wait_for_nodes,
+    wait_for_pods,
+)
+from kube_galaxy.pkg.utils.errors import ClusterError
+from kube_galaxy.pkg.utils.logging import error, info, print_dict, section, success, warning
+from kube_galaxy.pkg.utils.shell import run
 
-def status() -> None:
-    """Display project status including dependencies and file counts."""
+
+def status(wait: bool = False, timeout: int = 300) -> None:
+    """Display project status and optionally verify cluster health."""
     section("Kubernetes Galaxy Test - Project Status")
 
-    # Check dependencies
+    _print_dependency_status()
+    _print_cluster_context()
+
+    if wait:
+        _verify_cluster_health(timeout)
+        success("Cluster is healthy")
+
+
+def _print_dependency_status() -> None:
+    """Print required command dependency status."""
     info("Dependencies:")
     deps = {
-        "kubectl": check_command("kubectl"),
-        "kubeadm": check_command("kubeadm"),
-        "spread": check_command("spread"),
+        "kubectl": _check_command("kubectl"),
+        "spread": _check_command("spread"),
     }
     print_dict(deps)
 
-    # Count project files
+
+def _print_cluster_context() -> None:
+    """Print active cluster context and current node table if available."""
+    if not shutil.which("kubectl"):
+        warning("kubectl not available; skipping cluster checks")
+        return
+
     info("")
-    info("Project Files:")
-    file_counts = {
-        "Manifests": len(list(Path("manifests").glob("*.yaml")))
-        if Path("manifests").exists()
-        else 0,
-        "Workflows": len(
-            list(Path(".github/workflows").glob("*.yml"))
-            + list(Path(".github/workflows").glob("*.yaml"))
-        )
-        if Path(".github/workflows").exists()
-        else 0,
-        "Actions": len(
-            list(Path(".github/actions").glob("*/action.yml"))
-            + list(Path(".github/actions").glob("*/action.yaml"))
-        )
-        if Path(".github/actions").exists()
-        else 0,
-        "Tests": len(list(Path("tests").glob("*.yaml")) + list(Path("tests").glob("*.yml")))
-        if Path("tests").exists()
-        else 0,
-    }
-    print_dict(file_counts)
+    try:
+        context = get_context()
+        info(f"Active Cluster: {context}")
+        nodes_output = get_nodes()
+        if nodes_output:
+            lines = nodes_output.strip().split("\n")
+            info(f"Cluster Nodes: {len(lines) - 1}")
+            for line in lines[1:]:
+                if line:
+                    info(f"    {line}")
+    except ClusterError:
+        info("Active Cluster: error checking")
 
-    # Show kubeadm cluster nodes
-    if shutil.which("kubectl"):
-        info("")
-        try:
-            result = subprocess.run(
-                ["kubectl", "get", "nodes"],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            if result.returncode == 0 and result.stdout:
-                lines = result.stdout.strip().split("\n")
-                info(f"Cluster Nodes: {len(lines) - 1}")  # Subtract header
-                for line in lines[1:]:  # Skip header
-                    if line:
-                        info(f"    {line}")
-        except Exception:
-            pass
 
-    # Show active cluster
-    if shutil.which("kubectl"):
-        info("")
-        try:
-            result = subprocess.run(
-                ["kubectl", "config", "current-context"],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            if result.returncode == 0:
-                context = result.stdout.strip()
-                info(f"Active Cluster: {context}")
-            else:
-                info("Active Cluster: none")
-        except Exception:
-            info("Active Cluster: error checking")
+def _verify_cluster_health(timeout: int) -> None:
+    """Wait for cluster readiness and print summary tables."""
+    if not shutil.which("kubectl"):
+        error("kubectl is required for --wait health checks", show_traceback=False)
+        raise typer.Exit(code=1)
+
+    section("Cluster Health Verification")
+    info("Waiting for nodes to be Ready...")
 
+    try:
+        wait_for_nodes(timeout=timeout)
+        wait_for_pods(namespace="kube-system", timeout=timeout)
+    except ClusterError as exc:
+        error(str(exc), show_traceback=False)
+        error("Cluster readiness checks failed", show_traceback=False)
+        raise typer.Exit(code=1) from exc
 
-def check_command(cmd: str) -> str:
+    _print_command_output(get_cluster_info, "Cluster Info")
+    _print_command_output(get_nodes, "Nodes")
+    _print_command_output(get_pods, "Pods")
+
+
+def _print_command_output(command: Callable[[], str], title: str) -> None:
+    """Run command and print its output with a section label."""
+    info("")
+    info(f"{title}:")
+    try:
+        if output := command().strip():
+            info(output)
+    except ClusterError as exc:
+        error(f"Failed to run: {title}", show_traceback=False)
+        raise typer.Exit(code=1) from exc
+
+
+def _check_command(cmd: str) -> str:
     """Check if a command is installed and return status."""
     if shutil.which(cmd):
         try:
             if cmd == "kubectl":
-                result = subprocess.run(
+                result = run(
                     [cmd, "version", "--client"],
                     capture_output=True,
-                    text=True,
-                    check=False,
-                )
-            elif cmd == "kubeadm":
-                result = subprocess.run(
-                    [cmd, "version"],
-                    capture_output=True,
-                    text=True,
                     check=False,
                 )
             else:
-                result = subprocess.run(
+                result = run(
                     [cmd, "--version"],
                     capture_output=True,
-                    text=True,
                     check=False,
                 )
 

src/kube_galaxy/cmd/status.py

@@ -1,6 +1,5 @@
 """Test command handler."""
 
-import subprocess
 from pathlib import Path
 
 import typer
@@ -9,6 +8,8 @@
 from kube_galaxy.pkg.manifest.loader import load_manifest
 from kube_galaxy.pkg.manifest.validator import validate_manifest
 from kube_galaxy.pkg.testing.spread import collect_test_results, run_spread_tests
+from kube_galaxy.pkg.utils.client import get_context, verify_connectivity
+from kube_galaxy.pkg.utils.errors import ClusterError
 from kube_galaxy.pkg.utils.logging import error, exception, info, section, success, warning
 
 
@@ -22,25 +23,10 @@ def spread(manifest_path: str) -> None:
 
     try:
         # Check if kubectl can connect
-        result = subprocess.run(
-            ["kubectl", "cluster-info"],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        if result.returncode != 0:
-            error("No Kubernetes cluster available. Please set up a cluster first.")
-            info("You can create a test cluster with: kube-galaxy setup")
-            raise typer.Exit(code=1)
+        verify_connectivity()
 
         # Get cluster context
-        result = subprocess.run(
-            ["kubectl", "config", "current-context"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        cluster_context = result.stdout.strip()
+        cluster_context = get_context()
         success(f"Connected to cluster: {cluster_context}")
 
         # Run spread tests from manifest
@@ -57,7 +43,7 @@ def spread(manifest_path: str) -> None:
 
         success("Spread tests completed")
 
-    except Exception as e:
+    except ClusterError as e:
         exception("Spread tests failed", e)
         raise typer.Exit(code=1) from e
 

src/kube_galaxy/cmd/test.py

@@ -1,5 +1,6 @@
 """Cluster setup and provisioning with 8-stage component lifecycle."""
 
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 
 from kube_galaxy.pkg.arch.detector import ArchInfo, get_arch_info
@@ -81,7 +82,7 @@ def setup_cluster(manifest_path: str, work_dir: str = ".") -> None:
         num_hooks = len(SetupHooks)
         for idx, hook in enumerate(SetupHooks, 1):
             section(f"Stage {idx}/{num_hooks}: {hook.value.capitalize()} Components")
-            _run_hook(instances_list, configs, hook.value)
+            _run_hook(instances_list, configs, hook.value, parallel=hook.is_parallel)
 
         section("Cluster Setup Complete!")
         success("Kubeconfig: $HOME/.kube/config")
@@ -128,7 +129,7 @@ def teardown_cluster(manifest_path: str, force: bool = False) -> None:
         num_hooks = len(TeardownHooks)
         for idx, hook in enumerate(TeardownHooks):
             section(f"Stage {idx + 1}/{num_hooks}: {hook.value.capitalize()} Components")
-            _run_hook(instances_list, configs, hook.value, force)
+            _run_hook(instances_list, configs, hook.value, force, parallel=hook.is_parallel)
 
         # Final cleanup: remove any remaining kube-galaxy alternatives
         _cleanup_kube_galaxy_alternatives(force)
@@ -151,6 +152,7 @@ def _run_hook(
     configs: list[ComponentConfig],
     hook_name: str,
     force: bool = False,
+    parallel: bool = False,
 ) -> None:
     """
     Run a specific lifecycle hook for all components.
@@ -160,24 +162,36 @@ def _run_hook(
         configs: List of component configs (must be in same order as instances)
         hook_name: Name of the hook to run (e.g., "install")
         force: Continue execution even if errors occur
+        parallel: Execute hooks concurrently (respects component order for submission)
 
     Raises:
         ClusterError: If any component hook fails
     """
     hook_name_caps = hook_name.title()
-    for config, instance in zip(configs, instances, strict=True):
-        info(f"  {config.name}: {hook_name_caps}...")
-        hook_method = getattr(instance, f"{hook_name}_hook", None)
-        if not hook_method:
-            raise ClusterError(f"{hook_name_caps} hook not implemented for {config.name}")
-        try:
-            hook_method()
-        except Exception as exc:
-            forced = " (continuing due to --force)" if force else ""
-            message = f"{hook_name_caps} failed for {config.name}{forced}: {exc}"
-            exception(f"  ✗ {message}", exc)
-            if not force:
-                raise ClusterError(message) from exc
+    max_workers = 10 if parallel else 1
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures_list = []
+
+        # Submit all tasks in component order
+        for config, instance in zip(configs, instances, strict=True):
+            hook_method = getattr(instance, f"{hook_name}_hook", None)
+            if not hook_method:
+                raise ClusterError(f"{hook_name_caps} hook not implemented for {config.name}")
+            info(f"  {config.name}: {hook_name_caps}...")
+            future = executor.submit(hook_method)
+            futures_list.append((config.name, future))
+
+        # Collect results in submission order
+        for component_name, future in futures_list:
+            try:
+                future.result()
+            except Exception as exc:
+                forced = " (continuing due to --force)" if force else ""
+                message = f"{hook_name_caps} failed for {component_name}{forced}: {exc}"
+                exception(f"  ✗ {message}", exc)
+                if not force:
+                    raise ClusterError(message) from exc
 
 
 def _cleanup_kube_galaxy_alternatives(force: bool) -> None: