/**
  * Execute the console command.
  *
  * @return void
  */
 public function fire()
 {
     echo 'Iniciado' . PHP_EOL;
     $start = microtime(true);
     $totalUsers = User::count();
     //cria o main loop
     $loop = \React\EventLoop\Factory::create();
     //cria a conexão MySQL
     $connection = new \React\MySQL\Connection($loop, array('dbname' => $_ENV['DB_DATABASE'], 'user' => $_ENV['DB_USERNAME'], 'passwd' => $_ENV['DB_PASSWORD']));
     $connection->connect(function () {
     });
     $query1 = '
         SELECT * FROM users
             LEFT JOIN companies ON users.company_id = companies.id
         LIMIT ' . $totalUsers / 2 . '
     ;';
     $query2 = '
         SELECT * FROM users
             LEFT JOIN companies ON users.company_id = companies.id
         LIMIT ' . $totalUsers / 2 . '
         OFFSET ' . $totalUsers / 2 . '
     ;';
     $this->getUsers($connection, $query1, $loop);
     $this->getUsers($connection, $query2, $loop);
     $loop->run();
     echo 'Processados ' . count($this->users) . ' usuários' . PHP_EOL;
     echo 'Demorou ' . number_format((microtime(true) - $start) * 1000, 2, ',', '') . 'ms' . PHP_EOL;
 }
 /**
  * Execute the console command.
  *
  * @return mixed
  */
 public function fire()
 {
     // create a log channel
     $log = new Logger('websocket');
     $log->pushHandler(new RotatingFileHandler(storage_path() . '/logs/websocket.log', 10, Logger::DEBUG));
     $config = Config::get('announcements-server');
     $loop = LoopFactory::create();
     $announcements = new AnnouncementsWebSocket($log);
     // Listen for the web server to make a message push.
     $broadcast = 'tcp://' . $config['broadcast']['ip'] . ':' . $config['broadcast']['port'];
     $this->info('Starting broadcast socket on ' . $broadcast);
     $context = new ZMQContext($loop);
     $broadcastSocket = $context->getSocket(ZMQ::SOCKET_PULL);
     $broadcastSocket->bind($broadcast);
     $broadcastSocket->on('message', array($announcements, 'onBroadcast'));
     // Listen for status check.
     $status = 'tcp://' . $config['status']['ip'] . ':' . $config['status']['port'];
     $this->info('Starting status socket on ' . $status);
     $statusSock = new SocketServer($loop);
     $statusSock->listen($config['status']['port'], $config['status']['ip']);
     new IoServer(new AnnouncementsServerStatus(), $statusSock);
     // Listen for WebSocket connections.
     $wsPort = $config['websocket']['port'];
     $wsIp = $config['websocket']['ip'];
     $this->info('Starting WebSocket socket on ws://' . $wsIp . ':' . $wsPort);
     $webSock = new SocketServer($loop);
     $webSock->listen($wsPort, $wsIp);
     new IoServer(new HttpServer(new WsServer($announcements)), $webSock);
     // Ping all clients each 2 min.
     $loop->addPeriodicTimer(120, function () use($announcements) {
         $announcements->ping();
     });
     $log->info('Server started');
     $loop->run();
 }
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $arguments = $this->getCommandArguments($input);
     $builder = $this->getEnvironmentHelper()->getProcessBuilder($arguments);
     $command = $builder->getProcess()->getCommandLine();
     $loop = Factory::create();
     $process = new Process($command, $this->getEnvironmentHelper()->getCwd());
     $port = (int) $input->getOption('port');
     $server = $this->initializeServer($loop, $port);
     $started = false;
     $this->addEnvironmentInfo($port, $command);
     $loop->addPeriodicTimer(self::LOOP_TIMER_PERIOD, function (Timer $timer) use($output, $process, $server, &$started) {
         $clients = $server->getConnections();
         if (true === $started && false === $process->isRunning()) {
             exit($process->getExitCode());
         }
         if ($clients->count()) {
             if (!$process->isRunning()) {
                 $process->start($timer->getLoop());
                 $started = true;
                 $this->broadcastToClients($clients);
             }
             $callable = function ($output) use($clients) {
                 $this->buffer .= $output;
                 $this->broadcastToClients($clients);
             };
             $process->stdin->on('data', $callable);
             $process->stdout->on('data', $callable);
             $process->stderr->on('data', $callable);
         }
     });
     $server->bind();
     $loop->run();
 }
