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

walker/checks/check_utils.py

@@ -1,97 +0,0 @@
-from collections.abc import Callable
-from concurrent.futures import ThreadPoolExecutor, as_completed
-import time
-
-from walker.checks.check import Check
-from walker.checks.check_context import CheckContext
-from walker.checks.check_result import CheckResult
-from walker.checks.compactionstats import CompactionStats
-from walker.checks.cpu import Cpu
-from walker.checks.disk import Disk
-from walker.checks.gossip import Gossip
-from walker.checks.issue import Issue
-from walker.checks.memory import Memory
-from walker.checks.status import Status
-from walker.config import Config
-from walker.k8s_utils.cassandra_nodes import CassandraNodes
-from walker.k8s_utils.kube_context import KubeContext
-from walker.k8s_utils.secrets import Secrets
-from walker.k8s_utils.statefulsets import StatefulSets
-from walker.utils import elapsed_time, log2
-
-def all_checks() -> list[Check]:
-    return [CompactionStats(), Cpu(), Gossip(), Memory(), Disk(), Status()]
-
-def checks_from_csv(check_str: str):
-    checks: list[Check] = []
-
-    checks_by_name = {c.name(): c for c in all_checks()}
-
-    if check_str:
-        for check_name in check_str.strip(' ').split(','):
-            if check_name in checks_by_name:
-                checks.append(checks_by_name[check_name])
-            else:
-                log2(f'Invalid check name: {check_name}.')
-
-                return None
-
-    return checks
-
-def run_checks(cluster: str = None, namespace: str = None, pod: str = None, checks: list[Check] = None, show_output=True):
-    if not checks:
-        checks = all_checks()
-
-    sss: list[tuple[str, str]] = StatefulSets.list_sts_name_and_ns()
-
-    action = 'issues'
-    crs: list[CheckResult] = []
-
-    def on_clusters(f: Callable[[any, list[str]], any]):
-        for ss, ns in sss:
-            if (not cluster or cluster == ss) and (not namespace or namespace == ns):
-                pods = StatefulSets.pods(ss, ns)
-                for pod_name in [pod.metadata.name for pod in pods]:
-                    if not pod or pod == pod_name:
-                        f(ss, ns, pod_name, show_output)
-
-    max_workers = Config().action_workers(action, 30)
-    if max_workers < 2:
-        def serial(ss, ns, pod_name, show_output):
-            if not pod or pod == pod_name:
-                crs.append(run_checks_on_pod(checks, ss[0], ns, pod_name, show_output))
-
-        on_clusters(serial)
-    else:
-        if KubeContext.show_parallelism():
-            log2(f'Executing on all nodes from statefulset with {max_workers} workers...')
-        start_time = time.time()
-        try:
-            futures = []
-            with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                def submit(ss, ns, pod_name, show_output):
-                    f = executor.submit(run_checks_on_pod, checks, ss, ns, pod_name, show_output,)
-                    if f: futures.append(f)
-
-                on_clusters(submit)
-
-            crs = [future.result() for future in as_completed(futures)]
-        finally:
-            if KubeContext.show_parallelism():
-                log2(f"Parallel {action} elapsed time: {elapsed_time(start_time)} with {max_workers} workers")
-
-    return crs
-
-def run_checks_on_pod(checks: list[Check], cluster: str = None, namespace: str = None, pod: str = None, show_output=True):
-    host_id = CassandraNodes.get_host_id(pod, namespace)
-    user, pw = Secrets.get_user_pass(pod, namespace)
-    results = {}
-    issues: list[Issue] = []
-    for c in checks:
-        check_results = c.check(CheckContext(cluster, host_id, pod, namespace, user, pw, show_output=show_output))
-        if check_results.details:
-            results = results | {check_results.name: check_results.details}
-        if check_results.issues:
-            issues.extend(check_results.issues)
-
-    return CheckResult(None, results, issues)

walker/columns/columns.py

