ReactPHP

https://reactphp.org/
Admin
ReactPHP is a low-level library for event-driven, non-blocking I/O programming in PHP with...
Tokens:91,282
Snippets:1,177
Trust Score:9.8
Update:1 month ago
Show doc for...
Tokens:
Raw
### Perform HTTP GET Request

Source: https://reactphp.org/http-client

Complete example showing how to initiate a GET request, handle response data, and manage the event loop.

```php
<?php

$loop = React\EventLoop\Factory::create();
$client = new React\HttpClient\Client($loop);

$request = $client->request('GET', 'https://github.com/');
$request->on('response', function ($response) {
    $response->on('data', function ($chunk) {
        echo $chunk;
    });
    $response->on('end', function() {
        echo 'DONE';
    });
});
$request->on('error', function (\Exception $e) {
    echo $e;
});
$request->end();
$loop->run();
```

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

### Install ReactPHP Async via Composer

Source: https://reactphp.org/async

Standard installation command for the library.

```bash
composer require react/async:^4.3
```

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

### Install via Composer

Source: https://reactphp.org/http-client

Install the latest supported version of the library using Composer.

```bash
$ composer require react/http-client:^0.5.10
```

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

### Install dependencies and run tests

Source: https://reactphp.org/datagram

Commands to prepare the environment and execute the test suite.

```bash
composer install
```

```bash
vendor/bin/phpunit
```

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

### Install Dependencies

Source: https://reactphp.org/cache

Install project dependencies after cloning the repository.

```bash
composer install
```

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

### Install ReactPHP DNS

Source: https://reactphp.org/dns

Use Composer to install the library in your project.

```bash
composer require react/dns:^1.14
```

```bash
composer require react/dns:^1.14.0
```

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

### Perform HTTP Request to Localhost

Source: https://reactphp.org/http-client/changelog.html

Example of initiating a GET request to a local host, which works across all platforms.

```php
$client = new Client($loop);
$request = $client->request('GET', 'http://localhost/');
$request->on('response', function (Response $response) {
    // …
});
$request->end();
```

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

### Initialize and use HTTP Browser

Source: https://reactphp.org/http/changelog.html

Demonstrates creating a browser instance and performing an asynchronous GET request.

```php
$browser = new React\Http\Browser($loop);
$browser->get($url)->then(function (Psr\Http\Message\ResponseInterface $response) {
    echo $response->getBody();
});
```

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

### Install dependencies via Composer

Source: https://reactphp.org/socket-client

Run this command to install project dependencies after cloning the repository.

```bash
$ composer install
```

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

### Install ReactPHP Promise Timer

Source: https://reactphp.org/promise-timer

Use Composer to install the latest supported version of the library.

```bash
composer require react/promise-timer:^1.11
```

```bash
composer require react/promise-timer:^1.11.0
```

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

### View process hierarchy

Source: https://reactphp.org/child-process

Example of the process tree structure when using the default shell wrapper.

```text
5480 … \_ php example.php
5481 …    \_ sh -c yes
5482 …        \_ yes
```

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

### Initialize ReadableResourceStream

Source: https://reactphp.org/stream/changelog.html

Example of initializing a new readable resource stream.

```php
$stream = new ReadableResourceStream(STDIN, $loop);
```

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

### Install PromiseTimer via Composer

Source: https://reactphp.org/promise-timer/changelog.html

The standard command to install the latest version of the library using Composer.

```bash
composer require react/promise-timer:^1.11.0
```

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

### Default process creation on Windows

Source: https://reactphp.org/child-process

Attempting to start a process with default pipes on Windows will result in a LogicException.

```php
// throws LogicException on Windows
$process = new Process('ping example.com');
$process->start();
```

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

### Handle process I/O streams

Source: https://reactphp.org/child-process

Demonstrates interacting with STDOUT and STDIN streams after starting a process.

```php
$process = new Process($command);
$process->start();

$process->stdout->on('data', function ($chunk) {
    echo $chunk;
});

$process->stdout->on('end', function () {
    echo 'ended';
});

$process->stdout->on('error', function (Exception $e) {
    echo 'error: ' . $e->getMessage();
});

$process->stdout->on('close', function () {
    echo 'closed';
});

$process->stdin->write($data);
$process->stdin->end($data = null);
// …
```

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

### Create a basic HTTP server with ReactPHP

Source: https://reactphp.org

This example demonstrates setting up a simple HTTP server that responds with 'Hello World!' using the ReactPHP HTTP and Socket components.

```php
<?php

// $ composer require react/http react/socket # install example using Composer
// $ php example.php # run example on command line, requires no additional web server

require __DIR__ . '/vendor/autoload.php';

$http = new React\Http\HttpServer(function (Psr\Http\Message\ServerRequestInterface $request) {
    return React\Http\Message\Response::plaintext(
        "Hello World!\n"
    );
});

$socket = new React\Socket\SocketServer('127.0.0.1:8080');
$http->listen($socket);

echo "Server running at http://127.0.0.1:8080" . PHP_EOL;
```

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

