kaqing 2.0.50__py3-none-any.whl → 2.0.110__py3-none-any.whl

adam/commands/bash.py

@@ -1,7 +1,10 @@
 from adam.commands.command import Command
-from adam.k8s_utils.cassandra_clusters import CassandraClusters
-from adam.k8s_utils.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.cassandra_clusters import CassandraClusters
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.pod_exec_result import PodExecResult
 from adam.repl_state import BashSession, ReplState, RequiredState
+from adam.utils_repl.automata_completer import AutomataCompleter
+from adam.utils_repl.state_machine import StateMachine
 
 class Bash(Command):
     COMMAND = 'bash'
@@ -25,12 +28,16 @@ class Bash(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, s0)
 
-        state, args = self.apply_state(args, s0)
+        state, args = self.apply_state(args, s0, args_to_check=2)
         if not self.validate_state(state):
             return state
 
         if state.in_repl:
-            r = self.exec_with_dir(s0, args)
+            if s0.sts != state.sts or s0.pod != state.pod:
+                r = self.exec_with_dir(state, args)
+            else:
+                r = self.exec_with_dir(s0, args)
+
             if not r:
                 state.exit_bash()
 
@@ -38,8 +45,7 @@ class Bash(Command):
 
             return r
         else:
-            a = ' '.join(args)
-            command = f'bash -c "{a}"'
+            command = ' '.join(args)
 
             if state.pod:
                 CassandraNodes.exec(state.pod, state.namespace, command, show_out=True)
@@ -48,7 +54,7 @@ class Bash(Command):
 
             return state
 
-    def exec_with_dir(self, state: ReplState, args: list[str]):
+    def exec_with_dir(self, state: ReplState, args: list[str]) -> list[PodExecResult]:
         session_just_created = False
         if not args:
             session_just_created = True
@@ -65,23 +71,80 @@ class Bash(Command):
                 if pwd := state.bash_session.pwd(state):
                     args = ['cd', pwd, '&&'] + args
 
-        a = ' '.join(args)
-        command = f'bash -c "{a}"'
+        command = ' '.join(args)
 
         rs = []
 
         if state.pod:
-            rs = [CassandraNodes.exec(state.pod, state.namespace, command, show_out=not session_just_created)]
+            rs = [CassandraNodes.exec(state.pod, state.namespace, command,
+                                      show_out=not session_just_created, shell='bash')]
         elif state.sts:
-            rs = CassandraClusters.exec(state.sts, state.namespace, command, action='bash', show_out=not session_just_created)
+            rs = CassandraClusters.exec(state.sts, state.namespace, command, action='bash',
+                                        show_out=not session_just_created, shell='bash')
 
         return rs
 
     def completion(self, state: ReplState):
         if state.pod or state.sts:
-            return {Bash.COMMAND: None}
+            return {Bash.COMMAND: AutomataCompleter(BashStateMachine())}
 
         return {}
 
     def help(self, _: ReplState):
-        return f'{Bash.COMMAND} [bash-commands]\t run bash on the Cassandra nodes'
+        return f'{Bash.COMMAND} [bash-commands]\t run bash on the Cassandra nodes'
+
+BASH_SPEC = [
+    # <command> ::= <simple_command> | <pipeline> | <conditional_command>
+    # <simple_command> ::= <word> <argument>* <redirection>*
+    # <pipeline> ::= <command> '|' <command>
+    # <conditional_command> ::= <command> '&&' <command> | <command> '||' <command>
+    # <word> ::= <letter> <letter_or_digit>*
+    # <argument> ::= <word>
+    # <redirection> ::= '>' <filename> | '<' <filename>
+    # <filename> ::= <word>
+    # <letter> ::= 'a' | 'b' | ... | 'z' | 'A' | 'B' | ... | 'Z'
+    # <digit> ::= '0' | '1' | ... | '9'
+    # <letter_or_digit> ::= <letter> | <digit>
+
+    '                                > word           > word',
+    'word                            > word           > word                                ^ |,>,2>,<,&,&&,||',
+    '-                               > pipe           > word_pipe',
+    '-                               > _rdr0_         > word_rdr0',
+    '-                               > _rdr1_         > word_rdr1',
+    '-                               > _rdr2_         > word_rdr2',
+    '-                               > &              > word_bg                             ^ |,>,2>,<,&,&&,||',
+    '-                               > &&|_or_        > word',
+    'word_a                          > word           > word',
+    'word_pipe                       > word           > word',
+    'word_rdr0                       > word           > word_rdr0_f',
+    'word_rdr1                       > word           > word_rdr1_f',
+    'word_rdr2                       > word           > word_rdr2_f',
+    'word_rdr1_f                     > pipe           > word_pipe                           ^ |,2>,<,&,&&,||',
+    '-                               > _rdr2_         > word_rdr2',
+    '-                               > _rdr0_         > word_rdr0',
+    'word_rdr2_f                     > pipe           > word_pipe                           ^ |,<,&,&&,||',
+    '-                               > _rdr0_         > word_rdr0',
+    '-                               > &              > word_bg                             ^ |,>,2>,<,&,&&,||',
+    '-                               > &&|_or_        > word',
+    'word_rdr0_f                     > pipe           > word_pipe                           ^ |,&,&&,||',
+    '-                               > &              > word_bg                             ^ |,>,2>,<,&,&&,||',
+    '-                               > &&|_or_        > word',
+    'word_bg                         > &&|_or_        >                                     ^ &&,||',
+]
+
+BASH_KEYWORDS = [
+    '&',
+    '&&',
+    '|',
+    '||',
+    '>',
+    '2>',
+    '>>',
+    '<'
+]
+class BashStateMachine(StateMachine[str]):
+    def spec(self) -> str:
+        return BASH_SPEC
+
+    def keywords(self) -> list[str]:
+        return BASH_KEYWORDS

