ClickHouseDB\Transport\CurlerRolling

Complexity

Total Complexity

45

Size/Duplication

Total Lines	376
Duplicated Lines	0 %

Test Coverage

Coverage

80.95%

Importance

Changes	5
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	execOne()	0	12	2
A	getRunningRequests()	0	3	1
A	close()	0	4	2
A	execLoopWait()	0	8	2
A	handlerMulti()	0	11	3
A	countActive()	0	3	1
A	countPending()	0	3	1
A	setSimultaneousLimit()	0	8	3
A	countCompleted()	0	3	1
A	getSimultaneousLimit()	0	3	1
A	getInfo()	0	3	1
A	addQueLoop()	0	18	5
A	parse_headers_from_curl_response()	0	17	4
B	exec()	0	53	6
A	_prepareLoopQue()	0	17	2
B	makePendingRequestsQue()	0	32	8
A	makeResponse()	0	16	1
A	__destruct()	0	3	1

<?php

Missing declare(strict_types=1).

namespace ClickHouseDB\Transport;

use ClickHouseDB\Exception\TransportException;

class CurlerRolling
{
    const SLEEP_DELAY = 1000; // 1ms

Constant \ClickHouseDB\Transport\CurlerRolling::SLEEP_DELAY visibility missing.

    /**
     * @var int
     *
     * Max number of simultaneous requests.
     */
    private $simultaneousLimit = 10;

    /**
     * @var array

@var annotation of property \ClickHouseDB\Transport\CurlerRolling::$activeRequests does not specify type hint for its items.

     *
     * Requests currently being processed by curl
     */
    private $activeRequests = [];

    /**

Found multi-line comment for property \ClickHouseDB\Transport\CurlerRolling::$runningRequests with single line content, use one-line comment instead.

     * @var int
     */
    private $runningRequests = 0;

    /**
     * @var CurlerRequest[]
     *
     * Requests queued to be processed
     */
    private $pendingRequests = [];

    /**

Found multi-line comment for property \ClickHouseDB\Transport\CurlerRolling::$completedRequestCount with single line content, use one-line comment instead.

     * @return int
     */
    private $completedRequestCount = 0;

Property \ClickHouseDB\Transport\CurlerRolling::$completedRequestCount does not have @var annotation for its value.

    /**

Found multi-line comment for property \ClickHouseDB\Transport\CurlerRolling::$_pool_master with single line content, use one-line comment instead.

     * @var null|resource

Null type hint should be on last position in "null|resource".

     */
    private $_pool_master = null;

Member variable "_pool_master" is not in valid camel caps format

    /**

Found multi-line comment for property \ClickHouseDB\Transport\CurlerRolling::$waitRequests with single line content, use one-line comment instead.

     * @var int
     */
    private $waitRequests = 0;

    /**

Found multi-line comment for property \ClickHouseDB\Transport\CurlerRolling::$handleMapTasks with single line content, use one-line comment instead.

     * @var array

@var annotation of property \ClickHouseDB\Transport\CurlerRolling::$handleMapTasks does not specify type hint for its items.

     */
    private $handleMapTasks = [];

    /**

Empty comment

     *
     */
    public function __destruct()

Method \ClickHouseDB\Transport\CurlerRolling::__destruct() does not need documentation comment.

    {
        $this->close();
    }

Expected 1 blank line after function; 2 found

    /**
     * @return resource
     */
    private function handlerMulti()
    {
        if (!$this->_pool_master) {

Member variable "_pool_master" is not in valid camel caps format

Expected 1 space after NOT operator; 0 found

            $this->_pool_master = curl_multi_init();

Function curl_multi_init() should not be referenced via a fallback global name, but via a use statement.

It seems like curl_multi_init() of type CurlMultiHandle or true is incompatible with the declared type null|resource of property $_pool_master.

Member variable "_pool_master" is not in valid camel caps format

            if (function_exists('curl_multi_setopt')) {

Function function_exists() should not be referenced via a fallback global name, but via a use statement.

                curl_multi_setopt($this->_pool_master, CURLMOPT_MAXCONNECTS, $this->simultaneousLimit);

Function curl_multi_setopt() should not be referenced via a fallback global name, but via a use statement.

Constant CURLMOPT_MAXCONNECTS should not be referenced via a fallback global name, but via a use statement.

It seems like $this->_pool_master can also be of type true; however, parameter $multi_handle of curl_multi_setopt() does only seem to accept CurlMultiHandle|resource, maybe add an additional type check?

Member variable "_pool_master" is not in valid camel caps format

            }
        }

        return $this->_pool_master;

The expression return $this->_pool_master also could return the type CurlMultiHandle|true which is incompatible with the documented return type resource.

Member variable "_pool_master" is not in valid camel caps format

    }

