kaqing 2.0.29__tar.gz → 2.0.31__tar.gz

{kaqing-2.0.29 → kaqing-2.0.31}/PKG-INFO

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

{kaqing-2.0.29 → kaqing-2.0.31}/adam/commands/alter_tables.py

@@ -1,12 +1,9 @@
-import click
-
 from adam.commands.command import Command
-from adam.commands.command_helpers import ClusterOrPodCommandHelper
-from adam.commands.cql_utils import parse_cql_desc_tables, run_cql
+from adam.commands.cql_utils import tables as get_tables, run_cql
 from adam.config import Config
 from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import log, log2
+from adam.utils import log2
 
 class AlterTables(Command):
     COMMAND = 'alter tables with'
@@ -47,16 +44,16 @@ class AlterTables(Command):
         args, include_reaper = Command.extract_options(args, '--include-reaper')
         arg_str = ' '.join(args)
 
-        r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=True)
-        if not r:
-            log2('No pod is available')
-            return 'no-pod'
+        # r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=True)
+        # if not r:
+        #     log2('No pod is available')
+        #     return 'no-pod'
 
         excludes = [e.strip(' \r\n') for e in Config().get(
             'cql.alter-tables.excludes',
             'system_auth,system_traces,reaper_db,system_distributed,system_views,system,system_schema,system_virtual_schema').split(',')]
         batching = Config().get('cql.alter-tables.batching', True)
-        tables = parse_cql_desc_tables(r[0].stdout)
+        tables = get_tables(state, on_any=True)
         for k, v in tables.items():
             if k not in excludes or k == 'reaper_db' and include_reaper:
                 if batching:
@@ -92,20 +89,4 @@ class AlterTables(Command):
         return {}
 
     def help(self, _: ReplState) -> str:
-        return f'[{AlterTables.COMMAND}] <param = value> [--include-reaper] \t alter on all tables'
-
-class CqlCommandHelper(click.Command):
-    def get_help(self, ctx: click.Context):
-        log(super().get_help(ctx))
-        log()
-        log('  e.g. qing cql <cluster or pod> select host_id from system.local')
-        log()
-        log('Advanced Usages:')
-        log('  1. Use -- to specify what arguments are passed to the cqlsh.')
-        log('  2. Use "" to avoid expansion on shell variables.')
-        log('  3. Use ; to use multiple CQL statements')
-        log()
-        log('  e.g. qing cql <cluster or pod> -- "consistency quorum; select * from system.local" --request-timeout=3600')
-        log()
-
-        ClusterOrPodCommandHelper.cluter_or_pod_help()
+        return f'{AlterTables.COMMAND} <param = value> [--include-reaper] \t alter on all tables'

kaqing-2.0.31/adam/commands/cql_utils.py

