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

adam/commands/devices/device_app.py

@@ -1,10 +1,11 @@
 from adam.apps import Apps
-from adam.commands.bash.bash import Bash
-from adam.commands.command import Command
+from adam.commands import app
+from adam.commands.bash.bash_completer import BashCompleter
+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
+from adam.utils import tabulize, log, wait_log
 from adam.utils_k8s.app_pods import AppPods
 from adam.utils_k8s.ingresses import Ingresses
 
@@ -37,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 Bash().run('bash ' + cmd, state)
+            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)
@@ -58,19 +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 super().completion(state) | {f'@{p}': {cmd: None} for p in self.pod_names(state)}
 
         return default
 
@@ -100,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:
@@ -114,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:
@@ -132,15 +134,30 @@ 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]
-                                Config().wait_log(f'Moving to {state.app_env}/{state.app_app}/{state.app_pod}...')
+                                wait_log(f'Moving to {state.app_env}/{state.app_app}/{state.app_pod}...')
                             else:
-                                Config().wait_log(f'No pods found, moving to {state.app_env}/{state.app_app}...')
+                                wait_log(f'No pods found, moving to {state.app_env}/{state.app_app}...')
                         else:
-                            Config().wait_log(f'Moving to {state.app_env}/{state.app_app}/{state.app_pod}...')
+                            wait_log(f'Moving to {state.app_env}/{state.app_app}/{state.app_pod}...')
                     elif len(ea) > 1:
                         state.app_app = ea[1]
-                        Config().wait_log(f'Moving to {state.app_env}/{state.app_app}...')
+                        wait_log(f'Moving to {state.app_env}/{state.app_app}...')
                     else:
-                        Config().wait_log(f'Moving to {state.app_env}...')
+                        wait_log(f'Moving to {state.app_env}...')
+
+    def bash_target_changed(self, s0: ReplState, s1: ReplState):
+        return s0.app_env != s1.app_env or s0.app_app != s1.app_app or s0.app_pod != s1.app_pod
+
+    def exec_no_dir(self, command: str, state: ReplState):
+        with app(state) as pods:
+            return pods.exec(command)
+
+    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState):
+        with app(state) as pods:
+            return pods.exec(command, not session_just_created)
+
+    def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        return {cmd: BashCompleter(lambda: [])} | \
+               {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,10 +34,16 @@ 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, state: ReplState):
+    def pwd(self, _: ReplState):
         return '\t'.join([f'{ReplState.L}:>', '/'])
 
     def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
-        return True, chain.run(f'audit {cmd}', state)
+        return True, chain.run(f'audit {cmd}', state)
+
+    def show_tables(self, _: ReplState):
+        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,10 +1,11 @@
-from adam.commands.bash.bash import Bash
-from adam.commands.command import Command
+from adam.commands.bash.bash_completer import BashCompleter
+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
+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
@@ -33,15 +34,24 @@ 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 Bash().run('bash ' + cmd, state)
+            return self.bash(state, state, cmd.split(' '))
         elif state.sts and state.namespace:
             show_pods(StatefulSets.pods(state.sts, state.namespace), state.namespace, show_namespace=not KubeContext.in_cluster_namespace())
             show_rollout(state.sts, state.namespace)
@@ -49,11 +59,8 @@ 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()}}
 
@@ -75,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 == '':
@@ -97,17 +104,17 @@ 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:
-                        log2('Not a valid pod name or host id.')
+                        state.pod = dir
 
     def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
         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()}}
 
@@ -140,6 +147,33 @@ class DeviceCass(Command, Device):
                 if auto_enter == 'first-pod':
                     state.pod = f'{state.sts}-0'
                 if KubeContext().in_cluster_namespace:
-                    Config().wait_log(f'Moving to the only Cassandra cluster: {state.sts}...')
+                    wait_log(f'Moving to the only Cassandra cluster: {state.sts}...')
                 else:
-                    Config().wait_log(f'Moving to the only Cassandra cluster: {state.sts}@{state.namespace}...')
+                    wait_log(f'Moving to the only Cassandra cluster: {state.sts}@{state.namespace}...')
+
+    def show_tables(self, state: ReplState):
+        tabulize(cassandra_table_names(state), separator=',')
+
+    def show_table_preview(self, state: ReplState, table: str, rows: int):
+        with cassandra(state) as pods:
+            pods.cql(f'select * from {table} limit {rows}', show_out=True, use_single_quotes=True, on_any=True)
+
+    def bash_target_changed(self, s0: ReplState, s1: ReplState):
+        return s0.sts != s1.sts or s0.pod != s1.pod
+
+    def exec_no_dir(self, command: str, state: ReplState):
+        with cassandra(state) as pods:
+            return pods.exec(command, action='bash', show_out=True, shell='bash')
+
+    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState):
+        with cassandra(state) as pods:
+            return pods.exec(command, action='bash', show_out=not session_just_created, shell='bash')
+
+    def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        completions = {cmd: BashCompleter(lambda: [])}
+
+        if state.sts and 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
+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
@@ -78,7 +79,7 @@ class DeviceExport(Command, Device):
     def enter(self, state: ReplState):
         if auto_enter := Config().get('repl.x.auto-enter', 'no'):
             if auto_enter == 'latest':
-                Config().wait_log(f'Moving to the latest export database...')
+                wait_log(f'Moving to the latest export database...')
                 if dbs := ExportDatabases.database_names():
                     state.export_session = sorted(dbs)[-1]
                 else:

adam/commands/devices/device_postgres.py

@@ -1,10 +1,10 @@
+from adam.commands.bash.bash_completer import BashCompleter
 from adam.commands.command import Command
 from adam.commands.devices.device import Device
-from adam.commands.postgres.postgres_context import PostgresContext
-from adam.commands.postgres.postgres_utils import pg_database_names, pg_table_names
-from adam.config import Config
+from adam.commands.postgres.postgres_databases import PostgresDatabases, pg_path
+from adam.commands.postgres.utils_postgres import pg_database_names, pg_table_names, postgres
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log
+from adam.utils import tabulize, log2, wait_log
 
 class DevicePostgres(Command, Device):
     COMMAND = f'{ReplState.P}:'
@@ -35,75 +35,126 @@ class DevicePostgres(Command, Device):
     def help(self, _: ReplState):
         return f'{DevicePostgres.COMMAND}\t move to Postgres Operations device'
 
+    def pod(self, state: ReplState) -> str:
+        pod, _ = PostgresDatabases.pod_and_container(state.namespace)
+        return pod
+
+    def pod_names(self, state: ReplState) -> list[str]:
+        return [self.pod(state)]
+
+    def default_container(self, state: ReplState) -> str:
+        _, container = PostgresDatabases.pod_and_container(state.namespace)
+        return container
+
     def ls(self, cmd: str, state: ReplState):
-        if state.pg_path:
-            pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
-            if pg.db:
-                self.show_pg_tables(pg)
+        if state.pod_targetted:
+            self.bash(state, state, ['ls'])
+            return
+
+        with pg_path(state) as (host, database):
+            if database:
+                tabulize(pg_table_names(state), header='NAME', separator=',')
+            elif host:
+                tabulize(pg_database_names(state), header='DATABASE', separator=',')
             else:
-                self.show_pg_databases(pg)
-        else:
-            self.show_pg_hosts(state)
+                self.show_pg_hosts(state)
 
     def show_pg_hosts(self, state: ReplState):
         if state.namespace:
-            def line(pg: PostgresContext):
-                return f'{pg.path()},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
-
-            lines = [line(PostgresContext.apply(state.namespace, pg)) for pg in PostgresContext.hosts(state.namespace)]
-
-            log(lines_to_tabular(lines, 'NAME,ENDPOINT,USERNAME,PASSWORD', separator=','))
+            tabulize(PostgresDatabases.hosts(state),
+                     lambda p: f'{p.host},{p.endpoint()}:{p.port()},{p.username()},{p.password()}',
+                     header='NAME,ENDPOINT,USERNAME,PASSWORD',
+                     separator=',')
         else:
-            def line(pg: PostgresContext):
-                return f'{pg.path()},{pg.namespace},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
-
-            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: PostgresContext):
-        log(lines_to_tabular(pg_database_names(pg.namespace, pg.path()), 'DATABASE', separator=','))
-
-    def show_pg_tables(self, pg: PostgresContext):
-        log(lines_to_tabular(pg_table_names(pg.namespace, pg.path()), 'NAME', separator=','))
+            tabulize(PostgresDatabases.hosts(state),
+                     lambda p: f'{p.host},{p.namespace},{p.endpoint()}:{p.port()},{p.username()},{p.password()}',
+                     header='NAME,NAMESPACE,ENDPOINT,USERNAME,PASSWORD',
+                     separator=',')
 
     def cd(self, dir: str, state: ReplState):
         if dir == '':
             state.pg_path = None
-        else:
-            context: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path, arg=dir)
-            # patch up state.namespace from pg cd
-            if not state.namespace and context.namespace:
-                state.namespace = context.namespace
-            state.pg_path = context.path()
+            return
+
+        with pg_path(state) as (host, database):
+            if dir == '..':
+                if database:
+                    database = None
+                else:
+                    host = None
+            else:
+                tks = dir.split('@')
+                if not host:
+                    host = tks[0]
+                else:
+                    database = tks[0]
+
+                if len(tks) > 1:
+                    state.namespace = tks[1]
+
+            if database:
+                state.pg_path = f'{host}/{database}'
+            else:
+                state.pg_path = host
 
     def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path) if state.pg_path else None
-        if pg and pg.db:
-            return {cmd: {'..': None}}
-        elif pg and pg.host:
-            return {cmd: {'..': None} | {p: None for p in pg_database_names(state.namespace, pg.path())}}
-        else:
-            return {cmd: {p: None for p in PostgresContext.hosts(state.namespace)}}
+        return {cmd: {d: None for d in self.direct_dirs(cmd, state, default=default)}}
+
+    def direct_dirs(self, cmd: str, state: ReplState, default: dict = {}) -> list[str]:
+        with pg_path(state) as (host, database):
+            if database:
+                return ['..']
+            elif host:
+                return ['..'] + [p for p in pg_database_names(state)]
+            else:
+                return [p for p in PostgresDatabases.host_names(state.namespace)]
 
     def pwd(self, state: ReplState):
         words = []
 
-        pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
-
-        if pg.host:
-            words.append(f'host/{pg.host}')
-        if pg.db:
-            words.append(f'database/{pg.db}')
+        with pg_path(state) as (host, database):
+            if host:
+                words.append(f'host/{host}')
+            if database:
+                words.append(f'database/{database}')
 
-        return '\t'.join([f'{ReplState.P}:>'] + (words if words else ['/']))
+            return '\t'.join([f'{ReplState.P}:>'] + (words if words else ['/']))
 
     def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
-        pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
-        if pg.db:
-            return True, chain.run(f'pg {cmd}', state)
+        with pg_path(state) as (_, database):
+            if not database:
+                database = PostgresDatabases.default_db()
+
+            if database:
+                return True, chain.run(f'pg {cmd}', state)
 
         return False, None
 
