kaqing 2.0.174__py3-none-any.whl → 2.0.188__py3-none-any.whl

adam/commands/cat.py

@@ -2,7 +2,6 @@ from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.commands.devices.devices import Devices
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import log2
 
 class Cat(Command):
     COMMAND = 'cat'
@@ -28,13 +27,10 @@ class Cat(Command):
 
         with self.validate(args, state) as (args, state):
             with validate_args(args, state, name='file'):
-                return Devices.device(state).cat(cmd, state)
+                return Devices.device(state).bash(state, state, cmd.split(' '))
 
     def completion(self, state: ReplState):
-        if super().completion(state):
-            return Devices.device(state).cat_completion(Cat.COMMAND, state, default={})
-
-        return {}
+        return super().completion(state, lambda: {f: None for f in Devices.device(state).files(state)}, pods=Devices.device(state).pods(state, '-'), auto='jit')
 
     def help(self, _: ReplState):
-        return f'{Cat.COMMAND} file [&]\t run cat command on the Cassandra nodes'
+        return f'{Cat.COMMAND} file [&]\t run cat command on the pod'

adam/commands/check.py

@@ -7,7 +7,7 @@ from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
 from adam.commands.issues import Issues
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log
+from adam.utils import tabulize, log
 from adam.utils_issues import IssuesUtils
 
 class Check(Issues):
@@ -34,7 +34,7 @@ class Check(Issues):
 
         with self.validate(args, state) as (args, state):
             with extract_options(args, ['-s', '--show']) as (args, show_out):
-                with validate_args(args, state, name='check name', msg=lambda:log(lines_to_tabular([check.help() for check in all_checks()], separator=':'))) as arg:
+                with validate_args(args, state, name='check name', msg=lambda: tabulize([check.help() for check in all_checks()], separator=':')) as arg:
                     checks = checks_from_csv(args[0])
                     if not checks:
                         return 'invalid check name'

adam/commands/cli_commands.py

@@ -3,14 +3,19 @@ import re
 
 from adam.commands.reaper.utils_reaper import Reapers
 from adam.config import Config
+from adam.utils import log_timing
 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:
-    @functools.lru_cache()
     def values(state: ReplState, collapse = False):
+        with log_timing('CliCommands.values'):
+            return CliCommands._values(state, collapse)
+
+    @functools.lru_cache()
+    def _values(state: ReplState, collapse = False):
         # node-exec-?, nodetool-?, cql-?, reaper-exec, reaper-forward, reaper-ui, reaper-usernae, reaper-password
         d = {}
 

adam/commands/{cp.py → clipboard_copy.py}

@@ -1,3 +1,4 @@
+from functools import partial
 import click
 import pyperclip
 
@@ -5,11 +6,12 @@ from adam.commands import validate_args
 from adam.commands.command import Command, InvalidArgumentsException
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
 from adam.commands.cli_commands import CliCommands
+from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import lines_to_tabular, log, log2
+from adam.utils import tabulize, log, log2
 
 class ClipboardCopy(Command):
-    COMMAND = 'cp'
+    COMMAND = 'cli cp'
 
     # the singleton pattern
     def __new__(cls, *args, **kwargs):
