Hacktoberfest 2026: as issues que os mantenedores marcaram para outubro, abertas e boas para iniciantes. Ver issues do Hacktoberfest

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

Aberta Para iniciantes
  • Algo errado?
#2,004 0 comentários 0 reações 0 responsáveis Ver no GitHub

Mantenedores costumam responder em até 1 dia

@avanish-garg já está trabalhando nisso.

Desde 22/10/2026.

  • #2005 de @avanish-garg — aberto

Avaliação

Dificuldade
2/5
Tempo estimado
1-3 horas
Facilidade para iniciantes
78/100
Tipo de issue
Bug
Clareza
Claramente especificada
Status de atividade
Ativa
Stack de tecnologia
python
Domínio
backend

Direção de pesquisa

Comece em temporalio/worker/_workflow_instance.py, em WorkflowInboundImpl.handle_update_validator, e depois acompanhe o registro de validadores por _UpdateDefinition.set_validator e pelos caminhos do decorator, set_update_handler e set_dynamic_update_handler. Leia primeiro os testes relacionados à validação de updates e queries. O trabalho estará concluído quando validadores assíncronos forem rejeitados no registro em todos esses caminhos, enquanto validadores síncronos continuarem funcionando.

Escrita pelo modelo de indexação a partir do texto da issue.

Descrição

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.

Linguagem predominante
Python
Estrelas
1.2k
Forks
269
Merge médio
1d 11h
PRs com merge (30d)
64

Preparar o ambiente

Primeiros passos

  1. Leia a issue inteira e depois o guia de contribuição do projeto.
  2. Comente na issue dizendo que vai assumir — evita que duas pessoas façam o mesmo trabalho.
  3. Faça um fork do repositório e trabalhe em uma branch.
  4. Abra um pull request que referencie o número da issue.

Mais de temporalio/sdk-python

Todas as issues de temporalio/sdk-python

Issues semelhantes

Mais issues de Python

Receba novas issues na sua caixa de entrada

Um resumo curto de issues do GitHub para quem está começando.