kaqing 2.0.110__py3-none-any.whl → 2.0.214__py3-none-any.whl

adam/commands/app.py

@@ -1,67 +0,0 @@
-import json
-
-from adam.apps import Apps
-from adam.commands.command import Command
-from adam.repl_state import ReplState, RequiredState
-from adam.app_session import AppSession
-from adam.utils import log2
-
-class App(Command):
-    COMMAND = 'app'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(App, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return App.COMMAND
-
-    def required(self):
-        return RequiredState.APP_APP
-
-    def run(self, cmd: str, state: ReplState):
-        if not(args := self.args(cmd)):
-            return super().run(cmd, state)
-
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        args, forced = Command.extract_options(args, '--force')
-
-        if not args:
-            return 'arg missing'
-
-        t_f = args[0].split('.')
-        if len(t_f) < 2:
-            return 'arg missing'
-
-        payload, valid = Apps().payload(t_f[0], t_f[1], args[1:] if len(args) > 1 else [])
-        if not valid:
-            log2('Missing one or more action arguments.')
-            return state
-
-        if payload:
-            try:
-                payload = json.loads(payload)
-            except json.decoder.JSONDecodeError as e:
-                log2(f'Invalid json argument: {e}')
-                return state
-
-        AppSession.run(state.app_env, state.app_app, state.namespace, t_f[0], t_f[1], payload=payload, forced=forced)
-
-        return state
-
-    def completion(self, state: ReplState):
-        if state.app_app:
-            return super().completion(state, {'--force': None})
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f"{App.COMMAND} [--force]\t post app API query with type and function"

adam/commands/bash.py

@@ -1,150 +0,0 @@
-from adam.commands.command import Command
-from adam.utils_k8s.cassandra_clusters import CassandraClusters
-from adam.utils_k8s.cassandra_nodes import CassandraNodes
-from adam.pod_exec_result import PodExecResult
-from adam.repl_state import BashSession, ReplState, RequiredState
-from adam.utils_repl.automata_completer import AutomataCompleter
-from adam.utils_repl.state_machine import StateMachine
-
-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
-
-    def run(self, cmd: str, s0: ReplState):
-        if not(args := self.args(cmd)):
-            return super().run(cmd, s0)
-
-        state, args = self.apply_state(args, s0, args_to_check=2)
-        if not self.validate_state(state):
-            return state
-
-        if state.in_repl:
-            if s0.sts != state.sts or s0.pod != state.pod:
-                r = self.exec_with_dir(state, args)
-            else:
-                r = self.exec_with_dir(s0, args)
-
-            if not r:
-                state.exit_bash()
-
-                return 'inconsistent pwd'
-
-            return r
-        else:
-            command = ' '.join(args)
-
-            if state.pod:
-                CassandraNodes.exec(state.pod, state.namespace, command, show_out=True)
-            elif state.sts:
-                CassandraClusters.exec(state.sts, state.namespace, command, action='bash', show_out=True)
-
-            return state
-
-    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
-
-        command = ' '.join(args)
-
-        rs = []
-
-        if state.pod:
-            rs = [CassandraNodes.exec(state.pod, state.namespace, command,
-                                      show_out=not session_just_created, shell='bash')]
-        elif state.sts:
-            rs = CassandraClusters.exec(state.sts, state.namespace, command, action='bash',
-                                        show_out=not session_just_created, shell='bash')
-
-        return rs
-
-    def completion(self, state: ReplState):
-        if state.pod or state.sts:
-            return {Bash.COMMAND: AutomataCompleter(BashStateMachine())}
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{Bash.COMMAND} [bash-commands]\t run bash on the Cassandra nodes'
-
-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           > word',
-    'word                            > word           > word                                ^ |,>,2>,<,&,&&,||',
-    '-                               > pipe           > word_pipe',
-    '-                               > _rdr0_         > word_rdr0',
-    '-                               > _rdr1_         > word_rdr1',
-    '-                               > _rdr2_         > word_rdr2',
-    '-                               > &              > word_bg                             ^ |,>,2>,<,&,&&,||',
-    '-                               > &&|_or_        > word',
-    'word_a                          > word           > word',
-    'word_pipe                       > word           > word',
-    'word_rdr0                       > word           > word_rdr0_f',
-    'word_rdr1                       > word           > word_rdr1_f',
-    'word_rdr2                       > word           > word_rdr2_f',
-    'word_rdr1_f                     > pipe           > word_pipe                           ^ |,2>,<,&,&&,||',
-    '-                               > _rdr2_         > word_rdr2',
-    '-                               > _rdr0_         > word_rdr0',
-    'word_rdr2_f                     > pipe           > word_pipe                           ^ |,<,&,&&,||',
-    '-                               > _rdr0_         > word_rdr0',
-    '-                               > &              > word_bg                             ^ |,>,2>,<,&,&&,||',
-    '-                               > &&|_or_        > word',
-    'word_rdr0_f                     > pipe           > word_pipe                           ^ |,&,&&,||',
-    '-                               > &              > word_bg                             ^ |,>,2>,<,&,&&,||',
-    '-                               > &&|_or_        > word',
-    'word_bg                         > &&|_or_        >                                     ^ &&,||',
-]
-
-BASH_KEYWORDS = [
-    '&',
-    '&&',
-    '|',
-    '||',
-    '>',
-    '2>',
-    '>>',
-    '<'
-]
-class BashStateMachine(StateMachine[str]):
-    def spec(self) -> str:
-        return BASH_SPEC
-
-    def keywords(self) -> list[str]:
-        return BASH_KEYWORDS

adam/commands/cd.py

@@ -1,125 +0,0 @@
-from adam.commands.command import Command
-from adam.commands.postgres.postgres_utils import pg_database_names
-from adam.commands.postgres.postgres_context import PostgresContext
-from adam.utils_k8s.cassandra_clusters import CassandraClusters
-from adam.utils_k8s.kube_context import KubeContext
-from adam.utils_k8s.statefulsets import StatefulSets
-from adam.repl_state import ReplState
-from adam.utils import log2
-from adam.apps import Apps
-
-class Cd(Command):
-    COMMAND = 'cd'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Cd, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    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 not self.validate_state(state):
-            return 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:
-                    context: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path, arg=dir)
-                    # patch up state.namespace from pg cd
-                    if not state.namespace and context.namespace:
-                        state.namespace = context.namespace
-                    state.pg_path = context.path()
-            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]
-
-                        state.app_env = dir.split('@')[0]
-                    else:
-                        state.app_app = dir
-            elif state.device == ReplState.L:
-                pass
-            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]
-                        if len(ss_and_ns) > 1:
-                            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
-
-    def completion(self, state: ReplState):
-        if state.device == ReplState.P:
-            pg: PostgresContext = PostgresContext.apply(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: None for p in pg_database_names(state.namespace, pg.path())}}
-            else:
-                return {Cd.COMMAND: {p: None for p in PostgresContext.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()}}
-        elif state.device == ReplState.C:
-            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 {}
-
-    def help(self, _: ReplState):
-        return f'{Cd.COMMAND} <path> | .. \t move around'

adam/commands/cp.py

@@ -1,95 +0,0 @@
-import click
-import pyperclip
-
-from adam.commands.command import Command
-from adam.commands.command_helpers import ClusterOrPodCommandHelper
-from adam.commands.cli_commands import CliCommands
-from adam.repl_state import ReplState, RequiredState
-from adam.utils import lines_to_tabular, log, log2
-
-class ClipboardCopy(Command):
-    COMMAND = '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)
-
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        if len(args) < 1:
-            if state.in_repl:
-                log2('Key is required.')
-                log2()
-                log2('Keys:')
-                log2(lines_to_tabular([f'{k},{v}' for k, v in CliCommands.values(state, collapse=True).items()], separator=','))
-            else:
-                log2('* Key is missing.')
-                Command.display_help()
-
-            return 'command-missing'
-
-        key = args[0]
-        if not key in CliCommands.values(state):
-            if state.in_repl:
-                log2('Key is required.')
-                log2()
-                log2('Keys:')
-                log2(lines_to_tabular([f'{k},{v}' for k, v in CliCommands.values(state, collapse=True).items()], separator=','))
-            else:
-                log2('* Invalid key')
-                Command.display_help()
-
-            return 'command-invalid'
-
-        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 'value-copied'
-
-    def completion(self, state: ReplState):
-        if state.sts:
-            return {ClipboardCopy.COMMAND: {key: None for key in CliCommands.values(state).keys()}}
-
-        return {}
-
-    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()
-        log('Keys:')
-
-        log(lines_to_tabular(self.lines(), separator=':'))
-        log()
-        ClusterOrPodCommandHelper.cluter_or_pod_help()

adam/commands/cql/cql_completions.py

@@ -1,15 +0,0 @@
-from adam.commands.cql.cql_utils import cassandra_table_names
-from adam.config import Config
-from adam.repl_state import ReplState
-from adam.sql.sql_completer import SqlCompleter
-
-def cql_completions(state: ReplState) -> dict[str, any]:
-    ps = Config().get('cql.alter-tables.gc-grace-periods', '3600,86400,864000,7776000').split(',')
-    return {
-        'describe': {
-            'keyspaces': None,
-            'table': {t: None for t in cassandra_table_names(state)},
-            'tables': None},
-    } | SqlCompleter(lambda: cassandra_table_names(state), table_props=lambda: {
-        'GC_GRACE_SECONDS': ps
-    }, variant='cql').completions_for_nesting()

adam/commands/cql/cql_utils.py

