kaqing 2.0.184__tar.gz → 2.0.209__tar.gz

kaqing-2.0.209/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include adam qingl.lark

{kaqing-2.0.184 → kaqing-2.0.209}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.184
+Version: 2.0.209
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.184 → kaqing-2.0.209}/adam/app_session.py

@@ -8,7 +8,7 @@ from adam.log import Log
 from adam.sso.idp import Idp
 from adam.sso.idp_login import IdpLogin
 from adam.config import Config
-from adam.utils import debug, debug_trace, json_to_csv, tabulize, log, log2, log_exc
+from adam.utils import debug, debug_trace, json_to_csv, tabulize, log2, log_exc
 from adam.apps import Apps
 
 class AppLogin:

{kaqing-2.0.184 → kaqing-2.0.209}/adam/batch.py

@@ -11,16 +11,16 @@ from adam.commands.deploy.deploy import Deploy, DeployCommandHelper
 from adam.commands.deploy.undeploy import Undeploy, UndeployCommandHelper
 from adam.commands.issues import Issues
 from adam.commands.login import Login
-from adam.commands.logs import Logs
-from adam.commands.ls import Ls
+from adam.commands.download_cassandra_log import DownloadCassandraLog
+from adam.commands.fs.ls import Ls
 from adam.commands.medusa.medusa import Medusa
 from adam.commands.nodetool import NodeTool, NodeToolCommandHelper
 from adam.commands.postgres.postgres import Postgres, PostgresCommandHelper
 from adam.commands.preview_table import PreviewTable
 from adam.commands.reaper.reaper import Reaper, ReaperCommandHelper
 from adam.commands.repair.repair import Repair, RepairCommandHelper
-from adam.commands.report import Report
-from adam.commands.restart import Restart
+from adam.commands.generate_report import GenerateReport
+from adam.commands.restart_nodes import RestartNodes
 from adam.commands.rollout import RollOut
 from adam.commands.show.show import Show, ShowCommandHelper
 from adam.commands.watch import Watch
@@ -128,7 +128,7 @@ def login(kubeconfig: str, config: str, param: list[str], namespace: str, pod: s
 @click.option('--pod', '-p', required=False, metavar='pod', help='Kubernetes pod name')
 @click.argument('extra_args', nargs=-1, metavar='<pod>', type=click.UNPROCESSED)
 def logs(kubeconfig: str, config: str, param: list[str], namespace: str, pod: str, extra_args):
-    run_command(Logs(), kubeconfig, config, param, None, namespace, pod, extra_args)
+    run_command(DownloadCassandraLog(), kubeconfig, config, param, None, namespace, pod, extra_args)
 
 
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterCommandHelper, help='List statefulset or pods.')
@@ -221,7 +221,7 @@ def repair(kubeconfig: str, config: str, param: list[str], cluster: str, namespa
 @click.option('--show', '-s', is_flag=True, help='show output from Cassandra nodes')
 @click.argument('extra_args', nargs=-1, metavar='[cluster|pod]', type=click.UNPROCESSED)
 def report(kubeconfig: str, config: str, param: list[str], cluster: str, namespace: str, pod: str, show: bool, extra_args):
-    run_command(Report(), kubeconfig, config, param, cluster, namespace, pod, ('-s',) + extra_args if show else extra_args)
+    run_command(GenerateReport(), kubeconfig, config, param, cluster, namespace, pod, ('-s',) + extra_args if show else extra_args)
 
 
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help='Restart Cassandra Cluster or Node')
@@ -234,7 +234,7 @@ def report(kubeconfig: str, config: str, param: list[str], cluster: str, namespa
 @click.option('--force', is_flag=True, help='need for restarting the whole cluster')
 @click.argument('extra_args', nargs=-1, metavar='<cluster|pod>', type=click.UNPROCESSED)
 def restart(kubeconfig: str, config: str, param: list[str], cluster: str, namespace: str, pod: str, force: bool, extra_args):
-    run_command(Restart(), kubeconfig, config, param, cluster, namespace, pod, ('--force',) + extra_args if force else extra_args)
+    run_command(RestartNodes(), kubeconfig, config, param, cluster, namespace, pod, ('--force',) + extra_args if force else extra_args)
 
 
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help='Rolling restart Cassandra Cluster.')

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/app/app.py

@@ -31,8 +31,8 @@ class App(Command):
 
                 return state
 
-    def completion(self, state: ReplState):
-        return super().completion(state, {'--force': None})
+    def completion(self, _: ReplState):
+        return {}
 
     def help(self, _: ReplState):
         return f"<AppType>.<AppAction> <args> [--force]\t post app action; check with 'show app actions' command"

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/app/show_app_actions.py

