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

adam/__init__.py

@@ -0,0 +1 @@
+from .version import __version__, __release__

adam/app_session.py

@@ -0,0 +1,182 @@
+import json
+import threading
+import time
+import traceback
+import requests
+from urllib.parse import urlparse
+
+from adam.log import Log
+from adam.repl_state import ReplState
+from adam.sso.idp import Idp
+from adam.sso.idp_login import IdpLogin
+from adam.config import Config
+from adam.utils import debug, json_to_csv, lines_to_tabular, log, log2
+from adam.apps import Apps
+
+class AppLogin:
+    def __init__(self, session: requests.Session, app_access_token: str, idp_uri: str, idp_login: IdpLogin = None):
+        self.session = session
+        self.app_access_token = app_access_token
+        self.idp_uri = idp_uri
+        self.idp_login = idp_login
+
+class NoAppIngressException(Exception):
+    pass
+
+class AppSession:
+    sessions_by_host = {}
+
+    def __init__(self, host: str = None, env: str = None):
+        self.host = host
+        self.env = env
+        self.app_login: AppLogin = None
+
+    def create(env: str, app: str, namespace: str = None) -> 'AppSession':
+        if not(host := Apps.app_host(env, app, namespace)):
+            raise NoAppIngressException('Cannot locate ingress for app.')
+
+        key = f'{host}/{env}'
+        if key in AppSession.sessions_by_host:
+            return AppSession.sessions_by_host[key]
+
+        session = AppSession(host, env)
+
+        AppSession.sessions_by_host[key] = session
+
+        return session
+
+    def run(env: str, app: str, namespace: str, type: str, action: str, payload: any = None, forced = False):
+        app_session: AppSession = AppSession.create(env, app, namespace)
+
+        def run0(app_login: AppLogin, retried: bool):
+            if app_login:
+                with app_login.session as session:
+                    uri = f'https://{app_session.host}/{env}/{app}/api/8/{type}/{action}'
+                    r = session.post(uri, json=payload, headers={
+                        'X-Request-Envelope': 'true'
+                    })
+
+                    if Config().is_debug():
+                        log2(f'{r.status_code} {uri}')
+                        log2(payload)
+
+                    if r.status_code >= 200 and r.status_code < 300 or r.status_code == 400:
+                        try:
+                            js = r.json()
+                            try:
+                                header, lines = json_to_csv(js, delimiter='\t')
+                                log(lines_to_tabular(lines, header=header, separator='\t'))
+                            except Exception as e:
+                                # traceback.print_exc(e)
+                                log(js)
+                        except:
+                            if urlparse(r.url).hostname != urlparse(uri).hostname and not retried:
+                                app_login = app_session.login(idp_uri=app_login.idp_uri, forced=forced, use_token_from_env=False, use_cached_creds=False)
+                                retried = True
+
+                                return run0(app_login, True)
+
+                            if r.text:
+                                log2(f'{r.status_code} {r.url} Failed parsing the results.')
+                                debug(r.text)
+                    else:
+                        log2(r.status_code)
+                        log2(r.text)
+
+        app_login = app_session.login(forced=forced)
+        run0(app_login, False)
+
+    def login(self, idp_uri: str = None, forced = False, use_token_from_env=True, use_cached_creds=True) -> AppLogin:
+        if not forced and self.app_login:
+            return self.app_login
+
+        idp_login: IdpLogin = Idp.login(self.host, idp_uri=idp_uri, forced=forced, use_token_from_env=use_token_from_env, use_cached_creds=use_cached_creds, verify=False)
+        if not idp_login:
+            log2(f"Invalid username/password.")
+
+            return None
+
+        if idp_login.state == 'EMPTY':
+            idp_login.state = IdpLogin.create_from_idp_uri(self.idp_redirect_url()).state
+
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        }
+        form_data = {
+            'state': idp_login.state,
+            'id_token': idp_login.id_token
+        }
+
+        stop_event = threading.Event()
+
+        session = idp_login.session
+        if not session:
+            session = requests.Session()
+
+        def login0():
+            try:
+                # oidc/login may hang
+                timeout = Config().get('app.login.timeout', 5)
+                debug(f'-> {idp_login.app_login_url}')
+                session.post(idp_login.app_login_url, headers=headers, data=form_data, timeout=timeout)
+            except Exception:
+                pass
+            finally:
+                stop_event.set()
+
+        my_thread = threading.Thread(target=login0, daemon=True)
+        my_thread.start()
+
+        app_access_token = None
+        while not app_access_token and not stop_event.is_set():
+            time.sleep(1)
+
+            try:
+                check_uri = Config().get('app.login.session-check-url', 'https://{host}/{env}/{app}/api/8/C3/userSessionToken')
+                check_uri = check_uri.replace('{host}', self.host).replace('{env}', self.env).replace('{app}', 'c3')
+                r = session.get(check_uri)
+                debug(f'{r.status_code} {check_uri}')
+
+                res_text = r.text
+                js = json.loads(res_text)
+                if 'signedToken' not in js:
+                    log2('Cannot get c3 access token, pleae re-login.')
+                    break
+
+                app_access_token = js['signedToken']
+                debug(f'{r.text}')
+
+                self.app_login = AppLogin(session, app_access_token, idp_uri)
+            except Exception:
+                try:
+                    need = urlparse(r.url).hostname
+                    if idp_login.idp_uri:
+                        idp_uri = r.url
+                        has = urlparse(idp_login.idp_uri).hostname
+                        msg = Config().get('app.login.another', "You're logged in to {has}. However, for this app, you need to log in to {need}.")
+                        msg = msg.replace('{has}', has).replace('{need}', need)
+                        log2(msg)
+                    else:
+                        log2(f"Invalid username/password.")
+                    break
+                finally:
+                    debug(traceback.format_exc())
+
+                    if 'res_text' in locals():
+                        Log.log_to_file(res_text)
+
+        return AppLogin(session, app_access_token, idp_uri, idp_login=idp_login)
+
+    def idp_redirect_url(self, show_endpoints = True) -> str:
+        # stgawsscpsr-c3-c3
+        uri = Config().get('app.login.url', 'https://{host}/{env}/{app}')
+        uri = uri.replace('{host}', self.host).replace('{env}', self.env).replace('{app}', 'c3')
+        r = requests.get(uri)
+
+        parsed_url = urlparse(r.url)
+        if show_endpoints:
+            log2(f'{r.status_code} {uri} <-> {parsed_url.hostname}...')
+        if r.status_code < 200 or r.status_code > 299:
+            return None
+
+        return r.url

