vantage-cli 0.1.1__py3-none-any.whl

vantage_cli/__init__.py

@@ -0,0 +1,131 @@
+"""Vantage CLI package for managing cloud computing resources."""
+
+import asyncio
+import importlib.metadata
+import inspect
+from typing import Any, Callable, Optional
+
+import typer
+
+__version__ = importlib.metadata.version("vantage-cli")
+
+
+class AsyncTyper(typer.Typer):
+    """A Typer subclass that automatically wraps async functions with asyncio.run()."""
+
+    @staticmethod
+    def maybe_run_async(func: Callable, *args: Any, **kwargs: Any) -> Any:
+        """Run function asynchronously if it's a coroutine, otherwise run normally."""
+        if inspect.iscoroutinefunction(func):
+            return asyncio.run(func(*args, **kwargs))
+        return func(*args, **kwargs)
+
+    def command(
+        self,
+        name: Optional[str] = None,
+        *,
+        cls: Optional[type] = None,
+        context_settings: Optional[dict] = None,
+        help: Optional[str] = None,
+        epilog: Optional[str] = None,
+        short_help: Optional[str] = None,
+        options_metavar: Optional[str] = None,
+        add_help_option: bool = True,
+        no_args_is_help: bool = False,
+        hidden: bool = False,
+        deprecated: bool = False,
+        rich_help_panel: Optional[str] = None,
+    ):
+        """Override command decorator to handle async functions."""
+
+        def decorator(func: Callable) -> Callable:
+            if inspect.iscoroutinefunction(func):
+                # Create a sync wrapper that preserves the original function signature
+                import functools
+
+                @functools.wraps(func)
+                def sync_wrapper(*args, **kwargs):
+                    return self.maybe_run_async(func, *args, **kwargs)
+
+                wrapped_func = sync_wrapper
+            else:
+                wrapped_func = func
+
+            # Build kwargs for parent method, filtering out None values
+            kwargs = {
+                "name": name,
+                "cls": cls,
+                "context_settings": context_settings,
+                "help": help,
+                "epilog": epilog,
+                "short_help": short_help,
+                "add_help_option": add_help_option,
+                "no_args_is_help": no_args_is_help,
+                "hidden": hidden,
+                "deprecated": deprecated,
+                "rich_help_panel": rich_help_panel,
+            }
+            if options_metavar is not None:
+                kwargs["options_metavar"] = options_metavar
+
+            return super(AsyncTyper, self).command(**kwargs)(wrapped_func)
+
+        return decorator
+
+    def callback(
+        self,
+        *,
+        cls: Optional[type] = None,
+        invoke_without_command: bool = False,
+        no_args_is_help: bool = False,
+        subcommand_metavar: Optional[str] = None,
+        chain: bool = False,
+        result_callback: Optional[Callable] = None,
+        context_settings: Optional[dict] = None,
+        help: Optional[str] = None,
+        epilog: Optional[str] = None,
+        short_help: Optional[str] = None,
+        options_metavar: Optional[str] = None,
+        add_help_option: bool = True,
+        hidden: bool = False,
+        deprecated: bool = False,
+        rich_help_panel: Optional[str] = None,
+    ):
+        """Override callback decorator to handle async functions."""
+
+        def decorator(func: Callable) -> Callable:
+            if inspect.iscoroutinefunction(func):
+                # Create a sync wrapper that preserves the original function signature
+                import functools
+
+                @functools.wraps(func)
+                def sync_wrapper(*args, **kwargs):
+                    return self.maybe_run_async(func, *args, **kwargs)
+
+                wrapped_func = sync_wrapper
+            else:
+                wrapped_func = func
+
+            # Build kwargs for parent method, filtering out None values
+            kwargs = {
+                "cls": cls,
+                "invoke_without_command": invoke_without_command,
+                "no_args_is_help": no_args_is_help,
+                "subcommand_metavar": subcommand_metavar,
+                "chain": chain,
+                "result_callback": result_callback,
+                "context_settings": context_settings,
+                "help": help,
+                "epilog": epilog,
+                "short_help": short_help,
+                "add_help_option": add_help_option,
+                "hidden": hidden,
+                "deprecated": deprecated,
+                "rich_help_panel": rich_help_panel,
+            }
+            if options_metavar is not None:
+                kwargs["options_metavar"] = options_metavar
+
+            return super(AsyncTyper, self).callback(**kwargs)(wrapped_func)
+
+        return decorator

