CurlerRolling::getInfo() - Code Metrics - Inspection of "Docker Compose in tests" - smi2/phpClickHouse - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#81)

by Šimon

created 2018-08-02 11:30 UTC

CurlerRolling::getInfo() A

↳ Parent: CurlerRolling

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	3
rs	10
ccs	0
cts	2
cp	0
cc	1
eloc	1
nc	1
nop	0
crap	2

<?php


namespace ClickHouseDB\Transport;

use ClickHouseDB\Exception\TransportException;

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

    /**
     * @var array

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

    /**

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

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

    /**

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


    /**

     * @var null|resource
     */
    private $_pool_master = null;

    /**

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

    /**

     * @var array

     */
    private $handleMapTasks = [];

    /**

     *
     */
    public function __destructor()

    {
        $this->close();
    }


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

            $this->_pool_master = curl_multi_init();


            if (function_exists('curl_multi_setopt')) {

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

            }
        }

        return $this->_pool_master;
    }

    /**

     *
     */
    public function close()

    {
        if ($this->_pool_master) {

            curl_multi_close($this->handlerMulti());

        }
    }


    /**
     * @param CurlerRequest $req

     * @param bool $checkMultiAdd

     * @param bool $force

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

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

        if (!$id) {

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

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

            if (!$checkMultiAdd) {

                return false;
            }

            throw new TransportException("Cant add exists que - cant overwrite : $id!\n");
// Instead of
$x = "foo $bar $baz";

// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
        }

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

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

    {
        $response = curl_multi_getcontent($oneHandle);
$a = "a";
$ab = "ab";
$abc = "abc";
        $header_size = curl_getinfo($oneHandle, CURLINFO_HEADER_SIZE);

        $header = substr($response, 0, $header_size);
$a = "a";
$ab = "ab";
$abc = "abc";
        $body = substr($response, $header_size);
$a = "a";
$ab = "ab";
$abc = "abc";

        $n = new CurlerResponse();
$a = "a";
$ab = "ab";
$abc = "abc";
        $n->_headers = $this->parse_headers_from_curl_response($header);
        $n->_body = $body;
$a = "a";
$ab = "ab";
$abc = "abc";
        $n->_info = curl_getinfo($oneHandle);
$a = "a";
$ab = "ab";
$abc = "abc";
        $n->_error = curl_error($oneHandle);
$a = "a";
$ab = "ab";
$abc = "abc";
        $n->_errorNo = curl_errno($oneHandle);

        $n->_useTime = 0;

        return $n;
    }

    /**
     * @return bool
     * @throws TransportException
     */
    public function execLoopWait()

    {
        $c = 0;
$a = "a";
$ab = "ab";
$abc = "abc";
        $count=0;
$a = "a";
$ab = "ab";
$abc = "abc";
        // add all tasks
        do {
            $this->exec();

            $loop = $this->countActive();
            $pend = $this->countPending();

            $count=$loop+$pend;

            $c++;

            if ($c > 20000) {
                break;
            }
            usleep(500);

        } while ($count);

        return true;
    }

    /**
     * @param string $response
     * @return array

     */
    private function parse_headers_from_curl_response($response)

    {
        $headers = [];
$a = "a";
$ab = "ab";
$abc = "abc";
        $header_text = $response;

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

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

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

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

        return $headers;
    }

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

    {
        return sizeof($this->pendingRequests);

    }

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

    {
        return count($this->activeRequests);

    }

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

    {
        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
     * @throws \InvalidArgumentException
     * @return $this
     */
    public function setSimultaneousLimit($count)

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

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

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        }

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

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

    {
        return $this->simultaneousLimit;
    }

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

    {
        return $this->runningRequests;
    }

    /**
     * @param CurlerRequest $request

     * @param bool $auto_close

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

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


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

        if ($auto_close) {
            $request->close();
        }

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

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

    {
        return "runningRequests = {$this->runningRequests} , pending=" . sizeof($this->pendingRequests) . " ";
// Instead of
$x = "foo $bar $baz";

// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
    }

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

    {
        $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);
// Without braces (not recommended)
if (true)
    doSomething();

// Recommended
if (true) {
    doSomething();
}

        if ($execrun != CURLM_OK) {

            throw new TransportException("[ NOT CURLM_OK ]");
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        }

        $this->runningRequests = $running;

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

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

            // send the return values to the callback function.

            $key = (string) $done['handle'];
$a = "a";
$ab = "ab";
$abc = "abc";
            $task_id = $this->handleMapTasks[$key];
            $request = $this->pendingRequests[$this->handleMapTasks[$key]];

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

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



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

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

            $this->completedRequestCount++;

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


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

        }

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

        return $this->countActive();
    }

    public function makePendingRequestsQue()

    {


        $max = $this->getSimultaneousLimit();
$a = "a";
$ab = "ab";
$abc = "abc";
        $active = $this->countActive();



        if ($active < $max) {


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

            $add = [];



            foreach ($this->pendingRequests as $task_id => $params) {
                if (empty($this->activeRequests[$task_id])) {

                    $add[$task_id] = $task_id;
                }
            }



            if (sizeof($add)) {

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

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

                    if (!is_array($ll)) {

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

                    }
                }

                foreach ($ll as $task_id) {
                    $this->_prepareLoopQue($task_id);
                }


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

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

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

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

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


        $key = (string) $h;
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->handleMapTasks[$key] = $task_id;
    }
}


1			<?php
			0 ignored issues – show introduced 2018-07-08 20:56 UTC by Report Bug Copy Issue Report Missing declare(strict_types = 1). Loading history...
2
3			namespace ClickHouseDB\Transport;
4
5			use ClickHouseDB\Exception\TransportException;
6
7			class CurlerRolling
8			{
9			/**
10			* @var int
11			*
12			* Max number of simultaneous requests.
13			*/
14			private $simultaneousLimit = 10;
15
16			/**
17			* @var array
			0 ignored issues – show introduced 2018-07-08 20:56 UTC by Report Bug Copy Issue Report @var annotation of property \ClickHouseDB\Transport\CurlerRolling::$activeRequests does not specify type hint for its items. Loading history...
18			*
19			* Requests currently being processed by curl
20			*/
21			private $activeRequests = [];
22
23			/**
			0 ignored issues – show introduced 2018-07-08 20:56 UTC by Report Bug Copy Issue Report Found multi-line comment for property \ClickHouseDB\Transport\CurlerRolling::$runningRequests with single line content, use one-line comment instead. Loading history...
24			* @var int
25			*/
26			private $runningRequests = 0;
27
28			/**
29			* @var CurlerRequest[]
30			*
31			* Requests queued to be processed
32			*/
33			private $pendingRequests = [];
34
35			/**
			0 ignored issues – show introduced 2018-07-08 20:56 UTC by Report Bug Copy Issue Report Found multi-line comment for property \ClickHouseDB\Transport\CurlerRolling::$completedRequestCount with single line content, use one-line comment instead. Loading history...
36			* @return int

smi2 / phpClickHouse

Pull Request — master (#81)

CurlerRolling::getInfo() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like