{walker → adam}/apps.py

@@ -1,18 +1,15 @@
 import copy
 import functools
-import importlib
-import os
-from pathlib import Path
 import re
 from typing import cast
 import yaml
 
-from walker.config import Config
-from walker.k8s_utils.ingresses import Ingresses
+from adam.config import Config
+from adam.utils_k8s.ingresses import Ingresses
 
 from . import __version__
-from walker.k8s_utils.services import Services
-from walker.utils import log2
+from adam.utils_k8s.services import Services
+from adam.utils import copy_config_file
 
 class AppAction:
     def __init__(self, name: str, payload: str = None, args: dict[str, str] = None, help: str = None):
@@ -135,24 +132,11 @@ class Apps:
                 with open(path) as f:
                     self.actions = cast(dict[str, any], yaml.safe_load(f))
             except:
-                self.copy_apps_file()
+                with open(copy_config_file(f'apps.yaml.{__version__}', 'adam.embedded_apps')) as f:
+                    self.actions = cast(dict[str, any], yaml.safe_load(f))
         elif not hasattr(self, 'actions'):
-            self.copy_apps_file()
-
-    def copy_apps_file(self):
-        dir = f'{Path.home()}/.kaqing'
-        path = f'{dir}/apps.yaml.{__version__}'
-        if not os.path.exists(path):
-            os.makedirs(dir, exist_ok=True)
-            module = importlib.import_module('walker.embedded_apps')
-            with open(path, 'w') as f:
-                yaml.dump(module.apps(), f, default_flow_style=False)
-            log2(f'Default apps.yaml has been written to {path}.')
-
-        with open(path) as f:
-            self.actions = cast(dict[str, any], yaml.safe_load(f))
-
-        return path
+            with open(copy_config_file(f'apps.yaml.{__version__}', 'adam.embedded_apps')) as f:
+                self.actions = cast(dict[str, any], yaml.safe_load(f))
 
     def app_types(self) -> list[AppType]:
         return AppType.create(self.actions)

{walker → adam}/batch.py

@@ -1,36 +1,42 @@
 import click
 
