/**
* {@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()));
}
/**
* @return Client
*/
public function getHttpClient()
{
if (!$this->http_client) {
$factory = new HttpClientFactory();
$this->http_client = $factory->create($this->getLoop(), $this->getDns());
}
return $this->http_client;
}
/**
* Build a React Http Client.
*
* @param LoopInterface $loop
* @param DnsResolver $dns
*
* @return HttpClient
*/
public static function buildHttpClient(LoopInterface $loop, DnsResolver $dns = null)
{
if (null === $dns) {
$dns = self::buildDnsResolver($loop);
}
$factory = new HttpClientFactory();
return $factory->create($loop, $dns);
}
/**
* Initialize the React client
* @param LoopInterface|null $loop React Event loop
* @param Resolver $resolver React async DNS resolver
*/
public function __construct(LoopInterface $loop, Resolver $resolver, MessageFactory $messageFactory)
{
$this->loop = $loop;
$this->resolver = $resolver;
$this->messageFactory = $messageFactory;
$factory = new Factory();
$this->client = $factory->create($loop, $resolver);
}
/**
* @param HttpClient $httpClient
*/
public function setHttpClient(HttpClient $httpClient = null)
{
if (!$httpClient instanceof HttpClient) {
$this->setDnsResolver($this->dnsResolver);
$factory = new HttpClientFactory();
$httpClient = $factory->create($this->loop, $this->dnsResolver);
}
$this->httpClient = $httpClient;
}
/**
* 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;
}
/**
* @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);
}
<?php
use React\HttpClient\Factory;
use React\HttpClient\Response;
require __DIR__ . '/../vendor/autoload.php';
$loop = React\EventLoop\Factory::create();
$resolverFactory = new React\Dns\Resolver\Factory();
$resolver = $resolverFactory->create('8.8.8.8', $loop);
$factory = new Factory();
$client = $factory->create($loop, $resolver);
$request = $client->request('GET', 'https://google.com/');
$request->on('response', function (Response $response) {
var_dump($response->getHeaders());
$response->on('data', function ($chunk) {
echo $chunk;
});
$response->on('end', function () {
echo 'DONE' . PHP_EOL;
});
});
$request->end();
$loop->run();
