kaqing 2.0.14__py3-none-any.whl → 2.0.145__py3-none-any.whl

adam/commands/cql/cql_completions.py

@@ -0,0 +1,28 @@
+from adam.commands.cql.cql_utils import cassandra_keyspaces, cassandra_table_names
+from adam.commands.export.exporter import Exporter
+from adam.commands.export.export_databases import ExportDatabases
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.sql.sql_completer import SqlCompleter, SqlVariant
+
+def cql_completions(state: ReplState) -> dict[str, any]:
+    ps = Config().get('cql.alter-tables.gc-grace-periods', '3600,86400,864000,7776000').split(',')
+    # warm up caches
+    cassandra_keyspaces(state)
+    cassandra_table_names(state)
+    ExportDatabases.database_names()
+
+    expandables = {
+        'keyspaces': lambda: cassandra_keyspaces(state),
+        'table-props': lambda: {
+            'GC_GRACE_SECONDS': ps
+        },
+        'export-dbs': lambda: ExportDatabases.database_names(),
+        'export-sessions': lambda: Exporter.export_session_names(state.sts, state.pod, state.namespace),
+        'export-sessions-incomplete': lambda: Exporter.export_session_names(state.sts, state.pod, state.namespace, export_state='pending_import'),
+    }
+
+    return SqlCompleter(
+        lambda: cassandra_table_names(state),
+        expandables=expandables,
+        variant=SqlVariant.CQL).completions_for_nesting()

adam/commands/cql/cql_utils.py

