vantage-cli 0.1.1__py3-none-any.whl

vantage_cli/commands/clouds/update.py

@@ -0,0 +1,97 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Update cloud command."""
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+import typer
+from typing_extensions import Annotated
+
+logger = logging.getLogger(__name__)
+
+
+def update_command(
+    ctx: typer.Context,
+    cloud_name: Annotated[str, typer.Argument(help="Name of the cloud to update")],
+    provider: Annotated[
+        Optional[str], typer.Option("--provider", "-p", help="Update cloud provider")
+    ] = None,
+    region: Annotated[
+        Optional[str], typer.Option("--region", "-r", help="Update default region")
+    ] = None,
+    config_file: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--config-file",
+            help="Path to updated configuration file",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+        ),
+    ] = None,
+    credentials_file: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--credentials-file",
+            help="Path to updated credentials file",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+        ),
+    ] = None,
+    description: Annotated[
+        Optional[str], typer.Option("--description", help="Update cloud description")
+    ] = None,
+):
+    """Update an existing cloud configuration."""
+    verbose = ctx.obj.get("verbose", False)
+    settings = ctx.obj.get("settings")
+
+    logger.info(f"Updating cloud configuration: {cloud_name}")
+
+    if verbose:
+        logger.debug(f"Provider: {provider}")
+        logger.debug(f"Region: {region}")
+        logger.debug(f"Config file: {config_file}")
+        logger.debug(f"Credentials file: {credentials_file}")
+        logger.debug(f"Description: {description}")
+        logger.debug(f"Settings: {settings}")
+
+    # TODO: Check if cloud exists
+
+    # Check if any updates were provided
+    updates = []
+    if provider:
+        updates.append(f"provider: {provider}")
+    if region:
+        updates.append(f"region: {region}")
+    if config_file:
+        updates.append(f"config file: {config_file}")
+    if credentials_file:
+        updates.append(f"credentials file: {credentials_file}")
+    if description:
+        updates.append(f"description: {description}")
+
+    if not updates:
+        typer.echo(f"No updates specified for cloud '{cloud_name}'")
+        typer.echo("Use --help to see available update options")
+        raise typer.Exit(1)
+
+    typer.echo(f"Updating cloud '{cloud_name}' with:")
+    for update in updates:
+        typer.echo(f"  - {update}")
+
+    # TODO: Implement actual cloud configuration update logic
+    # This would typically:
+    # 1. Load existing cloud configuration
+    # 2. Update specified fields
+    # 3. Validate the updated configuration
+    # 4. Save the updated configuration
+    # 5. Update any related files or settings
+
+    logger.info(f"Cloud {cloud_name} updated successfully")
+    typer.echo(f"✅ Cloud '{cloud_name}' updated successfully")

vantage_cli/commands/clusters/__init__.py

@@ -0,0 +1,27 @@
+# © 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 .create import create_cluster
+from .delete import delete_cluster
+from .get import get_cluster
+from .list import list_clusters
+
+# Create the cluster command group
+cluster_app = AsyncTyper(
+    name="clusters",
+    help="Manage Vantage compute clusters for high-performance computing workloads.",
+    context_settings={
+        "allow_extra_args": True,
+        "allow_interspersed_args": True,
+        "ignore_unknown_options": True,
+    },
+)
+
+# Register subcommands directly
+cluster_app.command("create")(create_cluster)
+cluster_app.command("delete")(delete_cluster)
+cluster_app.command("get")(get_cluster)
+cluster_app.command("list")(list_clusters)

vantage_cli/commands/clusters/create.py

@@ -0,0 +1,270 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Create cluster command for Vantage CLI."""
+
+from pathlib import Path
+from typing import Any, Optional
+
+import click
+import typer
+from loguru import logger
+from rich.console import Console
+from typing_extensions import Annotated
+
+from vantage_cli.config import attach_settings
+from vantage_cli.exceptions import Abort
+from vantage_cli.gql_client import create_async_graphql_client
+
+from .render import render_cluster_details
+from .utils import get_app_choices, get_available_apps, get_cloud_choices
+
+console = Console()
+
+
+@attach_settings
+async def create_cluster(
+    ctx: typer.Context,
+    cluster_name: Annotated[str, typer.Argument(help="Name of the cluster to create")],
+    cloud: Annotated[
+        str,
+        typer.Option(
+            "--cloud",
+            "-c",
+            help="Cloud to use for deployment.",
+            case_sensitive=False,
+            click_type=click.Choice(get_cloud_choices(), case_sensitive=False),
+        ),
+    ],
+    config_file: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--config-file",
+            help="Path to configuration file for cluster creation.",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+        ),
+    ] = None,
+    deploy: Annotated[
+        Optional[str],
+        typer.Option(
+            "--deploy",
+            help="Deploy an application after cluster creation.",
+            case_sensitive=False,
+            click_type=click.Choice(get_app_choices(), case_sensitive=False),
+        ),
+    ] = None,
+):
+    """Create a new Vantage cluster."""
+    # Ensure we have settings configured
+    if not ctx.obj or not ctx.obj.settings:
+        raise Abort(
+            "No settings configured. Please run 'vantage config set' first.",
+            subject="Configuration Required",
+            log_message="Settings not configured",
+        )
+
+    # Validate cloud provider
+    supported_clouds = ctx.obj.settings.supported_clouds
+    if cloud not in supported_clouds:
+        raise Abort(
+            f"Unsupported cloud provider: {cloud}. Supported providers: {', '.join(supported_clouds)}",
+            subject="Invalid Cloud Provider",
+            log_message=f"Invalid cloud provider: {cloud}",
+        )
+
+    # GraphQL mutation for creating a cluster
+    create_mutation = """
+    mutation createCluster($createClusterInput: CreateClusterInput!) {
+        createCluster(createClusterInput: $createClusterInput) {
+            ... on Cluster {
+                name
+                status
+                clientId
+                description
+                ownerEmail
+                provider
+                cloudAccountId
+                creationParameters
+            }
+            ... on ClusterNameInUse {
+                message
+            }
+            ... on InvalidInput {
+                message
+            }
+            ... on ClusterCouldNotBeDeployed {
+                message
+            }
+            ... on UnexpectedBehavior {
+                message
+            }
+        }
+    }
+    """
+
+    # Map cloud provider to GraphQL enum values
+    provider_mapping = {
+        "localhost": "on_prem",
+        "aws": "aws",
+        "gcp": "on_prem",  # TODO: Add GCP support to backend
+        "azure": "on_prem",  # TODO: Add Azure support to backend
+        "on-premises": "on_prem",
+    }
+
+    # Build the input variables
+    cluster_input: dict[str, Any] = {
+        "name": cluster_name,
+        "description": f"Cluster {cluster_name} created via CLI",
+        "provider": provider_mapping.get(cloud, "on_prem"),
+    }
+
+    # Add provider-specific attributes if needed
+    if cloud == "aws":
+        # For AWS, we need providerAttributes (camelCase for GraphQL)
+        # This is a simplified example - in practice you'd need to collect more details
+        cluster_input["providerAttributes"] = {
+            "aws": {
+                "headNodeInstanceType": "t3.medium",  # camelCase for GraphQL
+                "keyPair": "default",  # This should be configurable
+                "cloudAccountId": 1,  # This should come from user's cloud account
+                "regionName": "us_west_2",
+            }
+        }
+
+    # If config file is provided, read and parse it
+    if config_file:
+        try:
+            import json
+
+            config_data = json.loads(config_file.read_text())
+            # Merge config file data with input
+            cluster_input.update(config_data)
+        except Exception as e:
+            raise Abort(
+                f"Failed to read configuration file: {e}",
+                subject="Configuration File Error",
+                log_message=f"Config file error: {e}",
+            )
+
+    variables = {"createClusterInput": cluster_input}
+
+    try:
+        # Create async GraphQL client
+        logger.debug(f"CTX OBJ: {ctx.obj}")
+        graphql_client = create_async_graphql_client(ctx.obj.settings, ctx.obj.profile)
+
+        # Execute the mutation
+        logger.debug(f"Creating cluster: {cluster_name}")
+        console.print(f"[bold blue]Creating cluster '{cluster_name}' on {cloud}...[/bold blue]")
+
+        response_data = await graphql_client.execute_async(create_mutation, variables)
+
+        # Handle the response
+        create_result = response_data.get("createCluster")
+
+        if not create_result:
+            raise Abort(
+                "No response from server",
+                subject="Server Error",
+                log_message="Empty response from createCluster mutation",
+            )
+
+        # Check for errors in the response
+        if "message" in create_result:
+            # This is an error response
+            error_message = create_result["message"]
+            console.print(f"[bold red]Failed to create cluster: {error_message}[/bold red]")
+            raise Abort(
+                f"Cluster creation failed: {error_message}",
+                subject="Cluster Creation Failed",
+                log_message=f"GraphQL error: {error_message}",
+            )
+
+        # Success case - cluster was created
+        if "name" in create_result:
+            console.print(
+                f"[bold green]✓ Cluster '{create_result['name']}' created successfully![/bold green]"
+            )
+            console.print()
+
+            # Display detailed cluster information
+            render_cluster_details(create_result, json_output=False)
+
+            # Deploy application if --deploy option was provided
+            if deploy:
+                await deploy_app_to_cluster(ctx, create_result, deploy)
+
+        else:
+            console.print(
+                "[bold yellow]Cluster creation initiated but status unclear[/bold yellow]"
+            )
+
+    except Abort:
+        # Re-raise Abort exceptions as they contain user-friendly messages
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error creating cluster: {e}")
+        raise Abort(
+            "An unexpected error occurred while creating the cluster.",
+            subject="Unexpected Error",
+            log_message=f"Unexpected error: {e}",
+        )
+
+
+async def deploy_app_to_cluster(ctx: typer.Context, cluster_data: dict, app_name: str):
+    """Deploy an application to the newly created cluster."""
+    try:
+        # Get available apps
+        available_apps = get_available_apps()
+
+        if app_name not in available_apps:
+            console.print(f"[bold red]✗ App '{app_name}' not found[/bold red]")
+            return
+
+        console.print(
+            f"[bold blue]Deploying app '{app_name}' to cluster '{cluster_data['name']}'...[/bold blue]"
+        )
+
+        # Get the app info
+        app_info = available_apps[app_name]
+
+        # Check if this is a function-based app or class-based app
+        if "deploy_function" in app_info:
+            # Function-based app
+            deploy_function = app_info["deploy_function"]
+            await deploy_function(ctx, cluster_data)
+            console.print(f"[bold green]✓ App '{app_name}' deployed successfully![/bold green]")
+        elif "instance" in app_info:
+            # Class-based app
+            app_instance = app_info["instance"]
+
+            # Check if the app has a deploy method
+            if hasattr(app_instance, "deploy"):
+                # Call the app's deploy method
+                await app_instance.deploy(ctx)
+                console.print(
+                    f"[bold green]✓ App '{app_name}' deployed successfully![/bold green]"
+                )
+            else:
+                console.print(
+                    f"[bold yellow]! App '{app_name}' does not support automatic deployment[/bold yellow]"
+                )
+                console.print(
+                    "[dim]You can manually deploy this app using the appropriate commands.[/dim]"
+                )
+        else:
+            console.print(
+                f"[bold yellow]! App '{app_name}' does not support automatic deployment[/bold yellow]"
+            )
+            console.print(
+                "[dim]You can manually deploy this app using the appropriate commands.[/dim]"
+            )
+
+    except Exception as e:
+        logger.error(f"Failed to deploy app '{app_name}': {e}")
+        console.print(f"[bold red]✗ Failed to deploy app '{app_name}': {e}[/bold red]")
+        console.print(
+            "[dim]The cluster was created successfully, but app deployment failed.[/dim]"
+        )

