kaqing 1.98.15__py3-none-any.whl → 2.0.145__py3-none-any.whl

adam/commands/deploy/deploy_pod.py

@@ -0,0 +1,110 @@
+from kubernetes import client
+
+from adam.commands.command import Command
+from adam.commands.deploy.deploy_utils import deploy_frontend, gen_labels
+from adam.commands.deploy.undeploy_pod import UndeployPod
+from adam.config import Config
+from adam.utils_k8s.config_maps import ConfigMaps
+from adam.utils_k8s.deployment import Deployments
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.service_accounts import ServiceAccounts
+from adam.utils_k8s.volumes import ConfigMapMount
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import ing, log2
+
+class DeployPod(Command):
+    COMMAND = 'deploy pod'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DeployPod, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DeployPod.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
+
+        args, forced = Command.extract_options(args, '--force')
+        if forced:
+            UndeployPod().run(UndeployPod.COMMAND, state)
+
+        if KubeContext.in_cluster():
+            log2('This is doable only from outside of the Kubernetes cluster.')
+            return state
+
+        sa_name = Config().get('pod.sa.name', 'ops')
+        sa_proto = Config().get('pod.sa.proto', 'c3')
+        additional_cluster_roles = Config().get('pod.sa.additional-cluster-roles', 'c3aiops-k8ssandra-operator').split(',')
+        label_selector = Config().get('pod.label-selector', 'run=ops')
+        labels = gen_labels(label_selector)
+
+        with ing('Creating service account'):
+            ServiceAccounts.replicate(sa_name, state.namespace, sa_proto, labels=labels, add_cluster_roles=additional_cluster_roles)
+
+        settings_filename = 'settings.yaml'
+        settings_path = f'/kaqing/{settings_filename}'
+        settings_data = None
+        try:
+            with open(settings_filename, 'r') as file:
+                settings_data = file.read()
+        except:
+            try:
+                with open(settings_path, 'r') as file:
+                    settings_data = file.read()
+            except:
+                pass
+
+        if not settings_data:
+            log2(f'{settings_filename} not found.')
+            return state
+
+        cm_name = Config().get('pod.cm.name', 'ops')
+        map_data = {
+            settings_filename : settings_data
+        }
+        with ing('Creating config map'):
+            ConfigMaps.create(cm_name, state.namespace, map_data, labels=labels)
+
+        pod_name = Config().get('pod.name', 'ops')
+        image = Config().get('pod.image', 'seanahnsf/kaqing')
+        security_context = client.V1SecurityContext(
+            capabilities=client.V1Capabilities(
+                add=["SYS_PTRACE"]
+            )
+        )
+        with ing('Creating deployment'):
+            Deployments.create(state.namespace,
+                                pod_name,
+                                image,
+                                env={'NAMESPACE': state.namespace},
+                                container_security_context=security_context,
+                                labels=labels,
+                                sa_name=sa_name,
+                                config_map_mount=ConfigMapMount(cm_name, settings_filename, settings_path))
+
+        uri = deploy_frontend(pod_name, state.namespace, label_selector)
+
+        Pods.wait_for_running(state.namespace, pod_name, msg=f'In moments, ops pod will be available at {uri}.', label_selector=label_selector)
+
+        return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'--force': None})
+
+    def help(self, _: ReplState):
+        return f'{DeployPod.COMMAND} [--force]\t deploy Ops pod, --force to undeploy first'

adam/commands/deploy/deploy_utils.py

@@ -0,0 +1,29 @@
+from adam.app_session import AppSession
+from adam.utils import ing
+from adam.utils_k8s.ingresses import Ingresses
+from adam.utils_k8s.services import Services
+
+def deploy_frontend(name: str, namespace: str, label_selector: str):
+    app_session: AppSession = AppSession.create('c3', 'c3', namespace)
+    port = 7678
+    labels = gen_labels(label_selector)
+    with ing('Creating service'):
+        Services.create_service(name, namespace, port, labels, labels=labels)
+    with ing('Creating ingress'):
+        Ingresses.create_ingress(name, 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': '/'
+        }, labels=labels)
+
+    return f'https://{app_session.host}/c3/c3/ops'
+
+def undeploy_frontend(namespace: str, label_selector: str):
+    with ing('Deleting ingress'):
+        Ingresses.delete_ingresses(namespace, label_selector=label_selector)
+    with ing('Deleting service'):
+        Services.delete_services(namespace, label_selector=label_selector)
+
+def gen_labels(label_selector: str):
+    kv = label_selector.split('=')
+    return {kv[0]: kv[1]}

