edge-containers-cli 4.0.0__tar.gz → 4.1.1b0__tar.gz

edge_containers_cli-4.1.1b0/.github/workflows/_container.yml

@@ -0,0 +1,51 @@
+on:
+  workflow_call:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          # Need this to get version number from last tag
+          fetch-depth: 0
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GitHub Docker Registry
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and export to Docker local cache
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          target: server
+
+      - name: Create tags for publishing image
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/${{ github.repository }}
+          tags: |
+            type=ref,event=tag
+            type=raw,value=latest
+
+      - name: Push cached image to container registry
+        if: github.ref_type == 'tag'
+        uses: docker/build-push-action@v5
+        # This does not build the image again, it will find the image in the
+        # Docker cache and publish it
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

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

@@ -34,6 +34,13 @@ jobs:
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
+  container:
+    needs: check
+    if: needs.check.outputs.branch-pr == ''
+    uses: ./.github/workflows/_container.yml
+    permissions:
+      packages: write
+
   dist:
     needs: check
     if: needs.check.outputs.branch-pr == ''

edge_containers_cli-4.1.1b0/Dockerfile

@@ -0,0 +1,29 @@
+# The devcontainer should use the developer target and run as root with podman
+# or docker with user namespaces.
+ARG PYTHON_VERSION=3.11
+FROM python:${PYTHON_VERSION} as developer
+
+# Add any system dependencies for the developer/build environment here
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    graphviz \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set up a virtual environment and put it in PATH
+RUN python -m venv /venv
+ENV PATH=/venv/bin:$PATH
+
+# The build stage installs the context into the venv
+FROM developer as build
+COPY . /context
+WORKDIR /context
+RUN pip install .
+
+# The runtime stage copies the built venv into a slim runtime container
+FROM python:${PYTHON_VERSION}-slim as server
+# Add apt-get system dependecies for runtime here if needed
+COPY --from=build /venv/ /venv/
+ENV PATH=/venv/bin:$PATH
+RUN pip install textual-dev
+
+# change this entrypoint if it is not the same as the repo
+ENTRYPOINT ["textual", "serve"]  # Usage: "ec -b DEMO monitor" -p 8081

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edge-containers-cli
-Version: 4.0.0
+Version: 4.1.1b0
 Summary: CLI for deploying and managing epics containers IOCs and services
 Author-email: Giles Knap <giles.knap@gmail.com>
 License:                                  Apache License

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/src/edge_containers_cli/__main__.py

@@ -23,15 +23,22 @@ def version_callback(value: bool):
 
 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()
+        mthd.replace("_", "-") for mthd in ec_backend.get_notimplemented_cmds()
     ]
+    typer_commands = ctx.command.commands  # type: ignore
     for command in not_implemented:
-        typer_commands = ctx.command.commands  # type: ignore
         if command in typer_commands:
             typer_commands.pop(command)
 
+    # Dynamically drop any cli options as specified
+    for cmd_name, drop_params in ec_backend.get_notimplemented_params().items():
+        for index, param in enumerate(typer_commands[cmd_name].params):
+            if param.name in drop_params:
+                typer_commands[cmd_name].params.pop(index)
+
     return backend.value
 
 

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/src/edge_containers_cli/_version.py

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

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/src/edge_containers_cli/backend.py

@@ -4,6 +4,7 @@ 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.demo_commands import DemoCommands
 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
@@ -20,6 +21,13 @@ class Backend:
         self._Commands: type | None = None
         self._commands: Commands | None = None
 
+    @property
+    def Commands(self):
+        if self._Commands is None:
+            raise BackendError("Backend commands not set")
+        else:
+            return self._Commands
+
     @property
     def commands(self):
         if self._commands is None:
@@ -29,10 +37,13 @@ class Backend:
 
     def set_backend(self, backend: ECBackends):
         self._value = backend
