renamed revert to undo

Author: Andrei Neagu

services/dynamic-scheduler/src/simcore_service_dynamic_scheduler/services/generic_scheduler/__init__.py

@@ -1,6 +1,6 @@
 from ._core import (
     cancel_operation,
-    restart_operation_step_stuck_during_revert,
+    restart_operation_step_stuck_during_undo,
     restart_operation_step_stuck_in_manual_intervention_during_create,
     start_operation,
 )
@@ -39,7 +39,7 @@
     "ParallelStepGroup",
     "ProvidedOperationContext",
     "RequiredOperationContext",
-    "restart_operation_step_stuck_during_revert",
+    "restart_operation_step_stuck_during_undo",
     "restart_operation_step_stuck_in_manual_intervention_during_create",
     "ScheduleId",
     "SingleStepGroup",

services/dynamic-scheduler/src/simcore_service_dynamic_scheduler/services/generic_scheduler/_core.py

@@ -117,9 +117,9 @@ async def start_operation(
 
     async def cancel_operation(self, schedule_id: ScheduleId) -> None:
         """
-        Sets the operation to revert form the point in which it arrived in:
-        - when is_creating=True: cancels all steps & moves operation to revert
-        - when is_creating=False: does nothing, since revert is already running
+        Sets the operation to undo form the point in which it arrived in:
+        - when is_creating=True: cancels all steps & moves operation to undo
+        - when is_creating=False: does nothing, since undo is already running
 
         # NOTE: SEE `_on_schedule_event` for more details
         """
@@ -131,7 +131,7 @@ async def cancel_operation(self, schedule_id: ScheduleId) -> None:
 
         if is_creating is False:
             _logger.warning(
-                "Cannot cancel steps for schedule_id='%s' since REVERT is running",
+                "Cannot cancel steps for schedule_id='%s' since UNDO is running",
                 schedule_id,
             )
             return
@@ -270,7 +270,7 @@ async def restart_operation_step_stuck_in_error(
             step_name,
             operation_name,
             schedule_id,
-            "manual intervention" if in_manual_intervention else "error in revert",
+            "manual intervention" if in_manual_intervention else "error in undo",
         )
         # restart only this step
         await start_and_mark_as_started(
@@ -303,24 +303,24 @@ async def _on_schedule_event(self, schedule_id: ScheduleId) -> None:
         - `CEREATEING`: default mode when starting an operation
             - runs the `create()` of each step in each group (`first` -> `last` group)
             - when done, it removes all operation data
-        - `REVERTING`: revert the actions of `create()` in reverse order with respect to CREATING
-            - runs the `revert()` of each step in each group (`current` -> `first` group)
+        - `UNDOING`: undo the actions of `create()` in reverse order with respect to CREATING
+            - runs the `undo()` of each step in each group (`current` -> `first` group)
             - when done, it removes all operation data
         - `REPEATING`: repeats the `create()` of all steps in a group
             - waits and runs the `create()` of all the steps in last group in the operation
             - never completes, unless operation is cancelled
 
         NOTE: `REPEATING` is triggered by setting `BaseStepGroup(repeat_steps=True)` during definition
         of an `operation`.
-        NOTE: `REVERTING` is triggered by calling `cancel_operation()` or when a step finishes with
+        NOTE: `UNDOING` is triggered by calling `cancel_operation()` or when a step finishes with
         status `FAILED` or `CANCELLED` (except in manual intervention).
 
         There are 3 reasons why an operation will hang:
         - MANUAL_INTERVENTION: step failed during `create()` and flagged for manual intervention
             -> requires support intervention
-        - STEP_ISSUE: a step failed during `revert()` due to an error in the step's revert code
+        - STEP_ISSUE: a step failed during `undo()` due to an error in the step's undo code
             -> unexpected behviour / requires developer intervention
-        - FRAMEWORK_ISSUE: a step failed during `revert()` because it was cancelled
+        - FRAMEWORK_ISSUE: a step failed during `undo()` because it was cancelled
             -> unexpected behviour / requires developer intervention
 
         NOTE: only MANUAL_INTERVENTION is an allowed to happen all other failuires are to be treated
@@ -398,8 +398,8 @@ async def _on_schedule_event(self, schedule_id: ScheduleId) -> None:
                 )
 
         else:
-            with log_context(_logger, logging.DEBUG, f"REVERTING {base_message}"):
-                await self._advance_as_reverting(
+            with log_context(_logger, logging.DEBUG, f"UNDOING {base_message}"):
+                await self._advance_as_undoing(
                     steps_statuses,
                     schedule_data_proxy,
                     schedule_id,
@@ -419,15 +419,15 @@ async def _advance_as_repeating(
     ) -> None:
         # REPEATING logic:
         # 1) sleep before repeating
-        # 2) if any of the repeating steps was cancelled -> move to revert
+        # 2) if any of the repeating steps was cancelled -> move to undo
         # 3) -> restart all steps in the group
 
         step_proxies: Iterable[StepStoreProxy] = group_step_proxies.values()
 
         # 1) sleep before repeating
         await asyncio.sleep(current_step_group.wait_before_repeat.total_seconds())
 
-        # 2) if any of the repeating steps was cancelled -> move to revert
+        # 2) if any of the repeating steps was cancelled -> move to undo
 
         # since some time passed, query all steps statuses again,
         # a cancellation request might have been requested
@@ -467,7 +467,7 @@ async def _advance_as_creating(
         # - 1a) -> move to next group
         # - 1b) if reached the end of the CREATE operation -> remove all created data
         # 2) if manual intervention is required -> do nothing else
-        # 3) if any step in CANCELLED or FAILED (and not in manual intervention) -> move to revert
+        # 3) if any step in CANCELLED or FAILED (and not in manual intervention) -> move to undo
 
         # 1) if all steps in group in SUUCESS
         if all(status == StepStatus.SUCCESS for status in steps_statuses.values()):
@@ -522,15 +522,15 @@ async def _advance_as_creating(
             )
             return
 
-        # 3) if any step in CANCELLED or FAILED (and not in manual intervention) -> move to revert
+        # 3) if any step in CANCELLED or FAILED (and not in manual intervention) -> move to undo
         if any(
             s in {StepStatus.FAILED, StepStatus.CANCELLED}
             for s in steps_statuses.values()
         ):
             with log_context(
                 _logger,
                 logging.DEBUG,
-                f"{operation_name=} was not successfull: {steps_statuses=}, moving to revert",
+                f"{operation_name=} was not successfull: {steps_statuses=}, moving to undo",
             ):
                 await schedule_data_proxy.create_or_update("is_creating", value=False)
                 await enqueue_schedule_event(self.app, schedule_id)
@@ -540,7 +540,7 @@ async def _advance_as_creating(
             direction="creation", steps_statuses=steps_statuses, schedule_id=schedule_id
         )
 
-    async def _advance_as_reverting(
+    async def _advance_as_undoing(
         self,
         steps_statuses: dict[StepName, StepStatus],
         schedule_data_proxy: ScheduleDataStoreProxy,
@@ -549,9 +549,9 @@ async def _advance_as_reverting(
         group_index: NonNegativeInt,
         current_step_group: BaseStepGroup,
     ) -> None:
-        # REVERT logic:
+        # UNDO logic:
         # 1) if all steps in group in SUCCESS
-        # - 1a) if reached the end of the REVERT operation -> remove all created data
+        # - 1a) if reached the end of the UNDO operation -> remove all created data
         # - 1b) -> move to previous group
         # 2) it is unexpected to have a FAILED step -> do nothing else
         # 3) it is unexpected to have a CANCELLED step -> do nothing else
@@ -561,7 +561,7 @@ async def _advance_as_reverting(
             previous_group_index = group_index - 1
             if previous_group_index < 0:
 
-                # 1a) if reached the end of the REVERT operation -> remove all created data
+                # 1a) if reached the end of the UNDO operation -> remove all created data
                 await cleanup_after_finishing(
                     self._store, schedule_id=schedule_id, is_creating=False
                 )
@@ -598,7 +598,7 @@ async def _advance_as_reverting(
                 for step_name, traceback in error_tracebacks
             )
             message = (
-                f"Operation 'revert' for schedule_id='{schedule_id}' failed for steps: "
+                f"Operation 'undo' for schedule_id='{schedule_id}' failed for steps: "
                 f"'{failed_step_names}'. Step code should never fail during destruction, "
                 f"please report to developers:\n{formatted_tracebacks}"
             )
@@ -613,7 +613,7 @@ async def _advance_as_reverting(
             n for n, s in steps_statuses.items() if s == StepStatus.CANCELLED
         ]:
             message = (
-                f"Operation 'revert' for schedule_id='{schedule_id}' was cancelled for steps: "
+                f"Operation 'undo' for schedule_id='{schedule_id}' was cancelled for steps: "
                 f"{cancelled_step_names}. This should not happen, and should be addressed."
             )
             _logger.error(message)
@@ -626,7 +626,7 @@ async def _advance_as_reverting(
             return
 
         raise UnexpectedStepHandlingError(
-            direction="revert", steps_statuses=steps_statuses, schedule_id=schedule_id
+            direction="undo", steps_statuses=steps_statuses, schedule_id=schedule_id
         )
 
 
@@ -642,10 +642,10 @@ async def start_operation(
 
 async def cancel_operation(app: FastAPI, schedule_id: ScheduleId) -> None:
     """
-    Unstruct scheduler to revert all steps completed until
+    Unstruct scheduler to undo all steps completed until
     now for the running operation.
 
-    `reverting` refers to the act of undoing the effects of a step
+    `undoing` refers to the act of undoing the effects of a step
     that has already been completed (eg: remove a created network)
     """
     await Core.get_from_app_state(app).cancel_operation(schedule_id)
@@ -667,14 +667,14 @@ async def restart_operation_step_stuck_in_manual_intervention_during_create(
     )
 
 
-async def restart_operation_step_stuck_during_revert(
+async def restart_operation_step_stuck_during_undo(
     app: FastAPI, schedule_id: ScheduleId, step_name: StepName
 ) -> None:
     """
-    Restarts a `stuck step` while the operation is being reverted
+    Restarts a `stuck step` while the operation is being undone
 
     `stuck step` is a step that has failed and exhausted all retries
-    `reverting` refers to the act of undoing the effects of a step
+    `undoing` refers to the act of undoing the effects of a step
     that has already been completed (eg: remove a created network)
     """
     await Core.get_from_app_state(app).restart_operation_step_stuck_in_error(

services/dynamic-scheduler/src/simcore_service_dynamic_scheduler/services/generic_scheduler/_core_utils.py

@@ -202,7 +202,7 @@ async def cleanup_after_finishing(
 ) -> None:
     removal_proxy = OperationRemovalProxy(store=store, schedule_id=schedule_id)
     await removal_proxy.delete()
-    verb = "COMPLETED" if is_creating else "REVERTED"
+    verb = "COMPLETED" if is_creating else "UNDONE"
     _logger.debug("Operation for schedule_id='%s' %s successfully", verb, schedule_id)
 
 

services/dynamic-scheduler/src/simcore_service_dynamic_scheduler/services/generic_scheduler/_deferred_runner.py

@@ -143,7 +143,7 @@ async def get_retries(cls, context: DeferredContext) -> int:
         return (
             await step.get_create_retries(context)
             if is_creating
-            else await step.get_revert_retries(context)
+            else await step.get_undo_retries(context)
         )
 
     @classmethod
@@ -153,7 +153,7 @@ async def get_timeout(cls, context: DeferredContext) -> timedelta:
         return (
             await step.get_create_wait_between_attempts(context)
             if is_creating
-            else await step.get_revert_wait_between_attempts(context)
+            else await step.get_undo_wait_between_attempts(context)
         )
 
     @classmethod
@@ -190,16 +190,16 @@ async def run(cls, context: DeferredContext) -> None:
             )
         else:
             required_context = await operation_context_proxy.read(
-                *step.get_revert_requires_context_keys()
+                *step.get_undo_requires_context_keys()
             )
             _raise_if_any_context_value_is_none(required_context)
 
-            step_provided_operation_context = await step.revert(app, required_context)
+            step_provided_operation_context = await step.undo(app, required_context)
             provided_operation_context = step_provided_operation_context or {}
-            revert_provides_keys = step.get_revert_provides_context_keys()
+            undo_provides_keys = step.get_undo_provides_context_keys()
 
             _raise_if_provided_context_keys_are_missing_or_none(
-                provided_operation_context, revert_provides_keys
+                provided_operation_context, undo_provides_keys
             )
 
         await operation_context_proxy.create_or_update(provided_operation_context)

services/dynamic-scheduler/src/simcore_service_dynamic_scheduler/services/generic_scheduler/_models.py

@@ -15,9 +15,9 @@
 
 # contains all inputs and outpus of each step in the operation
 OperationContext: TypeAlias = dict[str, Any]
-# the inputs of `create` or `revert` of a step
+# the inputs of `create` or `undo` of a step
 RequiredOperationContext: TypeAlias = dict[str, Any]
-# the outputs of `create` or `revert` of a step
+# the outputs of `create` or `undo` of a step
 ProvidedOperationContext: TypeAlias = dict[str, Any]
 
 

services/dynamic-scheduler/src/simcore_service_dynamic_scheduler/services/generic_scheduler/_operation.py

@@ -85,39 +85,39 @@ def wait_for_manual_intervention(cls) -> bool:
         """
         return _DEFAULT_WAIT_FOR_MANUAL_INTERVENTION
 
-    ### REVERT
+    ### UNDO
 
     @classmethod
-    async def revert(
+    async def undo(
         cls, app: FastAPI, required_context: RequiredOperationContext
     ) -> ProvidedOperationContext | None:
         """
         [optional] handler responsible for cleanup of resources created above.
         NOTE: Ensure this is successful if:
             - `create` is not executed
             - `create` is executed partially
-            - `revert` is called multiple times
+            - `undo` is called multiple times
         """
         _ = required_context
         _ = app
         return {}
 
     @classmethod
-    def get_revert_requires_context_keys(cls) -> set[str]:
+    def get_undo_requires_context_keys(cls) -> set[str]:
         """
-        [optional] keys that must be present in the OperationContext when REVERT is called
+        [optional] keys that must be present in the OperationContext when UNDO is called
         """
         return set()
 
     @classmethod
-    def get_revert_provides_context_keys(cls) -> set[str]:
+    def get_undo_provides_context_keys(cls) -> set[str]:
         """
-        [optional] keys that will be added to the OperationContext when REVERT is successful
+        [optional] keys that will be added to the OperationContext when UNDO is successful
         """
         return set()
 
     @classmethod
-    async def get_revert_retries(cls, context: DeferredContext) -> int:
+    async def get_undo_retries(cls, context: DeferredContext) -> int:
         """
         [optional] amount of retires in case of failure
         HINT: you can use `get_operation_context_proxy()`, `get_step_group_proxy(context)`
@@ -127,7 +127,7 @@ async def get_revert_retries(cls, context: DeferredContext) -> int:
         return _DEFAULT_STEP_RETRIES
 
     @classmethod
-    async def get_revert_wait_between_attempts(
+    async def get_undo_wait_between_attempts(
         cls, context: DeferredContext
     ) -> timedelta:
         """
@@ -240,7 +240,7 @@ def _has_abstract_methods(cls: type[object]) -> bool:
 def _validate_operation(operation: Operation) -> dict[StepName, type[BaseStep]]:
     detected_steps_names: dict[StepName, type[BaseStep]] = {}
     create_provided_keys: set[str] = set()
-    revert_provided_keys: set[str] = set()
+    undo_provided_keys: set[str] = set()
 
     for k, step_group in enumerate(operation):
         if (
@@ -278,14 +278,14 @@ def _validate_operation(operation: Operation) -> dict[StepName, type[BaseStep]]:
                     )
                     raise ValueError(msg)
                 create_provided_keys.add(key)
-            for key in step.get_revert_provides_context_keys():
-                if key in revert_provided_keys:
+            for key in step.get_undo_provides_context_keys():
+                if key in undo_provided_keys:
                     msg = (
                         f"Step {step_name=} provides already provided {key=} in "
-                        f"{step.get_revert_provides_context_keys.__name__}()"
+                        f"{step.get_undo_provides_context_keys.__name__}()"
                     )
                     raise ValueError(msg)
-                revert_provided_keys.add(key)
+                undo_provided_keys.add(key)
 
         if (
             step_group.repeat_steps is True
@@ -310,7 +310,7 @@ def get_operation_provided_context_keys(operation: Operation) -> set[str]:
     for step_group in operation:
         for step in step_group.get_step_subgroup_to_run():
             provided_keys.update(step.get_create_provides_context_keys())
-            provided_keys.update(step.get_revert_provides_context_keys())
+            provided_keys.update(step.get_undo_provides_context_keys())
 
     return provided_keys