PHP API

Vaata Markdownina Muuda teenuses GitHub Dokumentatsioon: 2cc7b2b

Kõik Queuety võimalused on kättesaadavad staatilise klassi Queuety\Queuety kaudu. See on ainus sisenemispunkt tööde väljasaatmiseks, töövoogude koostamiseks, olekumasinate juhtimiseks, järjekordade haldamiseks ja sisemiste alamsüsteemide kasutamiseks.

PHP

use Queuety\Queuety;

Eraldiseisev juurdepääs tuumale

Queuety andmebaasipõhist käituskeskkonda saab lähtestada väljaspool WordPress-i.

See eraldiseisev kasutusviis on mõeldud orkestreerimise tuuma jaoks:

tööd ja töötajad (töötajate kogumid vajavad ka konstante DB_HOST, DB_NAME, DB_USER ja DB_PASSWORD; vt allpool)
töövood ja signaalid
olekumasinad ja sündmused
artefaktid, logid, mõõdikud ja ajakavad

See ei asenda adapterit WordPress. Queuety::on_action(), replace_wp_cron(), plugina alglaadimine ja päris wp queuety ... registreerimistee vajavad endiselt WordPress-i.

`Queuety::init( Connection $conn )`

Lähtesta Queuety otse andmebaasiga ühendudes.

PHP

use Queuety\Connection;
use Queuety\Queuety;

$conn = new Connection(
    host: '127.0.0.1:3306',
    dbname: 'wordpress',
    user: 'root',
    password: 'secret',
    prefix: 'wp_',
);

Queuety::init( $conn );

Valikuline argument table_prefix muudab käituskeskkonna tabelinimede osa Queuety ühendusepõhiseks:

PHP

$conn = new Connection(
    host: '127.0.0.1:3306',
    dbname: 'wordpress',
    user: 'root',
    password: 'secret',
    prefix: 'wp_',
    table_prefix: 'themequeue_',
);

See teisendab näiteks tabelinime queuety_jobs nimeks wp_themequeue_jobs.

`Queuety::ensure_schema()`

Veendu, et aktiivse ühenduse jaoks vajalikud käituskeskkonna tabelid Queuety oleksid olemas.

PHP

Queuety::init( $conn );
Queuety::ensure_schema();

Täieliku mudeli ja adapteri WordPress piiride kohta vt Eraldiseisev kasutus.

Tööd

`Queuety::dispatch( $handler, $payload )`

Saada töö käivitamiseks. Argumendiks sobib käitleja nime string või Contracts\Job-i eksemplar. Tagastab aheldatud valikute määramiseks PendingJob ehitaja.

PHP

// Handler name + payload (original API)
Queuety::dispatch( 'send_email', [ 'to' => 'user@example.com' ] );

// Contracts\Job instance (v0.6.0+)
Queuety::dispatch( new SendEmailJob( to: 'user@example.com' ) );

// With options
Queuety::dispatch( 'send_email', [ 'to' => 'user@example.com' ] )
    ->on_queue( 'emails' )
    ->with_priority( Priority::High )
    ->delay( 300 )
    ->max_attempts( 5 )
    ->rate_limit( 10, 60 )
    ->unique()
    ->after( $other_job_id );

// Get the job ID
$job_id = Queuety::dispatch( 'send_email', $payload )->id();

Kui antakse eksemplar Contracts\Job, eraldab serialiseerija käitleja nimeks FQCN-i ja andmeteks avalikud omadused. Parameetrit $payload eiratakse, kui $handler on Job eksemplar.

Meetodid `PendingJob`

Meetod	Kirjeldus
`on_queue( string $queue )`	Määra sihtjärjekord
`with_priority( Priority $priority )`	Määra prioriteeditase
`delay( int $seconds )`	Viivitus enne töö kättesaadavaks muutumist
`max_attempts( int $max )`	Uuesti proovimise maksimaalne arv
`rate_limit( int $max, int $window )`	Kiiruse piirang: maksimaalne käivituste arv ajavahemikus sekundites
`unique()`	Väldi korduvaid väljasaatmisi
`after( int $job_id )`	Oota, kuni teine töö on lõpetanud
`concurrency_group( string $group, int $limit )`	Lisa töö jagatud töötaja vastuvõtugruppi
`cost_units( int $units )`	Lisa väljasaatmisele suhtelise käivituskulu metaandmed
`id()`	Saada töö jõuga ja tagasta töö ID

concurrency_group() ja cost_units() toetavad laiemat mudelit Ressursside haldus, nii et sama väljasaatmine saab osaleda arvupõhistes samaaegsuspiirangutes, kaalutud järjekorra- või pakkujaeelarvetes ning töötajate vastuvõtuheuristikates.

`Queuety::dispatch_sync( $handler, $payload )`

Käivita töö sünkroonselt praeguses protsessis, lisamata seda järjekorda.

PHP

// With a Job instance
Queuety::dispatch_sync( new SendEmailJob( to: 'user@example.com', subject: 'Hi', body: 'Hello' ) );

// With a handler name and payload
Queuety::dispatch_sync( 'send_email', [ 'to' => 'user@example.com' ] );

Töö meetodit handle() kutsutakse otse. Andmebaasi rida ei looda, töötajat ei kaasata ja vahevara ei rakendata.

`Queuety::batch( $jobs )`

Saada mitu tööd ühe mitmerealise INSERT-käsuga.

PHP

$job_ids = Queuety::batch( [
    [ 'handler' => 'send_email', 'payload' => [ 'to' => 'a@example.com' ], 'queue' => 'emails' ],
    [ 'handler' => 'send_email', 'payload' => [ 'to' => 'b@example.com' ], 'priority' => 2 ],
] );

`Queuety::create_batch( $jobs )`

Loo BatchBuilder, et saata tööde rühm välja koos tagasihelistuste ja edenemise jälgimisega. Täpsemat teavet leiad jaotisest Pakktöötlus.

PHP

$batch = Queuety::create_batch( [
    new ImportUsersJob( $chunk_1 ),
    new ImportUsersJob( $chunk_2 ),
] )
    ->name( 'Import users' )
    ->then( ImportCompleteHandler::class )
    ->catch( ImportFailedHandler::class )
    ->finally( ImportCleanupHandler::class )
    ->allow_failures()
    ->on_queue( 'imports' )
    ->dispatch();

Meetodid `BatchBuilder`

Meetod	Tagastab	Kirjeldus
`name( string $name )`	`self`	Määra pakile nimi
`on_queue( string $queue )`	`self`	Määra kõigi paki tööde järjekord
`then( string $handler_class )`	`self`	Käitleja, keda kutsutakse paki eduka lõpetamise korral
`catch( string $handler_class )`	`self`	Käitleja, keda kutsutakse paki esimese töö nurjumisel
`finally( string $handler_class )`	`self`	Käitleja, keda kutsutakse paki lõppemisel (edu või nurjumine)
`allow_failures()`	`self`	Luba kutsuda tagasihelistus `then` ka nurjumiste korral
`dispatch()`	`Batch`	Loo paki kirje ja kõik tööd, tagastab väärtusobjekti `Batch`

`Queuety::find_batch( $id )`

Leia pakk ID järgi. Tagastab väärtusobjekti Batch või null.

PHP

$batch = Queuety::find_batch( $batch_id );

if ( null !== $batch ) {
    echo $batch->progress() . '% complete';
}

Töötajate juhtimine

`Queuety::run_worker( $queue = 'default', $once = false )`

Käivita üks töötaja tsükkel otse.

PHP

Queuety::run_worker( 'default' );
Queuety::run_worker( 'critical,default', true );

`Queuety::run_worker_pool( $workers, $queue = 'default' )`

