kaqing 1.98.138__py3-none-any.whl → 1.98.140__py3-none-any.whl

adam/batch.py

@@ -22,7 +22,6 @@ 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.user_entry import UserEntry
 from adam.commands.watch import Watch
 from adam.k8s_utils.kube_context import KubeContext
 from adam.repl import enter_repl
@@ -261,16 +260,6 @@ def undeploy(kubeconfig: str, config: str, param: list[str], namespace: str, ext
     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=PodCommandHelper, help='Get cassandra log.')
-@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)
-
-
 @cli.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True), cls=ClusterOrPodCommandHelper, help='Watch pods in cluster.')
 @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')
@@ -283,7 +272,7 @@ def watch(kubeconfig: str, config: str, param: list[str], cluster: str, namespac
 
 
 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()
+    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):

adam/commands/deploy/deploy.py

@@ -1,7 +1,6 @@
 import click
 
 from adam.commands.command import Command
-from adam.commands.command_helpers import ClusterCommandHelper
 from adam.commands.deploy.deploy_pod import DeployPod
 from .deploy_frontend import DeployFrontend
 from adam.repl_state import ReplState

adam/commands/deploy/deploy_frontend.py

@@ -1,9 +1,6 @@
-from adam.app_session import AppSession
 from adam.commands.command import Command
 from adam.commands.deploy.deploy_utils import deploy_frontend
 from adam.config import Config
-from adam.k8s_utils.ingresses import Ingresses
-from adam.k8s_utils.services import Services
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
 

adam/commands/deploy/deploy_pod.py

@@ -3,11 +3,10 @@ from kubernetes import client
 from adam.commands.command import Command
 from adam.commands.deploy.deploy_utils import deploy_frontend, gen_labels
 from adam.config import Config
-from adam.k8s_utils.ingresses import Ingresses
+from adam.k8s_utils.deployment import Deployments
 from adam.k8s_utils.kube_context import KubeContext
 from adam.k8s_utils.pods import Pods
 from adam.k8s_utils.service_accounts import ServiceAccounts
-from adam.k8s_utils.services import Services
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
 
@@ -55,11 +54,12 @@ class DeployPod(Command):
                 add=["SYS_PTRACE"]
             )
         )
-        Pods.create(state.namespace, pod_name, image, env={'NAMESPACE': state.namespace}, container_security_context=security_context, labels=labels, sa_name=sa_name)
+        Deployments.create(state.namespace, pod_name, image, env={'NAMESPACE': state.namespace}, container_security_context=security_context, labels=labels, sa_name=sa_name)
 
         uri = deploy_frontend(pod_name, state.namespace, label_selector)
 
-        Pods.wait_for_running(state.namespace, pod_name, msg=f'Ops pod is starting up; it will be available at {uri}.')
+        # Pods.wait_for_running(state.namespace, label_selector, msg=f'Ops pod is starting up; it will be available at {uri}.')
+        Pods.wait_for_running(state.namespace, pod_name, msg=f'Ops pod is starting up; it will be available at {uri}.', label_selector=label_selector)
 
         return state
 

adam/commands/deploy/deploy_utils.py

@@ -1,14 +1,12 @@
 from adam.app_session import AppSession
 from adam.k8s_utils.ingresses import Ingresses
 from adam.k8s_utils.services import Services
-from adam.utils import log2
 
 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)
     Services.create_service(name, namespace, port, labels, labels=labels)
-    # Services.create_service(name, namespace, port, {"run": "ops"})
     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',

adam/commands/deploy/undeploy.py

@@ -1,10 +1,8 @@
 import click
 
 from adam.commands.command import Command
-from adam.commands.command_helpers import ClusterCommandHelper
 from adam.commands.deploy.undeploy_frontend import UndeployFrontend
 from adam.commands.deploy.undeploy_pod import UndeployPod
-from .deploy_frontend import DeployFrontend
 from adam.repl_state import ReplState
 from adam.utils import lines_to_tabular, log, log2
 

