ballista-cli 0.1.0__py3-none-any.whl

ballista_cli/cli.py

@@ -0,0 +1,533 @@
+import os.path
+from enum import StrEnum
+from pathlib import Path
+from typing import Annotated
+
+import prettytable
+import typer
+import yaml
+from async_typer import AsyncTyper
+from ballista_sdk.adapters import EnvironmentWithAdapter
+from ballista_sdk.adapters.docker_compose import DockerComposeInfrastructureAdapter
+from ballista_sdk.adapters.kubernetes import KubernetesAPIInfrastructureAdapter
+from ballista_sdk.api.v1 import (
+    Bolt,
+    DefaultExecutionParameters,
+    Environment,
+    EnvironmentTier,
+    ExecutionParameters,
+    ExternalizedServiceParameters,
+    VolumeExecutionParameters,
+)
+from ballista_sdk.bolts.factory import BoltFactory
+from ballista_sdk.bolts.v1 import BoltV1Factory
+
+DOCKER_COMPOSE_LOCAL = False
+
+
+# TODO: Stuff to get a ballista-workspace.yaml file, or maybe a .ballista folder in a parent folder?
+
+
+def get_bolt_factory(api_version: str) -> BoltFactory:
+    if api_version == "v1":
+        return BoltV1Factory()
+
+    raise ValueError()
+
+
+def get_local_bolt() -> Bolt:
+    """Get a Bolt from local path."""
+
+    filename = "./ballista.yaml" if os.path.isfile("./ballista.yaml") else None
+    if not filename:
+        raise ValueError("NO BALLISTA.YAML")
+
+    with open(filename, "r") as f:
+        ballista_yaml = yaml.safe_load(f)
+
+    if ballista_yaml is None:
+        raise ValueError()
+
+    api_version = ballista_yaml.get("api_version")
+
+    factory = get_bolt_factory(api_version=api_version)
+    return factory.get_bolt(ballista_yaml)
+
+
+def get_local_default_bolts() -> list[Bolt]:
+    """Loads default Bolts from home folder."""
+
+    bolts = []
+
+    home = Path.home()
+    ballista_folder = home / ".ballista"
+    defaults_yaml = ballista_folder / "defaults.yaml"
+    if defaults_yaml.exists():
+        with open(defaults_yaml) as f:
+            for bolt_yaml in yaml.safe_load_all(f):
+                api_version = bolt_yaml.get("api_version")
+
+                factory = get_bolt_factory(api_version=api_version)
+                bolt = factory.get_bolt(bolt_yaml)
+                bolts.append(bolt)
+
+    return bolts
+
+
+def get_local_environment() -> EnvironmentWithAdapter:
+    """Get a local Environment for development purposes."""
+
+    # TODO: When we have registry support, we won't need this.
+    # Load any local Bolts
+    local_bolts = get_local_default_bolts()
+
+    if DOCKER_COMPOSE_LOCAL:
+        adapter = DockerComposeInfrastructureAdapter(local_bolts)
+    else:
+        adapter = KubernetesAPIInfrastructureAdapter()
+
+    environment = Environment(name="local", tier=EnvironmentTier.DEVELOPMENT)
+
+    return environment, adapter
+
+
+# TODO: Improve this when there are more adapters
+async def get_remote_environments() -> list[EnvironmentWithAdapter]:
+    # Read in remote Kubernetes environments
+    adapter = KubernetesAPIInfrastructureAdapter()
+    return [(e, adapter) for e in await adapter.list_environments()]
+
+
+async def get_available_environments(
+    include_remotes: bool = False, environment_names: list[str] | None = None
+) -> list[EnvironmentWithAdapter]:
+    environments = [get_local_environment()]
+
+    if include_remotes:
+        environments.extend(await get_remote_environments())
+
+    if environment_names:
+        return [(environment, _) for environment, _ in environments if environment.name in environment_names]
+
+    else:
+        return environments
+
+
+def get_local_execution_parameters() -> ExecutionParameters:
+    """Get ExecutionParameters for the local development environment with the following settings:
+
+    - All services are externalized at `localhost`.
+    - Volumes are allowed at ???.
+
+    """
+
+    return ExecutionParameters(
+        initial=DefaultExecutionParameters(
+            external_service=ExternalizedServiceParameters(host="localhost"),
+            volume=VolumeExecutionParameters(type="standard"),
+        )
+    )
+
+
+def get_dev_execution_parameters() -> ExecutionParameters:
+    return ExecutionParameters(
+        initial=DefaultExecutionParameters(
+            external_service=ExternalizedServiceParameters(host="dev.ballista.build", port=8123),
+            volume=VolumeExecutionParameters(type="standard"),
+        )
+    )
+
+
+cli = AsyncTyper()
+
+
+@cli.command(short_help="initialize a new ballista powered project")
+def init(project: Annotated[str, typer.Argument(help="Name of new project.")]):
+    # TODO: Need to pick an api, so just use v1 for now. We'll probably want a default version with compatibility for old ones up to a certain date.
+    if True:
+        bolt_factory = BoltV1Factory()
+
+    # Check if that project (folder) already exists
+    if os.path.exists(project):
+        raise ValueError(f'Path "{project}" already exists.')
+
+    os.makedirs(project)
+    new_bolt = bolt_factory.create_bolt(project=project, version="0.1.0")
+    with open(os.path.join(project, "ballista.yaml"), "w") as f:
+        yaml.dump(new_bolt.to_dict(), f)
+
+
+@cli.command(
+    short_help="Build artifacts defined in ballista.yaml",
+    help="""Build a path containing a ballista.yaml into a Launch-able Bolt.
+
+Defined artifacts contained in a ballista.yaml will be built and ready to be Launched.
+""",
+)
+def build(
+    artifacts: Annotated[list[str] | None, typer.Argument(help="List of artifacts to buid.")] = None,
+    artifact_types: Annotated[
+        list[str] | None,
+        typer.Option(help="List of specified Artifact Types to build."),
+    ] = None,
+):
+    ballista_bolt = get_local_bolt()
+
+    for artifact in ballista_bolt.buildable_artifacts:
+        build = artifact.build
+        image_name = f"{ballista_bolt.project}_{artifact.name}:{ballista_bolt.version}"
+
+        path = "."
+        dockerfile = build.dockerfile or "Dockerfile"
+        # Process possible path for the Dockerfile
+        dockerfile_pieces = dockerfile.rsplit("/", 1)
+        if len(dockerfile_pieces) > 1:
+            path, _ = dockerfile_pieces
+
+        cmd = f"docker build {path} -t {image_name} -f {dockerfile} --target {build.dockerfile_target}"
+        os.system(cmd)
+
+
+@cli.command(short_help="Start local development environment.")
+async def up(artifact_names: Annotated[list[str] | None, typer.Option("--artifact", "-a")] = None):
+    bolt = get_local_bolt()
+    environment, adapter = get_local_environment()
+    execution_parameters = get_local_execution_parameters()
+
+    executable_artifacts = bolt.executable_artifacts
+    if artifact_names and (found_artifacts := [a for a in executable_artifacts if a.name in artifact_names]):
+        executable_artifacts = found_artifacts
+
+    await adapter.deploy(
+        bolt=bolt,
+        artifacts=executable_artifacts,
+        environment=environment,
+        execution_parameters=execution_parameters,
+    )
+
+
+@cli.command(short_help="Teardown local development environment.")
+async def down():
+    bolt = get_local_bolt()
+    environment, adapter = get_local_environment()
+    execution_parameters = get_local_execution_parameters()
+
+    await adapter.teardown(
+        bolt=bolt,
+        artifacts=bolt.executable_artifacts,
+        environment=environment,
+        execution_parameters=execution_parameters,
+    )
+
+
+@cli.command(short_help="Deploy to an environment.")
+async def deploy(
+    environment_name: str, allow_unknown_environment: bool = False, environment_adapter_name: str | None = None
+):
+    environments = await get_available_environments(include_remotes=True, environment_names=[environment_name])
+
+    if not environments:
+        print(f'Unknown environment "{environment_name}".')
+        if allow_unknown_environment:
+            environment = Environment(name=environment_name, tier=EnvironmentTier.DEVELOPMENT)
+            # TODO: Figure this out
+            adapter = KubernetesAPIInfrastructureAdapter()
+        else:
+            typer.Exit(1)
+            return
+    else:
+        environment, adapter = environments[0]
+
+    ballista_bolt = get_local_bolt()
+
+    # TODO: Get real execution parameters somehow!
+    execution_parameters = get_dev_execution_parameters()
+    await adapter.deploy(
+        bolt=ballista_bolt,
+        artifacts=ballista_bolt.executable_artifacts,
+        environment=environment,
+        execution_parameters=execution_parameters,
+    )
+
+
+class GenerationTypes(StrEnum):
+    SETTINGS = "settings"
+
+
+@cli.command(short_help="generate files from ballista dependencies")
+def generate(type: GenerationTypes):
+    print("GENERATE")
+
+
+@cli.command(short_help="Execute a command within an Artifact context.")
+def run(artifact_name: str):
+    environment, adapter = get_local_environment()
+    bolt = get_local_bolt()
+
+    artifacts = [a for a in bolt.executable_artifacts if a.name == artifact_name]
+    if len(artifacts) == 0:
+        raise ValueError("artifact_name not found")
+
+    artifact = artifacts[0]
+    # TODO: Get environment the artifact needs
+    #
+
+
+# @cli.command(short_help="Environment information")
+# def env():
+#     pass
+
+
+list_cli = AsyncTyper(no_args_is_help=True)
+cli.add_typer(list_cli, name="list", short_help="List stuff")
+
+
+@list_cli.command(name="artifact_types")
+async def list_artifact_types(
+    environment_names: Annotated[
+        list[str] | None, typer.Option("--environment", "-e", help="Specific environment name.")
+    ] = None,
+    include_remotes: Annotated[bool, typer.Option(help="Include remote environments.")] = False,
+):
+    table = prettytable.PrettyTable()
+    table.align = "l"
+    table.field_names = ["Artifact Type", "Configs"]
+
+    environments = await get_available_environments(
+        include_remotes=include_remotes, environment_names=environment_names
+    )
+    for environment, adapter in environments:
+        for artifact_type in await adapter.list_artifact_types([environment]):
+            table.add_row(
+                [f"{artifact_type.title} ({artifact_type.name})", "NYI"],
+                divider=True,
+            )
+
+    print(table.get_string())
+
+
+@list_cli.command("environments")
+async def list_environments(
+    environment_names: Annotated[
+        list[str] | None, typer.Option("--environment", "-e", help="Specific environment name.")
+    ] = None,
+    include_remotes: Annotated[bool, typer.Option(help="Include remote environments.")] = False,
+):
+    table = prettytable.PrettyTable()
+    table.align = "l"
+    table.field_names = ["Environment", "Tier", "Adapter"]
+
+    environments = await get_available_environments(
+        include_remotes=include_remotes, environment_names=environment_names
+    )
+    for environment, adapter in environments:
+        table.add_row([f"{environment.name} ({environment.name})", environment.tier, adapter.name])
+
+    print(table.get_string())
+
+
+@list_cli.command("executable_artifacts")
+async def list_executable_artifacts(
+    project_names: Annotated[list[str] | None, typer.Option("--project", "-p", help="Specific project name.")] = None,
+    artifact_names: Annotated[
+        list[str] | None, typer.Option("--artifact", "-a", help="Specific artifact name.")
+    ] = None,
+    environment_names: Annotated[
+        list[str] | None, typer.Option("--environment", "-e", help="Specific environment name.")
+    ] = None,
+    include_remotes: Annotated[bool, typer.Option(help="Include remote environments.")] = False,
+):
+    table = prettytable.PrettyTable()
+    table.align = "l"
+    table.field_names = ["Project", "Artifact", "Version"]
+
+    environments = await get_available_environments(
+        include_remotes=include_remotes, environment_names=environment_names
+    )
+    for environment, adapter in environments:
+        for project_name, artifact_name, artifact_version in await adapter.list_executable_artifacts(
+            [environment], project_names=project_names
+        ):
+            table.add_row([project_name, artifact_name, artifact_version])
+
+    print(table.get_string())
+
+
+@list_cli.command("provided_resources")
+async def list_provided_resources(
+    project_names: Annotated[list[str] | None, typer.Option("--project", "-p", help="Specific project name.")] = None,
+    artifact_names: Annotated[
+        list[str] | None, typer.Option("--artifact", "-a", help="Specific artifact name.")
+    ] = None,
+    environment_names: Annotated[
+        list[str] | None, typer.Option("--environment", "-e", help="Specific environment name.")
+    ] = None,
+    include_remotes: Annotated[bool, typer.Option(help="Include remote environments.")] = False,
+):
+    verbose = False
+
+    table = prettytable.PrettyTable()
+    table.align = "l"
+    table.field_names = ["Resource", "Configs", "Secrets", "Requirements"]
+
+    environments = await get_available_environments(
+        include_remotes=include_remotes, environment_names=environment_names
+    )
+    for environment, adapter in environments:
+        for provided_resource, provider_artifact_reference in await adapter.list_provided_resources(
+            [environment], project_names=project_names, artifact_names=artifact_names
+        ):
+            configs = None
+            if provided_resource.configs:
+                configs = prettytable.PrettyTable(align="l")
+                configs.set_style(prettytable.TableStyle.PLAIN_COLUMNS)
+                configs.header = False
+                if verbose:
+                    configs.add_rows(
+                        [[f"{c.title} ({c.name})", c.description, c.shared] for c in provided_resource.configs]
+                    )
+                else:
+                    configs.add_rows([[f"{c.title} ({c.name})"] for c in provided_resource.configs])
+
+            secrets = None
+            if provided_resource.secrets:
+                secrets = prettytable.PrettyTable(align="l")
+                secrets.set_style(prettytable.TableStyle.PLAIN_COLUMNS)
+                secrets.header = False
+                if verbose:
+                    secrets.add_rows(
+                        [[f"{s.title} ({s.name})", s.description, s.shared] for s in provided_resource.secrets]
+                    )
+                else:
+                    secrets.add_rows([[f"{s.title} ({s.name})"] for s in provided_resource.secrets])
+
+            requirements = None
+            if provided_resource.requirements and provided_resource.requirements.properties:
+                requirements = prettytable.PrettyTable(align="l")
+                requirements.set_style(prettytable.TableStyle.PLAIN_COLUMNS)
+                requirements.header = False
+                if verbose:
+                    requirements.add_rows(
+                        [
+                            [f"{req_property.title or req_name} ({req_name})", req_property.description]
+                            for req_name, req_property in provided_resource.requirements.properties.items()
+                        ]
+                    )
+                else:
+                    requirements.add_rows(
+                        [
+                            [f"{req_property.title or req_name} ({req_name})"]
+                            for req_name, req_property in provided_resource.requirements.properties.items()
+                        ]
+                    )
+
+            table.add_row(
+                [
+                    f"{provided_resource.title} ({provider_artifact_reference.project_name}:{provided_resource.name})",
+                    configs,
+                    secrets,
+                    requirements,
+                ],
+                divider=True,
+            )
+
+    print(table.get_string())
+
+
+@list_cli.command("provided_services", short_help="List all Provided Services.")
+async def list_provided_services(
+    project_names: Annotated[list[str] | None, typer.Option("--project", "-p", help="Specific project name.")] = None,
+    artifact_names: Annotated[
+        list[str] | None, typer.Option("--artifact", "-a", help="Specific artifact name.")
+    ] = None,
+    environment_names: Annotated[
+        list[str] | None, typer.Option("--environment", "-e", help="Specific environment name.")
+    ] = None,
+    include_remotes: Annotated[bool, typer.Option(help="Include remote environments.")] = False,
+):
+    table = prettytable.PrettyTable()
+    table.align = "l"
+    table.field_names = ["Project", "Artifact", "Service", "Type", "Port"]
+
+    environments = await get_available_environments(
+        include_remotes=include_remotes, environment_names=environment_names
+    )
+    for environment, adapter in environments:
+        for provided_service, provider_artifact_reference in await adapter.list_provided_services(
+            [environment], project_names=project_names, artifact_names=artifact_names
+        ):
+            if provided_service.grpc:
+                service_type = "grpc"
+                service_port = provided_service.grpc
+            elif provided_service.http:
+                service_type = "http"
+                service_port = provided_service.http
+            elif provided_service.tcp:
+                service_type = "tcp"
+                service_port = provided_service.tcp
+
+            table.add_row(
+                [
+                    provider_artifact_reference.project_name,
+                    provider_artifact_reference.artifact_name,
+                    provided_service.name,
+                    service_type,
+                    service_port,
+                ]
+            )
+
+    print(table.get_string())
+
+
+@list_cli.command("resources", short_help="List Resources and their statuses.")
+async def list_resources(
+    project_names: Annotated[list[str] | None, typer.Option("--project", "-p", help="Specific project name.")] = None,
+    artifact_names: Annotated[
+        list[str] | None, typer.Option("--artifact", "-a", help="Specific artifact name.")
+    ] = None,
+    environment_names: Annotated[
+        list[str] | None, typer.Option("--environment", "-e", help="Specific environment name.")
+    ] = None,
+    include_remotes: Annotated[bool, typer.Option(help="Include remote environments.")] = False,
+):
+    table = prettytable.PrettyTable()
+    table.align = "l"
+    table.field_names = ["Project", "Artifact", "Resource", "Status"]
+
+    environments = await get_available_environments(
+        include_remotes=include_remotes, environment_names=environment_names
+    )
+    for environment, adapter in environments:
+        for artifact_reference in await adapter.list_executable_artifacts(
+            [environment], project_names=project_names, artifact_names=artifact_names
+        ):
+            _, resolved_artifact = await adapter.resolve_artifact_reference(environment, artifact_reference)
+            if resolved_artifact.execution and resolved_artifact.execution.requires.resources:
+                for resource in resolved_artifact.execution.requires.resources:
+                    table.add_row(
+                        [
+                            artifact_reference.project_name,
+                            artifact_reference.artifact_name,
+                            resource.resource_name,
+                            "STATUS",
+                        ]
+                    )
+
+    print(table.get_string())
+
+
+@list_cli.command("services")
+async def list_services(
+    project_names: Annotated[list[str] | None, typer.Option("--project", "-p", help="Specific project name.")] = None,
+    artifact_names: Annotated[
+        list[str] | None, typer.Option("--artifact", "-a", help="Specific artifact name.")
+    ] = None,
+    environment_names: Annotated[
+        list[str] | None, typer.Option("--environment", "-e", help="Specific environment name.")
+    ] = None,
+    include_remotes: Annotated[bool, typer.Option(help="Include remote environments.")] = False,
+):
+    table = prettytable.PrettyTable()
+    table.align = "l"
+
+    print(table.get_string())

