zrb 0.26.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

zrb/builtin/project/add/fastapp/app/template/_automate/snake_zrb_app_name/container/support/start.py

@@ -17,7 +17,6 @@ from .._input import enable_monitoring_input
 from .._service_config import snake_zrb_app_name_service_configs
 from ..remove import remove_snake_zrb_app_name_container
 from ._group import snake_zrb_app_name_support_container_group
-from ._helper import activate_support_compose_profile, should_start_support_container
 
 start_snake_zrb_app_name_support_container = DockerComposeStartTask(
     icon="🐳",
@@ -31,10 +30,23 @@ start_snake_zrb_app_name_support_container = DockerComposeStartTask(
         https_input,
         image_input,
     ],
-    should_execute=should_start_support_container,
     upstreams=[remove_snake_zrb_app_name_container],
     cwd=RESOURCE_DIR,
-    setup_cmd=activate_support_compose_profile,
+    should_execute=" ".join(
+        [
+            "{{",
+            'env.APP_DB_CONNECTION.startswith("postgresql")',
+            'or env.APP_BROKER_TYPE in ("kafka", "rabbitmq")',
+            "or input.enable_snake_zrb_app_name_monitoring",
+            "}}",
+        ]
+    ),
+    compose_profiles=[
+        '{{"postgres" if env.APP_DB_CONNECTION.startswith("postgresql") else ""}}',
+        '{{"kafka" if env.APP_BROKER_TYPE == "kafka" else ""}}',
+        '{{"rabbitmq" if env.APP_BROKER_TYPE == "rabbitmq" else ""}}',
+        '{{"monitoring" if input.enable_snake_zrb_app_name_monitoring else ""}}',
+    ],
     compose_env_prefix="CONTAINER_ZRB_ENV_PREFIX",
     compose_service_configs=snake_zrb_app_name_service_configs,
     env_files=[compose_env_file],

zrb/config/config.py

@@ -18,12 +18,6 @@ def _get_current_shell() -> str:
     return "bash"
 
 
-def _get_valid_container_backend(container_backend: str) -> str:
-    if container_backend.lower().strip() == "podman":
-        return "podman"
-    return "docker"
-
-
 def _get_default_tmp_dir() -> str:
     if os.path.isdir("/tmp"):
         return "/tmp"
@@ -52,7 +46,4 @@ SHOW_ADVERTISEMENT = untyped_to_boolean(os.getenv("ZRB_SHOW_ADVERTISEMENT", "1")
 SHOW_PROMPT = untyped_to_boolean(os.getenv("ZRB_SHOW_PROMPT", "1"))
 SHOW_TIME = untyped_to_boolean(os.getenv("ZRB_SHOW_TIME", "1"))
 VERSION = _get_version()
-CONTAINER_BACKEND = _get_valid_container_backend(
-    os.getenv("ZRB_CONTAINER_BACKEND", "docker")
-)
 ENABLE_TYPE_CHECKING = untyped_to_boolean(os.getenv("ZRB_ENABLE_TYPE_CHECKING", "1"))

zrb/helper/asyncio_task.py

@@ -1,4 +1,5 @@
 import asyncio
+import sys
 
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
@@ -6,18 +7,30 @@ from zrb.helper.log import logger
 logger.debug(colored("Loading zrb.helper.asyncio_task", attrs=["dark"]))
 
 
+def _surpress_event_loop_error(unraisable):
+    if not (
+        isinstance(unraisable.exc_value, RuntimeError)
+        and str(unraisable.exc_value) == "Event loop is closed"
+    ):
+        # Raise exception for anything except "event loop is closed"
+        sys.__unraisablehook__(unraisable)
+
+
+sys.unraisablehook = _surpress_event_loop_error
+
+
 async def stop_asyncio():
     tasks = [task for task in asyncio.all_tasks() if task is not asyncio.current_task()]
     for task in tasks:
         task.cancel()
-
     # Wait until all tasks are cancelled
     await asyncio.gather(*tasks, return_exceptions=True)
 
 
 def stop_asyncio_sync():
-    loop = asyncio.get_event_loop()
-    if loop.is_running():
-        loop.create_task(stop_asyncio())
-    else:
-        loop.run_until_complete(stop_asyncio())
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            loop.create_task(stop_asyncio())
+    except asyncio.CancelledError:
+        logger.warning("Task is cancelled")

zrb/helper/cli.py

@@ -58,7 +58,6 @@ def create_cli() -> click.Group:
                     attrs=["bold"],
                 )
             )
-            traceback.print_exc()
     # Load zrb_init.py
     project_dir = os.getenv("ZRB_PROJECT_DIR", os.getcwd())
     project_script = os.path.join(project_dir, "zrb_init.py")

zrb/task/base_task/base_task.py

@@ -159,16 +159,15 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
     def copy(self) -> AnyTask:
         return copy.deepcopy(self)
 
-    def to_function(
+    def __get_async_function(
         self,
         env_prefix: str = "",
         raise_error: bool = True,
-        is_async: bool = False,
         show_done_info: bool = True,
         should_clear_xcom: bool = False,
         should_stop_looper: bool = False,
     ) -> Callable[..., Any]:
-        async def function(*args: Any, **kwargs: Any) -> Any:
+        async def async_function(*args: Any, **kwargs: Any) -> Any:
             self.log_info("Copy task")
             self_cp: AnyTask = self.copy()
             result = await self_cp._run_and_check_all(
@@ -184,9 +183,41 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
                 self_cp.clear_xcom()
             return result
 
+        return async_function
+
+    def __to_sync_function(
+        self, async_function: Callable[..., Any]
+    ) -> Callable[..., Any]:
+        def sync_function(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return asyncio.run(async_function(*args, **kwargs))
+            except RuntimeError as e:
+                if "event loop is closed" not in str(e).lower():
+                    raise e
+            except asyncio.CancelledError:
+                self.print_out_dark("Task is cancelled")
+
+        return sync_function
+
+    def to_function(
+        self,
+        env_prefix: str = "",
+        raise_error: bool = True,
+        is_async: bool = False,
+        show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
+    ) -> Callable[..., Any]:
+        async_function = self.__get_async_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
         if is_async:
-            return function
-        return lambda *args, **kwargs: asyncio.run(function(*args, **kwargs))
+            return async_function
+        return self.__to_sync_function(async_function)
 
     async def run(self, *args: Any, **kwargs: Any) -> Any:
         if self._run_function is not None:
@@ -287,9 +318,6 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             result = results[-1]
             self._print_result(result)
             return result
-        except RuntimeError as e:
-            if "event loop is closed" not in str(e).lower():
-                raise e
         except Exception as e:
             self.log_error(f"{e}")
             if raise_error:
@@ -384,7 +412,9 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         is_failed: bool = False
         while self._should_attempt():
             try:
-                self.log_debug(f"Started with args: {args} and kwargs: {local_kwargs}")
+                self.log_debug(
+                    f"Started with args: {args} and kwargs: {local_kwargs}"
+                )  # noqa
                 await self.on_started()
                 self.__running_tasks.append(self)
                 result = await run_async(self.run, *args, **local_kwargs)

zrb/task/cmd_task.py

@@ -291,8 +291,6 @@ class CmdTask(BaseTask):
         for pid in self._pids:
             self.__kill_by_pid(pid)
         stop_asyncio_sync()
-        _print_out_dark(f"Exiting with signal {signum}")
-        sys.exit(signum)
 
     def __on_exit(self):
         self._global_state.no_more_attempt = True
@@ -351,14 +349,15 @@ class CmdTask(BaseTask):
             )
         )
         # wait process
-        await process.wait()
-        # wait reader and logger
-        await stdout_process
-        await stderr_process
-        await stdout_queue.put(None)
-        await stderr_queue.put(None)
-        await stdout_log_process
-        await stderr_log_process
+        await asyncio.gather(
+            process.wait(),
+            stdout_process,
+            stderr_process,
+        )
+        # stop messages in queue
+        await asyncio.gather(stdout_queue.put(None), stderr_queue.put(None))
+        # end logging
+        await asyncio.gather(stdout_log_process, stderr_log_process)
 
     def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
         return self._create_cmd_script(self._cmd_path, self._cmd, *args, **kwargs)

zrb/task/docker_compose_start_task.py

@@ -45,6 +45,7 @@ class DockerComposeStartTask(DockerComposeTask):
         compose_options: Mapping[JinjaTemplate, JinjaTemplate] = {},
         compose_flags: Iterable[JinjaTemplate] = [],
         compose_args: Iterable[JinjaTemplate] = [],
+        compose_profiles: Iterable[JinjaTemplate] = [],
         compose_env_prefix: str = "",
         setup_cmd: CmdVal = "",
         setup_cmd_path: CmdVal = "",
@@ -85,9 +86,11 @@ class DockerComposeStartTask(DockerComposeTask):
             executable=executable,
             compose_service_configs=compose_service_configs,
             compose_file=compose_file,
+            compose_cmd="up",
             compose_options=compose_options,
             compose_flags=compose_flags,
             compose_args=compose_args,
+            compose_profiles=compose_profiles,
             compose_env_prefix=compose_env_prefix,
             setup_cmd=setup_cmd,
             setup_cmd_path=setup_cmd_path,
@@ -116,31 +119,31 @@ class DockerComposeStartTask(DockerComposeTask):
             should_show_working_directory=should_show_working_directory,
         )
 
