Agent::__construct() - Code Metrics - half2me/curlx - Measure and Improve Code Quality continuously with Scrutinizer

Agent::__construct() A
last analyzed 2016-03-03 09:55 UTC

↳ Parent: Agent

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	0	Features	0

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

<?php

namespace CurlX;

/**
 * Class Agent
 * @package CurlX
 *
 * @property int $max_concurrent The maximum number of simultaneous connections allowed
 * @property int $maxConcurrent The maximum number of simultaneous connections allowed
 * @property string $url default url for requests
 * @property array $post_data array of default post data for requests
 * @property float $time running time of the agent
 * @property int $timeout default timeout (in msec) for requests
 * @property array $options default cUrl options for requests
 * @property array $headers default headers for requests
 * @property resource $handle cUrl Multi Handle
 * @property callable[] $listeners array of registered listeners which will be registered to newly created requests
 * @property array $response responses of the individual requests
 */
class Agent
{
    /**
     * @var array results
     */
    protected $result;

    /**
     * @var array responses
     */
    protected $response;

    /**
     * @var int The maximum number of simultaneous connections allowed
     */
    protected $maxConcurrent = 0;

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

    /**
     * @var Request default request
     */
    protected $defaultRequest;

    /**
     * @var resource cUrl Multi Handle
     */
    protected $mh;

    protected $requestCounter = 0;

    /**
     * Agent constructor.
     * @param int $maxConcurrent max current requests
     */
    public function __construct($maxConcurrent = 10)
    {
        $this->setMaxConcurrent($maxConcurrent);
        $this->defaultRequest = new Request();
        $this->mh = curl_multi_init();
    }

    /**
     * Destructor
     */
    public function __destruct()
    {
        curl_multi_close($this->mh);
    }

    /**
     * Magic setter function
     * @param string $name attribute to set
     * @param mixed $value the new value
     * @return void
     */
    public function __set($name, $value)
    {
        $c = Request::camelize($name);
        $m = "set$c";
        if (method_exists($this, $m)) {
            $this->$m($value);
        } else {
            $this->defaultRequest->__set($name, $value);
        }
    }

    /**
     * Magic getter function
     * @param string $name of the attribute to get
     * @return mixed the attribute's value
     */
    public function __get($name)
    {
        $c = Request::camelize($name);
        $m = "get$c";
        if (method_exists($this, $m)) {
            return $this->$m();
        } else {
            return $this->defaultRequest->__get($name);
        }
    }

    /**
     * Add a default listener to be added to all new Requests
     * @param callable $listener the listener
     * @return void
     */
    public function addListener(callable $listener)
    {
        $this->defaultRequest->addListener($listener);
    }

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

    /**
     * Get the currently set value of maxConcurrent
     * @return int maximum number of concurrent requests
     */
    public function getMaxConcurrent()
    {
        return $this->maxConcurrent;
    }

    /**
     * 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)
    {
        $request = clone $this->defaultRequest;
        $request->url = $url;
        return $this->addRequest($request);
    }

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

    /**
     * Returns the Request object for a give cUrl handle
     * @param resource $handle cUrl handle
     * @return RequestInterface Request with handle
     */
    protected 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
     * @return void
     */
    public function execute()
    {
        // start the first batch of requests
        $numOfRequests = count($this->requests);
        while ($this->requestCounter < $this->maxConcurrent && $this->requestCounter < $numOfRequests) {
            curl_multi_add_handle($this->mh, $this->requests[$this->requestCounter]->handle);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $this->requestCounter++;
        }

        do {
            while (($mrc = curl_multi_exec($this->mh, $running)) == CURLM_CALL_MULTI_PERFORM) {


            }
            if ($mrc != CURLM_OK) {
                break;
            }

            // a request was just completed -- find out which one
            while ($done = curl_multi_info_read($this->mh)) {
                // Callback
                $this->getRequestByHandle($done['handle'])->callBack($done);

                // start a new request
                if ($this->requestCounter < $numOfRequests) {
                    curl_multi_add_handle($this->mh, $this->requests[$this->requestCounter]->handle);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $this->requestCounter++;

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


Agent::__construct() A
last analyzed 2016-03-03 09:55 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace CurlX;
4
5			/**
6			* Class Agent
7			* @package CurlX
8			*
9			* @property int $max_concurrent The maximum number of simultaneous connections allowed
10			* @property int $maxConcurrent The maximum number of simultaneous connections allowed
11			* @property string $url default url for requests
12			* @property array $post_data array of default post data for requests
13			* @property float $time running time of the agent
14			* @property int $timeout default timeout (in msec) for requests
15			* @property array $options default cUrl options for requests
16			* @property array $headers default headers for requests
17			* @property resource $handle cUrl Multi Handle
18			* @property callable[] $listeners array of registered listeners which will be registered to newly created requests
19			* @property array $response responses of the individual requests
20			*/
21			class Agent
22			{
23			/**
24			* @var array results
25			*/
26			protected $result;
27
28			/**
29			* @var array responses
30			*/
31			protected $response;
32
33			/**
34			* @var int The maximum number of simultaneous connections allowed
35			*/
36			protected $maxConcurrent = 0;
37
38			/**
39			* @var RequestInterface[] array of Requests
40			*/
41			protected $requests;
42
43			/**
44			* @var Request default request
45			*/
46			protected $defaultRequest;
47
48			/**
49			* @var resource cUrl Multi Handle
50			*/
51			protected $mh;
52
53			protected $requestCounter = 0;
54
55			/**
56			* Agent constructor.
57			* @param int $maxConcurrent max current requests
58			*/
59			public function __construct($maxConcurrent = 10)
60			{
61			$this->setMaxConcurrent($maxConcurrent);
62			$this->defaultRequest = new Request();
63			$this->mh = curl_multi_init();
64			}
65
66			/**
67			* Destructor
68			*/
69			public function __destruct()
70			{
71			curl_multi_close($this->mh);
72			}
73
74			/**
75			* Magic setter function
76			* @param string $name attribute to set
77			* @param mixed $value the new value
78			* @return void
79			*/
80			public function __set($name, $value)
81			{
82			$c = Request::camelize($name);
83			$m = "set$c";
84			if (method_exists($this, $m)) {
85			$this->$m($value);
86			} else {
87			$this->defaultRequest->__set($name, $value);
88			}
89			}
90
91			/**
92			* Magic getter function
93			* @param string $name of the attribute to get
94			* @return mixed the attribute's value
95			*/
96			public function __get($name)
97			{
98			$c = Request::camelize($name);
99			$m = "get$c";
100			if (method_exists($this, $m)) {
101			return $this->$m();
102			} else {
103			return $this->defaultRequest->__get($name);
104			}
105			}
106
107			/**
108			* Add a default listener to be added to all new Requests
109			* @param callable $listener the listener
110			* @return void
111			*/
112			public function addListener(callable $listener)
113			{
114			$this->defaultRequest->addListener($listener);
115			}
116
117			/**
118			* Set the maximum number of concurrent requests
119			* @param int $maxConcurrent maximum concurrent requests
120			* @return void
121			*/
122			public function setMaxConcurrent($maxConcurrent)
123			{
124			if ($maxConcurrent > 0) {
125			$this->maxConcurrent = $maxConcurrent;
126			}
127			}
128
129			/**
130			* Get the currently set value of maxConcurrent
131			* @return int maximum number of concurrent requests
132			*/
133			public function getMaxConcurrent()
134			{
135			return $this->maxConcurrent;
136			}
137
138			/**
139			* Adds a new request to the queue and returns it
140			* this request will have its default options set to global options
141			* @param null $url URL to send the request to
142			* @return RequestInterface the newly added request object
143			*/
144			public function newRequest($url = null)
145			{
146			$request = clone $this->defaultRequest;
147			$request->url = $url;
148			return $this->addRequest($request);
149			}
150
151			/**
152			* Add a request to the request queue
153			* @param RequestInterface $request the request to add
154			* @return RequestInterface
155			*/
156			public function addRequest(RequestInterface $request)
157			{
158			$this->requests[] = $request;
159			return $request;
160			}
161
162			/**
163			* Returns the Request object for a give cUrl handle
164			* @param resource $handle cUrl handle
165			* @return RequestInterface Request with handle
166			*/
167			protected function getRequestByHandle($handle)
168			{
169			foreach ($this->requests as $request) {
170			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...
171			return $request;
172			}
173			}
174			}
175
176			/**
177			* Execute the request queue
178			* @return void
179			*/
180			public function execute()
181			{
182			// start the first batch of requests
183			$numOfRequests = count($this->requests);
184			while ($this->requestCounter < $this->maxConcurrent && $this->requestCounter < $numOfRequests) {
185			curl_multi_add_handle($this->mh, $this->requests[$this->requestCounter]->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...
186			$this->requestCounter++;
187			}
188
189			do {
190			while (($mrc = curl_multi_exec($this->mh, $running)) == CURLM_CALL_MULTI_PERFORM) {
			0 ignored issues – show Unused Code introduced 2016-02-12 20:52 UTC by Report Bug Copy Issue Report This `while` loop is empty and can be removed. This check looks for `while` loops that have no statements or where all statements have been commented out. This may be the result of changes for debugging or the code may simply be obsolete. Consider removing the loop. Loading history...
191
192			}
193			if ($mrc != CURLM_OK) {
194			break;
195			}
196
197			// a request was just completed -- find out which one
198			while ($done = curl_multi_info_read($this->mh)) {
199			// Callback
200			$this->getRequestByHandle($done['handle'])->callBack($done);
201
202			// start a new request
203			if ($this->requestCounter < $numOfRequests) {
204			curl_multi_add_handle($this->mh, $this->requests[$this->requestCounter]->handle);
			0 ignored issues – show Bug introduced 2016-02-12 18:09 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...
205			$this->requestCounter++;
206
207			// remove the curl handle that just completed
208			curl_multi_remove_handle($this->mh, $done['handle']);
209			}
210			}
211			} while ($running);
212			}
213			}
214

half2me / curlx

Agent::__construct() A last analyzed 2016-03-03 09:55 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

Agent::__construct() A
last analyzed 2016-03-03 09:55 UTC