EasyHttp\Client

Complexity

Total Complexity

53

Size/Duplication

Total Lines	457
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	create_curl_handler()	0	19	6
A	get_chunk_size()	0	9	2
A	setTempPath()	0	8	2
B	bulk()	0	60	11
A	__construct()	0	4	1
A	get_file_size()	0	16	2
B	set_curl_options()	0	49	7
A	get_file_type()	0	3	1
A	upload()	0	17	3
A	setHasSelfSignedCertificate()	0	3	1
A	handle_media()	0	20	5
B	download()	0	63	8
A	request()	0	28	4

<?php

namespace EasyHttp;

use CurlHandle;
use EasyHttp\Enums\ErrorCode;
use EasyHttp\Model\DownloadResult;
use EasyHttp\Model\HttpOptions;
use EasyHttp\Model\HttpResponse;
use EasyHttp\Traits\ClientTrait;
use EasyHttp\Util\Utils;
use InvalidArgumentException;
use RuntimeException;

/**
 * Client
 *
 * @link    https://github.com/shahradelahi/easy-http
 * @author  Shahrad Elahi (https://github.com/shahradelahi)
 * @license https://github.com/shahradelahi/easy-http/blob/master/LICENSE (MIT License)
 */
class Client
{

    use ClientTrait;

    /**
     * This variable is used to defied is certificate self-signed or not
     *
     * @var bool
     */
    private bool $isSelfSigned = true;

    /**
     * The temp directory to download files - default is $_SERVER['TEMP']
     *
     * @var ?string
     */
    private ?string $tempDir;

    /**
     * The Max count of chunk to download file
     *
     * @var int
     */
    public int $maxChunkCount = 10;

    /**
     * The constructor of the client
     */
    public function __construct()
    {
        $this->tempDir = $_SERVER['TEMP'] ?? null;
        $this->setHasSelfSignedCertificate(true);
    }

    /**
     * Set has self-signed certificate
     *
     * This is used to set the curl option CURLOPT_SSL_VERIFYPEER
     * and CURLOPT_SSL_VERIFYHOST to false. This is useful when you are
     * in local environment, or you have self-signed certificate.
     *
     * @param bool $has
     *
     * @return void
     */
    public function setHasSelfSignedCertificate(bool $has): void
    {
        $this->isSelfSigned = $has;
    }

    /**
     * Set the temporary directory path to save the downloaded files
     *
     * @param string $path
     *
     * @return void
     */
    public function setTempPath(string $path): void
    {
        if (!file_exists($path)) {
            throw new InvalidArgumentException(
                sprintf('The path "%s" does not exist', $path)
            );
        }
        $this->tempDir = $path;
    }

    /**
     * This method is used to send a http request to a given url.
     *
     * @param string $method
     * @param string $uri
     * @param array|HttpOptions $options
     *
     * @return HttpResponse
     */
    public function request(string $method, string $uri, array|HttpOptions $options = []): HttpResponse
    {
        $CurlHandle = $this->create_curl_handler($method, $uri, $options);
        if (!$CurlHandle) throw new RuntimeException(
            'An error occurred while creating the curl handler'
        );

        $result = new HttpResponse();
        $result->setCurlHandle($CurlHandle);

        $response = curl_exec($CurlHandle);
        if (curl_errno($CurlHandle) || !$response) {
            $result->setErrorCode(curl_errno($CurlHandle));
            $result->setErrorMessage(
                curl_error($CurlHandle) ??
                ErrorCode::getMessage(curl_errno($CurlHandle))
            );
            return $result;
        }

        $result->setStatusCode(curl_getinfo($CurlHandle, CURLINFO_HTTP_CODE));
        $result->setHeaderSize(curl_getinfo($CurlHandle, CURLINFO_HEADER_SIZE));
        $result->setHeaders(substr((string)$response, 0, $result->getHeaderSize()));
        $result->setBody(substr((string)$response, $result->getHeaderSize()));

        curl_close($CurlHandle);

        return $result;
    }