@@ -0,0 +1,209 @@
+import functools
+import re
+
+from adam.config import Config
+from adam.utils_k8s.cassandra_clusters import CassandraClusters
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.secrets import Secrets
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState
+from adam.utils import log2
+
+@functools.lru_cache()
+def cassandra_keyspaces(state: ReplState, on_any=True):
+    if state.pod:
+        Config().wait_log(f'Inspecting Cassandra Keyspaces on {state.pod}...')
+    else:
+        Config().wait_log(f'Inspecting Cassandra Keyspaces...')
+
+    r: list[PodExecResult] = run_cql(state, 'describe keyspaces', show_out=False, on_any=on_any)
+    if not r:
+        log2('No pod is available')
+        return []
+
+    return parse_cql_desc_keyspaces(r.stdout if state.pod else r[0].stdout)
+
+def cassandra_table_names(state: ReplState, keyspace = None):
+    return [f'{k}.{t}' for k, ts in cassandra_tables(state, on_any=True).items() for t in ts if not keyspace or keyspace == '*' or k == keyspace]
+
+@functools.lru_cache()
+def cassandra_tables(state: ReplState, on_any=False) -> dict[str, list[str]]:
+    r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=on_any)
+    if not r:
+        log2('No pod is available')
+        return {}
+
+    return parse_cql_desc_tables(r.stdout if state.pod else r[0].stdout)
+
+@functools.lru_cache()
+def table_spec(state: ReplState, table: str, on_any=False) -> 'TableSpec':
+    r: list[PodExecResult] = run_cql(state, f'describe table {table}', show_out=False, on_any=on_any)
+    if not r:
+        log2('No pod is available')
+        return None
+
+    return parse_cql_desc_table(r.stdout if state.pod else r[0].stdout)
+
+def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_single_quotes = False, on_any = False, background=False, log_file=None) -> list[PodExecResult]:
+    user, pw = Secrets.get_user_pass(state.sts if state.sts else state.pod, state.namespace, secret_path='cql.secret')
+    if use_single_quotes:
+        command = f"cqlsh -u {user} -p {pw} {' '.join(opts)} -e '{cql}'"
+    else:
+        command = f'cqlsh -u {user} -p {pw} {" ".join(opts)} -e "{cql}"'
+
+    if state.pod:
+        return CassandraNodes.exec(state.pod, state.namespace, command, show_out=show_out, background=background, log_file=log_file)
+    else:
+        return CassandraClusters.exec(state.sts, state.namespace, command, show_out=show_out, action='cql', on_any=on_any, background=background, log_file=log_file)
+
+def parse_cql_desc_tables(out: str):
+    # Keyspace data_endpoint_auth
+    # ---------------------------
+    # "token"
+
+    # Keyspace reaper_db
+    # ------------------
+    # repair_run                     schema_migration
+    # repair_run_by_cluster          schema_migration_leader
+
+    # Keyspace system
+    tables_by_keyspace: dict[str, list[str]] = {}
+    keyspace = None
+    state = 's0'
+    for line in out.split('\n'):
+        if state == 's0':
+            groups = re.match(r'^Keyspace (.*)$', line)
+            if groups:
+                keyspace = groups[1].strip(' \r')
+                state = 's1'
+        elif state == 's1':
+            if line.startswith('---'):
+                state = 's2'
+        elif state == 's2':
+            if not line.strip(' \r'):
+                state = 's0'
+            else:
+                for table in line.split(' '):
+                    if t := table.strip(' \r'):
+                        if not keyspace in tables_by_keyspace:
+                            tables_by_keyspace[keyspace] = []
+                        tables_by_keyspace[keyspace].append(t)
+
+    return tables_by_keyspace
+
+def parse_cql_desc_keyspaces(out: str) -> list[str]:
+    #
+    # Warning: Cannot create directory at `/home/cassandra/.cassandra`. Command history will not be saved. Please check what was the environment property CQL_HISTORY set to.
+    #
+    #
+    # Warning: Using a password on the command line interface can be insecure.
+    # Recommendation: use the credentials file to securely provide the password.
+    #
+    #
+    # azops88_db  system_auth         system_traces
+    # reaper_db   system_distributed  system_views
+    # system      system_schema       system_virtual_schema
+    #
+    kses = []
+    for line in out.split('\n'):
+        line = line.strip(' \r')
+        if not line:
+            continue
+        if line.startswith('Warning:'):
+            continue
+        if line.startswith('Recommendation:'):
+            continue
+
+        for ks in line.split(' '):
+            if s := ks.strip(' \r\t'):
+                kses.append(s)
+
+    return kses
+
+class ColumnSpec:
+    def __init__(self, name: str, type: str, key_index = -1):
+        self.name = name
+        self.type = type
+        self.key_index = key_index
+
+    def __eq__(self, other):
+        if not isinstance(other, ColumnSpec):
+            return NotImplemented
+
+        return self.name == other.name and self.type == other.type and self.key_index == other.key_index
+
+class TableSpec:
+    def __init__(self, columns: list[ColumnSpec]):
+        self.columns = columns
+
+    def row_key(self):
+        for c in self.columns:
+            if c.key_index == 0:
+                return c.name
+
+    def keys(self):
+        return [c.name for c in self.columns if c.key_index > -1]
+
+def parse_cql_desc_table(out: str) -> TableSpec:
+    # CREATE TABLE azops88_db.analyticscontainer_dfeevalhistory (
+    #     id text,
+    #     columnname text,
+    #     version bigint static,
+    #     contentb blob,
+    #     contentbool boolean,
+    #     contentn double,
+    #     contents text,
+    #     PRIMARY KEY (id, columnname)
+    # ) WITH CLUSTERING ORDER BY (columnname ASC)
+    #     AND additional_write_policy = '99p'
+    #     AND bloom_filter_fp_chance = 0.1
+    #     AND caching = {'keys': 'ALL', 'rows_per_partition': 'NONE'}
+    #     AND cdc = false
+    #     AND comment = ''
+    #     AND compaction = {'class': 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'}
+    #     AND compression = {'chunk_length_in_kb': '16', 'class': 'org.apache.cassandra.io.compress.SnappyCompressor'}
+    #     AND memtable = 'default'
+    #     AND crc_check_chance = 1.0
+    #     AND default_time_to_live = 0
+    #     AND extensions = {}
+    #     AND gc_grace_seconds = 3600
+    #     AND max_index_interval = 2048
+    #     AND memtable_flush_period_in_ms = 0
+    #     AND min_index_interval = 128
+    #     AND read_repair = 'BLOCKING'
+    #     AND speculative_retry = '99p';
+    pkeys = {}
+    columns: list[ColumnSpec] = []
+
+    state = 's0'
+    for line in out.split('\n'):
+        if state == 's0':
+            if line.startswith('CREATE TABLE'):
+                state = 's1'
+        elif state == 's1':
+            if line.startswith(')'):
+                state = 's2'
+                continue
+
+            groups = re.match(r'^\s*PRIMARY KEY\s*\((.*)\).*$', line)
+            if groups:
+                pkeys = {n.strip(' '): i for i, n in enumerate(groups[1].strip(' \r').split(','))}
+                continue
+
+            #  single key column - name text PRIMARY KEY,
+            groups = re.match(r'^\s*(\S*?)\s*(\S*?)\s*PRIMARY KEY,.*$', line)
+            if groups:
+                columns.append(ColumnSpec(groups[1], groups[2]))
+                pkeys[groups[1]] = 0
+            else:
+                groups = re.match(r'^\s*(\S*?)\s*(\S*?),.*$', line)
+                if groups:
+                    columns.append(ColumnSpec(groups[1], groups[2]))
+        elif state == 's2':
+            pass
+
+    for column in columns:
+        if column.name in pkeys.keys():
+            column.key_index = pkeys[column.name]
+
+    return TableSpec(columns)