-    def enter(self, state: ReplState):
-        Config().wait_log('Inspecting postgres database instances...')
+    def enter(self, _: ReplState):
+        wait_log('Inspecting postgres database instances...')
+
+    def show_tables(self, state: ReplState):
+        tabulize(PostgresDatabases.tables(state, default_schema=True), lambda d: d['name'], separator=',')
+
+    def show_table_preview(self, state: ReplState, table: str, rows: int):
+        PostgresDatabases.run_sql(state, f'select * from {table} limit {rows}')
+
+    def bash(self, s0: ReplState, s1: ReplState, args: list[str]):
+        pod, container = PostgresDatabases.pod_and_container(s1.namespace)
+        log2(f'Running on {pod}(container:{container})...')
+
+        return super().bash(s0, s1, args)
+
+    def bash_target_changed(self, s0: ReplState, s1: ReplState):
+        return s0.pg_path != s1.pg_path
+
+    def exec_no_dir(self, command: str, state: ReplState):
+        with postgres(state) as pod:
+            return pod.exec(command, show_out=True)
+
+    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState):
+        with postgres(state) as pod:
+            return pod.exec(command, show_out=not session_just_created)
+
+    def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        return {cmd: BashCompleter(lambda: [])}

adam/commands/download_file.py

@@ -0,0 +1,47 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.config import Config
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+from adam.utils_k8s.pods import Pods
+
+class DownloadFile(Command):
+    COMMAND = 'download file'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DownloadFile, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DownloadFile.COMMAND
+
+    def required(self):
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='file'):
+                to_file = Pods.download_file(Devices.device(state).pod(state),
+                                             Devices.device(state).default_container(state),
+                                             state.namespace,
+                                             args[0],
+                                             args[1] if len(args) > 1 else None)
+                log2(f'Downloaded to {to_file}.')
+
+                return state
+
+    def completion(self, state: ReplState):
+        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'{DownloadFile.COMMAND} from-file [to-file]\t download file from pod'

adam/commands/exit.py

@@ -23,10 +23,7 @@ class Exit(Command):
         exit()
 
     def completion(self, state: ReplState):
-        if state.pod:
-            return {Exit.COMMAND: None}
-
-        return {}
+        return {Exit.COMMAND: None}
 
     def help(self, _: ReplState):
         return f'{Exit.COMMAND}\t exit kaqing <Ctrl-D>'

adam/commands/export/clean_up_all_export_sessions.py

@@ -0,0 +1,37 @@
+from adam.commands.command import Command
+from adam.commands.export.export_sessions import export_session
+from adam.repl_state import ReplState, RequiredState
+
+class CleanUpAllExportSessions(Command):
+    COMMAND = 'clean up all export sessions'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(CleanUpAllExportSessions, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return CleanUpAllExportSessions.COMMAND
+
+    def required(self):
+        return RequiredState.CLUSTER_OR_POD
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with export_session(state) as sessions:
+                sessions.clean_up_all()
+
+            return state
+
+    def completion(self, _: ReplState):
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{CleanUpAllExportSessions.COMMAND}\t clean up all export sessions'

adam/commands/export/clean_up_export_sessions.py

@@ -1,9 +1,10 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
-from adam.commands.export.exporter import Exporter
+from adam.commands.export.export_sessions import export_session
 from adam.repl_state import ReplState, RequiredState
 
 class CleanUpExportSessions(Command):
-    COMMAND = 'clean up all export sessions'
+    COMMAND = 'clean up export sessions'
 
     # the singleton pattern
     def __new__(cls, *args, **kwargs):
@@ -24,17 +25,15 @@ class CleanUpExportSessions(Command):
         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
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='export session', separator=',') as session_names:
+                with export_session(state) as sessions:
+                    sessions.clean_up(session_names)
 
-        if Exporter.clean_up_all_sessions(state.sts, state.pod, state.namespace):
-            Exporter.clear_export_session_cache()
-
-        return state
+                return state
 
     def completion(self, _: ReplState):
         return {}
 
     def help(self, _: ReplState):
-        return f'{CleanUpExportSessions.COMMAND}\t clean up all export sessions'
+        return f'{CleanUpExportSessions.COMMAND} <export-session-name,...>\t clean up export sessions'