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

adam/commands/bash/bash.py

@@ -0,0 +1,36 @@
+from adam.commands.bash import bash
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState, RequiredState
+
+class Bash(Command):
+    COMMAND = 'bash'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Bash, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Bash.COMMAND
+
+    def required(self):
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
+
+    def run(self, cmd: str, s0: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, s0)
+
+        with self.validate(args, s0) as (args, s1):
+            with bash(s0, s1) as exec:
+                return exec(args)
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {c : {'&': None} for c in ['ls', 'cat', 'head']}, pods=Devices.device(state).pods(state, '-'))
+
+    def help(self, _: ReplState):
+        return f'{Bash.COMMAND} [pod-name] [bash-commands] [&]\t run bash on the Cassandra nodes'

adam/commands/bash/bash_completer.py

@@ -0,0 +1,93 @@
+from typing import Callable
+from prompt_toolkit.completion import WordCompleter
+
+from adam.utils_repl.automata_completer import AutomataCompleter
+from adam.utils_repl.state_machine import State, StateMachine
+
+BASH_SPEC = [
+    # <command> ::= <simple_command> | <pipeline> | <conditional_command>
+    # <simple_command> ::= <word> <argument>* <redirection>*
+    # <pipeline> ::= <command> '|' <command>
+    # <conditional_command> ::= <command> '&&' <command> | <command> '||' <command>
+    # <word> ::= <letter> <letter_or_digit>*
+    # <argument> ::= <word>
+    # <redirection> ::= '>' <filename> | '<' <filename>
+    # <filename> ::= <word>
+    # <letter> ::= 'a' | 'b' | ... | 'z' | 'A' | 'B' | ... | 'Z'
+    # <digit> ::= '0' | '1' | ... | '9'
+    # <letter_or_digit> ::= <letter> | <digit>
+
+    '                                > word           > cmd                                ^ hosts',
+    'cmd                             > word           > cmd                                ^ |,>,2>,<,&,&&,||',
+    '-                               > pipe           > cmd_pipe',
+    '-                               > _rdr0_         > cmd_rdr0',
+    '-                               > _rdr1_         > cmd_rdr1',
+    '-                               > _rdr2_         > cmd_rdr2',
+    '-                               > &              > cmd_bg                             ^ |,>,2>,<,&,&&,||',
+    '-                               > &&|_or_        > nocmd',
+    'cmd_a                           > word           > cmd',
+    'cmd_pipe                        > word           > cmd',
+    'cmd_rdr0                        > word           > cmd_rdr0_f',
+    'cmd_rdr1                        > word           > cmd_rdr1_f',
+    'cmd_rdr2                        > word           > cmd_rdr2_f',
+    'cmd_rdr1_f                      > pipe           > cmd_pipe                           ^ |,2>,<,&,&&,||',
+    '-                               > _rdr2_         > cmd_rdr2',
+    '-                               > _rdr0_         > cmd_rdr0',
+    'cmd_rdr2_f                      > pipe           > cmd_pipe                           ^ |,<,&,&&,||',
+    '-                               > _rdr0_         > cmd_rdr0',
+    '-                               > &              > cmd_bg                             ^ |,>,2>,<,&,&&,||',
+    '-                               > &&|_or_        > nocmd',
+    'cmd_rdr0_f                      > pipe           > cmd_pipe                           ^ |,&,&&,||',
+    '-                               > &              > cmd_bg                             ^ |,>,2>,<,&,&&,||',
+    '-                               > &&|_or_        > cmd',
+    'cmd_bg                          > &&|_or_        > nocmd                              ^ &&,||',
+    'nocmd                           > word           > cmd',
+]
+
+BASH_KEYWORDS = [
+    '&',
+    '&&',
+    '|',
+    '||',
+    '>',
+    '2>',
+    '>>',
+    '<',
+    'hosts'
+]
+
+class BashStateMachine(StateMachine[str]):
+    def spec(self) -> str:
+        return BASH_SPEC
+
+    def keywords(self) -> list[str]:
+        return BASH_KEYWORDS
+
+class BashCompleter(AutomataCompleter[str]):
+    def __init__(self,
+                 hosts: Callable[[], list[str]],
+                 debug = False):
+        super().__init__(BashStateMachine(debug=debug), '', debug=debug)
+
+        self.hosts = hosts
+        self.debug = debug
+
+    def suggestions_completer(self, state: State, suggestions: str) -> list[str]:
+        if not suggestions:
+            return None
+
+        terms = []
+        for suggestion in suggestions.split(','):
+            terms.extend(self._terms(state, suggestion))
+
+        return WordCompleter(terms)
+
+    def _terms(self, _: State, word: str) -> list[str]:
+        terms = []
+
+        if word == 'hosts':
+            terms.extend(self.hosts())
+        else:
+            terms.append(word)
+
+        return terms