adam/commands/{cqlsh.py → cql/cqlsh.py}

@@ -2,7 +2,9 @@ import click
 
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
-from adam.commands.cql_utils import run_cql
+from adam.commands.cql.cql_completions import cql_completions
+from adam.utils_k8s.statefulsets import StatefulSets
+from .cql_utils import run_cql
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log, log2
 
@@ -32,11 +34,14 @@ class Cqlsh(Command):
         if not self.validate_state(state):
             return state
 
+        background = False
         opts = []
         cqls = []
-        for arg in args:
+        for index, arg in enumerate(args):
             if arg.startswith('--'):
                 opts.append(arg)
+            elif index == len(args) -1 and arg == '&':
+                background = True
             elif arg != '-e':
                 cqls.append(arg)
         if not cqls:
@@ -50,21 +55,21 @@ class Cqlsh(Command):
             return 'no-cql'
 
         cql = ' '.join(cqls)
-        return run_cql(state, cql, opts, show_out=True)
+        return run_cql(state, cql, opts, show_out=True, background=background)
 
     def completion(self, state: ReplState) -> dict[str, any]:
+        if state.device != state.C:
+            # conflicts with psql completions
+            return {}
+
         if state.sts or state.pod:
-            return {Cqlsh.COMMAND: None} | {
-                'delete': {'from': None},
-                'insert': {'into': None},
-                'select': None,
-                'update': None,
-            }
+            return cql_completions(state) | \
+                   {f'@{p}': cql_completions(state) for p in StatefulSets.pod_names(state.sts, state.namespace)}
 
         return {}
 
     def help(self, _: ReplState) -> str:
-        return f'[{Cqlsh.COMMAND}] <cql-statements>\t run cqlsh with queries'
+        return f'<cql-statements> [&]\t run cqlsh with queries'
 
 class CqlCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):

adam/commands/deploy/code_utils.py

@@ -5,8 +5,8 @@ import subprocess
 
 from adam.apps import Apps
 from adam.config import Config
-from adam.k8s_utils.ingresses import Ingresses
-from adam.k8s_utils.services import Services
+from adam.utils_k8s.ingresses import Ingresses
+from adam.utils_k8s.services import Services
 from adam.utils import log2, random_alphanumeric
 
 def start_user_code(namespace: str):

adam/commands/deploy/deploy.py

@@ -4,8 +4,7 @@ from adam.commands.command import Command
 from adam.commands.deploy.deploy_pg_agent import DeployPgAgent
 from adam.commands.deploy.deploy_pod import DeployPod
 from .deploy_frontend import DeployFrontend
-from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2
+from adam.repl_state import ReplState, RequiredState
 
 class Deploy(Command):
     COMMAND = 'deploy'
@@ -23,22 +22,17 @@ class Deploy(Command):
     def command(self):
         return Deploy.COMMAND
 
+    def required(self):
+        return RequiredState.NAMESPACE
+
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
-
-        if state.in_repl:
-            log(lines_to_tabular([c.help(ReplState()) for c in Deploy.cmd_list()], separator=':'))
+        if not self.validate_state(state):
+            return state
 
-            return 'command-missing'
-        else:
-            # head with the Chain of Responsibility pattern
-            cmds = Command.chain(Deploy.cmd_list())
-            if not cmds.run(cmd, state):
-                log2('* Command is missing.')
-                Command.display_help()
+        return super().intermediate_run(cmd, state, args, Deploy.cmd_list())
 
     def cmd_list():
         return [DeployFrontend(), DeployPod(), DeployPgAgent()]
@@ -49,13 +43,6 @@ class Deploy(Command):
 
         return {}
 
