Client::watch() - Code Metrics - Inspection of "feat: 第一版" - hughcube/http-security - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( 9d73a2...14c4f6 )

by hugh
created 2020-03-15 12:09 UTC
Client::watch() A

↳ Parent: Client
Complexity

Conditions	1
Paths	1
Size

Total Lines	21
Code Lines	12
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	12
c	1
b	0
f	0
nc	1
nop	2
dl	0
loc	21
rs	9.8666
<?php
/**
 * Created by IntelliJ IDEA.
 * User: hugh.li
 * Date: 2020/1/21
 * Time: 14:52
 */

namespace HughCube\ACMClient;

use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\RequestOptions;
use HughCube\ACMClient\Exceptions\HttpException;
use HughCube\PUrl\Url;
use Psr\Http\Message\RequestInterface;

class Client
{
    /**
     * 获取节点的url
     */
    const GET_SERVER = "diamond-server/diamond";

    /**
     * 获取配置信息的url
     */
    const GET_CONFIG = "diamond-server/config.co";

    /**
     * 设置配置的url
     */
    const SET_CONFIG = "diamond-server/basestone.do?method=syncUpdateAll";

    /**
     * 删除配置的url
     */
    const DEL_CONFIG = "diamond-server/datum.do?method=deleteAllDatums";

    /**
     * @val HttpClient
     */
    private $httpClient;

    /**
     * @var Endpoint[]
     */
    protected $endpoints;

    /**
     * @var Config
     */
    private $config;

    public function __construct(Config $config)
    {
        $this->config = $config;
    }

    /**
     * @return Config
     */
    public function getConfig()
    {
        return $this->config;
    }

    /**
     * @return Endpoint[]
     * @throws HttpException
     */
    protected function getEndpoints()
    {
        if (!is_array($this->endpoints) || empty($this->endpoints)) {

            $endpoint = new Endpoint($this->config->getEndpoint(), null);

            $this->endpoints = [];
            $response = $this->sendRequest("GET", $endpoint->makeUrl(static::GET_SERVER));
            foreach (explode("\n", $response->getBody()->getContents()) as $server) {
                $server = trim($server);
                if (empty($server)) {
                    continue;
                }

                $parts = explode(":", $server);
                $parts[1] = (isset($parts[1]) && $parts[1]) ? $parts[1] : null;
                $this->endpoints[] = new Endpoint($parts[0], $parts[1]);
                $this->endpoints[] = new Endpoint($parts[0], /** @scrutinizer ignore-type */ $parts[1]);
            }
        }

        return $this->endpoints;
    }

    /**
     * @return $this
     */
    public function resetEndpoints()
    {
        $this->endpoints = null;

        return $this;
    }

    /**
     * @return Url
     * @throws HttpException
     */
    protected function makeUrl(string $path)
    {
        $endpoints = $this->getEndpoints();
        $key = array_rand($endpoints, 1);

        return $endpoints[$key]->makeUrl($path);
    }

    /**
     * @return HttpClient
     */
    protected function getHttpClient()
    {
        if (!$this->httpClient instanceof HttpClient) {
            $handler = HandlerStack::create();
            $handler->push($this->signatureHandler());
            $this->httpClient = new HttpClient([
                "handler" => $handler,
                RequestOptions::PROXY => $this->getConfig()->getProxy()
            ]);
        }

        return $this->httpClient;
    }

    /**
     * 添加请求头信息
     *
     * @return \Closure
     */
    private function signatureHandler()
    {
        return function (callable $handler) {
            return function (RequestInterface $request, array $options) use ($handler) {
                $request = $request
                    ->withHeader("timeStamp", time() * 1000)
                    ->withHeader("Spas-AccessKey", $this->getConfig()->getAccessKey());

                $signatureData = sprintf(
                    "%s+%s+%s",
                    $this->getConfig()->getNamespace(),
                    $this->getConfig()->getGroupName(),
                    $request->getHeaderLine("timeStamp")
                );

                $signature = base64_encode(hash_hmac('sha1', $signatureData, $this->config->getSecretKey(), true));

                $request = $request->withHeader("Spas-Signature", $signature);

                return $handler($request, $options);
            };
        };
    }

    /**
     * @param $method
     * @param Url $uri
     * @param array $params
     * @param array $options
     * @return \Psr\Http\Message\ResponseInterface
     * @throws HttpException
     */
    protected function sendRequest($method, Url $uri, array $params = [], array $options = [])
    {
        $params = array_merge($params, [
            "tenant" => $this->getConfig()->getNamespace(),
            "group" => $this->getConfig()->getGroupName()
        ]);

        if ("GET" === strtoupper($method)) {
            foreach ($params as $name => $value) {
                $uri = $uri->withQueryValue($name, $value);
            }
        }

        if ("POST" === strtoupper($method) && !empty($params)) {
            $options[RequestOptions::FORM_PARAMS] = $params;
        }

        try {
            $response = $this->getHttpClient()->request($method, $uri, $options);
        } catch (\Throwable $exception) {
            throw new HttpException($exception->getMessage(), $exception->getCode(), $exception);
        }

        return $response;
    }

    /**
     * 读取配置集
     *
     * @param string $dataId
     * @return string
     * @throws \Exception
     */
    public function read(string $dataId)
    {
        $response = $this->sendRequest(
            "GET",
            $this->makeUrl(static::GET_CONFIG),
            ["dataId" => $dataId]
        );

        return $response->getBody()->getContents();
    }

    /**
     * 写入配置集
     *
     * @param string $dataId
     * @param string $content
     * @return boolean
     * @throws \Exception
     */
    public function write(string $dataId, string $content)
    {
        $response = $this->sendRequest(
            "POST",
            $this->makeUrl(static::SET_CONFIG),
            ["dataId" => $dataId, "content" => $content]
        );

        return 200 == $response->getStatusCode();
    }

    /**
     * 删除配置集
     *
     * @param string $dataId
     * @return boolean
     * @throws \Exception
     */
    public function remove(string $dataId)
    {
        $response = $this->sendRequest(
            "POST",
            $this->makeUrl(static::DEL_CONFIG),
            ["dataId" => $dataId]
        );

        return 200 == $response->getStatusCode();
    }

    /**
     * 监听配置集
     *
     * @param string $dataId
     * @param string $content
     * @return boolean
     * @throws \Exception
     */
    public function watch(string $dataId, string $content)
    {
        $wordDelimiter = chr(37) . chr(48) . chr(50);
        $lineDelimiter = chr(37) . chr(48) . chr(49);

        $args = [
            $dataId,
            $this->getConfig()->getGroupName(),
            md5($content),
            $this->getConfig()->getNamespace()
        ];

        $response = $this->sendRequest(
            "POST",
            $this->makeUrl(static::GET_CONFIG),
            [
                "Probe-Modify-Request" => implode($wordDelimiter, $args) . $lineDelimiter
            ]
        );

        return 200 == $response->getStatusCode();
    }
}

hughcube / http-security

Push — master ( 9d73a2...14c4f6 )

Client::watch() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
