kaqing 2.0.200__py3-none-any.whl → 2.0.211__py3-none-any.whl

adam/utils.py

@@ -1,3 +1,4 @@
+from abc import ABC
 from concurrent.futures import Future, ThreadPoolExecutor
 from contextlib import redirect_stdout
 import copy
@@ -12,7 +13,7 @@ import random
 import string
 import threading
 import traceback
-from typing import Callable, Iterator, TypeVar, Union
+from typing import Callable, Iterator, TextIO, TypeVar, Union
 from dateutil import parser
 import subprocess
 import sys
@@ -128,14 +129,24 @@ def log(s = None):
 
     return True
 
-def log2(s = None, nl = True):
+def log2(s = None, nl = True, file: str = None):
     if not loggable():
         return False
 
     if s:
-        click.echo(s, err=True, nl=nl)
+        if file:
+            with open(file, 'at') as f:
+                f.write(s)
+                if nl:
+                    f.write('\n')
+        else:
+            click.echo(s, err=True, nl=nl)
     else:
-        print(file=sys.stderr)
+        if file:
+            with open(file, 'at') as f:
+                f.write('\n')
+        else:
+            print(file=sys.stderr)
 
     return True
 
@@ -273,28 +284,10 @@ def json_to_csv(json_data: list[dict[any, any]], delimiter: str = ','):
     else:
         return None
 
-def log_to_file(config: dict[any, any]):
-    with log_exc():
-        base = f"/kaqing/logs"
-        os.makedirs(base, exist_ok=True)
-
-        now = datetime.now()
-        timestamp_str = now.strftime("%Y%m%d-%H%M%S")
-        filename = f"{base}/login.{timestamp_str}.txt"
-        with open(filename, 'w') as f:
-            if isinstance(config, dict):
-                try:
-                    json.dump(config, f, indent=4)
-                except:
-                    f.write(config)
-            else:
-                    f.write(config)
-
 def copy_config_file(rel_path: str, module: str, suffix: str = '.yaml', show_out = True):
-    dir = f'{Path.home()}/.kaqing'
+    dir = creating_dir(f'{Path.home()}/.kaqing')
     path = f'{dir}/{rel_path}'
     if not os.path.exists(path):
-        os.makedirs(dir, exist_ok=True)
         module = importlib.import_module(module)
         with open(path, 'w') as f:
             yaml.dump(module.config(), f, default_flow_style=False)
@@ -336,34 +329,42 @@ def in_docker() -> bool:
     return False
 
 class Ing:
-    def __init__(self, msg: str, suppress_log=False):
+    def __init__(self, msg: str, suppress_log=False, job_log: str = None, condition = True):
         self.msg = msg
         self.suppress_log = suppress_log
+        self.job_log = job_log
+        self.condition = condition
 
     def __enter__(self):
+        if not self.condition:
+            return None
+
         if not hasattr(log_state, 'ing_cnt'):
             log_state.ing_cnt = 0
 
         try:
             if not log_state.ing_cnt:
                 if not self.suppress_log and not ConfigHolder().config.is_debug():
-                    log2(f'{self.msg}...', nl=False)
+                    log2(f'{self.msg}...', nl=False, file=self.job_log)
 
             return None
         finally:
             log_state.ing_cnt += 1
 
     def __exit__(self, exc_type, exc_val, exc_tb):
+        if not self.condition:
+            return False
+
         log_state.ing_cnt -= 1
         if not log_state.ing_cnt:
             if not self.suppress_log and not ConfigHolder().config.is_debug():
-                log2(' OK')
+                log2(' OK', file=self.job_log)
 
         return False
 
-def ing(msg: str, body: Callable[[], None]=None, suppress_log=False):
+def ing(msg: str, body: Callable[[], None]=None, suppress_log=False, job_log: str = None, condition = True):
     if not body:
-        return Ing(msg, suppress_log=suppress_log)
+        return Ing(msg, suppress_log=suppress_log, job_log=job_log, condition=condition)
 
     r = None
 
@@ -598,8 +599,11 @@ class ParallelService:
         else:
             return iterator
 
+thread_pools: dict[str, ThreadPoolExecutor] = {}
+thread_pool_lock = threading.Lock()
+
 class ParallelMapHandler:
-    def __init__(self, collection: list, workers: int, samples: int = sys.maxsize, msg: str = None, collect = True):
+    def __init__(self, collection: list, workers: int, samples: int = sys.maxsize, msg: str = None, collect = True, name = None):
         self.collection = collection
         self.workers = workers
         self.executor = None
@@ -611,24 +615,28 @@ class ParallelMapHandler:
             else:
                 self.msg = None
         self.collect = collect
+        self.name = name
 
         self.begin = []
         self.end = []
         self.start_time = None
 
     def __enter__(self):
+        self.start_time = None
+
         self.calc_msgs()
 
         if self.workers > 1 and (not self.size() or self.size()) and self.samples == sys.maxsize:
             self.start_time = time.time()
 
-            self.executor = ThreadPoolExecutor(max_workers=self.workers)
+            self.executor = self.pool()
+            # self.executor = ThreadPoolExecutor(max_workers=self.workers)
             self.executor.__enter__()
 
         return ParallelService(self)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if self.executor:
+        if not self.name and self.executor:
             self.executor.__exit__(exc_type, exc_val, exc_tb)
 
         if self.end:
@@ -636,6 +644,15 @@ class ParallelMapHandler:
 
         return False
 
+    def pool(self, thread_name_prefix: str = None):
+        if not self.name:
+            return ThreadPoolExecutor(max_workers=self.workers)
+
+        if self.name not in thread_pools:
+            thread_pools[self.name] = ThreadPoolExecutor(max_workers=self.workers, thread_name_prefix=thread_name_prefix)
+
+        return thread_pools[self.name]
+
     def size(self):
         if not self.collection:
             return 0
@@ -646,25 +663,28 @@ class ParallelMapHandler:
         if not self.msg:
             return
 
+        self.begin = []
+        self.end = []
         size = self.size()
         offloaded = False
         serially = False
         sampling = False
         if size == 0:
             offloaded = True
-            self.msg = self.msg.replace('{size}', '1')
+            msg = self.msg.replace('{size}', '1')
         elif self.workers > 1 and size > 1 and self.samples == sys.maxsize:
-            self.msg = self.msg.replace('{size}', f'{size}')
+            msg = self.msg.replace('{size}', f'{size}')
         elif self.samples < sys.maxsize:
             sampling = True
+            samples = self.samples
             if self.samples > size:
-                self.samples = size
-            self.msg = self.msg.replace('{size}', f'{self.samples}/{size} sample')
+                samples = size
+            msg = self.msg.replace('{size}', f'{samples}/{size} sample')
         else:
             serially = True
-            self.msg = self.msg.replace('{size}', f'{size}')
+            msg = self.msg.replace('{size}', f'{size}')
 
-        for token in self.msg.split(' '):
+        for token in msg.split(' '):
             if '|' in token:
                 self.begin.append(token.split('|')[0])
                 if not sampling and not serially and not offloaded:
@@ -681,8 +701,19 @@ class ParallelMapHandler:
         else:
             log2(f'{" ".join(self.begin)} with {self.workers} workers...')
 
-def parallelize(collection: list, workers: int = 0, samples = sys.maxsize, msg: str = None, collect = True):
-    return ParallelMapHandler(collection, workers, samples = samples, msg = msg, collect = collect)
+# parallelizers: dict[str, ParallelMapHandler] = {}
+# parallelizer_lock = threading.Lock()
+
+def parallelize(collection: list, workers: int = 0, samples = sys.maxsize, msg: str = None, collect = True, name = None):
+    return ParallelMapHandler(collection, workers, samples = samples, msg = msg, collect = collect, name = name)
+    # if not name:
+    #     return ParallelMapHandler(collection, workers, samples = samples, msg = msg, collect = collect)
+
+    # with parallelizer_lock:
+    #     if name not in parallelizers:
+    #         parallelizers[name] = ParallelMapHandler(collection, workers, samples = samples, msg = msg, collect = collect, name = name)
+
+    # return parallelizers[name]
 
 class OffloadService:
     def __init__(self, handler: 'OffloadHandler'):
@@ -701,23 +732,24 @@ class OffloadService:
             return future
 
 class OffloadHandler(ParallelMapHandler):
-    def __init__(self, max_workers: int, msg: str = None):
-        super().__init__(None, max_workers, msg=msg, collect=False )
+    def __init__(self, max_workers: int, msg: str = None, name: str = None):
+        super().__init__(None, max_workers, msg=msg, collect=False, name=f'offload-{name}')
 
     def __enter__(self):
+        self.start_time = None
         self.calc_msgs()
 
         if self.workers > 1:
-        # if self.workers > 1 and (not self.size() or self.size()) and self.samples == sys.maxsize:
             self.start_time = time.time()
 
-            self.executor = ThreadPoolExecutor(max_workers=self.workers, thread_name_prefix='offload')
+            self.executor = self.pool(thread_name_prefix='offload')
+            # self.executor = ThreadPoolExecutor(max_workers=self.workers, thread_name_prefix='offload')
             self.executor.__enter__()
 
         return OffloadService(self)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if self.executor:
+        if not self.name and self.executor:
             self.executor.__exit__(exc_type, exc_val, exc_tb)
 
         if self.end:
@@ -725,38 +757,33 @@ class OffloadHandler(ParallelMapHandler):
 
         return False
 
-    # def size(self):
-    #     if not self.collection:
-    #         return 0
-
-    #     return len(self.collection)
-
     def calc_msgs(self):
         if not self.msg:
             return
 
+        self.begin = []
+        self.end = []
         size = self.size()
-            # return
 
         offloaded = False
         serially = False
         sampling = False
         if size == 0:
             offloaded = True
-            self.msg = self.msg.replace('{size}', '1')
+            msg = self.msg.replace('{size}', '1')
         elif self.workers > 1 and size > 1 and self.samples == sys.maxsize:
-            self.msg = self.msg.replace('{size}', f'{size}')
+            msg = self.msg.replace('{size}', f'{size}')
         elif self.samples < sys.maxsize:
             sampling = True
-            if self.samples > size:
-                self.samples = size
-            self.msg = self.msg.replace('{size}', f'{self.samples}/{size} sample')
+            samples = self.samples
+            if samples > size:
+                samples = size
+            msg = self.msg.replace('{size}', f'{samples}/{size} sample')
         else:
             serially = True
-            self.msg = self.msg.replace('{size}', f'{size}')
-            # return
+            msg = self.msg.replace('{size}', f'{size}')
 
-        for token in self.msg.split(' '):
+        for token in msg.split(' '):
             if '|' in token:
                 self.begin.append(token.split('|')[0])
                 if not sampling and not serially and not offloaded:
@@ -773,32 +800,39 @@ class OffloadHandler(ParallelMapHandler):
         else:
             log2(f'{" ".join(self.begin)} with {self.workers} workers...')
 
-def offload(max_workers: int = 3, msg: str = None):
-    return OffloadHandler(max_workers, msg = msg)
+def offload(max_workers: int = 3, msg: str = None, name: str = None):
+    return OffloadHandler(max_workers, msg = msg, name = name)
 
 def kaqing_log_file_name(suffix = 'log'):
-    return f"{ConfigHolder().config.get('log-prefix', '/tmp/qing')}-{datetime.now().strftime('%d%H%M%S')}.{suffix}"
+    return f"{log_dir()}/{datetime.now().strftime('%d%H%M%S')}.{suffix}"
+
+def log_dir():
+    return creating_dir(ConfigHolder().config.get('log-dir', '/tmp/qing-db/q/logs'))
 
 class LogFileHandler:
-    def __init__(self, suffix = 'log'):
+    def __init__(self, suffix = 'log', condition=True):
         self.suffix = suffix
+        self.condition = condition
 
     def __enter__(self):
-        self.f = open(kaqing_log_file_name(), 'w')
-        self.f.__enter__()
+        self.f = None
+        if self.condition:
+            self.f = open(kaqing_log_file_name(suffix=self.suffix), 'w')
+            self.f.__enter__()
 
         return self.f
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self.f.__exit__(exc_type, exc_val, exc_tb)
+        if self.f:
+            self.f.__exit__(exc_type, exc_val, exc_tb)
 
-        if ConfigHolder().append_command_history:
-            ConfigHolder().append_command_history(f':sh cat {self.f.name}')
+            if ConfigHolder().append_command_history:
+                ConfigHolder().append_command_history(f':cat {self.f.name}')
 
         return False
 
-def kaqing_log_file(suffix = 'log'):
-    return LogFileHandler(suffix = suffix)
+def kaqing_log_file(suffix = 'log', condition=True):
+    return LogFileHandler(suffix = suffix, condition=condition)
 
 class CommandLog:
     log_file = None