@@ -1,5 +1,5 @@
 from adam.app_session import AppSession
-from adam.apps import AppAction, Apps
+from adam.apps import Apps
 from adam.commands.command import Command
 from adam.config import Config
 from adam.repl_state import ReplState

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/app/utils_app.py

@@ -3,12 +3,20 @@ from typing import Union
 
 from adam.app_session import AppSession
 from adam.apps import Apps
-from adam.pod_exec_result import PodExecResult
+from adam.utils_k8s.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
 from adam.utils import log2
 from adam.utils_k8s.app_clusters import AppClusters
 from adam.utils_k8s.app_pods import AppPods
 
+def app_cd_dirs(state: ReplState):
+    if state.app_app:
+        return ['..'] + AppPods.pod_names(state.namespace, state.app_env, state.app_app)
+    elif state.app_env:
+        return ['..'] + [app[0].split('-')[1] for app in Apps.apps(state.app_env)]
+    else:
+        return [env[0] for env in Apps.envs()]
+
 class AppRestHandler:
     def __init__(self, state: ReplState, forced = False):
         self.state = state

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/audit/audit.py

@@ -1,6 +1,7 @@
 import click
 
 from adam.commands import validate_args
+from adam.commands.audit.completions_l import completions_l
 from adam.commands.audit.audit_repair_tables import AuditRepairTables
 from adam.commands.audit.audit_run import AuditRun
 from adam.commands.audit.show_last10 import ShowLast10
@@ -10,7 +11,7 @@ from adam.commands.audit.utils_show_top10 import show_top10_completions_for_nest
 from adam.commands.command import Command
 from adam.commands.intermediate_command import IntermediateCommand
 from adam.repl_state import ReplState
-from adam.sql.sql_completer import SqlCompleter, SqlVariant
+from adam.sql.lark_completer import LarkCompleter
 from adam.utils import log2, wait_log
 from adam.utils_athena import Athena
 
@@ -50,25 +51,10 @@ class Audit(IntermediateCommand):
             return state
 
     def completion(self, state: ReplState):
-        if state.device == ReplState.L:
-            if not self.schema_read:
-                wait_log(f'Inspecting audit database schema...')
-                self.schema_read = True
-                # warm up the caches first time when l: drive is accessed
-                Athena.table_names()
-                Athena.column_names()
-                Athena.column_names(partition_cols_only=True)
-
-            return super().completion(state) | show_top10_completions_for_nesting() | SqlCompleter(
-                lambda: Athena.table_names(),
-                expandables={
-                    'columns': lambda table: Athena.column_names(),
-                    'partition_columns': lambda table: Athena.column_names(partition_cols_only=True)
-                },
-                variant=SqlVariant.ATHENA
-            ).completions_for_nesting()
-
-        return {}
+        if state.device != ReplState.L:
+            return {}
+
+        return completions_l()
 
     def cmd_list(self):
         return [AuditRepairTables(), AuditRun(), ShowLast10(), ShowSlow10(), ShowTop10()]

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/audit/audit_repair_tables.py

@@ -46,7 +46,7 @@ class AuditRepairTables(Command):
                     with Audits.offload() as exec:
                         exec.submit(lambda: self.auto_repair(hours))
 
-            return super().completion(state)
+            # return super().completion(state)
 
         return {}
 

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/audit/audit_run.py

@@ -44,7 +44,7 @@ class AuditRun(Command):
             return state
 
     def completion(self, state: ReplState):
-        return super().completion(state)
+        return {}
 
     def help(self, _: ReplState):
         return f"{AuditRun.COMMAND}\t run"

kaqing-2.0.209/adam/commands/audit/completions_l.py

@@ -0,0 +1,15 @@
+from adam.repl_state import ReplState
+from adam.sql.lark_completer import LarkCompleter
+from adam.utils_athena import Athena
+
+def completions_l():
+    return LarkCompleter(
+        expandables={
+            'tables': lambda x: Athena.table_names(),
+            'columns': lambda table: Athena.column_names(),
+            'partition-columns': lambda table: Athena.column_names(partition_cols_only=True),
+            'topn-counts': lambda x: ['10'],
+            'topn-types': lambda x: ['last', 'slow', 'top'],
+            'topn-windows': lambda x: ['day', 'month'],
+        }, variant=ReplState.L
+    ).completions_for_nesting()

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/audit/show_last10.py

@@ -30,7 +30,6 @@ class ShowLast10(Command):
             return state
 
     def completion(self, _: ReplState):
