kaqing 2.0.101__py3-none-any.whl → 2.0.103__py3-none-any.whl

adam/batch.py

@@ -9,7 +9,6 @@ from adam.commands.command_helpers import ClusterCommandHelper, ClusterOrPodComm
 from adam.commands.cql.cqlsh import CqlCommandHelper, Cqlsh
 from adam.commands.deploy.deploy import Deploy, DeployCommandHelper
 from adam.commands.deploy.undeploy import Undeploy, UndeployCommandHelper
-from adam.commands.describe.describe import Describe, DescribeCommandHelper
 from adam.commands.issues import Issues
 from adam.commands.login import Login
 from adam.commands.logs import Logs
@@ -97,19 +96,6 @@ def deploy(kubeconfig: str, config: str, param: list[str], namespace: str, extra
     run_command(Deploy(), kubeconfig, config, param, None, namespace, None, extra_args)
 
 
-@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=DescribeCommandHelper, help='Describe keyspace(s) or table(s).')
-@click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
-@click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
-@click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
-@click.option('--cluster', '-c', required=False, metavar='statefulset', help='Kubernetes statefulset name')
-@click.option('--namespace', '-n', required=False, metavar='namespace', help='Kubernetes namespace')
-@click.option('--pod', '-p', required=False, metavar='pod', help='Kubernetes pod name')
-@click.option('--all-nodes', '-a', is_flag=True, help='execute on all Cassandra nodes')
-@click.argument('extra_args', nargs=-1, metavar='<cluster|pod>', type=click.UNPROCESSED)
-def describe(kubeconfig: str, config: str, param: list[str], cluster: str, namespace: str, pod: str, all_nodes: bool, extra_args):
-    run_command(Describe(), kubeconfig, config, param, cluster, namespace, pod, extra_args + ('&',) if all_nodes else extra_args)
-
-
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help="Print Qing's issues.")
 @click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
 @click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')

adam/commands/audit/audit.py

@@ -54,17 +54,12 @@ class Audit(Command):
                 audit_column_names()
                 audit_column_names(partition_cols_only=True)
 
-            # def columns(_):
-            #     return audit_column_names()
-
-            return super().completion(state) | SqlCompleter.completions(
+            return super().completion(state) | SqlCompleter(
                 lambda: audit_table_names(),
                 columns=lambda table: audit_column_names(),
                 partition_columns=lambda table: audit_column_names(partition_cols_only=True),
                 variant='athena'
-            )
-        # | {
-        #         'desc': {table: None for table in audit_table_names()}}
+            ).completions_for_nesting()
 
         return {}
 

adam/commands/cd.py

@@ -1,6 +1,6 @@
 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.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
@@ -36,11 +36,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
@@ -91,13 +91,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}}

adam/commands/commands_utils.py

@@ -1,5 +1,4 @@
 from concurrent.futures import ThreadPoolExecutor
-import time
 from kubernetes import client
 from typing import List
 
@@ -10,7 +9,7 @@ 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,4 +1,4 @@
-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
@@ -8,8 +8,8 @@ def cql_completions(state: ReplState) -> dict[str, any]:
     return {
         'describe': {
             'keyspaces': None,
-            'table': {t: None for t in table_names(state)},
+            'table': {t: None for t in cassandra_table_names(state)},
             'tables': None},
-    } | SqlCompleter.completions(lambda: table_names(state), table_props=lambda: {
+    } | SqlCompleter(lambda: cassandra_table_names(state), table_props=lambda: {
         'GC_GRACE_SECONDS': ps
-    }, variant='cql')
+    }, variant='cql').completions_for_nesting()

adam/commands/cql/cql_utils.py

@@ -23,32 +23,29 @@ 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):
     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 not on_any:
-        command = f'{command} &'
-
     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/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/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/ls.py

@@ -4,7 +4,7 @@ from adam.commands.command import Command
 from adam.commands.commands_utils import show_pods, show_rollout
 from adam.commands.cql.cqlsh import Cqlsh
 from adam.commands.postgres.postgres_utils import pg_database_names, pg_table_names
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.config import Config
 from adam.utils_k8s.custom_resources import CustomResources
 from adam.utils_k8s.ingresses import Ingresses
