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); }