Hoe implementeer je het wachtpatroon (Waiter) voor…

De implementatie van het Waiter-patroon voor API's bestaat uit het cyclisch controleren van de status van de bron of het uitvoeren van een operatie totdat aan de verwachte voorwaarde is voldaan of de ingestelde timeout is verlopen.

Belangrijke stappen:

Definieer de te controleren voorwaarde: Begrijp duidelijk welke staat van de API of bron als "klaar" wordt beschouwd (bijvoorbeeld, de status van het verzoek is veranderd, een nieuwe invoer is verschenen, de verwachte gegevens zijn geretourneerd).
Kies het controlemechanisme: Bepaal hoe de statuscontrole wordt uitgevoerd. Dit kan een herhaalde aanvraag aan dezelfde endpoint zijn, een aanvraag aan een speciale status-endpoint of het controleren van de inhoud van het antwoord.
Stel de wachttijdparameters in: Definieer de maximale wachttijd (timeout) en het interval tussen controles.
Implementeer de lus: Creëer een lus die de statuscontrole met het ingestelde interval uitvoert.
Beheer de uitgangsvoorwaarden:
- Stop bij het bereiken van de verwachte voorwaarde.
- Stop bij het verlopen van de timeout, met een uitzondering of foutmelding.
Foutafhandeling tijdens controle: Voorzie in het afhandelen van mogelijke fouten tijdens de uitvoering van de controle binnen de lus (bijvoorbeeld, de API is tijdelijk niet bereikbaar).

Voorbeeld pseudocode:

# wait_for_resource_ready(api_endpoint, expected_condition, timeout_seconds, interval_seconds)

start_time = current_time
while current_time - start_time < timeout_seconds:
    response = make_api_request(api_endpoint) # Voer API-aanvraag uit

    if check_condition(response, expected_condition): # Controleer de klaar-voor-actie
        return True # Voorwaarde voldaan

    sleep(interval_seconds) # Wacht voor de volgende controle
    current_time = current_time # Werk de huidige tijd bij

raise TimeoutError("Bron niet klaar binnen timeout") # Timeout verlopen

# check_condition(response, expected_condition):
# Logica voor het controleren van de klaar-voor-actie op basis van API-respons
# Bijvoorbeeld, return response['status'] == 'ready'

Voorbeeld in Python met de requests-bibliotheek:

import requests
import time

def wait_for_status(url, expected_status, timeout=60, interval=5):
    """
    Wacht tot de endpoint een bepaalde status retourneert.
    """
    start_time = time.time()

    while time.time() - start_time < timeout:
        try:
            response = requests.get(url)
            if response.status_code == expected_status:
                print(f"[{time.strftime('%H:%M:%S')}] Status {expected_status} ontvangen.")
                return True
        except requests.exceptions.RequestException as e:
            print(f"[{time.strftime('%H:%M:%S')}] Fout bij verzoek: {e}. Herhaal over {interval} seconden.")

        time.sleep(interval)

    raise TimeoutError(f"Niet gelukt om status {expected_status} te krijgen binnen {timeout} seconden.")

# Voorbeeld gebruik
# try:
#     wait_for_status("http://api.example.com/status", 200)
# except TimeoutError as e:
#     print(e)

De specifieke implementatie hangt af van de API en de testvereisten. Het is belangrijk om flexibiliteit te bieden in het instellen van timeouts en intervallen, en informatieve berichten te geven bij timeout.

Hoe implementeer je het wachtpatroon (Waiter) voor API's?