-    def help(self, _: ReplState):
-        return None
-
 class DeployCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
-        log(super().get_help(ctx))
-        log()
-        log('Sub-Commands:')
-
-        log(lines_to_tabular([c.help(ReplState()).replace(f'{Deploy.COMMAND} ', '  ', 1) for c in Deploy.cmd_list()], separator=':'))
+        Command.intermediate_help(super().get_help(ctx), Deploy.COMMAND, Deploy.cmd_list())

adam/commands/deploy/deploy_frontend.py

@@ -49,4 +49,4 @@ class DeployFrontend(Command):
         return super().completion(state)
 
     def help(self, _: ReplState):
-        return f'{DeployFrontend.COMMAND}\t deploy frontend'
+        return f'{DeployFrontend.COMMAND}\t deploy Web frontend'

adam/commands/deploy/deploy_pg_agent.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 
@@ -29,10 +29,10 @@ class DeployPgAgent(Command):
         if not self.validate_state(state):
             return state
 
-        PostgresSession.deploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace)
+        PostgresContext.deploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace)
 
     def completion(self, state: ReplState):
         return super().completion(state)
 
     def help(self, _: ReplState):
-        return f'{DeployPgAgent.COMMAND}\t deploy postgres agent'
+        return f'{DeployPgAgent.COMMAND}\t deploy Postgres agent'

adam/commands/deploy/deploy_pod.py

@@ -1,17 +1,17 @@
 from kubernetes import client
-import yaml
 
 from adam.commands.command import Command
-from adam.commands.deploy.deploy_utils import creating, deploy_frontend, gen_labels
+from adam.commands.deploy.deploy_utils import deploy_frontend, gen_labels
+from adam.commands.deploy.undeploy_pod import UndeployPod
 from adam.config import Config
-from adam.k8s_utils.config_maps import ConfigMaps
-from adam.k8s_utils.deployment import Deployments
-from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.pods import Pods
-from adam.k8s_utils.service_accounts import ServiceAccounts
-from adam.k8s_utils.volumes import ConfigMapMount
+from adam.utils_k8s.config_maps import ConfigMaps
+from adam.utils_k8s.deployment import Deployments
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.service_accounts import ServiceAccounts
+from adam.utils_k8s.volumes import ConfigMapMount
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import log2
+from adam.utils import ing, log2
 
 class DeployPod(Command):
     COMMAND = 'deploy pod'
@@ -39,6 +39,10 @@ class DeployPod(Command):
         if not self.validate_state(state):
             return state
 
+        args, forced = Command.extract_options(args, '--force')
+        if forced:
+            UndeployPod().run(UndeployPod.COMMAND, state)
+
         if KubeContext.in_cluster():
             log2('This is doable only from outside of the Kubernetes cluster.')
             return state
@@ -49,10 +53,8 @@ class DeployPod(Command):
         label_selector = Config().get('pod.label-selector', 'run=ops')
         labels = gen_labels(label_selector)
 
-        creating('service account', lambda: ServiceAccounts.replicate(sa_name,
-                                                                      state.namespace,
-                                                                      sa_proto, labels=labels,
-                                                                      add_cluster_roles=additional_cluster_roles))
+        with ing('Creating service account'):
+            ServiceAccounts.replicate(sa_name, state.namespace, sa_proto, labels=labels, add_cluster_roles=additional_cluster_roles)
 
         settings_filename = 'settings.yaml'
         settings_path = f'/kaqing/{settings_filename}'
@@ -75,10 +77,8 @@ class DeployPod(Command):
         map_data = {
             settings_filename : settings_data
         }
-        creating('config map', lambda: ConfigMaps.create(cm_name,
-                                                         state.namespace,
-                                                         map_data,
-                                                         labels=labels))
+        with ing('Creating config map'):
+            ConfigMaps.create(cm_name, state.namespace, map_data, labels=labels)
 
         pod_name = Config().get('pod.name', 'ops')
         image = Config().get('pod.image', 'seanahnsf/kaqing')
@@ -87,14 +87,15 @@ class DeployPod(Command):
                 add=["SYS_PTRACE"]
             )
         )