-        if backend == ECBackends.K8S:
-            self._Commands = K8sCommands
-        elif backend == ECBackends.ARGOCD:
-            self._Commands = ArgoCommands
+        match backend:
+            case ECBackends.DEMO:
+                self._Commands = DemoCommands
+            case ECBackends.K8S:
+                self._Commands = K8sCommands
+            case ECBackends.ARGOCD:
+                self._Commands = ArgoCommands
 
     def set_context(self, context: ECContext):
         """
@@ -44,7 +55,7 @@ class Backend:
             self._cxt = context
             self._commands = self._Commands(context)
 
-    def get_notimplemented(self) -> list[str]:
+    def get_notimplemented_cmds(self) -> list[str]:
         notimplemented = []
         if self._Commands is None:
             return []
@@ -54,6 +65,9 @@ class Backend:
                     notimplemented.append(command)
         return notimplemented
 
+    def get_notimplemented_params(self) -> dict[str, list[str]]:
+        return self.Commands.params_opt_out
+
 
 backend = Backend()
 

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/src/edge_containers_cli/cli.py

@@ -234,9 +234,14 @@ def start(
     service_name: str = typer.Argument(
         ..., help="Name of the service container to start", autocompletion=all_svc
     ),
+    temp: bool = typer.Option(False, help="Directly overrides the controller values"),
 ):
     """Start a service"""
-    backend.commands.start(service_name)
+    try:
+        backend.commands.start(service_name, temp)
+    except GitError as e:
+        msg = f"{str(e)} - Try 'ec start <service> --temp' to bypass the git server"
+        raise GitError(msg) from e
 
 
 @cli.command()
@@ -246,9 +251,14 @@ def stop(
         help="Name of the service container to stop",
         autocompletion=running_svc,
     ),
+    temp: bool = typer.Option(False, help="Directly overrides the controller values"),
 ):
     """Stop a service"""
-    backend.commands.stop(service_name)
+    try:
+        backend.commands.stop(service_name, temp)
+    except GitError as e:
+        msg = f"{str(e)} - Try ec stop <service> --temp to bypass the git server"
+        raise GitError(msg) from e
 
 
 @cli.command()

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/src/edge_containers_cli/cmds/argo_commands.py

@@ -6,12 +6,14 @@ Relies on the Helm class for deployment aspects.
 
 import webbrowser
 from datetime import datetime
+from pathlib import Path
 
 import polars
 from ruamel.yaml import YAML
 
 from edge_containers_cli.cmds.commands import CommandError, Commands, ServicesDataFrame
 from edge_containers_cli.definitions import ECContext
+from edge_containers_cli.git import set_values
 from edge_containers_cli.globals import TIME_FORMAT
 from edge_containers_cli.shell import ShellError, shell
 
@@ -21,6 +23,36 @@ def extract_ns_app(target: str) -> tuple[str, str]:
     return namespace, app
 
 
+def patch_value(target: str, key: str, value: str | bool | int):
+    cmd_temp_ = f"argocd app set {target} -p {key}={value}"
+    shell.run_command(cmd_temp_, skip_on_dryrun=True)
+    cmd_sync = f"argocd app sync {target} --apply-out-of-sync-only"
+    shell.run_command(cmd_sync, skip_on_dryrun=True)
+
+
+def push_value(target: str, key: str, value: str | bool | int):
+    # Get source details
+    app_resp = shell.run_command(
+        f"argocd app get {target} -o yaml",
+    )
+    app_dicts = YAML(typ="safe").load(app_resp)
+    repo_url = app_dicts["spec"]["source"]["repoURL"]
+    path = Path(app_dicts["spec"]["source"]["path"])
+
+    set_values(
+        repo_url,
+        path / "values.yaml",
+        key,
+        value,
+    )
+
+    # Sync & release a possible patched value
+    cmd_sync = f"argocd app sync {target} --apply-out-of-sync-only"
+    shell.run_command(cmd_sync, skip_on_dryrun=True)
+    cmd_unset = f"argocd app unset {target} -p {key}"
+    shell.run_command(cmd_unset, skip_on_dryrun=True)
+
+
 class ArgoCommands(Commands):
     """
     A class for implementing the Kubernetes based commands
@@ -52,17 +84,19 @@ class ArgoCommands(Commands):
         )
         shell.run_command(cmd, skip_on_dryrun=True)
 
