EventStore\Http\GuzzleHttpClient

Complexity

Total Complexity

11

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	11

Test Coverage

Coverage

48.48%

Importance

Changes	4
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	send()	0	10	3
A	__construct()	0	6	2
A	withFilesystemCache()	0	6	1
A	withApcCache()	0	6	1
A	withDoctrineCache()	0	21	1
A	sendRequestBatch()	0	15	3

<?php
namespace EventStore\Http;

use Doctrine\Common\Cache\ApcCache;
use Doctrine\Common\Cache\Cache;
use Doctrine\Common\Cache\FilesystemCache;
use Exception as PhpException;
use GuzzleHttp\Client;
use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\ClientException as GuzzleClientException;
use GuzzleHttp\Exception\RequestException as GuzzleRequestException;
use GuzzleHttp\Handler\CurlMultiHandler;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Pool;
use Kevinrob\GuzzleCache\CacheMiddleware;
use Kevinrob\GuzzleCache\Storage\DoctrineCacheStorage;
use Kevinrob\GuzzleCache\Strategy\PublicCacheStrategy;
use Psr\Http\Message\RequestInterface;

final class GuzzleHttpClient implements HttpClientInterface
{
    public function __construct(ClientInterface $client = null)
    {
        $this->client = $client ?: new Client([

The property client does not exist. Did you maybe forget to declare it?

            'handler' => new CurlMultiHandler(),
        ]);
    }

    public static function withFilesystemCache($path)
    {
        return self::withDoctrineCache(
            new FilesystemCache($path)
        );
    }

    public static function withApcCache()
    {
        return self::withDoctrineCache(
            new ApcCache()

The class Doctrine\Common\Cache\ApcCache has been deprecated with message: since version 1.6, use ApcuCache instead

        );
    }

    public static function withDoctrineCache(Cache $doctrineCache)
    {
        $stack = new HandlerStack(new CurlMultiHandler());

        $stack->push(
            new CacheMiddleware(
                new PublicCacheStrategy(
                    new DoctrineCacheStorage(
                        $doctrineCache
                    )
                )
            ),
          'cache'
        );

        $client = new Client([
            'handler' => $stack
        ]);

        return new self($client);
    }

    public function sendRequestBatch(array $requests)
    {
        $responses = Pool::batch(
            $this->client,
            $requests
        );

        foreach ($responses as $response) {
            if ($response instanceof PhpException) {
                throw $response;
            }
        }

        return $responses;
    }

    public function send(RequestInterface $request)
    {
        try {
            return $this->client->send($request);
        } catch (GuzzleClientException $e) {
            throw new Exception\ClientException($e->getMessage(), $e->getCode(), $e);
        } catch (GuzzleRequestException $e) {
            throw new Exception\RequestException($e->getMessage(), $e->getCode(), $e);
        }
    }
}