adam/commands/cd.py

@@ -1,9 +1,9 @@
 from adam.commands.command import Command
 from adam.commands.postgres.postgres_utils import pg_database_names
-from adam.commands.postgres.postgres_session import PostgresSession
-from adam.k8s_utils.cassandra_clusters import CassandraClusters
-from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.commands.postgres.postgres_context import PostgresContext
+from adam.utils_k8s.cassandra_clusters import CassandraClusters
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState
 from adam.utils import log2
 from adam.apps import Apps
@@ -23,10 +23,16 @@ class Cd(Command):
     def command(self):
         return Cd.COMMAND
 
+    def required(self):
+        return ReplState.NON_L
+
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
+        if not self.validate_state(state):
+            return state
+
         if len(args) < 2:
             return state
 
@@ -36,11 +42,11 @@ class Cd(Command):
                 if dir == '':
                     state.pg_path = None
                 else:
-                    session = PostgresSession(state.namespace, state.pg_path)
+                    context: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path, arg=dir)
                     # patch up state.namespace from pg cd
-                    if not state.namespace and (ns := session.find_namespace(arg)):
-                        state.namespace = ns
-                    state.pg_path = session.directory(arg)
+                    if not state.namespace and context.namespace:
+                        state.namespace = context.namespace
+                    state.pg_path = context.path()
             elif state.device == ReplState.A:
                 if dir == '':
                     state.app_env = None
@@ -59,6 +65,8 @@ class Cd(Command):
                         state.app_env = dir.split('@')[0]
                     else:
                         state.app_app = dir
+            elif state.device == ReplState.L:
+                pass
             else:
                 if dir == '':
                     state.sts = None
@@ -72,7 +80,8 @@ class Cd(Command):
                     if not state.sts:
                         ss_and_ns = dir.split('@')
                         state.sts = ss_and_ns[0]
-                        state.namespace = ss_and_ns[1]
+                        if len(ss_and_ns) > 1:
+                            state.namespace = ss_and_ns[1]
                     elif not state.pod:
                         p, _ = KubeContext.is_pod_name(dir)
                         if p:
@@ -88,13 +97,13 @@ class Cd(Command):
 
     def completion(self, state: ReplState):
         if state.device == ReplState.P:
-            pg = PostgresSession(state.namespace, state.pg_path) if state.pg_path else None
+            pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path) if state.pg_path else None
             if pg and pg.db:
                 return {Cd.COMMAND: {'..': None}}
             elif pg and pg.host:
-                return {Cd.COMMAND: {'..': None} | {p: None for p in pg_database_names(state.namespace, pg.directory())}}
+                return {Cd.COMMAND: {'..': None} | {p: None for p in pg_database_names(state.namespace, pg.path())}}
             else:
-                return {Cd.COMMAND: {p: None for p in PostgresSession.hosts(state.namespace)}}
+                return {Cd.COMMAND: {p: None for p in PostgresContext.hosts(state.namespace)}}
         elif state.device == ReplState.A:
             if state.app_app:
                 return {Cd.COMMAND: {'..': None}}
@@ -102,7 +111,7 @@ class Cd(Command):
                 return {Cd.COMMAND: {'..': None} | {app[0].split('-')[1]: None for app in Apps.apps(state.app_env)}}
             else:
                 return {Cd.COMMAND: {'..': None} | {env[0]: None for env in Apps.envs()}}
-        else:
+        elif state.device == ReplState.C:
             if state.pod:
                 return {Cd.COMMAND: {'..': None}}
             elif state.sts:

adam/commands/check.py

@@ -23,11 +23,17 @@ class Check(Issues):
     def command(self):
         return Check.COMMAND
 
+    def required(self):
+        return ReplState.NON_L
+
     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 not self.validate_state(state):
