# Termene-limită pentru fluxurile de lucru

Puteți stabili un termen-limită pentru fluxurile de lucru. Dacă un flux de lucru aflat în execuție nu se încheie în intervalul specificat, Queuety îl marchează ca eșuat și apelează opțional un handler. Fluxurile de lucru suspendate sau care așteaptă un semnal ori alte fluxuri de lucru nu expiră în timp ce așteaptă. Termenele-limită sunt verificate aproximativ o dată pe minut de un proces `wp queuety work` de lungă durată, nu de worker-ele `--once` sau de mecanismul de rezervă WP-Cron. Astfel, termenul-limită funcționează ca un comutator de siguranță pentru fluxurile de lucru de lungă durată care nu ar trebui să ruleze la nesfârșit.

## Stabilirea unui termen-limită

Folosiți `must_complete_within()` pe constructorul fluxului de lucru pentru a stabili durata maximă permisă. Folosiți `on_deadline()` pentru a înregistra un handler care rulează când termenul-limită este depășit.

```php
use Queuety\Queuety;

Queuety::workflow( 'data_import' )
    ->then( FetchDataHandler::class )
    ->then( TransformDataHandler::class )
    ->then( LoadDataHandler::class )
    ->must_complete_within( hours: 24 )
    ->on_deadline( ImportTimeoutHandler::class )
    ->dispatch( [ 'source' => $url ] );
```

Metoda `must_complete_within()` acceptă parametri cu nume, ale căror valori se adună:

```php
->must_complete_within( hours: 2, minutes: 30 )  // 2.5 hours
->must_complete_within( days: 1 )                 // 24 hours
->must_complete_within( seconds: 3600 )           // 1 hour
->must_complete_within( days: 1, hours: 12 )      // 36 hours
```

## Handler pentru depășirea termenului-limită

Clasa handlerului `on_deadline()` trebuie să implementeze o metodă `handle( array $state ): void`. Aceasta primește starea publică a fluxului de lucru (toate cheile care nu încep cu `_`).

```php
class ImportTimeoutHandler {

    public function handle( array $state ): void {
        // Alert the team.
        wp_mail(
            'ops@example.com',
            'Import workflow timed out',
            'Workflow for source ' . ( $state['source'] ?? 'unknown' ) . ' exceeded its deadline.'
        );

        // Clean up partial work.
        if ( isset( $state['temp_file'] ) ) {
            unlink( $state['temp_file'] );
        }
    }
}
```

Handlerul pentru depășirea termenului-limită este opțional. Dacă doriți doar ca fluxul de lucru să eșueze fără a rula logică personalizată, folosiți `must_complete_within()` fără `on_deadline()`.

## Cum funcționează verificarea termenului-limită

Worker-ul verifică termenele-limită expirate la fiecare 60 de secunde, în cadrul buclei de procesare. Când găsește un flux de lucru al cărui `status` este încă `running` și al cărui `deadline_at` este în trecut, apelează handlerul `on_deadline` dacă este înregistrat, marchează fluxul de lucru ca eșuat cu mesajul de eroare `Deadline exceeded` și înregistrează un eveniment în jurnalul `workflow_deadline_exceeded`. Termenul-limită în sine este stocat ca marcaj temporal `deadline_at` în rândul fluxului de lucru și este calculat la trimitere, pe baza duratei configurate.

## Ce se întâmplă la expirare

Când un flux de lucru își depășește termenul-limită, starea lui devine `failed`, mesajul de eroare este setat la `Deadline exceeded`, handlerul pentru termenul-limită rulează sincron dacă este înregistrat, iar o intrare este înregistrată în jurnalul `workflow_deadline_exceeded`. Joburile aflate în execuție nu sunt întrerupte în mijlocul executării, dar fluxul de lucru nu va avansa dincolo de limita pasului expirat. Dacă handlerul pentru termenul-limită aruncă o excepție, aceasta este ignorată în mod silențios, iar fluxul de lucru rămâne eșuat.

## Metodele WorkflowBuilder

| Metodă | Descriere |
|---|---|
| `must_complete_within( int $seconds = 0, int $minutes = 0, int $hours = 0, int $days = 0 )` | Stabilește durata maximă permisă. Toți parametrii se adună. |
| `on_deadline( string $handler_class )` | Înregistrează un handler apelat când termenul-limită este depășit. |

## Exemplu: termen-limită cu reîncercare

Rareori este util să reîncercați un flux de lucru care a eșuat din cauza depășirii termenului-limită. `retry_workflow()` îl resetează la `running` și repune pasul eșuat în coadă, dar nu șterge și nu prelungește termenul-limită, așa că următoarea verificare, în aproximativ un minut, îl va face să eșueze din nou. Trimiteți un flux de lucru nou.

```php
$status = Queuety::workflow_status( $workflow_id );

if ( 'failed' === $status->status->value ) {
    // Check if it was a deadline failure.
    // You may want to dispatch a new workflow instead of retrying.
    Queuety::retry_workflow( $workflow_id );
}
```

## Termen-limită și întârzieri de repaus

Termenele-limită se aplică întregii durate a fluxului de lucru. Întârzierile de repaus (`->delay()`) suspendă fluxul de lucru pentru o durată fixă, ca parte a secvenței sale de pași. Un flux de lucru cu o întârziere de repaus de 1 oră și un termen-limită de 2 ore va eșua dacă pașii fără repaus durează în total mai mult de 1 oră.