kaqing 2.0.98__py3-none-any.whl → 2.0.203__py3-none-any.whl

adam/commands/medusa/utils_medusa.py

@@ -0,0 +1,15 @@
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.utils_k8s.custom_resources import CustomResources
+from adam.utils_k8s.statefulsets import StatefulSets
+
+def medusa_backup_names(state: ReplState, warm=False):
+    if warm and (auto := Config().get('medusa.restore-auto-complete', 'off')) in ['off', 'jit', 'lazy']:
+        return {}
+
+    ns = state.namespace
+    dc: str = StatefulSets.get_datacenter(state.sts, ns)
+    if not dc:
+        return {}
+
+    return {id: None for id in [f"{x['metadata']['name']}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]}

adam/commands/nodetool.py

@@ -2,10 +2,10 @@ import click
 
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
+from adam.commands.cql.utils_cql import cassandra
+from adam.commands.devices.devices import Devices
 from adam.commands.nodetool_commands import NODETOOL_COMMANDS
 from adam.config import Config
-from adam.utils_k8s.cassandra_clusters import CassandraClusters
-from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log
 
@@ -31,28 +31,17 @@ class NodeTool(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
-
-        user, pw = state.user_pass()
-        command = f"nodetool -u {user} -pw {pw} {' '.join(args)}"
-
-        if state.pod:
-            return CassandraNodes.exec(state.pod, state.namespace, command, show_out=True)
-        elif state.sts:
-            return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool', show_out=True)
+        with self.validate(args, state) as (args, state):
+            with cassandra(state) as pods:
+                pods.nodetool(' '.join(args), status=(args[0] == 'status'))
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
-        if state.pod or state.sts:
-            return {NodeTool.COMMAND: {'help': None} | {c: None for c in NODETOOL_COMMANDS}}
-
-        return {}
+        return super().completion(state, {c: {'&': None} for c in NODETOOL_COMMANDS}, pods=Devices.of(state).pods(state, '-'))
 
     def help(self, _: ReplState):
-        return f'{NodeTool.COMMAND} <sub-command>\t run nodetool with arguments'
+        return f'{NodeTool.COMMAND} <sub-command> [&]\t run nodetool with arguments'
 
 class NodeToolCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):

adam/commands/os/cat.py

@@ -0,0 +1,36 @@
+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
+
+class Cat(Command):
+    COMMAND = 'cat'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Cat, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Cat.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'):
+                return Devices.of(state).bash(state, state, cmd.split(' '))
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {f: None for f in Devices.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{Cat.COMMAND} file [&]\t run cat command on the pod'

adam/commands/os/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.utils_k8s.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.of(state).pod(state),
+                                             Devices.of(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.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{DownloadFile.COMMAND} from-file [to-file]\t download file from pod'

adam/commands/os/find_files.py

@@ -0,0 +1,51 @@
+import os
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2
+from adam.utils_local import local_tmp_dir
+
+class FindLocalFiles(Command):
+    COMMAND = 'find local'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(FindLocalFiles, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return FindLocalFiles.COMMAND
+
+    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):
+            cmd = 'find'
+
+            if not args:
+                cmd = f'find {local_tmp_dir()}'
+            elif len(args) == 1:
+                cmd = f"find {local_tmp_dir()} -name '{args[0]}'"
+            else:
+                new_args = [f"'{arg}'" if '*' in arg else arg for arg in args]
+                cmd = 'find ' + ' '.join(new_args)
+
+            log2(cmd)
+            os.system(cmd)
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {
+            '*.csv': None,
+            '*.db': None,
+            '*': None
+        })
+
+    def help(self, _: ReplState):
+        return f'{FindLocalFiles.COMMAND} [linux-find-arguments]\t find files from local machine'

adam/commands/os/find_processes.py

@@ -0,0 +1,76 @@
+from adam.commands import extract_options, validate_args
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.commands.export.utils_export import state_with_pod
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2, tabulize
+
+class FindProcesses(Command):
+    COMMAND = 'find processes'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(FindProcesses, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return FindProcesses.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 extract_options(args, '-kill') as (args, kill):
+                with validate_args(args, state, name='words to look for'):
+                    arg = ' | '.join([f'grep {a}' for a in args])
+                    awk = "awk '{ print $1, $2, $8, $NF }'"
+                    rs = Devices.of(state).bash(state, state, f"ps -ef | grep -v grep | {arg} | {awk}".split(' '))
+
+                    lines: list[list[str]] = []
+                    for r in rs:
+                        for l in r.stdout.split('\n'):
+                            l = l.strip(' \t\r\n')
+                            if not l:
+                                continue
+
+                            tokens = [r.pod] + l.split(' ')
+                            lines.append(tokens)
+
+                    pids = []
+                    for l in lines:
+                        pids.append(f'{l[2]}@{l[0]}')
+
+                    tabulize(lines, lambda l: '\t'.join(l), header = 'POD\tUSER\tPID\tCMD\tLAST_ARG', separator='\t')
+                    log2()
+                    log2(f'PIDS with {",".join(args)}: {",".join(pids)}')
+
+                    if kill:
+                        log2()
+                        for pidp in pids:
+                            pid_n_pod = pidp.split('@')
+                            pid = pid_n_pod[0]
+                            if len(pid_n_pod) < 2:
+                                continue
+
+                            pod = pid_n_pod[1]
+
+                            log2(f'@{pod} bash kill -9 {pid}')
+
+                            with state_with_pod(state, pod) as state1:
+                                Devices.of(state).bash(state, state1, ['kill', '-9', pid])
+
+                    return rs
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{FindProcesses.COMMAND} word... [-kill]\t find processes with words'

adam/commands/os/head.py

@@ -0,0 +1,36 @@
+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
+
+class Head(Command):
+    COMMAND = 'head'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Head, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Head.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'):
+                return Devices.of(state).bash(state, state, cmd.split(' '))
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {f: None for f in Devices.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{Head.COMMAND} file [&]\t run head command on the pod'

adam/commands/os/shell.py

@@ -0,0 +1,41 @@
+import os
+
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2
+
+class Shell(Command):
+    COMMAND = ':sh'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Shell, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Shell.COMMAND
+
+    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, _):
+            with validate_args(args, state, at_least=0) as args_str:
+                if args_str:
+                    os.system(args_str)
+                    log2()
+                else:
+                    os.system('QING_DROPPED=true bash')
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{Shell.COMMAND}\t drop down to shell'

adam/commands/param_get.py

@@ -1,7 +1,8 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 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
 
 class GetParam(Command):
     COMMAND = 'get'
@@ -22,21 +23,17 @@ class GetParam(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
+        with self.validate(args, state) as (args, state):
+            def msg():
+                tabulize(Config().keys(), lambda key: f'{key}\t{Config().get(key, None)}', separator='\t')
 
-        if len(args) < 1:
-            lines = [f'{key}\t{Config().get(key, None)}' for key in Config().keys()]
-            log(lines_to_tabular(lines, separator='\t'))
+            with validate_args(args, state, msg=msg) as key:
+                if v := Config().get(key, None):
+                    log(v)
+                else:
+                    log2(f'{key} is not set.')
 
-            return state
-
-        key = args[0]
-        if v := Config().get(key, None):
-            log(v)
-        else:
-            log2(f'{key} is not set.')
-
-        return v if v else state
+                return v if v else state
 
     def completion(self, _: ReplState):
         return {GetParam.COMMAND: {key: None for key in Config().keys()}}

adam/commands/param_set.py

@@ -1,3 +1,4 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.config import Config
 from adam.repl_state import ReplState
@@ -22,20 +23,15 @@ class SetParam(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, exactly=2, msg=lambda: log2('set <key> <value>')):
+                key = args[0]
+                value = args[1]
+                Config().set(key, value)
 
-        if len(args) < 2:
-            log2('set <key> <value>')
+                log(Config().get(key, None))
 
-            return 'invalid args'
-
-        key = args[0]
-        value = args[1]
-        Config().set(key, value)
-
-        log(Config().get(key, None))
-
-        return value
+                return value
 
     def completion(self, _: ReplState):
         return {SetParam.COMMAND: {key: ({'true': None, 'false': None} if Config().get(key, None) in [True, False] else None) for key in Config().keys()}}

adam/commands/postgres/completions_p.py

@@ -0,0 +1,22 @@
+from adam.commands.postgres.postgres_databases import PostgresDatabases
+from adam.commands.postgres.utils_postgres import pg_table_names
+from adam.repl_state import ReplState
+from adam.sql.lark_completer import LarkCompleter
+
+def completions_p(state: ReplState):
+    return {
+        '\h': None,
+        '\d': None,
+        '\dt': None,
+        '\du': None
+    } | LarkCompleter(expandables={
+        'tables': lambda x: pg_table_names(state),
+        'columns': lambda x: ['id'],
+        'hosts': lambda x: ['@' + PostgresDatabases.pod_and_container(state.namespace)[0]],
+    }, variant=ReplState.P).completions_for_nesting()
+
+def psql0_completions(state: ReplState):
+    return {
+        '\h': None,
+        '\l': None,
+    }

adam/commands/postgres/postgres.py

@@ -1,17 +1,18 @@
 import click
 
+from adam.commands import extract_trailing_options, validate_args
 from adam.commands.command import Command
-from adam.commands.postgres.psql_completions import psql_completions
-from adam.commands.postgres.postgres_utils import pg_table_names
+from adam.commands.intermediate_command import IntermediateCommand
+from adam.commands.postgres.postgres_databases import pg_path
+from adam.commands.postgres.completions_p import psql0_completions, completions_p
+from adam.commands.postgres.utils_postgres import pg_table_names, postgres
 from .postgres_ls import PostgresLs
 from .postgres_preview import PostgresPreview
-from .postgres_session import PostgresSession
 from adam.repl_state import ReplState
-from adam.utils import log, log2
+from adam.utils import log, log2, log_timing
 
-class Postgres(Command):
+class Postgres(IntermediateCommand):
     COMMAND = 'pg'
-    reaper_login = None
 
     # the singleton pattern
     def __new__(cls, *args, **kwargs):
@@ -29,69 +30,60 @@ class Postgres(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
+        with self.validate(args, state) as (args, state):
+            with extract_trailing_options(args, '&') as (args, backgrounded):
+                with validate_args(args, state, name='SQL statement') as sql:
+                    if not state.pg_path:
+                        if state.in_repl:
+                            log2('Enter "use <pg-name>" first.')
+                        else:
+                            log2('* pg-name is missing.')
 
-        if not args:
-            if state.in_repl:
-                log2('Please use SQL statement. e.g. pg \l')
-            else:
-                log2('* Command or SQL statements is missing.')
-                Command.display_help()
+                        return state
 
-            return 'command-missing'
+                    if state.in_repl:
+                        with postgres(state) as pod:
+                            pod.sql(args, backgrounded=backgrounded)
+                    elif not self.run_subcommand(cmd, state):
+                        with postgres(state) as pod:
+                            pod.sql(args, backgrounded=backgrounded)
 
-        if state.in_repl:
-            self.run_sql(state, args)
-        else:
-            # head with the Chain of Responsibility pattern
-            cmds = Command.chain(Postgres.cmd_list())
-            if not cmds.run(cmd, state) :
-                self.run_sql(state, args)
+                    return state
 
-        return state
-
-    def cmd_list():
-        return [PostgresLs(), PostgresPreview()]
-
-    def run_sql(self, state: ReplState, args: list[str]):
-        if not state.pg_path:
-            if state.in_repl:
-                log2('Enter "use <pg-name>" first.')
-            else:
-                log2('* pg-name is missing.')
-
-            return state
-
-        PostgresSession(state.namespace, state.pg_path).run_sql(' '.join(args))
+    def cmd_list(self):
+        return [PostgresLs(), PostgresPreview(), PostgresPg()]
 
     def completion(self, state: ReplState):
         if state.device != state.P:
-            # conflicts with cql completions
             return {}
 
-        leaf = {}
-        session = PostgresSession(state.namespace, state.pg_path)
-        if session.db:
-          if pg_table_names(state.namespace, state.pg_path):
-            leaf = psql_completions(state.namespace, state.pg_path)
-        elif state.pg_path:
-            leaf = {
-                '\h': None,
-                '\l': None,
-            }
-
-        if state.pg_path:
-            return super().completion(state, leaf) | leaf
-        else:
-            return {}
+        with pg_path(state) as (host, database):
+            if database:
+                if pg_table_names(state):
+                    with log_timing('psql_completions'):
+                        return completions_p(state)
+            elif host:
+                return psql0_completions(state)
+
+        return {}
 
     def help(self, _: ReplState):
-        return f'[{Postgres.COMMAND}] <sql-statements>\t run psql with queries'
+        return f'<sql-statements> [&]\t run queries on Postgres databases'
 
 class PostgresCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
-        Command.intermediate_help(super().get_help(ctx), Postgres.COMMAND, Postgres.cmd_list(), show_cluster_help=True)
+        IntermediateCommand.intermediate_help(super().get_help(ctx), Postgres.COMMAND, Postgres().cmd_list(), show_cluster_help=True)
         log('PG-Name:  Kubernetes secret for Postgres credentials')
         log('          e.g. stgawsscpsr-c3-c3-k8spg-cs-001')
         log('Database: Postgres database name within a host')
-        log('          e.g. stgawsscpsr_c3_c3')
+        log('          e.g. stgawsscpsr_c3_c3')
+
+# No action body, only for a help entry and auto-completion
+class PostgresPg(Command):
+    COMMAND = 'pg'
+
+    def command(self):
+        return PostgresPg.COMMAND
+
+    def help(self, _: ReplState):
+        return f'pg <sql-statements>\t run queries on Postgres databases'