    /**

Empty comment

     *
     */
    public function close()

Method \ClickHouseDB\Transport\CurlerRolling::close() does not have void return type hint.

Method \ClickHouseDB\Transport\CurlerRolling::close() does not need documentation comment.

    {
        if ($this->_pool_master) {

Use early exit to reduce code nesting.

Member variable "_pool_master" is not in valid camel caps format

            curl_multi_close($this->handlerMulti());

Function curl_multi_close() should not be referenced via a fallback global name, but via a use statement.

        }
    }

Expected 1 blank line after function; 2 found

    /**
     * @param CurlerRequest $req

Incorrect annotations group.

Method \ClickHouseDB\Transport\CurlerRolling::addQueLoop() has useless @param annotation for parameter $req.

     * @param bool $checkMultiAdd

Expected 10 spaces after parameter type; 1 found

     * @param bool $force

Expected 10 spaces after parameter type; 1 found

     * @return bool
     * @throws TransportException
     */
    public function addQueLoop(CurlerRequest $req, $checkMultiAdd = true, $force = false)

Method \ClickHouseDB\Transport\CurlerRolling::addQueLoop() does not have native type hint for its parameter $checkMultiAdd but it should be possible to add it based on @param annotation "bool".

Method \ClickHouseDB\Transport\CurlerRolling::addQueLoop() does not have native type hint for its parameter $force but it should be possible to add it based on @param annotation "bool".

Method \ClickHouseDB\Transport\CurlerRolling::addQueLoop() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "bool".

    {
        $id = $req->getId();

        if (!$id) {

Expected 1 space after NOT operator; 0 found

            $id = $req->getUniqHash($this->completedRequestCount);
        }

        if (!$force && isset($this->pendingRequests[$id])) {

Expected 1 space after NOT operator; 0 found

            if (!$checkMultiAdd) {

Expected 1 space after NOT operator; 0 found

                return false;
            }

            throw new TransportException("Cant add exists que - cant overwrite : $id!\n");

Variable "$id" not allowed in double quoted string; use sprintf() or concatenation instead

        }

        $this->pendingRequests[$id] = $req;
        return true;

Expected 1 lines before "return", found 0.

    }

    /**
     * @param resource $oneHandle

Incorrect annotations group.

     * @return CurlerResponse
     */
    private function makeResponse($oneHandle)

Method \ClickHouseDB\Transport\CurlerRolling::makeResponse() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "CurlerResponse".

    {
        $response = curl_multi_getcontent($oneHandle);

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

Function curl_multi_getcontent() should not be referenced via a fallback global name, but via a use statement.

        $header_size = curl_getinfo($oneHandle, CURLINFO_HEADER_SIZE);

Function curl_getinfo() should not be referenced via a fallback global name, but via a use statement.

Constant CURLINFO_HEADER_SIZE should not be referenced via a fallback global name, but via a use statement.

The variable $header_size should be in camel caps format.

        $header = substr($response ?? '', 0, $header_size);

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

Function substr() should not be referenced via a fallback global name, but via a use statement.

The variable $header_size should be in camel caps format.

        $body = substr($response ?? '', $header_size);

Equals sign not aligned with surrounding assignments; expected 8 spaces but found 1 space

Function substr() should not be referenced via a fallback global name, but via a use statement.

The variable $header_size should be in camel caps format.

        $n = new CurlerResponse();

Equals sign not aligned with surrounding assignments; expected 11 spaces but found 1 space

        $n->_headers = $this->parse_headers_from_curl_response($header);
        $n->_body = $body;

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        $n->_info = curl_getinfo($oneHandle);

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

Function curl_getinfo() should not be referenced via a fallback global name, but via a use statement.

        $n->_error = curl_error($oneHandle);

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

Function curl_error() should not be referenced via a fallback global name, but via a use statement.

        $n->_errorNo = curl_errno($oneHandle);

Function curl_errno() should not be referenced via a fallback global name, but via a use statement.

        $n->_useTime = 0;

        return $n;
    }

