edge-containers-cli 3.5.4__tar.gz → 4.0.0__tar.gz

{edge_containers_cli-3.5.4 → edge_containers_cli-4.0.0}/.github/workflows/_release.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Create GitHub Release
         # We pin to the SHA, not the tag, for security reasons.
         # https://docs.github.com/en/actions/learn-github-actions/security-hardening-for-github-actions#using-third-party-actions
-        uses: softprops/action-gh-release@69320dbe05506a9a39fc8ae11030b214ec2d1f87 # v0.1.15
+        uses: softprops/action-gh-release@c062e08bd532815e2082a85e87e3ef29c3e6d191 # v0.1.15
         with:
           prerelease: ${{ contains(github.ref_name, 'a') || contains(github.ref_name, 'b') || contains(github.ref_name, 'rc') }}
           files: "*"

{edge_containers_cli-3.5.4 → edge_containers_cli-4.0.0}/.github/workflows/ci.yml

@@ -34,19 +34,6 @@ jobs:
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
-  system:
-    needs: check
-    if: needs.check.outputs.branch-pr == ''
-    strategy:
-      matrix:
-        runs-on: ["ubuntu-latest"]
-        python-version: ["3.12"]
-      fail-fast: false
-    uses: ./.github/workflows/_sys_test.yml
-    with:
-      runs-on: ${{ matrix.runs-on }}
-      python-version: ${{ matrix.python-version }}
-
   dist:
     needs: check
     if: needs.check.outputs.branch-pr == ''

{edge_containers_cli-3.5.4 → edge_containers_cli-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edge-containers-cli
-Version: 3.5.4
+Version: 4.0.0
 Summary: CLI for deploying and managing epics containers IOCs and services
 Author-email: Giles Knap <giles.knap@gmail.com>
 License:                                  Apache License
@@ -219,7 +219,7 @@ Requires-Dist: typer[all]
 Requires-Dist: requests
 Requires-Dist: ruamel.yaml
 Requires-Dist: jinja2
-Requires-Dist: polars
+Requires-Dist: polars-lts-cpu
 Requires-Dist: textual
 Provides-Extra: dev
 Requires-Dist: copier; extra == "dev"

{edge_containers_cli-3.5.4 → edge_containers_cli-4.0.0}/pyproject.toml

@@ -19,7 +19,7 @@ dependencies = [
     "requests",
     "ruamel.yaml",
     "jinja2",
-    "polars",
+    "polars-lts-cpu",
     "textual",
 ]
 

edge_containers_cli-4.0.0/src/edge_containers_cli/__init__.py

@@ -0,0 +1,13 @@
+import polars
+
+from ._version import __version__
+
+__all__ = ["__version__"]
+
+# Set formatting of polars tables
+polars.Config.set_tbl_hide_column_data_types(True)
+polars.Config.set_tbl_hide_dataframe_shape(True)
+polars.Config.set_tbl_rows(-1)
+polars.Config.set_tbl_cols(-1)
+polars.Config.set_fmt_str_lengths(82)
+polars.Config.set_tbl_formatting("ASCII_MARKDOWN")

edge_containers_cli-4.0.0/src/edge_containers_cli/__main__.py

@@ -0,0 +1,122 @@
+from typing import Optional
+
+import typer
+
+from edge_containers_cli.cli import cli
+from edge_containers_cli.definitions import ENV, ECBackends, ECContext, ECLogLevels
+
+from . import __version__
+from .backend import backend as ec_backend
+from .backend import init_backend
+from .logging import init_logging
+from .shell import init_shell
+from .utils import init_cleanup
+
+__all__ = ["main"]
+
+
+def version_callback(value: bool):
+    if value:
+        typer.echo(__version__)
+        raise typer.Exit()
+
+
+def backend_callback(ctx: typer.Context, backend: ECBackends):
+    init_backend(backend)
+    # Dynamically drop any method not implemented
+    not_implemented = [
+        mthd.replace("_", "-") for mthd in ec_backend.get_notimplemented()
+    ]
+    for command in not_implemented:
+        typer_commands = ctx.command.commands  # type: ignore
+        if command in typer_commands:
+            typer_commands.pop(command)
+
+    return backend.value
+
+
+@cli.callback()
+def main(
+    ctx: typer.Context,
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        callback=version_callback,
+        is_eager=True,
+        help="Log the version of ec and exit",
+    ),
+    repo: str = typer.Option(
+        ECContext().repo,
+        "-r",
+        "--repo",
+        help="Service instances repository",
+        envvar=ENV.repo.value,
+    ),
+    target: str = typer.Option(
+        ECContext().target,
+        "-t",
+        "--target",
+        help="K8S namespace or ARGOCD app-namespace/root-app",
+        envvar=ENV.target.value,
+    ),
+    backend: ECBackends = typer.Option(
+        ECBackends.ARGOCD,
+        "-b",
+        "--backend",
+        callback=backend_callback,
+        is_eager=True,
+        help="Backend to use",
+        envvar=ENV.backend.value,
+        expose_value=True,
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "-v",
+        "--verbose",
+        help="Print the commands we run",
+        envvar=ENV.verbose.value,
+        show_default=True,
+    ),
+    dryrun: bool = typer.Option(
+        False,
+        "--dryrun",
+        help="Print the commands we run without execution",
+        envvar=ENV.dryrun.value,
+        show_default=True,
+    ),
+    debug: bool = typer.Option(
+        False,
+        "-d",
+        "--debug",
+        help="Enable debug logging, retain temp files",
+        envvar=ENV.debug.value,
+        show_default=True,
+    ),
+    log_level: ECLogLevels = typer.Option(
+        ECLogLevels.WARNING,
+        help="Log level",
+        envvar=ENV.log_level.value,
+    ),
+    log_url: str = typer.Option(
+        ECContext().log_url,
+        help="Log url",
+        envvar=ENV.log_url.value,
+    ),
+):
+    """Edge Containers assistant CLI"""
+    init_logging(ECLogLevels.DEBUG if debug else log_level)
+    init_shell(verbose, dryrun)
+    init_cleanup(debug)
+
+    context = ECContext(
+        repo=repo,
+        target=target,
+        log_url=log_url,
+    )
+    ec_backend.set_context(context)
+
+
+# test with:
+#     python -m edge_containers_cli
+if __name__ == "__main__":
+    cli()