-
         return {}
 
     def help(self, _: ReplState):

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/bash/bash.py

@@ -30,7 +30,7 @@ class Bash(Command):
                 return exec(args)
 
     def completion(self, state: ReplState):
-        return Devices.device(state).bash_completion(Bash.COMMAND, state, default = {})
+        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'

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/bash/utils_bash.py

@@ -13,4 +13,4 @@ class BashHandler:
         return False
 
     def exec(self, args: list[str]):
-        return Devices.device(self.s1).bash(self.s0, self.s1, args)
+        return Devices.of(self.s1).bash(self.s0, self.s1, args)

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/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 = {}
 

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/clipboard_copy.py

@@ -6,6 +6,7 @@ from adam.commands import validate_args
 from adam.commands.command import Command, InvalidArgumentsException
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
 from adam.commands.cli_commands import CliCommands
+from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import tabulize, log, log2
 
@@ -62,7 +63,7 @@ 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"

{kaqing-2.0.184 → kaqing-2.0.209}/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'] = []
 
@@ -29,10 +31,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,18 +42,27 @@ 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(' ')):
@@ -130,7 +141,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 +159,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):

{kaqing-2.0.184 → kaqing-2.0.209}/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

{kaqing-2.0.184/adam/commands → kaqing-2.0.209/adam/commands/cql}/alter_tables.py

@@ -59,7 +59,7 @@ 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:

kaqing-2.0.209/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': lambda x: {
+                    'GC_GRACE_SECONDS': ps
+                },
+                'table-props-value': lambda x: {None: None, 'GC_GRACE_SECONDS': ps}[x],
+                'export-database-types': lambda x: ['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()

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/cql/cqlsh.py

@@ -3,9 +3,8 @@ import click
 from adam.commands import extract_trailing_options
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
-from adam.commands.cql.cql_completions import cql_completions
+from adam.commands.cql.completions_c import completions_c
 from adam.commands.cql.utils_cql import cassandra
-from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log
 
@@ -38,13 +37,10 @@ class Cqlsh(Command):
 
     def completion(self, state: ReplState) -> dict[str, any]:
         if state.device != state.C:
-            # conflicts with psql completions
             return {}
 
         if state.sts or state.pod:
-            c = cql_completions(state)
-            return c | \
-                   {f'@{p}': c for p in StatefulSets.pod_names(state.sts, state.namespace)}
+            return completions_c(state)
 
         return {}
 

{kaqing-2.0.184 → kaqing-2.0.209}/adam/commands/cql/utils_cql.py

@@ -7,11 +7,19 @@ from adam.commands.commands_utils import show_table
 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.utils_k8s.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
 from adam.utils import log2, log_timing, wait_log
 from adam.utils_k8s.statefulsets import StatefulSets
 
+def cd_dirs(state: ReplState) -> list[str]:
+    if state.pod:
+        return [".."]
+    elif state.sts:
+        return [".."] + StatefulSets.pod_names(state.sts, state.namespace)
+    else:
+        return StatefulSets.list_sts_names()
+
 @functools.lru_cache()
 def cassandra_keyspaces(state: ReplState, on_any=True):
     if state.pod:
@@ -47,7 +55,7 @@ def table_spec(state: ReplState, table: str, on_any=False) -> 'TableSpec':
 
     return parse_cql_desc_table(r.stdout if state.pod else r[0].stdout)
 
-def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, backgrounded=False, log_file=None) -> list[PodExecResult]:
+def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, backgrounded=False, log_file=None, history=True) -> list[PodExecResult]:
     if show_query:
         log2(cql)
 
@@ -61,7 +69,7 @@ def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, show_
 
     with log_timing(cql):
         with cassandra(state) as pods:
-            return pods.exec(command, action='cql', show_out=show_out, on_any=on_any, backgrounded=backgrounded, log_file=log_file)
+            return pods.exec(command, action='cql', show_out=show_out, on_any=on_any, backgrounded=backgrounded, log_file=log_file, history=history)
 
 def parse_cql_desc_tables(out: str):
     # Keyspace data_endpoint_auth
@@ -219,16 +227,16 @@ class CassandraPodService:
     def __init__(self, handler: 'CassandraExecHandler'):
         self.handler = handler
 
