php-task

https://github.com/php-task/php-task
Admin
php-task is a task-library for synchronous and asynchronous tasks with support for task scheduling,...
Tokens:7,125
Snippets:32
Trust Score:4.4
License:MIT
Update:7 months ago
Show doc for...
Tokens:
Raw
### Custom Persistence Implementation Example

Source: https://context7.com/php-task/php-task/llms.txt

This example demonstrates how to use the default array-based storage repositories and outlines the process for creating custom repositories for persistent storage.

```APIDOC
## Storage Repositories - Custom Persistence

The library provides array-based storage implementations out of the box, but you can implement your own repositories to use databases like MySQL, PostgreSQL, or Redis.

### In-Memory Storage Example

This section shows how to use the default in-memory repositories for tasks and their executions.

```php
<?php

use Task\Storage\ArrayStorage\ArrayTaskRepository;
use Task\Storage\ArrayStorage\ArrayTaskExecutionRepository;
use Task\TaskStatus;

// In-memory storage (useful for testing)
$taskRepository = new ArrayTaskRepository();
$executionRepository = new ArrayTaskExecutionRepository();

// Create a task directly through the repository
$task = $taskRepository->create(MyHandler::class, ['data' => 'value']);
$taskRepository->save($task);

// Find task by UUID
$foundTask = $taskRepository->findByUuid($task->getUuid());

// Get paginated list of tasks
$tasks = $taskRepository->findAllPaginated(1, 10); // Page 1, 10 items per page

// Create an execution
$execution = $executionRepository->create(
    $task,
    new \DateTimeImmutable('+5 minutes')
);
$execution->setStatus(TaskStatus::PLANNED);
$executionRepository->save($execution);

// Find executions for a task
$executions = $executionRepository->findByTask($task);
$executions = $executionRepository->findByTaskUuid($task->getUuid());

// Find next scheduled execution
$nextExecution = $executionRepository->findNextScheduled(
    new \DateTimeImmutable(), // Current time
    []                        // UUIDs to skip
);

// Find pending execution
$pending = $executionRepository->findPending($task);

// Remove task and executions
$executionRepository->remove($execution);
$taskRepository->remove($task);
```

### Implementing Custom Repositories

To use persistent storage, you need to implement the `TaskRepositoryInterface` and `TaskExecutionRepositoryInterface`. These interfaces define the methods required for managing tasks and their executions.

**Example Structure for a Custom Repository (Conceptual):**

```php
<?php

use Task\Storage\TaskRepositoryInterface;
use Task\Storage\TaskExecutionRepositoryInterface;
use Task\Task;
use Task\TaskExecution;

class MyDatabaseTaskRepository implements TaskRepositoryInterface
{
    // Implement methods like create, save, findByUuid, findAllPaginated, remove
    public function create(string $handlerClass, array $payload): Task
    {
        // Logic to create a task and store it in your database
        // ...
        return $task;
    }

    public function save(Task $task): void
    {
        // Logic to save or update a task in your database
        // ...
    }

    // ... other methods ...
}

class MyDatabaseTaskExecutionRepository implements TaskExecutionRepositoryInterface
{
    // Implement methods like create, save, findByTask, findByTaskUuid, findNextScheduled, findPending, remove
    public function create(Task $task, DateTimeInterface $scheduledAt): TaskExecution
    {
        // Logic to create a task execution and store it
        // ...
        return $execution;
    }

    public function save(TaskExecution $execution): void
    {
        // Logic to save or update a task execution
        // ...
    }

    // ... other methods ...
}
```

After implementing your custom repositories, you would inject instances of these classes into the `TaskRunner` or other components that require task management.
```

--------------------------------

### TaskStatus - Execution State Management

Source: https://context7.com/php-task/php-task/llms.txt

This section explains the TaskStatus class, which defines the possible states for a task execution, and provides an example of how to query and manage task statuses.

```APIDOC
## TaskStatus - Execution State Management

The `TaskStatus` class defines the possible states of a task execution, allowing you to track and query task progress.

### Description

Defines and manages the possible states of a task execution.

### Method

Class constants and methods

### Endpoint

N/A

### Parameters

N/A

### Request Example

```php
<?php

use Task\TaskStatus;

