kaqing 1.77.0__py3-none-any.whl → 2.0.171__py3-none-any.whl

{walker → adam}/checks/disk.py

@@ -1,12 +1,12 @@
 import re
 from pathlib import Path
 
-from walker.checks.check import Check
-from walker.checks.check_context import CheckContext
-from walker.checks.check_result import CheckResult
-from walker.checks.issue import Issue
-from walker.config import Config
-from walker.k8s_utils.cassandra_nodes import CassandraNodes
+from adam.checks.check import Check
+from adam.checks.check_context import CheckContext
+from adam.checks.check_result import CheckResult
+from adam.checks.issue import Issue
+from adam.config import Config
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
 
 class Disk(Check):
     def name(self):

{walker → adam}/checks/gossip.py

@@ -1,10 +1,10 @@
 import re
 
-from walker.checks.check import Check
-from walker.checks.check_context import CheckContext
-from walker.checks.check_result import CheckResult
-from walker.checks.issue import Issue
-from walker.k8s_utils.cassandra_nodes import CassandraNodes
+from adam.checks.check import Check
+from adam.checks.check_context import CheckContext
+from adam.checks.check_result import CheckResult
+from adam.checks.issue import Issue
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
 
 class Gossip(Check):
     def name(self):

{walker → adam}/checks/memory.py

@@ -1,10 +1,10 @@
-from walker.checks.check import Check
-from walker.checks.check_context import CheckContext
-from walker.checks.check_result import CheckResult
-from walker.checks.issue import Issue
-from walker.k8s_utils.cassandra_nodes import CassandraNodes
-from walker.k8s_utils.custom_resources import CustomResources
-from walker.k8s_utils.pods import Pods
+from adam.checks.check import Check
+from adam.checks.check_context import CheckContext
+from adam.checks.check_result import CheckResult
+from adam.checks.issue import Issue
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.custom_resources import CustomResources
+from adam.utils_k8s.pods import Pods
 
 class Memory(Check):
     def name(self):

{walker → adam}/checks/status.py

@@ -1,10 +1,10 @@
 import re
 
-from walker.checks.check import Check
-from walker.checks.check_context import CheckContext
-from walker.checks.check_result import CheckResult
-from walker.checks.issue import Issue
-from walker.k8s_utils.cassandra_nodes import CassandraNodes
+from adam.checks.check import Check
+from adam.checks.check_context import CheckContext
+from adam.checks.check_result import CheckResult
+from adam.checks.issue import Issue
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
 
 class Status(Check):
     def name(self):

{walker → adam}/cli.py

@@ -4,9 +4,9 @@ import click
 import click_completion
 click_completion.init()
 
-from walker import batch
-from walker.cli_group import cli
-from walker.utils import display_help
+from adam import batch
+from adam.cli_group import cli
+from adam.utils import display_help
 from . import __version__, repl
 
 @cli.command()

{walker → adam}/columns/column.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 
-from walker.checks.check_result import CheckResult
+from adam.checks.check_result import CheckResult
 
 class Column:
     @abstractmethod

adam/columns/columns.py

@@ -0,0 +1,45 @@
+from adam.columns.column import Column
+from adam.columns.compactions import Compactions
+from adam.columns.cpu import Cpu
+from adam.columns.cpu_metrics import CpuMetrics
+from adam.columns.dir_data import DataDir
+from adam.columns.dir_snapshots import SnapshotsDir
+from adam.columns.gossip import Gossip
+from adam.columns.host_id import HostId
+from adam.columns.memory import Memory
+from adam.columns.node_address import NodeAddress
+from adam.columns.node_load import NodeLoad
+from adam.columns.node_owns import NodeOwns
+from adam.columns.node_status import NodeStatus
+from adam.columns.node_tokens import NodeTokens
+from adam.columns.pod_name import PodName
+from adam.columns.volume_cassandra import CassandraVolume
+from adam.columns.volume_root import RootVolume
+
+def collect_checks(columns: list[Column]):
+    checks = sum([c.checks() for c in columns], [])
+    return {cc.name(): cc for cc in checks}.values()
+
+class Columns:
+    COLUMNS_BY_NAME = None
+
+    def all_columns():
+        return [Compactions(), Cpu(), CpuMetrics(), DataDir(), SnapshotsDir(), Gossip(), HostId(), Memory(),
+                NodeAddress(), NodeLoad(), NodeOwns(), NodeStatus(),NodeTokens(), PodName(), CassandraVolume(), RootVolume()]
+
+    def columns_by_name():
+        return {c.name(): c.__class__ for c in Columns.all_columns()}
+
+    def create_columns(columns: str):
+        if not Columns.COLUMNS_BY_NAME:
+            Columns.COLUMNS_BY_NAME = Columns.columns_by_name()
+
+        cols = []
+        for name in columns.split(','):
+            name = name.strip(' ')
+            if not name in Columns.COLUMNS_BY_NAME:
+                return None
+
+            cols.append(Columns.COLUMNS_BY_NAME[name]())
+
+        return cols