### Install ReactPHP Promise Stream

Source: https://reactphp.org/promise-stream

Use Composer to install the latest supported version of the library.

```bash
composer require react/promise-stream:^1.7
```

```bash
composer require react/promise-stream:^1.7.0
```

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

### Initialize SecureServer with PEM certificate

Source: https://reactphp.org/socket

Basic setup for a SecureServer using a PEM encoded certificate file.

```php
$server = new React\Socket\TcpServer(8000);
$server = new React\Socket\SecureServer($server, null, array(
    'local_cert' => 'server.pem'
));
```

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

### Install ReactPHP Stream via Composer

Source: https://reactphp.org/stream

Use Composer to install the latest supported version of the library.

```bash
composer require react/stream:^1.4
```

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

### Install library via Composer

Source: https://reactphp.org/datagram

Standard command to add the library dependency to a project.

```bash
composer require react/datagram:^1.10
```

```bash
composer require react/datagram:^1.10.0
```

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

### Install PromiseStream via Composer

Source: https://reactphp.org/promise-stream/changelog.html

Command to install the latest version of the PromiseStream library.

```bash
composer require react/promise-stream:^1.7.0
```

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

### Start a TLS server

Source: https://reactphp.org/socket

Prepend the tls:// scheme to the URI and provide TLS context options including the certificate file.

```php
$socket = new React\Socket\SocketServer('tls://127.0.0.1:8080', array(
    'tls' => array(
        'local_cert' => 'server.pem'
    )
));
```

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

### View process hierarchy without shell wrapper

Source: https://reactphp.org/child-process

Example of the process tree structure when using the exec command.

```text
5480 … \_ php example.php
5481 …    \_ yes
```

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

### Install Async via Composer

Source: https://reactphp.org/async/license.html

Use this command to add the Async library to your project dependencies.

```bash
composer require react/async:^4.3.0
```

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

### Create Connections with Connector

Source: https://reactphp.org/socket-client

Examples of using the Connector class to establish various types of streaming connections.

```php
$loop = React\EventLoop\Factory::create();
$connector = new Connector($loop);

$connector->connect($uri)->then(function (ConnectionInterface $connection) {
    $connection->write('...');
    $connection->end();
});

$loop->run();
```

```php
$connector->connect('www.google.com:80')->then(function (ConnectionInterface $connection) {
    $connection->write('...');
    $connection->end();
});
```

```php
$connector->connect('tls://www.google.com:443')->then(function (ConnectionInterface $connection) {
    $connection->write('...');
    $connection->end();
});
```

```php
$connector->connect('unix:///tmp/demo.sock')->then(function (ConnectionInterface $connection) {
    $connection->write('...');
    $connection->end();
});
```

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

### Execute a child process

Source: https://reactphp.org/child-process

Starts a process and listens for output and exit events.

```php
$process = new React\ChildProcess\Process('echo foo');
$process->start();

$process->stdout->on('data', function ($chunk) {
    echo $chunk;
});

$process->on('exit', function($exitCode, $termSignal) {
    echo 'Process exited with code ' . $exitCode . PHP_EOL;
});
```

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

### Install ReactPHP Event Loop via Composer

Source: https://reactphp.org/event-loop

Use this command to add the library to your project dependencies.

```bash
composer require react/event-loop:^1.6
```

```bash
composer require react/event-loop:^1.6.0
```

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

### Install HttpClient via Composer

Source: https://reactphp.org/http-client/license.html

Use this command to add the HttpClient library to your project dependencies.

```bash
composer require react/http-client:^0.5.11
```

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

### Install ReactPHP HTTP via Composer

Source: https://reactphp.org/http/license.html

Use this command to install the ReactPHP HTTP component in your project.

```bash
composer require react/http:^1.11.0
```

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

### Install SocketClient via Composer

Source: https://reactphp.org/socket-client/license.html

Use this command to add the SocketClient library to your project dependencies.

```bash
composer require react/socket-client:^0.7.0
```

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

### Install multiple versions for compatibility

Source: https://reactphp.org/async

Command to target multiple major versions of the library to support a wider range of PHP environments.

```bash
composer require "react/async:^4 || ^3 || ^2"
```

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

### Attach HttpServer to a SocketServer

Source: https://reactphp.org/http

Starts listening for incoming connections by attaching the HttpServer to a SocketServer instance.

```php
$http = new React\Http\HttpServer($handler);

$socket = new React\Socket\SocketServer('0.0.0.0:8080');
$http->listen($socket);
```

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

### Configure HTTP and HTTPS Servers

Source: https://reactphp.org/http/changelog.html

