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

adam/commands/cql/utils_cql.py

@@ -0,0 +1,343 @@
+import functools
+import re
+from typing import Union
+
+from adam.commands.command import Command
+from adam.commands.commands_utils import show_table
+from adam.utils_k8s.cassandra_clusters import CassandraClusters
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.secrets import Secrets
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState
+from adam.utils import log2, log_timing, wait_log
+from adam.utils_k8s.statefulsets import StatefulSets
+
+@functools.lru_cache()
+def cassandra_keyspaces(state: ReplState, on_any=True):
+    if state.pod:
+        wait_log(f'Inspecting Cassandra Keyspaces on {state.pod}...')
+    else:
+        wait_log(f'Inspecting Cassandra Keyspaces...')
+
+    r: list[PodExecResult] = run_cql(state, 'describe keyspaces', show_out=False, on_any=on_any)
+    if not r:
+        log2('No pod is available')
+        return []
+
+    return parse_cql_desc_keyspaces(r.stdout if state.pod else r[0].stdout)
+
+def cassandra_table_names(state: ReplState, keyspace = None):
+    return [f'{k}.{t}' for k, ts in cassandra_tables(state, on_any=True).items() for t in ts if not keyspace or keyspace == '*' or k == keyspace]
+
+@functools.lru_cache()
+def cassandra_tables(state: ReplState, on_any=False) -> dict[str, list[str]]:
+    r: list[PodExecResult] = run_cql(state, 'describe tables', show_out=False, on_any=on_any)
+    if not r:
+        log2('No pod is available')
+        return {}
+
+    return parse_cql_desc_tables(r.stdout if state.pod else r[0].stdout)
+
+@functools.lru_cache()
+def table_spec(state: ReplState, table: str, on_any=False) -> 'TableSpec':
+    r: list[PodExecResult] = run_cql(state, f'describe table {table}', show_out=False, on_any=on_any)
+    if not r:
+        log2('No pod is available')
+        return None
+
+    return parse_cql_desc_table(r.stdout if state.pod else r[0].stdout)
+
+def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, background=False, log_file=None) -> list[PodExecResult]:
+    if show_query:
+        log2(cql)
+
+    command = None
+    with log_timing('Secrets.get_user_pass'):
+        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}"'
+
+    with log_timing(cql):
+        with cassandra(state) as pods:
+            return pods.exec(command, action='cql', show_out=show_out, on_any=on_any, background=background, log_file=log_file)
+
+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
+
+def parse_cql_desc_keyspaces(out: str) -> list[str]:
+    #
+    # Warning: Cannot create directory at `/home/cassandra/.cassandra`. Command history will not be saved. Please check what was the environment property CQL_HISTORY set to.
+    #
+    #
+    # Warning: Using a password on the command line interface can be insecure.
+    # Recommendation: use the credentials file to securely provide the password.
+    #
+    #
+    # azops88_db  system_auth         system_traces
+    # reaper_db   system_distributed  system_views
+    # system      system_schema       system_virtual_schema
+    #
+    kses = []
+    for line in out.split('\n'):
+        line = line.strip(' \r')
+        if not line:
+            continue
+        if line.startswith('Warning:'):
+            continue
+        if line.startswith('Recommendation:'):
+            continue
+
+        for ks in line.split(' '):
+            if s := ks.strip(' \r\t'):
+                kses.append(s)
+
+    return kses
+
+class ColumnSpec:
+    def __init__(self, name: str, type: str, key_index = -1):
+        self.name = name
+        self.type = type
+        self.key_index = key_index
+
+    def __eq__(self, other):
+        if not isinstance(other, ColumnSpec):
+            return NotImplemented
+
+        return self.name == other.name and self.type == other.type and self.key_index == other.key_index
+
+class TableSpec:
+    def __init__(self, columns: list[ColumnSpec]):
+        self.columns = columns
+
+    def row_key(self):
+        for c in self.columns:
+            if c.key_index == 0:
+                return c.name
+
+    def keys(self):
+        return [c.name for c in self.columns if c.key_index > -1]
+
+def parse_cql_desc_table(out: str) -> TableSpec:
+    # CREATE TABLE azops88_db.analyticscontainer_dfeevalhistory (
+    #     id text,
+    #     columnname text,
+    #     version bigint static,
+    #     contentb blob,
+    #     contentbool boolean,
+    #     contentn double,
+    #     contents text,
+    #     PRIMARY KEY (id, columnname)
+    # ) WITH CLUSTERING ORDER BY (columnname ASC)
+    #     AND additional_write_policy = '99p'
+    #     AND bloom_filter_fp_chance = 0.1
+    #     AND caching = {'keys': 'ALL', 'rows_per_partition': 'NONE'}
+    #     AND cdc = false
+    #     AND comment = ''
+    #     AND compaction = {'class': 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'}
+    #     AND compression = {'chunk_length_in_kb': '16', 'class': 'org.apache.cassandra.io.compress.SnappyCompressor'}
+    #     AND memtable = 'default'
+    #     AND crc_check_chance = 1.0
+    #     AND default_time_to_live = 0
+    #     AND extensions = {}
+    #     AND gc_grace_seconds = 3600
+    #     AND max_index_interval = 2048
+    #     AND memtable_flush_period_in_ms = 0
+    #     AND min_index_interval = 128
+    #     AND read_repair = 'BLOCKING'
+    #     AND speculative_retry = '99p';
+    pkeys = {}
+    columns: list[ColumnSpec] = []
+
+    state = 's0'
+    for line in out.split('\n'):
+        if state == 's0':
+            if line.startswith('CREATE TABLE'):
+                state = 's1'
+        elif state == 's1':
+            if line.startswith(')'):
+                state = 's2'
+                continue
+
+            groups = re.match(r'^\s*PRIMARY KEY\s*\((.*)\).*$', line)
+            if groups:
+                pkeys = {n.strip(' '): i for i, n in enumerate(groups[1].strip(' \r').split(','))}
+                continue
+
+            #  single key column - name text PRIMARY KEY,
+            groups = re.match(r'^\s*(\S*?)\s*(\S*?)\s*PRIMARY KEY,.*$', line)
+            if groups:
+                columns.append(ColumnSpec(groups[1], groups[2]))
+                pkeys[groups[1]] = 0
+            else:
+                groups = re.match(r'^\s*(\S*?)\s*(\S*?),.*$', line)
+                if groups:
+                    columns.append(ColumnSpec(groups[1], groups[2]))
+        elif state == 's2':
+            pass
+
+    for column in columns:
+        if column.name in pkeys.keys():
+            column.key_index = pkeys[column.name]
+
+    return TableSpec(columns)
+
+class CqlShHandler:
+    def __init__(self, state: ReplState, opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, background=False):
+        self.state = state
+        self.opts = opts
+        self.show_out = show_out
+        self.show_query = show_query
+        self.use_single_quotes = use_single_quotes
+        self.on_any = on_any
+        self.backgroud = background
+
+    def __enter__(self):
+        return self.query
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+    def query(self, args: list[str], log_file: str = None):
+        query: str = args
+        background = self.backgroud
+        show_out = self.show_out
+
+        if isinstance(query, list):
+            opts = []
+            cqls = []
+            for index, arg in enumerate(args):
+                if arg.startswith('--'):
+                    opts.append(arg)
+                # elif index == len(args) -1 and arg == '&':
+                #     background = True
+                elif arg != '-e':
+                    cqls.append(arg)
+            if not cqls:
+                if self.state.in_repl:
+                    log2('Please enter cql statement. e.g. select host_id from system.local')
+                else:
+                    log2('* CQL statement is missing.')
+                    log2()
+                    Command.display_help()
+
+                return 'no-cql'
+
+            query = ' '.join(cqls)
+            show_out = True
+
+        return run_cql(self.state, query, opts=self.opts, show_out=show_out, show_query=self.show_query, use_single_quotes=self.use_single_quotes, on_any=self.on_any, background=background, log_file=log_file)
+
+class CassandraPodService:
+    def __init__(self, handler: 'CassandraExecHandler'):
+        self.handler = handler
+
+    def exec(self, command: str, action='bash', show_out = True, on_any = False, throw_err = False, shell = '/bin/sh', background = False, log_file = None) -> Union[PodExecResult, list[PodExecResult]]:
+        state = self.handler.state
+        pod = self.handler.pod
+
+        if pod:
+            return CassandraNodes.exec(pod, state.namespace, command,
+                                    show_out=show_out, throw_err=throw_err, shell=shell, background=background, log_file=log_file)
+        elif state.sts:
+            return CassandraClusters.exec(state.sts, state.namespace, command, action=action,
+                                        show_out=show_out, on_any=on_any, shell=shell, background=background, log_file=log_file)
+
+        return []
+
+    def cql(self, args: list[str], opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, background=False, log_file: str = None):
+        state = self.handler.state
+        query: str = args
+
+        if isinstance(query, list):
+            opts = []
+            cqls = []
+            for arg in args:
+                if arg.startswith('--'):
+                    opts.append(arg)
+                elif arg != '-e':
+                    cqls.append(arg)
+            if not cqls:
+                if self.state.in_repl:
+                    log2('Please enter cql statement. e.g. select host_id from system.local')
+                else:
+                    log2('* CQL statement is missing.')
+                    log2()
+                    Command.display_help()
+
+                return 'no-cql'
+
+            query = ' '.join(cqls)
+            show_out = True
+
+        return run_cql(state, query, opts=opts, show_out=show_out, show_query=show_query, use_single_quotes=use_single_quotes, on_any=on_any, background=background, log_file=log_file)
+
+    def show_table(self, cols: str, header: str, show_out = True):
+        state = self.handler.state
+
+        if state.pod:
+            show_table(state, [state.pod], cols, header, show_out=show_out)
+        elif state.sts:
+            pod_names = [pod.metadata.name for pod in StatefulSets.pods(state.sts, state.namespace)]
+            show_table(state, pod_names, cols, header, show_out=show_out)
+
+    def nodetool(self, args: str, show_out = True) -> Union[PodExecResult, list[PodExecResult]]:
+        state = self.handler.state
+        pod = self.handler.pod
+
+        user, pw = state.user_pass()
+        command = f"nodetool -u {user} -pw {pw} {args}"
+
+        if pod:
+            return CassandraNodes.exec(pod, state.namespace, command, show_out=show_out)
+        else:
+            return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool', show_out=show_out)
+
+class CassandraExecHandler:
+    def __init__(self, state: ReplState, pod: str = None):
+        self.state = state
+        self.pod = pod
+        if not pod and state.pod:
+            self.pod = state.pod
+
+    def __enter__(self):
+        return CassandraPodService(self)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+def cassandra(state: ReplState, pod: str=None):
+    return CassandraExecHandler(state, pod=pod)