@@ -45,7 +45,7 @@ class Ls(Command):
 
         if state.device == ReplState.P:
             if state.pg_path:
-                pg = PostgresSession(state.namespace, state.pg_path)
+                pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
                 if pg.db:
                     self.show_pg_tables(pg)
                 else:
@@ -110,25 +110,25 @@ class Ls(Command):
 
     def show_pg_hosts(self, state: ReplState):
         if state.namespace:
-            def line(pg: PostgresSession):
-                return f'{pg.directory()},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
+            def line(pg: PostgresContext):
+                return f'{pg.path()},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
 
-            lines = [line(PostgresSession(state.namespace, pg)) for pg in PostgresSession.hosts(state.namespace)]
+            lines = [line(PostgresContext.apply(state.namespace, pg)) for pg in PostgresContext.hosts(state.namespace)]
 
             log(lines_to_tabular(lines, 'NAME,ENDPOINT,USERNAME,PASSWORD', separator=','))
         else:
-            def line(pg: PostgresSession):
-                return f'{pg.directory()},{pg.namespace},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
+            def line(pg: PostgresContext):
+                return f'{pg.path()},{pg.namespace},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
 
-            lines = [line(PostgresSession(state.namespace, pg)) for pg in PostgresSession.hosts(state.namespace)]
+            lines = [line(PostgresContext.apply(state.namespace, pg)) for pg in PostgresContext.hosts(state.namespace)]
 
             log(lines_to_tabular(lines, 'NAME,NAMESPACE,ENDPOINT,USERNAME,PASSWORD', separator=','))
 
-    def show_pg_databases(self, pg: PostgresSession):
-        log(lines_to_tabular(pg_database_names(pg.namespace, pg.directory()), 'DATABASE', separator=','))
+    def show_pg_databases(self, pg: PostgresContext):
+        log(lines_to_tabular(pg_database_names(pg.namespace, pg.path()), 'DATABASE', separator=','))
 
-    def show_pg_tables(self, pg: PostgresSession):
-        log(lines_to_tabular(pg_table_names(pg.namespace, pg.directory()), 'NAME', separator=','))
+    def show_pg_tables(self, pg: PostgresContext):
+        log(lines_to_tabular(pg_table_names(pg.namespace, pg.path()), 'NAME', separator=','))
 
     def show_audit_log_tables(self):
         log(lines_to_tabular(audit_table_names(), 'NAME', separator=','))

adam/commands/nodetool.py

@@ -47,7 +47,7 @@ class NodeTool(Command):
 
     def completion(self, state: ReplState):
         if state.pod or state.sts:
-            return {NodeTool.COMMAND: {'help': None} | {c: None for c in NODETOOL_COMMANDS}}
+            return {NodeTool.COMMAND: {'help': None} | {c: {'&': None} for c in NODETOOL_COMMANDS}}
 
         return {}
 

adam/commands/postgres/postgres.py

@@ -5,7 +5,7 @@ from adam.commands.postgres.psql_completions import psql_completions
 from adam.commands.postgres.postgres_utils import pg_table_names
 from .postgres_ls import PostgresLs
 from .postgres_preview import PostgresPreview
-from .postgres_session import PostgresSession
+from .postgres_context import PostgresContext
 from adam.repl_state import ReplState
 from adam.utils import log, log2
 
@@ -62,7 +62,7 @@ class Postgres(Command):
 
             return state
 
-        PostgresSession(state.namespace, state.pg_path).run_sql(' '.join(args))
+        PostgresContext.apply(state.namespace, state.pg_path).run_sql(' '.join(args))
 
     def completion(self, state: ReplState):
         if state.device != state.P:
@@ -70,7 +70,7 @@ class Postgres(Command):
             return {}
 
         leaf = {}
-        session = PostgresSession(state.namespace, state.pg_path)
+        session = PostgresContext.apply(state.namespace, state.pg_path)
         if session.db:
           if pg_table_names(state.namespace, state.pg_path):
             leaf = psql_completions(state.namespace, state.pg_path)

