Ivory\HttpAdapter\CurlHttpAdapter

Complexity

Total Complexity

27

Size/Duplication

Total Lines	192
Duplicated Lines	4.17 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

5.09%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getName()	0	4	1
A	sendInternalRequest()	0	16	2
B	sendInternalRequests()	0	39	6
D	createCurl()	8	46	10
A	configureTimeout()	0	8	2
A	createResponse()	0	19	2
A	resolveInternalRequest()	0	10	3

<?php

/*
 * This file is part of the Ivory Http Adapter package.
 *
 * (c) Eric GELOEN <geloen.eric@gmail.com>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Ivory\HttpAdapter;

use Ivory\HttpAdapter\Extractor\ProtocolVersionExtractor;
use Ivory\HttpAdapter\Extractor\StatusCodeExtractor;
use Ivory\HttpAdapter\Message\InternalRequestInterface;
use Ivory\HttpAdapter\Message\RequestInterface;
use Ivory\HttpAdapter\Message\ResponseInterface;
use Ivory\HttpAdapter\Normalizer\BodyNormalizer;
use Ivory\HttpAdapter\Normalizer\HeadersNormalizer;

/**
 * @author GeLo <geloen.eric@gmail.com>
 */
class CurlHttpAdapter extends AbstractCurlHttpAdapter
{
    /**
     * @param ConfigurationInterface|null $configuration
     */
    public function __construct(ConfigurationInterface $configuration = null)
    {
        parent::__construct($configuration);
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return 'curl';
    }

    /**
     * {@inheritdoc}
     */
    protected function sendInternalRequest(InternalRequestInterface $internalRequest)
    {
        $curl = $this->createCurl($internalRequest);

        try {
            $response = $this->createResponse($curl, curl_exec($curl), $internalRequest);
        } catch (HttpAdapterException $e) {
            curl_close($curl);

            throw $e;
        }

        curl_close($curl);

        return $response;
    }

    /**
     * {@inheritdoc}
     */
    protected function sendInternalRequests(array $internalRequests, $success, $error)
    {
        $curlMulti = curl_multi_init();

        $contexts = [];
        foreach ($internalRequests as $internalRequest) {
            $contexts[] = [
                'curl'    => $curl = $this->createCurl($internalRequest),
                'request' => $internalRequest,
            ];

            curl_multi_add_handle($curlMulti, $curl);
        }

        do {
            do {
                $exec = curl_multi_exec($curlMulti, $running);
            } while ($exec === CURLM_CALL_MULTI_PERFORM);

            while ($done = curl_multi_info_read($curlMulti)) {
                $curl = $done['handle'];
                $internalRequest = $this->resolveInternalRequest($curl, $contexts);

                try {
                    $response = $this->createResponse($curl, curl_multi_getcontent($curl), $internalRequest);
                    $response = $response->withParameter('request', $internalRequest);
                    call_user_func($success, $response);
                } catch (HttpAdapterException $e) {
                    $e->setRequest($internalRequest);
                    call_user_func($error, $e);
                }

                curl_multi_remove_handle($curlMulti, $curl);
                curl_close($curl);
            }
        } while ($running);

        curl_multi_close($curlMulti);
    }

    /**
     * @param InternalRequestInterface $internalRequest
     *
     * @return resource
     */
    private function createCurl(InternalRequestInterface $internalRequest)
    {
        $curl = curl_init();

        curl_setopt($curl, CURLOPT_URL, (string) $internalRequest->getUri());
        curl_setopt($curl, CURLOPT_FOLLOWLOCATION, false);
        curl_setopt($curl, CURLOPT_HTTP_VERSION, $this->prepareProtocolVersion($internalRequest));
        curl_setopt($curl, CURLOPT_HEADER, true);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curl, CURLOPT_HTTPHEADER, $this->prepareHeaders($internalRequest, false, false));

        $this->configureTimeout($curl, 'CURLOPT_TIMEOUT');
        $this->configureTimeout($curl, 'CURLOPT_CONNECTTIMEOUT');

        $files = $internalRequest->getFiles();

        if (!empty($files) && $this->isSafeUpload()) {
            curl_setopt($curl, CURLOPT_SAFE_UPLOAD, true);
        }

        switch ($internalRequest->getMethod()) {
            case RequestInterface::METHOD_HEAD:
                curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $internalRequest->getMethod());
                curl_setopt($curl, CURLOPT_NOBODY, true);
                break;

            case RequestInterface::METHOD_TRACE:
                curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $internalRequest->getMethod());
                break;

            case RequestInterface::METHOD_POST:

This code seems to be duplicated across your project.

                curl_setopt($curl, CURLOPT_POST, true);
                curl_setopt($curl, CURLOPT_POSTFIELDS, $this->prepareContent($internalRequest));
                break;

            case RequestInterface::METHOD_PUT:
            case RequestInterface::METHOD_PATCH:
            case RequestInterface::METHOD_DELETE:
            case RequestInterface::METHOD_OPTIONS:

This code seems to be duplicated across your project.

                curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $internalRequest->getMethod());
                curl_setopt($curl, CURLOPT_POSTFIELDS, $this->prepareContent($internalRequest));
                break;
        }

        return $curl;
    }

    /**
     * @param resource $curl
     * @param string   $type
     */
    private function configureTimeout($curl, $type)
    {
        if (defined($type.'_MS')) {
            curl_setopt($curl, constant($type.'_MS'), $this->getConfiguration()->getTimeout() * 1000);
        } else { // @codeCoverageIgnoreStart
            curl_setopt($curl, constant($type), $this->getConfiguration()->getTimeout());
        } // @codeCoverageIgnoreEnd
    }

    /**
     * @param resource                 $curl
     * @param string|bool|null         $data
     * @param InternalRequestInterface $internalRequest
     *
     * @throws HttpAdapterException
     *
     * @return ResponseInterface
     */
    private function createResponse($curl, $data, InternalRequestInterface $internalRequest)
    {
        if (empty($data)) {
            throw HttpAdapterException::cannotFetchUri(
                (string) $internalRequest->getUri(),
                $this->getName(),
                curl_error($curl)
            );
        }

        $headers = substr($data, 0, $headersSize = curl_getinfo($curl, CURLINFO_HEADER_SIZE));

        return $this->getConfiguration()->getMessageFactory()->createResponse(
            StatusCodeExtractor::extract($headers),
            ProtocolVersionExtractor::extract($headers),
            HeadersNormalizer::normalize($headers),
            BodyNormalizer::normalize(substr($data, $headersSize), $internalRequest->getMethod())
        );
    }

    /**
     * @param resource $curl
     * @param array    $contexts
     *
     * @return InternalRequestInterface
     */
    private function resolveInternalRequest($curl, array $contexts)
    {
        foreach ($contexts as $context) {
            if ($context['curl'] === $curl) {
                break;
            }
        }

        return $context['request'];

The variable $context seems to be defined by a foreach iteration on line 208. Are you sure the iterator is never empty, otherwise this variable is not defined?

    }
}