Laravel Octane

https://github.com/laravel/octane
Admin
A high-performance application server for Laravel that boots your application once and feeds it...
Tokens:88,190
Snippets:666
Trust Score:9.7
License:MIT
Update:1 week ago
Show doc for...
Tokens:
Raw
### octane:install command definition

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/commands.md

InstallCommand for octane:install with options --server and --force. Dispatches to server-specific installers and writes OCTANE_SERVER= to .env on success.

```php
#[AsCommand(name: 'octane:install')]
class InstallCommand extends Command
{
    use Concerns\InstallsFrankenPhpDependencies,
        Concerns\InstallsRoadRunnerDependencies;

    public $signature = 'octane:install
                    {--server= : The server that should be used to serve the application}
                    {--force : Overwrite any existing configuration files}';
}
```

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

### Worker instantiation example from bin/roadrunner-worker

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/worker.md

Shows how to create and boot a Worker with an ApplicationFactory and a RoadRunnerClient, as done by the bin/roadrunner-worker script.

```php
use Laravel\Octane\ApplicationFactory;
use Laravel\Octane\RoadRunner\RoadRunnerClient;
use Laravel\Octane\Worker;

$worker = (new Worker(
    new ApplicationFactory($basePath), $roadRunnerClient
))->boot();
```

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

### table() usage example

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Example of using Octane::table() to set and get a value from a Swoole table. Requires the table to be configured under octane.tables and running under the Swoole server.

```php
use Laravel\Octane\Facades\Octane;

Octane::table('example')->set('user:1', ['name' => 'Taylor', 'votes' => 10]);

$row = Octane::table('example')->get('user:1');
```

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

### OnServerStart constructor and __invoke signatures

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/swoole-internals.md

Event handler for the start event. Writes process IDs, sets the master process name, and when shouldTick enqueues a tick task every second via Timer::tick(1000, fn () => $server->task('octane-tick')). When maxExecutionTime > 0, also ticks to run EnsureRequestsDontExceedMaxExecutionTime.

```php
public function __construct(
    protected ServerStateFile $serverStateFile,
    protected SwooleExtension $extension,
    protected string $appName,
    protected int $maxExecutionTime,
    protected $timerTable,
    protected bool $shouldTick = true,
    protected bool $shouldSetProcessName = true
)
public function __invoke($server)
```

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

### Interval cache usage example

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/cache.md

Shows how to register an interval cache with a 60-second refresh and trigger automatic refresh via Octane::tick.

```php
use Illuminate\Support\Facades\Cache;
use Laravel\Octane\Facades\Octane;

Cache::store('octane')->interval('weather', fn () => fetchWeather(), 60); // refresh at most every 60s

Octane::tick('refresh-intervals', fn () => null); // TickReceived triggers refreshIntervalCaches automatically
```

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

### octane:start command signature with all options

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/commands.md

Defines the `octane:start` Artisan command signature, including options for server, host, port, admin-port, RPC settings, workers, max-requests, RoadRunner config, FrankenPHP Caddyfile, HTTPS, HTTP redirect, watch, poll, and log level. The server option resolves to `swoole`, `roadrunner`, or `frankenphp`; otherwise the command returns 1. Signals SIGINT, SIGTERM, and SIGHUP are subscribed, and `stopServer()` calls `octane:stop`.

```php
public $signature = 'octane:start
    {--server= : The server that should be used to serve the application}
    {--host= : The IP address the server should bind to}
    {--port= : The port the server should be available on [default: "8000"]}
    {--admin-port= : The port the admin server should be available on [FrankenPHP only]}
    {--rpc-host= : The RPC IP address the server should bind to}
    {--rpc-port= : The RPC port the server should be available on}
    {--workers= : The number of workers that should be available to handle requests}
    {--task-workers= : The number of task workers that should be available to handle tasks}
    {--max-requests= : The number of requests to process before reloading the server}
    {--rr-config= : The path to the RoadRunner .rr.yaml file}
    {--caddyfile= : The path to the FrankenPHP Caddyfile file}
    {--https : Enable HTTPS, HTTP/2, and HTTP/3, and automatically generate and renew certificates [FrankenPHP only]}
    {--http-redirect : Enable HTTP to HTTPS redirection (only enabled if --https is passed) [FrankenPHP only]}
    {--watch : Automatically reload the server when the application is modified}
    {--poll : Use file system polling while watching in order to watch files over a network}
    {--log-level= : Log messages at or above the specified log level}';
```

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

### Manual request handling loop example

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/worker.md

Shows how to marshal a request and pass it to the worker's handle method, as done in the RoadRunner worker script.

```php
[$request, $context] = $client->marshalRequest(new RequestContext([
    'psr7Request' => $psr7Request,
]));

$worker->handle($request, $context);
```

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

### createApplication() usage example

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/application-factory.md

Used by every server entry script to create the application instance. Passes initial container instances such as Client, Server, and WorkerState. The RoadRunner worker passes Client::class, while Swoole's OnWorkerStart::bootWorker() passes octane.cacheTable, Server::class, and WorkerState::class.

