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

adam/repl_commands.py

@@ -1,5 +1,13 @@
-from adam.commands.app import App
-from adam.commands.app_ping import AppPing
+from adam.commands.alter_tables import AlterTables
+from adam.commands.app.app import App
+from adam.commands.app.app_ping import AppPing
+from adam.commands.app.show_app_actions import ShowAppActions
+from adam.commands.app.show_app_id import ShowAppId
+from adam.commands.app.show_app_queues import ShowAppQueues
+from adam.commands.audit.audit import Audit
+from adam.commands.cat import Cat
+from adam.commands.code import Code
+from adam.commands.download_file import DownloadFile
 from adam.commands.deploy.code_start import CodeStart
 from adam.commands.deploy.code_stop import CodeStop
 from adam.commands.deploy.deploy import Deploy
@@ -10,22 +18,44 @@ 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.devices.device_app import DeviceApp
+from adam.commands.devices.device_auit_log import DeviceAuditLog
+from adam.commands.devices.device_cass import DeviceCass
+from adam.commands.devices.device_export import DeviceExport
+from adam.commands.devices.device_postgres import DevicePostgres
+from adam.commands.export.download_export_session import DownloadExportSession
+from adam.commands.export.drop_export_database import DropExportDatabase
+from adam.commands.export.export import ExportTables
+from adam.commands.export.import_files import ImportCSVFiles
+from adam.commands.export.import_session import ImportSession
+from adam.commands.export.clean_up_export_sessions import CleanUpExportSessions
+from adam.commands.export.clean_up_all_export_sessions import CleanUpAllExportSessions
+from adam.commands.export.drop_export_databases import DropExportDatabases
+from adam.commands.export.export_x_select import ExportXSelect
+from adam.commands.export.export_use import ExportUse
+from adam.commands.export.export_select import ExportSelect
+from adam.commands.export.show_column_counts import ShowColumnCounts
+from adam.commands.export.show_export_databases import ShowExportDatabases
+from adam.commands.export.show_export_session import ShowExportSession
+from adam.commands.export.show_export_sessions import ShowExportSessions
+from adam.commands.find_files import FindLocalFiles
+from adam.commands.find_processes import FindProcesses
+from adam.commands.head import Head
+from adam.commands.kubectl import Kubectl
 from adam.commands.shell import Shell
-from adam.commands.show.show_app_queues import ShowAppQueues
-from adam.commands.cp import ClipboardCopy
-from adam.commands.bash import Bash
+from adam.commands.clipboard_copy import ClipboardCopy
+from adam.commands.bash.bash import Bash
 from adam.commands.cd import Cd
 from adam.commands.check import Check
 from adam.commands.command import Command
-from adam.commands.cqlsh import Cqlsh
-from adam.commands.devices import DeviceApp, DeviceCass, DevicePostgres
+from adam.commands.cql.cqlsh import Cqlsh
 from adam.commands.exit import Exit
 from adam.commands.medusa.medusa import Medusa
 from adam.commands.param_get import GetParam
 from adam.commands.issues import Issues
 from adam.commands.ls import Ls
 from adam.commands.nodetool import NodeTool
-from adam.commands.postgres.postgres import Postgres
+from adam.commands.postgres.postgres import Postgres, PostgresPg
 from adam.commands.preview_table import PreviewTable
 from adam.commands.pwd import Pwd
 from adam.commands.reaper.reaper import Reaper
@@ -35,25 +65,24 @@ from adam.commands.restart import Restart
 from adam.commands.rollout import RollOut
 from adam.commands.param_set import SetParam
 from adam.commands.show.show import Show
-from adam.commands.show.show_app_actions import ShowAppActions
-from adam.commands.show.show_app_id import ShowAppId
 from adam.commands.show.show_cassandra_status import ShowCassandraStatus
 from adam.commands.show.show_cassandra_version import ShowCassandraVersion
-from adam.commands.show.show_commands import ShowKubectlCommands
+from adam.commands.show.show_cli_commands import ShowKubectlCommands
+from adam.commands.show.show_host import ShowHost
 from adam.commands.show.show_login import ShowLogin
 from adam.commands.show.show_params import ShowParams
 from adam.commands.show.show_processes import ShowProcesses
