kiri-wchat/wchat/common/HttpClient.php

<?php

namespace wchat\common;

use Swoole\Coroutine\Http\Client as SClient;
use Swoole\Coroutine\System;

class HttpClient
{

	private $host = '';

	private $header = [];

	private $callback = null;
	private $method = 'get';

	private $url = '';
	private $isSSL = false;
	private $agent = '';
	private $isFileStream = false;
	private $errorCodeField = '';
	private $errorMsgField = '';
	private $use_swoole = false;

	private $ssl_cert_file = '';
	private $ssl_key_file = '';
	private $ca = '';
	private $port = '';

	/**
	 * @return string
	 */
	public function getCa(): string
	{
		return $this->ca;
	}

	/**
	 * @param string $ca
	 */
	public function setCa(string $ca): void
	{
		$this->ca = $ca;
	}


	/**
	 * @return string
	 */
	public function getPort(): string
	{
		return $this->port;
	}

	/**
	 * @param string $port
	 */
	public function setPort(string $port): void
	{
		$this->port = $port;
	}

	const POST = 'post';
	const GET = 'get';
	const PUT = 'put';
	const DELETE = 'delete';
	const OPTIONS = 'option';

	/**
	 * HttpClient constructor.
	 */
	private function __construct()
	{
	}

	public function setData($data)
	{
		$this->_data = $data;
	}

	/**
	 * @return string
	 */
	public function getSslCertFile(): string
	{
		return $this->ssl_cert_file;
	}

	/**
	 * @param string $ssl_cert_file
	 */
	public function setSslCertFile(string $ssl_cert_file)
	{
		$this->ssl_cert_file = $ssl_cert_file;
	}

	/**
	 * @return string
	 */
	public function getSslKeyFile(): string
	{
		return $this->ssl_key_file;
	}

	/**
	 * @param string $ssl_key_file
	 */
	public function setSslKeyFile(string $ssl_key_file)
	{
		$this->ssl_key_file = $ssl_key_file;
	}

	/**
	 */
	public static function NewRequest()
	{
		static $client = null;
		if (!($client instanceof HttpClient)) {
			$client = new HttpClient();
		}
		return $client;
	}

	/**
	 * @param string $name
	 * @return $this
	 */
	public function setErrorField(string $name)
	{
		$this->errorCodeField = $name;
		return $this;
	}

	/**
	 * @param $bool
	 * @return $this
	 */
	public function setUseSwoole($bool)
	{
		$this->use_swoole = $bool;
		if ($this->use_swoole) {
			function_exists('setCli') && setCli(true);
		}
		return $this;
	}

	/**
	 * @param string $name
	 * @return $this
	 */
	public function setErrorMsgField(string $name)
	{
		$this->errorMsgField = $name;
		return $this;
	}

	/**
	 * @param string $host
	 */
	public function setHost(string $host)
	{
		$this->host = $this->replaceHost($host);
		$match_quest = '/^[a-zA-Z\-](\.[a-zA-Z\-])*/';
		if (preg_match($match_quest, $this->host)) {
			$this->addHeader('Host', $this->host);
		}
	}

	/**
	 * @param $path
	 * @param array $data
	 * @return Result
	 */
	public function grpc($path, array $data)
	{
		$client = new \Swoole\Coroutine\Client(SWOOLE_TCP);
		if (empty($this->host) || empty($this->port)) {
			return new Result(['code' => 0, 'message' => '']);
		}
		if (!$client->connect($this->host, $this->port)) {
			return new Result(['code' => 500, 'message' => $client->errMsg]);
		}
		$path = $this->port . '/' . ltrim($path, '/');
		$send = $client->send(serialize([
			'body'   => $data,
			'header' => [
				'request_uri'    => $path,
				'request_method' => 'grpc'
			]
		]));
		$client->close();
		if ($send) {
			$param = ['code' => 0, 'message' => ''];
		} else {
			$param = ['code' => 500, 'message' => $client->errMsg];
		}
		return new Result($param);
	}

	/**
	 * @param array $header
	 */
	public function setHeader($key, $value)
	{
		$this->header[$key] = $value;
	}

