Ejemplo n.º 1
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()));
 }
Ejemplo n.º 2
0
 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);
 }
Ejemplo n.º 3
0
 /** @test */
 public function createCachedShouldCreateResolverWithCachedExecutor()
 {
     $loop = $this->getMock('React\\EventLoop\\LoopInterface');
     $factory = new Factory();
     $resolver = $factory->createCached('8.8.8.8:53', $loop);
     $this->assertInstanceOf('React\\Dns\\Resolver\\Resolver', $resolver);
     $this->assertInstanceOf('React\\Dns\\Query\\CachedExecutor', $this->getResolverPrivateMemberValue($resolver, 'executor'));
 }
Ejemplo n.º 4
0
 /**
  * @return Resolver
  */
 public function getDns()
 {
     if (!$this->dns) {
         $factory = new DnsFactory();
         $this->dns = $factory->createCached($this->resolver, $this->getLoop());
     }
     return $this->dns;
 }
 /**
  * @param DnsResolver $dnsResolver
  */
 public function setDnsResolver(DnsResolver $dnsResolver = null)
 {
     if (!$dnsResolver instanceof DnsResolver) {
         $dnsResolverFactory = new DnsFactory();
         $dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $this->loop);
     }
     $this->dnsResolver = $dnsResolver;
 }
Ejemplo n.º 6
0
 /**
  * @test
  * @dataProvider factoryShouldAddDefaultPortProvider
  */
 public function factoryShouldAddDefaultPort($input, $expected)
 {
     $loop = $this->getMock('React\\EventLoop\\LoopInterface');
     $factory = new Factory();
     $resolver = $factory->create($input, $loop);
     $this->assertInstanceOf('React\\Dns\\Resolver\\Resolver', $resolver);
     $this->assertSame($expected, $this->getResolverPrivateMemberValue($resolver, 'nameserver'));
 }
Ejemplo n.º 7
0
 /**
  * @return React\SocketClient\Connector
  */
 public function getConnector()
 {
     if ($this->connector === null) {
         $dnsResolverFactory = new React\Dns\Resolver\Factory();
         $dns = $dnsResolverFactory->createCached($this->config['dns'], $this->loop);
         $this->connector = new React\SocketClient\Connector($this->loop, $dns);
     }
     return $this->connector;
 }
Ejemplo n.º 8
0
 /**
  * create sender attached to the given event loop and DNS resolver
  *
  * @param LoopInterface   $loop
  * @param Resolver|string $dns  DNS resolver instance or IP address
  * @return self
  */
 public static function createFromLoopDns(LoopInterface $loop, $dns)
 {
     if (!$dns instanceof Resolver) {
         $dnsResolverFactory = new ResolverFactory();
         $dns = $dnsResolverFactory->createCached($dns, $loop);
     }
     $connector = new Connector($loop, $dns);
     return self::createFromLoopConnectors($loop, $connector);
 }
Ejemplo n.º 9
0
 private function startConnection()
 {
     $loop = \EventLoop\getLoop();
     $dnsResolverFactory = new Factory();
     $dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $loop);
     $factory = new \React\HttpClient\Factory();
     $client = $factory->create($loop, $dnsResolver);
     $cNegotiator = new ClientNegotiator($this->url, $this->subProtocols);
     $headers = $cNegotiator->getRequest()->getHeaders();
     $flatHeaders = [];
     foreach ($headers as $k => $v) {
         $flatHeaders[$k] = $v[0];
     }
     $request = $client->request("GET", $this->url, $flatHeaders, '1.1');
     $request->on('response', function (Response $response, Request $request) use($cNegotiator) {
         if ($response->getCode() !== 101) {
             throw new \Exception("Unexpected response code " . $response->getCode());
         }
         // TODO: Should validate response
         //$cNegotiator->validateResponse($response);
         $subprotoHeader = "";
         $psr7Response = new \GuzzleHttp\Psr7\Response($response->getCode(), $response->getHeaders(), null, $response->getVersion());
         if (count($psr7Response->getHeader('Sec-WebSocket-Protocol')) == 1) {
             $subprotoHeader = $psr7Response->getHeader('Sec-WebSocket-Protocol')[0];
         }
         parent::onNext(new MessageSubject(new AnonymousObservable(function (ObserverInterface $observer) use($response) {
             $response->on('data', function ($data) use($observer) {
                 $observer->onNext($data);
             });
             $response->on('error', function ($e) use($observer) {
                 $observer->onError($e);
             });
             $response->on('close', function () use($observer) {
                 $observer->onCompleted();
             });
             $response->on('end', function () use($observer) {
                 $observer->onCompleted();
                 // complete the parent observer - we only do 1 connection
                 parent::onCompleted();
             });
             return new CallbackDisposable(function () use($response) {
                 // commented this out because disposal was causing the other
                 // end (the request) to close also - which causes the pending messages
                 // to get tossed
                 //$response->close();
             });
         }), new CallbackObserver(function ($x) use($request) {
             $request->write($x);
         }, function ($e) use($request) {
             $request->close();
         }, function () use($request) {
             $request->end();
         }), true, $this->useMessageObject, $subprotoHeader, $cNegotiator->getRequest(), $psr7Response));
     });
     $request->writeHead();
 }
