zrb 0.9.3__py3-none-any.whl → 0.11.0__py3-none-any.whl

zrb/shell-scripts/ensure-podman-is-installed.sh

@@ -0,0 +1,55 @@
+set -e
+if command_exists podman
+then
+    log_info "Podman is already installed."
+else
+    log_info "Installing Podman..."
+    if [ "$OS_TYPE" = "Darwin" ]
+    then
+        if command_exists brew
+        then
+            brew install --cask podman
+            log_info "Please start Podman before proceeding."
+        else
+            log_info "Homebrew not found. Please install Homebrew and try again."
+            exit 1
+        fi
+    elif [ "$OS_TYPE" = "Linux" ]
+    then
+        if command_exists apt
+        then
+            try_sudo apt update
+            try_sudo apt install -y podman
+        elif command_exists yum
+        then
+            try_sudo yum install -y podman
+        elif command_exists dnf
+        then
+            try_sudo dnf install -y podman
+        elif command_exists pacman
+        then
+            try_sudo pacman -Syu --noconfirm podman
+        else
+            log_info "No known package manager found. Please install Podman manually."
+            exit 1
+        fi
+    else
+        log_info "Unsupported OS type. Please install Podman manually."
+        exit 1
+    fi
+fi
+
+if ! command_exists podman-compose
+then
+    log_info "Installing Podman Compose plugin..."
+    pip install podman-compose
+fi
+
+# Check Podman Compose plugin installation
+if command_exists podman && command_exists podman-compose
+then
+    log_info "Podman Compose plugin is already installed."
+else
+    log_info "Podman Compose plugin is not installed or podman is not running. Please check your installation."
+    exit 1
+fi

zrb/task/any_task.py

@@ -384,6 +384,44 @@ class AnyTask(ABC):
         """
         pass
 
+    @abstractmethod
+    def insert_fallback(self, *fallbacks: TAnyTask):
+        """
+        Inserts one or more `AnyTask` instances at the beginning of the current task's fallback list.
+
+        This method is used to define dependencies for the current task. Tasks in the fallback list are executed when the task is failed.
+        Adding a task to the beginning of the list means it will be
+        executed earlier than those already in the list.
+
+        Args:
+            fallbacks (TAnyTask): One or more task instances to be added to the fallback list.
+
+        Examples:
+            >>> from zrb import Task
+            >>> task = Task(name='task')
+            >>> fallback_task = Task(name='fallback-task')
+            >>> task.insert_fallback(fallback_task)
+        """
+        pass
+
+    @abstractmethod
+    def add_fallback(self, *fallbacks: TAnyTask):
+        """
+        Adds one or more `AnyTask` instances to the end of the current task's fallback list.
+
+        This method appends tasks to the fallback list, indicating that these tasks should be executed when the task is failed.
+
+        Args:
+            fallbacks (TAnyTask): One or more task instances to be added to the fallback list.
+
+        Examples:
+            >>> from zrb import Task
+            >>> task = Task(name='task')
+            >>> fallback_task = Task(name='fallback-task')
+            >>> task.add_fallback(fallback_task)
+        """
+        pass
+
     @abstractmethod
     def add_upstream(self, *upstreams: TAnyTask):
         """
@@ -519,6 +557,20 @@ class AnyTask(ABC):
         """
         pass
 
+    @abstractmethod
+    def _lock_upstreams(self):
+        """
+        Lock upstreams so that it cannot be altered anymore
+        """
+        pass
+
+    @abstractmethod
+    def _lock_fallbacks(self):
+        """
+        Lock fallbacks so that it cannot be altered anymore
+        """
+        pass
+
     @abstractmethod
     def _set_execution_id(self, execution_id: str):
         """
@@ -885,6 +937,37 @@ class AnyTask(ABC):
         """
         pass
 
+    @abstractmethod
+    def inject_fallbacks(self):
+        """
+        Injects fallback tasks into the current task.
+
+        This method is used for programmatically adding fallback to the task.
+        fallback tasks are those that must be completed when the task is failed.
+        Override this method in subclasses to specify such dependencies.
+
+        Examples:
+            >>> from zrb import Task
+            >>> class MyTask(Task):
+            >>>     def inject_fallbacks(self):
+            >>>         self.add_fallback(another_task)
+        """
+        pass
+
+    @abstractmethod
+    def _get_fallbacks(self) -> Iterable[TAnyTask]:
+        """
+        Retrieves the fallback tasks of the current task.
+
+        An internal method to get the list of fallback tasks that have been set for the
+        task, either statically or through `inject_fallbacks`. This is essential for task
+        fallback scenario.
+
+        Returns:
+            Iterable[TAnyTask]: An iterable of fallback tasks.
+        """
+        pass
+
     @abstractmethod
     def _get_combined_inputs(self) -> Iterable[AnyInput]:
         """