{walker/commands/frontend → adam/commands/deploy}/code_start.py

@@ -1,7 +1,7 @@
-from walker.commands.command import Command
-from walker.commands.frontend.code_utils import start_user_code, stop_user_codes
-from walker.repl_state import ReplState, RequiredState
-from walker.utils import log2
+from adam.commands.command import Command
+from adam.commands.deploy.code_utils import start_user_code, stop_user_codes
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
 
 class CodeStart(Command):
     COMMAND = 'code start'
@@ -25,19 +25,16 @@ class CodeStart(Command):
         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.')
+        with self.validate(args, state) as (args, state):
+            log2('This will support c3/c3 only for demo.')
 
-        stop_user_codes(state.namespace)
-        try:
-            start_user_code(state.namespace)
-        finally:
             stop_user_codes(state.namespace)
+            try:
+                start_user_code(state.namespace)
+            finally:
+                stop_user_codes(state.namespace)
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
         if state.namespace:

adam/commands/deploy/code_stop.py

@@ -0,0 +1,40 @@
+from adam.commands.command import Command
+from adam.commands.deploy.code_utils import stop_user_codes
+from adam.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)
+
+        with self.validate(args, state) as (args, state):
+            _, dry = Command.extract_options(args, '--dry')
+            stop_user_codes(state.namespace, dry)
+
+            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 → adam/commands/deploy}/code_utils.py