Shows the transition from older plaintext server initialization to the updated Socket component usage, including secure HTTPS server setup.

```php
// old plaintext HTTP server
$socket = new React\Socket\Server($loop);
$socket->listen(8080, '127.0.0.1');
$http = new React\Http\Server($socket);

// new plaintext HTTP server
$socket = new React\Socket\Server('127.0.0.1:8080', $loop);
$http = new React\Http\Server($socket);

// new secure HTTPS server
$socket = new React\Socket\Server('127.0.0.1:8080', $loop);
$socket = new React\Socket\SecureServer($socket, $loop, array(
    'local_cert' => __DIR__ . '/localhost.pem'
));
$http = new React\Http\Server($socket);
```

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

### Configure Write Chunk Size

Source: https://reactphp.org/stream

Example of initializing the stream with a custom write chunk size in bytes.

```php
$stream = new WritableResourceStream(STDOUT, null, null, 8192);
```

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

### Configure Read Chunk Size

Source: https://reactphp.org/stream

Example of initializing the stream with a specific read chunk size for buffer control.

```php
$stream = new ReadableResourceStream(STDIN, null, 8192);
```

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

### Systemd socket activation command

Source: https://reactphp.org/socket/changelog.html

Example command to activate a PHP socket server using systemd.

```bash
$ systemd-socket-activate -l 8000 php examples/03-http-server.php php://fd/3
```

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

### Configure Write Buffer Soft Limit

Source: https://reactphp.org/stream

Example of initializing the stream with a custom write buffer soft limit in bytes.

```php
$stream = new WritableResourceStream(STDOUT, null, 8192);
```

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

### Configure RequestBodyBufferMiddleware

Source: https://reactphp.org/http

Example showing the integration of RequestBodyBufferMiddleware within an HttpServer, including concurrent request limiting.

```php
$http = new React\Http\HttpServer(
    new React\Http\Middleware\StreamingRequestMiddleware(),
    new React\Http\Middleware\LimitConcurrentRequestsMiddleware(100), // 100 concurrent buffering handlers
    new React\Http\Middleware\RequestBodyBufferMiddleware(16 * 1024 * 1024), // 16 MiB
    function (Psr\Http\Message\ServerRequestInterface $request) {
        // The body from $request->getBody() is now fully available without the need to stream it 
        return new React\Http\Message\Response(React\Http\Message\Response::STATUS_OK);
    },
);
```

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

### Initialize Server and StreamingServer

Source: https://reactphp.org/http/changelog.html

Demonstrates the transition from the old Server class to the new PSR-7 compatible Server and the advanced StreamingServer.

```php
// old: handle incomplete/streaming requests
$server = new Server($handler);

// new: handle complete, buffered and parsed requests
// new: full PSR-7 support, including POST fields and file uploads
$server = new Server($handler);

// new: handle incomplete/streaming requests
$server = new StreamingServer($handler);
```

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

### Start an HTTP Server

Source: https://reactphp.org/http

Attaches an HttpServer to a SocketServer to begin listening for incoming plaintext or TLS-encrypted HTTP requests.

```php
$http = new React\Http\HttpServer($handler);

$socket = new React\Socket\SocketServer('0.0.0.0:8080');
$http->listen($socket);
```

```php
$http = new React\Http\HttpServer($handler);

$socket = new React\Socket\SocketServer('tls://0.0.0.0:8443', array(
    'tls' => array(
        'local_cert' => __DIR__ . '/localhost.pem'
    )
));
$http->listen($socket);
```

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

### Install Promise library via Composer

Source: https://reactphp.org/promise/license.html

Use this command to add the ReactPHP Promise library to your project dependencies.

```bash
composer require react/promise:^3.3.0
```

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

### Initialize Process with Default Loop

Source: https://reactphp.org/child-process/changelog.html

Demonstrates the simplified process initialization introduced in version 0.6.3, allowing the omission of the loop argument.

```php
// old (still supported)
$process = new React\ChildProcess\Process($command);
$process->start($loop);

// new (using default loop)
$process = new React\ChildProcess\Process($command);
$process->start();
```

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

### Send GET Request

Source: https://reactphp.org/http

Perform an HTTP GET request and handle the promise response.

```php
$browser->get($url)->then(function (Psr\Http\Message\ResponseInterface $response) {
    var_dump((string)$response->getBody());
}, function (Exception $e) {
    echo 'Error: ' . $e->getMessage() . PHP_EOL;
});
```

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

### Initialize Server with URI

Source: https://reactphp.org/socket/changelog.html

Pass the listening URI directly to the constructor instead of using the listen() method.

```php
// old
$server = new Server($loop);
$server->listen(8080);

// new
$server = new Server(8080, $loop);
```

```php
// old
$server = new Server($loop);
$server->listen(8080, '127.0.0.1');

// new
$server = new Server('127.0.0.1:8080', $loop);
```