Beispiel #4
0
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     // Make sure that websockets are enabled in the config so that the proper
     // session storage handler is used
     if (!$this->getContainer()->getParameter('bzion.features.websocket.enabled')) {
         $message = "You need to enable websockets in your config before using the push server";
         $output->writeln("<bg=red;options=bold>\n\n [ERROR] {$message}\n</>");
         return;
     }
     $loop = EventLoopFactory::create();
     $pusher = new EventPusher($loop, $output);
     $pushPort = $input->getOption('push') ?: $this->getContainer()->getParameter('bzion.features.websocket.push_port');
     $pullPort = $input->getOption('pull') ?: $this->getContainer()->getParameter('bzion.features.websocket.pull_port');
     $pullSocket = new Server($loop);
     $pullSocket->on('connection', function ($conn) use($pusher) {
         $conn->on('data', function ($data) use($pusher) {
             $pusher->onServerEvent(json_decode($data));
         });
     });
     // Bind to 127.0.0.1, so that only the server can send messages to the socket
     $pullSocket->listen($pullPort, '127.0.0.1');
     $output->writeln(" <fg=green>Running pull service on port {$pullPort}</>");
     $session = new SessionProvider($pusher, new DatabaseSessionHandler());
     $pushSocket = new Server($loop);
     $webServer = new IoServer(new WsServer($session), $pushSocket);
     // Binding to 0.0.0.0 means remotes can connect
     $pushSocket->listen($pushPort, '0.0.0.0');
     $output->writeln(" <fg=green>Running push service on port {$pushPort}</>");
     $output->writeln("\n <bg=green;options=bold>Welcome to the BZiON live notification server!</>");
     $loop->run();
 }
 public function setUp()
 {
     $this->loop = Factory::create();
     $this->dialog = $this->getMock('Clue\\React\\Zenity\\Dialog\\AbstractDialog');
     $this->dialog->expects($this->once())->method('createZen')->will($this->returnValue(new BaseZen()));
     $this->launcher = new Launcher($this->loop);
 }
