kaqing 2.0.115__py3-none-any.whl → 2.0.172__py3-none-any.whl

adam/commands/export/show_export_session.py

@@ -0,0 +1,48 @@
+from adam.commands.command import Command
+from adam.commands.export.export_databases import ExportDatabases
+from adam.commands.export.exporter import Exporter
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class ShowExportSession(Command):
+    COMMAND = 'show export session'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowExportSession, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowExportSession.COMMAND
+
+    def required(self):
+        return RequiredState.CLUSTER_OR_POD
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            if not args:
+                if state.in_repl:
+                    log2('Specify export database name.')
+                else:
+                    log2('* Database name is missing.')
+
+                    Command.display_help()
+
+                return 'command-missing'
+
+            ExportDatabases.disply_export_session(state.sts, state.pod, state.namespace, args[0])
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {session: None for session in Exporter.export_session_names(state.sts, state.pod, state.namespace)})
+
+    def help(self, _: ReplState):
+        return f'{ShowExportSession.COMMAND} <export-session-name>\t show export session'

adam/commands/export/show_export_sessions.py

@@ -0,0 +1,44 @@
+from adam.commands.command import Command
+from adam.commands.export.exporter import Exporter
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import lines_to_tabular, log
+from adam.utils_k8s.statefulsets import StatefulSets
+
+class ShowExportSessions(Command):
+    COMMAND = 'show export sessions'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowExportSessions, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowExportSessions.COMMAND
+
+    def required(self):
+        return RequiredState.CLUSTER_OR_POD
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            pod = state.pod
+            if not pod:
+                pod = StatefulSets.pod_names(state.sts, state.namespace)[0]
+
+            sessions: dict[str, str] = Exporter.find_export_sessions(pod, state.namespace)
+            log(lines_to_tabular([f'{session}\t{export_state}' for session, export_state in sorted(sessions.items(), reverse=True)],
+                                    header='EXPORT_SESSION\tSTATUS', separator='\t'))
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{ShowExportSessions.COMMAND}\t list export sessions'

adam/commands/export/utils_export.py

@@ -1,54 +1,122 @@
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import datetime
 import io
 import re
-import time
-from typing import Callable
-import boto3
 
-from adam.commands.cql.cql_utils import cassandra_table_names, run_cql, table_spec
 from adam.config import Config
+from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
-from adam.utils import elapsed_time, log2
-from adam.utils_athena import Athena
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
-from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.pods import log_prefix
+from adam.utils_k8s.statefulsets import StatefulSets
 
-def export_tables(args: list[str], state: ReplState, max_workers = 0):
-    consistency = None
-    specs = None
+class ImportSpec:
+    def __init__(self, session: str, importer: str):
+        self.session = session
+        self.importer = importer
 
-    if args:
-        consistency, specs = ExportSpec.parse_multiple(' '.join(args))
+    def parse_specs(specs_str: str):
+        session: str = None
+        importer: str = None
 
-    if not specs:
-        specs = [ExportSpec(t) for t in cassandra_table_names(state, keyspace=f'{state.namespace}_db')]
+        if specs_str:
+            importer, session = ImportSpec._extract_importer(specs_str.strip(' '))
 
-    if not max_workers:
-        max_workers = Config().action_workers('export', 8)
+        return ImportSpec(session, importer)
 
-    if max_workers > 1 and len(specs) > 1:
-        log2(f'Executing on {len(specs)} Cassandra tables in parallel...')
-        start_time = time.time()
-        try:
-            with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                futures = [executor.submit(export_table, spec, state, True, consistency=consistency) for spec in specs]
-                if len(futures) == 0:
-                    return []
-
-            return [future.result() for future in as_completed(futures)]
-        finally:
-            log2(f"{len(specs)} parallel table export elapsed time: {elapsed_time(start_time)} with {max_workers} workers")
-    else:
-        return [export_table(spec, state, multi_tables=len(specs) > 1, consistency=consistency) for spec in specs]
+    def _extract_importer(spec_str: str) -> tuple[str, str]:
+        importer = None
+        rest = spec_str
+
+        p = re.compile(r"(.*?)to\s+(.*)", re.IGNORECASE)
+        match = p.match(spec_str)
+        if match:
+            rest = match.group(1).strip(' ')
+            importer = match.group(2).strip(' ')
+
+        return importer, rest
+
+class ExportSpec(ImportSpec):
+    def __init__(self, keyspace: str, consistency: str, importer: str, tables: list['ExportTableSpec'], session: str = None):
+        super().__init__(None, importer)
+
+        self.keyspace = keyspace
+        self.consistency = consistency
+        self.tables = tables
+        self.session = session
+
+    def __str__(self):
+        return f'keyspace: {self.keyspace}, consistency: {self.consistency}, importer: {self.importer}, tables: {",".join([t.table for t in self.tables])}, session: {self.session}'
+
+    def __eq__(self, other):
+        if not isinstance(other, ExportSpec):
+            return NotImplemented
+
+        return self.keyspace == other.keyspace and self.tables == other.tables and self.consistency == other.consistency and self.importer == other.importer and self.session == other.session
+
+    def parse_specs(specs_str: str):
+        keyspace: str = None
+        consistency: str = None
+        importer: str = None
+        specs: list[ExportTableSpec] = None
+
+        if specs_str:
+            importer, specs_str = ExportSpec._extract_importer(specs_str.strip(' '))
+            keyspace, specs_str = ExportSpec._extract_keyspace(specs_str)
+            consistency, specs = ExportSpec._extract_consisteny(specs_str)
+
+        return ExportSpec(keyspace, consistency, importer, specs)
+
+    def _extract_keyspace(spec_str: str) -> tuple[str, str]:
+        keyspace = None
+        rest = spec_str
+
+        p = re.compile(r"\s*\*\s+in\s+(\S+)(.*)", re.IGNORECASE)
+        match = p.match(spec_str)
+        if match:
+            keyspace = match.group(1).strip(' ')
+            rest = match.group(2).strip(' ')
+        elif spec_str.startswith('*'):
+            keyspace = '*'
+            rest = spec_str[1:].strip(' ')
+
+        return keyspace, rest
+
+    def _extract_consisteny(spec_str: str) -> tuple[str, list['ExportTableSpec']]:
+        consistency = None
+
+        p = re.compile(r"(.*?)with\s+consistency\s+(.*)", re.IGNORECASE)
+        match = p.match(spec_str)
+        if match:
+            spec_str = match.group(1).strip(' ')
+            consistency = match.group(2)
+
+        if spec_str:
+            p = r",\s*(?![^()]*\))"
+            specs = re.split(p, spec_str)
+
+            return consistency, [ExportTableSpec.parse(spec) for spec in specs]
+
+        return consistency, None
 
-class ExportSpec:
-    def __init__(self, table: str, columns: str = None, target_table: str = None):
+class ExportTableSpec:
+    def __init__(self, keyspace: str, table: str, columns: str = None, target_table: str = None):
+        self.keyspace = keyspace
         self.table = table
         self.columns = columns
         self.target_table = target_table
 
-    def parse(spec_str: str) -> 'ExportSpec':
+    def __str__(self):
+        return f'{self.keyspace}.{self.table}({self.columns}) AS {self.target_table}'
+
+    def __eq__(self, other):
+        if not isinstance(other, ExportTableSpec):
+            return NotImplemented
+
+        return self.keyspace == other.keyspace and self.table == other.table and self.columns == other.columns and self.target_table == other.target_table
+
+    def from_status(status: 'ExportTableStatus'):
+        return ExportTableSpec(status.keyspace, status.table, target_table=status.target_table)
+
+    def parse(spec_str: str) -> 'ExportTableSpec':
         target = None
 
         p = re.compile(r"(.*?)\s+as\s+(.*)", re.IGNORECASE)
@@ -57,148 +125,120 @@ class ExportSpec:
             spec_str = match.group(1)
             target = match.group(2)
 
+        keyspace = None
         table = spec_str
         columns = None
 
-        p = re.compile('(.*?)\((.*)\)')
+        p = re.compile('(.*?)\.(.*?)\((.*)\)')
         match = p.match(spec_str)
         if match:
-            table = match.group(1)
-            columns = match.group(2)
+            keyspace = match.group(1)
+            table = match.group(2)
+            columns = match.group(3)
+        else:
+            p = re.compile('(.*?)\.(.*)')
+            match = p.match(spec_str)
+            if match:
+                keyspace = match.group(1)
+                table = match.group(2)
 
-        return ExportSpec(table, columns, target)
+        return ExportTableSpec(keyspace, table, columns, target)
 
     def __eq__(self, other):
-        if isinstance(other, ExportSpec):
-            return self.table == other.table and self.columns == other.columns and self.target_table == other.target_table
+        if isinstance(other, ExportTableSpec):
+            return self.keyspace == other.keyspace and self.table == other.table and self.columns == other.columns and self.target_table == other.target_table
 
         return False
 
     def __str__(self):
