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

adam/commands/audit/show_top10.py

@@ -0,0 +1,36 @@
+from adam.commands.audit.utils_show_top10 import run_configured_query
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+
+class ShowTop10(Command):
+    COMMAND = 'show top'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowTop10, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowTop10.COMMAND
+
+    def required(self):
+        return ReplState.L
+
+    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):
+            run_configured_query('audit.queries.top10', args)
+
+            return state
+
+    def completion(self, _: ReplState):
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{ShowTop10.COMMAND} [limit]\t show top <limit> audit lines'

adam/commands/audit/utils_show_top10.py

@@ -0,0 +1,71 @@
+from datetime import datetime, timedelta
+
+from adam.config import Config
+from adam.utils import log2, log_exc
+from adam.utils_athena import Athena
+from adam.utils_audits import Audits
+from adam.utils_repl.automata_completer import AutomataCompleter
+from adam.utils_repl.state_machine import StateMachine
+
+def run_configured_query(config_key: str, args: list[str]):
+    limit, date_condition = extract_limit_and_duration(args)
+    if query := Config().get(config_key, None):
+        query = '\n    '.join(query.split('\n'))
+        query = query.replace('{date_condition}', date_condition)
+        query = query.replace('{limit}', str(limit))
+
+        log2(query)
+        log2()
+        Athena.run_query(query)
+
+def extract_limit_and_duration(args: list[str]) -> tuple[int, datetime]:
+    limit = 10
+    _from = datetime.now() - timedelta(days=30)
+    if args:
+        with log_exc():
+            limit = int(args[0])
+
+        if len(args) > 2 and args[1] == 'over':
+            if args[2] == 'day':
+                _from = datetime.now() - timedelta(days=1)
+
+    return (limit, Audits.date_from(_from))
+
+def limit_and_duration_completion():
+    return {'10': {'over': {
+        'day': None,
+        'month': None
+    }}}
+
+SHOW_TOP10_SPEC = [
+    '                                > show           > show',
+    'show                            > last|slow|top  > show_top                            ^ last,slow,top',
+    'show_top                        > word           > show_top_n                          ^ 10',
+    'show_top_n                      > over           > show_top_n_over                     ^ over',
+    'show_top_n_over                 > day|month      > show_top_n_over$                    ^ day,month',
+]
+
+SHOW_TOP10_KEYWORDS = [
+    'show',
+    'top',
+    'last',
+    'slow',
+    'over',
+    'day',
+    'month'
+]
+
+class ShowTop10StateMachine(StateMachine[str]):
+    def spec(self) -> str:
+        return SHOW_TOP10_SPEC
+
+    def keywords(self) -> list[str]:
+        return SHOW_TOP10_KEYWORDS
+
+def show_top10_completions_for_nesting():
+    return {
+        'show': {
+            'last': AutomataCompleter(ShowTop10StateMachine(), first_term='show last'),
+            'slow': AutomataCompleter(ShowTop10StateMachine(), first_term='show slow'),
+            'top': AutomataCompleter(ShowTop10StateMachine(), first_term='show top'),
+    }}

adam/commands/bash/__init__.py

