# Munkafolyamat-függőségek

Használjon munkafolyamat-függőségi várakozást, ha egy legfelső szintű munkafolyamatnak csak más munkafolyamatok befejezése után kell folytatódnia. Ez lehetővé teszi a munkafolyamatok közötti koordinációt anélkül, hogy mindent egyetlen hatalmas munkafolyamat-definícióba kellene zsúfolnia.

Ezek a várakozások különösen jól használhatók az [Aszinkron átadások](https://queuety.inline0.dev/hu/docs/workflows/async-handoffs) funkcióval: az egyik munkafolyamat elindíthat független gyermek-munkafolyamatokat, majd később megvárhatja őket.

A teljesebb tervező/végrehajtó példákért lásd az [Ügynökök összehangolása](https://queuety.inline0.dev/hu/docs/workflows/agent-orchestration) című részt.

A Queuety három építőmetódust kínál:

- `wait_for_workflow()` egy munkafolyamathoz
- `wait_for_workflows()` több munkafolyamathoz, `all`, `any` vagy `quorum` szemantikával
- `wait_for_workflow_group()`, ha a munkafolyamat-azonosítók egy korábban elindított csoportból származnak

## Várakozás egy munkafolyamatra

```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();
```

Amikor a `research_run` befejeződik, a `editorial_run` folytatódik. Ha megadja a `result_key` értékét, a befejezett függőség állapota ezen a kulcson tárolódik:

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

`result_key` nélkül a függőségi munkafolyamat nyilvános állapota egyesül a várakozó munkafolyamat legfelső szintű állapotával.

## Várakozás több munkafolyamatra

```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();
```

- A `WaitMode::All` csak akkor folytatja a munkafolyamatot, ha minden felsorolt munkafolyamat befejeződött.
- A `WaitMode::Any` akkor folytatja, amikor az első felsorolt munkafolyamat befejeződik.
- A `WaitMode::Quorum` akkor folytatja, ha elegendő számú munkafolyamat sikeresen befejeződött.

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

A `result_key` használatával a több munkafolyamatra vonatkozó várakozások a befejezett függőségek állapotát munkafolyamat-azonosító szerint tárolják:

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

`result_key` nélkül a befejezett függőségek állapota a függőségi sorrendnek megfelelően egyesül a várakozó munkafolyamat legfelső szintű állapotával.

## Függőségi azonosítók feloldása a munkafolyamat állapotából

A függőségi lista futásidőig halasztható: az azonosítókat kiolvashatja a nyilvános állapotból:

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

Több függőség esetén:

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

## Várakozás egy elindított munkafolyamat-csoportra

Ha egy korábbi `start_workflows()` vagy `start_agents()` lépés tartós csoportkulcsot tárolt el, közvetlenül erre a csoportra várhat, ahelyett, hogy saját maga vezetné át a munkafolyamat-azonosítókat a nyilvános állapoton.

```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();
```

## Mi történik várakozás közben

Amikor egy munkafolyamat eléri ezen lépések egyikét, `waiting_for_workflows` állapotba kerül. Várakozás közben egyetlen feldolgozó sem marad hozzákapcsolva.

```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']
```

Ha egy függőség már a várakozási lépés elérése előtt befejeződött, a munkafolyamat azonnal folytatódik.

## Hibakezelési szemantika

A munkafolyamat-függőségi várakozás a sikeres befejezésre épül:

- A `wait_for_workflow()` és a `WaitMode::All` meghiúsul, ha bármely szükséges függőség sikertelen vagy megszakított állapotba kerül.
- A `WaitMode::Any` csak akkor hiúsul meg, ha minden függőség végállapotba került, és egyik sem fejeződött be sikeresen.
- A `WaitMode::Quorum` akkor hiúsul meg, ha a még aktív munkafolyamatok száma már nem elegendő az előírt kvórum teljesítéséhez.

Ez hasznossá teszi a munkafolyamat-várakozást a tervező/végrehajtó rendszerekben, ahol az egyik munkafolyamat minden egyes feladathoz egyet indíthat, a másik pedig megvárhatja a `all` eredményeit vagy az elsőként befejeződő sikeres ágat.