* [HappyEyeBallsConnector](#happyeyeballsconnector)

The `HappyEyeBallsConnector` class implements the

[`ConnectorInterface`](#connectorinterface) and allows you to create plaintext

TCP/IP connections to any hostname-port-combination. Internally it implements the

happy eyeballs algorythm from [`RFC6555`](https://tools.ietf.org/html/rfc6555) and

[`RFC8305`](https://tools.ietf.org/html/rfc8305) to support IPv6 and IPv4 hostnames.

It does so by decorating a given `TcpConnector` instance so that it first

looks up the given domain name via DNS (if applicable) and then establishes the

underlying TCP/IP connection to the resolved target IP address.

Make sure to set up your DNS resolver and underlying TCP connector like this:

$dnsResolverFactory = new React\Dns\Resolver\Factory();

$dns = $dnsResolverFactory->createCached('8.8.8.8', $loop);

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

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

$connection->write('...');

$connection->end();

});

$loop->run();

See also the [examples](examples).

Pending connection attempts can be cancelled by cancelling its pending promise like so:

$promise = $dnsConnector->connect('www.google.com:80');

$promise->cancel();

Calling `cancel()` on a pending promise will cancel the underlying DNS lookups

and/or the underlying TCP/IP connection(s) and reject the resulting promise.

look up the IP addresses for the given hostname.

It will then replace the hostname in the destination URI with this IP's and

append a `hostname` query parameter and pass this updated URI to the underlying

connector.

The Happy Eye Balls algorythm describes looking the IPv6 and IPv4 address for

the given hostname so this connector sends out two DNS lookups for the A and

AAAA records. It then uses all IP addresses (both v6 and v4) and tries to

connect to all of them with a 50ms interval in between. Alterating between IPv6

and IPv4 addresses. When a connection is established all the other DNS lookups

and connection attempts are cancelled.

namespace React\Socket;

use React\Dns\Model\Message;

use React\Dns\Resolver\ResolverInterface;

use React\EventLoop\LoopInterface;

use React\EventLoop\TimerInterface;

use React\Promise;

use React\Promise\CancellablePromiseInterface;

final class HappyEyeBallsConnectionBuilder

{

const CONNECT_INTERVAL = 0.1;

const RESOLVE_WAIT = 0.5;

public $loop;

public $connector;

public $resolver;

public $uri;

public $host;

public $resolved = array(

Message::TYPE_A => false,

Message::TYPE_AAAA => false,

);

public $resolverPromises = array();

public $connectionPromises = array();

public $connectQueue = array();

public $timer;

public $parts;

public $ipsCount = 0;

public $failureCount = 0;

public $resolve;

public $reject;

public function __construct(LoopInterface $loop, ConnectorInterface $connector, ResolverInterface $resolver, $uri, $host, $parts)

{

$this->loop = $loop;

$this->connector = $connector;

$this->resolver = $resolver;

$this->uri = $uri;

$this->host = $host;

$this->parts = $parts;

}

public function connect()

{

$that = $this;

return new Promise\Promise(function ($resolve, $reject) use ($that) {

$lookupResolve = function ($type) use ($that, $resolve, $reject) {

return function (array $ips) use ($that, $type, $resolve, $reject) {

unset($that->resolverPromises[$type]);

$that->resolved[$type] = true;

$that->mixIpsIntoConnectQueue($ips);

if ($that->timer instanceof TimerInterface) {

return;

}

$that->check($resolve, $reject);

};

};

$ipv4Deferred = null;

$timer = null;

$that->resolverPromises[Message::TYPE_AAAA] = $that->resolve(Message::TYPE_AAAA, $reject)->then($lookupResolve(Message::TYPE_AAAA))->then(function () use (&$ipv4Deferred) {

if ($ipv4Deferred instanceof Promise\Deferred) {

$ipv4Deferred->resolve();

}

});

$that->resolverPromises[Message::TYPE_A] = $that->resolve(Message::TYPE_A, $reject)->then(function ($ips) use ($that, &$ipv4Deferred, &$timer) {

if ($that->resolved[Message::TYPE_AAAA] === true) {

return Promise\resolve($ips);

}

/**

$ipv4Deferred = new Promise\Deferred();

$deferred = new Promise\Deferred();

$timer = $that->loop->addTimer($that::RESOLVE_WAIT, function () use ($deferred, $ips) {

$ipv4Deferred = null;

$deferred->resolve($ips);

});

$ipv4Deferred->promise()->then(function () use ($that, &$timer, $deferred, $ips) {

$that->loop->cancelTimer($timer);

$deferred->resolve($ips);

});

return $deferred->promise();

})->then($lookupResolve(Message::TYPE_A));

}, function ($_, $reject) use ($that, &$timer) {

$that->cleanUp();

if ($timer instanceof TimerInterface) {

$that->loop->cancelTimer($timer);

}

$reject(new \RuntimeException('Connection to ' . $that->uri . ' cancelled during DNS lookup'));

$_ = $reject = null;

});

}

/**

public function resolve($type, $reject)

{

$that = $this;

return $that->resolver->resolveAll($that->host, $type)->then(null, function () use ($type, $reject, $that) {

unset($that->resolverPromises[$type]);

$that->resolved[$type] = true;

if ($that->hasBeenResolved() === false) {

return;

}

if ($that->ipsCount === 0) {

$that->resolved = null;

$that->resolverPromises = null;

$reject(new \RuntimeException('Connection to ' . $that->uri . ' failed during DNS lookup: DNS error'));

}

});

}

/**

public function check($resolve, $reject)

{

if (\count($this->connectQueue) === 0 && $this->resolved[Message::TYPE_A] === true && $this->resolved[Message::TYPE_AAAA] === true && $this->timer instanceof TimerInterface) {

$this->loop->cancelTimer($this->timer);

$this->timer = null;

}

if (\count($this->connectQueue) === 0) {

return;

}

$ip = \array_shift($this->connectQueue);

$that = $this;

$that->connectionPromises[$ip] = $this->attemptConnection($ip)->then(function ($connection) use ($that, $ip, $resolve) {

unset($that->connectionPromises[$ip]);

$that->cleanUp();

$resolve($connection);

}, function () use ($that, $ip, $resolve, $reject) {

unset($that->connectionPromises[$ip]);

$that->failureCount++;

if ($that->hasBeenResolved() === false) {

return;

}

if ($that->ipsCount === $that->failureCount) {

$that->cleanUp();

$reject(new \RuntimeException('All attempts to connect to "' . $that->host . '" have failed'));

}

});

/**

if ((\count($this->connectQueue) > 0 || ($this->resolved[Message::TYPE_A] === false || $this->resolved[Message::TYPE_AAAA] === false)) && $this->timer === null) {

$this->timer = $this->loop->addPeriodicTimer(self::CONNECT_INTERVAL, function () use ($that, $resolve, $reject) {

$that->check($resolve, $reject);

});

}

}

/**

public function attemptConnection($ip)

{

$promise = null;

$that = $this;

return new Promise\Promise(

function ($resolve, $reject) use (&$promise, $that, $ip) {

$uri = '';

// prepend original scheme if known

if (isset($that->parts['scheme'])) {

$uri .= $that->parts['scheme'] . '://';

}

if (\strpos($ip, ':') !== false) {

// enclose IPv6 addresses in square brackets before appending port

$uri .= '[' . $ip . ']';

} else {

$uri .= $ip;

}

// append original port if known

if (isset($that->parts['port'])) {

$uri .= ':' . $that->parts['port'];

}

// append orignal path if known

if (isset($that->parts['path'])) {

$uri .= $that->parts['path'];

}

// append original query if known

if (isset($that->parts['query'])) {

$uri .= '?' . $that->parts['query'];

}

// append original hostname as query if resolved via DNS and if

// destination URI does not contain "hostname" query param already

$args = array();

\parse_str(isset($that->parts['query']) ? $that->parts['query'] : '', $args);

if ($that->host !== $ip && !isset($args['hostname'])) {

$uri .= (isset($that->parts['query']) ? '&' : '?') . 'hostname=' . \rawurlencode($that->host);

}

// append original fragment if known

if (isset($that->parts['fragment'])) {

$uri .= '#' . $that->parts['fragment'];

}

$promise = $that->connector->connect($uri);

$promise->then($resolve, $reject);

},

function ($_, $reject) use (&$promise, $that) {

// cancellation should reject connection attempt

// (try to) cancel pending connection attempt

$reject(new \RuntimeException('Connection to ' . $that->uri . ' cancelled during connection attempt'));

if ($promise instanceof CancellablePromiseInterface) {

// overwrite callback arguments for PHP7+ only, so they do not show

// up in the Exception trace and do not cause a possible cyclic reference.

$_ = $reject = null;

$promise->cancel();

$promise = null;

}

}

);

}

/**

public function cleanUp()

{

/** @var CancellablePromiseInterface $promise */

foreach ($this->connectionPromises as $index => $connectionPromise) {

if ($connectionPromise instanceof CancellablePromiseInterface) {

$connectionPromise->cancel();

}

}

/** @var CancellablePromiseInterface $promise */

foreach ($this->resolverPromises as $index => $resolverPromise) {

if ($resolverPromise instanceof CancellablePromiseInterface) {

$resolverPromise->cancel();

}

}

if ($this->timer instanceof TimerInterface) {

$this->loop->cancelTimer($this->timer);

$this->timer = null;

}

}

/**

public function hasBeenResolved()

{

foreach ($this->resolved as $typeHasBeenResolved) {

if ($typeHasBeenResolved === false) {

return false;

}

}

return true;

}

/**

public function mixIpsIntoConnectQueue(array $ips)

{

$this->ipsCount += \count($ips);

$connectQueueStash = $this->connectQueue;

$this->connectQueue = array();

while (\count($connectQueueStash) > 0 || \count($ips) > 0) {

if (\count($ips) > 0) {

$this->connectQueue[] = \array_shift($ips);

}

if (\count($connectQueueStash) > 0) {

$this->connectQueue[] = \array_shift($connectQueueStash);

}

}

}

}