zrb/task/base_remote_cmd_task.py

@@ -78,6 +78,7 @@ class SingleBaseRemoteCmdTask(CmdTask):
         post_cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -110,6 +111,7 @@ class SingleBaseRemoteCmdTask(CmdTask):
             cmd_path=cmd_path,
             cwd=cwd,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/base_task/base_task.py

@@ -39,6 +39,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
     """
 
     __xcom: Mapping[str, Mapping[str, str]] = {}
+    __running_tasks: List[AnyTask] = []
 
     def __init__(
         self,
@@ -53,6 +54,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         checkers: Iterable[AnyTask] = [],
         checking_interval: Union[float, int] = 0,
         run: Optional[Callable[..., Any]] = None,
@@ -87,6 +89,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             retry=retry,
             retry_interval=retry_interval,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             checkers=checkers,
             checking_interval=checking_interval,
             run=run,
@@ -257,7 +260,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         except Exception as e:
             self.log_error(f"{e}")
             if raise_error:
-                raise
+                raise e
         finally:
             if show_done_info:
                 self._show_env_prefix()
@@ -303,7 +306,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         self.log_debug("Waiting execution to be started")
         while not self.__is_execution_started:
             # Don't start checking before the execution itself has been started
-            await asyncio.sleep(0.1)
+            await asyncio.sleep(0.05)
         check_coroutines: Iterable[asyncio.Task] = []
         for checker_task in self._get_checkers():
             checker_task._set_execution_id(self.get_execution_id())
@@ -334,15 +337,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         await self.on_triggered()
         self.__is_execution_triggered = True
         await self.on_waiting()
-        # get upstream checker
-        upstream_check_processes: Iterable[asyncio.Task] = []
-        self._lock_upstreams()
-        for upstream_task in self._get_upstreams():
-            upstream_check_processes.append(
-                asyncio.create_task(upstream_task._loop_check())
-            )
-        # wait all upstream checkers to complete
-        await asyncio.gather(*upstream_check_processes)
+        await self.__check_upstreams()
         # mark execution as started, so that checkers can start checking
         self.__is_execution_started = True
         local_kwargs = dict(kwargs)
@@ -353,27 +348,70 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             return None
         # start running task
         result: Any = None
+        is_failed: bool = False
         while self._should_attempt():
             try:
                 self.log_debug(f"Started with args: {args} and kwargs: {local_kwargs}")
                 await self.on_started()
+                self.__running_tasks.append(self)
                 result = await run_async(self.run, *args, **local_kwargs)
+                self.__running_tasks.remove(self)
                 break
             except Exception as e:
-                is_last_attempt = self._is_last_attempt()
-                await self.on_failed(is_last_attempt, e)
-                if is_last_attempt:
-                    raise e
                 attempt = self._get_attempt()
                 self.log_error(f"Encounter error on attempt {attempt}")
+                if self._is_last_attempt():
+                    is_failed = True
+                    raise e
+                self.__running_tasks.remove(self)
+                await self.on_failed(is_last_attempt=False, exception=e)
                 self._increase_attempt()
                 await asyncio.sleep(self._retry_interval)
                 await self.on_retry()
+            finally:
+                if is_failed:
+                    running_tasks = self.__running_tasks
+                    self.__running_tasks = []
+                    await self.__trigger_failure(running_tasks)
+                    await self.__trigger_fallbacks(running_tasks, kwargs)
         self.set_xcom(self.get_name(), f"{result}")
         self.log_debug(f"XCom: {self.__xcom}")
         await self._mark_done()
         return result
 
+    async def __check_upstreams(self):
+        coroutines: Iterable[asyncio.Task] = []
+        self._lock_upstreams()
+        for upstream_task in self._get_upstreams():
+            coroutines.append(asyncio.create_task(upstream_task._loop_check()))
+        # wait all upstream checkers to complete
+        await asyncio.gather(*coroutines)
+
+    async def __trigger_failure(self, tasks: List[AnyTask]):
+        coroutines = [
+            task.on_failed(is_last_attempt=True, exception=Exception("canceled"))
+            for task in tasks
+        ]
+        await asyncio.gather(*coroutines)
+
+    async def __trigger_fallbacks(
+        self, tasks: List[AnyTask], kwargs: Mapping[str, Any]
+    ):
+        coroutines: Iterable[asyncio.Task] = []
+        for fallback in self.__get_all_fallbacks(tasks):
+            fallback._set_execution_id(self.get_execution_id())
+            coroutines.append(asyncio.create_task(fallback._run_all(**kwargs)))
+        await asyncio.gather(*coroutines)
+
+    def __get_all_fallbacks(self, tasks: List[AnyTask]) -> List[AnyTask]:
+        all_fallbacks: List[AnyTask] = []
+        for task in tasks:
+            task._lock_fallbacks()
+            for fallback in task._get_fallbacks():
+                if fallback not in all_fallbacks:
+                    all_fallbacks.append(fallback)
+        return all_fallbacks
+
     async def _check_should_execute(self, *args: Any, **kwargs: Any) -> bool:
         if callable(self._should_execute):
             return await run_async(self._should_execute, *args, **kwargs)

zrb/task/base_task/component/base_task_model.py

@@ -56,6 +56,7 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         retry: int = 2,
         retry_interval: Union[int, float] = 1,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         checkers: Iterable[AnyTask] = [],
         checking_interval: Union[int, float] = 0,
         run: Optional[Callable[..., Any]] = None,
@@ -85,6 +86,7 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
             retry=retry,
             retry_interval=retry_interval,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             checkers=checkers,
             checking_interval=checking_interval,
             run=run,

zrb/task/base_task/component/common_task_model.py

@@ -47,6 +47,7 @@ class CommonTaskModel:
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         checkers: Iterable[AnyTask] = [],
         checking_interval: Union[float, int] = 0,
         run: Optional[Callable[..., Any]] = None,
@@ -73,6 +74,7 @@ class CommonTaskModel:
         self._retry = retry
         self._retry_interval = retry_interval
         self._upstreams = upstreams
+        self._fallbacks = fallbacks
         self._checkers = [checker.copy() for checker in checkers]
         self._checking_interval = checking_interval
         self._run_function: Optional[Callable[..., Any]] = run
@@ -90,16 +92,21 @@ class CommonTaskModel:
         self.__allow_add_env_files = True
         self.__allow_add_inputs = True
         self.__allow_add_upstreams: bool = True
+        self.__allow_add_fallbacks: bool = True
         self.__allow_add_checkers: bool = True
         self.__has_already_inject_env_files: bool = False
         self.__has_already_inject_envs: bool = False
         self.__has_already_inject_inputs: bool = False
         self.__has_already_inject_upstreams: bool = False
+        self.__has_already_inject_fallbacks: bool = False
         self.__all_inputs: Optional[List[AnyInput]] = None
 
     def _lock_upstreams(self):
         self.__allow_add_upstreams = False
 
+    def _lock_fallbacks(self):
+        self.__allow_add_fallbacks = False
+
     def _set_execution_id(self, execution_id: str):
         if self.__execution_id == "":
             self.__execution_id = execution_id
@@ -276,6 +283,25 @@ class CommonTaskModel:
             self.__has_already_inject_upstreams = True
         return list(self._upstreams)
 
+    def insert_fallback(self, *fallbacks: AnyTask):
+        if not self.__allow_add_fallbacks:
+            raise Exception(f"Cannot insert fallbacks to `{self.get_name()}`")
+        self._fallbacks = list(fallbacks) + list(self._fallbacks)
+
+    def add_fallback(self, *fallbacks: AnyTask):
+        if not self.__allow_add_fallbacks:
+            raise Exception(f"Cannot add fallbacks to `{self.get_name()}`")
+        self._fallbacks = list(self._fallbacks) + list(fallbacks)
+
+    def inject_fallbacks(self):
+        pass
+
+    def _get_fallbacks(self) -> List[AnyTask]:
+        if not self.__has_already_inject_fallbacks:
+            self.inject_fallbacks()
+            self.__has_already_inject_fallbacks = True
+        return list(self._fallbacks)
+
     def get_icon(self) -> str:
         return self._icon
 

zrb/task/checker.py

@@ -32,6 +32,7 @@ class Checker(BaseTask):
         color: Optional[str] = None,
         description: str = "",
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -55,6 +56,7 @@ class Checker(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/cmd_task.py

@@ -113,6 +113,7 @@ class CmdTask(BaseTask):
         cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -141,6 +142,7 @@ class CmdTask(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/docker_compose_task.py

@@ -1,6 +1,7 @@
 import os
 import pathlib
 
+from zrb.config.config import container_backend
 from zrb.helper.accessories.name import get_random_name
 from zrb.helper.docker_compose.fetch_external_env import fetch_compose_file_env_map
 from zrb.helper.docker_compose.file import read_compose_file, write_compose_file
@@ -36,27 +37,30 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
-CURRENT_DIR = os.path.dirname(__file__)
-SHELL_SCRIPT_DIR = os.path.join(CURRENT_DIR, "..", "shell-scripts")
-TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
 
-ensure_docker_is_installed = CmdTask(
-    name="ensure-docker-is-installed",
-    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,
-)
+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,
+    )
+    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],
+    )
 
-ensure_zrb_network_exists = CmdTask(
-    name="ensure-zrb-network-exists",
-    cmd=[
-        "docker network inspect zrb >/dev/null 2>&1 || \\",
-        "docker network create -d bridge zrb",
-    ],
-    upstreams=[ensure_docker_is_installed],
-)
+
+TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
+ensure_zrb_network_task = _get_ensure_zrb_network_task(container_backend)
 
 
 @typechecked
@@ -96,6 +100,7 @@ class DockerComposeTask(CmdTask):
         setup_cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -126,7 +131,8 @@ class DockerComposeTask(CmdTask):
             description=description,
             executable=executable,
             cwd=cwd,
-            upstreams=[ensure_zrb_network_exists] + upstreams,
+            upstreams=[ensure_zrb_network_task] + upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,
@@ -350,7 +356,7 @@ class DockerComposeTask(CmdTask):
         cmd_str = "\n".join(
             [
                 setup_cmd_str,
-                f"docker compose {options} {self._compose_cmd} {flags} {args}",
+                f"{container_backend} compose {options} {self._compose_cmd} {flags} {args}",  # noqa
             ]
         )
         self.log_info(f"Command: {cmd_str}")

zrb/task/flow_task.py

@@ -32,6 +32,7 @@ class FlowTask(BaseTask):
         color: Optional[str] = None,
         description: str = "",
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -72,6 +73,7 @@ class FlowTask(BaseTask):
             color=color,
             description=description,
             upstreams=final_upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/http_checker.py

@@ -75,6 +75,7 @@ class HTTPChecker(Checker):
         url: str = "/",
         is_https: Union[bool, str] = False,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -98,6 +99,7 @@ class HTTPChecker(Checker):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/notifier.py

@@ -46,6 +46,7 @@ class Notifier(BaseTask):
         show_toast: bool = True,
         show_stdout: bool = True,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -69,6 +70,7 @@ class Notifier(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/path_checker.py

@@ -42,6 +42,7 @@ class PathChecker(Checker):
         color: Optional[str] = None,
         description: str = "",
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -67,6 +68,7 @@ class PathChecker(Checker):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/path_watcher.py

@@ -56,6 +56,7 @@ class PathWatcher(Checker):
         color: Optional[str] = None,
         description: str = "",
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -83,6 +84,7 @@ class PathWatcher(Checker):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/port_checker.py

@@ -54,6 +54,7 @@ class PortChecker(Checker):
         port: Union[int, JinjaTemplate] = 80,
         timeout: Union[int, JinjaTemplate] = 5,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -77,6 +78,7 @@ class PortChecker(Checker):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/recurring_task.py

@@ -63,6 +63,7 @@ class RecurringTask(BaseTask):
         color: Optional[str] = None,
         description: str = "",
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -92,6 +93,7 @@ class RecurringTask(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/remote_cmd_task.py

@@ -53,6 +53,7 @@ class RemoteCmdTask(BaseRemoteCmdTask):
         cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -94,6 +95,7 @@ class RemoteCmdTask(BaseRemoteCmdTask):
             post_cmd=post_cmd,
             cwd=cwd,
             upstreams=[ensure_ssh_is_installed] + upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/resource_maker.py

@@ -57,6 +57,7 @@ class ResourceMaker(BaseTask):
         color: Optional[str] = None,
         description: str = "",
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -78,6 +79,7 @@ class ResourceMaker(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/rsync_task.py

@@ -56,6 +56,7 @@ class RsyncTask(BaseRemoteCmdTask):
         executable: Optional[str] = None,
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -91,6 +92,7 @@ class RsyncTask(BaseRemoteCmdTask):
             cmd=cmd,
             cwd=cwd,
             upstreams=[ensure_rsync_is_installed] + upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,