+            return state
+
         args, show = Command.extract_options(args, ['-s', '--show'])
 
         if not args:

adam/commands/cli_commands.py

@@ -3,9 +3,9 @@ import re
 
 from adam.commands.reaper.reaper_session import ReaperSession
 from adam.config import Config
-from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.secrets import Secrets
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.secrets import Secrets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState
 
 class CliCommands:

adam/commands/command.py

@@ -2,7 +2,6 @@ from abc import abstractmethod
 import copy
 import subprocess
 import sys
-from typing import Callable
 
 from adam.commands.command_helpers import ClusterCommandHelper
 from adam.repl_state import ReplState, RequiredState
@@ -29,8 +28,10 @@ class Command:
 
         return None
 
-    def completion(self, _: ReplState, leaf: dict[str, any] = None) -> dict[str, any]:
-        # COMMAND = 'reaper activate schedule'
+    def completion(self, state: ReplState, leaf: dict[str, any] = None) -> dict[str, any]:
+        if not self.validate_state(state, show_err=False):
+            return {}
+
         d = leaf
         for t in reversed(self.command().split(' ')):
             d = {t: d}
@@ -40,8 +41,8 @@ class Command:
     def required(self) -> RequiredState:
         return None
 
-    def validate_state(self, state: ReplState, pg_required: RequiredState = None, app_required: RequiredState = None):
-        return state.validate(self.required(), pg_required=pg_required, app_required=app_required)
+    def validate_state(self, state: ReplState, show_err=True):
+        return state.validate(self.required(), show_err=show_err)
 
     def help(self, _: ReplState) -> str:
         return None
@@ -54,8 +55,8 @@ class Command:
 
         return a
 
-    def apply_state(self, args: list[str], state: ReplState, resolve_pg = True) -> tuple[ReplState, list[str]]:
-        return state.apply_args(args, cmd=self.command_tokens(), resolve_pg=resolve_pg)
+    def apply_state(self, args: list[str], state: ReplState, resolve_pg = True, args_to_check = 6) -> tuple[ReplState, list[str]]:
+        return state.apply_args(args, cmd=self.command_tokens(), resolve_pg=resolve_pg, args_to_check=args_to_check)
 
     def command_tokens(self):
         return self.command().split(' ')
@@ -105,19 +106,22 @@ class Command:
             cmd = s
         print()
 
-    def intermediate_run(self, cmd: str, state: ReplState, args: list[str], cmds: list['Command'], separator='\t'):
+    def intermediate_run(self, cmd: str, state: ReplState, args: list[str], cmds: list['Command'], separator='\t', display_help=True):
         state, _ = self.apply_state(args, state)
 
         if state.in_repl:
-            log(lines_to_tabular([c.help(state) for c in cmds], separator=separator))
+            if display_help:
+                log(lines_to_tabular([c.help(state) for c in cmds], separator=separator))
 
             return 'command-missing'
         else:
             # head with the Chain of Responsibility pattern
             cmds = Command.chain(cmds)
             if not cmds.run(cmd, state):
-                log2('* Command is missing.')
-                Command.display_help()
+                if display_help:
+                    log2('* Command is missing.')
+                    Command.display_help()
+                return 'command-missing'
 
         return state
 

adam/commands/commands_utils.py

@@ -1,16 +1,15 @@
 from concurrent.futures import ThreadPoolExecutor
-import time
 from kubernetes import client
 from typing import List
 
 from adam.checks.check_utils import run_checks
 from adam.columns.columns import Columns, collect_checks
 from adam.commands.issues import Issues
-from adam.k8s_utils.cassandra_nodes import CassandraNodes
-from adam.k8s_utils.pods import Pods
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState
-from adam.utils import convert_seconds, duration, lines_to_tabular, log, log2
+from adam.utils import duration, lines_to_tabular, log, log2
 
 def show_pods(pods: List[client.V1Pod], ns: str, show_namespace = True, show_host_id = True):
     if len(pods) == 0:

adam/commands/cql/cql_completions.py

@@ -1,13 +1,15 @@
-from adam.commands.cql.cql_table_completer import CqlTableNameCompleter
-from adam.commands.cql.cql_utils import table_names
+from adam.commands.cql.cql_utils import cassandra_table_names
+from adam.config import Config
 from adam.repl_state import ReplState
 from adam.sql.sql_completer import SqlCompleter
 
 def cql_completions(state: ReplState) -> dict[str, any]:
-    table_name_completer = CqlTableNameCompleter(table_names(state))
+    ps = Config().get('cql.alter-tables.gc-grace-periods', '3600,86400,864000,7776000').split(',')
     return {
         'describe': {
             'keyspaces': None,
-            'table': table_name_completer,
+            'table': {t: None for t in cassandra_table_names(state)},
             'tables': None},
-    } | SqlCompleter.completions(table_name_completer)
+    } | SqlCompleter(lambda: cassandra_table_names(state), table_props=lambda: {
+        'GC_GRACE_SECONDS': ps
+    }, variant='cql').completions_for_nesting()

