durable-workflow 2.5.2__tar.gz → 2.5.3__tar.gz

{durable_workflow-2.5.2/src/durable_workflow.egg-info → durable_workflow-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.2
+Version: 2.5.3
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.5.2 → durable_workflow-2.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.5.2"
+version = "2.5.3"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -71,8 +71,8 @@ durable-workflow-replay-conformance = "durable_workflow.replay_conformance:main"
 durable-workflow-workflow-updates-conformance = "durable_workflow.workflow_updates_conformance:main"
 
 [tool.durable-workflow]
-product-train = "2.5.2"
-registry-version = "2.5.2"
+product-train = "2.5.3"
+registry-version = "2.5.3"
 supported-server-versions = "2.5.16"
 worker-protocol-version = "1.19"
 control-plane-version = "2"

{durable_workflow-2.5.2 → durable_workflow-2.5.3}/src/durable_workflow/worker.py

@@ -69,6 +69,7 @@ from .errors import (
     DurableWorkflowError,
     ExternalPayloadError,
     InvalidArgument,
+    NonDeterministicReplayError,
     NonRetryableError,
     QueryFailed,
     ServerError,
@@ -2502,20 +2503,35 @@ class Worker:
 
         update_id = task.get("workflow_update_id")
         if isinstance(update_id, str) and update_id:
-            update_command = apply_update(
-                cls,
-                history,
-                start_input,
-                update_id,
-                workflow_id=task.get("workflow_id"),
-                run_id=run_id,
-                payload_codec=codec,
-                external_storage=self.external_storage,
-                external_storage_cache=self.external_storage_cache,
-                prepare_local_activities=self._prepared_local_activities_supported,
-                prepare_local_activity_groups=self._prepared_local_activity_groups_supported,
-                local_activity_cancellation_policies=self._local_activity_cancellation_policies,
-            )
+            try:
+                update_command = apply_update(
+                    cls,
+                    history,
+                    start_input,
+                    update_id,
+                    workflow_id=task.get("workflow_id"),
+                    run_id=run_id,
+                    payload_codec=codec,
+                    external_storage=self.external_storage,
+                    external_storage_cache=self.external_storage_cache,
+                    prepare_local_activities=self._prepared_local_activities_supported,
+                    prepare_local_activity_groups=self._prepared_local_activity_groups_supported,
+                    local_activity_cancellation_policies=self._local_activity_cancellation_policies,
+                )
+            except NonDeterministicReplayError as exc:
+                log.exception("workflow update task %s replay failed for run %s", task_id, run_id)
+                try:
+                    await self.client.fail_workflow_task(
+                        task_id=task_id,
+                        lease_owner=self.worker_id,
+                        workflow_task_attempt=attempt,
+                        message=f"workflow replay failed before update {update_id!r}: {exc}",
+                        failure_type=type(exc).__name__,
+                        stack_trace=traceback.format_exc(),
+                    )
+                except Exception as failure_error:
+                    log.warning("failed to report update replay failure: %s", failure_error)
+                return None
             command = update_command.to_server_command(
                 self.task_queue,
                 payload_codec=command_codec,

{durable_workflow-2.5.2 → durable_workflow-2.5.3}/src/durable_workflow/workflow.py

@@ -3067,6 +3067,8 @@ def apply_update(
             prepare_local_activity_groups=prepare_local_activity_groups,
             local_activity_cancellation_policies=local_activity_cancellation_policies,
         )
+    except NonDeterministicReplayError:
+        raise
     except Exception as exc:
         return _fail_update_from_exception(
             update_id,
@@ -5144,16 +5146,20 @@ def _replay_state(
         for _ in range(boundary):
             _apply_receiver(pending_receivers.pop(0))
 
-    def _condition_wait_mismatch(opened: Mapping[str, Any], cmd: WaitCondition) -> FailWorkflow | None:
+    def _condition_wait_mismatch(
+        opened: Mapping[str, Any], cmd: WaitCondition,
+    ) -> NonDeterministicReplayError | None:
+        step = recorded_wait_steps[wait_yield_count]
+        identity = f"condition wait {opened.get('condition_wait_id')!r}"
         opened_key = opened.get("condition_key")
         if isinstance(opened_key, str) and opened_key != (cmd.condition_key or ""):
-            return FailWorkflow(
-                message=(
-                    "wait_condition key changed during replay: "
+            return NonDeterministicReplayError(
+                step.workflow_sequence, "condition wait", step.event_types,
+                detail=(
+                    f"condition_key_changed: {identity} wait_condition key changed during replay: "
                     f"history has {opened_key!r}, workflow yielded "
                     f"{cmd.condition_key!r}"
                 ),
-                exception_type="NonDeterministicWaitCondition",
             )
 
         opened_fingerprint = opened.get("condition_definition_fingerprint")
@@ -5161,13 +5167,14 @@ def _replay_state(
             isinstance(opened_fingerprint, str)
             and cmd.condition_definition_fingerprint != opened_fingerprint
         ):
-            return FailWorkflow(
-                message=(
+            return NonDeterministicReplayError(
+                step.workflow_sequence, "condition wait", step.event_types,
+                detail=(
+                    f"condition_fingerprint_changed: {identity} "
                     "wait_condition predicate fingerprint changed during replay: "
                     f"history has {opened_fingerprint!r}, workflow yielded "
                     f"{cmd.condition_definition_fingerprint!r}"
                 ),
-                exception_type="NonDeterministicWaitCondition",
             )
 
         return None
@@ -6655,7 +6662,7 @@ def _replay_state(
                         next_value = True
                         continue
                     if next_opened_mismatch is not None:
-                        return _state([next_opened_mismatch])
+                        raise next_opened_mismatch
                     step = _next_unconsumed_recorded_step()
                     if step is not None:
                         _assert_step_matches(cmd, step)
@@ -6707,7 +6714,7 @@ def _replay_state(
                         opened = wait_opened[wait_yield_count]
                         mismatch = _condition_wait_mismatch(opened, cmd)
                         if mismatch is not None:
-                            return _state([mismatch])
+                            raise mismatch
                         opened_id = opened.get("condition_wait_id")
                         if isinstance(opened_id, str):
                             resolution = wait_resolutions.get(opened_id)

{durable_workflow-2.5.2 → durable_workflow-2.5.3/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.2
+Version: 2.5.3
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.5.2 → durable_workflow-2.5.3}/src/durable_workflow.egg-info/SOURCES.txt

@@ -62,6 +62,7 @@ tests/test_committed_cancellation_scope_descendants.py
 tests/test_committed_cancellation_scope_groups.py
 tests/test_committed_cancellation_scope_history.py
 tests/test_committed_cancellation_scope_replay.py
+tests/test_condition_replay_drift.py
 tests/test_control_plane_parity_fixtures.py
 tests/test_cooperative_cancellation.py
 tests/test_cooperative_cancellation_client.py

durable_workflow-2.5.3/tests/test_condition_replay_drift.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from durable_workflow import Worker, serializer, workflow
+from durable_workflow.client import Client
+from durable_workflow.errors import NonDeterministicReplayError, QueryFailed
+from durable_workflow.workflow import WorkflowContext, apply_update, query_state, replay
+
+
+@workflow.defn(name="tests.replay.condition-identity")
+class ConditionIdentityWorkflow:
+    @workflow.query("state")
+    def state(self) -> str:
+        return "waiting"
+
+    @workflow.update("approve")
+    def approve(self) -> str:
+        return "approved"
+
+    def run(self, ctx: WorkflowContext):  # type: ignore[no-untyped-def]
+        yield ctx.wait_condition(lambda: False, key="approved")
+        return "done"
+
+
+def condition_history(field: str) -> list[dict]:
+    return [{
+        "event_type": "ConditionWaitOpened",
+        "payload": {
+            "sequence": 7,
+            "condition_wait_id": "wait-original",
+            "condition_key": "approved",
+            field: "old-key" if field == "condition_key" else "sha256:different",
+        },
+    }]
+
+
+@pytest.mark.parametrize("field", ["condition_key", "condition_definition_fingerprint"])
+@pytest.mark.parametrize("consumer", ["replay", "query", "update"])
+def test_condition_drift_is_not_a_business_failure(field: str, consumer: str) -> None:
+    history = condition_history(field)
+    error = QueryFailed if consumer == "query" else NonDeterministicReplayError
+    with pytest.raises(error) as captured:
+        if consumer == "query":
+            query_state(ConditionIdentityWorkflow, history, [], "state")
+        elif consumer == "update":
+            apply_update(ConditionIdentityWorkflow, history, [], "update-original")
+        else:
+            replay(ConditionIdentityWorkflow, history, [])
+
+    mismatch = captured.value.__cause__ if consumer == "query" else captured.value
+    assert isinstance(mismatch, NonDeterministicReplayError)
+    assert mismatch.workflow_sequence == 7
+    assert "wait-original" in str(mismatch)
+    assert "changed" in str(mismatch)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("field", ["condition_key", "condition_definition_fingerprint"])
+@pytest.mark.parametrize("consumer", ["workflow", "update"])
+async def test_worker_reports_drift_once_without_a_completion(field: str, consumer: str) -> None:
+    client = AsyncMock(spec=Client)
+    worker = Worker(client, task_queue="condition-drift", workflows=[ConditionIdentityWorkflow])
+    task = {
+        "task_id": "task-original",
+        "workflow_id": "workflow-original",
+        "run_id": "run-original",
+        "workflow_type": "tests.replay.condition-identity",
+        "workflow_task_attempt": 2,
+        "history_events": condition_history(field),
+        "arguments": serializer.envelope([], codec="avro"),
+        "payload_codec": "avro",
+    }
+    if consumer == "update":
+        task["workflow_update_id"] = "update-original"
+
+    assert await worker._run_workflow_task_core(task) is None
+
+    client.complete_workflow_task.assert_not_awaited()
+    client.fail_workflow_task.assert_awaited_once()
+    report = client.fail_workflow_task.await_args.kwargs
+    assert report["task_id"] == "task-original"
+    assert report["workflow_task_attempt"] == 2
+    assert report["lease_owner"] == worker.worker_id
+    assert report["failure_type"] == "NonDeterministicReplayError"
+    assert "wait-original" in report["message"]
+
+
+def test_application_predicate_failure_remains_terminal() -> None:
+    @workflow.defn(name="tests.condition-predicate-failure")
+    class PredicateFailure:
+        def run(self, ctx: WorkflowContext):  # type: ignore[no-untyped-def]
+            def predicate() -> bool:
+                raise ValueError("application failed")
+
+            yield ctx.wait_condition(predicate, key="approved")
+
+    outcome = replay(PredicateFailure, [], [])
+    assert len(outcome.commands) == 1
+    command = outcome.commands[0].to_server_command("condition-drift")
+    assert command["type"] == "fail_workflow"
+    assert command["exception_type"] == "ValueError"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("field", ["condition_key", "condition_definition_fingerprint"])
+async def test_query_worker_reports_unavailable_state_without_changing_the_run(field: str) -> None:
+    client = AsyncMock(spec=Client)
+    worker = Worker(client, task_queue="condition-drift", workflows=[ConditionIdentityWorkflow])
+    outcome = await worker._run_query_task({
+        "query_task_id": "query-original",
+        "query_task_attempt": 2,
+        "workflow_id": "workflow-original",
+        "run_id": "run-original",
+        "workflow_type": "tests.replay.condition-identity",
+        "query_name": "state",
+        "history_events": condition_history(field),
+        "workflow_arguments": serializer.envelope([], codec="avro"),
+        "query_arguments": serializer.envelope([], codec="avro"),
+        "payload_codec": "avro",
+    })
+
+    assert outcome == "failed"
+    client.complete_query_task.assert_not_awaited()
+    client.complete_workflow_task.assert_not_awaited()
+    client.fail_workflow_task.assert_not_awaited()
+    client.fail_query_task.assert_awaited_once()
+    report = client.fail_query_task.await_args.kwargs
+    assert report["reason"] == "query_workflow_state_unavailable"
+    assert "wait-original" in report["message"]

{durable_workflow-2.5.2 → durable_workflow-2.5.3}/tests/test_replay_regression_corpus.py

@@ -17,6 +17,7 @@ from durable_workflow.workflow import (
     commands_to_server_commands,
     query_state,
 )
+from tests.test_condition_replay_drift import ConditionIdentityWorkflow
 from tests.test_golden_history_replay import (
     GoldenSagaCompensationWorkflow,
     GoldenSignalWaitWorkflow,
@@ -291,6 +292,7 @@ WORKFLOWS = [
     YieldedContinueAfterMetadataWorkflow,
 ]
 WORKFLOW_TYPES = {str(getattr(workflow, "__workflow_name__", workflow.__name__)): workflow for workflow in WORKFLOWS}
+WORKFLOW_TYPES["tests.replay.condition-identity"] = ConditionIdentityWorkflow
 
 
 def _fixture_paths() -> list[Path]:

{durable_workflow-2.5.2 → durable_workflow-2.5.3}/tests/test_wait_condition.py

@@ -6,7 +6,6 @@ from durable_workflow import serializer, workflow
 from durable_workflow.errors import NonDeterministicReplayError
 from durable_workflow.workflow import (
     CompleteWorkflow,
-    FailWorkflow,
     WaitCondition,
     WorkflowContext,
     query_state,
@@ -1052,14 +1051,12 @@ class TestReplayWaitCondition:
             },
         ]
 
-        outcome = replay(WaitUntilApproved, history, [])
+        with pytest.raises(NonDeterministicReplayError, match="key changed") as captured:
+            replay(WaitUntilApproved, history, [])
 
-        assert len(outcome.commands) == 1
-        assert not isinstance(outcome.commands[0], CompleteWorkflow)
-        cmd = outcome.commands[0]
-        assert isinstance(cmd, FailWorkflow)
-        assert cmd.exception_type == "NonDeterministicWaitCondition"
-        assert "key changed" in cmd.message
+        assert captured.value.workflow_sequence == 1
+        assert "old-key" in str(captured.value)
+        assert "approved" in str(captured.value)
 
     def test_replay_rejects_changed_condition_fingerprint(self) -> None:
         initial = replay(WaitUntilApproved, [], [])
@@ -1077,14 +1074,12 @@ class TestReplayWaitCondition:
             },
         ]
 
-        outcome = replay(WaitUntilApproved, history, [])
+        with pytest.raises(NonDeterministicReplayError, match="predicate fingerprint changed") as captured:
+            replay(WaitUntilApproved, history, [])
 
-        assert len(outcome.commands) == 1
-        cmd = outcome.commands[0]
-        assert isinstance(cmd, FailWorkflow)
-        assert cmd.exception_type == "NonDeterministicWaitCondition"
-        assert "predicate fingerprint changed" in cmd.message
-        assert fingerprint in cmd.message
+        assert captured.value.workflow_sequence == 1
+        assert "sha256:different" in str(captured.value)
+        assert fingerprint in str(captured.value)
 
     def test_replay_accepts_matching_condition_fingerprint(self) -> None:
         initial = replay(WaitUntilApproved, [], [])