adam/commands/bash/utils_bash.py

@@ -0,0 +1,16 @@
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState
+
+class BashHandler:
+    def __init__(self, s0: ReplState, s1: ReplState):
+        self.s0 = s0
+        self.s1 = s1
+
+    def __enter__(self):
+        return self.exec
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+    def exec(self, args: list[str]):
+        return Devices.device(self.s1).bash(self.s0, self.s1, args)

adam/commands/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.device(state).bash(state, state, cmd.split(' '))
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {f: None for f in Devices.device(state).files(state)}, pods=Devices.device(state).pods(state, '-'), auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{Cat.COMMAND} file [&]\t run cat command on the pod'

adam/commands/cd.py

@@ -1,11 +1,8 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
-from adam.commands.postgres.postgres_session import PostgresSession
-from adam.k8s_utils.cassandra_clusters import CassandraClusters
-from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.commands.devices.device import Device
+from adam.commands.devices.devices import Devices
 from adam.repl_state import ReplState
-from adam.utils import log2
-from adam.apps import Apps
 
 class Cd(Command):
     COMMAND = 'cd'
@@ -22,94 +19,23 @@ class Cd(Command):
     def command(self):
         return Cd.COMMAND
 
+    def required(self):
+        return ReplState.NON_L
+
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        if len(args) < 2:
-            return state
-
-        arg = args[1]
-        for dir in arg.split('/'):
-            if state.device == ReplState.P:
-                if dir == '':
-                    state.pg_path = None
-                else:
-                    session = PostgresSession(state.namespace, state.pg_path)
-                    # patch up state.namespace from pg cd
-                    if not state.namespace and (ns := session.find_namespace(arg)):
-                        state.namespace = ns
-                    state.pg_path = session.directory(arg)
-            elif state.device == ReplState.A:
-                if dir == '':
-                    state.app_env = None
-                    state.app_app = None
-                elif dir == '..':
-                    if state.app_app:
-                        state.app_app = None
-                    else:
-                        state.app_env = None
-                else:
-                    if not state.app_env:
-                        tks = dir.split('@')
-                        if len(tks) > 1:
-                            state.namespace = tks[1]
+        with self.validate(args, state, apply=False) as (args, state):
+            with validate_args(args, state, name='directory') as arg_str:
+                device: Device = Devices.device(state)
+                for dir in arg_str.split('/'):
+                    device.cd(dir, state)
 
-                        state.app_env = dir.split('@')[0]
-                    else:
-                        state.app_app = dir
-            else:
-                if dir == '':
-                    state.sts = None
-                    state.pod = None
-                elif dir == '..':
-                    if state.pod:
-                        state.pod = None
-                    else:
-                        state.sts = None
-                else:
-                    if not state.sts:
-                        ss_and_ns = dir.split('@')
-                        state.sts = ss_and_ns[0]
-                        state.namespace = ss_and_ns[1]
-                    elif not state.pod:
-                        p, _ = KubeContext.is_pod_name(dir)
-                        if p:
-                            state.pod = p
-                        else:
-                            names = CassandraClusters.pod_names_by_host_id(state.sts, state.namespace);
-                            if dir in names:
-                                state.pod = names[dir]
-                            else:
-                                log2('Not a valid pod name or host id.')
-
-        return state
+                return state
 
     def completion(self, state: ReplState):
