public function run()
{
if (!isset($this->params['token'])) {
throw new \Exception('A token must be set. Please see https://my.slack.com/services/new/bot');
}
$this->loadInternalCommands();
$this->init();
$logger = new \Zend\Log\Logger();
$writer = new \Zend\Log\Writer\Stream("php://output");
$logger->addWriter($writer);
$loop = \React\EventLoop\Factory::create();
$client = new \Devristo\Phpws\Client\WebSocket($this->wsUrl, $loop, $logger);
$client->on("request", function ($headers) use($logger) {
$logger->notice("Request object created!");
});
$client->on("handshake", function () use($logger) {
$logger->notice("Handshake received!");
});
$client->on("connect", function () use($logger, $client) {
$logger->notice("Connected!");
});
$client->on("message", function ($message) use($client, $logger) {
$data = $message->getData();
$logger->notice("Got message: " . $data);
$data = json_decode($data, true);
$command = $this->getCommand($data);
if ($command instanceof Command\BaseCommand) {
$command->setClient($client);
$command->setChannel($data['channel']);
$command->setUser($data['user']);
$command->setContext($this->context);
$command->executeCommand($data, $this->context);
}
});
$client->open();
/* Webserver */
if ($this->webserverPort !== false) {
$logger->notice("Listening on port " . $this->webserverPort);
$socket = new \React\Socket\Server($loop);
$http = new \React\Http\Server($socket);
$http->on('request', function ($request, $response) use($client) {
$post = $request->getPost();
if ($post['name'] == 'output') {
$hook = new \PhpSlackBot\Webhook\OutputWebhook();
$hook->setClient($client);
$hook->setContext($this->context);
$hook->executeWebhook(json_decode($post['payload'], true));
}
$response->writeHead(200, array('Content-Type' => 'text/plain'));
$response->end("Ok\n");
});
$socket->listen(8080);
}
$loop->run();
}
/**
* Running HTTP Server
*/
public function run()
{
$loop = new \React\EventLoop\StreamSelectLoop();
$socket = new \React\Socket\Server($loop);
$http = new \React\Http\Server($socket, $loop);
$http->on('request', function ($request, $response) {
with(new HttpSession($this->host, $this->port, $this->verbose))->handle($request, $response);
});
$socket->listen($this->port, $this->host);
$loop->run();
}
/**
* @param int $port
* @throws \React\Socket\ConnectionException
*/
public function start($port = 6364)
{
$socket = new \React\Socket\Server($this->loop);
$http = new \React\Http\Server($socket);
$http->on('request', function (Request $request, Response $response) {
$path = trim($request->getPath(), '/');
if (!array_key_exists($path, $this->routes)) {
$this->response($response, 0, "method not found", 101);
return null;
}
$query_info = $request->getQuery();
$method = array($this, $this->routes[$path]);
return call_user_func($method, $query_info, $response);
});
$socket->listen($port);
}
public function __construct()
{
$this->loop = Factory::create();
$this->socket = new \React\Socket\Server($this->loop);
$this->config = $this->readConfig();
$this->resolver = new DIContainer();
$this->resolver->config = $this->config;
$this->resolver->storage = new Storage($this->loop, $this->config->influx);
$this->resolver->telegram = new Api($this->config->telegram->apiToken, true, new GuzzleHttpClient(new Client(['handler' => HandlerStack::create(new HttpClientAdapter($this->loop))])));
$this->resolver->telegram->addCommand(new StartCommand($this->resolver->storage));
$this->resolver->telegram->addCommand(new AirCommand($this->resolver->storage));
$this->dispatcher = new Dispatcher($this->routes()->getData(), $this->resolver);
$http = new \React\Http\Server($this->socket);
$http->on('request', function (Request $request, Response $response) {
$this->onRequest($request, $response);
});
}
/**
* Run the Teleport HTTP Server on the specified port.
*
* @param int $port A valid port to run the Teleport HTTP Server on.
*
* @throws \RuntimeException If an invalid port is specified.
*/
public function run($port)
{
$port = (int) $port;
if ($port < 1) {
throw new \RuntimeException("Invalid port specified for Teleport HTTP Server", E_USER_ERROR);
}
/** @var \React\EventLoop\LibEventLoop $loop */
$loop = \React\EventLoop\Factory::create();
$socket = new \React\Socket\Server($loop);
$http = new \React\Http\Server($socket);
$server =& $this;
$http->on('request', function ($request, $response) use($server) {
/** @var \React\Http\Request $request */
/** @var \React\Http\Response $response */
$arguments = $request->getQuery();
$arguments['action'] = trim($request->getPath(), '/');
$headers = array('Content-Type' => 'text/javascript');
if (isset($arguments['action']) && !empty($arguments['action']) && strpos($arguments['action'], '.') === false) {
try {
/** @var \Teleport\Request\Request $request */
$request = $server->getRequest('Teleport\\Request\\APIRequest');
$request->handle($arguments);
$results = $request->getResults();
$response->writeHead(200, $headers);
$response->end(json_encode(array('success' => true, 'message' => $results)));
} catch (InvalidRequestException $e) {
$response->writeHead(400, $headers);
$response->end(json_encode(array('success' => false, 'message' => $e->getMessage())));
} catch (\Exception $e) {
$response->writeHead(500, $headers);
$response->end(json_encode(array('success' => false, 'message' => $e->getMessage())));
}
} else {
$response->writeHead(400, $headers);
$response->end(json_encode(array('success' => false, 'message' => 'no valid action was specified')));
}
});
if ($this->getConfig()->get('verbose', null, false) || $this->getConfig()->get('debug', null, false)) {
echo "teleport server initializing" . PHP_EOL;
}
$socket->listen($port);
if ($this->getConfig()->get('verbose', null, false) || $this->getConfig()->get('debug', null, false)) {
echo "teleport server listening on port {$port}" . PHP_EOL;
}
$loop->run();
}
/**
* {@inheritDoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$loop = Factory::create();
$socket = new Server($loop);
$container = $this->getContainer();
$wandelSettings = $container['settings']['servers']['wandel'];
$http = new \React\Http\Server($socket);
$lastRequested = 0;
$spamWarningSent = false;
$app = function (Request $request, Response $response) use($wandelSettings, &$lastRequested, &$spamWarningSent) {
$request->on('data', function ($data) use($request, $response, $wandelSettings, &$lastRequested, &$spamWarningSent) {
parse_str($data, $postParams);
// If there is nothing, do nothing.
if ($data == '' || $postParams['token'] != $wandelSettings['slack_token']) {
$response->writeHead(404);
$response->end();
return;
}
// Spam filter and send spam warning text.
if (time() - $lastRequested < WandelMenuCommand::SPAM_FILTER) {
if (!$spamWarningSent) {
$payload = json_encode(['text' => 'Hey, do not spam the WandelBot!']);
$response->writeHead(200);
$response->end($payload);
$spamWarningSent = true;
return;
}
return;
}
// Check valid url format.
$wandelMenuUrl = null;
foreach ($wandelSettings['menu_1'] as $menuFormat) {
$wandelMenuUrl = sprintf($menuFormat, date('W'));
if (file_get_contents($wandelMenuUrl)) {
break;
}
}
// No menu? well then there is nothing here.
if ($wandelMenuUrl == null) {
$response->writeHead(404);
$response->end();
return;
}
$responseText = $wandelMenuUrl . ' - Brought you by horriblesolutions.com';
$payload = json_encode(['text' => $responseText]);
$spamWarningSent = false;
$lastRequested = time();
$response->writeHead(200);
$response->end($payload);
});
};
$http->on('request', $app);
$host = $wandelSettings['host'];
$port = $wandelSettings['port'];
$socket->listen($port, $host);
$output->writeln(sprintf('Server started on %s:%s', $host, $port));
$loop->run();
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$i = 0;
$app = function ($request, $response) use(&$i, $output) {
$i++;
$text = "This is request number {$i}.\n";
$headers = array('Content-Type' => 'text/plain');
$output->writeln($text);
$response->writeHead(200, $headers);
$response->end($text);
};
$loop = \React\EventLoop\Factory::create();
$socket = new \React\Socket\Server($loop);
$http = new \React\Http\Server($socket);
$http->on('request', $app);
$socket->listen(1337);
$loop->run();
}
function main()
{
$loop = React\EventLoop\Factory::create();
$socket = new React\Socket\Server($loop);
$http = new React\Http\Server($socket, $loop);
$st = new Storage('im.db');
$http->on('request', function ($request, $response) use($st) {
$r = new Request($request, $response);
# var_dump($r->request->getHeaders());
if (!array_key_exists("Content-Length", $r->request->getHeaders())) {
$r->abort(400, "need json content");
return;
}
$r->contentLength = intval($r->request->getHeaders()["Content-Length"]);
$request->on('data', function ($data) use($r, $st) {
$r->addInput($data);
if (!$r->readyToProcess()) {
return;
}
if (!($js = $r->parseInput())) {
$r->abort(400, "Invalid json");
return;
}
global $methods;
// imported it from Methods.php.
// Failed to find how to import it explicitly
// (like python's "import Variable from Module")
if (!isset($js->method) || !array_key_exists($js->method, $methods)) {
$r->abort(400, "Invalid method");
return;
}
try {
$methods[$js->method]($r, $js, $st);
} catch (Exception $e) {
$r->abort(500, "inernal server error");
}
});
});
echo "Server running at http://127.0.0.1:1337\n";
$socket->listen(1337);
$loop->run();
}
public function connectToMaster()
{
$this->loop = \React\EventLoop\Factory::create();
$this->client = stream_socket_client('tcp://127.0.0.1:5500');
$this->connection = new \React\Socket\Connection($this->client, $this->loop);
$this->connection->on('close', \Closure::bind(function () {
$this->shutdown();
}, $this));
$socket = new \React\Socket\Server($this->loop);
$http = new \React\Http\Server($socket);
$http->on('request', array($this, 'onRequest'));
$port = 5501;
while ($port < 5600) {
try {
$socket->listen($port);
break;
} catch (\React\Socket\ConnectionException $e) {
$port++;
}
}
$this->connection->write(json_encode(array('cmd' => 'register', 'pid' => getmypid(), 'port' => $port)));
}
/**
* @param $port
*
* @throws \React\Socket\ConnectionException
*/
public function listen($port = false)
{
if ($port) {
$this->port = $port;
}
/**
* @param \React\Http\Request $request
* @param \React\Http\Response $response
*/
$requestHandler = function ($request, $response) {
// If debugging is on, track the request start time
$requestStartTime = $this->debugging ? microtime(true) : null;
$symfonyFormattedRequest = $this->convertRequest($request);
// Run the Lumen app and get a response
/** @var \Illuminate\Http\Response $lumenResponse */
$lumenResponse = $this->lumenApplication->dispatch($symfonyFormattedRequest);
$lumenResponse->prepare($symfonyFormattedRequest);
// Build a React response from the symfony response
$response->writeHead($lumenResponse->getStatusCode(), $lumenResponse->headers->all());
$response->end($lumenResponse->content());
if ($this->debugging) {
echo $this->getLogEntry($request, $lumenResponse, $requestStartTime);
}
$response->on('close', function () use($lumenResponse) {
$this->lumenApplication->runTerminableMiddleware($lumenResponse);
});
};
$loop = \React\EventLoop\Factory::create();
$socket = new \React\Socket\Server($loop);
$http = new \React\Http\Server($socket, $loop);
$http->on('request', $requestHandler);
if ($this->debugging) {
echo "Server running on port " . $this->port . PHP_EOL . PHP_EOL;
}
$socket->listen($this->port);
$loop->run();
}
/**
* @Setup
* @internal
*/
public function setup()
{
$this->loop = new ReactLoopAdapter($this->socketManager);
$this->socket = new SocketServer($this->loop);
$this->httpServer = new \React\Http\Server($this->socket);
$this->wamp = new WampHandler();
$this->wsServer = new WsServer(new WampServer($this->wamp));
$that = $this;
$this->httpServer->on('request', function ($request, $response) use($that) {
$request = new Request($request);
$response = new Response($response);
$session = new Session($that->sessionStorage, $request, $response);
$httpRequest = new StdClass();
$httpRequest->request = $request;
$httpRequest->response = $response;
$httpRequest->body = '';
$httpRequest->session = $session;
$request->on('data', function ($bodyBuffer) use($that, &$httpRequest) {
$httpRequest->body .= $bodyBuffer;
if (!$that->isRequestBodyFullyReceived($httpRequest)) {
return;
}
$that->handleRequest($httpRequest);
$httpRequest = null;
});
});
// setup handler for root path
$this->registerHandler("|^/\$|", function ($request, $response) {
$response->writeHead(200, array('Content-Type' => 'text/plain'));
$response->end("Hello Budabot!\n");
});
// switch server's port if http_server_port setting is changed
$this->settingManager->registerChangeListener('http_server_port', function ($name, $oldValue, $newValue) use($that) {
if ($that->isListening) {
$that->listen($newValue);
}
});
// make sure we close the socket before exit
register_shutdown_function(function () use($that) {
$that->stopListening();
});
}
<?php
require 'vendor/autoload.php';
$loop = React\EventLoop\Factory::create();
$socket = new React\Socket\Server($loop);
$http = new React\Http\Server($socket);
$context = new React\ZMQ\Context($loop);
$dealer = $context->getSocket(ZMQ::SOCKET_DEALER);
$dealer->bind('tcp://127.0.0.1:4444');
$conns = new ArrayObject();
$dealer->on('message', function ($msg) use($conns) {
list($hash, $blank, $data) = $msg;
if (!isset($conns[$hash])) {
return;
}
$response = $conns[$hash];
$response->writeHead();
$response->end($data);
});
$http->on('request', function ($request, $response) use($dealer, $conns) {
$hash = spl_object_hash($request);
$conns[$hash] = $response;
$request->on('end', function () use($conns, $hash) {
unset($conns[$hash]);
});
$dealer->send(array($hash, '', $request->getPath()));
});
$socket->listen(8080);
$loop->run();
<?php
require __DIR__ . '/vendor/autoload.php';
use Clue\React\Sse\BufferedChannel;
use React\Http\Request;
use React\Http\Response;
use React\SocketClient\TcpConnector;
use React\Stream\Stream;
$loop = React\EventLoop\Factory::create();
$socket = new React\Socket\Server($loop);
$channel = new BufferedChannel();
$http = new React\Http\Server($socket);
$http->on('request', function (Request $request, Response $response) use($channel) {
if ($request->getPath() === '/') {
$response->writeHead('200', array('Content-Type' => 'text/html'));
$response->end(file_get_contents(__DIR__ . '/../01-simple-periodic/eventsource.html'));
return;
}
echo 'connected' . PHP_EOL;
$headers = $request->getHeaders();
$id = isset($headers['Last-Event-ID']) ? $headers['Last-Event-ID'] : null;
$response->writeHead(200, array('Content-Type' => 'text/event-stream'));
$channel->connect($response, $id);
$response->on('close', function () use($response, $channel) {
echo 'disconnected' . PHP_EOL;
$channel->disconnect($response);
});
});
$port = isset($argv[2]) ? $argv[2] : 8000;
$connector = new TcpConnector($loop);
$connector->create('127.0.0.1', $port)->then(function (Stream $stream) use($channel) {
public function run()
{
if (!isset($this->params['token'])) {
throw new \Exception('A token must be set. Please see https://my.slack.com/services/new/bot');
}
$this->init();
$logger = new \Zend\Log\Logger();
$writer = new \Zend\Log\Writer\Stream("php://output");
$logger->addWriter($writer);
$loop = \React\EventLoop\Factory::create();
$client = new \Devristo\Phpws\Client\WebSocket($this->wsUrl, $loop, $logger);
$client->on("request", function ($headers) use($logger) {
$logger->notice("Request object created!");
});
$client->on("handshake", function () use($logger) {
$logger->notice("Handshake received!");
});
$client->on("connect", function () use($logger, $client) {
$logger->notice("Connected!");
});
$client->on("message", function ($message) use($client, $logger) {
$data = $message->getData();
$logger->notice("Got message: " . $data);
$data = json_decode($data, true);
if (count($this->catchAllCommands)) {
foreach ($this->catchAllCommands as $command) {
$command->setClient($client);
$command->setContext($this->context);
$command->executeCommand($data, $this->context);
}
}
$command = $this->getCommand($data);
if ($command instanceof Command\BaseCommand) {
$command->setClient($client);
$command->setChannel($data['channel']);
$command->setUser($data['user']);
$command->setContext($this->context);
$command->executeCommand($data, $this->context);
}
});
$client->open();
/* Webserver */
if (null !== $this->webserverPort) {
$logger->notice("Listening on port " . $this->webserverPort);
$socket = new \React\Socket\Server($loop);
$http = new \React\Http\Server($socket);
$http->on('request', function ($request, $response) use($client) {
$request->on('data', function ($data) use($client, $request, $response) {
parse_str($data, $post);
if ($this->authentificationToken === null || $this->authentificationToken !== null && isset($post['auth']) && $post['auth'] === $this->authentificationToken) {
if (isset($post['name']) && is_string($post['name']) && isset($this->webhooks[$post['name']])) {
$hook = $this->webhooks[$post['name']];
$hook->setClient($client);
$hook->setContext($this->context);
$hook->executeWebhook(json_decode($post['payload'], true), $this->context);
$response->writeHead(200, array('Content-Type' => 'text/plain'));
$response->end("Ok\n");
} else {
$response->writeHead(404, array('Content-Type' => 'text/plain'));
$response->end("No webhook found\n");
}
} else {
$response->writeHead(403, array('Content-Type' => 'text/plain'));
$response->end("");
}
});
});
$socket->listen($this->webserverPort);
}
$loop->run();
}
<?php
// script to test for mem leaks
// You can test it using:
// siege localhost:8080
require __DIR__ . '/../../vendor/autoload.php';
$reactor = (new Alert\ReactorFactory())->select();
$loop = (new Loopio\LoopFactory())->createReactLoop($reactor);
$socket = new React\Socket\Server($loop);
$http = new React\Http\Server($socket, $loop);
$i = 0;
$http->on('request', function ($request, $response) use(&$i) {
$i++;
$response->writeHead();
$response->end("Hello World!\n");
});
$loop->addPeriodicTimer(2, function () use(&$i) {
$kmem = memory_get_usage(true) / 1024;
echo "Request: {$i}\n";
echo "Memory: {$kmem} KiB\n";
});
$socket->listen(8080);
$loop->run();
//
// Main
//
echo "Volkszaehler push server\n";
if (!Volkszaehler\Util\Configuration::read('push.enabled')) {
throw new \Exception("Push server is disabled in configuration", 1);
}
// read config
$localPort = Volkszaehler\Util\Configuration::read('push.server');
$remotePort = Volkszaehler\Util\Configuration::read('push.broadcast');
echo sprintf("Listening for updates on %d. Clients may connect at %d.\n", $localPort, $remotePort);
$loop = React\EventLoop\Factory::create();
$hub = new Volkszaehler\Server\PushHub();
// configure local httpd interface
$localSocket = new React\Socket\Server($loop);
$localServer = new React\Http\Server($localSocket);
$localSocket->listen($localPort, '0.0.0.0');
// remote loggers can push updates
// main push request/ websocket response loop
$localServer->on('request', function (React\Http\Request $request, React\Http\Response $response) use($hub) {
$content = '';
$headers = $request->getHeaders();
$contentLength = isset($headers['Content-Length']) ? (int) $headers['Content-Length'] : 0;
$request->on('data', function ($data) use($request, $response, $hub, &$content, $contentLength) {
// read data (may be empty for GET request)
$content .= $data;
// handle request after receive
if (strlen($content) >= $contentLength) {
$headers = array('Content-Type' => 'application/json');
try {
$data = $hub->handleRequest($content);
<?php
use React\EventLoop\Factory;
use React\Socket\Server;
use React\Http\Request;
use React\Http\Response;
require __DIR__ . '/../vendor/autoload.php';
$loop = Factory::create();
$socket = new Server($loop);
$server = new \React\Http\Server($socket);
$server->on('request', function (Request $request, Response $response) {
$response->writeHead(200, array('Content-Type' => 'text/plain'));
$response->end("Hello world!\n");
});
$socket->listen(isset($argv[1]) ? $argv[1] : 0, '0.0.0.0');
echo 'Listening on ' . $socket->getPort() . PHP_EOL;
$loop->run();
<?php
require '../vendor/autoload.php';
// Hello world HTTP server taken from http://reactphp.org/
$app = function ($request, $response) {
$response->writeHead(200, array('Content-Type' => 'text/plain'));
$response->end("Hello World\n");
};
$loop = React\EventLoop\Factory::create();
$socket = new React\Socket\Server($loop);
$http = new React\Http\Server($socket, $loop);
$http->on('request', $app);
echo "Server running at http://127.0.0.1:1337\n";
$socket->listen(1337);
$loop->run();
public function subscribe(ObserverInterface $observer, $scheduler = null)
{
$socket = new \React\Socket\Server(\EventLoop\getLoop());
$negotiator = new Negotiator(new Validator());
if (!empty($this->subProtocols)) {
$negotiator->setSupportedSubProtocols($this->subProtocols);
}
$http = new \React\Http\Server($socket);
$http->on('request', function (Request $request, Response $response) use($negotiator, $observer, &$outStream) {
$uri = new Uri($request->getPath());
if (count($request->getQuery()) > 0) {
$uri = $uri->withQuery(\GuzzleHttp\Psr7\build_query($request->getQuery()));
}
$psrRequest = new \GuzzleHttp\Psr7\Request($request->getMethod(), $uri, $request->getHeaders());
// cram the remote address into the header in out own X- header so
// the user will have access to it
$psrRequest = $psrRequest->withAddedHeader("X-RxWebsocket-Remote-Address", $request->remoteAddress);
$negotiatorResponse = $negotiator->handshake($psrRequest);
$response->writeHead($negotiatorResponse->getStatusCode(), array_merge($negotiatorResponse->getHeaders(), ["Content-Length" => "0"]));
if ($negotiatorResponse->getStatusCode() !== 101) {
$response->end();
return;
}
$subProtocol = "";
if (count($negotiatorResponse->getHeader('Sec-WebSocket-Protocol')) > 0) {
$subProtocol = $negotiatorResponse->getHeader('Sec-WebSocket-Protocol')[0];
}
$connection = new MessageSubject(new AnonymousObservable(function (ObserverInterface $observer) use($request) {
$request->on('data', function ($data) use($observer) {
$observer->onNext($data);
});
$request->on('error', function ($error) use($observer) {
$observer->onError($error);
});
$request->on('close', function () use($observer) {
$observer->onCompleted();
});
$request->on('end', function () use($observer) {
$observer->onCompleted();
});
return new CallbackDisposable(function () use($request) {
$request->close();
});
}), new CallbackObserver(function ($x) use($response) {
$response->write($x);
}, function ($error) use($response) {
$response->close();
}, function () use($response) {
$response->end();
}), false, $this->useMessageObject, $subProtocol, $psrRequest, $negotiatorResponse);
$observer->onNext($connection);
});
$socket->listen($this->port, $this->bindAddress);
// $http->on('end', function () {});
// $http->on('data', function () {});
// $http->on('pause', function () {});
// $http->on('resume', function () {});
$this->started = true;
return new CallbackDisposable(function () use($socket) {
$socket->shutdown();
});
}
/**
* Checks Adapters and runs the server with the app
*
* @param \Slim\App $app Slim application instance
*
* @return callable
*/
public function run(\Slim\App $app)
{
$serverCallback = $this->getCallbacks($app);
// We make the setup of ReactPHP.
$loop = \React\EventLoop\Factory::create();
$socket = new \React\Socket\Server($loop);
$http = new \React\Http\Server($socket, $loop);
// Link callback to the Request event.
$http->on('request', $serverCallback);
echo "Server running at http://" . $this->host . ":" . $this->port . "\n";
$socket->listen($this->port, $this->host);
$loop->run();
}
function registerSignalHandlers($loop)
{
$pcntl = new MKraemer\ReactPCNTL\PCNTL($loop);
$pcntl->on(SIGTERM, function () {
echo 'Bye' . PHP_EOL;
die;
});
$pcntl->on(SIGINT, function () {
echo 'Terminated by console' . PHP_EOL;
die;
});
}
$loop = React\EventLoop\Factory::create();
registerSignalHandlers($loop);
$socket = new React\Socket\Server($loop);
$http = new React\Http\Server($socket);
$loader = new Twig_Loader_Array(['index' => '
a = {{ a }}
b = {{ b }}
c = {{ c }}
{% if d %}
d = {{ d }}
{% endif %}
']);
$twig = new Twig_Environment($loader);
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dnsResolver = $dnsResolverFactory->createCached('127.0.0.1', $loop);
$factory = new React\HttpClient\Factory();
$client = $factory->create($loop, $dnsResolver);
$http->on('request', function ($request, $response) use($loop, $twig, $client) {
$url = "http://monster.akond.dev/tmp.test.php";
$factory = new React\HttpClient\Factory();
$client = $factory->create($loop, $dnsResolver);
$db = new PDO(HOMER_DNS);
$db->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
$queue = new Homer\Queue($db);
$search = new Homer\Search($db);
$limiter = new Homer\Limiter();
$loop->addPeriodicTimer(HOMER_TIMER, function ($timer) use($client, $queue, $search, $limiter) {
while ($row = $queue->pop()) {
if ($limiter->available($row['url'])) {
$loader = new Homer\Loader($client, $queue, $search);
if ($loader->load($row['url'], $row['deep'])) {
$limiter->limit($row['url']);
echo "Loading {$row['url']}\n";
break;
}
}
}
$limiter->release(HOMER_LIMITER_TIME);
});
if (HOMER_STAT) {
$socket = new React\Socket\Server($loop);
$http = new React\Http\Server($socket, $loop);
$stat = new Homer\Statistic();
$loop->addPeriodicTimer(HOMER_TIMER, function ($timer) use($stat) {
$stat->add('memory', memory_get_usage(true) / (1024 * 1024));
});
$http->on('request', array($stat, 'app'));
$socket->listen(HOMER_HTTP_PORT);
}
$loop->run();
/**
* Run react/http server for incoming GitHub webhook events
*
* @param LoopInterface $loop
* @param int $port
* @param string $ip
*/
private function runServer(LoopInterface $loop, $port = 8080, $ip = '0.0.0.0')
{
// Set up react HTTP server to listen for github webhooks
$socket = new \React\Socket\Server($loop);
$http = new \React\Http\Server($socket, $loop);
$http->on('request', function ($request, $response) {
$headers = $request->getHeaders();
$path = $request->getPath();
$hook = substr($path, 1);
// Basic check if we got event and signature headers
if (empty($headers['X-GitHub-Event'])) {
$response->writeHead(500, ['Content-Type' => 'text/plain']);
$response->end("Missing event header\n");
$this->plugin->getLogger()->error("Received request with missing event header");
return;
}
if (empty($headers['X-Hub-Signature'])) {
$response->writeHead(500, ['Content-Type' => 'text/plain']);
$response->end("Missing signature\n");
$this->plugin->getLogger()->error("Received request with missing signature header");
return;
}
// Check if the hook actually exists
if (empty($hook)) {
$response->writeHead(500, ['Content-Type' => 'text/plain']);
$response->end("Missing hook name\n");
$this->plugin->getLogger()->error("Received request with missing hook name, check out the plugin README");
return;
}
$hooks = $this->plugin->getHooks();
if (!isset($hooks[$hook])) {
$response->writeHead(500, ['Content-Type' => 'text/plain']);
$response->end("Missing hook name\n");
$this->plugin->getLogger()->error("{$hook} does not match any defined hooks in the plugin configuration, check out the plugin README");
return;
}
// Okay the request
$response->writeHead(200, ['Content-Type' => 'text/plain']);
$response->end("OK\n");
// Get incoming JSON payload
$payload = "";
$request->on('data', function ($data) use(&$payload) {
$payload .= $data;
});
// Wait for the end of data burst
$request->on('end', function () use(&$payload, $headers, $hook) {
$raw_payload = $payload;
// Parse json payload to PHP array
$payload = json_decode($payload, TRUE);
if (!$payload) {
$this->plugin->getLogger()->error(sprintf("Unable to parse payload: %s", json_last_error_msg()));
$this->plugin->getLogger()->debug('Payload: ' . var_export($payload, TRUE));
return;
}
// Verify signature
$hooks = $this->plugin->getHooks();
if (!empty($hooks[$hook]['secret'])) {
list($algo, $signature) = explode("=", $headers['X-Hub-Signature']);
if (hash_hmac($algo, $raw_payload, $hooks[$hook]['secret']) != $signature) {
$this->plugin->getLogger()->error("Invalid signature, void request");
return;
}
} else {
$this->plugin->getLogger()->warning("No secret set for {$hook}, seriously consider setting one");
}
$this->plugin->getEventEmitter()->emit("githubhooks.{$hook}.{$headers['X-GitHub-Event']}", [$payload]);
});
});
$socket->listen($port, $ip);
}
<?php
//C:\wamp\bin\php\php5.5.12\php.exe
require 'engine/autoloader.php';
$avtoloader = Autoloader::init();
$paths = array('app/libs', 'app/controllers');
$avtoloader->load($paths);
///
require 'vendor/autoload.php';
$loop = React\EventLoop\Factory::create();
$socket = new React\Socket\Server($loop);
$http = new React\Http\Server($socket);
///
$queue = new queueHandler();
///
$http->on('request', function ($request, $response) {
$answer = 'void';
$query = $request->getQuery();
$path = $request->getPath();
$dispatcher = Dispatcher::getInstance();
$answer = $dispatcher->run($query, $path);
if (isset($query['param'])) {
if ($query['param'] == 'time') {
$answer = microtime(true);
}
if ($query['param'] == 'die') {
echo 'Die';
exit;
}
}
$response->writeHead(200, array('Content-Type' => 'text/plain'));
/**
* 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();
}
/**
* @param InputInterface $input
* @param OutputInterface $output
* @return int|null|void Script exit code
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$loop = \React\EventLoop\Factory::create();
$socket = new \React\Socket\Server($loop);
$server = $this->server;
$socket->on('connection', function ($connection) use($server) {
$name = '';
$connection->on('data', function ($data) use(&$name, $server, $connection) {
if ($name) {
return;
}
$name = trim($data);
$server->addSocketConnection($connection, $name);
});
});
$socket->listen(1337, '0.0.0.0');
//http server
$webroot = $this->webroot;
$detailsSocket = new \React\Socket\Server($loop);
$http = new \React\Http\Server($detailsSocket);
$gameToArray = function (\Connect4\Server\GameArchive\ArchivedGame $game) {
$board = $game->getBoard();
$data = ['id' => $game->getId(), 'board' => [], 'redPlayer' => $game->getRedPlayerName(), 'yellowPlayer' => $game->getYellowPlayerName(), 'date' => $game->getDate()->format('Y-m-d H:i:s'), 'transcript' => [], 'state' => $board->getState()->getValue()];
foreach (range(\Connect4\Lib\Row::MIN, \Connect4\Lib\Row::MAX) as $rowNumber) {
$rowContents = $board->getRowContents(new \Connect4\Lib\Row($rowNumber));
$cells = [];
foreach ($rowContents as $cell) {
$cells[] = (string) $cell;
}
$data['board'][] = $cells;
}
foreach ($board->getTranscript() as $move) {
$data['transcript'][] = [$move->getPlayer()->getValue(), $move->getColumn()->getValue()];
}
return $data;
};
$http->on('request', function ($request, $response) use($server, $webroot, $gameToArray) {
$serve = function ($content, $type, $code = 200) use($response) {
$headers = array('Content-Type' => $type);
$response->writeHead($code, $headers);
$response->end($content);
};
switch ($request->getPath()) {
case '/archive':
$query = $request->getQuery();
$archive = $server->getGameArchive();
if (isset($query['since'])) {
$archivedGames = $archive->getArchiveSince($query['since']);
} else {
$archivedGames = $archive->getArchive();
}
$games = [];
foreach ($archivedGames as $i => $game) {
$games[] = $gameToArray($game, $i + 1);
}
$serve(json_encode($games), 'application/json');
break;
case '/':
$serve(file_get_contents($webroot . '/index.html'), 'text/html');
break;
case '/connect4.js':
$serve(file_get_contents($webroot . '/connect4.js'), 'application/javascript');
break;
case '/connect4.css':
$serve(file_get_contents($webroot . '/connect4.css'), 'text/css');
break;
default:
$serve('Not Found', 'text/html', 404);
break;
}
});
$detailsSocket->listen(8080, '0.0.0.0');
$loop->run();
}
<?php
require 'vendor/autoload.php';
$loop = React\EventLoop\Factory::create();
$socket = new React\Socket\Server($loop);
$http = new React\Http\Server($socket, $loop);
$http->on('request', function ($request, $response) {
$response->writeHead(200, array('Content-Type' => 'text/plain'));
$response->end("Hello World aevc ReactPHP\n");
});
$socket->listen(1337);
$loop->run();
require __DIR__ . '/vendor/docopt/docopt/src/docopt.php';
$doc = <<<DOC
ReactJS HTTP Server
Usage:
server.php [INPUT ...] [-p=]
Options:
-h --help Show this screen.
-p= Port
DOC;
// Parse the docopt doc block
$args = Docopt\docopt($doc);
$loop = React\EventLoop\Factory::create();
$socket = new React\Socket\Server($loop);
$http = new React\Http\Server($socket);
// Set up react using v8
$react = ReactJS\ReactFactory::createUsingV8($args['INPUT']);
function validateRequest($data)
{
$errors = [];
if (empty($data['renderType'])) {
$errors[] = 'renderType empty';
} elseif (!in_array($data['renderType'], ['mountable', 'static'])) {
$errors[] = 'Invalid renderType';
}
if (empty($data['componentPath'])) {
$errors[] = 'componentPath empty';
}
if (empty($data['props'])) {
$errors[] = 'props empty';
}
ob_start();
imagegif($im);
imagedestroy($im);
return ob_get_clean();
}
function sendEmptyFrameAfter($gifServer)
{
return function ($request, $response) use($gifServer) {
$gifServer($request, $response);
$gifServer->addFrame(createGifFrame(['']));
};
}
$loop = React\EventLoop\Factory::create();
$socket = new React\Socket\Server($loop);
$http = new React\Http\Server($socket);
$gifServer = new React\Gifsocket\Server($loop);
$messages = [];
$addMessage = function ($message) use($gifServer, &$messages) {
$messages[] = $message;
if (count($messages) > 18) {
$messages = array_slice($messages, count($messages) - 18);
}
$frame = createGifFrame($messages);
$gifServer->addFrame($frame);
};
$stdin = new React\Stream\Stream(STDIN, $loop);
$stdin->on('data', function ($data) use($addMessage) {
$messages = explode("\n", trim($data));
foreach ($messages as $message) {
$addMessage($message);
public function run()
{
$socket = new \React\Socket\Server(self::$loop);
$http = new \React\Http\Server($socket);
$http->on('request', function ($request, $response) {
if (strtolower($request->getMethod()) == 'post') {
$request->on('data', function ($data) use($request, $response) {
$content = $this->handle($request, $response, $data);
$response->end($content);
});
} else {
$content = $this->handle($request, $response);
$response->end($content);
}
});
$socket->listen(self::PORT);
self::$loop->run();
}