adam/commands/deploy/undeploy.py

@@ -0,0 +1,48 @@
+import click
+
+from adam.commands.command import Command
+from adam.commands.deploy.undeploy_frontend import UndeployFrontend
+from adam.commands.deploy.undeploy_pg_agent import UndeployPgAgent
+from adam.commands.deploy.undeploy_pod import UndeployPod
+from adam.repl_state import ReplState, RequiredState
+
+class Undeploy(Command):
+    COMMAND = 'undeploy'
+    reaper_login = None
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Undeploy, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Undeploy.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)
+
+        if not self.validate_state(state):
+            return state
+
+        return super().intermediate_run(cmd, state, args, Undeploy.cmd_list())
+
+    def cmd_list():
+        return [UndeployFrontend(), UndeployPod(), UndeployPgAgent()]
+
+    def completion(self, state: ReplState):
+        if state.sts:
+            return super().completion(state)
+
+        return {}
+
+class UndeployCommandHelper(click.Command):
+    def get_help(self, ctx: click.Context):
+        Command.intermediate_help(super().get_help(ctx), Undeploy.COMMAND, Undeploy.cmd_list())

adam/commands/deploy/undeploy_frontend.py

@@ -0,0 +1,41 @@
+from adam.commands.command import Command
+from adam.commands.deploy.deploy_utils import undeploy_frontend
+from adam.config import Config
+from adam.repl_state import ReplState, RequiredState
+
+class UndeployFrontend(Command):
+    COMMAND = 'undeploy frontend'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(UndeployFrontend, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return UndeployFrontend.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
+
+        label_selector = Config().get('pod.label-selector', 'run=ops')
+        undeploy_frontend(state.namespace, label_selector)
+
+        return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{UndeployFrontend.COMMAND}\t undeploy Web frontend'

adam/commands/deploy/undeploy_pg_agent.py

@@ -0,0 +1,42 @@
+from adam.commands.command import Command
+from adam.commands.postgres.postgres_context import PostgresContext
+from adam.config import Config
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import ing
+
+class UndeployPgAgent(Command):
+    COMMAND = 'undeploy pg-agent'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(UndeployPgAgent, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return UndeployPgAgent.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
+
+        with ing('Deleting pod'):
+            PostgresContext.undeploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace)
+
+        return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{UndeployPgAgent.COMMAND}\t undeploy Postgres agent'

adam/commands/deploy/undeploy_pod.py

@@ -0,0 +1,51 @@
+from adam.commands.command import Command
+from adam.commands.deploy.deploy_utils import undeploy_frontend
+from adam.config import Config
+from adam.utils import ing
+from adam.utils_k8s.config_maps import ConfigMaps
+from adam.utils_k8s.deployment import Deployments
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.service_accounts import ServiceAccounts
+from adam.repl_state import ReplState, RequiredState
+
+class UndeployPod(Command):
+    COMMAND = 'undeploy pod'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(UndeployPod, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return UndeployPod.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
+
+        label_selector = Config().get('pod.label-selector', 'run=ops')
+        with ing('Deleting service account'):
+            ServiceAccounts.delete(state.namespace, label_selector=label_selector)
+        with ing('Deleting config map'): ConfigMaps.delete_with_selector(state.namespace, label_selector)
+        with ing('Deleting deployment'): Deployments.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0)
+        with ing('Deleting pod'): Pods.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0)
+        undeploy_frontend(state.namespace, label_selector)
+
+        return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{UndeployPod.COMMAND}\t undeploy Ops pod'

adam/commands/devices/device.py

@@ -0,0 +1,27 @@
+from abc import abstractmethod
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+
+class Device:
+    @abstractmethod
+    def ls(self, cmd: str, state: ReplState):
+        pass
+
+    def ls_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        return default
+
+    def cd(self, dir: str, state: ReplState):
+        pass
+
+    def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        return default
+
+    @abstractmethod
+    def pwd(self, state: ReplState):
+        pass
+
+    def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
+        return False, None
+
+    def enter(state: ReplState):
+        pass

adam/commands/devices/device_app.py

