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

adam/commands/command.py

@@ -1,11 +1,12 @@
 from abc import abstractmethod
+from collections.abc import Callable
 import copy
 import subprocess
 import sys
+from typing import Union
 
-from adam.commands.command_helpers import ClusterCommandHelper
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import is_lambda, lines_to_tabular, log, log2
+from adam.utils import is_lambda, log2
 
 repl_cmds: list['Command'] = []
 
@@ -44,7 +45,10 @@ class Command:
     def required(self) -> RequiredState:
         return None
 
-    def validate_state(self, state: ReplState, show_err=True):
+    def validate(self, args: list[str], state: ReplState, apply = True):
+        return ValidateStateHandler(self, args, state, apply = apply)
+
+    def validate_state(self, state: ReplState, show_err = True):
         return state.validate(self.required(), show_err=show_err)
 
     def help(self, _: ReplState) -> str:
@@ -93,17 +97,50 @@ class Command:
         args.extend(['--help'])
         subprocess.run(args)
 
-    def extract_options(args: list[str], names: list[str]):
-        found: list[str] = []
+    def extract_options(args: list[str], trailing: Union[str, list[str]] = [], sequence: list[str] = [], options: list[str] = []):
+        found_options: list[str] = []
+        found_trailing = None
+        found_sequence = None
+
+        if trailing is None:
+            trailing = []
+        elif isinstance(trailing, str):
+            trailing = [trailing]
+
+        if options is None:
+            options = []
+        elif isinstance(options, str):
+            options = [options]
+
+        if args and trailing:
+            while args[-1] in trailing:
+                found_trailing = True
+                args = args[:-1]
+
+        if args and sequence:
+            args, found_sequence = Command.extract_option_sequence(args, sequence)
 
         new_args: list[str] = []
-        for arg in args:
-            if arg in names:
-                found.append(arg)
-            else:
-                new_args.append(arg)
+        if args:
+            for arg in args:
+                if arg in options:
+                    found_options.append(arg)
+                else:
+                    new_args.append(arg)
+
+        return new_args, found_trailing, found_sequence, found_options
+
+    def extract_option_sequence(args, sequence):
+        len_sub = len(sequence)
+        len_main = len(args)
+        for i in range(len_main - len_sub + 1):
+            if args[i:i+len_sub] == sequence:
+                new_args = copy.copy(args)
+                del new_args[i:i+len_sub]
+
+                return new_args, True
 
-        return new_args, found
+        return new_args, False
 
     def print_chain(cmd: 'Command'):
         print(f'{cmd.command()}', end = '')
@@ -112,31 +149,109 @@ class Command:
             cmd = s
         print()
 
-    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)
+class InvalidStateException(Exception):
+    def __init__(self, state: ReplState):
+        super().__init__(f'Invalid state')
+
+class ValidateStateHandler:
+    def __init__(self, cmd: Command, args: list[str], state: ReplState, apply = True):
+        self.cmd = cmd
+        self.args = args
+        self.state = state
+        self.apply = apply
+
+    def __enter__(self) -> tuple[list[str], ReplState]:
+        state = self.state
+        args = self.args
+        if self.apply:
+            state, args = self.cmd.apply_state(args, state)
+        else:
+            args = args[len(self.cmd.command_tokens()):]
 
-        if state.in_repl:
-            if display_help:
-                log(lines_to_tabular([c.help(state) for c in cmds], separator=separator))
+        if not self.cmd.validate_state(state):
+            raise InvalidStateException(state)
 
-            return 'command-missing'
-        else:
-            # head with the Chain of Responsibility pattern
-            cmds = Command.chain(cmds)
-            if not cmds.run(cmd, state):
-                if display_help:
-                    log2('* Command is missing.')
-                    Command.display_help()
-                return 'command-missing'
-
-        return 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()
+        return args, state
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+class InvalidArgumentsException(Exception):
+    def __init__(self):
+        super().__init__(f'Invalid arguments')
+
+class ValidateArgCountHandler:
+    def __init__(self, args: list[str], state: ReplState, count_at_least: int = 1, name: str = None, msg: Callable[[], None] = None):
+        self.args = args
+        self.state = state
+        self.count_at_least = count_at_least
+        self.name = name
+        self.msg = msg
+
+    def __enter__(self) -> tuple[list[str], ReplState]:
+        if len(self.args) < self.count_at_least:
+            if self.state.in_repl:
+                if self.msg:
+                    self.msg()
+                elif self.name:
+                    log2(f'{self.name} is required.')
+            elif self.name:
+                log2(f'* {self.name} is missing.')
+
+                Command.display_help()
+
+            raise InvalidArgumentsException()
+
+        return ' '.join(self.args)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+class ExtractOptionsHandler:
+    def __init__(self, args: list[str], options: list[str] = None):
+        self.args = args
+        self.options = options
+
+    def __enter__(self) -> tuple[list[str], list[str]]:
+        args, _, _, options = Command.extract_options(self.args, options=self.options)
+        return args, options
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+class ExtractTrailingOptionsHandler:
+    def __init__(self, args: list[str], trailing: list[str] = None):
+        self.args = args
+        self.trailing = trailing
+
+    def __enter__(self) -> tuple[list[str], list[str]]:
+        args, trailing, _, _ = Command.extract_options(self.args, trailing=self.trailing)
+        return args, trailing
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+class ExtractAllOptionsHandler:
+    def __init__(self, args: list[str], trailing: list[str] = None, sequence: list[str] = None, options: list[str] = None):
+        self.args = args
+        self.trailing = trailing
+        self.sequence = sequence
+        self.options = options
+
+    def __enter__(self) -> tuple[list[str], list[str]]:
+        return Command.extract_options(self.args, trailing=self.trailing, sequence=self.sequence, options=self.options)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+class ExtractSequenceOptionsHandler:
+    def __init__(self, args: list[str], sequence: list[str]):
+        self.args = args
+        self.sequence = sequence
+
+    def __enter__(self) -> tuple[list[str], list[str]]:
+        args, _, sequence, _ = Command.extract_options(self.args, sequence=self.sequence)
+        return args, sequence
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False

adam/commands/commands_utils.py

@@ -1,10 +1,9 @@
-from concurrent.futures import ThreadPoolExecutor
 from kubernetes import client
 from typing import List
 
 from adam.checks.check_utils import run_checks
 from adam.columns.columns import Columns, collect_checks
-from adam.commands.issues import Issues
+from adam.utils_issues import IssuesUtils
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.utils_k8s.pods import Pods
 from adam.utils_k8s.statefulsets import StatefulSets
@@ -20,18 +19,10 @@ def show_pods(pods: List[client.V1Pod], ns: str, show_namespace = True, show_hos
     if show_host_id:
         names = [pod.metadata.name for pod in pods]
 
-        def get_host_id_with_pod(pod, ns):
-            return (CassandraNodes.get_host_id(pod, ns), pod)
-
-        def body(executor: ThreadPoolExecutor, pod, ns, show_out):
-            if executor:
-                return executor.submit(get_host_id_with_pod, pod, ns)
-
-            id = CassandraNodes.get_host_id(pod, ns)
-
-            return (id, pod)
-
-        host_ids_by_pod = {pod: id for id, pod in Pods.on_pods(names, ns, body, action='get-host-id', show_out=False)}
+        msg = 'd`Retrieving|Retrived {size} host ids'
+        with Pods.parallelize(names, msg=msg, action = 'get-host-id') as exec:
+            host_pods = exec.map(lambda pod: (CassandraNodes.get_host_id(pod, ns), pod))
+            host_ids_by_pod = {pod: id for id, pod in host_pods}
 
     def line(pod: client.V1Pod):
         pod_cnt = len(pod.status.container_statuses)
@@ -70,10 +61,10 @@ def show_rollout(sts: str, ns: str):
         else:
             log2(f'Cluster has completed rollout {d} ago.')
 
-def show_table(state: ReplState, pods: list[str], cols: str, header: str, show_output=False):
+def show_table(state: ReplState, pods: list[str], cols: str, header: str, show_out=False):
     columns = Columns.create_columns(cols)
 
-    results = run_checks(cluster=state.sts, pod=state.pod, namespace=state.namespace, checks=collect_checks(columns), show_output=show_output)
+    results = run_checks(cluster=state.sts, pod=state.pod, namespace=state.namespace, checks=collect_checks(columns), show_out=show_out)
 
     def line(pod_name: str):
         cells = [c.pod_value(results, pod_name) for c in columns]
@@ -84,4 +75,4 @@ def show_table(state: ReplState, pods: list[str], cols: str, header: str, show_o
 
     log(lines_to_tabular(lines, header, separator=','))
 
-    Issues.show(results, state.in_repl)
+    IssuesUtils.show(results, state.in_repl)

adam/commands/cp.py

@@ -1,7 +1,8 @@
 import click
 import pyperclip
 
-from adam.commands.command import Command
+from adam.commands import validate_args
+from adam.commands.command import Command, InvalidArgumentsException
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
 from adam.commands.cli_commands import CliCommands
 from adam.repl_state import ReplState, RequiredState
@@ -29,47 +30,32 @@ class ClipboardCopy(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
-
-        if len(args) < 1:
-            if state.in_repl:
+        with self.validate(args, state) as (args, state):
+            def display_keys():
                 log2('Key is required.')
                 log2()
                 log2('Keys:')
                 log2(lines_to_tabular([f'{k},{v}' for k, v in CliCommands.values(state, collapse=True).items()], separator=','))
-            else:
-                log2('* Key is missing.')
-                Command.display_help()
 
-            return 'command-missing'
+            with validate_args(args, state, name='key', msg=display_keys) as key:
+                if not key in CliCommands.values(state):
+                    if state.in_repl:
+                        display_keys()
+                    else:
+                        log2('* Invalid key')
+                        Command.display_help()
 
-        key = args[0]
-        if not key in CliCommands.values(state):
-            if state.in_repl:
-                log2('Key is required.')
-                log2()
-                log2('Keys:')
-                log2(lines_to_tabular([f'{k},{v}' for k, v in CliCommands.values(state, collapse=True).items()], separator=','))
-            else:
-                log2('* Invalid key')
-                Command.display_help()
-
-            return 'command-invalid'
+                    raise InvalidArgumentsException()
 
-        value = CliCommands.values(state)[key]
-        pyperclip.copy(value)
-        log2('The following line has been copied to clipboard. Use <Ctrl-V> to use it.')
-        log2(f'  {value}')
+                value = CliCommands.values(state)[key]
+                pyperclip.copy(value)
+                log2('The following line has been copied to clipboard. Use <Ctrl-V> to use it.')
+                log2(f'  {value}')
 
-        return 'value-copied'
+                return state
 
     def completion(self, state: ReplState):
-        if state.sts:
-            return {ClipboardCopy.COMMAND: {key: None for key in CliCommands.values(state).keys()}}
-
-        return {}
+        return super().completion(state, lambda: {key: None for key in CliCommands.values(state).keys()})
 
     def help(self, _: ReplState):
         return f"{ClipboardCopy.COMMAND} <key>\t copy a value to clipboard for conveninence"

adam/commands/cql/cql_completions.py

@@ -1,16 +1,20 @@
-from adam.commands.cql.cql_utils import cassandra_keyspaces, cassandra_table_names
-from adam.commands.export.exporter import Exporter
+from adam.commands.cql.utils_cql import cassandra_keyspaces, cassandra_table_names
+from adam.commands.export.export_sessions import ExportSessions
 from adam.commands.export.export_databases import ExportDatabases
 from adam.config import Config
 from adam.repl_state import ReplState
 from adam.sql.sql_completer import SqlCompleter, SqlVariant
+from adam.utils import log_timing
 
 def cql_completions(state: ReplState) -> dict[str, any]:
     ps = Config().get('cql.alter-tables.gc-grace-periods', '3600,86400,864000,7776000').split(',')
     # warm up caches
-    cassandra_keyspaces(state)
-    cassandra_table_names(state)
-    ExportDatabases.database_names()
+    with log_timing('cassandra_keyspaces'):
+        cassandra_keyspaces(state)
+    with log_timing('cassandra_table_names'):
+        cassandra_table_names(state)
+    with log_timing('ExportDatabases.database_names'):
+        ExportDatabases.database_names()
 
     expandables = {
         'keyspaces': lambda: cassandra_keyspaces(state),
@@ -18,8 +22,8 @@ def cql_completions(state: ReplState) -> dict[str, any]:
             'GC_GRACE_SECONDS': ps
         },
         'export-dbs': lambda: ExportDatabases.database_names(),
-        'export-sessions': lambda: Exporter.export_session_names(state.sts, state.pod, state.namespace),
-        'export-sessions-incomplete': lambda: Exporter.export_session_names(state.sts, state.pod, state.namespace, export_state='pending_import'),
+        'export-sessions': lambda: ExportSessions.export_session_names(state.sts, state.pod, state.namespace),
+        'export-sessions-incomplete': lambda: ExportSessions.export_session_names(state.sts, state.pod, state.namespace, export_state='pending_import'),
     }
 
     return SqlCompleter(

adam/commands/cql/cqlsh.py

@@ -1,12 +1,13 @@
 import click
 
+from adam.commands import extract_trailing_options
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
 from adam.commands.cql.cql_completions import cql_completions
+from adam.commands.cql.utils_cql import cassandra
 from adam.utils_k8s.statefulsets import StatefulSets
-from .cql_utils import run_cql
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import log, log2
+from adam.utils import log
 
 class Cqlsh(Command):
     COMMAND = 'cql'
@@ -30,32 +31,10 @@ class Cqlsh(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
-
-        background = False
-        opts = []
-        cqls = []
-        for index, arg in enumerate(args):
-            if arg.startswith('--'):
-                opts.append(arg)
-            elif index == len(args) -1 and arg == '&':
-                background = True
-            elif arg != '-e':
-                cqls.append(arg)
-        if not cqls:
-            if state.in_repl:
-                log2('Please enter cql statement. e.g. select host_id from system.local')
-            else:
-                log2('* CQL statement is missing.')
-                log2()
-                Command.display_help()
-
-            return 'no-cql'
-
-        cql = ' '.join(cqls)
-        return run_cql(state, cql, opts, show_out=True, background=background)
+        with self.validate(args, state) as (args, state):
+            with extract_trailing_options(args, '&') as (args, backgrounded):
+                with cassandra(state) as pods:
+                    pods.cql(args, background=backgrounded)
 
     def completion(self, state: ReplState) -> dict[str, any]:
         if state.device != state.C:
@@ -63,8 +42,9 @@ class Cqlsh(Command):
             return {}
 
         if state.sts or state.pod:
-            return cql_completions(state) | \
-                   {f'@{p}': cql_completions(state) for p in StatefulSets.pod_names(state.sts, state.namespace)}
+            c = cql_completions(state)
+            return c | \
+                   {f'@{p}': c for p in StatefulSets.pod_names(state.sts, state.namespace)}
 
         return {}
 

adam/commands/cql/{cql_utils.py → utils_cql.py}

@@ -1,20 +1,23 @@
 import functools
 import re
+from typing import Union
 
-from adam.config import Config
+from adam.commands.command import Command
+from adam.commands.commands_utils import show_table
 from adam.utils_k8s.cassandra_clusters import CassandraClusters
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.utils_k8s.secrets import Secrets
 from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
-from adam.utils import log2
+from adam.utils import log2, log_timing, wait_log
+from adam.utils_k8s.statefulsets import StatefulSets
 
 @functools.lru_cache()
 def cassandra_keyspaces(state: ReplState, on_any=True):
     if state.pod:
-        Config().wait_log(f'Inspecting Cassandra Keyspaces on {state.pod}...')
+        wait_log(f'Inspecting Cassandra Keyspaces on {state.pod}...')
     else:
-        Config().wait_log(f'Inspecting Cassandra Keyspaces...')
+        wait_log(f'Inspecting Cassandra Keyspaces...')
 
     r: list[PodExecResult] = run_cql(state, 'describe keyspaces', show_out=False, on_any=on_any)
     if not r:
@@ -44,17 +47,21 @@ def table_spec(state: ReplState, table: str, on_any=False) -> 'TableSpec':
 
     return parse_cql_desc_table(r.stdout if state.pod else r[0].stdout)
 
-def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_single_quotes = False, on_any = False, background=False, log_file=None) -> list[PodExecResult]:
-    user, pw = Secrets.get_user_pass(state.sts if state.sts else state.pod, state.namespace, secret_path='cql.secret')
-    if use_single_quotes:
-        command = f"cqlsh -u {user} -p {pw} {' '.join(opts)} -e '{cql}'"
-    else:
-        command = f'cqlsh -u {user} -p {pw} {" ".join(opts)} -e "{cql}"'
+def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, background=False, log_file=None) -> list[PodExecResult]:
+    if show_query:
+        log2(cql)
 
-    if state.pod:
-        return CassandraNodes.exec(state.pod, state.namespace, command, show_out=show_out, background=background, log_file=log_file)
-    else:
-        return CassandraClusters.exec(state.sts, state.namespace, command, show_out=show_out, action='cql', on_any=on_any, background=background, log_file=log_file)
+    command = None
+    with log_timing('Secrets.get_user_pass'):
+        user, pw = Secrets.get_user_pass(state.sts if state.sts else state.pod, state.namespace, secret_path='cql.secret')
+        if use_single_quotes:
+            command = f"cqlsh -u {user} -p {pw} {' '.join(opts)} -e '{cql}'"
+        else:
+            command = f'cqlsh -u {user} -p {pw} {" ".join(opts)} -e "{cql}"'
+
+    with log_timing(cql):
+        with cassandra(state) as pods:
+            return pods.exec(command, action='cql', show_out=show_out, on_any=on_any, background=background, log_file=log_file)
 
 def parse_cql_desc_tables(out: str):
     # Keyspace data_endpoint_auth
@@ -206,4 +213,129 @@ def parse_cql_desc_table(out: str) -> TableSpec:
         if column.name in pkeys.keys():
             column.key_index = pkeys[column.name]
 
-    return TableSpec(columns)
+    return TableSpec(columns)
+
+class CqlShHandler:
+    def __init__(self, state: ReplState, opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, background=False):
+        self.state = state
+        self.opts = opts
+        self.show_out = show_out
+        self.show_query = show_query
+        self.use_single_quotes = use_single_quotes
+        self.on_any = on_any
+        self.backgroud = background
+
+    def __enter__(self):
+        return self.query
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+    def query(self, args: list[str], log_file: str = None):
+        query: str = args
+        background = self.backgroud
+        show_out = self.show_out
+
+        if isinstance(query, list):
+            opts = []
+            cqls = []
+            for index, arg in enumerate(args):
+                if arg.startswith('--'):
+                    opts.append(arg)
+                elif arg != '-e':
+                    cqls.append(arg)
+            if not cqls:
+                if self.state.in_repl:
+                    log2('Please enter cql statement. e.g. select host_id from system.local')
+                else:
+                    log2('* CQL statement is missing.')
+                    log2()
+                    Command.display_help()
+
+                return 'no-cql'
+
+            query = ' '.join(cqls)
+            show_out = True
+
+        return run_cql(self.state, query, opts=self.opts, show_out=show_out, show_query=self.show_query, use_single_quotes=self.use_single_quotes, on_any=self.on_any, background=background, log_file=log_file)
+
+class CassandraPodService:
+    def __init__(self, handler: 'CassandraExecHandler'):
+        self.handler = handler
+
+    def exec(self, command: str, action='bash', show_out = True, on_any = False, throw_err = False, shell = '/bin/sh', background = False, log_file = None) -> Union[PodExecResult, list[PodExecResult]]:
+        state = self.handler.state
+        pod = self.handler.pod
+
+        if pod:
+            return CassandraNodes.exec(pod, state.namespace, command,
+                                    show_out=show_out, throw_err=throw_err, shell=shell, background=background, log_file=log_file)
+        elif state.sts:
+            return CassandraClusters.exec(state.sts, state.namespace, command, action=action,
+                                        show_out=show_out, on_any=on_any, shell=shell, background=background, log_file=log_file)
+
+        return []
+
+    def cql(self, args: list[str], opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, background=False, log_file: str = None):
+        state = self.handler.state
+        query: str = args
+
+        if isinstance(query, list):
+            opts = []
+            cqls = []
+            for arg in args:
+                if arg.startswith('--'):
+                    opts.append(arg)
+                elif arg != '-e':
+                    cqls.append(arg)
+            if not cqls:
+                if self.state.in_repl:
+                    log2('Please enter cql statement. e.g. select host_id from system.local')
+                else:
+                    log2('* CQL statement is missing.')
+                    log2()
+                    Command.display_help()
+
+                return 'no-cql'
+
+            query = ' '.join(cqls)
+            show_out = True
+
+        return run_cql(state, query, opts=opts, show_out=show_out, show_query=show_query, use_single_quotes=use_single_quotes, on_any=on_any, background=background, log_file=log_file)
+
+    def display_table(self, cols: str, header: str, show_out = True):
+        state = self.handler.state
+
+        if state.pod:
+            show_table(state, [state.pod], cols, header, show_out=show_out)
+        elif state.sts:
+            pod_names = [pod.metadata.name for pod in StatefulSets.pods(state.sts, state.namespace)]
+            show_table(state, pod_names, cols, header, show_out=show_out)
+
+    def nodetool(self, args: str, show_out = True) -> Union[PodExecResult, list[PodExecResult]]:
+        state = self.handler.state
+        pod = self.handler.pod
+
+        user, pw = state.user_pass()
+        command = f"nodetool -u {user} -pw {pw} {args}"
+
+        if pod:
+            return CassandraNodes.exec(pod, state.namespace, command, show_out=show_out)
+        else:
+            return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool', show_out=show_out)
+
+class CassandraExecHandler:
+    def __init__(self, state: ReplState, pod: str = None):
+        self.state = state
+        self.pod = pod
+        if not pod and state.pod:
+            self.pod = state.pod
+
+    def __enter__(self):
+        return CassandraPodService(self)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+def cassandra(state: ReplState, pod: str=None):
+    return CassandraExecHandler(state, pod=pod)

adam/commands/deploy/code_start.py

@@ -25,19 +25,16 @@ class CodeStart(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
-
-        log2('This will support c3/c3 only for demo.')
+        with self.validate(args, state) as (args, state):
+            log2('This will support c3/c3 only for demo.')
 
-        stop_user_codes(state.namespace)
-        try:
-            start_user_code(state.namespace)
-        finally:
             stop_user_codes(state.namespace)
+            try:
+                start_user_code(state.namespace)
+            finally:
+                stop_user_codes(state.namespace)
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
         if state.namespace: