Agent::setMaxConcurrent() - Code Metrics - Inspection of "Update scrutinizer.yml" - half2me/curlx - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 700166...f06841 )

by Benjamin

created 2016-02-09 21:50 UTC

Agent::setMaxConcurrent() A

↳ Parent: Agent

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	6
rs	9.4285
cc	2
eloc	3
nc	2
nop	1

<?php

namespace CurlX;

class Agent
{
    protected $maxConcurrent = 0; //max. number of simultaneous connections allowed
    protected $options = []; //shared cURL options
    protected $headers = []; //shared cURL request headers
    protected $timeout = 5000; //timeout used for curl_multi_select function
    protected $post = [];
    protected $startTime;
    protected $endTime;

    // TODO: normalize headers key => value is key: value

    /**
     * @var RequestInterface[] $requests array of Requests
     */
    protected $requests;

    /**
     * @var callable[] $listeners array of listeners
     */
    protected $listeners = [];
    protected $mh;

    /**
     * Agent constructor.
     * @param int $max_concurrent max current requests
     */
    function __construct($max_concurrent = 10)

    {
        $this->setMaxConcurrent($max_concurrent);
    }

    /**
     * Set the maximum number of concurrent requests
     * @param int $max_requests maximum concurrent requests
     */
    public function setMaxConcurrent($max_requests)
    {
        if ($max_requests > 0) {
            $this->maxConcurrent = $max_requests;
        }
    }

    /**
     * Set global cUrl options
     * @param array $options array of options
     */
    public function setOptions(array $options)
    {
        if(!empty($options)) {
            $this->options += $options;
        }
    }

    /**
     * Set global cUrl headers
     * @param array $headers headers
     */
    public function setHeaders(array $headers)
    {
        if (!empty($headers)) {
            $this->headers += $headers;
        }
    }

    /**
     * Set global timeout
     * If individual requests don't have a timeout value, this will be used
     * @param int $timeout timeout in msec
     */
    public function setTimeout($timeout)
    {
        if ($timeout > 0) {
            $this->timeout = $timeout; // to seconds
        }
    }

    /**
     * Adds a new request to the queue and returns it
     * this request will have its default options set to global options
     * @param null $url URL to send the request to
     * @return RequestInterface the newly added request object
     */
    public function newRequest($url = null)
    {
        return $this->addRequest(new Request($url), true);
    }

    /**
     * Add a request to the request queue
     * @param RequestInterface $request the request to add
     * @return RequestInterface
     */
    public function addRequest(RequestInterface $request, $setGlobals = false)
    {
        $this->requests = $request;

        if($setGlobals) {
            if(!empty($this->post)) $request->post = $this->post;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            if(!empty($this->headers)) $request->headers = $this->headers;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            if(!empty($this->options)) $request->options = $this->options;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $request->timeout = $this->timeout;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }
        return $request;
    }

    /**
     * Returns the Request object for a give cUrl handle
     * @param mixed $handle
     * @return RequestInterface request with handle
     */
    private function getRequestByHandle($handle)
    {
        foreach($this->requests as $request) {
            if($request->handle === $handle) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                return $request;
            }
        }
    }

    /**
     * Execute the request queue
     */
    public function execute()
    {
        $this->mh = curl_multi_init();

        foreach($this->requests as $key => $request) {
            curl_multi_add_handle($this->mh, $request->handle);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $request->startTimer();
            if($key >= $this->maxConcurrent) break;
        }

        do{
            do{
                $mh_status = curl_multi_exec($this->mh, $active);
            } while($mh_status == CURLM_CALL_MULTI_PERFORM);
            if($mh_status != CURLM_OK) {
                break;
            }

            // a request just completed, find out which one
            while($completed = curl_multi_info_read($this->mh)) {
                $request = $this->getRequestByHandle($completed['handle']);
                $request->callback($completed);
                curl_multi_remove_handle($this->mh, $completed['handle']);

                // TODO: Add the next request to the queue
            }

            usleep(15);
        } while ($active);
        curl_multi_close($this->mh);
    }
}
?>


1			<?php
2
3			namespace CurlX;
4
5			class Agent
6			{
7			protected $maxConcurrent = 0; //max. number of simultaneous connections allowed
8			protected $options = []; //shared cURL options
9			protected $headers = []; //shared cURL request headers
10			protected $timeout = 5000; //timeout used for curl_multi_select function
11			protected $post = [];
12			protected $startTime;
13			protected $endTime;
14
15			// TODO: normalize headers key => value is key: value
16
17			/**
18			* @var RequestInterface[] $requests array of Requests
19			*/
20			protected $requests;
21
22			/**
23			* @var callable[] $listeners array of listeners
24			*/
25			protected $listeners = [];
26			protected $mh;
27
28			/**
29			* Agent constructor.
30			* @param int $max_concurrent max current requests
31			*/
32			function __construct($max_concurrent = 10)
			0 ignored issues – show Best Practice introduced 2016-02-09 21:53 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
33			{
34			$this->setMaxConcurrent($max_concurrent);
35			}
36
37			/**
38			* Set the maximum number of concurrent requests
39			* @param int $max_requests maximum concurrent requests
40			*/
41			public function setMaxConcurrent($max_requests)
42			{
43			if ($max_requests > 0) {
44			$this->maxConcurrent = $max_requests;
45			}
46			}
47
48			/**
49			* Set global cUrl options
50			* @param array $options array of options
51			*/
52			public function setOptions(array $options)
53			{
54			if(!empty($options)) {
55			$this->options += $options;
56			}
57			}
58
59			/**
60			* Set global cUrl headers
61			* @param array $headers headers
62			*/
63			public function setHeaders(array $headers)
64			{
65			if (!empty($headers)) {
66			$this->headers += $headers;
67			}
68			}
69
70			/**
71			* Set global timeout
72			* If individual requests don't have a timeout value, this will be used
73			* @param int $timeout timeout in msec
74			*/
75			public function setTimeout($timeout)
76			{
77			if ($timeout > 0) {
78			$this->timeout = $timeout; // to seconds
79			}
80			}
81
82			/**
83			* Adds a new request to the queue and returns it
84			* this request will have its default options set to global options
85			* @param null $url URL to send the request to
86			* @return RequestInterface the newly added request object
87			*/
88			public function newRequest($url = null)
89			{
90			return $this->addRequest(new Request($url), true);
91			}
92
93			/**
94			* Add a request to the request queue
95			* @param RequestInterface $request the request to add
96			* @return RequestInterface
97			*/
98			public function addRequest(RequestInterface $request, $setGlobals = false)
99			{
100			$this->requests = $request;
			0 ignored issues – show Documentation Bug introduced 2016-02-09 21:53 UTC by Report Bug Copy Issue Report It seems like `$request` of type `object<CurlX\RequestInterface>` is incompatible with the declared type `array<integer,object<CurlX\RequestInterface>>` of property `$requests`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
101			if($setGlobals) {
102			if(!empty($this->post)) $request->post = $this->post;
			0 ignored issues – show Bug introduced 2016-02-09 21:53 UTC by Report Bug Copy Issue Report Accessing `post` on the interface `CurlX\RequestInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
103			if(!empty($this->headers)) $request->headers = $this->headers;
			0 ignored issues – show Bug introduced 2016-02-09 21:53 UTC by Report Bug Copy Issue Report Accessing `headers` on the interface `CurlX\RequestInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
104			if(!empty($this->options)) $request->options = $this->options;
			0 ignored issues – show Bug introduced 2016-02-09 21:53 UTC by Report Bug Copy Issue Report Accessing `options` on the interface `CurlX\RequestInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
105			$request->timeout = $this->timeout;
			0 ignored issues – show Bug introduced 2016-02-09 21:53 UTC by Report Bug Copy Issue Report Accessing `timeout` on the interface `CurlX\RequestInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
106			}
107			return $request;
108			}
109
110			/**
111			* Returns the Request object for a give cUrl handle
112			* @param mixed $handle
113			* @return RequestInterface request with handle
114			*/
115			private function getRequestByHandle($handle)
116			{
117			foreach($this->requests as $request) {
118			if($request->handle === $handle) {
			0 ignored issues – show Bug introduced 2016-02-09 21:53 UTC by Report Bug Copy Issue Report Accessing `handle` on the interface `CurlX\RequestInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
119			return $request;
120			}
121			}
122			}
123
124			/**
125			* Execute the request queue
126			*/
127			public function execute()
128			{
129			$this->mh = curl_multi_init();
130
131			foreach($this->requests as $key => $request) {
132			curl_multi_add_handle($this->mh, $request->handle);
			0 ignored issues – show Bug introduced 2016-02-09 21:53 UTC by Report Bug Copy Issue Report Accessing `handle` on the interface `CurlX\RequestInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
133			$request->startTimer();
134			if($key >= $this->maxConcurrent) break;
135			}
136
137			do{
138			do{
139			$mh_status = curl_multi_exec($this->mh, $active);
140			} while($mh_status == CURLM_CALL_MULTI_PERFORM);
141			if($mh_status != CURLM_OK) {
142			break;
143			}
144
145			// a request just completed, find out which one
146			while($completed = curl_multi_info_read($this->mh)) {
147			$request = $this->getRequestByHandle($completed['handle']);
148			$request->callback($completed);
149			curl_multi_remove_handle($this->mh, $completed['handle']);
150
151			// TODO: Add the next request to the queue
152			}
153
154			usleep(15);
155			} while ($active);
156			curl_multi_close($this->mh);
157			}
158			}
159			?>
			0 ignored issues – show Best Practice introduced 2016-02-09 21:53 UTC by Report Bug Copy Issue Report It is not recommended to use PHP's closing tag `?>` in files other than templates. Using a closing tag in PHP files that only contain PHP code is not recommended as you might accidentally add whitespace after the closing tag which would then be output by PHP. This can cause severe problems, for example headers cannot be sent anymore. A simple precaution is to leave off the closing tag as it is not required, and it also has no negative effects whatsoever. Loading history...

half2me / curlx

Push — master ( 700166...f06841 )

Agent::setMaxConcurrent() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like