```php
// old
$server = new Server($loop);
$server->listen(8080, 'localhost');

// new
$server = new Server('127.0.0.1:8080', $loop);
```

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

### Create HTTP Server

Source: https://reactphp.org/http

Initializes an HTTP server that responds with 'Hello World!' to every incoming request.

```php
<?php

require __DIR__ . '/vendor/autoload.php';

$http = new React\Http\HttpServer(function (Psr\Http\Message\ServerRequestInterface $request) {
    return React\Http\Message\Response::plaintext(
        "Hello World!\n"
    );
});

$socket = new React\Socket\SocketServer('127.0.0.1:8080');
$http->listen($socket);
```

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

### Create an async HTTP server with EventLoop

Source: https://reactphp.org/event-loop

Demonstrates setting up a non-blocking TCP server and a periodic timer using the global Loop interface.

```php
<?php

use React\EventLoop\Loop;

require __DIR__ . '/vendor/autoload.php';

$server = stream_socket_server('tcp://127.0.0.1:8080');
stream_set_blocking($server, false);

Loop::addReadStream($server, function ($server) {
    $conn = stream_socket_accept($server);
    $data = "HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nHi\n";
    Loop::addWriteStream($conn, function ($conn) use (&$data) {
        $written = fwrite($conn, $data);
        if ($written === strlen($data)) {
            fclose($conn);
            Loop::removeWriteStream($conn);
        } else {
            $data = substr($data, $written);
        }
    });
});

Loop::addPeriodicTimer(5, function () {
    $memory = memory_get_usage() / 1024;
    $formatted = number_format($memory, 3).'K';
    echo "Current memory usage: {$formatted}\n";
});
```

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

### Install Cache Component

Source: https://reactphp.org/cache/changelog.html

Use Composer to install the latest version of the ReactPHP Cache component.

```bash
composer require react/cache:^1.2.0
```

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

### Initialize Streams with Default Loop

Source: https://reactphp.org/stream/changelog.html

Demonstrates the transition from explicitly passing a loop instance to using the default loop for stream initialization.

```php
// old (still supported)
$stream = new ReadableResourceStream($resource, $loop);
$stream = new WritabeResourceStream($resource, $loop);
$stream = new DuplexResourceStream($resource, $loop);

// new (using default loop)
$stream = new ReadableResourceStream($resource);
$stream = new WritabeResourceStream($resource);
$stream = new DuplexResourceStream($resource);
```

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

### Install legacy PSR-7 dependency

Source: https://reactphp.org/http/changelog.html

Use this command to explicitly install the RingCentral PSR-7 dependency if required for backward compatibility.

```bash
composer require ringcentral/psr7
```

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

### Browser::get()

Source: https://reactphp.org/http

Sends an HTTP GET request to the specified URL.

```APIDOC
## GET $url

### Description
Sends an asynchronous HTTP GET request.

### Parameters
- **$url** (string) - Required - The target URL.
- **$headers** (array) - Optional - Associative array of additional headers.
```

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

### Initialize Browser

Source: https://reactphp.org/http

Basic instantiation of the Browser class.

```php
$browser = new React\Http\Browser();
```

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

### Retrieve local address

Source: https://reactphp.org/socket/changelog.html

Use getLocalAddress() to get the local socket address.

```php
echo $connection->getLocalAddress(); // 127.0.0.1:8080
```

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

### Initialize and use DnsConnector

Source: https://reactphp.org/socket

Sets up a DNS resolver and a DnsConnector to establish TCP/IP connections to hostnames.

```php
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached('8.8.8.8');

$dnsConnector = new React\Socket\DnsConnector($tcpConnector, $dns);

$dnsConnector->connect('www.google.com:80')->then(function (React\Socket\ConnectionInterface $connection) {
    $connection->write('...');
    $connection->end();
});
```

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

### Handle InvalidArgumentException

Source: https://reactphp.org/stream

Example of passing an invalid resource to the constructor, which results in an InvalidArgumentException.

```php
// throws InvalidArgumentException
$stream = new WritableResourceStream(false);
```

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

### Handle InvalidArgumentException

Source: https://reactphp.org/stream

Example of passing an invalid resource to the constructor, which triggers an exception.

```php
// throws InvalidArgumentException
$stream = new ReadableResourceStream(false);
```

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

### Create and use a DNS resolver

Source: https://reactphp.org/dns

Initializes a resolver using system configuration and resolves a hostname to an IP address.

```php
$config = React\Dns\Config\Config::loadSystemConfigBlocking();
if (!$config->nameservers) {
    $config->nameservers[] = '8.8.8.8';
}

$factory = new React\Dns\Resolver\Factory();
$dns = $factory->create($config);

$dns->resolve('igor.io')->then(function ($ip) {
    echo "Host: $ip\n";
});
```

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

### Simplify Resolver Factory Usage

