kaqing 2.0.52__py3-none-any.whl → 2.0.184__py3-none-any.whl

adam/commands/deploy/deploy_utils.py

@@ -1,39 +1,29 @@
-from typing import Callable
 from adam.app_session import AppSession
-from adam.k8s_utils.ingresses import Ingresses
-from adam.k8s_utils.services import Services
-from adam.utils import log2
+from adam.utils import ing
+from adam.utils_k8s.ingresses import Ingresses
+from adam.utils_k8s.services import Services
 
 def deploy_frontend(name: str, namespace: str, label_selector: str):
     app_session: AppSession = AppSession.create('c3', 'c3', namespace)
     port = 7678
     labels = gen_labels(label_selector)
-    creating('service', lambda: Services.create_service(name, namespace, port, labels, labels=labels))
-    creating('ingress', lambda: Ingresses.create_ingress(name, namespace, app_session.host, '/c3/c3/ops($|/)', port, annotations={
-        'kubernetes.io/ingress.class': 'nginx',
-        'nginx.ingress.kubernetes.io/use-regex': 'true',
-        'nginx.ingress.kubernetes.io/rewrite-target': '/'
-    }, labels=labels))
+    with ing('Creating service'):
+        Services.create_service(name, namespace, port, labels, labels=labels)
+    with ing('Creating ingress'):
+        Ingresses.create_ingress(name, namespace, app_session.host, '/c3/c3/ops($|/)', port, annotations={
+            'kubernetes.io/ingress.class': 'nginx',
+            'nginx.ingress.kubernetes.io/use-regex': 'true',
+            'nginx.ingress.kubernetes.io/rewrite-target': '/'
+        }, labels=labels)
 
     return f'https://{app_session.host}/c3/c3/ops'
 
 def undeploy_frontend(namespace: str, label_selector: str):
-    deleting('ingress', lambda: Ingresses.delete_ingresses(namespace, label_selector=label_selector))
-    deleting('service', lambda: Services.delete_services(namespace, label_selector=label_selector))
+    with ing('Deleting ingress'):
+        Ingresses.delete_ingresses(namespace, label_selector=label_selector)
+    with ing('Deleting service'):
+        Services.delete_services(namespace, label_selector=label_selector)
 
 def gen_labels(label_selector: str):
     kv = label_selector.split('=')
-    return {kv[0]: kv[1]}
-
-def creating(name: str, body: Callable[[], None]):
-    log2(f'Creating {name}...', nl=False)
-    body()
-    log2(' OK')
-
-def deleting(name: str, body: Callable[[], None]):
-    try:
-        log2(f'Deleting {name}...', nl=False)
-        body()
-        log2(' OK')
-    except Exception as e:
-        log2(e)
+    return {kv[0]: kv[1]}

adam/commands/deploy/undeploy.py

@@ -1,14 +1,12 @@
 import click
 
-from adam.commands.command import Command
 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.repl_state import ReplState
+from adam.commands.intermediate_command import IntermediateCommand
 
-class Undeploy(Command):
+class Undeploy(IntermediateCommand):
     COMMAND = 'undeploy'
-    reaper_login = None
 
     # the singleton pattern
     def __new__(cls, *args, **kwargs):
@@ -16,27 +14,12 @@ class Undeploy(Command):
 
         return cls.instance
 
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
     def command(self):
         return Undeploy.COMMAND
 
-    def run(self, cmd: str, state: ReplState):
-        if not(args := self.args(cmd)):
-            return super().run(cmd, state)
-
-        return super().intermediate_run(cmd, state, args, Undeploy.cmd_list())
-
-    def cmd_list():
+    def cmd_list(self):
         return [UndeployFrontend(), UndeployPod(), UndeployPgAgent()]
 
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
-
 class UndeployCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
-        Command.intermediate_help(super().get_help(ctx), Undeploy.COMMAND, Undeploy.cmd_list())
+        IntermediateCommand.intermediate_help(super().get_help(ctx), Undeploy.COMMAND, Undeploy().cmd_list())

adam/commands/deploy/undeploy_frontend.py

@@ -25,14 +25,11 @@ class UndeployFrontend(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
-
-        label_selector = Config().get('pod.label-selector', 'run=ops')
-        undeploy_frontend(state.namespace, label_selector)
+        with self.validate(args, state) as (args, state):
+            label_selector = Config().get('pod.label-selector', 'run=ops')
+            undeploy_frontend(state.namespace, label_selector)
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
         return super().completion(state)

adam/commands/deploy/undeploy_pg_agent.py

@@ -1,8 +1,8 @@
 from adam.commands.command import Command
-from adam.commands.deploy.deploy_utils import deleting
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_databases import PostgresDatabases
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
+from adam.utils import ing
 
 class UndeployPgAgent(Command):
     COMMAND = 'undeploy pg-agent'
@@ -26,13 +26,11 @@ class UndeployPgAgent(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
-
-        deleting('pod', lambda: PostgresSession.undeploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace))
+        with self.validate(args, state) as (args, state):
+            with ing('Deleting pod'):
+                PostgresDatabases.undeploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace)
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
         return super().completion(state)