Beispiel #6
0
 /**
  * @param string        $httpHost HTTP hostname clients intend to connect to. MUST match JS `new WebSocket('ws://$httpHost');`
  * @param int           $port     Port to listen on. If 80, assuming production, Flash on 843 otherwise expecting Flash to be proxied through 8843
  * @param string        $address  IP address to bind to. Default is localhost/proxy only. '0.0.0.0' for any machine.
  * @param LoopInterface $loop     Specific React\EventLoop to bind the application to. null will create one for you.
  */
 public function __construct($httpHost = 'localhost', $port = 8080, $address = '127.0.0.1', LoopInterface $loop = null, $context = array())
 {
     if (extension_loaded('xdebug')) {
         trigger_error("XDebug extension detected. Remember to disable this if performance testing or going live!", E_USER_WARNING);
     }
     if (3 !== strlen('✓')) {
         throw new \DomainException('Bad encoding, length of unicode character ✓ should be 3. Ensure charset UTF-8 and check ini val mbstring.func_autoload');
     }
     if (null === $loop) {
         $loop = LoopFactory::create();
     }
     $this->httpHost = $httpHost;
     $socket = new Reactor($loop, $context);
     $socket->listen($port, $address);
     $this->routes = new RouteCollection();
     $this->_server = new IoServer(new HttpServer(new Router(new UrlMatcher($this->routes, new RequestContext()))), $socket, $loop);
     $policy = new FlashPolicy();
     if ('*' !== $httpHost) {
         $policy->addAllowedAccess($httpHost, 80);
         $policy->addAllowedAccess($httpHost, $port);
     }
     $flashSock = new Reactor($loop);
     $this->flashServer = new IoServer($policy, $flashSock);
     if (80 == $port) {
         $flashSock->listen(843, '0.0.0.0');
     } else {
         $flashSock->listen(8843);
     }
 }
 /**
  * @param InputInterface $input
  * @param OutputInterface $output
  * @return int
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $loop = \React\EventLoop\Factory::create();
     // Listen for the web server to make a ZeroMQ push after an ajax request
     $context = new Context($loop);
     $pull = $context->getSocket(\ZMQ::SOCKET_SUB);
     $pull->connect('tcp://127.0.0.1:5566');
     // Binding to 127.0.0.1 means the only client that can connect is itself
     $pull->subscribe('');
     $batch = 0;
     $pull->on('message', function ($msg) use(&$batch) {
         $arr = json_decode($msg);
         if ($arr->event == 'block') {
             $batch++;
         }
     });
     $period = $input->getArgument('interval');
     $loop->addPeriodicTimer($period, function () use(&$batch, $period) {
         $velocity = $batch / $period;
         echo " count: " . $batch . " - or " . $velocity . " per second " . PHP_EOL;
         $batch = 0;
     });
     $loop->run();
     return 0;
 }
 public function __construct()
 {
     parent::__construct(function () {
         $consensus = new ConsensusFactory(Bitcoin::getEcAdapter());
         $loop = LoopFactory::create();
         $context = new ZmqContext($loop);
         $control = $context->getSocket(\ZMQ::SOCKET_SUB);
         $control->connect('tcp://127.0.0.1:5594');
         $control->subscribe('control');
         $control->on('messages', function ($msg) use($loop) {
             if ($msg[1] == 'shutdown') {
                 $loop->stop();
             }
         });
         $results = $context->getSocket(\ZMQ::SOCKET_PUSH);
         $results->connect("tcp://127.0.0.1:5593");
         $workers = $context->getSocket(\ZMQ::SOCKET_PULL);
         $workers->connect('tcp://127.0.0.1:5592');
         $workers->on('message', function ($message) use($consensus, $results) {
             $details = json_decode($message, true);
             $txid = $details['txid'];
             $flags = $details['flags'];
             $vin = $details['vin'];
             $scriptPubKey = new Script(Buffer::hex($details['scriptPubKey']));
             $tx = TransactionFactory::fromHex($details['tx']);
             $results->send(json_encode(['txid' => $txid, 'vin' => $vin, 'result' => $consensus->getConsensus(new Flags($flags))->verify($tx, $scriptPubKey, $vin)]));
         });
         $loop->run();
         exit(0);
     });
 }
Beispiel #9
0
 /**
  * start crontab and loop
  */
 public function start()
 {
     $this->logger->info("crontab start");
     $crontab = $this->createCrontab();
     $loop = Factory::create();
     // add periodic timer
     $loop->addPeriodicTimer(1, 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;
         }
     });
     // recover the sub processes
     $loop->addPeriodicTimer(60, function () {
         while (($pid = pcntl_waitpid(0, $status, WNOHANG)) > 0) {
             $message = "process exit. pid:" . $pid . ". exit code:" . $status;
             $this->logger->info($message);
         }
     });
     $loop->run();
 }
Beispiel #10
0
 /**
  * @test
  */
 public function eventloop_schedule_recursive()
 {
     $loop = Factory::create();
     $scheduler = new EventLoopScheduler($loop);
     $actionCalled = false;
     $count = 0;
     $action = function ($reschedule) use(&$actionCalled, &$count) {
         $actionCalled = true;
         $count++;
         if ($count < 5) {
             $reschedule();
         }
     };
     $disposable = $scheduler->scheduleRecursive($action);
     $this->assertInstanceOf('Rx\\DisposableInterface', $disposable);
     $this->assertFalse($actionCalled);
     $this->assertEquals(0, $count);
     $loop->tick();
     $this->assertEquals(1, $count);
     $loop->tick();
     $this->assertEquals(2, $count);
     $loop->tick();
     $this->assertEquals(3, $count);
     $loop->tick();
     $this->assertEquals(4, $count);
     $loop->tick();
     $this->assertEquals(5, $count);
     $loop->tick();
     $this->assertTrue($actionCalled);
     $this->assertEquals(5, $count);
 }
 public function runTestProcess($arguments, $expectedExitCode = 0, $timeout = 5)
 {
     $command = __DIR__ . '/../../../../bin/phpunit-parallel ' . $arguments;
     $loop = Factory::create();
     $p = new Process($command);
     $p->start($loop);
     $stdout = '';
     $stderr = '';
     $timer = $loop->addTimer($timeout, function () use($arguments, $p, $stdout, $stderr) {
         $p->terminate(SIGKILL);
         $this->fail("running phpunit-parallel with '{$arguments}' did not complete in time\nstdout: {$stdout}\nstderr: {$stderr}\n");
     });
     $p->stdout->on('data', function ($data) use(&$stdout) {
         $stdout .= $data;
     });
     $p->stderr->on('data', function ($data) use(&$stderr) {
         $stderr .= $data;
     });
     $p->on('exit', function () use($timer) {
         $timer->cancel();
     });
     $loop->run();
     if ($p->getExitCode() !== $expectedExitCode) {
         $this->fail("Process exited with code {$p->getExitCode()}, expected {$expectedExitCode}\nstdout: {$stdout}\nstderr: {$stderr}\n");
     }
     return [$stdout, $stderr];
 }
