kaqing 2.0.184__py3-none-any.whl → 2.0.227__py3-none-any.whl

adam/commands/export/utils_export.py

@@ -1,12 +1,13 @@
 import io
+import os
 import re
 
 from adam.config import Config
-from adam.pod_exec_result import PodExecResult
+from adam.utils import ExecResult, creating_dir, log2, log_to_pods
 from adam.repl_state import ReplState
-from adam.utils_k8s.cassandra_nodes import CassandraNodes
-from adam.utils_k8s.pods import log_prefix
+from adam.utils_k8s.pods import Pods
 from adam.utils_k8s.statefulsets import StatefulSets
+from adam.utils_local import local_exec
 
 class ImportSpec:
     def __init__(self, table_name: str, session: str = None, files: list[str] = None, importer: str = None):
@@ -196,7 +197,7 @@ class ExportTableStatus:
         statuses: list[ExportTableStatus] = []
 
         status_in_whole = 'done'
-        log_files: list[str] = find_files(pod, namespace, f'{log_prefix()}-{export_session}_*.log*')
+        log_files: list[str] = Pods.find_files(pod, 'cassandra', namespace, f'{table_log_dir(pod, namespace)}/{export_session}_*.log*', remote=log_to_pods())
 
         for log_file in log_files:
             status: ExportTableStatus = ExportTableStatus.from_log_file(pod, namespace, export_session, log_file)
@@ -211,7 +212,7 @@ class ExportTableStatus:
         def get_csv_files_n_table(target_table: str):
             db = f'{copy_session}_{target_table}'
             csv_file = f'{csv_dir()}/{db}/*.csv'
-            csv_files: list[str] = find_files(pod, namespace, csv_file)
+            csv_files: list[str] = Pods.find_files(pod, 'cassandra', namespace, csv_file, remote=log_to_pods())
             if csv_files:
                 table = target_table
                 m = re.match(f'{csv_dir()}/{db}/(.*).csv', csv_files[0])
@@ -221,7 +222,7 @@ class ExportTableStatus:
 
             return csv_files, target_table
 
-        m = re.match(f'{log_prefix()}-{copy_session}_(.*?)\.(.*?)\.log(.*)', log_file)
+        m = re.match(f'{table_log_dir(pod, namespace)}/{copy_session}_(.*?)\.(.*?)\.log(.*)', log_file)
         if m:
             keyspace = m.group(1)
             target_table = m.group(2)
@@ -234,7 +235,11 @@ class ExportTableStatus:
 
             # 4 rows exported to 1 files in 0 day, 0 hour, 0 minute, and 1.335 seconds.
             pattern = 'rows exported to'
-            r: PodExecResult = CassandraNodes.exec(pod, namespace, f"grep '{pattern}' {log_file}", show_out=Config().is_debug(), shell='bash')
+            if log_to_pods():
+                r: ExecResult = Pods.exec(pod, 'cassandra', namespace, f"grep '{pattern}' {log_file}", show_out=Config().is_debug())
+            else:
+                r: ExecResult = local_exec(["grep", pattern, log_file], show_out=Config().is_debug())
+
             if r.exit_code() == 0:
                 csv_files, table = get_csv_files_n_table(target_table)
                 if csv_files:
@@ -246,23 +251,6 @@ class ExportTableStatus:
 
         return ExportTableStatus(None, None, 'unknown')
 
-def csv_dir():
-    return Config().get('export.csv_dir', '/c3/cassandra/tmp')
-
-def find_files(pod: str, namespace: str, pattern: str, mmin: int = 0):
-    if mmin:
-        r = CassandraNodes.exec(pod, namespace, f'find {pattern} -mmin -{mmin}', show_out=Config().is_debug(), shell='bash')
-    else:
-        r = CassandraNodes.exec(pod, namespace, f'find {pattern}', show_out=Config().is_debug(), shell='bash')
-
-    log_files = []
-    for line in r.stdout.split('\n'):
-        line = line.strip(' \r')
-        if line:
-            log_files.append(line)
-
-    return log_files
-
 class GeneratorStream(io.RawIOBase):
     def __init__(self, generator):
         self._generator = generator