    /**
     * @return bool

Incorrect annotations group.

     * @throws TransportException
     */
    public function execLoopWait()

Method \ClickHouseDB\Transport\CurlerRolling::execLoopWait() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "bool".

    {
        do {
            $this->exec();
            usleep(self::SLEEP_DELAY);

Function usleep() should not be referenced via a fallback global name, but via a use statement.

        } while (($this->countActive() + $this->countPending()) > 0);

Useless parentheses.

        return true;
    }

    /**
     * @param string $response

Incorrect annotations group.

     * @return array

@return annotation of method \ClickHouseDB\Transport\CurlerRolling::parse_headers_from_curl_response() does not specify type hint for items of its traversable return value.

     */
    private function parse_headers_from_curl_response($response)

Method name "CurlerRolling::parse_headers_from_curl_response" is not in camel caps format

Method \ClickHouseDB\Transport\CurlerRolling::parse_headers_from_curl_response() does not have native type hint for its parameter $response but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Transport\CurlerRolling::parse_headers_from_curl_response() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "array".

    {
        $headers = [];

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

        $header_text = $response;

The variable $header_text should be in camel caps format.

        foreach (explode("\r\n", $header_text) as $i => $line) {

Function explode() should not be referenced via a fallback global name, but via a use statement.

The variable $header_text should be in camel caps format.

            if ($i === 0) {
                $headers['http_code'] = $line;
            } else {
                $r = explode(': ', $line);

Function explode() should not be referenced via a fallback global name, but via a use statement.

                if (sizeof($r) == 2) {

Function sizeof() should not be referenced via a fallback global name, but via a use statement.

The use of function sizeof() is forbidden; use count() instead

Operator == is disallowed, use === instead.

                    $headers[$r[0]] = $r[1];
                }
            }
        }

        return $headers;
    }

    /**
     * @return int
     */
    public function countPending()

Method \ClickHouseDB\Transport\CurlerRolling::countPending() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "int".

    {
        return sizeof($this->pendingRequests);

Function sizeof() should not be referenced via a fallback global name, but via a use statement.

The use of function sizeof() is forbidden; use count() instead

    }

    /**
     * @return int
     */
    public function countActive()

Method \ClickHouseDB\Transport\CurlerRolling::countActive() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "int".

    {
        return count($this->activeRequests);

Function count() should not be referenced via a fallback global name, but via a use statement.

    }

    /**
     * @return int
     */
    public function countCompleted()

Method \ClickHouseDB\Transport\CurlerRolling::countCompleted() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "int".

    {
        return $this->completedRequestCount;
    }

    /**
     * Set the limit for how many cURL requests will be execute simultaneously.
     *
     * Please be mindful that if you set this too high, requests are likely to fail
     * more frequently or automated software may perceive you as a DOS attack and
     * automatically block further requests.
     *
     * @param int $count

Incorrect annotations group.

     * @throws \InvalidArgumentException

Class \InvalidArgumentException should not be referenced via a fully qualified name, but via a use statement.

     * @return $this
     */
    public function setSimultaneousLimit($count)

Method \ClickHouseDB\Transport\CurlerRolling::setSimultaneousLimit() does not have native type hint for its parameter $count but it should be possible to add it based on @param annotation "int".

    {
        if (!is_int($count) || $count < 2) {

The condition is_int($count) is always true.

Function is_int() should not be referenced via a fallback global name, but via a use statement.

Expected 1 space after NOT operator; 0 found

            throw new \InvalidArgumentException("setSimultaneousLimit count must be an int >= 2");

Class \InvalidArgumentException should not be referenced via a fully qualified name, but via a use statement.

The string literal setSimultaneousLimit count must be an int >= 2 does not require double quotes, as per coding-style, please use single quotes.

        }

        $this->simultaneousLimit = $count;
        return $this;

Expected 1 lines before "return", found 0.

    }