vantage_cli/commands/clusters/delete.py

@@ -0,0 +1,101 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Delete cluster command for Vantage CLI."""
+
+import typer
+from loguru import logger
+from typing_extensions import Annotated
+
+from vantage_cli.command_base import JsonOption, get_effective_json_output
+from vantage_cli.config import attach_settings
+from vantage_cli.exceptions import Abort
+from vantage_cli.gql_client import create_async_graphql_client
+
+from .render import render_cluster_deletion_result
+
+
+@attach_settings
+async def delete_cluster(
+    ctx: typer.Context,
+    cluster_name: Annotated[str, typer.Argument(help="Name of the cluster to delete")],
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation prompt")] = False,
+    json_output: JsonOption = False,
+):
+    """Delete a Vantage cluster."""
+    # Get effective JSON output setting
+    effective_json = get_effective_json_output(ctx, json_output)
+
+    # Confirmation prompt unless force is used
+    if not force and not effective_json:
+        from rich.console import Console
+        from rich.prompt import Confirm
+
+        console = Console()
+        console.print(
+            f"\n[yellow]⚠️  You are about to delete cluster '[bold red]{cluster_name}[/bold red]'[/yellow]"
+        )
+        console.print("[yellow]This action cannot be undone![/yellow]")
+
+        if not Confirm.ask("Are you sure you want to proceed?"):
+            console.print("[dim]Deletion cancelled.[/dim]")
+            return
+
+    # GraphQL mutation for deleting a cluster
+    delete_mutation = """
+    mutation deleteCluster($clusterName: String!) {
+        deleteCluster(clusterName: $clusterName) {
+            ... on ClusterDeleted {
+                message
+            }
+            ... on ClusterNotFound {
+                message
+            }
+            ... on InvalidProviderInput {
+                message
+            }
+            ... on UnexpectedBehavior {
+                message
+            }
+        }
+    }
+    """
+
+    try:
+        # Create async GraphQL client
+        profile = getattr(ctx.obj, "profile", "default")
+        graphql_client = create_async_graphql_client(ctx.obj.settings, profile)
+
+        # Prepare deletion variables
+        delete_variables = {"clusterName": cluster_name}
+
+        # Execute the deletion mutation
+        logger.debug(f"Deleting cluster: {cluster_name}")
+        delete_response = await graphql_client.execute_async(delete_mutation, delete_variables)
+
+        # Extract deletion result
+        deletion_data = delete_response.get("deleteCluster", {})
+
+        # Log the response for debugging
+        logger.debug(f"Delete response: {deletion_data}")
+
+        # Determine success - if we get any response it likely succeeded
+        # The GraphQL union types make it tricky to detect success vs failure
+        success = bool(deletion_data)  # If we got a response without error, consider it success
+
+        # Render deletion result
+        render_cluster_deletion_result(
+            cluster_name=cluster_name,
+            success=success,
+            json_output=effective_json,
+        )
+
+    except Abort:
+        # Re-raise Abort exceptions as they contain user-friendly messages
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error deleting cluster '{cluster_name}': {e}")
+        raise Abort(
+            f"An unexpected error occurred while deleting cluster '{cluster_name}'.",
+            subject="Unexpected Error",
+            log_message=f"Unexpected error: {e}",
+        )

vantage_cli/commands/clusters/get.py

@@ -0,0 +1,30 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Get cluster command for Vantage CLI."""
+
+import typer
+from typing_extensions import Annotated
+
+from vantage_cli.command_base import JsonOption, get_effective_json_output
+from vantage_cli.commands.clusters.utils import get_cluster_by_name
+from vantage_cli.config import attach_settings
+from vantage_cli.exceptions import Abort
+
+from .render import render_cluster_details
+
+
+@attach_settings
+async def get_cluster(
+    ctx: typer.Context,
+    cluster_name: Annotated[str, typer.Argument(help="Name of the cluster to get details for")],
+    json_output: JsonOption = False,
+):
+    """Get details of a specific Vantage cluster."""
+    cluster = await get_cluster_by_name(ctx=ctx, cluster_name=cluster_name)
+    if not cluster:
+        raise Abort(
+            f"No cluster found with name '{cluster_name}'.",
+            subject="Cluster Not Found",
+            log_message=f"Cluster '{cluster_name}' not found",
+        )
+    render_cluster_details(cluster, json_output=get_effective_json_output(ctx, json_output))

