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

adam/commands/ls.py

@@ -0,0 +1,41 @@
+import copy
+
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState
+
+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)
+
+        with self.validate(args, state) as (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(':', '')
+
+            Devices.device(state).ls(cmd, state)
+
+            return state
+
+    def completion(self, state: ReplState):
+        return Devices.device(state).ls_completion(Ls.COMMAND, state, default = super().completion(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.py

@@ -0,0 +1,27 @@
+import click
+
+from adam.commands.command import Command
+from adam.commands.intermediate_command import IntermediateCommand
+from .medusa_backup import MedusaBackup
+from .medusa_restore import MedusaRestore
+from .medusa_show_backupjobs import MedusaShowBackupJobs
+from .medusa_show_restorejobs import MedusaShowRestoreJobs
+
+class Medusa(IntermediateCommand):
+    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 command(self):
+        return Medusa.COMMAND
+
+    def cmd_list(self):
+        return [MedusaBackup(), MedusaRestore(), MedusaShowBackupJobs(), MedusaShowRestoreJobs()]
+
+class MedusaCommandHelper(click.Command):
+    def get_help(self, ctx: click.Context):
+        IntermediateCommand.intermediate_help(super().get_help(ctx), Medusa.COMMAND, Medusa().cmd_list(), show_cluster_help=True)

adam/commands/medusa/medusa_backup.py

@@ -0,0 +1,57 @@
+from datetime import datetime
+import re
+
+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 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)
+
+        with self.validate(args, state) as (args, 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)
+            finally:
+                CustomResources.clear_caches()
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{MedusaBackup.COMMAND}\t start a backup job'

adam/commands/medusa/medusa_restore.py

@@ -0,0 +1,83 @@
+from datetime import datetime
+
+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.config import Config
+from adam.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)
+
+        with self.validate(args, state) as (args, state):
+            ns = state.namespace
+            dc: str = 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:
+                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 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 {}
+
+    def help(self, _: ReplState):
+        return f'{MedusaRestore.COMMAND}\t start a restore job'

adam/commands/medusa/medusa_show_backupjobs.py

@@ -0,0 +1,51 @@
+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
+
+
+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)
+
+        with self.validate(args, state) as (args, state):
+            ns = state.namespace
+            dc = StatefulSets.get_datacenter(state.sts, ns)
+            if not dc:
+                return state
+
+            try:
+                # always show latest
+                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'))
+            except Exception as e:
+                log2("Exception: MedusaShowBackupJobs failed: %s\n" % e)
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{MedusaShowBackupJobs.COMMAND}\t show Medusa backups'

adam/commands/medusa/medusa_show_restorejobs.py

@@ -0,0 +1,47 @@
+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
+
+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)
+
+        with self.validate(args, state) as (args, 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):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{MedusaShowRestoreJobs.COMMAND}\t show Medusa restores'

{walker → adam}/commands/nodetool.py

@@ -1,13 +1,13 @@
 import click
 
-from walker.commands.command import Command
-from walker.commands.command_helpers import ClusterOrPodCommandHelper
-from walker.commands.nodetool_commands import NODETOOL_COMMANDS
-from walker.config import Config
-from walker.k8s_utils.cassandra_clusters import CassandraClusters
-from walker.k8s_utils.cassandra_nodes import CassandraNodes
-from walker.repl_state import ReplState, RequiredState
-from walker.utils import log
+from adam.commands.command import Command
+from adam.commands.command_helpers import ClusterOrPodCommandHelper
+from adam.commands.cql.utils_cql import cassandra
+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'
@@ -31,26 +31,22 @@ class NodeTool(Command):
         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
-
-        user, pw = state.user_pass()
-        command = f"nodetool -u {user} -pw {pw} {' '.join(args)}"
+        with self.validate(args, state) as (args, state):
+            with cassandra(state) as pods:
+                pods.nodetool(' '.join(args))
 
-        if state.pod:
-            return CassandraNodes.exec(state.pod, state.namespace, command, show_out=True)
-        elif state.sts:
-            return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool', show_out=True)
+            return state
 
     def completion(self, state: ReplState):
-        if state.pod or state.sts:
-            return {NodeTool.COMMAND: {'help': None} | {c: None for c in NODETOOL_COMMANDS}}
+        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 {}
 
     def help(self, _: ReplState):
-        return f'{NodeTool.COMMAND} <sub-command>\t run nodetool with arguments'
+        return f'{NodeTool.COMMAND} <sub-command> [&]\t run nodetool with arguments'
 
 class NodeToolCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):

{walker → adam}/commands/param_get.py

@@ -1,7 +1,7 @@
-from walker.commands.command import Command
-from walker.config import Config
-from walker.repl_state import ReplState
-from walker.utils import lines_to_tabular, log, log2
+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
 
 class GetParam(Command):
     COMMAND = 'get'
@@ -22,21 +22,20 @@ class GetParam(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
+        with self.validate(args, state) as (args, state):
+            if len(args) < 1:
+                lines = [f'{key}\t{Config().get(key, None)}' for key in Config().keys()]
+                log(lines_to_tabular(lines, separator='\t'))
 
-        if len(args) < 1:
-            lines = [f'{key}\t{Config().get(key, None)}' for key in Config().keys()]
-            log(lines_to_tabular(lines, separator='\t'))
+                return state
 
-            return state
+            key = args[0]
+            if v := Config().get(key, None):
+                log(v)
+            else:
+                log2(f'{key} is not set.')
 
-        key = args[0]
-        if v := Config().get(key, None):
-            log(v)
-        else:
-            log2(f'{key} is not set.')
-
-        return v if v else state
+            return v if v else state
 
     def completion(self, _: ReplState):
         return {GetParam.COMMAND: {key: None for key in Config().keys()}}

adam/commands/param_set.py

@@ -0,0 +1,43 @@
+from adam.commands.command import Command
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.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)
+
+        with self.validate(args, state) as (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: ({'true': None, 'false': None} if Config().get(key, None) in [True, False] else 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"

adam/commands/postgres/postgres.py

@@ -0,0 +1,104 @@
+import click
+
+from adam.commands import extract_trailing_options
+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.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
+
+class Postgres(IntermediateCommand):
+    COMMAND = 'pg'
+
+    # 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)
+
+        with self.validate(args, state) as (args, state):
+            with extract_trailing_options(args, '&') as (args, backgrounded):
+                if not args:
+                    if state.in_repl:
+                        log2('Please use SQL statement. e.g. pg \l')
+                    else:
+                        log2('* Command or SQL statements is missing.')
+                        Command.display_help()
+
+                    return 'command-missing'
+
+                if not state.pg_path:
+                    if state.in_repl:
+                        log2('Enter "use <pg-name>" first.')
+                    else:
+                        log2('* pg-name is missing.')
+
+                    return state
+
+                if state.in_repl:
+                    with postgres(state) as pod:
+                        pod.sql(args, background=backgrounded)
+                elif not self.run_subcommand(cmd, state):
+                    with postgres(state) as pod:
+                        pod.sql(args, background=backgrounded)
+
+                return state
+
+    def cmd_list(self):
+        return [PostgresLs(), PostgresPreview(), PostgresPg()]
+
+    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 {}
+
+    def help(self, _: ReplState):
+        return f'<sql-statements> [&]\t run queries on Postgres databases'
+
+class PostgresCommandHelper(click.Command):
+    def get_help(self, ctx: click.Context):
+        IntermediateCommand.intermediate_help(super().get_help(ctx), Postgres.COMMAND, Postgres().cmd_list(), show_cluster_help=True)
+        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')
+
+# No action body, only for a help entry and auto-completion
+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'