pyntcli 0.1.99__py3-none-any.whl → 0.1.100__py3-none-any.whl

pyntcli/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.99"
+__version__ = "0.1.100"
 
 try:
     from logzio import sender

pyntcli/commands/burp.py

@@ -227,15 +227,15 @@ class BurpCommand(sub_command.PyntSubCommand):
             return
 
     def run_cmd(self, args: argparse.Namespace):
-        container = pynt_container.get_container_with_arguments(
-            "proxy",
+        container_config = pynt_container.DockerContainerConfig(
             args,
+            "proxy",
             pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PORT, args.port, "--port"),
             pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PROXY_PORT, args.proxy_port, "--proxy-port"),
         )
 
         for host in args.captured_domains:
-            container.docker_arguments += ["--host-targets", host]
+            container_config.docker_arguments += ["--host-targets", host]
 
         if "ca_path" in args and args.ca_path:
             if not os.path.isfile(args.ca_path):
@@ -248,14 +248,14 @@ class BurpCommand(sub_command.PyntSubCommand):
                 return
 
             ca_name = os.path.basename(args.ca_path)
-            container.docker_arguments += ["--ca-path", ca_name]
-            container.mounts.append(
+            container_config.docker_arguments += ["--ca-path", ca_name]
+            container_config.mounts.append(
                 pynt_container.create_mount(
                     os.path.abspath(args.ca_path), "/etc/pynt/{}".format(ca_name)
                 )
             )
 
-        container.docker_arguments += ["--test-name", os.path.basename(args.xml)]
+        container_config.docker_arguments += ["--test-name", os.path.basename(args.xml)]
 
         if not os.path.isfile(args.xml):
             ui_thread.print(
@@ -286,12 +286,7 @@ class BurpCommand(sub_command.PyntSubCommand):
             )
             return
 
-        proxy_docker = pynt_container.PyntContainer(
-            image_name=pynt_container.PYNT_DOCKER_IMAGE,
-            tag="v1-latest",
-            detach=True,
-            base_container=container,
-            use_native=args.use_docker_native)
+        proxy_docker = pynt_container.PyntContainerNative(container_config)
 
         proxy_docker.prepare_client()
         proxy_docker.pre_run_validation(args.port)

pyntcli/commands/command.py

@@ -145,19 +145,19 @@ class CommandSubCommand(sub_command.PyntSubCommand):
             return
 
     def run_cmd(self, args: argparse.Namespace):
-        container = pynt_container.get_container_with_arguments(
-            "proxy",
+        container_config = pynt_container.DockerContainerConfig(
             args,
+            "proxy",
             pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PORT, args.port, "--port"),
             pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PROXY_PORT, args.proxy_port, "--proxy-port"),
         )
 
         if args.captured_domains:
             for host in args.captured_domains:
-                container.docker_arguments += ["--host-targets", host]
+                container_config.docker_arguments += ["--host-targets", host]
 
         if args.test_name:
-            container.docker_arguments += ["--test-name", args.test_name]
+            container_config.docker_arguments += ["--test-name", args.test_name]
 
         if "ca_path" in args and args.ca_path:
             if not os.path.isfile(args.ca_path):
@@ -170,19 +170,14 @@ class CommandSubCommand(sub_command.PyntSubCommand):
                 return
 
             ca_name = os.path.basename(args.ca_path)