adam/commands/cql/cql_utils.py

@@ -2,16 +2,19 @@ import functools
 import re
 
 from adam.config import Config
-from adam.k8s_utils.cassandra_clusters import CassandraClusters
-from adam.k8s_utils.cassandra_nodes import CassandraNodes
-from adam.k8s_utils.secrets import Secrets
+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 keyspaces(state: ReplState, on_any=False):
-    Config().wait_log('Inspecting Cassandra Keyspaces...')
+    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:
@@ -20,19 +23,19 @@ def keyspaces(state: ReplState, on_any=False):
 
     return parse_cql_desc_keyspaces(r.stdout if state.pod else r[0].stdout)
 
-def table_names(state: ReplState):
+def cassandra_table_names(state: ReplState):
     return [f'{k}.{t}' for k, ts in tables(state, on_any=True).items() for t in ts]
 
 @functools.lru_cache()
-def tables(state: ReplState, on_any=False):
+def 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 {}
 
     return parse_cql_desc_tables(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):
+def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_single_quotes = False, on_any = False, background=False) -> 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}'"
@@ -40,9 +43,9 @@ def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_s
         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)
+        return CassandraNodes.exec(state.pod, state.namespace, command, show_out=show_out, background=background)
     else:
-        return CassandraClusters.exec(state.sts, state.namespace, command, show_out=show_out, action='cql', on_any=on_any)
+        return CassandraClusters.exec(state.sts, state.namespace, command, show_out=show_out, action='cql', on_any=on_any, background=background)
 
 def parse_cql_desc_tables(out: str):
     # Keyspace data_endpoint_auth

adam/commands/cql/cqlsh.py

@@ -3,7 +3,7 @@ import click
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
 from adam.commands.cql.cql_completions import cql_completions
-from .cql_utils import run_cql, table_names
+from .cql_utils import run_cql, cassandra_table_names
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log, log2
 
@@ -33,11 +33,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:
@@ -51,7 +54,7 @@ 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:

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,7 +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.repl_state import ReplState, RequiredState
 
 class Deploy(Command):
     COMMAND = 'deploy'
@@ -22,10 +22,16 @@ 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)
 
+        if not self.validate_state(state):
+            return state
+
         return super().intermediate_run(cmd, state, args, Deploy.cmd_list())
 
     def cmd_list():

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,7 +29,7 @@ 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)

adam/commands/deploy/deploy_pod.py

@@ -5,12 +5,12 @@ from adam.commands.command import Command
 from adam.commands.deploy.deploy_utils import creating, 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
 

adam/commands/deploy/deploy_utils.py

@@ -1,7 +1,7 @@
 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_k8s.ingresses import Ingresses
+from adam.utils_k8s.services import Services
 from adam.utils import log2
 
 def deploy_frontend(name: str, namespace: str, label_selector: str):

adam/commands/deploy/undeploy.py

@@ -4,7 +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.repl_state import ReplState, RequiredState
 
 class Undeploy(Command):
     COMMAND = 'undeploy'
@@ -22,10 +22,16 @@ 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)
 
+        if not self.validate_state(state):
+            return state
+
         return super().intermediate_run(cmd, state, args, Undeploy.cmd_list())
 
     def cmd_list():

adam/commands/deploy/undeploy_pg_agent.py

@@ -1,6 +1,6 @@
 from adam.commands.command import Command
 from adam.commands.deploy.deploy_utils import deleting
-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
 
@@ -30,7 +30,7 @@ class UndeployPgAgent(Command):
         if not self.validate_state(state):
             return state
 
-        deleting('pod', lambda: PostgresSession.undeploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace))
+        deleting('pod', lambda: PostgresContext.undeploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace))
 
         return state
 

adam/commands/deploy/undeploy_pod.py

@@ -1,10 +1,10 @@
 from adam.commands.command import Command
 from adam.commands.deploy.deploy_utils import undeploy_frontend, deleting
 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_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):

adam/commands/devices.py

@@ -1,6 +1,35 @@
 from adam.commands.command import Command
 from adam.repl_state import ReplState
 
+class DeviceAuditLog(Command):
+    COMMAND = f'{ReplState.L}:'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DeviceAuditLog, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DeviceAuditLog.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not self.args(cmd):
+            return super().run(cmd, state)
+
+        state.device = ReplState.L
+
+        return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{DeviceAuditLog.COMMAND}\t move to Audit Log Operations device'
+
 class DeviceCass(Command):
     COMMAND = f'{ReplState.C}:'