GroupByInc\API\AbstractBridge

Complexity

Total Complexity

20

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	6
Bugs	1	Features	4

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	search()	0	6	1
A	refinements()	0	6	1
C	query()	0	37	7
A	execute()	0	11	3
A	getContentEncoding()	0	11	3
A	deserialize()	0	10	2
A	setConnectTimeout()	0	5	1
A	setTimeout()	0	5	1

<?php

namespace GroupByInc\API;

use Exception;
use GroupByInc\API\Util\SerializerFactory;
use GroupByInc\API\Util\UriBuilder;
use Httpful\Mime;
use Httpful\Request;
use Httpful\Response;
use JMS\Serializer\Serializer;
use RuntimeException;

abstract class AbstractBridge
{
    const SEARCH = '/search';
    const CLUSTER = '/cluster';
    const REFINEMENTS = '/refinements';
    const RESULTS_CLASS = 'GroupByInc\API\Model\Results';
    const REFINEMENTS_RESULT_CLASS = 'GroupByInc\API\Model\RefinementsResult';
    const HTTP = 'http://';
    const HTTPS = 'https://';
    const COLON = ':';
    const MAX_TRIES = 3;
    const RETRY_TIMEOUT = 80000;
    const DEFAULT_TIMEOUT = 30;
    const DEFAULT_CONNECT_TIMEOUT = 15;

    /** @var string */
    private $clientKey;
    /** @var string */
    private $bridgeUrl;
    /** @var string */
    private $bridgeUrlCluster;
    /** @var string */
    private $bridgeRefinementsUrl;
    /** @var Serializer */
    private $serializer;
    /** @var int */
    private $timeout;
    /** @var int */
    private $connectTimeout;

    /**
     * @param string $clientKey
     * @param string $baseUrl
     */
    function __construct($clientKey, $baseUrl)

It is generally recommended to explicitly declare the visibility for methods.

    {
        $this->clientKey = $clientKey;
        $this->bridgeUrl = $baseUrl . self::SEARCH;
        $this->bridgeUrlCluster = $baseUrl . self::CLUSTER;
        $this->bridgeRefinementsUrl = $baseUrl . self::SEARCH . self::REFINEMENTS;

        $this->serializer = SerializerFactory::build();
    }

    /**
     * @param Query $query
     *
     * @return mixed
     */
    public function search($query)
    {
        $content = $query->getBridgeJson($this->clientKey);

        return $this->query($this->bridgeUrl, $content, self::RESULTS_CLASS);
    }

    /**
     * @param Query  $query
     * @param string $navigationName
     *
     * @return mixed
     */
    public function refinements($query, $navigationName)
    {
        $content = $query->getBridgeRefinementsJson($this->clientKey, $navigationName);

        return $this->query($this->bridgeRefinementsUrl, $content, self::REFINEMENTS_RESULT_CLASS);
    }

    /**
     * @param string $url
     * @param string $content
     * @param string $class
     *
     * @return mixed
     */
    private function query($url, $content, $class)
    {
        $response = null;
        $tries = 0;
        $lastError = null;

        while ($tries < self::MAX_TRIES) {
            try {
                $response = $this->execute($url, $content, $tries);
                break;
            } catch (Exception $e) {
                usleep(self::RETRY_TIMEOUT);
                error_log('Connection failed, retrying');
                $lastError = $e;
                $tries++;
            }
        }

        if ($tries == self::MAX_TRIES) {
            throw new RuntimeException("Error: call to URL $url failed after " . self::MAX_TRIES . " tries", 0, $lastError);
        }

        if ($response->hasErrors()) {
            throw new RuntimeException("Error: call to URL $url failed with status $response->code, response $response");
        }

        if ($response->content_type !== Mime::JSON) {
            throw new RuntimeException("Error: bridge at URL $url did not return the expected JSON response, it returned: " . $response->content_type . " instead");
        }

        $responseBody = $response->raw_body;
        if (strpos($this->getContentEncoding($response), 'gzip') !== FALSE) {
            $responseBody = gzdecode($responseBody);
        }

        return $this->deserialize($responseBody, $class);
    }

    /**
     * @param string $url
     * @param string $content
     * @param int    $tries
     *
     * @return Response
     */
    protected function execute($url, $content, $tries)
    {
        echo "sending request $content to $url";

        return Request::post($url . "?retry=$tries")
            ->body($content)
            ->timeout(isset($this->timeout) ? $this->timeout : self::DEFAULT_TIMEOUT)
            ->addOnCurlOption(CURLOPT_CONNECTTIMEOUT, isset($this->connectTimeout) ? $this->connectTimeout : self::DEFAULT_CONNECT_TIMEOUT)
            ->sendsType(Mime::JSON)
            ->send();
    }

    /**
     * @param Response $response
     *
     * @return bool|string
     */
    private function getContentEncoding($response)
    {
        $headers = $response->headers;
        foreach ($headers as $header) {

The expression $headers of type object<Httpful\Response\Headers> is not traversable.

            list($k, $v) = explode(':', $header);
            if ('content-encoding' == strtolower($k)) {
                return trim($v);
            }
        }
        return false;
    }

    private function deserialize($json, $class)
    {
        $object = null;
        try {
            $object = $this->serializer->deserialize($json, $class, 'json');
        } catch (RuntimeException $e) {
            error_log("deserialization failed with exception $e");
        }
        return $object;
    }

    /**
     * @param int $connectTimeout seconds
     * @return $this
     */
    public function setConnectTimeout($connectTimeout)
    {
        $this->connectTimeout = $connectTimeout;
        return $this;
    }

    /**
     * @param int $timeout seconds
     * @return $this
     */
    public function setTimeout($timeout)
    {
        $this->timeout = $timeout;
        return $this;
    }

}