-            container.docker_arguments += ["--ca-path", ca_name]
-            container.mounts.append(
+            container_config.docker_arguments += ["--ca-path", ca_name]
+            container_config.mounts.append(
                 pynt_container.create_mount(
                     os.path.abspath(args.ca_path), "/etc/pynt/{}".format(ca_name)
                 )
             )
 
-        proxy_docker = pynt_container.PyntContainer(
-            image_name=pynt_container.PYNT_DOCKER_IMAGE,
-            tag="v1-latest",
-            detach=True,
-            base_container=container,
-            use_native=args.use_docker_native)
+        proxy_docker = pynt_container.PyntContainerNative(container_config)
 
         proxy_docker.prepare_client()
         proxy_docker.pre_run_validation(args.port)

pyntcli/commands/har.py

@@ -58,8 +58,10 @@ class HarSubCommand(sub_command.PyntSubCommand):
     def run_cmd(self, args: argparse.Namespace):
         ui_thread.print_verbose("Building container")
         port = util.find_open_port()
-        container = pynt_container.get_container_with_arguments(
-            "har", args, pynt_container.PyntDockerPort(src=PYNT_CONTAINER_INTERNAL_PORT, dest=port, name="--port")
+        container_config = pynt_container.DockerContainerConfig(
+            args,
+            "har",
+            pynt_container.PyntDockerPort(src=PYNT_CONTAINER_INTERNAL_PORT, dest=port, name="--port")
         )
 
         if not os.path.isfile(args.har):
@@ -72,26 +74,21 @@ class HarSubCommand(sub_command.PyntSubCommand):
             return
 
         har_name = os.path.basename(args.har)
-        container.docker_arguments += ["--har", har_name]
-        container.mounts.append(
+        container_config.docker_arguments += ["--har", har_name]
+        container_config.mounts.append(
             pynt_container.create_mount(
                 os.path.abspath(args.har), "/etc/pynt/{}".format(har_name)
             )
         )
 
         for host in args.captured_domains:
-            container.docker_arguments += ["--host-targets", host]
+            container_config.docker_arguments += ["--host-targets", host]
 
         with util.create_default_file_mounts(args) as m:
 
-            container.mounts += m
+            container_config.mounts += m
 
-            har_docker = pynt_container.PyntContainer(
-                image_name=pynt_container.PYNT_DOCKER_IMAGE,
-                tag="v1-latest",
-                detach=True,
-                base_container=container,
-                use_native=args.use_docker_native)
+            har_docker = pynt_container.PyntContainerNative(container_config)
 
             har_docker.prepare_client()
             har_docker.pre_run_validation(port)

pyntcli/commands/listen.py

@@ -106,17 +106,17 @@ class ListenSubCommand(sub_command.PyntSubCommand):
             return
 
     def run_cmd(self, args: argparse.Namespace):
-        container = pynt_container.get_container_with_arguments(
-            "proxy",
+        container_config = pynt_container.DockerContainerConfig(
             args,
+            "proxy",
             pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PORT, args.port, "--port"),
             pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PROXY_PORT, args.proxy_port, "--proxy-port"))
 
         for host in args.captured_domains:
-            container.docker_arguments += ["--host-targets", host]
+            container_config.docker_arguments += ["--host-targets", host]
 
         if args.test_name:
-            container.docker_arguments += ["--test-name", args.test_name]
+            container_config.docker_arguments += ["--test-name", args.test_name]
 
         if "ca_path" in args and args.ca_path:
             if not os.path.isfile(args.ca_path):
@@ -129,18 +129,14 @@ class ListenSubCommand(sub_command.PyntSubCommand):
                 return
 
             ca_name = os.path.basename(args.ca_path)
-            container.docker_arguments += ["--ca-path", ca_name]
-            container.mounts.append(
+            container_config.docker_arguments += ["--ca-path", ca_name]
+            container_config.mounts.append(
                 pynt_container.create_mount(
                     os.path.abspath(args.ca_path), "/etc/pynt/{}".format(ca_name)
                 )
             )
 
-        proxy_docker = pynt_container.PyntContainer(
-            image_name=pynt_container.PYNT_DOCKER_IMAGE,
-            tag="v1-latest",
-            detach=True,
-            base_container=container)
+        proxy_docker = pynt_container.PyntContainerNative(container_config)
 
         proxy_docker.prepare_client()
         proxy_docker.pre_run_validation(args.port)

pyntcli/commands/newman.py

@@ -57,8 +57,10 @@ class NewmanSubCommand(sub_command.PyntSubCommand):
     def run_cmd(self, args: argparse.Namespace):
 
         port = util.find_open_port()
-        container = pynt_container.get_container_with_arguments(
-            "newman", args, pynt_container.PyntDockerPort(src=PYNT_CONTAINER_INTERNAL_PORT, dest=port, name="--port")
+        container_config = pynt_container.DockerContainerConfig(
+            args,
+            "newman",
+            pynt_container.PyntDockerPort(src=PYNT_CONTAINER_INTERNAL_PORT, dest=port, name="--port")
         )
 
         if not os.path.isfile(args.collection):
@@ -71,8 +73,8 @@ class NewmanSubCommand(sub_command.PyntSubCommand):
             return
 
         collection_name = os.path.basename(args.collection)
-        container.docker_arguments += ["-c", collection_name]
-        container.mounts.append(
+        container_config.docker_arguments += ["-c", collection_name]
+        container_config.mounts.append(
             pynt_container.create_mount(
                 os.path.abspath(args.collection), "/etc/pynt/{}".format(collection_name)
             )
@@ -91,21 +93,16 @@ class NewmanSubCommand(sub_command.PyntSubCommand):
                     return
                 env_name = os.path.basename(environ)
                 env_names.append(env_name)
-                container.mounts.append(
+                container_config.mounts.append(
                     pynt_container.create_mount(
                         os.path.abspath(environ), "/etc/pynt/{}".format(env_name)
                     )
                 )
-            container.docker_arguments += ["-e", ",".join(env_names)]
+            container_config.docker_arguments += ["-e", ",".join(env_names)]
 
         with util.create_default_file_mounts(args) as m:
-            container.mounts += m
-            newman_docker = pynt_container.PyntContainer(
-                image_name=pynt_container.PYNT_DOCKER_IMAGE,
-                tag="v1-latest",
-                detach=True,
-                base_container=container,
-                use_native=args.use_docker_native)
+            container_config.mounts += m
+            newman_docker = pynt_container.PyntContainerNative(container_config)
 
             newman_docker.prepare_client()
             newman_docker.pre_run_validation(port)

pyntcli/commands/postman.py

@@ -95,13 +95,12 @@ class PostmanSubCommand(sub_command.PyntSubCommand):
             ui_thread.print("application-id is not supported in postman integration, use the collection variables to set application id.")
             args.application_id = ""
 
-        container = pynt_container.get_container_with_arguments("postman", args, pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PORT, args.port, name="--port"))
+        container_config = pynt_container.DockerContainerConfig(
+            args,
+            "postman",
+            pynt_container.PyntDockerPort(PYNT_CONTAINER_INTERNAL_PORT, args.port, name="--port"))
 
-        postman_docker = pynt_container.PyntContainer(image_name=pynt_container.PYNT_DOCKER_IMAGE,
-                                                      tag="v1-latest",
-                                                      detach=True,
-                                                      base_container=container,
-                                                      use_native=args.use_docker_native)
+        postman_docker = pynt_container.PyntContainerNative(container_config)
         postman_docker.prepare_client()
         postman_docker.pre_run_validation(args.port)
         postman_docker.run()

pyntcli/commands/root.py

@@ -88,7 +88,14 @@ class BaseCommand:
         parser.add_argument(
             "--use-docker-native",
             action="store_true",
-            help="Use native docker instead of docker sdk"
+            help=argparse.SUPPRESS,
+        )
+        parser.add_argument(
+            "--pynt-image",
+            default="",
+            required=False,
+            type=str,
+            help=argparse.SUPPRESS,
         )
 
     def get_subparser(self) -> argparse._SubParsersAction:

pyntcli/main.py

@@ -32,14 +32,6 @@ def signal_handler(signal_number, frame):
 
     exit(0)
 
-
-def get_docker_platform_name(use_docker_native: bool = False) -> str:
-    if use_docker_native:
-        return pynt_container.get_docker_platform_by_native_command()
-
-    return pynt_container.get_docker_platform_by_sdk()
-
-
 def print_header():
     ui_thread.print(ui_thread.PrinterText(*ui_thread.pynt_header())
                     .with_line(*ui_thread.pynt_version())
@@ -79,16 +71,12 @@ def main():
         if "--verbose" in argv:
             ui_thread.VERBOSE = True
 
-        use_docker_native = True if "--use-docker-native" in argv else False
-        if use_docker_native:
-            analytics.emit(analytics.DOCKER_NATIVE_FLAG, {"message": "using docker native flag"})
-
         log.set_source(__version__)
         ui_thread.print_verbose("Logging in...")
         user_id = login.user_id()
         start_analytics(user_id)
         ui_thread.print_verbose("Asserting docker is properly installed")
-        platform_name = get_docker_platform_name(use_docker_native)
+        platform_name = pynt_container.get_docker_platform_name()
         ui_thread.print_verbose("Docker platform: {}".format(platform_name))
         signal.signal(signal.SIGINT, signal_handler)
         cli = pynt_cmd.PyntCommand()

pyntcli/pynt_docker/pynt_container.py

@@ -1,8 +1,5 @@
 import platform
 import subprocess
-import docker
-from docker.errors import DockerException, APIError, ImageNotFound
-from requests.exceptions import ReadTimeout
 from docker.types import Mount
 import os
 import json
@@ -46,7 +43,7 @@ class PortInUseException(Exception):
         super().__init__(self.message)
 
 
-def get_docker_platform_by_native_command():
+def get_docker_platform_name():
     try:
         version_data = json.loads(subprocess.check_output(["docker", "version", "--format", "{{json .}}"], text=True))
         platform = version_data.get("Server", {}).get("Platform", {})
@@ -56,23 +53,6 @@ def get_docker_platform_by_native_command():
         raise DockerNotAvailableException()
 
 
-def get_docker_platform_by_sdk():
-    try:
-        c = docker.from_env()
-        version_data = c.version()
-        platform = version_data.get("Platform")
-        analytics.deferred_emit(analytics.DOCKER_PLATFORM, platform)
-        if platform and platform.get("Name"):
-            return platform.get("Name")
-
-        return ""
-
-    except DockerException:
-        raise DockerNotAvailableException()
-    except Exception:  # TODO: This is since windows is not behaving nice
-        raise DockerNotAvailableException()
-
-
 class PyntBaseContainer():
     def __init__(self, docker_type, docker_arguments, mounts, environment={}) -> None:
         self.docker_type = docker_type
@@ -88,33 +68,83 @@ class PyntDockerPort:
         self.name = name
 
 
-def is_network_host(use_docker_sdk: bool) -> bool:
+class PyntDockerImage:
+    def __init__(self, name, is_self_managed) -> None:
+        self.name = name
+        self.is_self_managed = is_self_managed
+
+
+class DockerContainerConfig:
+    def __init__(self, args: argparse.Namespace, integration_name: str, *port_args: PyntDockerPort):
+        self.image = get_image_config(args)
+        self.is_detach = True
+        self.ports = port_args
+        self.docker_arguments = build_docker_args(integration_name, args)
+        self.mounts = get_docker_mounts(args)
+        self.env_vars = {PYNT_ID: CredStore().get_tokens(), "PYNT_SAAS_URL": PYNT_SAAS}
+        if user_set_all_variables():
+            add_env_variables(self.env_vars)
+
+        ports = {}
+        create_network_host = is_network_host()
+        for p in port_args:
+            if create_network_host:
+                self.docker_arguments.append(p.name)
+                self.docker_arguments.append(str(p.dest))
+            else:
+                ports[str(p.src)] = int(p.dest)
+
+        if create_network_host:
+            self.docker_type = PyntNativeHost(network="host")
+        else:
+            self.docker_type = PyntDockerDesktopContainer(ports=ports)
+
+
+def get_image_config(args: argparse.Namespace) -> PyntDockerImage:
+    default_image = f'{PYNT_DOCKER_IMAGE}:v1-latest'
+    if "pynt_image" in args and args.pynt_image:
+        return PyntDockerImage(args.pynt_image, True)
+    env_name = value_from_environment_variable("IMAGE")
+    env_tag = value_from_environment_variable("TAG")
+    if env_name:
+        return PyntDockerImage(f'{env_name}:{env_tag}', True)
+
+    return PyntDockerImage(default_image, False)
+
+
+def is_network_host() -> bool:
     platform_sys_name = platform.system()
     if platform_sys_name == "Windows" or platform_sys_name == "Darwin":
         return False
     else:
-        docker_platform_name = get_docker_platform_by_sdk().lower() if use_docker_sdk else get_docker_platform_by_native_command().lower()
+        docker_platform_name = get_docker_platform_name().lower()
         if "desktop" in docker_platform_name:
             return False
         return True
 
 
-def get_container_with_arguments(integration: str, args: argparse.Namespace, *port_args: PyntDockerPort) \
-        -> PyntBaseContainer:
-    docker_arguments = [integration]
-    ports = {}
-    create_network_host = is_network_host(args.use_docker_native)
-    for p in port_args:
-        if create_network_host:
-            docker_arguments.append(p.name)
-            docker_arguments.append(str(p.dest))
-        else:
-            ports[str(p.src)] = int(p.dest)
+def user_set_all_variables():
+    return all([PYNT_BUCKET_NAME, PYNT_PARAM1, PYNT_PARAM2])
+
+
+def add_env_variables(env: dict):
+    env["PYNT_BUCKET_NAME"] = PYNT_BUCKET_NAME
+    env["PYNT_PARAM1"] = base64.b64encode(PYNT_PARAM1.encode('utf-8'))
+    env["PYNT_PARAM2"] = base64.b64encode(PYNT_PARAM2.encode('utf-8'))
+
+
+def value_from_environment_variable(key):
+    e = os.environ.get(key)
+
+    if e:
+        ui_thread.print_verbose(f"Using environment variable {key}={e}")
+        return e
+
+    return None
 
-    if create_network_host:
-        docker_type = PyntNativeContainer(network="host")
-    else:
-        docker_type = PyntDockerDesktopContainer(ports=ports)
+
+def build_docker_args(integration_name:str, args: argparse.Namespace) -> list[str]:
+    docker_arguments = [integration_name]
 
     if "insecure" in args and args.insecure:
         docker_arguments.append("--insecure")
@@ -128,73 +158,46 @@ def get_container_with_arguments(integration: str, args: argparse.Namespace, *po
     if "dev_flags" in args:
         docker_arguments += args.dev_flags.split(" ")
 
-    mounts = []
     if "host_ca" in args and args.host_ca:
         ca_name = os.path.basename(args.host_ca)
         docker_arguments += ["--host-ca", ca_name]
-        mounts.append(create_mount(os.path.abspath(args.host_ca), "/etc/pynt/{}".format(ca_name)))
 
     if "transport_config" in args and args.transport_config:
         tc_name = os.path.basename(args.transport_config)
         docker_arguments += ["--transport-config", tc_name]
-        mounts.append(create_mount(os.path.abspath(args.transport_config), "/etc/pynt/{}".format(tc_name)))
 
     if "verbose" in args and args.verbose:
         docker_arguments.append("--verbose")
 
-    creds_path = os.path.dirname(CredStore().file_location)
-    mitm_cert_path = os.path.join(creds_path, "cert")
-    os.makedirs(mitm_cert_path, exist_ok=True)
-    mounts.append(create_mount(mitm_cert_path, "/root/.mitmproxy"))
-
-    env = {PYNT_ID: CredStore().get_tokens(), "PYNT_SAAS_URL": PYNT_SAAS}
-    if user_set_all_variables():
-        add_env_variables(env)
-    return PyntBaseContainer(docker_type, docker_arguments, mounts, env)
-
+    return docker_arguments
 
-def _container_image_from_tag(tag: str) -> str:
-    if ":" in tag:
-        return tag.split(":")[0]
-
-    return tag
-
-
-def user_set_all_variables():
-    return all([PYNT_BUCKET_NAME, PYNT_PARAM1, PYNT_PARAM2])
-
-
-def add_env_variables(env: dict):
-    env["PYNT_BUCKET_NAME"] = PYNT_BUCKET_NAME
-    env["PYNT_PARAM1"] = base64.b64encode(PYNT_PARAM1.encode('utf-8'))
-    env["PYNT_PARAM2"] = base64.b64encode(PYNT_PARAM2.encode('utf-8'))
 
+def get_docker_mounts(args: argparse.Namespace) -> list:
+    mounts = []
+    if "host_ca" in args and args.host_ca:
+        ca_name = os.path.basename(args.host_ca)
+        mounts.append(create_mount(os.path.abspath(args.host_ca), "/etc/pynt/{}".format(ca_name)))
 
-def value_from_environment_variable(key, fallback=""):
-    e = os.environ.get(key)
+    if "transport_config" in args and args.transport_config:
+        tc_name = os.path.basename(args.transport_config)
+        mounts.append(create_mount(os.path.abspath(args.transport_config), "/etc/pynt/{}".format(tc_name)))
 
-    if e:
-        ui_thread.print_verbose(f"Using environment variable {key}={e}")
-        return e
-    if fallback != "":
-        ui_thread.print_verbose(f"Using variable {key}={fallback}")
-    return fallback
+    return mounts
 
 
 class PyntContainerNative:
-    def __init__(self, image_name, tag, base_container, is_detach=True):
-        self.image_name = value_from_environment_variable("IMAGE", image_name)
-        self.tag = value_from_environment_variable("TAG", tag)
-        self.is_detach = is_detach
-        self.mounts = base_container.mounts
-        self.env_vars = base_container.environment
-        self.base_container = base_container
+    def __init__(self, container_config: DockerContainerConfig):
+        self.config = container_config
         self.container_name = ""
         self.system = platform.system().lower()
-
         self.stdout = None
         self.running = False
 
+        creds_path = os.path.dirname(CredStore().file_location)
+        mitm_cert_path = os.path.join(creds_path, "cert")
+        os.makedirs(mitm_cert_path, exist_ok=True)
+        self.config.mounts.append(create_mount(mitm_cert_path, "/root/.mitmproxy"))
+
     def is_alive(self):
         command = ["docker", "ps", "--filter", f"name={self.container_name}", "--filter", "status=running"]
         result = subprocess.run(
@@ -211,23 +214,20 @@ class PyntContainerNative:
     def run(self):
         self.running = True
 
-        self.get_image()
-        args = self.base_container.docker_arguments if self.base_container.docker_arguments else None
-        docker_command = ["docker", "run"]
-
-        if self.is_detach:
-            docker_command.append("-d")
+        self.fetch_and_validate_image()
+        args = self.config.docker_arguments if self.config.docker_arguments else None
+        docker_command = ["docker", "run", "-d"]
 
         mounts = []
-        for mount in self.base_container.mounts:
+        for mount in self.config.mounts:
             mounts.extend(["-v", f"{mount['Source']}:{mount['Target']}"])
 
         env_vars = []
-        for key, value in self.base_container.environment.items():
+        for key, value in self.config.env_vars.items():
             env_vars.extend(self.adapt_environment_variable_partial(key, value))
 
         docker_type_options = []
-        for key, value in self.base_container.docker_type.get_arguments().items():
+        for key, value in self.config.docker_type.get_arguments().items():
             if key == "ports":
                 if isinstance(value, dict):
                     for s, d in value.items():
@@ -239,10 +239,11 @@ class PyntContainerNative:
         docker_command += mounts
         docker_command += env_vars
         docker_command += docker_type_options
-        docker_command += [f"{self.image_name}:{self.tag}"]
+        docker_command += [f"{self.config.image.name}"]
         docker_command += args
 
         command = self.adapt_run_command(docker_command)
+        PyntContainerRegistry.instance().register_container(self)
         process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
         stdout, stderr = process.communicate()
 
@@ -268,8 +269,8 @@ class PyntContainerNative:
     def kill_other_instances(self, report_to_user=True):
         ui_thread.print_verbose("Killing other pynt containers if such exist")
         try:
-            for tag in IMAGE_TAGS:
-                command = ["docker", "ps", "-q", "-f", f"ancestor={self.image_name}:{tag}"]
+            for _ in IMAGE_TAGS:
+                command = ["docker", "ps", "-q", "-f", f"ancestor={self.config.image.name}"]
                 containers_output = subprocess.check_output(command, text=True)
                 if not containers_output:
                     continue
@@ -286,41 +287,28 @@ class PyntContainerNative:
             analytics.emit(analytics.ERROR, {"error": "Unable to kill other pynt containers"})
             ui_thread.print(ui_thread.PrinterText("Error: Unable to kill other pynt containers", ui_thread.PrinterText.WARNING))
 
-    def pull_image(self):
-        try:
-            command = ["docker", "pull", f"{self.image_name}:{self.tag}"]
-            subprocess.run(command, capture_output=True, text=True)
-        except subprocess.CalledProcessError:
-            analytics.emit(analytics.ERROR, {"error": "Unable to pull image from ghcr"})
-            ui_thread.print(ui_thread.PrinterText("Error: Docker unable to pull latest Pynt image due to VPN/proxy. If using a mirror for Docker images, visit docs.pynt.io for help.", ui_thread.PrinterText.WARNING))
-            return None
-
-    def get_image(self):
+    def fetch_and_validate_image(self):
         try:
             ui_thread.print(ui_thread.PrinterText("Pulling latest docker image", ui_thread.PrinterText.INFO))
-            command = ['docker', 'pull', f'{self.image_name}:{self.tag}']
-            process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            stdout, stderr = process.communicate()
-
-            if process.returncode != 0:
-                raise ImageUnavailableException(f"Failed to pull image: {stderr.decode().strip()}")
-
-            command = ['docker', 'images', '-q', f'{self.image_name}']
-            process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            stdout, stderr = process.communicate()
-
-            stdout = stdout.decode('utf-8')
-            stderr = stderr.decode('utf-8')
-
-            if stderr:
-                ui_thread.print(ui_thread.PrinterText(f"Error: {stderr}", ui_thread.PrinterText.WARNING))
+            pull_command = ['docker', 'pull', self.config.image.name]
+            get_image_command = ['docker', 'images', '-q', f'{self.config.image.name}']
+            pull_process = subprocess.Popen(pull_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            pull_stdout, pull_stderr = pull_process.communicate()
+            get_process = subprocess.Popen(get_image_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            get_stdout, _ = get_process.communicate()
+            local_image_id = get_stdout.decode('utf-8')
+            if self.config.image.is_self_managed and local_image_id:
+                return local_image_id.strip()
+            elif local_image_id == "":
+                ui_thread.print(ui_thread.PrinterText(f"Error: the image {self.config.image.name} not found",
+                                                      ui_thread.PrinterText.WARNING))
+                raise ImageUnavailableException("Failed to find local image")
+            if pull_stderr and local_image_id == "":
+                ui_thread.print(ui_thread.PrinterText(f"Error: {pull_stderr}", ui_thread.PrinterText.WARNING))
                 raise ImageUnavailableException("Failed to pull image")
 
-            if process.returncode != 0:
+            if pull_process.returncode != 0:
                 raise ImageUnavailableException("Failed to pull image")
-
-            image_id = stdout.strip()
-            return image_id
         except Exception as e:
             raise ImageUnavailableException(f"An error occurred: {str(e)}")
 
@@ -340,169 +328,12 @@ class PyntContainerNative:
             return ["-e", f"{key}={json.dumps(value)}"]
         return ["-e", f"{key}={value}"]
 
-
-class PyntContainerSDK:
-    def __init__(self, image_name, tag, base_container, is_detach=True) -> None:
-        self.image_name = value_from_environment_variable("IMAGE", image_name)
-        self.tag = value_from_environment_variable("TAG", tag)
-        self.base_container = base_container
-        self.is_detach = is_detach
-
-        self.mounts = base_container.mounts
-        self.env_vars = base_container.environment
-
-        self.docker_client: docker.DockerClient = None
-        self.container_name = ""
-        self.stdout = None
-        self.running = False
-        self.system = platform.system().lower()
-
-    def _initialize(self):
-        self.docker_client = docker.from_env()
-        docker_password = value_from_environment_variable("DOCKER_PASSWORD")
-        docker_username = value_from_environment_variable("DOCKER_USERNAME")
-        docker_registry = value_from_environment_variable("DOCKER_REGISTRY")
-        if docker_password and docker_username and docker_registry:
-            self.docker_client.login(username=docker_username, password=docker_password, registry=docker_registry)
-
-    def is_alive(self):
-        if not self.docker_client or not self.container_name:
-            return False
-
-        l = self.docker_client.containers.list(filters={"name": self.container_name})
-        if len(l) != 1:
-            return False
-
-        return l[0].status == "running"
-
-    def prepare_client(self):
-        if not self.docker_client:
-            self._initialize()
-
-    def run(self):
-        if not self.docker_client:
-            self._initialize()
-
-        self.running = True
-
-        image = self.get_image()
-        ui_thread.print(ui_thread.PrinterText("Docker pull done", ui_thread.PrinterText.INFO))
-
-        args = self.base_container.docker_arguments if self.base_container.docker_arguments else None
-
-        run_arguments = {
-            "image": image,
-            "detach": self.is_detach,
-            "mounts": self.base_container.mounts,
-            "environment": self.base_container.environment,
-            "stream": True,
-            "remove": True,
-            "command": args
-        }
-
-        run_arguments.update(self.base_container.docker_type.get_arguments())
-
-        ui_thread.print_verbose("Running pynt docker with arguments:\n {}".format(" ".join(args)))
-        c = self.docker_client.containers.run(**run_arguments)
-        self.container_name = c.name
-        self.stdout = c.logs(stream=True)
-
-    def kill_other_instances(self, report_to_user=True):
-        for c in self.docker_client.containers.list():
-            if len(c.image.tags) and _container_image_from_tag(c.image.tags[0]) == self.image_name:
-                c.kill()
-                self.wait_for_container_end(c)
-                if report_to_user:
-                    ui_thread.print(ui_thread.PrinterText("Another Pynt container was running, killed it", ui_thread.PrinterText))
-
-    def wait_for_container_end(self, container):
-        # only windows kill is require a wait for the container to stop, otherwise the port stays in use
-        if self.system != "windows":
-            return
-        try:
-            container.wait(timeout=10)
-        except ReadTimeout:  # container is still running
-            ui_thread.print(
-                ui_thread.PrinterText("Timeout reached while waiting for container to stop", ui_thread.PrinterText))
-        except APIError:  # container is already stopped
-            pass
-
-    def pull_image(self):
-        try:
-            return self.docker_client.images.pull(self.image_name, tag=self.tag)
-        except APIError as e:
-            analytics.emit(analytics.ERROR, {"error": "Unable to pull image from ghcr: {}".format(e)})
-            ui_thread.print(ui_thread.PrinterText("Error: Docker unable to pull latest Pynt image due to VPN/proxy. Visit docs.pynt.io for help using a mirror for Docker images.", ui_thread.PrinterText.WARNING))
-            return None
-
-    def get_image(self):
-        ui_thread.print(ui_thread.PrinterText("Pulling latest docker image", ui_thread.PrinterText.INFO))
-        try:
-            image = self.pull_image()
-            if not image:
-                ui_thread.print(ui_thread.PrinterText("Trying to get pynt local image", ui_thread.PrinterText.INFO))
-                image = self.docker_client.images.get(f"{self.image_name}:{self.tag}")
-            return image
-        except ImageNotFound:
-            raise ImageUnavailableException()
-
-    def stop(self):
-        if not self.running:
-            return
-        self.kill_other_instances(report_to_user=False)
-        self.docker_client.close()
-        self.docker_client = None
-        self.running = False
-
-
-class PyntContainer:
-    def __init__(self, image_name, tag, detach, base_container: PyntBaseContainer, use_native=False) -> None:
-        self.use_native = use_native
-
-        if use_native:
-            self.client_implementation = PyntContainerNative(image_name=image_name, tag=tag, base_container=base_container, is_detach=detach)
-        else:
-            self.client_implementation = PyntContainerSDK(image_name=image_name, tag=tag, base_container=base_container, is_detach=detach)
-
-        self.image = image_name
-        self.tag = tag
-        self.detach = detach
-        self.container_name = ""
-        self.base_container = base_container
-        self.stdout = None
-
-    def kill_other_instances(self):
-        self.client_implementation.kill_other_instances()
-
-    def stop(self):
-        self.client_implementation.stop()
-
-    def is_alive(self):
-        return self.client_implementation.is_alive()
-
-    def pull_image(self):
-        return self.client_implementation.pull_image()
-
-    def get_image(self):
-        return self.client_implementation.get_image()
-
-    def run(self):
-        self.client_implementation.run()
-        self.stdout = self.client_implementation.stdout
-        PyntContainerRegistry.instance().register_container(self)
-
     def pre_run_validation(self, port):
         self.kill_other_instances()
 
         if container_utils.is_port_in_use(int(port)):
             raise PortInUseException(port)
 
-    def prepare_client(self):
-        self.client_implementation.prepare_client()
-
-    def running(self):
-        return self.client_implementation.running
-
 
 class PyntDockerDesktopContainer:
     def __init__(self, ports) -> None:
@@ -512,7 +343,7 @@ class PyntDockerDesktopContainer:
         return {"ports": self.ports} if self.ports else {}
 
 
-class PyntNativeContainer:
+class PyntNativeHost:
     def __init__(self, network) -> None:
         self.network = network
 
@@ -524,7 +355,7 @@ class PyntContainerRegistry:
     _instance = None
 
     def __init__(self) -> None:
-        self.containers: List[PyntContainer] = []
+        self.containers: List[PyntContainerNative] = []
 
     @staticmethod
     def instance():
@@ -533,7 +364,7 @@ class PyntContainerRegistry:
 
         return PyntContainerRegistry._instance
 
-    def register_container(self, c: PyntContainer):
+    def register_container(self, c: PyntContainerNative):
         self.containers.append(c)
 
     def stop_all_containers(self):

{pyntcli-0.1.99.dist-info → pyntcli-0.1.100.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyntcli
-Version: 0.1.99
+Version: 0.1.100
 Summary: Command line utility to handle all of Pynt's different integrations
 Author-email: Pynt-io <support@pynt.io>
 Project-URL: Homepage, https://pynt.io

{pyntcli-0.1.99.dist-info → pyntcli-0.1.100.dist-info}/RECORD

@@ -1,22 +1,22 @@
 ignoreTests/conftest.py,sha256=gToq5K74GtgeGQXjFvXSzMaE6axBYxAzcFG5XJPOXjI,427
 ignoreTests/auth/login.py,sha256=KFlzWhXBAuwdi7GXf16gCB3ya94LQG2wjcSChE149rQ,3798
 ignoreTests/store/cred_store.py,sha256=_7-917EtNC9eKEumO2_lt-7KuDmCwOZFaowCm7DbA_A,254
-pyntcli/__init__.py,sha256=96CSieH-K5R3B_CG2Gfc3dNu3WA01VqXDKUfJ__2Pdg,402
-pyntcli/main.py,sha256=-INlAS5ks6ofT38Nap0FylRYjCdrLZLuTn5-Pea5UXY,6528
+pyntcli/__init__.py,sha256=-ZeumLDPTHS2r0t8ZT98JHgmzaxmfZaDpjbaLrfkeuw,403
+pyntcli/main.py,sha256=WEbWyqzDjtnZGSWgqru1FCT7wmHdi11uzd1LmwTTCI4,6095
 pyntcli/analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyntcli/analytics/send.py,sha256=9TRAEoPbv4rWOZfcNaGanrRJAFvNs39P-uKSl49GcQE,3679
 pyntcli/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyntcli/auth/login.py,sha256=TljsRXbEkNI1YUrKm5mlTw4YiecYScYUsit8Z8vstss,5228
 pyntcli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyntcli/commands/burp.py,sha256=z6_kYEL6cXNg5yFFR4d8UAgJGTLn3XgUNWsqCBhsJoE,12398
-pyntcli/commands/command.py,sha256=Aw2wb4pV99r9ot6gC2ckqg_1379PZLfudQZ3Igx8Lds,11143
-pyntcli/commands/har.py,sha256=YekPhsbIuuw_lNby97CPDNkEJysFycr_cx-8nPTX6Co,4470
+pyntcli/commands/burp.py,sha256=5lZKSDHJvmVNvxEkQPKQ4lNx8pSzEK-rTHhSvn-ZBtY,12253
+pyntcli/commands/command.py,sha256=7x5eGXGz1rHtAy-Shdh3KLIqQ7TVAZEKd5DiKaCLOSQ,10998
+pyntcli/commands/har.py,sha256=NzxyXlgS5YtQJqi9528V0FkbonMaZ0wHuvRl0LmR5JA,4329
 pyntcli/commands/id_command.py,sha256=UBEgMIpm4vauTCsKyixltiGUolNg_OfHEJvJ_i5BpJY,943
-pyntcli/commands/listen.py,sha256=UERWRArlJQGbM9-bZzG4OlDD7r73UxdwHFWWzxkNObE,9081
-pyntcli/commands/newman.py,sha256=n1eNjeE6dEPjq9Sax9MXcZCJLzn29MidLjV2GeVYmPU,5307
-pyntcli/commands/postman.py,sha256=b_nF-ryleENUrr1RzqmzhJmhWR4IWPw0ehS9y_11m4U,5262
+pyntcli/commands/listen.py,sha256=oxgMvJYpPEu6h8qRFoueGF3a_nmwzaWMPL8ucfy7yxE,8983
+pyntcli/commands/newman.py,sha256=PRbsbDTxL54FRVYOYEpKJ5icVdGXtG2bfiGsnJgmKT4,5173
+pyntcli/commands/postman.py,sha256=HPFNcmAtVziLCAimUg8GUXBMUGBGAXBrSPvP6Tuiubk,4971
 pyntcli/commands/pynt_cmd.py,sha256=T7jee0yw67Zth3lTkSDInCLnbu_IhpNqb7GqnTiTceQ,7012
-pyntcli/commands/root.py,sha256=4yeGlTeL3Xu2xlSbMYhhaDwUnP29sF2Y2sxq8E1P3lo,3986
+pyntcli/commands/root.py,sha256=6dSzKSjUX-ZetE2KYJNkBmfDDrcYJligmHBqIAIc2aQ,4140
 pyntcli/commands/static_file_extensions.py,sha256=PZJb02BI-64tbU-j3rdCNsXzTh7gkIDGxGKbKNw3h5k,1995
 pyntcli/commands/sub_command.py,sha256=GF3-rE_qk2L4jGPFqHLm9SdGINmu3EakhjJTFyWjRms,374
 pyntcli/commands/util.py,sha256=csZHQ2Xbdh-_KX-yIVrnaeNsT0NbuS-ej6kND3CxD_w,4414
@@ -24,7 +24,7 @@ pyntcli/log/__init__.py,sha256=cOGwOYzMoshEbZiiasBGkj6wF0SBu3Jdpl-AuakDesw,19
 pyntcli/log/log.py,sha256=cWCdWmUaAwePwdhYDcgNMEG9d9RM34sGahxBCYEdv2Y,1069
 pyntcli/pynt_docker/__init__.py,sha256=PQIOVxc7XXtMLfEX7ojgwf_Z3mmTllO3ZvzUZTPOxQY,30
 pyntcli/pynt_docker/container_utils.py,sha256=_Onn7loInzyJAG2-Uk6CGpsuRyelmUFHOvtJj4Uzi9A,175
-pyntcli/pynt_docker/pynt_container.py,sha256=Fbm03hofQR7F5_wQaJ2NgEjBE8TvYE7_fv5K_ps4y7M,19499
+pyntcli/pynt_docker/pynt_container.py,sha256=NxizyjSgXSyPbKFs5ggyBSOcLVlb0xk9MS96L2XLrZ4,13126
 pyntcli/store/__init__.py,sha256=1fP8cEAQCF_myja3gnhHH9FEqtBiOJ-2aBmUXSKBdFA,41
 pyntcli/store/json_connector.py,sha256=UGs3uORw3iyn0YJ8kzab-veEZToA6d-ByXYuqEleWsA,560
 pyntcli/store/store.py,sha256=ZLSe0WAjHDp8cSt4BBFDkPGRux4cgOo5UfF7V4naM7U,2559
@@ -39,8 +39,8 @@ pyntcli/ui/report.py,sha256=W-icPSZrGLOubXgam0LpOvHLl_aZg9Zx9qIkL8Ym5PE,1930
 pyntcli/ui/ui_thread.py,sha256=XUBgLpYQjVhrilU-ofw7VSXgTiwneSdTxm61EvC3x4Q,5091
 tests/test_utils.py,sha256=t5fTQUk1U_Js6iMxcGYGqt4C-crzOJ0CqCKtLkRtUi0,2050
 tests/commands/test_pynt_cmd.py,sha256=BjGFCFACcSziLrNA6_27t6TjSmvdu54wx9njwLpRSJY,8379
-pyntcli-0.1.99.dist-info/METADATA,sha256=6jNnyPGykzIJa0hDpAMadLZYm3FznLEz5g8Th7n2wF0,493
-pyntcli-0.1.99.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-pyntcli-0.1.99.dist-info/entry_points.txt,sha256=kcGmqAxXDttNk2EPRcqunc_LTVp61gzakz0v-GEE2SY,43
-pyntcli-0.1.99.dist-info/top_level.txt,sha256=64XSgBzSpgwjYjEKHZE7q3JH2a816zEeyZBXfJi3AKI,42
-pyntcli-0.1.99.dist-info/RECORD,,
+pyntcli-0.1.100.dist-info/METADATA,sha256=ofzCKRvESAbl7zbATZPp-PCqCJT-EP_3xPNRPj_3i0E,494
+pyntcli-0.1.100.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+pyntcli-0.1.100.dist-info/entry_points.txt,sha256=kcGmqAxXDttNk2EPRcqunc_LTVp61gzakz0v-GEE2SY,43
+pyntcli-0.1.100.dist-info/top_level.txt,sha256=64XSgBzSpgwjYjEKHZE7q3JH2a816zEeyZBXfJi3AKI,42
+pyntcli-0.1.100.dist-info/RECORD,,