    /**
     * Send multiple requests to a given url.
     *
     * @param array $requests [{method, uri, options}, ...]
     *
     * @return array<HttpResponse>
     */
    public function bulk(array $requests): array
    {
        $result = [];
        $handlers = [];
        $multi_handler = curl_multi_init();
        foreach ($requests as $request) {

            $CurlHandle = $this->create_curl_handler(
                $request['method'] ?? null,
                $request['uri'],
                $request['options'] ?? []
            );
            if (!$CurlHandle) throw new RuntimeException(
                'An error occurred while creating the curl handler'
            );
            $handlers[] = $CurlHandle;
            curl_multi_add_handle($multi_handler, $CurlHandle);

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

        }

        $active = null;
        do {
            $mrc = curl_multi_exec($multi_handler, $active);

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

        } while ($mrc == CURLM_CALL_MULTI_PERFORM);

        while ($active && $mrc == CURLM_OK) {
            if (curl_multi_select($multi_handler) != -1) {

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

                do {
                    $mrc = curl_multi_exec($multi_handler, $active);
                } while ($mrc == CURLM_CALL_MULTI_PERFORM);
            }
        }

        foreach ($handlers as $handler) {
            curl_multi_remove_handle($multi_handler, $handler);

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

        }
        curl_multi_close($multi_handler);

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

        foreach ($handlers as $handler) {
            $content = curl_multi_getcontent($handler);
            $response = new HttpResponse();

            if (curl_errno($handler)) {
                $response->setErrorCode(curl_errno($handler));
                $response->setErrorMessage(
                    curl_error($handler) ??
                    ErrorCode::getMessage(curl_errno($handler))
                );
            }

            $response->setCurlHandle($handler);
            $response->setStatusCode(curl_getinfo($handler, CURLINFO_HTTP_CODE));
            $response->setHeaderSize(curl_getinfo($handler, CURLINFO_HEADER_SIZE));
            $response->setHeaders(substr($content, 0, $response->getHeaderSize()));
            $response->setBody(substr($content, $response->getHeaderSize()));

            $result[] = $response;
        }

        return $result;
    }

    /**
     * Create curl handler.
     *
     * @param ?string $method
     * @param string $uri
     * @param array|HttpOptions $options
     *
     * @return false|CurlHandle
     */
    private function create_curl_handler(?string $method, string $uri, array|HttpOptions $options = []): false|CurlHandle
    {
        $handler = curl_init();
        if (is_resource($handler) || !$handler) return false;

        if (gettype($options) === 'array') {
            $options = new HttpOptions($options);
        }

        if (count($options->getQuery()) > 0) {
            if (!str_contains($uri, '?')) $uri .= '?';
            $uri .= $options->getQueryString();
        }

        curl_setopt($handler, CURLOPT_URL, $uri);

        $this->set_curl_options($handler, $method, $options);

        return $handler;
    }

    /**
     * Download large files.
     *
     * This method is used to download large files with creating multiple requests.
     *
     * Change `max_chunk_count` variable to change the number of chunks. (default: 10)
     *
     * @param string $url The direct url to the file.
     * @param array|HttpOptions $options The options to use.
     *
     * @return DownloadResult
     */
    public function download(string $url, array|HttpOptions $options = []): DownloadResult
    {
        if (empty($this->tempDir)) {
            throw new RuntimeException(
                'The temp directory is not set. Please set the temp directory using the `setTempDir` method.'
            );
        }

        if (!file_exists($this->tempDir)) {
            if (mkdir($this->tempDir, 0777, true) === false) {
                throw new RuntimeException(
                    'The temp directory is not writable. Please set the temp directory using the `setTempDir` method.'
                );
            }
        }

        if (gettype($options) === 'array') {
            $options = new HttpOptions($options);
        }

        $fileSize = $this->get_file_size($url);
        $chunkSize = $this->get_chunk_size($fileSize);

        $result = new DownloadResult();

        $result->id = uniqid();
        $result->chunksPath = $this->tempDir . '/' . $result->id . '/';
        mkdir($result->chunksPath, 0777, true);

        $result->fileSize = $fileSize;
        $result->chunkSize = $chunkSize;
        $result->chunks = ceil($fileSize / $chunkSize);

        $result->startTime = time();

        $requests = [];
        for ($i = 0; $i < $result->chunks; $i++) {
            $range = $i * $chunkSize . '-' . ($i + 1) * $chunkSize;
            if ($i + 1 === $result->chunks) {
                $range = $i * $chunkSize . '-' . $fileSize;
            }
            $requests[] = [
                'method' => 'GET',
                'uri' => $url,
                'options' => array_merge($options->toArray(), [
                    'CurlOptions' => [
                        CURLOPT_RANGE => $range
                    ],
                ])
            ];
        }

        foreach ($this->bulk($requests) as $response) {
            $result->addChunk(
                Utils::randomString(16),
                $response->getBody(),
                $response->getInfoFromCurl()->TOTAL_TIME
            );
        }

        $result->endTime = time();

        return $result;
    }

    /**
     * Upload single or multiple files
     *
     * This method is sending file with request method of POST and
     * Content-Type of multipart/form-data.
     *
     * @param string $url The direct url to the file.
     * @param array $filePath The path to the file.
     * @param array|HttpOptions $options The options to use.
     *
     * @return HttpResponse
     */
    public function upload(string $url, array $filePath, array|HttpOptions $options = []): HttpResponse
    {
        if (gettype($options) === 'array') {
            $options = new HttpOptions($options);
        }

        $multipart = [];

        foreach ($filePath as $key => $file) {
            $multipart[$key] = new \CURLFile(
                realpath($file),
                $this->get_file_type($file)
            );
        }

        $options->setMultipart($multipart);
        return $this->post($url, $options);
    }