Source: https://reactphp.org/dns/changelog.html

Demonstrates the transition from explicitly passing a loop to using the default loop in the DNS factory.

```php
// old (still supported)
$factory = new React\Dns\Resolver\Factory();
$resolver = $factory->create($config, $loop);

// new (using default loop)
$factory = new React\Dns\Resolver\Factory();
$resolver = $factory->create($config);
```

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

### Handle RuntimeException on Windows

Source: https://reactphp.org/stream

Example of a scenario where non-blocking mode cannot be enabled, resulting in a RuntimeException.

```php
// throws RuntimeException on Windows
$stream = new ReadableResourceStream(STDIN);
```

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

### Install EventLoop via Composer

Source: https://reactphp.org/event-loop/license.html

Use this command to add the EventLoop component to your project dependencies.

```bash
composer require react/event-loop:^1.6.0
```

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

### Initialize Unix Domain Socket Server

Source: https://reactphp.org/socket/changelog.html

Demonstrates creating a server using the unix:// URI scheme or the dedicated UnixServer class.

```php
// new: Server now supports "unix://" scheme
$server = new Server('unix:///tmp/server.sock', $loop);

// new: advanced usage
$server = new UnixServer('/tmp/server.sock', $loop);
```

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

### Initialize UnixServer

Source: https://reactphp.org/socket

Creates a new Unix domain socket server instance at the specified path.

```php
$server = new React\Socket\UnixServer('/tmp/server.sock');
```

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

### Install Datagram via Composer

Source: https://reactphp.org/datagram/license.html

Use this command to add the Datagram component to your project dependencies.

```bash
composer require react/datagram:^1.10.0
```

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

### Install ChildProcess via Composer

Source: https://reactphp.org/child-process/license.html

Use this command to add the ChildProcess library to your project dependencies.

```bash
composer require react/child-process:^0.6.7
```

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

### Connect via different protocols

Source: https://reactphp.org/socket

Demonstrates establishing plaintext TCP, secure TLS, and Unix domain socket connections using URI schemes.

```php
$connector->connect('www.google.com:80')->then(function (React\Socket\ConnectionInterface $connection) {
    $connection->write('...');
    $connection->end();
});
```

```php
$connector->connect('tls://www.google.com:443')->then(function (React\Socket\ConnectionInterface $connection) {
    $connection->write('...');
    $connection->end();
});
```

```php
$connector->connect('unix:///tmp/demo.sock')->then(function (React\Socket\ConnectionInterface $connection) {
    $connection->write('...');
    $connection->end();
});
```

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

### Retrieve server address

Source: https://reactphp.org/socket

Get the full URI the server is listening on, or extract the port from the address.

```php
$address = $socket->getAddress();
echo 'Server listening on ' . $address . PHP_EOL;
```

```php
$address = $socket->getAddress();
$port = parse_url($address, PHP_URL_PORT);
echo 'Server listening on port ' . $port . PHP_EOL;
```

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

### Initialize connectors with DNS support

Source: https://reactphp.org/socket-client/changelog.html

Shows the transition from the deprecated Connector class to the modern DnsConnector and TcpConnector classes.

```php
// old (still supported, but marked deprecated)
$connector = new Connector($loop, $resolver);

// new equivalent
$connector = new DnsConnector(new TcpConnector($loop), $resolver);

// new feature: supports connecting to IP addresses only
$connector = new TcpConnector($loop);
```

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

### Initialize ThroughStream with Data Callback

Source: https://reactphp.org/stream/changelog.html

Demonstrates the simplified ThroughStream implementation using a data callback instead of inheritance.

```php
$through = new ThroughStream(function ($data) {
    return json_encode($data) . PHP_EOL;
});
$through->on('data', $this->expectCallableOnceWith("[2, true]\n"));

$through->write(array(2, true));
```

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

### Chain processes using exit events

Source: https://reactphp.org/child-process

Start a subsequent process only after the first one has exited.

```php
$first = new Process('cat first');
$first->start();

$first->on('exit', function () {
    $second = new Process('cat second');
    $second->start();
});
```

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

### Initialize HTTP Client

Source: https://reactphp.org/http-client

Basic instantiation of the Client using the EventLoop.

```php
$loop = React\EventLoop\Factory::create();
$client = new Client($loop);
```

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

### Create a DNS client for localhost

Source: https://reactphp.org/datagram/changelog.html

Use the factory to create a client targeting localhost, ensuring compatibility with local host files.

```php
$factory = new Factory($loop);
$factory->createClient('localhost:5353');
```

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

### Install Stream via Composer

Source: https://reactphp.org/stream/license.html

Use this command to add the ReactPHP Stream component to your project dependencies.

```bash
composer require react/stream:^1.4.0
```

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

### Install Socket via Composer

Source: https://reactphp.org/socket/license.html