adam/commands/deploy/undeploy_frontend.py

@@ -1,8 +1,6 @@
 from adam.commands.command import Command
 from adam.commands.deploy.deploy_utils import undeploy_frontend
 from adam.config import Config
-from adam.k8s_utils.ingresses import Ingresses
-from adam.k8s_utils.services import Services
 from adam.repl_state import ReplState, RequiredState
 
 class UndeployFrontend(Command):

adam/commands/deploy/undeploy_pod.py

@@ -1,12 +1,10 @@
-from adam.app_session import AppSession
 from adam.commands.command import Command
-from adam.commands.deploy.deploy_utils import deploy_frontend, undeploy_frontend
+from adam.commands.deploy.deploy_utils import undeploy_frontend
 from adam.config import Config
-from adam.k8s_utils.ingresses import Ingresses
+from adam.k8s_utils.deployment import Deployments
 from adam.k8s_utils.kube_context import KubeContext
 from adam.k8s_utils.pods import Pods
 from adam.k8s_utils.service_accounts import ServiceAccounts
-from adam.k8s_utils.services import Services
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
 
@@ -41,9 +39,11 @@ class UndeployPod(Command):
             return state
 
         label_selector = Config().get('pod.label-selector', 'run=ops')
-        undeploy_frontend(state.namespace, label_selector)
-        Pods.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0)
         ServiceAccounts.delete(state.namespace, label_selector=label_selector)
+        Deployments.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0)
+        # instantly destroy the pod
+        Pods.delete_with_selector(state.namespace, label_selector, grace_period_seconds=0)
+        undeploy_frontend(state.namespace, label_selector)
 
         return state
 

adam/k8s_utils/deployment.py