// Available task statuses
$statuses = [
    TaskStatus::PLANNED,
    TaskStatus::RUNNING,
    TaskStatus::COMPLETED,
    TaskStatus::ABORTED,
    TaskStatus::FAILED,
];

// Query executions by status
$executionRepository = new ArrayTaskExecutionRepository();

// Find a specific execution and check its status
$execution = $executionRepository->findByUuid('550e8400-e29b-41d4-a716-446655440000');

if ($execution) {
    switch ($execution->getStatus()) {
        case TaskStatus::PLANNED:
            echo "Task is waiting to be executed\n";
            break;
        case TaskStatus::RUNNING:
            echo "Task is currently running since " . $execution->getStartTime()->format('H:i:s') . "\n";
            break;
        case TaskStatus::COMPLETED:
            echo "Task completed in " . $execution->getDuration() . " seconds\n";
            echo "Result: " . json_encode($execution->getResult()) . "\n";
            break;
        case TaskStatus::FAILED:
            echo "Task failed with error: " . $execution->getException() . "\n";
            break;
    }
}
```

### Response

N/A

### Response Example

N/A
```

--------------------------------

### Implement Task Logic with TaskHandlerInterface (PHP)

Source: https://context7.com/php-task/php-task/llms.txt

Defines the TaskHandlerInterface for custom task logic. Provides examples of SendEmailHandler and DataProcessingHandler, demonstrating how to implement the handle method to process specific workloads and return results. Tasks are scheduled using a factory.

```php
<?php

use Task\Handler\TaskHandlerInterface;

class SendEmailHandler implements TaskHandlerInterface
{
    public function handle($workload)
    {
        $email = $workload['email'];
        $subject = $workload['subject'];
        $body = $workload['body'];

        // Simulate sending email
        $result = mail($email, $subject, $body);

        if (!$result) {
            throw new \RuntimeException("Failed to send email to {$email}");
        }

        return [
            'sent' => true,
            'recipient' => $email,
            'timestamp' => date('Y-m-d H:i:s')
        ];
    }
}

class DataProcessingHandler implements TaskHandlerInterface
{
    public function handle($workload)
    {
        $datasetId = $workload['dataset_id'];
        $operation = $workload['operation'];

        // Process data
        $processedCount = $this->processDataset($datasetId, $operation);

        return [
            'dataset_id' => $datasetId,
            'processed_records' => $processedCount,
            'completed_at' => new \DateTimeImmutable()
        ];
    }

    private function processDataset($id, $operation)
    {
        // Processing logic here
        return 1500; // records processed
    }
}

// Register handler with the factory and schedule task
$task = $scheduler->createTask(SendEmailHandler::class, [
    'email' => 'customer@example.com',
    'subject' => 'Your Order Confirmation',
    'body' => 'Thank you for your order!'
])->executeAt(new \DateTimeImmutable())->schedule();

```

--------------------------------

### Manage Task Execution States with TaskStatus in PHP

Source: https://context7.com/php-task/php-task/llms.txt

This code snippet illustrates how to use the TaskStatus class in PHP to manage and query the state of task executions. It defines constants for various task statuses (Planned, Running, Completed, Aborted, Failed) and shows an example of retrieving a task execution and performing actions based on its current status. This requires a TaskStatus class and a repository for task executions.

```php
<?php

use Task\TaskStatus;

// Available task statuses
$statuses = [
    TaskStatus::PLANNED,    // 'planned' - Execution is scheduled but not started
    TaskStatus::RUNNING,    // 'running' - Execution is currently in progress
    TaskStatus::COMPLETED,  // 'completed' - Execution finished successfully
    TaskStatus::ABORTED,    // 'aborted' - Execution was manually stopped
    TaskStatus::FAILED,     // 'failed' - Execution encountered an error
];

// Query executions by status
$executionRepository = new ArrayTaskExecutionRepository();

// Find a specific execution and check its status
$execution = $executionRepository->findByUuid('550e8400-e29b-41d4-a716-446655440000');

if ($execution) {
    switch ($execution->getStatus()) {
        case TaskStatus::PLANNED:
            echo "Task is waiting to be executed\n";
            break;
        case TaskStatus::RUNNING:
            echo "Task is currently running since " . $execution->getStartTime()->format('H:i:s') . "\n";
            break;
        case TaskStatus::COMPLETED:
            echo "Task completed in " . $execution->getDuration() . " seconds\n";
            echo "Result: " . json_encode($execution->getResult()) . "\n";
            break;
        case TaskStatus::FAILED:
            echo "Task failed with error: " . $execution->getException() . "\n";
            break;
    }
}

```