    /**
     * Setup curl options based on the given method and our options.
     *
     * @param CurlHandle $cHandler
     * @param ?string $method
     * @param HttpOptions $options
     *
     * @return void
     */
    private function set_curl_options(CurlHandle $cHandler, ?string $method, HttpOptions $options): void
    {
        curl_setopt($cHandler, CURLOPT_HEADER, true);
        curl_setopt($cHandler, CURLOPT_CUSTOMREQUEST, $method ?? 'GET');

        # Fetch the header
        $fetchedHeaders = [];
        foreach ($options->getHeader() as $header => $value) {
            $fetchedHeaders[] = $header . ': ' . $value;
        }

        # Set headers
        curl_setopt($cHandler, CURLOPT_HTTPHEADER, $fetchedHeaders ?? []);


        # Add body if we have one.
        if ($options->getBody()) {
            curl_setopt($cHandler, CURLOPT_CUSTOMREQUEST, $method ?? 'POST');
            curl_setopt($cHandler, CURLOPT_POSTFIELDS, $options->getBody());
            curl_setopt($cHandler, CURLOPT_POST, true);
        }

        # Check for a proxy
        if ($options->getProxy() != null) {
            curl_setopt($cHandler, CURLOPT_PROXY, $options->getProxy()->getHost());
            curl_setopt($cHandler, CURLOPT_PROXYUSERPWD, $options->getProxy()->getAuth());
            if ($options->getProxy()->type !== null) {
                curl_setopt($cHandler, CURLOPT_PROXYTYPE, $options->getProxy()->type);
            }
        }

        curl_setopt($cHandler, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($cHandler, CURLOPT_FOLLOWLOCATION, true);

        # Add and override the custom curl options.
        foreach ($options->getCurlOptions() as $option => $value) {
            curl_setopt($cHandler, $option, $value);
        }

        # if we have a timeout, set it.
        curl_setopt($cHandler, CURLOPT_TIMEOUT, $options->getTimeout());

        # If self-signed certs are allowed, set it.
        if ($this->isSelfSigned === true) {
            curl_setopt($cHandler, CURLOPT_SSL_VERIFYPEER, false);
            curl_setopt($cHandler, CURLOPT_SSL_VERIFYHOST, false);
        }

        $this->handle_media($cHandler, $options);
    }

    /**
     * Handle the media
     *
     * @param CurlHandle $handler
     * @param HttpOptions $options
     * @return void
     */
    private function handle_media(CurlHandle $handler, HttpOptions $options): void
    {
        if (count($options->getMultipart()) > 0) {
            curl_setopt($handler, CURLOPT_POST, true);
            curl_setopt($handler, CURLOPT_CUSTOMREQUEST, 'POST');

            $form_data = new FormData();
            foreach ($options->getMultipart() as $key => $value) {
                $form_data->addFile($key, $value);
            }

            $headers = [];
            foreach ($options->getHeader() as $header => $value) {
                if (Utils::insensitiveString($header, 'content-type')) continue;
                $headers[] = $header . ': ' . $value;
            }
            $headers[] = 'Content-Type: multipart/form-data';

            curl_setopt($handler, CURLOPT_HTTPHEADER, $headers);
            curl_setopt($handler, CURLOPT_POSTFIELDS, $form_data->getFiles());
        }
    }

    /**
     * Get filetype with the extension.
     *
     * @param string $filename The absolute path to the file.
     * @return string eg. image/jpeg
     */
    public static function get_file_type(string $filename): string
    {
        return MimeType::$TYPES[pathinfo($filename, PATHINFO_EXTENSION)] ?? 'application/octet-stream';
    }

    /**
     * Get file size.
     *
     * @param string $url The direct url to the file.
     * @return int
     */
    public function get_file_size(string $url): int
    {
        if (file_exists($url)) {
            return filesize($url);
        }

        $response = $this->get($url, [
            'headers' => [
                'User-Agent' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36',
            ],
            'CurlOptions' => [
                CURLOPT_NOBODY => true,
            ]
        ]);

        return (int)$response->getHeaderLine('Content-Length') ?? 0;
    }

    /**
     * Get the size of each chunk.
     *
     * For default, we're dividing filesize to 10 as max size of each chunk.
     * If the file size was smaller than 2MB, we'll use the filesize as single chunk.
     *
     * @param int $fileSize The file size.
     * @return int
     */
    private function get_chunk_size(int $fileSize): int
    {
        $maxChunkSize = $fileSize / $this->maxChunkCount;

        if ($fileSize <= 2 * 1024 * 1024) {
            return $fileSize;
        }

        return min($maxChunkSize, $fileSize);
    }

}