@@ -0,0 +1,219 @@
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import sys
+import time
+from typing import TypeVar, cast
+from kubernetes import client
+from kubernetes.stream import stream
+from kubernetes.stream.ws_client import ERROR_CHANNEL
+
+from adam.config import Config
+from adam.k8s_utils.pods import Pods
+from adam.pod_exec_result import PodExecResult
+from adam.utils import elapsed_time, log2
+from .kube_context import KubeContext
+
+T = TypeVar('T')
+_TEST_POD_EXEC_OUTS: PodExecResult = None
+
+# utility collection on deployments; methods are all static
+class Deployments:
+    def set_test_pod_exec_outs(outs: PodExecResult):
+        global _TEST_POD_EXEC_OUTS
+        _TEST_POD_EXEC_OUTS = outs
+
+        return _TEST_POD_EXEC_OUTS
+
+    def delete(pod_name: str, namespace: str):
+        try:
+            v1 = client.CoreV1Api()
+            api_response = v1.delete_namespaced_pod(pod_name, namespace)
+        except Exception as e:
+            log2("Exception when calling CoreV1Api->delete_namespaced_pod: %s\n" % e)
+
+    def delete_with_selector(namespace: str, label_selector: str, grace_period_seconds: int = None):
+        v1 = client.AppsV1Api()
+
+        ret = v1.list_namespaced_deployment(namespace=namespace, label_selector=label_selector)
+        for i in ret.items:
+            v1.delete_namespaced_deployment(name=i.metadata.name, namespace=namespace, grace_period_seconds=grace_period_seconds)
+
+    def on_pods(pods: list[str],
+                namespace: str,
+                body: Callable[[ThreadPoolExecutor, str, str, bool], T],
+                post: Callable[[T], T] = None,
+                action: str = 'action', max_workers=0, show_out=True) -> list[T]:
+        show_out = KubeContext.show_out(show_out)
+
+        if not max_workers:
+            max_workers = Config().action_workers(action, 0)
+        if max_workers > 0:
+            # if parallel, node sampling is suppressed
+            if KubeContext.show_parallelism():
+                log2(f'Executing on all nodes from statefulset in parallel...')
+            start_time = time.time()
+            try:
+                with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                    # disable stdout from the pod_exec, then show the output in a for loop
+                    futures = [body(executor, pod, namespace, show_out) for pod in pods]
+                    if len(futures) == 0:
+                        return cast(list[T], [])
+
+                rs = [future.result() for future in as_completed(futures)]
+                if post:
+                    rs = [post(r, show_out=show_out) for r in rs]
+
+                return rs
+            finally:
+                if KubeContext.show_parallelism():
+                    log2(f"Parallel {action} elapsed time: {elapsed_time(start_time)} with {max_workers} workers")
+        else:
+            results: list[T] = []
+
+            samples = Config().action_node_samples(action, sys.maxsize)
+            l = min(len(pods), samples)
+            adj = 'all'
+            if l < len(pods):
+                adj = f'{l} sample'
+            if show_out:
+                log2(f'Executing on {adj} nodes from statefulset...')
+            for pod_name in pods:
+                try:
+                    result = body(None, pod_name, namespace, show_out)
+                    if post:
+                        result = post(result, show_out=show_out)
+                    results.append(result)
+                    if result:
+                        l -= 1
+                        if not l:
+                            break
+                except Exception as e:
+                    log2(e)
+
+            return results
+
+    def exec(pod_name: str, container: str, namespace: str, command: str, show_out = True, throw_err = False, interaction: Callable[[any, list[str]], any] = None):
+        if _TEST_POD_EXEC_OUTS:
+            return _TEST_POD_EXEC_OUTS
+
+        show_out = KubeContext.show_out(show_out)
+
+        api = client.CoreV1Api()
+
+        exec_command = ["/bin/sh", "-c", command]
+        k_command = f'kubectl exec {pod_name} -c {container} -n {namespace} -- {command}'
+        if show_out:
+            print(k_command)
+
+        resp = stream(
+            api.connect_get_namespaced_pod_exec,
+            pod_name,
+            namespace,
+            command=exec_command,
+            container=container,
+            stderr=True,
+            stdin=True,
+            stdout=True,
+            tty=True,
+            _preload_content=False,
+        )
+
+        stdout = []
+        stderr = []
+        error_output = None
+        try:
+            while resp.is_open():
+                resp.update(timeout=1)
+                if resp.peek_stdout():
+                    frag = resp.read_stdout()
+                    stdout.append(frag)
+                    if show_out: print(frag, end="")
+
+                    if interaction:
+                        interaction(resp, stdout)
+                if resp.peek_stderr():
+                    frag = resp.read_stderr()
+                    stderr.append(frag)
+                    if show_out: print(frag, end="")
+
+            try:
+                # get the exit code from server
+                error_output = resp.read_channel(ERROR_CHANNEL)
+            except Exception:
+                pass
+        except Exception as e:
+            if throw_err:
+                raise e
+            else:
+                log2(e)
+        finally:
+            resp.close()
+
+        return PodExecResult("".join(stdout), "".join(stderr), k_command, error_output)
+
+    def get_container(namespace: str, pod_name: str, container_name: str):
+        pod = Pods.get(namespace, pod_name)
+        if not pod:
+            return None
+
+        for container in pod.spec.containers:
+            if container_name == container.name:
+                return container
+
+        return None
+
+    def get(namespace: str, pod_name: str):
+        v1 = client.CoreV1Api()
+        return v1.read_namespaced_pod(name=pod_name, namespace=namespace)
+
+    def create_deployment_spec(name: str, image: str, image_pull_secret: str,
+                               envs: list, container_security_context: client.V1SecurityContext,
+                               volume_name: str, pvc_name:str, mount_path:str,
+                               command: list[str]=None, sa_name=None, labels: dict[str, str] = {}):
+        return client.V1DeploymentSpec(
+            replicas=1,
+            selector=client.V1LabelSelector(match_labels=labels),
+            template=client.V1PodTemplateSpec(
+                metadata=client.V1ObjectMeta(labels=labels),
+                spec=Pods.create_pod_spec(name, image, image_pull_secret, envs, container_security_context,
+                                          volume_name, pvc_name, mount_path, command=command, sa_name=sa_name,
+                                          restart_policy="Always"),
+            ),
+        )
+
+    def create(namespace: str, deployment_name: str, image: str,
+               command: list[str] = None,
+               secret: str = None,
+               env: dict[str, any] = {},
+               container_security_context: client.V1SecurityContext = None,
+               labels: dict[str, str] = {},
+               volume_name: str = None,
+               pvc_name: str = None,
+               mount_path: str = None,
+               sa_name=None):
+        v1 = client.AppsV1Api()
+        envs = []
+        for k, v in env.items():
+            envs.append(client.V1EnvVar(name=str(k), value=str(v)))
+        deployment = Deployments.create_deployment_spec(deployment_name, image, secret, envs, container_security_context, volume_name, pvc_name, mount_path, command=command, sa_name=sa_name, labels=labels)
+        return v1.create_namespaced_deployment(
+            namespace=namespace,
+            body=client.V1Deployment(spec=deployment, metadata=client.V1ObjectMeta(
+                name=deployment_name,
+                labels=labels
+            ))
+        )
+
+    def wait_for_running(namespace: str, pod_name: str, msg: str=None):
+        msged = False
+
+        while Pods.get(namespace, pod_name).status.phase != 'Running':
+            if not msged:
+                if not msg:
+                    msg = f'Waiting for the {pod_name} pod to start up...'
+                log2(msg)
+                msged = True
+            time.sleep(5)
+
+    def completed(namespace: str, pod_name: str):
+        return Pods.get(namespace, pod_name).status.phase in ['Succeeded', 'Failed']

