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

adam/commands/kubectl.py

@@ -0,0 +1,38 @@
+import subprocess
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+
+class Kubectl(Command):
+    COMMAND = 'k'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Kubectl, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Kubectl.COMMAND
+
+    def required(self):
+        return RequiredState.NAMESPACE
+
+    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):
+            subprocess.run(["kubectl"] + args)
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+
+    def help(self, _: ReplState):
+        return f'{Kubectl.COMMAND} \t run a kubectl command'

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
-from adam.utils import log, log2
+from adam.utils import log, log2, log_exc
 
 class Login(Command):
     COMMAND = 'login'
@@ -26,41 +26,42 @@ class Login(Command):
     def command(self):
         return Login.COMMAND
 
+    def required(self):
+        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.show-out', 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, _: ReplState):
-        return {}
+    def completion(self, state: ReplState):
+        return super().completion(state)
 
     def help(self, _: ReplState):
         return f'{Login.COMMAND}\t SSO login'

adam/commands/logs.py

@@ -1,6 +1,6 @@
 from adam.commands.command import Command
 from adam.config import Config
-from adam.k8s_utils.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.repl_state import ReplState, RequiredState
 
 class Logs(Command):
@@ -25,14 +25,12 @@ 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
         return {}
 
     def help(self, _: ReplState):

adam/commands/ls.py

@@ -1,20 +1,8 @@
 import copy
-import re
 
 from adam.commands.command import Command
-from adam.commands.commands_utils import show_pods, show_rollout
-from adam.commands.cqlsh import Cqlsh
-from adam.commands.postgres.postgres_session import PostgresSession
-from adam.config import Config
-from adam.k8s_utils.custom_resources import CustomResources
-from adam.k8s_utils.ingresses import Ingresses
-from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.services import Services
-from adam.k8s_utils.statefulsets import StatefulSets
-from adam.pod_exec_result import PodExecResult
+from adam.commands.devices.devices import Devices
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2
-from adam.apps import Apps
 
 class Ls(Command):
     COMMAND = 'ls'
@@ -35,111 +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)
 
-        if state.device == ReplState.P:
-            if state.pg_path:
-                pg = PostgresSession(state.namespace, state.pg_path)
-                if pg.db:
-                    self.show_pg_tables(pg)
-                else:
-                    self.show_pg_databases(pg)
-            else:
-                self.show_pg_hosts(state)
-        elif state.device == ReplState.A:
-            if state.app_env:
-                def line(n: str, ns: str):
-                    host = Ingresses.get_host(Config().get('app.login.ingress', '{app_id}-k8singr-appleader-001').replace('{app_id}', f'{ns}-{n}'), ns)
-                    if not host:
-                        return None
-
-                    endpoint = Config().get('app.login.url', 'https://{host}/{env}/{app}').replace('{host}', host).replace('{env}', state.app_env).replace('{app}', 'c3')
-                    if not endpoint:
-                        return None
-
-                    return f"{n.split('-')[1]},{Ingresses.get_host(f'{ns}-{n}-k8singr-appleader-001', ns)},{endpoint}"
-
-                svcs = [l for l in [line(n, ns) for n, ns in Apps.apps(state.app_env)] if l]
-
-                log(lines_to_tabular(svcs, 'APP,HOST,ENDPOINT', separator=','))
-            else:
-                svcs = [n for n, ns in Apps.envs()]
-
-                log(lines_to_tabular(svcs, 'ENV', separator=','))
-        else:
-            if state.pod:
-                r: PodExecResult = Cqlsh().run(f'cql describe tables', state)
-                if r.stderr:
-                    log(r.stderr)
-                log(r.stdout)
-            elif state.sts and state.namespace:
-                show_pods(StatefulSets.pods(state.sts, state.namespace), state.namespace, show_namespace=not KubeContext.in_cluster_namespace())
-                show_rollout(state.sts, state.namespace)
-            else:
-                self.show_statefulsets()
-
-        return state
-
-    def show_statefulsets(self):
-        ss = StatefulSets.list_sts_names(show_namespace=not KubeContext.in_cluster_namespace())
-        if len(ss) == 0:
-            log2('No cassandra statefulsets found.')
-            return
-
-        app_ids = CustomResources.get_app_ids()
-        list = []
-        for s in ss:
-            cr_name = CustomResources.get_cr_name(s)
-            app_id = 'Unknown'
-            if cr_name in app_ids:
-                app_id = app_ids[cr_name]
-            list.append(f"{s} {app_id}")
-
-        header = 'STATEFULSET_NAME@NAMESPACE APP_ID'
-        if KubeContext.in_cluster_namespace():
-            header = 'STATEFULSET_NAME APP_ID'
-        log(lines_to_tabular(list, header))
-
-    def show_pg_hosts(self, state: ReplState):
-        if state.namespace:
-            def line(pg: PostgresSession):
-                return f'{pg.directory()},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
-
-            lines = [line(PostgresSession(state.namespace, pg)) for pg in PostgresSession.hosts(state.namespace)]
-
-            log(lines_to_tabular(lines, 'NAME,ENDPOINT,USERNAME,PASSWORD', separator=','))
-        else:
-            def line(pg: PostgresSession):
-                return f'{pg.directory()},{pg.namespace},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
-
-            lines = [line(PostgresSession(state.namespace, pg)) for pg in PostgresSession.hosts(state.namespace)]
-
-            log(lines_to_tabular(lines, 'NAME,NAMESPACE,ENDPOINT,USERNAME,PASSWORD', separator=','))
-
-    def show_pg_databases(self, pg: PostgresSession):
-        lines = [db["name"] for db in pg.databases() if db["owner"] == PostgresSession.default_owner()]
-
-        log(lines_to_tabular(lines, 'DATABASE', separator=','))
-
-    def show_pg_tables(self, pg: PostgresSession):
-        lines = [db["name"] for db in pg.tables() if db["schema"] == PostgresSession.default_schema()]
-
-        log(lines_to_tabular(lines, 'NAME', separator=','))
+            return state
 
     def completion(self, state: ReplState):
