# Kom igång

## Installation

### Krav

- PHP 8.2 eller senare och WordPress 6.4 eller senare
- MySQL 8.0+ eller MariaDB 10.6+. Arbetare hämtar jobb och schemalagda uppgifter med `SELECT ... FOR UPDATE SKIP LOCKED`, vilket äldre servrar avvisar med ett syntaxfel.
- `mysqli` eller `pdo_mysql` (se nedan)
- WP-CLI på servern om du kör dedikerade arbetare med `wp queuety work`
- Tilläggen `pcntl` och `posix` PHP om du kör arbetarpooler med `--workers` eller `--min-workers`/`--max-workers`

Queuety kräver antingen `mysqli` eller `pdo_mysql` i körmiljön PHP som laddar WordPress och WP-CLI. Drivrutinen väljs automatiskt: `mysqli` föredras i körmiljöer för WordPress, medan `pdo_mysql` finns tillgängligt för fristående direkt användning av körmiljön.

Om du vill använda den databasbaserade körmiljön utan pluginlagret WordPress, se [Fristående användning](https://queuety.inline0.dev/sv/docs/features/standalone-use). Den använder samma anslutning och körtidstabeller, men innehåller inte hookbryggorna WordPress eller registreringen WP-CLI.

### Från versionsarkivet

Varje [GitHub-version](https://github.com/inline0/queuety/releases) har en `queuety.zip`-fil: pluginet med sina Composer-beroenden redan installerade. Installera den senaste med WP-CLI:

```bash
wp plugin install https://github.com/inline0/queuety/releases/latest/download/queuety.zip --activate
```

Du kan också hämta zip-filen och ladda upp den under Tillägg > Lägg till nytt > Ladda upp tillägg. Detta är den enklaste metoden för en vanlig WordPress-webbplats.

### Via Composer för Composer-hanterade WordPress

```bash
composer require queuety/queuety
```

Aktivera sedan pluginet:

```bash
wp plugin activate queuety
```

Pakettypen är `wordpress-plugin`. Composer placerar det endast i tilläggskatalogen när projektet kräver `composer/installers` och mappar den typen till en installationssökväg, som Bedrock gör, och projektet måste läsa in sin egen `vendor/autoload.php` (det gör även Bedrock). Utan `composer/installers` installerar Composer det i `vendor/queuety/queuety`, där WordPress inte hittar det, så använd versionsarkivet på en vanlig WordPress-installation.

### Från källkod under utveckling

Placera kodarkivet i `wp-content/plugins/queuety` och installera sedan beroendena för PHP:

```bash
composer install
wp plugin activate queuety
```

Vid aktivering skapar Queuety sina databastabeller (`queuety_jobs`, `queuety_workflows`, `queuety_logs`, `queuety_schedules`, `queuety_queue_states`, `queuety_webhooks`, `queuety_locks`, `queuety_signals`, `queuety_workflow_dependencies`, `queuety_workflow_dispatch_keys`, `queuety_batches`, `queuety_chunks`, `queuety_workflow_events`, `queuety_artifacts`, `queuety_state_machines`, `queuety_state_machine_events`) så att arbetare kan hämta jobb direkt från MySQL.

Som standard schemalägger tillägget också en engångsarbetare via WordPress cron varje minut för kön `default`. Det ger en grundlösning för jobb och arbetsflöden som inte kräver ett skal och som körs på `default`, så länge WordPress cron körs. Varje körning behandlar högst ett jobb och utlöser inte återkommande scheman, återställer inte inaktuella jobb och kontrollerar inte tidsgränser för arbetsflöden. De funktionerna körs bara i en långvarig `wp queuety work`-process ([#14](https://github.com/inline0/queuety/issues/14)). För anpassade köer, återkommande scheman, lägre fördröjning eller större arbetsbelastningar bör du använda dedikerade `wp queuety work`-processer.

## Konfiguration

Alla konstanter är valfria. Definiera dem i `wp-config.php` innan tillägget läses in, eller innan Queuety startar i en inbäddad installation av temastil:

| Konstant | Standard | Beskrivning |
|---|---|---|
| `QUEUETY_RETENTION_DAYS` | `7` | Standardålder i dagar för `wp queuety purge` och `Queuety::purge()`. Ingenting rensas automatiskt |
| `QUEUETY_LOG_RETENTION_DAYS` | `0` | Läses av `Config::log_retention_days()` men används ännu inte; loggar sparas tills du anropar `Queuety::purge_logs()` ([#15](https://github.com/inline0/queuety/issues/15)) |
| `QUEUETY_MAX_EXECUTION_TIME` | `300` | Högsta antal sekunder per jobb före timeout (tillämpas ännu inte, se [Jobb](https://queuety.inline0.dev/sv/docs/jobs#timeout)) |
| `QUEUETY_WORKER_SLEEP` | `1` | Sekunder att vänta när kön är tom |
| `QUEUETY_WORKER_MAX_JOBS` | `1000` | Högsta antal jobb innan arbetaren startas om |
| `QUEUETY_WORKER_MAX_MEMORY` | `128` | Högsta antal MB innan arbetaren startas om |
| `QUEUETY_RETRY_BACKOFF` | `exponential` | Backoff-strategi: `exponential`, `linear` eller `fixed` |
| `QUEUETY_STALE_TIMEOUT` | `600` | Sekunder innan jobb som fastnat återställs |
| `QUEUETY_CACHE_TTL` | `5` | Standardvärde för cache-TTL i sekunder |
| `QUEUETY_DEBUG` | `false` | Aktivera utförlig loggning för arbetaren |
| `QUEUETY_CLI_COMMAND` | `queuety` | Namn på rotkommandot WP-CLI |
| `QUEUETY_TABLE_PREFIX` | `queuety_` | Gemensamt basnamn för alla Queuety-tabeller efter DB-prefixet WordPress |
| `QUEUETY_TABLE_JOBS` | `queuety_jobs` | Namn på jobbtabel­len |
| `QUEUETY_TABLE_WORKFLOWS` | `queuety_workflows` | Namn på arbetsflödestabellen |
| `QUEUETY_TABLE_LOGS` | `queuety_logs` | Namn på loggtabellen |
| `QUEUETY_TABLE_SCHEDULES` | `queuety_schedules` | Namn på schematabellen |
| `QUEUETY_TABLE_SIGNALS` | `queuety_signals` | Namn på signaltabellen |
| `QUEUETY_TABLE_WORKFLOW_DEPENDENCIES` | `queuety_workflow_dependencies` | Namn på tabellen för väntande beroenden i arbetsflöden |
| `QUEUETY_TABLE_WORKFLOW_DISPATCH_KEYS` | `queuety_workflow_dispatch_keys` | Namn på tabellen för idempotens i beständiga arbetsflöden |
| `QUEUETY_TABLE_CHUNKS` | `queuety_chunks` | Namn på tabellen för strömningssegment |
| `QUEUETY_TABLE_QUEUE_STATES` | `queuety_queue_states` | Namn på tabellen för köstatus |
| `QUEUETY_TABLE_WEBHOOKS` | `queuety_webhooks` | Namn på webhook-tabellen |
| `QUEUETY_TABLE_LOCKS` | `queuety_locks` | Namn på låstabellen |
| `QUEUETY_TABLE_BATCHES` | `queuety_batches` | Namn på batchtabellen |
| `QUEUETY_TABLE_WORKFLOW_EVENTS` | `queuety_workflow_events` | Namn på arbetsflödets händelseloggstabell |
| `QUEUETY_TABLE_ARTIFACTS` | `queuety_artifacts` | Namn på arbetsflödets artefakttabell |
| `QUEUETY_TABLE_STATE_MACHINES` | `queuety_state_machines` | Namn på tillståndsmaskintabellen |
| `QUEUETY_TABLE_STATE_MACHINE_EVENTS` | `queuety_state_machine_events` | Namn på tillståndsmaskinens händelseloggstabell |
| `QUEUETY_DB_DRIVER` | `auto` | MySQL-drivrutin: `auto`, `mysqli` eller `pdo`. `auto` föredrar `mysqli` när WordPress är laddat, annars `pdo_mysql` och därefter `mysqli` |

Konstanter för resursantagning och adaptiv pool (`QUEUETY_RESOURCE_*`, `QUEUETY_WORKER_POOL_*`) finns på sidan [Arbetare](https://queuety.inline0.dev/sv/docs/features/workers).

`QUEUETY_TABLE_PREFIX` ändrar endast delen Queuety av tabellnamnen. Databasprefixet WordPress läggs fortfarande runt resultatet, så `$wpdb->prefix = 'wp_'` och `QUEUETY_TABLE_PREFIX = 'themequeue_'` skapar tabeller som `wp_themequeue_jobs`. Uttryckliga `QUEUETY_TABLE_*`-konstanter har fortfarande företräde för enskilda tabeller.

Fristående anslutningar kan också ange tabellprefixet Queuety per anslutning:

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

Det bevarar databasprefixet WordPress och ändrar endast tabellsegmentet Queuety.

## Ditt första jobb

Skapa en hanterarklass som implementerar gränssnittet `Handler`:

```php
use Queuety\Handler;

class SendEmailHandler implements Handler {
    public function handle( array $payload ): void {
        wp_mail( $payload['to'], $payload['subject'], $payload['body'] );
    }

    public function config(): array {
        return [
            'queue'           => 'emails',
            'max_attempts'    => 5,
        ];
    }
}
```

Registrera den och skicka iväg ett jobb:

```php
use Queuety\Queuety;

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

Queuety::dispatch( 'send_email', [
    'to'      => 'user@example.com',
    'subject' => 'Welcome',
    'body'    => 'Hello from Queuety!',
] );
```

Eller använd den moderna jobbklassen som kan skickas iväg:

```php
use Queuety\Contracts\Job;
use Queuety\Dispatchable;

readonly class SendEmailJob implements Job {
    use Dispatchable;

    public function __construct(
        public string $to,
        public string $subject,
        public string $body,
    ) {}

    public function handle(): void {
        wp_mail( $this->to, $this->subject, $this->body );
    }
}

SendEmailJob::dispatch( 'user@example.com', 'Welcome', 'Hello from Queuety!' );
```

## Ditt första arbetsflöde

Definiera steghanterare som implementerar gränssnittet `Step`:

```php
use Queuety\Step;

class FetchDataHandler implements Step {
    public function handle( array $state ): array {
        $user = get_user_by( 'ID', $state['user_id'] );
        return [ 'user_name' => $user->display_name ];
    }

    public function config(): array {
        return [];
    }
}

class CallLLMHandler implements Step {
    public function handle( array $state ): array {
        $response = wp_remote_post( 'https://api.openai.com/v1/chat/completions', [
            'body' => json_encode( [ 'prompt' => "Generate report for {$state['user_name']}" ] ),
        ] );
        return [ 'llm_response' => wp_remote_retrieve_body( $response ) ];
    }

    public function config(): array {
        return [ 'max_attempts' => 5 ];
    }
}

class FormatOutputHandler implements Step {
    public function handle( array $state ): array {
        $url = save_report( $state['user_name'], $state['llm_response'] );
        return [ 'report_url' => $url ];
    }

    public function config(): array {
        return [];
    }
}
```

Skicka iväg arbetsflödet:

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

## Starta en arbetare

```bash
wp queuety work
```

Arbetaren söker efter väntande jobb, kör dem, för arbetsflöden vidare och väntar när kön är tom. Tryck på `Ctrl+C` för att stoppa; processen avslutas omedelbart, även mitt under ett jobb (se [Arbetare](https://queuety.inline0.dev/sv/docs/features/workers#worker-lifecycle)).

`SendEmailHandler` ovan skickar sina jobb till kön `emails` via `config()`, så en arbetare på `default` hämtar dem inte. Ange namnet på varje kö du använder:

```bash
wp queuety work --queue=emails,default
```

Om du inte kör en dedikerad arbetare har Queuety fortfarande den tidigare beskrivna reservlösningen med WordPress cron en gång i minuten, begränsad till kön `default` och ett jobb per körning. Den dedikerade arbetaren ger högre genomströmning och lägre fördröjning.

Kör flera arbetare i produktion:

```bash
wp queuety work --workers=4
```

Bearbeta flera köer i prioritetsordning:

```bash
wp queuety work --queue=high,default,low
```

## Nästa steg

- [Jobb](https://queuety.inline0.dev/sv/docs/jobs) innehåller den fullständiga guiden till att skicka jobb och skriva hanterare
- [Arbetsflöden](https://queuety.inline0.dev/sv/docs/workflows) beskriver kedjor, parallella steg, villkorsstyrd förgrening och körning av arbetsflöden
- [Mellanprogram](https://queuety.inline0.dev/sv/docs/features/middleware) beskriver hastighetsbegränsning, strypning och anpassad pipeline-logik
- [Batchbearbetning](https://queuety.inline0.dev/sv/docs/features/batching) beskriver hur grupper av jobb skickas iväg med återanrop
- [Strömningssteg](https://queuety.inline0.dev/sv/docs/workflows/streaming) beskriver hur strömmade data sparas bit för bit
- [Schemaläggning](https://queuety.inline0.dev/sv/docs/features/scheduling) beskriver återkommande jobb
- [Cachelagring](https://queuety.inline0.dev/sv/docs/features/caching) beskriver det utbytbara cachelagret
- [Testning](https://queuety.inline0.dev/sv/docs/features/testing) beskriver QueueFake och testpåståenden
- [CLI Referens](https://queuety.inline0.dev/sv/docs/cli) innehåller alla tillgängliga kommandon
- [PHP API](https://queuety.inline0.dev/sv/docs/api) för programmatisk åtkomst