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();
}
/**
* {@inheritdoc}
*/
public function run($tasks, $servers, $environments, $input, $output)
{
$this->tasks = $tasks;
$this->servers = $servers;
$this->input = $input;
$this->output = new OutputWatcher($output);
$this->informer = new Informer($this->output);
$this->port = self::START_PORT;
connect:
$this->pure = new Server($this->port);
$this->loop = $this->pure->getLoop();
// Start workers for each server.
$this->loop->addTimer(0, [$this, 'startWorkers']);
// Wait for output
$this->outputStorage = $this->pure['output'] = new QueueStorage();
$this->loop->addPeriodicTimer(0, [$this, 'catchOutput']);
// Lookup for exception
$this->exceptionStorage = $this->pure['exception'] = new QueueStorage();
$this->loop->addPeriodicTimer(0, [$this, 'catchExceptions']);
// Send workers tasks to do.
$this->loop->addPeriodicTimer(0, [$this, 'sendTasks']);
// Wait all workers finish they tasks.
$this->loop->addPeriodicTimer(0, [$this, 'idle']);
// Start loop
try {
$this->pure->run();
} catch (ConnectionException $exception) {
// If port is already used, try with another one.
$output->writeln("<error>" . $exception->getMessage() . "</error>");
if (++$this->port <= self::STOP_PORT) {
goto connect;
}
}
}
public function __construct(LoopInterface $loop, EventEmitter $emit, \SplObjectStorage $clients, RoundProcessor $roundProcessor, EngineHelper $helper, $time = 60, $debug = false)
{
$this->debug = $debug;
$this->helper = $helper;
$this->emit = $emit;
$this->loop = $loop;
$this->roundTimer = new RoundTimer($loop, $emit);
$this->roundNumber = 0;
$this->clients = $clients;
$this->disconnected = new \SplObjectStorage();
$this->time = $time;
$that = $this;
$this->say = new Say($this->clients);
$this->roundProcessor = $roundProcessor;
$players = new Say($this->clients);
// Setup listeners on the roundTimer object.
$emit->on('GAME.COUNTDOWN', function () use($that) {
if ($this->playerCount !== $this->clients->count()) {
$this->playerCount = $this->clients->count();
$this->say->to($this->clients)->that(Say::TICK, ["players" => $this->playerCount]);
}
});
// Setup listeners on the roundTimer object.
$emit->on('GAME.COUNTDOWN_END', function () use($that, $loop, $emit) {
$this->say->to($this->clients)->that(Say::GAME_STARTING, ["players" => $this->clients->count()]);
$this->setGameStarted(true);
$loop->addTimer(3, function () use($loop, $emit) {
$this->startRound($loop, $emit);
});
});
$this->roundTimer->startCountDown($this->time);
}
/**
* Add event listener to event loop.
*
* @param $fd
* @param $flag
* @param $func
* @param array $args
* @return bool
*/
public function add($fd, $flag, $func, $args = array())
{
switch ($flag) {
case EventInterface::EV_READ:
return $this->_loop->addReadStream($fd, $func);
case EventInterface::EV_WRITE:
return $this->_loop->addWriteStream($fd, $func);
case EventInterface::EV_SIGNAL:
return $this->_loop->addSignal($fd, $func);
case EventInterface::EV_TIMER:
return $this->_loop->addPeriodicTimer($fd, $func);
case EventInterface::EV_TIMER_ONCE:
return $this->_loop->addTimer($fd, $func);
}
return false;
}
/**
* @param Player $player
* @param ServerMessageInterface $message
* @param int $timeout
*
* @return Promise
*/
public function enqueueMessage(Player $player, ServerMessageInterface $message, $timeout = 0)
{
$deferred = new Deferred();
$sendMessage = function () use($player, $message, $deferred) {
$connection = $this->getPlayerConnection($player);
if (!$connection) {
$deferred->reject(new \RuntimeException('Connection for player ' . $player->getName() . ' does not exist'));
return;
}
try {
$serializedMessage = $this->serializer->serialize($message);
// Newline is the message separator
$connection->getSocket()->write($serializedMessage . "\n");
$connection->setLastMessageSentAt(new \DateTime());
$deferred->resolve();
} catch (\Exception $e) {
try {
$connection->getSocket()->close();
} catch (\Exception $e) {
}
$deferred->reject($e);
}
};
if ($timeout > 0) {
/** @noinspection PhpParamsInspection */
$this->loop->addTimer($timeout, $sendMessage);
} else {
$sendMessage();
}
return $deferred->promise();
}
/**
* Sets up a callback to poll a specified feed.
*
* @param string $url Feed URL
*/
protected function queuePoll($url)
{
$self = $this;
$this->loop->addTimer($this->interval, function () use($url, $self) {
$self->pollFeed($url);
});
}
public function handleConnectedSocks(Stream $stream, $host, $port, $timeout, $protocolVersion, $auth = null)
{
$deferred = new Deferred();
$resolver = $deferred->resolver();
$timerTimeout = $this->loop->addTimer($timeout, function () use($resolver) {
$resolver->reject(new Exception('Timeout while establishing socks session'));
});
if ($protocolVersion === '5' || $auth !== null) {
$promise = $this->handleSocks5($stream, $host, $port, $auth);
} else {
$promise = $this->handleSocks4($stream, $host, $port);
}
$promise->then(function () use($resolver, $stream) {
$resolver->resolve($stream);
}, function ($error) use($resolver) {
$resolver->reject(new Exception('Unable to communicate...', 0, $error));
});
$loop = $this->loop;
$deferred->then(function (Stream $stream) use($timerTimeout, $loop) {
$loop->cancelTimer($timerTimeout);
$stream->removeAllListeners('end');
return $stream;
}, function ($error) use($stream, $timerTimeout, $loop) {
$loop->cancelTimer($timerTimeout);
$stream->close();
return $error;
});
$stream->on('end', function (Stream $stream) use($resolver) {
$resolver->reject(new Exception('Premature end while establishing socks session'));
});
return $deferred->promise();
}
protected function queueProcess()
{
if (!$this->benchmarks->valid()) {
return;
}
$b = $this->benchmarks->current();
$this->benchmarks->next();
$key = serialize([$b->benchmark, $b->subbenchmark, $b->count]);
if (!isset($this->stdout[$key])) {
$this->stdout[$key] = '';
}
if (!isset($this->runtimes[$key])) {
$this->runtimes[$key] = [];
}
$current_process_id = $this->process_id;
$this->process_id++;
$this->processes[$current_process_id] = $process = new Process($b->command);
$start = null;
$process->on('exit', function ($code, $signal) use($b, $key, &$current_process_id, &$start) {
$this->runtimes[$key][] = microtime(true) - $start;
$this->output->writeln('<comment>End ' . $b->benchmark . '-' . $b->subbenchmark . ' ' . $b->count . ' #' . $b->execution . '</comment>');
unset($this->processes[$current_process_id]);
$this->queueProcess();
});
$this->loop->addTimer(0.001, function ($timer) use($process, $key, $b, &$start) {
$this->output->writeln('<comment>Start ' . $b->benchmark . '-' . $b->subbenchmark . ' ' . $b->count . ' #' . $b->execution . '</comment>');
$start = microtime(true);
$process->start($timer->getLoop());
$process->stdout->on('data', function ($data) use(&$stdout, $key) {
$this->stdout[$key] .= $data;
});
});
}
/**
* @param HttpRequest $request
*/
public function setRequestTimeout(HttpRequest $request)
{
if ($this->options['timeout'] > 0) {
$this->requestTimer = $this->loop->addTimer($this->options['timeout'], function () use($request) {
$request->closeError(new \Exception('Transaction time out'));
});
}
}
/**
* Runs the application
*
* @return void
*/
public function run()
{
if (!self::$defaultApplication) {
self::$defaultApplication = $this;
}
$application = $this;
if (OsDetector::isMacOS()) {
$processName = './phpgui-i386-darwin';
$processPath = __DIR__ . '/../lazarus/phpgui-i386-darwin.app/Contents/MacOS/';
} elseif (OsDetector::isFreeBSD()) {
$processName = './phpgui-x86_64-freebsd';
$processPath = __DIR__ . '/../lazarus/';
} elseif (OsDetector::isUnix()) {
$processName = './phpgui-x86_64-linux';
$processPath = __DIR__ . '/../lazarus/';
} elseif (OsDetector::isWindows()) {
$processName = '.\\phpgui-x86_64-win64';
$processPath = __DIR__ . '\\..\\lazarus\\';
} else {
throw new RuntimeException('Operational System not identified by PHP-GUI.');
}
$this->process = $process = new Process($processName, $processPath);
$this->process->on('exit', function () use($application) {
$application->loop->stop();
});
$this->receiver = $receiver = new Receiver($this);
$this->sender = $sender = new Sender($this, $receiver);
$this->loop->addTimer(0.001, function ($timer) use($process, $application, $receiver) {
$process->start($timer->getLoop());
// We need to pause all default streams
// The react/loop uses fread to read data from streams
// On Windows, fread always is blocking
// Stdin is paused, we use our own way to write on it
$process->stdin->pause();
// Stdout is paused, we use our own way to read it
$process->stdout->pause();
// Stderr is paused for avoiding fread
$process->stderr->pause();
$process->stdout->on('data', function ($data) use($receiver) {
$receiver->onData($data);
});
$process->stderr->on('data', function ($data) {
if (!empty($data)) {
Output::err($data);
}
});
$application->running = true;
// Bootstrap the application
$application->fire('start');
});
$this->loop->addPeriodicTimer(0.001, function () use($application) {
$application->sender->tick();
if (@is_resource($application->process->stdout->stream)) {
$application->receiver->tick();
}
});
$this->loop->run();
}
public function __construct(LoopInterface $loop)
{
$bspcProcess = proc_open('pactl subscribe', [['pipe', 'r'], ['pipe', 'w']], $pipes);
$bspcStdout = new Stream($pipes[1], $loop);
$bspcStdout->on('data', [$this, 'onUpdate']);
$loop->addTimer(0, function () {
$this->queryData();
});
}
public function testFutureTickEventGeneratedByTimer()
{
$this->loop->addTimer(0.001, function () {
$this->loop->futureTick(function () {
echo 'future-tick' . PHP_EOL;
});
});
$this->expectOutputString('future-tick' . PHP_EOL);
$this->loop->run();
}
protected function registerCancelTimer()
{
$this->cancel_timer = $this->loop->addTimer(0.5, function () {
if (false == $this->isAllNeedsProvided()) {
$this->deferred->reject();
}
echo "resolving by timer\n";
$this->deferred->resolve($this->response);
});
}
/**
* NewEventLoopScheduler constructor.
* @param callable|LoopInterface $timerCallableOrLoop
*/
public function __construct($timerCallableOrLoop)
{
// passing a loop directly into the scheduler will be deprecated in the next major release
$this->timerCallable = $timerCallableOrLoop instanceof LoopInterface ? function ($ms, $callable) use($timerCallableOrLoop) {
$timerCallableOrLoop->addTimer($ms / 1000, $callable);
} : $timerCallableOrLoop;
parent::__construct($this->now(), function ($a, $b) {
return $a - $b;
});
}
protected function processQueue()
{
$this->loop->addTimer($this->interval, function () {
if ($this->callQueue->isEmpty()) {
return;
}
$message = $this->callQueue->dequeue();
$data = ['function' => $message->getFunction(), 'args' => $message->getArgs(), 'errorResultCode' => $message->getErrorResultCode()];
$message->getDeferred()->resolve($data);
});
}
/**
* Enqueue a callback to be invoked once after the given interval.
*
* The execution order of timers scheduled to execute at the same time is
* not guaranteed.
*
* @param numeric $interval The number of seconds to wait before execution.
* @param callable $callback The callback to invoke.
*
* @return TimerInterface
*/
public function addTimer($interval, callable $callback)
{
$loopTimer = null;
$wrapper = function () use(&$loopTimer, $callback, $interval) {
$this->emit('timerTick', [$interval, $callback, $loopTimer]);
$callback($loopTimer);
};
$loopTimer = new TimerDecorator($this, $this->loop->addTimer($interval, $wrapper));
$this->emit('addTimer', [$interval, $callback, $loopTimer]);
return $loopTimer;
}
/**
* wait/sleep for $time seconds
*
* @param float $time
* @param LoopInterface $loop
*/
function sleep($time, LoopInterface $loop)
{
$wait = true;
$loop->addTimer($time, function () use($loop, &$wait) {
$loop->stop();
$wait = false;
});
do {
$loop->run();
} while ($wait);
}
protected function checkQueue()
{
if ($this->callQueue->count() > 0 && $this->readyPool->count() > 0) {
$this->callQueue->dequeue()->resolve();
}
if ($this->callQueue->count() > 0) {
$this->timer = $this->loop->addTimer(static::INTERVAL, function () {
$this->checkQueue();
});
}
}
/**
* @param LoopInterface $loop
* @param Messenger $messenger
* @return Process
*/
public static function create(LoopInterface $loop, Messenger $messenger)
{
try {
return new Process($loop, $messenger);
} catch (\Exception $exeption) {
$messenger->error(MessagesFactory::error(['message' => $exeption->getMessage(), 'code' => $exeption->getCode(), 'line' => $exeption->getLine(), 'file' => $exeption->getFile()]));
$loop->addTimer(1, function () use($loop) {
$loop->stop();
});
}
}
function resolve($time, LoopInterface $loop)
{
return new Promise(function ($resolve) use($loop, $time, &$timer) {
// resolve the promise when the timer fires in $time seconds
$timer = $loop->addTimer($time, function () use($time, $resolve) {
$resolve($time);
});
}, function ($resolveUnused, $reject) use(&$timer, $loop) {
// cancelling this promise will cancel the timer and reject
$loop->cancelTimer($timer);
$reject(new \RuntimeException('Timer cancelled'));
});
}
/**
* Schedule a callback to execute once
*
* Time intervals are measured in milliseconds.
*
* @param callable $callback Any valid PHP callable
* @param float $delay The delay in seconds before the callback will be invoked (zero is allowed)
* @return int
*/
public function once(callable $callback, $delay)
{
$watcherId = null;
$timer = $this->reactor->addTimer($delay / $this->timeScaleFactor, function () use(&$watcherId, $callback) {
$this->deregisterWatcher($watcherId);
if (isset($this->disabledWatchers[$watcherId])) {
return null;
}
return call_user_func($callback, $watcherId, $this);
});
$watcherId = $this->registerWatcher(self::WATCHER_TYPE_TIMER, $timer);
return $watcherId;
}
/**
* Callback when heartbeat timer timed out.
*/
public function onHeartbeat()
{
$now = microtime(true);
$nextHeartbeat = ($this->lastWrite ?: $now) + $this->options["heartbeat"];
if ($now >= $nextHeartbeat) {
$this->writer->appendFrame(new HeartbeatFrame(), $this->writeBuffer);
$this->flushWriteBuffer()->then(function () {
$this->heartbeatTimer = $this->eventLoop->addTimer($this->options["heartbeat"], [$this, "onHeartbeat"]);
});
} else {
$this->heartbeatTimer = $this->eventLoop->addTimer($nextHeartbeat - $now, [$this, "onHeartbeat"]);
}
}
/**
* @param LoopInterface $loop
* @param array $options
* @param null $termiteCallable
* @return Messenger
*/
public static function child(LoopInterface $loop, array $options = [], $termiteCallable = null)
{
$messenger = new Messenger(new Stream(STDIN, $loop), new Stream(STDOUT, $loop), new Stream(STDERR, $loop), ['read' => 'stdin', 'write_err' => 'stderr', 'write' => 'stdout'] + $options);
if ($termiteCallable === null) {
$termiteCallable = function () use($loop) {
$loop->addTimer(self::TERMINATE_TIMEOUT, [$loop, 'stop']);
};
}
$messenger->registerRpc(Messenger::TERMINATE_RPC, function (Payload $payload, Messenger $messenger) use($loop, $termiteCallable) {
$messenger->emit('terminate', [$messenger]);
$termiteCallable($payload, $messenger);
return new FulfilledPromise();
});
return $messenger;
}
/**
* start crontab every minute
*/
public function crontabCallback(Crontab $crontab, LoopInterface $loop)
{
$loop->addTimer(60 - time() % 60, function () use($crontab) {
$pid = pcntl_fork();
if ($pid > 0) {
return;
} elseif ($pid == 0) {
$crontab->start(time());
exit;
} else {
$this->logger->error("could not fork");
exit;
}
});
}
public function initialize(Messenger $server, Messenger $client, LoopInterface $loop)
{
foreach ($this->messages as $message) {
$client->on($message->event, function ($arg) use($message, $loop) {
$this->assertEquals($arg, $message->arguments);
$message->called = true;
$this->totalCalled++;
if ($this->totalCalled === count($this->messages)) {
$loop->stop();
}
});
$loop->addTimer(0.001, function () use($server, $message) {
$server->send($message->event, $message->arguments);
});
}
$loop->addTimer(3, function () use($loop) {
$loop->stop();
throw new \RuntimeException('Timeout reached, server has not accomplished all messages.');
});
$loop->run();
foreach ($this->messages as $message) {
$this->assertTrue($message->called);
}
}
/**
* @return array
*/
protected function preparePromises()
{
$userFacingDeferred = new Deferred();
$privateDeferred = new Deferred();
$userFacingPromise = $userFacingDeferred->promise();
$privateDeferred->promise()->then(function ($shortUrl) use($userFacingDeferred) {
$userFacingDeferred->resolve($shortUrl);
}, function () use($userFacingDeferred) {
$userFacingDeferred->reject();
});
$this->loop->addTimer($this->shortenTimeout, function () use($privateDeferred) {
$privateDeferred->reject();
});
return [$privateDeferred, $userFacingPromise];
}
public function testEmptyReadablePipe()
{
$ended = false;
$buffer = buffer(['highWaterMark' => 1])->pause();
$buffer->on('end', function () use(&$ended) {
$ended = true;
});
$this->eventLoop->addTimer(0, function () use($buffer) {
$stream = readable(new \ArrayIterator([]));
$stream->pipe($buffer);
$stream->resume();
});
$items = iterator_to_array(iterator($buffer, $this->waitFn(0.5)));
$this->assertSame([], $items);
$this->assertTrue($ended);
}
/**
* @param LoopInterface $loop
* @param callable $task
* @param int|float $interval
* @param bool $periodic
* @param int $count
*
* @throws \InvalidArgumentException
*/
public function __construct(LoopInterface $loop, callable $task, $interval, $periodic = false, $count = null)
{
$this->maxIterations = $count !== null ? (int) $count : ($periodic ? null : 1);
if ($this->maxIterations !== null && $this->maxIterations <= 0) {
throw new \InvalidArgumentException('The count argument must be a positive integer value');
}
$this->task = new Delegate($task);
$this->iterations = 0;
$onTick = function () {
$this->onTick();
};
if ($periodic) {
$this->timer = $loop->addPeriodicTimer($interval, $onTick);
} else {
$this->timer = $loop->addTimer($interval, $onTick);
}
}
/**
* @param RemoteEventMessage $message
* @param null $timeout
* @return \React\Promise\Promise|\React\Promise\PromiseInterface
*/
public function whenResponseTo(RemoteEventMessage $message, $timeout = null)
{
$deferred = new Deferred();
$tag = $message->getTag();
$this->deferred[$tag] = $deferred;
$this->carrierProtocol->sendString($message->toJson());
$this->logger->debug(sprintf("Awaiting response to '%s'%s with %s", $message->getData(), $message->getRoom() ? " in room " . $message->getRoom() : '', $timeout ? "timeout {$timeout}" : 'no timeout'));
if ($timeout) {
$list =& $this->deferred;
$logger = $this->logger;
$this->timers[$tag] = $this->loop->addTimer($timeout, function () use($deferred, &$list, $tag, $logger) {
unset($list[$tag]);
$logger->debug("Request with tag {$tag} has timed out");
$deferred->reject("Timeout occurred");
});
}
return $deferred->promise();
}
public function ping($timeout = 10)
{
$payload = $this->pingSeq;
$this->conn->send(new Frame($payload, true, Frame::OP_PING));
$seq = $this->pingSeq;
$this->pingSeq++;
if ($timeout > 0) {
$timer = $this->loop->addTimer($timeout, function () use($seq) {
if (isset($this->pingRequests[$seq])) {
$this->pingRequests[$seq]['deferred']->reject('timeout');
unset($this->pingRequests[$seq]);
}
});
$deferred = new Deferred();
$this->pingRequests[$seq] = array('seq' => $seq, 'deferred' => $deferred, 'timer' => $timer);
return $deferred->promise();
}
}