@@ -826,6 +860,23 @@ class CommandLog:
                 pass
 
             if ConfigHolder().append_command_history:
-                ConfigHolder().append_command_history(f':sh cat {CommandLog.log_file.name}')
+                ConfigHolder().append_command_history(f':cat {CommandLog.log_file.name}')
 
             CommandLog.log_file = None
+
+class ExecResult(ABC):
+    def exit_code(self) -> int:
+        pass
+
+    def cat_log_file_cmd(self) -> str:
+        pass
+
+_dirs_created = set()
+
+def creating_dir(dir):
+    if dir not in _dirs_created:
+        _dirs_created.add(dir)
+        if not os.path.exists(dir):
+            os.makedirs(dir, exist_ok=True)
+
+    return dir

adam/utils_k8s/app_clusters.py

@@ -2,7 +2,7 @@ import sys
 from typing import TypeVar
 
 from adam.utils_k8s.app_pods import AppPods
-from adam.pod_exec_result import PodExecResult
+from adam.utils_k8s.pod_exec_result import PodExecResult
 from adam.utils import log, log2
 from adam.utils_k8s.pods import Pods
 from .kube_context import KubeContext
@@ -11,8 +11,15 @@ T = TypeVar('T')
 
 # utility collection on app clusters; methods are all static
 class AppClusters:
-    def exec(pods: list[str], namespace: str, command: str, action: str = 'action',
-             max_workers=0, show_out=True, on_any = False, shell = '/bin/sh', backgrounded = False) -> list[PodExecResult]:
+    def exec(pods: list[str],
+             namespace: str,
+             command: str,
+             action: str = 'action',
+             max_workers=0,
+             show_out=True,
+             on_any = False,
+             shell = '/bin/sh',
+             backgrounded = False) -> list[PodExecResult]:
         samples = 1 if on_any else sys.maxsize
         msg = 'd`Running|Ran ' + action + ' command onto {size} pods'
         with Pods.parallelize(pods, max_workers, samples, msg, action=action) as exec:

adam/utils_k8s/app_pods.py

@@ -4,7 +4,7 @@ from kubernetes import client
 
 from adam.config import Config
 from adam.utils_k8s.pods import Pods
-from adam.pod_exec_result import PodExecResult
+from adam.utils_k8s.pod_exec_result import PodExecResult
 from adam.repl_session import ReplSession
 
 # utility collection on app pods; methods are all static
@@ -25,11 +25,17 @@ class AppPods:
 
         return v1.list_namespaced_pod(namespace, label_selector=label_selector).items
 
-    def exec(pod_name: str, namespace: str, command: str, show_out = True, throw_err = False, shell = '/bin/sh', backgrounded = False) -> PodExecResult:
+    def exec(pod_name: str,
+             namespace: str,
+             command: str,
+             show_out = True,
+             throw_err = False,
+             shell = '/bin/sh',
+             backgrounded = False) -> PodExecResult:
         container = Config().get('app.container-name', 'c3-server')
         r = Pods.exec(pod_name, container, namespace, command, show_out = show_out, throw_err = throw_err, shell = shell, backgrounded = backgrounded)
 
         if r and r.log_file:
-            ReplSession().append_history(f'@{r.pod} cat {r.log_file}')
+            ReplSession().append_history(f':cat {r.log_file}')
 
         return r

adam/utils_k8s/cassandra_clusters.py

@@ -3,7 +3,7 @@ from typing import TypeVar
 
 from adam.config import Config
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
-from adam.pod_exec_result import PodExecResult
+from adam.utils_k8s.pod_exec_result import PodExecResult
 from adam.utils import log, log2
 from adam.utils_k8s.pods import Pods
 from adam.utils_k8s.statefulsets import StatefulSets
@@ -22,16 +22,16 @@ class CassandraClusters:
              shell = '/bin/sh',
              backgrounded = False,
              log_file = None,
-             via_sh = True) -> list[PodExecResult]:
+             history=True) -> list[PodExecResult]:
 
         pods = StatefulSets.pod_names(sts, namespace)
         samples = 1 if on_any else sys.maxsize
-        if via_sh and (backgrounded or command.endswith(' &')) and Config().get('repl.background-process.via-sh', True) and not log_file:
+        if (backgrounded or command.endswith(' &')) and not log_file:
             log_file = Pods.log_file(command)
 
         msg = 'd`Running|Ran ' + action + ' command onto {size} pods'
         with Pods.parallelize(pods, max_workers, samples, msg, action=action) as exec:
-            results: list[PodExecResult] = exec.map(lambda pod: CassandraNodes.exec(pod, namespace, command, False, False, shell, backgrounded, log_file, via_sh=via_sh))
+            results: list[PodExecResult] = exec.map(lambda pod: CassandraNodes.exec(pod, namespace, command, False, False, shell, backgrounded, log_file, history))
             for result in results:
                 if show_out and not Config().is_debug():
                     log(result.command)

adam/utils_k8s/cassandra_nodes.py

@@ -1,18 +1,24 @@
 from adam.config import Config
 from adam.utils_k8s.pods import Pods
 from adam.utils_k8s.secrets import Secrets
-from adam.pod_exec_result import PodExecResult
+from adam.utils_k8s.pod_exec_result import PodExecResult
 from adam.repl_session import ReplSession
 
 # utility collection on cassandra nodes; methods are all static
 class CassandraNodes:
-    def exec(pod_name: str, namespace: str, command: str, show_out = True, throw_err = False, shell = '/bin/sh', backgrounded = False, log_file = None, no_history = False, via_sh = True) -> PodExecResult:
-        r = Pods.exec(pod_name, "cassandra", namespace, command, show_out = show_out, throw_err = throw_err, shell = shell, backgrounded = backgrounded, log_file=log_file, via_sh=via_sh)
+    def exec(pod_name: str,
+             namespace: str,
+             command: str,
+             show_out = True,
+             throw_err = False,
+             shell = '/bin/sh',
+             backgrounded = False,
+             log_file = None,
+             history = True) -> PodExecResult:
+        r = Pods.exec(pod_name, "cassandra", namespace, command, show_out = show_out, throw_err = throw_err, shell = shell, backgrounded = backgrounded, log_file=log_file)
 
-        if not no_history and r and r.log_file:
-            entry = f'@{r.pod} cat {r.log_file}'
-            if Config().get('repl.background-process.via-sh', True):
-                entry = f':sh cat {r.log_file}'
+        if history and r and r.log_file:
+            entry = f':cat {r.log_file}'
 
             ReplSession().append_history(entry)
 

adam/{pod_exec_result.py → utils_k8s/pod_exec_result.py}

@@ -1,8 +1,8 @@
 import yaml
 
-from adam.utils import log_exc
+from adam.utils import ExecResult, log_exc
 
-class PodExecResult:
+class PodExecResult(ExecResult):
     # {
     #   'metadata': {},
     #   'status': 'Failure',
@@ -34,6 +34,12 @@ class PodExecResult:
 
         return code
 
+    def cat_log_file_cmd(self):
+        if self.pod and self.log_file:
+            return f'@{self.pod} cat {self.log_file}'
+
+        return None
+
     def __str__(self):
         return f'{"OK" if self.exit_code() == 0 else self.exit_code()} {self.command}'
 

adam/utils_k8s/pods.py

@@ -13,9 +13,9 @@ from kubernetes.stream.ws_client import ERROR_CHANNEL, WSClient
 from adam.config import Config
 from adam.repl_session import ReplSession
 from adam.utils_k8s.volumes import ConfigMapMount
-from adam.pod_exec_result import PodExecResult
-from adam.utils import GeneratorStream, ParallelMapHandler, log2, debug, log_exc
-from adam.utils_local import local_tmp_dir
+from adam.utils_k8s.pod_exec_result import PodExecResult
+from adam.utils import GeneratorStream, ParallelMapHandler, log2, debug, log_dir, log_exc
+from adam.utils_local import local_downloads_dir
 from .kube_context import KubeContext
 
 from websocket._core import WebSocket
@@ -63,14 +63,13 @@ class Pods:
              backgrounded = False,
              log_file = None,
              interaction: Callable[[any, list[str]], any] = None,
-             env_prefix: str = None,
-             via_sh = True):
+             env_prefix: str = None):
         if _TEST_POD_EXEC_OUTS:
             return _TEST_POD_EXEC_OUTS
 
         show_out = KubeContext.show_out(show_out)
 
-        if via_sh and (backgrounded or command.endswith(' &')) and Config().get('repl.background-process.via-sh', True):
+        if backgrounded or command.endswith(' &'):
             command = command.strip(' &')
 
             log_all_file = None
@@ -82,11 +81,17 @@ class Pods:
             else:
                 log_pod_file = Pods.log_file(command, pod_name=pod_name)
 
+            if env_prefix:
+                command = f'{env_prefix} {command}'
+
             command = command.replace('"', '\\"')
             cmd = f'nohup kubectl exec {pod_name} -c {container} -- {shell} -c "{command} &" > {log_pod_file} 2>&1 &'
             if log_all_file:
                 cmd = f'{cmd} >> {log_all_file}'
 
+            if show_out:
+                log2(cmd)
+
             result = subprocess.run(cmd, capture_output=True, text=True, shell=True)
 
             return PodExecResult(result.stdout, result.stderr, cmd, None, pod=pod_name, log_file=log_pod_file)
@@ -98,22 +103,22 @@ class Pods:
         if env_prefix:
             exec_command = [shell, '-c', f'{env_prefix} {command}']
 
-        if backgrounded or command.endswith(' &'):
-            # should be false for starting a background process
-            tty = False
-
-            if Config().get('repl.background-process.auto-nohup', True):
-                command = command.strip(' &')
-                cmd_name = ''
-                if command.startswith('nodetool '):
-                    cmd_name = f".{'_'.join(command.split(' ')[5:])}"
-
-                if not log_file:
-                    log_file = f'{log_prefix()}-{datetime.now().strftime("%d%H%M%S")}{cmd_name}.log'
-                command = f"nohup {command} > {log_file} 2>&1 &"
-                if env_prefix:
-                    command = f'{env_prefix} {command}'
-                exec_command = [shell, '-c', command]
+        # if backgrounded or command.endswith(' &'):
+        #     # should be false for starting a background process
+        #     tty = False
+
+        #     if Config().get('repl.background-process.auto-nohup', True):
+        #         command = command.strip(' &')
+        #         cmd_name = ''
+        #         if command.startswith('nodetool '):
+        #             cmd_name = f".{'_'.join(command.split(' ')[5:])}"
+
+        #         if not log_file:
+        #             log_file = f'{log_prefix()}-{datetime.now().strftime("%d%H%M%S")}{cmd_name}.log'
+        #         command = f"nohup {command} > {log_file} 2>&1 &"
+        #         if env_prefix:
+        #             command = f'{env_prefix} {command}'
+        #         exec_command = [shell, '-c', command]
 
         k_command = f'kubectl exec {pod_name} -c {container} -n {namespace} -- {shell} -c "{command}"'
         debug(k_command)
@@ -178,10 +183,13 @@ class Pods:
             if groups := re.match(r'.*-(.*)', pod_name):
                 pod_suffix = f'-{groups[1]}'
 
+        return f'{log_dir()}/{Pods.job_id()}{cmd_name}{pod_suffix}.log'
+
+    def job_id(dt: datetime = None):
         if not dt:
             dt = datetime.now()
 
-        return f'{log_prefix()}-{dt.strftime("%d%H%M%S")}{cmd_name}{pod_suffix}.log'
+        return dt.strftime("%d%H%M%S")
 
     def log_file_from_template(log_file: str, pod_name: str):
         pod_suffix = pod_name
@@ -227,14 +235,14 @@ class Pods:
 
     def download_file(pod_name: str, container: str, namespace: str, from_path: str, to_path: str = None):
         if not to_path:
-            to_path = f'{local_tmp_dir()}/{os.path.basename(from_path)}'
+            to_path = f'{local_downloads_dir()}/{os.path.basename(from_path)}'
 
         bytes = Pods.read_file(pod_name, container, namespace, from_path)
         with open(to_path, 'wb') as f:
             for item in GeneratorStream(bytes):
                 f.write(item)
 
-        ReplSession().append_history(f':sh cat {to_path}')
+        ReplSession().append_history(f':cat {to_path}')
 
         return to_path
 
@@ -346,7 +354,4 @@ class Pods:
             log2(' Timed Out')
 
     def completed(namespace: str, pod_name: str):
-        return Pods.get(namespace, pod_name).status.phase in ['Succeeded', 'Failed']
-
-def log_prefix():
-    return Config().get('log-prefix', '/tmp/qing')
+        return Pods.get(namespace, pod_name).status.phase in ['Succeeded', 'Failed']