@@ -0,0 +1,112 @@
+import functools
+import re
+
+from adam.config import Config
+from adam.k8s_utils.cassandra_clusters import CassandraClusters
+from adam.k8s_utils.cassandra_nodes import CassandraNodes
+from adam.k8s_utils.secrets import Secrets
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState
+from adam.utils import log2
+
+@functools.lru_cache()
+def keyspaces(sts: str, namespace: str):
+    Config().wait_log("Inspecting Cassandra Keyspaces...")
+
+    user, pw = Secrets.get_user_pass(sts, namespace, secret_path='cql.secret')
+    command = f'cqlsh -u {user} -p {pw} -e "describe keyspaces"'
+
+    r: list[PodExecResult] = CassandraClusters.exec(sts, namespace, command, show_out=False, action='cql', on_any=True)
+    if not r:
+        log2('No pod is available')
+        return []
+
+    return parse_cql_desc_keyspaces(r[0].stdout)
+
+def table_names(state: ReplState):
+    return [f'{k}.{t}' for k, ts in tables(state, on_any=True).items() for t in ts]
+
+@functools.lru_cache()
+def tables(state: ReplState, on_any=False):
+    r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=on_any)
+    if not r:
+        log2('No pod is available')
+        return []
+
+    return parse_cql_desc_tables(r[0].stdout)
+
+def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_single_quotes = False, on_any = False):
+    user, pw = Secrets.get_user_pass(state.sts if state.sts else state.pod, state.namespace, secret_path='cql.secret')
+    if use_single_quotes:
+        command = f"cqlsh -u {user} -p {pw} {' '.join(opts)} -e '{cql}'"
+    else:
+        command = f'cqlsh -u {user} -p {pw} {" ".join(opts)} -e "{cql}"'
+
+    if state.pod:
+        return CassandraNodes.exec(state.pod, state.namespace, command, show_out=show_out)
+    else:
+        return CassandraClusters.exec(state.sts, state.namespace, command, show_out=show_out, action='cql', on_any=on_any)
+
+def parse_cql_desc_tables(out: str):
+    # Keyspace data_endpoint_auth
+    # ---------------------------
+    # "token"
+
+    # Keyspace reaper_db
+    # ------------------
+    # repair_run                     schema_migration
+    # repair_run_by_cluster          schema_migration_leader
+
+    # Keyspace system
+    tables_by_keyspace: dict[str, list[str]] = {}
+    keyspace = None
+    state = 's0'
+    for line in out.split('\n'):
+        if state == 's0':
+            groups = re.match(r'^Keyspace (.*)$', line)
+            if groups:
+                keyspace = groups[1].strip(' \r')
+                state = 's1'
+        elif state == 's1':
+            if line.startswith('---'):
+                state = 's2'
+        elif state == 's2':
+            if not line.strip(' \r'):
+                state = 's0'
+            else:
+                for table in line.split(' '):
+                    if t := table.strip(' \r'):
+                        if not keyspace in tables_by_keyspace:
+                            tables_by_keyspace[keyspace] = []
+                        tables_by_keyspace[keyspace].append(t)
+
+    return tables_by_keyspace
+
+def parse_cql_desc_keyspaces(out: str) -> list[str]:
+    #
+    # Warning: Cannot create directory at `/home/cassandra/.cassandra`. Command history will not be saved. Please check what was the environment property CQL_HISTORY set to.
+    #
+    #
+    # Warning: Using a password on the command line interface can be insecure.
+    # Recommendation: use the credentials file to securely provide the password.
+    #
+    #
+    # azops88_db  system_auth         system_traces
+    # reaper_db   system_distributed  system_views
+    # system      system_schema       system_virtual_schema
+    #
+    kses = []
+    for line in out.split('\n'):
+        line = line.strip(' \r')
+        if not line:
+            continue
+        if line.startswith('Warning:'):
+            continue
+        if line.startswith('Recommendation:'):
+            continue
+
+        for ks in line.split(' '):
+            if s := ks.strip(' \r\t'):
+                kses.append(s)
+
+    return kses

{kaqing-2.0.29 → kaqing-2.0.31}/adam/commands/cqlsh.py

@@ -2,7 +2,7 @@ import click
 
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
-from adam.commands.cql_utils import run_cql
+from adam.commands.cql_utils import run_cql, table_names, tables
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log, log2
 
@@ -54,11 +54,13 @@ class Cqlsh(Command):
 
     def completion(self, state: ReplState) -> dict[str, any]:
         if state.sts or state.pod:
+            ts = table_names(state)
             return {Cqlsh.COMMAND: None} | {
-                'delete': {'from': None},
-                'insert': {'into': None},
-                'select': None,
-                'update': None,
+                'delete': {'from': {t: {'where': None} for t in ts}},
+                'insert': {'into': {t: {'values': None} for t in ts}},
+                'select': {'*': {'from': {t: {'limit': {'1': None}, 'where': None} for t in ts}}},
+                'update': {t: {'set': None} for t in ts},
+                'describe': {'keyspaces': None, 'table': {t: None for t in ts}, 'tables': None},
             }
 
         return {}

{kaqing-2.0.29 → kaqing-2.0.31}/adam/commands/deploy/deploy_pod.py

@@ -3,6 +3,7 @@ import yaml
 
 from adam.commands.command import Command
 from adam.commands.deploy.deploy_utils import creating, deploy_frontend, gen_labels