    /**
     * @return int
     */
    public function getSimultaneousLimit()

Method \ClickHouseDB\Transport\CurlerRolling::getSimultaneousLimit() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "int".

    {
        return $this->simultaneousLimit;
    }

    /**
     * @return int
     */
    public function getRunningRequests()

Method \ClickHouseDB\Transport\CurlerRolling::getRunningRequests() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "int".

    {
        return $this->runningRequests;
    }

    /**
     * @param CurlerRequest $request

Incorrect annotations group.

Method \ClickHouseDB\Transport\CurlerRolling::execOne() has useless @param annotation for parameter $request.

     * @param bool $auto_close

Expected 10 spaces after parameter type; 1 found

     * @return mixed
     * @throws TransportException
     */
    public function execOne(CurlerRequest $request, $auto_close = false)

Method \ClickHouseDB\Transport\CurlerRolling::execOne() does not have native type hint for its parameter $auto_close but it should be possible to add it based on @param annotation "bool".

The variable $auto_close should be in camel caps format.

    {
        $h = $request->handle();
        curl_exec($h);

Function curl_exec() should not be referenced via a fallback global name, but via a use statement.

        $request->setResponse($this->makeResponse($h));

It seems like $h can also be of type CurlHandle; however, parameter $oneHandle of ClickHouseDB\Transport\CurlerRolling::makeResponse() does only seem to accept resource, maybe add an additional type check?

        if ($auto_close) {

The variable $auto_close should be in camel caps format.

            $request->close();
        }

        return $request->response()->http_code();
    }

    /**
     * @return string
     */
    public function getInfo()

Method \ClickHouseDB\Transport\CurlerRolling::getInfo() does not have native return type hint for its return value but it should be possible to add it based on @return annotation "string".

    {
        return "runningRequests = {$this->runningRequests} , pending=" . sizeof($this->pendingRequests) . " ";

Variable "$this" not allowed in double quoted string; use sprintf() or concatenation instead

Function sizeof() should not be referenced via a fallback global name, but via a use statement.

The use of function sizeof() is forbidden; use count() instead

The string literal does not require double quotes, as per coding-style, please use single quotes.

    }

    /**
     * @throws TransportException
     */
    public function exec()

Method \ClickHouseDB\Transport\CurlerRolling::exec() does not have return type hint nor @return annotation for its return value.

    {
        $this->makePendingRequestsQue();

        // ensure we're running
        // a request was just completed -- find out which one

        while (($execrun = curl_multi_exec($this->handlerMulti(), $running)) == CURLM_CALL_MULTI_PERFORM);

Function curl_multi_exec() should not be referenced via a fallback global name, but via a use statement.

Constant CURLM_CALL_MULTI_PERFORM should not be referenced via a fallback global name, but via a use statement.

Operator == is disallowed, use === instead.

        if ($execrun != CURLM_OK) {

Constant CURLM_OK should not be referenced via a fallback global name, but via a use statement.

Operator != is disallowed, use !== instead.

            throw new TransportException("[ NOT CURLM_OK ]");

The string literal [ NOT CURLM_OK ] does not require double quotes, as per coding-style, please use single quotes.

        }

        $this->runningRequests = $running;

        while ($done = curl_multi_info_read($this->handlerMulti())) {

Function curl_multi_info_read() should not be referenced via a fallback global name, but via a use statement.

            $response = $this->makeResponse($done['handle']);

            // send the return values to the callback function.

Functions must not contain multiple empty lines in a row; found 2 empty lines

            if (is_object($done['handle'])) {

Function is_object() should not be referenced via a fallback global name, but via a use statement.

                $key = spl_object_id( $done['handle'] );

Function spl_object_id() should not be referenced via a fallback global name, but via a use statement.

            } else {
                $key = (string) $done['handle'] ;

Space found before semicolon; expected "];" but found "] ;"

            }

            $task_id = $this->handleMapTasks[$key];

The variable $task_id should be in camel caps format.

            $request = $this->pendingRequests[$this->handleMapTasks[$key]];

            unset($this->handleMapTasks[$key]);
            unset($this->activeRequests[$task_id]);

The variable $task_id should be in camel caps format.

            $this->pendingRequests[$task_id]->setResponse($response);

The variable $task_id should be in camel caps format.

            $this->pendingRequests[$task_id]->onCallback();

The variable $task_id should be in camel caps format.

Functions must not contain multiple empty lines in a row; found 2 empty lines

            if (!$request->isPersistent()) {

Expected 1 space after NOT operator; 0 found

                unset($this->pendingRequests[$task_id]);

The variable $task_id should be in camel caps format.

            }

            $this->completedRequestCount++;

            // remove the curl handle that just completed
            curl_multi_remove_handle($this->handlerMulti(), $done['handle']);

Function curl_multi_remove_handle() should not be referenced via a fallback global name, but via a use statement.

            // if something was requeued, this will get it running/update our loop check values
            $status = curl_multi_exec($this->handlerMulti(), $active);

The assignment to $status is dead and can be removed.

Function curl_multi_exec() should not be referenced via a fallback global name, but via a use statement.

        }

        // see if there is anything to read
        curl_multi_select($this->handlerMulti(), 0.01);

Function curl_multi_select() should not be referenced via a fallback global name, but via a use statement.

        return $this->countActive();

Expected 1 lines before "return", found 0.

    }

