Viewing file:  GuzzleHandler.php (6.63 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
<?php
namespace Aws\Handler\GuzzleV5;
use Exception;
use GuzzleHttp\Client;
use GuzzleHttp\ClientInterface;
use GuzzleHttp\Event\EndEvent;
use GuzzleHttp\Exception\ConnectException;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Message\ResponseInterface as GuzzleResponse;
use GuzzleHttp\Promise;
use GuzzleHttp\Psr7\Response as Psr7Response;
use GuzzleHttp\Stream\Stream;
use Psr\Http\Message\RequestInterface as Psr7Request;
use Psr\Http\Message\StreamInterface as Psr7StreamInterface;
/**
* A request handler that sends PSR-7-compatible requests with Guzzle 5.
*
* The handler accepts a PSR-7 Request object and an array of transfer options
* and returns a Guzzle 6 Promise. The promise is either resolved with a
* PSR-7 Response object or rejected with an array of error data.
*
* @codeCoverageIgnore
*/
class GuzzleHandler
{
private static $validOptions = [
'proxy' => true,
'expect' => true,
'cert' => true,
'verify' => true,
'timeout' => true,
'debug' => true,
'connect_timeout' => true,
'stream' => true,
'delay' => true,
'sink' => true,
];
/** @var ClientInterface */
private $client;
/**
* @param ClientInterface $client
*/
public function __construct(ClientInterface $client = null)
{
$this->client = $client ?: new Client();
}
/**
* @param Psr7Request $request
* @param array $options
* @return Promise\Promise|Promise\PromiseInterface
* @throws \GuzzleHttp\Exception\GuzzleException
*/
public function __invoke(Psr7Request $request, array $options = [])
{
// Create and send a Guzzle 5 request
$guzzlePromise = $this->client->send(
$this->createGuzzleRequest($request, $options)
);
$promise = new Promise\Promise(
function () use ($guzzlePromise) {
try {
$guzzlePromise->wait();
} catch (\Exception $e) {
// The promise is already delivered when the exception is
// thrown, so don't rethrow it.
}
},
[$guzzlePromise, 'cancel']
);
$guzzlePromise->then([$promise, 'resolve'], [$promise, 'reject']);
return $promise->then(
function (GuzzleResponse $response) {
// Adapt the Guzzle 5 Future to a Guzzle 6 ResponsePromise.
return $this->createPsr7Response($response);
},
function (Exception $exception) use ($options) {
// If we got a 'sink' that's a path, set the response body to
// the contents of the file. This will build the resulting
// exception with more information.
if ($exception instanceof RequestException) {
if (isset($options['sink'])) {
if (!($options['sink'] instanceof Psr7StreamInterface)) {
$exception->getResponse()->setBody(
Stream::factory(
file_get_contents($options['sink'])
)
);
}
}
}
// Reject with information about the error.
return new Promise\RejectedPromise($this->prepareErrorData($exception));
}
);
}
private function createGuzzleRequest(Psr7Request $psrRequest, array $options)
{
$ringConfig = [];
$statsCallback = isset($options['http_stats_receiver'])
? $options['http_stats_receiver']
: null;
unset($options['http_stats_receiver']);
// Remove unsupported options.
foreach (array_keys($options) as $key) {
if (!isset(self::$validOptions[$key])) {
unset($options[$key]);
}
}
// Handle delay option.
if (isset($options['delay'])) {
$ringConfig['delay'] = $options['delay'];
unset($options['delay']);
}
// Prepare sink option.
if (isset($options['sink'])) {
$ringConfig['save_to'] = ($options['sink'] instanceof Psr7StreamInterface)
? new GuzzleStream($options['sink'])
: $options['sink'];
unset($options['sink']);
}
// Ensure that all requests are async and lazy like Guzzle 6.
$options['future'] = 'lazy';
// Create the Guzzle 5 request from the provided PSR7 request.
$request = $this->client->createRequest(
$psrRequest->getMethod(),
$psrRequest->getUri(),
$options
);
if (is_callable($statsCallback)) {
$request->getEmitter()->on(
'end',
function (EndEvent $event) use ($statsCallback) {
$statsCallback($event->getTransferInfo());
}
);
}
// For the request body, adapt the PSR stream to a Guzzle stream.
$body = $psrRequest->getBody();
if ($body->getSize() === 0) {
$request->setBody(null);
} else {
$request->setBody(new GuzzleStream($body));
}
$request->setHeaders($psrRequest->getHeaders());
$request->setHeader(
'User-Agent',
$request->getHeader('User-Agent')
. ' ' . Client::getDefaultUserAgent()
);
// Make sure the delay is configured, if provided.
if ($ringConfig) {
foreach ($ringConfig as $k => $v) {
$request->getConfig()->set($k, $v);
}
}
return $request;
}
private function createPsr7Response(GuzzleResponse $response)
{
if ($body = $response->getBody()) {
$body = new PsrStream($body);
}
return new Psr7Response(
$response->getStatusCode(),
$response->getHeaders(),
$body,
$response->getReasonPhrase()
);
}
private function prepareErrorData(Exception $e)
{
$error = [
'exception' => $e,
'connection_error' => false,
'response' => null,
];
if ($e instanceof ConnectException) {
$error['connection_error'] = true;
}
if ($e instanceof RequestException && $e->getResponse()) {
$error['response'] = $this->createPsr7Response($e->getResponse());
}
return $error;
}
}
|