{walker → adam}/columns/compactions.py

@@ -1,8 +1,8 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.compactionstats import CompactionStats
-from walker.columns.column import Column
-from walker.columns.host_id import HostId
-from walker.columns.node_utils import merge_compactions
+from adam.checks.check_result import CheckResult
+from adam.checks.compactionstats import CompactionStats
+from adam.columns.column import Column
+from adam.columns.host_id import HostId
+from adam.columns.node_utils import merge_compactions
 
 class Compactions(Column):
     def name(self):

{walker → adam}/columns/cpu.py

@@ -1,6 +1,8 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.cpu import Cpu as CpuCheck
-from walker.columns.column import Column
+from kubernetes.utils.quantity import parse_quantity
+
+from adam.checks.check_result import CheckResult
+from adam.checks.cpu import Cpu as CpuCheck
+from adam.columns.column import Column
 
 class Cpu(Column):
     def name(self):
@@ -14,4 +16,4 @@ class Cpu(Column):
         cpu = r.details[CpuCheck().name()]
         busy = 100.0 - float(cpu['idle'])
 
-        return f'{round(busy)}%'
+        return f'{round(busy)}%/{parse_quantity(cpu["limit"]) * 100}%'

adam/columns/cpu_metrics.py

@@ -0,0 +1,22 @@
+from kubernetes.utils.quantity import parse_quantity
+
+from adam.checks.check_result import CheckResult
+from adam.checks.cpu_metrics import CpuMetrics as CpuCheck
+from adam.columns.column import Column
+
+class CpuMetrics(Column):
+    def name(self):
+        return 'cpu-metrics'
+
+    def checks(self):
+        return [CpuCheck()]
+
+    def pod_value(self, check_results: list[CheckResult], pod_name: str):
+        r = self.result_by_pod(check_results, pod_name)
+        cpu = r.details[CpuCheck().name()]
+
+        cpu_decimal = parse_quantity(cpu['cpu'])
+        cpu_limit = parse_quantity(cpu['limit'])
+        business = cpu_decimal * 100 / cpu_limit
+
+        return f"{business:.2f}%({cpu_decimal}/{cpu_limit})"

{walker → adam}/columns/dir_data.py

@@ -1,6 +1,6 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.disk import Disk
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.checks.disk import Disk
+from adam.columns.column import Column
 
 class DataDir(Column):
     def name(self):

{walker → adam}/columns/dir_snapshots.py

@@ -1,6 +1,6 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.disk import Disk
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.checks.disk import Disk
+from adam.columns.column import Column
 
 class SnapshotsDir(Column):
     def name(self):

{walker → adam}/columns/gossip.py

@@ -1,8 +1,8 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.status import Status
-from walker.columns.column import Column
-from walker.columns.host_id import HostId
-from walker.columns.node_utils import merge_gossip
+from adam.checks.check_result import CheckResult
+from adam.checks.status import Status
+from adam.columns.column import Column
+from adam.columns.host_id import HostId
+from adam.columns.node_utils import merge_gossip
 
 class Gossip(Column):
     def name(self):

{walker → adam}/columns/host_id.py

@@ -1,6 +1,6 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.status import Status
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.checks.status import Status
+from adam.columns.column import Column
 
 class HostId(Column):
     def name(self):

{walker → adam}/columns/memory.py

@@ -1,8 +1,8 @@
 from kubernetes.utils import parse_quantity
 
-from walker.checks.check_result import CheckResult
-from walker.checks.memory import Memory as MemoryCheck
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.checks.memory import Memory as MemoryCheck
+from adam.columns.column import Column
 
 class Memory(Column):
     def name(self):