--------------------------------

### Execute Scheduled Tasks with TaskRunner (PHP)

Source: https://context7.com/php-task/php-task/llms.txt

The TaskRunner class is responsible for executing scheduled tasks. It orchestrates the process by finding pending executions, utilizing a TaskHandlerFactory, and managing task lifecycle events through an EventDispatcher. Dependencies like task repositories and lock storage are configured during setup.

```php
<?php

use Symfony\Component\EventDispatcher\EventDispatcher;
use Task\Executor\InsideProcessExecutor;
use Task\Handler\TaskHandlerFactory;
use Task\Lock\Lock;
use Task\Lock\Storage\FileLockStorage;
use Task\Runner\PendingExecutionFinder;
use Task\Runner\TaskRunner;
use Task\Storage\ArrayStorage\ArrayTaskExecutionRepository;

// Setup dependencies
$taskExecutionRepository = new ArrayTaskExecutionRepository();
$handlerFactory = new TaskHandlerFactory();
$lockStorage = new FileLockStorage('/tmp/task-locks');
$lock = new Lock($lockStorage, 300); // 5-minute TTL
$eventDispatcher = new EventDispatcher();

// Create execution finder (with locking support)
$executionFinder = new PendingExecutionFinder(
    $taskExecutionRepository,
    $handlerFactory,
    $lock
);

// Create the executor
$executor = new InsideProcessExecutor($handlerFactory);

// Create the task runner
$taskRunner = new TaskRunner(
    $taskExecutionRepository,
    $executionFinder,
    $executor,
    $eventDispatcher
);

// Run all pending tasks
$taskRunner->runTasks();

echo "All pending tasks have been executed";

```

--------------------------------

### Initialize and Schedule Tasks with TaskScheduler

Source: https://context7.com/php-task/php-task/llms.txt

Demonstrates how to initialize the TaskScheduler with necessary repositories and factories, and how to schedule one-time, recurring, and cron-based tasks.

```php
<?php

use Symfony\Component\EventDispatcher\EventDispatcher;
use Task\Builder\TaskBuilderFactory;
use Task\Handler\TaskHandlerFactory;
use Task\Scheduler\TaskScheduler;
use Task\Storage\ArrayStorage\ArrayTaskExecutionRepository;
use Task\Storage\ArrayStorage\ArrayTaskRepository;

$taskRepository = new ArrayTaskRepository();
$taskExecutionRepository = new ArrayTaskExecutionRepository();
$taskBuilderFactory = new TaskBuilderFactory();
$eventDispatcher = new EventDispatcher();

$scheduler = new TaskScheduler(
    $taskBuilderFactory,
    $taskRepository,
    $taskExecutionRepository,
    $eventDispatcher
);

$task = $scheduler->createTask(MyTaskHandler::class, ['user_id' => 123])
    ->executeAt(new \DateTimeImmutable('+1 hour'))
    ->schedule();

$dailyTask = $scheduler->createTask(DailyReportHandler::class, ['report_type' => 'sales'])
    ->daily()
    ->schedule();

$frequentTask = $scheduler->createTask(HealthCheckHandler::class)
    ->cron('*/5 * * * *')
    ->schedule();

$scheduler->scheduleTasks();

echo "Task scheduled with UUID: " . $task->getUuid();
```

--------------------------------

### Manage Tasks and Executions with Repositories

Source: https://context7.com/php-task/php-task/llms.txt

Demonstrates how to initialize in-memory repositories, create tasks, manage execution schedules, and perform CRUD operations on background jobs. This implementation uses the ArrayTaskRepository and ArrayTaskExecutionRepository classes.