```php
$app = (new ApplicationFactory($basePath))->createApplication([
    Client::class => $client,
    Server::class => $server,
    WorkerState::class => $workerState,
]);
```

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

### concurrently() usage example

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Example of using Octane::concurrently() to run multiple tasks in parallel and destructure the results. Tasks are keyed and results are returned in the same order.

```php
use Laravel\Octane\Facades\Octane;

[$users, $orders] = Octane::concurrently([
    'users'  => fn () => User::all(),
    'orders' => fn () => Order::all(),
]);
```

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

### RequestContext usage example

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/request-context.md

Shows how to instantiate RequestContext with initial data and use ArrayAccess and magic property access to write values.

```php
use Laravel\Octane\RequestContext;

$context = new RequestContext(['swooleRequest' => $request]);
$context['extra'] = 'value';   // ArrayAccess write
$context->extra = 'value2';    // magic write
```

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

### Using FakeClient and FakeWorker in PHPUnit tests

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/utilities.md

Example of using FakeClient and FakeWorker to drive requests through the full Octane lifecycle in a PHPUnit test. Creates a FakeClient with a GET request to '/home', boots a FakeWorker, runs it, and checks the status code of the first response.

```php
use Laravel\Octane\Testing\Fakes\FakeClient;
use Laravel\Octane\Testing\Fakes\FakeWorker;

$fakeClient = new FakeClient([
    Request::create('/home', 'GET'),
]);

$worker = (new FakeWorker($appFactory, $fakeClient))->boot();

$worker->run();   // handles all requests

$status = $fakeClient->responses[0]->getStatusCode();
```

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

### ServerStateFile::read() return shape

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/types.md

Return value of ServerStateFile::read() for all three adapters. Contains masterProcessId, managerProcessId (Swoole only), and a state array written by the Start*Command.

```php
[
    'masterProcessId' => int|null,
    'managerProcessId' => int|null,   // Swoole only
    'state' => array,                 // written by the Start*Command
]
```

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

### ApplicationGateway sandbox pattern usage example

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/application-gateway.md

Shows how ApplicationGateway is used internally by Worker::handle(). Clones the app as a sandbox, sets it as the current application, creates the gateway, handles the request, terminates, and restores the original app. Demonstrates the sandbox pattern; no public need to instantiate it.

```php
use Laravel\Octane\ApplicationGateway;
use Laravel\Octane\CurrentApplication;

$sandbox = clone $app;
CurrentApplication::set($sandbox);

$gateway = new ApplicationGateway($app, $sandbox);
$response = $gateway->handle($request);
// ... send response ...
$gateway->terminate($request, $response);

CurrentApplication::set($app);
```

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

### RoadRunner binary -o overrides

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/commands.md

Command-line overrides passed to the RoadRunner binary when starting the server, configuring HTTP address, worker pool, RPC, static files, middleware, and logging.

```bash
-c <config> -o version=3
-o http.address={host}:{port}
-o server.command={php},{vendor/bin/roadrunner-worker}
-o http.pool.num_workers={workers ('auto'→0)}
-o http.pool.max_jobs={max-requests}
-o rpc.listen=tcp://{rpcHost}:{rpcPort}
-o http.pool.supervisor.exec_ttl={octane.max_execution_time}s   (default "30s")
-o http.static.dir={public_path}
-o http.middleware={octane.roadrunner.http_middleware, default 'static'}
-o logs.mode=production
-o logs.level={--log-level, or 'debug' local / 'warn'}
-o logs.output=stdout
-o logs.encoding=json
serve
```

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

### tick() usage example

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Example of using Octane::tick() to register a periodic callback. The callback runs every 10 seconds, with exceptions reported to the application's exception handler.

```php
use Laravel\Octane\Facades\Octane;

Octane::tick('check-database', fn () => /* ... */, seconds: 10);
```

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

### Registering a custom internal route with Octane::route()

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Example from a service provider that registers a custom internal route for GET /custom. When matched, Octane invokes the route instead of the kernel, returning a Response with 'hello'.

```php
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Laravel\Octane\Facades\Octane;

Octane::route('GET', '/custom', function (Request $request) {
    return new Response('hello');
});
```

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

### Octane::tick example with seconds()

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Registers a tick callback that warms the cache every 30 seconds. Uses the Octane facade and Cache facade. The callback catches exceptions and the seconds method overrides the default interval.

```php
use Laravel\Octane\Facades\Octane;
use Illuminate\Support\Facades\Cache;

Octane::tick('cache-warm', function () {
    Cache::put('warm', ['users' => User::count()], 60);
})->seconds(30);
```

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

### Warming custom services via config/octane.php

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/application-factory.md

Example configuration for warming custom services. The 'warm' key in config/octane.php merges Octane's default services with a custom service key.

```php
// config/octane.php
'warm' => [
    ...Octane::defaultServicesToWarm(),
    'my-custom-service',
],
```

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

### Stream::request() JSON output format

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/request-context.md

Example JSON line written to STDOUT by Stream::request().

```json
{"type":"request","method":"...","url":"...","memory":<bytes>,"statusCode":<int>,"duration":<float>}
```

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

### onRequestHandled() usage example

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/worker.md