	/**
	 * @param $key
	 * @param $value
	 */
	public function addHeader($key, $value)
	{
		$this->header[$key] = $value;
	}

	/**
	 * @param null $callback
	 */
	public function setCallback($callback)
	{
		$this->callback = $callback;
	}

	/**
	 * @param string $method
	 */
	public function setMethod(string $method)
	{
		$this->method = $method;
	}

	/**
	 * @param string $url
	 */
	public function setUrl(string $url)
	{
		$this->url = $url;
	}

	public function setAgent(string $agent)
	{
		$this->agent = $agent;
	}

	/**
	 * @param bool $isSSL
	 */
	public function setIsSSL(bool $isSSL)
	{
		$this->isSSL = $isSSL;
		if ($this->isSSL) {
			$this->port = 443;
		}
	}

	/**
	 * @return bool
	 */
	public function getIsSSL()
	{
		return $this->isSSL;
	}

	/**
	 * @param bool $isFIle
	 * 设置返回类型
	 */
	public function asFileStream($isFIle = true)
	{
		$this->isFileStream = $isFIle;
	}

	/**
	 * @param $url
	 * @param array $data
	 * @return array|mixed|Result
	 * @throws \Exception
	 */
	private function request($url, $data = [])
	{
		$data = $this->paramEncode($data);
		if ($this->use_swoole) {
			$url = $this->matchHost($url);
			var_dump($this->host, $url);
			return $this->coroutine($this->host, $url, $data);
		} else {
			return $this->useCurl($url, $data);
		}
	}

	/**
	 * @return bool
	 */
	private function isCli()
	{
		return function_exists('getIsCli') && getIsCli();
	}

	/**
	 * @param string $string
	 * @return bool|mixed
	 */
	private function matchHost($string = '')
	{
		if (empty($string)) {
			return false;
		}

		// 手动设置请求域名
		if (!empty($this->host)) {
			if (!$this->checkIsIp($this->host)) {
				$this->host = System::gethostbyname($this->host);
			}
			return $string;
		}

		// 替换请求头为空
		$string = str_replace('http://', '', $string);
		if ($this->isHttps($string)) {
			$string = str_replace('https://', '', $string);
			$this->setIsSSL(true);
		}

		$hostAndUrls = explode('/', $string);
		if (empty($hostAndUrls)) {
			return false;
		}

		$this->host = array_shift($hostAndUrls);
		$hostAndUrls = implode('/', $hostAndUrls);
		if (strpos($this->host, ':') !== false) {
			[$this->host, $this->port] = explode(':', $this->host);
			if ($this->checkIsIp($this->host)) {
				return $hostAndUrls;
			}
		}

		if (!$this->isDomainName($this->host)) {
			return false;
		}

		$this->host = System::gethostbyname($this->host);

		return $hostAndUrls;
	}

	/**
	 * @param $name
	 * @return bool|mixed
	 */
	private function isDomainName($name)
	{
		if (!preg_match('/^[a-zA-Z\-0-9]+(\.[a-zA-Z\-0-9]+)+[^\/]?/', $name, $out)) {
			return false;
		}
		return $out[0];
	}

	/**
	 * @param $url
	 * @param $data
	 * @return array|Result|mixed
	 */
	private function useCurl($url, $data)
	{
		if ($this->isHttp($url) || $this->isHttps($url)) {
			return $this->curl($url, $data);
		}
		if ($this->isSSL) {
			return $this->curl('https://' . $this->host . '/' . $url, $data);
		} else {
			return $this->curl('http://' . $this->host . '/' . $url, $data);
		}
	}

	/**
	 * @param $url
	 * @return array
	 */
	private function parseUrlHost($url)
	{
		if (!$this->isHttp($url) && !$this->isHttps($url)) {
			$url = ($this->isSSL ? 'https://' : 'http://') . $url;
		}
		$url = $this->matchHost($url);
		if ($this->checkIsIp($this->host)) {
			return [$url, $this->host];
		}
		return [$url, System::gethostbyname($this->host)];
	}

	/**
	 * @param $url
	 * @return mixed
	 */
	private function cutRequestUrl($url)
	{
		$url = $this->replaceHost($url);
		$explode = explode('/', $url);
		$first = array_shift($explode);
		if (strpos($first, ':') !== false) {
			[$first, $this->port] = explode(':', $first);
			if ($this->port !== 443) {
				$this->isSSL = false;
			}
		}
		$url = '/' . implode('/', $explode);
		return [$first, $url];
	}