Ejemplo n.º 10
0
 public function __construct(LoopInterface $loop, Resolver $resolver = null)
 {
     if (null === $resolver) {
         $factory = new DnsFactory();
         $resolver = $factory->create('8.8.8.8', $loop);
     }
     $this->_loop = $loop;
     $this->_connector = new Connector($loop, $resolver);
     $this->_secureConnector = new SecureConnector($this->_connector, $loop);
 }
Ejemplo n.º 11
0
 public function __construct(LoopInterface $loop, Resolver $resolver = null)
 {
     $this->defaultHeaders['User-Agent'] = Guzzle::getUserAgent();
     if (null === $resolver) {
         $factory = new DnsFactory();
         $resolver = $factory->create('8.8.8.8', $loop);
     }
     $this->_loop = $loop;
     $this->_connector = new Connector($loop, $resolver);
     $this->_secureConnector = new SecureConnector($this->_connector, $loop);
 }
 public static function factory($loop, array $options = array())
 {
     $defaultOptions = array('port' => 15672, 'user' => 'guest', 'password' => 'guest', 'scheme' => 'http', 'url' => '127.0.0.1');
     $options = array_merge($defaultOptions, $options);
     $dnsResolverFactory = new DnsResolverFactory();
     $dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $loop);
     $connectionManager = new ConnectionManager($loop, $dnsResolver);
     $secureConnectionManager = new SecureConnectionManager($loop, $dnsResolver);
     $client = new Client($loop, $connectionManager, $secureConnectionManager);
     return new self($client, $options);
 }
Ejemplo n.º 13
0
 public function __construct(LoopInterface $loop, ConnectorInterface $connector = null, ProtocolFactory $protocol = null)
 {
     if ($connector === null) {
         $resolverFactory = new ResolverFactory();
         $connector = new Connector($loop, $resolverFactory->create('8.8.8.8', $loop));
     }
     if ($protocol === null) {
         $protocol = new ProtocolFactory();
     }
     $this->connector = $connector;
     $this->protocol = $protocol;
 }
Ejemplo n.º 14
0
 public function __construct(LoopInterface $loop, Connector $connector = null, SecureConnector $secureConnector = null)
 {
     if ($connector === null) {
         $resolverFactory = new ResolverFactory();
         $connector = new Connector($loop, $resolverFactory->create('8.8.8.8', $loop));
     }
     if ($secureConnector === null) {
         $secureConnector = new SecureConnector($connector, $loop);
     }
     $this->loop = $loop;
     $this->connector = $connector;
     $this->secureConnector = $secureConnector;
 }
Ejemplo n.º 15
0
 public function __construct(LoopInterface $loop, ConnectorInterface $connector = null, Prober $prober = null)
 {
     if ($connector === null) {
         $resolverFactory = new ResolverFactory();
         $resolver = $resolverFactory->create('8.8.8.8', $loop);
         $connector = new Connector($loop, $resolver);
     }
     if ($prober === null) {
         $prober = new Prober();
     }
     $this->loop = $loop;
     $this->connector = $connector;
     $this->prober = $prober;
 }