@@ -325,6 +313,7 @@ class PodPushHandler:
         state = self.state
 
         if not state.pod:
+            self.pushed = True
             state.push()
 
             if not self.pod:
@@ -340,4 +329,30 @@ class PodPushHandler:
         return False
 
 def state_with_pod(state: ReplState, pod: str = None):
-    return PodPushHandler(state, pod=pod)
+    return PodPushHandler(state, pod=pod)
+
+def fs_exec(pod: str, namespace: str, cmd: str, show_out = False):
+    if log_to_pods():
+        Pods.exec(pod, 'cassandra', namespace, cmd, show_out = show_out)
+    else:
+        os_system_exec(cmd, show_out=show_out)
+
+def os_system_exec(cmd: str, show_out = False):
+    if show_out: log2(cmd)
+
+    os.system(cmd)
+
+def csv_dir():
+    return Config().get('export.csv_dir', '/c3/cassandra/tmp')
+
+def table_log_dir(pod: str, namespace: str):
+    if log_to_pods():
+        return remote_export_log_dir(pod, namespace)
+    else:
+        return export_log_dir()
+
+def export_log_dir():
+    return creating_dir(Config().get('export.log-dir', '/tmp/qing-db/q/export/logs'))
+
+def remote_export_log_dir(pod: str, namespace: str):
+    return Pods.creating_dir(pod, 'cassandra', namespace, Config().get('export.remote.log-dir', '/tmp/q/export/logs'))

adam/commands/{cat.py → fs/cat.py}

@@ -27,10 +27,10 @@ class Cat(Command):
 
         with self.validate(args, state) as (args, state):
             with validate_args(args, state, name='file'):
-                return Devices.device(state).bash(state, state, cmd.split(' '))
+                return Devices.of(state).bash(state, state, cmd.split(' '))
 
     def completion(self, state: ReplState):
-        return super().completion(state, pods=Devices.device(state).pods(state))
+        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'
+    def help(self, state: ReplState):
+        return super().help(state, 'run cat command on the pod', args='<file>')

adam/commands/fs/cat_local.py

@@ -0,0 +1,42 @@
+import os
+
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+from adam.utils_local import find_local_files
+
+class CatLocal(Command):
+    COMMAND = ':cat'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(CatLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return CatLocal.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') as args:
+                os.system(f'cat {args}')
+                log2()
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {n: None for n in find_local_files(file_type='f', max_depth=1)}, auto='jit')
+
+    def help(self, state: ReplState):
+        return super().help(state, 'run cat command on local file system', args='<file>')

adam/commands/{cd.py → fs/cd.py}

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

adam/commands/{download_file.py → fs/download_file.py}

@@ -1,6 +1,8 @@
 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
@@ -29,8 +31,8 @@ class DownloadFile(Command):
 
         with self.validate(args, state) as (args, state):
             with validate_args(args, state, name='file'):
-                to_file = Pods.download_file(state.pod,
-                                             Devices.device(state).default_container(state),
+                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)
@@ -39,9 +41,7 @@ class DownloadFile(Command):
                 return state
 
     def completion(self, state: ReplState):
-        return super().completion(state, pods=Devices.device(state).pods(state))
+        return super().completion(state, lambda: {f: None for f in Devices.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
 
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{DownloadFile.COMMAND} from-file [to-file]\t download file from pod'
+    def help(self, state: ReplState):
+        return super().help(state, 'download file from pod', args='<from-file> [to-file]')

adam/commands/{find_files.py → fs/find_files.py}

@@ -3,10 +3,10 @@ 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
+from adam.utils_local import local_qing_dir
 
 class FindLocalFiles(Command):
-    COMMAND = 'find local'
+    COMMAND = ':find file'
 
     # the singleton pattern
     def __new__(cls, *args, **kwargs):
@@ -28,14 +28,14 @@ class FindLocalFiles(Command):
             cmd = 'find'
 
             if not args:
-                cmd = f'find {local_tmp_dir()}'
+                cmd = f'find {local_qing_dir()}'
             elif len(args) == 1:
-                cmd = f"find {local_tmp_dir()} -name '{args[0]}'"
+                cmd = f"find {local_qing_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)
+            log2(cmd, text_color='gray')
             os.system(cmd)
 
             return state
@@ -47,5 +47,5 @@ class FindLocalFiles(Command):
             '*': None
         })
 
