Commercetools\Core\Client\Adapter\Guzzle5Adapter

Complexity

Total Complexity

25

Size/Duplication

Total Lines	261
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	authenticate()	0	21	2
A	setCorrelationIdProvider()	0	3	1
A	execute()	0	20	3
B	__construct()	0	27	4
A	getBatchHttpRequests()	0	22	2
A	setOAuthTokenProvider()	0	3	1
A	getEmitter()	0	3	1
A	setLogger()	0	5	2
A	getAdapterInfo()	0	3	1
B	executeAsync()	0	27	2
A	packResponse()	0	9	2
A	addHandler()	0	3	1
A	executeBatch()	0	21	3

<?php
/**
 * @author @jenschude <jens.schulze@commercetools.de>
 */

namespace Commercetools\Core\Client\Adapter;

use Commercetools\Core\Client\OAuth\TokenProvider;
use Commercetools\Core\Helper\CorrelationIdProvider;
use Commercetools\Core\Helper\Subscriber\CorrelationIdSubscriber;
use Commercetools\Core\Helper\Subscriber\TokenSubscriber;
use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Pool;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Response;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Log\LoggerInterface;
use Commercetools\Core\Helper\Subscriber\Log\LogSubscriber;
use Commercetools\Core\Error\ApiException;
use Psr\Log\LogLevel;

class Guzzle5Adapter implements AdapterOptionInterface, CorrelationIdAware, TokenProviderAware
{
    const DEFAULT_CONCURRENCY = 25;

    /**
     * @var Client
     */
    protected $client;

    /**
     * @var LoggerInterface
     */
    protected $logger;

    private $concurrency;

    /**
     * @param array $options
     */
    public function __construct(array $options = [])
    {
        if (isset($options['base_uri'])) {
            $options['base_url'] = $options['base_uri'];
            unset($options['base_uri']);
        }
        if (isset($options['concurrency'])) {
            $options['pool_size'] = $options['concurrency'];
            unset($options['concurrency']);
        }
        if (isset($options['headers'])) {
            $options['defaults']['headers'] = $options['headers'];
            unset($options['headers']);
        }
        $options = array_merge(
            [
                'allow_redirects' => false,
                'verify' => true,
                'timeout' => 60,
                'connect_timeout' => 10,
                'pool_size' => self::DEFAULT_CONCURRENCY
            ],
            $options
        );
        $this->concurrency = $options['pool_size'];

        $this->client = new Client($options);
    }

    public function setLogger(LoggerInterface $logger, $logLevel = LogLevel::INFO, $formatter = null)
    {
        $this->logger = $logger;
        if ($logger instanceof LoggerInterface) {

The condition $logger instanceof Psr\Log\LoggerInterface can never be false since $logger is always a sub-type of Psr\Log\LoggerInterface.

            $this->getEmitter()->attach(new LogSubscriber($logger, $formatter, $logLevel));
        }
    }

    public function addHandler($handler)
    {
        $this->getEmitter()->attach($handler);
    }

    public function setCorrelationIdProvider(CorrelationIdProvider $provider)
    {
        $this->addHandler(new CorrelationIdSubscriber($provider));
    }

    public function setOAuthTokenProvider(TokenProvider $tokenProvider)
    {
        $this->addHandler(new TokenSubscriber($tokenProvider));
    }

    /**
     * @internal
     * @return \GuzzleHttp\Event\Emitter|\GuzzleHttp\Event\EmitterInterface

The type GuzzleHttp\Event\Emitter was not found. Maybe you did not declare it correctly or list all dependencies?

The type GuzzleHttp\Event\EmitterInterface was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function getEmitter()
    {
        return $this->client->getEmitter();

The expression return $this->client->getEmitter() also could return the type GuzzleHttp\Promise\PromiseInterface which is incompatible with the documented return type GuzzleHttp\Event\EmitterInterface|GuzzleHttp\Event\Emitter.

    }

    /**
     * @param RequestInterface $request
     * @param array $clientOptions
     * @return ResponseInterface
     * @throws \Commercetools\Core\Error\ApiException
     * @throws \Commercetools\Core\Error\BadGatewayException
     * @throws \Commercetools\Core\Error\ConcurrentModificationException
     * @throws \Commercetools\Core\Error\ErrorResponseException
     * @throws \Commercetools\Core\Error\GatewayTimeoutException
     * @throws \Commercetools\Core\Error\InternalServerErrorException
     * @throws \Commercetools\Core\Error\InvalidTokenException
     * @throws \Commercetools\Core\Error\NotFoundException
     * @throws \Commercetools\Core\Error\ServiceUnavailableException
     */
    public function execute(RequestInterface $request, array $clientOptions = [])
    {
        $options = [
            'headers' => $request->getHeaders(),
            'body' => (string)$request->getBody()
        ];
        if (count($clientOptions)) {
            $options = array_merge($options, $clientOptions);
        }

        try {
            $guzzleRequest = $this->client->createRequest($request->getMethod(), (string)$request->getUri(), $options);
            $guzzleResponse = $this->client->send($guzzleRequest);

It seems like $guzzleRequest can also be of type GuzzleHttp\Promise\PromiseInterface; however, parameter $request of GuzzleHttp\Client::send() does only seem to accept Psr\Http\Message\RequestInterface, maybe add an additional type check?

            $response = $this->packResponse($guzzleResponse);
        } catch (RequestException $exception) {
            $response = $this->packResponse($exception->getResponse());
            throw ApiException::create($request, $response, $exception);
        }

        return $response;
    }