vantage_cli/apps/__init__.py

@@ -0,0 +1,22 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Cluster management commands for Vantage CLI."""
+
+from vantage_cli import AsyncTyper
+from vantage_cli.apps.juju_localhost import juju_localhost_app
+from vantage_cli.apps.multipass_singlenode import multipass_singlenode_app
+
+# Create the apps command group
+apps_app = AsyncTyper(
+    name="apps",
+    help="Vantage infrastructure automation applications.",
+    context_settings={
+        "allow_extra_args": True,
+        "allow_interspersed_args": True,
+        "ignore_unknown_options": True,
+    },
+)
+
+# Register subcommand groups
+apps_app.add_typer(juju_localhost_app)
+apps_app.add_typer(multipass_singlenode_app)

vantage_cli/apps/common.py

@@ -0,0 +1,78 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Common validation utilities for deployment apps."""
+
+from typing import Any, Dict, Optional
+
+import typer
+from rich.console import Console
+
+from vantage_cli.constants import (
+    ERROR_NO_CLIENT_ID,
+    ERROR_NO_CLIENT_SECRET,
+    ERROR_NO_CLUSTER_DATA,
+)
+
+
+def validate_cluster_data(
+    cluster_data: Optional[Dict[str, Any]], console: Console
+) -> Dict[str, Any]:
+    """Validate that cluster data exists and contains required fields.
+
+    Args:
+        cluster_data: Optional cluster configuration dictionary
+        console: Rich console for error output
+
+    Returns:
+        Validated cluster data dictionary
+
+    Raises:
+        typer.Exit: If validation fails
+    """
+    if not cluster_data:
+        console.print(ERROR_NO_CLUSTER_DATA)
+        raise typer.Exit(code=1)
+    return cluster_data
+
+
+def validate_client_credentials(
+    cluster_data: Dict[str, Any], console: Console
+) -> tuple[str, Optional[str]]:
+    """Validate and extract client credentials from cluster data.
+
+    Args:
+        cluster_data: Cluster configuration dictionary
+        console: Rich console for error output
+
+    Returns:
+        Tuple of (client_id, client_secret) where client_secret may be None
+
+    Raises:
+        typer.Exit: If client_id is missing
+    """
+    client_id = cluster_data.get("clientId", None)
+    if not client_id:
+        console.print(ERROR_NO_CLIENT_ID)
+        raise typer.Exit(code=1)
+
+    client_secret = cluster_data.get("clientSecret", None)
+    return client_id, client_secret
+
+
+def require_client_secret(client_secret: Optional[str], console: Console) -> str:
+    """Validate that client secret exists.
+
+    Args:
+        client_secret: Optional client secret string
+        console: Rich console for error output
+
+    Returns:
+        Validated client secret string
+
+    Raises:
+        typer.Exit: If client secret is missing
+    """
+    if not client_secret:
+        console.print(ERROR_NO_CLIENT_SECRET)
+        raise typer.Exit(code=1)
+    return client_secret

vantage_cli/apps/juju_localhost/__init__.py

@@ -0,0 +1,17 @@
+"""Juju localhost deployment app package."""
+
+from vantage_cli import AsyncTyper
+
+from .app import deploy_command
+
+juju_localhost_app = AsyncTyper(
+    name="juju-localhost",
+    help="Juju localhost SLURM application commands.",
+    context_settings={
+        "allow_extra_args": True,
+        "allow_interspersed_args": True,
+        "ignore_unknown_options": True,
+    },
+)
+
+juju_localhost_app.command("deploy")(deploy_command)