@@ -1,43 +0,0 @@
-from walker.columns.column import Column
-from walker.columns.compactions import Compactions
-from walker.columns.cpu import Cpu
-from walker.columns.dir_data import DataDir
-from walker.columns.dir_snapshots import SnapshotsDir
-from walker.columns.gossip import Gossip
-from walker.columns.host_id import HostId
-from walker.columns.memory import Memory
-from walker.columns.node_address import NodeAddress
-from walker.columns.node_load import NodeLoad
-from walker.columns.node_owns import NodeOwns
-from walker.columns.node_status import NodeStatus
-from walker.columns.node_tokens import NodeTokens
-from walker.columns.pod_name import PodName
-from walker.columns.volume_cassandra import CassandraVolume
-from walker.columns.volume_root import RootVolume
-
-def collect_checks(columns: list[Column]):
-    checks = sum([c.checks() for c in columns], [])
-    return {cc.name(): cc for cc in checks}.values()
-
-class Columns:
-    COLUMNS_BY_NAME = None
-
-    def all_columns():
-        return [Compactions(), Cpu(), DataDir(), SnapshotsDir(), Gossip(), HostId(), Memory(),
-                NodeAddress(), NodeLoad(), NodeOwns(), NodeStatus(),NodeTokens(), PodName(), CassandraVolume(), RootVolume()]
-
-    def columns_by_name():
-        return {c.name(): c.__class__ for c in Columns.all_columns()}
-
-    def create_columns(columns: str):
-        if not Columns.COLUMNS_BY_NAME:
-            Columns.COLUMNS_BY_NAME = Columns.columns_by_name()
-
-        cols = []
-        for name in columns.split(','):
-            name = name.strip(' ')
-            if not name in Columns.COLUMNS_BY_NAME:
-                return None
-            cols.append(Columns.COLUMNS_BY_NAME[name]())
-
-        return cols

walker/commands/add_user.py

@@ -1,68 +0,0 @@
-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.utils import log, log2
-
-class AddAdmin(Command):
-    COMMAND = 'add admin'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(AddAdmin, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return AddAdmin.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]
-
-        login: IdpLogin = None
-        while not login:
-            try:
-                if not(host := Apps.app_host('c3', 'c3', state.namespace)):
-                    log2('Cannot locate ingress for app.')
-                    username = None
-                    continue
-
-                if not (login := Idp.login(host, username=username, use_cached=False)):
-                    log2('Invalid username/password. Please try again.')
-                    username = None
-            except:
-                log2(traceback.format_exc())
-                pass
-
-        if print_token:
-            log(f'IDP_TOKEN={login.ser()}')
-
-        return state
-
-    def completion(self, _: ReplState):
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{AddAdmin.COMMAND}\t SSO login'

walker/commands/app.py

@@ -1,67 +0,0 @@
-import json
-
-from walker.apps import Apps
-from walker.commands.command import Command
-from walker.repl_state import ReplState, RequiredState
-from walker.app_session import AppSession
-from walker.utils import log2
-
-class App(Command):
-    COMMAND = 'app'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(App, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return App.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, app_required=RequiredState.APP_APP):
-            return state
-
-        args, forced = Command.extract_options(args, '--force')
-
-        if not args:
-            return 'arg missing'
-
-        t_f = args[0].split('.')
-        if len(t_f) < 2:
-            return 'arg missing'
-
-        payload, valid = Apps().payload(t_f[0], t_f[1], args[1:] if len(args) > 1 else [])
-        if not valid:
-            log2('Missing one or more action arguments.')
-            return state
-
-        if payload:
-            try:
-                payload = json.loads(payload)
-            except json.decoder.JSONDecodeError as e:
-                log2(f'Invalid json argument: {e}')
-                return state
-
-        AppSession.run(state.app_env, state.app_app, state.namespace, t_f[0], t_f[1], payload=payload, forced=forced)
-
-        return state
-
-    def completion(self, state: ReplState):
-        if state.app_app:
-            return super().completion(state, {'--force': None})
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f"{App.COMMAND} [--force]\t post app API query with type and function"

walker/commands/bash.py

@@ -1,87 +0,0 @@
-from walker.commands.command import Command
-from walker.k8s_utils.cassandra_clusters import CassandraClusters
-from walker.k8s_utils.cassandra_nodes import CassandraNodes
-from walker.repl_state import BashSession, ReplState, RequiredState
-
-class Bash(Command):
-    COMMAND = 'bash'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Bash, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Bash.COMMAND
-
-    def required(self):
-        return RequiredState.CLUSTER_OR_POD
-
-    def run(self, cmd: str, s0: ReplState):
-        if not(args := self.args(cmd)):
-            return super().run(cmd, s0)
-
-        state, args = self.apply_state(args, s0)
-        if not self.validate_state(state):
-            return state
-
-        if state.in_repl:
-            r = self.exec_with_dir(s0, args)
-            if not r:
-                state.exit_bash()
-
-                return 'inconsistent pwd'
-
-            return r
-        else:
-            a = ' '.join(args)
-            command = f'bash -c "{a}"'
-
-            if state.pod:
-                CassandraNodes.exec(state.pod, state.namespace, command, show_out=True)
-            elif state.sts:
-                CassandraClusters.exec(state.sts, state.namespace, command, action='bash', show_out=True)
-
-            return state
-
-    def exec_with_dir(self, state: ReplState, args: list[str]):
-        session_just_created = False
-        if not args:
-            session_just_created = True
-            session = BashSession(state.device)
-            state.enter_bash(session)
-
-        if state.bash_session:
-            if args != ['pwd']:
-                if args:
-                    args.append('&&')
-                args.extend(['pwd', '>', f'/tmp/.qing-{state.bash_session.session_id}'])
-
-            if not session_just_created:
-                if pwd := state.bash_session.pwd(state):
-                    args = ['cd', pwd, '&&'] + args
-
-        a = ' '.join(args)
-        command = f'bash -c "{a}"'
-
-        rs = []
-
-        if state.pod:
-            rs = [CassandraNodes.exec(state.pod, state.namespace, command, show_out=not session_just_created)]
-        elif state.sts:
-            rs = CassandraClusters.exec(state.sts, state.namespace, command, action='bash', show_out=not session_just_created)
-
-        return rs
-
-    def completion(self, state: ReplState):
-        if state.pod or state.sts:
-            return {Bash.COMMAND: None}
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{Bash.COMMAND} [bash-commands]\t run bash'