Käivita fikseeritud suurusega töötajate kogum otse. Vajab laiendusi pcntl ja posix. Kogum loeb alamühenduste jaoks konstante WordPress DB_HOST, DB_NAME, DB_USER ja DB_PASSWORD (lähtestatud ühendus annab ainult tabelite prefiksid), seega määra need kogumi käivitamisel väljaspool WordPress-i (#5).

PHP

Queuety::run_worker_pool( 4, 'providers' );

`Queuety::run_auto_scaling_worker_pool( $min_workers, $max_workers, $queue = 'default' )`

Käivita kohanduv töötajate kogum otse. Samad nõuded nagu run_worker_pool() puhul.

PHP

Queuety::run_auto_scaling_worker_pool( 2, 6, 'providers' );

Väärtusobjekt `Batch`

Meetod/omadus	Tüüp	Kirjeldus
`$id`	`int`	Paki ID
`$name`	`string\|null`	Valikuline paki nimi
`$total_jobs`	`int`	Tööde koguarv pakis
`$pending_jobs`	`int`	Ootel tööd
`$failed_jobs`	`int`	Nurjunud tööde arv
`$failed_job_ids`	`array`	Nurjunud tööde ID-d
`$created_at`	`DateTimeImmutable`	Paki loomise aeg
`$finished_at`	`DateTimeImmutable\|null`	Paki lõpetamise aeg
`$cancelled_at`	`DateTimeImmutable\|null`	Paki tühistamise aeg
`progress()`	`int`	Lõpetamise protsent (0–100)
`finished()`	`bool`	Kas pakk on lõpetatud
`has_failures()`	`bool`	Kas mõni töö nurjus
`cancelled()`	`bool`	Kas pakk tühistati

`Queuety::chain( $jobs )`

Loo ChainBuilder järjestikuseks tööde käivitamiseks. Iga töö sõltub eelmise edukast lõpetamisest.

PHP

$first_job_id = Queuety::chain( [
    new FetchDataJob( $url ),
    new ProcessDataJob(),
    new NotifyCompleteJob(),
] )
    ->on_queue( 'pipeline' )
    ->catch( ChainFailedHandler::class )
    ->dispatch();

Meetodid `ChainBuilder`

Meetod	Tagastab	Kirjeldus
`on_queue( string $queue )`	`self`	Määra ahela kõigi tööde järjekord
`catch( string $handler_class )`	`self`	Käitleja, keda kutsutakse ahela mis tahes töö lõplikul matmisel
`dispatch()`	`int`	Loo kõik tööd järjestikuste sõltuvustega ja tagasta esimese töö ID

`Queuety::retry( $job_id )`

Proovi kindlat tööd uuesti. Selle olekuks määratakse pending.

PHP

Queuety::retry( 42 );

`Queuety::retry_buried()`

Proovi kõiki maetud töid uuesti. Tagastab uuesti proovitud tööde arvu.

PHP

$count = Queuety::retry_buried();

`Queuety::purge( $older_than_days )`

Kustuta lõpetatud tööd. Tagastab kustutatud tööde arvu.

PHP

$count = Queuety::purge();     // uses QUEUETY_RETENTION_DAYS
$count = Queuety::purge( 30 ); // purge jobs older than 30 days

Järjekorrad

`Queuety::stats( $queue )`

Tagasta oleku järgi rühmitatud tööde arvud.

PHP

$stats = Queuety::stats();          // all queues
$stats = Queuety::stats( 'emails' ); // specific queue
// ['pending' => 12, 'processing' => 3, 'completed' => 150, 'failed' => 2, 'buried' => 1]

`Queuety::buried( $queue )`

Tagasta kõik maetud tööd.

PHP

$jobs = Queuety::buried();
$jobs = Queuety::buried( 'emails' );

`Queuety::pause( $queue )`

Peata järjekord, et töötajad selle vahele jätaksid.

PHP

Queuety::pause( 'emails' );

`Queuety::resume( $queue )`

Jätka peatatud järjekorda.

PHP

Queuety::resume( 'emails' );

`Queuety::is_paused( $queue )`

Kontrolli, kas järjekord on peatatud.

PHP

if ( Queuety::is_paused( 'emails' ) ) {
    // Queue is paused
}

Töövood

`Queuety::workflow( $name )`

Alusta töövoo koostamist. Tagastab objekti WorkflowBuilder.

PHP

$workflow_id = Queuety::workflow( 'generate_report' )
    ->then( FetchDataHandler::class )
    ->then( CallLLMHandler::class )
    ->then( FormatOutputHandler::class )
    ->dispatch( [ 'user_id' => 42 ] );

Meetodid `WorkflowBuilder`

Meetod	Kirjeldus
`then( string $handler_class, ?string $name = null )`	Lisa järjestikune samm. Tingimusliku hargnemise jaoks on võimalik lisada valikuline nimi.
`parallel( array $handler_classes )`	Lisa paralleelsete sammude rühm.
`for_each( string $items_key, string $handler_class, ?string $result_key = null, ForEachMode $mode = ForEachMode::All, ?int $quorum = null, ?string $reducer_class = null, ?string $name = null )`	Lisa dünaamiline iga üksuse jaoks samm, mis loob olekus iga üksuse kohta ühe harutöö.
`repeat_while( string $target_step, ?string $state_key = null, mixed $expected = true, ?string $name = null, ?string $condition_class = null, ?int $max_iterations = null )`	Liigu tagasi varasema nimega sammu juurde, kuni avalik olekuvõti või klass `RepeatCondition` vastab tingimusele.
`repeat_until( string $target_step, ?string $state_key = null, mixed $expected = true, ?string $name = null, ?string $condition_class = null, ?int $max_iterations = null )`	Liigu tagasi varasema nimega sammu juurde, kuni avalik olekuvõti või klass `RepeatCondition` vastab tingimusele.
`run_workflow( string $workflow_name, WorkflowBuilder $sub_builder )`	Lisa töövoo käivitamise samm.
`delay( int $seconds = 0, int $minutes = 0, int $hours = 0, int $days = 0 )`	Lisa püsiv viivitussamm. Kestused liidetakse kokku.
`wait_for_signal( string $name, ?string $result_key = null, ?string $step_name = null, array $match_payload = [], ?string $correlation_key = null )`	Lisa signaali ootamise samm. Valikulised `match_payload` ja `correlation_key` võimaldavad eirata mitteseotud sündmusi.
`wait_for_signals( array $signal_names, WaitMode $mode = WaitMode::All, ?string $result_key = null, ?string $name = null, array $match_payload = [], ?string $correlation_key = null )`	Oota mitut signaali: kõiki või ükskõik millist; soovi korral sobita andmeid ja korrelatsiooni.
`wait_for_approval( string $signal_name = 'approval', ?string $result_key = 'approval', ?string $name = null, array $match_payload = [], ?string $correlation_key = null )`	Oota inimese kinnitussignaali.
`wait_for_decision( string $approve_signal = 'approved', string $reject_signal = 'rejected', ?string $result_key = 'decision', ?string $name = null, array $match_payload = [], ?string $correlation_key = null )`	Oota kinnitust või tagasilükkamist ning salvesta struktureeritud otsuse andmed.
`wait_for_input( string $signal_name = 'input', ?string $result_key = 'input', ?string $name = null, array $match_payload = [], ?string $correlation_key = null )`	Oota inimese sisendsignaali.
`wait_for_workflow( int\|string $workflow, ?string $result_key = null, ?string $name = null )`	Oota ühe töövoo või avalikus olekus talletatud töövoo ID lõpetamist.
`wait_for_workflows( array\|string $workflows, WaitMode $mode = WaitMode::All, ?string $result_key = null, ?string $name = null, ?int $quorum = null )`	Oota mitme töövoo lõpetamist: kõigi, ükskõik millise või nõutud kvoorumi.
`wait_for_workflow_group( string $group_key, WaitMode $mode = WaitMode::All, ?int $quorum = null, ?string $result_key = null, ?string $name = null )`	Oota varem käivitatud töövoogude rühma sisemise rühmavõtme järgi.
`start_workflows( string $items_key, WorkflowBuilder $workflow_builder, string $result_key = 'started_workflow_ids', string $payload_key = 'item', bool $inherit_state = true, ?string $name = null, ?string $group_key = null )`	Saada iga käitusaja üksuse kohta välja üks tipptaseme töövoog ja soovi korral lisa käivitatud kogumile püsiv rühmavõti.
`start_agents( string $items_key, WorkflowBuilder $workflow_builder, string $result_key = 'agent_workflow_ids', string $payload_key = 'agent_task', bool $inherit_state = true, ?string $name = null, ?string $group_key = null )`	Agendipõhine alias nimele `start_workflows()`.
`wait_for_agents( array\|string $workflows = 'agent_workflow_ids', WaitMode $mode = WaitMode::All, ?string $result_key = 'agent_results', ?string $name = null, ?int $quorum = null )`	Agendipõhine alias nimele `wait_for_workflows()`.
`wait_for_agent_group( string $group_key = 'agents', WaitMode $mode = WaitMode::All, ?int $quorum = null, ?string $result_key = 'agent_results', ?string $name = null )`	Agendipõhine alias nimele `wait_for_workflow_group()`.
`version( string $version )`	Lisa töövoo määratlusele rakenduse tasemel versioon, mida saab kontrollida ja eksportida.
`idempotency_key( string $key )`	Muuda töövoo väljasaatmine helistaja antud võtme alusel püsivaks. Sama võtmega uuesti väljasaatmisel tagastatakse algne töövoo ID.
`max_transitions( int $max )`	Nurja töövoog, kui lõpetatakse üle `$max` sammuülemineku.
`max_for_each_items( int $max )`	Nurja töövoog, kui `for_each()` samm püüab luua üle `$max` üksuse.
`max_state_bytes( int $bytes )`	Nurja töövoog, kui avalik olek kasvab üle `$bytes` piiri.
`max_cost_units( int $max )`	Nurja töövoog, kui lõpetatud sammude kulu ületab `$max` kuluühikut.
`max_started_workflows( int $max )`	Nurja töövoog enne, kui saadetakse välja üle `$max` alamtöövoo.
`compensate_with( string $handler_class )`	Lisa viimati lisatud sammule kompenseeriv käitleja.
`compensate_on_failure()`	Käivita töövoo nurjumisel automaatselt lõpetatud sammude kompensatsioonid.
`on_queue( string $queue )`	Määra kõigi sammude järjekord.
`with_priority( Priority $priority )`	Määra kõigi sammude prioriteet.
`max_attempts( int $max )`	Määra igale sammule korduskatsete maksimaalne arv.
`on_cancel( string $handler_class )`	Registreeri tühistamise puhastuskäitleja klass. Vt Tühistamine.
`prune_state_after( int $steps = 2 )`	Luba automaatne oleku kärpimine. Eemaldab lävest vanemad sammväljundid. Vt Olekukärpimine.
`must_complete_within( int $seconds = 0, int $minutes = 0, int $hours = 0, int $days = 0 )`	Määra töövoole tähtaeg. Kestused liidetakse kokku. Vt Tähtajad.
`on_deadline( string $handler_class )`	Registreeri käitleja, mida kutsutakse töövoo tähtaja ületamisel. Vt Tähtajad.
`dispatch( array $initial_payload = [] )`	Saada töövoog välja. Tagastab töövoo ID.

`Queuety::workflow_status( $workflow_id )`

Hangi töövoo olek. Tagastab objekti WorkflowState või null.

PHP

$state = Queuety::workflow_status( $workflow_id );
echo $state->name;          // 'generate_report'
echo $state->status->value; // 'running'
echo $state->current_step;  // 1
echo $state->total_steps;   // 3
print_r( $state->state );   // accumulated public state array
echo $state->wait_type;     // 'signal' or 'workflow' while blocked
echo $state->wait_mode;     // 'all', 'any', or 'quorum'
echo $state->definition_version; // 'research.v2'
echo $state->definition_hash;    // '4c7a...'
echo $state->idempotency_key;    // 'brief:42:research'
echo $state->artifact_count;     // 2
print_r( $state->budget );       // configured workflow budget + current usage
print_r( $state->wait_details ); // matched/remaining blockers, result key, correlation info
print_r( $state->artifact_keys ); // ['draft', 'citations']

WorkflowState pakub lisaks järgmist:

waiting_for: signaalide nimed või töövoogude ID-d, mis praegu käivitamist takistavad
current_step_name: praeguse sammu seadistatud nimi, kui see on olemas
wait_mode: praegune ooteolek (all, any või quorum), kui töövoog on blokeeritud
wait_details: täiendavad kontrolliandmed, näiteks sobitatud ja allesjäänud takistused
definition_version: väärtus, mille määras version(), kui see on olemas
definition_hash: töövoo definitsiooni deterministlik räsi
idempotency_key: püsiv väljasaatmisvõti, kui see on olemas
budget: seadistatud piirangud koos praeguse kasutusega, kui kaitsepiirangud on lubatud
artifact_count: töövoo salvestatud artefaktide arv
artifact_keys: salvestatud artefaktide võtmed kiireks kontrollimiseks

`Queuety::retry_workflow( $workflow_id )`

Käivitage ebaõnnestunud töövoog uuesti alates ebaõnnestunud sammust.

PHP

Queuety::retry_workflow( $workflow_id );

Tekitab erindi RuntimeException, kui töövoog on pärast tõrget juba kompenseeritud.

`Queuety::pause_workflow( $workflow_id )`

Peatage töötav töövoog. Praeguse sammu juba järjekorda pandud töö võib siiski lõpule jõuda, kuid hilisemaid samme ei panda järjekorda enne töövoo jätkamist.

PHP

Queuety::pause_workflow( $workflow_id );

`Queuety::resume_workflow( $workflow_id )`

Jätkake peatatud töövoogu.

PHP

Queuety::resume_workflow( $workflow_id );

`Queuety::cancel_workflow( $workflow_id )`

Tühistage töövoog ja käivitage kõik registreeritud puhastuskäitlejad. Määrab olekuks cancelled ning matab kõik töövoo ootel ja töötlemisel olevad tööd.

PHP

Queuety::cancel_workflow( $workflow_id );

Tekitab erindi RuntimeException, kui töövoog on juba completed või cancelled. Lisateavet leiate jaotisest Tühistamine.

`Queuety::rewind_workflow( $workflow_id, $to_step )`

Viige töövoog tagasi eelmise sammu juurde ja käivitage see sealt uuesti. Olek taastatakse antud sammu sündmuslogi kirjest state_after ning järjekorda pannakse järgmine samm.

PHP

Queuety::rewind_workflow( $workflow_id, to_step: 1 );

Tekitab erindi RuntimeException, kui sihtsammu kohta pole salvestatud olekut. Nõuab Workflow Event Log kasutamist. Lisateavet leiate jaotisest Ajas rändamine.

`Queuety::fork_workflow( $workflow_id )`

Hargitage töötav töövoog selle praeguses olekus iseseisvaks koopiaks. Tagastab uue töövoo ID.

PHP

$forked_id = Queuety::fork_workflow( $workflow_id );

Hargnenud töövoog saab oma ID ja töötab algsest sõltumatult. Lisateavet leiate jaotisest Hargnemine.

`Queuety::export_workflow( $workflow_id )`

Eksportige töövoo täielik käivitusajalugu JSON-ühilduva massiivina. Sisaldab töövoo kirjet, kõiki töid, töövoo sündmusi ja logikirjeid.

PHP

$data = Queuety::export_workflow( $workflow_id );

Andmestruktuuri JSON ja kasutusjuhtude kohta vaadake jaotist Eksportimine ja taasesitus.

`Queuety::replay_workflow( $data )`

Taasesitage eksporditud töövoog praeguses keskkonnas. Loob ekspordiandmete põhjal uue töövoo ja tagastab selle ID.

PHP

$new_id = Queuety::replay_workflow( $data );

Üksikasju vaadake jaotisest Eksportimine ja taasesitus.

`Queuety::replace_wp_cron()`

Asendage sisseehitatud WordPress cron süsteem Queuety ajastiga. Püüab kinni wp_schedule_event(), wp_unschedule_event() ja wp_get_scheduled_event() ning suunab korduvad sündmused läbi Queuety töölise.

PHP

Queuety::replace_wp_cron();

Töötab ainult siis, kui WordPress on laaditud. Üksikasju vaadake jaotisest WP-Cron asendamine.

`Queuety::restore_wp_cron()`

Taastage WordPress vaikimisi cron käitumine, eemaldades Queuety cron silla konksud.

PHP

Queuety::restore_wp_cron();

Piirangute kohta vaadake jaotist WP-Cron asendamine.

`Queuety::signal( $workflow_id, $name, $data )`

Saatke töövoole signaal. Kui töövoog ootab parajasti seda signaali, jätkub see kohe. Vastasel juhul salvestatakse signaal ja see võetakse vastu, kui töövoog jõuab vastava wait_for_signal sammuni.

PHP

Queuety::signal( $workflow_id, 'approved' );

// With data merged into workflow state
Queuety::signal( $workflow_id, 'approved', [
    'approved_by' => 'admin@example.com',
] );

Üksikasju vaadake jaotisest Töövoo signaalid.

`Queuety::approve_workflow( $workflow_id, $data = [], $signal_name = 'approval' )`

Semantiline ümbris signal() ümber kinnitamise töövoogude jaoks.

PHP

Queuety::approve_workflow( $workflow_id, [
    'reviewer' => 'editor@example.com',
] );

`Queuety::reject_workflow( $workflow_id, $data = [], $signal_name = 'rejected' )`

Semantiline ümbris signal() ümber tagasilükkamise töövoogude jaoks.

PHP

Queuety::reject_workflow( $workflow_id, [
    'reason' => 'needs citations',
] );

`Queuety::submit_workflow_input( $workflow_id, $data = [], $signal_name = 'input' )`

Semantiline ümbris signal() ümber struktureeritud inimeste sisendi jaoks.

PHP

Queuety::submit_workflow_input( $workflow_id, [
    'notes' => 'Ship after legal review',
] );

`Queuety::put_artifact( $workflow_id, $artifact_key, $content, $kind = 'json', $step_index = null, $metadata = [] )`

Salvestage töövoo jaoks üks püsiv artefakt.

PHP

Queuety::put_artifact(
    $workflow_id,
    'research_brief',
    [ 'summary' => 'done' ],
    'json',
    metadata: [ 'source' => 'agent' ],
);

`Queuety::put_current_artifact( $artifact_key, $content, $kind = 'json', $metadata = [] )`

Salvestage parajasti täidetava töövoo sammu jaoks üks artefakt.

PHP

Queuety::put_current_artifact(
    'draft',
    [ 'status' => 'ready' ],
    'json',
);

`Queuety::workflow_artifact( $workflow_id, $artifact_key )`

Hankige töövoo üks salvestatud artefakt.

PHP

$artifact = Queuety::workflow_artifact( $workflow_id, 'draft' );

`Queuety::workflow_artifacts( $workflow_id, $include_content = false )`

Loetlege töövoo artefaktid.

PHP

$artifacts = Queuety::workflow_artifacts( $workflow_id );

`Queuety::delete_workflow_artifact( $workflow_id, $artifact_key )`

Kustutage töövoo üks artefakt.

PHP

Queuety::delete_workflow_artifact( $workflow_id, 'draft' );

Olekumasinad

`Queuety::machine( $name )`

Alustage olekumasina koostamist. Tagastab StateMachineBuilder.

PHP

use Queuety\Enums\StateMachineStatus;

$machine_id = Queuety::machine( 'agent_session' )
    ->state( 'awaiting_user' )
    ->on( 'user_message', 'planning' )
    ->state( 'planning' )
    ->action( PlanSessionAction::class )
    ->on( 'planned', 'completed' )
    ->state( 'completed', StateMachineStatus::Completed )
    ->dispatch( [ 'thread_id' => 42 ] );

`StateMachineBuilder` meetodid

Meetod	Kirjeldus
`initial( string $state_name )`	Määrab algoleku sõnaselgelt.
`state( string $state_name, ?StateMachineStatus $terminal_status = null )`	Alustab ühe oleku seadistamist.
`action( string\|array $action_class )`	Registreerib praeguse oleku järjekorda pandava sisenemistoimingu. Edastage klassi nimi või struktureeritud määratlus väljadega `class`, `payload` ja `config`; `payload` jõuab `StateAction::handle()`-ni väärtusena `$payload`.
`on( string $event, string $target, string\|array\|null $guard_class = null, ?string $name = null )`	Registreerib praegusest olekust ühe sündmusepõhise ülemineku. Tingimus aktsepteerib sama struktureeritud vormi nagu `action()`.
`on_queue( string $queue )`	Määrab järjekorra, mida kasutatakse järjekorda pandavate olekutoimingute jaoks.
`with_priority( Priority $priority )`	Määrab järjekorda pandavate olekutoimingute prioriteedi.
`max_attempts( int $max_attempts )`	Määrab järjekorda pandavate olekutoimingute korduskatsete piirangu.
`version( string $version )`	Märgistab masina definitsiooni rakendustaseme versiooniga.
`idempotency_key( string $key )`	Muudab väljakutsuja antud võtme jaoks väljasaatmise püsivaks. Sama võtmega uuesti väljasaatmisel tagastatakse algne masina ID.
`dispatch( array $initial_state = [] )`	Saadab masina välja ja tagastab masina ID.

Olekusse sisenemise toimingute klassid võivad määratleda ka valikulise meetodi config(), millel on samad ressursipoliitika võtmed, mida toetavad töövoo sammud: concurrency_group, concurrency_limit ja cost_units.

`Queuety::dispatch_state_machine_definition( $definition, $initial_state = [], $options = [] )`

Saatke serialiseeritud olekumasina definitsiooni pakett välja. Enamik rakendusekoodist peaks eelistama machine()->dispatch(). See madalama taseme meetod on mõeldud adapteritele, et need saaksid masina käivitada ilma koostajast sõltumata.

PHP

$machine_id = Queuety::dispatch_state_machine_definition(
    $definition,
    [ 'thread_id' => 42 ],
    [ 'idempotency_key' => 'thread:42' ],
);

`Queuety::machine_status( $machine_id )`

Hankige masina praegune olek. Tagastab objekti StateMachineState või null.

PHP

$status = Queuety::machine_status( $machine_id );

echo $status->name;               // 'agent_session'
echo $status->status->value;      // 'waiting_event'
echo $status->current_state;      // 'awaiting_review'
print_r( $status->state );        // public machine state
print_r( $status->available_events ); // valid incoming events in the current state

StateMachineState pakub ka järgmist:

definition_version
definition_hash
idempotency_key
error_message
current_action
terminal_status

`Queuety::machine_event( $machine_id, $event_name, $payload = [] )`

Saatke ootavale masinale üks väline sündmus.

PHP

Queuety::machine_event(
    $machine_id,
    'approve',
    [
        'approved' => true,
        'reviewer' => 'editor@example.com',
    ]
);

Koormusandmed on üleminekutingimustele kättesaadavad ning sündmuse vastuvõtmisel ühendatakse need masina avaliku olekuga.

`Queuety::list_machines( $limit = 50, $status = null )`

Loetlege säilitatud masina kirjed kontrollimiseks.

PHP

$machines = Queuety::list_machines();
$waiting  = Queuety::list_machines( status: 'waiting_event' );

Iga rida sisaldab masina ID-d, nime, olekut, praegust olekut, definitsiooni versiooni, definitsiooni räsi, idempotentsusvõtit ja elutsükli ajatemplid.

`Queuety::machine_timeline( $machine_id, $limit = 100, $offset = 0 )`

Hankige ühe masina püsivate sündmuste ajajoon.

PHP

$timeline = Queuety::machine_timeline( $machine_id );
$page_two = Queuety::machine_timeline( $machine_id, 100, 100 );

Iga sündmuserida sisaldab järgmist: id, machine_id, job_id, state_name, handler, event, event_name, transition_name, queue, attempt, input, output, state_before, state_after, context, artifacts, chunks, error, duration_ms ja created_at.

`Queuety::machine_trace( $machine_id )`

Hankige olekumasina siluri jaoks normaliseeritud jäljepakett UI.

PHP

$trace = Queuety::machine_trace( $machine_id );

Jälg sisaldab järgmist: machine, rühmitatud states, töötlemata events, korreleeritud toimingu jobs, logs, artifacts ja chunks.

`Queuety::machine_state_at( $machine_id, $event_id )`

Hankige avalik olek pärast konkreetset masina jäljesündmust või null, kui seda ei leitud.

PHP

$state = Queuety::machine_state_at( $machine_id, $event_id );

Elutsükli mudeli ja kasutusmustrite kohta vaadake jaotist Olekumasinad.

Töövoomallid

`Queuety::define_workflow( $name )`

Looge mallina kasutatav töövoo koostaja.

PHP

$builder = Queuety::define_workflow( 'onboarding' )
    ->then( CreateAccountHandler::class )
    ->then( SendWelcomeEmailHandler::class );

`Queuety::register_workflow_template( $builder )`

Registreerige töövoomall.

PHP

Queuety::register_workflow_template( $builder );

`Queuety::run_workflow( $name, $payload, $options = [] )`

Saatke registreeritud töövoomall nime järgi välja. Tagastab töövoo ID.

PHP

$workflow_id = Queuety::run_workflow( 'onboarding', [ 'email' => 'user@example.com' ] );

$workflow_id = Queuety::run_workflow(
    'onboarding',
    [ 'email' => 'user@example.com' ],
    [ 'idempotency_key' => 'onboarding:user@example.com' ],
);

Tekitab erindi RuntimeException, kui mall pole registreeritud.

`Queuety::dispatch_workflow_definition( $definition, $payload, $options = [] )`

Saatke töövoog käitusaja definitsioonipaketist välja.

Enamik rakendusekoodist peaks eelistama run_workflow() või workflow()->dispatch(). See madalama taseme meetod võimaldab korduvkasutatavatel adapteritel saata serialiseeritud töövookirjelduse välja ilma sisemistest töövoohalduri meetoditest sõltumata.

PHP

$workflow_id = Queuety::dispatch_workflow_definition(
    $definition,
    [ 'email' => 'user@example.com' ],
    [ 'idempotency_key' => 'onboarding:user@example.com' ],
);

`Queuety::on_action( $hook, $workflow, $map = null, $when = null, $idempotency_key = null, $priority = 10, $accepted_args = null )`

Registreerige WordPress toiming, mis saadab töövoo välja.

PHP

Queuety::on_action(
    'save_post',
    workflow: 'content_review',
    map: static fn ( int $post_id, object $post, bool $update ): array => [
        'post_id' => $post_id,
        'post_type' => $post->post_type,
        'update' => $update,
    ],
    when: static fn ( int $post_id, object $post ): bool => 'post' === $post->post_type,
    idempotency_key: static fn ( int $post_id ): string => "save_post:{$post_id}",
);

$workflow võib olla üks järgmistest:

registreeritud töövoomalli nimi
tekstisisene WorkflowBuilder

map, when ja idempotency_key käitatakse sünkroonselt praeguse WordPress päringu jooksul. Ainult töövoo etapid käitatakse pärast väljasaatmist asünkroonselt.

Täielikku juhendit vaadake jaotisest Toimingupäästikud.

`Queuety::workflow_templates()`

Hankige töövoomallide register.

PHP

$registry = Queuety::workflow_templates();
$template = $registry->get( 'onboarding' ); // WorkflowTemplate or null

`Queuety::load_workflows( $directory, $recursive )`

Laadige kataloogist kõik töövoofailid ja registreerige need. Iga fail .php peaks tagastama WorkflowBuilder. Tagastab registreeritud töövoogude arvu.

PHP

$count = Queuety::load_workflows( __DIR__ . '/workflows/' );
$count = Queuety::load_workflows( __DIR__ . '/workflows/', recursive: true );

`Queuety::load_workflow_file( $file_path )`

Laadige ja registreerige üks töövoofail. Tagastab WorkflowTemplate või null, kui fail ei tagasta koostajat.

PHP

$template = Queuety::load_workflow_file( __DIR__ . '/workflows/onboard-user.php' );

Ajastamine

`Queuety::schedule( $handler, $payload )`

Looge korduv ajakava. Tagastab koostaja PendingSchedule.

PHP

Queuety::schedule( 'cleanup_handler' )
    ->every( '1 hour' )
    ->on_queue( 'maintenance' );

Queuety::schedule( 'nightly_report' )
    ->cron( '0 3 * * *' )
    ->on_queue( 'reports' );

`PendingSchedule` meetodid

Meetod	Kirjeldus
`every( string $interval )`	Määrab intervalliväljendi (e.g, `1 hour`, `30 minutes`)
`cron( string $expression )`	Määrab 5-väljalise cron-avaldise
`overlap( OverlapPolicy $policy )`	Määrab kattumise poliitika (vaikimisi: `Allow`). Vaadake Ajastamine.
`on_queue( string $queue )`	Määrab sihtjärjekorra (vaikimisi: `default`)
`id()`	Sunnib väljasaatmise ja tagastab ajakava ID

`Queuety::scheduler()`

Hankige sisemine Scheduler eksemplar.

PHP

$scheduler = Queuety::scheduler();
$schedules = $scheduler->list();
$scheduler->remove( 'handler_name' );
$count = $scheduler->tick(); // manually trigger

Käitlejate registreerimine

`Queuety::register( $name, $class )`

Registreerige käitlejaklass nime all.

PHP

Queuety::register( 'send_email', SendEmailHandler::class );

`Queuety::discover_handlers( $directory, $namespace )`

Avastage kataloogist automaatselt käitlejaklassid ja registreerige need. Tagastab registreeritud käitlejate arvu.

PHP

$count = Queuety::discover_handlers( __DIR__ . '/handlers', 'MyPlugin\\Handlers' );

`Queuety::registry()`

Hankige käitlejate register.

PHP

$registry = Queuety::registry();

Vaadeldavus

`Queuety::logger()`

Hankige logikirjete pärimiseks Logger eksemplar.

PHP

$logger = Queuety::logger();
$logs   = $logger->for_job( 42 );
$logs   = $logger->for_workflow( 7 );
$logs   = $logger->for_handler( 'send_email', 50 );
$logs   = $logger->for_event( LogEvent::Failed, 50 );
$logs   = $logger->since( new \DateTimeImmutable( '-1 hour' ), 100 );
$count  = $logger->purge( 30 );

`Queuety::metrics()`

Hankige Metrics eksemplar.

PHP

$stats = Queuety::metrics()->handler_stats( 60 ); // last 60 minutes

`Queuety::webhook_notifier()`

Hankige WebhookNotifier eksemplar.

PHP

$notifier = Queuety::webhook_notifier();
$id       = $notifier->register( 'job.buried', 'https://hooks.slack.com/...' );
$webhooks = $notifier->list();
$notifier->remove( $id );

`Queuety::rate_limiter()`

Hankige RateLimiter eksemplar.

PHP

$limiter = Queuety::rate_limiter();
$limiter->register( 'call_openai', 60, 60 );

Vahemälu

`Queuety::cache()`

Hankige aktiivse vahemälu taustsüsteemi eksemplar.

PHP

$cache = Queuety::cache();
$cache->set( 'my_key', 'my_value', 60 );
$value = $cache->get( 'my_key' );

`Queuety::set_cache( $cache )`

Asendage vahemälu taustsüsteem. Kohandatud teostuse kasutamiseks helistage sellele enne Queuety::init().

PHP

Queuety::set_cache( new RedisCache() );
Queuety::init( $connection );

`QUEUETY_CACHE_TTL`

Vahemälu vaike-TTL sekundites (vaikimisi: 5). Muutke sisemiste vahemälutoimingute vaikimisi TTL-i, määrates selle konstandi failis wp-config.php.

PHP

define( 'QUEUETY_CACHE_TTL', 10 );

Taustsüsteemide ja automaattuvastuse kohta vaadake jaotist Vahemällu salvestamine.

Olekumasina sündmuslogi

`Queuety::machine_events()`

Hankige StateMachineEventLog eksemplar.

PHP

$log = Queuety::machine_events();

Töövoo sündmuslogi

`Queuety::workflow_events()`

Hankige WorkflowEventLog eksemplar.

PHP

$log = Queuety::workflow_events();

`Queuety::workflow_timeline( $workflow_id, $limit = 100, $offset = 0 )`

Hankige töövoo sündmuste täielik ajajoon. Tagastab sündmuseridade massiivi ID järgi järjestatuna.

PHP

$events = Queuety::workflow_timeline( $workflow_id );
$next   = Queuety::workflow_timeline( $workflow_id, 100, 100 );

Iga sündmuserida sisaldab järgmist: id, workflow_id, job_id, parent_event_id, step_index, step_name, step_type, handler, event, queue, attempt, input, output, state_before, state_after, context, artifacts, chunks, error, error_message (kopeeritud väärtusest error.message), duration_ms ja created_at.

`Queuety::workflow_trace( $workflow_id )`

Hankige töövoo siluri jaoks normaliseeritud jäljepakett UI.

PHP

$trace = Queuety::workflow_trace( $workflow_id );

Jälg sisaldab järgmist: workflow, rühmitatud steps, töötlemata events, jobs, logs, artifacts, chunks, signals ja wait_dependencies.

`Queuety::trace_input( $input )`

Määrake praegu täidetava töövoosammu rakendustaseme sisend.

`Queuety::trace_output( $output )`

Määrake praegu täidetava töövoosammu rakendustaseme väljund.

`Queuety::trace_context( array $context )`

Ühendage praegu täidetava töövoosammu konteksti rakendustaseme andmed.

`Queuety::workflow_state_at( $workflow_id, $step_index )`

Hankige avalik olek pärast konkreetse töövoosammu lõpetamist või jätkamist või null, kui seda ei leitud.

PHP

$state = Queuety::workflow_state_at( $workflow_id, 2 );

Kasutusjuhtude ja käskude CLI kohta vaadake jaotist Töövoo sündmuslogi.

Sisemised eksemplarid

Need meetodid tagastavad sisemised eksemplarid täpsemate kasutusjuhtude jaoks.

Meetod	Tagastab	Kirjeldus
`Queuety::queue()`	`Queue`	Järjekorratoimingud (hõivamine, vabastamine, matmine)
`Queuety::worker()`	`Worker`	Töölisprotsessi juhtimine
`Queuety::workflow_manager()`	`Workflow`	Töövoo korraldamine
`Queuety::machines()`	`StateMachine`	Olekumasina elutsükli haldus
`Queuety::connection()`	`Connection`	Andmebaasiühendus
`Queuety::batch_manager()`	`BatchManager`	Pakktöötluse elutsükli haldus (tühistamine, kärpimine)
`Queuety::chunk_store()`	`ChunkStore`	Tükkide säilitamine voogedastuse sammude jaoks
`Queuety::machine_events()`	`StateMachineEventLog`	Olekumasina jäljesündmused ja normaliseeritud jäljepaketid
`Queuety::workflow_events()`	`WorkflowEventLog`	Töövoo jäljesündmused ja normaliseeritud jäljepaketid
`Queuety::resource_manager()`	`ResourceManager`	Töölise vastuvõtuprofiilid, kaalutud eelarved ja süsteemimälu kontroll
`Queuety::cache()`	`Cache`	Vahemälu taustsüsteemi eksemplar

Testimine

`Queuety::fake()`

Asendage järjekord testimiseks mälusisese teeseldud järjekorraga. Tagastab eksemplari QueueFake, mis salvestab väljasaatmised ilma andmebaasi kasutamata. create_batch() salvestab ka teeseldud pakktöötluse metaandmed; ahelaid kontrollitakse nende väljastatud üksikute järjekorda pandud tööde põhjal.

PHP

$fake = Queuety::fake();
SendEmailJob::dispatch( 'user@example.com', 'Hello', 'Hi!' );
$fake->assert_pushed( SendEmailJob::class );

`Queuety::reset()`

Lähtestage kogu sisemine olek, sealhulgas järjekorra teeseldud objekt. Kutsuge see funktsioonis tearDown().

PHP

Queuety::reset();

`QueueFake` meetodid

Meetod	Kirjeldus
`assert_pushed( string $class, ?Closure $callback )`	Kinnitab, et töökäsk lükati järjekorda. Valikuline tagasihelistusfunktsioon filtreerib tööandmete järgi.
`assert_pushed_times( string $class, int $count )`	Kinnitab, et töö lükati järjekorda täpselt N korda.
`assert_not_pushed( string $class )`	Kinnitab, et tööd ei pandud kordagi järjekorda.
`assert_nothing_pushed()`	Kinnitab, et järjekorda ei pandud üldse ühtegi tööd.
`assert_batched( ?Closure $callback )`	Kinnitab, et pakktöö saadeti välja. Valikuline tagasihelistusfunktsioon filtreerib pakktöö andmete järgi.
`pushed( string $class )`	Hangi kõik salvestatud klassi väljasaatmised massiivina.
`batches()`	Hangi kõik salvestatud pakktööd massiivina.
`reset()`	Kustuta kõik salvestatud tööd ja pakktööd.

Täielikke näiteid vaadake jaotisest Testimine.

Liidesed

`Handler`

Liides lihtsate töökäskude käitlejatele.

PHP

interface Handler {
    public function handle( array $payload ): void;
    public function config(): array;
}

config() võib tagastada väärtused queue, max_attempts, backoff, rate_limit, concurrency_group, concurrency_limit ja cost_units.

`Step`

Liides töövoosammude käitlejatele.

PHP

interface Step {
    public function handle( array $state ): array;
    public function config(): array;
}

config() võib tagastada väärtused max_attempts, backoff, concurrency_group, concurrency_limit ja cost_units.

`Contracts\ForEachHandler`

Liides dünaamiliste for-each-haru käitlejatele.

PHP

namespace Queuety\Contracts;

interface ForEachHandler {
    public function handle_item( array $state, mixed $item, int $index ): array;
    public function config(): array;
}

config() võib tagastada väärtused max_attempts, backoff, rate_limit, concurrency_group, concurrency_limit ja cost_units.

`Contracts\ForEachReducer`

for-each-tulemuste valikuline taandaja.

PHP

namespace Queuety\Contracts;

interface ForEachReducer {
    public function reduce( array $state, array $for_each ): array;
}

`Contracts\Compensation`

Liides sammu kompenseerimiskäitlejatele.

PHP

namespace Queuety\Contracts;

interface Compensation {
    public function handle( array $state ): void;
}

`Contracts\RepeatCondition`

Liides tsüklipredikaatidele, mida kasutavad repeat_until() ja repeat_while(), kui olekuvõtme võrdlusest ei piisa.

PHP

namespace Queuety\Contracts;

interface RepeatCondition {
    public function matches( array $state ): bool;
}

`Contracts\StateAction`

Liides järjekorda pandavatele olekusse sisenemise toimingutele.

PHP

namespace Queuety\Contracts;

interface StateAction {
    public function handle( array $state, ?string $event = null, array $event_payload = [], array $payload = [] ): array|string;
}

$payload kannab toimingu määratlusest pärit struktureeritud payload, kui masin määratleti sellisega. Tagastage avaliku oleku uuendused. Lisage _event ja soovi korral _event_payload, kui toiming peaks kohe ülemineku tegema.

Olekutoimingud võivad määratleda ka valikulise meetodi config(). Queuety loeb sellest väärtused concurrency_group, concurrency_limit ja cost_units, kui sisenemistoiming pannakse järjekorda.

`Contracts\StateGuard`

Liides olekumasina üleminekutingimustele.

PHP

namespace Queuety\Contracts;

interface StateGuard {
    public function allows( array $state, array $event_payload, string $event, array $payload = [] ): bool;
}

`Contracts\Job`

Liides iseseisvatele, väljastatavatele töökäskude klassidele. Töökäskude klassid kapseldavad oma koormusandmed avalike omadustena ja täitmisloogika meetodis handle().

PHP

namespace Queuety\Contracts;

interface Job {
    public function handle(): void;
}

Töökäskude klassid võivad soovi korral määratleda meetodi middleware(), mis tagastab eksemplaride Contracts\Middleware massiivi.

`Contracts\Cache`

Liides vahemälu taustsüsteemidele. Sisseehitatud teostuste ja kohandatud taustsüsteemide kohta vaadake jaotist Vahemällu salvestamine.

PHP

namespace Queuety\Contracts;

interface Cache {
    public function get( string $key ): mixed;
    public function set( string $key, mixed $value, int $ttl = 0 ): void;
    public function delete( string $key ): void;
    public function has( string $key ): bool;
    public function add( string $key, mixed $value, int $ttl = 0 ): bool;
    public function flush(): void;
}

Meetod	Tagastab	Kirjeldus
`get( $key )`	`mixed`	Hangib väärtuse. Tagastab `null`, kui väärtust ei leitud või see on aegunud.
`set( $key, $value, $ttl )`	`void`	Salvestab väärtuse. TTL 0 tähendab, et aegumist pole.
`delete( $key )`	`void`	Eemaldab väärtuse.
`has( $key )`	`bool`	Kontrollib, kas võti on olemas ega ole aegunud.
`add( $key, $value, $ttl )`	`bool`	Aatomiline sea-kui-puudub toiming. Tagastab `true`, kui väärtus seati.
`flush()`	`void`	Eemaldab vahemälust kõik üksused.

`WorkflowEventLog`

Salvestab töövoosammude üleminekud koos täieliku jäljekontekstiga. Kasutage Queuety::workflow_events() kaudu.

Meetod	Tagastab	Kirjeldus
`record_event( array $event )`	`void`	Salvestab töötlemata jäljesündmuse
`record_step_started( ... )`	`void`	Salvestab sündmuse step_started koos sisendi ja täitmiseelse olekuga
`record_step_completed( ... )`	`void`	Salvestab sündmuse step_completed koos sisendi, väljundi ning täitmiseelse ja -järgse olekuga
`record_step_failed( ... )`	`void`	Salvestab sündmuse step_failed koos jäljekonteksti ja struktureeritud tõrke üksikasjadega
`get_timeline( int $workflow_id, ?int $limit = 100, int $offset = 0 )`	`array`	Hangib töövoo jäljesündmused järjestatult koos valikulise lehitsemisega
`get_trace( int $workflow_id )`	`array`	Hangib normaliseeritud jäljepaketi
`get_state_at_step( int $workflow_id, int $step_index )`	`array\|null`	Hangib avaliku oleku pärast konkreetse sammu lõpetamist või jätkamist
`prune( int $older_than_days )`	`int`	Kustutab sündmused, mis on etteantud päevade arvust vanemad. Tagastab kustutatud ridade arvu.

`StateMachineEventLog`

Salvestab olekumasina elutsükli, toimingu, ülemineku ja tingimuse sündmused samade jäljeväljadega nagu töövoosündmused.

Meetod	Tagastab	Kirjeldus
`record_event( array $event )`	`void`	Salvestab töötlemata masina jälje sündmuse
`get_timeline( int $machine_id, ?int $limit = 100, int $offset = 0 )`	`array`	Hangib masina jälje sündmused järjekorras, soovi korral lehekülgede kaupa
`get_trace( int $machine_id )`	`array`	Hangib normaliseeritud masina jälje komplekti
`get_state_at_event( int $machine_id, int $event_id )`	`array\|null`	Hangib avaliku oleku pärast kindlat masina jälje sündmust
`prune( int $older_than_days )`	`int`	Kustutab määratud arvust päevadest vanemad sündmused. Tagastab kustutatud read.

`Contracts\StreamingStep`

Töövoo sammude töötlejate liides, mis väljastavad tükkide voo. Iga väljastatud väärtus salvestatakse kohe andmebaasi. Vt Voogedastuse sammud.

PHP

namespace Queuety\Contracts;

interface StreamingStep {
    public function stream( array $state, array $existing_chunks = [] ): \Generator;
    public function on_complete( array $chunks, array $state ): array;
    public function config(): array;
}

Meetod	Kirjeldus
`stream( $state, $existing_chunks )`	Generaator, mis väljastab stringitükke. Iga väljastamise järel kirjutatakse andmebaasi kohe. Uuesti proovimisel sisaldab `$existing_chunks` varem salvestatud tükke.
`on_complete( $chunks, $state )`	Käivitatakse pärast voo lõppu. Tagastab andmed, mis liidetakse töövoo olekuga.
`config()`	Valikuline konfiguratsioon. Toetab väärtusi `max_attempts`, `backoff`, `concurrency_group`, `concurrency_limit` ja `cost_units`.

`ChunkStore`

Haldab voogedastuse sammude tükkide salvestamist. Juurdepääsuga Queuety::chunk_store().

Meetod	Tagastab	Kirjeldus
`get_chunks( int $job_id )`	`string[]`	Hangib kõik töö tükid tükiindeksi järgi järjestatuna
`append_chunk( int $job_id, int $chunk_index, string $content, ?int $workflow_id, ?int $step_index )`	`void`	Lisab ühe tüki
`clear_chunks( int $job_id )`	`void`	Kustutab kõik töö tükid
`chunk_count( int $job_id )`	`int`	Loendab töö tükid
`get_accumulated( int $job_id )`	`string`	Ühendab kõik tükid üheks stringiks

`Heartbeat`

Staatiline abimeetod tegevuse elusolekusignaalide saatmiseks sammutöötlejate ja voogedastuse sammude seest. Vt Elusolekusignaalid.

Meetod	Kirjeldus
`Heartbeat::init( int $job_id, Connection $conn )`	Määrab töö konteksti. Töötaja kutsub selle automaatselt.
`Heartbeat::beat( array $progress = [] )`	Saadab elusolekusignaali. Uuendab väärtust `reserved_at` ja salvestab soovi korral edenemisandmed väärtusse `heartbeat_data`.
`Heartbeat::clear()`	Tühjendab töö konteksti. Töötaja kutsub selle automaatselt.
`Heartbeat::current_job_id()`	Hangib praeguse töö ID (testimiseks).

`Contracts\Middleware`

Töö vahevara liides. Vahevara ümbritseb töö täitmist sibulakujulise konveierina.

PHP

namespace Queuety\Contracts;

interface Middleware {
    public function handle( object $job, \Closure $next ): void;
}

Omadused

`Dispatchable`

Pakub staatilisi väljakutsemeetodeid tööklassidele, mis rakendavad liidest Contracts\Job. Konstruktorile antud argumendid edastatakse töö eksemplari loomiseks.

PHP

use Queuety\Contracts\Job;
use Queuety\Dispatchable;

class SendEmailJob implements Job {
    use Dispatchable;
    // ...
}

// Dispatches a new SendEmailJob instance
SendEmailJob::dispatch( 'user@example.com', 'Subject', 'Body' );

Meetod	Tagastab	Kirjeldus
`dispatch( ...$args )`	`PendingJob`	Loob eksemplari ja saadab selle täitmisele
`dispatch_if( bool $condition, ...$args )`	`PendingJob\|null`	Saadab töö täitmisele ainult siis, kui `$condition` on tõene
`dispatch_unless( bool $condition, ...$args )`	`PendingJob\|null`	Saadab töö täitmisele ainult siis, kui `$condition` on väär
`with_chain( array $jobs )`	`ChainBuilder`	Alustab selle tööklassiga tööde ahela

PHP

// Conditional dispatch
SendEmailJob::dispatch_if( $user->wants_email, $user->email, 'Hello', 'Hi!' );
SendEmailJob::dispatch_unless( $maintenance_mode, $user->email, 'Hello', 'Hi!' );

// Chain from a job class
FetchDataJob::with_chain( [
    new ProcessDataJob(),
    new NotifyCompleteJob(),
] )->dispatch();

Töö omadused

Tööklassid saavad deklareerida avalikke omadusi, mida töötaja loeb refleksiooni abil, et alistada uuestiproovimise ja ajalõpu käitumist.

Omadus	Tüüp	Kirjeldus
`$tries`	`int`	Maksimaalne katsete arv, enne kui töö maetakse
`$timeout`	`int`	Täitmise maksimaalne kestus sekundites (vajab `pcntl`)
`$backoff`	`array`	Iga uuestiproovimise katse kasvavad viiteajad sekundites

PHP

class ImportProductsJob implements Job {
    use Dispatchable;

    public int $tries = 5;
    public int $timeout = 120;
    public array $backoff = [ 10, 30, 60, 120 ];

    // ...
}

`failed()` konks

Kui töö maetakse pärast kõigi uuestiproovimise katsete ammendumist, kutsub töötaja töö eksemplaril meetodi failed(), kui see on määratletud.

PHP

public function failed( \Throwable $exception ): void {
    error_log( "Job failed: {$exception->getMessage()}" );
}

Sisseehitatud vahevara

Kõik vahevara klassid rakendavad liidest Contracts\Middleware ja asuvad nimeruumis Queuety\Middleware.

Klass	Kirjeldus
`RateLimited( int $max, int $window )`	Jõustab kiirusepiirangu: `$max` täitmist iga `$window` sekundi jooksul
`Timeout( int $seconds )`	Katkestab töö pärast `$seconds` sekundit (vajab `pcntl`)
`UniqueJob( ?string $key )`	Takistab samaaegset täitmist andmebaasiluku abil
`WithoutOverlapping( string $key, int $release_after )`	Takistab kattuvat täitmist, aegudes luku automaatselt
`ThrottlesExceptions( int $max_attempts, int $decay_minutes )`	Piirab erandite hulka, et väline teenus ei põhjustaks tööde tulva

Kasutuse üksikasju ja näiteid vt jaotisest Vahevara.

Enumid

`Priority`

PHP

enum Priority: int {
    case Low    = 0;
    case Normal = 1;
    case High   = 2;
    case Urgent = 3;
}

`JobStatus`

PHP

enum JobStatus: string {
    case Pending    = 'pending';
    case Processing = 'processing';
    case Completed  = 'completed';
    case Failed     = 'failed';
    case Buried     = 'buried';
}

`WorkflowStatus`

PHP

enum WorkflowStatus: string {
    case Running        = 'running';
    case Completed      = 'completed';
    case Failed         = 'failed';
    case Paused         = 'paused';
    case WaitingForSignal  = 'waiting_for_signal';
    case WaitingForWorkflows = 'waiting_for_workflows';
    case Cancelled      = 'cancelled';
}

`StateMachineStatus`

PHP

enum StateMachineStatus: string {
    case Running = 'running';
    case WaitingEvent = 'waiting_event';
    case Completed = 'completed';
    case Failed = 'failed';
    case Paused = 'paused';
    case Cancelled = 'cancelled';
}

`BackoffStrategy`

PHP

enum BackoffStrategy: string {
    case Fixed       = 'fixed';
    case Linear      = 'linear';
    case Exponential = 'exponential';
}

`ForEachMode`

PHP

enum ForEachMode: string {
    case All = 'all';
    case FirstSuccess = 'first_success';
    case Quorum = 'quorum';
}

`WaitMode`

PHP

enum WaitMode: string {
    case All    = 'all';
    case Any    = 'any';
    case Quorum = 'quorum';
}

`LogEvent`

PHP

enum LogEvent: string {
    case Started                  = 'started';
    case Completed                = 'completed';
    case Failed                   = 'failed';
    case Buried                   = 'buried';
    case Retried                  = 'retried';
    case WorkflowStarted          = 'workflow_started';
    case WorkflowCompleted        = 'workflow_completed';
    case WorkflowFailed           = 'workflow_failed';
    case WorkflowPaused           = 'workflow_paused';
    case WorkflowResumed          = 'workflow_resumed';
    case WorkflowCancelled        = 'workflow_cancelled';
    case WorkflowRewound          = 'workflow_rewound';
    case WorkflowForked           = 'workflow_forked';
    case WorkflowDeadlineExceeded = 'workflow_deadline_exceeded';
    case Debug                    = 'debug';
}

`OverlapPolicy`

PHP

enum OverlapPolicy: string {
    case Allow  = 'allow';
    case Skip   = 'skip';
    case Buffer = 'buffer';
}

Lisateavet iga poliitika toimimise kohta vt jaotisest Ajastamine.

Atribuudid

`#[QueuetyHandler]`

PHP 8 atribuut automaatseks registreerimiseks. Vt PHP atribuudid.

PHP

use Queuety\Attributes\QueuetyHandler;

#[QueuetyHandler( name: 'send_email', queue: 'emails', max_attempts: 5 )]
class SendEmailHandler implements Handler {
    // ...
}

CLI sild

`Queuety::cli_command()`

Tagastab avaldatud WP-CLI juurkäsu nime.

Vaikimisi juurkäsk on queuety. Määratlege QUEUETY_CLI_COMMAND enne Queuety käivitumist, kui käsk tuleb avaldada muu nime all.

`Queuety::cli_command_map()`

Tagastab serialiseeritava Queuety CLI kataloogi töökeskkondadele, mis peavad mõistma tarnitud käskude valikut ilma WP-CLI klasse läbi vaatamata.

Iga kirje sisaldab järgmist:

stabiilne toimingu ID
suhteline CLI tee
WP-CLI töötleja klass ja meetod
võimalikud täitmise sihtkohad
adapter, mis normaliseerib töötlemata CLI argumendid täitmisplaaniks

`Queuety::resolve_cli_command( $path, $args, $assoc_args )`

Teisendab parsitud CLI väljakutse täitmisplaaniks, mille töökeskkond peab käivitama.

PHP

$plan = Queuety::resolve_cli_command(
    [ 'workflow', 'export' ],
    [ '42' ],
    [ 'output' => '/tmp/workflow.json' ]
);

echo $plan['callable']; // Queuety\Queuety::export_workflow_to_file
print_r( $plan['arguments'] );

Täitmisplaanid arvestavad sihilikult edastusviisiga:

käsud lahendatakse avalikeks PHP väljakutsutavateks objektideks koos normaliseeritud argumentidega
kataloog loetleb kõik võimalikud täitmise sihtkohad ette, samas kui callable ja transport määravad parsitud sisendi jaoks valitud haru

See on standard, mida Queuety kasutavad agendi töökeskkondade jaoks: stabiilne toimingu ID, avalik API sihtkoht ja adapteri hallatav normaliseerimine CLI-iga seotud teemade jaoks, näiteks järjekorra vaikeväärtused, JSON koormuse dekodeerimine, töötajate kogumi harude valik ning töövoo ekspordifailide käsitlemine.

PHP API

Eraldiseisev juurdepääs tuumale

Queuety::init( Connection $conn )

Queuety::ensure_schema()

Tööd

Queuety::dispatch( $handler, $payload )

Meetodid PendingJob

Queuety::dispatch_sync( $handler, $payload )

Queuety::batch( $jobs )

Queuety::create_batch( $jobs )

Meetodid BatchBuilder

Queuety::find_batch( $id )

Töötajate juhtimine

Queuety::run_worker( $queue = 'default', $once = false )

Queuety::run_worker_pool( $workers, $queue = 'default' )

Queuety::run_auto_scaling_worker_pool( $min_workers, $max_workers, $queue = 'default' )

Väärtusobjekt Batch

Queuety::chain( $jobs )

Meetodid ChainBuilder

Queuety::retry( $job_id )

Queuety::retry_buried()

Queuety::purge( $older_than_days )

Järjekorrad

Queuety::stats( $queue )

Queuety::buried( $queue )

Queuety::pause( $queue )

Queuety::resume( $queue )

Queuety::is_paused( $queue )

Töövood

Queuety::workflow( $name )

Meetodid WorkflowBuilder

Queuety::workflow_status( $workflow_id )

Queuety::retry_workflow( $workflow_id )

Queuety::pause_workflow( $workflow_id )

Queuety::resume_workflow( $workflow_id )

Queuety::cancel_workflow( $workflow_id )

Queuety::rewind_workflow( $workflow_id, $to_step )

Queuety::fork_workflow( $workflow_id )

Queuety::export_workflow( $workflow_id )

Queuety::replay_workflow( $data )

Queuety::replace_wp_cron()

Queuety::restore_wp_cron()

Queuety::signal( $workflow_id, $name, $data )

Queuety::approve_workflow( $workflow_id, $data = [], $signal_name = 'approval' )

Queuety::reject_workflow( $workflow_id, $data = [], $signal_name = 'rejected' )

Queuety::submit_workflow_input( $workflow_id, $data = [], $signal_name = 'input' )

Queuety::put_artifact( $workflow_id, $artifact_key, $content, $kind = 'json', $step_index = null, $metadata = [] )

Queuety::put_current_artifact( $artifact_key, $content, $kind = 'json', $metadata = [] )

Queuety::workflow_artifact( $workflow_id, $artifact_key )

Queuety::workflow_artifacts( $workflow_id, $include_content = false )

Queuety::delete_workflow_artifact( $workflow_id, $artifact_key )