/** * Connect to $numSeeds DNS seeds * * @param int $numSeeds * @return \React\Promise\Promise|\React\Promise\PromiseInterface */ public function queryDnsSeeds($numSeeds = 1) { $peerList = new Deferred(); // Take $numSeeds $seedHosts = self::dnsSeedHosts(); $seeds = array_slice($seedHosts, 0, min($numSeeds, count($seedHosts))); // Connect to $numSeeds peers /** @var Peer[] $vNetAddr */ $vNetAddr = []; foreach ($seeds as $seed) { echo " [ query DNS seed: " . $seed . " ] \n"; $this->dns->resolve($seed)->then(function ($ipList) use(&$vNetAddr, $peerList, &$numSeeds) { $vNetAddr[] = $ipList; if (count($vNetAddr) == $numSeeds) { $peerList->resolve($vNetAddr); } }); } // Compile the list of lists of peers into $this->knownAddresses return $peerList->promise()->then(function (array $vPeerVAddrs) { shuffle($vPeerVAddrs); /** @var NetworkAddressInterface[] $addresses */ $addresses = []; array_map(function (array $value) use(&$addresses) { foreach ($value as $ip) { $addresses[] = new NetworkAddress(Buffer::hex('01', 8), $ip, 8333); } }, $vPeerVAddrs); $this->knownAddresses = array_merge($this->knownAddresses, $addresses); return $this; }); }
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 createInternalAsync($host, $docroot, $router) { $deferred = new Deferred(); $process = new BuiltinServer($host, $docroot, $router, $this->php); $process->start($this->loop); $process->on('exit', function ($code) use($deferred) { $this->stderr->write("Process exit with code {$code}\n"); $deferred->reject(); }); $process->stdin->close(); $process->stdout->close(); $process->stderr->on('data', function ($output) use($deferred) { $this->stderr->write($output); $deferred->reject(); }); $timer = new Deferred(); $this->loop->addTimer(0.05, function () use($timer, $process) { if (DIRECTORY_SEPARATOR === '\\') { // Pipes opened by proc_open() can break stream_select() loop in Windows. // This fix might do the trick... $process->stderr->close(); } $timer->resolve($process); }); return \React\Promise\race([$deferred->promise(), $timer->promise()])->then(null, function () use($process) { $process->terminate(); return new RejectedPromise(); }); }
/** * @expectedException \RuntimeException */ public function testThrowsWhenAccessingInvalidProperty() { $deferred = new Deferred(); $f = new FutureArray($deferred->promise(), function () { }); $f->foo; }
public function connect($timeout = 5) { if ($this->connectDeferred) { return $this->connectDeferred->promise(); } $this->connectionStatus = 'connecting'; $promise = new Deferred(); $client = $this; $loop = $this->loop; $this->connectDeferred = $promise; $this->connectDeferred->then(function () use($client) { $client->setConnectionStatus('connected'); }); $timer = $this->loop->addTimer($timeout, function () use($client, $promise) { $promise->reject(new ConnectionException('Connection timeout')); $client->resetConnectDeferred(); $client->setConnectionStatus('not-connected'); }); $this->on('connect', function ($client) use($timer, $promise) { $timer->cancel(); $promise->resolve($client); }); $frame = $this->packageCreator->connect($this->options['vhost'], $this->options['login'], $this->options['passcode']); $this->output->sendFrame($frame); return $this->connectDeferred->promise(); }
/** * @param Request $request * @return \React\Promise\Promise|\React\Promise\PromiseInterface */ public function sendRequest(Request $request) { $result = new Deferred(); $this->deferred[$request->getId()] = $result; $this->sendData($request->write()); return $result->promise(); }
/** * @returns \React\Promise\Promise */ public function show() { $deferred = new Deferred(); $this->io->out('hello'); $deferred->reject(false); return $deferred->promise(); }
public function doQuery($nameserver, $queryData, $name) { $that = $this; $parser = $this->parser; $loop = $this->loop; $deferred = new Deferred(function ($_, $reject) use(&$conn, &$timer, $name) { $conn->close(); $timer->cancel(); $reject(new \RuntimeException(sprintf("DNS query for %s cancelled", $name))); }); $timer = $this->loop->addTimer($this->timeout, function () use(&$conn, $name, $deferred) { $conn->close(); $deferred->reject(new TimeoutException(sprintf("DNS query for %s timed out", $name))); }); $conn = $this->factory->createSender(); $conn->on('message', function ($data) use($conn, $parser, $deferred, $timer) { $response = new Message(); $responseReady = $parser->parseChunk($data, $response); $conn->close(); $timer->cancel(); if (!$responseReady) { $deferred->reject(new BadServerException('Invalid response received')); return; } if ($response->header->isTruncated()) { $deferred->reject(new BadServerException('The server set the truncated bit although we issued a TCP request')); return; } $deferred->resolve($response); }); $conn->send($queryData, $nameserver); return $deferred->promise(); }
private function collectEvents($command, $expectedEndEvent) { $req = $this->client->createAction($command); $ret = $this->client->request($req); $id = $req->getActionId(); $deferred = new Deferred(); // collect all intermediary channel events with this action ID $collected = array(); $collector = function (Event $event) use($id, &$collected, $deferred, $expectedEndEvent) { if ($event->getActionId() === $id) { $collected[] = $event; if ($event->getName() === $expectedEndEvent) { $deferred->resolve($collected); } } }; $this->client->on('event', $collector); // unregister collector if client fails $client = $this->client; $unregister = function () use($client, $collector) { $client->removeListener('event', $collector); }; $ret->then(null, $unregister); // stop waiting for events $deferred->promise()->then($unregister); return $ret->then(function (Response $response) use($deferred) { // final result has been received => merge all intermediary channel events return $deferred->promise()->then(function ($collected) use($response) { $last = array_pop($collected); return new Collection($response, $collected, $last); }); }); }
public function search($searchTarget = 'ssdp:all', $mx = 2) { $data = "M-SEARCH * HTTP/1.1\r\n"; $data .= "HOST: " . self::ADDRESS . "\r\n"; $data .= "MAN: \"ssdp:discover\"\r\n"; $data .= "MX: {$mx}\r\n"; $data .= "ST: {$searchTarget}\r\n"; $data .= "\r\n"; $socket = $this->multicast->createSender(); // TODO: The TTL for the IP packet SHOULD default to 2 and SHOULD be configurable. $timer = $this->loop->addTimer($mx, function () use($socket, &$deferred) { $deferred->resolve(); $socket->close(); }); $deferred = new Deferred(function () use($socket, &$timer) { // canceling resulting promise cancels timer and closes socket $timer->cancel(); $socket->close(); throw new RuntimeException('Cancelled'); }); $that = $this; $socket->on('message', function ($data, $remote) use($deferred, $that) { $message = $that->parseMessage($data, $remote); $deferred->progress($message); }); $socket->send($data, self::ADDRESS); return $deferred->promise(); }
/** * {@inheritdoc} */ public function sendAsyncRequest(RequestInterface $request) { $reactRequest = $this->buildReactRequest($request); $deferred = new Deferred(); $reactRequest->on('error', function (\Exception $error) use($deferred, $request) { $deferred->reject(new RequestException($error->getMessage(), $request, $error)); }); $reactRequest->on('response', function (ReactResponse $reactResponse = null) use($deferred, $reactRequest, $request) { $bodyStream = $this->streamFactory->createStream(); $reactResponse->on('data', function ($data) use(&$bodyStream) { $bodyStream->write((string) $data); }); $reactResponse->on('end', function (\Exception $error = null) use($deferred, $request, $reactResponse, &$bodyStream) { $response = $this->buildResponse($reactResponse, $bodyStream); if (null !== $error) { $deferred->reject(new HttpException($error->getMessage(), $request, $response, $error)); } else { $deferred->resolve($response); } }); }); $reactRequest->end((string) $request->getBody()); $promise = new Promise($deferred->promise()); $promise->setLoop($this->loop); return $promise; }
/** * {@inheritdoc} */ public function sendAsyncRequest(RequestInterface $request) { $requestStream = $this->buildReactRequest($request); $deferred = new Deferred(); $requestStream->on('error', function (\Exception $error) use($deferred, $request) { $deferred->reject(new RequestException($error->getMessage(), $request, $error)); }); $requestStream->on('response', function (ReactResponse $response = null) use($deferred, $requestStream, $request) { $bodyStream = null; $response->on('data', function ($data) use(&$bodyStream) { if ($data instanceof StreamInterface) { $bodyStream = $data; } else { $bodyStream->write($data); } }); $response->on('end', function (\Exception $error = null) use($deferred, $request, $response, &$bodyStream) { $bodyStream->rewind(); $psr7Response = $this->messageFactory->createResponse($response->getCode(), $response->getReasonPhrase(), $response->getHeaders(), $bodyStream, $response->getVersion()); if (null !== $error) { $deferred->reject(new HttpException($error->getMessage(), $request, $psr7Response, $error)); } else { $deferred->resolve($psr7Response); } }); }); $requestStream->end((string) $request->getBody()); $promise = new ReactPromiseAdapter($deferred->promise()); $this->loop->run(); return $promise; }
public static function createFuture(callable $wait, callable $cancel = null) { $deferred = new Deferred(); return new FutureResponse($deferred->promise(), function () use($deferred, $wait) { $deferred->resolve($wait()); }, $cancel); }
/** @internal */ public function go(Process $process) { $this->deferred = $deferred = new Deferred(); $this->process = $process; $buffered = null; $process->stdout->on('data', function ($data) use(&$buffered) { if ($data !== '') { $buffered .= $data; } }); $process->on('exit', function ($code) use($deferred) { if ($code !== 0) { $deferred->reject($code); } else { $deferred->resolve(); } }); $that = $this; $this->promise = $deferred->promise()->then(function () use(&$buffered, $that) { if ($buffered === null) { $buffered = true; } else { $buffered = $that->parseValue(trim($buffered)); } return $buffered; }); }
public function __invoke(GetAllUsers $query, Deferred $deferred = null) { $user = $this->userFinder->findAll(); if (null === $deferred) { return $user; } $deferred->resolve($user); }
protected function createPromiseRejected($value = null, $delay = 0.01) { $deferred = new Deferred(); $this->loop->addTimer($delay, function () use($deferred, $value) { $deferred->reject($value); }); return $deferred->promise(); }
public function __invoke(GetTodoById $query, Deferred $deferred = null) { $todo = $this->todoFinder->findById($query->todoId()); if (null === $deferred) { return $todo; } $deferred->resolve($todo); }
/** * @expectedException \Exception * @expectedExceptionMessage foo */ public function testThrowingExceptionInDerefMarksAsFailed() { $deferred = new Deferred(); $f = new FutureValue($deferred->promise(), function () { throw new \Exception('foo'); }); $f->wait(); }
public function __invoke(GetUserById $query, Deferred $deferred = null) { $user = $this->userFinder->findById($query->userId()); if (null === $deferred) { return $user; } $deferred->resolve($user); }
public function __invoke(GetTodosByAssigneeId $query, Deferred $deferred = null) { $todos = $this->todoFinder->findByAssigneeId($query->userId()); if (null === $deferred) { return $todos; } $deferred->resolve($todos); }
protected function createConnectionManagerMock($ret) { $mock = $this->getMockBuilder('React\\SocketClient\\Connector')->disableOriginalConstructor()->getMock(); $deferred = new Deferred(); $deferred->resolve($ret); $mock->expects($this->any())->method('create')->will($this->returnValue($deferred->promise())); return $mock; }
public function start() { $deferred = new Deferred(); $this->loop->addTimer($this->interval, function () use($deferred) { $deferred->resolve(); }); return $deferred->promise(); }
/** @test */ public function progressIsAnAliasForNotify() { $deferred = new Deferred(); $sentinel = new \stdClass(); $mock = $this->createCallableMock(); $mock->expects($this->once())->method('__invoke')->with($sentinel); $deferred->promise()->then($this->expectCallableNever(), $this->expectCallableNever(), $mock); $deferred->progress($sentinel); }
/** * @param Rpc $message * @return PromiseInterface */ public function rpc(Rpc $message) { $hash = spl_object_hash($message); $deferred = new Deferred(); $this->deferreds[$hash] = $deferred; $this->queue->enqueue($message); $this->manager->ping(); return $deferred->promise(); }
public function promiseAction(Request $request) { $secs = intval($request->attributes->get("secs")); $deferred = new Deferred(); $this->loop->addTimer($secs, function () use($secs, $deferred) { $deferred->resolve(Response::create("{$secs} seconds later...\n")); }); return $deferred->promise(); }
public function getPromiseTestAdapter(callable $canceller = null) { $d = new Deferred($canceller); $factory = function () use($d) { return $d->promise(); }; return new CallbackPromiseAdapter(['promise' => function () use($factory) { return new LazyPromise($factory); }, 'resolve' => [$d, 'resolve'], 'reject' => [$d, 'reject'], 'settle' => [$d, 'resolve']]); }
/** * Message producers need to be invokable. * * A producer MUST be able to handle a message async without returning a response. * A producer MAY also support future response by resolving the passed $deferred. * * Note: A $deferred is only passed by a QueryBus but in this case the $deferred * MUST either be resolved/rejected OR the message producer * MUST throw a Prooph\ServiceBus\Exception\RuntimeException if it cannot * handle the $deferred * * @param Message $message * @param null|Deferred $deferred * @throws RuntimeException If a $deferred is passed but producer can not handle it */ public function __invoke(Message $message, Deferred $deferred = null) { $this->assertDeferred(null !== $deferred); $data = $this->arrayFromMessage($message); $this->zmqClient->send(json_encode($data), ZMQ::MODE_DONTWAIT); if ($deferred) { $response = $this->zmqClient->receive(); $deferred->resolve($response); } }
protected function waitForStreamOnce($stream) { $deferred = new Deferred(); $loop = $this->loop; $this->loop->addWriteStream($stream, function ($stream) use($loop, $deferred) { $loop->removeWriteStream($stream); $deferred->resolve($stream); }); return $deferred->promise(); }
public function start() { $command = $this->getCommand($this->keys); $deferred = new Deferred(); $command->start($this->loop, 0.001); $command->on('exit', function () use($deferred) { $deferred->resolve(); }); return $deferred->promise(); }
public function testJsonResolvingPromiseWithWrongValueWillEmitErrorAndCloseEvent() { $deferred = new Deferred(); $stream = $this->parser->parseJsonStream($deferred->promise()); $this->assertTrue($stream->isReadable()); $stream->on('error', $this->expectCallableOnce()); $stream->on('close', $this->expectCallableOnce()); $deferred->resolve('not a stream'); $this->assertFalse($stream->isReadable()); }