-    def help(self, _: ReplState):
-        return f'{FindLocalFiles.COMMAND} [linux-find-arguments]\t find files from local machine'
+    def help(self, state: ReplState):
+        return super().help(state, 'find files from local machine', args='[linux-find-arguments]')

adam/commands/{find_processes.py → fs/find_processes.py}

@@ -2,8 +2,10 @@ 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.commands.fs.utils_fs import ProcessInfo, find_pids_for_cluster
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2, tabulize
+from adam.utils_k8s.pod_exec_result import PodExecResult
 
 class FindProcesses(Command):
     COMMAND = 'find processes'
@@ -29,26 +31,16 @@ class FindProcesses(Command):
 
         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)
+                with validate_args(args, state, name='words to look for', separator=' ') as keywords:
+                    action = 'find-files'
+                    msg = 'd`Running|Ran ' + action + ' command onto {size} pods'
+                    processes = find_pids_for_cluster(state, keywords)
 
                     pids = []
-                    for l in lines:
-                        pids.append(f'{l[2]}@{l[0]}')
+                    for p in processes:
+                        pids.append(f'{p.pid}@{p.pod}')
 
-                    tabulize(lines, lambda l: '\t'.join(l), header = 'POD\tUSER\tPID\tCMD\tLAST_ARG', separator='\t')
+                    ProcessInfo.tabulize(processes)
                     log2()
                     log2(f'PIDS with {",".join(args)}: {",".join(pids)}')
 
@@ -62,15 +54,15 @@ class FindProcesses(Command):
 
                             pod = pid_n_pod[1]
 
-                            log2(f'@{pod} kill -9 {pid}')
+                            log2(f'@{pod} bash kill -9 {pid}')
 
                             with state_with_pod(state, pod) as state1:
-                                Devices.device(state).bash(state, state1, ['kill', '-9', pid])
+                                Devices.of(state).bash(state, state1, ['kill', '-9', pid])
 
-                    return rs
+                    return state
 
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{FindProcesses.COMMAND} word... [-kill]\t find processes with words'
+    def help(self, state: ReplState):
+        return super().help(state, 'find processes with words  --kill kill matching processes', args='word... [-kill]')

adam/commands/{head.py → fs/head.py}

@@ -26,11 +26,11 @@ class Head(Command):
             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(' '))
+            with validate_args(args, state, name='file') as args:
+                return Devices.of(state).bash(state, state, ['head', '-n', '10', args])
 
     def completion(self, state: ReplState):
-        return super().completion(state, pods=Devices.device(state).pods(state))
+        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'
+    def help(self, state: ReplState):
+        return super().help(state, 'run head command on the pod', args='<file>')

adam/commands/fs/head_local.py

@@ -0,0 +1,46 @@
+import os
+
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+from adam.utils_local import find_local_files
+
+class HeadLocal(Command):
+    COMMAND = ':head'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(HeadLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return HeadLocal.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') as args:
+                cmd = f'head -n 10 {args}'
+                log2(cmd)
+                log2()
+
+                os.system(cmd)
+                log2()
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {n: None for n in find_local_files(file_type='f', max_depth=1)}, auto='jit')
+
+    def help(self, state: ReplState):
+        return super().help(state, 'run head command on local system', args='<file>')

