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

Single event notification is being yielded every time with `wait_for_external_event`

Abierto
  • ¿Algo no está bien?
#507 3 comentarios 4 reacciones 0 asignados Ver en GitHub

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
4/5
Tiempo estimado
3-5 días
Aptitud para principiantes
48/100
Tipo de issue
Error
Claridad
Bastante claro
Estado de actividad
Tranquilo
Stack tecnológico
python
Área
backend, distributed-systems

Línea de trabajo

Comienza con el punto de entrada wait_for_external_event y reproduce el comportamiento utilizando el repositorio de ejemplo enlazado y OrchestrationHistory.csv. Verifica que un evento emitido antes de esperar se consuma una sola vez, que el segundo wait se bloquee a la espera de un evento futuro y que el orquestador ya no recurra hasta que se supere la profundidad máxima de recursión.

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

Descripción

bug fixed-in-v2 P1

🐛 Describe the bug
When an event notification is raised for an orchestrator that is not yet waiting, then using wait_for_external_event multiple times will always yield that same specific initial event.

A typical scenario when this might happen is when multiple event notifications are raised at the same time by other orchestrators and the main orchestrator would not be waiting during handling of the first event.

🤔 Expected behavior
The expected behavior is that a single event notification only yields a single wait_for_external_event. This does work as expected for event notifications that were submitted after an orchestrator already started to wait for the external event, but not for notification events that were scheduled before waiting for the external event.

☕ Steps to reproduce

I have been able to reproduce the issue in a small example as seen below.

Sample repository: https://github.com/arjendev/durable-functions-python-external-events-issue-sample
Sample orchestration history: https://github.com/arjendev/durable-functions-python-external-events-issue-sample/blob/main/OrchestrationHistory.csv

myApp = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@myApp.route(route="orchestrators/{functionName}")
@myApp.durable_client_input(client_name="client")
async def http_start(req: func.HttpRequest, client: DurableOrchestrationClient):
    function_name = req.route_params.get('functionName')
    instance_id = await client.start_new(function_name)
    response = client.create_check_status_response(req, instance_id)
    return response

# Orchestrator
@myApp.orchestration_trigger(context_name="context")
def hello_orchestrator(context: DurableOrchestrationContext):
    yield context.call_activity("raise_my_durable_event", context.instance_id)
    while True:
        yield context.wait_for_external_event("my-durable-event")

# Activity
@myApp.activity_trigger(input_name="instance", activity="raise_my_durable_event")
@myApp.durable_client_input(client_name="client")
async def raise_my_durable_event(client: DurableOrchestrationClient, instance):
    await client.raise_event(instance, "my-durable-event")

The expected behavior of execution of the orchestrator would be:

  1. Start the orchestrator through the http_trigger
  2. Main orchestrator starts and raises an event notification with name: my-durable-event
  3. Main orchestrator enters the while loop and starts waiting for external events and immediately yields the already scheduled event notification
  4. Main orchestrator halts in the second iteration of the while loop and waits for future events

However, on step 4, the wait_for_external_event keeps returning the initial event and thus the while loop runs forever with the eventual error: Orchestrator function 'hello_orchestrator' failed: maximum recursion depth exceeded in comparison.

Lenguaje dominante
Python
Estrellas
157
Forks
70
Sin PR fusionados en 30 d

Preparar el entorno

Abrir en Codespaces

Inicia el contenedor de desarrollo del proyecto en tu navegador, con tu propia cuenta de GitHub.

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 Azure/azure-functions-durable-python

Todos los issues de Azure/azure-functions-durable-python

Issues similares

Más issues de Python

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.