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

adam/commands/fs/head.py

@@ -0,0 +1,36 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState, RequiredState
+
+class Head(Command):
+    COMMAND = 'head'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Head, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Head.COMMAND
+
+    def required(self):
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='file'):
+                return Devices.of(state).bash(state, state, cmd.split(' '))
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {f: None for f in Devices.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{Head.COMMAND} file [&]\t run head command on the pod'

adam/commands/fs/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.of(state).ls(cmd, state)
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'&': None}, pods=Devices.of(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/fs/ls_local.py

@@ -0,0 +1,40 @@
+import os
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2
+from adam.utils_local import local_qing_dir
+
+class LsLocal(Command):
+    COMMAND = ':ls'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(LsLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return LsLocal.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 args:
+                os.system(f'ls {args}')
+            else:
+                os.system(f'ls {local_qing_dir()}')
+            log2()
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{LsLocal.COMMAND} [dir]\t list files on local system'

adam/commands/fs/pwd.py

@@ -0,0 +1,45 @@
+from adam.app_session import AppSession
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState
+from adam.utils import tabulize, log, log_exc
+
+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)
+
+        with self.validate(args, state) as (_, state):
+            host = "unknown"
+            with log_exc():
+                app_session: AppSession = AppSession.create('c3', 'c3')
+                host = app_session.host
+
+            tabulize([device.pwd(state) for device in Devices.all()] + [
+                f'',
+                f'HOST\t{host}',
+                f'NAMESPACE\t{state.namespace if state.namespace else "/"}',
+            ], header='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'

adam/commands/fs/rm.py

@@ -0,0 +1,18 @@
+from adam.commands.fs.rm_downloads import RmDownloads
+from adam.commands.fs.rm_logs import RmLogs
+from adam.commands.intermediate_command import IntermediateCommand
+
+class RmLocal(IntermediateCommand):
+    COMMAND = ':rm'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RmLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def command(self):
+        return RmLocal.COMMAND
+
+    def cmd_list(self):
+        return [RmDownloads(), RmLogs()]

adam/commands/fs/rm_downloads.py

@@ -0,0 +1,39 @@
+import os
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2
+from adam.utils_local import local_downloads_dir
+
+class RmDownloads(Command):
+    COMMAND = ':rm downloads'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RmDownloads, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RmDownloads.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):
+            cmd = f'rm -rf {local_downloads_dir()}/*'
+            log2(cmd)
+            os.system(cmd)
+            log2()
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{RmDownloads.COMMAND}\t remove all downloads files under {local_downloads_dir()}'

adam/commands/fs/rm_logs.py

@@ -0,0 +1,38 @@
+import os
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2, log_dir
+
+class RmLogs(Command):
+    COMMAND = ':rm logs'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RmLogs, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RmLogs.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):
+            cmd = f'rm -rf {log_dir()}/*'
+            log2(cmd)
+            os.system(cmd)
+            log2()
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{RmLogs.COMMAND}\t remove all qing log files under {log_dir()}'

adam/commands/{shell.py → fs/shell.py}

@@ -1,7 +1,9 @@
 import os
 
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.repl_state import ReplState
+from adam.utils import log2
 
 class Shell(Command):
     COMMAND = ':sh'
@@ -18,13 +20,19 @@ class Shell(Command):
     def command(self):
         return Shell.COMMAND
 
-    def run(self, cmd: str, s0: ReplState):
+    def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
-            return super().run(cmd, s0)
+            return super().run(cmd, state)
 
-        _, args = self.apply_state(args, s0)
+        with self.validate(args, state) as (args, _):
+            with validate_args(args, state, at_least=0) as args_str:
+                if args_str:
+                    os.system(args_str)
+                    log2()
+                else:
+                    os.system('QING_DROPPED=true bash')
 
-        os.system('QING_DROPPED=true bash')
+            return state
 
     def completion(self, state: ReplState):
         return super().completion(state)

adam/commands/{show → fs}/show_adam.py

@@ -1,7 +1,7 @@
 import sys
 import os
 
-from adam.utils import lines_to_tabular, log2
+from adam.utils import tabulize
 
 current_dir = os.path.dirname(os.path.abspath(__file__))
 
@@ -34,10 +34,10 @@ class ShowAdam(Command):
 
         package = os.path.dirname(os.path.abspath(__file__))
         package = package.split('/adam/')[0] + '/adam'
-        log2(lines_to_tabular([
+        tabulize([
             f'version\t{__version__}',
             f'source\t{package}'
-        ], separator='\t'))
+        ], separator='\t', to=2)
 
         return state
 

adam/commands/{show → fs}/show_host.py

@@ -19,7 +19,7 @@ class ShowHost(Command):
         return ShowHost.COMMAND
 
     def run(self, cmd: str, state: ReplState):
-        if not(args := self.args(cmd)):
+        if not self.args(cmd):
             return super().run(cmd, state)
 
         log(get_my_host())

adam/commands/help.py

@@ -1,7 +1,7 @@
 from adam.commands.command import Command
 from adam.repl_commands import ReplCommands
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log
+from adam.utils import tabulize, log
 
 class Help(Command):
     COMMAND = 'help'
@@ -28,7 +28,7 @@ class Help(Command):
 
         lines = []
         lines.append('NAVIGATION')
-        lines.append('  a: | c: | l: | p:\t switch to another operational device: App, Cassandra, Audit or Postgres')
+        lines.append('  a: | c: | l: | p: | x:\t switch to another operational device: App, Cassandra, Audit, Postgres or Export')
         lines.extend(section(ReplCommands.navigation()))
         lines.append('CASSANDRA')
         lines.extend(section(ReplCommands.cassandra_ops()))
@@ -36,6 +36,8 @@ class Help(Command):
         lines.extend(section(ReplCommands.postgres_ops()))
         lines.append('APP')
         lines.extend(section(ReplCommands.app_ops()))
+        lines.append('EXPORT DB')
+        lines.extend(section(ReplCommands.export_ops()))
         lines.append('AUDIT')
         lines.extend(section(ReplCommands.audit_ops()))
         lines.append('TOOLS')
@@ -43,7 +45,7 @@ class Help(Command):
         lines.append('')
         lines.extend(section(ReplCommands.exit()))
 
-        log(lines_to_tabular(lines, separator='\t'))
+        tabulize(lines, separator='\t')
 
         return lines
 

adam/commands/intermediate_command.py

@@ -0,0 +1,52 @@
+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 tabulize, log, log2
+
+class IntermediateCommand(Command):
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        return self.intermediate_run(cmd, state, args, self.cmd_list())
+
+    def completion(self, state: ReplState):
+        return {}
+
+    @abstractmethod
+    def cmd_list(self):
+        pass
+
+    def intermediate_run(self, cmd: str, state: ReplState, args: list[str], cmds: list['Command'], separator='\t', display_help=True):
+        state, _ = self.apply_state(args, state)
+
+        if state.in_repl:
+            if display_help:
+                tabulize(cmds, lambda c: c.help(state), separator=separator)
+
+            return 'command-missing'
+        else:
+            # head with the Chain of Responsibility pattern
+            if not self.run_subcommand(cmd, state):
+                if display_help:
+                    log2('* Command is missing.')
+                    Command.display_help()
+                return 'command-missing'
+
+        return state
+
+    def run_subcommand(self, cmd: str, state: ReplState):
+        cmds = Command.chain(self.cmd_list())
+        return cmds.run(cmd, state)
+
+    def intermediate_help(super_help: str, cmd: str, cmd_list: list['Command'], separator='\t', show_cluster_help=False):
+        log(super_help)
+        log()
+        log('Sub-Commands:')
+
+        tabulize(cmd_list, lambda c: c.help(ReplState()).replace(f'{cmd} ', '  ', 1), separator=separator)
+        if show_cluster_help:
+            log()
+            ClusterCommandHelper.cluster_help()

adam/commands/kubectl.py

@@ -0,0 +1,38 @@
+import subprocess
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+
+class Kubectl(Command):
+    COMMAND = 'k'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Kubectl, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Kubectl.COMMAND
+
+    def required(self):
+        return RequiredState.NAMESPACE
+
+    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):
+            subprocess.run(["kubectl"] + args)
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+
+    def help(self, _: ReplState):
+        return f'{Kubectl.COMMAND} \t run a kubectl command'

adam/commands/medusa/medusa.py

@@ -1,13 +1,13 @@
 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
-from adam.repl_state import ReplState, RequiredState
 
-class Medusa(Command):
+class Medusa(IntermediateCommand):
     COMMAND = 'medusa'
 
     # the singleton pattern
@@ -16,30 +16,12 @@ class Medusa(Command):
 
         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)
-
-        return super().intermediate_run(cmd, state, args, Medusa.cmd_list())
-
-    def cmd_list():
+    def cmd_list(self):
         return [MedusaBackup(), MedusaRestore(), MedusaShowBackupJobs(), MedusaShowRestoreJobs()]
 
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
-
 class MedusaCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
-        Command.intermediate_help(super().get_help(ctx), Medusa.COMMAND, Medusa.cmd_list(), show_cluster_help=True)
+        IntermediateCommand.intermediate_help(super().get_help(ctx), Medusa.COMMAND, Medusa().cmd_list(), show_cluster_help=True)

adam/commands/medusa/medusa_backup.py

@@ -1,13 +1,12 @@
 from datetime import datetime
-import re
 
+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
 from adam.utils_k8s.custom_resources import CustomResources
 from adam.utils import log2
 
-
 class MedusaBackup(Command):
     COMMAND = 'backup'
 
@@ -29,33 +28,27 @@ class MedusaBackup(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 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)
+        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")
+            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()
 
-        return {}
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
 
     def help(self, _: ReplState):
         return f'{MedusaBackup.COMMAND}\t start a backup job'