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

adam/commands/fs/show_last_results.py

@@ -0,0 +1,39 @@
+from adam.commands.fs.utils_fs import show_last_pod_results, show_last_results
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log_to_pods
+
+class ShowLastResults(Command):
+    COMMAND = 'show last results'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowLastResults, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowLastResults.COMMAND
+
+    def aliases(self):
+        return [':?']
+
+    def run(self, cmd: str, state: ReplState):
+        if not self.args(cmd):
+            return super().run(cmd, state)
+
+        if log_to_pods():
+            show_last_pod_results(state)
+        else:
+            show_last_results(state)
+
+        return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, state: ReplState):
+        return super().help(state, 'show results of last command')

adam/commands/fs/tail.py

@@ -0,0 +1,36 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState, RequiredState
+
+class Tail(Command):
+    COMMAND = 'tail'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Tail, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Tail.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:
+                return Devices.of(state).bash(state, state, ['tail', '-n', '10', args])
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {f: None for f in Devices.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
+
+    def help(self, state: ReplState):
+        return super().help(state, 'run tail command on the pod', args='<file>')

adam/commands/fs/tail_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 TailLocal(Command):
+    COMMAND = ':tail'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(TailLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return TailLocal.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'tail -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 tail command on local file system', args='<file>')

adam/commands/fs/utils_fs.py

@@ -0,0 +1,192 @@
+import itertools
+import os
+import re
+
+from adam.commands.devices.devices import Devices
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.utils import Color, PodLogFile, log2, log_dir, log_to_pods, pod_log_dir, tabulize
+from adam.utils_k8s.pod_exec_result import PodExecResult
+from adam.utils_k8s.pods import Pods
+from adam.utils_local import find_local_files
+from adam.utils_async_job import AsyncJobs
+
+def show_last_results(state: ReplState):
+    last_id, last_command = AsyncJobs.last_command()
+    logs: list[str] = find_local_files(f'{log_dir()}/{last_id}*')
+
+    # /tmp/qing-db/q/logs/16145959.repair-0.err
+    # /tmp/qing-db/q/logs/16145959.repair-0.log
+
+    logs_by_n: dict[str, LogLine] = {}
+    for l in logs:
+        size = str(os.path.getsize(l))
+        n = l[len(f'{log_dir()}/{last_id}'):]
+        if n.startswith('.'):
+            n = n[1:]
+
+        if n.endswith('.log'):
+            n = n[:-4]
+            key = 'out'
+        else:
+            n = n[:-4]
+            key = 'err'
+
+        n = n.split('-')[-1]
+
+        if n not in logs_by_n:
+            logs_by_n[n] = LogLine(n, file=l.replace('.log', '.err'))
+
+        if key == 'out':
+            logs_by_n[n].out = size
+        else:
+            logs_by_n[n].err = size
+
+    if last_command:
+        keywords = last_command.strip(' &').split(' ')
+        if keywords and keywords[0] == 'nodetool':
+            # nodetool -u cs-a7b13e29bd-superuser -pw lDed6uXQAQP72kHOYuML repair &
+            keywords = keywords[-1:]
+
+        for ps in find_pids_for_pod(state.pod, Devices.of(state).default_container(state), state.namespace, keywords, match_last_arg=True):
+            n = ps.pod.split('-')[-1]
+            if n in logs_by_n:
+                logs_by_n[n].merge(ps)
+
+    log2(f'[{last_id}] {last_command}')
+    log2()
+    tabulize(sorted(logs_by_n.keys()), fn=lambda n: logs_by_n[n].table_line(), header=LogLine.header, separator='\t')
+
+def show_last_pod_results(state: ReplState):
+    last_id, last_command = AsyncJobs.last_command()
+
+    container = Devices.of(state).default_container(state)
+
+    if last_command:
+        keywords = last_command.strip(' &').split(' ')
+        if keywords and keywords[0] == 'nodetool':
+            # nodetool -u cs-a7b13e29bd-superuser -pw lDed6uXQAQP72kHOYuML repair &
+            keywords = keywords[-1:]
+
+    action = 'find-files'
+    msg = 'd`Running|Ran ' + action + ' onto {size} pods'
+    pods = Devices.of(state).pod_names(state)
+    with Pods.parallelize(pods, len(pods), msg=msg, action=action) as exec:
+        results: list[LogLine] = exec.map(lambda pod: log_line_for_pod(pod, container, state.namespace, pod_log_dir(), last_id, log_to_pods(), keywords))
+
+        log2(f'[{last_id}] {last_command}')
+        log2()
+        tabulize(sorted(results, key=lambda l: l.ordinal), fn=lambda l: l.table_line(), header=LogLine.header, separator='\t')
+
+def log_line_for_pod(pod: str, container: str, namespace: str, dir: str, last_id: str, remote: bool, keywords: list[str]):
+    logs: list[PodLogFile] = Pods.find_files(pod, container, namespace, f'{dir}/{last_id}*', remote=remote)
+
+    line = LogLine()
+
+    procs = []
+    if keywords:
+        procs = find_pids_for_pod(pod, container, namespace, keywords)
+
+    for log in logs:
+        l = str(log)
+        if l.endswith('.log'):
+            key = 'out'
+        else:
+            key = 'err'
+
+        line.ordinal = log.pod.split('-')[-1]
+        line.file = l.replace('.log', '.err')
+
+        if key == 'out':
+            line.out = log.size
+        else:
+            line.err = log.size
+            for proc in procs:
+                line.merge(proc)
+
+    return line
+
+def find_pids_for_cluster(state: ReplState, keywords: list[str], match_last_arg = False) -> list['ProcessInfo']:
+    container = Devices.of(state).default_container(state)
+
+    action = 'find-procs'
+    msg = 'd`Running|Ran ' + action + ' onto {size} pods'
+    pods = Devices.of(state).pod_names(state)
+    with Pods.parallelize(pods, len(pods), msg=msg, action=action) as exec:
+        r: list[list[ProcessInfo]] = exec.map(lambda pod: find_pids_for_pod(pod, container, state.namespace, keywords, match_last_arg=match_last_arg))
+
+        return list(itertools.chain.from_iterable(r))
+
+def find_pids_for_pod(pod: str, container: str, namespace: str, keywords: list[str], match_last_arg = False) -> list['ProcessInfo']:
+    r: PodExecResult = Pods.exec(pod, container, namespace, _find_procs_command(keywords), text_color=Color.gray)
+
+    return ProcessInfo.from_find_process_results(r, last_arg = keywords[-1] if match_last_arg else None)
+
+def _find_procs_command(keywords: list[str]):
+    regex_pattern = re.compile(r'[^\w\s]')
+
+    greps = []
+    for a in keywords:
+        a = a.strip('"\'').strip(' ')
+
+        if a and not regex_pattern.search(a):
+            greps.append(f'grep -- {a}')
+
+    awk = "awk '{ print $1, $2, $8, $NF }'"
+
+    return f"ps -ef | grep -v grep | {' | '.join(greps)} | {awk}"
+
+class ProcessInfo:
+    header = 'POD\tUSER\tPID\tCMD\tLAST_ARG'
+
+    def __init__(self, user: str, pid: str, cmd: str, last_arg: str, pod: str = None):
+        self.user = user
+        self.pid = pid
+        self.cmd = cmd
+        self.last_arg = last_arg
+        self.pod = pod
+
+    def from_find_process_results(rs: PodExecResult, last_arg: str = None):
+        processes: list[ProcessInfo] = []
+
+        for l in rs.stdout.split('\n'):
+            l = l.strip(' \t\r\n')
+            if not l:
+                continue
+
+            tokens = l.split(' ')
+            if last_arg and tokens[3] != last_arg:
+                continue
+
+            processes.append(ProcessInfo(tokens[0], tokens[1], tokens[2], tokens[3], pod=rs.pod))
+
+        return processes
+
+    def table_line(self):
+        return '\t'.join([self.pod, self.user, self.pid, self.cmd, self.last_arg])
+
+    def tabulize(processes: list['ProcessInfo']):
+        tabulize(processes, lambda p: p.table_line(), header = ProcessInfo.header, separator='\t')
+
+class LogLine(ProcessInfo):
+    header='ORDINAL\tPID\tCMD\tLAST_ARG\tOUT_SIZE\tERR_SIZE\tLOG(ERR)_FILES'
+
+    def __init__(self, ordinal: str = '-', out: str = '-', err: str = '-', file: str = '-', user: str = '-', pid: str = '-', cmd: str = '-', last_arg: str = '-', pod: str = '-'):
+        super().__init__(user, pid, cmd, last_arg, pod)
+        self.ordinal = ordinal
+        self.out = out
+        self.err = err
+        self.file = file
+
+    def __repr__(self):
+        return f"LogLine({', '.join([self.ordinal, self.pid, self.cmd, self.last_arg, self.out, self.err, self.file])})"
+
+    def table_line(self):
+        return '\t'.join([self.ordinal, self.pid, self.cmd, self.last_arg, self.out, self.err, self.file if self.err not in ['-', '0'] else self.file.replace('.err', '.log')])
+
+    def merge(self, process: ProcessInfo):
+        self.user = process.user
+        self.pid = process.pid
+        self.cmd = process.cmd
+        self.last_arg = process.last_arg
+        self.pod = process.pod

adam/commands/help.py

@@ -28,7 +28,7 @@ class Help(Command):
 
         lines = []
         lines.append('NAVIGATION')
-        lines.append('  a: | c: | l: | p: | x:\t switch to another operational device: App, Cassandra, Audit, Postgres or Export')
+        lines.append('  a: | c: | l: | p: | x:\tswitch to another operational device: App, Cassandra, Audit, Postgres or Export')
         lines.extend(section(ReplCommands.navigation()))
         lines.append('CASSANDRA')
         lines.extend(section(ReplCommands.cassandra_ops()))
@@ -52,5 +52,5 @@ class Help(Command):
     def completion(self, _: ReplState):
         return {Help.COMMAND: None}
 
-    def help(self, _: ReplState):
+    def help(self, state: ReplState):
         return None

adam/commands/intermediate_command.py

@@ -12,6 +12,9 @@ class IntermediateCommand(Command):
 
         return self.intermediate_run(cmd, state, args, self.cmd_list())
 
+    def completion(self, state: ReplState):
+        return {}
+
     @abstractmethod
     def cmd_list(self):
         pass

adam/commands/kubectl.py

@@ -34,5 +34,5 @@ class Kubectl(Command):
         return super().completion(state)
 
 
-    def help(self, _: ReplState):
-        return f'{Kubectl.COMMAND} \t run a kubectl command'
+    def help(self, state: ReplState):
+        return super().help(state, 'run a kubectl command', args='[kubectl-args]')

adam/commands/medusa/medusa_backup.py

@@ -50,5 +50,5 @@ class MedusaBackup(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{MedusaBackup.COMMAND}\t start a backup job'
+    def help(self, state: ReplState):
+        return super().help(state, 'start a backup job')

adam/commands/medusa/medusa_restore.py

@@ -1,13 +1,12 @@
-from collections.abc import Callable
 from datetime import datetime
 from functools import partial
 
 from adam.commands import validate_args
 from adam.commands.command import Command, InvalidArgumentsException
+from adam.commands.medusa.utils_medusa import medusa_backup_names
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils_k8s.custom_resources import CustomResources
-from adam.config import Config
 from adam.utils import tabulize, log2, log_exc
 
 class MedusaRestore(Command):
@@ -67,20 +66,7 @@ class MedusaRestore(Command):
                 return state
 
     def completion(self, state: ReplState):
-        if sc := super().completion(state):
-            ns = state.namespace
-            dc: str = StatefulSets.get_datacenter(state.sts, ns)
-            if not dc:
-                return {}
-
-            if Config().get('medusa.restore-auto-complete', False):
-                leaf = {id: None for id in [f"{x['metadata']['name']}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]}
-
-                return super().completion(state, leaf)
-            else:
-                return sc
-
-        return {}
+        return super().completion(state, lambda: {id: None for id in medusa_backup_names(state)}, auto_key='medusa.backups')
 
-    def help(self, _: ReplState):
-        return f'{MedusaRestore.COMMAND}\t start a restore job'
+    def help(self, state: ReplState):
+        return super().help(state, 'start a restore job')

adam/commands/medusa/medusa_show_backupjobs.py

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

adam/commands/medusa/medusa_show_restorejobs.py

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

adam/commands/medusa/utils_medusa.py

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

adam/commands/nodetool/nodetool.py

@@ -0,0 +1,87 @@
+import time
+import click
+
+from adam.commands import extract_options
+from adam.commands.command import Command
+from adam.commands.command_helpers import ClusterOrPodCommandHelper
+from adam.commands.cql.utils_cql import cassandra
+from adam.commands.devices.devices import Devices
+from adam.commands.nodetool.nodetool_commands import NODETOOL_COMMANDS
+from adam.commands.nodetool.utils_nodetool import abort_nodetool_tasks, find_running_nodetool_tasks
+from adam.config import Config
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log, log2, tabulize
+
+class NodeTool(Command):
+    COMMAND = 'nodetool'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(NodeTool, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return NodeTool.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):
+            with extract_options(args, '--force') as (args, forced):
+                with cassandra(state) as pods:
+                    if subcommand := args[0]:
+                        if subcommand in ['compact', 'repair']:
+                            ps = find_running_nodetool_tasks(subcommand, state)
+                            if ps:
+                                tabulize(ps, lambda p: '\t'.join(p), header='POD\tCMD\tID/PID\tLAST_ARG\tREAPER_RUN_STATE', separator='\t')
+                                log2()
+
+                                if forced:
+                                    log2(f"* Found running instances of 'nodetool {subcommand}', aborting existing ones...")
+                                    abort_nodetool_tasks(state, subcommand, ps)
+
+                                    wait_duration = Config().get('nodetool.grace-period-after-abort', 10)
+                                    log2(f"* Scheduling new 'nodetool {subcommand}' in {wait_duration} secs...")
+                                    time.sleep(wait_duration)
+                                else:
+                                    log2(f"* Found running instances of 'nodetool {subcommand}', add --force to abort existing ones.")
+
+                                    return state
+
+                    pods.nodetool(' '.join(args), status=(args[0] == 'status'))
+
+                    return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {c: {'--force': {'&': None}, '&': None} for c in NODETOOL_COMMANDS}, pods=Devices.of(state).pods(state, '-'))
+
+    def help(self, state: ReplState):
+        return super().help(state, 'run nodetool with arguments', args='<sub-command> [&]')
+
+class NodeToolCommandHelper(click.Command):
+    def get_help(self, ctx: click.Context):
+        log(super().get_help(ctx))
+        log()
+        log('Sub-Commands:')
+
+        cmds = ''
+        for c in NODETOOL_COMMANDS:
+            if cmds:
+                cmds += ', '
+            cmds += c
+            if len(cmds) > Config().get('nodetool.commands_in_line', 40):
+                log('  ' + cmds)
+                cmds = ''
+
+        if len(cmds) > 0:
+            log('  ' + cmds)
+        log()
+        ClusterOrPodCommandHelper.cluter_or_pod_help()

adam/commands/nodetool/utils_nodetool.py

@@ -0,0 +1,44 @@
+from adam.commands.devices.devices import Devices
+from adam.commands.export.utils_export import state_with_pod
+from adam.commands.fs.utils_fs import find_pids_for_cluster
+from adam.commands.reaper.utils_reaper import reaper
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.utils import log2
+
+def find_running_nodetool_tasks(subcommand: str, state: ReplState) -> list[list[str]]:
+    lines = []
+    processes = find_pids_for_cluster(state, [subcommand])
+    for p in processes:
+        l = [p.pod, p.cmd, p.pid, p.last_arg]
+        lines.append(l)
+
+    if subcommand == 'repair':
+        with reaper(state) as http:
+            response = http.get('repair_run?state=RUNNING', params={
+                'cluster_name': 'all',
+                'limit': Config().get('reaper.show-runs-batch', 10)
+            })
+
+            runs = response.json()
+            if runs:
+                for r in runs:
+                    l = ['reaper', 'reaper', r['id'], '', r['state']]
+                    lines.append(l)
+
+    return lines
+
+def abort_nodetool_tasks(state: ReplState, subcommand: str, processes: list[list[str]]):
+    for p in processes:
+        pod = p[0]
+        cmd = p[1]
+        id = p[2]
+
+        if pod == 'reaper':
+            with reaper(state) as http:
+                http.put(f'repair_run/{id}/state/ABORTED')
+        elif cmd == subcommand:
+            log2(f'@{pod} bash kill -9 {id}')
+
+            with state_with_pod(state, pod) as state1:
+                    Devices.of(state).bash(state, state1, ['kill', '-9', id])

adam/commands/postgres/completions_p.py

@@ -0,0 +1,22 @@
+from adam.commands.postgres.postgres_databases import PostgresDatabases
+from adam.commands.postgres.utils_postgres import pg_table_names
+from adam.repl_state import ReplState
+from adam.sql.lark_completer import LarkCompleter
+
+def completions_p(state: ReplState):
+    return {
+        '\h': None,
+        '\d': None,
+        '\dt': None,
+        '\du': None
+    } | LarkCompleter(expandables={
+        'tables': lambda x: pg_table_names(state),
+        'columns': ['id'],
+        'hosts': ['@' + PostgresDatabases.pod_and_container(state.namespace)[0]],
+    }, variant=ReplState.P).completions_for_nesting()
+
+def psql0_completions(state: ReplState):
+    return {
+        '\h': None,
+        '\l': None,
+    }

adam/commands/postgres/postgres.py

@@ -4,12 +4,12 @@ from adam.commands import extract_trailing_options, validate_args
 from adam.commands.command import Command
 from adam.commands.intermediate_command import IntermediateCommand
 from adam.commands.postgres.postgres_databases import pg_path
-from adam.commands.postgres.psql_completions import psql_completions
+from adam.commands.postgres.completions_p import psql0_completions, completions_p
 from adam.commands.postgres.utils_postgres import pg_table_names, postgres
 from .postgres_ls import PostgresLs
 from .postgres_preview import PostgresPreview
 from adam.repl_state import ReplState
-from adam.utils import log, log2
+from adam.utils import log, log2, log_timing
 
 class Postgres(IntermediateCommand):
     COMMAND = 'pg'
@@ -55,27 +55,20 @@ class Postgres(IntermediateCommand):
 
     def completion(self, state: ReplState):
         if state.device != state.P:
-            # conflicts with cql completions
             return {}
 
-        leaf = {}
         with pg_path(state) as (host, database):
             if database:
                 if pg_table_names(state):
-                    leaf = psql_completions(state)
+                    with log_timing('psql_completions'):
+                        return completions_p(state)
             elif host:
-                leaf = {
-                    '\h': None,
-                    '\l': None,
-                }
-
-        if state.pg_path:
-            return super().completion(state, leaf) | leaf
-        else:
-            return {}
+                return psql0_completions(state)
+
+        return {}
 
-    def help(self, _: ReplState):
-        return f'<sql-statements> [&]\t run queries on Postgres databases'
+    def help(self, state: ReplState):
+        return super().help(state, 'run queries on Postgres databases', command='[pg] <sql-statements>')
 
 class PostgresCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
@@ -90,7 +83,4 @@ class PostgresPg(Command):
     COMMAND = 'pg'
 
     def command(self):
-        return PostgresPg.COMMAND
-
-    def help(self, _: ReplState):
-        return f'pg <sql-statements>\t run queries on Postgres databases'
+        return PostgresPg.COMMAND

adam/commands/postgres/postgres_databases.py

@@ -144,12 +144,12 @@ class PostgresDatabases:
             env_prefix = f'PGPASSWORD="{password}"'
 
             r = Pods.exec(pod_name, container_name, state.namespace, cmd, show_out=show_out, backgrounded=backgrounded, env_prefix=env_prefix)
-            if r and Config().get('repl.history.push-cat-remote-log-file', True):
-                if r.log_file and ReplSession().prompt_session:
-                    ReplSession().prompt_session.history.append_string(f'@{r.pod} cat {r.log_file}')
+            if r and r.log_file:
+                ReplSession().append_history(f':cat {r.log_file}')
 
             return r
 
+    @functools.lru_cache()
     def pod_and_container(namespace: str):
         container_name = Config().get('pg.agent.name', 'ops-pg-agent')