-    def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
-        # setup
-        setup_cmd = self._create_cmd_script(
-            self._setup_cmd_path, self._setup_cmd, *args, **kwargs
+    def _get_execute_docker_compose_script(
+        self,
+        compose_cmd: JinjaTemplate,
+        compose_options: Mapping[JinjaTemplate, JinjaTemplate],
+        compose_flags: Iterable[JinjaTemplate],
+        compose_args: Iterable[JinjaTemplate],
+        *args: Any
+    ) -> JinjaTemplate:
+        return "\n".join(
+            [
+                # compose start
+                super()._get_execute_docker_compose_script(
+                    compose_cmd=compose_cmd,
+                    compose_options=compose_options,
+                    compose_flags=list(compose_flags) + ["-d"],
+                    compose_args=compose_args,
+                    *args,
+                ),
+                # compose log
+                super()._get_execute_docker_compose_script(
+                    compose_cmd="logs",
+                    compose_options={},
+                    compose_flags=["-f"],
+                    compose_args=[],
+                    *args,
+                ),
+            ]
         )
-        cmd_list = [setup_cmd] if setup_cmd.strip() != "" else []
-        # compose command
-        cmd_list = cmd_list + [
-            # compose start
-            self._get_docker_compose_cmd_script(
-                compose_cmd="up",
-                compose_options=self._compose_options,
-                compose_flags=list(self._compose_flags) + ["-d"],
-                compose_args=self._compose_args,
-                *args,
-            ),
-            # compose log
-            self._get_docker_compose_cmd_script(
-                compose_cmd="logs",
-                compose_options={},
-                compose_flags=["-f"],
-                compose_args=[],
-                *args,
-            ),
-        ]
-        cmd_str = "\n".join(cmd_list)
-        self.log_info(f"Command: {cmd_str}")
-        return cmd_str

zrb/task/docker_compose_task.py

@@ -3,7 +3,6 @@ import pathlib
 from collections.abc import Callable, Iterable, Mapping
 from typing import Any, Optional, TypeVar, Union
 
-from zrb.config.config import CONTAINER_BACKEND
 from zrb.helper.accessories.color import colored
 from zrb.helper.accessories.name import get_random_name
 from zrb.helper.docker_compose.fetch_external_env import fetch_compose_file_env_map
@@ -33,32 +32,22 @@ from zrb.task_input.any_input import AnyInput
 
 logger.debug(colored("Loading zrb.task.docker_compose_task", attrs=["dark"]))
 
+TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
 
-def _get_ensure_zrb_network_task(backend: str):
-    CURRENT_DIR = os.path.dirname(__file__)
-    SHELL_SCRIPT_DIR = os.path.join(CURRENT_DIR, "..", "shell-scripts")
-    ensure_container_backend = CmdTask(
-        name="ensure-compose-backend",
-        cmd_path=[
-            os.path.join(SHELL_SCRIPT_DIR, "_common-util.sh"),
-            os.path.join(SHELL_SCRIPT_DIR, f"ensure-{backend}-is-installed.sh"),
-        ],
-        preexec_fn=None,
-        should_print_cmd_result=False,
-    )
-    return CmdTask(
-        name="ensure-zrb-network",
-        cmd=[
-            f"{backend} network inspect zrb >/dev/null 2>&1 || \\",
-            f"{backend} network create -d bridge zrb",
-        ],
-        upstreams=[ensure_container_backend],
-        should_print_cmd_result=False,
-    )
-
+CURRENT_DIR = os.path.dirname(__file__)
+SHELL_SCRIPT_DIR = os.path.join(CURRENT_DIR, "..", "shell-scripts")
 
-TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
-ensure_zrb_network_task = _get_ensure_zrb_network_task(CONTAINER_BACKEND)
+ensure_container_backend = CmdTask(
+    name="ensure-compose-backend",
+    cmd_path=[
+        os.path.join(SHELL_SCRIPT_DIR, "_common-util.sh"),
+        os.path.join(SHELL_SCRIPT_DIR, "ensure-docker-is-installed.sh"),
+    ],
+    preexec_fn=None,
+    should_print_cmd_result=False,
+    should_show_cmd=False,
+    should_show_working_directory=False,
+)
 
 
 @typechecked
@@ -93,6 +82,7 @@ class DockerComposeTask(CmdTask):
         compose_options: Mapping[JinjaTemplate, JinjaTemplate] = {},
         compose_flags: Iterable[JinjaTemplate] = [],
         compose_args: Iterable[JinjaTemplate] = [],
+        compose_profiles: CmdVal = "",
         compose_env_prefix: str = "",
         setup_cmd: CmdVal = "",
         setup_cmd_path: CmdVal = "",
@@ -120,21 +110,20 @@ class DockerComposeTask(CmdTask):
         should_show_cmd: bool = True,
         should_show_working_directory: bool = True,
     ):
-        combined_env_files = list(env_files)
         CmdTask.__init__(
             self,
             name=name,
             group=group,
             inputs=inputs,
             envs=envs,
-            env_files=combined_env_files,
+            env_files=env_files,
             icon=icon,
             color=color,
             description=description,
             executable=executable,
             cwd=cwd,
             should_render_cwd=should_render_cwd,
-            upstreams=[ensure_zrb_network_task] + upstreams,
+            upstreams=[ensure_container_backend] + upstreams,
             fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
@@ -168,6 +157,7 @@ class DockerComposeTask(CmdTask):
         self._compose_flags = compose_flags
         self._compose_args = compose_args
         self._compose_env_prefix = compose_env_prefix
+        self._compose_profiles = compose_profiles
         self._compose_template_file = self.__get_compose_template_file(compose_file)
         self._compose_runtime_file = self.__get_compose_runtime_file(
             self._compose_template_file
@@ -333,14 +323,24 @@ class DockerComposeTask(CmdTask):
         raise Exception(f"Invalid compose file: {compose_file}")
 
     def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
+        cmd_list = []
+        # create network
+        create_network_script = self._get_create_compose_network_script()
+        if create_network_script.strip() != "":
+            cmd_list.append(create_network_script)
+        # set compose profiles
+        compose_profile_script = self._get_compose_profile_script(*args, **kwargs)
+        if compose_profile_script.strip() != "":
+            cmd_list.append(compose_profile_script)
         # setup
-        setup_cmd = self._create_cmd_script(
+        setup_script = self._create_cmd_script(
             self._setup_cmd_path, self._setup_cmd, *args, **kwargs
         )
-        cmd_list = [setup_cmd] if setup_cmd.strip() != "" else []
+        if setup_script.strip() != "":
+            cmd_list.append(setup_script)
         # compose command
         cmd_list.append(
-            self._get_docker_compose_cmd_script(
+            self._get_execute_docker_compose_script(
                 compose_cmd=self._compose_cmd,
                 compose_options=self._compose_options,
                 compose_flags=self._compose_flags,
@@ -352,7 +352,38 @@ class DockerComposeTask(CmdTask):
         self.log_info(f"Command: {cmd_str}")
         return cmd_str
 
-    def _get_docker_compose_cmd_script(
+    def _get_compose_profile_script(self, *args, **kwargs) -> str:
+        # Get list representation of self._compose_profiles
+        compose_profiles = self._compose_profiles
+        if callable(compose_profiles):
+            compose_profiles = self._compose_profiles(*args, **kwargs)
+        if isinstance(compose_profiles, str):
+            compose_profiles = compose_profiles.split(",")
+        # Get only non empty profiles
+        filtered_compose_profiles = [
+            self.render_str(profile)
+            for profile in compose_profiles
+            if self.render_str(profile).strip() != ""
+        ]
+        if len(filtered_compose_profiles) == 0:
+            return ""
+        compose_profiles_str = ",".join(filtered_compose_profiles)
+        return f"export COMPOSE_PROFILES={compose_profiles_str}"
+
+    def _get_create_compose_network_script(self) -> str:
+        compose_data = read_compose_file(self._compose_runtime_file)
+        networks: Mapping[str, Mapping[str, Any]] = compose_data.get("networks", {})
+        scripts = []
+        for key, config in networks.items():
+            if not config.get("external", False):
+                continue
+            network_name = config.get("name", key)
+            scripts.append(
+                f"docker network inspect {network_name} > /dev/null 2>&1 || docker network create -d bridge{network_name}"  # noqa
+            )
+        return "\n".join(scripts)
+
+    def _get_execute_docker_compose_script(
         self,
         compose_cmd: str,
         compose_options: Mapping[JinjaTemplate, JinjaTemplate],
@@ -383,4 +414,4 @@ class DockerComposeTask(CmdTask):
                 if self.render_str(arg) != ""
             ]
         )
-        return f"{CONTAINER_BACKEND} compose {options} {compose_cmd} {flags} {args}"
+        return f"docker compose {options} {compose_cmd} {flags} {args}"

zrb/task/flow_task.py

@@ -85,7 +85,6 @@ class FlowTask(BaseTask):
             retry_interval=retry_interval,
             should_execute=should_execute,
             return_upstream_result=return_upstream_result,
-            run=lambda *args, **kwargs: kwargs.get("_task").print_out("🆗"),
         )
 
     def copy(self) -> TFlowTask:

zrb/task/looper.py

@@ -1,4 +1,4 @@
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from typing import Optional
 
 from zrb.helper.accessories.color import colored

zrb/task/remote_cmd_task.py

@@ -6,6 +6,7 @@ from typing import Any, Optional, Union
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import JinjaTemplate
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnFailed,
@@ -16,9 +17,8 @@ from zrb.task.any_task_event_handler import (
     OnTriggered,
     OnWaiting,
 )
-from zrb.task.base_remote_cmd_task import BaseRemoteCmdTask, RemoteConfig
 from zrb.task.cmd_task import CmdTask, CmdVal
-from zrb.task_env.env import Env
+from zrb.task_env.env import Env, PrivateEnv
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
@@ -27,8 +27,6 @@ logger.debug(colored("Loading zrb.task.remote_cmd_task", attrs=["dark"]))
 
 _CURRENT_DIR = os.path.dirname(__file__)
 _SHELL_SCRIPT_DIR = os.path.join(_CURRENT_DIR, "..", "shell-scripts")
-with open(os.path.join(_SHELL_SCRIPT_DIR, "ssh-util.sh")) as file:
-    _SSH_UTIL_SCRIPT = file.read()
 
 ensure_ssh_is_installed = CmdTask(
     name="ensure-ssh-is-installed",
@@ -37,15 +35,17 @@ ensure_ssh_is_installed = CmdTask(
         os.path.join(_SHELL_SCRIPT_DIR, "ensure-ssh-is-installed.sh"),
     ],
     preexec_fn=None,
+    should_print_cmd_result=False,
+    should_show_cmd=False,
+    should_show_working_directory=False,
 )
 
 
 @typechecked
-class RemoteCmdTask(BaseRemoteCmdTask):
+class RemoteCmdTask(CmdTask):
     def __init__(
         self,
         name: str,
-        remote_configs: Iterable[RemoteConfig],
         group: Optional[Group] = None,
         inputs: Iterable[AnyInput] = [],
         envs: Iterable[Env] = [],
@@ -54,9 +54,15 @@ class RemoteCmdTask(BaseRemoteCmdTask):
         color: Optional[str] = None,
         description: str = "",
         executable: Optional[str] = None,
+        remote_host: JinjaTemplate = "localhost",
+        remote_port: Union[JinjaTemplate, int] = 22,
+        remote_user: JinjaTemplate = "root",
+        remote_password: JinjaTemplate = "",
+        remote_ssh_key: JinjaTemplate = "",
         cmd: CmdVal = "",
         cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
+        should_render_cwd: bool = True,
         upstreams: Iterable[AnyTask] = [],
         fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
@@ -74,31 +80,26 @@ class RemoteCmdTask(BaseRemoteCmdTask):
         max_error_line: int = 1000,
         preexec_fn: Optional[Callable[[], Any]] = os.setsid,
         should_execute: Union[bool, str, Callable[..., bool]] = True,
+        return_upstream_result: bool = False,
+        should_print_cmd_result: bool = True,
+        should_show_cmd: bool = True,
+        should_show_working_directory: bool = True,
     ):
-        pre_cmd = "\n".join(
-            [
-                _SSH_UTIL_SCRIPT,
-                "_SCRIPT=\"$(cat <<'ENDSCRIPT'",
-            ]
-        )
-        post_cmd = "\n".join(["ENDSCRIPT", ')"', 'auth_ssh "$_SCRIPT"'])
-        BaseRemoteCmdTask.__init__(
+        CmdTask.__init__(
             self,
             name=name,
-            remote_configs=remote_configs,
             group=group,
             inputs=inputs,
-            envs=envs,
+            envs=envs + [PrivateEnv(name="_ZRB_SSH_PASSWORD", default=remote_password)],
             env_files=env_files,
             icon=icon,
             color=color,
             description=description,
             executable=executable,
-            pre_cmd=pre_cmd,
             cmd=cmd,
             cmd_path=cmd_path,
-            post_cmd=post_cmd,
             cwd=cwd,
+            should_render_cwd=should_render_cwd,
             upstreams=[ensure_ssh_is_installed] + upstreams,
             fallbacks=fallbacks,
             on_triggered=on_triggered,
@@ -116,4 +117,40 @@ class RemoteCmdTask(BaseRemoteCmdTask):
             max_error_line=max_error_line,
             preexec_fn=preexec_fn,
             should_execute=should_execute,
+            return_upstream_result=return_upstream_result,
+            should_print_cmd_result=should_print_cmd_result,
+            should_show_cmd=should_show_cmd,
+            should_show_working_directory=should_show_working_directory,
+        )
+        self._remote_host = remote_host
+        self._remote_port = remote_port
+        self._remote_user = remote_user
+        self._remote_password = remote_password
+        self._remote_ssh_key = remote_ssh_key
+
+    def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
+        cmd_script = self._create_cmd_script(self._cmd_path, self._cmd, *args, **kwargs)
+        cmd_script = "\n".join(
+            [
+                "_SCRIPT=$(cat << 'ENDSCRIPT'",
+                cmd_script,
+                "ENDSCRIPT",
+                ")",
+            ]
         )
+        ssh_command = self._get_ssh_command()
+        return "\n".join([cmd_script, ssh_command])
+
+    def _get_ssh_command(self) -> str:
+        host = self.render_str(self._remote_host)
+        port = self.render_str(self._remote_port)
+        user = self.render_str(self._remote_user)
+        password = self.render_str(self._remote_password)
+        key = self.render_str(self._remote_ssh_key)
+        if key != "" and password != "":
+            return f'sshpass -p "$_ZRB_SSH_PASSWORD" ssh -t -p "{port}" -i "{key}" "{user}@{host}" "$_SCRIPT"'  # noqa
+        if key != "":
+            return f'ssh -t -p "{port}" -i "{key}" "{user}@{host}" "$_SCRIPT"'
+        if password != "":
+            return f'sshpass -p "$_ZRB_SSH_PASSWORD" ssh -t -p "{port}" "{user}@{host}" "$_SCRIPT"'  # noqa
+        return f'ssh -t -p "{port}" "{user}@{host}" "$_SCRIPT"'