ballista_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: ballista-cli
+Version: 0.1.0
+Summary: Ballista.build CLI
+Author-email: August Bigelow <dev@atbigelow.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: async-typer>=0.2.1
+Requires-Dist: ballista-sdk<0.2,>=0.1
+Requires-Dist: prettytable
+Requires-Dist: typer<0.26,>=0.25
+Description-Content-Type: text/markdown
+
+# Ballista.build CLI
+
+CLI for using Ballista.build
+
+## Commands
+
+- `init` - Create an initial ballista.yaml
+- `build` - Build the artifacts contained in a ballista.yaml
+- `up` - Execute project in local environment
+- `down` - Teardown project in local environment
+- `run` - Run a command with an Artifact context
+- `deploy` - Deploy to an environment
+- `list` - List various items from environments
+
+## Configuration
+
+`~/.ballista/defaults.yaml`

ballista_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+ballista_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ballista_cli/cli.py,sha256=Sp8qeFs86L0lNcKtd9BCClWJgbVHLNq-beWrL-RSH2Q,19556
+ballista_cli-0.1.0.dist-info/METADATA,sha256=CYMng0m6LrySxqCUSfjoAKCg9FWOJGHr6P27nAMMRpA,1102
+ballista_cli-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+ballista_cli-0.1.0.dist-info/entry_points.txt,sha256=FckQJh1fF4FC_3i7MNgUfKqaWYxn3pB-aDzMOFwBSew,50
+ballista_cli-0.1.0.dist-info/licenses/LICENSE,sha256=6nehCbDq6UrbI_AojHmZOQhXgcyaIEZTQECloF-FfGo,1116
+ballista_cli-0.1.0.dist-info/RECORD,,

ballista_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ballista_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ballista = ballista_cli.cli:cli

ballista_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 20236 August Trapper Bigelow and the ballista.build contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.