-        creating('deployment', lambda: Deployments.create(state.namespace,
-                                                  pod_name,
-                                                  image,
-                                                  env={'NAMESPACE': state.namespace},
-                                                  container_security_context=security_context,
-                                                  labels=labels,
-                                                  sa_name=sa_name,
-                                                  config_map_mount=ConfigMapMount(cm_name, settings_filename, settings_path)))
+        with ing('Creating deployment'):
+            Deployments.create(state.namespace,
+                                pod_name,
+                                image,
+                                env={'NAMESPACE': state.namespace},
+                                container_security_context=security_context,
+                                labels=labels,
+                                sa_name=sa_name,
+                                config_map_mount=ConfigMapMount(cm_name, settings_filename, settings_path))
 
         uri = deploy_frontend(pod_name, state.namespace, label_selector)
 
@@ -103,7 +104,7 @@ class DeployPod(Command):
         return state
 
     def completion(self, state: ReplState):
-        return super().completion(state)
+        return super().completion(state, {'--force': None})
 
     def help(self, _: ReplState):
-        return f'{DeployPod.COMMAND}\t deploy pod'
+        return f'{DeployPod.COMMAND} [--force]\t deploy Ops pod, --force to undeploy first'

adam/commands/deploy/deploy_utils.py

@@ -1,39 +1,29 @@
-from typing import Callable
 from adam.app_session import AppSession
-from adam.k8s_utils.ingresses import Ingresses
-from adam.k8s_utils.services import Services
-from adam.utils import log2
+from adam.utils import ing
+from adam.utils_k8s.ingresses import Ingresses
+from adam.utils_k8s.services import Services
 
 def deploy_frontend(name: str, namespace: str, label_selector: str):
     app_session: AppSession = AppSession.create('c3', 'c3', namespace)
     port = 7678
     labels = gen_labels(label_selector)
-    creating('service', lambda: Services.create_service(name, namespace, port, labels, labels=labels))
-    creating('ingress', lambda: Ingresses.create_ingress(name, namespace, app_session.host, '/c3/c3/ops($|/)', port, annotations={
-        'kubernetes.io/ingress.class': 'nginx',
-        'nginx.ingress.kubernetes.io/use-regex': 'true',
-        'nginx.ingress.kubernetes.io/rewrite-target': '/'
-    }, labels=labels))
+    with ing('Creating service'):
+        Services.create_service(name, namespace, port, labels, labels=labels)
+    with ing('Creating ingress'):
+        Ingresses.create_ingress(name, namespace, app_session.host, '/c3/c3/ops($|/)', port, annotations={
+            'kubernetes.io/ingress.class': 'nginx',
+            'nginx.ingress.kubernetes.io/use-regex': 'true',
+            'nginx.ingress.kubernetes.io/rewrite-target': '/'
+        }, labels=labels)
 
     return f'https://{app_session.host}/c3/c3/ops'
 
 def undeploy_frontend(namespace: str, label_selector: str):
-    deleting('ingress', lambda: Ingresses.delete_ingresses(namespace, label_selector=label_selector))
-    deleting('service', lambda: Services.delete_services(namespace, label_selector=label_selector))
+    with ing('Deleting ingress'):
+        Ingresses.delete_ingresses(namespace, label_selector=label_selector)
+    with ing('Deleting service'):
+        Services.delete_services(namespace, label_selector=label_selector)
 
 def gen_labels(label_selector: str):
     kv = label_selector.split('=')
-    return {kv[0]: kv[1]}
-
-def creating(name: str, body: Callable[[], None]):
-    log2(f'Creating {name}...', nl=False)
-    body()
-    log2(' OK')
-
-def deleting(name: str, body: Callable[[], None]):
-    try:
-        log2(f'Deleting {name}...', nl=False)
-        body()
-        log2(' OK')
-    except Exception as e:
-        log2(e)
+    return {kv[0]: kv[1]}

adam/commands/deploy/undeploy.py

@@ -4,8 +4,7 @@ from adam.commands.command import Command
 from adam.commands.deploy.undeploy_frontend import UndeployFrontend
 from adam.commands.deploy.undeploy_pg_agent import UndeployPgAgent
 from adam.commands.deploy.undeploy_pod import UndeployPod
-from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2
+from adam.repl_state import ReplState, RequiredState
 
 class Undeploy(Command):
     COMMAND = 'undeploy'
@@ -23,22 +22,17 @@ class Undeploy(Command):
     def command(self):
         return Undeploy.COMMAND
 