@@ -31,16 +33,22 @@ class ClipboardCopy(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            def display_keys():
-                log2('Key is required.')
+            def display_keys(missing = False):
+                if missing:
+                    log2('Key is required.')
+                else:
+                    log2('Key is invalid.')
                 log2()
-                log2('Keys:')
-                log2(lines_to_tabular([f'{k},{v}' for k, v in CliCommands.values(state, collapse=True).items()], separator=','))
+                tabulize(CliCommands.values(state, collapse=True).items(),
+                         lambda a: f'{a[0]},{a[1]}',
+                         header='KEY,VALUE',
+                         separator=',',
+                         to=2)
 
-            with validate_args(args, state, name='key', msg=display_keys) as key:
+            with validate_args(args, state, name='key', msg=partial(display_keys, True)) as key:
                 if not key in CliCommands.values(state):
                     if state.in_repl:
-                        display_keys()
+                        display_keys(False)
                     else:
                         log2('* Invalid key')
                         Command.display_help()
@@ -55,7 +63,7 @@ class ClipboardCopy(Command):
                 return state
 
     def completion(self, state: ReplState):
-        return super().completion(state, lambda: {key: None for key in CliCommands.values(state).keys()})
+        return super().completion(state, lambda: {key: None for key in CliCommands.values(state).keys()}, auto_key='cli.cp-auto-complete')
 
     def help(self, _: ReplState):
         return f"{ClipboardCopy.COMMAND} <key>\t copy a value to clipboard for conveninence"
@@ -74,8 +82,6 @@ class CopyCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
         log(super().get_help(ctx))
         log()
-        log('Keys:')
-
-        log(lines_to_tabular(self.lines(), separator=':'))
+        tabulize(self.lines(), header='KEY:DESC', separator=':')
         log()
         ClusterOrPodCommandHelper.cluter_or_pod_help()

adam/commands/code.py

@@ -4,7 +4,7 @@ from functools import partial
 from adam.commands.command import Command
 from adam.commands.cql.utils_cql import cassandra_table_names, run_cql
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import lines_to_tabular
+from adam.utils import tabulize
 from adam.utils_k8s.statefulsets import StatefulSets
 
 class Code(Command):
@@ -46,7 +46,7 @@ class Code(Command):
                 "cql('select...'): run cql statement"
             ]
 
-            code.interact(local=my_local, banner=lines_to_tabular(lines, header='Variables', separator=':'))
+            code.interact(local=my_local, banner=tabulize(lines, header='Variables', separator=':'))
 
             return state
 

adam/commands/command.py

@@ -5,8 +5,10 @@ import subprocess
 import sys
 from typing import Union
 
+from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import is_lambda, log2
+from adam.sql.lark_completer import LarkCompleter
+from adam.utils import log2
 
 repl_cmds: list['Command'] = []
 
@@ -29,12 +31,38 @@ class Command:
 
         return None
 
-    def completion(self, state: ReplState, leaf: dict[str, any] = None) -> dict[str, any]:
-        if not self.validate_state(state, show_err=False):
+    def completion(self, state: ReplState, leaf: dict[str, any] = None, pods: tuple[list[str], str] = None, auto: str = 'on', auto_key: str = None) -> dict[str, any]:
+        # pods is a tuple of list of pod names and the current pod repl is on
+        if not pods:
+            return self._completion(state, leaf, auto=auto, auto_key=auto_key)
+
+        c = {}
+
+        pod_names = pods[0]
+        pod = pods[1]
+
+        if pod:
+            c |= self._completion(state, leaf, auto=auto, auto_key=auto_key)
+
+        c |= {f'@{p}': self._completion(state, leaf, to_validate=False, auto=auto, auto_key=auto_key) for p in pod_names if p != pod}
+
+        return c
+
+    def _completion(self, state: ReplState, leaf: dict[str, any] = None, to_validate = True, auto: str = 'on', auto_key: str = None) -> dict[str, any]:
+        if to_validate and not self.validate_state(state, show_err=False):
             return {}
 
-        if is_lambda(leaf):
-            leaf = leaf()
+        if callable(leaf):
+            if auto_key:
+                auto_key = f'auto-complete.{auto_key}'
+                auto = Config().get(auto_key, 'off')
+
+            if auto == 'on':
+                leaf = leaf()
+            elif auto in ['lazy', 'jit']:
+                leaf = LarkCompleter.from_lambda(auto_key, leaf, auto=auto)
+            else:
+                leaf = None
 
         d = leaf
         for t in reversed(self.command().split(' ')):
@@ -113,7 +141,7 @@ class Command:
             options = [options]
 
         if args and trailing:
-            while args[-1] in trailing:
+            while args and args[-1] in trailing:
                 found_trailing = True
                 args = args[:-1]
 
@@ -131,6 +159,8 @@ class Command:
         return new_args, found_trailing, found_sequence, found_options
 
     def extract_option_sequence(args, sequence):
+        new_args = args
+
         len_sub = len(sequence)
         len_main = len(args)
         for i in range(len_main - len_sub + 1):
@@ -181,15 +211,27 @@ class InvalidArgumentsException(Exception):
         super().__init__(f'Invalid arguments')
 
 class ValidateArgCountHandler:
-    def __init__(self, args: list[str], state: ReplState, count_at_least: int = 1, name: str = None, msg: Callable[[], None] = None):
+    def __init__(self, args: list[str], state: ReplState, at_least: int = 1, exactly: int = 1,
+                 name: str = None, msg: Callable[[], None] = None, default: Union[str, list[str]] = None,
+                 separator: str = None):
         self.args = args
         self.state = state
-        self.count_at_least = count_at_least
+        self.at_least = at_least
+        self.exactly = exactly
         self.name = name
         self.msg = msg
+        self.default = default
+        self.separator = separator
+
+    def __enter__(self) -> Union[tuple[list[str], ReplState], tuple[str, ReplState]]:
+        if self.exactly > 0 and len(self.args) != self.exactly or len(self.args) < self.at_least:
+            if self.default:
+                v = self.default
+                if isinstance(v, list):
+                    v = ' '.join(v)
+
+                return v
 
-    def __enter__(self) -> tuple[list[str], ReplState]:
-        if len(self.args) < self.count_at_least:
             if self.state.in_repl:
                 if self.msg:
                     self.msg()
@@ -202,7 +244,15 @@ class ValidateArgCountHandler:
 
             raise InvalidArgumentsException()
 
-        return ' '.join(self.args)
+        if self.separator == ' ':
+            return self.args
+
+        # join and re-split with separator
+        args_to_return = ' '.join(self.args)
+        if self.separator:
+            args_to_return = [arg.strip(' ') for arg in args_to_return.split(self.separator)]
+
+        return args_to_return
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         return False

adam/commands/commands_utils.py

@@ -1,14 +1,17 @@
+from datetime import datetime
 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.config import Config
+from adam.repl_session import ReplSession
 from adam.utils_issues import IssuesUtils
 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 duration, lines_to_tabular, log, log2
+from adam.utils import SORT, duration, tabulize, log, log2
 
 def show_pods(pods: List[client.V1Pod], ns: str, show_namespace = True, show_host_id = True):
     if len(pods) == 0:
@@ -48,9 +51,7 @@ def show_pods(pods: List[client.V1Pod], ns: str, show_namespace = True, show_hos
             line += f"@{ns}"
         return line + f" {ready}/{pod_cnt} {status}"
 
-    pod_names = [line(pod) for pod in pods]
-
-    log(lines_to_tabular(pod_names, 'HOST_ID POD_NAME READY POD_STATUS' if show_host_id else 'POD_NAME READY POD_STATUS'))
+    tabulize(pods, line, header='HOST_ID POD_NAME READY POD_STATUS' if show_host_id else 'POD_NAME READY POD_STATUS')
 
 def show_rollout(sts: str, ns: str):
     restarted, rollingout = StatefulSets.restarted_at(sts, ns)
@@ -61,18 +62,24 @@ def show_rollout(sts: str, ns: str):
         else:
             log2(f'Cluster has completed rollout {d} ago.')
 
-def show_table(state: ReplState, pods: list[str], cols: str, header: str, show_out=False):
+def show_table(state: ReplState, pods: list[str], cols: str, header: str, show_out=False, backgrounded = False):
     columns = Columns.create_columns(cols)
 
     results = run_checks(cluster=state.sts, pod=state.pod, namespace=state.namespace, checks=collect_checks(columns), show_out=show_out)
 
-    def line(pod_name: str):
-        cells = [c.pod_value(results, pod_name) for c in columns]
-        return ','.join(cells)
+    r = tabulize(pods, lambda p: ','.join([c.pod_value(results, p) for c in columns]), header=header, separator=',', sorted=SORT, to = 0 if backgrounded else 1)
+
+    if backgrounded:
+        log_prefix = Config().get('log-prefix', '/tmp/qing')
+        log_file = f'{log_prefix}-{datetime.now().strftime("%d%H%M%S")}.log'
+
+        with open(log_file, 'w') as f:
+            f.write(r)
+
+        ReplSession().append_history(f':sh cat {log_file}')
 
-    lines = [line(pod) for pod in pods]
-    lines.sort()
+        r = log_file
 
-    log(lines_to_tabular(lines, header, separator=','))
+    IssuesUtils.show(results, state.in_repl)
 
-    IssuesUtils.show(results, state.in_repl)
+    return r

adam/commands/cql/completions_c.py

@@ -0,0 +1,28 @@
+from adam.commands.cql.utils_cql import cassandra_keyspaces, cassandra_table_names
+from adam.commands.export.export_sessions import ExportSessions
+from adam.commands.export.export_databases import ExportDatabases
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.sql.lark_completer import LarkCompleter
+from adam.utils import log_timing
+from adam.utils_k8s.statefulsets import StatefulSets
+
+def completions_c(state: ReplState) -> dict[str, any]:
+    ps = Config().get('cql.alter-tables.gc-grace-periods', '3600,86400,864000,7776000').split(',')
+
+    with log_timing('lark.completions'):
+        return LarkCompleter(
+            expandables = {
+                'tables': lambda x: cassandra_table_names(state),
+                'keyspaces': lambda x: cassandra_keyspaces(state.with_no_pod()),
+                'table-props': lambda x: {
+                    'GC_GRACE_SECONDS': ps
+                },
+                'export-database-types': lambda x: ['athena', 'sqlite', 'csv'],
+                'export-databases': lambda x: ExportDatabases.database_names(),
+                'export-sessions': lambda x: ExportSessions.export_session_names(state.sts, state.pod, state.namespace),
+                'export-sessions-incomplete': lambda x: ExportSessions.export_session_names(state.sts, state.pod, state.namespace, export_state='pending_import'),
+                'hosts': lambda x: [f'@{p}' for p in StatefulSets.pod_names(state.sts, state.namespace)],
+            },
+            variant=ReplState.C
+        ).completions_for_nesting()

adam/commands/cql/cqlsh.py

@@ -3,9 +3,8 @@ import click
 from adam.commands import extract_trailing_options
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
-from adam.commands.cql.cql_completions import cql_completions
+from adam.commands.cql.completions_c import completions_c
 from adam.commands.cql.utils_cql import cassandra
-from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log
 
@@ -34,17 +33,14 @@ class Cqlsh(Command):
         with self.validate(args, state) as (args, state):
             with extract_trailing_options(args, '&') as (args, backgrounded):
                 with cassandra(state) as pods:
-                    pods.cql(args, background=backgrounded)
+                    pods.cql(args, backgrounded=backgrounded)
 
     def completion(self, state: ReplState) -> dict[str, any]:
         if state.device != state.C:
-            # conflicts with psql completions
             return {}
 
         if state.sts or state.pod:
-            c = cql_completions(state)
-            return c | \
-                   {f'@{p}': c for p in StatefulSets.pod_names(state.sts, state.namespace)}
+            return completions_c(state)
 
         return {}
 

adam/commands/cql/utils_cql.py

@@ -12,6 +12,14 @@ from adam.repl_state import ReplState
 from adam.utils import log2, log_timing, wait_log
 from adam.utils_k8s.statefulsets import StatefulSets
 
+def cd_dirs(state: ReplState) -> list[str]:
+    if state.pod:
+        return [".."]
+    elif state.sts:
+        return [".."] + StatefulSets.pod_names(state.sts, state.namespace)
+    else:
+        return StatefulSets.list_sts_names()
+
 @functools.lru_cache()
 def cassandra_keyspaces(state: ReplState, on_any=True):
     if state.pod:
@@ -47,7 +55,7 @@ def table_spec(state: ReplState, table: str, on_any=False) -> 'TableSpec':
 
     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, show_query = False, use_single_quotes = False, on_any = False, background=False, log_file=None) -> list[PodExecResult]:
+def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, backgrounded=False, log_file=None) -> list[PodExecResult]:
     if show_query:
         log2(cql)
 
@@ -61,7 +69,7 @@ def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, show_
 
     with log_timing(cql):
         with cassandra(state) as pods:
-            return pods.exec(command, action='cql', show_out=show_out, on_any=on_any, background=background, log_file=log_file)
+            return pods.exec(command, action='cql', show_out=show_out, on_any=on_any, backgrounded=backgrounded, log_file=log_file)
 
 def parse_cql_desc_tables(out: str):
     # Keyspace data_endpoint_auth