-    def start(self, service_name):
+    def start(self, service_name, temp):
         self._check_service(service_name)
-        namespace, app = extract_ns_app(self.target)
-        cmd = f"argocd app set {namespace}/{service_name} -p global.enabled=true"
-        shell.run_command(cmd, skip_on_dryrun=True)
+        if temp:
+            patch_value(self.target, f"ec_services.{service_name}.enabled", True)
+        else:
+            push_value(self.target, f"ec_services.{service_name}.enabled", True)
 
-    def stop(self, service_name):
+    def stop(self, service_name, temp):
         self._check_service(service_name)
-        namespace, app = extract_ns_app(self.target)
-        cmd = f"argocd app set {namespace}/{service_name} -p global.enabled=false"
-        shell.run_command(cmd, skip_on_dryrun=True)
+        if temp:
+            patch_value(self.target, f"ec_services.{service_name}.enabled", False)
+        else:
+            push_value(self.target, f"ec_services.{service_name}.enabled", False)
 
     def _get_logs(self, service_name, prev) -> str:
         namespace, app = extract_ns_app(self.target)

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/src/edge_containers_cli/cmds/commands.py

@@ -39,6 +39,8 @@ class Commands(ABC):
     Methods not exposed to the CLI should be private
     """
 
+    params_opt_out: dict[str, list[str]] = {}
+
     def __init__(self, ctx: ECContext):
         self._target = ctx.target
         self._target_valid = False
@@ -72,50 +74,50 @@ class Commands(ABC):
             log.debug("log_url = %s", self._log_url)
             return self._log_url
 
-    def attach(self, service_name: str):
+    def attach(self, service_name: str) -> None:
         raise NotImplementedError
 
-    def delete(self, service_name: str):
+    def delete(self, service_name: str) -> None:
         raise NotImplementedError
 
-    def deploy(self, service_name: str, version: str, args: str):
+    def deploy(self, service_name: str, version: str, args: str) -> None:
         raise NotImplementedError
 
-    def deploy_local(self, svc_instance: Path, args: str):
+    def deploy_local(self, svc_instance: Path, args: str) -> None:
         raise NotImplementedError
 
-    def exec(self, service_name: str):
+    def exec(self, service_name: str) -> None:
         raise NotImplementedError
 
-    def logs(self, service_name: str, prev: bool):
+    def logs(self, service_name: str, prev: bool) -> None:
         raise NotImplementedError
 
-    def log_history(self, service_name: str):
+    def log_history(self, service_name: str) -> None:
         raise NotImplementedError
 
-    def ps(self, running_only: bool):
+    def ps(self, running_only: bool) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def restart(self, service_name: str):
+    def restart(self, service_name: str) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def start(self, service_name: str):
+    def start(self, service_name: str, temp: bool) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def stop(self, service_name: str):
+    def stop(self, service_name: str, temp: bool) -> None:
         raise NotImplementedError
 
-    def template(self, svc_instance: Path, args: str):
+    def template(self, svc_instance: Path, args: str) -> None:
         raise NotImplementedError
 
     @abstractmethod
     def _get_services(self, running_only: bool) -> ServicesDataFrame:
         raise NotImplementedError
 
-    def _ps(self, running_only: bool):
+    def _ps(self, running_only: bool) -> None:
         services_df = self._get_services(running_only)
         print(services_df)
 
@@ -123,19 +125,19 @@ class Commands(ABC):
     def _get_logs(self, service_name: str, prev: bool) -> str:
         raise NotImplementedError
 
-    def _logs(self, service_name: str, prev: bool):
+    def _logs(self, service_name: str, prev: bool) -> None:
         print(self._get_logs(service_name, prev))
 
-    def _validate_target(self):
+    def _validate_target(self) -> None:
         raise NotImplementedError
 
-    def _running_services(self):
+    def _running_services(self) -> list[str]:
         return self._get_services(running_only=True)["name"].to_list()
 
-    def _all_services(self):
+    def _all_services(self) -> list[str]:
         return self._get_services(running_only=False)["name"].to_list()
 
-    def _check_service(self, service_name: str):
+    def _check_service(self, service_name: str) -> None:
         services_list = self._get_services(running_only=False)["name"]
         if service_name in services_list:
             pass

edge_containers_cli-4.1.1b0/src/edge_containers_cli/cmds/demo_commands.py

@@ -0,0 +1,135 @@
+"""
+implements commands for deploying and managing service instances suing argocd
+
+Relies on the Helm class for deployment aspects.
+"""
+
+import time
+from datetime import datetime
+
+import polars
+
+from edge_containers_cli.cmds.commands import CommandError, Commands, ServicesDataFrame
+from edge_containers_cli.definitions import ECContext
+from edge_containers_cli.globals import TIME_FORMAT
+
+DELAY = 0.0
+
+
+def process_t(time_string) -> str:
+    time_stamp = datetime.strptime(time_string, "%Y-%m-%dT%H:%M:%SZ")
+    return datetime.strftime(time_stamp, TIME_FORMAT)
+
+
+sample_data = {
+    "name": ["demo-ea-01", "demo-ea-02", "demo-ea-03"],  # type: ignore
+    "version": ["2024.10.1", "2024.10.1b", "2024.10.1"],
+    "ready": [True, True, False],
+    "deployed": [
+        process_t("2024-10-22T11:23:10Z"),
+        process_t("2024-10-28T14:53:55Z"),
+        process_t("2024-10-22T12:51:50Z"),
+    ],
+}
+sample_ServicesDataFrame = ServicesDataFrame(polars.from_dict(sample_data))
+
+
+def demo_wrapper():
+    """Using closure to display once"""
+    called = False
+
+    def decorator(function):
+        """Called selectively to avoid breaking autocompletion"""
+
+        def wrapper(*args, **kwargs):
+            nonlocal called
+            if not called:
+                called = True
+                print("***RUNNING IN DEMO MODE***")
+            return function(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+demo_message = demo_wrapper()
+
+
+class DemoCommands(Commands):
+    """
+    A class for implementing the Kubernetes based commands
+    """
+
+    def __init__(
+        self,
+        ctx: ECContext,
+    ):
+        self._target = "Demo Beamline"
+        self._target_valid = False
+        self._stateDF = sample_ServicesDataFrame
+
+    @demo_message
+    def logs(self, service_name, prev):
+        self._logs(service_name, prev)
+
+    @demo_message
+    def log_history(self, service_name):
+        pass
+
+    @demo_message
+    def ps(self, running_only):
+        self._ps(running_only)
+
+    @demo_message
+    def restart(self, service_name):
+        self.stop(service_name, False)
+        self.start(service_name, False)
+
+    @demo_message
+    def start(self, service_name, temp):
+        self._check_service(service_name)
+        time.sleep(DELAY)
+        self._stateDF = self._stateDF.with_columns(
+            polars.when(polars.col("name") == service_name)
+            .then(True)
+            .otherwise(polars.col("ready"))
+            .alias("ready")
+        )
+
+    @demo_message
+    def stop(self, service_name, temp):
+        self._check_service(service_name)
+        time.sleep(DELAY)
+        self._stateDF = self._stateDF.with_columns(
+            polars.when(polars.col("name") == service_name)
+            .then(False)
+            .otherwise(polars.col("ready"))
+            .alias("ready")
+        )
+
+    def _get_logs(self, service_name, prev) -> str:
+        self._check_service(service_name)
+        logs_list = ["Lorem ipsum dolor sit amet"] * 25
+        return "\n".join(logs_list)
+
+    def _get_services(self, running_only) -> ServicesDataFrame:
+        if running_only:
+            return ServicesDataFrame(self._stateDF.filter(polars.col("ready").eq(True)))
+        else:
+            return ServicesDataFrame(self._stateDF)
+
+    def _check_service(self, service_name: str):
+        """
+        validate that there is a app with the given service_name
+        """
+        services_list = self._get_services(running_only=False)["name"]
+        if service_name in services_list:
+            pass
+        else:
+            raise CommandError(
+                f"Service '{service_name}' not found in '{self._target}'"
+            )
+
+    def _validate_target(self):
+        pass

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/src/edge_containers_cli/cmds/k8s_commands.py

@@ -23,6 +23,11 @@ class K8sCommands(Commands):
     A class for implementing the Kubernetes based commands
     """
 
