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

adam/commands/postgres/postgres_context.py

@@ -0,0 +1,248 @@
+from datetime import datetime
+import functools
+import re
+import subprocess
+
+from adam.config import Config
+from adam.repl_session import ReplSession
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.secrets import Secrets
+from adam.utils import log2
+
+class PostgresContext:
+    def apply(namespace: str, path: str, arg: str = None) -> 'PostgresContext':
+        context = PostgresContext(namespace, path)
+
+        if arg:
+            if arg == '..':
+                if context.db:
+                    context.db = None
+                else:
+                    context.host = None
+            else:
+                tks = arg.split('@')
+                if not context.host:
+                    context.host = tks[0]
+                else:
+                    context.db = tks[0]
+
+                if not namespace and tks[1]:
+                    context.namespace = tks[1]
+
+        return context
+
+    def __init__(self, ns: str, path: str):
+        self.namespace = ns
+        self.conn_details = None
+        self.host = None
+        self.db = None
+
+        if path:
+            tks = path.split('/')
+            hn = tks[0].split('@')
+            self.host = hn[0]
+            if len(hn) > 1 and not ns:
+                self.namespace = hn[1]
+
+            if len(tks) > 1:
+                self.db = tks[1]
+
+    def path(self):
+        if not self.host:
+            return None
+
+        d = self.host
+        if not self.db:
+            return d
+
+        return f'{self.host}/{self.db}'
+
+    def hosts(ns: str):
+        return PostgresContext.hosts_for_namespace(ns)
+
+    @functools.lru_cache()
+    def hosts_for_namespace(ns: str):
+        ss = Secrets.list_secrets(ns, name_pattern=Config().get('pg.name-pattern', '^{namespace}.*k8spg.*'))
+
+        def excludes(name: str):
+            exs = Config().get('pg.excludes', '.helm., -admin-secret')
+            if exs:
+                for ex in exs.split(','):
+                    if ex.strip(' ') in name:
+                        return True
+
+            return False
+
+        return [s for s in ss if not excludes(s)]
+
+    def databases(self):
+        dbs = []
+        #  List of databases
+        #                  Name                  |  Owner   | Encoding |   Collate   |    Ctype    | ICU Locale | Locale Provider |   Access privileges
+        # ---------------------------------------+----------+----------+-------------+-------------+------------+-----------------+-----------------------
+        #  postgres                              | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |            | libc            |
+        #  stgawsscpsr_c3_c3                     | postgres | UTF8     | C           | C           |            | libc            |
+        #  template1                             | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |            | libc            | =c/postgres          +
+        #                                        |          |          |             |             |            |                 | postgres=CTc/postgres
+        # (48 rows)
+        if r := self.run_sql('\l', show_out=False):
+            s = 0
+            for line in r.stdout.split('\n'):
+                line: str = line.strip(' \r')
+                if s == 0:
+                    if 'List of databases' in line:
+                        s = 1
+                elif s == 1:
+                    if 'Name' in line and 'Owner' in line and 'Encoding' in line:
+                        s = 2
+                elif s == 2:
+                    if line.startswith('---------'):
+                        s = 3
+                elif s == 3:
+                    groups = re.match(r'^\s*(\S*)\s*\|\s*(\S*)\s*\|.*', line)
+                    if groups and groups[1] != '|':
+                        dbs.append({'name': groups[1], 'owner': groups[2]})
+
+        return dbs
+
+    def tables(self):
+        dbs = []
+        #                                            List of relations
+        #   Schema  |                            Name                            | Type  |     Owner
+        # ----------+------------------------------------------------------------+-------+---------------
+        #  postgres | c3_2_admin_aclpriv                                         | table | postgres
+        #  postgres | c3_2_admin_aclpriv_a                                       | table | postgres
+        if r := self.run_sql('\dt', show_out=False):
+            s = 0
+            for line in r.stdout.split('\n'):
+                line: str = line.strip(' \r')
+                if s == 0:
+                    if 'List of relations' in line:
+                        s = 1
+                elif s == 1:
+                    if 'Schema' in line and 'Name' in line and 'Type' in line:
+                        s = 2
+                elif s == 2:
+                    if line.startswith('---------'):
+                        s = 3
+                elif s == 3:
+                    groups = re.match(r'^\s*(\S*)\s*\|\s*(\S*)\s*\|.*', line)
+                    if groups and groups[1] != '|':
+                        dbs.append({'schema': groups[1], 'name': groups[2]})
+
+        return dbs
+
+    def run_sql(self, sql: str, show_out = True, background = False):
+        db = self.db if self.db else PostgresContext.default_db()
+
+        if KubeContext.in_cluster():
+            cmd1 = f'env PGPASSWORD={self.password()} psql -h {self.endpoint()} -p {self.port()} -U {self.username()} {db} --pset pager=off -c'
+            log2(f'{cmd1} "{sql}"')
+            # remove double quotes from the sql argument
+            cmd = cmd1.split(' ') + [sql]
+
+            r = subprocess.run(cmd, capture_output=not background, text=True)
+            if show_out:
+                log2(r.stdout)
+                log2(r.stderr)
+
+            return r
+        else:
+            ns = self.namespace
+            pod_name = Config().get('pg.agent.name', 'ops-pg-agent')
+
+            if Config().get('pg.agent.just-in-time', False):
+                if not PostgresContext.deploy_pg_agent(pod_name, ns):
+                    return
+
+            real_pod_name = pod_name
+            try:
+                # try with dedicated pg agent pod name configured
+                Pods.get(ns, pod_name)
+            except:
+                try:
+                    # try with the ops pod
+                    pod_name = Config().get('pod.name', 'ops')
+                    real_pod_name = Pods.get_with_selector(ns, label_selector = Config().get('pod.label-selector', 'run=ops')).metadata.name
+                except:
+                    log2(f"Could not locate {pod_name} pod.")
+                    return None
+
+            cmd = f'psql -h {self.endpoint()} -p {self.port()} -U {self.username()} {db} --pset pager=off -c "{sql}"'
+            env_prefix = f'PGPASSWORD="{self.password()}"'
+
+            r = Pods.exec(real_pod_name, pod_name, ns, cmd, show_out=show_out, background=background, env_prefix=env_prefix)
+            if r and Config().get('repl.history.push-cat-remote-log-file', True):
+                if r.log_file and ReplSession().prompt_session:
+                    ReplSession().prompt_session.history.append_string(f'@{r.pod} cat {r.log_file}')
+
+            return r
+
+    def deploy_pg_agent(pod_name: str, ns: str) -> str:
+        image = Config().get('pg.agent.image', 'seanahnsf/kaqing')
+        timeout = Config().get('pg.agent.timeout', 3600)
+        try:
+            Pods.create(ns, pod_name, image, ['sleep', f'{timeout}'], env={'NAMESPACE': ns}, sa_name='c3')
+        except Exception as e:
+            if e.status == 409:
+                if Pods.completed(ns, pod_name):
+                    try:
+                        Pods.delete(pod_name, ns)
+                        Pods.create(ns, pod_name, image, ['sleep', f'{timeout}'], env={'NAMESPACE': ns}, sa_name='c3')
+                    except Exception as e2:
+                        log2("Exception when calling BatchV1Api->create_pod: %s\n" % e2)
+
+                        return
+            else:
+                log2("Exception when calling BatchV1Api->create_pod: %s\n" % e)
+
+                return
+
+        Pods.wait_for_running(ns, pod_name)
+
+        return pod_name
+
+    def undeploy_pg_agent(pod_name: str, ns: str):
+        Pods.delete(pod_name, ns, grace_period_seconds=0)
+
+    def endpoint(self):
+        if not self.conn_details:
+            self.conn_details = Secrets.get_data(self.namespace, self.host)
+
+        endpoint_key = Config().get('pg.secret.endpoint-key', 'postgres-db-endpoint')
+
+        return self.conn_details[endpoint_key] if endpoint_key in self.conn_details else ''
+
+    def port(self):
+        if not self.conn_details:
+            self.conn_details = Secrets.get_data(self.namespace, self.host)
+
+        port_key = Config().get('pg.secret.port-key', 'postgres-db-port')
+
+        return  self.conn_details[port_key] if port_key in self.conn_details else ''
+
+    def username(self):
+        if not self.conn_details:
+            self.conn_details = Secrets.get_data(self.namespace, self.host)
+
+        username_key = Config().get('pg.secret.username-key', 'postgres-admin-username')
+
+        return  self.conn_details[username_key] if username_key in self.conn_details else ''
+
+    def password(self):
+        if not self.conn_details:
+            self.conn_details = Secrets.get_data(self.namespace, self.host)
+
+        password_key = Config().get('pg.secret.password-key', 'postgres-admin-password')
+
+        return  self.conn_details[password_key] if password_key in self.conn_details else ''
+
+    def default_db():
+        return Config().get('pg.default-db', 'postgres')
+
+    def default_owner():
+        return Config().get('pg.default-owner', 'postgres')
+
+    def default_schema():
+        return Config().get('pg.default-schema', 'postgres')