@@ -3,11 +3,11 @@ from pathlib import Path
 import socket
 import subprocess
 
-from walker.apps import Apps
-from walker.config import Config
-from walker.k8s_utils.ingresses import Ingresses
-from walker.k8s_utils.services import Services
-from walker.utils import log2, random_alphanumeric
+from adam.apps import Apps
+from adam.config import Config
+from adam.utils_k8s.ingresses import Ingresses
+from adam.utils_k8s.services import Services
+from adam.utils import debug, log2, random_alphanumeric
 
 def start_user_code(namespace: str):
     try:
@@ -57,8 +57,7 @@ def kill_process_by_pattern(pattern, dry=False):
         pids = process.stdout.strip().split('\n')
 
         if not pids or pids == ['']:
-            if Config().is_debug():
-                log2(f"No processes found matching pattern: '{pattern}'")
+            debug(f"No processes found matching pattern: '{pattern}'")
             return
 
         for pid in pids:
@@ -67,8 +66,7 @@ def kill_process_by_pattern(pattern, dry=False):
                     if not dry:
                         subprocess.run(f"kill -9 {pid}", shell=True, check=True)
 
-                    if Config().is_debug():
-                        log2(f"Killed process with PID: {pid} (matching pattern: '{pattern}')")
+                    debug(f"Killed process with PID: {pid} (matching pattern: '{pattern}')")
                 except subprocess.CalledProcessError as e:
                     log2(f"Error killing process {pid}: {e}")
 

