MultiHttp\Request

Complexity

Total Complexity

76

Size/Duplication

Total Lines	452
Duplicated Lines	1.55 %

Coupling/Cohesion

Components	7
Dependencies	4

Test Coverage

Coverage

86.34%

Importance

Changes

0

40 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	create()	0	4	1
A	setLogger()	0	4	1
A	timeout()	0	5	1
A	noFollow()	0	4	1
A	follow()	0	6	1
A	endCallback()	0	4	1
A	hasEndCallback()	0	4	1
A	uri()	0	5	1
A	hasCert()	0	4	2
A	cert()	0	8	1
A	body()	0	9	1
A	mime()	0	9	3
A	addHeader()	0	5	1
A	addHeaders()	0	7	2
A	expectsType()	0	4	1
A	sendType()	0	4	1
A	expects()	0	6	2
A	getIni()	0	5	2
A	optionAlias()	0	10	4
A	addQuery()	0	13	4
A	post()	0	4	1
A	quickPost()	0	5	1
A	ini()	7	7	1
A	addOptions()	0	6	1
A	put()	0	4	1
A	patch()	0	4	1
A	get()	0	4	1
A	quickGet()	0	5	1
A	options()	0	4	1
A	head()	0	4	1
A	delete()	0	4	1
A	trace()	0	4	1
A	send()	0	11	3
A	applyOptions()	0	8	1
F	prepare()	0	66	17
A	onEnd()	0	9	2
A	filterAndRaw()	0	13	3
A	makeResponse()	0	22	3
A	log()	0	9	2

<?php
/**
 *
 * @author  qiangjian@staff.sina.com.cn sunsky303@gmail.com
 * Date: 2017/6/16
 * Time: 10:02
 * @version $Id: $
 * @since 1.0
 * @copyright Sina Corp.
 */

namespace MultiHttp;

use MultiHttp\Exception\InvalidArgumentException;

class Request extends Http
{
    const MAX_REDIRECTS_DEFAULT = 10;
    protected static $curlAlias = array(
        'url' => 'CURLOPT_URL',
        'uri' => 'CURLOPT_URL',
        'debug' => 'CURLOPT_VERBOSE',//for debug verbose
        'method' => 'CURLOPT_CUSTOMREQUEST',
        'data' => 'CURLOPT_POSTFIELDS', // array or string , file begin with '@'
        'ua' => 'CURLOPT_USERAGENT',
        'timeout' => 'CURLOPT_TIMEOUT', // (secs) 0 means indefinitely
        'connect_timeout' => 'CURLOPT_CONNECTTIMEOUT',
        'referer' => 'CURLOPT_REFERER',
        'binary' => 'CURLOPT_BINARYTRANSFER',
        'port' => 'CURLOPT_PORT',
        'header' => 'CURLOPT_HEADER', // TRUE:include header
        'headers' => 'CURLOPT_HTTPHEADER', // array
        'download' => 'CURLOPT_FILE', // writing file stream (using fopen()), default is STDOUT
        'upload' => 'CURLOPT_INFILE', // reading file stream
        'transfer' => 'CURLOPT_RETURNTRANSFER', // TRUE:return string; FALSE:output directly (curl_exec)
        'follow_location' => 'CURLOPT_FOLLOWLOCATION',
        'timeout_ms' => 'CURLOPT_TIMEOUT_MS', // milliseconds,  libcurl version > 7.36.0 ,
    );
    protected static $logger;
    public $curlHandle;
    public
        $uri,

It is generally advisable to only define one property per statement.

The visibility should be declared for property $uri.

        $timeout,
        $maxRedirects,
        $followRedirects;
    public $cert;
    public $key;
    public $passphrase;
    public $encoding;
    public $payload;
    public $retryTimes;

    /**
     * @var int seconds
     */
    public $retryDuration;
    protected $options = array(
        'CURLOPT_MAXREDIRS' => 10,
        'header' => true,
        'method' => self::GET,
        'transfer' => true,
        'follow_location' => true,
        'timeout' => 0,
//        'ip' => null, //host, in string, .e.g: 172.16.1.1:888

38% of this comment could be valid code. Did you maybe forget this after debugging?

        'retry_times' => 1,//redo task when failed
        'retry_duration' => 0,//in seconds
    );
    protected $endCallback;
    protected $withURIQuery;
    protected $hasInitialized = false;

    protected function __construct()
    {

    }

    public static function create()
    {
        return new self;
    }

    public static function setLogger($logger)
    {
        self::$logger = $logger;
    }

    /**
     * Specify   timeout
     * @param float|int $timeout seconds to timeout the HTTP call
     * @return Request
     */
    public function timeout($timeout)
    {
        $this->timeout = $timeout;
        return $this;
    }

    public function noFollow()
    {
        return $this->follow(0);
    }

    /**
     * If the response is a 301 or 302 redirect, automatically
     * send off another request to that location
     * @param int $follow follow or not to follow or maximal number of redirects
     * @return Request
     */
    public function follow($follow)
    {
        $this->maxRedirects = abs($follow);
        $this->followRedirects = $follow > 0;
        return $this;
    }

