kaqing 2.0.145__py3-none-any.whl → 2.0.189__py3-none-any.whl

adam/commands/find_processes.py

@@ -0,0 +1,76 @@
+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.device(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.device(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/head.py

@@ -0,0 +1,36 @@
+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.device(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')
+
+    def help(self, _: ReplState):
+        return f'{Head.COMMAND} file [&]\t run head command on the pod'

adam/commands/help.py

@@ -1,7 +1,7 @@
 from adam.commands.command import Command
 from adam.repl_commands import ReplCommands
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log
+from adam.utils import tabulize, log
 
 class Help(Command):
     COMMAND = 'help'
@@ -45,7 +45,7 @@ class Help(Command):
         lines.append('')
         lines.extend(section(ReplCommands.exit()))
 
-        log(lines_to_tabular(lines, separator='\t'))
+        tabulize(lines, separator='\t')
 
         return lines
 

adam/commands/intermediate_command.py

@@ -0,0 +1,52 @@
+from abc import abstractmethod
+
+from adam.commands.command import Command
+from adam.commands.command_helpers import ClusterCommandHelper
+from adam.repl_state import ReplState
+from adam.utils import tabulize, log, log2
+
+class IntermediateCommand(Command):
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        return self.intermediate_run(cmd, state, args, self.cmd_list())
+
+    def completion(self, state: ReplState):
+        return {}
+
+    @abstractmethod
+    def cmd_list(self):
+        pass
+
+    def intermediate_run(self, cmd: str, state: ReplState, args: list[str], cmds: list['Command'], separator='\t', display_help=True):
+        state, _ = self.apply_state(args, state)
+
+        if state.in_repl:
+            if display_help:
+                tabulize(cmds, lambda c: c.help(state), separator=separator)
+
+            return 'command-missing'
+        else:
+            # head with the Chain of Responsibility pattern
+            if not self.run_subcommand(cmd, state):
+                if display_help:
+                    log2('* Command is missing.')
+                    Command.display_help()
+                return 'command-missing'
+
+        return state
+
+    def run_subcommand(self, cmd: str, state: ReplState):
+        cmds = Command.chain(self.cmd_list())
+        return cmds.run(cmd, state)
+
+    def intermediate_help(super_help: str, cmd: str, cmd_list: list['Command'], separator='\t', show_cluster_help=False):
+        log(super_help)
+        log()
+        log('Sub-Commands:')
+
+        tabulize(cmd_list, lambda c: c.help(ReplState()).replace(f'{cmd} ', '  ', 1), separator=separator)
+        if show_cluster_help:
+            log()
+            ClusterCommandHelper.cluster_help()

adam/commands/issues.py

@@ -1,10 +1,9 @@
 from adam.checks.check_result import CheckResult
 from adam.checks.check_utils import run_checks
-from adam.checks.issue import Issue
+from adam.commands import extract_options
 from adam.commands.command import Command
-from adam.repl_session import ReplSession
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2
+from adam.utils_issues import IssuesUtils
 
 class Issues(Command):
     COMMAND = 'issues'
@@ -28,48 +27,17 @@ class Issues(Command):
         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
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, ['-s', '--show']) as (args, show_out):
+                results = run_checks(state.sts, state.namespace, state.pod, show_out=show_out)
 
-        args, show = Command.extract_options(args, ['-s', '--show'])
+                issues = CheckResult.collect_issues(results)
+                IssuesUtils.show_issues(issues, in_repl=state.in_repl)
 
-        results = run_checks(state.sts, state.namespace, state.pod, show_output=show)
+                return issues if issues else 'issues'
 
-        issues = CheckResult.collect_issues(results)
-        Issues.show_issues(issues, in_repl=state.in_repl)
-
-        return issues if issues else 'issues'
-
-    def show(check_results: list[CheckResult], in_repl = False):
-        Issues.show_issues(CheckResult.collect_issues(check_results), in_repl=in_repl)
-
-    def show_issues(issues: list[Issue], in_repl = False):
-        if not issues:
-            log2('No issues found.')
-        else:
-            suggested = 0
-            log2(f'* {len(issues)} issues found.')
-            lines = []
-            for i, issue in enumerate(issues, start=1):
-                lines.append(f"{i}||{issue.category}||{issue.desc}")
-                lines.append(f"||statefulset||{issue.statefulset}@{issue.namespace}")
-                lines.append(f"||pod||{issue.pod}@{issue.namespace}")
-                if issue.details:
-                    lines.append(f"||details||{issue.details}")
-
-                if issue.suggestion:
-                    lines.append(f'||suggestion||{issue.suggestion}')
-                    if in_repl:
-                        ReplSession().prompt_session.history.append_string(issue.suggestion)
-                        suggested += 1
-            log(lines_to_tabular(lines, separator='||'))
-            if suggested:
-                log2()
-                log2(f'* {suggested} suggested commands are added to history. Press <Up> arrow to access them.')
-
-    def completion(self, _: ReplState):
-        return {Issues.COMMAND: None}
+    def completion(self, state: ReplState):
+        return super().completion(state, {'-s': None})
 
     def help(self, _: ReplState):
-        return f'{Issues.COMMAND}\t find all issues'
+        return f'{Issues.COMMAND} [-s]\t find all issues'

adam/commands/kubectl.py

@@ -25,13 +25,10 @@ class Kubectl(Command):
         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
-
-        subprocess.run(["kubectl"] + args)
+        with self.validate(args, state) as (args, state):
+            subprocess.run(["kubectl"] + args)
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
         return super().completion(state)

adam/commands/login.py

@@ -1,15 +1,15 @@
 import os
 import signal
-import traceback
 
 from adam.app_session import AppSession
 from adam.apps import Apps
+from adam.commands import extract_options
 from adam.config import Config
 from adam.sso.idp import Idp
 from adam.sso.idp_login import IdpLogin
 from adam.commands.command import Command
-from adam.repl_state import ReplState, RequiredState
-from adam.utils import log, log2
+from adam.repl_state import ReplState
+from adam.utils import log, log2, log_exc
 
 class Login(Command):
     COMMAND = 'login'
@@ -30,37 +30,35 @@ class Login(Command):
         return ReplState.NON_L
 
     def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
         def custom_handler(signum, frame):
             AppSession.ctrl_c_entered = True
 
         signal.signal(signal.SIGINT, custom_handler)
 
-        if not(args := self.args(cmd)):
-            return super().run(cmd, state)
-
-        state, args = self.apply_state(args, state)
-        args, debug = Command.extract_options(args, ['d'])
-        if debug:
-            Config().set('debug', True)
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, 'd') as (args, debug):
+                if debug:
+                    Config().set('debug', True)
 
-        username: str = os.getenv('USERNAME')
-        if len(args) > 0:
-            username = args[0]
+                username: str = os.getenv('USERNAME')
+                if len(args) > 0:
+                    username = args[0]
 
-        login: IdpLogin = None
-        try:
-            if not(host := Apps.app_host('c3', 'c3', state.namespace)):
-                log2('Cannot locate ingress for app.')
-                return state
+                login: IdpLogin = None
+                with log_exc(True):
+                    if not(host := Apps.app_host('c3', 'c3', state.namespace)):
+                        log2('Cannot locate ingress for app.')
+                        return state
 
-            if not (login := Idp.login(host, username=username, use_token_from_env=False)):
-                log2('Invalid username/password. Please try again.')
-        except:
-            log2(traceback.format_exc())
+                    if not (login := Idp.login(host, username=username, use_token_from_env=False)):
+                        log2('Invalid username/password. Please try again.')
 
-        log(f'IDP_TOKEN={login.ser() if login else ""}')
+                log(f'IDP_TOKEN={login.ser() if login else ""}')
 
-        return state
+                return state
 
     def completion(self, state: ReplState):
         return super().completion(state)

adam/commands/logs.py

@@ -25,12 +25,9 @@ class Logs(Command):
         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
-
-        path = Config().get('logs.path', '/c3/cassandra/logs/system.log')
-        return CassandraNodes.exec(state.pod, state.namespace, f'cat {path}')
+        with self.validate(args, state) as (args, state):
+            path = Config().get('logs.path', '/c3/cassandra/logs/system.log')
+            return CassandraNodes.exec(state.pod, state.namespace, f'cat {path}')
 
     def completion(self, _: ReplState):
         # available only on cli

adam/commands/ls.py

@@ -23,20 +23,19 @@ class Ls(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
+        with self.validate(args, state) as (args, state):
+            if len(args) > 0:
+                arg = args[0]
+                if arg in ['p:', 'c:'] and arg != f'{state.device}:':
+                    state = copy.copy(state)
+                    state.device = arg.replace(':', '')
 
-        if len(args) > 0:
-            arg = args[0]
-            if arg in ['p:', 'c:'] and arg != f'{state.device}:':
-                state = copy.copy(state)
-                state.device = arg.replace(':', '')
+            Devices.device(state).ls(cmd, state)
 
-        Devices.device(state).ls(cmd, state)
-
-        return state
+            return state
 
     def completion(self, state: ReplState):
-        return Devices.device(state).ls_completion(Ls.COMMAND, state, default = super().completion(state))
+        return super().completion(state, {'&': None}, pods=Devices.device(state).pods(state, '-'))
 
     def help(self, _: ReplState):
         return f'{Ls.COMMAND} [device:]\t list apps, envs, clusters, nodes, pg hosts/databases or export databases'

adam/commands/medusa/medusa.py

@@ -1,13 +1,13 @@
 import click
 
 from adam.commands.command import Command
+from adam.commands.intermediate_command import IntermediateCommand
 from .medusa_backup import MedusaBackup
 from .medusa_restore import MedusaRestore
 from .medusa_show_backupjobs import MedusaShowBackupJobs
 from .medusa_show_restorejobs import MedusaShowRestoreJobs
-from adam.repl_state import ReplState, RequiredState
 
-class Medusa(Command):
+class Medusa(IntermediateCommand):
     COMMAND = 'medusa'
 
     # the singleton pattern
@@ -16,30 +16,12 @@ class Medusa(Command):
 
         return cls.instance
 
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
     def command(self):
         return Medusa.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)
-
-        return super().intermediate_run(cmd, state, args, Medusa.cmd_list())
-
-    def cmd_list():
+    def cmd_list(self):
         return [MedusaBackup(), MedusaRestore(), MedusaShowBackupJobs(), MedusaShowRestoreJobs()]
 
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
-
 class MedusaCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
-        Command.intermediate_help(super().get_help(ctx), Medusa.COMMAND, Medusa.cmd_list(), show_cluster_help=True)
+        IntermediateCommand.intermediate_help(super().get_help(ctx), Medusa.COMMAND, Medusa().cmd_list(), show_cluster_help=True)

adam/commands/medusa/medusa_backup.py

@@ -1,13 +1,12 @@
 from datetime import datetime
-import re
 
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils_k8s.custom_resources import CustomResources
 from adam.utils import log2
 
-
 class MedusaBackup(Command):
     COMMAND = 'backup'
 
@@ -29,33 +28,27 @@ class MedusaBackup(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
-
-        ns = state.namespace
-        sts = state.sts
-        now_dtformat = datetime.now().strftime("%Y-%m-%d.%H.%M.%S")
-        bkname = 'medusa-' + now_dtformat + 'full-backup-' + sts
-        if len(args) == 1:
-            bkname = str(args[0])
-        groups = re.match(r'^(.*?-.*?-).*', sts)
-        dc = StatefulSets.get_datacenter(state.sts, ns)
-        if not dc:
-            return state
-
-        try:
-            CustomResources.create_medusa_backupjob(bkname, dc, ns)
-        except Exception as e:
-            log2("Exception: MedusaBackup failed: %s\n" % e)
-
-        return state
 
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
+        with self.validate(args, state) as (args, state):
+            ns = state.namespace
+            sts = state.sts
+            now_dtformat = datetime.now().strftime("%Y-%m-%d.%H.%M.%S")
+            with validate_args(args, state, default='medusa-' + now_dtformat + 'full-backup-' + sts) as bkname:
+                dc = StatefulSets.get_datacenter(state.sts, ns)
+                if not dc:
+                    return state
+
+                try:
+                    CustomResources.create_medusa_backupjob(bkname, dc, ns)
+                except Exception as e:
+                    log2("Exception: MedusaBackup failed: %s\n" % e)
+                finally:
+                    CustomResources.clear_caches()
 
-        return {}
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
 
     def help(self, _: ReplState):
         return f'{MedusaBackup.COMMAND}\t start a backup job'

adam/commands/medusa/medusa_restore.py

@@ -1,11 +1,15 @@
+from collections.abc import Callable
 from datetime import datetime
+from functools import partial
 
-from adam.commands.command import Command
+from adam.commands import validate_args
+from adam.commands.command import Command, InvalidArgumentsException
+from adam.commands.medusa.utils_medusa import medusa_backup_names
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils_k8s.custom_resources import CustomResources
 from adam.config import Config
-from adam.utils import lines_to_tabular, log2
+from adam.utils import tabulize, log2, log_exc
 
 class MedusaRestore(Command):
     COMMAND = 'restore'
@@ -28,56 +32,55 @@ class MedusaRestore(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
-
-        ns = state.namespace
-        dc = StatefulSets.get_datacenter(state.sts, ns)
-        if not dc:
-            return state
-
-        if len(args) == 1:
-            bkname = args[0]
-            job = CustomResources.medusa_get_backupjob(dc, ns, bkname)
-            if not job:
-                log2('\n* Backup job name is not valid.')
-                bklist = [f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '')}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]
-                log2(lines_to_tabular(bklist, 'NAME\tCREATED\tFINISHED', separator='\t'))
 
+        with self.validate(args, state) as (args, state):
+            ns = state.namespace
+            dc: str = StatefulSets.get_datacenter(state.sts, ns)
+            if not dc:
                 return state
 
-            if not input(f"Restoring from {bkname} created at {job['metadata']['creationTimestamp']}. Please enter Yes to continue: ").lower() in ['y', 'yes']:
-                return state
-        else:
-            bklist = [f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '')}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]
-            log2('\n* Missing Backup Name')
-            log2('Usage: qing medusa restore <backup> <sts@name_space>\n')
-            log2(lines_to_tabular(bklist, 'NAME\tCREATED\tFINISHED', separator='\t'))
-            return state
-
-        now_dtformat = datetime.now().strftime("%Y-%m-%d.%H.%M.%S")
-        rtname = 'medusa-' + now_dtformat + '-restore-from-' + bkname
-        try:
-            CustomResources.create_medusa_restorejob(rtname, bkname, dc, ns)
-        except Exception as e:
-            log2("Exception: MedusaRestore failed: %s\n" % e)
-
-        return state
+            def msg(missing: bool):
+                if missing:
+                    log2('\n* Missing Backup Name')
+                    log2('Usage: qing restore <backup> <sts@name_space>\n')
+                else:
+                    log2('\n* Backup job name is not valid.')
 