-from adam.commands.show.show_repairs import ShowRepairs
+from adam.commands.show.show_cassandra_repairs import ShowCassandraRepairs
 from adam.commands.show.show_storage import ShowStorage
 from adam.commands.show.show_adam import ShowAdam
 from adam.commands.watch import Watch
 
 class ReplCommands:
     def repl_cmd_list() -> list[Command]:
-        cmds: list[Command] = ReplCommands.navigation() + ReplCommands.cassandra_check() + ReplCommands.cassandra_ops() + \
-            ReplCommands.tools() + ReplCommands.app() + ReplCommands.exit()
+        cmds: list[Command] = ReplCommands.navigation() + ReplCommands.cassandra_ops() + ReplCommands.postgres_ops() + \
+            ReplCommands.app_ops() + ReplCommands.audit_ops() + ReplCommands.export_ops() + ReplCommands.tools() + ReplCommands.exit()
 
-        intermediate_cmds: list[Command] = [App(), Reaper(), Repair(), Deploy(), Show(), Undeploy()]
+        intermediate_cmds: list[Command] = [App(), Audit(), Reaper(), Repair(), Deploy(), Show(), Undeploy()]
         ic = [c.command() for c in intermediate_cmds]
         # 1. dedup commands
         deduped = []
@@ -70,20 +99,33 @@ class ReplCommands:
         return deduped
 
     def navigation() -> list[Command]:
-        return [Ls(), PreviewTable(), DeviceApp(), DevicePostgres(), DeviceCass(), Cd(), Pwd(), ClipboardCopy(),
-                GetParam(), SetParam(), ShowParams(), ShowKubectlCommands(), ShowLogin(), ShowAdam()]
-
-    def cassandra_check() -> list[Command]:
-        return [ShowCassandraStatus(), ShowCassandraVersion(), ShowRepairs(), ShowStorage(), ShowProcesses(), Check(), Issues(), NodeTool(), Report()]
+        return [Ls(), PreviewTable(), DeviceApp(), DevicePostgres(), DeviceCass(), DeviceAuditLog(), DeviceExport(),
+                Cd(), Cat(), Head(), DownloadFile(), FindLocalFiles(), FindProcesses(), Pwd(), ClipboardCopy(),
+                GetParam(), SetParam(), ShowParams(), ShowKubectlCommands(), ShowLogin(), ShowAdam(), ShowHost()]
 
     def cassandra_ops() -> list[Command]:
-        return Medusa.cmd_list() + [Restart(), RollOut(), Watch()] + Reaper.cmd_list() + Repair.cmd_list()
+        return [Cqlsh(), ShowCassandraStatus(), ShowCassandraVersion(), ShowCassandraRepairs(), ShowStorage(), ShowProcesses(),
+                Check(), Issues(), NodeTool(), Report(), AlterTables(), Bash(),
+                ExportTables(), ExportXSelect(), ExportUse(),  ShowExportDatabases(), ShowColumnCounts(),
+                DropExportDatabase(), DropExportDatabases(),
+                ShowExportSessions(), ShowExportSession(), DownloadExportSession(),
+                CleanUpExportSessions(), CleanUpAllExportSessions(), ImportSession(), ImportCSVFiles()] + \
+                Medusa().cmd_list() + [Restart(), RollOut(), Watch()] + Reaper().cmd_list() + Repair().cmd_list()
 
-    def tools() -> list[Command]:
-        return [Cqlsh(), Postgres(), Bash(), Shell(), CodeStart(), CodeStop(), DeployFrontend(), UndeployFrontend(), DeployPod(), UndeployPod(), DeployPgAgent(), UndeployPgAgent()]
+    def postgres_ops() -> list[Command]:
+        return [Postgres(), DeployPgAgent(), UndeployPgAgent(), PostgresPg()]
 
-    def app() -> list[Command]:
+    def app_ops() -> list[Command]:
         return [ShowAppActions(), ShowAppId(), ShowAppQueues(), AppPing(), App()]
 
+    def audit_ops() -> list[Command]:
+        return [Audit()] + Audit().cmd_list()
+
+    def export_ops() -> list[Command]:
+        return [ExportSelect(), DropExportDatabase(), DropExportDatabases(), ShowColumnCounts()]
+
+    def tools() -> list[Command]:
+        return [Shell(), CodeStart(), CodeStop(), DeployFrontend(), UndeployFrontend(), DeployPod(), UndeployPod(), Kubectl(), Code()]
+
     def exit() -> list[Command]:
         return [Exit()]

