kaqing 2.0.177__tar.gz → 2.0.184__tar.gz

{kaqing-2.0.177 → kaqing-2.0.184}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.177
+Version: 2.0.184
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.177 → kaqing-2.0.184}/adam/checks/check_utils.py

@@ -47,7 +47,9 @@ def run_checks(cluster: str = None, namespace: str = None, pod: str = None, chec
                 if not pod or pod == pod_name:
                     sts_ns_pods.append((sts, ns, pod_name))
 
-    with parallelize(sts_ns_pods, Config().action_workers('issues', 30), msg='d`Running|Ran checks on {size} pods') as exec:
+    with parallelize(sts_ns_pods,
+                     Config().action_workers('issues', 30),
+                     msg='d`Running|Ran checks on {size} pods') as exec:
         return exec.map(lambda sts_ns_pod: run_checks_on_pod(checks, sts_ns_pod[0], sts_ns_pod[1], sts_ns_pod[2], show_out))
 
 def run_checks_on_pod(checks: list[Check], cluster: str = None, namespace: str = None, pod: str = None, show_out=True):

{kaqing-2.0.177 → kaqing-2.0.184}/adam/commands/__init__.py

@@ -18,5 +18,7 @@ def extract_all_options(args: list[str], trailing = None, sequence = None, optio
 def extract_sequence(args: list[str], sequence: list[str]):
     return ExtractSequenceOptionsHandler(args, sequence = sequence)
 
-def validate_args(args: list[str], state: ReplState, count_at_least: int = 1, name: str = None, msg: Callable[[], None] = None, default: str = None):
-    return ValidateArgCountHandler(args, state, count_at_least=count_at_least, name=name, msg=msg, default=default)
+def validate_args(args: list[str], state: ReplState, at_least: int = 1, exactly: int = -1,
+                  name: str = None, msg: Callable[[], None] = None, default: str = None,
+                  separator=None):
+    return ValidateArgCountHandler(args, state, at_least=at_least, exactly=exactly, name=name, msg=msg, default=default, separator=separator)

kaqing-2.0.184/adam/commands/app/app.py

@@ -0,0 +1,38 @@
+from adam.commands import app, extract_options
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+
+class App(Command):
+    COMMAND = 'app'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(App, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return App.COMMAND
+
+    def required(self):
+        return RequiredState.APP_APP
+
+    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 extract_options(args, '--force') as (args, forced):
+                with app(state) as http:
+                    http.post(args, forced=forced)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'--force': None})
+
+    def help(self, _: ReplState):
+        return f"<AppType>.<AppAction> <args> [--force]\t post app action; check with 'show app actions' command"

kaqing-2.0.184/adam/commands/app/app_ping.py

@@ -0,0 +1,38 @@
+from adam.commands import app, extract_options
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+
+class AppPing(Command):
+    COMMAND = 'app ping'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(AppPing, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return AppPing.COMMAND
+
+    def required(self):
+        return RequiredState.APP_APP
+
+    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 extract_options(args, '--force') as (args, forced):
+                with app(state) as http:
+                    http.post(['Echo.echoStatic'], forced=forced)
+
+                    return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'--force': None})
+
+    def help(self, _: ReplState):
+        return f"{AppPing.COMMAND} [--force]\t ping app server with Echo.echoStatic()"

kaqing-2.0.184/adam/commands/app/show_app_actions.py

@@ -0,0 +1,49 @@
+from adam.app_session import AppSession
+from adam.apps import AppAction, Apps
+from adam.commands.command import Command
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.utils import tabulize, log
+
+class ShowAppActions(Command):
+    COMMAND = 'show app actions'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowAppActions, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowAppActions.COMMAND
+
+    def required(self):
+        return ReplState.A
+
+    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):
+            actions = []
+            for typ in Apps().app_types():
+                actions.extend(typ.actions)
+
+            lines = tabulize(actions, lambda a: str(a), header='ACTION,ARGS,DESCRIPTION', separator=',')
+            log()
+
+            app_session: AppSession = AppSession.create(state.app_env or 'c3', state.app_app or 'c3')
+            endpoint = Config().get('app.console-endpoint', 'https://{host}/{env}/{app}/static/console/index.html')
+            endpoint = endpoint.replace('{host}', app_session.host).replace('{env}', app_session.env).replace('{app}', state.app_app or 'c3')
+            tabulize([f'CONSOLE:,{endpoint}'], separator=',')
+
+            return lines
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f"{ShowAppActions.COMMAND}\t show app actions"