@@ -215,68 +223,24 @@ def parse_cql_desc_table(out: str) -> TableSpec:
 
     return TableSpec(columns)
 
-class CqlShHandler:
-    def __init__(self, state: ReplState, opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, background=False):
-        self.state = state
-        self.opts = opts
-        self.show_out = show_out
-        self.show_query = show_query
-        self.use_single_quotes = use_single_quotes
-        self.on_any = on_any
-        self.backgroud = background
-
-    def __enter__(self):
-        return self.query
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        return False
-
-    def query(self, args: list[str], log_file: str = None):
-        query: str = args
-        background = self.backgroud
-        show_out = self.show_out
-
-        if isinstance(query, list):
-            opts = []
-            cqls = []
-            for index, arg in enumerate(args):
-                if arg.startswith('--'):
-                    opts.append(arg)
-                elif arg != '-e':
-                    cqls.append(arg)
-            if not cqls:
-                if self.state.in_repl:
-                    log2('Please enter cql statement. e.g. select host_id from system.local')
-                else:
-                    log2('* CQL statement is missing.')
-                    log2()
-                    Command.display_help()
-
-                return 'no-cql'
-
-            query = ' '.join(cqls)
-            show_out = True
-
-        return run_cql(self.state, query, opts=self.opts, show_out=show_out, show_query=self.show_query, use_single_quotes=self.use_single_quotes, on_any=self.on_any, background=background, log_file=log_file)
-
 class CassandraPodService:
     def __init__(self, handler: 'CassandraExecHandler'):
         self.handler = handler
 
-    def exec(self, command: str, action='bash', show_out = True, on_any = False, throw_err = False, shell = '/bin/sh', background = False, log_file = None) -> Union[PodExecResult, list[PodExecResult]]:
+    def exec(self, command: str, action='bash', show_out = True, on_any = False, throw_err = False, shell = '/bin/sh', backgrounded = False, log_file = None) -> Union[PodExecResult, list[PodExecResult]]:
         state = self.handler.state
         pod = self.handler.pod
 
         if pod:
             return CassandraNodes.exec(pod, state.namespace, command,
-                                    show_out=show_out, throw_err=throw_err, shell=shell, background=background, log_file=log_file)
+                                    show_out=show_out, throw_err=throw_err, shell=shell, backgrounded=backgrounded, log_file=log_file)
         elif state.sts:
             return CassandraClusters.exec(state.sts, state.namespace, command, action=action,
-                                        show_out=show_out, on_any=on_any, shell=shell, background=background, log_file=log_file)
+                                        show_out=show_out, on_any=on_any, shell=shell, backgrounded=backgrounded, log_file=log_file)
 
         return []
 
-    def cql(self, args: list[str], opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, background=False, log_file: str = None):
+    def cql(self, args: list[str], opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, backgrounded=False, log_file: str = None):
         state = self.handler.state
         query: str = args
 
@@ -301,18 +265,18 @@ class CassandraPodService:
             query = ' '.join(cqls)
             show_out = True
 
-        return run_cql(state, query, opts=opts, show_out=show_out, show_query=show_query, use_single_quotes=use_single_quotes, on_any=on_any, background=background, log_file=log_file)
+        return run_cql(state, query, opts=opts, show_out=show_out, show_query=show_query, use_single_quotes=use_single_quotes, on_any=on_any, backgrounded=backgrounded, log_file=log_file)
 
-    def display_table(self, cols: str, header: str, show_out = True):
+    def display_table(self, cols: str, header: str, show_out = True, backgrounded = False):
         state = self.handler.state
 
         if state.pod:
-            show_table(state, [state.pod], cols, header, show_out=show_out)
+            return show_table(state, [state.pod], cols, header, show_out=show_out, backgrounded = backgrounded)
         elif state.sts:
             pod_names = [pod.metadata.name for pod in StatefulSets.pods(state.sts, state.namespace)]
-            show_table(state, pod_names, cols, header, show_out=show_out)
+            return show_table(state, pod_names, cols, header, show_out=show_out, backgrounded = backgrounded)
 