adam/k8s_utils/pods.py

@@ -165,7 +165,17 @@ class Pods:
         v1 = client.CoreV1Api()
         return v1.read_namespaced_pod(name=pod_name, namespace=namespace)
 
-    def create_pod_spec(name: str, image: str, image_pull_secret: str, envs: list, container_security_context: client.V1SecurityContext, volume_name: str, pvc_name:str, mount_path:str, command: list[str]=None, sa_name=None):
+    def get_with_selector(namespace: str, label_selector: str):
+        v1 = client.CoreV1Api()
+
+        ret = v1.list_namespaced_pod(namespace=namespace, label_selector=label_selector)
+        for i in ret.items:
+            return v1.read_namespaced_pod(name=i.metadata.name, namespace=namespace)
+
+    def create_pod_spec(name: str, image: str, image_pull_secret: str,
+                        envs: list, container_security_context: client.V1SecurityContext,
+                        volume_name: str, pvc_name:str, mount_path:str,
+                        command: list[str]=None, sa_name=None, restart_policy="Never"):
         volume_mounts = []
         if volume_name and pvc_name and mount_path:
             volume_mounts=[client.V1VolumeMount(mount_path=mount_path, name=volume_name)]
@@ -182,7 +192,7 @@ class Pods:
             security_context=client.V1PodSecurityContext(run_as_user=1001, run_as_group=1001, fs_group=1001)
 
         return client.V1PodSpec(
-            restart_policy="Never",
+            restart_policy=restart_policy,
             containers=[container],
             image_pull_secrets=[client.V1LocalObjectReference(name=image_pull_secret)],
             security_context=security_context,
@@ -213,10 +223,10 @@ class Pods:
             ))
         )
 
-    def wait_for_running(namespace: str, pod_name: str, msg: str=None):
+    def wait_for_running(namespace: str, pod_name: str, msg: str=None, label_selector: str = None):
         msged = False
 
-        while Pods.get(namespace, pod_name).status.phase != 'Running':
+        while (Pods.get_with_selector(namespace, label_selector) if label_selector else Pods.get(namespace, pod_name)).status.phase != 'Running':
             if not msged:
                 if not msg:
                     msg = f'Waiting for the {pod_name} pod to start up...'

adam/version.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-__version__ = "1.98.138"  #: the working version
+__version__ = "1.98.140"  #: the working version
 __release__ = "1.0.0"  #: the release version