adam/commands/postgres/postgres_preview.py

@@ -1,5 +1,4 @@
 from adam.commands.command import Command
-from adam.commands.ls import Ls
 from adam.commands.preview_table import PreviewTable
 from adam.repl_state import ReplState, RequiredState
 

adam/commands/postgres/postgres_utils.py

@@ -0,0 +1,31 @@
+import functools
+
+from adam.commands.postgres.postgres_context import PostgresContext
+from adam.config import Config
+
+TestPG = [False]
+
+@functools.lru_cache()
+def pg_database_names(ns: str, pg_path: str):
+    if TestPG[0]:
+        return ['azops88_c3ai_c3']
+
+    Config().wait_log('Inspecting Postgres Databases...')
+
+    pg = PostgresContext.apply(ns, pg_path)
+    return [db['name'] for db in pg.databases() if db['owner'] == PostgresContext.default_owner()]
+
+@functools.lru_cache()
+def pg_table_names(ns: str, pg_path: str):
+    if TestPG[0]:
+        return ['C3_2_XYZ1']
+
+    Config().wait_log('Inspecting Postgres Database...')
+    return [table['name'] for table in pg_tables(ns, pg_path) if table['schema'] == PostgresContext.default_schema()]
+
+def pg_tables(ns: str, pg_path: str):
+    pg = PostgresContext.apply(ns, pg_path)
+    if pg.db:
+        return pg.tables()
+
+    return []

