public function testPeer()
{
$localhost = '127.0.0.1';
$localport = '8333';
$remotehost = '127.0.0.1';
$remoteport = '9999';
$loop = new StreamSelectLoop();
$dnsResolverFactory = new \React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached('8.8.8.8', $loop);
$reactServer = new Server($loop);
$network = Bitcoin::getDefaultNetwork();
$client = new NetworkAddress(Buffer::hex('0000000000000001'), $localhost, $localport);
$server = new NetworkAddress(Buffer::hex('0000000000000001'), $remotehost, $remoteport);
$msgs = new Factory($network, new Random());
$serverReceivedConnection = false;
$serverListener = new Listener($server, $msgs, $reactServer, $loop);
$serverListener->on('connection', function (Peer $peer) use(&$serverReceivedConnection, &$serverListener) {
$peer->close();
$serverReceivedConnection = true;
});
$serverListener->listen($server->getPort());
$connector = new Connector($loop, $dns);
$clientConnection = new Peer($client, $msgs, $loop);
$clientConnection->connect($connector, $server)->then(function (Peer $peer) use($serverListener, &$loop) {
$peer->close();
$serverListener->close();
});
$loop->run();
$this->assertTrue($serverReceivedConnection);
}
/**
* @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();
}
public function setUp()
{
$this->loop = React\EventLoop\Factory::create();
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached('8.8.8.8', $this->loop);
$this->factory = new Factory($this->loop, $dns);
}
/**
* Handler called when a CONNECT message is sent by a client
*
* A React SocketClient will be created, Google DNS is used to resolve host names. When the connection is made
* several event listeners are attached. When data is received on the stream, it is forwarded to the client requesting
* the proxied TCP connection
*
* Other events forwarded are connect and close
*
* @param WebSocketTransportInterface $user
* @param $message
*/
protected function requestConnect(WebSocketTransportInterface $user, $message)
{
$address = $message->address;
$this->logger->notice(sprintf("User %s requests connection to %s", $user->getId(), $address));
try {
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached('8.8.8.8', $this->loop);
$stream = new \React\SocketClient\Connector($this->loop, $dns);
list($host, $port) = explode(":", $address);
$logger = $this->logger;
$that = $this;
$stream->create($host, $port)->then(function (\React\Stream\Stream $stream) use($user, $logger, $message, $address, $that) {
$id = uniqid("stream-{$address}-");
$that->addStream($user, $id, $stream);
// Notify the user when the connection has been made
$user->sendString(json_encode(array('connection' => $id, 'event' => 'connected', 'tag' => property_exists($message, 'tag') ? $message->tag : null)));
// Forward data back to the user
$stream->on("data", function ($data) use($stream, $id, $user, $logger) {
$logger->notice("Forwarding " . strlen($data) . " bytes from stream {$id} to {$user->getId()}");
$message = array('connection' => $id, 'event' => 'data', 'data' => $data);
$user->sendString(json_encode($message));
});
// When the stream closes, notify the user
$stream->on("close", function () use($user, $id, $logger, $address) {
$logger->notice(sprintf("Connection %s of user %s to %s has been closed", $id, $user->getId(), $address));
$message = array('connection' => $id, 'event' => 'close');
$user->sendString(json_encode($message));
});
});
} catch (Exception $e) {
$user->sendString(json_encode(array('event' => 'error', 'tag' => property_exists($message, 'tag') ? $message->tag : null, 'message' => $e->getMessage())));
}
}
/**
* @return HttpClient
*/
protected function createHttpAsyncClient()
{
$loop = \React\EventLoop\Factory::create();
$dnsResolverFactory = new \React\Dns\Resolver\Factory();
$dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $loop);
$messageFactory = new \Http\Discovery\MessageFactory\GuzzleFactory();
return new ReactHttpClient($loop, $dnsResolver, $messageFactory);
}
public function setUp()
{
$loop = React\EventLoop\Factory::create();
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached('8.8.8.8', $loop);
$factory = new Socks\Factory($loop, $dns);
$this->client = $factory->createClient('127.0.0.1', 9050);
}
private function createImapstream(&$imapaccount)
{
//$loop = \React\EventLoop\Factory::create();
$dnsResolverFactory = new \React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached('8.8.8.8', $this->loop);
$imapconnector = new \React\SocketClient\Connector($this->loop, $dns);
$secureConnector = new \React\SocketClient\SecureConnector($imapconnector, $this->loop);
$mailaccount = $imapaccount['mailaccount'];
echo $mailaccount->getImapserver() . ($mailaccount->getImapport() ? $mailaccount->getImapport() : 993);
$secureConnector->create($mailaccount->getImapserver(), $mailaccount->getImapport() ? $mailaccount->getImapport() : 993)->then(function (\React\Stream\Stream $imapstream) use(&$imapaccount) {
$uid = uniqid();
echo $imapaccount['mailaccount']->getImapserver() . ': ' . $uid;
$imapaccount['imapstream'] = $imapstream;
$login = $imapaccount['mailaccount']->getImapusername();
$password = $imapaccount['mailaccount']->getImappassword();
$imapstream->write($uid . " LOGIN {$login} {$password}\r\n");
$status = 'LOGIN';
$imapstream->on('data', function ($data) use($uid, &$status, &$imapstream, &$imapaccount) {
echo $imapaccount['mailaccount']->getImapserver() . ': ' . $data;
$dataexpl = explode("\r\n", $data);
foreach ($dataexpl as $dexpl) {
if (preg_match("/^" . $uid . " OK/", $dexpl)) {
//login OK:
if ($status == 'LOGIN') {
$imapstream->write($uid . " SELECT " . $imapaccount['mailaccount']->getImappathprefix() . "\r\n");
$status = 'SELECT';
echo "SEND: SELECT {$status}\r\n";
} else {
if ($status == 'SELECT') {
$imapstream->write($uid . " IDLE\r\n");
$status = 'IDLE';
echo "SEND: IDLE {$status}\r\n";
}
}
}
if ($status == 'IDLE') {
if (preg_match("/^\\* (\\d+) RECENT/", $dexpl, $countrecent)) {
//login OK:
$countrecent = $countrecent[1];
echo 'RECENT:' . $countrecent;
$this->notifychanges($imapaccount);
}
if (preg_match("/^\\* (\\d+) EXISTS/", $dexpl, $countrecent)) {
//login OK:
$countrecent = $countrecent[1];
echo 'EXISTS' . $countrecent;
$this->notifychanges($imapaccount);
}
}
}
});
$imapstream->on('end', function () use($uid, &$status, &$imapstream, &$imapaccount) {
echo 'END!!!!!';
});
});
return $imapaccount;
}
public function start()
{
$loop = \React\EventLoop\Factory::create();
$dnsResolverFactory = new \React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached($this->nameserver, $loop);
$connector = new \React\SocketClient\Connector($loop, $dns);
$this->loadPlugins();
$this->startLoop($loop, $connector);
$loop->run();
}
/**
* Start transport provider
*
* @param \Thruway\Peer\ClientInterface $client
* @param \React\EventLoop\LoopInterface $loop
*/
public function startTransportProvider(ClientInterface $client, LoopInterface $loop)
{
$this->client = $client;
$this->loop = $loop;
$dnsResolverFactory = new \React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached('8.8.8.8', $loop);
$connector = new Connector($loop, $dns);
$connector->create($this->address, $this->port)->then(function (Stream $stream) {
$stream->on('data', [$this, "handleData"]);
$stream->on('close', [$this, "handleClose"]);
$this->handleConnection($stream);
});
}
public function __construct($url, LoopInterface $loop, LoggerInterface $logger, array $streamOptions = null)
{
$this->logger = $logger;
$this->loop = $loop;
$this->streamOptions = $streamOptions;
$parts = parse_url($url);
$this->url = $url;
if (in_array($parts['scheme'], array('ws', 'wss')) === false) {
throw new WebSocketInvalidUrlScheme();
}
$dnsResolverFactory = new \React\Dns\Resolver\Factory();
$this->dns = $dnsResolverFactory->createCached('8.8.8.8', $loop);
}
function connectToLightTable($clientId, $port, $projectRootDir, Logger $log)
{
$message = ['client-id' => intval($clientId), 'tags' => 'php.client', 'commands' => ['editor.eval.php', 'editor.eval.php.exception', 'editor.eval.php.result'], 'name' => 'PHP', 'type' => 'php', 'dir' => $projectRootDir];
$loop = EventLoopFactory::create();
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached('8.8.8.8', $loop);
$connector = new React\SocketClient\Connector($loop, $dns);
$connector->create('127.0.0.1', intval($port))->then(function (React\Stream\Stream $stream) use($log, $message) {
echo 'Connected';
$encodedMessage = json_encode($message);
$stream->write($encodedMessage . "\n");
$log->addInfo(sprintf('Acknowledged connection and client id #%d', $message['client-id']));
$stream->on('data', function ($data) use($stream, $log, $encodedMessage) {
$log->addInfo(sprintf('Decoding data "%s"', print_r($data, true)));
$decodedData = json_decode($data, $asAssociativeArray = true);
if ($decodedData[1] == 'editor.eval.php') {
try {
ob_start();
require $decodedData[2]['path'];
$output = ob_get_contents();
$outputType = 'result';
$responseType = 'editor.eval.php.result';
} catch (\Exception $exception) {
$output = $exception->getMessage();
$output .= $exception->getTraceAsString();
$outputType = 'ex';
$responseType = 'editor.eval.php.exception';
}
$response = json_encode([$decodedData[0], $responseType, ["meta" => $decodedData[2]['meta'], $outputType => $output]]);
$stream->write($response . "\n");
ob_end_clean();
}
if ($decodedData[1] === 'client.close') {
$stream->close();
}
});
});
$loop->run();
}
/**
* Execute the console command.
*
* @return void
*/
public function fire()
{
echo 'Iniciado' . PHP_EOL;
$start = microtime(true);
$totalUsers = User::count();
$buffer = '';
$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('127.0.0.1', 1337)->then(function (\React\Stream\Stream $stream) use(&$buffer) {
$stream->on('data', function ($data, $stream) use(&$buffer) {
$buffer .= $data;
});
});
$loop->nextTick(function () use($totalUsers) {
$this->users = $this->getUsers($totalUsers / 2, 0);
});
$loop->run();
$buffer = unserialize($buffer);
$this->users = array_merge($this->users, $buffer);
echo 'Processados ' . count($this->users) . ' usuários' . PHP_EOL;
echo 'Demorou ' . number_format((microtime(true) - $start) * 1000, 2, ',', '') . 'ms' . PHP_EOL;
}
<?php
include_once __DIR__ . '/../vendor/autoload.php';
$loop = React\EventLoop\Factory::create();
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached('8.8.8.8', $loop);
$socket = new React\Socket\Server($loop);
$socket->listen('9050', 'localhost');
$factory = new Socks\Factory($loop, $dns);
$server = $factory->createServer($socket);
$server->setAuthArray(array('tom' => 'god', 'user' => 'p@ssw0rd'));
echo 'SOCKS server listening on localhost:9050' . PHP_EOL;
$loop->run();
<?php
require __DIR__ . '/../vendor/autoload.php';
$loop = React\EventLoop\Factory::create();
$factory = new React\Dns\Resolver\Factory();
$resolver = $factory->create('8.8.8.8', $loop);
$connFactory = new React\Whois\ConnectionFactory($loop);
$domain = 'igor.io';
$client = new React\Whois\Client($resolver, $connFactory);
$client->query($domain)->then(function ($result) {
echo $result;
});
echo "Getting whois for {$domain}...\n";
$loop->run();
<?php
// async DNS resolution
require __DIR__ . '/../vendor/autoload.php';
$loop = React\EventLoop\Factory::create();
$factory = new React\Dns\Resolver\Factory();
$dns = $factory->create('8.8.8.8', $loop);
$domain = 'igor.io';
$dns->resolve($domain)->then(function ($ip) {
echo "Host: {$ip}\n";
}, function ($e) {
echo "Error: {$e->getMessage()}\n";
});
echo "Resolving domain {$domain}...\n";
$loop->run();
/**
* @param $method
* @param null $params
* @return \React\Promise\Promise
*/
private function request($method, $params = null)
{
$deferred = new Deferred();
$loop = $this->getLoop();
$dnsResolverFactory = new \React\Dns\Resolver\Factory();
$dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $loop);
$factory = new \React\HttpClient\Factory();
$client = $factory->create($loop, $dnsResolver);
$request = $client->request('GET', $this->slackURL . $method . '?token=' . $this->token . '&' . $params);
$buffer = '';
$request->on('response', function ($response) use(&$buffer, $deferred) {
$response->on('data', function ($data) use(&$buffer) {
$buffer .= $data;
});
$response->on('error', function ($error) use($deferred) {
$deferred->reject($error);
});
});
$request->on('end', function () use(&$buffer, $deferred) {
$deferred->resolve(json_decode($buffer));
});
$request->on('error', function ($error) use($deferred) {
$deferred->reject($error);
});
$request->end();
return $deferred->promise();
}
<?php
use React\Promise\Deferred;
use React\EventLoop\Timer\Timer;
require "vendor/autoload.php";
$loop = React\EventLoop\Factory::create();
if (0) {
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dnsResolver = $dnsResolverFactory->createCached('127.0.0.1', $loop);
$factory = new React\HttpClient\Factory();
$client = $factory->create($loop, $dnsResolver);
}
$loop->addPeriodicTimer(0.25, function () {
static $count = 0;
$count++;
echo $count, PHP_EOL;
if ($count == 10) {
posix_kill(posix_getpid(), SIGTERM);
}
});
$pcntl = new MKraemer\ReactPCNTL\PCNTL($loop);
$pcntl->on(SIGTERM, function () {
// Clear some queue
// Write syslog
// Do ALL the stuff
echo 'Bye' . PHP_EOL;
die;
});
$pcntl->on(SIGINT, function () {
echo 'Terminated by console' . PHP_EOL;
die;
public function start(array $args)
{
// apply default settings for arguments
$args += array('socket' => 'socks://localhost:9050', 'measureTraffic' => true, 'measureTime' => true, 'interactive' => DIRECTORY_SEPARATOR === '/' && !isset($args['no-interaction']) && !isset($args['n']) && defined('STDIN') && is_resource(STDIN));
$settings = $this->parseSocksSocket($args['socket']);
if ($settings['host'] === '*') {
$settings['host'] = '0.0.0.0';
}
$this->loop = $loop = \React\EventLoop\Factory::create();
$this->stdio = new Stream(STDOUT, $loop);
$this->stdio->pause();
if ($args['interactive']) {
$this->stdio = new Stdio($loop);
$this->stdio->getReadline()->setPrompt('> ');
// forward all lines through commander
$this->stdio->getReadline()->on('data', array($this, 'onReadLine'));
// exit program when input stream closes
$this->stdio->on('end', function () use($loop) {
echo 'STDIN closed. Exiting program...';
$loop->stop();
echo PHP_EOL;
// stop output buffering
ob_end_flush();
});
// make sure any echo calls will be piped through this stdio instance
$stdio = $this->stdio;
ob_start(function ($chunk) use($stdio) {
$stdio->write($chunk);
return '';
}, 1);
$this->stdio->write('Running in interactive mode. Type "help" for more info.' . PHP_EOL);
} else {
$this->stdio->write('Running in non-interactive mode.');
}
$dnsResolverFactory = new \React\Dns\Resolver\Factory();
$this->resolver = $dns = $dnsResolverFactory->createCached('8.8.8.8', $loop);
$this->via = new ConnectionManagerSelective();
$this->via->addConnectionManagerFor($this->createConnectionManager('none'), '*', '*', self::PRIORITY_DEFAULT);
$socket = new \React\Socket\Server($loop);
$this->server = new \Clue\React\Socks\Server($loop, $socket, $this->via);
if (isset($settings['protocolVersion'])) {
$this->server->setProtocolVersion($settings['protocolVersion']);
}
try {
$socket->listen($settings['port'], $settings['host']);
} catch (Exception $e) {
$this->stdio->write('ERROR: Unable to start listening socket: ' . $e->getMessage() . PHP_EOL);
$this->stdio->close();
}
$this->stdio->write('SOCKS proxy server listening on ' . $settings['host'] . ':' . $settings['port'] . PHP_EOL);
if (isset($settings['user']) || isset($settings['pass'])) {
$settings += array('user' => '', 'pass' => '');
$this->server->setAuthArray(array($settings['user'] => $settings['pass']));
}
new Option\Log($this->server, $this->stdio);
if ($args['measureTraffic']) {
new Option\MeasureTraffic($this->server);
}
if ($args['measureTime']) {
new Option\MeasureTime($this->server);
}
$loop->run();
}
<?php
require_once __DIR__ . '/vendor/autoload.php';
require_once __DIR__ . '/config.php';
$loop = React\EventLoop\Factory::create();
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dnsResolver = $dnsResolverFactory->createCached(HOMER_RESOLVER_ADDRESS, $loop);
$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();
/**
* @return Resolver
*/
public function getResolver()
{
if (!$this->resolver) {
$factory = new \React\Dns\Resolver\Factory();
$this->setResolver($factory->createCached('8.8.8.8', $this->getLoop()));
}
return $this->resolver;
}
<?php
require __DIR__ . '/../vendor/autoload.php';
$loop = \React\EventLoop\Factory::create();
$dns_factory = new React\Dns\Resolver\Factory();
$resolver = $dns_factory->createCached('8.8.8.8', $loop);
$client = new \Calcinai\Bolt\Client('ws://127.0.0.1:1337/chat', $loop, $resolver);
$client->setOrigin('127.0.0.1');
$client->connect();
$client->on('stateChange', function ($newState) {
echo "State changed to: {$newState}\n";
});
$client->on('message', function ($message) use($client) {
});
$loop->run();
//print_r($client);
private function getDnsResolver()
{
$dnsResolverFactory = new \React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached('8.8.8.8', $this->loop);
return $dns;
}
<?php
/**
* Common bootstrap for all examples
*/
if (file_exists($path = __DIR__ . '/../vendor/autoload.php')) {
require_once $path;
} elseif (file_exists($path = __DIR__ . '/../../../../vendor/autoload.php')) {
require_once $path;
}
// Init react
$eventLoop = React\EventLoop\Factory::create();
$dnsFactory = new React\Dns\Resolver\Factory();
$dnsResolver = $dnsFactory->createCached("8.8.8.8", $eventLoop);
$httpClientFactory = new React\HttpClient\Factory();
$httpClient = $httpClientFactory->create($eventLoop, $dnsResolver);
// Register flow() function
Flow\Flow::register(new Flow\Schedulers\HorizontalScheduler($eventLoop));
<?php
require __DIR__ . '/../vendor/autoload.php';
$config = (include 'config.php');
$loop = React\EventLoop\Factory::create();
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$resolver = $dnsResolverFactory->createCached('192.168.0.1', $loop);
$version = new oliverlorenz\reactphpmqtt\protocol\Version4();
$connector = new oliverlorenz\reactphpmqtt\Connector($loop, $resolver, $version);
$p = $connector->create($config['server']);
$p->then(function (\React\Stream\Stream $stream) use($connector) {
return $connector->subscribe($stream, '#', 0);
});
$loop->run();
<?php
require_once '../vendor/autoload.php';
/**
Example is used with React stream, but you can use whatever library you want to as long as it implement Madkom\EventStore\Client\Domain\Socket\Stream
Your EventStore must be up, to handle connection
*/
$loop = React\EventLoop\Factory::create();
$dnsResolverFactory = new React\Dns\Resolver\Factory();
$dns = $dnsResolverFactory->createCached(null, $loop);
$connector = new React\SocketClient\Connector($loop, $dns);
$resolvedConnection = $connector->create('127.0.0.1', 1113);
$resolvedConnection->then(function (React\Stream\Stream $stream) {
// We create Event Store API Object
$eventStore = new \Madkom\EventStore\Client\Application\Api\EventStore(new \Madkom\EventStore\Client\Infrastructure\ReactStream($stream), new \Madkom\EventStore\Client\Infrastructure\InMemoryLogger());
// We add bunch of listeners, because API is asynchronous
$eventStore->addAction(\Madkom\EventStore\Client\Domain\Socket\Message\MessageType::HEARTBEAT_REQUEST, function () {
echo "I response to ES heartbeat request\n";
});
$eventStore->addAction(\Madkom\EventStore\Client\Domain\Socket\Message\MessageType::WRITE_EVENTS_COMPLETED, function ($data) {
echo "Added new event: \n";
// print_r($data);
});
$eventStore->addAction(\Madkom\EventStore\Client\Domain\Socket\Message\MessageType::READ_STREAM_EVENTS_FORWARD_COMPLETED, function ($data) {
print_r($data);
});
//We start to listen for event we added
$eventStore->run();
//Now let's try writing messages to stream
$eventStreamId = 'someteststream';
// Add new event to stream
