kaqing 2.0.188__py3-none-any.whl → 2.0.200__py3-none-any.whl

adam/batch.py

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

adam/commands/bash/bash.py

@@ -30,7 +30,7 @@ class Bash(Command):
                 return exec(args)
 
     def completion(self, state: ReplState):
-        return super().completion(state, {c : {'&': None} for c in ['ls', 'cat', 'head']}, pods=Devices.device(state).pods(state, '-'))
+        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.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, no_history=True)
+
+            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/nodetool.py

@@ -0,0 +1,64 @@
+import click
+
+from adam.commands.command import Command
+from adam.commands.command_helpers import ClusterOrPodCommandHelper
+from adam.commands.cql.utils_cql import cassandra
+from adam.commands.devices.devices import Devices
+from adam.commands.cassandra.nodetool_commands import NODETOOL_COMMANDS
+from adam.config import Config
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log
+
+class NodeTool(Command):
+    COMMAND = 'nodetool'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(NodeTool, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return NodeTool.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 cassandra(state) as pods:
+                pods.nodetool(' '.join(args), status=(args[0] == 'status'))
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {c: {'&': None} for c in NODETOOL_COMMANDS}, pods=Devices.of(state).pods(state, '-'))
+
+    def help(self, _: ReplState):
+        return f'{NodeTool.COMMAND} <sub-command> [&]\t run nodetool with arguments'
+
+class NodeToolCommandHelper(click.Command):
+    def get_help(self, ctx: click.Context):
+        log(super().get_help(ctx))
+        log()
+        log('Sub-Commands:')
+
+        cmds = ''
+        for c in NODETOOL_COMMANDS:
+            if cmds:
+                cmds += ', '
+            cmds += c
+            if len(cmds) > Config().get('nodetool.commands_in_line', 40):
+                log('  ' + cmds)
+                cmds = ''
+
+        if len(cmds) > 0:
+            log('  ' + cmds)
+        log()
+        ClusterOrPodCommandHelper.cluter_or_pod_help()

adam/commands/cassandra/nodetool_commands.py

@@ -0,0 +1,120 @@
+NODETOOL_COMMANDS = [
+    'assassinate',
+    'bootstrap',
+    'cleanup',
+    'clearsnapshot',
+    'clientstats',
+    'compact',
+    'compactionhistory',
+    'compactionstats',
+    'decommission',
+    'describecluster',
+    'describering',
+    'disableauditlog',
+    'disableautocompaction',
+    'disablebackup',
+    'disablebinary',
+    'disablefullquerylog',
+    'disablegossip',
+    'disablehandoff',
+    'disablehintsfordc',
+    'disableoldprotocolversions',
+    'drain',
+    'enableauditlog',
+    'enableautocompaction',
+    'enablebackup',
+    'enablebinary',
+    'enablefullquerylog',
+    'enablegossip',
+    'enablehandoff',
+    'enablehintsfordc',
+    'enableoldprotocolversions',
+    'failuredetector',
+    'flush',
+    'garbagecollect',
+    'gcstats',
+    'getbatchlogreplaythrottle',
+    'getcompactionthreshold',
+    'getcompactionthroughput',
+    'getconcurrency',
+    'getconcurrentcompactors',
+    'getconcurrentviewbuilders',
+    'getendpoints',
+    'getfullquerylog',
+    'getinterdcstreamthroughput',
+    'getlogginglevels',
+    'getmaxhintwindow',
+    'getseeds',
+    'getsnapshotthrottle',
+    'getsstables',
+    'getstreamthroughput',
+    'gettimeout',
+    'gettraceprobability',
+    'gossipinfo',
+    'help',
+    'import',
+    'info',
+    'invalidatecountercache',
+    'invalidatekeycache',
+    'invalidaterowcache',
+    'join',
+    'listsnapshots',
+    'move',
+    'netstats',
+    'pausehandoff',
+    'profileload',
+    'proxyhistograms',
+    'rangekeysample',
+    'rebuild',
+    'rebuild_index',
+    'refresh',
+    'refreshsizeestimates',
+    'reloadlocalschema',
+    'reloadseeds',
+    'reloadssl',
+    'reloadtriggers',
+    'relocatesstables',
+    'removenode',
+    'repair',
+    'repair_admin',
+    'replaybatchlog',
+    'resetfullquerylog',
+    'resetlocalschema',
+    'resumehandoff',
+    'ring',
+    'scrub',
+    'setbatchlogreplaythrottle',
+    'setcachecapacity',
+    'setcachekeystosave',
+    'setcompactionthreshold',
+    'setcompactionthroughput',
+    'setconcurrency',
+    'setconcurrentcompactors',
+    'setconcurrentviewbuilders',
+    'sethintedhandoffthrottlekb',
+    'setinterdcstreamthroughput',
+    'setlogginglevel',
+    'setmaxhintwindow',
+    'setsnapshotthrottle',
+    'setstreamthroughput',
+    'settimeout',
+    'settraceprobability',
+    'sjk',
+    'snapshot',
+    'status',
+    'statusautocompaction',
+    'statusbackup',
+    'statusbinary',
+    'statusgossip',
+    'statushandoff',
+    'stop',
+    'stopdaemon',
+    'tablehistograms',
+    'tablestats',
+    'toppartitions',
+    'tpstats',
+    'truncatehints',
+    'upgradesstables',
+    'verify',
+    'version',
+    'viewbuildstatus']

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

