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

adam/commands/find_files.py

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

@@ -0,0 +1,52 @@
+import click
+import json
+
+from adam.checks.check_result import CheckResult
+from adam.checks.check_utils import run_checks
+from adam.commands import extract_options
+from adam.commands.command import Command
+from adam.commands.commands_utils import kaqing_log_file
+from adam.repl_state import ReplState
+from adam.utils import log2
+
+class GenerateReport(Command):
+    COMMAND = 'generate report'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(GenerateReport, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return GenerateReport.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)
+
+        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)
+                output = CheckResult.report(results)
+
+                if state.in_repl:
+                    with kaqing_log_file() as json_file:
+                        json.dump(output, json_file, indent=2)
+                        log2(f'Report stored in {json_file.name}.')
+                else:
+                    click.echo(json.dumps(output, indent=2))
+
+                return output
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'-s': None})
+
+    def help(self, _: ReplState):
+        return f"{GenerateReport.COMMAND} [-s]\t generate report"

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.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'

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

@@ -3,7 +3,7 @@ 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 lines_to_tabular, log, log2
+from adam.utils import tabulize, log, log2
 
 class IntermediateCommand(Command):
     def run(self, cmd: str, state: ReplState):
@@ -12,6 +12,9 @@ class IntermediateCommand(Command):
 
         return self.intermediate_run(cmd, state, args, self.cmd_list())
 
+    def completion(self, state: ReplState):
+        return {}
+
     @abstractmethod
     def cmd_list(self):
         pass
@@ -21,7 +24,7 @@ class IntermediateCommand(Command):
 
         if state.in_repl:
             if display_help:
-                log(lines_to_tabular([c.help(state) for c in cmds], separator=separator))
+                tabulize(cmds, lambda c: c.help(state), separator=separator)
 
             return 'command-missing'
         else:
@@ -43,7 +46,7 @@ class IntermediateCommand(Command):
         log()
         log('Sub-Commands:')
 
-        log(lines_to_tabular([c.help(ReplState()).replace(f'{cmd} ', '  ', 1) for c in cmd_list], separator=separator))
+        tabulize(cmd_list, lambda c: c.help(ReplState()).replace(f'{cmd} ', '  ', 1), separator=separator)
         if show_cluster_help:
             log()
             ClusterCommandHelper.cluster_help()

adam/commands/login.py

@@ -1,6 +1,5 @@
 import os
 import signal
-import traceback
 
 from adam.app_session import AppSession
 from adam.apps import Apps
@@ -9,8 +8,8 @@ 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'
@@ -49,15 +48,13 @@ class Login(Command):
                     username = args[0]
 
                 login: IdpLogin = None
-                try:
+                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())
 
                 log(f'IDP_TOKEN={login.ser() if login else ""}')
 

adam/commands/ls.py

@@ -30,12 +30,12 @@ class Ls(Command):
                     state = copy.copy(state)
                     state.device = arg.replace(':', '')
 
-            Devices.device(state).ls(cmd, state)
+            Devices.of(state).ls(cmd, 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.of(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_backup.py

@@ -1,6 +1,6 @@
 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
@@ -33,22 +33,19 @@ class MedusaBackup(Command):
             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)
-            finally:
-                CustomResources.clear_caches()
+            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 state
+                return state
 
     def completion(self, state: ReplState):
         return super().completion(state)

adam/commands/medusa/medusa_restore.py

@@ -1,11 +1,13 @@
 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'
@@ -35,49 +37,36 @@ class MedusaRestore(Command):
             if not dc:
                 return state
 
-            if len(args) == 1:
-                bkname = args[0]
-                job = CustomResources.medusa_get_backupjob(dc, ns, bkname)
-                if not job:
+            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.')
-                    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'))
 
-                    return state
+                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)
+
+            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()
 
                 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)
+                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
+                return state
 
     def completion(self, state: ReplState):
-        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 {}
+        return super().completion(state, lambda: {id: None for id in medusa_backup_names(state)}, auto_key='medusa.backups')
 
     def help(self, _: ReplState):
         return f'{MedusaRestore.COMMAND}\t start a restore job'

adam/commands/medusa/medusa_show_backupjobs.py

@@ -2,7 +2,7 @@ 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 lines_to_tabular, log2
+from adam.utils import tabulize, log_exc
 
 
 class MedusaShowBackupJobs(Command):
@@ -33,14 +33,14 @@ class MedusaShowBackupJobs(Command):
             if not dc:
                 return state
 
-            try:
-                # always show latest
+            with log_exc(lambda e: "Exception: MedusaShowBackupJobs failed: %s\n" % e):
                 CustomResources.clear_caches()
 
-                bklist = [f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '') if 'status' in x else 'unknown'}" 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)
+                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 state
 

adam/commands/medusa/medusa_show_restorejobs.py

@@ -2,7 +2,7 @@ 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 lines_to_tabular, log2
+from adam.utils import tabulize, log_exc
 
 class MedusaShowRestoreJobs(Command):
     COMMAND = 'show restores'
@@ -32,11 +32,11 @@ class MedusaShowRestoreJobs(Command):
             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
 

adam/commands/medusa/utils_medusa.py

@@ -0,0 +1,15 @@
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.utils_k8s.custom_resources import CustomResources
+from adam.utils_k8s.statefulsets import StatefulSets
+
+def medusa_backup_names(state: ReplState, warm=False):
+    if warm and (auto := Config().get('medusa.restore-auto-complete', 'off')) in ['off', 'jit', 'lazy']:
+        return {}
+
+    ns = state.namespace
+    dc: str = StatefulSets.get_datacenter(state.sts, ns)
+    if not dc:
+        return {}
+
+    return {id: None for id in [f"{x['metadata']['name']}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]}

adam/commands/nodetool.py

@@ -3,11 +3,11 @@ 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.nodetool_commands import NODETOOL_COMMANDS
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log
-from adam.utils_k8s.statefulsets import StatefulSets
 
 class NodeTool(Command):
     COMMAND = 'nodetool'
@@ -33,17 +33,12 @@ class NodeTool(Command):
 
         with self.validate(args, state) as (args, state):
             with cassandra(state) as pods:
-                pods.nodetool(' '.join(args))
+                pods.nodetool(' '.join(args), status=(args[0] == 'status'))
 
             return state
 
     def completion(self, state: ReplState):
-        if super().completion(state):
-            d = {c: {'&': None} for c in NODETOOL_COMMANDS}
-            return {NodeTool.COMMAND: {'help': None} | d} | \
-                   {f'@{p}': {NodeTool.COMMAND: d} for p in StatefulSets.pod_names(state.sts, state.namespace)}
-
-        return {}
+        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'

adam/commands/os/cat.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 Cat(Command):
+    COMMAND = 'cat'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Cat, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Cat.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'{Cat.COMMAND} file [&]\t run cat command on the pod'

adam/commands/os/download_file.py

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