-    def completion(self, state: ReplState):
-        if state.sts:
-            ns = state.namespace
-            dc = StatefulSets.get_datacenter(state.sts, ns)
-            if not dc:
-                return {}
+                tabulize(CustomResources.medusa_show_backupjobs(dc, ns),
+                         lambda x: f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '')}",
+                         header='NAME\tCREATED\tFINISHED',
+                         separator='\t',
+                         to=2)
 
-            if Config().get('medusa.restore-auto-complete', False):
-                leaf = {id: None for id in [f"{x['metadata']['name']}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]}
+            with validate_args(args, state, msg=partial(msg, True)) as bkname:
+                if not (job := CustomResources.medusa_get_backupjob(dc, ns, bkname)):
+                    msg(False)
+                    raise InvalidArgumentsException()
 
-                return super().completion(state, leaf)
-            else:
-                return super().completion(state)
+                if not input(f"Restoring from {bkname} created at {job['metadata']['creationTimestamp']}. Please enter Yes to continue: ").lower() in ['y', 'yes']:
+                    return state
+
+                with log_exc(lambda e: "Exception: MedusaRestore failed: %s\n" % e):
+                    now_dtformat = datetime.now().strftime("%Y-%m-%d.%H.%M.%S")
+                    rtname = 'medusa-' + now_dtformat + '-restore-from-' + bkname
+                    CustomResources.create_medusa_restorejob(rtname, bkname, dc, ns)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {id: None for id in medusa_backup_names(state)}, auto_key='medusa.backups')
+        # if sc := super().completion(state):
+        #     ns = state.namespace
+        #     dc: str = StatefulSets.get_datacenter(state.sts, ns)
+        #     if not dc:
+        #         return {}
+
+        #     if Config().get('medusa.restore-auto-complete', False):
+        #         leaf = {id: None for id in [f"{x['metadata']['name']}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]}
+
+        #         return super().completion(state, leaf)
+        #     else:
+        #         return sc
 
         return {}