vantage_cli/commands/clusters/list.py

@@ -0,0 +1,84 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""List clusters command."""
+
+import typer
+from loguru import logger
+
+from vantage_cli.command_base import JsonOption, get_effective_json_output
+from vantage_cli.config import attach_settings
+from vantage_cli.exceptions import Abort
+from vantage_cli.gql_client import create_async_graphql_client
+from vantage_cli.render import render_quick_start_guide
+
+from .render import render_clusters_table
+
+
+@attach_settings
+async def list_clusters(
+    ctx: typer.Context,
+    json_output: JsonOption = False,
+):
+    """List all Vantage clusters."""
+    # GraphQL query to fetch clusters
+    query = """
+    query getClusters($first: Int!) {
+        clusters(first: $first) {
+            edges {
+                node {
+                    name
+                    status
+                    clientId
+                    description
+                    ownerEmail
+                    provider
+                    cloudAccountId
+                    creationParameters
+                }
+            }
+            total
+        }
+    }
+    """
+
+    variables = {"first": 100}  # Fetch up to 100 clusters
+
+    try:
+        # Create async GraphQL client
+        profile = getattr(ctx.obj, "profile", "default")
+        graphql_client = create_async_graphql_client(ctx.obj.settings, profile)
+
+        # Execute the query
+        logger.debug("Executing clusters query")
+        response_data = await graphql_client.execute_async(query, variables)
+
+        # Extract cluster data
+        clusters_data = response_data.get("clusters", {})
+        clusters = [edge["node"] for edge in clusters_data.get("edges", [])]
+        total_count = clusters_data.get("total", 0)
+
+        # Get effective JSON output setting
+        effective_json = get_effective_json_output(ctx, json_output)
+
+        # Render results using Rich table
+        render_clusters_table(
+            clusters,
+            title="Clusters List",
+            total_count=total_count,
+            json_output=effective_json,
+        )
+
+        # Show quick start guide after listing clusters (only if not JSON output)
+        if clusters and not effective_json:
+            render_quick_start_guide()
+
+    except Abort:
+        # Re-raise Abort exceptions as they contain user-friendly messages
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error listing clusters: {e}")
+        raise Abort(
+            "An unexpected error occurred while listing clusters.",
+            subject="Unexpected Error",
+            log_message=f"Unexpected error: {e}",
+        )