kaqing 2.0.110__py3-none-any.whl → 2.0.214__py3-none-any.whl

adam/commands/issues.py

@@ -1,75 +0,0 @@
-from adam.checks.check_result import CheckResult
-from adam.checks.check_utils import run_checks
-from adam.checks.issue import Issue
-from adam.commands.command import Command
-from adam.repl_session import ReplSession
-from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2
-
-class Issues(Command):
-    COMMAND = 'issues'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Issues, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Issues.COMMAND
-
-    def required(self):
-        return ReplState.NON_L
-
-    def run(self, cmd: str, state: ReplState):
-        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
-
-        args, show = Command.extract_options(args, ['-s', '--show'])
-
-        results = run_checks(state.sts, state.namespace, state.pod, show_output=show)
-
-        issues = CheckResult.collect_issues(results)
-        Issues.show_issues(issues, in_repl=state.in_repl)
-
-        return issues if issues else 'issues'
-
-    def show(check_results: list[CheckResult], in_repl = False):
-        Issues.show_issues(CheckResult.collect_issues(check_results), in_repl=in_repl)
-
-    def show_issues(issues: list[Issue], in_repl = False):
-        if not issues:
-            log2('No issues found.')
-        else:
-            suggested = 0
-            log2(f'* {len(issues)} issues found.')
-            lines = []
-            for i, issue in enumerate(issues, start=1):
-                lines.append(f"{i}||{issue.category}||{issue.desc}")
-                lines.append(f"||statefulset||{issue.statefulset}@{issue.namespace}")
-                lines.append(f"||pod||{issue.pod}@{issue.namespace}")
-                if issue.details:
-                    lines.append(f"||details||{issue.details}")
-
-                if issue.suggestion:
-                    lines.append(f'||suggestion||{issue.suggestion}')
-                    if in_repl:
-                        ReplSession().prompt_session.history.append_string(issue.suggestion)
-                        suggested += 1
-            log(lines_to_tabular(lines, separator='||'))
-            if suggested:
-                log2()
-                log2(f'* {suggested} suggested commands are added to history. Press <Up> arrow to access them.')
-
-    def completion(self, _: ReplState):
-        return {Issues.COMMAND: None}
-
-    def help(self, _: ReplState):
-        return f'{Issues.COMMAND}\t find all issues'

adam/commands/logs.py

@@ -1,40 +0,0 @@
-from adam.commands.command import Command
-from adam.config import Config
-from adam.utils_k8s.cassandra_nodes import CassandraNodes
-from adam.repl_state import ReplState, RequiredState
-
-class Logs(Command):
-    COMMAND = 'logs'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Logs, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Logs.COMMAND
-
-    def required(self):
-        return RequiredState.POD
-
-    def run(self, cmd: str, state: ReplState):
-        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
-
-        path = Config().get('logs.path', '/c3/cassandra/logs/system.log')
-        return CassandraNodes.exec(state.pod, state.namespace, f'cat {path}')
-
-    def completion(self, _: ReplState):
-        # available only on cli
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{Logs.COMMAND}\t show cassandra system log'

adam/commands/ls.py

@@ -1,146 +0,0 @@
-import copy
-
-from adam.commands.command import Command
-from adam.commands.commands_utils import show_pods, show_rollout
-from adam.commands.cql.cqlsh import Cqlsh
-from adam.commands.postgres.postgres_utils import pg_database_names, pg_table_names
-from adam.commands.postgres.postgres_context import PostgresContext
-from adam.config import Config
-from adam.utils_k8s.custom_resources import CustomResources
-from adam.utils_k8s.ingresses import Ingresses
-from adam.utils_k8s.kube_context import KubeContext
-from adam.utils_k8s.statefulsets import StatefulSets
-from adam.pod_exec_result import PodExecResult
-from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2
-from adam.apps import Apps
-from adam.utils_audits import Audits
-
-class Ls(Command):
-    COMMAND = 'ls'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Ls, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Ls.COMMAND
-
-    def run(self, cmd: str, state: ReplState):
-        if not(args := self.args(cmd)):
-            return super().run(cmd, state)
-
-        state, args = self.apply_state(args, state)
-
-        if len(args) > 0:
-            arg = args[0]
-            if arg in ['p:', 'c:'] and arg != f'{state.device}:':
-                state = copy.copy(state)
-                state.device = arg.replace(':', '')
-
-        if state.device == ReplState.P:
-            if state.pg_path:
-                pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
-                if pg.db:
-                    self.show_pg_tables(pg)
-                else:
-                    self.show_pg_databases(pg)
-            else:
-                self.show_pg_hosts(state)
-        elif state.device == ReplState.A:
-            if state.app_env:
-                def line(n: str, ns: str):
-                    host = Ingresses.get_host(Config().get('app.login.ingress', '{app_id}-k8singr-appleader-001').replace('{app_id}', f'{ns}-{n}'), ns)
-                    if not host:
-                        return None
-
-                    endpoint = Config().get('app.login.url', 'https://{host}/{env}/{app}').replace('{host}', host).replace('{env}', state.app_env).replace('{app}', 'c3')
-                    if not endpoint:
-                        return None
-
-                    return f"{n.split('-')[1]},{Ingresses.get_host(f'{ns}-{n}-k8singr-appleader-001', ns)},{endpoint}"
-
-                svcs = [l for l in [line(n, ns) for n, ns in Apps.apps(state.app_env)] if l]
-
-                log(lines_to_tabular(svcs, 'APP,HOST,ENDPOINT', separator=','))
-            else:
-                svcs = [n for n, ns in Apps.envs()]
-
-                log(lines_to_tabular(svcs, 'ENV', separator=','))
-        elif state.device == ReplState.L:
-            self.show_audit_log_tables()
-        else:
-            if state.pod:
-                r: PodExecResult = Cqlsh().run(f'cql describe tables', state)
-                if r.stderr:
-                    log(r.stderr)
-                log(r.stdout)
-            elif state.sts and state.namespace:
-                show_pods(StatefulSets.pods(state.sts, state.namespace), state.namespace, show_namespace=not KubeContext.in_cluster_namespace())
-                show_rollout(state.sts, state.namespace)
-            else:
-                self.show_statefulsets()
-
-        return state
-
-    def show_statefulsets(self):
-        ss = StatefulSets.list_sts_names()
-        if len(ss) == 0:
-            log2('No Cassandra clusters found.')
-            return
-
-        app_ids = CustomResources.get_app_ids()
-        list = []
-        for s in ss:
-            cr_name = CustomResources.get_cr_name(s)
-            app_id = 'Unknown'
-            if cr_name in app_ids:
-                app_id = app_ids[cr_name]
-            list.append(f"{s} {app_id}")
-
-        header = 'STATEFULSET_NAME@NAMESPACE APP_ID'
-        if KubeContext.in_cluster_namespace():
-            header = 'STATEFULSET_NAME APP_ID'
-        log(lines_to_tabular(list, header))
-
-    def show_pg_hosts(self, state: ReplState):
-        if state.namespace:
-            def line(pg: PostgresContext):
-                return f'{pg.path()},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
-
-            lines = [line(PostgresContext.apply(state.namespace, pg)) for pg in PostgresContext.hosts(state.namespace)]
-
-            log(lines_to_tabular(lines, 'NAME,ENDPOINT,USERNAME,PASSWORD', separator=','))
-        else:
-            def line(pg: PostgresContext):
-                return f'{pg.path()},{pg.namespace},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
-
-            lines = [line(PostgresContext.apply(state.namespace, pg)) for pg in PostgresContext.hosts(state.namespace)]
-
-            log(lines_to_tabular(lines, 'NAME,NAMESPACE,ENDPOINT,USERNAME,PASSWORD', separator=','))
-
-    def show_pg_databases(self, pg: PostgresContext):
-        log(lines_to_tabular(pg_database_names(pg.namespace, pg.path()), 'DATABASE', separator=','))
-
-    def show_pg_tables(self, pg: PostgresContext):
-        log(lines_to_tabular(pg_table_names(pg.namespace, pg.path()), 'NAME', separator=','))
-
-    def show_audit_log_tables(self):
-        log(lines_to_tabular(Audits.audit_table_names(), 'NAME', separator=','))
-
-    def completion(self, state: ReplState):
-        if state.device == ReplState.C:
-            if state.pod:
-                return super().completion(state)
-            elif not state.sts:
-                return {Ls.COMMAND: {n: None for n in StatefulSets.list_sts_names()}}
-
-        return super().completion(state)
-
-    def help(self, _: ReplState):
-        return f'{Ls.COMMAND} [device:]\t list apps, envs, clusters, nodes, pg hosts or pg databases'

adam/commands/postgres/postgres_context.py

@@ -1,239 +0,0 @@
-import functools
-import re
-import subprocess
-
-from adam.config import Config
-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
-
-class PostgresContext:
-    def apply(namespace: str, path: str, arg: str = None) -> 'PostgresContext':
-        context = PostgresContext(namespace, path)
-
-        if arg:
-            if arg == '..':
-                if context.db:
-                    context.db = None
-                else:
-                    context.host = None
-            else:
-                tks = arg.split('@')
-                if not context.host:
-                    context.host = tks[0]
-                else:
-                    context.db = tks[0]
-
-                if not namespace and tks[1]:
-                    context.namespace = tks[1]
-
-        return context
-
-    def __init__(self, ns: str, path: str):
-        self.namespace = ns
-        self.conn_details = None
-        self.host = None
-        self.db = None
-
-        if path:
-            tks = path.split('/')
-            hn = tks[0].split('@')
-            self.host = hn[0]
-            if len(hn) > 1 and not ns:
-                self.namespace = hn[1]
-
-            if len(tks) > 1:
-                self.db = tks[1]
-
-    def path(self):
-        if not self.host:
-            return None
-
-        d = self.host
-        if not self.db:
-            return d
-
-        return f'{self.host}/{self.db}'
-
-    def hosts(ns: str):
-        return PostgresContext.hosts_for_namespace(ns)
-
-    @functools.lru_cache()
-    def hosts_for_namespace(ns: str):
-        ss = Secrets.list_secrets(ns, 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(self):
-        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 := self.run_sql('\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]})
-
-        return dbs
-
-    def tables(self):
-        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 := self.run_sql('\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]})
-
-        return dbs
-
-    def run_sql(self, sql: str, show_out = True):
-        db = self.db if self.db else PostgresContext.default_db()
-
-        if KubeContext.in_cluster():
-            cmd1 = f'env PGPASSWORD={self.password()} psql -h {self.endpoint()} -p {self.port()} -U {self.username()} {db} --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=True, text=True)
-            if show_out:
-                log2(r.stdout)
-                log2(r.stderr)
-
-            return r
-        else:
-            ns = self.namespace
-            pod_name = Config().get('pg.agent.name', 'ops-pg-agent')
-
-            if Config().get('pg.agent.just-in-time', False):
-                if not PostgresContext.deploy_pg_agent(pod_name, ns):
-                    return
-
-            real_pod_name = pod_name
-            try:
-                # try with dedicated pg agent pod name configured
-                Pods.get(ns, pod_name)
-            except:
-                try:
-                    # try with the ops pod
-                    pod_name = Config().get('pod.name', 'ops')
-                    real_pod_name = Pods.get_with_selector(ns, label_selector = Config().get('pod.label-selector', 'run=ops')).metadata.name
-                except:
-                    log2(f"Could not locate {pod_name} pod.")
-                    return None
-
-            cmd = f'PGPASSWORD="{self.password()}" psql -h {self.endpoint()} -p {self.port()} -U {self.username()} {db} --pset pager=off -c "{sql}"'
-
-            return Pods.exec(real_pod_name, pod_name, ns, cmd, show_out=show_out)
-
-    def deploy_pg_agent(pod_name: str, ns: str) -> str:
-        image = Config().get('pg.agent.image', 'seanahnsf/kaqing')
-        timeout = Config().get('pg.agent.timeout', 3600)
-        try:
-            Pods.create(ns, pod_name, image, ['sleep', f'{timeout}'], env={'NAMESPACE': ns}, sa_name='c3')
-        except Exception as e:
-            if e.status == 409:
-                if Pods.completed(ns, pod_name):
-                    try:
-                        Pods.delete(pod_name, ns)
-                        Pods.create(ns, pod_name, image, ['sleep', f'{timeout}'], env={'NAMESPACE': ns}, sa_name='c3')
-                    except Exception as e2:
-                        log2("Exception when calling BatchV1Api->create_pod: %s\n" % e2)
-
-                        return
-            else:
-                log2("Exception when calling BatchV1Api->create_pod: %s\n" % e)
-
-                return
-
-        Pods.wait_for_running(ns, pod_name)
-
-        return pod_name
-
-    def undeploy_pg_agent(pod_name: str, ns: str):
-        Pods.delete(pod_name, ns, grace_period_seconds=0)
-
-    def endpoint(self):
-        if not self.conn_details:
-            self.conn_details = Secrets.get_data(self.namespace, self.host)
-
-        endpoint_key = Config().get('pg.secret.endpoint-key', 'postgres-db-endpoint')
-
-        return self.conn_details[endpoint_key] if endpoint_key in self.conn_details else ''
-
-    def port(self):
-        if not self.conn_details:
-            self.conn_details = Secrets.get_data(self.namespace, self.host)
-
-        port_key = Config().get('pg.secret.port-key', 'postgres-db-port')
-
-        return  self.conn_details[port_key] if port_key in self.conn_details else ''
-
-    def username(self):
-        if not self.conn_details:
-            self.conn_details = Secrets.get_data(self.namespace, self.host)
-
-        username_key = Config().get('pg.secret.username-key', 'postgres-admin-username')
-
-        return  self.conn_details[username_key] if username_key in self.conn_details else ''
-
-    def password(self):
-        if not self.conn_details:
-            self.conn_details = Secrets.get_data(self.namespace, self.host)
-
-        password_key = Config().get('pg.secret.password-key', 'postgres-admin-password')
-
-        return  self.conn_details[password_key] if password_key in self.conn_details 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')

adam/commands/postgres/postgres_utils.py

@@ -1,31 +0,0 @@
-import functools
-
-from adam.commands.postgres.postgres_context import PostgresContext
-from adam.config import Config
-
-TestPG = [False]
-
-@functools.lru_cache()
-def pg_database_names(ns: str, pg_path: str):
-    if TestPG[0]:
-        return ['azops88_c3ai_c3']
-
-    Config().wait_log('Inspecting Postgres Databases...')
-
-    pg = PostgresContext.apply(ns, pg_path)
-    return [db['name'] for db in pg.databases() if db['owner'] == PostgresContext.default_owner()]
-
-@functools.lru_cache()
-def pg_table_names(ns: str, pg_path: str):
-    if TestPG[0]:
-        return ['C3_2_XYZ1']
-
-    Config().wait_log('Inspecting Postgres Database...')
-    return [table['name'] for table in pg_tables(ns, pg_path) if table['schema'] == PostgresContext.default_schema()]
-
-def pg_tables(ns: str, pg_path: str):
-    pg = PostgresContext.apply(ns, pg_path)
-    if pg.db:
-        return pg.tables()
-
-    return []

adam/commands/postgres/psql_completions.py

@@ -1,10 +0,0 @@
-from adam.commands.postgres.postgres_utils import pg_table_names
-from adam.sql.sql_completer import SqlCompleter
-
-def psql_completions(ns: str, pg_path: str):
-    return {
-        '\h': None,
-        '\d': None,
-        '\dt': None,
-        '\du': None
-    } | SqlCompleter(lambda: pg_table_names(ns, pg_path)).completions_for_nesting()

adam/commands/pwd.py

@@ -1,77 +0,0 @@
-from adam.app_session import AppSession
-from adam.commands.command import Command
-from adam.commands.postgres.postgres_context import PostgresContext
-from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log
-
-class Pwd(Command):
-    COMMAND = 'pwd'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Pwd, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Pwd.COMMAND
-
-    def run(self, cmd: str, state: ReplState):
-        if not(args := self.args(cmd)):
-            return super().run(cmd, state)
-
-        state, _ = self.apply_state(args, state)
-
-        def device_line(state: ReplState, device: str):
-            words = []
-
-            if device == ReplState.P:
-                pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
-
-                if pg.host:
-                    words.append(f'host/{pg.host}')
-                if pg.db:
-                    words.append(f'database/{pg.db}')
-            elif device == ReplState.A:
-                if state.app_env:
-                    words.append(f'env/{state.app_env}')
-                if state.app_app:
-                    words.append(f'app/{state.app_app}')
-            elif device == ReplState.L:
-                pass
-            else:
-                if state.sts:
-                    words.append(f'sts/{state.sts}')
-                if state.pod:
-                    words.append(f'pod/{state.pod}')
-
-            return '\t'.join([f'{device}:>'] + (words if words else ['/']))
-
-        host = "unknown"
-        try:
-            app_session: AppSession = AppSession.create('c3', 'c3')
-            host = app_session.host
-        except:
-            pass
-
-        log(lines_to_tabular([
-            device_line(state, ReplState.A),
-            device_line(state, ReplState.C),
-            device_line(state, ReplState.L),
-            device_line(state, ReplState.P),
-            f'',
-            f'HOST\t{host}',
-            f'NAMESPACE\t{state.namespace if state.namespace else "/"}',
-        ], 'DEVICE\tLOCATION', separator='\t'))
-        log()
-
-        return state
-
-    def completion(self, state: ReplState):
-        return super().completion(state)
-
-    def help(self, _: ReplState):
-        return f'{Pwd.COMMAND}\t print current working directories'