-from walker.commands.bash import Bash
-from walker.commands.check import Check, CheckCommandHelper
-from walker.commands.cp import ClipboardCopy, CopyCommandHelper
-from walker.commands.command import Command
-from walker.commands.command_helpers import ClusterCommandHelper, ClusterOrPodCommandHelper, PodCommandHelper
-from walker.commands.cqlsh import CqlCommandHelper, Cqlsh
-from walker.commands.frontend.setup import Setup, SetupCommandHelper
-from walker.commands.frontend.teardown import TearDown, TearDownCommandHelper
-from walker.commands.issues import Issues
-from walker.commands.login import Login
-from walker.commands.logs import Logs
-from walker.commands.ls import Ls
-from walker.commands.medusa.medusa import Medusa
-from walker.commands.nodetool import NodeTool, NodeToolCommandHelper
-from walker.commands.postgres.postgres import Postgres, PostgresCommandHelper
-from walker.commands.preview_table import PreviewTable
-from walker.commands.processes import Processes
-from walker.commands.reaper.reaper import Reaper, ReaperCommandHelper
-from walker.commands.repair.repair import Repair, RepairCommandHelper
-from walker.commands.report import Report
-from walker.commands.restart import Restart
-from walker.commands.rollout import RollOut
-from walker.commands.show.show import Show, ShowCommandHelper
-from walker.commands.status import Status as StatusCmd
-from walker.commands.storage import Storage
-from walker.commands.user_entry import UserEntry
-from walker.commands.watch import Watch
-from walker.k8s_utils.kube_context import KubeContext
-from walker.repl import enter_repl
-from walker.repl_state import ReplState
-from walker.cli_group import cli
+from adam.commands.audit.audit import Audit, AuditCommandHelper
+from adam.commands.bash.bash import Bash
+from adam.commands.check import Check, CheckCommandHelper
+from adam.commands.cp import ClipboardCopy, CopyCommandHelper
+from adam.commands.command import Command
+from adam.commands.command_helpers import ClusterCommandHelper, ClusterOrPodCommandHelper, PodCommandHelper
+from adam.commands.cql.cqlsh import CqlCommandHelper, Cqlsh
+from adam.commands.deploy.deploy import Deploy, DeployCommandHelper
+from adam.commands.deploy.undeploy import Undeploy, UndeployCommandHelper
+from adam.commands.issues import Issues
+from adam.commands.login import Login
+from adam.commands.logs import Logs
+from adam.commands.ls import Ls
+from adam.commands.medusa.medusa import Medusa
+from adam.commands.nodetool import NodeTool, NodeToolCommandHelper
+from adam.commands.postgres.postgres import Postgres, PostgresCommandHelper
+from adam.commands.preview_table import PreviewTable
+from adam.commands.reaper.reaper import Reaper, ReaperCommandHelper
+from adam.commands.repair.repair import Repair, RepairCommandHelper
+from adam.commands.report import Report
+from adam.commands.restart import Restart
+from adam.commands.rollout import RollOut
+from adam.commands.show.show import Show, ShowCommandHelper
+from adam.commands.watch import Watch
+from adam.utils_k8s.kube_context import KubeContext
+from adam.repl import enter_repl
+from adam.repl_state import ReplState
+from adam.cli_group import cli
+
+@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=AuditCommandHelper, help='Run audit functions.')
+@click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
+@click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
+@click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
+@click.argument('extra_args', nargs=-1, metavar='repair', type=click.UNPROCESSED)
+def audit(kubeconfig: str, config: str, param: list[str], extra_args):
+    run_command(Audit(), kubeconfig, config, param, None, None, None, extra_args, device=ReplState.L)
+
 
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help='Run a single bash command.')
 @click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
@@ -80,6 +86,16 @@ def cql(kubeconfig: str, config: str, param: list[str], cluster: str, namespace:
     run_command(Cqlsh(), kubeconfig, config, param, cluster, namespace, pod, extra_args)
 
 
+@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=DeployCommandHelper, help='Setup.')
+@click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
+@click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
+@click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
+@click.option('--namespace', '-n', required=False, metavar='namespace', help='Kubernetes namespace')
+@click.argument('extra_args', nargs=-1, metavar='<pod>', type=click.UNPROCESSED)
+def deploy(kubeconfig: str, config: str, param: list[str], namespace: str, extra_args):
+    run_command(Deploy(), kubeconfig, config, param, None, namespace, None, extra_args)
+
+
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help="Print Qing's issues.")
 @click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
 @click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
@@ -93,7 +109,7 @@ def issues(kubeconfig: str, config: str, param: list[str], cluster: str, namespa
     run_command(Issues(), kubeconfig, config, param, cluster, namespace, pod, ('-s',) + extra_args if show else extra_args)
 
 
-@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=PodCommandHelper, help='Get cassandra log.')
+@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=PodCommandHelper, help='SSO login.')
 @click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
 @click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
 @click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