walker/commands/cd.py

@@ -1,115 +0,0 @@
-from walker.commands.command import Command
-from walker.commands.postgres.postgres_session import PostgresSession
-from walker.k8s_utils.cassandra_clusters import CassandraClusters
-from walker.k8s_utils.kube_context import KubeContext
-from walker.k8s_utils.statefulsets import StatefulSets
-from walker.repl_state import ReplState
-from walker.utils import log2
-from walker.apps import Apps
-
-class Cd(Command):
-    COMMAND = 'cd'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Cd, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Cd.COMMAND
-
-    def run(self, cmd: str, state: ReplState):
-        if not(args := self.args(cmd)):
-            return super().run(cmd, state)
-
-        if len(args) < 2:
-            return state
-
-        arg = args[1]
-        for dir in arg.split('/'):
-            if state.device == ReplState.P:
-                if dir == '':
-                    state.pg_path = None
-                else:
-                    session = PostgresSession(state.namespace, state.pg_path)
-                    # patch up state.namespace from pg cd
-                    if not state.namespace and (ns := session.find_namespace(arg)):
-                        state.namespace = ns
-                    state.pg_path = session.directory(arg)
-            elif state.device == ReplState.A:
-                if dir == '':
-                    state.app_env = None
-                    state.app_app = None
-                elif dir == '..':
-                    if state.app_app:
-                        state.app_app = None
-                    else:
-                        state.app_env = None
-                else:
-                    if not state.app_env:
-                        tks = dir.split('@')
-                        if len(tks) > 1:
-                            state.namespace = tks[1]
-
-                        state.app_env = dir.split('@')[0]
-                    else:
-                        state.app_app = dir
-            else:
-                if dir == '':
-                    state.sts = None
-                    state.pod = None
-                elif dir == '..':
-                    if state.pod:
-                        state.pod = None
-                    else:
-                        state.sts = None
-                else:
-                    if not state.sts:
-                        ss_and_ns = dir.split('@')
-                        state.sts = ss_and_ns[0]
-                        state.namespace = ss_and_ns[1]
-                    elif not state.pod:
-                        p, _ = KubeContext.is_pod_name(dir)
-                        if p:
-                            state.pod = p
-                        else:
-                            names = CassandraClusters.pod_names_by_host_id(state.sts, state.namespace);
-                            if dir in names:
-                                state.pod = names[dir]
-                            else:
-                                log2('Not a valid pod name or host id.')
-
-        return state
-
-    def completion(self, state: ReplState):
-        if state.device == ReplState.P:
-            pg = PostgresSession(state.namespace, state.pg_path) if state.pg_path else None
-            if pg and pg.db:
-                return {Cd.COMMAND: {'..': None}}
-            elif pg and pg.host:
-                return {Cd.COMMAND: {'..': None} | {p['name']: None for p in pg.databases()}}
-            else:
-                return {Cd.COMMAND: {p: None for p in PostgresSession.hosts(state.namespace)}}
-        elif state.device == ReplState.A:
-            if state.app_app:
-                return {Cd.COMMAND: {'..': None}}
-            elif state.app_env:
-                return {Cd.COMMAND: {'..': None} | {app[0].split('-')[1]: None for app in Apps.apps(state.app_env)}}
-            else:
-                return {Cd.COMMAND: {'..': None} | {env[0]: None for env in Apps.envs()}}
-        else:
-            if state.pod:
-                return {Cd.COMMAND: {'..': None}}
-            elif state.sts:
-                return {Cd.COMMAND: {'..': None} | {p: None for p in StatefulSets.pod_names(state.sts, state.namespace)}}
-            else:
-                return {Cd.COMMAND: {p: None for p in StatefulSets.list_sts_names()}}
-
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{Cd.COMMAND} <path> | .. \t move around'