Use this command to add the ReactPHP Socket component to your project dependencies.

```bash
composer require react/socket:^1.17.0
```

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

### Initialize Connector

Source: https://reactphp.org/socket

Shows the current and legacy constructor signatures for the Connector class.

```php
// constructor signature as of v1.9.0
$connector = new React\Socket\Connector(array $context = [], ?LoopInterface $loop = null);

// legacy constructor signature before v1.9.0
$connector = new React\Socket\Connector(?LoopInterface $loop = null, array $context = []);
```

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

### Establish a connection with connect()

Source: https://reactphp.org/socket-client

Uses the connect method to initiate a streaming connection to a remote address, returning a promise that resolves to a ConnectionInterface.

```php
$connector->connect('google.com:443')->then(
    function (ConnectionInterface $connection) {
        // connection successfully established
    },
    function (Exception $error) {
        // failed to connect due to $error
    }
);
```

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

### Handle RuntimeException on Windows

Source: https://reactphp.org/stream

Example of a scenario where non-blocking mode is not supported, such as pipes on Windows, causing a RuntimeException.

```php
// throws RuntimeException on Windows
$stream = new WritableResourceStream(STDOUT);
```

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

### HttpServer::__construct

Source: https://reactphp.org/http

Initializes a new HttpServer instance with a request handler function.

```APIDOC
## HttpServer::__construct

### Description
Initializes the HttpServer with a request handler function that processes PSR-7 ServerRequestInterface objects and returns a ResponseInterface.

### Parameters
- **handler** (callable) - Required - A function that accepts a Psr\Http\Message\ServerRequestInterface and returns a response.
- **loop** (LoopInterface|null) - Optional - The event loop instance to use.
```

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

### Initialize HTTP Client

Source: https://reactphp.org/http-client/changelog.html

Comparison between the deprecated factory-based initialization and the current constructor-based approach.

```php
// old
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $loop);
$factory = new React\HttpClient\Factory();
$client = $factory->create($loop, $dnsResolver);

// new
$client = new React\HttpClient\Client($loop);
```

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

### Execute a basic command

Source: https://reactphp.org/child-process

Run a simple command line string using the Process class.

```php
$process = new Process('echo test');
$process->start();
```

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

### Initialize SocketServer

Source: https://reactphp.org/socket

Create a new SocketServer instance to accept plaintext TCP/IP connections.

```php
$socket = new React\Socket\SocketServer('127.0.0.1:8080');
```

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

### Install DNS component via Composer

Source: https://reactphp.org/dns/license.html

Use this command to add the ReactPHP DNS component to your project dependencies.

```bash
composer require react/dns:^1.14.0
```

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

### Connect with TcpConnector

Source: https://reactphp.org/socket

Demonstrates creating a plaintext TCP/IP connection and handling the resulting connection interface.

```php
$tcpConnector = new React\Socket\TcpConnector();

$tcpConnector->connect('127.0.0.1:80')->then(function (React\Socket\ConnectionInterface $connection) {
    $connection->write('...');
    $connection->end();
});
```

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

### Retrieve a cache item

Source: https://reactphp.org/cache

Fetches a value from the cache using the get method, which resolves with the cached value or a default.

```php
$cache
    ->get('foo')
    ->then('var_dump');
```

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

### Handle server initialization errors

Source: https://reactphp.org/socket/changelog.html

Server initialization now throws a RuntimeException instead of a ConnectionException when listening fails.

```php
// old: throws React\Socket\ConnectionException
$server = new Server($loop);
$server->listen(80);

// new: throws RuntimeException
$server = new Server(80, $loop);
```

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

### Establish a connection with Connector

Source: https://reactphp.org/socket/changelog.html

Use the Connector class to initiate async, streaming TCP/IP or TLS socket connections.

```php
$connector = new React\Socket\Connector($loop);
$connector->connect('google.com:80')->then(function (ConnectionInterface $conn) {
    $connection->write('…');
});
```

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

### Initialize a TcpServer

Source: https://reactphp.org/socket

Basic instantiation of a TcpServer listening on a specific port.

```php
$server = new React\Socket\TcpServer(8080);
```

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

### Simplify instantiation with default loop

Source: https://reactphp.org/http/changelog.html

Illustrates the simplified instantiation of Browser and Server classes by omitting the explicit loop argument.

```php
// old (still supported)
$browser = new React\Http\Browser($loop);
$server = new React\Http\Server($loop, $handler);

// new (using default loop)
$browser = new React\Http\Browser();
$server = new React\Http\Server($handler);
```

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

### Access Request URI Scheme

Source: https://reactphp.org/http/changelog.html

Example of accessing PSR-7 request properties like the URI scheme within the handler.

```php
$app = function (ServerRequestInterface $request) {
    return new Response(
        200,
        array('Content-Type' => 'text/plain'),
        $request->getUri()->getScheme()
    );
};
```

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