@@ -0,0 +1,88 @@
+import datetime
+from kubernetes import client
+from kubernetes.client.rest import ApiException
+
+from adam.commands import extract_options
+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
+from adam.utils import duration, log2
+
+class RollOut(Command):
+    COMMAND = 'rollout'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RollOut, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RollOut.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):
+                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.")
+
+                    return state
+
+                self.rolling_restart(state.sts, state.namespace)
+
+                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
+
+    def rolling_restart(self, statefulset, namespace):
+        # kubectl rollout restart statefulset <statefulset-name>
+        v1_apps = client.AppsV1Api()
+
+        now = datetime.datetime.now(datetime.timezone.utc)
+        now = str(now.isoformat("T") + "Z")
+        body = {
+            'spec': {
+                'template':{
+                    'metadata': {
+                        'annotations': {
+                            'kubectl.kubernetes.io/restartedAt': now
+                        }
+                    }
+                }
+            }
+        }
+
+        try:
+            v1_apps.patch_namespaced_stateful_set(statefulset, namespace, body, pretty='true')
+        except ApiException as e:
+            log2("Exception when calling AppsV1Api->read_namespaced_statefulset_status: %s\n" % e)
+
+    def completion(self, state: ReplState):
+        if super().completion(state):
+            return {RollOut.COMMAND: None}
+
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{RollOut.COMMAND} [--force]\t rollout all nodes'

adam/commands/cat.py

@@ -27,10 +27,10 @@ class Cat(Command):
 
         with self.validate(args, state) as (args, state):
             with validate_args(args, state, name='file'):
-                return Devices.device(state).bash(state, state, cmd.split(' '))
+                return Devices.of(state).bash(state, state, cmd.split(' '))
 
     def completion(self, state: ReplState):
-        return super().completion(state, lambda: {f: None for f in Devices.device(state).files(state)}, pods=Devices.device(state).pods(state, '-'), auto='jit')
+        return super().completion(state, lambda: {f: None for f in Devices.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
 
     def help(self, _: ReplState):
         return f'{Cat.COMMAND} file [&]\t run cat command on the pod'

adam/commands/cd.py

@@ -28,14 +28,14 @@ class Cd(Command):
 
         with self.validate(args, state, apply=False) as (args, state):
             with validate_args(args, state, name='directory') as arg_str:
-                device: Device = Devices.device(state)
+                device: Device = Devices.of(state)
                 for dir in arg_str.split('/'):
                     device.cd(dir, state)
 
                 return state
 
     def completion(self, state: ReplState):
-        return Devices.device(state).cd_completion(Cd.COMMAND, state, default = {})
+        return Devices.of(state).cd_completion(Cd.COMMAND, state, default = {})
 
     def help(self, _: ReplState):
         return f'{Cd.COMMAND} <path> | .. \t move around on the operational device hierarchy'

adam/commands/command.py

@@ -44,7 +44,7 @@ class Command:
         if pod:
             c |= self._completion(state, leaf, auto=auto, auto_key=auto_key)
 
-        c |= {f'@{p}': self._completion(state, leaf, to_validate=False, auto=auto, auto_key=auto_key) for p in pod_names if p != pod}
+        c |= {f'@{p}': self._completion(state.with_pod(p), leaf, to_validate=False, auto=auto, auto_key=auto_key) for p in pod_names if p != pod}
 
         return c
 

adam/commands/commands_utils.py

@@ -1,17 +1,14 @@
-from datetime import datetime
 from kubernetes import client
 from typing import List
 
 from adam.checks.check_utils import run_checks
 from adam.columns.columns import Columns, collect_checks
-from adam.config import Config
-from adam.repl_session import ReplSession
 from adam.utils_issues import IssuesUtils
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.utils_k8s.pods import Pods
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState
-from adam.utils import SORT, duration, tabulize, log, log2
+from adam.utils import SORT, duration, kaqing_log_file, tabulize, log2
 
 def show_pods(pods: List[client.V1Pod], ns: str, show_namespace = True, show_host_id = True):
     if len(pods) == 0:
@@ -70,16 +67,14 @@ def show_table(state: ReplState, pods: list[str], cols: str, header: str, show_o
     r = tabulize(pods, lambda p: ','.join([c.pod_value(results, p) for c in columns]), header=header, separator=',', sorted=SORT, to = 0 if backgrounded else 1)
 
     if backgrounded:
-        log_prefix = Config().get('log-prefix', '/tmp/qing')
-        log_file = f'{log_prefix}-{datetime.now().strftime("%d%H%M%S")}.log'
+        r = write_to_kaqing_log_file(r)
 
-        with open(log_file, 'w') as f:
-            f.write(r)
-
-        ReplSession().append_history(f':sh cat {log_file}')
+    IssuesUtils.show(results, state.in_repl)
 
-        r = log_file
+    return r
 
-    IssuesUtils.show(results, state.in_repl)
+def write_to_kaqing_log_file(r: str):
+    with kaqing_log_file() as f:
+        f.write(r)
 
-    return r
+        return f.name