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

adam/commands/{show → cassandra}/show_cassandra_version.py

@@ -1,7 +1,5 @@
 from adam.commands.command import Command
-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.commands.cql.utils_cql import cassandra
 from adam.repl_state import ReplState, RequiredState
 
 class ShowCassandraVersion(Command):
@@ -26,23 +24,12 @@ class ShowCassandraVersion(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, _ = state.apply_args(args)
-        if not self.validate_state(state):
-            return state
-
-        user, pw = Secrets.get_user_pass(state.sts if state.sts else state.pod, state.namespace, secret_path='cql.secret')
-        command = f'cqlsh -u {user} -p {pw} -e "show version"'
-
-        if state.pod:
-            return CassandraNodes.exec(state.pod, state.namespace, command)
-        else:
-            return CassandraClusters.exec(state.sts, state.namespace, command, action='cql')
+        with self.validate(args, state) as (_, state):
+            with cassandra(state) as pods:
+                return pods.cql('show version', show_out=True, on_any=True)
 
     def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
+        return super().completion(state)
 
     def help(self, _: ReplState):
         return f'{ShowCassandraVersion.COMMAND}\t show Cassandra version'

adam/commands/cassandra/show_processes.py

@@ -0,0 +1,50 @@
+from adam.commands import extract_options, extract_sequence, extract_trailing_options
+from adam.commands.command import Command
+from adam.commands.cql.utils_cql import cassandra
+from adam.config import Config
+from adam.repl_state import ReplState, RequiredState
+
+class ShowProcesses(Command):
+    COMMAND = 'show processes'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowProcesses, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowProcesses.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 extract_trailing_options(args, '&') as (args, backgrounded):
+                with extract_options(args, ['-s', '--show']) as (args, show_out):
+                    with extract_sequence(args, ['with', 'recipe', '=', 'qing']) as (_, recipe_qing):
+                        cols = Config().get('processes.columns', 'pod,cpu-metrics,mem')
+                        header = Config().get('processes.header', 'POD_NAME,M_CPU(USAGE/LIMIT),MEM/LIMIT')
+                        if recipe_qing:
+                            cols = Config().get('processes-qing.columns', 'pod,cpu,mem')
+                            header = Config().get('processes-qing.header', 'POD_NAME,Q_CPU/TOTAL,MEM/LIMIT')
+
+                    with cassandra(state) as pods:
+                        pods.display_table(cols, header, show_out=show_out, backgrounded=backgrounded, msg='Checking processes')
+
+                    return state
+
+    def completion(self, state: ReplState):
+        recipes = ['metrics', 'qing']
+        return super().completion(state, {'with': {'recipe': {'=': {r: {'-s': {'&': None}, '&': None} for r in recipes}}}, '-s': {'&': None}, '&': None})
+        # return super().completion(state, {'with': {'recipe': {'=': {'metrics': {'-s': {'&': None}, '&': None}, 'qing': {'-s': {'&': None}}}}}, '-s': {'&': None}, '&': None})
+
+    def help(self, _: ReplState):
+        return f'{ShowProcesses.COMMAND} [with recipe qing|metrics] [-s]\t show process overview  -s show commands on nodes'

adam/commands/cassandra/show_storage.py

@@ -0,0 +1,44 @@
+from adam.commands import extract_options, extract_trailing_options
+from adam.commands.command import Command
+from adam.commands.cql.utils_cql import cassandra
+from adam.config import Config
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import ing
+
+class ShowStorage(Command):
+    COMMAND = 'show storage'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowStorage, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowStorage.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 extract_trailing_options(args, '&') as (args, backgrounded):
+                with extract_options(args, ['-s', '--show']) as (args, show_out):
+                    cols = Config().get('storage.columns', 'pod,volume_root,volume_cassandra,snapshots,data,compactions')
+                    header = Config().get('storage.header', 'POD_NAME,VOLUME /,VOLUME CASS,SNAPSHOTS,DATA,COMPACTIONS')
+                    with cassandra(state) as pods:
+                        pods.display_table(cols, header, show_out=show_out, backgrounded=backgrounded, msg='Checking storage')
+
+                    return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'-s': {'&': None}, '&': None})
+
+    def help(self, _: ReplState):
+        return f'{ShowStorage.COMMAND} [-s]\t show storage overview  -s show commands on nodes'

adam/commands/{watch.py → cassandra/watch.py}