{kaqing-1.98.138.dist-info → kaqing-1.98.140.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 1.98.138
+Version: 1.98.140
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-1.98.138.dist-info → kaqing-1.98.140.dist-info}/RECORD

@@ -1,7 +1,7 @@
 adam/__init__.py,sha256=oVw1FNd9HZPJ7wm6BNn5ybyNGJLjJ8kopMeBiwgMaOI,59
 adam/app_session.py,sha256=Klypm4JYHOlovaRCHAZ2P_Mj_nheMlcQgX403R0TJGk,6969
 adam/apps.py,sha256=UTpUJBAMRFvR8kJZwileGC0UmPvsOjJ_AgvWoGmnIFI,6701
-adam/batch.py,sha256=Bf5Q07_DW8FEUwuXCq70qjkKs2Sarv1ujNYpBFBQfQM,24102
+adam/batch.py,sha256=o82yYDgyoJw1t87QyAfn9jGqIcWX23ehRI21U4JUTv8,23221
 adam/cli.py,sha256=03pIZdomAu7IL-GSP6Eun_PKwwISShRAmfx6eVRPGC0,458
 adam/cli_group.py,sha256=W3zy1BghCtVcEXizq8fBH-93ZRVVwgAyGPzy0sHno1Y,593
 adam/config.py,sha256=38UcmYRxf-Kq4iPbKS7tNPQqN64fam1bWNy6jhWREd0,2552
@@ -14,7 +14,7 @@ adam/repl_commands.py,sha256=ionPWjPhzrzm59zbhO1WsGGcLVba3bnPl6uPjvQ4C34,4093
 adam/repl_session.py,sha256=uIogcvWBh7wd8QQ-p_JgLsyJ8YJgINw5vOd6JIsd7Vo,472
 adam/repl_state.py,sha256=QarrUAwYWOz3YTemtaf2opbHLa5a3LEsyuonNwhvOhk,7131
 adam/utils.py,sha256=j7p7iruLuV11swa0z9ZLBgoJHu_nkTSVKtQe0q71gmk,7025
-adam/version.py,sha256=j3ymiKxzAmfnS3pyEwSXPXYtWvf4WbZT5q6Ov440ki8,141
+adam/version.py,sha256=aHmraJ9rwWAccgp_8uuEZLVAOkQ32VkuKXEpe6zSLEA,141
 adam/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/checks/check.py,sha256=Qopr3huYcMu2bzQgb99dEUYjFzkjKHRI76S6KA9b9Rk,702
 adam/checks/check_context.py,sha256=FEHkQ32jY1EDopQ2uYWqy9v7aEEX1orLpJWhopwAlh4,402
@@ -76,19 +76,18 @@ adam/commands/report.py,sha256=Ky45LIzSlB_X4V12JZWjU3SA2u4_FKRencRTq7psOWU,1944
 adam/commands/restart.py,sha256=Hik1t5rjH2ATZv4tzwrGB3e44b3dNuATgY327_Nb8Bs,2044
 adam/commands/rollout.py,sha256=52_4ijna3v-8Oug12et43DRHFDNhiN34p6xLTQmhdbQ,2959
 adam/commands/shell.py,sha256=wY_PIx7Lt6vuxhFArlfxdEnBbrouCJ3yNHhFn17DEqw,848
-adam/commands/user_entry.py,sha256=TJBffUJTVAuJw-UJWv2JOoeEy1iQBXAOLahQJsmX1RY,4719
 adam/commands/watch.py,sha256=mmBFpB8T1V7zrNs5b2YNyDDztMym_ILPDdkrbdAXTas,2438
 adam/commands/deploy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/commands/deploy/code_start.py,sha256=-iH8HThTNM83IfBxT_LqTByuHVatV9d-Il4OYOfrwLI,1370
 adam/commands/deploy/code_stop.py,sha256=ch7ZMgosvTHsGaIcDwQY5XYh_5HYrUjBkZFOI-d2gOU,1696
 adam/commands/deploy/code_utils.py,sha256=5Gp4U8HzKpPkbkHDU7whlvGOK-wWaAbCIIGzVoN9hio,3296