@@ -173,19 +189,6 @@ def preview(kubeconfig: str, config: str, param: list[str], cluster: str, namesp
     run_command(PreviewTable(), kubeconfig, config, param, cluster, namespace, pod, extra_args)
 
 
-@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help='Show process overview from Cassandra nodes.')
-@click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
-@click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
-@click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
-@click.option('--cluster', '-c', required=False, metavar='statefulset', help='Kubernetes statefulset name')
-@click.option('--namespace', '-n', required=False, metavar='namespace', help='Kubernetes namespace')
-@click.option('--pod', '-p', required=False, metavar='pod', help='Kubernetes pod name')
-@click.option('--show', '-s', is_flag=True, help='show output from Cassandra nodes')
-@click.argument('extra_args', nargs=-1, metavar='<cluster|pod>', type=click.UNPROCESSED)
-def processes(kubeconfig: str, config: str, param: list[str], cluster: str, namespace: str, pod: str, show: bool, extra_args):
-    run_command(Processes(), kubeconfig, config, param, cluster, namespace, pod, ('-s',) + extra_args if show else extra_args)
-
-
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ReaperCommandHelper, help='Execute Cassandra Reaper operations.')
 @click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
 @click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
@@ -245,16 +248,6 @@ def rollout(kubeconfig: str, config: str, param: list[str], cluster: str, namesp
     run_command(RollOut(), kubeconfig, config, param, cluster, namespace, None, extra_args)
 
 
-@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=SetupCommandHelper, help='Setup.')
-@click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
-@click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
-@click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
-@click.option('--namespace', '-n', required=False, metavar='namespace', help='Kubernetes namespace')
-@click.argument('extra_args', nargs=-1, metavar='<pod>', type=click.UNPROCESSED)
-def setup(kubeconfig: str, config: str, param: list[str], namespace: str, extra_args):
-    run_command(Setup(), kubeconfig, config, param, None, namespace, None, extra_args)
-
-
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ShowCommandHelper, help='Show configuration or kubectl commands.')
 @click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
 @click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
@@ -267,50 +260,14 @@ def show(kubeconfig: str, config: str, param: list[str], cluster: str, namespace
     run_command(Show(), kubeconfig, config, param, cluster, namespace, pod, extra_args)
 
 
-@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help='Show combined nodetool status from Cassandra nodes.')
-@click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
-@click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
-@click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
-@click.option('--cluster', '-c', required=False, metavar='statefulset', help='Kubernetes statefulset name')
-@click.option('--namespace', '-n', required=False, metavar='namespace', help='Kubernetes namespace')
-@click.option('--pod', '-p', required=False, metavar='pod', help='Kubernetes pod name')
-@click.option('--show', '-s', is_flag=True, help='show output from Cassandra nodes')
-@click.argument('extra_args', nargs=-1, metavar='<cluster|pod>', type=click.UNPROCESSED)
-def status(kubeconfig: str, config: str, param: list[str], cluster: str, namespace: str, pod: str, show: bool, extra_args):
-    run_command(StatusCmd(), kubeconfig, config, param, cluster, namespace, pod, ('-s',) + extra_args if show else extra_args)
-
-
-@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help='Show storage overview from Cassandra nodes.')
-@click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
-@click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
-@click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
-@click.option('--cluster', '-c', required=False, metavar='statefulset', help='Kubernetes statefulset name')
-@click.option('--namespace', '-n', required=False, metavar='namespace', help='Kubernetes namespace')
-@click.option('--pod', '-p', required=False, metavar='pod', help='Kubernetes pod name')
-@click.option('--show', '-s', is_flag=True, help='show output from Cassandra nodes')
-@click.argument('extra_args', nargs=-1, metavar='<cluster|pod>', type=click.UNPROCESSED)
-def storage(kubeconfig: str, config: str, param: list[str], cluster: str, namespace: str, pod: str, show: bool, extra_args):
-    run_command(Storage(), kubeconfig, config, param, cluster, namespace, pod, ('-s',) + extra_args if show else extra_args)
-
-
-@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=TearDownCommandHelper, help='Teardown.')
-@click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
-@click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
-@click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
-@click.option('--namespace', '-n', required=False, metavar='namespace', help='Kubernetes namespace')
-@click.argument('extra_args', nargs=-1, metavar='<pod>', type=click.UNPROCESSED)
-def teardown(kubeconfig: str, config: str, param: list[str], namespace: str, extra_args):
-    run_command(TearDown(), kubeconfig, config, param, None, namespace, None, extra_args)
-
-
-@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=PodCommandHelper, help='Get cassandra log.')
+@cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=UndeployCommandHelper, help='Undeploy.')
 @click.option('--kubeconfig', '-k', required=False, metavar='path', help='path to kubeconfig file')
 @click.option('--config', default='params.yaml', metavar='path', help='path to kaqing parameters file')
 @click.option('--param', '-v', multiple=True, metavar='<key>=<value>', help='parameter override')
 @click.option('--namespace', '-n', required=False, metavar='namespace', help='Kubernetes namespace')
 @click.argument('extra_args', nargs=-1, metavar='<pod>', type=click.UNPROCESSED)
