MultiHttp\Request

Complexity

Total Complexity

54

Size/Duplication

Total Lines	264
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

86.44%

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	create()	0	3	1
A	endCallback()	0	3	1
A	hasEndCallback()	0	3	1
A	onEnd()	0	7	2
A	getURI()	0	3	1
A	getIni()	0	6	2
A	addQuery()	0	12	4
A	post()	0	3	1
A	ini()	0	6	1
A	addOptions()	0	5	1
A	put()	0	3	1
A	patch()	0	3	1
A	get()	0	3	1
A	options()	0	3	1
A	head()	0	3	1
A	delete()	0	3	1
A	trace()	0	3	1
A	send()	0	9	2
A	applyOptions()	0	6	1
F	prepare()	0	56	15
A	filterAndRaw()	0	11	3
A	optionAlias()	0	9	4
A	makeResponse()	0	9	2
A	log()	0	12	3
A	setLogger()	0	4	1

<?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 {
	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 ,
	);
	public $curlHandle;
    protected $options = array(
        'CURLOPT_MAXREDIRS' => 10,
        'header' => true,
        'method' => self::GET,
        'transfer' => true,
        'follow_location' => true,
        'timeout' => 0);
    protected $endCallback;
	protected $withURIQuery;
	protected static $logger;
	protected $uri;

	protected function __construct() {

	}

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

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

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

	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;
	}

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

	/**
	 * @param $field alias or field name
	 * @return bool|mixed
	 */
	public function getIni($field) {
		$alias = self::optionAlias($field);
//		if (null === ($rawField = constant($alias))) {throw new InvalidArgumentException('field is invalid');

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

//		}
		return isset($this->options[$alias])?$this->options[$alias]:false;
	}


	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, array $payload = array(), array $options = array()) {
		return $this->ini(Http::POST, $uri, $payload, $options);
	}

	protected function ini($method, $url, array $data = array(), array $options = array()) {
		$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;
	}

	/*  no body  */

	function put($uri, array $payload = array(), 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, array $payload = array(), 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);
	}

	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() {
        $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();
		return $this;
	}

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

        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;
	}

	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;
	}

	/**
	 * @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 makeResponse($isMultiCurl = false) {
		$body     = $isMultiCurl?curl_multi_getcontent($this->curlHandle):curl_exec($this->curlHandle);
		$info     = curl_getinfo($this->curlHandle);
		$errno    = curl_errno($this->curlHandle);
		$error    = curl_error($this->curlHandle);
        $response = Response::create($this, $body, $info, $errno, $error);
        self::log($response);
		return $response;
	}

    private static function log(Response $response)
    {
        if (is_null(self::$logger)) {
            return;
        }
        if($response->hasErrors()){
            self::$logger->error($response->request->getURI() . "\t" . $response->error, array(
                'response' => print_r($response,1),
            ));
        }

    }

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