Hacktoberfest 2026: die Issues, die Maintainer für den Oktober markiert haben – offen und einsteigerfreundlich. Hacktoberfest-Issues durchsuchen

[Bug] async def update validator is accepted but never runs, so every update is accepted

Geschlossen Anfängerfreundlich
  • Stimmt etwas nicht?
#2,004 0 Kommentare 0 Reaktionen 0 zugewiesene Personen Auf GitHub ansehen

Maintainer antworten meist innerhalb von 1 Tag

Ein zugehöriger Pull Request wurde bereits gemerged.

  • #2005 von @avanish-garg — gemerged

Bewertung

Schwierigkeit
2/5
Geschätzter Aufwand
1-3 Stunden
Anfängerfreundlichkeit
78/100
Issue-Typ
Bug
Klarheit
Klar beschrieben
Aktivitätsstatus
Aktiv
Tech-Stack
python
Bereich
backend

Rechercherichtung

Beginne in temporalio/worker/_workflow_instance.py bei WorkflowInboundImpl.handle_update_validator und verfolge dann die Registrierung von Validatoren über _UpdateDefinition.set_validator sowie die Pfade über den Decorator, set_update_handler und set_dynamic_update_handler. Lies zuerst die zugehörigen Tests zur Update- und Query-Validierung. Erledigt ist die Aufgabe, wenn asynchrone Validatoren bei der Registrierung über diese Pfade hinweg abgelehnt werden, während synchrone Validatoren weiterhin funktionieren.

Vom Indexierungsmodell aus dem Issue-Text verfasst.

Beschreibung

bug
What are you really trying to do?

Reject an update with invalid arguments before it is written to history, using an update validator on a workflow whose update handler is async def.

Describe the bug

@my_update.validator accepts an async def function without any error, but the validator never executes, so the update is always accepted.

The inbound interceptor calls the validator without awaiting it (WorkflowInboundImpl.handle_update_validator in temporalio/worker/_workflow_instance.py, handler(*input.args)), unlike handle_signal, handle_query and handle_update_handler, which check inspect.iscoroutinefunction and await. For an async def validator the call only creates a coroutine object, which is dropped. The only symptom is a RuntimeWarning: coroutine ... was never awaited on the worker, so a validator that is meant to reject bad input silently lets everything through.

The README says "Validators cannot be async", and the other definition-time mistakes are all reported when the workflow is defined (@workflow.run on a non-async function raises ValueError, duplicate handlers raise ValueError, a validator/handler signature mismatch raises ValueError since #723, async queries emit a DeprecationWarning). The async validator is the one case with no check at all. pyright and mypy do flag it statically, but nothing does at runtime.

The same happens through the dynamic registration paths, workflow.set_update_handler(name, handler, validator=async_fn) and workflow.set_dynamic_update_handler(handler, validator=async_fn).

Expected: a ValueError when the validator is registered (decorator time, as for the signature mismatch). Actual: no error, and the update with n=-5 below is accepted.

Minimal Reproduction
import asyncio, uuid

from temporalio import workflow
from temporalio.client import WorkflowUpdateFailedError
from temporalio.testing import WorkflowEnvironment
from temporalio.worker import UnsandboxedWorkflowRunner, Worker


@workflow.defn
class W:
    def __init__(self) -> None:
        self.done = False
        self.total = 0

    @workflow.run
    async def run(self) -> int:
        await workflow.wait_condition(lambda: self.done)
        return self.total

    @workflow.update
    async def add_sync(self, n: int) -> int:
        self.total += n
        return self.total

    @add_sync.validator
    def _v_sync(self, n: int) -> None:
        if n < 0:
            raise ValueError("negative")

    @workflow.update
    async def add_async(self, n: int) -> int:
        self.total += n
        return self.total

    @add_async.validator
    async def _v_async(self, n: int) -> None:  # accepted by the decorator
        if n < 0:
            raise ValueError("negative")

    @workflow.signal
    def finish(self) -> None:
        self.done = True


async def main():
    async with await WorkflowEnvironment.start_local() as env:
        async with Worker(
            env.client,
            task_queue="tq",
            workflows=[W],
            workflow_runner=UnsandboxedWorkflowRunner(),
        ):
            h = await env.client.start_workflow(W.run, id=str(uuid.uuid4()), task_queue="tq")
            try:
                await h.execute_update(W.add_sync, -5)
                print("sync validator : ACCEPTED -5 (unexpected)")
            except WorkflowUpdateFailedError as e:
                print("sync validator : rejected -5 ->", repr(e.cause)[:60])
            print("async validator: returned", await h.execute_update(W.add_async, -5))
            await h.signal(W.finish)
            print("final total:", await h.result())


asyncio.run(main())

Output on current main (646d70f5):

.../temporalio/worker/_workflow_instance.py:3264: RuntimeWarning: coroutine '_bind_method.<locals>.with_object' was never awaited
  handler(*input.args)
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
sync validator : rejected -5 -> ApplicationError('ValueError: negative')
async validator: returned -5 (update with n=-5 ACCEPTED; total is now negative)
final total: -5

(UnsandboxedWorkflowRunner is only used to keep the script short.)

Environment/Versions
  • OS and processor: M-series Mac (macOS 26.3.1, arm64)
  • Temporal Version: SDK main at 646d70f5 (pure Python from the repo, temporalio 1.34.0 wheel bridge), Python 3.12.14, dev server from WorkflowEnvironment.start_local() (Temporal CLI 1.9.1, server 1.32.0)
  • Are you using Docker or Kubernetes or building Temporal from source? No
Additional context

Proposed fix, in the PR that will follow: raise ValueError("Update validator must not be an async function") in _UpdateDefinition.set_validator, which the decorator and both set_update_handler / set_dynamic_update_handler go through. It is a (very small) behavior change, since a workflow that has an async def validator today would now fail at class definition instead of silently accepting every update. A DeprecationWarning like the one for async queries would keep that workflow loading, but it would keep the validation switched off, so I went with raising. Happy to switch to a warning if you prefer.

Vorherrschende Sprache
Python
Sterne
1.2k
Forks
269
Ø Merge
1 T. 11 Std.
Gemergte PRs (30 T.)
68

Entwicklungsumgebung

Erste Schritte

  1. Lesen Sie das ganze Issue und danach den Beitragsleitfaden des Projekts.
  2. Schreiben Sie ins Issue, dass Sie es übernehmen — das erspart doppelte Arbeit.
  3. Forken Sie das Repository und arbeiten Sie in einem Branch.
  4. Öffnen Sie einen Pull Request, der die Issue-Nummer nennt.

Mehr aus temporalio/sdk-python

Alle Issues in temporalio/sdk-python

Ähnliche Issues

Weitere Issues zu Python

Neue Issues direkt in Ihr Postfach

Eine kurze Übersicht über anfängerfreundliche GitHub-Issues.