{walker → adam}/columns/node_address.py

@@ -1,6 +1,6 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.status import Status
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.checks.status import Status
+from adam.columns.column import Column
 
 class NodeAddress(Column):
     def name(self):

{walker → adam}/columns/node_load.py

@@ -1,6 +1,6 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.status import Status
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.checks.status import Status
+from adam.columns.column import Column
 
 class NodeLoad(Column):
     def name(self):

{walker → adam}/columns/node_owns.py

@@ -1,6 +1,6 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.status import Status
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.checks.status import Status
+from adam.columns.column import Column
 
 class NodeOwns(Column):
     def name(self):

{walker → adam}/columns/node_status.py

@@ -1,6 +1,6 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.status import Status
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.checks.status import Status
+from adam.columns.column import Column
 
 class NodeStatus(Column):
     def name(self):

{walker → adam}/columns/node_tokens.py

@@ -1,6 +1,6 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.status import Status
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.checks.status import Status
+from adam.columns.column import Column
 
 class NodeTokens(Column):
     def name(self):

{walker → adam}/columns/node_utils.py

@@ -1,5 +1,5 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.compactionstats import CompactionStats
+from adam.checks.check_result import CheckResult
+from adam.checks.compactionstats import CompactionStats
 
 def merge_gossip(check_results: list[CheckResult]):
     hosts_with_gossip_issue = set()

{walker → adam}/columns/pod_name.py

@@ -1,5 +1,5 @@
-from walker.checks.check_result import CheckResult
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.columns.column import Column
 
 class PodName(Column):
     def name(self):

{walker → adam}/columns/volume_cassandra.py

@@ -1,7 +1,7 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.disk import Disk
-from walker.columns.column import Column
-from walker.config import Config
+from adam.checks.check_result import CheckResult
+from adam.checks.disk import Disk
+from adam.columns.column import Column
+from adam.config import Config
 
 class CassandraVolume(Column):
     def name(self):

{walker → adam}/columns/volume_root.py

@@ -1,6 +1,6 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.disk import Disk
-from walker.columns.column import Column
+from adam.checks.check_result import CheckResult
+from adam.checks.disk import Disk
+from adam.columns.column import Column
 
 class RootVolume(Column):
     def name(self):

adam/commands/__init__.py

@@ -0,0 +1,15 @@
+from adam.commands.command import ExtractAllOptionsHandler, ExtractOptionsHandler, ExtractTrailingOptionsHandler
+from adam.repl_state import ReplState
+from adam.utils_app import AppHandler
+
+def app(state: ReplState) -> AppHandler:
+    return AppHandler(state)
+
+def extract_options(args: list[str], options = None):
+    return ExtractOptionsHandler(args, options = options)
+
+def extract_trailing_options(args: list[str], trailing = None):
+    return ExtractTrailingOptionsHandler(args, trailing = trailing)
+
+def extract_all_options(args: list[str], trailing = None, options = None):
+    return ExtractAllOptionsHandler(args, trailing = trailing, options = options)

adam/commands/alter_tables.py

