kaqing 2.0.184__py3-none-any.whl → 2.0.227__py3-none-any.whl

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, state: ReplState):
+        return super().help(state, 'restart Cassandra nodes', args='<pod-name>... --force')

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

@@ -3,8 +3,8 @@ from kubernetes import client
 from kubernetes.client.rest import ApiException
 
 from adam.commands import extract_options
+from adam.commands.cassandra.watch import Watch
 from adam.commands.command import Command
-from adam.commands.watch import Watch
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
@@ -84,5 +84,5 @@ class RollOut(Command):
 
         return {}
 
-    def help(self, _: ReplState):
-        return f'{RollOut.COMMAND} [--force]\t rollout all nodes'
+    def help(self, state: ReplState):
+        return super().help(state, 'rollout all nodes  --force ignore current rolling out', args='[--force]')

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

@@ -1,3 +1,4 @@
+from adam.commands import extract_trailing_options
 from adam.commands.command import Command
 from adam.commands.cql.utils_cql import cassandra
 from adam.repl_state import ReplState, RequiredState
@@ -25,11 +26,12 @@ class ShowCassandraRepairs(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            with cassandra(state) as pods:
-                return pods.nodetool('repair_admin list')
+            with extract_trailing_options(args, '&') as (args, backgrounded):
+                with cassandra(state) as pods:
+                    return pods.nodetool('repair_admin list', backgrounded=backgrounded)
 
     def completion(self, state: ReplState):
-        return super().completion(state)
+        return super().completion(state, {'&': None})
 
-    def help(self, _: ReplState):
-        return f'{ShowCassandraRepairs.COMMAND}\t show Cassandra repairs'
+    def help(self, state: ReplState):
+        return super().help(state, 'show Cassandra repairs', args='[&]')

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

@@ -1,3 +1,4 @@
+from datetime import datetime
 import sys
 
 from adam.checks.check_result import CheckResult
@@ -5,14 +6,16 @@ from adam.checks.check_utils import run_checks
 from adam.checks.compactionstats import CompactionStats
 from adam.checks.gossip import Gossip
 from adam.columns.columns import Columns
-from adam.commands import extract_options
+from adam.commands import extract_options, extract_trailing_options
 from adam.commands.command import Command
+from adam.commands.commands_utils import write_to_kaqing_log_file
 from adam.commands.cql.utils_cql import cassandra
 from adam.config import Config
+from adam.repl_session import ReplSession
 from adam.utils_issues import IssuesUtils
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import SORT, tabulize, log, log2, log_exc
+from adam.utils import SORT, log_dir, tabulize, log2, log_exc
 from adam.checks.status import parse_nodetool_status
 
 class ShowCassandraStatus(Command):
@@ -38,23 +41,24 @@ class ShowCassandraStatus(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            with extract_options(args, ['-s', '--show']) as (args, show_out):
-                if state.namespace and state.pod:
-                    self.show_single_pod(state, show_out=show_out)
-                elif state.namespace and state.sts:
-                    self.merge(state, Config().get('nodetool.samples', sys.maxsize), show_output=show_out)
+            with extract_trailing_options(args, '&') as (args, backgrounded):
+                with extract_options(args, ['-s', '--show']) as (args, show_out):
+                    if state.namespace and state.pod:
+                        self.show_single_pod(state, show_out=show_out, backgrounded=backgrounded)
+                    elif state.namespace and state.sts:
+                        self.merge(state, Config().get('nodetool.samples', sys.maxsize), show_output=show_out, backgrounded=backgrounded)
 
-                return state
+                    return state
 
-    def show_single_pod(self, state: ReplState, show_out = False):
+    def show_single_pod(self, state: ReplState, show_out = False, backgrounded = False):
         with log_exc(True):
             with cassandra(state) as pods:
                 result = pods.nodetool('status', show_out=False)
                 status = parse_nodetool_status(result.stdout)
                 check_results = run_checks(cluster=state.sts, namespace=state.namespace, checks=[CompactionStats(), Gossip()], show_out=show_out)
-                self.show_table(status, check_results)
+                self.show_table(status, check_results, backgrounded=backgrounded)
 
-    def merge(self, state: ReplState, samples: int, show_output=False):
+    def merge(self, state: ReplState, samples: int, show_output=False, backgrounded = False):
         statuses: list[list[dict]] = []
 
         pod_names = StatefulSets.pod_names(state.sts, state.namespace)
@@ -73,7 +77,7 @@ class ShowCassandraStatus(Command):
         combined_status = self.merge_status(statuses)
         log2(f'Showing merged status from {len(statuses)}/{len(pod_names)} nodes...')
         check_results = run_checks(cluster=state.sts, namespace=state.namespace, checks=[CompactionStats(), Gossip()], show_out=show_output)
-        self.show_table(combined_status, check_results)
+        self.show_table(combined_status, check_results, backgrounded=backgrounded)
 
         return combined_status
 
@@ -94,17 +98,20 @@ class ShowCassandraStatus(Command):
 
         return combined
 
-    def show_table(self, status: list[dict[str, any]], check_results: list[CheckResult]):
+    def show_table(self, status: list[dict[str, any]], check_results: list[CheckResult], backgrounded=False):
         cols = Config().get('status.columns', 'status,address,load,tokens,owns,host_id,gossip,compactions')
         header = Config().get('status.header', '--,Address,Load,Tokens,Owns,Host ID,GOSSIP,COMPACTIONS')
         columns = Columns.create_columns(cols)
 
-        tabulize(status, lambda s: ','.join([c.host_value(check_results, s) for c in columns]), header=header, separator=',', sorted=SORT)
+        r = tabulize(status, lambda s: ','.join([c.host_value(check_results, s) for c in columns]), header=header, separator=',', sorted=SORT, to = 0 if backgrounded else 1)
+
+        if backgrounded:
+            r = write_to_kaqing_log_file(r)
 
         IssuesUtils.show(check_results)
 
     def completion(self, state: ReplState):
-        return super().completion(state, {'-s': None})
+        return super().completion(state, {'-s': {'&': None}, '&': None})
 
-    def help(self, _: ReplState):
-        return f'{ShowCassandraStatus.COMMAND} [-s]\t show merged nodetool status  -s show commands on nodes'
+    def help(self, state: ReplState):
+        return super().help(state, 'show merged nodetool status  -s show processing details', args='[-s]')

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

@@ -31,5 +31,5 @@ class ShowCassandraVersion(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{ShowCassandraVersion.COMMAND}\t show Cassandra version'
+    def help(self, state: ReplState):
+        return super().help(state, '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', '=', 'mpstat']) 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-mpstat.columns', 'pod,cpu,mem')
+                            header = Config().get('processes-mpstat.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', 'mpstat']
+        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, state: ReplState):
+        return super().help(state, 'show process overview  -s show processing details', args='[with recipe=metrics|mpstat] [-s]')

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, state: ReplState):
+        return super().help(state, 'show storage overview  -s show processing details', args='[-s]')

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