-def entry(kubeconfig: str, config: str, param: list[str], namespace: str, extra_args):
-    run_command(UserEntry(), kubeconfig, config, param, None, namespace, None, extra_args)
+def undeploy(kubeconfig: str, config: str, param: list[str], namespace: str, extra_args):
+    run_command(Undeploy(), kubeconfig, config, param, None, namespace, None, extra_args)
 
 
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help='Watch pods in cluster.')
@@ -324,14 +281,14 @@ def watch(kubeconfig: str, config: str, param: list[str], cluster: str, namespac
     run_command(Watch(), kubeconfig, config, param, cluster, namespace, None, extra_args)
 
 
-def run_command(cmd: Command, kubeconfig: str, config: str, params: list[str], cluster:str, namespace: str, pod: str, extra_args):
-    is_user_entry = cmd.command() == UserEntry().command()
+def run_command(cmd: Command, kubeconfig: str, config: str, params: list[str], cluster:str, namespace: str, pod: str, extra_args, device=ReplState.C):
+    is_user_entry = False
 
     KubeContext.init_config(kubeconfig, is_user_entry=is_user_entry)
     if not KubeContext.init_params(config, params, is_user_entry=is_user_entry):
         return
 
-    state = ReplState(ns_sts=cluster, pod=pod, namespace=namespace)
+    state = ReplState(device=device, ns_sts=cluster, pod=pod, namespace=namespace)
     if cmd.command() == 'pg' and not extra_args:
         state, _ = state.apply_args(extra_args)
         state.device = ReplState.P

{walker → adam}/checks/check.py

@@ -1,8 +1,8 @@
 from abc import abstractmethod
 
-from walker.checks.check_context import CheckContext
-from walker.checks.check_result import CheckResult
-from walker.checks.issue import Issue
+from adam.checks.check_context import CheckContext
+from adam.checks.check_result import CheckResult
+from adam.checks.issue import Issue
 
 class Check:
     """Abstract base class for checks"""

{walker → adam}/checks/check_result.py

@@ -1,4 +1,4 @@
-from walker.checks.issue import Issue
+from adam.checks.issue import Issue
 
 class CheckResult:
     def __init__(self, name: str, details: any = None, issues: list[Issue] = None):

adam/checks/check_utils.py

@@ -0,0 +1,65 @@
+from adam.checks.check import Check
+from adam.checks.check_context import CheckContext
+from adam.checks.check_result import CheckResult
+from adam.checks.compactionstats import CompactionStats
+from adam.checks.cpu import Cpu
+from adam.checks.disk import Disk
+from adam.checks.gossip import Gossip
+from adam.checks.issue import Issue
+from adam.checks.memory import Memory
+from adam.checks.status import Status
+from adam.config import Config
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.secrets import Secrets
+from adam.utils_k8s.statefulsets import StatefulSets
+from adam.utils import parallelize, 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_out=True):
+    if not checks:
+        checks = all_checks()
+
+    sts_ns: list[tuple[str, str]] = StatefulSets.list_sts_name_and_ns()
+
+    sts_ns_pods: list[tuple[str, str, str]] = []
+    for sts, ns in sts_ns:
+        if (not cluster or cluster == sts) and (not namespace or namespace == ns):
+            pods = StatefulSets.pods(sts, ns)
+            for pod_name in [pod.metadata.name for pod in pods]:
+                if not pod or pod == pod_name:
+                    sts_ns_pods.append((sts, ns, pod_name))
+
+    with parallelize(sts_ns_pods, Config().action_workers('issues', 30), msg='d`Running|Ran checks on {size} pods') as exec:
+        return exec.map(lambda sts_ns_pod: run_checks_on_pod(checks, sts_ns_pod[0], sts_ns_pod[1], sts_ns_pod[2], show_out))
+
+def run_checks_on_pod(checks: list[Check], cluster: str = None, namespace: str = None, pod: str = None, show_out=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_out))
+        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 → adam}/checks/compactionstats.py

