/**
* Make a directory as described in the task description
* @param Deferred $deferred
* @param TaskInterface $task
* @return bool
*/
protected function processDeferred(Deferred $deferred, TaskInterface $task)
{
yield;
/** @var Description $description */
$description = $task->getDescription();
$deferred->notify(new Notification("Creating directory '{$description->getName()}'", Notification::PRIORITY_NORMAL));
if ($this->getFileSystem()->isDirectory($description->getName())) {
$deferred->resolve("Directory '{$description->getName()}' already exists");
return;
}
if ($this->getFileSystem()->makeDirectory($description->getName())) {
$deferred->resolve("Created directory '{$description->getName()}'");
return;
}
$deferred->reject("Directory '{$description->getName()}' could not be created");
}
/**
* Make a directory as described in the task description
* @param Deferred $deferred
* @param TaskInterface $task
* @return bool
*/
protected function processDeferred(Deferred $deferred, TaskInterface $task)
{
yield;
/** @var Description $description */
$description = $task->getDescription();
$deferred->notify(new Notification("Deleting file or directory '{$description->getName()}'", Notification::PRIORITY_NORMAL));
if (!$this->getFileSystem()->isFile($description->getName()) && !$this->getFileSystem()->isDirectory($description->getName())) {
$deferred->resolve("File or directory '{$description->getName()}' does not exist");
return;
}
if ($this->getFileSystem()->delete($description->getName())) {
$deferred->resolve("Deleted file or directory '{$description->getName()}'");
return;
}
$deferred->reject("File or directory '{$description->getName()}' could not be deleted");
}
public function doQuery($nameserver, $transport, $queryData, $name)
{
$parser = $this->parser;
$loop = $this->loop;
$response = new Message();
$deferred = new Deferred();
$retryWithTcp = function () use($nameserver, $queryData, $name) {
return $this->doQuery($nameserver, 'tcp', $queryData, $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->createConnection($nameserver, $transport);
$conn->on('data', function ($data) use($retryWithTcp, $conn, $parser, $response, $transport, $deferred, $timer) {
$responseReady = $parser->parseChunk($data, $response);
if (!$responseReady) {
return;
}
$timer->cancel();
if ($response->header->isTruncated()) {
if ('tcp' === $transport) {
$deferred->reject(new BadServerException('The server set the truncated bit although we issued a TCP request'));
} else {
$conn->end();
$deferred->resolve($retryWithTcp());
}
return;
}
$conn->end();
$deferred->resolve($response);
});
$conn->write($queryData);
return $deferred->promise();
}
/**
* {@inheritdoc}
*/
public function tick()
{
if ($this->firstTick) {
$this->firstTick = false;
$this->deferred->notify(new MessageEvent($this, $this->generator->current()));
} else {
$this->deferred->notify(new MessageEvent($this, $this->generator->send(null)));
}
if (!$this->generator->valid()) {
$this->deferred->resolve(new Event($this));
}
}
/**
* Return file name through a promise.
*
* @param integer $xAxis X coordinate.
* @param integer $yAxis Y coordinate.
*
* @return \React\Promise\Promise
*/
public function getTile($xAxis, $yAxis)
{
$fileName = str_replace(['{x}', '{y}'], [$xAxis, $yAxis], $this->location);
$deferred = new Deferred();
$this->loader->imageExists($fileName)->then(function () use($deferred, $fileName) {
$deferred->resolve($fileName);
}, function () use($deferred, $fileName) {
if (empty($this->fallbackImage)) {
return $deferred->resolve($fileName);
}
$deferred->resolve($this->fallbackImage);
});
return $deferred->promise();
}
/**
* {@inheritdoc}
*/
public function tick()
{
$this->startPendingTasks();
if ($this->runningTasks->isEmpty()) {
$this->deferred->resolve();
return;
}
/** @var TaskInterface $task */
$task = $this->runningTasks->dequeue();
if (false !== ($pos = array_search($task, $this->finishedTasks, true))) {
unset($this->finishedTasks[array_search($task, $this->finishedTasks, true)]);
return $this->tick();
}
$task->tick();
$this->runningTasks->enqueue($task);
}
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 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();
}
public function wait()
{
if ($this->isRealized) {
return false;
}
// Seed the pool with N number of requests.
$this->addNextRequests();
// Stop if the pool was cancelled while transferring requests.
if ($this->isRealized) {
return false;
}
// Wait on any outstanding FutureResponse objects.
while ($response = array_pop($this->waitQueue)) {
try {
$response->wait();
} catch (\Exception $e) {
// Eat exceptions because they should be handled asynchronously
}
$this->addNextRequests();
}
// Clean up no longer needed state.
$this->isRealized = true;
$this->waitQueue = $this->eventListeners = [];
$this->client = $this->iter = null;
$this->deferred->resolve(true);
return true;
}
/**
* @param $channel
* @param string $message
* @return DeferredPromise
*/
public function call($channel, $message)
{
$loop = LoopFactory::create();
$factory = new StompFactory($loop);
$client = $factory->createClient();
$deferred = new Deferred();
$timer = $loop->addTimer(2, function () use($deferred, $client) {
$client->disconnect();
$deferred->reject(new RpcTimeIsOutException());
});
$client->connect()->then(function (StompClient $client) use($message, $channel, $loop, $deferred, $timer) {
$rpcReceiver = function (Frame $frame) use($deferred, $timer, $client) {
$timer->cancel();
$client->disconnect();
try {
$deferred->resolve($frame);
} catch (\Exception $e) {
$deferred->reject($e);
}
};
$client->sendToTemp($channel, $message, [], $rpcReceiver);
}, function () use($deferred, $client) {
$client->disconnect();
$deferred->reject(new \RuntimeException('Error start rpc connection'));
});
$loop->run();
return $deferred->promise();
}
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);
}
}
private function executeRequest($method, $uri, $body = null)
{
$deferred = new Deferred();
$request = $this->client->request($method, $this->buildUrl($uri), array('Content-Length' => strlen($body), 'Authorization' => 'Basic ' . base64_encode($this->options['user'] . ':' . $this->options['password']), 'Content-Type' => 'application/json'));
$request->writeHead();
$request->on('error', function ($error) use($uri, $deferred) {
$deferred->reject(sprintf('Error while doing the request on %s : %s', $uri, $error->getMessage()));
});
$request->on('response', function (Response $response) use($deferred) {
if ($response->getCode() < 200 || $response->getCode() >= 400) {
$deferred->reject(sprintf('The response is not as expected (status code %s, message is %s)', $response->getCode(), $response->getReasonPhrase()));
}
$response->on('error', function ($error) use($deferred) {
$deferred->reject($error->getMessage());
});
$data = (object) array('data' => '');
$response->on('data', function ($chunk) use($data) {
$data->data .= $chunk;
});
$response->on('end', function () use($deferred, $data) {
$deferred->resolve($data->data);
});
});
$request->end($body);
return $deferred->promise();
}
/**
* 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;
});
}
/** @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;
});
}
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();
});
}
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);
}
public function __invoke(GetTodosByAssigneeId $query, Deferred $deferred = null)
{
$todos = $this->todoFinder->findByAssigneeId($query->userId());
if (null === $deferred) {
return $todos;
}
$deferred->resolve($todos);
}
public function __invoke(GetUserById $query, Deferred $deferred = null)
{
$user = $this->userFinder->findById($query->userId());
if (null === $deferred) {
return $user;
}
$deferred->resolve($user);
}
public function start()
{
$deferred = new Deferred();
$this->loop->addTimer($this->interval, function () use($deferred) {
$deferred->resolve();
});
return $deferred->promise();
}
public function __invoke(GetAllUsers $query, Deferred $deferred = null)
{
$user = $this->userFinder->findAll();
if (null === $deferred) {
return $user;
}
$deferred->resolve($user);
}
/**
* {@inheritdoc}
*/
public function tick()
{
if (!$this->process->isRunning() && $this->outputBuffer->isEmpty()) {
usleep(1000);
if ($this->outputBuffer->isEmpty()) {
if ($this->process->isSuccessful()) {
$this->deferred->resolve(new MessageEvent($this, $this->process->getOutput()));
} else {
$this->deferred->reject(new MessageEvent($this, $this->process->getOutput()));
}
return;
}
}
if (!$this->outputBuffer->isEmpty()) {
$this->deferred->notify(new MessageEvent($this, $this->outputBuffer->dequeue()[1]));
}
}
protected function createPromiseResolved($value = null, $delay = 0.01)
{
$deferred = new Deferred();
$this->loop->addTimer($delay, function () use($deferred, $value) {
$deferred->resolve($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);
}
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 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();
}
/**
* create stream client socket connected to given address
*
* @param string $address
* @return PromiseInterface to return a \Sockets\Stream
* @uses RawFactory::createFromString()
* @uses RawSocket::setBlocking() to turn on non-blocking mode
* @uses RawSocket::connect() to initiate async connection
* @uses LoopInterface::addWriteStream() to wait for connection result once
* @uses RawSocket::assertAlive() to check connection result
*/
public function createClient($address)
{
$that = $this;
$factory = $this->rawFactory;
return $this->resolve($address)->then(function ($address) use($factory, $that) {
$deferred = new Deferred();
$socket = $factory->createFromString($address, $scheme);
if ($socket->getType() !== SOCK_STREAM) {
$socket->close();
throw new Exception('Not a stream address scheme');
}
$socket->setBlocking(false);
try {
// socket is nonblocking, so connect should emit EINPROGRESS
$socket->connect($address);
// socket is already connected immediately?
$deferred->resolve(new Connection($socket, $that->getSocketLoop()));
} catch (Exception $exception) {
if ($exception->getCode() === SOCKET_EINPROGRESS) {
// connection in progress => wait for the socket to become writable
$that->getSocketLoop()->addWriteStream($socket->getResource(), function ($resource, $loop) use($deferred, $socket) {
// only poll for writable event once
$loop->removeWriteStream($resource);
try {
// assert that socket error is 0 (no TCP RST received)
$socket->assertAlive();
} catch (Exception $e) {
// error returned => connected failed
$socket->close();
$deferred->reject(new Exception('Error while establishing connection', $e->getCode(), $e));
return;
}
// no error => connection established
$deferred->resolve(new Connection($socket, $loop));
});
} else {
// re-throw any other socket error
$socket->close();
$deferred->reject($exception);
}
}
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());
}
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();
}
/**
* 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();
}