-adam/commands/deploy/deploy.py,sha256=ymGprq2rBpAMsxaqRrVnrcYetAq9GDTguohlAWFuFa8,1855
-adam/commands/deploy/deploy_frontend.py,sha256=_HBekXvRAXIzHf4SgAsY_OgKdnesuM3THgdbbwyAARY,1832
-adam/commands/deploy/deploy_pod.py,sha256=mLl6jTII7JAz_ES4zWtsu8WF8MvlgevU-hes-y1s2Ec,2649
-adam/commands/deploy/deploy_utils.py,sha256=L-UONUT_Ew8hRw2ozdWMx3tr0kmBInxX8xDXr4d4EO8,1143
-adam/commands/deploy/undeploy.py,sha256=JWRwYLiS7iD2utRr2Zb8HCg_rbgHTw-A17CCs2ezl00,1949
-adam/commands/deploy/undeploy_frontend.py,sha256=P04l_DI6y1dAqHMQMG94MG7K4piCw84zhPszc4Lz28o,1349
-adam/commands/deploy/undeploy_pod.py,sha256=D9dNMWyFK3hzOd4tXIfVQ7tMM8me17_fHfDFbooU4OQ,1866
+adam/commands/deploy/deploy.py,sha256=_y_pSBHIEVMTgjDqEZwvmGfLQBirHBH4sCnsl0CKOM8,1792
+adam/commands/deploy/deploy_frontend.py,sha256=TSvMTy6uUfOBIV96hKFy-M1hNCE6OeRW9M_dj1ZJsv0,1700
+adam/commands/deploy/deploy_pod.py,sha256=IaDmrxpYw_YqkK599Vq4N7_4tINq5ihBlccVPEFcpCk,2773
+adam/commands/deploy/deploy_utils.py,sha256=-YB-XUwr8zVsf9HKYWx_TP-dB2WgOpEmUGyYNcoie0U,1046
+adam/commands/deploy/undeploy.py,sha256=CNgbB00TR1YRgX0xGgdGAT8YNPlcLssMsRX-pSby-Ao,1842
+adam/commands/deploy/undeploy_frontend.py,sha256=mbHlWb5UHUVpR1trfflCS_TDip7eAqxqoZ47RzRZcno,1257
+adam/commands/deploy/undeploy_pod.py,sha256=Notj7_MNU-sHxulJPnWKi1QUDUE8cWArZZEko8hKw3A,1901
 adam/commands/medusa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/commands/medusa/medusa.py,sha256=Y_yyOZRb6u45wfTVBRp3kuklyYDTSlaAJQdAiymP_8M,2185
 adam/commands/medusa/medusa_backup.py,sha256=j4DTVWFT-4rzs4gG_pBvjE-JuPsVCJIsnyQjIzJ4EbA,1801
@@ -138,10 +137,11 @@ adam/k8s_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/k8s_utils/cassandra_clusters.py,sha256=9gUn31SsyW32asSFM8cKdkDSw5LYqPY2Iv0r4fDg_fU,2017
 adam/k8s_utils/cassandra_nodes.py,sha256=jQlaxIQKnavvsXH7lMM8WPriusp7KO698UygytIA8Xw,1134
 adam/k8s_utils/custom_resources.py,sha256=cIeaZRQET2DelTGU2f5QsMckh7TddPpWZDFeNK3txeQ,7647
+adam/k8s_utils/deployment.py,sha256=ai5DwdU0y6s6i0jmOKnfydbXSfZZCkG3f-XTf7P7-64,8504
 adam/k8s_utils/ingresses.py,sha256=ul3Z6fDGc_Cxcn-ExP0vXhZatoShCUZFtpwtCY4Qx7o,3460
 adam/k8s_utils/jobs.py,sha256=P7j3JiZ33TRnkjkPLLrGlypAPxK1BZQHvVpF8s7eHA8,2604
 adam/k8s_utils/kube_context.py,sha256=nocEyVNjXWG-N-GNnEYHDvnot7H5LQUFmpZIwIyE7As,3310