{edge_containers_cli-3.5.4 → edge_containers_cli-4.0.0}/src/edge_containers_cli/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.5.4'
-__version_tuple__ = version_tuple = (3, 5, 4)
+__version__ = version = '4.0.0'
+__version_tuple__ = version_tuple = (4, 0, 0)

edge_containers_cli-4.0.0/src/edge_containers_cli/autocomplete.py

@@ -0,0 +1,96 @@
+import urllib
+from pathlib import Path
+
+import typer
+
+import edge_containers_cli.globals as globals
+from edge_containers_cli.backend import backend as ec_backend
+from edge_containers_cli.cmds.commands import CommandError
+from edge_containers_cli.definitions import ECContext
+from edge_containers_cli.git import GitError, create_version_map
+from edge_containers_cli.shell import ShellError
+from edge_containers_cli.utils import cache_dict, new_workdir, read_cached_dict
+
+
+def url_encode(in_string: str) -> str:
+    return urllib.parse.quote(in_string, safe="")  # type: ignore
+
+
+def autocomplete_backend_init(ctx: typer.Context):
+    params = ctx.parent.params  # type: ignore
+    context = ECContext(
+        repo=params["repo"],
+        target=params["target"],
+        log_url=params["log_url"],
+    )
+    ec_backend.set_context(context)
+
+
+def fetch_service_graph(repo: str) -> dict:
+    version_map = read_cached_dict(
+        globals.CACHE_ROOT / url_encode(repo), globals.SERVICE_CACHE
+    )
+    if not version_map:
+        with new_workdir() as path:
+            version_map = create_version_map(
+                repo, Path(globals.SERVICES_DIR), path, shared=[globals.SHARED_VALUES]
+            )
+            cache_dict(
+                globals.CACHE_ROOT / url_encode(repo),
+                globals.SERVICE_CACHE,
+                version_map,
+            )
+
+    return version_map
+
+
+def avail_services(ctx: typer.Context) -> list[str]:
+    autocomplete_backend_init(ctx)
+
+    # This block prevents getting a stack trace during autocompletion
+    try:
+        services_graph = fetch_service_graph(ec_backend.commands.repo)
+        return list(services_graph.keys())
+    except (ShellError, CommandError) as e:
+        typer.echo(f"\n{e}", nl=False, err=True)
+        return []
+
+
+def avail_versions(ctx: typer.Context) -> list[str]:
+    autocomplete_backend_init(ctx)
+    service_name = ctx.params["service_name"]
+
+    # This block prevents getting a stack trace during autocompletion
+    try:
+        version_map = fetch_service_graph(ec_backend.commands.repo)
+        svc_versions = version_map[service_name]
+        return svc_versions
+    except KeyError:
+        typer.echo(f"\n{service_name} not found", nl=False, err=True)
+        return []
+    except (ShellError, CommandError, GitError) as e:
+        typer.echo(f"\n{e}", nl=False, err=True)
+        return []
+
+
+def force_plain_completion() -> list[str]:
+    """Forces filepath completion"""
+    return []
+
+
+def running_svc(ctx: typer.Context) -> list[str]:
+    autocomplete_backend_init(ctx)
+    try:
+        return ec_backend.commands._running_services()
+    except (CommandError, ShellError) as e:
+        typer.echo(f"\n{e}", nl=False, err=True)
+        return []
+
+
+def all_svc(ctx: typer.Context) -> list[str]:
+    autocomplete_backend_init(ctx)
+    try:
+        return ec_backend.commands._all_services()
+    except (CommandError, ShellError) as e:
+        typer.echo(f"\n{e}", nl=False, err=True)
+        return []