adam/commands/{ls.py → fs/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'
+    def help(self, state: ReplState):
+        return super().help(state, 'list apps, envs, clusters, nodes, pg hosts/databases or export databases', args='[device:]')

adam/commands/fs/ls_local.py

@@ -0,0 +1,40 @@
+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_qing_dir
+
+class LsLocal(Command):
+    COMMAND = ':ls'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(LsLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return LsLocal.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):
+            if args:
+                os.system(f'ls {args}')
+            else:
+                os.system(f'ls {local_qing_dir()}')
+            log2()
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, state: ReplState):
+        return super().help(state, 'list files on local system', args='[dir]')

adam/commands/{pwd.py → fs/pwd.py}

@@ -41,5 +41,5 @@ class Pwd(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{Pwd.COMMAND}\t print current working directories'
+    def help(self, state: ReplState):
+        return super().help(state, 'print current working directories')

adam/commands/fs/rm.py

@@ -0,0 +1,18 @@
+from adam.commands.fs.rm_downloads import RmDownloads
+from adam.commands.fs.rm_logs_local import RmLogsLocal
+from adam.commands.intermediate_command import IntermediateCommand
+
+class RmLocal(IntermediateCommand):
+    COMMAND = ':rm'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RmLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def command(self):
+        return RmLocal.COMMAND
+
+    def cmd_list(self):
+        return [RmDownloads(), RmLogsLocal()]

adam/commands/fs/rm_downloads.py

@@ -0,0 +1,39 @@
+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_downloads_dir
+
+class RmDownloads(Command):
+    COMMAND = ':rm downloads'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RmDownloads, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RmDownloads.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 = f'rm -rf {local_downloads_dir()}/*'
+            log2(cmd)
+            os.system(cmd)
+            log2()
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, state: ReplState):
+        return super().help(state, f'remove all downloads files under {local_downloads_dir()}')

adam/commands/fs/rm_logs.py

@@ -0,0 +1,44 @@
+import os
+
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.utils import log2, log_dir
+from adam.utils_k8s.pods import Pods
+
+class RmLogs(Command):
+    COMMAND = 'rm logs'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RmLogs, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RmLogs.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 = f'rm -rf {self.log_dir()}/*'
+            action = 'rm-logs'
+            msg = 'd`Running|Ran ' + action + ' onto {size} pods'
+            pods = Devices.of(state).pod_names(state)
+            container = Devices.of(state).default_container(state)
+            with Pods.parallelize(pods, len(pods), msg=msg, action=action) as exec:
+                exec.map(lambda pod: Pods.exec(pod, container, state.namespace, cmd, show_out=True, text_color='gray'))
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, state: ReplState):
+        return super().help(state, f'remove all qing log files under {self.log_dir()}')

adam/commands/fs/rm_logs_local.py

@@ -0,0 +1,38 @@
+import os
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2, log_dir
+
+class RmLogsLocal(Command):
+    COMMAND = ':rm logs'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RmLogsLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RmLogsLocal.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 = f'rm -rf {log_dir()}/*'
+            log2(cmd, text_color='gray')
+            os.system(cmd)
+            log2()
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, state: ReplState):
+        return super().help(state, f'remove all qing log files under {log_dir()}')

adam/commands/{shell.py → fs/shell.py}

@@ -37,5 +37,5 @@ class Shell(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{Shell.COMMAND}\t drop down to shell'
+    def help(self, state: ReplState):
+        return super().help(state, 'drop down to shell')

adam/commands/{show → fs}/show_adam.py

@@ -1,7 +1,7 @@
 import sys
 import os
 
-from adam.utils import tabulize, log2
+from adam.utils import tabulize
 
 current_dir = os.path.dirname(os.path.abspath(__file__))
 
@@ -44,5 +44,5 @@ class ShowAdam(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{ShowAdam.COMMAND}\t show kaqing version'
+    def help(self, state: ReplState):
+        return super().help(state, 'show kaqing version')

adam/commands/{show → fs}/show_host.py

@@ -29,5 +29,5 @@ class ShowHost(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{ShowHost.COMMAND}\t show host'
+    def help(self, state: ReplState):
+        return super().help(state, 'show host')