Event-driven non-blocking I/O in PHP. 

A programming paradigm where code 

execution is triggered by events.

Program can work on other task while

 waiting for input/output operations.

andrer@dev:~/http-analyzer (master)$ ./http-analyzer analyze github.com
GET: http://github.com
IP: 192.30.252.129
Status Code: 200
Time spent in 1 redirection(s): 302 ms
Response size:        12.3 KB

  DNS Lookup:           60.9 ms
  Connecting:          188.7 ms
  Sending:               0.1 ms
  Waiting (TTFB):      637.7 ms
  Recieving:             0.6 ms
  Total time:          940.3 ms 

Non-blocking I/O enables you to 

work on other requests while waiting.

But how do you know when it's done?

When an asynchronously non-blocking operation 

has progressed, it will tell you through events.

The following graphs comes from Phil Sturgeons 

blog post about benchmarking ReactPHP vs Node.js

http://philsturgeon.co.uk/blog/2013/11/benchmarking-codswallop-nodejs-v-php

The linearity of the red (and blue) line is 

caused by consistent network latency.

Node's maxConnection setting has been tuned, 

getting it up to speed with PHP.

$loop = React\EventLoop\Factory::create();

$source = new React\Stream\Stream(fopen('omg.txt', 'r'), $loop);
$dest = new React\Stream\Stream(fopen('wtf.txt', 'w'), $loop);

$source->pipe($dest);

$loop->run(); 

$redis = new Predis\Client();
$loop = React\EventLoop\Factory::create();

$buffer = '';

$dest = new React\Stream\Stream(fopen('local-copy.txt', 'w'), $loop);
$source = new React\Stream\Stream(fopen('http://internet/4GB-file.txt', 'r'), $loop);
$source->on('data', function($data) use (&$buffer, $redis) {
    $buffer .= $data;

    if (strpos($buffer, PHP_EOL) !== false) {
        foreach (explode(PHP_EOL, $buffer) as $line) {
            $redis->rpush('queue', $line);
        }

        $buffer = '';
    }
});

$dest->pipe($source);
$loop->run();

Based on CommonJS Promises/A

• Deferred
  
• Promise
  
• Resolver
  

<?php
function doAsyncHttpRequest($url) {
    $deferred = new React\Promise\Deferred();

    // Pass only the Resolver
    fetchHttpAsynchronously($deferred->resolver(), $url);

    // Return only the Promise, so that the caller cannot
    // resolve, reject, or otherwise work with the original Deferred.
    return $deferred->promise();
} 

$promise = doAsyncHttpRequest('http://api.awesome.com/sauce/21');

$promise->then(function($apiResponse) {
    echo 'API responded with ' . $apiResponse;
});

<?php
function doAsyncHttpRequest($resolver, $url) {
    // Perform the HTTP request asynchronously and 
    // resolve the promise using the API response.

    $resolver->resolve($response);
}

interface PromiseInterface {
    public function then(
        callable $fulfilledHandler = null, 
        callable $errorHandler = null, 
        callable $progressHandler = null
    );
}

interface ResolverInterface {
    public function resolve(mixed $result = null);
    public function reject(mixed $reason = null);
    public function progress(mixed $update = null);}

Used for creation, joining, mapping 

and reducing collections of Promises.

$promise = React\Promise\When::all(
    array|React\Promise\PromiseInterface $promisesOrValues,
    callable $fulfilledHandler = null,
    callable $errorHandler = null,
    callable $progressHandler = null
);

$promise = React\Promise\When::any(
    array|React\Promise\PromiseInterface $promisesOrValues,
    callable $fulfilledHandler = null,
    callable $errorHandler = null,
    callable $progressHandler = null
);

$promise = React\Promise\When::some(
    array|React\Promise\PromiseInterface $promisesOrValues,
    integer $howMany,
    callable $fulfilledHandler = null,
    callable $errorHandler = null,
    callable $progressHandler = null
);

$promise = React\Promise\When::map(
    array|React\Promise\PromiseInterface $promisesOrValues,
    callable $mapFunc
);

$promise = React\Promise\When::reduce(
    array|React\Promise\PromiseInterface $promisesOrValues,
    callable $reduceFunc,
    $initialValue = null
);

Pre-fills argument(s) to a given function 

function multiplyNumbers($a, $b) {
    return $a * $b;
}

$vat = 1.24;

$priceA = 100;
$priceAWithVat = multiplyNumbers($price, $vat);

$priceB = 300;
$priceBWithVat = multiplyNumbers($price, $vat);

$addVat = React\Partial\bind('multiplyNumbers', 1.24);

$priceA = 100;
$priceAWithVat = $addVat($price);

$priceB = 100;
$priceBWithVat = $addVat($price);

Useful for adding arguments you have now,

but not when the function will be used in the future.

$url = 'http://www.vg.no';

$promise = performAsyncGet($url);

function responseHandler($url, $response) {
    // Your handler wants both the $url and $response
}

$promise->then('responseHandler'); // But.. we have no URL?

$promise->then(function($data) use ($url) {
    responseHandler($url, $data);
});

$promise->then(React\Partial\bind('responseHandler', $url));

A rather silly example on how to use 

the different components together.

We want to GET several URLs in parallel and
show how many bytes each where and
create a grand total.

<?php
require 'vendor/autoload.php';

$loop = React\EventLoop\Factory::create();

$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $loop);

$factory = new React\HttpClient\Factory();
$client = $factory->create($loop, $dnsResolver);

function handleResponse($resolver, $response) {
    $body = '';

    $response->on('data', function ($data) use (&$body) {
        $body .= $data;
    });

    $response->on('end', function() use (&$body, $resolver) {
        $resolver->resolve($body);
    });
}

$promises = [];

foreach (['http://www.vg.no', 'http://www.google.com'] as $url) {
    $deferred = new React\Promise\Deferred();
    $promise = $deferred->promise();

    $promise->then(function($data) use ($url) {
        // Executed when the $url is loaded and does not know about any other requests.
        printf('%s responded with %d bytes' . PHP_EOL, $url, strlen($data));
    });

    $request = $client->request('GET', $url);
    $request->on('response', React\Partial\bind('handleResponse', $deferred->resolver()));
    $request->end();
    
    $promises[] = $promise;
}

React\Promise\When::reduce($promises,
    function ($value, $data) {
        return strlen($data) + $value;
    }
)->then(function($data) {
    printf('Downloaded %d bytes in total.' . PHP_EOL, $data);
});

$loop->run();

http://www.google.com responded with 258 bytes
http://www.vg.no responded with 255766 bytes
Downloaded 256024 bytes in total.