Example usage of onRequestHandled, used internally by OnWorkerStart::streamRequestsToConsole() to stream per-request JSON lines to stdout. The closure receives ($request, $response, $sandbox) and returns early unless the environment is local or testing.

```php
$worker->onRequestHandled(function ($request, $response, $sandbox) {
    if (! $sandbox->environment('local', 'testing')) {
        return;
    }

    Stream::request(
        $request->getMethod(),
        $request->fullUrl(),
        $response->getStatusCode(),
        (microtime(true) - $this->workerState->lastRequestTime) * 1000,
    );
});
```

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

### octane:frankenphp command signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/commands.md

Defines the command signature for the FrankenPHP server, including options for host, port, workers, HTTPS, watching, and logging. The signature is used by Laravel Octane to start the FrankenPHP server with the specified configuration.

```php
public $signature = 'octane:frankenphp
    {--host=127.0.0.1 : The IP address the server should bind to}
    {--port= : The port the server should be available on}
    {--admin-host=localhost : The host the admin server should be available on}
    {--admin-port=2019 : The port the admin server should be available on}
    {--workers=auto : The number of workers that should be available to handle requests}
    {--max-requests=500 : The number of requests to process before reloading the server}
    {--caddyfile= : The path to the FrankenPHP Caddyfile file}
    {--https : Enable HTTPS, HTTP/2, and HTTP/3, and automatically generate and renew certificates}
    {--http-redirect : Enable HTTP to HTTPS redirection (only enabled if --https is passed)}
    {--watch : Automatically reload the server when the application is modified}
    {--poll : Use file system polling while watching in order to watch files over a network}
    {--log-level= : Log messages at or above the specified log level}';
```

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

### MimeType::get() - Get MIME type for extension or full map

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/utilities.md

Static method that returns the MIME type for a given file extension, or the full extension-to-MIME map when called with no arguments. Unknown extensions resolve to 'application/octet-stream'.

```php
/**
 * Get the MIME type for a given extension or return all mimes.
 *
 * @param  string  $extension
 * @return string|array
 */
public static function get($extension = null)
{
    return isset($extension) ? self::getMimeTypeFromExtension($extension) : self::$mimes;
}
```

```php
use Laravel\Octane\MimeType;

MimeType::get('png');   // 'image/png'
MimeType::get();        // full map
```

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

### Avoid singleton vs prefer scoped binding for request-specific state

Source: https://github.com/laravel/octane/blob/2.x/resources/boost/skills/octane-development/SKILL.md

Shows the recommended pattern for binding services that hold request-derived data. Using singleton retains state across requests, while scoped ensures a fresh instance per request. Use scoped for services that depend on request data.

```php
// Avoid: holds request 1's user for every later request
$this->app->singleton(UserContext::class);

// Prefer: flushed and re-resolved per request
$this->app->scoped(UserContext::class);
```

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

### prepareApplicationForNextOperation()

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Returns the listeners that prepare the sandbox for a new operation (requests, tasks, ticks).

```APIDOC
## prepareApplicationForNextOperation()

### Description
Returns the listeners that prepare the sandbox for a new operation (requests, tasks, ticks).

### Method
`prepareApplicationForNextOperation`

### Signature
`public static function prepareApplicationForNextOperation(): array`

### Parameters
None

### Return
`array` - Listener class names including `CreateConfigurationSandbox`, `CreateUrlGeneratorSandbox`, `GiveNewApplicationInstanceTo*Manager` family, `FlushDatabaseRecordModificationState`, `FlushDatabaseQueryLog`, `RefreshQueryDurationHandling`, `FlushArrayCache`, `FlushLogContext`, `FlushMonologState`, `FlushOnce`, `FlushStrCache`, `FlushTranslatorCache`, `FlushVite`, plus first-party package preparers `PrepareInertiaForNextOperation`, `PrepareLivewireForNextOperation`, `PrepareScoutForNextOperation`, `PrepareSocialiteForNextOperation`
```

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

### prepareApplicationForNextRequest()

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Returns the listeners that run before each request.

```APIDOC
## prepareApplicationForNextRequest()

### Description
Returns the listeners that run before each request.

### Method
`prepareApplicationForNextRequest`

### Signature
`public static function prepareApplicationForNextRequest(): array`

### Parameters
None

### Return
`array` - Listener class names: `FlushLocaleState`, `FlushQueuedCookies`, `FlushSessionState`, `FlushAuthenticationState`, `EnforceRequestScheme`, `EnsureRequestServerPortMatchesScheme`, `GiveNewRequestInstanceToApplication`, `GiveNewRequestInstanceToPaginator`
```

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

### Table column creation from config in bin/createSwooleTables.php

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/swoole-internals.md

Iterates octane.tables entries and creates columns with types mapped from string, int, or float. Default size is 1000 when not specified.

```php
$table->column($columnName, match (explode(':', $column)[0] ?? 'string') {
    'string' => Table::TYPE_STRING,
    'int' => Table::TYPE_INT,
    'float' => Table::TYPE_FLOAT,
}, explode(':', $column)[1] ?? 1000);
```

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

### createApplication() method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/application-factory.md