adam/repl_session.py

@@ -1,6 +1,8 @@
 from prompt_toolkit import PromptSession
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 
+from adam.config import Config
+
 class ReplSession:
     # the singleton pattern
     def __new__(cls, *args, **kwargs):
@@ -10,4 +12,9 @@ class ReplSession:
 
     def __init__(self):
         if not hasattr(self, 'prompt_session'):
-            self.prompt_session = PromptSession(auto_suggest=AutoSuggestFromHistory())
+            self.prompt_session = PromptSession(auto_suggest=AutoSuggestFromHistory())
+
+    def append_history(self, entry: str):
+        if entry and Config().get('repl.history.push-cat-remote-log-file', True):
+            if self.prompt_session:
+                self.prompt_session.history.append_string(entry)

adam/repl_state.py

@@ -1,11 +1,14 @@
-import copy
+from copy import copy
 from enum import Enum
-
-from adam.commands.postgres.postgres_session import PostgresSession
-from adam.k8s_utils.cassandra_clusters import CassandraClusters
-from adam.k8s_utils.cassandra_nodes import CassandraNodes
-from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.secrets import Secrets
+import re
+from typing import Callable
+
+from adam.utils_k8s.app_clusters import AppClusters
+from adam.utils_k8s.app_pods import AppPods
+from adam.utils_k8s.cassandra_clusters import CassandraClusters
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.secrets import Secrets
 from adam.utils import display_help, log2, random_alphanumeric
 
 class BashSession:
@@ -16,25 +19,8 @@ class BashSession:
     def pwd(self, state: 'ReplState'):
         command = f'cat /tmp/.qing-{self.session_id}'
 
-        if state.pod:
-            rs = [CassandraNodes.exec(state.pod, state.namespace, command, show_out=False)]
-        elif state.sts:
-            rs = CassandraClusters.exec(state.sts, state.namespace, command, action='bash', show_out=False)
-
-        dir = None
-        for r in rs:
-            if r.exit_code(): # if fails to read the session file, ignore
-                continue
-
-            dir0 = r.stdout.strip(' \r\n')
-            if dir:
-                if dir != dir0:
-                    log2('Inconsitent working dir found across multiple pods.')
-                    return None
-            else:
-                dir = dir0
-
-        return dir
+        with device(state) as pods:
+            return pods.exec(command, action='bash', show_out=False)
 
 class RequiredState(Enum):
     CLUSTER = 'cluster'
@@ -43,16 +29,22 @@ class RequiredState(Enum):
     NAMESPACE = 'namespace'
     PG_DATABASE = 'pg_database'
     APP_APP = 'app_app'
+    EXPORT_DB = 'export_db'
 
 class ReplState:
     A = 'a'
     C = 'c'
+    L = 'l'
     P = 'p'
+    X = 'x'
+
+    ANY = [A, C, L, P, X]
+    NON_L = [A, C, P, X]
 
     def __init__(self, device: str = None,
                  sts: str = None, pod: str = None, namespace: str = None, ns_sts: str = None,
                  pg_path: str = None,
-                 app_env: str = None, app_app: str = None,
+                 app_env: str = None, app_app: str = None, app_pod: str = None,
                  in_repl = False, bash_session: BashSession = None, remote_dir = None):
         self.namespace = KubeContext.in_cluster_namespace()
 
@@ -62,12 +54,16 @@ class ReplState:
         self.pg_path = pg_path
         self.app_env = app_env
         self.app_app = app_app
+        self.app_pod = app_pod
         if namespace:
             self.namespace = namespace
         self.in_repl = in_repl
         self.bash_session = bash_session
         self.remote_dir = remote_dir
-        self.wait_log_flag = False
+        self.original_state: ReplState = None
+        self.pod_targetted = False
+
+        self.export_session: str = None
 
         if ns_sts:
             nn = ns_sts.split('@')
@@ -82,13 +78,51 @@ class ReplState:
     def __hash__(self):
         return hash((self.sts, self.pod))
 
