# Ajastamine

Queuety toetab korduvaid töid sisseehitatult. `wp_cron` asemel salvestatakse ajakavad andmebaasi ning pika käitusega `wp queuety work` protsess (või töötajate kogumi ülemprotsess) hindab neid umbes kord minutis. `wp queuety work --once`, `wp queuety flush` ega plugina sisseehitatud WP-Cron varuvariant ajakavasid ei hinda ([#14](https://github.com/inline0/queuety/issues/14)); kui pika käitusega töötajat pole, käivitage `wp queuety schedule run` ise.

## Intervallipõhine ajastamine

Lihtsate intervallipõhiste ajakavade jaoks kasutage `every()`. Avaldis võib olla mis tahes string, mis ühildub PHP `DateTimeImmutable::modify()`-iga:

```php
use Queuety\Queuety;

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

Queuety::schedule( 'sync_inventory' )
    ->every( '30 minutes' )
    ->on_queue( 'sync' );

Queuety::schedule( 'daily_report', [ 'type' => 'summary' ] )
    ->every( '1 day' );
```

## Cron-ajastamine

Tavaliste 5-väljaliste cron-avaldiste jaoks kasutage `cron()`:

```php
// Every day at 3am
Queuety::schedule( 'nightly_cleanup' )
    ->cron( '0 3 * * *' );

// Every Monday at 9am
Queuety::schedule( 'weekly_digest' )
    ->cron( '0 9 * * 1' )
    ->on_queue( 'emails' );

// Every 15 minutes
Queuety::schedule( 'health_check' )
    ->cron( '*/15 * * * *' );
```

## Ajakava valikud

`PendingSchedule` koostaja toetab järgmisi meetodeid:

| Meetod | Kirjeldus |
|---|---|
| `every( string $interval )` | Määra intervalliavaldis |
| `cron( string $expression )` | Määra cron-avaldis |
| `on_queue( string $queue )` | Määra sihtjärjekord (vaikimisi: `'default'`) |
| `overlap( OverlapPolicy $policy )` | Määra kattumise reegel (vaikimisi: `Allow`) |

Enne ajakava käivitamist tuleb kutsuda kas `every()` või `cron()`. Kui kumbagi pole määratud, visatakse `RuntimeException`.

## Kattumise reeglid

Kui ajastatud töö veel käib (ootel või töötlemisel), kui saabub järgmine käivitusaeg, määrab kattumise reegel, mis juhtub. Määrake see meetodiga `overlap()`:

```php
use Queuety\Queuety;
use Queuety\Enums\OverlapPolicy;

Queuety::schedule( 'sync_inventory' )
    ->every( '5 minutes' )
    ->overlap( OverlapPolicy::Skip )
    ->on_queue( 'sync' );
```

`OverlapPolicy`-loendis on kolm valikut:

| Reegel | Väärtus | Käitumine |
|---|---|---|
| `OverlapPolicy::Allow` | `allow` | Käivita alati uus töö, isegi kui eelmine käitus veel kestab. See on vaikevalik. |
| `OverlapPolicy::Skip` | `skip` | Jäta praegune käivituskord vahele, kui käsitlejal on ootel või töötlemisel töid. `next_run` uuendatakse tavapäraselt, et ajakava püsiks graafikus. |
| `OverlapPolicy::Buffer` | `buffer` | Sarnaselt valikule Skip tööd ei käivitata ja `next_run` liigub järgmise korrapärase käivituseni. Erinevalt valikust Skip ei uuendata `last_run`. |

### Allow (vaikimisi)

Sama käsitleja mitu eksemplari võivad töötada korraga. Kasutage seda idempotentsete käsitlejate puhul, kui kattumine pole probleem.

```php
Queuety::schedule( 'send_heartbeat_ping' )
    ->every( '1 minute' )
    ->overlap( OverlapPolicy::Allow );
```

### Skip

Kui käsitleja veel töötab, jäetakse käivituskord vaikselt vahele. Kasutage seda käsitlejate puhul, mille teise eksemplari käivitamine oleks raiskav või põhjustaks konflikte.

```php
Queuety::schedule( 'rebuild_search_index' )
    ->every( '10 minutes' )
    ->overlap( OverlapPolicy::Skip );
```

### Buffer

Praegu toimib samamoodi nagu Skip: kui käsitlejal on veel ootel või töötlemisel töö, siis seda käivituskorda ei käivitata ning `next_run` liigub järgmise korrapärase käivituseni. Ainus erinevus on see, et Buffer jätab `last_run` muutmata, samal ajal kui Skip märgib vahele jäetud käivituskorra viimaseks käivituseks.

```php
Queuety::schedule( 'sync_inventory' )
    ->every( '5 minutes' )
    ->overlap( OverlapPolicy::Buffer );
```

## Kuidas see töötab

Ajakava loomisel salvestab Queuety selle tabelisse `queuety_schedules` koos avaldise, käsitleja, payload’i ja järgmise arvutatud käitusajaga.

Iga ajastaja käivitustsükli ajal (pika käitusega töötajas umbes kord minutis või siis, kui käivitate `wp queuety schedule run`) kontrollib ajastaja, kas ajakavade `next_run` on möödunud. Iga tähtajaks saabunud ajakava puhul väljastab see uue töö ning uuendab väärtuse `next_run` järgmise käivituseni.

## Ajakavade haldamine käsuga CLI

```bash
# List all schedules
wp queuety schedule list

# Add a recurring schedule
wp queuety schedule add cleanup_handler --every="1 hour"
wp queuety schedule add nightly_report --cron="0 3 * * *" --queue=reports

# Remove a schedule
wp queuety schedule remove cleanup_handler

# Manually trigger the scheduler
wp queuety schedule run
```

## Ajakavade haldamine käsuga PHP

```php
// Get the scheduler instance
$scheduler = Queuety::scheduler();

// List all schedules
$schedules = $scheduler->list();

// Remove a schedule by handler name
$scheduler->remove( 'cleanup_handler' );

// Manually trigger a tick
$count = $scheduler->tick();
```

## Payload

Ajakavadele saab lisada staatilise payload’i, mis edastatakse igale käivitatud tööle:

```php
Queuety::schedule( 'generate_report', [ 'type' => 'daily', 'format' => 'pdf' ] )
    ->every( '1 day' )
    ->on_queue( 'reports' );
```

Iga kord, kui ajakava käivitub, väljastatakse selle payload’iga uus töö.