Creates a new application instance. Accepts an optional array of initial instances to register into the container before bootstrapping. Returns an Illuminate\Foundation\Application.

```php
/**
 * Create a new application instance.
 */
public function createApplication(array $initialInstances = []): Application
```

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

### bootstrap() method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/application-factory.md

Bootstraps the given application. Registers initial instances, runs bootstrappers (including SetRequestForConsole), and loads deferred providers. Returns the bootstrapped Application.

```php
/**
 * Bootstrap the given application.
 */
public function bootstrap(Application $app, array $initialInstances = []): Application
```

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

### OctaneStore::increment

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/cache.md

Increments the value of a cache key. If the key does not exist or is expired, starts at the given value with a one-year TTL.

```APIDOC
## OctaneStore::increment

### Description
Increments the value of a cache key.

### Method
`increment`

### Signature
`increment($key, $value = 1)`

### Parameters
- **$key** (string) - Required - The cache key.
- **$value** (int) - Optional - The amount to increment by. Defaults to 1.

### Returns
- int|bool - The new value, or `false` on failure.
```

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

### Default Swoole server options

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/commands.md

Returns the default Swoole server options merged into the state file. Includes coroutine and daemonize disabled, log file path, log level based on environment, max request count, package max length, reactor and worker counts, and task worker settings.

```php
[
    'enable_coroutine' => false,
    'daemonize' => false,
    'log_file' => storage_path('logs/swoole_http.log'),
    'log_level' => app()->environment('local') ? SWOOLE_LOG_INFO : SWOOLE_LOG_ERROR,
    'max_request' => $this->option('max-requests'),                 // default 500
    'package_max_length' => 10 * 1024 * 1024,
    'reactor_num' => $this->workerCount($extension),
    'send_yield' => true,
    'socket_buffer_size' => 10 * 1024 * 1024,
    'task_max_request' => $this->option('max-requests'),
    'task_worker_num' => $this->taskWorkerCount($extension),
    'worker_num' => $this->workerCount($extension),
]

```

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

### boot() method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/service-provider.md

Public method of OctaneServiceProvider that wires event listeners, registers cache driver, commands, internal routes, and publishes config.

```php
public function boot()
```

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

### Configuring and using a Swoole table

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/swoole-internals.md

Shows how to define a table in config/octane.php and then access it via the Octane facade. The table name includes a :1000 suffix for max rows, and columns use type:size syntax.

```php
// config/octane.php
'tables' => [
    'example:1000' => [
        'name' => 'string:1000',
        'votes' => 'int',
    ],
],
```

```php
use Laravel\Octane\Facades\Octane;

Octane::table('example')->set('user:1', ['name' => 'Taylor Otwell', 'votes' => 100]);

$votes = Octane::table('example')->get('user:1', 'votes');
```

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

### Swoole ServerProcessInspector constructor

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/server-state.md

Constructor for the Swoole server process inspector. Injects the signal dispatcher, server state file, and Exec utility. Used to manage the Swoole server process lifecycle.

```php
public function __construct(
    protected SignalDispatcher $dispatcher,
    protected ServerStateFile $serverStateFile,
    protected Exec $exec,
)
```

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

### ProvidesDefaultConfigurationOptions trait method signatures

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Declares the static methods prepareApplicationForNextRequest(), prepareApplicationForNextOperation(), and defaultServicesToWarm() from the ProvidesDefaultConfigurationOptions trait. Each returns an array of listener class names or container keys used for warming.

```php
public static function prepareApplicationForNextRequest(): array   // line 10
public static function prepareApplicationForNextOperation(): array // line 44
public static function defaultServicesToWarm(): array              // line 104
```

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

### WorkerExceptionInspector - Render reproduced worker exception

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/utilities.md

Extends Whoops\Exception\Inspector to render a reproduced worker exception with the original class name and trace. Used by Commands\Concerns\InteractsWithIO::throwableInfo() together with NunoMaduro\Collision\Writer when Collision is installed.

```php
public function __construct(Throwable $throwable, protected string $class, protected array $trace)
{
    parent::__construct($throwable);
}

/**
 * Get the worker exception name.
 *
 * @return string
 */
public function getExceptionName()
{
    return $this->class;
}

/**
 * Get the worker exception trace.
 *
 * @param  \Throwable  $throwable
 * @return array
 */
public function getTrace($throwable)
{
    return $this->trace;
}
```

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

### CurrentApplication class with set method

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/request-context.md

Static utility that swaps the 'current application' used by facades and the container. The set method replaces the static container instance and re-points facades at the new app. Called in Worker::handle() with a sandbox clone and in the finally block with the base app.

```php
class CurrentApplication
{
    /**
     * Set the current application in the container.
     */
    public static function set(Application $app): void
    {
        $app->instance('app', $app);
        $app->instance(Container::class, $app);

        Container::setInstance($app);

        Facade::clearResolvedInstances();
        Facade::setFacadeApplication($app);
    }
}
```

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

### FrankenPhp ServerProcessInspector constructor

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/server-state.md

Constructor for the FrankenPHP server process inspector. Injects the server state file. Uses the FrankenPHP admin API to manage the server process.

```php
public function __construct(protected ServerStateFile $serverStateFile)
```

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

### serveStaticFile method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/clients.md

Serves a static file by applying static_file_headers, setting status 200, Content-Type via MimeType, and using sendfile.

```php
public function serveStaticFile(Request $request, RequestContext $context): void
```

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

### TableFactory::make method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/swoole-internals.md

Returns a SwooleTable or OpenSwooleTable instance based on the openswoole extension. Constructs the table with size and 1 conflict probe.

```php
public static function make($size)
```

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

### Execute closures in parallel with Octane::concurrently

Source: https://github.com/laravel/octane/blob/2.x/resources/boost/skills/octane-development/SKILL.md

Use this method to run multiple tasks in parallel when using the Swoole driver. Closures must not capture non-serializable state like $this or Eloquent models; pass scalar IDs instead.

```php
[$users, $orders] = Octane::concurrently([
    fn () => User::all(),
    fn () => Order::pending()->get(),
]);
```

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

### OnWorkerStart constructor and __invoke signatures

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/swoole-internals.md

Event handler for workerstart. Clears apcu_clear_cache/opcache_reset when octaneConfig.swoole.clear_opcache (default true). Fills WorkerState via bootWorker(), which creates Worker(new ApplicationFactory($basePath), $client = new SwooleClient)->boot([...]); on Throwable it streams a shutdown line and calls $server->shutdown(). Registers onRequestHandled() to stream request info when the sandbox environment is local/testing. Sets the process name — task worker process when $workerId >= $server->setting['worker_num'], else worker process.

```php
public function __construct(
    protected SwooleExtension $extension,
    protected $basePath,
    protected array $serverState,
    protected WorkerState $workerState,
    protected bool $shouldSetProcessName = true
)
public function __invoke($server, int $workerId)
```

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

### SwooleHttpTaskDispatcher constructor

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/task-dispatchers.md

Constructor for the HTTP task dispatcher. Requires host, port, and a fallback dispatcher used when HTTP calls fail with connection exceptions.

```php
public function __construct(
    protected string $host,
    protected string $port,
    protected DispatchesTasks $fallbackDispatcher
)
```

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

### SwooleCoroutineDispatcher constructor signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/task-dispatchers.md

Constructor for the Swoole coroutine dispatcher. $withinCoroutineContext indicates whether Swoole\Coroutine\run() is needed (false) or the dispatcher already runs inside a coroutine (e.g., Swoole request handler).

```php
public function __construct(protected bool $withinCoroutineContext)
```

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

### Swoole ServerStateFile public API

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/server-state.md

Public methods for the Swoole state file class. `read()` returns an array with `masterProcessId`, `managerProcessId`, and `state` keys. `writeProcessIds()` merges both process IDs into the file with `JSON_PRETTY_PRINT`. Throws `RuntimeException('Unable to write to process ID file.')` when the file or directory is not writable.

```php
public function __construct(protected string $path)

public function read(): array
// ['masterProcessId' => $state['masterProcessId'] ?? null,
//  'managerProcessId' => $state['managerProcessId'] ?? null,
//  'state' => $state['state'] ?? []]

public function writeProcessIds(int $masterProcessId, int $managerProcessId): void
public function writeState(array $newState): void
public function delete(): bool
public function path(): string
```

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

### WorkerStarting event class with app property

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/events.md

Dispatched from Worker::boot() after the base application is created. The constructor accepts the freshly created base application instance.

```php
class WorkerStarting
{
    public function __construct(public Application $app)
    {
    }
}
```

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

### SwooleExtension constructor with optional closures

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/swoole-internals.md

Constructor for Laravel\Octane\Swoole\SwooleExtension. Accepts optional closures for isReadable and fileGetContents; defaults are injected lazily to allow faking cgroup probing in tests.

```php
public function __construct(
    protected ?Closure $isReadable = null,
    protected ?Closure $fileGetContents = null,
)
```

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

### OnManagerStart constructor and __invoke signatures

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/swoole-internals.md

Event handler for the managerstart event. Sets the manager process name (swoole_http_server: manager process for <appName>) on Linux only, inside SwooleExtension::setProcessName().

```php
public function __construct(
    protected SwooleExtension $extension,
    protected string $appName,
    protected bool $shouldSetProcessName = true
)
public function __invoke()
```

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

### CurrentApplication set method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/request-context.md

Static method signature for setting the current application. Accepts an Illuminate\Foundation\Application instance and returns void.

```php
public static function set(Application $app): void
```

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

### RoadRunner ServerProcessInspector constructor

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/server-state.md

Constructor for the RoadRunner server process inspector. Injects the server state file, Symfony process factory, and POSIX extension. Used to manage the RoadRunner server process lifecycle.

```php
public function __construct(
    protected ServerStateFile $serverStateFile,
    protected SymfonyProcessFactory $processFactory,
    protected PosixExtension $posix
)
```

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

### Default config/octane.php listeners and warm services

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Shows how the trait methods feed the default config/octane.php. The RequestReceived event uses both prepareApplicationForNextOperation() and prepareApplicationForNextRequest() listeners, and the 'warm' key uses defaultServicesToWarm().