adam/commands/postgres/psql_completions.py

@@ -0,0 +1,10 @@
+from adam.commands.postgres.postgres_utils import pg_table_names
+from adam.sql.sql_completer import SqlCompleter
+
+def psql_completions(ns: str, pg_path: str):
+    return {
+        '\h': None,
+        '\d': None,
+        '\dt': None,
+        '\du': None
+    } | SqlCompleter(lambda: pg_table_names(ns, pg_path)).completions_for_nesting()

adam/commands/preview_table.py

@@ -1,12 +1,11 @@
-import functools
-
 from adam.commands.command import Command
-from adam.commands.cql_utils import parse_cql_desc_tables, run_cql
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.cql.cql_utils import cassandra_table_names, run_cql
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.config import Config
-from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import lines_to_tabular, log, log2
+from adam.utils_athena import Athena
+from adam.utils_audits import Audits
 
 class PreviewTable(Command):
     COMMAND = 'preview'
@@ -24,28 +23,26 @@ class PreviewTable(Command):
         return PreviewTable.COMMAND
 
     def required(self):
-        return RequiredState.CLUSTER_OR_POD
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.PG_DATABASE, ReplState.L]
 
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
         state, args = self.apply_state(args, state)
-        if state.device == ReplState.P:
-            if not self.validate_state(state, RequiredState.PG_DATABASE):
-                return state
-        else:
-            if not self.validate_state(state):
-                return state
+        if not self.validate_state(state):
+            return state
 
         if not args:
             def show_tables():
                 if state.device == ReplState.P:
-                    pg = PostgresSession(state.namespace, state.pg_path)
-                    lines = [db["name"] for db in pg.tables() if db["schema"] == PostgresSession.default_schema()]
+                    pg = PostgresContext.apply(state.namespace, state.pg_path)
+                    lines = [db["name"] for db in pg.tables() if db["schema"] == PostgresContext.default_schema()]
                     log(lines_to_tabular(lines, separator=','))
+                elif state.device == ReplState.L:
+                    log(lines_to_tabular(Athena.table_names(), separator=','))
                 else:
-                    run_cql(state, f'describe tables', show_out=True)
+                    log(lines_to_tabular(cassandra_table_names(state), separator=','))
 
             if state.in_repl:
                 log2('Table is required.')
@@ -64,35 +61,16 @@ class PreviewTable(Command):
 
         rows = Config().get('preview.rows', 10)
         if state.device == ReplState.P:
-            PostgresSession(state.namespace, state.pg_path).run_sql(f'select * from {table} limit {rows}')
+            PostgresContext.apply(state.namespace, state.pg_path).run_sql(f'select * from {table} limit {rows}')
+        elif state.device == ReplState.L:
+            Athena.run_query(f'select * from {table} limit {rows}')
         else:
-            run_cql(state, f'select * from {table} limit {rows}', show_out=True, use_single_quotes=True)
+            run_cql(state, f'select * from {table} limit {rows}', show_out=True, use_single_quotes=True, on_any=True)
 
         return state
 
-    def completion(self, state: ReplState):
-        if state.device == ReplState.P:
-            if tables := PreviewTable.pg_tables(state.namespace, state.pg_path):
-                return {PreviewTable.COMMAND: {db["name"]: None for db in tables if db["schema"] == PostgresSession.default_schema()}}
-        else:
-            if state.pod:
-                tables = PreviewTable.cql_tables(state)
-                return {PreviewTable.COMMAND: {f'{k}.{t}': None for k, ts in tables.items() for t in ts}}
-
+    def completion(self, _: ReplState):
         return {}
 
     def help(self, _: ReplState):
-        return f'{PreviewTable.COMMAND} TABLE\t preview table'
-
-    @functools.lru_cache()
-    def cql_tables(state: ReplState):
-        r: PodExecResult =  run_cql(state, 'describe tables', show_out=False)
-        return parse_cql_desc_tables(r.stdout)
-
-    @functools.lru_cache()
-    def pg_tables(ns: str, pg_path: str):
-        pg = PostgresSession(ns, pg_path)
-        if pg.db:
-            return pg.tables()
-
-        return None
+        return f'{PreviewTable.COMMAND} TABLE\t preview table'

adam/commands/pwd.py

@@ -1,6 +1,6 @@
 from adam.app_session import AppSession
 from adam.commands.command import Command
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.devices.devices import Devices
 from adam.repl_state import ReplState
 from adam.utils import lines_to_tabular, log
 
@@ -25,29 +25,6 @@ class Pwd(Command):
 
         state, _ = self.apply_state(args, state)
 
-        def device_line(state: ReplState, device: str):
-            words = []
-
-            if device == ReplState.P:
-                pg = PostgresSession(state.namespace, state.pg_path)
-
-                if pg.host:
-                    words.append(f'host/{pg.host}')
-                if pg.db:
-                    words.append(f'database/{pg.db}')
-            elif device == ReplState.A:
-                if state.app_env:
-                    words.append(f'env/{state.app_env}')
-                if state.app_app:
-                    words.append(f'app/{state.app_app}')
-            else:
-                if state.sts:
-                    words.append(f'sts/{state.sts}')
-                if state.pod:
-                    words.append(f'pod/{state.pod}')
-
-            return '\t'.join([f'{device}:>'] + (words if words else ['/']))
-
         host = "unknown"
         try:
             app_session: AppSession = AppSession.create('c3', 'c3')
@@ -55,10 +32,7 @@ class Pwd(Command):
         except:
             pass
 