@@ -0,0 +1,146 @@
+from adam.apps import Apps
+from adam.commands.bash.bash import Bash
+from adam.commands.command import Command
+from adam.commands.devices.device import Device
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.utils import lines_to_tabular, log
+from adam.utils_k8s.app_pods import AppPods
+from adam.utils_k8s.ingresses import Ingresses
+
+class DeviceApp(Command, Device):
+    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'
+
+    def ls(self, cmd: str, state: ReplState):
+        if state.app_pod:
+            return Bash().run('bash ' + cmd, state)
+        elif state.app_app:
+            pods = AppPods.pod_names(state.namespace, state.app_env, state.app_app)
+
+            log(lines_to_tabular(pods, 'POD_NAME'))
+        elif state.app_env:
+            def line(n: str, ns: str):
+                host = Ingresses.get_host(Config().get('app.login.ingress', '{app_id}-k8singr-appleader-001').replace('{app_id}', f'{ns}-{n}'), ns)
+                if not host:
+                    return None
+
+                endpoint = Config().get('app.login.url', 'https://{host}/{env}/{app}').replace('{host}', host).replace('{env}', state.app_env).replace('{app}', 'c3')
+                if not endpoint:
+                    return None
+
+                return f"{n.split('-')[1]},{Ingresses.get_host(f'{ns}-{n}-k8singr-appleader-001', ns)},{endpoint}"
+
+            svcs = [l for l in [line(n, ns) for n, ns in Apps.apps(state.app_env)] if l]
+
+            log(lines_to_tabular(svcs, 'APP,HOST,ENDPOINT', separator=','))
+        else:
+            svcs = [n for n, ns in Apps.envs()]
+
+            log(lines_to_tabular(svcs, 'ENV', separator=','))
+
+
+    def ls_completion(self, cmd, state, default: dict = {}):
+        if state.app_app:
+            def pod_names():
+                return [p for p in AppPods.pod_names(state.namespace, state.app_env, state.app_app)]
+
+            return super().completion(state) | {f'@{p}': {cmd: None} for p in pod_names()}
+
+        return default
+
+    def cd(self, dir: str, state: ReplState):
+        if dir == '':
+            state.app_env = None
+            state.app_app = None
+            state.app_pod = None
+        elif dir == '..':
+            if state.app_pod:
+                state.app_pod = None
+            elif state.app_app:
+                state.app_app = None
+            else:
+                state.app_env = None
+        else:
+            if state.app_app:
+                state.app_pod = dir
+            elif 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
+
+    def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        if state.app_app:
+            return {cmd: {'..': None} | {pod: None for pod in AppPods.pod_names(state.namespace, state.app_env, state.app_app)}}
+        elif state.app_env:
+            return {cmd: {'..': None} | {app[0].split('-')[1]: None for app in Apps.apps(state.app_env)}}
+        else:
+            return {cmd: {'..': None} | {env[0]: None for env in Apps.envs()}}
+
+    def pwd(self, state: ReplState):
+        words = []
+
+        if state.app_env:
+            words.append(f'env/{state.app_env}')
+        if state.app_app:
+            words.append(f'app/{state.app_app}')
+
+        return '\t'.join([f'{ReplState.X}:>'] + (words if words else ['/']))
+
+    def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
+        if state.app_app:
+            return True, chain.run(f'app {cmd}', state)
+
+        return False, None
+
+    def enter(self, state: ReplState):
+        if not state.app_env:
+            if auto_enter := Config().get('repl.a.auto-enter', 'c3/c3/*'):
+                if auto_enter != 'no':
+                    ea = auto_enter.split('/')
+                    state.app_env = ea[0]
+                    if len(ea) > 2:
+                        state.app_app = ea[1]
+                        state.app_pod = ea[2]
+                        if state.app_pod == '*':
+                            if (pods := AppPods.pod_names(state.namespace, ea[0], ea[1])):
+                                state.app_pod = pods[0]
+                                Config().wait_log(f'Moving to {state.app_env}/{state.app_app}/{state.app_pod}...')
+                            else:
+                                Config().wait_log(f'No pods found, moving to {state.app_env}/{state.app_app}...')
+                        else:
+                            Config().wait_log(f'Moving to {state.app_env}/{state.app_app}/{state.app_pod}...')
+                    elif len(ea) > 1:
+                        state.app_app = ea[1]
+                        Config().wait_log(f'Moving to {state.app_env}/{state.app_app}...')
+                    else:
+                        Config().wait_log(f'Moving to {state.app_env}...')

adam/commands/devices/device_auit_log.py

