edge-containers-cli 3.4.1__tar.gz → 3.5.1__tar.gz

{edge-containers-cli-3.4.1 → edge_containers_cli-3.5.1}/.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@9d7c94cfd0a1f3ed45544c887983e9fa900f0564 # v0.1.15
+        uses: softprops/action-gh-release@69320dbe05506a9a39fc8ae11030b214ec2d1f87 # 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.4.1 → edge_containers_cli-3.5.1}/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v4.6.0
     hooks:
       - id: check-added-large-files
       - id: check-yaml

{edge-containers-cli-3.4.1 → edge_containers_cli-3.5.1}/PKG-INFO

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

{edge-containers-cli-3.4.1 → edge_containers_cli-3.5.1}/pyproject.toml

@@ -20,6 +20,7 @@ dependencies = [
     "ruamel.yaml",
     "jinja2",
     "polars",
+    "textual",
 ]
 
 dynamic = ["version"]
@@ -74,11 +75,15 @@ testpaths = "src tests"
 
 [tool.coverage.run]
 data_file = "/tmp/edge_containers_cli.coverage"
+omit = ["src/edge_containers_cli/cmds/monitor.py"]
 
 [tool.coverage.paths]
 # Tests are run from installed location, map back to the src directory
 source = ["src", "**/site-packages/"]
 
+[tool.coverage.report]
+omit = ["src/edge_containers_cli/cmds/monitor.py"]
+
 # tox must currently be configured via an embedded ini string
 # See: https://github.com/tox-dev/tox/issues/999
 [tool.tox]

{edge-containers-cli-3.4.1 → edge_containers_cli-3.5.1}/src/edge_containers_cli/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.4.1'
-__version_tuple__ = version_tuple = (3, 4, 1)
+__version__ = version = '3.5.1'
+__version_tuple__ = version_tuple = (3, 5, 1)

{edge-containers-cli-3.4.1 → edge_containers_cli-3.5.1}/src/edge_containers_cli/autocomplete.py

@@ -12,7 +12,7 @@ import edge_containers_cli.globals as globals
 import edge_containers_cli.shell as shell
 from edge_containers_cli.cmds.k8s_commands import check_namespace
 from edge_containers_cli.docker import Docker
-from edge_containers_cli.git import create_svc_graph
+from edge_containers_cli.git import create_version_map
 from edge_containers_cli.logging import log
 from edge_containers_cli.utils import cleanup_temp
 
@@ -46,14 +46,14 @@ def read_cached_dict(cache_folder: str, cached_file: str) -> dict:
 
 
 def fetch_service_graph(beamline_repo: str) -> dict:
-    svc_graph = read_cached_dict(url_encode(beamline_repo), globals.IOC_CACHE)
-    if not svc_graph:
+    version_map = read_cached_dict(url_encode(beamline_repo), globals.IOC_CACHE)
+    if not version_map:
         tmp_dir = Path(tempfile.mkdtemp())
-        svc_graph = create_svc_graph(beamline_repo, tmp_dir)
-        cache_dict(url_encode(beamline_repo), globals.IOC_CACHE, svc_graph)
+        version_map = create_version_map(beamline_repo, tmp_dir)
+        cache_dict(url_encode(beamline_repo), globals.IOC_CACHE, version_map)
         cleanup_temp(tmp_dir)
 
-    return svc_graph
+    return version_map
 
 
 def avail_services(ctx: typer.Context) -> list[str]:
@@ -77,8 +77,8 @@ def avail_versions(ctx: typer.Context) -> list[str]:
 
     # This block prevents getting a stack trace during autocompletion
     try:
-        svc_graph = fetch_service_graph(beamline_repo)
-        svc_versions = svc_graph[service_name]
+        version_map = fetch_service_graph(beamline_repo)
+        svc_versions = version_map[service_name]
         return svc_versions
     except KeyError:
         log.error("IOC not found")

{edge-containers-cli-3.4.1 → edge_containers_cli-3.5.1}/src/edge_containers_cli/cmds/cli.py

@@ -15,28 +15,61 @@ from edge_containers_cli.autocomplete import (
 )
 from edge_containers_cli.cmds.k8s_commands import K8sCommands
 from edge_containers_cli.cmds.local_commands import LocalCommands
-from edge_containers_cli.git import create_svc_graph
+from edge_containers_cli.cmds.monitor import MonitorApp
+from edge_containers_cli.git import create_version_map
+from edge_containers_cli.globals import EC_K8S_NAMESPACE
 from edge_containers_cli.logging import log
 from edge_containers_cli.utils import cleanup_temp, drop_path
 