Ejemplo n.º 16
0
 public function __construct($method, $url, $body = null, array $headers = [], $protocolVersion = '1.0', $bufferResults = true, $includeResponse = false)
 {
     $this->method = $method;
     $this->url = $url;
     $this->body = $body;
     $this->headers = $headers;
     $this->protocolVersion = $protocolVersion;
     $this->bufferResults = $bufferResults;
     $this->includeResponse = $includeResponse;
     $loop = \EventLoop\getLoop();
     $dnsResolverFactory = new Factory();
     $dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $loop);
     $factory = new \React\HttpClient\Factory();
     $this->client = $factory->create($loop, $dnsResolver);
 }
Ejemplo n.º 17
0
 public function testVerifyPeerDisabledForBadSslResolves()
 {
     if (!function_exists('stream_socket_enable_crypto')) {
         $this->markTestSkipped('Not supported on your platform (outdated HHVM?)');
     }
     if (!class_exists('React\\SocketClient\\TcpConnector')) {
         $this->markTestSkipped('Test requires SocketClient:0.5');
     }
     $dnsResolverFactory = new DnsFactory();
     $resolver = $dnsResolverFactory->createCached('8.8.8.8', $this->loop);
     $tcp = new DnsConnector(new TcpConnector($this->loop), $resolver);
     $ssl = new SecureConnector($tcp, $this->loop, array('verify_peer' => false));
     $sender = Sender::createFromLoopConnectors($this->loop, $tcp, $ssl);
     $browser = $this->browser->withSender($sender);
     Block\await($browser->get('https://self-signed.badssl.com/'), $this->loop);
 }
Ejemplo n.º 18
0
 /**
  * Create a new Irto\OAuth2Proxy\Server instance with $config
  * 
  * @param array $config
  * 
  * @return Irto\OAuth2Proxy\Server
  */
 public static function create(array $config)
 {
     $server = new static();
     isset($config['verbose']) && $server->setVerbose($config['verbose']);
     $server->singleton('config', function ($server) use($config) {
         return new Collection($config);
     });
     $server->bind('Irto\\OAuth2Proxy\\Server', function ($server) {
         return $server;
     });
     // Create main loop React\EventLoop based
     $server->singleton('React\\EventLoop\\LoopInterface', function ($server) {
         return React\EventLoop\Factory::create();
     });
     // DNS resolve, used for create async requests
     $server->singleton('React\\Dns\\Resolver\\Resolver', function ($server) {
         $dnsResolverFactory = new React\Dns\Resolver\Factory();
         return $dnsResolverFactory->createCached('8.8.8.8', $server['React\\EventLoop\\LoopInterface']);
         //Google DNS
     });
     // HTTP Client
     $server->singleton('React\\HttpClient\\Client', function ($server) {
         $factory = new React\HttpClient\Factory();
         return $factory->create($server['React\\EventLoop\\LoopInterface'], $server['React\\Dns\\Resolver\\Resolver']);
     });
     // Request handler to React\Http
     $server->singleton('React\\Socket\\Server', function ($server) {
         $socket = new React\Socket\Server($server['React\\EventLoop\\LoopInterface']);
         $socket->listen($server->get('port'));
         return $socket;
     });
     // HTTP server for handle requests
     $server->singleton('React\\Http\\Server', function ($server) {
         return new React\Http\Server($server['React\\Socket\\Server']);
     });
     // HTTP server for handle requests
     $server->singleton('SessionHandlerInterface', function ($server) {
         return $server->make('Irto\\OAuth2Proxy\\Session\\AsyncRedisSessionHandler', ['lifetime' => array_get($server['config']->all(), 'session.lifetime')]);
     });
     $server->bind('Illuminate\\Session\\Store', 'Irto\\OAuth2Proxy\\Session\\Store');
     $server->boot();
     return $server;
 }
Ejemplo n.º 19
0
 /** @test */
 public function gettingEncryptedStuffFromGoogleShouldWork()
 {
     $loop = new StreamSelectLoop();
     $factory = new Factory();
     $dns = $factory->create('8.8.8.8', $loop);
     $connected = false;
     $response = null;
     $secureConnector = new SecureConnector(new Connector($loop, $dns), $loop);
     $secureConnector->create('google.com', 443)->then(function ($conn) use(&$connected) {
         $connected = true;
         $conn->write("GET / HTTP/1.0\r\n\r\n");
         return BufferedSink::createPromise($conn);
     })->then(function ($data) use(&$response) {
         $response = $data;
     });
     $loop->run();
     $this->assertTrue($connected);
     $this->assertRegExp('#^HTTP/1\\.0#', $response);
 }