+    params_opt_out = {
+        "stop": ["temp"],
+        "start": ["temp"],
+    }
+
     def __init__(
         self,
         ctx: ECContext,
@@ -84,14 +89,14 @@ class K8sCommands(Commands):
             f"kubectl delete -n {self.target} {pod_name}", skip_on_dryrun=True
         )
 
-    def start(self, service_name):
+    def start(self, service_name, temp):
         self._check_service(service_name)
         shell.run_command(
             f"kubectl scale -n {self.target} statefulset {service_name} --replicas=1",
             skip_on_dryrun=True,
         )
 
-    def stop(self, service_name):
+    def stop(self, service_name, temp):
         self._check_service(service_name)
         shell.run_command(
             f"kubectl scale -n {self.target} statefulset {service_name} --replicas=0 ",

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/src/edge_containers_cli/cmds/monitor.py

@@ -385,7 +385,7 @@ class MonitorApp(App):
         Binding("r", "restart_ioc", "Restart IOC"),
         Binding("l", "ioc_logs", "IOC Logs"),
         Binding("o", "sort", "Sort"),
-        # Binding("d", "toggle_dark", "Toggle dark mode"),
+        Binding("d", "toggle_dark", "Toggle dark mode"),
     ]
 
     def __init__(
@@ -446,7 +446,7 @@ class MonitorApp(App):
         def check_start(start: bool | None) -> None:
             """Called when StartScreen is dismissed."""
             if start:
-                self.commands.start(service_name)
+                self.commands.start(service_name, False)
 
         self.push_screen(StartScreen(service_name), check_start)
 
@@ -457,7 +457,7 @@ class MonitorApp(App):
         def check_stop(stop: bool | None) -> None:
             """Called when StopScreen is dismissed."""
             if stop:
-                self.commands.stop(service_name)
+                self.commands.stop(service_name, False)
 
         self.push_screen(StopScreen(service_name), check_stop)
 

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/src/edge_containers_cli/definitions.py

@@ -5,6 +5,7 @@ from enum import Enum
 class ECBackends(str, Enum):
     ARGOCD = "ARGOCD"
     K8S = "K8S"
+    DEMO = "DEMO"
 
 
 class ECLogLevels(str, Enum):

{edge_containers_cli-4.0.0 → edge_containers_cli-4.1.1b0}/src/edge_containers_cli/git.py

@@ -9,14 +9,40 @@ import polars
 from natsort import natsorted
 
 from edge_containers_cli.logging import log
-from edge_containers_cli.shell import shell
-from edge_containers_cli.utils import chdir, new_workdir
+from edge_containers_cli.shell import ShellError, shell
+from edge_containers_cli.utils import YamlFile, chdir, new_workdir
 
 
 class GitError(Exception):
     pass
 
 
+def set_values(repo_url: str, file: Path, key: str, value: str | bool | int) -> None:
+    """
+    sets an existing key value pair in a yaml file and push the changes
+    """
+    with new_workdir() as path:
+        try:
+            shell.run_command(f"git clone --depth=1 {repo_url} {path}")
+            with chdir(path):  # From python 3.11 can use contextlib.chdir(working_dir)
+                file_data = YamlFile(file)
+
+                value_repo = file_data.get_key(key)
+                if value_repo == value:
+                    log.debug(f"{key} already set as {value}")
+                else:
+                    file_data.set_key(key, value)
+                    file_data.dump_file()
+
+                    commit_msg = f"Set {key}={value} in {file}"
+                    shell.run_command("git add .")
+                    shell.run_command(f'git commit -m "{commit_msg}"')
+                    shell.run_command("git push", skip_on_dryrun=True)
+
+        except (FileNotFoundError, ShellError) as e:
+            raise GitError(str(e)) from e
+
+
 def create_version_map(
     repo: str, root_dir: Path, working_dir: Path, shared: list[str] | None = None
 ) -> dict[str, list[str]]: