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

walker/commands/cp.py

@@ -1,95 +0,0 @@
-import click
-import pyperclip
-
-from walker.commands.command import Command
-from walker.commands.command_helpers import ClusterOrPodCommandHelper
-from walker.commands.cli_commands import CliCommands
-from walker.repl_state import ReplState, RequiredState
-from walker.utils import lines_to_tabular, log, log2
-
-class ClipboardCopy(Command):
-    COMMAND = 'cp'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(ClipboardCopy, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return ClipboardCopy.COMMAND
-
-    def required(self):
-        return RequiredState.CLUSTER_OR_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
-
-        if len(args) < 1:
-            if state.in_repl:
-                log2('Key is required.')
-                log2()
-                log2('Keys:')
-                log2(lines_to_tabular([f'{k},{v}' for k, v in CliCommands.values(state, collapse=True).items()], separator=','))
-            else:
-                log2('* Key is missing.')
-                Command.display_help()
-
-            return 'command-missing'
-
-        key = args[0]
-        if not key in CliCommands.values(state):
-            if state.in_repl:
-                log2('Key is required.')
-                log2()
-                log2('Keys:')
-                log2(lines_to_tabular([f'{k},{v}' for k, v in CliCommands.values(state, collapse=True).items()], separator=','))
-            else:
-                log2('* Invalid key')
-                Command.display_help()
-
-            return 'command-invalid'
-
-        value = CliCommands.values(state)[key]
-        pyperclip.copy(value)
-        log2('The following line has been copied to clipboard. Use <Ctrl-V> to use it.')
-        log2(f'  {value}')
-
-        return 'value-copied'
-
-    def completion(self, state: ReplState):
-        if state.sts:
-            return {ClipboardCopy.COMMAND: {key: None for key in CliCommands.values(state).keys()}}
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f"{ClipboardCopy.COMMAND} <key>\t copy a value to clipboard for conveninence"
-
-class CopyCommandHelper(click.Command):
-    def lines(self):
-        return [
-            'node-exec-?: kubectl exec command to the Cassandra pod',
-            'reaper-exec: kubectl exec command to the Reaper pod',
-            'reaper-forward: kubectl port-forward command to the Reaper pod',
-            'reaper-ui: uri to Reaper ui',
-            'reaper-username: Reaper user name',
-            'reaper-password: Reaper password',
-        ]
-
-    def get_help(self, ctx: click.Context):
-        log(super().get_help(ctx))
-        log()
-        log('Keys:')
-
-        log(lines_to_tabular(self.lines(), separator=':'))
-        log()
-        ClusterOrPodCommandHelper.cluter_or_pod_help()

walker/commands/cql_utils.py

@@ -1,53 +0,0 @@
-import re
-
-from walker.k8s_utils.cassandra_clusters import CassandraClusters
-from walker.k8s_utils.cassandra_nodes import CassandraNodes
-from walker.k8s_utils.secrets import Secrets
-from walker.repl_state import ReplState
-
-def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, use_single_quotes = False):
-    user, pw = Secrets.get_user_pass(state.sts if state.sts else state.pod, state.namespace, secret_path='cql.secret')
-    if use_single_quotes:
-        command = f"cqlsh -u {user} -p {pw} {' '.join(opts)} -e '{cql}'"
-    else:
-        command = f'cqlsh -u {user} -p {pw} {" ".join(opts)} -e "{cql}"'
-
-    if state.pod:
-        return CassandraNodes.exec(state.pod, state.namespace, command, show_out=show_out)
-    else:
-        return CassandraClusters.exec(state.sts, state.namespace, command, action='cql')
-
-def parse_cql_desc_tables(out: str):
-    # Keyspace data_endpoint_auth
-    # ---------------------------
-    # "token"
-
-    # Keyspace reaper_db
-    # ------------------
-    # repair_run                     schema_migration
-    # repair_run_by_cluster          schema_migration_leader
-
-    # Keyspace system
-    tables_by_keyspace: dict[str, list[str]] = {}
-    keyspace = None
-    state = 's0'
-    for line in out.split('\n'):
-        if state == 's0':
-            groups = re.match(r'^Keyspace (.*)$', line)
-            if groups:
-                keyspace = groups[1].strip(' \r')
-                state = 's1'
-        elif state == 's1':
-            if line.startswith('---'):
-                state = 's2'
-        elif state == 's2':
-            if not line.strip(' \r'):
-                state = 's0'
-            else:
-                for table in line.split(' '):
-                    if t := table.strip(' \r'):
-                        if not keyspace in tables_by_keyspace:
-                            tables_by_keyspace[keyspace] = []
-                        tables_by_keyspace[keyspace].append(t)
-
-    return tables_by_keyspace

walker/commands/devices.py

@@ -1,89 +0,0 @@
-from walker.commands.command import Command
-from walker.repl_state import ReplState
-
-class DeviceCass(Command):
-    COMMAND = f'{ReplState.C}:'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(DeviceCass, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return DeviceCass.COMMAND
-
-    def run(self, cmd: str, state: ReplState):
-        if not self.args(cmd):
-            return super().run(cmd, state)
-
-        state.device = ReplState.C
-
-        return state
-
-    def completion(self, state: ReplState):
-        return super().completion(state)
-
-    def help(self, _: ReplState):
-        return f'{DeviceCass.COMMAND}\t move to Cassandra Operations device'
-
-class DevicePostgres(Command):
-    COMMAND = f'{ReplState.P}:'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(DevicePostgres, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return DevicePostgres.COMMAND
-
-    def run(self, cmd: str, state: ReplState):
-        if not self.args(cmd):
-            return super().run(cmd, state)
-
-        state.device = ReplState.P
-
-        return state
-
-    def completion(self, state: ReplState):
-        return super().completion(state)
-
-    def help(self, _: ReplState):
-        return f'{DevicePostgres.COMMAND}\t move to Postgres Operations device'
-
-class DeviceApp(Command):
-    COMMAND = f'{ReplState.A}:'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(DeviceApp, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return DeviceApp.COMMAND
-
-    def run(self, cmd: str, state: ReplState):
-        if not self.args(cmd):
-            return super().run(cmd, state)
-
-        state.device = ReplState.A
-
-        return state
-
-    def completion(self, state: ReplState):
-        return super().completion(state)
-
-    def help(self, _: ReplState):
-        return f'{DeviceApp.COMMAND}\t move to App Operations device'

walker/commands/frontend/code_stop.py

@@ -1,57 +0,0 @@
-from walker.commands.command import Command
-from walker.commands.frontend.code_utils import stop_user_codes
-from walker.repl_state import ReplState, RequiredState
-
-class CodeStop(Command):
-    COMMAND = 'code stop'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(CodeStop, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return CodeStop.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)
-
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        _, dry = Command.extract_options(args, '--dry')
-        stop_user_codes(state.namespace, dry)
-
-        # if not args:
-        #     log2('Please specify <port>.')
-        #     return state
-
-        # port = args[0]
-        # name = f'ops-{port}'
-        # user = os.getenv("USER")
-        # label_selector=f'user={user}'
-        # Ingresses.delete_ingresses(state.namespace, label_selector=label_selector)
-        # Services.delete_services(state.namespace, label_selector=label_selector)
-
-        # pattern = f'/c3/c3/ops/code/{user}/'
-        # self.kill_process_by_pattern(pattern)
-
-        return state
-
-    def completion(self, state: ReplState):
-        if state.namespace:
-            return super().completion(state)
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{CodeStop.COMMAND}\t stop code server'

walker/commands/frontend/setup.py

@@ -1,60 +0,0 @@
-import click
-
-from walker.commands.command import Command
-from walker.commands.command_helpers import ClusterCommandHelper
-from .setup_frontend import SetupFrontend
-from walker.repl_state import ReplState
-from walker.utils import lines_to_tabular, log, log2
-
-class Setup(Command):
-    COMMAND = 'setup'
-    reaper_login = None
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Setup, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Setup.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:
-            log(lines_to_tabular([c.help(ReplState()) for c in Setup.cmd_list()], separator=':'))
-
-            return 'command-missing'
-        else:
-            # head with the Chain of Responsibility pattern
-            cmds = Command.chain(Setup.cmd_list())
-            if not cmds.run(cmd, state):
-                log2('* Command is missing.')
-                Command.display_help()
-
-    def cmd_list():
-        return [SetupFrontend()]
-
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
-
-    def help(self, _: ReplState):
-        return None
-
-class SetupCommandHelper(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'{Setup.COMMAND} ', '  ', 1) for c in Setup.cmd_list()], separator=':'))

walker/commands/frontend/setup_frontend.py

@@ -1,58 +0,0 @@
-from walker.app_session import AppSession
-from walker.commands.command import Command
-from walker.k8s_utils.ingresses import Ingresses
-from walker.k8s_utils.services import Services
-from walker.repl_state import ReplState, RequiredState
-from walker.utils import log2
-
-class SetupFrontend(Command):
-    COMMAND = 'setup frontend'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(SetupFrontend, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return SetupFrontend.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)
-
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        log2('This will support c3/c3 only for demo.')
-
-        app_session: AppSession = AppSession.create('c3', 'c3', state.namespace)
-        try:
-            name = 'ops'
-            port = 7678
-            Services.create_service(name, state.namespace, port, {"run": "ops"})
-            Ingresses.create_ingress(name, state.namespace, app_session.host, '/c3/c3/ops($|/)', port, annotations={
-                'kubernetes.io/ingress.class': 'nginx',
-                'nginx.ingress.kubernetes.io/use-regex': 'true',
-                'nginx.ingress.kubernetes.io/rewrite-target': '/'
-            })
-        except Exception as e:
-            if e.status == 409:
-                log2(f"Error: '{name}' already exists in namespace '{state.namespace}'.")
-            else:
-                log2(f"Error creating ingress or service: {e}")
-
-        return state
-
-    def completion(self, _: ReplState):
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{SetupFrontend.COMMAND}\t sets up frontend'

walker/commands/frontend/teardown.py

@@ -1,61 +0,0 @@
-import click
-
-from walker.commands.command import Command
-from walker.commands.command_helpers import ClusterCommandHelper
-from walker.commands.frontend.teardown_frontend import TearDownFrontend
-from .setup_frontend import SetupFrontend
-from walker.repl_state import ReplState
-from walker.utils import lines_to_tabular, log, log2
-
-class TearDown(Command):
-    COMMAND = 'teardown'
-    reaper_login = None
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(TearDown, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return TearDown.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:
-            log(lines_to_tabular([c.help(ReplState()) for c in TearDown.cmd_list()], separator=':'))
-
-            return 'command-missing'
-        else:
-            # head with the Chain of Responsibility pattern
-            cmds = Command.chain(TearDown.cmd_list())
-            if not cmds.run(cmd, state):
-                log2('* Command is missing.')
-                Command.display_help()
-
-    def cmd_list():
-        return [TearDownFrontend()]
-
-    def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-
-        return {}
-
-    def help(self, _: ReplState):
-        return None
-
-class TearDownCommandHelper(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'{TearDown.COMMAND} ', '  ', 1) for c in TearDown.cmd_list()], separator=':'))

walker/commands/frontend/teardown_frontend.py

@@ -1,42 +0,0 @@
-from walker.commands.command import Command
-from walker.k8s_utils.ingresses import Ingresses
-from walker.k8s_utils.services import Services
-from walker.repl_state import ReplState, RequiredState
-
-class TearDownFrontend(Command):
-    COMMAND = 'teardown frontend'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(TearDownFrontend, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return TearDownFrontend.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)
-
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        name = 'ops'
-        Ingresses.delete_ingress(name, state.namespace)
-        Services.delete_service(name, state.namespace)
-
-        return state
-
-    def completion(self, _: ReplState):
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{TearDownFrontend.COMMAND}\t tear down frontend'

walker/commands/issues.py

@@ -1,69 +0,0 @@
-from walker.checks.check_result import CheckResult
-from walker.checks.check_utils import run_checks
-from walker.checks.issue import Issue
-from walker.commands.command import Command
-from walker.repl_session import ReplSession
-from walker.repl_state import ReplState
-from walker.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 run(self, cmd: str, state: ReplState):
-        if not(args := self.args(cmd)):
-            return super().run(cmd, state)
-
-        state, args = self.apply_state(args, 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'

walker/commands/login.py

@@ -1,72 +0,0 @@
-import json
-import signal
-import traceback
-
-from walker.app_session import AppSession
-from walker.apps import Apps
-from walker.sso.idp import Idp
-from walker.sso.idp_login import IdpLogin
-from walker.commands.command import Command
-from walker.repl_state import ReplState
-from walker.sso.sso_config import SsoConfig
-from walker.utils import log, log2
-
-class Login(Command):
-    COMMAND = 'login'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Login, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Login.COMMAND
-
-    def run(self, cmd: str, state: ReplState):
-        def custom_handler(signum, frame):
-            AppSession.ctrl_c_entered = True
-
-        signal.signal(signal.SIGINT, custom_handler)
-
-        if not(args := self.args(cmd)):
-            return super().run(cmd, state)
-
-        state, args = self.apply_state(args, state)
-
-        # args, print_token = Command.extract_options(args, '--print-token')
-
-        username: str = None
-        if len(args) > 0:
-            username = args[0]
-
-        # print(SsoConfig().config)
-        # SsoConfig().find_idp_url()
-        # print(json.dumps(SsoConfig(), indent=4))
-
-        login: IdpLogin = None
-        try:
-            if not(host := Apps.app_host('c3', 'c3', state.namespace)):
-                log2('Cannot locate ingress for app.')
-                return state
-
-            # uri = Idp.build_uri(host, host)
-            if not (login := Idp.login(host, username=username, use_cached=False)):
-                log2('Invalid username/password. Please try again.')
-        except:
-            log2(traceback.format_exc())
-            pass
-
-        # if print_token:
-        log(f'IDP_TOKEN={login.ser() if login else ""}')
-
-        return state
-
-    def completion(self, _: ReplState):
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{Login.COMMAND}\t SSO login'