@@ -0,0 +1,43 @@
+from adam.commands.command import Command
+from adam.commands.devices.device import Device
+from adam.repl_state import ReplState
+from adam.utils import lines_to_tabular, log
+from adam.utils_athena import Athena
+
+class DeviceAuditLog(Command, Device):
+    COMMAND = f'{ReplState.L}:'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DeviceAuditLog, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DeviceAuditLog.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not self.args(cmd):
+            return super().run(cmd, state)
+
+        state.device = ReplState.L
+
+        return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{DeviceAuditLog.COMMAND}\t move to Audit Log Operations device'
+
+    def ls(self, cmd: str, _: ReplState):
+        log(lines_to_tabular(Athena.table_names(), 'NAME', separator=','))
+
+    def pwd(self, state: ReplState):
+        return '\t'.join([f'{ReplState.L}:>', '/'])
+
+    def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
+        return True, chain.run(f'audit {cmd}', state)

adam/commands/devices/device_cass.py

@@ -0,0 +1,145 @@
+from adam.commands.bash.bash import Bash
+from adam.commands.command import Command
+from adam.commands.commands_utils import show_pods, show_rollout
+from adam.commands.devices.device import Device
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.utils import lines_to_tabular, log, log2
+from adam.utils_k8s.cassandra_clusters import CassandraClusters
+from adam.utils_k8s.custom_resources import CustomResources
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.statefulsets import StatefulSets
+
+class DeviceCass(Command, Device):
+    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'
+
+    def ls(self, cmd: str, state: ReplState):
+        if state.pod:
+            return Bash().run('bash ' + cmd, state)
+        elif state.sts and state.namespace:
+            show_pods(StatefulSets.pods(state.sts, state.namespace), state.namespace, show_namespace=not KubeContext.in_cluster_namespace())
+            show_rollout(state.sts, state.namespace)
+        else:
+            self.show_statefulsets()
+
+    def ls_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        def pod_names():
+            return [p for p in StatefulSets.pod_names(state.sts, state.namespace)]
+
+        if state.sts:
+            return super().completion(state) | {f'@{p}': {'ls': None} for p in pod_names()}
+        else:
+            return {cmd: {n: None for n in StatefulSets.list_sts_names()}}
+
+    def show_statefulsets(self):
+        ss = StatefulSets.list_sts_names()
+        if len(ss) == 0:
+            log2('No Cassandra clusters found.')
+            return
+
+        app_ids = CustomResources.get_app_ids()
+        list = []
+        for s in ss:
+            cr_name = CustomResources.get_cr_name(s)
+            app_id = 'Unknown'
+            if cr_name in app_ids:
+                app_id = app_ids[cr_name]
+            list.append(f"{s} {app_id}")
+
+        header = 'STATEFULSET_NAME@NAMESPACE APP_ID'
+        if KubeContext.in_cluster_namespace():
+            header = 'STATEFULSET_NAME APP_ID'
+        log(lines_to_tabular(list, header))
+
+    def cd(self, dir: str, state: ReplState):
+        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]
+                if len(ss_and_ns) > 1:
+                    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.')
+
+    def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        if state.pod:
+            return {cmd: {'..': None}}
+        elif state.sts:
+            return {cmd: {'..': None} | {p: None for p in StatefulSets.pod_names(state.sts, state.namespace)}}
+        else:
+            return {cmd: {p: None for p in StatefulSets.list_sts_names()}}
+
+    def pwd(self, state: ReplState):
+        words = []
+
+        if state.sts:
+            words.append(f'sts/{state.sts}')
+        if state.pod:
+            words.append(f'pod/{state.pod}')
+
+        return '\t'.join([f'{ReplState.C}:>'] + (words if words else ['/']))
+
+    def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
+        if state.sts:
+            return True, chain.run(f'cql {cmd}', state)
+
+        return False, None
+
+    def enter(self, state: ReplState):
+        auto_enter = Config().get('repl.c.auto-enter', 'cluster')
+        if auto_enter and auto_enter in ['cluster', 'first-pod']:
+            sts = StatefulSets.list_sts_name_and_ns()
+            if not sts:
+                log2("No Cassandra clusters found.")
+            elif not state.sts and len(sts) == 1:
+                cluster = sts[0]
+                state.sts = cluster[0]
+                state.namespace = cluster[1]
+                if auto_enter == 'first-pod':
+                    state.pod = f'{state.sts}-0'
+                if KubeContext().in_cluster_namespace:
+                    Config().wait_log(f'Moving to the only Cassandra cluster: {state.sts}...')
+                else:
+                    Config().wait_log(f'Moving to the only Cassandra cluster: {state.sts}@{state.namespace}...')