walker/commands/check.py

@@ -1,68 +0,0 @@
-import click
-
-from walker.checks.check_result import CheckResult
-from walker.checks.check_utils import all_checks, checks_from_csv, run_checks
-from walker.commands.command import Command
-from walker.commands.command_helpers import ClusterOrPodCommandHelper
-from walker.commands.issues import Issues
-from walker.repl_state import ReplState
-from walker.utils import lines_to_tabular, log
-
-class Check(Issues):
-    COMMAND = 'check'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(Check, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return Check.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'])
-
-        if not args:
-            if state.in_repl:
-                log(lines_to_tabular([check.help() for check in all_checks()], separator=':'))
-            else:
-                log('* Check name is missing.')
-                Command.display_help()
-            return 'arg missing'
-
-        checks = checks_from_csv(args[0])
-        if not checks:
-            return 'invalid check name'
-
-        results = run_checks(state.sts, state.namespace, state.pod, checks=checks, show_output=show)
-
-        issues = CheckResult.collect_issues(results)
-        Issues.show_issues(issues, in_repl=state.in_repl)
-
-        return issues if issues else 'no issues found'
-
-    def completion(self, _: ReplState):
-        return {Check.COMMAND: {check.name(): None for check in all_checks()}}
-
-    def help(self, _: ReplState):
-        return f'{Check.COMMAND} <check-name>\t run a single check'
-
-class CheckCommandHelper(click.Command):
-    def get_help(self, ctx: click.Context):
-        log(super().get_help(ctx))
-        log()
-        log('Check-names:')
-
-        for check in all_checks():
-            log(f'  {check.name()}')
-        log()
-
-        ClusterOrPodCommandHelper.cluter_or_pod_help()

walker/commands/command.py

@@ -1,104 +0,0 @@
-from abc import abstractmethod
-import copy
-import subprocess
-import sys
-
-from walker.repl_state import ReplState, RequiredState
-
-repl_cmds: list['Command'] = []
-
-class Command:
-    """Abstract base class for commands"""
-    def __init__(self, successor: 'Command'=None):
-        if not hasattr(self, '_successor'):
-            self._successor = successor
-
-    @abstractmethod
-    def command(self) -> str:
-        pass
-
-    # The chain of responsibility pattern
-    # Do not do child of child!!!
-    @abstractmethod
-    def run(self, cmd: str, state: ReplState):
-        if self._successor:
-            return self._successor.run(cmd, state)
-
-        return None
-
-    def completion(self, _: ReplState, leaf: dict[str, any] = None) -> dict[str, any]:
-        # COMMAND = 'reaper activate schedule'
-        d = leaf
-        for t in reversed(self.command().split(' ')):
-            d = {t: d}
-
-        return d
-
-    def required(self) -> RequiredState:
-        return None
-
-    def validate_state(self, state: ReplState, pg_required: RequiredState = None, app_required: RequiredState = None):
-        return state.validate(self.required(), pg_required=pg_required, app_required=app_required)
-
-    @abstractmethod
-    def help(self, state: ReplState) -> str:
-        pass
-
-    def args(self, cmd: str):
-        a = list(filter(None, cmd.split(' ')))
-        spec = self.command_tokens()
-        if spec != a[:len(spec)]:
-            return None
-
-        return a
-
-    def apply_state(self, args: list[str], state: ReplState, resolve_pg = True) -> tuple[ReplState, list[str]]:
-        return state.apply_args(args, cmd=self.command_tokens(), resolve_pg=resolve_pg)
-
-    def command_tokens(self):
-        return self.command().split(' ')
-
-    # build a chain-of-responsibility chain
-    def chain(cl: list['Command']):
-        global repl_cmds
-        repl_cmds.extend(cl)
-
-        cmds = cl[0]
-        cmd = cmds
-        for successor in cl[1:]:
-            cmd._successor = successor
-            cmd = successor
-
-        return cmds
-
-    def command_to_completion(self):
-        # COMMAND = 'reaper activate schedule'
-        d = None
-        for t in reversed(self.command().split(' ')):
-            d = {t: d}
-
-        return d
-
-    def display_help():
-        args = copy.copy(sys.argv)
-        args.extend(['--help'])
-        subprocess.run(args)
-
-    def extract_options(args: list[str], names: list[str]):
-        found: list[str] = []
-
-        new_args: list[str] = []
-        for arg in args:
-            if arg in names:
-                found.append(arg)
-            else:
-                new_args.append(arg)
-
-        return new_args, found
-
-    def print_chain(cmd: 'Command'):
-        print(f'{cmd.command()}', end = '')
-        while s := cmd._successor:
-            print(f'-> {s.command()}', end = '')
-            cmd = s
-        print()