kaqing 2.0.172__py3-none-any.whl → 2.0.186__py3-none-any.whl

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,70 +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 index == len(args) -1 and arg == '&':
-                #     background = True
-                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
 
@@ -303,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
 
@@ -322,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):
@@ -340,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

adam/commands/devices/device_app.py

@@ -1,11 +1,11 @@
 from adam.apps import Apps
 from adam.commands import app
 from adam.commands.bash.bash_completer import BashCompleter
-from adam.commands.command import Command, InvalidState
+from adam.commands.command import Command, InvalidStateException
 from adam.commands.devices.device import Device
 from adam.config import Config
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, wait_log
+from adam.utils import tabulize, log, wait_log
 from adam.utils_k8s.app_pods import AppPods
 from adam.utils_k8s.ingresses import Ingresses
 
@@ -38,13 +38,20 @@ class DeviceApp(Command, Device):
     def help(self, _: ReplState):
         return f'{DeviceApp.COMMAND}\t move to App Operations device'
 
+    def pod(self, state: ReplState) -> str:
+        return state.app_pod
+
+    def pod_names(self, state: ReplState) -> list[str]:
+        return AppPods.pod_names(state.namespace, state.app_env, state.app_app)
+
+    def default_container(self, state: ReplState) -> str:
+        return Config().get('app.container-name', 'c3-server')
+
     def ls(self, cmd: str, state: ReplState):
         if state.app_pod:
             return self.bash(state, state, cmd.split(' '))
         elif state.app_app:
-            pods = AppPods.pod_names(state.namespace, state.app_env, state.app_app)
-
-            log(lines_to_tabular(pods, 'POD_NAME'))
+            tabulize(self.pod_names(state), header='POD_NAME')
         elif state.app_env:
             def line(n: str, ns: str):
                 host = Ingresses.get_host(Config().get('app.login.ingress', '{app_id}-k8singr-appleader-001').replace('{app_id}', f'{ns}-{n}'), ns)
@@ -59,30 +66,13 @@ class DeviceApp(Command, Device):
 
             svcs = [l for l in [line(n, ns) for n, ns in Apps.apps(state.app_env)] if l]
 
-            log(lines_to_tabular(svcs, 'APP,HOST,ENDPOINT', separator=','))
+            tabulize(svcs, header='APP,HOST,ENDPOINT', separator=',')
         else:
-            svcs = [n for n, ns in Apps.envs()]
-
-            log(lines_to_tabular(svcs, 'ENV', separator=','))
+            tabulize(Apps.envs(), lambda a: a[0], header='ENV', separator=',')
 
     def ls_completion(self, cmd, state, default: dict = {}):
         if state.app_app:
-            def pod_names():
-                return [p for p in AppPods.pod_names(state.namespace, state.app_env, state.app_app)]
-
-            return super().completion(state) | {f'@{p}': {cmd: None} for p in pod_names()}
-
-        return default
-
-    def cat(self, cmd: str, state: ReplState):
-        if state.app_pod:
-            return self.bash(state, state, cmd.split(' '))
-
-        return InvalidState()
-
-    def cat_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        if state.app_app:
-            return {f'@{p}': {cmd: None} for p in AppPods.pod_names(state.namespace, state.app_env, state.app_app)}
+            return super().completion(state) | {f'@{p}': {cmd: None} for p in self.pod_names(state)}
 
         return default
 
@@ -112,7 +102,7 @@ class DeviceApp(Command, Device):
 
     def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
         if state.app_app:
-            return {cmd: {'..': None} | {pod: None for pod in AppPods.pod_names(state.namespace, state.app_env, state.app_app)}}
+            return {cmd: {'..': None} | {pod: None for pod in self.pod_names(state)}}
         elif state.app_env:
             return {cmd: {'..': None} | {app[0].split('-')[1]: None for app in Apps.apps(state.app_env)}}
         else:
@@ -126,7 +116,7 @@ class DeviceApp(Command, Device):
         if state.app_app:
             words.append(f'app/{state.app_app}')
 
-        return '\t'.join([f'{ReplState.X}:>'] + (words if words else ['/']))
+        return '\t'.join([f'{ReplState.A}:>'] + (words if words else ['/']))
 
     def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
         if state.app_app:
@@ -144,7 +134,7 @@ class DeviceApp(Command, Device):
                         state.app_app = ea[1]
                         state.app_pod = ea[2]
                         if state.app_pod == '*':
