public function get($key)
{
if (!isset($this->data[$key])) {
return When::reject();
}
return When::resolve($this->data[$key]);
}
/**
* Checks domain availability of multiple domains.
*
* @param array $domains
*/
public function checkAll(array $domains)
{
return When::map($domains, array($this, 'check'))->then(function ($statuses) use($domains) {
ksort($statuses);
return array_combine($domains, $statuses);
});
}
public function loadEtcResolvConf($filename)
{
if (!file_exists($filename)) {
return When::reject(new \InvalidArgumentException("The filename for /etc/resolv.conf given does not exist: {$filename}"));
}
try {
$deferred = new Deferred();
$fd = fopen($filename, 'r');
stream_set_blocking($fd, 0);
$contents = '';
$stream = new Stream($fd, $this->loop);
$stream->on('data', function ($data) use(&$contents) {
$contents .= $data;
});
$stream->on('end', function () use(&$contents, $deferred) {
$deferred->resolve($contents);
});
$stream->on('error', function ($error) use($deferred) {
$deferred->reject($error);
});
return $deferred->promise();
} catch (\Exception $e) {
return When::reject($e);
}
}
protected function resolveHostname($host)
{
if (false !== filter_var($host, FILTER_VALIDATE_IP)) {
return When::resolve($host);
}
return $this->resolver->resolve($host);
}
/** @test */
public function resolveSouldProvideDefaultErrorbackToExecutor()
{
$executor = $this->createExecutorMock();
$executor->expects($this->once())->method('query')->with($this->anything(), $this->isInstanceOf('React\\Dns\\Query\\Query'))->will($this->returnCallback(function ($nameserver, $query) {
return When::resolve();
}));
$resolver = new Resolver('8.8.8.8:53', $executor);
$resolver->resolve('igor.io')->then($this->expectCallableNever());
}
private function callQueryCallbackWithAddress($address)
{
return $this->returnCallback(function ($nameserver, $query) use($address) {
$response = new Message();
$response->header->set('qr', 1);
$response->questions[] = new Record($query->name, $query->type, $query->class);
$response->answers[] = new Record($query->name, $query->type, $query->class, 3600, $address);
return When::resolve($response);
});
}
public function createSocketForAddress($address, $port)
{
$url = $this->getSocketUrl($address, $port);
$socket = stream_socket_client($url, $errno, $errstr, 0, STREAM_CLIENT_CONNECT | STREAM_CLIENT_ASYNC_CONNECT, $this->createStreamContext());
if (!$socket) {
return When::reject(new \RuntimeException(sprintf("connection to %s:%d failed: %s", $address, $port, $errstr), $errno));
}
stream_set_blocking($socket, 0);
// wait for connection
return $this->waitForStreamOnce($socket)->then(array($this, 'checkConnectedSocket'))->then(array($this, 'handleConnectedSocket'));
}
public function lookup(Query $query)
{
$id = $this->serializeQueryToIdentity($query);
$expiredAt = $this->expiredAt;
return $this->cache->get($id)->then(function ($value) use($query, $expiredAt) {
$recordBag = unserialize($value);
if (null !== $expiredAt && $expiredAt <= $query->currentTime) {
return When::reject();
}
return $recordBag->all();
});
}
public function query($nameserver, Query $query)
{
$cachedRecords = $this->cache->lookup($query);
if (count($cachedRecords)) {
$cachedResponse = $this->buildResponse($query, $cachedRecords);
return When::resolve($cachedResponse);
}
$cache = $this->cache;
return $this->executor->query($nameserver, $query)->then(function ($response) use($cache, $query) {
$cache->storeResponseMessage($query->currentTime, $response);
return $response;
});
}
/**
* @covers React\Dns\Query\RetryExecutor
* @test
*/
public function queryShouldForwardNonTimeoutErrors()
{
$executor = $this->createExecutorMock();
$executor->expects($this->once())->method('query')->with('8.8.8.8', $this->isInstanceOf('React\\Dns\\Query\\Query'))->will($this->returnCallback(function ($domain, $query) {
return When::reject(new \Exception());
}));
$callback = $this->expectCallableNever();
$errorback = $this->createCallableMock();
$errorback->expects($this->once())->method('__invoke')->with($this->isInstanceOf('Exception'));
$retryExecutor = new RetryExecutor($executor, 2);
$query = new Query('igor.io', Message::TYPE_A, Message::CLASS_IN, 1345656451);
$retryExecutor->query('8.8.8.8', $query)->then($callback, $errorback);
}
public function setAuth($auth)
{
if (!is_callable($auth)) {
throw new InvalidArgumentException('Given authenticator is not a valid callable');
}
if ($this->protocolVersion !== null && $this->protocolVersion !== '5') {
throw new UnexpectedValueException('Authentication requires SOCKS5. Consider using protocol version 5 or waive authentication');
}
// wrap authentication callback in order to cast its return value to a promise
$this->auth = function ($username, $password) use($auth) {
$ret = call_user_func($auth, $username, $password);
if ($ret instanceof PromiseInterface) {
return $ret;
}
return $ret ? When::resolve() : When::reject();
};
}
public function createSocketForAddress($address, $port, $hostName = null)
{
$url = $this->getSocketUrl($address, $port);
$contextOpts = $this->contextOptions;
// Fix for SSL in PHP >= 5.6, where peer name must be validated.
if ($hostName !== null) {
$contextOpts['ssl']['SNI_enabled'] = true;
$contextOpts['ssl']['SNI_server_name'] = $hostName;
$contextOpts['ssl']['peer_name'] = $hostName;
}
$flags = STREAM_CLIENT_CONNECT | STREAM_CLIENT_ASYNC_CONNECT;
$context = stream_context_create($contextOpts);
$socket = stream_socket_client($url, $errno, $errstr, 0, $flags, $context);
if (!$socket) {
return When::reject(new \RuntimeException(sprintf("connection to %s:%d failed: %s", $address, $port, $errstr), $errno));
}
stream_set_blocking($socket, 0);
// wait for connection
return $this->waitForStreamOnce($socket)->then(array($this, 'checkConnectedSocket'))->then(array($this, 'handleConnectedSocket'));
}
/** @test */
public function itShouldReceiveAgainNackedMessages()
{
$loop = $this->getEventLoop();
$client1 = $this->getClient($loop);
$client2 = $this->getClient($loop);
$counter = 0;
When::all(array($client1->connect(), $client2->connect()), function () use($client1, $client2, $loop, &$counter) {
$callback = function ($frame, $resolver) use($loop, &$counter) {
if (0 === $counter) {
$resolver->nack();
} else {
$resolver->ack();
$loop->stop();
}
$counter++;
};
$client1->subscribeWithAck('/topic/foo', 'client-individual', $callback);
$client2->subscribeWithAck('/topic/foo', 'client-individual', $callback);
$client1->send('/topic/foo', 'le message à la papa');
});
$loop->run();
$this->assertEquals(2, $counter);
}
private function resolve($host)
{
return When::resolve($host);
}
/**
* {@inheritdoc}
*/
public function unsubscribe($event, $callback)
{
$events = explode(' ', strtoupper($event));
$promises = [];
foreach ($events as $event) {
$promises[] = $this->unsubscribeSingle($event, $callback);
}
return When::all($promises, function ($results) {
foreach ($results as $result) {
if ($result === false) {
return false;
}
}
return true;
});
}
/**
* resolve given address via DNS if applicable
*
* Letting host names pass through will not break things, but it
* requires a blocking resolution afterwards. So make sure to try to
* resolve hostnames here.
*
* @param string $address
* @return PromiseInterface
* @todo use Resolver to perform async resolving
*/
private function resolve($address)
{
return When::resolve($address);
}
private function resolve($host)
{
// return if it's already an IP or we want to resolve remotely (socks 4 only supports resolving locally)
if (false !== filter_var($host, FILTER_VALIDATE_IP) || $this->protocolVersion !== '4' && !$this->resolveLocal) {
return When::resolve($host);
}
return $this->resolver->resolve($host);
}