adam/commands/deploy/undeploy_pod.py

@@ -1,10 +1,11 @@
 from adam.commands.command import Command
-from adam.commands.deploy.deploy_utils import undeploy_frontend, deleting
+from adam.commands.deploy.deploy_utils import undeploy_frontend
 from adam.config import Config
-from adam.k8s_utils.config_maps import ConfigMaps
-from adam.k8s_utils.deployment import Deployments
-from adam.k8s_utils.pods import Pods
-from adam.k8s_utils.service_accounts import ServiceAccounts
+from adam.utils import ing
+from adam.utils_k8s.config_maps import ConfigMaps
+from adam.utils_k8s.deployment import Deployments
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.service_accounts import ServiceAccounts
 from adam.repl_state import ReplState, RequiredState
 
 class UndeployPod(Command):
@@ -29,18 +30,16 @@ class UndeployPod(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
-
-        label_selector = Config().get('pod.label-selector', 'run=ops')
-        deleting('service account', lambda: ServiceAccounts.delete(state.namespace, label_selector=label_selector))
-        deleting('config map', lambda: ConfigMaps.delete_with_selector(state.namespace, label_selector))
-        deleting('deployment', lambda: Deployments.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0))
-        deleting('pod', lambda: Pods.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0))
-        undeploy_frontend(state.namespace, label_selector)
+        with self.validate(args, state) as (args, state):
+            label_selector = Config().get('pod.label-selector', 'run=ops')
+            with ing('Deleting service account'):
+                ServiceAccounts.delete(state.namespace, label_selector=label_selector)
+            with ing('Deleting config map'): ConfigMaps.delete_with_selector(state.namespace, label_selector)
+            with ing('Deleting deployment'): Deployments.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0)
+            with ing('Deleting pod'): Pods.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0)
+            undeploy_frontend(state.namespace, label_selector)
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
         return super().completion(state)

adam/commands/devices/device.py

@@ -0,0 +1,123 @@
+from abc import abstractmethod
+
+from adam.commands.command import Command
+from adam.config import Config
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import BashSession, ReplState
+from adam.utils import log2
+
+class Device:
+    def pods(self, state: ReplState) -> tuple[list[str], str]:
+        return self.pod_names(state), self.pod(state)
+
+    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 ls(self, cmd: str, state: ReplState):
+        pass
+
+    def ls_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        return default
+
+    def cd(self, dir: str, state: ReplState):
+        pass
+
+    def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        return default
+
+    @abstractmethod
+    def pwd(self, state: ReplState):
+        pass
+
+    def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
+        return False, None
+
+    def enter(self, state: ReplState):
+        pass
+
+    def preview(self, table: str, state: ReplState):
+        if not table:
+            if state.in_repl:
+                log2('Table is required.')
+                log2()
+                log2('Tables:')
+                self.show_tables(state)
+            else:
+                log2('* Table is missing.')
+                self.show_tables(state)
+
+                Command.display_help()
+
+            return 'command-missing'
+
+        rows = Config().get('preview.rows', 10)
+        self.show_table_preview(state, table, rows)
+
+        return state
+
+    @abstractmethod
+    def show_tables(self, state: ReplState):
+        pass
+
+    @abstractmethod
+    def show_table_preview(self, state: ReplState, table: str, rows: int):
+        pass
+
+    def bash(self, s0: ReplState, s1: ReplState, args: list[str]):
+        if s1.in_repl:
+            if self.bash_target_changed(s0, s1):
+                r = self._exec_with_dir(s1, args)
+            else:
+                r = self._exec_with_dir(s0, args)
+
+            if not r:
+                s1.exit_bash()
+
+                return 'inconsistent pwd'
+
+            return r
+        else:
+            self.exec_no_dir(' '.join(args), s1)
+
+            return s1
+
+    def _exec_with_dir(self, state: ReplState, args: list[str]) -> list[PodExecResult]:
+        session_just_created = False
+        if not args:
+            session_just_created = True
+            session = BashSession(state.device)
+            state.enter_bash(session)
+
+        if state.bash_session:
+            if args != ['pwd']:
+                if args:
+                    args.append('&&')
+                args.extend(['pwd', '>', f'/tmp/.qing-{state.bash_session.session_id}'])
+
+            if not session_just_created:
+                if pwd := state.bash_session.pwd(state):
+                    args = ['cd', pwd, '&&'] + args
+
+        return self.exec_with_dir(' '.join(args), session_just_created, state)
+
+    @abstractmethod
+    def bash_target_changed(self, s0: ReplState, s1: ReplState):
+        pass
+
+    @abstractmethod
+    def exec_no_dir(self, command: str, state: ReplState):
+        pass
+
+    @abstractmethod
+    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState):
+        pass
+
+    def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        return default