@@ -1,11 +1,11 @@
 import re
 
-from walker.checks.check import Check
-from walker.checks.check_context import CheckContext
-from walker.checks.check_result import CheckResult
-from walker.checks.issue import Issue
-from walker.config import Config
-from walker.k8s_utils.cassandra_nodes import CassandraNodes
+from adam.checks.check import Check
+from adam.checks.check_context import CheckContext
+from adam.checks.check_result import CheckResult
+from adam.checks.issue import Issue
+from adam.config import Config
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
 
 class CompactionStats(Check):
     def name(self):

{walker → adam}/checks/cpu.py

@@ -1,12 +1,13 @@
 from kubernetes.utils import parse_quantity
 
-from walker.checks.check import Check
-from walker.checks.check_context import CheckContext
-from walker.checks.check_result import CheckResult
-from walker.checks.issue import Issue
-from walker.config import Config
-from walker.k8s_utils.cassandra_nodes import CassandraNodes
-from walker.k8s_utils.custom_resources import CustomResources
+from adam.checks.check import Check
+from adam.checks.check_context import CheckContext
+from adam.checks.check_result import CheckResult
+from adam.checks.issue import Issue
+from adam.config import Config
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.custom_resources import CustomResources
+from adam.utils_k8s.pods import Pods
 
 class Cpu(Check):
     def name(self):
@@ -20,10 +21,15 @@ class Cpu(Check):
             'namespace': ctx.namespace,
             'statefulset': ctx.statefulset,
             'cpu': 'Unknown',
-            'idle': 'Unknown'
+            'idle': 'Unknown',
+            'limit': 'NA'
         }
 
         try:
+            container = Pods.get_container(ctx.namespace, ctx.pod, container_name='cassandra')
+            if container.resources.limits and "cpu" in container.resources.limits:
+                details['limit'] = container.resources.limits["cpu"]
+
             idle = 'Unknown'
             result = CassandraNodes.exec(ctx.pod, ctx.namespace, "mpstat 5 2 | grep Average | awk '{print $NF}'", show_out=ctx.show_output)
             lines = result.stdout.strip(' \r\n').split('\n')

adam/checks/cpu_metrics.py

@@ -0,0 +1,52 @@
+from kubernetes.utils import parse_quantity
+
+from adam.checks.check import Check
+from adam.checks.check_context import CheckContext
+from adam.checks.check_result import CheckResult
+from adam.checks.issue import Issue
+from adam.config import Config
+from adam.utils_k8s.custom_resources import CustomResources
+from adam.utils_k8s.pods import Pods
+
+class CpuMetrics(Check):
+    def name(self):
+        return 'cpu-metrics'
+
+    def check(self, ctx: CheckContext) -> CheckResult:
+        issues: list[Issue] = []
+
+        details = {
+            'name': ctx.pod,
+            'namespace': ctx.namespace,
+            'statefulset': ctx.statefulset,
+            'cpu': 'Unknown',
+            'limit': 'NA'
+        }
+
+        try:
+            container = Pods.get_container(ctx.namespace, ctx.pod, container_name='cassandra')
+            if container.resources.limits and "cpu" in container.resources.limits:
+                details['limit'] = container.resources.limits["cpu"]
+
+            metrics = CustomResources.get_metrics(ctx.namespace, ctx.pod, container_name='cassandra')
+            usage = 'Unknown'
+            if metrics:
+                usage = details['cpu'] = metrics["usage"]["cpu"]
+
+            cpu_threshold = Config().get('checks.cpu-threshold', 0.0)
+            if  cpu_threshold != 0.0 and usage != "Unknown" and parse_quantity(usage) > cpu_threshold:
+                issues.append(Issue(
+                    statefulset=ctx.statefulset,
+                    namespace=ctx.namespace,
+                    pod=ctx.pod,
+                    category='cpu',
+                    desc=f'CPU is too busy: {usage}',
+                    suggestion=f"qing restart {ctx.pod}@{ctx.namespace}"
+                ))
+        except Exception as e:
+            issues.append(self.issue_from_err(sts_name=ctx.statefulset, ns=ctx.namespace, pod_name=ctx.pod, exception=e))
+
+        return CheckResult(self.name(), details, issues)
+
+    def help(self):
+        return f'{CpuMetrics().name()}: check cpu busy percentage with metrics'