```php
<?php

use Task\Storage\ArrayStorage\ArrayTaskRepository;
use Task\Storage\ArrayStorage\ArrayTaskExecutionRepository;
use Task\TaskStatus;

// In-memory storage (useful for testing)
$taskRepository = new ArrayTaskRepository();
$executionRepository = new ArrayTaskExecutionRepository();

// Create a task directly through the repository
$task = $taskRepository->create(MyHandler::class, ['data' => 'value']);
$taskRepository->save($task);

// Find task by UUID
$foundTask = $taskRepository->findByUuid($task->getUuid());

// Get paginated list of tasks
$tasks = $taskRepository->findAllPaginated(1, 10); // Page 1, 10 items per page

// Create an execution
$execution = $executionRepository->create(
    $task,
    new \DateTimeImmutable('+5 minutes')
);
$execution->setStatus(TaskStatus::PLANNED);
$executionRepository->save($execution);

// Find executions for a task
$executions = $executionRepository->findByTask($task);
$executions = $executionRepository->findByTaskUuid($task->getUuid());

// Find next scheduled execution
$nextExecution = $executionRepository->findNextScheduled(
    new \DateTimeImmutable(), // Current time
    []                        // UUIDs to skip
);

// Find pending execution
$pending = $executionRepository->findPending($task);

// Remove task and executions
$executionRepository->remove($execution);
$taskRepository->remove($task);
```

--------------------------------

### Configure Task Scheduling with TaskBuilder

Source: https://context7.com/php-task/php-task/llms.txt

Shows the fluent interface of TaskBuilder for defining complex scheduling intervals including hourly, weekly, monthly, and custom cron expressions.

```php
<?php

use Task\Builder\TaskBuilder;
use Task\Scheduler\TaskSchedulerInterface;
use Task\Task;

$startDate = new \DateTimeImmutable('+1 day');
$endDate = new \DateTimeImmutable('+30 days');

$task = $scheduler->createTask(CacheCleanupHandler::class)
    ->hourly($startDate, $endDate)
    ->schedule();

$weeklyTask = $scheduler->createTask(WeeklyDigestHandler::class, ['subscribers' => true])
    ->weekly()
    ->schedule();

$billingTask = $scheduler->createTask(BillingHandler::class, [
    'account_id' => 'acc_12345',
    'amount' => 99.99
])
    ->monthly()
    ->schedule();

$mondayTask = $scheduler->createTask(TeamMeetingReminderHandler::class)
    ->cron('0 9 * * 1')
    ->schedule();

$oneTimeTask = $scheduler->createTask(SendWelcomeEmailHandler::class, [
    'email' => 'user@example.com',
    'name' => 'John Doe'
])
    ->executeAt(new \DateTimeImmutable('2024-12-25 00:00:00'))
    ->schedule();

echo "Tasks configured and scheduled successfully";
```

--------------------------------

### Listen to php-task Lifecycle Events in PHP

Source: https://context7.com/php-task/php-task/llms.txt

This snippet demonstrates how to use Symfony's EventDispatcher to listen for and react to various events dispatched by the php-task system throughout a task's lifecycle. It covers events like task creation, execution scheduling, pre- and post-execution, success, failure, retries, and completion. Dependencies include Symfony's EventDispatcher and Task-specific event classes.

```php
<?php

use Symfony\Component\EventDispatcher\EventDispatcher;
use Task\Event\Events;
use Task\Event\TaskEvent;
use Task\Event\TaskExecutionEvent;

$eventDispatcher = new EventDispatcher();

// Listen for task creation
$eventDispatcher->addListener(Events::TASK_CREATE, function (TaskEvent $event) {
    $task = $event->getTask();
    echo "Task created: " . $task->getUuid() . "\n";
    echo "Handler: " . $task->getHandlerClass() . "\n";
});

// Listen for execution creation
$eventDispatcher->addListener(Events::TASK_EXECUTION_CREATE, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    echo "Execution scheduled for: " . $execution->getScheduleTime()->format('Y-m-d H:i:s') . "\n";
});

// Before task execution
$eventDispatcher->addListener(Events::TASK_BEFORE, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    echo "Starting execution: " . $execution->getUuid() . "\n";
});

// After task execution (always fires, regardless of success/failure)
$eventDispatcher->addListener(Events::TASK_AFTER, function (TaskExecutionEvent $event) {
    echo "Execution handler completed\n";
});

// Task passed successfully
$eventDispatcher->addListener(Events::TASK_PASSED, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    $result = $execution->getResult();
    echo "Task passed with result: " . json_encode($result) . "\n";
});

// Task failed
$eventDispatcher->addListener(Events::TASK_FAILED, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    echo "Task failed: " . $execution->getException() . "\n";
    // Send alert, log to monitoring system, etc.
});

// Task will be retried
$eventDispatcher->addListener(Events::TASK_RETRIED, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    echo "Retrying task, attempt: " . $execution->getAttempts() . "\n";
});

// Task finished (after all processing complete)
$eventDispatcher->addListener(Events::TASK_FINISHED, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    echo "Execution finished in " . $execution->getDuration() . " seconds\n";
    echo "Final status: " . $execution->getStatus() . "\n";
});

```