```php
RequestReceived::class => [
    ...Octane::prepareApplicationForNextOperation(),
    ...Octane::prepareApplicationForNextRequest(),
],

'warm' => [
    ...Octane::defaultServicesToWarm(),
],
```

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

### OctaneStore::__construct

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/cache.md

Creates a new Octane store instance backed by a Swoole table. The table must have columns 'value' and 'expiration'.

```APIDOC
## OctaneStore::__construct

### Description
Creates a new Octane store instance backed by a Swoole table.

### Method
Constructor

### Signature
`public function __construct(protected $table)`

### Parameters
- **$table** (\Swoole\Table) - Required - The shared cache table (columns: `value`, `expiration`)
```

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

### ApplicationGateway request lifecycle sequence diagram

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/application-gateway.md

ASCII sequence diagram showing the flow from Worker::handle() through gateway->handle() and gateway->terminate(), including event dispatch points and the optional Octane route shortcut.

```text
Worker::handle()
  └─ gateway->handle($request)
       ├─ RequestReceived(app, sandbox, request)
       ├─ Octane route?  YES → invokeRoute → return
       └─ sandbox Kernel::handle(request)
            └─ RequestHandled(sandbox, request, response)
  └─ client->respond(context, OctaneResponse)
  └─ gateway->terminate(request, response)
       ├─ sandbox Kernel::terminate(request, response)
       ├─ RequestTerminated(app, sandbox, request, response)
       └─ route->flushController()
```

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

### OctaneStore constructor

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/cache.md

Constructor for OctaneStore, accepting a Swoole\Table with columns 'value' and 'expiration'.

```php
/**
 * Create a new Octane store.
 *
 * @param  \Swoole\Table  $table
 * @return void
 */
public function __construct(protected $table)
```

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

### FrankenPhpClient::marshalRequest() method

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/clients.md

Captures the HTTP request using Illuminate\Http\Request::capture() from $_SERVER/$_GET/etc. and returns it with the context. Source: src/FrankenPhp/FrankenPhpClient.php (line 19).

```php
public function marshalRequest(RequestContext $context): array
{
    return [
        Request::capture(),
        $context,
    ];
}
```

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

### Exec::run() - Run shell command and capture output

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/utilities.md

Executes a shell command and returns the captured stdout lines as an array. Used by Swoole\ServerProcessInspector::stopServer() with commands like 'pgrep -P <managerPid>'.

```php
class Exec
{
    /**
     * Run the given command.
     *
     * @param  string  $command
     * @return array
     */
    public function run($command)
    {
        exec($command, $output);

        return $output;
    }
}
```

```php
$pids = (new Exec)->run('pgrep -P 1234');
```

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

### Base Command class with InteractsWithIO

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/commands.md

Base class for all Octane commands, extending Illuminate\Console\Command and using the InteractsWithIO trait which provides output helpers and terminal-width utilities for rendering streamed worker output.

```php
class Command extends BaseCommand   // Illuminate\Console\Command
{
    use InteractsWithIO;
}
```

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

### SwooleClient class definition with constants and constructor

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/clients.md

Defines the SwooleClient class implementing Client and ServesStaticFiles, with a STATUS_CODE_REASONS constant mapping extra status codes to reason phrases and a constructor accepting a chunk size defaulting to 1048576 bytes (1 MiB) for response chunking.

```php
class SwooleClient implements Client, ServesStaticFiles
{
    use StreamsGeneratorResponses;

    const STATUS_CODE_REASONS = [
        419 => 'Page Expired',
        425 => 'Too Early',
        431 => 'Request Header Fields Too Large',                             // RFC6585
        451 => 'Unavailable For Legal Reasons',                               // RFC7725
    ];

    public function __construct(protected int $chunkSize = 1048576)
    {
    }
}
```

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

### ApplicationGateway class definition with constructor

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/application-gateway.md

Defines the per-request gateway that bridges the sandbox application and HTTP kernel. The constructor takes the pristine root application and the ephemeral sandbox clone used to handle the request. Instantiated inside Worker::handle() as new ApplicationGateway($this->app, $sandbox).

```php
class ApplicationGateway
{
    use DispatchesEvents;

    public function __construct(protected Application $app, protected Application $sandbox)
    {
    }
}
```

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

### table() method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Signature for the table() method that retrieves a Swoole table instance. Throws exceptions if not running under Swoole or if the table is not configured.

```php
/**
 * Get a Swoole table instance.
 */
public function table(string $table): Table
```

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

### Swoole state sub-array shape

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/types.md

State sub-array written by StartSwooleCommand::writeServerStateFile(). Includes appName, host, port, workers, taskWorkers, maxRequests (default 500), publicPath, storagePath, defaultServerOptions (Swoole server settings), and octaneConfig.

```php
[
    'appName' => string,            // config('app.name', 'Laravel')
    'host' => string,
    'port' => string,
    'workers' => int,
    'taskWorkers' => int,
    'maxRequests' => int,          // default 500
    'publicPath' => string,
    'storagePath' => string,
    'defaultServerOptions' => array, // Swoole server settings (see commands.md)
    'octaneConfig' => array,        // config('octane')
]
```

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