-        log(lines_to_tabular([
-            device_line(state, ReplState.A),
-            device_line(state, ReplState.C),
-            device_line(state, ReplState.P),
+        log(lines_to_tabular([device.pwd(state) for device in Devices.all()] + [
             f'',
             f'HOST\t{host}',
             f'NAMESPACE\t{state.namespace if state.namespace else "/"}',

adam/commands/reaper/reaper.py

@@ -1,7 +1,6 @@
 import click
 
 from adam.commands.command import Command
-from adam.commands.command_helpers import ClusterCommandHelper
 from .reaper_forward import ReaperForward
 from .reaper_forward_stop import ReaperForwardStop
 from .reaper_restart import ReaperRestart
@@ -14,7 +13,6 @@ from .reaper_schedule_stop import ReaperScheduleStop
 from .reaper_schedules import ReaperSchedules
 from .reaper_status import ReaperStatus
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import lines_to_tabular, log, log2
 
 class Reaper(Command):
     COMMAND = 'reaper'
@@ -39,24 +37,15 @@ class Reaper(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
 
-        if state.in_repl:
-            log(lines_to_tabular([c.help(ReplState()) for c in Reaper.cmd_list()], separator='\t'))
-
-            return 'command-missing'
-        else:
-            # head with the Chain of Responsibility pattern
-            cmds = Command.chain(Reaper.cmd_list())
-            if not cmds.run(cmd, state):
-                log2('* Command is missing.')
-                Command.display_help()
+        return super().intermediate_run(cmd, state, args, Reaper.cmd_list())
 
     def cmd_list():
         return [ReaperSchedules(), ReaperScheduleStop(), ReaperScheduleActivate(), ReaperScheduleStart(),
-                ReaperForwardStop(), ReaperForward(), ReaperRunAbort(), ReaperRunsAbort(), ReaperRestart(), ReaperRuns(), ReaperStatus()]
+                ReaperForwardStop(), ReaperForward(), ReaperRunAbort(), ReaperRunsAbort(), ReaperRestart(),
+                ReaperRuns(), ReaperStatus()]
 
     def completion(self, state: ReplState):
         if state.sts:
@@ -64,15 +53,6 @@ class Reaper(Command):
 
         return {}
 
-    def help(self, _: ReplState):
-        return None
-
 class ReaperCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
-        log(super().get_help(ctx))
-        log()
-        log('Sub-Commands:')
-
-        log(lines_to_tabular([c.help(ReplState()).replace(f'{Reaper.COMMAND} ', '  ', 1) for c in Reaper.cmd_list()], separator='\t'))
-        log()
-        ClusterCommandHelper.cluster_help()
+        Command.intermediate_help(super().get_help(ctx), Reaper.COMMAND, Reaper.cmd_list(), show_cluster_help=True)

adam/commands/reaper/reaper_restart.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.k8s_utils.pods import Pods
+from adam.utils_k8s.pods import Pods
 from .reaper_session import ReaperSession
 from adam.repl_state import ReplState, RequiredState
 

adam/commands/reaper/reaper_session.py

@@ -7,7 +7,7 @@ import requests
 from typing import List, cast
 
 from adam.config import Config
-from adam.k8s_utils.kube_context import KubeContext
+from adam.utils_k8s.kube_context import KubeContext
 from adam.repl_state import ReplState
 from adam.utils import lines_to_tabular, log2
 
@@ -149,7 +149,7 @@ class ReaperSession:
             return ReaperSession.schedules_ids_by_cluster[state.sts]
 
         if reaper := ReaperSession.create(state):
-            state.wait_log("Inspecting Cassandra Reaper...")
+            Config().wait_log('Inspecting Cassandra Reaper...')
 
             schedules = reaper.schedule_ids(state, show_output = False)
             ReaperSession.schedules_ids_by_cluster[state.sts] = schedules

adam/commands/repair/repair.py

@@ -1,13 +1,11 @@
 import click
 
 from adam.commands.command import Command
-from adam.commands.command_helpers import ClusterCommandHelper
 from .repair_run import RepairRun
 from .repair_scan import RepairScan
 from .repair_stop import RepairStop
 from .repair_log import RepairLog
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import lines_to_tabular, log, log2
 
 class Repair(Command):
     COMMAND = 'repair'
@@ -30,39 +28,17 @@ class Repair(Command):
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
-
-        state, args = self.apply_state(args, state)
         if not self.validate_state(state):
             return state
 
-        if state.in_repl:
-            log(lines_to_tabular([c.help(ReplState()) for c in Repair.cmd_list()], separator='\t'))
-
-            return 'command-missing'
-        else:
-            # head with the Chain of Responsibility pattern
-            cmds = Command.chain(Repair.cmd_list())
-            if not cmds.run(cmd, state):
-                log2('* Command is missing.')
-                Command.display_help()
+        return super().intermediate_run(cmd, state, args, Repair.cmd_list())
 
     def cmd_list():
         return [RepairRun(), RepairScan(), RepairStop(), RepairLog()]
 
     def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-        return {}
-
-    def help(self, _: ReplState):
-        return None
+        return super().completion(state)
 
 class RepairCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):
-        log(super().get_help(ctx))
-        log()
-        log('Sub-Commands:')
-
-        log(lines_to_tabular([c.help(ReplState()).replace(f'{Repair.COMMAND} ', '  ', 1) for c in Repair.cmd_list()], separator='\t'))
-        log()
-        ClusterCommandHelper.cluster_help()
+        Command.intermediate_help(super().get_help(ctx), Repair.COMMAND, Repair.cmd_list(), show_cluster_help=True)

adam/commands/repair/repair_log.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.k8s_utils.jobs import Jobs
+from adam.utils_k8s.jobs import Jobs
 from adam.repl_state import ReplState, RequiredState
 
 class RepairLog(Command):

adam/commands/repair/repair_run.py

@@ -1,6 +1,6 @@
 from adam.commands.command import Command
-from adam.k8s_utils.jobs import Jobs
-from adam.k8s_utils.volumes import Volumes
+from adam.utils_k8s.jobs import Jobs
+from adam.utils_k8s.volumes import Volumes
 from adam.repl_state import ReplState, RequiredState
 from adam.config import Config
 from adam.commands.reaper.reaper_session import ReaperSession

adam/commands/repair/repair_scan.py

@@ -1,7 +1,7 @@
 import time
 
 from adam.commands.command import Command
-from adam.k8s_utils.pods import Pods
+from adam.utils_k8s.pods import Pods
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
 from adam.config import Config
@@ -55,12 +55,7 @@ class RepairScan(Command):
             else:
                 log2("Exception when calling BatchV1Apii->create_namespaced_job: %s\n" % e)
 
-        msged = False
-        while Pods.get(ns, pod_name).status.phase != 'Running':
-            if not msged:
-                log2("Waiting for the scanner pod to start up...")
-                msged = True
-            time.sleep(5)
+        Pods.wait_for_running(ns, pod_name, 'Waiting for the scanner pod to start up...')
 
         try:
             Pods.exec(pod_name, pod_name, ns, f"find {log_path} -type f -mtime -{n} -print0 | xargs -0 grep failed")

adam/commands/repair/repair_stop.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.k8s_utils.jobs import Jobs
+from adam.utils_k8s.jobs import Jobs
 from adam.repl_state import ReplState, RequiredState
 from adam.config import Config
 

adam/commands/report.py

@@ -22,12 +22,18 @@ class Report(Command):
     def command(self):
         return Report.COMMAND
 
+    def required(self):
+        return ReplState.NON_L
+
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
         output: dict[str, any] = {}
         state, args = self.apply_state(args, state)
+        if not self.validate_state(state):
+            return state
+
         if state.in_repl:
             args, show = Command.extract_options(args, ['-s', '--show'])
 

adam/commands/restart.py

@@ -1,6 +1,6 @@
 from adam.commands.command import Command
-from adam.k8s_utils.pods import Pods
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
 

adam/commands/rollout.py

@@ -4,7 +4,7 @@ from kubernetes.client.rest import ApiException
 
 from adam.commands.command import Command
 from adam.commands.watch import Watch
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import duration, log2