Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

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

Cerrado Apto para principiantes
  • ¿Algo no está bien?
#2,004 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 1 día

Ya se ha fusionado un pull request relacionado.

  • #2005 de @avanish-garg — fusionado

Evaluación

Dificultad
2/5
Tiempo estimado
1-3 horas
Aptitud para principiantes
78/100
Tipo de issue
Error
Claridad
Bien especificado
Estado de actividad
Activo
Stack tecnológico
python
Área
backend

Línea de trabajo

Empieza en temporalio/worker/_workflow_instance.py, en WorkflowInboundImpl.handle_update_validator, y luego sigue el registro de validadores a través de _UpdateDefinition.set_validator y de las rutas del decorador, set_update_handler y set_dynamic_update_handler. Lee primero las pruebas relacionadas con la validación de updates y queries. La tarea estará hecha cuando los validadores asíncronos se rechacen al registrarse en todas esas rutas, mientras que los validadores síncronos sigan funcionando.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

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.

Lenguaje dominante
Python
Estrellas
1.2k
Forks
269
Merge medio
1 d 11 h
PR fusionados (30 d)
68

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de temporalio/sdk-python

Todos los issues de temporalio/sdk-python

Issues similares

Más issues de Python

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.