-        if state.device == ReplState.P:
-            pg = PostgresSession(state.namespace, state.pg_path) if state.pg_path else None
-            if pg and pg.db:
-                return {Cd.COMMAND: {'..': None}}
-            elif pg and pg.host:
-                return {Cd.COMMAND: {'..': None} | {p['name']: None for p in pg.databases()}}
-            else:
-                return {Cd.COMMAND: {p: None for p in PostgresSession.hosts(state.namespace)}}
-        elif state.device == ReplState.A:
-            if state.app_app:
-                return {Cd.COMMAND: {'..': None}}
-            elif state.app_env:
-                return {Cd.COMMAND: {'..': None} | {app[0].split('-')[1]: None for app in Apps.apps(state.app_env)}}
-            else:
-                return {Cd.COMMAND: {'..': None} | {env[0]: None for env in Apps.envs()}}
-        else:
-            if state.pod:
-                return {Cd.COMMAND: {'..': None}}
-            elif state.sts:
-                return {Cd.COMMAND: {'..': None} | {p: None for p in StatefulSets.pod_names(state.sts, state.namespace)}}
-            else:
-                return {Cd.COMMAND: {p: None for p in StatefulSets.list_sts_names()}}
-
-        return {}
+        return Devices.device(state).cd_completion(Cd.COMMAND, state, default = {})
 
     def help(self, _: ReplState):
-        return f'{Cd.COMMAND} <path> | .. \t move around'
+        return f'{Cd.COMMAND} <path> | .. \t move around on the operational device hierarchy'

adam/commands/check.py

@@ -2,11 +2,13 @@ import click
 
 from adam.checks.check_result import CheckResult
 from adam.checks.check_utils import all_checks, checks_from_csv, run_checks
+from adam.commands import extract_options, validate_args
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
 from adam.commands.issues import Issues
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log
+from adam.utils import tabulize, log
+from adam.utils_issues import IssuesUtils
 
 class Check(Issues):
     COMMAND = 'check'
@@ -23,37 +25,32 @@ class Check(Issues):
     def command(self):
         return Check.COMMAND
 
+    def required(self):
+        return ReplState.NON_L
+
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
-        args, show = Command.extract_options(args, ['-s', '--show'])
-
-        if not args:
-            if state.in_repl:
-                log(lines_to_tabular([check.help() for check in all_checks()], separator=':'))
-            else:
-                log('* Check name is missing.')
-                Command.display_help()
-            return 'arg missing'
-
-        checks = checks_from_csv(args[0])
-        if not checks:
-            return 'invalid check name'
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, ['-s', '--show']) as (args, show_out):
+                with validate_args(args, state, name='check name', msg=lambda: tabulize([check.help() for check in all_checks()], separator=':')) as arg:
+                    checks = checks_from_csv(args[0])
+                    if not checks:
+                        return 'invalid check name'
 
-        results = run_checks(state.sts, state.namespace, state.pod, checks=checks, show_output=show)
+                    results = run_checks(state.sts, state.namespace, state.pod, checks=checks, show_out=show_out)
 
-        issues = CheckResult.collect_issues(results)
-        Issues.show_issues(issues, in_repl=state.in_repl)
+                    issues = CheckResult.collect_issues(results)
+                    IssuesUtils.show_issues(issues, in_repl=state.in_repl)
 
-        return issues if issues else 'no issues found'
+                    return issues if issues else 'no issues found'
 
     def completion(self, _: ReplState):
-        return {Check.COMMAND: {check.name(): None for check in all_checks()}}
+        return {Check.COMMAND: {check.name(): {'-s': None} for check in all_checks()}}
 
     def help(self, _: ReplState):
-        return f'{Check.COMMAND} <check-name>\t run a single check'
+        return f'{Check.COMMAND} <check-name> [-s]\t run a single check'
 
 class CheckCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):

adam/commands/cli_commands.py

@@ -1,16 +1,21 @@
 import functools
 import re
 
-from adam.commands.reaper.reaper_session import ReaperSession
+from adam.commands.reaper.utils_reaper import Reapers
 from adam.config import Config
-from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.secrets import Secrets
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils import log_timing
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.secrets import Secrets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState
 
 class CliCommands:
-    @functools.lru_cache()
     def values(state: ReplState, collapse = False):
+        with log_timing('CliCommands.values'):
+            return CliCommands._values(state, collapse)
+
+    @functools.lru_cache()
+    def _values(state: ReplState, collapse = False):
         # node-exec-?, nodetool-?, cql-?, reaper-exec, reaper-forward, reaper-ui, reaper-usernae, reaper-password
         d = {}
 