### Initialize SocketServer on IPv6

Source: https://reactphp.org/socket

Listen on an IPv6 address by enclosing the host in square brackets.

```php
$socket = new React\Socket\SocketServer('[::1]:8080');
```

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

### Create a basic TCP server

Source: https://reactphp.org/socket

Initializes a SocketServer on a specific address and port, listening for incoming connections and handling data events.

```php
$socket = new React\Socket\SocketServer('127.0.0.1:8080');

$socket->on('connection', function (React\Socket\ConnectionInterface $connection) {
    $connection->write("Hello " . $connection->getRemoteAddress() . "!\n");
    $connection->write("Welcome to this amazing server!\n");
    $connection->write("Here's a tip: don't say anything.\n");

    $connection->on('data', function ($data) use ($connection) {
        $connection->close();
    });
});
```

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

### get(string $key, mixed $default = null)

Source: https://reactphp.org/cache

Retrieves an item from the cache. Resolves with the cached value or the provided default value on cache miss or error.

```APIDOC
## get(string $key, mixed $default = null)

### Description
Retrieves an item from the cache. This method returns a PromiseInterface that resolves with the cached value on success, or the provided $default value if the key is not found or an error occurs.

### Parameters
- **$key** (string) - Required - The unique key of the item to retrieve.
- **$default** (mixed) - Optional - The value to return if the item is not found or an error occurs.
```

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

### Update Server constructor and middleware

Source: https://reactphp.org/http/changelog.html

Illustrates the requirement of the loop interface and the shift to variadic middleware arguments.

```php
// old
$server = new React\Http\Server($handler);
$server = new React\Http\Server([$middleware, $handler]);

// new
$server = new React\Http\Server($loop, $handler);
$server = new React\Http\Server($loop, $middleware, $handler);
```

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

### React\ChildProcess\Process

Source: https://reactphp.org/child-process

The Process class is the primary interface for executing external commands. It allows starting a process, interacting with its standard I/O streams, and listening for termination events.

```APIDOC
## Class: React\ChildProcess\Process

### Description
Represents an external process that can be executed asynchronously. Once started, it provides access to STDIN, STDOUT, and STDERR streams.

### Constructor
`new React\ChildProcess\Process(string $command)`

### Methods
- **start()**: Starts the process. I/O streams are initialized upon calling this method.
- **on(string $event, callable $listener)**: Attaches event listeners. Supported events include 'exit' (emitted with $exitCode and $termSignal).

### Properties
- **$stdin**: WritableStreamInterface (for writing to the process)
- **$stdout**: ReadableStreamInterface (for reading process output)
- **$stderr**: ReadableStreamInterface (for reading process error output)

### Example
```php
$process = new React\ChildProcess\Process('echo foo');
$process->start();

$process->stdout->on('data', function ($chunk) {
    echo $chunk;
});

$process->on('exit', function($exitCode, $termSignal) {
    echo 'Process exited with code ' . $exitCode;
});
```
```

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

### Initialize Datagram Factory

Source: https://reactphp.org/datagram/changelog.html

Demonstrates the transition from passing an explicit loop to using the default loop in the Datagram Factory.

```php
// old (still supported)
$factory = new React\Datagram\Factory($loop);

// new (using default loop)
$factory = new React\Datagram\Factory();
```

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

### Initialize SecureServer with passphrase

Source: https://reactphp.org/socket

Configuration for a SecureServer when the private key is encrypted with a passphrase.

```php
$server = new React\Socket\TcpServer(8000);
$server = new React\Socket\SecureServer($server, null, array(
    'local_cert' => 'server.pem',
    'passphrase' => 'secret'
));
```

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

### Importing Async Functions

Source: https://reactphp.org/async

Demonstrates different ways to reference React/Async functions, including fully-qualified names and function imports.

```php
React\Async\await(…);
```

```php
use function React\Async\await;

await(…);
```

```php
use React\Async;

Async\await(…);
```

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

### Run Test Suite

Source: https://reactphp.org/cache

Execute the PHPUnit test suite from the project root.

```bash
vendor/bin/phpunit
```

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

### Initialize SocketServer on all interfaces

Source: https://reactphp.org/socket

Listen on all available network interfaces using the 0.0.0.0 address.

```php
$socket = new React\Socket\SocketServer('0.0.0.0:8080');
```

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

### Manual XML Response Construction

Source: https://reactphp.org/http

Demonstrates the manual instantiation of a Response object equivalent to the xml() shortcut method.

```php
$response = new React\Http\Message\Response(
    React\Http\Message\Response::STATUS_OK,
    [
        'Content-Type' => 'application/xml'
    ],
    $xml
);
```

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

### Initialize HttpServer with a request handler

Source: https://reactphp.org/http

Creates an HttpServer instance that returns a plaintext response for every incoming request.