-    def nodetool(self, args: str, show_out = True) -> Union[PodExecResult, list[PodExecResult]]:
+    def nodetool(self, args: str, status = False, show_out = True, backgrounded = False) -> Union[PodExecResult, list[PodExecResult]]:
         state = self.handler.state
         pod = self.handler.pod
 
@@ -320,9 +284,9 @@ class CassandraPodService:
         command = f"nodetool -u {user} -pw {pw} {args}"
 
         if pod:
-            return CassandraNodes.exec(pod, state.namespace, command, show_out=show_out)
+            return CassandraNodes.exec(pod, state.namespace, command, show_out=show_out, backgrounded=backgrounded)
         else:
-            return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool', show_out=show_out)
+            return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool.status' if status else 'nodetool', show_out=show_out, backgrounded=backgrounded)
 
 class CassandraExecHandler:
     def __init__(self, state: ReplState, pod: str = None):
@@ -338,4 +302,4 @@ class CassandraExecHandler:
         return False
 
 def cassandra(state: ReplState, pod: str=None):
-    return CassandraExecHandler(state, pod=pod)
+    return CassandraExecHandler(state, pod=pod)

adam/commands/deploy/deploy_pg_agent.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.commands.postgres.postgres_context import PostgresContext
+from adam.commands.postgres.postgres_databases import PostgresDatabases
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 
@@ -26,7 +26,7 @@ class DeployPgAgent(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            PostgresContext.deploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace)
+            PostgresDatabases.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/undeploy_pg_agent.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.commands.postgres.postgres_context import PostgresContext
+from adam.commands.postgres.postgres_databases import PostgresDatabases
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import ing
@@ -28,7 +28,7 @@ class UndeployPgAgent(Command):
 
         with self.validate(args, state) as (args, state):
             with ing('Deleting pod'):
-                PostgresContext.undeploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace)
+                PostgresDatabases.undeploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace)
 
             return state
 

adam/commands/devices/device.py

@@ -5,20 +5,35 @@ from adam.config import Config
 from adam.pod_exec_result import PodExecResult
 from adam.repl_state import BashSession, ReplState
 from adam.utils import log2
+from adam.utils_k8s.pods import Pods
 
 class Device:
-    @abstractmethod
-    def ls(self, cmd: str, state: ReplState):
-        pass
+    def pods(self, state: ReplState, me: str = None) -> tuple[list[str], str]:
+        return self.pod_names(state), me if me else self.pod(state)
 
-    def ls_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        return default
+    def default_pod(self, state: ReplState) -> tuple[list[str], str]:
+        if me := self.pod(state):
+            return me
+
+        if pods := self.pod_names(state):
+            return pods[0]
+
+        return None
+
+    def pod(self, state: ReplState) -> str:
+        return None
+
+    def pod_names(self, state: ReplState) -> list[str]:
+        return []
+
+    def default_container(self, state: ReplState) -> str:
+        return None
 
     @abstractmethod
-    def cat(self, cmd: str, state: ReplState):
+    def ls(self, cmd: str, state: ReplState):
         pass
 
-    def cat_completion(self, cmd: str, state: ReplState, default: dict = {}):
+    def ls_completion(self, cmd: str, state: ReplState, default: dict = {}):
         return default
 
     def cd(self, dir: str, state: ReplState):
@@ -27,6 +42,9 @@ class Device:
     def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
         return default
 
+    def direct_dirs(self, cmd: str, state: ReplState, default: dict = {}) -> list[str]:
+        return []
+
     @abstractmethod
     def pwd(self, state: ReplState):
         pass
@@ -115,4 +133,17 @@ class Device:
         pass
 
     def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        return default
+        return default
+
+    def files(self, state: ReplState):
+        r: PodExecResult = Pods.exec(self.default_pod(state), self.default_container(state), state.namespace, f'find -maxdepth 1 -type f', show_out=Config().is_debug(), shell='bash')
+
+        log_files = []
+        for line in r.stdout.split('\n'):
+            line = line.strip(' \r')
+            if line:
+                if line.startswith('./'):
+                    line = line[2:]
+                log_files.append(line)
+
+        return log_files