--------------------------------

### Event System - Task Lifecycle Hooks

Source: https://context7.com/php-task/php-task/llms.txt

This section demonstrates how to use the Symfony EventDispatcher to listen for and react to various events dispatched during the task lifecycle, such as creation, execution, success, failure, and completion.

```APIDOC
## Event System - Task Lifecycle Hooks

php-task dispatches events throughout the task lifecycle, allowing you to add logging, monitoring, or custom behavior at each stage.

### Description

Listen for and react to various events dispatched during the task lifecycle.

### Method

Event Dispatcher (Symfony Component)

### Endpoint

N/A (In-memory event dispatching)

### Parameters

N/A

### Request Example

```php
<?php

use Symfony\Component\EventDispatcher\EventDispatcher;
use Task\Event\Events;
use Task\Event\TaskEvent;
use Task\Event\TaskExecutionEvent;

$eventDispatcher = new EventDispatcher();

// Listen for task creation
$eventDispatcher->addListener(Events::TASK_CREATE, function (TaskEvent $event) {
    $task = $event->getTask();
    echo "Task created: " . $task->getUuid() . "\n";
    echo "Handler: " . $task->getHandlerClass() . "\n";
});

// Listen for execution creation
$eventDispatcher->addListener(Events::TASK_EXECUTION_CREATE, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    echo "Execution scheduled for: " . $execution->getScheduleTime()->format('Y-m-d H:i:s') . "\n";
});

// Before task execution
$eventDispatcher->addListener(Events::TASK_BEFORE, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    echo "Starting execution: " . $execution->getUuid() . "\n";
});

// After task execution (always fires, regardless of success/failure)
$eventDispatcher->addListener(Events::TASK_AFTER, function (TaskExecutionEvent $event) {
    echo "Execution handler completed\n";
});

// Task passed successfully
$eventDispatcher->addListener(Events::TASK_PASSED, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    $result = $execution->getResult();
    echo "Task passed with result: " . json_encode($result) . "\n";
});

// Task failed
$eventDispatcher->addListener(Events::TASK_FAILED, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    echo "Task failed: " . $execution->getException() . "\n";
    // Send alert, log to monitoring system, etc.
});

// Task will be retried
$eventDispatcher->addListener(Events::TASK_RETRIED, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    echo "Retrying task, attempt: " . $execution->getAttempts() . "\n";
});

// Task finished (after all processing complete)
$eventDispatcher->addListener(Events::TASK_FINISHED, function (TaskExecutionEvent $event) {
    $execution = $event->getTaskExecution();
    echo "Execution finished in " . $execution->getDuration() . " seconds\n";
    echo "Final status: " . $execution->getStatus() . "\n";
});
```

### Response

N/A (Callbacks are executed)

### Response Example

N/A
```

--------------------------------

### TaskBuilder - Fluent Scheduling Configuration

Source: https://context7.com/php-task/php-task/llms.txt

The TaskBuilder provides a fluent API to define when and how often a task should execute.

```APIDOC
## TaskBuilder Scheduling Methods

### Description
Configures the execution frequency of a task using built-in presets or custom cron expressions.

### Methods
- **hourly()** - Runs the task every hour.
- **daily()** - Runs the task every day.
- **weekly()** - Runs the task every week.
- **monthly()** - Runs the task every month.
- **cron(string $expression)** - Runs the task based on a custom cron string.
- **executeAt(DateTimeImmutable $date)** - Schedules a one-time execution at a specific time.

### Request Example
$scheduler->createTask(Handler::class)->cron('*/5 * * * *')->schedule();

### Response
- **Task** (object) - Returns the configured Task object ready for persistence.
```

--------------------------------

### Manage Distributed Locks with Lock Class

Source: https://context7.com/php-task/php-task/llms.txt

This snippet shows how to use the Lock class for distributed locking with file-based storage. It covers acquiring, refreshing, and releasing locks, as well as handling exceptions when a lock is already held by another process.