@@ -78,5 +78,5 @@ class Watch(Command):
 
         return {}
 
-    def help(self, _: ReplState):
-        return f'{Watch.COMMAND}\t watch Cassandra pod changes'
+    def help(self, state: ReplState):
+        return super().help(state, 'watch Cassandra pod changes')

adam/commands/{cli_commands.py → cli/cli_commands.py}

@@ -3,14 +3,19 @@ import re
 
 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 = {}
 

adam/commands/{clipboard_copy.py → cli/clipboard_copy.py}

@@ -3,9 +3,9 @@ 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.commands.cli_commands import CliCommands
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import tabulize, log, log2
 
@@ -62,10 +62,10 @@ class ClipboardCopy(Command):
                 return state
 
     def completion(self, state: ReplState):
-        return super().completion(state, lambda: {key: None for key in CliCommands.values(state).keys()})
+        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"
+    def help(self, state: ReplState):
+        return super().help(state, 'copy a value to clipboard for conveninence', args='<key')
 
 class CopyCommandHelper(click.Command):
     def lines(self):

adam/commands/{show/show_commands.py → cli/show_cli_commands.py}

@@ -1,7 +1,7 @@
+from adam.commands.cli.cli_commands import CliCommands
 from adam.commands.command import Command
-from adam.commands.cli_commands import CliCommands
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import tabulize, log
+from adam.utils import tabulize
 
 class ShowKubectlCommands(Command):
     COMMAND = 'show cli-commands'
@@ -22,7 +22,7 @@ class ShowKubectlCommands(Command):
         return RequiredState.CLUSTER_OR_POD
 
     def run(self, cmd: str, state: ReplState):