Ejemplo n.º 20
0
 protected function makeHttpRequest($method, $url, array $headers = [], $protocolVersion = '1.0', $body)
 {
     $dnsResolverFactory = new Factory();
     $dnsResolver = $dnsResolverFactory->createCached("127.0.0.1", \EventLoop\getLoop());
     $httpFactory = new \React\HttpClient\Factory();
     $httpClient = $httpFactory->create(\EventLoop\getLoop(), $dnsResolver);
     $deferred = new Deferred();
     $request = $httpClient->request($method, $url, $headers, $protocolVersion);
     $request->writeHead();
     $request->write($body);
     $request->on('response', function ($response) use($deferred) {
         $responseBody = "";
         $response->on('data', function ($data, $response) use(&$responseBody) {
             $responseBody .= $data;
         });
         $response->on('end', function () use(&$responseBody, $deferred, $response) {
             $deferred->resolve([$response, $responseBody]);
         });
     });
     $request->end();
     return $deferred->promise();
 }
Ejemplo n.º 21
0
 /**
  * Get the DNS Resolver, if one isn't set in instance will be created.
  *
  * @return Resolver
  */
 public function getResolver()
 {
     if ($this->resolver instanceof Resolver) {
         return $this->resolver;
     }
     $factory = new Factory();
     $this->resolver = $factory->createCached($this->getDnsServer(), $this->getLoop());
     return $this->resolver;
 }
Ejemplo n.º 22
0
 public function setUp()
 {
     $this->loop = LoopFactory::create();
     $factory = new Factory();
     $this->resolver = $factory->create('8.8.8.8', $this->loop);
 }
Ejemplo n.º 23
0
 /**
  * @param Container $container
  */
 public static function setupHttpClient($container)
 {
     $container->add('httpClient', function () use($container) {
         $dnsResolverFactory = new Factory();
         $loop = $container->get('eventloop');
         $dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $loop);
         $factory = new HttpFactory();
         $client = $factory->create($loop, $dnsResolver);
         return $client;
     }, true);
 }
Ejemplo n.º 24
0
 /**
  * Build a React Dns Resolver.
  *
  * @param LoopInterface $loop
  * @param string        $dns
  *
  * @return DnsResolver
  */
 public static function buildDnsResolver(LoopInterface $loop, $dns = '8.8.8.8')
 {
     $factory = new DnsResolverFactory();
     return $factory->createCached($dns, $loop);
 }
 public function __construct(LoopInterface $loop)
 {
     $this->setLoop($loop);
     $dnsResolverFactory = new ResolverFactory();
     $this->setResolver($dnsResolverFactory->createCached('8.8.8.8', $this->getLoop()));
 }
Ejemplo n.º 26
0
 private function createImapstream(&$imapaccount)
 {
     echo 'createImapstream';
     //$loop = \React\EventLoop\Factory::create();
     $dnsResolverFactory = new Factory();
     $dns = $dnsResolverFactory->createCached('8.8.8.8', $this->loop);
     $imapconnector = new Connector($this->loop, $dns);
     /** @var Mailaccount $mailaccount */
     $mailaccount = $imapaccount['mailaccount'];
     $imapport = $mailaccount->getImapport() ? $mailaccount->getImapport() : 993;
     //$imapport=143;
     if ($imapport == 993) {
         //secure
         $secureConnector = new SecureConnector($imapconnector, $this->loop);
         $conn = $secureConnector->create($mailaccount->getImapserver(), $imapport);
     } else {
         $conn = $imapconnector->create($mailaccount->getImapserver(), $imapport);
     }
     echo $mailaccount->getImapserver() . $imapport;
     $conn->then(function (\React\Stream\Stream $imapstream) use(&$imapaccount) {
         echo 'Jojo';
         $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, ['mailaccount_id' => $imapaccount['mailaccount']->getId(), 'recent' => $countrecent]);
                     }
                     if (preg_match("/^\\* (\\d+) EXISTS/", $dexpl, $countexists)) {
                         //login OK:
                         $countexists = $countexists[1];
                         echo 'EXISTS' . $countexists;
                         $this->notifychanges($imapaccount, ['mailaccount_id' => $imapaccount['mailaccount']->getId(), 'exists' => $countexists]);
                     }
                 }
             }
         });
         $imapstream->on('end', function () use($uid, &$status, &$imapstream, &$imapaccount) {
             echo 'END!!!!!';
             $this->createImapstream($imapaccount);
         });
     }, function (\Exception $error) use(&$imapaccount) {
         echo "Call Error: \n";
         dump($error->getMessage());
         echo "trying again...\n";
         $this->createImapstream($imapaccount);
     });
     return $imapaccount;
 }
