/**
* Run main bot process
*/
public function run()
{
$this->prepareOnMessage();
$this->preparePeriodicCommands();
$this->connect();
$this->loop->run();
}
public function getStatus(callable $callback)
{
$this->request('status', [], function ($result) use($callback) {
$callback(json_decode($result, true));
});
$this->loop->run();
}
/**
* Start the HTTP Server
*/
public function start()
{
$this->httpServer->on('request', [$this, 'handleRequest']);
$this->logger->info("Server is listening at " . $this->configuration['listen']['host'] . ":" . $this->configuration['listen']['port']);
$this->socketServer->listen($this->configuration['listen']['port'], $this->configuration['listen']['host']);
$this->eventLoop->run();
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$this->client->getUsers()->then(function ($users) use($output) {
$this->importUsers($users, $output);
});
$this->loop->run();
}
/**
* Run the application by entering the event loop
* @throws \RuntimeException If a loop was not previously specified
*/
public function run()
{
if (null === $this->loop) {
throw new \RuntimeException("A React Loop was not provided during instantiation");
}
// @codeCoverageIgnoreStart
$this->loop->run();
// @codeCoverageIgnoreEnd
}
/**
* {@inheritdoc}
*/
public function start(ServerContextInterface $context, RequestHandlerInterface $requestHandler)
{
$this->loop = Factory::create();
$this->socketServer = new SocketServer($this->loop);
$this->httpServer = new HttpServer($this->socketServer);
$this->httpServer->on('request', $this->createRequestHandler($requestHandler));
$this->socketServer->listen($context->getListenPort(), $context->getListenAddress());
$this->loop->run();
}
/**
* @param array $options
* @param array $arguments
* @return mixed
*/
public function run(array $options, array $arguments)
{
$port = isset($arguments[0]) ? $arguments[0] : "8001";
$host = isset($arguments[1]) ? $arguments[1] : "0.0.0.0";
/** @var \Castle23\Http\Server $server */
$server = $this->container->getInstanceOf(Server::class);
$this->socket->listen($port, $host);
$this->loop->run();
}
public function run()
{
$this->processes = $this->stdout = $this->runtimes = $this->results = [];
$this->process_id = 0;
while (count($this->processes) < $this->cpus) {
$this->queueProcess();
}
$this->loop->run();
$this->calculateResults();
}
/**
* Starts the websocket server
*
* @return void
*/
public function start()
{
$this->__loop = LoopFactory::create();
if ($this->__loop instanceof \React\EventLoop\StreamSelectLoop) {
$this->out('<warning>Your configuration doesn\'t seem to support \'ext-libevent\'. It is highly reccomended that you install and configure it as it provides significant performance gains over stream select!</warning>');
}
$socket = new Reactor($this->__loop);
$socket->listen(Configure::read('Ratchet.Connection.websocket.port'), Configure::read('Ratchet.Connection.websocket.address'));
$this->__ioServer = new IoServer(new HttpServer(new WsServer(new SessionProvider(new WampServer(new CakeWampAppServer($this, $this->__loop, CakeEventManager::instance(), $this->params['verbose'])), new CakeWampSessionHandler(), [], new PhpSerializeHandler()))), $socket, $this->__loop);
$this->__loop->run();
}
public function start()
{
$this->loop = \WyriHaximus\Ratchet\loopResolver();
$router = new Router($this->loop);
$router->addInternalClient(new InternalClient('first', $this->loop));
$router->addTransportProvider(new RatchetTransportProvider(Configure::read('WyriHaximus.Ratchet.Connection.Websocket.address'), Configure::read('WyriHaximus.Ratchet.Connection.Websocket.port')));
//$router->getRealmManager()->setDefaultAuthorizationManager(new AllPermissiveAuthorizationManager());
EventManager::instance()->dispatch(WebsocketStartEvent::create($this->loop));
$router->start(false);
$this->loop->run();
}
/**
* Runs the message server on the given port.
*
* @param string $consumer Command to execute when a message arrives
* @param integer $port Port to run the server on
*
* @return void
*/
public function run($consumer, $port, $callback = null)
{
// @codeCoverageIgnoreStart
$this->socket->on('connection', function (ConnectionInterface $conn) use($consumer, $callback) {
$conn->on('data', function ($data) use($conn, $consumer, $callback) {
$this->handleData(trim($data), $consumer, $conn, $callback);
});
});
// @codeCoverageIgnoreEnd
$this->socket->listen($port);
$this->loop->run();
}
/**
* Start the websocket server
*/
public function start()
{
$this->__loop = Factory::create();
$pusher = new CakeWampAppServer();
$context = new Context($this->__loop);
$pull = $context->getSocket(ZMQ::SOCKET_PULL);
$pull->bind("tcp://" . Configure::read('CakeRatchet.ZMQServer.host') . ":" . Configure::read('CakeRatchet.ZMQServer.port'));
$pull->on('message', array($pusher, 'onBlogEntry'));
$webSock = new Server($this->__loop);
$webSock->listen(Configure::read('CakeRatchet.Server.port'), Configure::read('CakeRatchet.Server.host'));
$this->__ioServer = new IoServer(new HttpServer(new WsServer(new WampServer($pusher))), $webSock);
$this->__loop->run();
}
/**
* Run react.
*
* @param int $port
* @param string $host
*/
public function run($port, $host)
{
$request_handler = function (Request $request, Response $response) {
echo $request->getMethod() . ' ' . $request->getPath() . PHP_EOL;
$sf_request = $this->request_bridge->convertRequest($request);
$sf_response = $this->app->handle($sf_request);
$this->app->terminate($sf_request, $sf_response);
$this->response_bridge->send($response, $sf_response);
};
$this->http->on('request', $request_handler);
$this->socket->listen($port, $host);
$this->loop->run();
}
/**
* @test
*/
public function itReadsToEnd()
{
$handle = $this->wrap(fopen('php://temp', 'w+'));
fwrite($handle, 'data');
async_stream_register_write($handle, function ($handle) {
fseek($handle, 0);
$this->assertFalse(feof($handle));
fread($handle, 4);
$this->assertTrue(feof($handle));
fclose($handle);
});
$this->loop->run();
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$client = $this->client;
$client->on('message', function (Payload $payload) use($output) {
$this->onMessage($payload, $output);
});
$client->on('reaction_added', function (Payload $payload) use($client, $output) {
$this->onReaction($payload, $output);
});
$client->connect()->then(function () use($client, $output) {
$output->writeln('<info>Connected</info>');
});
$this->loop->run();
}
/**
* @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 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();
}
/**
* 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);
}
}
/**
* Start the event reactor and assume program flow control
*
* @param callable $onStart Optional callback to invoke immediately upon reactor start
*/
public function run(callable $onStart = null)
{
if ($onStart) {
$this->reactor->nextTick($onStart);
}
$this->reactor->run();
}
/**
* Start the transport
*/
public function start($startLoop = true)
{
$this->transportProvider->startTransportProvider($this, $this->loop);
if ($startLoop) {
$this->loop->run();
}
}
/**
* {@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;
}
/**
* @param QueueMessage $message
*
* @return void
*/
protected function publishMessage(QueueMessage $message)
{
$this->channelFactory->fanout($this->exchange, $this->channel)->then(function ($r) use($message) {
/** @var Channel $channel */
$channel = $r[0];
return \React\Promise\all([$channel->publish(json_encode($this->serializer->serialize($message)), [], $this->exchange)]);
}, function (Exception $exception) {
$this->loop->stop();
throw new AsyncMessagingException(sprintf('Could not publish message: %s on line %s in file %s', $exception->getMessage(), $exception->getLine(), $exception->getFile()), 0, $exception);
})->then(function () {
$this->loop->stop();
}, function (Exception $exception) {
$this->loop->stop();
var_dump(sprintf('Could not publish message: %s on line %s in file %s', $exception->getMessage(), $exception->getLine(), $exception->getFile()));
});
$this->loop->run();
}
private function assertRunFasterThan($maxInterval)
{
$start = microtime(true);
$this->loop->run();
$end = microtime(true);
$interval = $end - $start;
$this->assertLessThan($maxInterval, $interval);
}
/**
* 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();
}
/**
* Starts the request loop
*/
public function start()
{
$this->prepareEventLoop();
$this->setupServer();
$this->startTime = new DateTime();
$this->_isRunning = TRUE;
$this->eventLoop->run();
$this->_isRunning = FALSE;
}
/**
* Starts shell
*/
public function run()
{
if ($this->running) {
return;
}
$shell = $this;
$this->loop->addReadStream(STDIN, function ($n) use($shell) {
$c = stream_get_contents($n, 1);
$shell->read($c);
});
// allows control keys to work
if (function_exists('readline_callback_handler_install')) {
readline_callback_handler_install('', function () {
});
}
$this->running = true;
$this->loop->run();
}
/**
* Calls {@link eventLoop}'s run() method. Processes messages for at most $maxSeconds.
*
* @param float $maxSeconds
*/
public function run($maxSeconds = null)
{
if ($maxSeconds !== null) {
$this->stopTimer = $this->eventLoop->addTimer($maxSeconds, function () {
$this->stop();
});
}
$this->eventLoop->run();
}
/**
* Start the transport
*
* @param boolean $startLoop
* @throws \Exception
*/
public function start($startLoop = true)
{
if ($this->transportProvider === null) {
throw new \Exception("You must add exactly one transport provider prior to starting");
}
$this->transportProvider->startTransportProvider($this, $this->loop);
if ($startLoop) {
$this->loop->run();
}
}
/**
* 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();
}
/**
* Start router
*
* @param bool $runLoop
* @throws \Exception
*/
public function start($runLoop = true)
{
Logger::info($this, "Starting router");
if ($this->loop === null) {
throw new \Exception("Loop is null");
}
$this->started = true;
$this->eventDispatcher->dispatch("router.start", new RouterStartEvent());
if ($runLoop) {
Logger::info($this, "Starting loop");
$this->loop->run();
}
}