    public function endCallback()
    {
        return $this->endCallback;
    }

    public function hasEndCallback()
    {
        return isset($this->endCallback);
    }

    public function uri($uri)
    {
        $this->uri = $uri;
        return $this;
    }

    public function hasCert()
    {
        return isset($this->cert) && isset($this->key);
    }

    /**
     * Use Client Side Cert Authentication
     * @param string $key file path to client key
     * @param string $cert file path to client cert
     * @param string $passphrase for client key
     * @param string $encoding default PEM
     * @return Request
     */
    public function cert($cert, $key, $passphrase = null, $encoding = 'PEM')
    {
        $this->cert = $cert;
        $this->key = $key;
        $this->passphrase = $passphrase;
        $this->encoding = $encoding;
        return $this;
    }

    public function body($payload, $mimeType = null)
    {
        $this->mime($mimeType);
        $this->payload = $payload;
        // Iserntentially don't call _serializePayload yet.  Wait until
        // we actually send off the request to convert payload to string.
        // At that time, the `serialized_payload` is set accordingly.
        return $this;
    }
    public function mime($mime)
    {
        if (empty($mime)) return $this;
        $this->content_type = $this->expected_type = Mime::getFullMime($mime);

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

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

        if ($this->isUpload()) {

The method isUpload() does not seem to exist on object<MultiHttp\Request>.

            $this->neverSerializePayload();

The method neverSerializePayload() does not seem to exist on object<MultiHttp\Request>.

        }
        return $this;
    }
    public function addHeader($header_name, $value)
    {
        $this->headers[$header_name] = $value;

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

        return $this;
    }

    public function addHeaders(array $headers)
    {
        foreach ($headers as $header => $value) {
            $this->addHeader($header, $value);
        }
        return $this;
    }
    public function expectsType($mime)
    {
        return $this->expects($mime);
    }
    public function sendType($mime)
    {
        return $this->contentType = $mime;

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

    }
    public function expects($mime)
    {
        if (empty($mime)) return $this;
        $this->expected_type = Mime::getFullMime($mime);
        return $this;
    }
    /**
     * @param $field alias or field name
     * @return bool|mixed
     */
    public function getIni($field)
    {
        $alias = self::optionAlias($field);
        return isset($this->options[$alias]) ? $this->options[$alias] : false;
    }

    /**
     * @param $key
     * @return mixed
     */
    protected static function optionAlias($key)
    {
        $alias = false;
        if (isset(self::$curlAlias[$key])) {
            $alias = self::$curlAlias[$key];
        } elseif ((substr($key, 0, strlen('CURLOPT_')) == 'CURLOPT_') && defined($key)) {
            $alias = $key;
        }
        return $alias;
    }

    public function addQuery($data)
    {
        if (!empty($data)) {
            if (is_array($data)) {
                $this->withURIQuery = http_build_query($data);
            } else if (is_string($data)) {
                $this->withURIQuery = $data;
            } else {
                throw new InvalidArgumentException('data must be array or string');
            }
        }
        return $this;
    }

    public function post($uri, $payload = null, array $options = array())
    {
        return $this->ini(Http::POST, $uri, $payload, $options);
    }

    /**
     * @param $uri
     * @param null $payload
     * @param array $options
     * @param null $response
     * @return string
     */
    public function quickPost($uri, $payload = null, array $options = array(), &$response = null)
    {
        $response = $this->post($uri, $payload, $options)->send();
        return $response->body;
    }
    /*  no body  */

    protected function ini($method, $url,  $data , array $options = array())

This method seems to be duplicated in your project.

    {
        $options = array('url' => $url, 'method' => $method, 'data' => $data) + $options;
        $this->addOptions($options);

        return $this;
    }

    public function addOptions(array $options = array())
    {
        $this->options = $options + $this->options;
        $this->uri = $this->options['url'];
        return $this;
    }

    function put($uri, $payload = null, array $options = array())

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

    {
        return $this->ini(Http::PUT, $uri, $payload, $options);
    }

    function patch($uri, $payload = null, array $options = array())

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

    {
        return $this->ini(Http::PATCH, $uri, $payload, $options);
    }

    public function get($uri, array $options = array())
    {
        return $this->ini(Http::GET, $uri, array(), $options);
    }

    /**
     * @param $uri
     * @param array $options
     * @param null $response
     * @return string
     */
    public function quickGet($uri, array $options = array(), &$response = null)
    {
        $response = $this->get($uri, $options)->send();
        return $response->body;
    }

    function options($uri, array $options = array())

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

    {
        return $this->ini(Http::OPTIONS, $uri, array(), $options);
    }

    function head($uri, array $options = array())

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

    {
        return $this->ini(Http::HEAD, $uri, array('CURLOPT_NOBODY' => true), $options);
    }

    function delete($uri, array $options = array())

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