Beispiel #12
0
 public function __construct($config)
 {
     $loop = eventLoop::create();
     $this->loop = $loop;
     $this->serv = new server($loop);
     $this->config = $config;
 }
 public function testConnectWithValidPass()
 {
     $this->expectOutputString('endclose');
     $loop = \React\EventLoop\Factory::create();
     $conn = new Connection($loop, $this->connectOptions);
     $conn->on('end', function ($conn) {
         $this->assertInstanceOf('React\\MySQL\\Connection', $conn);
         echo 'end';
     });
     $conn->on('close', function ($conn) {
         $this->assertInstanceOf('React\\MySQL\\Connection', $conn);
         echo 'close';
     });
     $conn->connect(function ($err, $conn) use($loop) {
         $this->assertEquals(null, $err);
         $this->assertInstanceOf('React\\MySQL\\Connection', $conn);
     });
     $conn->ping(function ($err, $conn) use($loop) {
         $this->assertEquals(null, $err);
         $conn->close(function ($conn) {
             $this->assertEquals($conn::STATE_CLOSED, $conn->getState());
         });
         //$loop->stop();
     });
     $loop->run();
 }
 function testWampErrorException()
 {
     $loop = \React\EventLoop\Factory::create();
     $router = new \Thruway\Peer\Router($loop);
     //$router->addTransportProvider(new \Thruway\Transport\RawSocketTransportProvider());
     $client = new \Thruway\Peer\Client("realm1", $loop);
     $client->setAttemptRetry(false);
     $client->on('open', function (\Thruway\ClientSession $session) use($router) {
         $session->register('procedure_with_exception', function ($args) {
             throw new \Thruway\Exception\WampErrorException("error.from.exception", $args, (object) ["theKw" => "great"], (object) ["more_details" => "some_more_details"]);
         })->then(function () use($session, $router) {
             $session->call('procedure_with_exception', ['one', 'two'])->then(function ($args) use($router) {
                 $this->fail('Call with wamp exception should not have succeeded.');
                 $router->stop();
             }, function ($err) use($router) {
                 /** @var \Thruway\Message\ErrorMessage $err */
                 $this->assertInstanceOf('Thruway\\Message\\ErrorMessage', $err);
                 $this->assertTrue(is_array($err->getArguments()));
                 $this->assertEquals(2, count($err->getArguments()));
                 $this->assertEquals("one", $err->getArguments()[0]);
                 $this->assertEquals("two", $err->getArguments()[1]);
                 $this->assertInstanceOf('stdClass', $err->getArgumentsKw());
                 $this->assertObjectHasAttribute('theKw', $err->getArgumentsKw());
                 $this->assertEquals('great', $err->getArgumentsKw()->theKw);
                 $this->assertObjectHasAttribute('more_details', $err->getDetails());
                 $this->assertEquals('some_more_details', $err->getDetails()->more_details);
                 $this->assertEquals('error.from.exception', $err->getErrorURI());
                 $router->stop();
             });
         });
     });
     //$client->addTransportProvider(new \Thruway\Transport\RawSocketClientTransportProvider());
     $router->addInternalClient($client);
     $router->start();
 }
 /**
  * @return LoopInterface
  */
 public function getLoop()
 {
     if (is_null(static::$loop)) {
         static::setLoop(Factory::create());
     }
     return static::$loop;
 }
 /**
  * Sets up loop and server manually to allow periodic timer calls.
  */
 private function setupServer()
 {
     $this->setupApp();
     /** @var $loop \React\EventLoop\LoopInterface */
     $this->loop = \React\EventLoop\Factory::create();
     // Enable ZMQ Listener.
     // Requires , "react/zmq" package.
     $zmq = $this->getContainer()->getParameter('jdare_clank.zmq_configuration');
     if ($zmq['enabled']) {
         if (!class_exists('\\ZMQContext')) {
             throw new \Exception("Could not find ZMQContext, did you install the zmq bindings for PHP?");
         }
         // Listen for the web server to make a ZeroMQ push after an ajax request
         $context = new \React\ZMQ\Context($this->loop);
         $pull = $context->getSocket(\ZMQ::SOCKET_PULL);
         $bind = "tcp://127.0.0.1:{$zmq['port']}";
         echo "\nListening to ZMQ messages on {$bind}\n";
         $pull->bind($bind);
         // Binding to 127.0.0.1 means the only client that can connect is itself
         $pull->on('message', array($this->getContainer()->get("jdare_clank.clank_app"), 'onZMQMessage'));
     }
     $this->socket = new \React\Socket\Server($this->loop);
     if ($this->host) {
         $this->socket->listen($this->port, $this->host);
     } else {
         $this->socket->listen($this->port);
     }
     $this->setupPeriodicServices();
     $this->server = new \Ratchet\Server\IoServer($this->app, $this->socket, $this->loop);
 }