@@ -0,0 +1,81 @@
+from adam.commands import extract_options
+from adam.commands.command import Command
+from adam.commands.cql.utils_cql import cassandra, cassandra_tables as get_tables
+from adam.config import Config
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class AlterTables(Command):
+    COMMAND = 'alter tables with'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(AlterTables, 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 AlterTables.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 extract_options(args, '--include-reaper') as (args, include_reaper):
+                if not args:
+                    if state.in_repl:
+                        log2('Please enter gc grace in seconds. e.g. alter gc-grace-seconds 3600')
+                    else:
+                        log2('* gc grace second is missing.')
+                        log2()
+                        Command.display_help()
+
+                    return 'missing-arg'
+
+                arg_str = ' '.join(args)
+
+                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 = 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:
+                            # alter table <table_name> with GC_GRACE_SECONDS = <timeout>;
+                            cql = ';\n'.join([f'alter table {k}.{t} with {arg_str}' for t in v])
+                            try:
+                                with cassandra(state) as pods:
+                                    pods.cql(cql, show_out=Config().is_debug(), show_query=not Config().is_debug(), on_any=True)
+                            except Exception as e:
+                                log2(e)
+                                continue
+                        else:
+                            for t in v:
+                                try:
+                                    # alter table <table_name> with GC_GRACE_SECONDS = <timeout>;
+                                    cql = f'alter table {k}.{t} with {arg_str}'
+                                    with cassandra(state) as pods:
+                                        pods.cql(show_out=Config().is_debug(), show_query=not Config().is_debug(), on_any=True)
+                                except Exception as e:
+                                    log2(e)
+                                    continue
+
+                        log2(f'{len(v)} tables altered in {k}.')
+
+                # do not continue to cql route
+                return state
+
+    def completion(self, _: ReplState) -> dict[str, any]:
+        # auto completion is taken care of by sql completer
+        return {}
+
+    def help(self, _: ReplState) -> str:
+        return f'{AlterTables.COMMAND} <param = value> [--include-reaper] \t alter schema on all tables'

adam/commands/app_cmd.py

@@ -0,0 +1,38 @@
+from adam.commands import app, extract_options
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+
+class App(Command):
+    COMMAND = 'app'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(App, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return App.COMMAND
+
+    def required(self):
+        return RequiredState.APP_APP
+
+    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):
+                with app(state) as http:
+                    http.post(args, forced=forced)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'--force': None})
+
+    def help(self, _: ReplState):
+        return f"<AppType>.<AppAction> <args> [--force]\t post app action; check with 'show app actions' command"

{walker → adam}/commands/app_ping.py

@@ -1,6 +1,6 @@
-from walker.commands.command import Command
-from walker.repl_state import ReplState, RequiredState
-from walker.app_session import AppSession
+from adam.commands import app, extract_options
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
 
 class AppPing(Command):
     COMMAND = 'app ping'
@@ -18,27 +18,21 @@ class AppPing(Command):
         return AppPing.COMMAND
 
     def required(self):
-        return RequiredState.CLUSTER_OR_POD
+        return RequiredState.APP_APP
 
     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, app_required=RequiredState.APP_APP):
-            return state
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, '--force') as (args, forced):
+                with app(state) as http:
+                    http.post(['Echo.echoStatic'], forced=forced)
 
-        _, forced = Command.extract_options(args, '--force')
-
-        AppSession.run(state.app_env, state.app_app, state.namespace, 'Echo', 'echoStatic', forced= forced)
-
-        return state
+                    return state
 
     def completion(self, state: ReplState):
-        if state.app_app:
-            return super().completion(state, {'--force': None})
-
-        return {}
+        return super().completion(state, {'--force': None})
 
     def help(self, _: ReplState):
         return f"{AppPing.COMMAND} [--force]\t ping app server with Echo.echoStatic()"

adam/commands/audit/audit.py

@@ -0,0 +1,84 @@
+import click
+
+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
+from adam.commands.audit.show_slow10 import ShowSlow10
+from adam.commands.audit.show_top10 import ShowTop10
+from adam.commands.audit.utils_show_top10 import show_top10_completions_for_nesting
+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.utils import log2, wait_log
+from adam.utils_athena import Athena
+
+class Audit(IntermediateCommand):
+    COMMAND = 'audit'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Audit, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+        self.schema_read = False
+
+    def command(self):
+        return Audit.COMMAND
+
+    def required(self):
+        return ReplState.L
+
+    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):
+            r = None
+            if len(args) > 0:
+                r = self.intermediate_run(cmd, state, args, self.cmd_list(), display_help=False)
+
+            if not r or isinstance(r, str) and r == 'command-missing':
+                sql = 'select * from audit order by ts desc limit 10'
+                if args:
+                    sql = ' '.join(args)
+                else:
+                    log2(sql)
+
+                Athena.run_query(sql)
+
+            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 {}
+
+    def cmd_list(self):
+        return [AuditRepairTables(), AuditRun(), ShowLast10(), ShowSlow10(), ShowTop10()]
+
+    def help(self, _: ReplState):
+        return f'[{Audit.COMMAND}] [<sql-statements>]\t run SQL queries on Authena audit database'
+
+class AuditCommandHelper(click.Command):
+    def get_help(self, ctx: click.Context):
+        IntermediateCommand.intermediate_help(super().get_help(ctx), Audit.COMMAND, Audit().cmd_list(), show_cluster_help=False)