adam/commands/postgres/{postgres_session.py → postgres_context.py}

@@ -8,7 +8,28 @@ from adam.utils_k8s.pods import Pods
 from adam.utils_k8s.secrets import Secrets
 from adam.utils import log2
 
-class PostgresSession:
+class PostgresContext:
+    def apply(namespace: str, path: str, arg: str = None) -> 'PostgresContext':
+        context = PostgresContext(namespace, path)
+
+        if arg:
+            if arg == '..':
+                if context.db:
+                    context.db = None
+                else:
+                    context.host = None
+            else:
+                tks = arg.split('@')
+                if not context.host:
+                    context.host = tks[0]
+                else:
+                    context.db = tks[0]
+
+                if not namespace and tks[1]:
+                    context.namespace = tks[1]
+
+        return context
+
     def __init__(self, ns: str, path: str):
         self.namespace = ns
         self.conn_details = None
@@ -25,29 +46,7 @@ class PostgresSession:
             if len(tks) > 1:
                 self.db = tks[1]
 
-    def find_namespace(self, arg: str):
-        if arg:
-            tks = arg.split('@')
-            if len(tks) > 1:
-                return tks[1]
-
-        return None
-
-    def directory(self, arg: str = None):
-        if arg:
-            if arg == '..':
-                if self.db:
-                    self.db = None
-                else:
-                    self.host = None
-            else:
-                tks = arg.split('@')
-                arg = tks[0]
-                if not self.host:
-                    self.host = arg
-                else:
-                    self.db = arg
-
+    def path(self):
         if not self.host:
             return None
 
@@ -58,7 +57,7 @@ class PostgresSession:
         return f'{self.host}/{self.db}'
 
     def hosts(ns: str):
-        return PostgresSession.hosts_for_namespace(ns)
+        return PostgresContext.hosts_for_namespace(ns)
 
     @functools.lru_cache()
     def hosts_for_namespace(ns: str):
@@ -133,7 +132,7 @@ class PostgresSession:
         return dbs
 
     def run_sql(self, sql: str, show_out = True):
-        db = self.db if self.db else PostgresSession.default_db()
+        db = self.db if self.db else PostgresContext.default_db()
 
         if KubeContext.in_cluster():
             cmd1 = f'env PGPASSWORD={self.password()} psql -h {self.endpoint()} -p {self.port()} -U {self.username()} {db} --pset pager=off -c'
@@ -151,7 +150,7 @@ class PostgresSession:
             pod_name = Config().get('pg.agent.name', 'ops-pg-agent')
 
             if Config().get('pg.agent.just-in-time', False):
-                if not PostgresSession.deploy_pg_agent(pod_name, ns):
+                if not PostgresContext.deploy_pg_agent(pod_name, ns):
                     return
 
             real_pod_name = pod_name

adam/commands/postgres/postgres_utils.py

@@ -1,6 +1,6 @@
 import functools
 
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.config import Config
 
 TestPG = [False]
@@ -12,8 +12,8 @@ def pg_database_names(ns: str, pg_path: str):
 
     Config().wait_log('Inspecting Postgres Databases...')
 
-    pg = PostgresSession(ns, pg_path)
-    return [db['name'] for db in pg.databases() if db['owner'] == PostgresSession.default_owner()]
+    pg = PostgresContext.apply(ns, pg_path)
+    return [db['name'] for db in pg.databases() if db['owner'] == PostgresContext.default_owner()]
 
 @functools.lru_cache()
 def pg_table_names(ns: str, pg_path: str):
@@ -21,10 +21,10 @@ def pg_table_names(ns: str, pg_path: str):
         return ['C3_2_XYZ1']
 
     Config().wait_log('Inspecting Postgres Database...')
-    return [table['name'] for table in pg_tables(ns, pg_path) if table['schema'] == PostgresSession.default_schema()]
+    return [table['name'] for table in pg_tables(ns, pg_path) if table['schema'] == PostgresContext.default_schema()]
 
 def pg_tables(ns: str, pg_path: str):
