kaqing 1.77.0__py3-none-any.whl → 2.0.171__py3-none-any.whl

walker/commands/ls.py

@@ -1,145 +0,0 @@
-import copy
-import re
-
-from walker.commands.command import Command
-from walker.commands.commands_utils import show_pods, show_rollout
-from walker.commands.cqlsh import Cqlsh
-from walker.commands.postgres.postgres_session import PostgresSession
-from walker.config import Config
-from walker.k8s_utils.custom_resources import CustomResources
-from walker.k8s_utils.ingresses import Ingresses
-from walker.k8s_utils.kube_context import KubeContext
-from walker.k8s_utils.services import Services
-from walker.k8s_utils.statefulsets import StatefulSets
-from walker.pod_exec_result import PodExecResult
-from walker.repl_state import ReplState
-from walker.utils import lines_to_tabular, log, log2
-from walker.apps import Apps
-
-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 = PostgresSession(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=','))
-        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(show_namespace=not KubeContext.in_cluster_namespace())
-        if len(ss) == 0:
-            log2('No cassandra statefulsets 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: PostgresSession):
-                return f'{pg.directory()},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
-
-            lines = [line(PostgresSession(state.namespace, pg)) for pg in PostgresSession.hosts(state.namespace)]
-
-            log(lines_to_tabular(lines, 'NAME,ENDPOINT,USERNAME,PASSWORD', separator=','))
-        else:
-            def line(pg: PostgresSession):
-                return f'{pg.directory()},{pg.namespace},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
-
-            lines = [line(PostgresSession(state.namespace, pg)) for pg in PostgresSession.hosts(state.namespace)]
-
-            log(lines_to_tabular(lines, 'NAME,NAMESPACE,ENDPOINT,USERNAME,PASSWORD', separator=','))
-
-    def show_pg_databases(self, pg: PostgresSession):
-        lines = [db["name"] for db in pg.databases() if db["owner"] == PostgresSession.default_owner()]
-
-        log(lines_to_tabular(lines, 'DATABASE', separator=','))
-
-    def show_pg_tables(self, pg: PostgresSession):
-        lines = [db["name"] for db in pg.tables() if db["schema"] == PostgresSession.default_schema()]
-
-        log(lines_to_tabular(lines, 'NAME', separator=','))
-
-    def completion(self, state: ReplState):
-        if state.pod:
-            return {}
-
-        if not state.sts:
-            return {Ls.COMMAND: {n: None for n in StatefulSets.list_sts_names()}}
-
-        return {Ls.COMMAND: None}
-
-    def help(self, _: ReplState):
-        return f'{Ls.COMMAND} [device:]\t list apps, envs, clusters, nodes, pg hosts or pg databases'

walker/commands/medusa/medusa.py

@@ -1,69 +0,0 @@
-import click
-
-from walker.commands.command import Command
-from walker.commands.command_helpers import ClusterCommandHelper
-from .medusa_backup import MedusaBackup
-from .medusa_restore import MedusaRestore
-from .medusa_show_backupjobs import MedusaShowBackupJobs
-from .medusa_show_restorejobs import MedusaShowRestoreJobs
-from walker.repl_state import ReplState, RequiredState
-from walker.utils import lines_to_tabular, log, log2
-
-class Medusa(Command):
-    COMMAND = 'medusa'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Medusa, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Medusa.COMMAND
-
-    def required(self):
-        return RequiredState.CLUSTER
-
-    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
-
-        if state.in_repl:
-            log(lines_to_tabular([c.help(ReplState()) for c in Medusa.cmd_list()], separator=':'))
-
-            return 'command-missing'
-        else:
-            # head with the Chain of Responsibility pattern
-            cmds = Command.chain(Medusa.cmd_list())
-            if not cmds.run(cmd, state):
-                log2('* Command is missing.')
-                Command.display_help()
-
-    def cmd_list():
-        return [MedusaBackup(), MedusaRestore(), MedusaShowBackupJobs(), MedusaShowRestoreJobs()]
-
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
-
-    def help(self, _: ReplState):
-        return None
-
-class MedusaCommandHelper(click.Command):
-    def get_help(self, ctx: click.Context):
-        log(super().get_help(ctx))
-        log()
-        log('Sub-Commands:')
-
-        log(lines_to_tabular([c.help(ReplState()).replace(f'{Medusa.COMMAND} ', '  ', 1) for c in Medusa.cmd_list()], separator=':'))
-        log()
-        ClusterCommandHelper.cluster_help()

walker/commands/medusa/medusa_backup.py

@@ -1,61 +0,0 @@
-from datetime import datetime
-import re
-
-from walker.commands.command import Command
-from walker.k8s_utils.statefulsets import StatefulSets
-from walker.repl_state import ReplState, RequiredState
-from walker.k8s_utils.custom_resources import CustomResources
-from walker.utils import log2
-
-
-class MedusaBackup(Command):
-    COMMAND = 'backup'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(MedusaBackup, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return MedusaBackup.COMMAND
-
-    def required(self):
-        return RequiredState.CLUSTER
-
-    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
-
-        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])
-        groups = re.match(r'^(.*?-.*?-).*', sts)
-        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)
-
-        return state
-
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{MedusaBackup.COMMAND}\t start a backup job'

walker/commands/medusa/medusa_restore.py

@@ -1,86 +0,0 @@
-from datetime import datetime
-
-from walker.commands.command import Command
-from walker.k8s_utils.statefulsets import StatefulSets
-from walker.repl_state import ReplState, RequiredState
-from walker.k8s_utils.custom_resources import CustomResources
-from walker.config import Config
-from walker.utils import lines_to_tabular, log2
-
-class MedusaRestore(Command):
-    COMMAND = 'restore'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(MedusaRestore, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return MedusaRestore.COMMAND
-
-    def required(self):
-        return RequiredState.CLUSTER
-
-    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
-
-        ns = state.namespace
-        dc = StatefulSets.get_datacenter(state.sts, ns)
-        if not dc:
-            return state
-
-        if len(args) == 1:
-            bkname = args[0]
-            job = CustomResources.medusa_get_backupjob(dc, ns, bkname)
-            if not job:
-                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'))
-
-                return state
-
-            if not input(f"Restoring from {bkname} created at {job['metadata']['creationTimestamp']}. Please enter Yes to continue: ").lower() in ['y', 'yes']:
-                return state
-        else:
-            bklist = [f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '')}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]
-            log2('\n* Missing Backup Name')
-            log2('Usage: qing medusa restore <backup> <sts@name_space>\n')
-            log2(lines_to_tabular(bklist, 'NAME\tCREATED\tFINISHED', separator='\t'))
-            return state
-
-        now_dtformat = datetime.now().strftime("%Y-%m-%d.%H.%M.%S")
-        rtname = 'medusa-' + now_dtformat + '-restore-from-' + bkname
-        try:
-            print('SEAN doing')
-            # CustomResources.create_medusa_restorejob(rtname, bkname, dc, ns)
-        except Exception as e:
-            log2("Exception: MedusaRestore failed: %s\n" % e)
-
-        return state
-
-    def completion(self, state: ReplState):
-        if state.sts:
-            ns = state.namespace
-            dc = 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 super().completion(state)
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{MedusaRestore.COMMAND}\t start a restore job'

walker/commands/medusa/medusa_show_backupjobs.py

@@ -1,52 +0,0 @@
-from walker.commands.command import Command
-from walker.k8s_utils.statefulsets import StatefulSets
-from walker.repl_state import ReplState, RequiredState
-from walker.k8s_utils.custom_resources import CustomResources
-from walker.utils import lines_to_tabular, log2
-
-
-class MedusaShowBackupJobs(Command):
-    COMMAND = 'show backups'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(MedusaShowBackupJobs, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return MedusaShowBackupJobs.COMMAND
-
-    def required(self):
-        return RequiredState.CLUSTER
-
-    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
-        ns = state.namespace
-        dc = StatefulSets.get_datacenter(state.sts, ns)
-        if not dc:
-            return state
-
-        try:
-            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'))
-        except Exception as e:
-            log2("Exception: MedusaShowBackupJobs failed: %s\n" % e)
-
-        return state
-
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{MedusaShowBackupJobs.COMMAND}\t start a restore job'

walker/commands/medusa/medusa_show_restorejobs.py

@@ -1,52 +0,0 @@
-from walker.commands.command import Command
-from walker.k8s_utils.statefulsets import StatefulSets
-from walker.repl_state import ReplState, RequiredState
-from walker.k8s_utils.custom_resources import CustomResources
-from walker.utils import lines_to_tabular, log2
-
-class MedusaShowRestoreJobs(Command):
-    COMMAND = 'show restores'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(MedusaShowRestoreJobs, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return MedusaShowRestoreJobs.COMMAND
-
-    def required(self):
-        return RequiredState.CLUSTER
-
-    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
-
-        ns = state.namespace
-        dc = StatefulSets.get_datacenter(state.sts, ns)
-        if not dc:
-            return state
-
-        try:
-            rtlist = CustomResources.medusa_show_restorejobs(dc, ns)
-            log2(lines_to_tabular(rtlist, 'NAME\tCREATED\tFINISHED', separator='\t'))
-        except Exception as e:
-            log2("Exception: MedusaShowRestoreJobs failed: %s\n" % e)
-
-        return state
-
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{MedusaShowRestoreJobs.COMMAND}\t start a restore job'

walker/commands/param_set.py

@@ -1,44 +0,0 @@
-from walker.commands.command import Command
-from walker.config import Config
-from walker.repl_state import ReplState
-from walker.utils import log, log2
-
-class SetParam(Command):
-    COMMAND = 'set'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(SetParam, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return SetParam.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) < 2:
-            log2('set <key> <value>')
-
-            return 'invalid args'
-
-        key = args[0]
-        value = args[1]
-        Config().set(key, value)
-
-        log(Config().get(key, None))
-
-        return value
-
-    def completion(self, _: ReplState):
-        return {SetParam.COMMAND: {key: None for key in Config().keys()}}
-
-    def help(self, _: ReplState):
-        return f"{SetParam.COMMAND} <key> <value>\t sets a Kaqing parameter to a different value"

walker/commands/postgres/postgres.py

@@ -1,113 +0,0 @@
-import click
-
-from walker.commands.command import Command
-from walker.commands.command_helpers import ClusterCommandHelper
-from .postgres_ls import PostgresLs
-from .postgres_preview import PostgresPreview
-from .postgres_session import PostgresSession
-from walker.repl_state import ReplState
-from walker.utils import lines_to_tabular, log, log2
-
-class Postgres(Command):
-    COMMAND = 'pg'
-    reaper_login = None
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Postgres, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Postgres.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 state.in_repl:
-            if not args:
-                log2('Please use SQL statement. e.g. pg \l')
-
-                return 'command-missing'
-            else:
-                self.run_sql(state, args)
-        else:
-            if not args:
-                log2('* Command or SQL statements is missing.')
-                Command.display_help()
-
-                return 'command-missing'
-            else:
-                # head with the Chain of Responsibility pattern
-                cmds = Command.chain(Postgres.cmd_list())
-                if not cmds.run(cmd, state) :
-                    if not args:
-                        log2('* Command or SQL statements is missing.')
-                        Command.display_help()
-
-                        return 'command-missing'
-                    else:
-                        self.run_sql(state, args)
-
-        return state
-
-    def cmd_list():
-        return [PostgresLs(), PostgresPreview()]
-
-    def run_sql(self, state: ReplState, args: list[str]):
-        if not state.pg_path:
-            if state.in_repl:
-                log2('Enter "use <pg-name>" first.')
-            else:
-                log2('* pg-name is missing.')
-
-            return state
-
-        PostgresSession(state.namespace, state.pg_path).run_sql(' '.join(args))
-
-    def completion(self, state: ReplState):
-        leaf = {}
-        if PostgresSession(state.namespace, state.pg_path).db:
-            leaf = {
-                '\h': None,
-                '\d': None,
-                '\dt': None,
-                '\du': None,
-                'delete': {'from': None},
-                'insert': {'into': None},
-                'select': None,
-                'update': None,
-            }
-        elif state.pg_path:
-            leaf = {
-                '\h': None,
-                '\l': None,
-            }
-
-        if state.pg_path:
-            return super().completion(state, leaf) | leaf
-        else:
-            return {}
-
-    def help(self, _: ReplState):
-        return f'[{Postgres.COMMAND}] <sql-statements>\t run psql with queries'
-
-class PostgresCommandHelper(click.Command):
-    def get_help(self, ctx: click.Context):
-        log(super().get_help(ctx))
-        log()
-        log('Sub-Commands:')
-
-        log(lines_to_tabular([c.help(ReplState()).replace(f'{Postgres.COMMAND} ', '  ', 1) for c in Postgres.cmd_list()], separator='\t'))
-        log()
-        ClusterCommandHelper.cluster_help()
-        log('PG-Name:  Kubernetes secret for Postgres credentials')
-        log('          e.g. stgawsscpsr-c3-c3-k8spg-cs-001')
-        log('Database: Postgres database name within a host')
-        log('          e.g. stgawsscpsr_c3_c3')