@@ -8,10 +8,10 @@ from adam.commands.commands_utils import show_pods, show_rollout
 from adam.config import Config
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import convert_seconds, log2
+from adam.utils import log2
 
 class Watch(Command):
-    COMMAND = 'watch'
+    COMMAND = 'watch cassandra pods'
 
     # the singleton pattern
     def __new__(cls, *args, **kwargs):
@@ -26,37 +26,34 @@ class Watch(Command):
         return Watch.COMMAND
 
     def required(self):
-        return RequiredState.CLUSTER_OR_POD
+        return RequiredState.NAMESPACE
 
     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
-
-        pods = StatefulSets.pods(state.sts, state.namespace)
-        if not pods:
-            log2("No pods are found.")
-            return state
+        with self.validate(args, state) as (args, state):
+            pods = StatefulSets.pods(state.sts, state.namespace)
+            if not pods:
+                log2("No pods are found.")
+                return state
 
-        stop_event = threading.Event()
-        thread = threading.Thread(target=self.loop, args=(stop_event, state.sts, pods, state.namespace), daemon=True)
-        thread.start()
+            stop_event = threading.Event()
+            thread = threading.Thread(target=self.loop, args=(stop_event, state.sts, pods, state.namespace), daemon=True)
+            thread.start()
 
-        try:
-            log2(f"Press Ctrl+C to break.")
+            try:
+                log2(f"Press Ctrl+C to break.")
 
-            time.sleep(Config().get('watch.timeout', 3600 * 1))
-        except KeyboardInterrupt:
-            pass
+                time.sleep(Config().get('watch.timeout', 3600 * 1))
+            except KeyboardInterrupt:
+                pass
 
-        log2("Stopping watch...")
-        stop_event.set()
-        thread.join()
+            log2("Stopping watch...")
+            stop_event.set()
+            thread.join()
 
-        return state
+            return state
 
     def loop(self, stop_flag: threading.Event, sts: str, pods: List[client.V1Pod], ns: str):
         show_pods(pods, ns)
@@ -73,13 +70,13 @@ class Watch(Command):
                 cnt = Config().get('watch.interval', 10)
 
     def completion(self, state: ReplState):
-        if state.pod:
-            return {}
+        if sc := super().completion(state):
+            if state.sts:
+                return sc
 
-        if not state.sts:
-            return {Watch.COMMAND: {n: None for n in StatefulSets.list_sts_names()}}
+            return super().completion(state, {n: None for n in StatefulSets.list_sts_names()})
 
-        return {Watch.COMMAND: None}
+        return {}
 
     def help(self, _: ReplState):
-        return f'{Watch.COMMAND}\t watch pod changes'
+        return f'{Watch.COMMAND}\t watch Cassandra pod changes'

adam/commands/{cli_commands.py → cli/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.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/cli/clipboard_copy.py

@@ -0,0 +1,86 @@
+from functools import partial
+import click
+import pyperclip
+
+from adam.commands import validate_args
+from adam.commands.cli.cli_commands import CliCommands
+from adam.commands.command import Command, InvalidArgumentsException
+from adam.commands.command_helpers import ClusterOrPodCommandHelper
+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/cli/show_cli_commands.py

@@ -0,0 +1,56 @@
+from adam.commands.cli.cli_commands import CliCommands
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import tabulize, log
+
+class ShowKubectlCommands(Command):
+    COMMAND = 'show cli-commands'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowKubectlCommands, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowKubectlCommands.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):
+            v = CliCommands.values(state, collapse=True)
+            # node-exec-?, nodetool-?, cql-?, reaper-exec, reaper-forward, reaper-ui, reaper-username, reaper-password
+            cmds = [
+                f'bash,{v["node-exec-?"]}',
+                f'nodetool,{v["nodetool-?"]}',
+                f'cql,{v["cql-?"]}',
+            ]
+
+            if 'reaper-exec' in v:
+                cmds += [
+                    f'reaper,{v["reaper-exec"]}',
+                    f',{v["reaper-forward"]}  * should be run from your laptop',
+                    f',{v["reaper-ui"]}',
+                    f',{v["reaper-username"]}',
+                    f',{v["reaper-password"]}',
+                ]
+
+            cmds += [f'{k},{v0}' for k, v0 in v.items() if k.startswith('pg-')]
+
+            tabulize(cmds, separator=',')
+
+            return cmds
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f"{ShowKubectlCommands.COMMAND}\t show kubectl commands"

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'