kaqing-2.0.184/adam/commands/app/show_app_id.py

@@ -0,0 +1,44 @@
+from adam.commands.command import Command
+from adam.utils_k8s.custom_resources import CustomResources
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log
+
+class ShowAppId(Command):
+    COMMAND = 'show app id'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowAppId, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowAppId.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):
+            c3_app_id = 'Unknown'
+
+            apps = CustomResources.get_app_ids()
+            cr_name = CustomResources.get_cr_name(state.sts if state.sts else state.pod, namespace=state.namespace)
+            if cr_name in apps:
+                c3_app_id = (apps[cr_name])
+
+            log(c3_app_id)
+
+            return c3_app_id
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{ShowAppId.COMMAND}\t show app id for the Cassandra cluster'

kaqing-2.0.184/adam/commands/app/show_app_queues.py

@@ -0,0 +1,38 @@
+from adam.commands import app, extract_options
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+
+class ShowAppQueues(Command):
+    COMMAND = 'show app queues'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowAppQueues, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowAppQueues.COMMAND
+
+    def required(self):
+        return RequiredState.APP_APP
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (_, state):
+            with extract_options(args, '--force') as (args, forced):
+                with app(state) as http:
+                    http.post(['InvalidationQueue.countAll'], forced=forced)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'--force': None})
+
+    def help(self, _: ReplState):
+        return f"{ShowAppQueues.COMMAND} [--force]\t show invalidation queue counts"

kaqing-2.0.184/adam/commands/app/utils_app.py

@@ -0,0 +1,98 @@
+import json
+from typing import Union
+
+from adam.app_session import AppSession
+from adam.apps import Apps
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState
+from adam.utils import log2
+from adam.utils_k8s.app_clusters import AppClusters
+from adam.utils_k8s.app_pods import AppPods
+
+class AppRestHandler:
+    def __init__(self, state: ReplState, forced = False):
+        self.state = state
+        self.forced = forced
+
+    def __enter__(self):
+        return self.post
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+    def post(self, args: list[str]) -> Union[ReplState, str]:
+        if not args:
+            return 'arg missing'
+
+        t_f = args[0].split('.')
+        if len(t_f) < 2:
+            return 'arg missing'
+
+        state = self.state
+
+        payload, valid = Apps().payload(t_f[0], t_f[1], args[1:] if len(args) > 1 else [])
+        if not valid:
+            log2('Missing one or more action arguments.')
+            return state
+
+        if payload:
+            try:
+                payload = json.loads(payload)
+            except json.decoder.JSONDecodeError as e:
+                log2(f'Invalid json argument: {e}')
+                return state
+
+        AppSession.run(state.app_env, state.app_app, state.namespace, t_f[0], t_f[1], payload=payload, forced=self.forced)
+
+        return state
+
+class AppPodService:
+    def __init__(self, handler: 'AppHandler'):
+        self.handler = handler
+
+    def exec(self, command: str, show_out = True) -> Union[PodExecResult, list[PodExecResult]]:
+        state = self.handler.state
+
+        if state.app_pod:
+            return AppPods.exec(state.app_pod, state.namespace, command, show_out=show_out, shell='bash')
+        elif state.app_app:
+            pods = AppPods.pod_names(state.namespace, state.app_env, state.app_app)
+            return AppClusters.exec(pods, state.namespace, command, action='bash', show_out=show_out, shell='bash')
+
+        return []
+
+    def post(self, args: list[str], forced=False) -> Union[ReplState, str]:
+        state = self.handler.state
+
+        if not args:
+            return 'arg missing'
+
+        t_f = args[0].split('.')
+        if len(t_f) < 2:
+            return 'arg missing'
+
+        payload, valid = Apps().payload(t_f[0], t_f[1], args[1:] if len(args) > 1 else [])
+        if not valid:
+            log2('Missing one or more action arguments.')
+            return state
+
+        if payload:
+            try:
+                payload = json.loads(payload)
+            except json.decoder.JSONDecodeError as e:
+                log2(f'Invalid json argument: {e}')
+                return state
+
+        AppSession.run(state.app_env, state.app_app, state.namespace, t_f[0], t_f[1], payload=payload, forced=forced)
+
+        return state
+
+class AppHandler:
+    def __init__(self, state: ReplState):
+        self.state = state
+
+    def __enter__(self):
+        return AppPodService(self)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False

