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

adam/commands/cassandra/nodetool.py

@@ -1,64 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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/download_file.py

@@ -1,47 +0,0 @@
-from adam.commands import validate_args
-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.repl_state import ReplState, RequiredState
-from adam.utils import log2
-from adam.utils_k8s.pods import Pods
-
-class DownloadFile(Command):
-    COMMAND = 'download file'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(DownloadFile, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return DownloadFile.COMMAND
-
-    def required(self):
-        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
-
-    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 validate_args(args, state, name='file'):
-                to_file = Pods.download_file(Devices.of(state).pod(state),
-                                             Devices.of(state).default_container(state),
-                                             state.namespace,
-                                             args[0],
-                                             args[1] if len(args) > 1 else None)
-                log2(f'Downloaded to {to_file}.')
-
-                return state
-
-    def completion(self, state: ReplState):
-        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'{DownloadFile.COMMAND} from-file [to-file]\t download file from pod'

adam/commands/find_files.py

@@ -1,51 +0,0 @@
-import os
-
-from adam.commands.command import Command
-from adam.repl_state import ReplState
-from adam.utils import log2
-from adam.utils_local import local_tmp_dir
-
-class FindLocalFiles(Command):
-    COMMAND = 'find local'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(FindLocalFiles, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return FindLocalFiles.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):
-            cmd = 'find'
-
-            if not args:
-                cmd = f'find {local_tmp_dir()}'
-            elif len(args) == 1:
-                cmd = f"find {local_tmp_dir()} -name '{args[0]}'"
-            else:
-                new_args = [f"'{arg}'" if '*' in arg else arg for arg in args]
-                cmd = 'find ' + ' '.join(new_args)
-
-            log2(cmd)
-            os.system(cmd)
-
-            return state
-
-    def completion(self, state: ReplState):
-        return super().completion(state, {
-            '*.csv': None,
-            '*.db': None,
-            '*': None
-        })
-
-    def help(self, _: ReplState):
-        return f'{FindLocalFiles.COMMAND} [linux-find-arguments]\t find files from local machine'

adam/commands/os/find_processes.py

@@ -1,76 +0,0 @@
-from adam.commands import extract_options, validate_args
-from adam.commands.command import Command
-from adam.commands.devices.devices import Devices
-from adam.commands.export.utils_export import state_with_pod
-from adam.repl_state import ReplState, RequiredState
-from adam.utils import log2, tabulize
-
-class FindProcesses(Command):
-    COMMAND = 'find processes'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(FindProcesses, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return FindProcesses.COMMAND
-
-    def required(self):
-        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
-
-    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, '-kill') as (args, kill):
-                with validate_args(args, state, name='words to look for'):
-                    arg = ' | '.join([f'grep {a}' for a in args])
-                    awk = "awk '{ print $1, $2, $8, $NF }'"
-                    rs = Devices.of(state).bash(state, state, f"ps -ef | grep -v grep | {arg} | {awk}".split(' '))
-
-                    lines: list[list[str]] = []
-                    for r in rs:
-                        for l in r.stdout.split('\n'):
-                            l = l.strip(' \t\r\n')
-                            if not l:
-                                continue
-
-                            tokens = [r.pod] + l.split(' ')
-                            lines.append(tokens)
-
-                    pids = []
-                    for l in lines:
-                        pids.append(f'{l[2]}@{l[0]}')
-
-                    tabulize(lines, lambda l: '\t'.join(l), header = 'POD\tUSER\tPID\tCMD\tLAST_ARG', separator='\t')
-                    log2()
-                    log2(f'PIDS with {",".join(args)}: {",".join(pids)}')
-
-                    if kill:
-                        log2()
-                        for pidp in pids:
-                            pid_n_pod = pidp.split('@')
-                            pid = pid_n_pod[0]
-                            if len(pid_n_pod) < 2:
-                                continue
-
-                            pod = pid_n_pod[1]
-
-                            log2(f'@{pod} bash kill -9 {pid}')
-
-                            with state_with_pod(state, pod) as state1:
-                                Devices.of(state).bash(state, state1, ['kill', '-9', pid])
-
-                    return rs
-
-    def completion(self, state: ReplState):
-        return super().completion(state)
-
-    def help(self, _: ReplState):
-        return f'{FindProcesses.COMMAND} word... [-kill]\t find processes with words'

adam/commands/os/head.py

@@ -1,36 +0,0 @@
-from adam.commands import validate_args
-from adam.commands.command import Command
-from adam.commands.devices.devices import Devices
-from adam.repl_state import ReplState, RequiredState
-
-class Head(Command):
-    COMMAND = 'head'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Head, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Head.COMMAND
-
-    def required(self):
-        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
-
-    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 validate_args(args, state, name='file'):
-                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.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
-
-    def help(self, _: ReplState):
-        return f'{Head.COMMAND} file [&]\t run head command on the pod'