adam/commands/devices/device_app.py

@@ -0,0 +1,163 @@
+from adam.apps import Apps
+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 tabulize, log, wait_log
+from adam.utils_k8s.app_pods import AppPods
+from adam.utils_k8s.ingresses import Ingresses
+
+class DeviceApp(Command, Device):
+    COMMAND = f'{ReplState.A}:'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DeviceApp, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DeviceApp.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not self.args(cmd):
+            return super().run(cmd, state)
+
+        state.device = ReplState.A
+
+        return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    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:
+            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)
+                if not host:
+                    return None
+
+                endpoint = Config().get('app.login.url', 'https://{host}/{env}/{app}').replace('{host}', host).replace('{env}', state.app_env).replace('{app}', 'c3')
+                if not endpoint:
+                    return None
+
+                return f"{n.split('-')[1]},{Ingresses.get_host(f'{ns}-{n}-k8singr-appleader-001', ns)},{endpoint}"
+
+            svcs = [l for l in [line(n, ns) for n, ns in Apps.apps(state.app_env)] if l]
+
+            tabulize(svcs, header='APP,HOST,ENDPOINT', separator=',')
+        else:
+            tabulize(Apps.envs(), lambda a: a[0], header='ENV', separator=',')
+
+    def ls_completion(self, cmd, state, default: dict = {}):
+        if state.app_app:
+            return super().completion(state) | {f'@{p}': {cmd: None} for p in self.pod_names(state)}
+
+        return default
+
+    def cd(self, dir: str, state: ReplState):
+        if dir == '':
+            state.app_env = None
+            state.app_app = None
+            state.app_pod = None
+        elif dir == '..':
+            if state.app_pod:
+                state.app_pod = None
+            elif state.app_app:
+                state.app_app = None
+            else:
+                state.app_env = None
+        else:
+            if state.app_app:
+                state.app_pod = dir
+            elif not state.app_env:
+                tks = dir.split('@')
+                if len(tks) > 1:
+                    state.namespace = tks[1]
+
+                state.app_env = dir.split('@')[0]
+            else:
+                state.app_app = dir
+
+    def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        if 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:
+            return {cmd: {'..': None} | {env[0]: None for env in Apps.envs()}}
+
+    def pwd(self, state: ReplState):
+        words = []
+
+        if state.app_env:
+            words.append(f'env/{state.app_env}')
+        if state.app_app:
+            words.append(f'app/{state.app_app}')
+
+        return '\t'.join([f'{ReplState.X}:>'] + (words if words else ['/']))
+
+    def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
+        if state.app_app:
+            return True, chain.run(f'app {cmd}', state)
+
+        return False, None
+
+    def enter(self, state: ReplState):
+        if not state.app_env:
+            if auto_enter := Config().get('repl.a.auto-enter', 'c3/c3/*'):
+                if auto_enter != 'no':
+                    ea = auto_enter.split('/')
+                    state.app_env = ea[0]
+                    if len(ea) > 2:
+                        state.app_app = ea[1]
+                        state.app_pod = ea[2]
+                        if state.app_pod == '*':
+                            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:
+                                wait_log(f'No pods found, moving to {state.app_env}/{state.app_app}...')
+                        else:
+                            wait_log(f'Moving to {state.app_env}/{state.app_app}/{state.app_pod}...')
+                    elif len(ea) > 1:
+                        state.app_app = ea[1]
+                        wait_log(f'Moving to {state.app_env}/{state.app_app}...')
+                    else:
+                        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

@@ -0,0 +1,49 @@
+from adam.commands.command import Command
+from adam.commands.devices.device import Device
+from adam.repl_state import ReplState
+from adam.utils import tabulize, log
+from adam.utils_athena import Athena
+
+class DeviceAuditLog(Command, Device):
+    COMMAND = f'{ReplState.L}:'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DeviceAuditLog, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DeviceAuditLog.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not self.args(cmd):
+            return super().run(cmd, state)
+
+        state.device = ReplState.L
+
+        return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{DeviceAuditLog.COMMAND}\t move to Audit Log Operations device'
+
+    def ls(self, cmd: str, _: ReplState):
+        tabulize(Athena.table_names(), header='NAME', separator=',')
+
+    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)
+
+    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}')