-adam/k8s_utils/pods.py,sha256=I_xjOOJsbiW2_ZUz7Q-8sogyBzJqzVbrNZuRAHX1GmA,8758
+adam/k8s_utils/pods.py,sha256=zSCqW-13kWt11yT7iYwPCFxPnyrJP5F_avW6BFvikfk,9264
 adam/k8s_utils/secrets.py,sha256=pYaVKXTpx3-QgFtBjznWFq0N6ZcBdxnx21FRe5nBCCo,2305
 adam/k8s_utils/service_accounts.py,sha256=v2oQSqCrNvt2uRnKlNwR3fjtpUG7oF5nqgzEB7NnT-U,6349
 adam/k8s_utils/services.py,sha256=EOJJGACVbbRvu5T3rMKqIJqgYic1_MSJ17EA0TJ6UOk,3156
@@ -157,8 +157,8 @@ adam/sso/idp.py,sha256=fvcwUw_URTgsO6ySaqTIw0zQT2qRO1IPSGhf6rPtybo,5804
 adam/sso/idp_login.py,sha256=QAtCUeDTVWliJy40RK_oac8Vgybr13xH8wzeBoxPaa8,1754
 adam/sso/idp_session.py,sha256=9BUHNRf70u4rVKrVY1HKPOEmOviXvkjam8WJxmXSKIM,1735
 adam/sso/sso_config.py,sha256=5N8WZgIJQBtHUy585XLRWKjpU87_v6QluyNK9E27D5s,2459
-kaqing-1.98.138.dist-info/METADATA,sha256=CfpWrYBUPqJtbAECzmfyHZb8tokHOoF1rIKOnv1KDLY,134
-kaqing-1.98.138.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-kaqing-1.98.138.dist-info/entry_points.txt,sha256=SkzhuQJUWsXOzHeZ5TgQ2c3_g53UGK23zzJU_JTZOZI,39
-kaqing-1.98.138.dist-info/top_level.txt,sha256=8_2PZkwBb-xDcnc8a2rAbQeJhXKXskc7zTP7pSPa1fw,5
-kaqing-1.98.138.dist-info/RECORD,,
+kaqing-1.98.140.dist-info/METADATA,sha256=6GDFpkMOLNGQdRq63lPYleF-ifTzXW_GVOO9d4tBywI,134
+kaqing-1.98.140.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+kaqing-1.98.140.dist-info/entry_points.txt,sha256=SkzhuQJUWsXOzHeZ5TgQ2c3_g53UGK23zzJU_JTZOZI,39
+kaqing-1.98.140.dist-info/top_level.txt,sha256=8_2PZkwBb-xDcnc8a2rAbQeJhXKXskc7zTP7pSPa1fw,5
+kaqing-1.98.140.dist-info/RECORD,,

adam/commands/user_entry.py