-    def apply_args(self, args: list[str], cmd: list[str] = None, resolve_pg = True) -> tuple['ReplState', list[str]]:
+    def __str__(self):
+        msg = ''
+        if self.device == ReplState.P:
+            msg = f'{ReplState.P}:'
+            host, database = self.pg_host_n_database()
+            if database:
+                msg += database
+            elif host:
+                msg += host
+        elif self.device == ReplState.A:
+            msg = f'{ReplState.A}:'
+            if self.app_env:
+                msg += self.app_env
+            if self.app_app:
+                msg += f'/{self.app_app}'
+            if self.app_pod:
+                # azops88-c3-c3-k8sdeploy-appleader-001-79957cf5b6-9k4bw
+                group = re.match(r".*?-.*?-.*?-.*?-(.*?-.*?)-.*", self.app_pod)
+                msg += '/' + group[1]
+        elif self.device == ReplState.L:
+            msg = f'{ReplState.L}:'
+        elif self.device == ReplState.X:
+            msg = f'{ReplState.X}:'
+            if self.export_session:
+                msg += self.export_session
+        else:
+            msg = f'{ReplState.C}:'
+            if self.pod:
+                # cs-d0767a536f-cs-d0767a536f-default-sts-0
+                group = re.match(r".*?-.*?-(.*)", self.pod)
+                msg += group[1]
+            elif self.sts:
+                # cs-d0767a536f-cs-d0767a536f-default-sts
+                group = re.match(r".*?-.*?-(.*)", self.sts)
+                msg += group[1]
+
+        return msg
+
+    def apply_args(self, args: list[str], cmd: list[str] = None, resolve_pg = True, args_to_check = 6) -> tuple['ReplState', list[str]]:
         state = self
 
         new_args = []
         for index, arg in enumerate(args):
-            if index < 6:
-                state = copy.copy(state)
+            if index < args_to_check:
+                state = copy(state)
 
                 s, n = KubeContext.is_sts_name(arg)
                 if s:
@@ -120,92 +154,328 @@ class ReplState:
 
         return (state, new_args)
 
-    def validate(self, required: RequiredState = None, pg_required: RequiredState = None, app_required: RequiredState = None):
-        if not pg_required and not app_required:
-            if required == RequiredState.CLUSTER:
-                if not self.namespace or not self.sts:
+    def apply_device_arg(self, args: list[str], cmd: list[str] = None) -> tuple['ReplState', list[str]]:
+        state = self
+
+        new_args = []
+        for index, arg in enumerate(args):
+            if index < 6:
+                state = copy(state)
+
+                groups = re.match(r'^([a|c|l|p|x]):(.*)$', arg)
+                if groups:
+                    if groups[1] == 'p':
+                        state.device = 'p'
+                        state.pg_path = groups[2]
+                    elif groups[1] == 'c':
+                        state.device = 'c'
+                        if path := groups[2]:
+                            p_and_ns = path.split('@')
+                            sts_and_pod = p_and_ns[0].split('/')
+                            state.sts = sts_and_pod[0]
+                            if len(sts_and_pod) > 1:
+                                state.pod = sts_and_pod[1]
+                            if len(p_and_ns) > 1:
+                                state.namespace = p_and_ns[1]
+                            elif ns := KubeContext.in_cluster_namespace():
+                                state.namespace = ns
+                    elif groups[1] == 'l':
+                        state.device = 'l'
+                    elif groups[1] == 'x':
+                        state.device = 'x'
+                    else:
+                        state.device = 'a'
+                        if path := groups[2]:
+                            env_and_app = path.split('/')
+                            state.app_env = env_and_app[0]
+                            if len(env_and_app) > 1:
+                                state.app_app = env_and_app[1]
+                else:
+                    new_args.append(arg)
+            else:
+                new_args.append(arg)
+
+        if cmd:
+            new_args = new_args[len(cmd):]
+
+        return (state, new_args)
+
+    def validate(self, required: list[RequiredState] = [], show_err = True):
+        if not required:
+            return True
+
+        def default_err():
+            if self.in_repl:
+                log2(f'Not a valid command on {self.device}: drive.')
+            else:
+                log2('* on a wrong device.')
+                log2()
+                display_help()
+
+        if type(required) is not list:
+            valid, err = self._validate(required)
+            if valid:
+                return True
+
+            if show_err:
+                if err:
+                    err()
+                else:
+                    default_err()
+
+            return False
+
+        devices = [r for r in required if r in [ReplState.L, ReplState.A, ReplState.C, ReplState.P, ReplState.X]]
+        non_devices = [r for r in required if r not in [ReplState.L, ReplState.A, ReplState.C, ReplState.P, ReplState.X]]
+
+        first_error: Callable = None
+        for r in non_devices:
+            valid, err = self._validate(r)
+            if valid:
+                return True
+
+            if not first_error:
+                first_error = err
+
+        if devices:
+            valid, err = self._validate_device(devices)
+            if valid:
+                return True
+
+            if not first_error:
+                first_error = err
+
+        if show_err and first_error:
+            if first_error:
+                first_error()
+            else:
+                default_err()
+
+        return False
+
+    def _validate(self, required: RequiredState):
+        if required == RequiredState.CLUSTER:
+            if self.device != ReplState.C:
+                return (False, None)
+
+            if not self.namespace or not self.sts:
+                def error():
                     if self.in_repl:
                         log2('cd to a Cassandra cluster first.')
                     else:
                         log2('* Cassandra cluster is missing.')
                         log2()
                         display_help()