    {
        return $this->ini(Http::DELETE, $uri, array(), $options);
    }

    function trace($uri, array $options = array())

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

    {
        return $this->ini(Http::TRACE, $uri, array(), $options);
    }

    /**
     * @return Response
     */
    public function send()
    {
        if (!$this->hasInitialized)
            $this->applyOptions();
        $response = $this->makeResponse();
        if ($this->endCallback) {
            $func = $this->endCallback;
            $func($response);
        }
        return $response;
    }

    public function applyOptions()
    {
        $curl = curl_init();
        $this->curlHandle = $curl;
        $this->prepare();
        $this->hasInitialized = true;
        return $this;
    }

    protected function prepare()
    {
        if (empty($this->options['url'])) {
            throw new InvalidArgumentException('url can not empty');
        }

        if (isset($this->options['retry_times'])) {
           $this->retryTimes = abs($this->options['retry_times']);
        }

        if (isset($this->options['retry_duration'])) {
           $this->retryDuration = abs($this->options['retry_duration']);

It seems like abs($this->options['retry_duration']) can also be of type double. However, the property $retryDuration is declared as type integer. Maybe add an additional type check?

        }

        if (isset($this->options['data'])) {
            $this->options['data'] = is_array($this->options['data']) ? http_build_query($this->options['data']) : $this->options['data'];//for better compatibility
        }
        if (isset($this->withURIQuery)) {
            $this->options['url'] .= strpos($this->options['url'], '?') === FALSE ? '?' : '&';
            $this->options['url'] .= $this->withURIQuery;
        }
        if (isset($this->options['callback'])) {
            $this->onEnd($this->options['callback']);
            unset($this->options['callback']);
        }
        //swap ip and host
        if (!empty($this->options['ip'])) {
            $matches = array();
            preg_match('/\/\/([^\/]+)/', $this->options['url'], $matches);
            $host = $matches[1];
            if (empty($this->options['headers']) || !is_array($this->options['headers'])) {
                $this->options['headers'] = array('Host: ' . $host);
            } else {
                $this->options['headers'][] = 'Host: ' . $host;
            }
            $this->options['url'] = preg_replace('/\/\/([^\/]+)/', '//' . $this->options['ip'], $this->options['url']);
            unset($this->options['ip']);
            unset($host);
        }
        //process version
        if (!empty($this->options['http_version'])) {
            $version = $this->options['http_version'];
            if ($version == '1.0') {
                $this->options['CURLOPT_HTTP_VERSION'] = CURLOPT_HTTP_VERSION_1_0;
            } elseif ($version == '1.1') {
                $this->options['CURLOPT_HTTP_VERSION'] = CURLOPT_HTTP_VERSION_1_1;
            }

            unset($version);
        }

        //convert secs to milliseconds
        if (defined('CURLOPT_TIMEOUT_MS')) {
            if (!isset($this->options['timeout_ms'])) {
                $this->options['timeout_ms'] = intval($this->options['timeout'] * 1000);
            } else {
                $this->options['timeout_ms'] = intval($this->options['timeout_ms']);
            }
        }

        $cURLOptions = self::filterAndRaw($this->options);

        curl_setopt_array($this->curlHandle, $cURLOptions);

        return $this;
    }

    public function onEnd(callable $callback)
    {
        if (!is_callable($callback)) {
            throw new InvalidArgumentException('callback not is callable :' . print_r($callback, 1));
        }

        $this->endCallback = $callback;
        return $this;
    }

    protected static function filterAndRaw(array &$options)
    {
        $opts = array();
        foreach ($options as $key => $val) {
            $alias = self::optionAlias($key);
            $options[$alias] = $val;
            if ($alias) {
                $opts[constant($alias)] = $val;
            }
            unset($options[$key]);
        }
        return $opts;
    }


    public function makeResponse($isMultiCurl = false)
    {
        $handle = $this->curlHandle;
        $body = $errno = null;
        Helper::retry($this->retryTimes, function()use(&$body, &$errno, $isMultiCurl, $handle){
            $body = $isMultiCurl ? curl_multi_getcontent($handle) : curl_exec($handle);
            $errno = curl_errno($handle);
            var_dump(curl_error($handle), time());

var_dump(curl_error($handle), time()); looks like debug code. Are you sure you do not want to remove it? This might expose sensitive data.

            ob_flush();
            flush();
            return 0 == $errno;
        }, $this->retryDuration);

        $info = curl_getinfo($this->curlHandle);
        $error = curl_error($this->curlHandle);
        $response = Response::create($this, $body, $info, $errno, $error);
        if (!is_null(self::$logger)) {
            self::log($response);
        }

        return $response;
    }

    private static function log(Response $response)
    {
        if ($response->hasErrors()) {
            self::$logger->error($response->request->getURI() . "\t" . $response->error, array(

The method getURI() does not seem to exist on object<MultiHttp\Request>.

                'response' => print_r($response, 1),
            ));
        }

    }
}