vantage_cli/apps/juju_localhost/app.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 Vantage Compute Corporation
+# See LICENSE file for licensing details.
+"""Juju localhost deployment app for Vantage CLI."""
+
+import os
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import typer
+import yaml
+from juju.controller import Controller
+from juju.errors import JujuError
+from rich.console import Console
+from rich.panel import Panel
+from typing_extensions import Annotated
+
+from vantage_cli.apps.common import validate_client_credentials, validate_cluster_data
+from vantage_cli.config import attach_settings
+from vantage_cli.constants import (
+    ENV_CLIENT_SECRET,
+    JUJU_APPLICATION_NAME,
+    JUJU_SECRET_NAME,
+)
+
+from .bundle_yaml import VANTAGE_JUPYTERHUB_YAML
+
+
+def _build_secret_args(ctx: Any) -> list[str]:
+    return [
+        f"oidc-client-id={ctx.client_id}",
+        f"oidc-client-secret={ctx.client_secret}",
+        f"oidc-base-url={ctx.oidc_base_url}",
+        f"tunnel-api-url={ctx.tunnel_api_url}",
+        f"vantage-api-url={ctx.base_api_url}",
+        f"oidc-domain={ctx.oidc_domain}",
+        f"jupyterhub-token={ctx.jupyterhub_token}",
+    ]
+
+
+def _prepare_bundle(ctx: Any, model_name: str, secret_id: str) -> dict[str, Any]:
+    bundle_yaml = VANTAGE_JUPYTERHUB_YAML.copy()
+    bundle_yaml["applications"]["slurmctld"]["options"]["cluster-name"] = model_name
+    va_opts = bundle_yaml["applications"]["vantage-agent"]["options"]
+    jb_opts = bundle_yaml["applications"]["jobbergate-agent"]["options"]
+    hub_opts = bundle_yaml["applications"]["vantage-jupyterhub"]["options"]
+
+    va_opts["vantage-agent-base-api-url"] = ctx.base_api_url
+    va_opts["vantage-agent-oidc-client-id"] = ctx.client_id
+    va_opts["vantage-agent-oidc-domain"] = ctx.oidc_domain
+    va_opts["vantage-agent-oidc-client-secret"] = ctx.client_secret
+    va_opts["vantage-agent-cluster-name"] = model_name
+
+    jb_opts["jobbergate-agent-base-api-url"] = ctx.base_api_url
+    jb_opts["jobbergate-agent-oidc-domain"] = ctx.oidc_domain
+    jb_opts["jobbergate-agent-oidc-client-id"] = ctx.client_id
+    jb_opts["jobbergate-agent-oidc-client-secret"] = ctx.client_secret
+
+    hub_opts["vantage-jupyterhub-config-secret-id"] = secret_id
+    return bundle_yaml
+
+
+async def _write_and_deploy_model_bundle(model, bundle_yaml: dict[str, Any]) -> None:
+    original_cwd = os.getcwd()
+    with tempfile.TemporaryDirectory() as td:
+        f_name = Path(td) / "bundle.yaml"
+        with open(f_name, "w") as fh:
+            fh.write(yaml.dump(bundle_yaml))
+        Path(td).chmod(0o700)
+        os.chdir(td)
+        try:
+            await model.deploy("./bundle.yaml")
+        finally:
+            os.chdir(original_cwd)
+
+
+async def _run_slurmd_node_configured(model) -> None:
+    if slurmd_app := model.applications.get("slurmd"):
+        if slurmd_units := slurmd_app.units:
+            for slurmd_unit in slurmd_units:
+                action = await slurmd_unit.run_action("node-configured")
+                await action.wait()
+                print(f"Action result for {slurmd_unit.name}: {action.results}")
+
+
+async def _configure_jobbergate_influxdb(model) -> None:
+    slurmctld_app = model.applications.get("slurmctld")
+    if not slurmctld_app or not slurmctld_app.units:
+        print("Warning: slurmctld application not found")
+        return
+    leader_unit = None
+    for unit in slurmctld_app.units:
+        if await unit.is_leader_from_status():
+            leader_unit = unit
+        break
+    if leader_unit is None:
+        print("Warning: Could not find slurmctld leader unit")
+        return
+    action = await leader_unit.run("sudo cat /etc/slurm/acct_gather.conf")
+    await action.wait()
+    if action.results.get("return-code") != 0:
+        print(
+            f"Warning: Failed to get InfluxDB config: {action.results.get('stderr', 'Unknown error')}"
+        )
+        return
+    influxdb_conf = action.results.get("stdout", "")
+    host = user = pw = db = rp = None
+    for line in influxdb_conf.splitlines():
+        if line.startswith("profileinfluxdbhost"):
+            host = line.split("=", 1)[1].strip()
+        elif line.startswith("profileinfluxdbuser"):
+            user = line.split("=", 1)[1].strip()
+        elif line.startswith("profileinfluxdbpass"):
+            pw = line.split("=", 1)[1].strip()
+        elif line.startswith("profileinfluxdbdatabase"):
+            db = line.split("=", 1)[1].strip()
+        elif line.startswith("profileinfluxdbrtpolicy"):
+            rp = line.split("=", 1)[1].strip()
+    print(f"Parsed InfluxDB config: host={host}, user={user}, db={db}, rp={rp}")
+    if not all([user, pw, host, db, rp]):
+        print("Warning: Could not parse complete InfluxDB configuration")
+        return
+    influxdb_uri = f"influxdb://{user}:{pw}@{host}/{db}?rp={rp}"
+    jobbergate_agent = model.applications.get("jobbergate-agent")
+    if not jobbergate_agent:
+        print("Warning: jobbergate-agent application not found")
+        return
+    await jobbergate_agent.set_config({"jobbergate-agent-influx-dsn": influxdb_uri})
+    print("InfluxDB configuration applied to jobbergate-agent")
+
+
+async def deploy_juju_localhost(ctx: Any) -> None | typer.Exit:
+    """Deploy Vantage JupyterHub SLURM cluster using Juju on localhost (refactored)."""
+    console = Console()
+    controller = Controller()
+    model_name = "-".join(ctx.client_id.split("-")[:-4])
+    secret_name = JUJU_SECRET_NAME
+    try:
+        console.print("Connecting to Juju controller...")
+        await controller.connect()
+        console.print(f"Creating juju model: {model_name}")
+        model = await controller.add_model(model_name, cloud_name="localhost")
+        try:
+            console.print(f"Creating '{secret_name}' juju secret...")
+            secret = await model.add_secret(secret_name, _build_secret_args(ctx))
+            console.print(f"Secret created with ID: {secret}")
+            console.print("Deploying SLURM cluster...")
+            bundle_yaml = _prepare_bundle(ctx, model_name, secret)
+            await _write_and_deploy_model_bundle(model, bundle_yaml)
+            await model.grant_secret(secret_name, JUJU_APPLICATION_NAME)
+            try:
+                await model.wait_for_idle()
+            except JujuError:
+                return typer.Exit(code=1)
+            await _run_slurmd_node_configured(model)
+            await _configure_jobbergate_influxdb(model)
+            print(
+                f"'{model_name}' deployment complete!\nModel: {model_name}\nController: {controller.controller_name}"
+            )
+        finally:
+            await model.disconnect()
+    finally:
+        await controller.disconnect()
+
+
+async def deploy(ctx: typer.Context, cluster_data: Optional[Dict[str, Any]] = None) -> None:
+    """Deploy Juju localhost SLURM cluster using cluster data.
+
+    Args:
+        ctx: Typer context containing CLI configuration
+        cluster_data: Optional cluster configuration dictionary with client credentials
+
+    Raises:
+        typer.Exit: If deployment fails due to missing or invalid cluster data
+    """
+    console = Console()
+    console.print(Panel("Juju Localhost SLURM Application"))
+    console.print("Deploying juju localhost slurm application...")
+
+    # Validate cluster data and extract credentials
+    cluster_data = validate_cluster_data(cluster_data, console)
+    client_id, client_secret = validate_client_credentials(cluster_data, console)
+
+    # Get client secret from API if not in cluster data (import locally to avoid circular import)
+    if not client_secret:
+        from vantage_cli.commands.clusters import utils as cluster_utils
+
+        client_secret = await cluster_utils.get_cluster_client_secret(ctx=ctx, client_id=client_id)
+
+    # Check environment variable as fallback for client secret
+    if not client_secret:
+        client_secret = os.environ.get(ENV_CLIENT_SECRET, None)
+    if not client_secret:
+        console.print(
+            "[red]Error: No client secret found in cluster data, API, or environment.[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    # Get jupyterhub_token from cluster data if available, otherwise generate a default
+    jupyterhub_token = None
+    if cluster_data and "creationParameters" in cluster_data:
+        if jupyterhub_token_data := cluster_data["creationParameters"].get("jupyterhub_token"):
+            jupyterhub_token = jupyterhub_token_data
+
+    if jupyterhub_token is None:
+        console.print("[red]Error: No jupyterhub_token found in cluster data.[/red]")
+        raise typer.Exit(code=1)
+
+    # Temporarily disabled for testing
+    # vantage_cluster_context = VantageClusterContext(
+    class MockContext:
+        def __init__(self):
+            self.client_id = client_id
+            self.client_secret = client_secret
+            self.base_api_url = "http://localhost:8000"  # dummy
+            self.oidc_base_url = "http://localhost:8001"  # dummy
+            self.oidc_domain = "localhost"  # dummy
+            self.tunnel_api_url = "http://localhost:8002"  # dummy
+            self.jupyterhub_token = jupyterhub_token
+
+    vantage_cluster_context = MockContext()
+    await deploy_juju_localhost(vantage_cluster_context)
+
+
+# Typer CLI commands
+@attach_settings
+async def deploy_command(
+    ctx: typer.Context,
+    cluster_name: Annotated[
+        str,
+        typer.Argument(help="Name of the cluster to deploy"),
+    ],
+) -> None:
+    """Deploy a Vantage JupyterHub SLURM cluster using Juju localhost."""
+    console = Console()
+    console.print(Panel("Juju Localhost SLURM Application"))
+    console.print("Deploying juju localhost slurm application...")
+    # Get cluster data by name - for now using local import to avoid circular imports
+    from vantage_cli.commands.clusters import utils as cluster_utils
+
+    cluster_data = await cluster_utils.get_cluster_by_name(ctx, cluster_name)
+
+    # Fallback for testing if cluster not found
+    if not cluster_data:
+        console.print(
+            f"[yellow]Warning: Cluster '{cluster_name}' not found. Using test configuration.[/yellow]"
+        )
+        cluster_data = {"clientId": "dummy_client_for_testing"}
+
+    if not cluster_data:
+        console.print("[red]Error: No cluster data found.[/red]")
+        raise typer.Exit(code=1)
+
+    await deploy(ctx=ctx, cluster_data=cluster_data)

vantage_cli/apps/juju_localhost/bundle_yaml.py

@@ -0,0 +1,143 @@
+# Copyright (c) 2025 Vantage Compute Corporation
+# See LICENSE file for licensing details.
+"""Juju bundle definition for Vantage JupyterHub cluster deployment on localhost."""
+
+from typing import Any, Dict
+
+VANTAGE_JUPYTERHUB_YAML: Dict[str, Any] = {
+    "applications": {
+        "jobbergate-agent": {
+            "charm": "jobbergate-agent",
+            "base": "ubuntu@24.04/stable",
+            "channel": "edge",
+            "num_units": 0,
+            "options": {
+                "jobbergate-agent-oidc-client-id": "",
+                "jobbergate-agent-oidc-client-secret": "",
+            },
+        },
+        "vantage-agent": {
+            "charm": "vantage-agent",
+            "base": "ubuntu@24.04/stable",
+            "channel": "edge",
+            "num_units": 0,
+            "options": {
+                "vantage-agent-oidc-client-id": "",
+                "vantage-agent-oidc-client-secret": "",
+                "vantage-agent-cluster-name": "",
+            },
+        },
+        "vantage-jupyterhub-nfs-client": {
+            "charm": "filesystem-client",
+            "base": "ubuntu@24.04/stable",
+            "channel": "latest/edge",
+            "num_units": 0,
+            "options": {
+                "mountpoint": "/srv/vantage-nfs",
+            },
+        },
+        "mysql": {
+            "charm": "mysql",
+            "base": "ubuntu@22.04/stable",
+            "channel": "8.0/stable",
+            "num_units": 1,
+            "to": ["0"],
+            "constraints": "arch=amd64",
+            "storage": {
+                "database": "rootfs,1,1024M",
+            },
+        },
+        "influxdb": {
+            "charm": "influxdb",
+            "channel": "stable",
+            "base": "ubuntu@20.04/stable",
+            "num_units": 1,
+            "to": ["1"],
+            "constraints": "arch=amd64",
+        },
+        "slurmdbd": {
+            "charm": "slurmdbd",
+            "base": "ubuntu@24.04/stable",
+            "channel": "latest/edge",
+            "num_units": 1,
+            "to": ["2"],
+            "constraints": "arch=amd64",
+        },
+        "vantage-jupyterhub": {
+            "charm": "vantage-jupyterhub",
+            "base": "ubuntu@24.04/stable",
+            "channel": "edge",
+            "num_units": 1,
+            "options": {
+                "vantage-jupyterhub-config-secret-id": "",
+            },
+            "to": ["3"],
+            "constraints": "arch=amd64 cpu-cores=2 mem=2048 virt-type=virtual-machine",
+        },
+        "sackd": {
+            "charm": "sackd",
+            "base": "ubuntu@24.04/stable",
+            "channel": "latest/edge",
+            "num_units": 1,
+            "to": ["3"],
+            "constraints": "arch=amd64 cpu-cores=2 mem=2048 virt-type=virtual-machine",
+        },
+        "slurmctld": {
+            "charm": "slurmctld",
+            "base": "ubuntu@24.04/stable",
+            "channel": "latest/edge",
+            "num_units": 1,
+            "to": ["4"],
+            "options": {
+                "default-partition": "slurmd",
+                "cluster-name": "",
+            },
+            "constraints": "arch=amd64 cpu-cores=2 mem=2048 virt-type=virtual-machine",
+        },
+        "slurmd": {
+            "charm": "slurmd",
+            "base": "ubuntu@24.04/stable",
+            "channel": "latest/edge",
+            "num_units": 1,
+            "to": ["5"],
+            "constraints": "arch=amd64 cpu-cores=4 mem=8192 virt-type=virtual-machine",
+        },
+    },
+    "machines": {
+        "0": {
+            "constraints": "arch=amd64",
+            "base": "ubuntu@22.04/stable",
+        },
+        "1": {
+            "constraints": "arch=amd64",
+            "base": "ubuntu@20.04/stable",
+        },
+        "2": {
+            "constraints": "arch=amd64",
+            "base": "ubuntu@24.04/stable",
+        },
+        "3": {
+            "constraints": "arch=amd64 cpu-cores=2 mem=2048 virt-type=virtual-machine",
+            "base": "ubuntu@24.04/stable",
+        },
+        "4": {
+            "constraints": "arch=amd64 cpu-cores=2 mem=2048 virt-type=virtual-machine",
+            "base": "ubuntu@24.04/stable",
+        },
+        "5": {
+            "constraints": "arch=amd64 cpu-cores=4 mem=8192 virt-type=virtual-machine",
+            "base": "ubuntu@24.04/stable",
+        },
+    },
+    "relations": [
+        ["slurmdbd:database", "mysql:database"],
+        ["slurmctld:influxdb", "influxdb:query"],
+        ["slurmdbd:slurmctld", "slurmctld:slurmdbd"],
+        ["slurmd:slurmctld", "slurmctld:slurmd"],
+        ["sackd:slurmctld", "slurmctld:login-node"],
+        ["vantage-jupyterhub-nfs-client:juju-info", "slurmd:juju-info"],
+        ["vantage-jupyterhub:filesystem", "vantage-jupyterhub-nfs-client:filesystem"],
+        ["sackd:juju-info", "vantage-agent:juju-info"],
+        ["sackd:juju-info", "jobbergate-agent:juju-info"],
+    ],
+}