-        if state.pod:
-            return {}
-
-        if not state.sts:
-            return {Ls.COMMAND: {n: None for n in StatefulSets.list_sts_names()}}
-
-        return {Ls.COMMAND: None}
+        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 or pg databases'
+        return f'{Ls.COMMAND} [device:]\t list apps, envs, clusters, nodes, pg hosts/databases or export databases'

adam/commands/medusa/medusa.py

@@ -1,15 +1,13 @@
 import click
 
 from adam.commands.command import Command
-from adam.commands.command_helpers import ClusterCommandHelper
+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
-from adam.utils import lines_to_tabular, log, log2
 
-class Medusa(Command):
+class Medusa(IntermediateCommand):
     COMMAND = 'medusa'
 
     # the singleton pattern
@@ -18,52 +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)
-
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        if state.in_repl:
-            log(lines_to_tabular([c.help(ReplState()) for c in Medusa.cmd_list()], separator=':'))
-
-            return 'command-missing'
-        else:
-            # head with the Chain of Responsibility pattern
-            cmds = Command.chain(Medusa.cmd_list())
-            if not cmds.run(cmd, state):
-                log2('* Command is missing.')
-                Command.display_help()
-
-    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 {}
-
-    def help(self, _: ReplState):
-        return None
-
 class MedusaCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
-        log(super().get_help(ctx))
-        log()
-        log('Sub-Commands:')
-
-        log(lines_to_tabular([c.help(ReplState()).replace(f'{Medusa.COMMAND} ', '  ', 1) for c in Medusa.cmd_list()], separator=':'))
-        log()
-        ClusterCommandHelper.cluster_help()
+        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.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
-from adam.k8s_utils.custom_resources import CustomResources
+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.k8s_utils.statefulsets import StatefulSets
+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.k8s_utils.custom_resources import CustomResources
+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,57 +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:
-            print('SEAN doing')
-            # 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 {}
 

adam/commands/medusa/medusa_show_backupjobs.py

@@ -1,8 +1,8 @@
 from adam.commands.command import Command
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
-from adam.k8s_utils.custom_resources import CustomResources
-from adam.utils import lines_to_tabular, log2
+from adam.utils_k8s.custom_resources import CustomResources
+from adam.utils import tabulize, log_exc
 
 
 class MedusaShowBackupJobs(Command):
@@ -26,27 +26,26 @@ class MedusaShowBackupJobs(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
 
-        try:
-            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'))
-        except Exception as e:
-            log2("Exception: MedusaShowBackupJobs failed: %s\n" % e)
+        with self.validate(args, state) as (args, state):
+            ns = state.namespace
+            dc = StatefulSets.get_datacenter(state.sts, ns)
+            if not dc:
+                return state
 
-        return state
+            with log_exc(lambda e: "Exception: MedusaShowBackupJobs failed: %s\n" % e):
+                CustomResources.clear_caches()
 
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
+                tabulize(CustomResources.medusa_show_backupjobs(dc, ns),
+                         lambda x: f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '') if 'status' in x else 'unknown'}",
+                         header='NAME\tCREATED\tFINISHED',
+                         separator='\t',
+                         to=2)
 
-        return {}
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
 
     def help(self, _: ReplState):
-        return f'{MedusaShowBackupJobs.COMMAND}\t show backups'
+        return f'{MedusaShowBackupJobs.COMMAND}\t show Medusa backups'

adam/commands/medusa/medusa_show_restorejobs.py

@@ -1,8 +1,8 @@
 from adam.commands.command import Command
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
-from adam.k8s_utils.custom_resources import CustomResources
-from adam.utils import lines_to_tabular, log2
+from adam.utils_k8s.custom_resources import CustomResources
+from adam.utils import tabulize, log_exc
 
 class MedusaShowRestoreJobs(Command):
     COMMAND = 'show restores'
@@ -25,28 +25,23 @@ class MedusaShowRestoreJobs(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
+        with self.validate(args, state) as (args, state):
+            ns = state.namespace
+            dc = StatefulSets.get_datacenter(state.sts, ns)
+            if not dc:
+                return state
 
-        try:
-            rtlist = CustomResources.medusa_show_restorejobs(dc, ns)
-            log2(lines_to_tabular(rtlist, 'NAME\tCREATED\tFINISHED', separator='\t'))
-        except Exception as e:
-            log2("Exception: MedusaShowRestoreJobs failed: %s\n" % e)
+            with log_exc(lambda e: "Exception: MedusaShowRestoreJobs failed: %s\n" % e):
+                tabulize(CustomResources.medusa_show_restorejobs(dc, ns),
+                         header='NAME\tCREATED\tFINISHED',
+                         separator='\t',
+                         to=2)
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
+        return super().completion(state)
 
     def help(self, _: ReplState):
-        return f'{MedusaShowRestoreJobs.COMMAND}\t show restores'
+        return f'{MedusaShowRestoreJobs.COMMAND}\t show Medusa restores'