@@ -0,0 +1,5 @@
+from adam.commands.bash.utils_bash import BashHandler
+from adam.repl_state import ReplState
+
+def bash(s0: ReplState, s1: ReplState):
+    return BashHandler(s0, s1)

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.of(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.of(self.s1).bash(self.s0, self.s1, args)

adam/commands/cassandra/download_cassandra_log.py

@@ -0,0 +1,45 @@
+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.utils import log2
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.repl_state import ReplState, RequiredState
+from adam.utils_k8s.pods import Pods
+
+class DownloadCassandraLog(Command):
+    COMMAND = 'download cassandra log'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DownloadCassandraLog, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DownloadCassandraLog.COMMAND
+
+    def required(self):
+        return RequiredState.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):
+            path = Config().get('logs.path', '/c3/cassandra/logs/system.log')
+            r: PodExecResult = CassandraNodes.exec(state.pod, state.namespace, f'cat {path}', backgrounded=True, no_history=True)
+
+            to_file = Pods.download_file(state.pod, 'cassandra', state.namespace, path)
+            log2(f'Downloaded to {to_file}.')
+
+            return r
+
+    def completion(self, state: ReplState):
+        return super().completion(state, pods=Devices.of(state).pods(state, '-'), auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{DownloadCassandraLog.COMMAND}\t download cassandra system log'

adam/commands/cassandra/nodetool.py

@@ -0,0 +1,64 @@
+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.cassandra.nodetool_commands import NODETOOL_COMMANDS
+from adam.config import Config
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log
+
+class NodeTool(Command):
+    COMMAND = 'nodetool'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(NodeTool, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return NodeTool.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):
+            with cassandra(state) as pods:
+                pods.nodetool(' '.join(args), status=(args[0] == 'status'))
+
+            return state
+
+    def completion(self, state: ReplState):
+        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'
+
+class NodeToolCommandHelper(click.Command):
+    def get_help(self, ctx: click.Context):
+        log(super().get_help(ctx))
+        log()
+        log('Sub-Commands:')
+
+        cmds = ''
+        for c in NODETOOL_COMMANDS:
+            if cmds:
+                cmds += ', '
+            cmds += c
+            if len(cmds) > Config().get('nodetool.commands_in_line', 40):
+                log('  ' + cmds)
+                cmds = ''
+
+        if len(cmds) > 0:
+            log('  ' + cmds)
+        log()
+        ClusterOrPodCommandHelper.cluter_or_pod_help()

adam/commands/cassandra/nodetool_commands.py

@@ -0,0 +1,120 @@
+NODETOOL_COMMANDS = [
+    'assassinate',
+    'bootstrap',
+    'cleanup',
+    'clearsnapshot',
+    'clientstats',
+    'compact',
+    'compactionhistory',
+    'compactionstats',
+    'decommission',
+    'describecluster',
+    'describering',
+    'disableauditlog',
+    'disableautocompaction',
+    'disablebackup',
+    'disablebinary',
+    'disablefullquerylog',
+    'disablegossip',
+    'disablehandoff',
+    'disablehintsfordc',
+    'disableoldprotocolversions',
+    'drain',
+    'enableauditlog',
+    'enableautocompaction',
+    'enablebackup',
+    'enablebinary',
+    'enablefullquerylog',
+    'enablegossip',
+    'enablehandoff',
+    'enablehintsfordc',
+    'enableoldprotocolversions',
+    'failuredetector',
+    'flush',
+    'garbagecollect',
+    'gcstats',
+    'getbatchlogreplaythrottle',
+    'getcompactionthreshold',
+    'getcompactionthroughput',
+    'getconcurrency',
+    'getconcurrentcompactors',
+    'getconcurrentviewbuilders',
+    'getendpoints',
+    'getfullquerylog',
+    'getinterdcstreamthroughput',
+    'getlogginglevels',
+    'getmaxhintwindow',
+    'getseeds',
+    'getsnapshotthrottle',
+    'getsstables',
+    'getstreamthroughput',
+    'gettimeout',
+    'gettraceprobability',
+    'gossipinfo',
+    'help',
+    'import',
+    'info',
+    'invalidatecountercache',
+    'invalidatekeycache',
+    'invalidaterowcache',
+    'join',
+    'listsnapshots',
+    'move',
+    'netstats',
+    'pausehandoff',
+    'profileload',
+    'proxyhistograms',
+    'rangekeysample',
+    'rebuild',
+    'rebuild_index',
+    'refresh',
+    'refreshsizeestimates',
+    'reloadlocalschema',
+    'reloadseeds',
+    'reloadssl',
+    'reloadtriggers',
+    'relocatesstables',
+    'removenode',
+    'repair',
+    'repair_admin',
+    'replaybatchlog',
+    'resetfullquerylog',
+    'resetlocalschema',
+    'resumehandoff',
+    'ring',
+    'scrub',
+    'setbatchlogreplaythrottle',
+    'setcachecapacity',
+    'setcachekeystosave',
+    'setcompactionthreshold',
+    'setcompactionthroughput',
+    'setconcurrency',
+    'setconcurrentcompactors',
+    'setconcurrentviewbuilders',
+    'sethintedhandoffthrottlekb',
+    'setinterdcstreamthroughput',
+    'setlogginglevel',
+    'setmaxhintwindow',
+    'setsnapshotthrottle',
+    'setstreamthroughput',
+    'settimeout',
+    'settraceprobability',
+    'sjk',
+    'snapshot',
+    'status',
+    'statusautocompaction',
+    'statusbackup',
+    'statusbinary',
+    'statusgossip',
+    'statushandoff',
+    'stop',
+    'stopdaemon',
+    'tablehistograms',
+    'tablestats',
+    'toppartitions',
+    'tpstats',
+    'truncatehints',
+    'upgradesstables',
+    'verify',
+    'version',
+    'viewbuildstatus']

adam/commands/{restart.py → cassandra/restart_cluster.py}

@@ -1,15 +1,16 @@
+from adam.commands import extract_options
 from adam.commands.command import Command
 from adam.utils_k8s.pods import Pods
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
 
-class Restart(Command):
-    COMMAND = 'restart'
+class RestartCluster(Command):
+    COMMAND = 'restart cluster'
 
     # the singleton pattern
     def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Restart, cls).__new__(cls)