@@ -66,8 +71,7 @@ class CliCommands:
             return key.replace(f'{state.namespace}-', '').replace('-k8spg-cs-001', '')
         d |= {f'pg-{reduce_key(k)}': f'PGPASSWORD={v["postgres-admin-password"]} psql -h {v["postgres-db-endpoint"]} -p {v["postgres-db-port"]} -U {v["postgres-admin-username"]} postgres' for k, v in data.items()}
 
-        if r := ReaperSession.create(state):
-            reaper = r.reaper_spec(state)
+        if reaper := Reapers.reaper_spec(state):
             d |= {
                 'reaper-exec': reaper["exec"],
                 'reaper-forward': reaper["forward"],

adam/commands/clipboard_copy.py

@@ -0,0 +1,87 @@
+from functools import partial
+import click
+import pyperclip
+
+from adam.commands import validate_args
+from adam.commands.command import Command, InvalidArgumentsException
+from adam.commands.command_helpers import ClusterOrPodCommandHelper
+from adam.commands.cli_commands import CliCommands
+from adam.config import Config
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import tabulize, log, log2
+
+class ClipboardCopy(Command):
+    COMMAND = 'cli cp'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ClipboardCopy, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ClipboardCopy.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):
+            def display_keys(missing = False):
+                if missing:
+                    log2('Key is required.')
+                else:
+                    log2('Key is invalid.')
+                log2()
+                tabulize(CliCommands.values(state, collapse=True).items(),
+                         lambda a: f'{a[0]},{a[1]}',
+                         header='KEY,VALUE',
+                         separator=',',
+                         to=2)
+
+            with validate_args(args, state, name='key', msg=partial(display_keys, True)) as key:
+                if not key in CliCommands.values(state):
+                    if state.in_repl:
+                        display_keys(False)
+                    else:
+                        log2('* Invalid key')
+                        Command.display_help()
+
+                    raise InvalidArgumentsException()
+
+                value = CliCommands.values(state)[key]
+                pyperclip.copy(value)
+                log2('The following line has been copied to clipboard. Use <Ctrl-V> to use it.')
+                log2(f'  {value}')
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {key: None for key in CliCommands.values(state).keys()}, auto_key='cli.cp-auto-complete')
+
+    def help(self, _: ReplState):
+        return f"{ClipboardCopy.COMMAND} <key>\t copy a value to clipboard for conveninence"
+
+class CopyCommandHelper(click.Command):
+    def lines(self):
+        return [
+            'node-exec-?: kubectl exec command to the Cassandra pod',
+            'reaper-exec: kubectl exec command to the Reaper pod',
+            'reaper-forward: kubectl port-forward command to the Reaper pod',
+            'reaper-ui: uri to Reaper ui',
+            'reaper-username: Reaper user name',
+            'reaper-password: Reaper password',
+        ]
+
+    def get_help(self, ctx: click.Context):
+        log(super().get_help(ctx))
+        log()
+        tabulize(self.lines(), header='KEY:DESC', separator=':')
+        log()
+        ClusterOrPodCommandHelper.cluter_or_pod_help()

adam/commands/code.py

@@ -0,0 +1,57 @@
+import code
+from functools import partial
+
+from adam.commands.command import Command
+from adam.commands.cql.utils_cql import cassandra_table_names, run_cql
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import tabulize
+from adam.utils_k8s.statefulsets import StatefulSets
+
+class Code(Command):
+    COMMAND = 'python'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Code, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Code.COMMAND
+
+    def required(self):
+        return RequiredState.NAMESPACE
+
+    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):
+            sts = state.sts
+            pod = state.pod
+            pods = StatefulSets.pod_names(state.sts, state.namespace)
+            tables = cassandra_table_names(state)
+            cql = partial(run_cql, state, show_out=True)
+
+            my_local = globals() | locals()
+            # my_local = globals() | {'StatefulSets': StatefulSets} | locals()
+            lines = [
+                'sts: StatefulSet name',
+                'pod: Pod name',
+                'pods: Pod names in the current StatefulSet',
+                'tables: Cassandra tables names in the current StatefulSet',
+                "cql('select...'): run cql statement"
+            ]
+
+            code.interact(local=my_local, banner=tabulize(lines, header='Variables', separator=':'))
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{Code.COMMAND} \t invoke interactive Python shell'