-    def exec(self, command: str, action='bash', show_out = True, on_any = False, throw_err = False, shell = '/bin/sh', backgrounded = False, log_file = None) -> Union[PodExecResult, list[PodExecResult]]:
+    def exec(self, command: str, action='bash', show_out = True, on_any = False, throw_err = False, shell = '/bin/sh', backgrounded = False, log_file = None, history=True) -> Union[PodExecResult, list[PodExecResult]]:
         state = self.handler.state
         pod = self.handler.pod
 
         if pod:
             return CassandraNodes.exec(pod, state.namespace, command,
-                                    show_out=show_out, throw_err=throw_err, shell=shell, backgrounded=backgrounded, log_file=log_file)
+                                    show_out=show_out, throw_err=throw_err, shell=shell, backgrounded=backgrounded, log_file=log_file, history=history)
         elif state.sts:
             return CassandraClusters.exec(state.sts, state.namespace, command, action=action,
-                                        show_out=show_out, on_any=on_any, shell=shell, backgrounded=backgrounded, log_file=log_file)
+                                        show_out=show_out, on_any=on_any, shell=shell, backgrounded=backgrounded, log_file=log_file, history=history)
 
         return []
 
@@ -259,16 +267,16 @@ class CassandraPodService:
 
         return run_cql(state, query, opts=opts, show_out=show_out, show_query=show_query, use_single_quotes=use_single_quotes, on_any=on_any, backgrounded=backgrounded, log_file=log_file)
 
-    def display_table(self, cols: str, header: str, show_out = True):
+    def display_table(self, cols: str, header: str, show_out = True, backgrounded = False):
         state = self.handler.state
 
         if state.pod:
-            show_table(state, [state.pod], cols, header, show_out=show_out)
+            return show_table(state, [state.pod], cols, header, show_out=show_out, backgrounded = backgrounded)
         elif state.sts:
             pod_names = [pod.metadata.name for pod in StatefulSets.pods(state.sts, state.namespace)]
-            show_table(state, pod_names, cols, header, show_out=show_out)
+            return show_table(state, pod_names, cols, header, show_out=show_out, backgrounded = backgrounded)
 
-    def nodetool(self, args: str, status = False, show_out = True) -> Union[PodExecResult, list[PodExecResult]]:
+    def nodetool(self, args: str, status = False, show_out = True, backgrounded = False) -> Union[PodExecResult, list[PodExecResult]]:
         state = self.handler.state
         pod = self.handler.pod
 
@@ -276,9 +284,9 @@ class CassandraPodService:
         command = f"nodetool -u {user} -pw {pw} {args}"
 
         if pod:
-            return CassandraNodes.exec(pod, state.namespace, command, show_out=show_out)
+            return CassandraNodes.exec(pod, state.namespace, command, show_out=show_out, backgrounded=backgrounded)
         else:
-            return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool.status' if status else 'nodetool', show_out=show_out)
+            return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool.status' if status else 'nodetool', show_out=show_out, backgrounded=backgrounded)
 
 class CassandraExecHandler:
     def __init__(self, state: ReplState, pod: str = None):
@@ -294,4 +302,4 @@ class CassandraExecHandler:
         return False
 
 def cassandra(state: ReplState, pod: str=None):
-    return CassandraExecHandler(state, pod=pod)
+    return CassandraExecHandler(state, pod=pod)

kaqing-2.0.209/adam/commands/debug/debug.py

@@ -0,0 +1,22 @@
+from adam.commands.command import Command
+from adam.commands.debug.debug_completes import DebugCompletes
+from adam.commands.debug.debug_timings import DebugTimings
+from adam.commands.intermediate_command import IntermediateCommand
+
+class Debug(IntermediateCommand):
+    COMMAND = 'debug'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Debug, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Debug.COMMAND
+
+    def cmd_list(self):
+        return [DebugTimings(), DebugCompletes()]

kaqing-2.0.209/adam/commands/debug/debug_completes.py

@@ -0,0 +1,35 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.config import Config
+from adam.repl_state import ReplState
+
+class DebugCompletes(Command):
+    COMMAND = 'debug completes'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DebugCompletes, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DebugCompletes.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='on, off or file') as args:
+                Config().set('debugs.complete', args)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {f: None for f in ['on', 'off', 'file']})
+
+    def help(self, _: ReplState):
+        return f'{DebugCompletes.COMMAND} on|off|file\t turn auto complete debug on or off'

kaqing-2.0.209/adam/commands/debug/debug_timings.py

@@ -0,0 +1,35 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.config import Config
+from adam.repl_state import ReplState
+
+class DebugTimings(Command):
+    COMMAND = 'debug timings'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DebugTimings, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DebugTimings.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='on, off or file') as args:
+                Config().set('debugs.timings', args)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {f: None for f in ['on', 'off', 'file']})
+
+    def help(self, _: ReplState):
+        return f'{DebugTimings.COMMAND} on|off|file\t turn timing debug on or off'