@@ -1,133 +0,0 @@
-from functools import partial
-from http.server import BaseHTTPRequestHandler, HTTPServer
-import os
-import re
-import subprocess
-import signal
-import threading
-import traceback
-
-from adam.commands.deploy.code_utils import get_available_port
-from adam.config import Config
-from adam.sso.idp import Idp
-from adam.app_session import AppSession, IdpLogin
-from adam.apps import Apps
-from adam.commands.command import Command
-from adam.repl_state import ReplState
-from adam.utils import log2
-
-class TokenHandler(BaseHTTPRequestHandler):
-    def __init__(self, port: int, user: str, idp_token: str, *args, **kwargs):
-        self.port = port
-        self.user = user
-        self.idp_token = idp_token
-        super().__init__(*args, **kwargs)
-
-    def log_request(self, code='-', size='-'):
-        pass
-
-    def do_GET(self):
-        Config().debug(f'Token request from cient: {self.client_address}\r')
-        ports = self.get_user_ports()
-        Config().debug(f'ports: {ports}\r')
-        if os.getenv('CHECK_CLIENT_PORT', 'true').lower() != 'true' or self.client_address[1] in ports:
-            self.send_response(200)
-            self.send_header('Content-type', 'text/plain')
-            self.end_headers()
-            self.wfile.write(self.idp_token.encode('utf8'))
-        else:
-            self.send_response(403)
-            self.send_header('Content-type', 'text/plain')
-            self.end_headers()
-            self.wfile.write(f'Port: {self.port} has not been opened by you.\n'.encode('utf8'))
-
-    def get_user_ports(self):
-        # this needs SYS_PTRACE capability with the container
-        ports = []
-
-        # curl 627299 sahn 5u IPv4 542049941 0t0 TCP localhost:39524->localhost:8001 (ESTABLISHED)
-        command = ['bash', '-c', f"lsof -i -P 2> /dev/null | grep {self.user} | grep localhost" + " | awk '{print $9}'"]
-        result = subprocess.run(command, capture_output=True, text=True, check=True)
-        for line in result.stdout.split('\n'):
-            groups = re.match(r'localhost:(.*?)->localhost:(.*)$', line)
-            if groups:
-                ports.append(int(groups[1]))
-
-        return ports
-
-class UserEntry(Command):
-    COMMAND = 'entry'
-
-    # the singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, 'instance'): cls.instance = super(UserEntry, cls).__new__(cls)
-
-        return cls.instance
-
-    def __init__(self, successor: Command=None):
-        super().__init__(successor)
-
-    def command(self):
-        return UserEntry.COMMAND
-
-    def run_token_server(port: int, user: str, idp_token: str):
-        server_address = ('localhost', port)
-        handler = partial(TokenHandler, port, user, idp_token)
-        httpd = HTTPServer(server_address, handler)
-        Config().debug(f"Serving on port {port}")
-        httpd.serve_forever()
-
-    def run(self, cmd: str, state: ReplState):
-        def custom_handler(signum, frame):
-            AppSession.ctrl_c_entered = True
-
-        signal.signal(signal.SIGINT, custom_handler)
-
-        if not(args := self.args(cmd)):
-            return super().run(cmd, state)
-
-        state, args = self.apply_state(args, state)
-        args, debug = Command.extract_options(args, 'd')
-        if debug:
-            Config().set('debug.show-out', True)
-
-        username: str = None
-        if len(args) > 0:
-            username = args[0]
-
-        login: IdpLogin = None
-        while not login:
-            try:
-                if not(host := Apps.app_host('c3', 'c3', state.namespace)):
-                    log2('Cannot locate ingress for app.')
-                    username = None
-                    continue
-
-                if not (login := Idp.login(host, username=username, use_token_from_env=False, use_cached_creds=False)):
-                    log2('Invalid username/password. Please try again.')
-                    username = None
-            except Exception as e:
-                log2(e)
-
-                Config().debug(traceback.format_exc())
-
-        server_port = get_available_port()
-        server_thread = threading.Thread(target=UserEntry.run_token_server, args=(server_port, login.shell_user(), login.ser()), daemon=True)
-        server_thread.start()
-
-        sh = f'{os.getcwd()}/login.sh'
-        if not os.path.exists(sh):
-            sh = f'{os.getcwd()}/docker/login.sh'
-
-        if os.getenv('PASS_DOWN_IDP_TOKEN', "false").lower() == "true":
-            os.system(f'{sh} {login.shell_user()} {server_port} {login.ser()}')
-        else:
-            os.system(f'{sh} {login.shell_user()} {server_port}')
-
-        return state
-
-    def completion(self, _: ReplState):
-        return {}
-
-    def help(self, _: ReplState):
-        return f'{UserEntry.COMMAND}\t ttyd user entry'