PHP Classes

File: application/modules/extensions/aws/Aws/Handler/GuzzleV5/GuzzleHandler.php

Recommend this page to a friend!
  Classes of Tran Tuan   Pretty PHP S3 Files Manager   application/modules/extensions/aws/Aws/Handler/GuzzleV5/GuzzleHandler.php   Download  
File: application/modules/extensions/aws/Aws/Handler/GuzzleV5/GuzzleHandler.php
Role: Application script
Content type: text/plain
Description: Application script
Class: Pretty PHP S3 Files Manager
Web based interface to manage files in Amazon S3
Author: By
Last change:
Date: 8 years ago
Size: 5,395 bytes
 

Contents

Class file image Download
<?php
namespace Aws\Handler\GuzzleV5;

use
Aws\Sdk;
use
Exception;
use
GuzzleHttp\Client;
use
GuzzleHttp\ClientInterface;
use
GuzzleHttp\Exception\ConnectException;
use
GuzzleHttp\Exception\RequestException;
use
GuzzleHttp\Message\ResponseInterface as GuzzleResponse;
use
GuzzleHttp\Promise;
use
GuzzleHttp\Psr7\Response as Psr7Response;
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,
       
'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
     */
   
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) {
               
// Reject with information about the error.
               
return new Promise\RejectedPromise($this->prepareErrorData($exception));
            }
        );
    }

    private function
createGuzzleRequest(Psr7Request $psrRequest, array $options)
    {
       
$ringConfig = [];

       
// 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
       
);

       
// 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;
    }
}