-        if not self.args(cmd):
+        if not (args := self.args(cmd)):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
@@ -52,5 +52,5 @@ class ShowKubectlCommands(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f"{ShowKubectlCommands.COMMAND}\t show kubectl commands"
+    def help(self, state: ReplState):
+        return super().help(state, 'show kubectl commands')

adam/commands/code.py

@@ -53,5 +53,5 @@ class Code(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{Code.COMMAND} \t invoke interactive Python shell'
+    def help(self, state: ReplState):
+        return super().help(state, 'run interactive Python shell')

adam/commands/command.py

@@ -5,8 +5,10 @@ import subprocess
 import sys
 from typing import Union
 
+from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import is_lambda, log2
+from adam.sql.lark_completer import LarkCompleter
+from adam.utils import log2
 
 repl_cmds: list['Command'] = []
 
@@ -20,6 +22,9 @@ class Command:
     def command(self) -> str:
         pass
 
+    def aliases(self):
+        return None
+
     # The chain of responsibility pattern
     # Do not do child of child!!!
     @abstractmethod
@@ -29,10 +34,10 @@ class Command:
 
         return None
 
-    def completion(self, state: ReplState, leaf: dict[str, any] = None, pods: tuple[list[str], str] = None) -> dict[str, any]:
+    def completion(self, state: ReplState, leaf: dict[str, any] = None, pods: tuple[list[str], str] = None, auto: str = 'on', auto_key: str = None) -> dict[str, any]:
         # pods is a tuple of list of pod names and the current pod repl is on
         if not pods:
-            return self._completion(state, leaf)
+            return self._completion(state, leaf, auto=auto, auto_key=auto_key)
 
         c = {}
 
@@ -40,23 +45,39 @@ class Command:
         pod = pods[1]
 
         if pod:
-            c |= self._completion(state, leaf)
+            c |= self._completion(state, leaf, auto=auto, auto_key=auto_key)
 
-        c |= {f'@{p}': self._completion(state, leaf, to_validate=False) for p in pod_names if p != pod}
+        c |= {f'@{p}': self._completion(state.with_pod(p), leaf, to_validate=False, auto=auto, auto_key=auto_key) for p in pod_names if p != pod}
 
         return c
 
-    def _completion(self, state: ReplState, leaf: dict[str, any] = None, to_validate = True) -> dict[str, any]:
+    def _completion(self, state: ReplState, leaf: dict[str, any] = None, to_validate = True, auto: str = 'on', auto_key: str = None) -> dict[str, any]:
         if to_validate and not self.validate_state(state, show_err=False):
             return {}
 
-        if is_lambda(leaf):
-            leaf = leaf()
+        if callable(leaf):
+            if auto_key:
+                auto_key = f'auto-complete.{auto_key}'
+                auto = Config().get(auto_key, 'off')
+
+            if auto == 'on':
+                leaf = leaf()
+            elif auto in ['lazy', 'jit']:
+                leaf = LarkCompleter.from_lambda(auto_key, leaf, auto=auto)
+            else:
+                leaf = None
 
         d = leaf
         for t in reversed(self.command().split(' ')):
             d = {t: d}
 
+        if aliases := self.aliases():
+            for alias in aliases:
+                a = leaf
+                for t in reversed(alias.split(' ')):
+                    a = {t: a}
+                d |= a
+
         return d
 
     def required(self) -> RequiredState:
@@ -68,16 +89,33 @@ class Command:
     def validate_state(self, state: ReplState, show_err = True):
         return state.validate(self.required(), show_err=show_err)
 
-    def help(self, _: ReplState) -> str:
-        return None
+    def help(self, _: ReplState, desc: str = None, command: str = None, args: str = None):
+        if not desc:
+            return None
+
+        if not command:
+            command = self.command()
+        if args:
+            args = f' {args}'
+        else:
+            args = ''
+        aliases = '  alias ' + ','.join(self.aliases()) if self.aliases() else ''
+        return f'{command}{args}{aliases}\t{desc}'
 
     def args(self, cmd: str):
         a = list(filter(None, cmd.split(' ')))
         spec = self.command_tokens()
-        if spec != a[:len(spec)]:
-            return None
+        if spec == a[:len(spec)]:
+            return a
 
-        return a
+        if aliases := self.aliases():
+            for alias in aliases:
+                a = list(filter(None, cmd.split(' ')))
+                spec = alias.split(' ')
+                if spec == a[:len(spec)]:
+                    return a
+
+        return None
 
     def apply_state(self, args: list[str], state: ReplState, resolve_pg = True, args_to_check = 6) -> tuple[ReplState, list[str]]:
         """
@@ -130,7 +168,7 @@ class Command:
             options = [options]
 
         if args and trailing:
-            while args[-1] in trailing:
+            while args and args[-1] in trailing:
                 found_trailing = True
                 args = args[:-1]
 
@@ -148,6 +186,8 @@ class Command:
         return new_args, found_trailing, found_sequence, found_options
 
     def extract_option_sequence(args, sequence):
+        new_args = args
+
         len_sub = len(sequence)
         len_main = len(args)
         for i in range(len_main - len_sub + 1):

adam/commands/commands_utils.py

@@ -8,7 +8,7 @@ from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.utils_k8s.pods import Pods
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState
-from adam.utils import SORT, duration, tabulize, log, log2
+from adam.utils import SORT, duration, kaqing_log_file, tabulize, log2
 
 def show_pods(pods: List[client.V1Pod], ns: str, show_namespace = True, show_host_id = True):
     if len(pods) == 0:
@@ -59,14 +59,22 @@ def show_rollout(sts: str, ns: str):
         else:
             log2(f'Cluster has completed rollout {d} ago.')
 
-def show_table(state: ReplState, pods: list[str], cols: str, header: str, show_out=False):
+def show_table(state: ReplState, pods: list[str], cols: str, header: str, show_out=False, backgrounded = False):
     columns = Columns.create_columns(cols)
 
     results = run_checks(cluster=state.sts, pod=state.pod, namespace=state.namespace, checks=collect_checks(columns), show_out=show_out)
 
-    def line(pod_name: str):
-        return
+    r = tabulize(pods, lambda p: ','.join([c.pod_value(results, p) for c in columns]), header=header, separator=',', sorted=SORT, to = 0 if backgrounded else 1)
+
+    if backgrounded:
+        r = write_to_kaqing_log_file(r)
+
+    IssuesUtils.show(results, state.in_repl)
+
+    return r
 
-    tabulize(pods, lambda p: ','.join([c.pod_value(results, p) for c in columns]), header=header, separator=',', sorted=SORT)
+def write_to_kaqing_log_file(r: str):
+    with kaqing_log_file() as f:
+        f.write(r)
 
-    IssuesUtils.show(results, state.in_repl)
+        return f.name

adam/commands/{param_get.py → config/param_get.py}

@@ -38,5 +38,5 @@ class GetParam(Command):
     def completion(self, _: ReplState):
         return {GetParam.COMMAND: {key: None for key in Config().keys()}}
 
-    def help(self, _: ReplState):
-        return f"{GetParam.COMMAND} <key>\t shows a Kaqing parameter"
+    def help(self, state: ReplState):
+        return super().help(state, "shows a Kaqing system parameter's value", args='<key>')

adam/commands/{param_set.py → config/param_set.py}

@@ -36,5 +36,5 @@ class SetParam(Command):
     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()}}
 
-    def help(self, _: ReplState):
-        return f"{SetParam.COMMAND} <key> <value>\t sets a Kaqing parameter to a different value"
+    def help(self, state: ReplState):
+        return super().help(state, 'sets a Kaqing system parameter to a different value', args='<key> <value>')

adam/commands/{show → config}/show_params.py

@@ -1,7 +1,7 @@
 from adam.commands.command import Command
 from adam.config import Config
 from adam.repl_state import ReplState
-from adam.utils import tabulize, log
+from adam.utils import tabulize
 
 class ShowParams(Command):
     COMMAND = 'show params'
@@ -27,5 +27,5 @@ class ShowParams(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f"{ShowParams.COMMAND}\t show Kaqing parameters"
+    def help(self, state: ReplState):
+        return super().help(state, 'show Kaqing system parameters')

adam/commands/{alter_tables.py → cql/alter_tables.py}

@@ -59,8 +59,8 @@ class AlterTables(Command):
                     return state
 
     def completion(self, _: ReplState) -> dict[str, any]:
-        # auto completion is taken care of by sql completer
+        # auto completion is taken care of by lark completer
         return {}
 
-    def help(self, _: ReplState) -> str:
-        return f'{AlterTables.COMMAND} <param = value> [--include-reaper] \t alter schema on all tables'
+    def help(self, state: ReplState) -> str:
+        return super().help(state, 'alter schema on all tables', args='with <param=value>,... [--include-reaper]')

adam/commands/cql/completions_c.py

@@ -0,0 +1,29 @@
+from adam.commands.cql.utils_cql import cassandra_keyspaces, cassandra_table_names
+from adam.commands.export.export_sessions import ExportSessions
+from adam.commands.export.export_databases import ExportDatabases
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.sql.lark_completer import LarkCompleter
+from adam.utils import log_timing
+from adam.utils_k8s.statefulsets import StatefulSets
+
+def completions_c(state: ReplState) -> dict[str, any]:
+    ps = Config().get('cql.alter-tables.gc-grace-periods', '3600,86400,864000,7776000').split(',')
+
+    with log_timing('lark.completions'):
+        return LarkCompleter(
+            expandables = {
+                'tables': lambda x: cassandra_table_names(state),
+                'keyspaces': lambda x: cassandra_keyspaces(state.with_no_pod()),
+                'table-props': {
+                    'GC_GRACE_SECONDS': ps
+                },
+                'table-props-value': lambda x: {None: None, 'GC_GRACE_SECONDS': ps}[x],
+                'export-database-types': ['athena', 'sqlite', 'csv'],
+                'export-databases': lambda x: ExportDatabases.database_names(),
+                'export-sessions': lambda x: ExportSessions.export_session_names(state.sts, state.pod, state.namespace),
+                'export-sessions-incomplete': lambda x: ExportSessions.export_session_names(state.sts, state.pod, state.namespace, export_state='pending_import'),
+                'hosts': lambda x: [f'@{p}' for p in StatefulSets.pod_names(state.sts, state.namespace)],
+            },
+            variant=ReplState.C
+        ).completions_for_nesting()