+    def required(self):
+        return RequiredState.NAMESPACE
+
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
-
-        if state.in_repl:
-            log(lines_to_tabular([c.help(ReplState()) for c in Undeploy.cmd_list()], separator=':'))
+        if not self.validate_state(state):
+            return state
 
-            return 'command-missing'
-        else:
-            # head with the Chain of Responsibility pattern
-            cmds = Command.chain(Undeploy.cmd_list())
-            if not cmds.run(cmd, state):
-                log2('* Command is missing.')
-                Command.display_help()
+        return super().intermediate_run(cmd, state, args, Undeploy.cmd_list())
 
     def cmd_list():
         return [UndeployFrontend(), UndeployPod(), UndeployPgAgent()]
@@ -49,13 +43,6 @@ class Undeploy(Command):
 
         return {}
 
-    def help(self, _: ReplState):
-        return None
-
 class UndeployCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
-        log(super().get_help(ctx))
-        log()
-        log('Sub-Commands:')
-
-        log(lines_to_tabular([c.help(ReplState()).replace(f'{Undeploy.COMMAND} ', '  ', 1) for c in Undeploy.cmd_list()], separator=':'))
+        Command.intermediate_help(super().get_help(ctx), Undeploy.COMMAND, Undeploy.cmd_list())

adam/commands/deploy/undeploy_frontend.py

@@ -38,4 +38,4 @@ class UndeployFrontend(Command):
         return super().completion(state)
 
     def help(self, _: ReplState):
-        return f'{UndeployFrontend.COMMAND}\t undeploy frontend'
+        return f'{UndeployFrontend.COMMAND}\t undeploy Web frontend'

adam/commands/deploy/undeploy_pg_agent.py

@@ -1,7 +1,8 @@
 from adam.commands.command import Command
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
+from adam.utils import ing
 
 class UndeployPgAgent(Command):
     COMMAND = 'undeploy pg-agent'
@@ -29,7 +30,8 @@ class UndeployPgAgent(Command):
         if not self.validate_state(state):
             return state
 
-        PostgresSession.undeploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace)
+        with ing('Deleting pod'):
+            PostgresContext.undeploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace)
 
         return state
 
@@ -37,4 +39,4 @@ class UndeployPgAgent(Command):
         return super().completion(state)
 
     def help(self, _: ReplState):
-        return f'{UndeployPgAgent.COMMAND}\t undeploy postgres agent'
+        return f'{UndeployPgAgent.COMMAND}\t undeploy Postgres agent'

adam/commands/deploy/undeploy_pod.py

@@ -1,10 +1,11 @@
 from adam.commands.command import Command
-from adam.commands.deploy.deploy_utils import undeploy_frontend, deleting
+from adam.commands.deploy.deploy_utils import undeploy_frontend
 from adam.config import Config
-from adam.k8s_utils.config_maps import ConfigMaps
-from adam.k8s_utils.deployment import Deployments
-from adam.k8s_utils.pods import Pods
-from adam.k8s_utils.service_accounts import ServiceAccounts
+from adam.utils import ing
+from adam.utils_k8s.config_maps import ConfigMaps
+from adam.utils_k8s.deployment import Deployments
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.service_accounts import ServiceAccounts
 from adam.repl_state import ReplState, RequiredState
 
 class UndeployPod(Command):
@@ -34,10 +35,11 @@ class UndeployPod(Command):
             return state
 
         label_selector = Config().get('pod.label-selector', 'run=ops')
-        deleting('service account', lambda: ServiceAccounts.delete(state.namespace, label_selector=label_selector))
-        deleting('config map', lambda: ConfigMaps.delete_with_selector(state.namespace, label_selector))
-        deleting('deployment', lambda: Deployments.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0))
-        deleting('pod', lambda: Pods.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0))
+        with ing('Deleting service account'):
+            ServiceAccounts.delete(state.namespace, label_selector=label_selector)
+        with ing('Deleting config map'): ConfigMaps.delete_with_selector(state.namespace, label_selector)
+        with ing('Deleting deployment'): Deployments.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0)
+        with ing('Deleting pod'): Pods.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0)
         undeploy_frontend(state.namespace, label_selector)
 
         return state
@@ -46,4 +48,4 @@ class UndeployPod(Command):
         return super().completion(state)
 
     def help(self, _: ReplState):
-        return f'{UndeployPod.COMMAND}\t undeploy pod'
+        return f'{UndeployPod.COMMAND}\t undeploy Ops pod'