	/**
	 * @param $host
	 * @return string|string[]
	 */
	private function replaceHost($host)
	{
		if ($this->isHttp($host)) {
			return str_replace('http://', '', $host);
		}
		if ($this->isHttps($host)) {
			return str_replace('https://', '', $host);
		}
		return $host;
	}

	/**
	 * @param $url
	 * @return false|int
	 */
	private function checkIsIp($url)
	{
		return preg_match('/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/', $url);
	}

	/**
	 * @param $url
	 * @return bool
	 */
	private function isHttp($url)
	{
		return strpos($url, 'http://') === 0;
	}

	/**
	 * @param $url
	 * @return bool
	 */
	private function isHttps($url)
	{
		return strpos($url, 'https://') === 0;
	}


	/**
	 * @param $ip
	 * @param $url
	 * @param array $data
	 * @return array|mixed|Result
	 * @throws \Exception
	 * 使用swoole协程方式请求
	 */
	private function coroutine($ip, $url, $data = [])
	{
		$client = $this->generate_client($ip, $url, $data);
		if ($client->statusCode < 0) {
			throw new \Exception($client->errMsg);
		}

		$body = $client->body;

		$header = $client->getHeaders();

		$body = $this->resolve($header, $body);

		unset($this->_data);

		if ($client->getStatusCode() != 200) {
			if (is_string($body)) {
				$message = 'Request error code ' . $client->getStatusCode();
			} else {
				$message = $this->searchMessageByData($body);
			}
			return new Result(['code' => $client->getStatusCode(), 'message' => $message, 'data' => $body]);
		}

		return $this->structure($body, $data, $header);
	}

	/**
	 * @return mixed
	 */
	private function getHostIp()
	{
		$host = \Co::getAddrInfo($this->host);
		return array_shift($host);
	}

	/**
	 * @return int
	 */
	private function getHostPort()
	{
		if (!empty($this->port)) {
			return $this->port;
		}
		$port = 80;
		if ($this->isSSL) $port = 443;
		return $port;
	}

	/**
	 * @param $host
	 * @param $port
	 * @param $url
	 * @param $data
	 * @return \Swoole\Coroutine\Http\Client
	 */
	private function generate_client($host, $url, $data)
	{
		var_dump($host, $this->getHostPort(), $this->isSSL, $url);
		$client = new SClient($host, $this->getHostPort(), $this->isSSL);

//		$client->set($this->settings());
		if (!empty($this->agent)) {
			$this->header['User-Agent'] = $this->agent;
		}
		if (!empty($this->header)) {
			$client->setHeaders($this->header);
		}
		if (!empty($this->_data)) {
			$client->setData($this->_data);
		}
		if (strtolower($this->method) == self::GET) {
			if (!empty($data)) {
				$url .= '?' . $data;
			}
			$client->get($url);
		} else if (strtolower($this->method) == self::PUT) {
			$client->setMethod('PUT');
			if (!is_string($data)) {
				$data = json_encode($data);
			}
			if (!empty($data)) {
				$client->setData($data);
			}
			$client->execute($url);
		} else if (strtolower($this->method) == self::DELETE) {
			$client->setMethod('DELETE');
			if (!is_string($data)) {
				$data = json_encode($data);
			}
			if (!empty($data)) {
				$client->setData($data);
			}
			$client->execute($url);
		} else {
			$client->post($url, $data);
		}
		$client->close();
		return $client;
	}


	private function settings()
	{
		$sslCert = $this->getSslCertFile();
		$sslKey = $this->getSslKeyFile();
		$sslCa = $this->getCa();

		if (empty($sslCert) || empty($sslKey) || empty($sslCa)) {
			return [];
		}

		$params['ssl_host_name'] = $this->host;
		$params['ssl_cert_file'] = $this->getSslCertFile();
		$params['ssl_key_file'] = $this->getSslKeyFile();
		$params['ssl_verify_peer'] = true;
		$params['ssl_cafile'] = $sslCa;

		return $params;
	}