Ejemplo n.º 27
0
 /**
  * @param Factory $factory
  *
  * @return Resolver
  */
 public function getResolver(Factory $factory = null)
 {
     if ($this->resolver instanceof Resolver) {
         $this->logDebug('Existing Resolver found using it');
         return $this->resolver;
     }
     if ($factory === null) {
         $factory = new Factory();
     }
     $this->logDebug('Creating new Resolver');
     $this->resolver = $factory->createCached($this->dnsServer, $this->loop);
     return $this->resolver;
 }
Ejemplo n.º 28
0
<?php

use React\Dns\Resolver\Factory as DNSResolverFactory;
use React\EventLoop\Factory as EventLoopFactory;
use React\HttpClient\Factory as HttpClientFactory;
require 'vendor/autoload.php';
$loop = EventLoopFactory::create();
$dnsResolverFactory = new DNSResolverFactory();
$dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $loop);
$factory = new HttpClientFactory();
$client = $factory->create($loop, $dnsResolver);
$request = $client->request('GET', 'https://example.com/');
$request->on('response', function ($response) {
    $response->on('data', function ($data, $response) {
        echo $data;
    });
});
$request->end();
$loop->run();
Ejemplo n.º 29
0
 public function masterServer($bindMasterTo)
 {
     cli_set_process_title("mpcmf/console server:run/master -b {$bindMasterTo['host']} -p {$bindMasterTo['port']}");
     $output = $this->output;
     //MPCMF_DEBUG && $output->writeln('<error>[MASTER]</error> Preparing server');
     $loop = Factory::create();
     $dnsResolverFactory = new reactResolver();
     $dns = $dnsResolverFactory->createCached('8.8.8.8', $loop);
     $connector = new Connector($loop, $dns);
     $output->writeln('<error>[MASTER]</error> Binding callables and building socketServer');
     $socketServer = new reactSocketServer($loop);
     $clientId = null;
     $socketServer->on('connection', function (Connection $clientConnection) use($connector, $output, $clientId, $loop) {
         $clientConnection->pause();
         MPCMF_DEBUG && ($clientId = spl_object_hash($clientConnection));
         do {
             $threadKey = array_rand($this->threads);
             if ($this->threads[$threadKey]->isAlive()) {
                 break;
             }
             $loop->tick();
         } while (true);
         $childPort = json_decode($threadKey, true)['port'];
         //MPCMF_DEBUG && $output->writeln("<error>[MASTER:{$clientId}]</error> Client connected, using port {$childPort}");
         $clientConnection->on('end', function () use($clientConnection, $clientId, $output) {
             //MPCMF_DEBUG && $output->writeln("<error>[MASTER:{$clientId}]</error> Client connection ending");
         });
         $clientConnection->on('close', function () use($clientConnection, $clientId, $output) {
             //MPCMF_DEBUG && $output->writeln("<error>[MASTER:{$clientId}]</error> Client connection closed");
         });
         /** @var \React\Promise\FulfilledPromise|\React\Promise\Promise|\React\Promise\RejectedPromise $childConnection */
         $childConnection = $connector->create($this->childHost, $childPort);
         $childConnection->then(function (reactStream $childStream) use($clientConnection, $childConnection, $output, $clientId) {
             $childStream->pause();
             //MPCMF_DEBUG && $output->writeln('<error>=================== ' . spl_object_hash($childStream) . ' CHILD STREAM OPEN </error>');
             $childStream->on('end', function () use($clientConnection, $childConnection, $childStream, $output, $clientId) {
                 //MPCMF_DEBUG && $output->writeln("<error>[MASTER:{$clientId}]</error> Child closed connection");
                 //MPCMF_DEBUG && $output->writeln('<error>=================== ' . spl_object_hash($childStream) . ' CHILD STREAM CLOSE</error>');
                 $childStream->close();
                 $clientConnection->getBuffer()->on('full-drain', function () use($clientConnection, $output, $clientId) {
                     //MPCMF_DEBUG && $output->writeln("<error>[MASTER:{$clientId}]</error> Buffer is empty, closing client connection");
                     $clientConnection->close();
                 });
             });
             $childStream->on('data', function ($data) use($clientConnection, $childConnection, $childStream, $output, $clientId) {
                 //MPCMF_DEBUG && $output->writeln("<error>[MASTER:{$clientId}]</error> Response from child received");
                 //MPCMF_DEBUG && $output->writeln("<error>[MASTER:{$clientId}]</error> Sending response to client");
                 $clientConnection->write($data);
             });
             $childStream->resume();
             $clientConnection->on('data', function ($data) use($clientConnection, $childConnection, $output, $clientId, $childStream) {
                 //MPCMF_DEBUG && $output->writeln("<error>[MASTER:{$clientId}]</error> Client data received");
                 //MPCMF_DEBUG && $output->writeln("<error>[MASTER:{$clientId}]</error> Sending request to child");
                 $childStream->write($data);
             });
             $clientConnection->resume();
         });
     });
     $output->writeln("<error>[MASTER]</error> Starting server on {$bindMasterTo['host']}:{$bindMasterTo['port']}");
     $socketServer->listen($bindMasterTo['port'], $bindMasterTo['host']);
     $loop->addPeriodicTimer(1.0, [$this, 'checkThreads']);
     $loop->run();
 }
