/**
* Builds internal request handling objects.
*
* @return $this
*/
public function build()
{
if ($this->cache) {
$loader = new ClassLoader();
if ($this->apc) {
$apcLoader = new ApcClassLoader(sha1('ReactServer'), $loader);
$loader->unregister();
$apcLoader->register(true);
}
}
require_once $this->root_dir . '/AppKernel.php';
define('KERNEL_ROOT', $this->root_dir);
$kernel = new ReactKernel($this->env, $this->env === 'dev' ? true : false);
$this->loop = Factory::create();
// TODO make config for this part
if (class_exists('\\Doctrine\\DBAL\\Driver\\PingableConnection')) {
$this->loop->addPeriodicTimer(15, function () use($kernel) {
foreach ($kernel->getContainer()->get('doctrine')->getConnections() as $connection) {
if ($connection instanceof \Doctrine\DBAL\Driver\PingableConnection) {
$connection->ping();
}
}
});
}
$this->socket = new SocketServer($this->loop);
$http = new HttpServer($this->socket, $this->loop);
$http->on('request', $this->handleRequest($kernel));
return $this;
}
public function __construct(AMQPQueue $queue, LoopInterface $loop, Serializer $serializer)
{
$this->queue = $queue;
$this->loop = $loop;
$this->timer = $this->loop->addPeriodicTimer(1, [$this, 'listen']);
$this->serializer = $serializer;
}
/**
* Adds timer to Loop queue
*
* @param float $interval
* @return TimerInterface
*/
public function start($interval = self::DEFAULT_INTERVAL)
{
if ($this->timer) {
$this->stop();
}
return $this->timer = $this->loop->addPeriodicTimer($interval, $this);
}
/**
* @param TopicInterface $topic
* @param string $name
* @param int|float $timeout
* @param mixed $callback
*/
public function addPeriodicTimer(TopicInterface $topic, $name, $timeout, $callback)
{
$namespace = spl_object_hash($topic);
if (!isset($this->registry[$namespace])) {
$this->registry[$namespace] = [];
}
$this->registry[$namespace][$name] = $this->loop->addPeriodicTimer($timeout, $callback);
}
/**
* ShortUUID constructor.
*
* @param LoopInterface $loop
* @param int $generator_id
*/
public function __construct(LoopInterface $loop, $generator_id = 1)
{
$this->loop = $loop;
$this->generator_id = (int) $generator_id;
$this->resetCounter();
// reset the counter every 1 milliseconds
$this->loop->addPeriodicTimer(0.001, array($this, 'resetCounter'));
}
/**
* Constructor. Stores the message queue and the event loop for use.
*
* @param AMQPQueue $queue Message queue
* @param React\EventLoop\LoopInterface $loop Event loop
* @param float $interval Interval to check for new messages
* @param int $max Max number of messages to consume in one go
*/
public function __construct(AMQPQueue $queue, LoopInterface $loop, $interval, $max = null)
{
$this->queue = $queue;
$this->loop = $loop;
$this->max = $max;
$this->timer = $this->loop->addPeriodicTimer($interval, $this);
$this->on('close_amqp_consumer', [$this, 'close']);
}
/**
* Start the keep alive timer when the first client subscribes
*
* @param CakeEvent $event
*/
public function onSubscribeNewTopic(CakeEvent $event)
{
if (Configure::read('Ratchet.Connection.keepaliveInterval') > 0) {
$this->__timer = $this->__loop->addPeriodicTimer(Configure::read('Ratchet.Connection.keepaliveInterval'), function () use($event) {
$event->subject()->broadcast('Rachet.connection.keepAlive', ['ping']);
});
$event->subject()->broadcast('Rachet.connection.keepAlive', ['ping']);
}
}
public function init(LoopInterface $loop = null)
{
$this->loop = is_null($loop) ? \React\EventLoop\Factory::create() : $loop;
$this->loop->addPeriodicTimer(0.1, array($this, 'checkSchedule'));
$this->bindSignals();
$this->loop->addPeriodicTimer(1, function () {
pcntl_signal_dispatch();
});
}
public function __construct(LoopInterface $loop, FrameBuffer $frameBuffer, ContainerInterface $container)
{
$this->loop = $loop;
$this->frameBuffer = $frameBuffer;
$this->container = $container;
$this->connections = new \SplObjectStorage();
$fps = (double) $container->get('server.fps');
$this->update_timer = $this->loop->addPeriodicTimer(1.0 / $fps, [$this, 'onFrameUpdate']);
$this->switchToGameLoop($container->get(TestImageScreen::class));
}
protected function addLookupTimer()
{
$this->loop->addPeriodicTimer(30, function () {
$addresses = $this->lookup->lookup();
foreach ($addresses as $address) {
$key = $address['ip'] . ':' . $address['port'];
}
// ... refresh connection
});
}
public function start()
{
$this->bindSignals();
//master process shutdown request handler
$this->loop->addPeriodicTimer(1, function () {
pcntl_signal_dispatch();
});
foreach ($this->daemons as $daemon) {
$this->daemons[$daemon] = $this->newInstance($daemon);
}
}
public function handle($id)
{
$this->id = $id;
printf("Will connect on %s\n", $this->ip);
$this->dealer->connect($this->ip, sprintf('dealer-%s', $this->id));
$this->dealer->filter(function (Event $event) {
return $event->is("/response/foo");
})->subscribeCallback([$this, 'onFooResponse']);
$this->dealer->filter(function (Event $event) {
return $event->is("/response/bar");
})->subscribeCallback([$this, 'onBarResponse']);
echo "Will ask router every 5 seconds\n";
$this->loop->addPeriodicTimer(5, [$this, 'askRouter']);
}
/**
* @param int $port
* @param string $host
*/
public function listen($port, $host)
{
$this->http->on('request', function (ReactRequest $request, ReactResponse $response) {
return $this->onRequest($request, $response);
});
$this->logger->info("Phiremock http server listening on {$host}:{$port}");
$this->socket->listen($port, $host);
// Dispatch pending signals periodically
if (function_exists('pcntl_signal_dispatch')) {
$this->loop->addPeriodicTimer(0.5, function () {
pcntl_signal_dispatch();
});
}
$this->loop->run();
}
/**
* Start server
*
* @throws RuntimeException
*/
public function run()
{
try {
$this->loop->addPeriodicTimer($this->timePeriod, $this->getPeriodicTimerCallback());
//listening of the ports
foreach ($this->listen as $port) {
$socket = new Server($this->loop);
//initialize socket
$socket->on('connection', function (Connection $conn) {
$this->conns->attach($conn);
$conn->on('data', function ($data, $conn) {
//$request insteadof React\Http\Request
list($request, $body) = (new RequestHeaderParser())->parseRequest($data);
$this->conns->attach($conn, new LongPooling\ConnectionInfo($request, $body));
});
$conn->on('end', function ($conn) {
$this->conns->detach($conn);
});
});
$socket->listen($port);
}
$this->loop->run();
} catch (Exception $e) {
throw new RuntimeException("Server Run Exception", 301, $e);
}
}
/**
* @param bool $profile
*
* @throws \React\Socket\ConnectionException
*/
public function launch($host, $port, $profile)
{
$this->logger->info('Starting web socket');
$stack = new Builder();
$server = new Server($this->loop);
$server->listen($port, $host);
if (true === $profile) {
$memoryUsagePeriodicTimer = new PeriodicMemoryUsage($this->logger);
$this->periodicRegistry->addPeriodic($memoryUsagePeriodicTimer);
}
/** @var PeriodicInterface $periodic */
foreach ($this->periodicRegistry->getPeriodics() as $periodic) {
$this->loop->addPeriodicTimer($periodic->getTimeout(), [$periodic, 'tick']);
$this->logger->info(sprintf('Register periodic callback %s, executed each %s seconds', $periodic instanceof ProxyInterface ? get_parent_class($periodic) : get_class($periodic), $periodic->getTimeout()));
}
$allowedOrigins = array_merge(array('localhost', '127.0.0.1'), $this->originRegistry->getOrigins());
$stack->push('Ratchet\\Server\\IoServer', $server, $this->loop)->push('Ratchet\\Http\\HttpServer');
if ($this->originCheck) {
$stack->push('Gos\\Bundle\\WebSocketBundle\\Server\\App\\Stack\\OriginCheck', $allowedOrigins, $this->eventDispatcher);
}
$stack->push('Ratchet\\WebSocket\\WsServer')->push('Gos\\Bundle\\WebSocketBundle\\Server\\App\\Stack\\WampConnectionPeriodicTimer', $this->loop)->push('Ratchet\\Session\\SessionProvider', $this->sessionHandler)->push('Ratchet\\Wamp\\WampServer');
$app = $stack->resolve($this->wampApplication);
/* Server Event Loop to add other services in the same loop. */
$event = new ServerEvent($this->loop, $server);
$this->eventDispatcher->dispatch(Events::SERVER_LAUNCHED, $event);
$this->logger->info(sprintf('Launching %s on %s PID: %s', $this->getName(), $host . ':' . $port, getmypid()));
$app->run();
}
/**
* Create a new file driven handler instance.
*
* @param \Illuminate\Filesystem\Filesystem $files
* @param React\EventLoop\LoopInterface $loop
* @param string $path
*
* @return void
*/
public function __construct(Factory $factory, LoopInterface $loop, Server $server, $lifetime)
{
$this->factory = $factory;
$this->lifetime = $lifetime;
$this->server = $server;
$this->loop = $loop;
// PING redis connection every 5 minutes
// and try to reconnect on connection error
$this->timer = $loop->addPeriodicTimer(60 * 1, function () use($server) {
$this->promise->then(function ($client) use($server) {
$client->PING()->then(function ($pong) use($server) {
$server->log('Redis server responded ping with: %s', [$pong]);
return $pong == 'PONG';
}, function ($e) {
return $this->reconnectByError($e);
});
});
});
// server statistics for redis connection
$this->loop->addPeriodicTimer(60 * 30, function () {
$this->server->log('Server statistics to the last 30 minutes.');
$this->server->log('Best time of %fs, poor time of %fs and a average of %f seconds for total %d requests.', array_values($this->statistics));
$this->statistics = array('best' => 0, 'poor' => 0, 'avg' => 0, 'total' => 0);
});
}
/**
* Starts downloader in daemon mode, awaiting for future tasks
* @todo Locks and signal processing
*
* @param EventLoop\LoopInterface $loop A loop, worker is run on
*/
public function runDaemon(EventLoop\LoopInterface $loop)
{
$loop->addPeriodicTimer($this->tick, function ($timer) use($loop) {
$this->run($loop, $this->limit);
});
$loop->run();
}
/**
* @param string $captchaId
* @return Promise\Promise
*/
public function wait($captchaId)
{
$deferred = new Promise\Deferred();
$this->loop->addPeriodicTimer($this->requestInterval, function ($timer) use($deferred, $captchaId) {
$request = $this->client->request($this->getResultMethod(), $this->getResultPath(), ['Content-Length' => strlen($this->getResultQuery($captchaId)), 'Content-Type' => 'application/x-www-form-urlencoded']);
$request->on('response', function ($response) use($request, $deferred, $timer) {
/** @var \React\HttpClient\Response $response */
$response->on('data', function ($data, $response) use($request, $deferred, $timer) {
/** @var \GuzzleHttp\Psr7\Stream $data */
/** @var \React\HttpClient\Response $response */
$response->handleEnd();
$answer = $data->getContents();
// stream read
if (!$answer) {
$this->loop->cancelTimer($timer);
$deferred->reject(new ServiceException('ERROR_CONNECTION'));
} elseif (substr($answer, 0, 2) === 'OK') {
$this->loop->cancelTimer($timer);
$deferred->resolve(substr($answer, 3));
} elseif ($answer !== 'CAPCHA_NOT_READY') {
$this->loop->cancelTimer($timer);
$deferred->reject(new ServiceException($answer));
}
});
});
$request->end($this->getResultQuery($captchaId));
});
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;
}
}
}
/**
* 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;
}
/**
* Start manager loop
*/
private function startLoop()
{
$this->client = $this->stompFactory->createClient();
$this->client->connect()->then(function (Client $client) {
$this->loop->addPeriodicTimer(self::PROVISION_TIME, function () {
$this->provision();
});
$client->subscribe($this->channel, function (Frame $frame) use($client) {
try {
$request = $this->messageTransformer->decodeRequest($frame->body);
$closure = $request->getClosure();
if (!is_callable($closure)) {
throw new ManagerException('Запрос не содерджит callable');
}
$result = $closure($this);
$response = new Response($result);
} catch (\Exception $e) {
$this->logger->error('Exception при обработке запроса ' . $e->getMessage());
$response = new Response($e->getMessage(), Response::STATUS_ERROR);
}
if ($replayTo = $frame->getHeader('reply-to')) {
$body = $this->messageTransformer->encodeResponse($response);
$client->send($replayTo, $body);
}
});
}, function (\Exception $e) {
$this->logger->critical($e->getMessage());
});
$this->loop->run();
}
/**
* 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();
}
/**
* Create a new event pusher handler
*/
public function __construct(LoopInterface $loop, OutputInterface $output = null)
{
$this->loop = $loop;
$this->output = $output;
$this->clients = new \SplObjectStorage();
$this->subscriber = \Service::getContainer()->get('kernel.subscriber.bzion_subscriber');
// Ping timer
$loop->addPeriodicTimer(self::KEEP_ALIVE, array($this, 'ping'));
}
/**
* Enqueue a callback to be invoked repeatedly 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 addPeriodicTimer($interval, callable $callback)
{
$loopTimer = new TimerDecorator($this, $this->loop->addPeriodicTimer($interval, function () use(&$loopTimer, $callback, $interval) {
$this->emit('periodicTimerTick', [$interval, $callback, $loopTimer]);
$callback($loopTimer);
}));
$this->emit('addPeriodicTimer', [$interval, $callback, $loopTimer]);
return $loopTimer;
}
/**
* @param string
* @return \React\Promise\PromiseInterface
*/
function query($query)
{
return $this->pool->getConnection()->then(function (mysqli $conn) use($query) {
$status = $conn->query($query, MYSQLI_ASYNC);
if ($status === false) {
$this->pool->free($conn);
throw new Exception($conn->error);
}
$id = spl_object_hash($conn);
$this->conn[$id] = $conn;
$this->query[$id] = $query;
$this->deferred[$id] = $deferred = new Deferred();
if (!isset($this->timer)) {
$this->timer = $this->loop->addPeriodicTimer(0.01, function () {
$links = $errors = $reject = $this->conn;
mysqli_poll($links, $errors, $reject, 0);
// don't wait, just check
$each = array('links' => $links, 'errors' => $errors, 'reject' => $reject);
foreach ($each as $type => $connects) {
/**
* @var $conn mysqli
*/
foreach ($connects as $conn) {
$id = spl_object_hash($conn);
if (isset($this->conn[$id])) {
$deferred = $this->deferred[$id];
if ($type == 'links') {
/**
* @var $result mysqli_result
*/
$result = $conn->reap_async_query();
if ($result === false) {
$deferred->reject(new Exception($conn->error . '; sql: ' . $this->query[$id]));
} else {
$deferred->resolve(new Result($result, $conn->insert_id, $conn->affected_rows));
}
}
if ($type == 'errors') {
$deferred->reject(new Exception($conn->error . '; sql: ' . $this->query[$id]));
}
if ($type == 'reject') {
$deferred->reject(new Exception('Query was rejected; sql: ' . $this->query[$id]));
}
unset($this->deferred[$id], $this->conn[$id], $this->query[$id]);
$this->pool->free($conn);
}
}
}
if (empty($this->conn)) {
$this->timer->cancel();
$this->timer = null;
}
});
}
return $deferred->promise();
});
}
/**
* Prepare periodic commands
*/
protected function preparePeriodicCommands()
{
$commands = $this->invoker->getPeriodicCommands();
foreach ($commands as $command) {
$this->loop->addPeriodicTimer($command->getInterval(), function () use($command) {
$cmdResult = $command->execute();
$this->sendMessageByDestName($cmdResult->getText(), $cmdResult->getDestination());
});
}
}
/**
* @param int $timeout
* @return $this
*/
public function timeoutWithoutVersion($timeout = 20)
{
$this->once('data', function () use($timeout) {
$this->loop->addPeriodicTimer($timeout, function (Timer $timer) {
if (false === $this->exchangedVersion) {
$this->intentionalClose();
}
$timer->cancel();
});
});
return $this;
}
public function __construct(LoopInterface $loop, $queueKey, array $options = array())
{
$this->loop = $loop;
$this->queueKey = $queueKey;
$this->parseOptions($options);
$this->initQueue();
// add our queue polling loop
$self = $this;
$this->loop->addPeriodicTimer($this->loopInterval, function () use($self) {
$self->checkMessages();
});
}
public function handle()
{
printf("Will connect on %s\n", $this->sock);
$this->pusher->connect($this->sock);
echo "Will push keepalive every 5 seconds\n";
$this->loop->addPeriodicTimer(5, [$this, 'keepAlive']);
$this->httpd->route('POST', '/{type}', function (HttpdRequest $request, HttpdResponse $response) {
try {
$data = $request->getJson();
} catch (\Exception $e) {
$response->sendError($e->getMessage());
return;
}
$type = $request->getRouteParam('type');
$name = sprintf("/request/%s", $type);
printf("Sending %s with data : %s\n", $name, json_encode($data));
$this->pusher->send(new \Rxnet\Event\Event($name, $data));
$response->text("It worked\n");
});
printf("You can send to puller from curl -XPOST http://127.0.0.1:23002/whatever -d'{'json':'encoded'}'\n");
$this->httpd->listen(23002);
}
/**
* Starts the processor server.
*
* @param OutputInterface $output
* @param bool $verbose
* @throws \React\Socket\ConnectionException
*/
public function start(OutputInterface &$output, $verbose = false)
{
$this->output = $output;
$this->verbose = $verbose;
$this->loop = Factory::create();
$this->socket = new Server($this->loop);
$http = new \React\Http\Server($this->socket);
$http->on('request', [$this, 'manageRequest']);
$this->socket->listen($this->port, $this->host);
$this->registerListeners();
$this->loop->addPeriodicTimer($this->interval, [$this, 'manageQueue']);
$this->loop->run();
}