+                return (False, error)
+
+        elif required == RequiredState.POD:
+            if self.device != ReplState.C:
+                return (False, None)
 
-                    return False
-            elif required == RequiredState.POD:
-                if not self.namespace or not self.pod:
+            if not self.namespace or not self.pod:
+                def error():
                     if self.in_repl:
                         log2('cd to a pod first.')
                     else:
                         log2('* Pod is missing.')
                         log2()
                         display_help()
+                return (False, error)
 
-                    return False
-            elif required == RequiredState.CLUSTER_OR_POD:
-                if not self.namespace or not self.sts and not self.pod:
+        elif required == RequiredState.CLUSTER_OR_POD:
+            if self.device != ReplState.C:
+                return (False, None)
+
+            if not self.namespace or not self.sts and not self.pod:
+                def error():
                     if self.in_repl:
                         log2('cd to a Cassandra cluster first.')
                     else:
                         log2('* Cassandra cluster or pod is missing.')
                         log2()
                         display_help()
+                return (False, error)
+
+        elif required == RequiredState.NAMESPACE:
+            if self.device != ReplState.C:
+                return (False, None)
 
-                    return False
-            elif required == RequiredState.NAMESPACE:
-                if not self.namespace:
+            if not self.namespace:
+                def error():
                     if self.in_repl:
                         log2('Namespace is required.')
                     else:
                         log2('* namespace is missing.')
                         log2()
                         display_help()
+                return (False, error)
+
+        elif required == RequiredState.PG_DATABASE:
+            if self.device != ReplState.P:
+                return (False, None)
+
+            _, database = self.pg_host_n_database()
+            if not database:
+                def error():
+                    if self.in_repl:
+                        log2('cd to a database first.')
+                    else:
+                        log2('* database is missing.')
+                        log2()
+                        display_help()
+                return (False, error)
 
-                    return False
+        elif required == RequiredState.APP_APP:
+            if self.device != ReplState.A:
+                return (False, None)
+
+            if not self.app_app:
+                def error():
+                    if self.in_repl:
+                        log2('cd to an app first.')
+                    else:
+                        log2('* app is missing.')
+                        log2()
+                        display_help()
+                return (False, error)
+
+        elif required == RequiredState.EXPORT_DB:
+            if self.device not in [ReplState.C, ReplState.X]:
+                return (False, None)
+
+            if not self.export_session:
+                def error():
+                    if self.in_repl:
+                        if self.device == ReplState.C:
+                            log2("Select an export database first with 'use' command.")
+                        else:
+                            log2('cd to an export database first.')
+                    else:
+                        log2('* export database is missing.')
+                        log2()
+                        display_help()
+                return (False, error)
 
-        if pg_required == RequiredState.PG_DATABASE:
-            pg = PostgresSession(self.namespace, self.pg_path)
-            if not pg.db:
+        elif required in [ReplState.L, ReplState.A, ReplState.C, ReplState.P, ReplState.X] and self.device != required:
+            def error():
                 if self.in_repl:
-                    log2('cd to a database first.')
+                    log2(f'Switch to {required}: first.')
                 else:
-                    log2('* database is missing.')
+                    log2('* on a wrong device.')
                     log2()
                     display_help()
+            return (False, error)
 
-                return False
+        return (True, None)
 
-        if app_required == RequiredState.APP_APP and not self.app_app:
-            if self.in_repl:
-                log2('cd to an app first.')
-            else:
-                log2('* app is missing.')
-                log2()
-                display_help()
-
-            return False
+    def _validate_device(self, devices: list[RequiredState]):
+        if self.device not in devices:
+            def error():
+                if self.in_repl:
+                    log2(f'Not a valid command on {self.device}: drive.')
+                else:
+                    log2('* on a wrong device.')
+                    log2()
+                    display_help()
+            return (False, error)
 
-        return True
+        return (True, None)
 
     def user_pass(self, secret_path = 'cql.secret'):
         return Secrets.get_user_pass(self.pod if self.pod else self.sts, self.namespace, secret_path=secret_path)
 
     def enter_bash(self, bash_session: BashSession):
+        self.push()
+
         self.bash_session = bash_session
-        if self.device != ReplState.C:
-            self.device = ReplState.C
-            log2(f'Moved to {ReplState.C}: automatically. Will move back to {ReplState.P}: when you exit the bash session.')
 
     def exit_bash(self):
-        if self.bash_session and self.bash_session.device:
-            self.device = self.bash_session.device
-
+        self.pop()
         self.bash_session = None
 
-    def wait_log(self, msg: str):
-        if not self.wait_log_flag:
-            log2(msg)
-            self.wait_log_flag = True
+    def push(self, pod_targetted=False):
+        if not self.original_state:
+            self.original_state = copy(self)
+            self.pod_targetted = pod_targetted
+
+    def pop(self):
+        if o := self.original_state:
+            self.device = o.device
+            self.sts = o.sts
+            self.pod = o.pod
+            self.pg_path = o.pg_path
+            self.app_env = o.app_env
+            self.app_app = o.app_app
+            self.app_pod = o.app_pod
+            # self.export_session = o.export_session
+            self.namespace = o.namespace
+
+            self.original_state = None
+            self.pod_targetted = False
+
+    def pg_host_n_database(self):
+        host = None
+        database = None
+
+        if self.pg_path:
+            host_n_db = self.pg_path.split('/')
+            host = host_n_db[0]
+            if len(host_n_db) > 1:
+                database = host_n_db[1]
+
+        return host, database
+
+    def with_no_pod(self):
+        state1 = copy(self)
+        state1.pod = None
+
+        return state1
+
+class DevicePodService:
+    def __init__(self, handler: 'DeviceExecHandler'):
+        self.handler = handler
+
+    def exec(self, command: str, action='bash', show_out = True):
+        state = self.handler.state
+
+        rs = None
+        if state.device == ReplState.A and state.app_app:
+            if state.app_pod:
+                rs = [AppPods.exec(state.app_pod, state.namespace, command, show_out=show_out)]
+            else:
+                pods = AppPods.pod_names(state.namespace, state.app_env, state.app_app)
+                rs = AppClusters.exec(pods, state.namespace, command, show_out=show_out)
+        elif state.pod:
+            rs = [CassandraNodes.exec(state.pod, state.namespace, command, show_out=show_out)]
+        elif state.sts:
+            rs = CassandraClusters.exec(state.sts, state.namespace, command, action=action, show_out=show_out)
+        # assume that pg-agent or ops pod is single pod
+
+        dir = None
+        if rs:
+            for r in rs:
+                if r.exit_code(): # if fails to read the session file, ignore
+                    continue
+
+                dir0 = r.stdout.strip(' \r\n')
+                if dir:
+                    if dir != dir0:
+                        log2('Inconsitent working dir found across multiple pods.')
+                        return None
+                else:
+                    dir = dir0
+
+        return dir
+
+class DeviceExecHandler:
+    def __init__(self, state: ReplState):
+        self.state = state
+
+    def __enter__(self):
+        return DevicePodService(self)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
 
-    def clear_wait_log_flag(self):
-        self.wait_log_flag = False
+def device(state: ReplState):
+    return DeviceExecHandler(state)