```php
<?php

use Task\Lock\Lock;
use Task\Lock\Storage\FileLockStorage;
use Task\Lock\Exception\LockAlreadyAcquiredException;

$lockStorage = new FileLockStorage('/var/locks');
$lock = new Lock($lockStorage, 600);

$lockKey = 'critical_operation_123';

try {
    $lock->acquire($lockKey);
    performCriticalOperation();
    $lock->refresh($lockKey);
} catch (LockAlreadyAcquiredException $e) {
    echo "Lock already held: " . $e->getMessage();
} finally {
    if ($lock->isAcquired($lockKey)) {
        $lock->release($lockKey);
    }
}
```

--------------------------------

### Implement Exclusive Task Execution with LockingTaskHandlerInterface

Source: https://context7.com/php-task/php-task/llms.txt

This snippet demonstrates how to implement the LockingTaskHandlerInterface to ensure that tasks sharing the same resource ID do not execute concurrently. It defines a lock key based on the workload and simulates a critical section that requires exclusive access.

```php
<?php

use Task\Handler\TaskHandlerInterface;
use Task\Lock\LockingTaskHandlerInterface;

class ExclusiveResourceHandler implements TaskHandlerInterface, LockingTaskHandlerInterface
{
    public function handle($workload)
    {
        $resourceId = $workload['resource_id'];
        $this->processExclusiveResource($resourceId);
        return ['processed' => $resourceId];
    }

    public function getLockKey($workload)
    {
        return 'resource_lock_' . $workload['resource_id'];
    }

    private function processExclusiveResource($resourceId)
    {
        sleep(5);
    }
}

$task1 = $scheduler->createTask(ExclusiveResourceHandler::class, ['resource_id' => 'db_backup'])
    ->executeAt(new \DateTimeImmutable())
    ->schedule();

$task2 = $scheduler->createTask(ExclusiveResourceHandler::class, ['resource_id' => 'db_backup'])
    ->executeAt(new \DateTimeImmutable('+1 minute'))
    ->schedule();
```

--------------------------------

### TaskScheduler - Task Creation and Scheduling

Source: https://context7.com/php-task/php-task/llms.txt

The TaskScheduler is the primary interface for creating, configuring, and persisting tasks to the storage backend.

```APIDOC
## TaskScheduler::createTask

### Description
Initializes a new task instance with a specific handler and workload data, returning a TaskBuilder for further configuration.

### Method
PHP Method Call

### Parameters
- **handler** (string) - Required - The class name of the task handler.
- **workload** (array) - Optional - Data to be passed to the task handler.

### Request Example
$scheduler->createTask(MyTaskHandler::class, ['user_id' => 123])

### Response
- **TaskBuilder** (object) - Returns a builder instance to configure scheduling intervals.
```

--------------------------------

### Implement Automatic Task Retries with RetryTaskHandlerInterface (PHP)

Source: https://context7.com/php-task/php-task/llms.txt

Extends task handlers to support automatic retries on failure. The ExternalApiHandler implements both TaskHandlerInterface and RetryTaskHandlerInterface, defining a getMaximumAttempts method. Exceptions thrown during handle() execution can trigger retries based on the configured attempts.

```php
<?php

use Task\Handler\TaskHandlerInterface;
use Task\Executor\RetryTaskHandlerInterface;

class ExternalApiHandler implements TaskHandlerInterface, RetryTaskHandlerInterface
{
    public function handle($workload)
    {
        $apiUrl = $workload['api_url'];
        $payload = $workload['payload'];

        $ch = curl_init($apiUrl);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_TIMEOUT, 30);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode >= 500) {
            // Server error - this will trigger a retry
            throw new \RuntimeException("API server error: HTTP {$httpCode}");
        }

        if ($httpCode >= 400) {
            // Client error - no retry needed
            throw new \InvalidArgumentException("API client error: HTTP {$httpCode}");
        }

        return json_decode($response, true);
    }

    public function getMaximumAttempts()
    {
        return 3; // Retry up to 3 times
    }
}

// Schedule the retryable task
$task = $scheduler->createTask(ExternalApiHandler::class, [
    'api_url' => 'https://api.example.com/webhook',
    'payload' => ['event' => 'order.created', 'order_id' => 12345]
])->executeAt(new \DateTimeImmutable())->schedule();

```
Tokens:
Raw