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

adam/commands/audit/show_top10.py

@@ -1,8 +1,6 @@
-from adam.commands.audit.utils_show_top10 import extract_limit_and_duration
+from adam.commands.audit.utils_show_top10 import run_configured_query
 from adam.commands.command import Command
 from adam.repl_state import ReplState
-from adam.utils import log2
-from adam.utils_audits import Audits
 
 class ShowTop10(Command):
     COMMAND = 'show top'
@@ -26,20 +24,10 @@ class ShowTop10(Command):
         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
-
-        limit, date_condition = extract_limit_and_duration(args)
-        query = '\n    '.join([
-            "SELECT min(c) AS cluster, line, COUNT(*) AS cnt, avg(CAST(duration AS REAL)) AS duration",
-            f"FROM audit WHERE drive <> 'z' and ({date_condition})",
-            f"GROUP BY line ORDER BY cnt DESC LIMIT {limit};"])
-        log2(query)
-        log2()
-        Audits.run_audit_query(query)
+        with self.validate(args, state) as (args, state):
+            run_configured_query('audit.queries.top10', args)
 
-        return state
+            return state
 
     def completion(self, _: ReplState):
         return {}

adam/commands/audit/utils_show_top10.py

@@ -1,17 +1,29 @@
 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:
-        try:
+        with log_exc():
             limit = int(args[0])
-        except:
-            pass
 
         if len(args) > 2 and args[1] == 'over':
             if args[2] == 'day':

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, history=False)
+
+            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/{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"

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

@@ -2,8 +2,9 @@ import datetime
 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
@@ -31,32 +32,28 @@ class RollOut(Command):
         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
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, '--force') as (args, forced):
+                restarted, rollingout = StatefulSets.restarted_at(state.sts, state.namespace)
+                if rollingout and not forced:
+                    log2(f"* Cluster is being rolled out for {duration(restarted)}. Please wait until it's done or use --force.")
 
-        args, forced = Command.extract_options(args, '--force')
+                    return state
 
-        restarted, rollingout = StatefulSets.restarted_at(state.sts, state.namespace)
-        if rollingout and not forced:
-            log2(f"* Cluster is being rolled out for {duration(restarted)}. Please wait until it's done or use --force.")
+                self.rolling_restart(state.sts, state.namespace)
 
-            return state
+                auto_watch = False
+                if (auto_watch_cmds := Config().get('watch.auto', 'rollout')):
+                    cmds = [c.strip(' ') for c in auto_watch_cmds.split(',')]
+                    if self.command() in cmds:
+                        auto_watch = True
+                        log2('Rolling out cluster with auto watch...')
+                        Watch().run('watch', state)
 
-        self.rolling_restart(state.sts, state.namespace)
+                if not auto_watch:
+                    log2('Rolling out cluster...')
 
-        auto_watch = False
-        if (auto_watch_cmds := Config().get('watch.auto', 'rollout')):
-            cmds = [c.strip(' ') for c in auto_watch_cmds.split(',')]
-            if self.command() in cmds:
-                auto_watch = True
-                log2('Rolling out cluster with auto watch...')
-                Watch().run('watch', state)
-
-        if not auto_watch:
-            log2('Rolling out cluster...')
-
-        return state
+                return state
 
     def rolling_restart(self, statefulset, namespace):
         # kubectl rollout restart statefulset <statefulset-name>
@@ -82,9 +79,7 @@ class RollOut(Command):
             log2("Exception when calling AppsV1Api->read_namespaced_statefulset_status: %s\n" % e)
 
     def completion(self, state: ReplState):
-        if state.pod:
-            return {}
-        elif state.sts:
+        if super().completion(state):
             return {RollOut.COMMAND: None}
 
         return {}

adam/commands/cassandra/show_cassandra_repairs.py

@@ -0,0 +1,37 @@
+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
+
+class ShowCassandraRepairs(Command):
+    COMMAND = 'show cassandra repairs'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowCassandraRepairs, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowCassandraRepairs.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 cassandra(state) as pods:
+                    return pods.nodetool('repair_admin list', backgrounded=backgrounded)
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'&': None})
+
+    def help(self, _: ReplState):
+        return f'{ShowCassandraRepairs.COMMAND}\t show Cassandra repairs'

adam/commands/cassandra/show_cassandra_status.py

@@ -0,0 +1,117 @@
+from datetime import datetime
+import sys
+
+from adam.checks.check_result import CheckResult
+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, 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, log_dir, tabulize, log2, log_exc
+from adam.checks.status import parse_nodetool_status
+
+class ShowCassandraStatus(Command):
+    COMMAND = 'show cassandra status'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowCassandraStatus, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowCassandraStatus.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):
+                    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
+
+    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, backgrounded=backgrounded)
+
+    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)
+        for pod_name in pod_names:
+            pod_name = pod_name.split('(')[0]
+
+            with log_exc(True):
+                with cassandra(state, pod=pod_name) as pods:
+                    result = pods.nodetool('status', show_out=False)
+                    status = parse_nodetool_status(result.stdout)
+                    if status:
+                        statuses.append(status)
+                    if samples <= len(statuses) and len(pod_names) != len(statuses):
+                        break
+
+        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, backgrounded=backgrounded)
+
+        return combined_status
+
+    def merge_status(self, statuses: list[list[dict]]):
+        combined = statuses[0]
+
+        status_by_host = {}
+        for status in statuses[0]:
+            status_by_host[status['host_id']] = status
+        for status in statuses[1:]:
+            for s in status:
+                if s['host_id'] in status_by_host:
+                    c = status_by_host[s['host_id']]
+                    if c['status'] == 'UN' and s['status'] == 'DN':
+                        c['status'] = 'DN*'
+                else:
+                    combined.append(s)
+
+        return combined
+
+    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)
+
+        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}, '&': None})
+
+    def help(self, _: ReplState):
+        return f'{ShowCassandraStatus.COMMAND} [-s]\t show merged nodetool status  -s show commands on nodes'