# Dependențe între fluxuri de lucru

Folosiți așteptarea dependențelor dintre fluxurile de lucru când un flux de lucru de nivel superior ar trebui să continue numai după încheierea altor fluxuri de lucru. Astfel, coordonați fluxuri de lucru diferite fără a forța includerea tuturor într-o singură definiție uriașă.

Aceste așteptări se potrivesc în special cu [Transferuri asincrone](https://queuety.inline0.dev/ro/docs/workflows/async-handoffs), când un flux de lucru pornește mai întâi fluxuri de lucru copil independente, apoi le așteaptă.

Pentru exemple mai ample de planificator și executant, consultați [Orchestrarea agenților](https://queuety.inline0.dev/ro/docs/workflows/agent-orchestration).

Queuety oferă trei metode pentru constructor:

- `wait_for_workflow()` pentru un flux de lucru
- `wait_for_workflows()` pentru mai multe fluxuri de lucru cu semantica `all`, `any` sau `quorum`
- `wait_for_workflow_group()` când ID-urile fluxurilor de lucru provin dintr-un grup pornit anterior

## Așteptarea unui singur flux de lucru

```php
$research_id = Queuety::workflow( 'research_run' )
    ->then( PlanResearchStep::class )
    ->for_each( 'tasks', ExecuteResearchTask::class, 'results' )
    ->dispatch( [ 'brief_id' => 42 ] );

$editorial_id = Queuety::workflow( 'editorial_run' )
    ->wait_for_workflow( $research_id, 'research' )
    ->then( DraftBriefStep::class )
    ->dispatch();
```

Când se încheie `research_run`, `editorial_run` se reia. Dacă este setat `result_key`, starea dependenței încheiate este stocată sub acea cheie:

```php
$state['research']; // public state from the completed research workflow
```

Fără `result_key`, starea publică a fluxului de lucru dependent este îmbinată în starea de nivel superior a fluxului de lucru aflat în așteptare.

## Așteptarea mai multor fluxuri de lucru

```php
use Queuety\Enums\WaitMode;

Queuety::workflow( 'synthesis_run' )
    ->wait_for_workflows(
        [ $research_id, $editorial_id, $legal_id ],
        WaitMode::All,
        'dependencies'
    )
    ->then( PublishPacketStep::class )
    ->dispatch();
```

- `WaitMode::All` reia fluxul de lucru numai după încheierea tuturor fluxurilor de lucru enumerate.
- `WaitMode::Any` reia fluxul de lucru când se încheie primul flux de lucru enumerat.
- `WaitMode::Quorum` reia fluxul de lucru după ce se încheie cu succes numărul necesar de fluxuri de lucru.

```php
Queuety::workflow( 'synthesis_run' )
    ->wait_for_workflows(
        [ $research_id, $editorial_id, $legal_id ],
        WaitMode::Quorum,
        'dependencies',
        quorum: 2,
    )
    ->then( PublishPacketStep::class )
    ->dispatch();
```

Cu `result_key`, așteptările pentru mai multe fluxuri de lucru stochează starea dependențelor încheiate, indexată după ID-ul fluxului de lucru:

```php
[
    '42' => [ 'summary' => '...' ],
    '43' => [ 'summary' => '...' ],
]
```

Fără `result_key`, starea dependențelor încheiate este îmbinată în starea de nivel superior a fluxului de lucru aflat în așteptare, în ordinea dependențelor.

## Rezolvarea ID-urilor dependențelor din starea fluxului de lucru

Puteți amâna lista dependențelor până la execuție, citind ID-urile fluxurilor de lucru din starea publică:

```php
Queuety::workflow( 'agent_follow_up' )
    ->wait_for_workflow( 'parent_workflow_id', 'parent' )
    ->then( FinalizeAgentRunStep::class )
    ->dispatch( [ 'parent_workflow_id' => $workflow_id ] );
```

Pentru mai multe dependențe:

```php
Queuety::workflow( 'aggregator' )
    ->wait_for_workflows( 'dependency_ids', WaitMode::Any, 'winner' )
    ->dispatch( [ 'dependency_ids' => [ 12, 18, 22 ] ] );
```

## Așteptarea unui grup de fluxuri de lucru pornit

Dacă un pas `start_workflows()` sau `start_agents()` anterior a stocat o cheie de grup durabilă, puteți aștepta direct acel grup, în loc să transmiteți singur ID-urile fluxurilor de lucru prin starea publică.

```php
Queuety::workflow( 'brief_research' )
    ->then( PlanTopicsStep::class )
    ->start_agents( 'agent_tasks', $agent_run, group_key: 'researchers' )
    ->wait_for_agent_group( 'researchers', WaitMode::Quorum, 2, 'agent_results' )
    ->then( SynthesizeBriefStep::class )
    ->dispatch();
```

## Ce se întâmplă în timpul așteptării

Când un flux de lucru ajunge la unul dintre acești pași, trece în starea `waiting_for_workflows`. Niciun worker nu rămâne asociat fluxului de lucru în timp ce acesta așteaptă.

```php
$state = Queuety::workflow_status( $workflow_id );
echo $state->status->value; // 'waiting_for_workflows'
echo $state->wait_type;     // 'workflow'
print_r( $state->waiting_for ); // ['42', '43']
```

Dacă o dependență s-a încheiat deja înainte de atingerea pasului de așteptare, fluxul de lucru continuă imediat.

## Semantica eșecului

Așteptarea dependențelor dintre fluxurile de lucru este orientată spre succes:

- `wait_for_workflow()` și `WaitMode::All` eșuează dacă vreo dependență necesară eșuează sau este anulată.
- `WaitMode::Any` eșuează numai când toate dependențele ajung într-o stare terminală și niciuna nu s-a încheiat cu succes.
- `WaitMode::Quorum` eșuează când fluxurile de lucru active rămase nu mai pot îndeplini cvorumul necesar.

Astfel, așteptarea fluxurilor de lucru este utilă în sistemele de planificare și execuție, în care un flux de lucru poate distribui activitățile, iar altul poate aștepta rezultatele `all` sau prima ramură reușită care se încheie.