+from adam.commands.deploy.undeploy_pod import UndeployPod
 from adam.config import Config
 from adam.k8s_utils.config_maps import ConfigMaps
 from adam.k8s_utils.deployment import Deployments
@@ -39,6 +40,10 @@ class DeployPod(Command):
         if not self.validate_state(state):
             return state
 
+        args, forced = Command.extract_options(args, '--force')
+        if forced:
+            UndeployPod().run(UndeployPod.COMMAND, state)
+
         if KubeContext.in_cluster():
             log2('This is doable only from outside of the Kubernetes cluster.')
             return state
@@ -103,7 +108,7 @@ class DeployPod(Command):
         return state
 
     def completion(self, state: ReplState):
-        return super().completion(state)
+        return super().completion(state, {'--force': None})
 
     def help(self, _: ReplState):
-        return f'{DeployPod.COMMAND}\t deploy Ops pod'
+        return f'{DeployPod.COMMAND} [--force]\t deploy Ops pod, --force to undeploy first'

kaqing-2.0.31/adam/commands/describe/describe_keyspace.py

@@ -0,0 +1,60 @@
+from adam.commands.command import Command
+from adam.commands.cql_utils import keyspaces, run_cql
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class DescribeKeyspace(Command):
+    COMMAND = 'describe keyspace'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DescribeKeyspace, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def required(self):
+        return RequiredState.CLUSTER
+
+    def command(self):
+        return DescribeKeyspace.COMMAND
+
+    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, all_nodes = Command.extract_options(args, '--all-nodes')
+
+        if not args:
+            if state.in_repl:
+                log2('Please enter keyspace name')
+            else:
+                log2('* keyspace name is missing.')
+                log2()
+                Command.display_help()
+
+            return 'missing-keyspace'
+
+        r: list[PodExecResult] = run_cql(state, f'describe keyspace {args[0]}', show_out=True, on_any=not all_nodes)
+        if not r:
+            log2('No pod is available')
+            return 'no-pod'
+
+        # do not continue to cql route
+        return state
+
+    def completion(self, state: ReplState) -> dict[str, any]:
+        if state.sts:
+            return super().completion(state, {ks: {'--all-nodes': None} for ks in keyspaces(state.sts, state.namespace)})
+
+        return {}
+
+    def help(self, _: ReplState) -> str:
+        return f'{DescribeKeyspace.COMMAND} <keyspace-name> [--all-nodes]\t describe Cassandra keyspace'

kaqing-2.0.31/adam/commands/describe/describe_keyspaces.py

@@ -0,0 +1,50 @@
+from adam.commands.command import Command
+from adam.commands.cql_utils import keyspaces, run_cql
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class DescribeKeyspaces(Command):
+    COMMAND = 'describe keyspaces'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DescribeKeyspaces, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def required(self):
+        return RequiredState.CLUSTER
+
+    def command(self):
+        return DescribeKeyspaces.COMMAND
+
+    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
+
+        _, all_nodes = Command.extract_options(args, '--all-nodes')
+
+        r: list[PodExecResult] = run_cql(state, f'describe keyspaces', show_out=True, on_any=not all_nodes)
+        if not r:
+            log2('No pod is available')
+            return 'no-pod'
+
+        # do not continue to cql route
+        return state
+
+    def completion(self, state: ReplState) -> dict[str, any]:
+        if state.sts:
+            return super().completion(state, {'--all-nodes': None})
+
+        return {}
+
+    def help(self, _: ReplState) -> str:
+        return f'{DescribeKeyspaces.COMMAND} [--all-nodes]\t describe Cassandra keyspaces'

kaqing-2.0.31/adam/commands/describe/describe_table.py