    public function makePendingRequestsQue()

Method \ClickHouseDB\Transport\CurlerRolling::makePendingRequestsQue() does not have void return type hint.

    {
        $max = $this->getSimultaneousLimit();

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        $active = $this->countActive();

Functions must not contain multiple empty lines in a row; found 2 empty lines

        if ($active < $max) {
            $canAdd = $max - $active;
//            $pending = sizeof($this->pendingRequests);

            $add = [];

Functions must not contain multiple empty lines in a row; found 2 empty lines

            foreach ($this->pendingRequests as $task_id => $params) {

Expected 1 lines after "foreach", found 2.

The variable $task_id should be in camel caps format.

                if (empty($this->activeRequests[$task_id])) {

Use early exit to reduce code nesting.

The variable $task_id should be in camel caps format.

                    $add[$task_id] = $task_id;

The variable $task_id should be in camel caps format.

                }
            }

Functions must not contain multiple empty lines in a row; found 2 empty lines

            if (sizeof($add)) {

Function sizeof() should not be referenced via a fallback global name, but via a use statement.

The use of function sizeof() is forbidden; use count() instead

                if ($canAdd >= sizeof($add)) {

Function sizeof() should not be referenced via a fallback global name, but via a use statement.

The use of function sizeof() is forbidden; use count() instead

                    $ll = $add;
                } else {
                    $ll = array_rand($add, $canAdd);

Function array_rand() should not be referenced via a fallback global name, but via a use statement.

                    if (!is_array($ll)) {

Function is_array() should not be referenced via a fallback global name, but via a use statement.

Expected 1 space after NOT operator; 0 found

                        $ll = array($ll => $ll);

Short array syntax must be used to define arrays

                    }
                }

                foreach ($ll as $task_id) {

The variable $task_id should be in camel caps format.

                    $this->_prepareLoopQue($task_id);

The variable $task_id should be in camel caps format.

                }
            }// if add
        }// if can add
    }

    /**
     * @param string $task_id
     */
    private function _prepareLoopQue($task_id)

Method \ClickHouseDB\Transport\CurlerRolling::_prepareLoopQue() does not have native type hint for its parameter $task_id but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Transport\CurlerRolling::_prepareLoopQue() does not have void return type hint.

The variable $task_id should be in camel caps format.

    {
        $this->activeRequests[$task_id] = 1;

The variable $task_id should be in camel caps format.

        $this->waitRequests++;

        $h = $this->pendingRequests[$task_id]->handle();

The variable $task_id should be in camel caps format.

        // pool
        curl_multi_add_handle($this->handlerMulti(), $h);

Function curl_multi_add_handle() should not be referenced via a fallback global name, but via a use statement.

        if (is_object($h)) {

Function is_object() should not be referenced via a fallback global name, but via a use statement.

            $key = spl_object_id( $h );

Function spl_object_id() should not be referenced via a fallback global name, but via a use statement.

        } else {
            $key = (string) $h ;

Space found before semicolon; expected "$h;" but found "$h ;"

        }

        $this->handleMapTasks[$key] = $task_id;

The variable $task_id should be in camel caps format.

    }
}