```php
$http = new React\Http\HttpServer(function (Psr\Http\Message\ServerRequestInterface $request) {
    return React\Http\Message\Response::plaintext(
        "Hello World!\n"
    );
});
```

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

### Handle Connection Events and Methods

Source: https://reactphp.org/socket-client

Demonstrates standard event listeners and stream methods available on a ConnectionInterface instance.

```php
$connection->on('data', function ($chunk) {
    echo $chunk;
});

$connection->on('end', function () {
    echo 'ended';
});

$connection->on('error', function (Exception $e) {
    echo 'error: ' . $e->getMessage();
});

$connection->on('close', function () {
    echo 'closed';
});

$connection->write($data);
$connection->end($data = null);
$connection->close();
// …
```

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

### Update Server Initialization

Source: https://reactphp.org/http/changelog.html

Replaces the 'request' event listener with a direct callback passed to the Server constructor and uses the listen method.

```php
// old
$server = new Server($socket);
$server->on('request', $app);

// new
$server = new Server($app);
$server->listen($socket);
```

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

### Create a basic TCP client

Source: https://reactphp.org/socket

Uses a Connector to establish an outgoing connection to a server, piping the response to STDOUT and sending data.

```php
$connector = new React\Socket\Connector();

$connector->connect('127.0.0.1:8080')->then(function (React\Socket\ConnectionInterface $connection) {
    $connection->pipe(new React\Stream\WritableResourceStream(STDOUT));
    $connection->write("Hello World!\n");
}, function (Exception $e) {
    echo 'Error: ' . $e->getMessage() . PHP_EOL;
});
```

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

### new React\Socket\SocketServer(string $uri, array $context = [])

Source: https://reactphp.org/socket

Instantiates a new SocketServer instance. The URI defines the address and protocol (e.g., '0.0.0.0:8080', 'unix://...', 'tls://...'). Optional context array allows configuration of TCP or TLS settings.

```APIDOC
## Constructor: new React\Socket\SocketServer(string $uri, array $context = [])

### Description
Creates a new socket server instance. The server will begin listening on the specified URI immediately upon instantiation.

### Parameters
- **uri** (string) - Required - The URI to listen on. Examples: '0.0.0.0:8080', '[::1]:8080', 'unix:///tmp/server.sock', 'php://fd/3', or 'tls://127.0.0.1:8080'.
- **context** (array) - Optional - An array of stream context options for 'tcp' or 'tls' configurations.

### Exceptions
- **InvalidArgumentException** - Thrown if the URI is invalid, missing a port, or contains an unsupported scheme.
- **RuntimeException** - Thrown if the server fails to bind to the specified address (e.g., port in use or insufficient permissions).
```

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

### Update DNS Factory Configuration

Source: https://reactphp.org/dns/changelog.html

Shows how to pass a full Config object to the factory instead of a single nameserver string.

```php
// old (still supported)
$config = React\Dns\Config\Config::loadSystemConfigBlocking();
$server = $config->nameservers ? reset($config->nameservers) : '8.8.8.8';
$resolver = $factory->create($server, $loop);

// new
$config = React\Dns\Config\Config::loadSystemConfigBlocking();
if (!$config->nameservers) {
    $config->nameservers[] = '8.8.8.8';
}
$resolver = $factory->create($config, $loop);
```

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

### Initialize and use SecureConnector

Source: https://reactphp.org/socket

Wraps a DnsConnector with a SecureConnector to enable TLS encryption for connections.

```php
$secureConnector = new React\Socket\SecureConnector($dnsConnector);

$secureConnector->connect('www.google.com:443')->then(function (React\Socket\ConnectionInterface $connection) {
    $connection->write("GET / HTTP/1.0\r\nHost: www.google.com\r\n\r\n");
    ...
});
```

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

### Create a DNS client for intranet hosts

Source: https://reactphp.org/datagram/changelog.html

Use the factory to create a client targeting a specific DNS server, such as an intranet host.

```php
$factory = new Factory($loop);
$factory->createClient('intranet.example:5353');
```

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

### Update Socket Server Initialization

Source: https://reactphp.org/changelog.html

The Server constructor now accepts the port or URI directly, replacing the separate listen() method.

```php
// old
$server = new Server($loop);
$server->listen(8080);

// new
$server = new Server(8080, $loop);
```

```php
// old
$server = new Server($loop);
$server->listen(8080, '127.0.0.1');

// new
$server = new Server('127.0.0.1:8080', $loop);
```

```php
// old
$server = new Server($loop);
$server->listen(8080, 'localhost');

// new
$server = new Server('127.0.0.1:8080', $loop);
```

```php
// old: throws React\Socket\ConnectionException
$server = new Server($loop);
$server->listen(80);

// new: throws RuntimeException
$server = new Server(80, $loop);
```
Tokens:
Raw