@@ -0,0 +1,60 @@
+from adam.commands.command import Command
+from adam.commands.cql_utils import keyspaces, run_cql, table_names, tables
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class DescribeTable(Command):
+    COMMAND = 'describe table'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DescribeTable, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def required(self):
+        return RequiredState.CLUSTER
+
+    def command(self):
+        return DescribeTable.COMMAND
+
+    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, all_nodes = Command.extract_options(args, '--all-nodes')
+
+        if not args:
+            if state.in_repl:
+                log2('Please enter table name')
+            else:
+                log2('* table name is missing.')
+                log2()
+                Command.display_help()
+
+            return 'missing-table'
+
+        r: list[PodExecResult] = run_cql(state, f'describe table {args[0]}', show_out=True, on_any=not all_nodes)
+        if not r:
+            log2('No pod is available')
+            return 'no-pod'
+
+        # do not continue to cql route
+        return state
+
+    def completion(self, state: ReplState) -> dict[str, any]:
+        if state.sts:
+            return super().completion(state, {t: {'--all-nodes': None} for t in table_names(state)})
+
+        return {}
+
+    def help(self, _: ReplState) -> str:
+        return f'{DescribeTable.COMMAND} <table-name> [--all-nodes]\t describe Cassandra table'

kaqing-2.0.31/adam/commands/describe/describe_tables.py

@@ -0,0 +1,50 @@
+from adam.commands.command import Command
+from adam.commands.cql_utils import keyspaces, run_cql, table_names, tables
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class DescribeTables(Command):
+    COMMAND = 'describe tables'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DescribeTables, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def required(self):
+        return RequiredState.CLUSTER
+
+    def command(self):
+        return DescribeTables.COMMAND
+
+    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
+
+        _, all_nodes = Command.extract_options(args, '--all-nodes')
+
+        r: list[PodExecResult] = run_cql(state, f'describe tables', show_out=True, on_any=not all_nodes)
+        if not r:
+            log2('No pod is available')
+            return 'no-pod'
+
+        # do not continue to cql route
+        return state
+
+    def completion(self, state: ReplState) -> dict[str, any]:
+        if state.sts:
+            return super().completion(state, {'--all-nodes': None})
+
+        return {}
+
+    def help(self, _: ReplState) -> str:
+        return f'{DescribeTables.COMMAND} [--all-nodes]\t describe Cassandra tables'

{kaqing-2.0.29 → kaqing-2.0.31}/adam/commands/param_set.py

@@ -38,7 +38,7 @@ class SetParam(Command):
         return value
 
     def completion(self, _: ReplState):
-        return {SetParam.COMMAND: {key: ({'true': None, 'false': None} if key.startswith('debug') else None) for key in Config().keys()}}
+        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"

{kaqing-2.0.29 → kaqing-2.0.31}/adam/commands/preview_table.py

@@ -1,7 +1,7 @@
 import functools
 
 from adam.commands.command import Command
-from adam.commands.cql_utils import parse_cql_desc_tables, run_cql
+from adam.commands.cql_utils import run_cql, tables
 from adam.commands.postgres.postgres_session import PostgresSession
 from adam.config import Config
 from adam.pod_exec_result import PodExecResult
@@ -74,10 +74,9 @@ class PreviewTable(Command):
         if state.device == ReplState.P:
             if tables := PreviewTable.pg_tables(state.namespace, state.pg_path):
                 return {PreviewTable.COMMAND: {db["name"]: None for db in tables if db["schema"] == PostgresSession.default_schema()}}
-        else:
-            if state.pod:
-                tables = PreviewTable.cql_tables(state)
-                return {PreviewTable.COMMAND: {f'{k}.{t}': None for k, ts in tables.items() for t in ts}}
+        elif state.sts:
+            tables = PreviewTable.cql_tables(state)
+            return {PreviewTable.COMMAND: {f'{k}.{t}': None for k, ts in tables.items() for t in ts}}
 
         return {}
 
@@ -86,8 +85,16 @@ class PreviewTable(Command):
 
     @functools.lru_cache()
     def cql_tables(state: ReplState):
-        r: PodExecResult =  run_cql(state, 'describe tables', show_out=False)
-        return parse_cql_desc_tables(r.stdout)
+        if state.pod:
+            return tables(state)
+
+        return tables(state, on_any=True)
+
+        # r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=True)
+        # if not r:
+        #     return []
+
+        # return parse_cql_desc_tables(r[0].stdout)
 
     @functools.lru_cache()
     def pg_tables(ns: str, pg_path: str):