+        if not hasattr(cls, 'instance'): cls.instance = super(RestartCluster, cls).__new__(cls)
 
         return cls.instance
 
@@ -17,45 +18,30 @@ class Restart(Command):
         super().__init__(successor)
 
     def command(self):
-        return Restart.COMMAND
+        return RestartCluster.COMMAND
 
     def required(self):
-        return RequiredState.CLUSTER_OR_POD
+        return RequiredState.CLUSTER
 
     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:
-            if state.pod:
-                log2(f'Restarting {state.pod}...')
-                Pods.delete(state.pod, state.namespace)
-            else:
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, '--force') as (args, forced):
                 if not forced:
                     log2('Please add --force for restarting all nodes in a cluster.')
+
                     return 'force-needed'
 
                 log2(f'Restarting all pods from {state.sts}...')
                 for pod_name in StatefulSets.pod_names(state.sts, state.namespace):
                     Pods.delete(pod_name, state.namespace)
-        else:
-            for arg in args:
-                Pods.delete(arg, state.namespace)
 
-        return state
+                return state
 
     def completion(self, state: ReplState):
-        if state.pod:
-            return {Restart.COMMAND: None}
-        elif state.sts:
-            return {Restart.COMMAND: {p: None for p in StatefulSets.pod_names(state.sts, state.namespace)}}
-
-        return {}
+        return super().completion(state, {'--force': None})
 
     def help(self, _: ReplState):
-        return f"{Restart.COMMAND} [<host-id>] [--force]\t restart the node you're in or all the nodes in the cluster"
+        return f"{RestartCluster.COMMAND} --force\t restart all the nodes in the cluster"

adam/commands/cassandra/restart_node.py

@@ -0,0 +1,51 @@
+from adam.commands import extract_options
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.utils_k8s.pods import Pods
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class RestartNode(Command):
+    COMMAND = 'restart node'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RestartNode, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RestartNode.COMMAND
+
+    def required(self):
+        return RequiredState.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):
+            if not state.pod:
+                log2("'pod' is required")
+
+                return 'pod-needed'
+
+            with extract_options(args, '--force') as (args, forced):
+                if not forced:
+                    log2('Please add --force for restarting pod.')
+
+                    return 'force-needed'
+
+                log2(f'Restarting {state.pod}...')
+                Pods.delete(state.pod, state.namespace)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'--force': None}, pods=Devices.of(state).pods(state, '-'))
+
+    def help(self, _: ReplState):
+        return f"{RestartNode.COMMAND} --force\t restart the node"

adam/commands/cassandra/restart_nodes.py

@@ -0,0 +1,47 @@
+from adam.commands import extract_options, validate_args
+from adam.commands.command import Command
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.statefulsets import StatefulSets
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class RestartNodes(Command):
+    COMMAND = 'restart nodes'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RestartNodes, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RestartNodes.COMMAND
+
+    def required(self):
+        return RequiredState.CLUSTER
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state, apply=False) as (args, state):
+            with extract_options(args, '--force') as (args, forced):
+                with validate_args(args, state, name='pod name'):
+                    if not forced:
+                        log2('Please add --force for restarting nodes.')
+
+                        return 'force-needed'
+
+                    for arg in args:
+                        Pods.delete(arg, state.namespace)
+
+                    return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {p: {'--force': None} for p in StatefulSets.pod_names(state.sts, state.namespace)})
+
+    def help(self, _: ReplState):
+        return f"{RestartNodes.COMMAND} <pod-name>... --force\t restart Cassandra nodes"