Beispiel #17
0
 /**
  * @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();
 }
Beispiel #18
0
 /**
  * @param  InputInterface  $input
  * @param  OutputInterface $output
  * @return int|null|void   Script exit code
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $brainName = $input->getArgument('brain');
     $host = $input->getArgument('server');
     $brain = $this->brainFactory->build($brainName);
     $responseInterpreter = new \Connect4\Client\ResponseInterpreter();
     $client = new \Connect4\Client\Client($brain);
     $loop = \React\EventLoop\Factory::create();
     $dnsResolverFactory = new \React\Dns\Resolver\Factory();
     $dns = $dnsResolverFactory->createCached('8.8.8.8', $loop);
     $connector = new \React\SocketClient\Connector($loop, $dns);
     $connector->create($host, 1337)->then(function (\React\Stream\Stream $stream) use($brain, $responseInterpreter, $client) {
         $stream->write($brain->getName());
         $stream->on('data', function ($data) use($stream, $client, $responseInterpreter) {
             if (!$data) {
                 die('CONNECTION TERMINATED');
             }
             $response = $responseInterpreter->buildResponse($data);
             $move = $client->handle($response);
             if ($move) {
                 $stream->write($move->getColumn()->getValue());
             }
         });
     });
     $loop->run();
 }
Beispiel #19
0
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $loop = \React\EventLoop\Factory::create();
     $pusher = $this->getContainer()->get('websocket');
     $worldService = $this->getContainer()->get('worldevent');
     $dataChannel = $this->getContainer()->get('datachannel');
     // Циклическое событие
     $loop->addPeriodicTimer(120, function () use($pusher, $worldService, $dataChannel) {
         // Юзеры онлайн
         $onlineChars = $dataChannel->clients;
         // Вызов сообщения о погоде
         $worldEventWeather = $worldService->weather($onlineChars);
         if ($worldEventWeather) {
             $charsOutside = $worldEventWeather["chars"];
             $weather = $worldEventWeather["weather"];
             $worldEvent = array("worldweather" => $weather);
             // Отправка всем сводки о погоде
             $pusher->sendToList($charsOutside, $worldEvent);
         }
     });
     // Запуск вебсокет сервера
     $webSock = new \React\Socket\Server($loop);
     $webSock->listen(6661, '0.0.0.0');
     // Привязка к 0.0.0.0 позволяет коннектиться удаленно
     new \Ratchet\Server\IoServer(new \Ratchet\Http\HttpServer(new \Ratchet\WebSocket\WsServer(new \Ratchet\Wamp\WampServer($pusher))), $webSock);
     $loop->run();
 }
Beispiel #20
0
 /**
  * Init the API components
  */
 public function init()
 {
     $this->loop = Factory::create();
     // Catch signals
     $this->loop->addPeriodicTimer(1, function () {
         pcntl_signal_dispatch();
     });
     // Heartbeat, 2 minutes officially, here 5
     $this->loop->addPeriodicTimer(300, [$this, 'doHeartbeats']);
     // Clients logging
     if (true === ConfigurationLoader::get('client.async.enabled')) {
         $this->loop->addPeriodicTimer(0.5, function () {
             LoggerFactory::subscribe();
         });
     }
     // Init router
     $this->router = new Router();
     $this->router->init();
     // Init redis
     $this->redis = new Client(sprintf('tcp://%s:%d', ConfigurationLoader::get('client.async.redis.host'), ConfigurationLoader::get('client.async.redis.port')));
     // Async processes
     if (true === ConfigurationLoader::get('client.async.enabled')) {
         $this->clean(true);
         $this->catchSignals();
     } else {
         $this->logger->warning('You use the slow mode (synchronous), you can use the fast mode (asynchronous) by setting the configuration "client.async.enabled" to "true"');
     }
 }
 public function assertConnection(array $options, $message = null)
 {
     $settings = array_merge(["ip" => "0.0.0.0", "port" => 0, "startServer" => false, "match" => true], $options);
     // optionally starting server
     if ($settings["startServer"]) {
         $serverLoop = EventLoopFactory::create();
         $server = new SocketServer($serverLoop);
         $server->listen($settings["port"]);
     }
     // client setup
     $clientLoop = EventLoopFactory::create();
     $dnsResolverFactory = new DnsResolverFactory();
     $dns = $dnsResolverFactory->createCached("8.8.8.8", $clientLoop);
     // dunno why dns is required for this shit
     $connector = new SocketConnector($clientLoop, $dns);
     $promise = $connector->create($settings["ip"], $settings["port"])->then(function (SocketStream $stream) {
         $stream->close();
         return true;
     }, function (SocketConnectionException $e) {
         return false;
     });
     $clientLoop->run();
     // catching the output
     $out = null;
     $promise->done(function ($v) use(&$out) {
         $out = $v;
     });
     // optionally cleaning up the server
     if ($settings["startServer"]) {
         $server->shutdown();
     }
     $this->assertEquals($out, $settings["match"], $message);
 }