{kaqing-2.0.29 → kaqing-2.0.31}/adam/commands/reaper/reaper_session.py

@@ -149,7 +149,7 @@ class ReaperSession:
             return ReaperSession.schedules_ids_by_cluster[state.sts]
 
         if reaper := ReaperSession.create(state):
-            state.wait_log("Inspecting Cassandra Reaper...")
+            Config().wait_log("Inspecting Cassandra Reaper...")
 
             schedules = reaper.schedule_ids(state, show_output = False)
             ReaperSession.schedules_ids_by_cluster[state.sts] = schedules

{kaqing-2.0.29 → kaqing-2.0.31}/adam/config.py

@@ -17,6 +17,7 @@ class Config:
 
     def __init__(self, path: str = None, is_user_entry = False):
         if path:
+            self.wait_log_flag = False
             try:
                 with open(path) as f:
                     self.params = cast(dict[str, any], yaml.safe_load(f))
@@ -83,4 +84,12 @@ class Config:
             log2(f'incorrect path: {key}')
             return None
 
-        return v if v else 'false'
+        return v if v else 'false'
+
+    def wait_log(self, msg: str):
+        if not self.wait_log_flag:
+            log2(msg)
+            self.wait_log_flag = True
+
+    def clear_wait_log_flag(self):
+        self.wait_log_flag = False

{kaqing-2.0.29 → kaqing-2.0.31}/adam/k8s_utils/cassandra_clusters.py

@@ -3,6 +3,7 @@ from concurrent.futures import ThreadPoolExecutor
 import sys
 from typing import TypeVar
 
+from adam.config import Config
 from adam.k8s_utils.cassandra_nodes import CassandraNodes
 from adam.pod_exec_result import PodExecResult
 from adam.utils import log2

{kaqing-2.0.29 → kaqing-2.0.31}/adam/k8s_utils/pods.py

@@ -47,7 +47,7 @@ class Pods:
 
         if not max_workers:
             max_workers = Config().action_workers(action, 0)
-        if not on_any and  max_workers > 0:
+        if not on_any and max_workers > 0:
             # if parallel, node sampling is suppressed
             if KubeContext.show_parallelism():
                 log2(f'Executing on all nodes from statefulset in parallel...')
@@ -79,7 +79,8 @@ class Pods:
                 log2(f'Executing on {adj} nodes from statefulset...')
             for pod_name in pods:
                 try:
-                    result = body(None, pod_name, namespace, show_out)
+                    # disable stdout from the pod_exec, then show the output in a for loop
+                    result = body(None, pod_name, namespace, False)
                     if post:
                         result = post(result, show_out=show_out)
                     results.append(result)

{kaqing-2.0.29 → kaqing-2.0.31}/adam/repl.py

@@ -18,7 +18,7 @@ from adam.log import Log
 from adam.repl_commands import ReplCommands
 from adam.repl_session import ReplSession
 from adam.repl_state import ReplState
-from adam.utils import deep_merge_dicts, lines_to_tabular, log2
+from adam.utils import deep_merge_dicts, deep_sort_dict, lines_to_tabular, log2
 from adam.apps import Apps
 from . import __version__
 
@@ -70,7 +70,7 @@ def enter_repl(state: ReplState):
             cluster = ss[0]
             state.sts = cluster[0]
             state.namespace = cluster[1]
-            state.wait_log(f'Moving to the only Cassandra cluster: {state.sts}@{state.namespace}...')
+            Config().wait_log(f'Moving to the only Cassandra cluster: {state.sts}@{state.namespace}...')
     elif state.device == ReplState.A:
         if app := Config().get('repl.auto-enter-app', 'c3/c3'):
             if app != 'no':
@@ -78,9 +78,9 @@ def enter_repl(state: ReplState):
                 state.app_env = ea[0]
                 if len(ea) > 1:
                     state.app_app = ea[1]
-                    state.wait_log(f'Moving to {state.app_env}/{state.app_app}...')
+                    Config().wait_log(f'Moving to {state.app_env}/{state.app_app}...')
                 else:
-                    state.wait_log(f'Moving to {state.app_env}...')
+                    Config().wait_log(f'Moving to {state.app_env}...')
 
     kb = KeyBindings()
 
@@ -102,7 +102,7 @@ def enter_repl(state: ReplState):
                 for cmd in sorted_cmds:
                     s1 = time.time()
                     try:
-                        completions = deep_merge_dicts(completions, cmd.completion(state))
+                        completions = deep_sort_dict(deep_merge_dicts(completions, cmd.completion(state)))
                     finally:
                         if Config().get('debugs.timings', False):
                             Config().debug('Timing completion calc', cmd.command(), f'{time.time() - s1:.2f}')
@@ -151,7 +151,7 @@ def enter_repl(state: ReplState):
                 log2(e)
                 Config().debug(traceback.format_exc())
         finally:
-            state.clear_wait_log_flag()
+            Config().clear_wait_log_flag()
             if Config().get('debugs.timings', False) and 'cmd' in locals() and 's0' in locals():
                 print('Timing command', cmd, f'{time.time() - s0:.2f}')
 
@@ -168,5 +168,5 @@ def repl(kubeconfig: str, config: str, param: list[str], cluster:str, namespace:
         return
 
     state = ReplState(device=Config().get('repl.start-drive', 'a'), ns_sts=cluster, namespace=namespace, in_repl=True)
-    state, _ = state.apply_args(extra_args)
+    state, _ = state.apply_device_arg(extra_args)
     enter_repl(state)

{kaqing-2.0.29 → kaqing-2.0.31}/adam/repl_commands.py

@@ -11,6 +11,10 @@ from adam.commands.deploy.undeploy import Undeploy
 from adam.commands.deploy.undeploy_frontend import UndeployFrontend
 from adam.commands.deploy.undeploy_pg_agent import UndeployPgAgent
 from adam.commands.deploy.undeploy_pod import UndeployPod
+from adam.commands.describe.describe_keyspace import DescribeKeyspace
+from adam.commands.describe.describe_keyspaces import DescribeKeyspaces
+from adam.commands.describe.describe_table import DescribeTable
+from adam.commands.describe.describe_tables import DescribeTables
 from adam.commands.shell import Shell
 from adam.commands.show.show_app_queues import ShowAppQueues
 from adam.commands.cp import ClipboardCopy
@@ -75,14 +79,15 @@ class ReplCommands:
                 GetParam(), SetParam(), ShowParams(), ShowKubectlCommands(), ShowLogin(), ShowAdam()]
 
     def cassandra_check() -> list[Command]:
-        return [ShowCassandraStatus(), ShowCassandraVersion(), ShowRepairs(), ShowStorage(), ShowProcesses(), Check(), Issues(), NodeTool(), Report()]
+        return [DescribeKeyspace(), DescribeKeyspaces(), DescribeTable(), DescribeTables(), ShowCassandraStatus(),
+                ShowCassandraVersion(), ShowRepairs(), ShowStorage(), ShowProcesses(), Check(), Issues(), NodeTool(), Report()]
 
     def cassandra_ops() -> list[Command]:
-        # return Medusa.cmd_list() + [Restart(), RollOut(), Watch()] + Reaper.cmd_list() + Repair.cmd_list()
         return [AlterTables()] + Medusa.cmd_list() + [Restart(), RollOut(), Watch()] + Reaper.cmd_list() + Repair.cmd_list()
 
     def tools() -> list[Command]:
-        return [Cqlsh(), Postgres(), Bash(), Shell(), CodeStart(), CodeStop(), DeployFrontend(), UndeployFrontend(), DeployPod(), UndeployPod(), DeployPgAgent(), UndeployPgAgent()]
+        return [Cqlsh(), Postgres(), Bash(), Shell(), CodeStart(), CodeStop(), DeployFrontend(), UndeployFrontend(),
+                DeployPod(), UndeployPod(), DeployPgAgent(), UndeployPgAgent()]
 
     def app() -> list[Command]:
         return [ShowAppActions(), ShowAppId(), ShowAppQueues(), AppPing(), App()]