	/**
	 * @param $url
	 * @param array $data
	 * @return array|mixed|Result
	 */
	private function curl($url, $data = [])
	{
		try {
			$ch = curl_init();
			curl_setopt($ch, CURLOPT_URL, $this->createRequestUrl($url, $data));
			curl_setopt($ch, CURLOPT_TIMEOUT, 5);// 超时设置
			curl_setopt($ch, CURLOPT_HEADER, true);

			if ($headers = $this->parseHeaderMat()) {
				curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
			}

			if (!empty($this->agent)) {
				curl_setopt($ch, CURLOPT_USERAGENT, $this->agent);
			}
			curl_setopt($ch, CURLOPT_SSLCERT, $this->getSslCertFile());
			curl_setopt($ch, CURLOPT_SSLKEY, $this->getSslKeyFile());
			curl_setopt($ch, CURLOPT_NOBODY, FALSE);
			curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 1);   // 超时设置
			curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);//返回内容
			curl_setopt($ch, CURLOPT_FOLLOWLOCATION, TRUE);// 跟踪重定向
			curl_setopt($ch, CURLOPT_ENCODING, 'gzip,deflate');

			if ($this->method == self::POST) {
				curl_setopt($ch, CURLOPT_POST, 1);
			}
			if ($this->method != self::GET) {
				if (!empty($this->_data)) {
					curl_setopt($ch, CURLOPT_POSTFIELDS, $this->_data);
				} else {
					curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
				}
			}

			curl_setopt($ch, CURLOPT_CUSTOMREQUEST, strtoupper($this->method));
			$output = curl_exec($ch);
			curl_close($ch);