-    pg = PostgresSession(ns, pg_path)
+    pg = PostgresContext.apply(ns, pg_path)
     if pg.db:
         return pg.tables()
 

adam/commands/postgres/psql_completions.py

@@ -7,4 +7,4 @@ def psql_completions(ns: str, pg_path: str):
         '\d': None,
         '\dt': None,
         '\du': None
-    } | SqlCompleter.completions(lambda: pg_table_names(ns, pg_path))
+    } | SqlCompleter(lambda: pg_table_names(ns, pg_path)).completions_for_nesting()

adam/commands/preview_table.py

@@ -1,11 +1,6 @@
-import functools
-
-from adam.commands.audit.audit_table_completer import AuditTableNameCompleter
 from adam.commands.command import Command
-from adam.commands.cql.cql_table_completer import CqlTableNameCompleter
-from adam.commands.cql.cql_utils import run_cql, table_names, tables
-from adam.commands.postgres.postgres_session import PostgresSession
-from adam.commands.postgres.psql_table_completer import PsqlTableNameCompleter
+from adam.commands.cql.cql_utils import cassandra_table_names, run_cql
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import lines_to_tabular, log, log2
@@ -44,13 +39,13 @@ class PreviewTable(Command):
         if not args:
             def show_tables():
                 if state.device == ReplState.P:
-                    pg = PostgresSession(state.namespace, state.pg_path)
-                    lines = [db["name"] for db in pg.tables() if db["schema"] == PostgresSession.default_schema()]
+                    pg = PostgresContext.apply(state.namespace, state.pg_path)
+                    lines = [db["name"] for db in pg.tables() if db["schema"] == PostgresContext.default_schema()]
                     log(lines_to_tabular(lines, separator=','))
                 elif state.device == ReplState.L:
                     log(lines_to_tabular(audit_table_names(), separator=','))
                 else:
-                    run_cql(state, f'describe tables', show_out=True, on_any=True)
+                    log(lines_to_tabular(cassandra_table_names(state), separator=','))
 
             if state.in_repl:
                 log2('Table is required.')
@@ -69,7 +64,7 @@ class PreviewTable(Command):
 
         rows = Config().get('preview.rows', 10)
         if state.device == ReplState.P:
-            PostgresSession(state.namespace, state.pg_path).run_sql(f'select * from {table} limit {rows}')
+            PostgresContext.apply(state.namespace, state.pg_path).run_sql(f'select * from {table} limit {rows}')
         elif state.device == ReplState.L:
             run_audit_query(f'select * from {table} limit {rows}')
         else:
@@ -77,22 +72,8 @@ class PreviewTable(Command):
 
         return state
 
-    def completion(self, state: ReplState):
-        if state.device == ReplState.P:
-            return {PreviewTable.COMMAND: PsqlTableNameCompleter(state.namespace, state.pg_path)}
-        elif state.device == ReplState.L:
-            return {PreviewTable.COMMAND: AuditTableNameCompleter()}
-        elif state.sts:
-            return {PreviewTable.COMMAND: CqlTableNameCompleter(table_names(state))}
-
+    def completion(self, _: ReplState):
         return {}
 
     def help(self, _: ReplState):
-        return f'{PreviewTable.COMMAND} TABLE\t preview table'
-
-    @functools.lru_cache()
-    def cql_tables(state: ReplState):
-        if state.pod:
-            return tables(state)
-
-        return tables(state, on_any=True)
+        return f'{PreviewTable.COMMAND} TABLE\t preview table'

adam/commands/pwd.py

@@ -1,6 +1,6 @@
 from adam.app_session import AppSession
 from adam.commands.command import Command
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.repl_state import ReplState
 from adam.utils import lines_to_tabular, log
 
@@ -29,7 +29,7 @@ class Pwd(Command):
             words = []
 
             if device == ReplState.P:
-                pg = PostgresSession(state.namespace, state.pg_path)
+                pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
 
                 if pg.host:
                     words.append(f'host/{pg.host}')

adam/repl.py