Beispiel #22
0
 public function execute(InputInterface $input, OutputInterface $output)
 {
     /**
      * @var \Symfony\Component\Console\Helper\FormatterHelper
      */
     $formatter = $this->getHelper('formatter');
     $output->writeln($formatter->formatSection('IO', 'Start development server'));
     $bridgeName = $input->getOption('bridge');
     switch (strtolower($bridgeName)) {
         case 'phalcony':
             $bridge = new Phalcony();
             break;
         case 'hello':
         default:
             $bridge = new SimpleBridge();
             break;
     }
     $bridge->on('error', function (Exception $e) use(&$formatter, $output) {
         $output->writeln($formatter->formatBlock(array('[App]', $e->getMessage(), 'in the ' . $e->getFile() . ' file on ' . $e->getLine() . ' line'), 'error'));
     });
     $listen = $input->getOption('listen');
     $port = $input->getOption('port');
     $count = $input->getOption('count');
     for ($i = 0; $i < $count; $i++) {
         $this->newWorker($output, $formatter, $listen, $port + $i, clone $bridge);
     }
     $loop = Factory::create();
     $loop->addPeriodicTimer(1, function () use(&$output) {
         $output->writeln('Tick tak, bitch <3');
     });
     $loop->run();
 }
Beispiel #23
0
 /**
  * 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;
 }
Beispiel #24
0
 public function __construct(LoggerInterface $logger)
 {
     $this->loop = EventLoop::create();
     $this->socket = new ReactSocket($this->loop);
     $this->http = new ReactServer($this->socket);
     $this->logger = $logger;
 }
Beispiel #25
0
 /**
  * @param  \Ratchet\MessageComponentInterface $component The application that I/O will call when events are received
  * @param  int                                $port      The port to server sockets on
  * @param  string                             $address   The address to receive sockets on (0.0.0.0 means receive connections from any)
  * @return IoServer
  */
 public static function factory(MessageComponentInterface $component, $port = 80, $address = '0.0.0.0')
 {
     $loop = LoopFactory::create();
     $socket = new Reactor($loop);
     $socket->listen($port, $address);
     return new static($component, $socket, $loop);
 }
 public function createService(ServiceLocatorInterface $controllerManager)
 {
     $serviceLocator = $controllerManager->getServiceLocator();
     $loop = EventLoopFactory::create();
     $config = $serviceLocator->get('Config');
     return new RunRealtimeServer($loop, new SocketServer($loop), $config['t4web-queue']['queues']);
 }