-                            if (pods := AppPods.pod_names(state.namespace, ea[0], ea[1])):
+                            if (pods := self.pod_names(state)):
                                 state.app_pod = pods[0]
                                 wait_log(f'Moving to {state.app_env}/{state.app_app}/{state.app_pod}...')
                             else:
@@ -170,4 +160,4 @@ class DeviceApp(Command, Device):
 
     def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
         return {cmd: BashCompleter(lambda: [])} | \
-               {f'@{p}': {cmd: BashCompleter(lambda: [])} for p in AppPods.pod_names(state.namespace, state.app_env, state.app_app)}
+               {f'@{p}': {cmd: BashCompleter(lambda: [])} for p in self.pod_names(state)}

adam/commands/devices/device_auit_log.py

@@ -1,7 +1,7 @@
 from adam.commands.command import Command
 from adam.commands.devices.device import Device
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log
+from adam.utils import tabulize, log
 from adam.utils_athena import Athena
 
 class DeviceAuditLog(Command, Device):
@@ -34,7 +34,7 @@ class DeviceAuditLog(Command, Device):
         return f'{DeviceAuditLog.COMMAND}\t move to Audit Log Operations device'
 
     def ls(self, cmd: str, _: ReplState):
-        log(lines_to_tabular(Athena.table_names(), 'NAME', separator=','))
+        tabulize(Athena.table_names(), header='NAME', separator=',')
 
     def pwd(self, _: ReplState):
         return '\t'.join([f'{ReplState.L}:>', '/'])
@@ -43,7 +43,7 @@ class DeviceAuditLog(Command, Device):
         return True, chain.run(f'audit {cmd}', state)
 
     def show_tables(self, _: ReplState):
-        log(lines_to_tabular(Athena.table_names(), separator=','))
+        tabulize(Athena.table_names(), separator=',')
 
     def show_table_preview(self, _: ReplState, table: str, rows: int):
         Athena.run_query(f'select * from {table} limit {rows}')

adam/commands/devices/device_cass.py

@@ -1,11 +1,11 @@
 from adam.commands.bash.bash_completer import BashCompleter
-from adam.commands.command import Command, InvalidState
+from adam.commands.command import Command, InvalidStateException
 from adam.commands.commands_utils import show_pods, show_rollout
 from adam.commands.cql.utils_cql import cassandra, cassandra_table_names
 from adam.commands.devices.device import Device
 from adam.config import Config
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2, wait_log
+from adam.utils import tabulize, log, log2, wait_log
 from adam.utils_k8s.cassandra_clusters import CassandraClusters
 from adam.utils_k8s.custom_resources import CustomResources
 from adam.utils_k8s.kube_context import KubeContext
@@ -34,12 +34,21 @@ class DeviceCass(Command, Device):
 
         return state
 
+    def pod(self, state: ReplState) -> str:
+        return state.pod
+
+    def pod_names(self, state: ReplState) -> list[str]:
+        return StatefulSets.pod_names(state.sts, state.namespace)
+
     def completion(self, state: ReplState):
         return super().completion(state)
 
     def help(self, _: ReplState):
         return f'{DeviceCass.COMMAND}\t move to Cassandra Operations device'
 
+    def default_container(self, _: ReplState) -> str:
+        return 'cassandra'
+
     def ls(self, cmd: str, state: ReplState):
         if state.pod:
             return self.bash(state, state, cmd.split(' '))
@@ -50,26 +59,11 @@ class DeviceCass(Command, Device):
             self.show_statefulsets()
 
     def ls_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        def pod_names():
-            return [p for p in StatefulSets.pod_names(state.sts, state.namespace)]
-
         if state.sts:
-            return super().completion(state) | {f'@{p}': {'ls': None} for p in pod_names()}
+            return super().completion(state) | {f'@{p}': {'ls': None} for p in self.pod_names(state)}
         else:
             return {cmd: {n: None for n in StatefulSets.list_sts_names()}}
 
-    def cat(self, cmd: str, state: ReplState):
-        if state.pod:
-            return self.bash(state, state, cmd.split(' '))
-
-        return InvalidState()
-
-    def cat_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        if state.sts:
-            return {f'@{p}': {cmd: None} for p in StatefulSets.pod_names(state.sts, state.namespace)}
-
-        return default
-
     def show_statefulsets(self):
         ss = StatefulSets.list_sts_names()
         if len(ss) == 0:
@@ -88,7 +82,7 @@ class DeviceCass(Command, Device):
         header = 'STATEFULSET_NAME@NAMESPACE APP_ID'
         if KubeContext.in_cluster_namespace():
             header = 'STATEFULSET_NAME APP_ID'
-        log(lines_to_tabular(list, header))
+        tabulize(list, header=header)
 
     def cd(self, dir: str, state: ReplState):
         if dir == '':
@@ -110,7 +104,7 @@ class DeviceCass(Command, Device):
                 if p:
                     state.pod = p
                 else:
-                    names = CassandraClusters.pod_names_by_host_id(state.sts, state.namespace);
+                    names = CassandraClusters.pod_names_by_host_id(state.sts, state.namespace)
                     if dir in names:
                         state.pod = names[dir]
                     else:
@@ -120,7 +114,7 @@ class DeviceCass(Command, Device):
         if state.pod:
             return {cmd: {'..': None}}
         elif state.sts:
-            return {cmd: {'..': None} | {p: None for p in StatefulSets.pod_names(state.sts, state.namespace)}}
+            return {cmd: {'..': None} | {p: None for p in self.pod_names(state)}}
         else:
             return {cmd: {p: None for p in StatefulSets.list_sts_names()}}
 
@@ -158,7 +152,7 @@ class DeviceCass(Command, Device):
                     wait_log(f'Moving to the only Cassandra cluster: {state.sts}@{state.namespace}...')
 
     def show_tables(self, state: ReplState):
-        log(lines_to_tabular(cassandra_table_names(state), separator=','))
+        tabulize(cassandra_table_names(state), separator=',')
 
     def show_table_preview(self, state: ReplState, table: str, rows: int):
         with cassandra(state) as pods:
@@ -179,7 +173,7 @@ class DeviceCass(Command, Device):
         completions = {cmd: BashCompleter(lambda: [])}
 
         if state.sts and state.namespace:
-            completions |= {f'@{p}': {cmd: BashCompleter(lambda: [])} for p in StatefulSets.pod_names(state.sts, state.namespace)}
+            completions |= {f'@{p}': {cmd: BashCompleter(lambda: [])} for p in self.pod_names(state)}
 
         return completions
 

adam/commands/devices/device_export.py

@@ -1,9 +1,9 @@
 from adam.commands.command import Command
 from adam.commands.devices.device import Device
-from adam.commands.export.export_databases import ExportDatabases
+from adam.commands.export.export_databases import ExportDatabases, export_db
 from adam.config import Config
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2, wait_log
+from adam.utils import tabulize, log2, wait_log
 
 class DeviceExport(Command, Device):
     COMMAND = f'{ReplState.X}:'
@@ -36,16 +36,14 @@ class DeviceExport(Command, Device):
 
     def ls(self, cmd: str, state: ReplState):
         if state.export_session:
-            self.show_export_tables(state.export_session)
+            tabulize(ExportDatabases.table_names(state.export_session), header='NAME', separator=',')
         else:
-            self.show_export_databases()
+            ExportDatabases.show_databases()
 
-    def show_export_databases(self, importer: str = None):
-        lines = [f'{k}\t{v}' for k, v in ExportDatabases.database_names_with_keyspace_cnt(importer).items()]
-        log(lines_to_tabular(lines, 'NAME\tKEYSPACES', separator='\t'))
-
-    def show_export_tables(self, export_session: str):
-        log(lines_to_tabular(ExportDatabases.table_names(export_session), 'NAME', separator=','))
+    def show_table_preview(self, state: ReplState, table: str, rows: int):
+        if state.export_session:
+            with export_db(state) as dbs:
+                dbs.sql(f'select * from {table} limit {rows}')
 
     def cd(self, dir: str, state: ReplState):
         if dir in ['', '..']:
@@ -68,7 +66,10 @@ class DeviceExport(Command, Device):
         return '\t'.join([f'{ReplState.X}:>'] + (words if words else ['/']))
 
     def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
-        result = chain.run(f'.{cmd}', state)
+        if cmd.startswith('select '):
+            cmd = f'xelect {cmd[7:]}'
+
+        result = chain.run(cmd, state)
         if type(result) is ReplState:
             if state.export_session and not result.export_session:
                 state.export_session = None