edge_containers_cli-4.0.0/src/edge_containers_cli/backend.py

@@ -0,0 +1,62 @@
+"""
+Manage a backend for the project
+"""
+
+from edge_containers_cli.cmds.argo_commands import ArgoCommands
+from edge_containers_cli.cmds.commands import Commands
+from edge_containers_cli.cmds.k8s_commands import K8sCommands
+from edge_containers_cli.definitions import ECBackends, ECContext
+from edge_containers_cli.utils import public_methods
+
+
+class BackendError(Exception):
+    pass
+
+
+class Backend:
+    def __init__(self) -> None:
+        self._value: ECBackends | None = None
+        self._cxt: ECContext | None = None
+        self._Commands: type | None = None
+        self._commands: Commands | None = None
+
+    @property
+    def commands(self):
+        if self._commands is None:
+            raise BackendError("Backend commands not constructed")
+        else:
+            return self._commands
+
+    def set_backend(self, backend: ECBackends):
+        self._value = backend
+        if backend == ECBackends.K8S:
+            self._Commands = K8sCommands
+        elif backend == ECBackends.ARGOCD:
+            self._Commands = ArgoCommands
+
+    def set_context(self, context: ECContext):
+        """
+        Construct the appropriate Commands class
+        """
+        if self._Commands is None:
+            pass
+        else:
+            self._cxt = context
+            self._commands = self._Commands(context)
+
+    def get_notimplemented(self) -> list[str]:
+        notimplemented = []
+        if self._Commands is None:
+            return []
+        else:
+            for command in public_methods(self._Commands):
+                if getattr(self._Commands, command) is getattr(Commands, command):
+                    notimplemented.append(command)
+        return notimplemented
+
+
+backend = Backend()
+
+
+def init_backend(set_backend: ECBackends):
+    backend.set_backend(set_backend)

edge_containers_cli-4.0.0/src/edge_containers_cli/cli.py