adam/commands/deploy/deploy.py

@@ -0,0 +1,25 @@
+import click
+
+from adam.commands.deploy.deploy_pg_agent import DeployPgAgent
+from adam.commands.deploy.deploy_pod import DeployPod
+from adam.commands.intermediate_command import IntermediateCommand
+from .deploy_frontend import DeployFrontend
+
+class Deploy(IntermediateCommand):
+    COMMAND = 'deploy'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Deploy, cls).__new__(cls)
+
+        return cls.instance
+
+    def command(self):
+        return Deploy.COMMAND
+
+    def cmd_list(self):
+        return [DeployFrontend(), DeployPod(), DeployPgAgent()]
+
+class DeployCommandHelper(click.Command):
+    def get_help(self, ctx: click.Context):
+        IntermediateCommand.intermediate_help(super().get_help(ctx), Deploy.COMMAND, Deploy().cmd_list())

adam/commands/deploy/deploy_frontend.py

@@ -0,0 +1,49 @@
+from adam.commands.command import Command
+from adam.commands.deploy.deploy_utils import deploy_frontend
+from adam.config import Config
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+
+class DeployFrontend(Command):
+    COMMAND = 'deploy frontend'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DeployFrontend, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DeployFrontend.COMMAND
+
+    def required(self):
+        return RequiredState.NAMESPACE
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            log2('This will support c3/c3 only for demo.')
+
+            pod_name = Config().get('pod.name', 'ops')
+            label_selector = Config().get('pod.label-selector', 'run=ops')
+            try:
+                uri = deploy_frontend(pod_name, state.namespace, label_selector)
+                log2(f'Ops pod is available at {uri}.')
+            except Exception as e:
+                if e.status == 409:
+                    log2(f"Error: '{pod_name}' already exists in namespace '{state.namespace}'.")
+                else:
+                    log2(f"Error creating ingress or service: {e}")
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{DeployFrontend.COMMAND}\t deploy Web frontend'

adam/commands/deploy/deploy_pg_agent.py

@@ -0,0 +1,35 @@
+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
+
+class DeployPgAgent(Command):
+    COMMAND = 'deploy pg-agent'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DeployPgAgent, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DeployPgAgent.COMMAND
+
+    def required(self):
+        return RequiredState.NAMESPACE
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            PostgresContext.deploy_pg_agent(Config().get('pg.agent.name', 'ops-pg-agent'), state.namespace)
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{DeployPgAgent.COMMAND}\t deploy Postgres agent'

adam/commands/deploy/deploy_pod.py

@@ -0,0 +1,108 @@
+from kubernetes import client
+
+from adam.commands import extract_options
+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)
+
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, '--force') as (args, forced):
+                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'