Ejemplo n.º 30
0
<?php

require __DIR__ . '/../vendor/autoload.php';
use Crunch\FastCGI\Client\Client;
use Crunch\FastCGI\Client\ClientException;
use Crunch\FastCGI\Client\Factory as FastCGIClientFactory;
use Crunch\FastCGI\Protocol\RequestParameters;
use React\Dns\Resolver\Factory as DnsResolverFactory;
use React\EventLoop\Factory as EventLoopFactory;
use React\SocketClient\Connector as SocketConnector;
use React\Promise as promise;
$loop = EventLoopFactory::create();
$dnsResolverFactory = new DnsResolverFactory();
$dns = $dnsResolverFactory->createCached('0.0.0.0', $loop);
$connector = new SocketConnector($loop, $dns);
$factory = new FastCGIClientFactory($loop, $connector);
$factory->createClient('127.0.0.1', 1337)->then(function (Client $client) use($argv) {
    $name = @$argv[1] ?: 'World';
    $data = "name={$name}";
    $request = $client->newRequest(new RequestParameters(['REQUEST_METHOD' => 'POST', 'SCRIPT_FILENAME' => __DIR__ . '/docroot/hello-world.php', 'CONTENT_TYPE' => 'application/x-www-form-urlencoded', 'CONTENT_LENGTH' => strlen($data)]), new \Crunch\FastCGI\ReaderWriter\StringReader($data));
    $request2 = $client->newRequest(new RequestParameters(['REQUEST_METHOD' => 'POST', 'SCRIPT_FILENAME' => __DIR__ . '/docroot/hello-world.php', 'CONTENT_TYPE' => 'application/x-www-form-urlencoded', 'CONTENT_LENGTH' => strlen($data)]), new \Crunch\FastCGI\ReaderWriter\StringReader($data));
    $responseHandler = function ($response) use($client) {
        echo "\n" . $response->getContent()->read() . \PHP_EOL;
    };
    $failHandler = function (ClientException $fail) {
        echo "Request failed: {$fail->getMessage()}";
        return $fail;
    };
    $x = $client->sendRequest($request)->then($responseHandler, $failHandler);
    $y = $client->sendRequest($request2)->then($responseHandler, $failHandler);
    $z = $client->sendRequest($request2)->then($responseHandler, $failHandler);