-        return f'{self.table}, {self.columns}, {self.target_table}'
+        return f'{self.keyspace}.{self.table}({self.columns}) as {self.target_table}'
 
-    def parse_multiple(spec_str: str) -> tuple[str, list['ExportSpec']]:
-        consistency = None
+class ExportTableStatus:
+    def __init__(self, keyspace: str, target_table: str, status: str, table: str = None):
+        self.keyspace = keyspace
+        self.target_table = target_table
+        self.status = status
+        self.table = table
 
-        p = re.compile(r"(.*?)with\s+consistency\s+(.*)", re.IGNORECASE)
-        match = p.match(spec_str)
-        if match:
-            spec_str = match.group(1).strip(' ')
-            consistency = match.group(2)
+    def __str__(self):
+        return f'{self.keyspace}.{self.table} as {self.target_table} = {self.status}'
 
-        if spec_str:
-            p = r",\s*(?![^()]*\))"
-            specs = re.split(p, spec_str)
+    def __eq__(self, other):
+        if isinstance(other, ExportTableStatus):
+            return self.keyspace == other.keyspace and self.table == other.table and self.status == other.status and self.target_table == other.target_table
 
-            return consistency, [ExportSpec.parse(spec) for spec in specs]
-
-        return consistency, []
-
-def export_table(spec: ExportSpec, state: ReplState, multi_tables = True, consistency: str = None):
-    table = spec.table
-    columns = spec.columns
-    if not columns:
-        columns = Config().get('export.columns', f'<keys>')
-
-    if columns == '<keys>':
-        columns = ','.join(table_spec(state, table, on_any=True).keys())
-    elif columns == '<row-key>':
-        columns = table_spec(state, table, on_any=True).row_key()
-    elif columns == '*':
-        columns = ','.join([c.name for c in table_spec(state, table, on_any=True).columns])
-
-    if not columns:
-        log2(f'ERROR: Empty columns on {table}.')
-        return table
-
-    athena_table = spec.target_table if spec.target_table else table
-    if '.' in athena_table:
-        athena_table = athena_table.split('.')[-1]
-
-    temp_dir = Config().get('export.temp_dir', '/c3/cassandra/tmp')
-    session = state.export_session
-    create_db = not session
-    if create_db:
-        session = datetime.now().strftime("%Y%m%d%H%M%S")
-        state.export_session = session
-    db = f'export_{session}'
-
-    CassandraNodes.exec(state.pod, state.namespace, f'mkdir -p {temp_dir}/{session}', show_out=not multi_tables, shell='bash')
-    csv_file = f'{temp_dir}/{session}/{table}.csv'
-    succeeded = False
-    try:
-        suppress_ing_log = Config().is_debug() or multi_tables
-        queries = []
-        if consistency:
-            queries.append(f'CONSISTENCY {consistency}')
-        queries.append(f"COPY {table}({columns}) TO '{csv_file}' WITH HEADER = TRUE")
-        ing(f'Dumping table {table}{f" with consistency {consistency}" if consistency else ""}',
-            lambda: run_cql(state, ';'.join(queries), show_out=False),
-            suppress_log=suppress_ing_log)
-
-        def upload_to_s3():
-            bytes = Pods.read_file(state.pod, 'cassandra', state.namespace, csv_file)
-
-            s3 = boto3.client('s3')
-            s3.upload_fileobj(GeneratorStream(bytes), 'c3.ops--qing', f'export/{session}/{athena_table}/{table}.csv')
-
-        ing(f'Uploading to S3', upload_to_s3, suppress_log=suppress_ing_log)
-
-        def create_schema():
-            query = f'CREATE DATABASE IF NOT EXISTS {db};'
-            if Config().is_debug():
-                log2(query)
-            Athena.query(query, 'default')
-
-            query = f'DROP TABLE IF EXISTS {athena_table};'
-            if Config().is_debug():
-                log2(query)
-            Athena.query(query, db)
-
-            # columns = ', '.join([f'{h.strip(" ")} string' for h in header[0].split(',')])
-            athena_columns = ', '.join([f'{c} string' for c in columns.split(',')])
-            query = f'CREATE EXTERNAL TABLE IF NOT EXISTS {athena_table}(\n' + \
-                    f'    {athena_columns})\n' + \
-                        "ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'\n" + \
-                        'WITH SERDEPROPERTIES (\n' + \
-                        '    "separatorChar" = ",",\n' + \
-                        '    "quoteChar"     = "\\"")\n' + \
-                    f"LOCATION 's3://c3.ops--qing/export/{session}/{athena_table}'\n" + \
-                        'TBLPROPERTIES ("skip.header.line.count"="1");'
-            if Config().is_debug():
-                log2(query)
-            try:
-                Athena.query(query, db)
-            except Exception as e:
-                log2(f'*** Failed query:\n{query}')
-                raise e
-
-        ing(f"Creating database {db}" if create_db else f"Creating table {athena_table}", create_schema, suppress_log=suppress_ing_log)
-
-        succeeded = True
-    except Exception as e:
-        log2(e)
-    finally:
-        ing('Cleaning up temporary files',
-            lambda: CassandraNodes.exec(state.pod, state.namespace, f'rm -rf {csv_file}', show_out=False, shell='bash'),
-            suppress_log=suppress_ing_log)
-
-    if succeeded:
-        Athena.clear_cache()
-
-        if not suppress_ing_log:
-            query = f'select * from {athena_table} limit 10'
-            log2(query)
-            Athena.run_query(query, db)
-
-    return table
-
-def ing(msg: str, body: Callable[[], None], suppress_log=False):
-    if not suppress_log:
-        log2(f'{msg}...', nl=False)
-    body()
-    if not suppress_log:
-        log2(' OK')
+        return False
+
+    def from_session(sts: str, pod: str, namespace: str, export_session: str):
+        statuses: list[ExportTableStatus] = []
+
+        status_in_whole = 'done'
+        log_files: list[str] = find_files(pod, namespace, f'{log_prefix()}-{export_session}_*.log*')
+
+        for log_file in log_files:
+            status: ExportTableStatus = ExportTableStatus.from_log_file(pod, namespace, export_session, log_file)
+            statuses.append(status)
+
+            if status.status != 'done':
+                status_in_whole = status.status
+
+        return statuses, status_in_whole
+
+    def from_log_file(pod: str, namespace: str, copy_session: str, log_file: str):
+        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)
+            if csv_files:
+                table = target_table
+                m = re.match(f'{csv_dir()}/{db}/(.*).csv', csv_files[0])
+                if m:
+                    table = m.group(1)
+                return csv_files, table
+
+            return csv_files, target_table
+
+        m = re.match(f'{log_prefix()}-{copy_session}_(.*?)\.(.*?)\.log(.*)', log_file)
+        if m:
+            keyspace = m.group(1)
+            target_table = m.group(2)
+            state = m.group(3)
+            if state == '.pending_import':
+                _, table = get_csv_files_n_table(target_table)
+                return ExportTableStatus(keyspace, target_table, 'pending_import', table)
+            elif state == '.done':
+                return ExportTableStatus(keyspace, target_table, 'done', target_table)
+
+            # 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 r.exit_code() == 0:
+                csv_files, table = get_csv_files_n_table(target_table)
+                if csv_files:
+                    return ExportTableStatus(keyspace, target_table, 'exported', table)
+                else:
+                    return ExportTableStatus(keyspace, target_table, 'imported', target_table)
+            else:
+                return ExportTableStatus(keyspace, target_table, 'export_in_pregress')
+
+        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):
@@ -250,4 +290,25 @@ class GeneratorStream(io.RawIOBase):
 
             data = self._buffer[:size]
             self._buffer = self._buffer[size:]