			if ($output === FALSE) {
				$data = new Result(['code' => 500, 'message' => curl_error($ch)]);
			} else {
				[$header, $body, $status] = $this->explode($output);
				if ($status != 200) {
					$data = new Result(['code' => 500, 'message' => $body, 'header' => $header]);
				} else {
					$data = $this->structure($body, $data, $header);
				}
			}
			unset($ch);
			return $data;
		} catch (\Exception $exception) {
			return new Result(['code' => 500, 'message' => $exception->getMessage(), 'header' => []]);
		}
	}

	/**
	 * @param $output
	 * @return array
	 */
	private function explode($output)
	{
		[$header, $body] = explode("\r\n\r\n", $output, 2);
		if ($header == 'HTTP/1.1 100 Continue') {
			[$header, $body] = explode("\r\n\r\n", $body, 2);
		} else if (strpos($body, "\r\n\r\n") !== false) {
			[$header, $body] = explode("\r\n\r\n", $body, 2);
		}
		$header = explode("\r\n", $header);

		unset($output);

		$status = (int)explode(' ', trim($header[0]))[1];
		$header = $this->headerFormat($header);

		return [$header, $this->resolve($header, $body), $status];
	}

	/**
	 * @param $url
	 * @param $data
	 * @return string
	 */
	private function createRequestUrl($url, $data)
	{
		if ($this->isGet()) {
			return $url . '?' . $data;
		}
		return $url;
	}

	/**
	 * @param $data
	 * @param $body
	 * @return mixed
	 */
	private function resolve($data, $body)
	{
		if (is_array($body)) {
			return $body;
		}
		$type = $data['content-type'] ?? 'text/html';
		if (strpos($type, 'text/html') !== false) {
			return $body;
		} else if (strpos($type, 'json') !== false) {
			return json_decode($body, true);
		} else if (strpos($type, 'xml') !== false) {
			return Help::toArray($body);
		} else if (strpos($type, 'plain') !== false) {
			return Help::toArray($body);
		}
		return $body;
	}

	/**
	 * @param $headers
	 * @return array
	 */
	private function headerFormat($headers)
	{
		$_tmp = [];
		foreach ($headers as $key => $val) {
			$trim = explode(': ', trim($val));

			$_tmp[strtolower($trim[0])] = $trim[1] ?? '';
		}
		return $_tmp;
	}

	/**
	 * @param $body
	 * @param $_data
	 * @param $header
	 * @param $statusCode
	 * @return array|mixed|Result
	 * 构建返回体
	 */
	private function structure($body, $_data, $header = [], $statusCode = 200)
	{
		$this->setIsSSL(false);
		$this->setHeaders([]);

		if ($this->callback !== NULL) {
			$result = call_user_func($this->callback, $body, $_data, $header);
			$this->setCallback(null);

			return $result;
		}
		if (is_string($body)) {
			$result['code'] = 0;
			$result['message'] = '';
		} else {
			$result['code'] = $body[$this->errorCodeField] ?? 0;
			$result['message'] = $this->searchMessageByData($body);
		}
		$result['data'] = $body;
		$result['header'] = $header;
		$result['httpStatus'] = $statusCode;


		return new Result($result);
	}

	/**
	 * @param $body
	 * @return array|mixed|string
	 */
	private function searchMessageByData($body)
	{
		$parent = [];
		if (empty($this->errorMsgField)) {
			return 'system success.';
		}
		$explode = explode('.', $this->errorMsgField);
		if (!isset($body[$explode[0]])) {
			return 'system success.';
		}
		foreach ($explode as $item) {
			if (empty($item)) {
				continue;
			}
			if (empty($parent)) {
				$parent = $body[$item];
				continue;
			}
			if (is_string($parent) || !isset($parent[$item])) {
				break;
			}
			$parent = $parent[$item];
		}
		return !empty($parent) ? $parent : 'system success.';
	}


	/**
	 * @return bool
	 * check isPost Request
	 */
	public function isPost()
	{
		return strtolower($this->method) === self::POST;
	}

	/**
	 * @return bool
	 *
	 * check isGet Request
	 */
	public function isGet()
	{
		return strtolower($this->method) === self::GET;
	}

	/**
	 * @param        $arr
	 *
	 * @return array|string
	 * 将请求参数进行编码
	 */
	private function paramEncode($arr)
	{
		if (!is_array($arr)) {
			return $arr;
		}
		$_tmp = [];
		foreach ($arr as $Key => $val) {
			$_tmp[$Key] = $val;
		}
		if ($this->isGet()) {
			return http_build_query($_tmp);
		}
		return $_tmp;
	}

	/**
	 * @param $url
	 * @param array $data
	 * @return array|mixed|Result
	 * @throws
	 */
	public function post($url, $data = [])
	{
		$this->setMethod(self::POST);
		return $this->request($url, $data);
	}


	/**
	 * @param $url
	 * @param array $data
	 * @return array|mixed|Result
	 * @throws
	 */
	public function put($url, $data = [])
	{
		$this->setMethod(self::PUT);
		return $this->request($url, $data);
	}

	/**
	 * @param $url
	 * @param array $data
	 * @return array|mixed|Result
	 * @throws
	 */
	public function get($url, $data = [])
	{
		$this->setMethod(self::GET);
		return $this->request($url, $data);
	}

	/**
	 * @param $url
	 * @param array $data
	 * @return array|mixed|Result
	 * @throws \Exception
	 */
	public function option($url, $data = [])
	{
		$this->setMethod(self::OPTIONS);
		return $this->request($url, $data);
	}

	/**
	 * @param $url
	 * @param array $data
	 * @return array|mixed|Result
	 * @throws \Exception
	 */
	public function delete($url, $data = [])
	{
		$this->setMethod(self::DELETE);
		return $this->request($url, $data);
	}

	/**
	 * @param $url
	 * @param array $data
	 * @return array|mixed|Result
	 * @throws \Exception
	 */
	public function send($url, $data = [])
	{
		return $this->request($url, $data);
	}

	/**
	 * @return array
	 */
	private function parseHeaderMat()
	{
		if ($this->use_swoole) {
			return $this->header;
		}
		$headers = [];
		foreach ($this->header as $key => $val) {
			$header = $key . ':' . $val;
			if (in_array($header, $headers)) {
				continue;
			}
			$headers[] = $header;
		}
		$this->header = [];
		return $headers;
	}

	/**
	 * @param array $headers
	 * @return array
	 */
	public function setHeaders(array $headers)
	{
		if (empty($headers)) {
			return [];
		}
		foreach ($headers as $key => $val) {
			$this->header[$key] = $val;
		}
		return $this->header;
	}
}