### Resolve and use ServerProcessInspector

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/server-state.md

Resolve the RoadRunner ServerProcessInspector from the container and check if the server is running, then trigger a graceful worker reload.

```php
use Laravel\Octane\RoadRunner\ServerProcessInspector;

$inspector = app(ServerProcessInspector::class);

if ($inspector->serverIsRunning()) {
    $inspector->reloadServer();   // graceful worker reload
}
```

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

### RoadRunnerClient constructor

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/clients.md

Constructor for RoadRunnerClient that takes a Spiral\RoadRunner\Http\PSR7Worker instance as the required $client parameter.

```php
public function __construct(protected PSR7Worker $client)
```

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

### OctaneStore::getPrefix

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/cache.md

Returns the cache key prefix. Always returns an empty string.

```APIDOC
## OctaneStore::getPrefix

### Description
Returns the cache key prefix.

### Method
`getPrefix`

### Signature
`getPrefix()`

### Returns
- string - Always `''`.
```

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

### respond method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/clients.md

Sends response headers and content for the given Octane response.

```php
public function respond(RequestContext $context, OctaneResponse $octaneResponse): void
```

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

### SwooleClient constructor signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/clients.md

Constructor for SwooleClient with an optional integer chunk size parameter defaulting to 1048576 bytes (1 MiB), used for chunking response content.

```php
public function __construct(protected int $chunkSize = 1048576)
```

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

### marshalRequest() method

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/clients.md

Converts the PSR-7 request from RequestContext into an HttpFoundation request using the MarshalsPsr7RequestsAndResponses trait. Returns an array containing the HttpFoundation request and the original context.

```php
public function marshalRequest(RequestContext $context): array
{
    return [
        $this->toHttpFoundationRequest($context->psr7Request),
        $context,
    ];
}
```

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

### marshalRequest method

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/clients.md

Converts a Swoole request to an Illuminate request using ConvertSwooleRequestToIlluminateRequest, returning an array with the request and context. Handles form-urlencoded bodies for PUT/PATCH/DELETE and corrects headers under cli-server SAPI.

```php
public function marshalRequest(RequestContext $context): array
{
    return [
        (new Actions\ConvertSwooleRequestToIlluminateRequest)(
            $context->swooleRequest,
            PHP_SAPI
        ),
        $context,
    ];
}
```

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

### Publish octane config with artisan vendor:publish

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/service-provider.md

Command to publish the octane configuration file under the 'octane-config' tag.

```bash
php artisan vendor:publish --tag=octane-config
```

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

### resolve() method with docblock

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/task-dispatchers.md

Resolves the given callbacks via background tasks, returning results keyed by their given keys. If a task did not finish, the task's value will be 'false'. Throws TaskException or TaskTimeoutException. The $waitMilliseconds parameter is accepted for interface compatibility but tasks are executed synchronously regardless.

```php
/**
 * Concurrently resolve the given callbacks via background tasks, returning the results.
 *
 * Results will be keyed by their given keys - if a task did not finish, the tasks value will be "false".
 *
 *
 * @throws \Laravel\Octane\Exceptions\TaskException
 * @throws \Laravel\Octane\Exceptions\TaskTimeoutException
 */
public function resolve(array $tasks, int $waitMilliseconds = 1): array
```

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

### EnsureRequestsDontExceedMaxExecutionTime constructor and __invoke signatures

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/swoole-internals.md

Scans the timer table for worker rows where time() - row['time'] > maxExecutionTime; skips rows already superseded (fd changed); deletes the row; SIGKILLs the worker PID; then responds with a 408 Swoole response when the server still has the request's fd open. The timer table is created by bin/createSwooleTimerTable.php only when octane.max_execution_time > 0, with columns worker_pid, time, fd (size octane.max_timer_table_size, default 250).

```php
public function __construct(
    protected SwooleExtension $extension,
    protected $timerTable,
    protected $maxExecutionTime,
    protected ?Server $server = null
)
public function __invoke()
```

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

### FrankenPHP state sub-array shape

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/types.md

State sub-array written by StartFrankenPhpCommand::writeServerStateFile(). Includes appName, host, port, adminHost (default 'localhost'), adminPort (default 2019), workers (0 when 'auto'), maxRequests, and octaneConfig.

```php
[
    'appName' => string,
    'host' => string,
    'port' => string,
    'adminHost' => string,         // default 'localhost'
    'adminPort' => int,            // default 2019
    'workers' => int,              // 0 when 'auto'
    'maxRequests' => int,
    'octaneConfig' => array,
]
```

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

### Worker boot method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/worker.md

Signature for the boot method, which initializes the Octane worker with optional initial container instances. It creates the base application and dispatches the WorkerStarting event.

```php
/**
 * Boot / initialize the Octane worker.
 */
public function boot(array $initialInstances = []): void
```

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

### PosixExtension::kill - Send POSIX signal to process

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/utilities.md

Sends a signal to a given process using the POSIX extension. Returns a boolean. Used by RoadRunner\ServerProcessInspector.