@@ -13,7 +13,7 @@ from adam.cli_group import cli
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterCommandHelper
 from adam.commands.help import Help
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.config import Config
 from adam.utils_k8s.kube_context import KubeContext
 from adam.utils_k8s.statefulsets import StatefulSets
@@ -40,7 +40,7 @@ def enter_repl(state: ReplState):
         msg = ''
         if state.device == ReplState.P:
             msg = f'{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:
                 msg += pg.db
             elif pg and pg.host:
@@ -141,7 +141,7 @@ def enter_repl(state: ReplState):
                     cmd = f'bash {cmd}'
 
                 if cmd and cmd.strip(' ') and not cmds.run(cmd, state):
-                    try_device_default_action(state, cmds, cmd_list)
+                    try_device_default_action(state, cmds, cmd_list, cmd)
                     # not served by any command in the chain; try SQL query or C3 action
                     # c_sql_tried = False
                     # if state.device == ReplState.P:
@@ -186,10 +186,10 @@ def enter_repl(state: ReplState):
                 if cmd and (state.device != ReplState.L or Config().get('audit.log-audit-queries', False)):
                     executor.submit(audit_log, cmd, state)
 
-def try_device_default_action(state: ReplState, cmds: Command, cmd_list: list[Command]):
+def try_device_default_action(state: ReplState, cmds: Command, cmd_list: list[Command], cmd: str):
     c_sql_tried = False
     if state.device == ReplState.P:
-        pg = PostgresSession(state.namespace, state.pg_path)
+        pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
         if pg.db:
             c_sql_tried = True
             cmd = f'pg {cmd}'

adam/repl_commands.py

@@ -13,7 +13,6 @@ from adam.commands.deploy.undeploy import Undeploy
 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.commands.describe.describe import Describe
 from adam.commands.shell import Shell
 from adam.commands.show.show_app_queues import ShowAppQueues
 from adam.commands.cp import ClipboardCopy
@@ -58,7 +57,7 @@ class ReplCommands:
         cmds: list[Command] = ReplCommands.navigation() + ReplCommands.cassandra_check() + ReplCommands.cassandra_ops() + \
             ReplCommands.tools() + ReplCommands.app() + ReplCommands.exit()
 
-        intermediate_cmds: list[Command] = [App(), Reaper(), Repair(), Deploy(), Describe(), Show(), Undeploy()]
+        intermediate_cmds: list[Command] = [App(), Reaper(), Repair(), Deploy(), Show(), Undeploy()]
         ic = [c.command() for c in intermediate_cmds]
         # 1. dedup commands
         deduped = []
@@ -79,8 +78,7 @@ class ReplCommands:
                 GetParam(), SetParam(), ShowParams(), ShowKubectlCommands(), ShowLogin(), ShowAdam(), ShowHost()]
 
     def cassandra_check() -> list[Command]:
-        return Describe.cmd_list() + [ShowCassandraStatus(),
-                ShowCassandraVersion(), ShowRepairs(), ShowStorage(), ShowProcesses(), Check(), Issues(), NodeTool(), Report()]
+        return [ShowCassandraStatus(), ShowCassandraVersion(), ShowRepairs(), ShowStorage(), ShowProcesses(), Check(), Issues(), NodeTool(), Report()]
 
     def cassandra_ops() -> list[Command]:
         return [AlterTables()] + Medusa.cmd_list() + [Restart(), RollOut(), Watch()] + Reaper.cmd_list() + Repair.cmd_list()

adam/repl_state.py

@@ -2,7 +2,7 @@ import copy
 from enum import Enum
 import re
 
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.utils_k8s.cassandra_clusters import CassandraClusters
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.utils_k8s.kube_context import KubeContext
@@ -210,7 +210,7 @@ class ReplState:
                     return False
 
         if pg_required == RequiredState.PG_DATABASE:
-            pg = PostgresSession(self.namespace, self.pg_path)
+            pg: PostgresContext = PostgresContext.apply(self.namespace, self.pg_path)
             if not pg.db:
                 if self.in_repl:
                     log2('cd to a database first.')