@@ -1,112 +0,0 @@
-import functools
-import re
-
-from adam.config import Config
-from adam.utils_k8s.cassandra_clusters import CassandraClusters
-from adam.utils_k8s.cassandra_nodes import CassandraNodes
-from adam.utils_k8s.secrets import Secrets
-from adam.pod_exec_result import PodExecResult
-from adam.repl_state import ReplState
-from adam.utils import log2
-
-@functools.lru_cache()
-def keyspaces(state: ReplState, on_any=False):
-    if state.pod:
-        Config().wait_log(f'Inspecting Cassandra Keyspaces on {state.pod}...')
-    else:
-        Config().wait_log(f'Inspecting Cassandra Keyspaces...')
-
-    r: list[PodExecResult] = run_cql(state, 'describe keyspaces', show_out=False, on_any=on_any)
-    if not r:
-        log2('No pod is available')
-        return []
-
-    return parse_cql_desc_keyspaces(r.stdout if state.pod else r[0].stdout)
-
-def cassandra_table_names(state: ReplState):
-    return [f'{k}.{t}' for k, ts in tables(state, on_any=True).items() for t in ts]
-
-@functools.lru_cache()
-def tables(state: ReplState, on_any=False) -> dict[str, list[str]]:
-    r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=on_any)
-    if not r:
-        log2('No pod is available')
-        return {}
-
-    return parse_cql_desc_tables(r.stdout if state.pod else r[0].stdout)
-
-def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_single_quotes = False, on_any = False, background=False) -> list[PodExecResult]:
-    user, pw = Secrets.get_user_pass(state.sts if state.sts else state.pod, state.namespace, secret_path='cql.secret')
-    if use_single_quotes:
-        command = f"cqlsh -u {user} -p {pw} {' '.join(opts)} -e '{cql}'"
-    else:
-        command = f'cqlsh -u {user} -p {pw} {" ".join(opts)} -e "{cql}"'
-
-    if state.pod:
-        return CassandraNodes.exec(state.pod, state.namespace, command, show_out=show_out, background=background)
-    else:
-        return CassandraClusters.exec(state.sts, state.namespace, command, show_out=show_out, action='cql', on_any=on_any, background=background)
-
-def parse_cql_desc_tables(out: str):
-    # Keyspace data_endpoint_auth
-    # ---------------------------
-    # "token"
-
-    # Keyspace reaper_db
-    # ------------------
-    # repair_run                     schema_migration
-    # repair_run_by_cluster          schema_migration_leader
-
-    # Keyspace system
-    tables_by_keyspace: dict[str, list[str]] = {}
-    keyspace = None
-    state = 's0'
-    for line in out.split('\n'):
-        if state == 's0':
-            groups = re.match(r'^Keyspace (.*)$', line)
-            if groups:
-                keyspace = groups[1].strip(' \r')
-                state = 's1'
-        elif state == 's1':
-            if line.startswith('---'):
-                state = 's2'
-        elif state == 's2':
-            if not line.strip(' \r'):
-                state = 's0'
-            else:
-                for table in line.split(' '):
-                    if t := table.strip(' \r'):
-                        if not keyspace in tables_by_keyspace:
-                            tables_by_keyspace[keyspace] = []
-                        tables_by_keyspace[keyspace].append(t)
-
-    return tables_by_keyspace
-
-def parse_cql_desc_keyspaces(out: str) -> list[str]:
-    #
-    # Warning: Cannot create directory at `/home/cassandra/.cassandra`. Command history will not be saved. Please check what was the environment property CQL_HISTORY set to.
-    #
-    #
-    # Warning: Using a password on the command line interface can be insecure.
-    # Recommendation: use the credentials file to securely provide the password.
-    #
-    #
-    # azops88_db  system_auth         system_traces
-    # reaper_db   system_distributed  system_views
-    # system      system_schema       system_virtual_schema
-    #
-    kses = []
-    for line in out.split('\n'):
-        line = line.strip(' \r')
-        if not line:
-            continue
-        if line.startswith('Warning:'):
-            continue
-        if line.startswith('Recommendation:'):
-            continue
-
-        for ks in line.split(' '):
-            if s := ks.strip(' \r\t'):
-                kses.append(s)
-
-    return kses

adam/commands/devices.py

@@ -1,118 +0,0 @@
-from adam.commands.command import Command
-from adam.repl_state import ReplState
-
-class DeviceAuditLog(Command):
-    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'
-
-class DeviceCass(Command):
-    COMMAND = f'{ReplState.C}:'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(DeviceCass, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return DeviceCass.COMMAND
-
-    def run(self, cmd: str, state: ReplState):
-        if not self.args(cmd):
-            return super().run(cmd, state)
-
-        state.device = ReplState.C
-
-        return state
-
-    def completion(self, state: ReplState):
-        return super().completion(state)
-
-    def help(self, _: ReplState):
-        return f'{DeviceCass.COMMAND}\t move to Cassandra Operations device'
-
-class DevicePostgres(Command):
-    COMMAND = f'{ReplState.P}:'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(DevicePostgres, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return DevicePostgres.COMMAND
-
-    def run(self, cmd: str, state: ReplState):
-        if not self.args(cmd):
-            return super().run(cmd, state)
-
-        state.device = ReplState.P
-
-        return state
-
-    def completion(self, state: ReplState):
-        return super().completion(state)
-
-    def help(self, _: ReplState):
-        return f'{DevicePostgres.COMMAND}\t move to Postgres Operations device'
-
-class DeviceApp(Command):
-    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'