```php
/**
 * Send a signal to a given process using the POSIX extension.
 *
 * @return bool
 */
public function kill(int $processId, int $signal)
{
    return posix_kill($processId, $signal);
}
```

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

### Octane facade @method annotations

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Documents the methods available on the Octane facade via PHPDoc annotations. Lists tick, table, invokeRoute, concurrently, hasRouteFor, and route methods with their signatures.

```php
/**
 * @method static \Laravel\Octane\Swoole\InvokeTickCallable tick(string $key, callable $callback, int $seconds = 1, bool $immediate = true)
 * @method static \Swoole\Table table(string $name)
 * @method static \Symfony\Component\HttpFoundation\Response invokeRoute(\Illuminate\Http\Request $request, string $method, string $uri)
 * @method static array concurrently(array $tasks, int $waitMilliseconds = 3000)
 * @method static bool hasRouteFor(string $method, string $uri)
 * @method static void route(string $method, string $uri, \Closure $callback)
 *
 * @see \Laravel\Octane\Octane
 */
```

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

### ProvidesRouting trait method signatures

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Declares the route(), hasRouteFor(), invokeRoute(), and getRoutes() methods from the ProvidesRouting trait. route() registers a callback under the composite key $method.$uri; invokeRoute() calls the callback with the request; getRoutes() returns all registered routes keyed by $method.$uri.

```php
public function route(string $method, string $uri, Closure $callback): void   // line 16
public function hasRouteFor(string $method, string $uri): bool                // line 23
public function invokeRoute(Request $request, string $method, string $uri): Response // line 30
public function getRoutes(): array                                           // line 39
```

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

### Update RoadRunner dependencies in composer.json

Source: https://github.com/laravel/octane/blob/2.x/UPGRADE.md

Replace spiral/roadrunner with spiral/roadrunner-http and spiral/roadrunner-cli in your composer.json file.

```diff
-   "spiral/roadrunner": "^2.8.2",
+   "spiral/roadrunner-http": "^3.0.1",
+   "spiral/roadrunner-cli": "^2.5.0",
```

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

### register() method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/service-provider.md

Public method of OctaneServiceProvider that merges config, binds listener singletons, registers the 'octane' core service, and sets up server process inspectors and coroutine dispatcher.

```php
public function register()
```

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

### route()

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/octane.md

Registers a callback under the composite key `$method.$uri` for internal routing.

```APIDOC
## route()

### Description
Registers a callback under the composite key `$method.$uri` for internal routing.

### Method
`route`

### Signature
`public function route(string $method, string $uri, Closure $callback): void`

### Parameters
- **$method** (string) - Required - HTTP method (e.g., 'GET')
- **$uri** (string) - Required - URI path (e.g., '/custom')
- **$callback** (Closure) - Required - Callback to invoke when route is matched

### Return
`void`

### Example
```php
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Laravel\Octane\Facades\Octane;

Octane::route('GET', '/custom', function (Request $request) {
    return new Response('hello');
});
```
```

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

### SymfonyProcessFactory::createProcess - Create Symfony Process instance

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/utilities.md

Creates a new Symfony Process instance with configurable command, working directory, environment, input, and timeout. Returns a Symfony\Component\Process\Process object.

```php
/**
 * Create a new Symfony process instance.
 *
 * @param  mixed|null  $input
 * @return \Symfony\Component\Process\Process
 */
public function createProcess(array $command, ?string $cwd = null, ?array $env = null, $input = null, ?float $timeout = 60)
{
    return new Process($command, $cwd, $env, $input, $timeout);
}
```

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

### Swoole cache table configuration in config/octane.php

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/cache.md

Configuration snippet for the Swoole cache table. The table is created only when 'octane.cache' is set. The 'rows' key sets the table row count and 'bytes' sets the maximum bytes per value column.

```php
// config/octane.php
'cache' => [
    'rows' => 1000,   // table row count
    'bytes' => 10000,  // max bytes per value column
],
```

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

### Run tasks concurrently with Octane::concurrently

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/task-dispatchers.md

Use Octane::concurrently to execute multiple tasks in parallel and collect their results. The second argument sets a timeout in milliseconds; if a task exceeds it, the result is false and a TaskTimeoutException is thrown. The returned array is keyed by the provided task names.

```php
use Laravel\Octane\Facades\Octane;

$results = Octane::concurrently([
    'users'   => fn () => (new UserService)->list(),
    'reports' => fn () => Report::generate(),
], 5000);   // throw TaskTimeoutException after 5000ms

if ($results['reports'] === false) {
    // task did not finish in time
}
```

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

### RequestContext constructor

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/request-context.md

Constructor for RequestContext accepting an optional initial data array.

```php
public function __construct(public array $data = [])
```

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

### warm() method signature

Source: https://github.com/laravel/octane/blob/2.x/_autodocs/api-reference/application-factory.md

Warms the application with pre-resolved, cached services that persist across requests. Accepts an optional array of container keys to resolve; when empty, uses config('octane.warm', []). Returns the bootstrapped Application.

```php
/**
 * Warm the application with pre-resolved, cached services that persist across requests.
 */
public function warm(Application $app, array $services = []): Application
```
Tokens:
Raw