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

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:

adam/batch.py

@@ -2,28 +2,28 @@ import click
 
 from adam.commands.audit.audit import Audit, AuditCommandHelper
 from adam.commands.bash.bash import Bash
-from adam.commands.check import Check, CheckCommandHelper
-from adam.commands.clipboard_copy import ClipboardCopy, CopyCommandHelper
+from adam.commands.cassandra.restart_nodes import RestartNodes
+from adam.commands.cassandra.rollout import RollOut
+from adam.commands.cassandra.watch import Watch
+from adam.commands.cli.clipboard_copy import ClipboardCopy, CopyCommandHelper
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterCommandHelper, ClusterOrPodCommandHelper, PodCommandHelper
 from adam.commands.cql.cqlsh import CqlCommandHelper, Cqlsh
 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.app.login import Login
+from adam.commands.cassandra.download_cassandra_log import DownloadCassandraLog
+from adam.commands.diag.check import Check, CheckCommandHelper
+from adam.commands.diag.generate_report import GenerateReport
+from adam.commands.diag.issues import Issues
+from adam.commands.fs.ls import Ls
 from adam.commands.medusa.medusa import Medusa
-from adam.commands.nodetool import NodeTool, NodeToolCommandHelper
+from adam.commands.nodetool.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.rollout import RollOut
-from adam.commands.show.show import Show, ShowCommandHelper
-from adam.commands.watch import Watch
+from adam.commands.show import Show, ShowCommandHelper
 from adam.utils_k8s.kube_context import KubeContext
 from adam.repl import enter_repl
 from adam.repl_state import ReplState
@@ -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.')

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"

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

adam/commands/{show → app}/show_login.py

@@ -5,7 +5,7 @@ from adam.sso.idp import Idp
 from adam.sso.idp_login import IdpLogin
 from adam.commands.command import Command
 from adam.repl_state import ReplState
-from adam.utils import duration, tabulize, log, log2, log_exc
+from adam.utils import duration, tabulize, log2, log_exc
 
 class ShowLogin(Command):
     COMMAND = 'show login'

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

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()]

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 {}
 

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"

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()

adam/commands/audit/show_last10.py

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

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'

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)

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/cassandra/restart_cluster.py

@@ -0,0 +1,47 @@
+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 RestartCluster(Command):
+    COMMAND = 'restart cluster'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RestartCluster, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RestartCluster.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) 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)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'--force': None})
+
+    def help(self, _: ReplState):
+        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}

@@ -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

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'

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'

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/{show → cassandra}/show_storage.py

@@ -1,8 +1,9 @@
-from adam.commands import extract_options
+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'
@@ -27,16 +28,17 @@ class ShowStorage(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            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)
+            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
+                    return state
 
     def completion(self, state: ReplState):
-        return super().completion(state, {'-s': None})
+        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'