Beispiel #27
0
 /**
  * {@inheritdoc}
  */
 protected function doSendInternalRequest(InternalRequestInterface $internalRequest)
 {
     $loop = EventLoopFactory::create();
     $dnsResolverFactory = new DnsResolverFactory();
     $httpClientFactory = new HttpClientFactory();
     $error = null;
     $response = null;
     $body = null;
     $request = $httpClientFactory->create($loop, $dnsResolverFactory->createCached('8.8.8.8', $loop))->request($internalRequest->getMethod(), $url = (string) $internalRequest->getUrl(), $this->prepareHeaders($internalRequest, true, true, true));
     $request->on('error', function (\Exception $onError) use(&$error) {
         $error = $onError;
     });
     $request->on('response', function (Response $onResponse) use(&$response, &$body) {
         $onResponse->on('data', function ($data) use(&$body) {
             $body .= $data;
         });
         $response = $onResponse;
     });
     $request->end($this->prepareBody($internalRequest));
     $loop->run();
     if ($error !== null) {
         throw HttpAdapterException::cannotFetchUrl($url, $this->getName(), $error->getMessage());
     }
     return $this->getConfiguration()->getMessageFactory()->createResponse((int) $response->getCode(), $response->getReasonPhrase(), $response->getVersion(), $response->getHeaders(), BodyNormalizer::normalize($body, $internalRequest->getMethod()));
 }
 public function start($count = 1)
 {
     $loop = Factory::create();
     $server = stream_socket_server($this->config->getConnectionString());
     if ($server === false) {
         throw new \RuntimeException("create socket server failed");
     }
     $blocking = stream_set_blocking($server, 0);
     if ($blocking === false) {
         throw new \RuntimeException("stream_set_blocking failed");
     }
     $loop->addReadStream($server, function ($server) use($loop) {
         $dispatcher = $this->config->getDispatcher();
         if ($dispatcher !== null && !$dispatcher->acquire($server, $loop)) {
             return;
         }
         $conn = stream_socket_accept($server);
         $dispatcher->release($server, $loop);
         $loop->addReadStream($conn, function ($conn) use($loop) {
             call_user_func(array($this->handler, 'handle'), $conn, $loop);
         });
     });
     $master = new Master($loop, $count);
     $master->start();
 }
Beispiel #29
0
 public function __construct($config = [])
 {
     self::configure($config);
     $config = \SciActive\RequirePHP::_('NymphPubSubConfig');
     $this->loop = \React\EventLoop\Factory::create();
     // Create a logger which writes everything to the STDOUT
     $this->logger = new \Zend\Log\Logger();
     $this->writer = new \Zend\Log\Writer\Stream("php://output");
     $this->logger->addWriter($this->writer);
     // Create a WebSocket server using SSL
     try {
         $this->logger->notice("Nymph-PubSub server starting on {$config['host']}:{$config['port']}.");
     } catch (\Exception $e) {
         if (strpos($e->getMessage(), 'date.timezone')) {
             echo "It looks like you haven't set a default timezone. In order to avoid constant complaints from Zend's logger, I'm just going to kill myself now.\n\n";
             echo $e->getMessage() . "\n";
             exit;
         }
         throw $e;
     }
     $this->server = new WebSocketServer("tcp://{$config['host']}:{$config['port']}", $this->loop, $this->logger);
     // Create a router which transfers all /chat connections to the MessageHandler class
     $this->router = new \Devristo\Phpws\Server\UriHandler\ClientRouter($this->server, $this->logger);
     // route / url
     $this->router->addRoute('#^/#i', new MessageHandler($this->logger));
     // route unmatched urls
     $this->router->addRoute('#^(.*)$#i', new MessageHandlerForUnroutedUrls($this->logger));
     // Bind the server
     $this->server->bind();
 }
 /**
  * Returns the event loop dependency, initializing it if needed.
  *
  * @return \React\EventLoop\LoopInterface
  */
 public function getLoop()
 {
     if (!$this->loop) {
         $this->loop = \React\EventLoop\Factory::create();
     }
     return $this->loop;
 }