-cli = typer.Typer(pretty_exceptions_show_locals=False)
+
+class ErrorHandlingTyper(typer.Typer):
+    def __call__(self, *args, **kwargs):
+        try:
+            super().__call__(*args, **kwargs)
+        except NotImplementedError:
+            typer.echo("This function is not available for the current namespace")
+
+
+cli = ErrorHandlingTyper(pretty_exceptions_show_locals=False)
+
+
+def commands(ctx):
+    """
+    Construct the appropriate Commands class for the local or K8S namespace
+    """
+    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
+        commands = LocalCommands(ctx.obj)
+    else:
+        commands = K8sCommands(ctx.obj)
+
+    return commands
 
 
 @cli.command()
 def ps(
     ctx: typer.Context,
-    all: bool = typer.Option(
-        False, "-a", "--all", help="list stopped IOCs/services as well as running ones"
+    running_only: bool = typer.Option(
+        False, "-r", "--running-only", help="list only IOCs/services that are running"
     ),
     wide: bool = typer.Option(
         False, "--wide", "-w", help="use a wide format with additional fields"
     ),
 ):
     """List the IOCs/services running in the current namespace"""
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        LocalCommands(ctx.obj).ps(all, wide)
-    else:
-        K8sCommands(ctx.obj).ps(all, wide)
+    commands(ctx).ps(running_only, wide)
+
+
+@cli.command()
+def monitor(
+    ctx: typer.Context,
+    running_only: bool = typer.Option(
+        False, "-r", "--running-only", help="list only IOCs/services that are running"
+    ),
+):
+    """Open IOC monitor TUI."""
+    cmds = commands(ctx)
+    app = MonitorApp(EC_K8S_NAMESPACE, cmds, running_only)
+    app.run()
 
 
 @cli.command()
@@ -47,7 +80,7 @@ def env(
     ),
 ):
     """List all relevant environment variables"""
-    LocalCommands(ctx.obj).environment(verbose == verbose)
+    commands(ctx).environment(verbose == verbose)
 
 
 @cli.command()
