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

adam/commands/intermediate_command.py

@@ -3,7 +3,7 @@ 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
+from adam.utils import tabulize, log, log2
 
 class IntermediateCommand(Command):
     def run(self, cmd: str, state: ReplState):
@@ -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
@@ -21,7 +24,7 @@ class IntermediateCommand(Command):
 
         if state.in_repl:
             if display_help:
-                log(lines_to_tabular([c.help(state) for c in cmds], separator=separator))
+                tabulize(cmds, lambda c: c.help(state), separator=separator)
 
             return 'command-missing'
         else:
@@ -43,7 +46,7 @@ class IntermediateCommand(Command):
         log()
         log('Sub-Commands:')
 
-        log(lines_to_tabular([c.help(ReplState()).replace(f'{cmd} ', '  ', 1) for c in cmd_list], separator=separator))
+        tabulize(cmd_list, lambda c: c.help(ReplState()).replace(f'{cmd} ', '  ', 1), separator=separator)
         if show_cluster_help:
             log()
             ClusterCommandHelper.cluster_help()

adam/commands/ls.py

@@ -35,7 +35,7 @@ class Ls(Command):
             return state
 
     def completion(self, state: ReplState):
-        return Devices.device(state).ls_completion(Ls.COMMAND, state, default = super().completion(state))
+        return super().completion(state, {'&': None}, pods=Devices.device(state).pods(state, '-'))
 
     def help(self, _: ReplState):
         return f'{Ls.COMMAND} [device:]\t list apps, envs, clusters, nodes, pg hosts/databases or export databases'

adam/commands/medusa/medusa_backup.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
@@ -32,23 +33,20 @@ class MedusaBackup(Command):
             ns = state.namespace
             sts = state.sts
             now_dtformat = datetime.now().strftime("%Y-%m-%d.%H.%M.%S")
-            bkname = 'medusa-' + now_dtformat + 'full-backup-' + sts
-            if len(args) == 1:
-                bkname = str(args[0])
+            with validate_args(args, state, default='medusa-' + now_dtformat + 'full-backup-' + sts) as bkname:
+                dc = StatefulSets.get_datacenter(state.sts, ns)
+                if not dc:
+                    return state
+
+                try:
+                    CustomResources.create_medusa_backupjob(bkname, dc, ns)
+                except Exception as e:
+                    log2("Exception: MedusaBackup failed: %s\n" % e)
+                finally:
+                    CustomResources.clear_caches()
 
-            dc = StatefulSets.get_datacenter(state.sts, ns)
-            if not dc:
                 return state
 
-            try:
-                CustomResources.create_medusa_backupjob(bkname, dc, ns)
-            except Exception as e:
-                log2("Exception: MedusaBackup failed: %s\n" % e)
-            finally:
-                CustomResources.clear_caches()
-
-            return state
-
     def completion(self, state: ReplState):
         return super().completion(state)
 

adam/commands/medusa/medusa_restore.py

@@ -4,11 +4,12 @@ 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 lines_to_tabular, log2, log_exc
+from adam.utils import tabulize, log2, log_exc
 
 class MedusaRestore(Command):
     COMMAND = 'restore'
@@ -45,8 +46,11 @@ class MedusaRestore(Command):
                 else:
                     log2('\n* Backup job name is not valid.')
 
-                bklist = [f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '')}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]
-                log2(lines_to_tabular(bklist, 'NAME\tCREATED\tFINISHED', separator='\t'))
+                tabulize(CustomResources.medusa_show_backupjobs(dc, ns),
+                         lambda x: f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '')}",
+                         header='NAME\tCREATED\tFINISHED',
+                         separator='\t',
+                         to=2)
 
             with validate_args(args, state, msg=partial(msg, True)) as bkname:
                 if not (job := CustomResources.medusa_get_backupjob(dc, ns, bkname)):
@@ -64,18 +68,19 @@ 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 super().completion(state, lambda: {id: None for id in medusa_backup_names(state)}, auto_key='medusa.backups')
+        # 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 {}
 

adam/commands/medusa/medusa_show_backupjobs.py

@@ -2,7 +2,7 @@ from adam.commands.command import Command
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils_k8s.custom_resources import CustomResources
-from adam.utils import lines_to_tabular, log2, log_exc
+from adam.utils import tabulize, log_exc
 
 
 class MedusaShowBackupJobs(Command):
@@ -33,12 +33,14 @@ class MedusaShowBackupJobs(Command):
             if not dc:
                 return state
 
-            # try:
             with log_exc(lambda e: "Exception: MedusaShowBackupJobs failed: %s\n" % e):
                 CustomResources.clear_caches()
 
-                bklist = [f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '') if 'status' in x else 'unknown'}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]
-                log2(lines_to_tabular(bklist, 'NAME\tCREATED\tFINISHED', separator='\t'))
+                tabulize(CustomResources.medusa_show_backupjobs(dc, ns),
+                         lambda x: f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '') if 'status' in x else 'unknown'}",
+                         header='NAME\tCREATED\tFINISHED',
+                         separator='\t',
+                         to=2)
 
             return state
 

adam/commands/medusa/medusa_show_restorejobs.py

@@ -2,7 +2,7 @@ from adam.commands.command import Command
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils_k8s.custom_resources import CustomResources
-from adam.utils import lines_to_tabular, log2, log_exc
+from adam.utils import tabulize, log_exc
 
 class MedusaShowRestoreJobs(Command):
     COMMAND = 'show restores'
@@ -33,8 +33,10 @@ class MedusaShowRestoreJobs(Command):
                 return state
 
             with log_exc(lambda e: "Exception: MedusaShowRestoreJobs failed: %s\n" % e):
-                rtlist = CustomResources.medusa_show_restorejobs(dc, ns)
-                log2(lines_to_tabular(rtlist, 'NAME\tCREATED\tFINISHED', separator='\t'))
+                tabulize(CustomResources.medusa_show_restorejobs(dc, ns),
+                         header='NAME\tCREATED\tFINISHED',
+                         separator='\t',
+                         to=2)
 
             return state
 

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.py

@@ -3,11 +3,11 @@ import click
 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_commands import NODETOOL_COMMANDS
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log
-from adam.utils_k8s.statefulsets import StatefulSets
 
 class NodeTool(Command):
     COMMAND = 'nodetool'
@@ -33,17 +33,12 @@ class NodeTool(Command):
 
         with self.validate(args, state) as (args, state):
             with cassandra(state) as pods:
-                pods.nodetool(' '.join(args))
+                pods.nodetool(' '.join(args), status=(args[0] == 'status'))
 
             return state
 
     def completion(self, state: ReplState):
-        if super().completion(state):
-            d = {c: {'&': None} for c in NODETOOL_COMMANDS}
-            return {NodeTool.COMMAND: {'help': None} | d} | \
-                   {f'@{p}': {NodeTool.COMMAND: d} for p in StatefulSets.pod_names(state.sts, state.namespace)}
-
-        return {}
+        return super().completion(state, {c: {'&': None} for c in NODETOOL_COMMANDS}, pods=Devices.device(state).pods(state, '-'))
 
     def help(self, _: ReplState):
         return f'{NodeTool.COMMAND} <sub-command> [&]\t run nodetool with arguments'

adam/commands/param_get.py

@@ -2,7 +2,7 @@ from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.config import Config
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2
+from adam.utils import tabulize, log, log2
 
 class GetParam(Command):
     COMMAND = 'get'
@@ -25,8 +25,7 @@ class GetParam(Command):
 
         with self.validate(args, state) as (args, state):
             def msg():
-                lines = [f'{key}\t{Config().get(key, None)}' for key in Config().keys()]
-                log(lines_to_tabular(lines, separator='\t'))
+                tabulize(Config().keys(), lambda key: f'{key}\t{Config().get(key, None)}', separator='\t')
 
             with validate_args(args, state, msg=msg) as key:
                 if v := Config().get(key, None):

adam/commands/param_set.py

@@ -24,7 +24,7 @@ class SetParam(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            with validate_args(args, state, count_at_least=2, msg=lambda: log2('set <key> <value>')):
+            with validate_args(args, state, exactly=2, msg=lambda: log2('set <key> <value>')):
                 key = args[0]
                 value = args[1]
                 Config().set(key, value)

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': lambda x: ['id'],
+        'hosts': lambda x: ['@' + 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

@@ -3,13 +3,13 @@ import click
 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.psql_completions import psql_completions
+from adam.commands.postgres.postgres_databases import pg_path
+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 .postgres_context import PostgresContext
 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'
@@ -43,10 +43,10 @@ class Postgres(IntermediateCommand):
 
                     if state.in_repl:
                         with postgres(state) as pod:
-                            pod.sql(args, background=backgrounded)
+                            pod.sql(args, backgrounded=backgrounded)
                     elif not self.run_subcommand(cmd, state):
                         with postgres(state) as pod:
-                            pod.sql(args, background=backgrounded)
+                            pod.sql(args, backgrounded=backgrounded)
 
                     return state
 
@@ -55,24 +55,17 @@ class Postgres(IntermediateCommand):
 
     def completion(self, state: ReplState):
         if state.device != state.P:
-            # conflicts with cql completions
             return {}
 
-        leaf = {}
-        session = PostgresContext.apply(state.namespace, state.pg_path)
-        if session.db:
-          if pg_table_names(state.namespace, state.pg_path):
-            leaf = psql_completions(state.namespace, state.pg_path)
-        elif state.pg_path:
-            leaf = {
-                '\h': None,
-                '\l': None,
-            }
-
-        if state.pg_path:
-            return super().completion(state, leaf) | leaf
-        else:
-            return {}
+        with pg_path(state) as (host, database):
+            if database:
+                if pg_table_names(state):
+                    with log_timing('psql_completions'):
+                        return completions_p(state)
+            elif host:
+                return psql0_completions(state)
+
+        return {}
 
     def help(self, _: ReplState):
         return f'<sql-statements> [&]\t run queries on Postgres databases'

adam/commands/postgres/postgres_databases.py

@@ -0,0 +1,270 @@
+import functools
+import re
+import subprocess
+
+from adam.config import Config
+from adam.repl_session import ReplSession
+from adam.repl_state import ReplState
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.secrets import Secrets
+from adam.utils import log2, log_exc
+
+class ConnectionDetails:
+    def __init__(self, state: ReplState, namespace: str, host: str):
+        self.state = state
+        self.namespace = namespace
+        self.host = host
+
+    def endpoint(self):
+        return PostgresDatabases._connection_property(self.state, 'pg.secret.endpoint-key', 'postgres-db-endpoint', host=self.host)
+
+    def port(self):
+        return PostgresDatabases._connection_property(self.state, 'pg.secret.port-key', 'postgres-db-port', host=self.host)
+
+    def username(self):
+        return PostgresDatabases._connection_property(self.state, 'pg.secret.username-key', 'postgres-admin-username', host=self.host)
+
+    def password(self):
+        return PostgresDatabases._connection_property(self.state, 'pg.secret.password-key', 'postgres-admin-password', host=self.host)
+
+class PostgresDatabases:
+    def hosts(state: ReplState, namespace: str = None):
+        if not namespace:
+            namespace = state.namespace
+
+        return [ConnectionDetails(state, namespace, host) for host in PostgresDatabases.host_names(namespace)]
+
+    @functools.lru_cache()
+    def host_names(namespace: str):
+        ss = Secrets.list_secrets(namespace, name_pattern=Config().get('pg.name-pattern', '^{namespace}.*k8spg.*'))
+
+        def excludes(name: str):
+            exs = Config().get('pg.excludes', '.helm., -admin-secret')
+            if exs:
+                for ex in exs.split(','):
+                    if ex.strip(' ') in name:
+                        return True
+
+            return False
+
+        return [s for s in ss if not excludes(s)]
+
+    def databases(state: ReplState, default_owner = False):
+        dbs = []
+        #  List of databases
+        #                  Name                  |  Owner   | Encoding |   Collate   |    Ctype    | ICU Locale | Locale Provider |   Access privileges
+        # ---------------------------------------+----------+----------+-------------+-------------+------------+-----------------+-----------------------
+        #  postgres                              | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |            | libc            |
+        #  stgawsscpsr_c3_c3                     | postgres | UTF8     | C           | C           |            | libc            |
+        #  template1                             | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |            | libc            | =c/postgres          +
+        #                                        |          |          |             |             |            |                 | postgres=CTc/postgres
+        # (48 rows)
+        if r := PostgresDatabases.run_sql(state, '\l', show_out=False):
+            s = 0
+            for line in r.stdout.split('\n'):
+                line: str = line.strip(' \r')
+                if s == 0:
+                    if 'List of databases' in line:
+                        s = 1
+                elif s == 1:
+                    if 'Name' in line and 'Owner' in line and 'Encoding' in line:
+                        s = 2
+                elif s == 2:
+                    if line.startswith('---------'):
+                        s = 3
+                elif s == 3:
+                    groups = re.match(r'^\s*(\S*)\s*\|\s*(\S*)\s*\|.*', line)
+                    if groups and groups[1] != '|':
+                        dbs.append({'name': groups[1], 'owner': groups[2]})
+
+        if default_owner:
+            dbs = [db for db in dbs if db['owner'] == PostgresDatabases.default_owner()]
+
+        return dbs
+
+    def tables(state: ReplState, default_schema = False):
+        dbs = []
+        #                                            List of relations
+        #   Schema  |                            Name                            | Type  |     Owner
+        # ----------+------------------------------------------------------------+-------+---------------
+        #  postgres | c3_2_admin_aclpriv                                         | table | postgres
+        #  postgres | c3_2_admin_aclpriv_a                                       | table | postgres
+        if r := PostgresDatabases.run_sql(state, '\dt', show_out=False):
+            s = 0
+            for line in r.stdout.split('\n'):
+                line: str = line.strip(' \r')
+                if s == 0:
+                    if 'List of relations' in line:
+                        s = 1
+                elif s == 1:
+                    if 'Schema' in line and 'Name' in line and 'Type' in line:
+                        s = 2
+                elif s == 2:
+                    if line.startswith('---------'):
+                        s = 3
+                elif s == 3:
+                    groups = re.match(r'^\s*(\S*)\s*\|\s*(\S*)\s*\|.*', line)
+                    if groups and groups[1] != '|':
+                        dbs.append({'schema': groups[1], 'name': groups[2]})
+
+        if default_schema:
+            dbs = [db for db in dbs if db["schema"] == PostgresDatabases.default_schema()]
+
+        return dbs
+
+    def run_sql(state: ReplState, sql: str, database: str = None, show_out = True, backgrounded = False):
+        if not database:
+            database = PostgresDatabases.database(state)
+        if not database:
+            database = PostgresDatabases.default_db()
+
+        username = PostgresDatabases.username(state)
+        password = PostgresDatabases.password(state)
+        endpoint = PostgresDatabases.endpoint(state)
+
+        if KubeContext.in_cluster():
+            cmd1 = f'env PGPASSWORD={password} psql -h {endpoint} -p {PostgresDatabases.port()} -U {username} {database} --pset pager=off -c'
+            log2(f'{cmd1} "{sql}"')
+            # remove double quotes from the sql argument
+            cmd = cmd1.split(' ') + [sql]
+
+            r = subprocess.run(cmd, capture_output=not backgrounded, text=True)
+            if show_out:
+                log2(r.stdout)
+                log2(r.stderr)
+
+            return r
+        else:
+            pod_name, container_name = PostgresDatabases.pod_and_container(state.namespace)
+            if not pod_name:
+                return
+
+            cmd = f'psql -h {endpoint} -p {PostgresDatabases.port(state)} -U {username} {database} --pset pager=off -c "{sql}"'
+            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}')
+
+            return r
+
+    @functools.lru_cache()
+    def pod_and_container(namespace: str):
+        container_name = Config().get('pg.agent.name', 'ops-pg-agent')
+
+        if Config().get('pg.agent.just-in-time', False):
+            if not PostgresDatabases.deploy_pg_agent(container_name, namespace):
+                return None
+
+        pod_name = container_name
+        try:
+            # try with dedicated pg agent pod name configured
+            Pods.get(namespace, container_name)
+        except:
+            try:
+                # try with the ops pod
+                container_name = Config().get('pod.name', 'ops')
+                pod_name = Pods.get_with_selector(namespace, label_selector = Config().get('pod.label-selector', 'run=ops')).metadata.name
+            except:
+                log2(f"Could not locate {container_name} pod.")
+                return None
+
+        return pod_name, container_name
+
+    def deploy_pg_agent(pod_name: str, namespace: str) -> str:
+        image = Config().get('pg.agent.image', 'seanahnsf/kaqing')
+        timeout = Config().get('pg.agent.timeout', 3600)
+        try:
+            Pods.create(namespace, pod_name, image, ['sleep', f'{timeout}'], env={'NAMESPACE': namespace}, sa_name='c3')
+        except Exception as e:
+            if e.status == 409:
+                if Pods.completed(namespace, pod_name):
+                    with log_exc(lambda e2: "Exception when calling BatchV1Api->create_pod: %s\n" % e2):
+                        Pods.delete(pod_name, namespace)
+                        Pods.create(namespace, pod_name, image, ['sleep', f'{timeout}'], env={'NAMESPACE': namespace}, sa_name='c3')
+
+                        return
+            else:
+                log2("Exception when calling BatchV1Api->create_pod: %s\n" % e)
+
+                return
+
+        Pods.wait_for_running(namespace, pod_name)
+
+        return pod_name
+
+    def undeploy_pg_agent(pod_name: str, namespace: str):
+        Pods.delete(pod_name, namespace, grace_period_seconds=0)
+
+    def endpoint(state: ReplState):
+        return PostgresDatabases._connection_property(state, 'pg.secret.endpoint-key', 'postgres-db-endpoint')
+
+    def port(state: ReplState):
+        return PostgresDatabases._connection_property(state, 'pg.secret.port-key', 'postgres-db-port')
+
+    def username(state: ReplState):
+        return PostgresDatabases._connection_property(state, 'pg.secret.username-key', 'postgres-admin-username')
+
+    def password(state: ReplState):
+        return PostgresDatabases._connection_property(state, 'pg.secret.password-key', 'postgres-admin-password')
+
+    def _connection_property(state: ReplState, config_key: str, default: str, host: str = None, database: str = None):
+        with pg_path(state, host=host, database=database) as (host, _):
+            if not (conn := PostgresDatabases.conn_details(state.namespace, host)):
+                return ''
+
+            key = Config().get(config_key, default)
+            return conn[key] if key in conn else ''
+
+    def default_db():
+        return Config().get('pg.default-db', 'postgres')
+
+    def default_owner():
+        return Config().get('pg.default-owner', 'postgres')
+
+    def default_schema():
+        return Config().get('pg.default-schema', 'postgres')
+
+    def host(state: ReplState):
+        if not state.pg_path:
+            return None
+
+        return state.pg_path.split('/')[0]
+
+    def database(state: ReplState):
+        if not state.pg_path:
+            return None
+
+        tokens = state.pg_path.split('/')
+        if len(tokens) > 1:
+            return tokens[1]
+
+        return None
+
+    @functools.lru_cache()
+    def conn_details(namespace: str, host: str):
+        return Secrets.get_data(namespace, host)
+
+class PostgresPathHandler:
+    def __init__(self, state: ReplState, host: str = None, database: str = None):
+        self.state = state
+        self.host = host
+        self.database = database
+
+    def __enter__(self) -> tuple[str, str]:
+        if self.state and self.state.pg_path:
+            host_n_db = self.state.pg_path.split('/')
+            if not self.host:
+                self.host = host_n_db[0]
+            if not self.database and len(host_n_db) > 1:
+                self.database = host_n_db[1]
+
+        return self.host, self.database
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+def pg_path(state: ReplState, host: str = None, database: str = None):
+    return PostgresPathHandler(state, host=host, database=database)