@@ -0,0 +1,270 @@
+import os
+from pathlib import Path
+
+import typer
+
+import edge_containers_cli.globals as globals
+from edge_containers_cli.autocomplete import (
+    all_svc,
+    avail_services,
+    avail_versions,
+    force_plain_completion,
+    running_svc,
+)
+from edge_containers_cli.backend import backend
+from edge_containers_cli.cmds.commands import CommandError
+from edge_containers_cli.definitions import ENV
+from edge_containers_cli.git import GitError, list_all, list_instances
+from edge_containers_cli.logging import log
+from edge_containers_cli.shell import ShellError
+
+
+def confirmation(message: str, yes: bool):
+    typer.echo(message)
+    if not (yes or typer.confirm("Are you sure?")):
+        raise typer.Abort()
+
+
+class ErrorHandlingTyper(typer.Typer):
+    def __call__(self, *args, **kwargs):
+        try:
+            super().__call__(*args, **kwargs)
+        except (CommandError, ShellError, GitError) as e:
+            log.error(e)
+            typer.Exit(1)
+
+
+cli = ErrorHandlingTyper(pretty_exceptions_show_locals=False)
+
+
+@cli.command()
+def attach(
+    service_name: str = typer.Argument(
+        ..., help="Name of the service to attach to", autocompletion=running_svc
+    ),
+):
+    """
+    Attach to the console of a live service
+    """
+    backend.commands.attach(service_name)
+
+
+@cli.command()
+def delete(
+    service_name: str = typer.Argument(
+        ..., help="Name of the service to delete", autocompletion=all_svc
+    ),
+    yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation prompt"),
+):
+    """
+    Remove a helm deployment from the cluster
+    """
+    confirmation(
+        f"Remove all versions of {service_name} from the target `{backend.commands.target}`",
+        yes,
+    )
+    backend.commands.delete(service_name)
+
+
+@cli.command()
+def deploy(
+    service_name: str = typer.Argument(
+        ..., help="Name of the service to deploy", autocompletion=avail_services
+    ),
+    version: str = typer.Argument(
+        ...,
+        help="Version tag of the service to deploy",
+        autocompletion=avail_versions,
+    ),
+    wait: bool = typer.Option(False, "--wait", help="Waits for readiness"),
+    yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation prompt"),
+    args: str = typer.Option(
+        "", help="Additional args for helm or docker, 'must be quoted'"
+    ),
+):
+    """
+    Pull an service helm chart version from the domain repo and deploy it to the cluster
+    """
+    confirmation(
+        f"Deploy {service_name.lower()} "
+        f"of version `{version}` to target `{backend.commands.target}`",
+        yes,
+    )
+    args = args if not wait else args + " --wait"
+    backend.commands.deploy(service_name, version, args)
+
+
+@cli.command()
+def deploy_local(
+    svc_instance: Path = typer.Argument(
+        ...,
+        help="folder of local service definition",
+        exists=True,
+        file_okay=False,
+        resolve_path=True,
+        autocompletion=force_plain_completion,
+    ),
+    yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation prompt"),
+    args: str = typer.Option("", help="Additional args for helm, 'must be quoted'"),
+):
+    """
+    Deploy a local service helm chart directly to the cluster with dated beta version
+    """
+    confirmation(
+        f"Deploy local {svc_instance.name.lower()} "
+        f"from {svc_instance} to target `{backend.commands.target}`",
+        yes,
+    )
+    backend.commands.deploy_local(svc_instance, args)
+
+
+@cli.command()
+def env():
+    """List all relevant environment variables"""
+    for var in ENV:
+        print(f"{var.value}={os.environ.get(var.value, 'Not Defined')}")
+
+
+@cli.command()
+def exec(
+    service_name: str = typer.Argument(
+        ...,
+        help="Name of the service container to run in",
+        autocompletion=running_svc,
+    ),
+):
+    """Execute a bash prompt in a running container"""
+    backend.commands.exec(service_name)
+
+
+@cli.command()
+def instances(
+    service_name: str = typer.Argument(
+        ..., help="Name of the service to inspect", autocompletion=avail_services
+    ),
+):
+    """List all versions of the specified service in the repository"""
+    print(
+        list_instances(
+            service_name,
+            backend.commands.repo,
+            Path(globals.SERVICES_DIR),
+            shared=[globals.SHARED_VALUES],
+        )
+    )
+
+
+@cli.command()
+def list():
+    """List all services available in the service repository"""
+    print(
+        list_all(
+            backend.commands.repo,
+            Path(globals.SERVICES_DIR),
+            shared=[globals.SHARED_VALUES],
+        )
+    )
+
+
+@cli.command()
+def log_history(
+    service_name: str = typer.Argument(
+        ...,
+        help="Name of the service to inspect",
+        autocompletion=all_svc,
+    ),
+):
+    """Open historical logs for an service"""
+    backend.commands.log_history(service_name)
+
+
+@cli.command()
+def logs(
+    service_name: str = typer.Argument(
+        ..., help="Name of the service to inspect", autocompletion=running_svc
+    ),
+    prev: bool = typer.Option(
+        False,
+        "--previous",
+        "-p",
+        help="Show log from the previous instance of the service",
+    ),
+):
+    """Show logs for current and previous instances of an service"""
+    backend.commands.logs(service_name, prev)
+
+
+@cli.command()
+def monitor(
+    running_only: bool = typer.Option(
+        False, "-r", "--running-only", help="list only services that are running"
+    ),
+):
+    """Open monitor TUI."""
+    from edge_containers_cli.cmds.monitor import (
+        MonitorApp,  # Lazy import for performace
+    )
+
+    app = MonitorApp(backend.commands, running_only)
+    app.run()
+
+
+@cli.command()
+def ps(
+    running_only: bool = typer.Option(
+        False, "-r", "--running-only", help="list only services that are running"
+    ),
+):
+    """List the services running in the current target"""
+    backend.commands.ps(running_only)
+
+
+@cli.command()
+def restart(
+    service_name: str = typer.Argument(
+        ..., help="Name of the container to restart", autocompletion=running_svc
+    ),
+):
+    """Restart a service"""
+    backend.commands.restart(service_name)
+
+
+@cli.command()
+def start(
+    service_name: str = typer.Argument(
+        ..., help="Name of the service container to start", autocompletion=all_svc
+    ),
+):
+    """Start a service"""
+    backend.commands.start(service_name)
+
+
+@cli.command()
+def stop(
+    service_name: str = typer.Argument(
+        ...,
+        help="Name of the service container to stop",
+        autocompletion=running_svc,
+    ),
+):
+    """Stop a service"""
+    backend.commands.stop(service_name)
+
+
+@cli.command()
+def template(
+    svc_instance: Path = typer.Argument(
+        ...,
+        help="folder of local service definition",
+        exists=True,
+        file_okay=False,
+        resolve_path=True,
+        autocompletion=force_plain_completion,
+    ),
+    args: str = typer.Option("", help="Additional args for helm, 'must be quoted'"),
+):
+    """
+    Print out the helm template generated from a local service instance
+    """
+    args = f"{args} --debug"
+    backend.commands.template(svc_instance, args)