@@ -60,10 +93,7 @@ def attach(
     """
     Attach to the console of a live service
     """
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        LocalCommands(ctx.obj, service_name).attach()
-    else:
-        K8sCommands(ctx.obj, service_name).attach()
+    commands(ctx).attach(service_name)
 
 
 @cli.command()
@@ -76,10 +106,7 @@ def delete(
     """
     Remove a helm deployment from the cluster
     """
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        LocalCommands(ctx.obj, service_name).delete()
-    else:
-        K8sCommands(ctx.obj, service_name).delete()
+    commands(ctx).delete(service_name)
 
 
 @cli.command()
@@ -99,10 +126,7 @@ def template(
     print out the helm template generated from a local service instance
     """
     args = f"{args} --debug"
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        typer.echo("Not applicable to local deployments")
-    else:
-        K8sCommands(ctx.obj).template(svc_instance, args)
+    commands(ctx).template(svc_instance, args)
 
 
 @cli.command()
@@ -123,11 +147,7 @@ def deploy_local(
     """
     Deploy a local IOC/service helm chart directly to the cluster with dated beta version
     """
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        LocalCommands(ctx.obj).deploy_local(svc_instance, yes, args)
-    else:
-        args = args if not wait else args + " --wait"
-        K8sCommands(ctx.obj).deploy_local(svc_instance, yes, args)
+    commands(ctx).deploy_local(svc_instance, yes, args)
 
 
 @cli.command()
@@ -149,14 +169,9 @@ def deploy(
     """
     Pull an IOC/service helm chart version from the domain repo and deploy it to the cluster
     """
+    args = args if not wait else args + " --wait"
     service_name = drop_path(service_name)
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        LocalCommands(ctx.obj, service_name).deploy(service_name, version, args)
-    else:
-        args = args if not wait else args + " --wait"
-        K8sCommands(ctx.obj, service_name, check=False).deploy(
-            service_name, version, args
-        )
+    commands(ctx).deploy(service_name, version, args)
 
 
 @cli.command()
@@ -165,11 +180,11 @@ def list(
 ):
     """List all IOCs/services available in the helm registry"""
     tmp_dir = Path(tempfile.mkdtemp())
-    svc_graph = create_svc_graph(ctx.obj.beamline_repo, tmp_dir)
-    svc_list = natsorted(svc_graph.keys())
-    log.debug(f"svc_graph = {svc_graph}")
+    version_map = create_version_map(ctx.obj.beamline_repo, tmp_dir)
+    svc_list = natsorted(version_map.keys())
+    log.debug(f"version_map = {version_map}")
 
-    versions = [natsorted(svc_graph[svc])[-1] for svc in svc_list]
+    versions = [natsorted(version_map[svc])[-1] for svc in svc_list]
     services_df = polars.from_dict({"name": svc_list, "version": versions})
     print(services_df)
 
@@ -185,9 +200,9 @@ def instances(
 ):
     """List all versions of the IOC/service available in the helm registry"""
     tmp_dir = Path(tempfile.mkdtemp())
-    svc_graph = create_svc_graph(ctx.obj.beamline_repo, tmp_dir)
+    version_map = create_version_map(ctx.obj.beamline_repo, tmp_dir)
     try:
-        svc_list = svc_graph[service_name]
+        svc_list = version_map[service_name]
     except KeyError:
         svc_list = []
 
@@ -208,14 +223,12 @@ def exec(
     ),
 ):
     """Execute a bash prompt in a running container"""
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        LocalCommands(ctx.obj, service_name).exec()
-    else:
-        K8sCommands(ctx.obj, service_name).exec()
+    commands(ctx).exec(service_name)
 
 
 @cli.command()
 def log_history(
+    ctx: typer.Context,
     service_name: str = typer.Argument(
         ...,
         help="Name of the IOC/service to inspect",
@@ -223,7 +236,7 @@ def log_history(
     ),
 ):
     """Open historical logs for an IOC/service"""
-    K8sCommands(None, service_name).log_history()
+    commands(ctx).log_history(service_name)
 
 
 @cli.command()
@@ -241,10 +254,7 @@ def logs(
     follow: bool = typer.Option(False, "--follow", "-f", help="Follow the log stream"),
 ):
     """Show logs for current and previous instances of an IOC/service"""
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        LocalCommands(ctx.obj, service_name).logs(prev, follow)
-    else:
-        K8sCommands(ctx.obj, service_name).logs(prev, follow)
+    commands(ctx).logs(service_name, prev, follow)
 
 
 @cli.command()
@@ -255,10 +265,7 @@ def restart(
     ),
 ):
     """Restart an IOC/service"""
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        LocalCommands(ctx.obj, service_name).restart()
-    else:
-        K8sCommands(ctx.obj, service_name).restart()
+    commands(ctx).restart(service_name)
 
 
 @cli.command()
@@ -270,10 +277,7 @@ def start(
 ):
     """Start an IOC/service"""
     log.debug("Starting IOC/service with LOCAL={ctx.obj.namespace == " "}")
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        LocalCommands(ctx.obj, service_name).start()
-    else:
-        K8sCommands(ctx.obj, service_name).start()
+    commands(ctx).start(service_name)
 
 
 @cli.command()
@@ -286,10 +290,7 @@ def stop(
     ),
 ):
     """Stop an IOC/service"""
-    if ctx.obj.namespace == globals.LOCAL_NAMESPACE:
-        LocalCommands(ctx.obj, service_name).stop()
-    else:
-        K8sCommands(ctx.obj, service_name).stop()
+    commands(ctx).stop(service_name)
 
 
 @cli.command()

edge_containers_cli-3.5.1/src/edge_containers_cli/cmds/commands.py

@@ -0,0 +1,86 @@
+import webbrowser
+from pathlib import Path
+
+import polars
+import typer
+
+import edge_containers_cli.globals as globals
+import edge_containers_cli.shell as shell
+from edge_containers_cli.logging import log
+
+
+class Commands:
+    """
+    A base class for K8SCommands and LocalCommands
+
+    Implements the common functionality but defers specialist functions to
+    the subclasss
+
+    Allows the CLI or the TUI to call functions without worrying about local
+    vs Kubernetes containers
+    """
+
+    def __init__(self, ctx: globals.Context):
+        self.namespace = ctx.namespace
+        self.beamline_repo = ctx.beamline_repo
+
+    def attach(self, service_name):
+        raise NotImplementedError
+
+    def delete(self, service_name):
+        raise NotImplementedError
+
+    def template(self, svc_instance: Path, args: str):
+        raise NotImplementedError
+
+    def deploy_local(self, svc_instance: Path, yes: bool, args: str):
+        raise NotImplementedError
+
+    def deploy(self, service_name: str, version: str, args: str):
+        raise NotImplementedError
+
+    def exec(self, service_name: str):
+        raise NotImplementedError
+
+    def logs(self, service_name: str, prev: bool, follow: bool, stdout: bool):
+        raise NotImplementedError
+
+    def restart(self, service_name: str):
+        raise NotImplementedError
+
+    def start(self, service_name: str):
+        raise NotImplementedError
+
+    def stop(self, service_name: str):
+        raise NotImplementedError
+
+    def get_services(self, running_only: bool) -> polars.DataFrame:
+        raise NotImplementedError
+
+    def ps(self, running_only: bool, wide: bool):
+        select_data = self.get_services(running_only)
+        if not wide:
+            select_data.drop_in_place("image")
+        print(select_data)
+
+    def environment(self, verbose: bool):
+        """
+        declare the environment settings for ec
+        """
+        ns = self.namespace
+
+        if ns == globals.LOCAL_NAMESPACE:
+            typer.echo("ioc commands deploy to the local docker/podman instance")
+        else:
+            typer.echo(f"ioc commands deploy to the {ns} namespace the K8S cluster")
+
+        typer.echo("\nEC environment variables:")
+        shell.run_command("env | grep '^EC_'", interactive=False, show=True)
+
+    def log_history(self, service_name):
+        if not globals.EC_LOG_URL:
+            log.error("EC_LOG_URL environment not set")
+            raise typer.Exit(1)
+
+        url = globals.EC_LOG_URL.format(service_name=service_name)
+        webbrowser.open(url)

{edge-containers-cli-3.4.1 → edge_containers_cli-3.5.1}/src/edge_containers_cli/cmds/helm.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from typing import Optional
 
 import typer
+from ruamel.yaml import YAML
 
 import edge_containers_cli.globals as globals
 import edge_containers_cli.shell as shell
@@ -92,15 +93,19 @@ class Helm:
 
         with chdir(service_folder):
             shell.run_command(
-                f"helm dependency update {service_folder}; "
-                f"helm package {service_folder} --app-version {self.version}",
+                f"helm package {service_folder} -u --app-version {self.version}",
                 interactive=False,
             )
-            # find the packaged chart
-            chart_file = list(service_folder.glob("*.tgz"))[0]
+
+            # Determine package name
+            with open("Chart.yaml") as fp:
+                chart_yaml = YAML(typ="safe").load(fp)
+            package_path = (
+                service_folder / f'{chart_yaml["name"]}-{chart_yaml["version"]}.tgz'
+            )
 
         # use helm to install the chart
-        self._install(chart_file)
+        self._install(package_path)
 
     def _install(self, helm_chart: Path):
         """

{edge-containers-cli-3.4.1 → edge_containers_cli-3.5.1}/src/edge_containers_cli/cmds/k8s_commands.py

@@ -4,17 +4,17 @@ implements commands for deploying and managing service instances in the k8s clus
 Relies on the Helm class for deployment aspects.
 """
 
-import webbrowser
 from datetime import datetime
 from io import StringIO
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Union
 
 import polars
 import typer
 
 import edge_containers_cli.globals as globals
 import edge_containers_cli.shell as shell
+from edge_containers_cli.cmds.commands import Commands
 from edge_containers_cli.cmds.helm import Helm
 from edge_containers_cli.cmds.kubectl import jsonpath_deploy_info, jsonpath_pod_info
 from edge_containers_cli.logging import log
@@ -59,43 +59,35 @@ def check_namespace(namespace: Optional[str]):
     log.info("domain = %s", namespace)
 
 
-class K8sCommands:
+class K8sCommands(Commands):
     """
     A class for implementing the Kubernetes based commands
     """
 
     def __init__(
         self,
-        ctx: Optional[globals.Context],
-        service_name: str = "",
-        check: bool = True,
+        ctx: globals.Context,
+        # check: bool = True,
     ):
-        self.namespace: str = ""
-        self.beamline_repo: str = ""
-        # TODO isnt ctx always set??
-        if ctx is not None:
-            namespace = ctx.namespace
-            check_namespace(namespace)
-            if service_name != "" and check:
-                self.fullname = check_service(service_name, namespace)
-            self.namespace = namespace
-            self.beamline_repo = ctx.beamline_repo
-        self.service_name: str = service_name
-
-    def attach(self):
+        super().__init__(ctx)
+        check_namespace(self.namespace)
+
+    def attach(self, service_name):
+        fullname = check_service(service_name, self.namespace)
         shell.run_command(
-            f"kubectl -it -n {self.namespace} attach {self.fullname}",
+            f"kubectl -it -n {self.namespace} attach {fullname}",
             interactive=True,
         )
 
-    def delete(self):
+    def delete(self, service_name):
+        check_service(service_name, self.namespace)
         if not typer.confirm(
-            f"This will remove all versions of {self.service_name} "
+            f"This will remove all versions of {service_name} "
             "from the cluster. Are you sure ?"
         ):
             raise typer.Abort()
 
-        shell.run_command(f"helm delete -n {self.namespace} {self.service_name}")
+        shell.run_command(f"helm delete -n {self.namespace} {service_name}")
 
     def template(self, svc_instance: Path, args: str):
         datetime.strftime(datetime.now(), "%Y.%-m.%-d-b%-H.%-M")
@@ -127,48 +119,48 @@ class K8sCommands:
         )
         chart.deploy()
 
-    def exec(self):
-        shell.run_command(
-            f"kubectl -it -n {self.namespace} exec {self.fullname} -- bash"
-        )
-
-    def log_history(self):
-        if not globals.EC_LOG_URL:
-            log.error("EC_LOG_URL environment not set")
-            raise typer.Exit(1)
-
-        url = globals.EC_LOG_URL.format(service_name=self.service_name)
-        webbrowser.open(url)
+    def exec(self, service_name):
+        fullname = check_service(service_name, self.namespace)
+        shell.run_command(f"kubectl -it -n {self.namespace} exec {fullname} -- bash")
 
-    def logs(self, prev: bool, follow: bool):
+    def logs(
+        self, service_name: str, prev: bool, follow: bool, stdout: bool = False
+    ) -> Optional[Union[str, bool]]:
+        fullname = check_service(service_name, self.namespace)
         previous = "-p" if prev else ""
         fol = "-f" if follow else ""
 
-        shell.run_command(
-            f"kubectl -n {self.namespace} logs {self.fullname} {previous} {fol}"
-        )
+        if stdout:
+            a = shell.run_command(
+                f"kubectl -n {self.namespace} logs {fullname} {previous} {fol}",
+                interactive=False,
+                show=False,
+                error_OK=True,
+            )
+            return a
+        else:
+            shell.run_command(
+                f"kubectl -n {self.namespace} logs {fullname} {previous} {fol}",
+            )
 
-    def restart(self):
+    def restart(self, service_name):
+        check_service(service_name, self.namespace)
         pod_name = shell.run_command(
-            f"kubectl get -n {self.namespace} pod -l app={self.service_name} -o name",
+            f"kubectl get -n {self.namespace} pod -l app={service_name} -o name",
             interactive=False,
         )
         shell.run_command(f"kubectl delete -n {self.namespace} {pod_name}")
 
-    def start(self):
-        shell.run_command(
-            f"kubectl scale -n {self.namespace} {self.fullname} --replicas=1"
-        )
+    def start(self, service_name):
+        fullname = check_service(service_name, self.namespace)
+        shell.run_command(f"kubectl scale -n {self.namespace} {fullname} --replicas=1")
 
-    def stop(self):
+    def stop(self, service_name):
+        fullname = check_service(service_name, self.namespace)
         """Stop an IOC"""
-        shell.run_command(
-            f"kubectl scale -n {self.namespace} {self.fullname} --replicas=0 "
-        )
-
-    def ps(self, all: bool, wide: bool):
-        """List all IOCs and Services in the current namespace"""
+        shell.run_command(f"kubectl scale -n {self.namespace} {fullname} --replicas=0 ")
 
+    def get_services(self, running_only: bool) -> polars.DataFrame:
         services_df = polars.DataFrame()
 
         # Gives all services (running & not running) and their image
@@ -207,7 +199,7 @@ class K8sCommands:
                 polars.col("running").replace({"Running": True}, default=False),
                 polars.col("restarts").fill_null(0),
             )
-        elif all:
+        elif not running_only:
             services_df = services_df.with_columns(
                 running=polars.lit(False), restarts=polars.lit(0)
             )
@@ -229,9 +221,14 @@ class K8sCommands:
         services_df = services_df.select(
             ["name", "version", "running", "restarts", "deployed", "image"]
         )
-        if not all:
+        if running_only:
             services_df = services_df.filter(polars.col("running").eq(True))
             log.debug(services_df)
+        return services_df
+
+    def ps(self, running_only: bool, wide: bool):
+        """List all IOCs and Services in the current namespace"""
+        services_df = self.get_services(running_only)
         if not wide:
             services_df.drop_in_place("image")
             log.debug(services_df)