{kaqing-2.0.177 → kaqing-2.0.184}/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, pods=Devices.device(state).pods(state))
 
     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'

{kaqing-2.0.177 → kaqing-2.0.184}/adam/commands/clipboard_copy.py

@@ -10,7 +10,7 @@ from adam.repl_state import ReplState, RequiredState
 from adam.utils import tabulize, log, log2
 
 class ClipboardCopy(Command):
-    COMMAND = 'cp'
+    COMMAND = 'cli cp'
 
     # the singleton pattern
     def __new__(cls, *args, **kwargs):

{kaqing-2.0.177 → kaqing-2.0.184}/adam/commands/command.py

@@ -29,8 +29,25 @@ 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) -> 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)
+
+        c = {}
+
+        pod_names = pods[0]
+        pod = pods[1]
+
+        if pod:
+            c |= self._completion(state, leaf)
+
+        c |= {f'@{p}': self._completion(state, leaf, to_validate=False) for p in pod_names if p != pod}
+
+        return c
+
+    def _completion(self, state: ReplState, leaf: dict[str, any] = None, to_validate = True) -> dict[str, any]:
+        if to_validate and not self.validate_state(state, show_err=False):
             return {}
 
         if is_lambda(leaf):
@@ -181,16 +198,20 @@ 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, default: Union[str, list[str]] = 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) -> tuple[list[str], ReplState]:
-        if len(self.args) < self.count_at_least:
+    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):
@@ -210,7 +231,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

{kaqing-2.0.177 → kaqing-2.0.184}/adam/commands/cql/cqlsh.py

@@ -34,7 +34,7 @@ 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:

{kaqing-2.0.177 → kaqing-2.0.184}/adam/commands/cql/utils_cql.py

@@ -47,7 +47,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 +61,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 +215,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,7 +257,7 @@ 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):
         state = self.handler.state
@@ -312,7 +268,7 @@ class CassandraPodService:
             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)
 
-    def nodetool(self, args: str, show_out = True) -> Union[PodExecResult, list[PodExecResult]]:
+    def nodetool(self, args: str, status = False, show_out = True) -> Union[PodExecResult, list[PodExecResult]]:
         state = self.handler.state
         pod = self.handler.pod
 
@@ -322,7 +278,7 @@ class CassandraPodService:
         if pod:
             return CassandraNodes.exec(pod, state.namespace, command, show_out=show_out)
         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)
 
 class CassandraExecHandler:
     def __init__(self, state: ReplState, pod: str = None):

{kaqing-2.0.177 → kaqing-2.0.184}/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)

{kaqing-2.0.177 → kaqing-2.0.184}/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
 

{kaqing-2.0.177 → kaqing-2.0.184}/adam/commands/devices/device.py

@@ -7,18 +7,23 @@ from adam.repl_state import BashSession, ReplState
 from adam.utils import log2
 
 class Device:
-    @abstractmethod
-    def ls(self, cmd: str, state: ReplState):
-        pass
+    def pods(self, state: ReplState) -> tuple[list[str], str]:
+        return self.pod_names(state), self.pod(state)
 
-    def ls_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        return default
+    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):