CurlX\Agent

Complexity

Total Complexity

25

Size/Duplication

Total Lines	154
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	6
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setMaxConcurrent()	0	6	2
A	setOptions()	0	6	2
A	setHeaders()	0	6	2
A	setTimeout()	0	6	2
A	newRequest()	0	4	1
B	addRequest()	0	11	5
A	getRequestByHandle()	0	8	3
C	execute()	0	31	7

<?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)

It is generally recommended to explicitly declare the visibility for methods.

    {
        $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;

It seems like $request of type object<CurlX\RequestInterface> is incompatible with the declared type array<integer,object<CurlX\RequestInterface>> of property $requests.

        if($setGlobals) {
            if(!empty($this->post)) $request->post = $this->post;

Accessing post on the interface CurlX\RequestInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            if(!empty($this->headers)) $request->headers = $this->headers;

Accessing headers on the interface CurlX\RequestInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            if(!empty($this->options)) $request->options = $this->options;

Accessing options on the interface CurlX\RequestInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $request->timeout = $this->timeout;

Accessing timeout on the interface CurlX\RequestInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
        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) {

Accessing handle on the interface CurlX\RequestInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                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);

Accessing handle on the interface CurlX\RequestInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $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);
    }
}
?>

It is not recommended to use PHP's closing tag ?> in files other than templates.