    protected function packResponse(\GuzzleHttp\Message\ResponseInterface $response = null)

The type GuzzleHttp\Message\ResponseInterface was not found. Maybe you did not declare it correctly or list all dependencies?

    {
        if (!$response instanceof \GuzzleHttp\Message\ResponseInterface) {
            return null;
        }
        return new Response(
            $response->getStatusCode(),
            $response->getHeaders(),
            (string)$response->getBody()
        );
    }

    /**
     * @param RequestInterface[] $requests
     * @param array $clientOptions
     * @return \Psr\Http\Message\ResponseInterface[]
     * @throws \Commercetools\Core\Error\ApiException
     * @throws \Commercetools\Core\Error\BadGatewayException
     * @throws \Commercetools\Core\Error\ConcurrentModificationException
     * @throws \Commercetools\Core\Error\ErrorResponseException
     * @throws \Commercetools\Core\Error\GatewayTimeoutException
     * @throws \Commercetools\Core\Error\InternalServerErrorException
     * @throws \Commercetools\Core\Error\InvalidTokenException
     * @throws \Commercetools\Core\Error\NotFoundException
     * @throws \Commercetools\Core\Error\ServiceUnavailableException
     */
    public function executeBatch(array $requests, array $clientOptions = [])
    {
        $results = Pool::batch(
            $this->client,
            $this->getBatchHttpRequests($requests, $clientOptions),
            ['pool_size' => $this->concurrency]
        );

        $responses = [];
        foreach ($results as $key => $result) {
            if (!$result instanceof RequestException) {
                $response = $this->packResponse($result);
            } else {
                $httpResponse = $this->packResponse($result->getResponse());
                $request = $requests[$key];
                $response = ApiException::create($request, $httpResponse, $result);
            }
            $responses[$key] = $response;
        }

        return $responses;
    }

    /**
     * @param array $requests
     * @param array $clientOptions
     * @return array
     */
    protected function getBatchHttpRequests(array $requests, array $clientOptions = [])
    {
        $requests = array_map(
            function ($request) use ($clientOptions) {
                $options = ['headers' => $request->getHeaders()];
                if (count($clientOptions)) {
                    $options = array_merge($options, $clientOptions);
                }

                /**
                 * @var RequestInterface $request
                 */
                return $this->client->createRequest(
                    $request->getMethod(),
                    (string)$request->getUri(),
                    $options
                );
            },
            $requests
        );

        return $requests;
    }

    /**
     * @param $oauthUri
     * @param $clientId
     * @param $clientSecret
     * @param $formParams
     * @return ResponseInterface
     */
    public function authenticate($oauthUri, $clientId, $clientSecret, $formParams)
    {
        $options = [
            'body' => $formParams,
            'auth' => [$clientId, $clientSecret]
        ];

        try {
            $response = $this->client->post($oauthUri, $options);
        } catch (RequestException $exception) {
            $authRequest = $exception->getRequest();
            $request = new Request(
                $authRequest->getMethod(),
                $authRequest->getUrl(),

The method getUrl() does not exist on Psr\Http\Message\RequestInterface. Did you maybe mean getUri()?

                $authRequest->getHeaders(),
                (string)$authRequest->getBody()
            );
            $response = $this->packResponse($exception->getResponse());
            throw ApiException::create($request, $response, $exception);
        }
        return $response;
    }

    /**
     * @param RequestInterface $request
     * @param array $clientOptions
     * @return AdapterPromiseInterface
     */
    public function executeAsync(RequestInterface $request, array $clientOptions = [])
    {
        $options = [
            'future' => true,
            'exceptions' => false,
            'headers' => $request->getHeaders()
        ];
        if (count($clientOptions)) {
            $options = array_merge($options, $clientOptions);
        }
        $request = $this->client->createRequest($request->getMethod(), (string)$request->getUri(), $options);
        $guzzlePromise = $this->client->send($request, $options);

It seems like $request can also be of type GuzzleHttp\Promise\PromiseInterface; however, parameter $request of GuzzleHttp\Client::send() does only seem to accept Psr\Http\Message\RequestInterface, maybe add an additional type check?

        $promise = new Guzzle5Promise($guzzlePromise);
        $promise->then(
            function (\GuzzleHttp\Message\ResponseInterface $response) {
                return new Response(
                    $response->getStatusCode(),
                    $response->getHeaders(),
                    (string)$response->getBody(),
                    $response->getProtocolVersion(),
                    $response->getReasonPhrase()
                );
            }
        );

        return $promise;
    }

    public static function getAdapterInfo()
    {
        return 'GuzzleHttp/' . Client::VERSION;
    }
}