-            return data
+            return data
+
+class PodHandler:
+    def __init__(self, state: ReplState):
+        self.state = state
+
+    def __enter__(self):
+        state = self.state
+
+        if not state.pod:
+            state.push()
+            state.pod = StatefulSets.pod_names(state.sts, state.namespace)[0]
+
+        return state
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.state.pop()
+
+        return False
+
+def state_with_pod(state: ReplState):
+    return PodHandler(state)

adam/commands/help.py

@@ -28,7 +28,7 @@ class Help(Command):
 
         lines = []
         lines.append('NAVIGATION')
-        lines.append('  a: | c: | l: | p:\t switch to another operational device: App, Cassandra, Audit or Postgres')
+        lines.append('  a: | c: | l: | p: | x:\t switch to another operational device: App, Cassandra, Audit, Postgres or Export')
         lines.extend(section(ReplCommands.navigation()))
         lines.append('CASSANDRA')
         lines.extend(section(ReplCommands.cassandra_ops()))

adam/commands/intermediate_command.py

@@ -0,0 +1,49 @@
+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
+
+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())
+
+    @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:
+                log(lines_to_tabular([c.help(state) for c in cmds], 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:')
+
+        log(lines_to_tabular([c.help(ReplState()).replace(f'{cmd} ', '  ', 1) for c in cmd_list], 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'