Carno\HTTP\Powered\Swoole\Client

Complexity

Total Complexity

29

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	heartbeat()	0	3	1
B	execute()	0	43	10
A	disconnect()	0	3	2
A	initialize()	0	29	6
A	connect()	0	3	1
A	finalize()	0	5	2
A	__construct()	0	4	1
A	close()	0	17	4
A	failure()	0	3	1
A	closing()	0	3	1

<?php
/**
 * HTTP client by swoole
 * User: moyo
 * Date: 12/09/2017
 * Time: 3:07 PM
 */

namespace Carno\HTTP\Powered\Swoole;

use function Carno\Coroutine\await;
use Carno\HTTP\Contracts\Powered\Client as API;
use Carno\HTTP\Exception\RequestTimeoutException;
use Carno\HTTP\Options;
use Carno\HTTP\Powered\Swoole\Chips\Http;
use Carno\HTTP\Powered\Swoole\Chips\Socket;
use Carno\HTTP\Powered\Swoole\Chips\Throws;
use Carno\HTTP\Standard\Helper;
use Carno\Net\Address;
use Carno\Pool\Managed;
use Carno\Pool\Poolable;
use Carno\Promise\Promise;
use Carno\Promise\Promised;
use Psr\Http\Message\RequestInterface as Request;
use Swoole\Http\Client as SWHClient;

The type Swoole\Http\Client was not found. Maybe you did not declare it correctly or list all dependencies?

class Client implements API, Poolable
{
    use Helper, Managed;
    use Http, Socket, Throws;

The trait Carno\HTTP\Powered\Swoole\Chips\Throws requires some properties which are not provided by Carno\HTTP\Powered\Swoole\Client: $statusCode, $errCode

The trait Carno\HTTP\Powered\Swoole\Chips\Socket requires some properties which are not provided by Carno\HTTP\Powered\Swoole\Client: $opcode, $data, $statusCode

The trait Carno\HTTP\Powered\Swoole\Chips\Http requires some properties which are not provided by Carno\HTTP\Powered\Swoole\Client: $statusCode, $headers, $body

    /**
     * @var bool
     */
    private $keepalive = false;

    /**
     * @var Address
     */
    private $connect = null;

    /**
     * @var bool
     */
    private $closing = false;

    /**
     * @var SWHClient
     */
    private $http = null;

    /**
     * Client constructor.
     * @param Address $connect
     * @param bool $keepalive
     */
    public function __construct(Address $connect, bool $keepalive = false)
    {
        $this->connect = $connect;
        $this->keepalive = $keepalive;
    }

    /**
     * @param Request $request
     * @param Options $options
     */
    private function initialize(Request $request, Options $options) : void
    {
        $this->http = new SWHClient(
            $this->connect->host(),
            $this->connect->port(),
            in_array($scheme = $request->getUri()->getScheme(), ['https', 'wss'])
        );

        $this->http->set([
            'open_tcp_nodelay' => true,
            'keep_alive' => $this->keepalive || $socket = in_array($scheme, ['ws', 'wss']),
        ]);

        ($socket ?? null) && $this->http->set(['websocket_mask' => true]);

        if ($options->hasProxy()) {
            $px = $options->getProxy();
            $pxc = [
                'http_proxy_host' => $px['host'],
                'http_proxy_port' => $px['port'],
            ];
            $px['user'] && $pxc['http_proxy_user'] = $px['user'];
            $px['pass'] && $pxc['http_proxy_password'] = $px['pass'];
            $this->http->set($pxc);
        }

        $this->http->on('connect', function () {
            $this->http->on('error', [$this, 'failure']);
            $this->http->on('close', [$this, 'closing']);
        });
    }

    /**
     * @param string $ev
     */
    private function finalize(string $ev) : void

The parameter $ev is not used and could be removed.

    {
        if (isset($this->http)) {
            unset($this->http);
            $this->disconnect();
        }
    }

    /**
     */
    private function disconnect() : void
    {
        $this->closed()->pended() && $this->closed()->resolve();
    }

    /**
     * @return Promised
     */
    public function connect() : Promised
    {
        return Promise::resolved();
    }

    /**
     * @return Promised
     */
    public function heartbeat() : Promised
    {
        return Promise::resolved();
    }

    /**
     * @return Promised
     */
    public function close() : Promised
    {
        if ($this->closing) {
            goto CLOSED_STA;
        }

        $this->closing = true;

        if (isset($this->http) && $this->http->isConnected()) {
            $this->http->close();
        } else {
            $this->disconnect();
        }

        CLOSED_STA:

        return $this->closed();
    }

    /**
     * @param SWHClient $c
     */
    public function failure(SWHClient $c = null) : void

The parameter $c is not used and could be removed.

    {
        $this->finalize('error');
    }

    /**
     * @param SWHClient $c
     */
    public function closing(SWHClient $c = null) : void

The parameter $c is not used and could be removed.

    {
        $this->finalize('close');
    }

    /**
     * @param Request $request
     * @param Options $options
     * @return Promised
     */
    public function execute(Request $request, Options $options) : Promised
    {
        if (is_null($this->http)) {
            $this->initialize($request, $options);
        }

        // config init -->

        $this->http->set(['timeout' => $options->ttOverall > 0 ? round($options->ttOverall / 1000, 3) : -1]);

        // host filter -->

        if ($request->hasHeader('Host') && filter_var($request->getHeaderLine('Host'), FILTER_VALIDATE_IP)) {
            $request->withoutHeader('Host');
        }

        // keepalive parser -->

        if (!$this->keepalive &&
            (!$request->hasHeader('Connection') ||
                ($request->hasHeader('Connection') &&
                    $request->getHeaderLine('Connection') !== 'close'
                )
            )
        ) {
            $request->withHeader('Connection', 'close');
        }

        // set headers -->

        $this->http->setHeaders($this->getHeaderLines($request));

        // programme init -->

        list($executor, $receiver) =
            $request->getMethod() === 'UPGRADE'
                ? $this->socket($request)
                : $this->http($request)
        ;

        // executing -->

        return await($executor, $receiver, $options->ttOverall, RequestTimeoutException::class, $request->getUri());
    }
}