Http\Client\Socket\Client

Complexity

Total Complexity

18

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	sendRequest()	0	27	4
A	createSocket()	0	20	4
A	closeSocket()	0	4	1
A	configure()	0	17	1
B	determineRemoteFromRequest()	0	17	7

<?php

namespace Http\Client\Socket;

use Http\Client\Exception\NetworkException;
use Http\Client\HttpClient;
use Http\Message\MessageFactory;
use Psr\Http\Message\RequestInterface;
use Symfony\Component\OptionsResolver\Options;
use Symfony\Component\OptionsResolver\OptionsResolver;

/**
 * Socket Http Client
 *
 * Use stream and socket capabilities of the core of PHP to send HTTP requests
 *
 * @author Joel Wurtz <joel.wurtz@gmail.com>
 */
class Client implements HttpClient
{
    use RequestWriter;
    use ResponseReader;

    private $config = [
        'remote_socket'          => null,
        'timeout'                => null,
        'stream_context_options' => array(),
        'stream_context_param'   => array(),
        'ssl'                    => null,
        'write_buffer_size'      => 8192,
        'ssl_method'             => STREAM_CRYPTO_METHOD_TLS_CLIENT
    ];

    /**
     * @param MessageFactory $messageFactory
     * @param array          $config
     */
    public function __construct(MessageFactory $messageFactory, array $config = [])
    {
        $this->messageFactory = $messageFactory;
        $this->config = $this->configure($config);
    }

    /**
     * {@inheritdoc}
     */
    public function sendRequest(RequestInterface $request)
    {
        $remote  = $this->config['remote_socket'];
        $useSsl  = $this->config['ssl'];
        $request = $request->withHeader('Connection', 'close');

        if (null === $remote) {
            $remote = $this->determineRemoteFromRequest($request);
        }

        if (null === $useSsl) {
            $useSsl = ($request->getUri()->getScheme() == "https");
        }

        $socket = $this->createSocket($request, $remote, $useSsl);

        try {
            $this->writeRequest($socket, $request, $this->config['write_buffer_size']);
            $response = $this->readResponse($request, $socket);
        } catch (\Exception $e) {
            $this->closeSocket($socket);

            throw $e;
        }

        return $response;
    }

    /**
     * Create the socket to write request and read response on it
     *
     * @param RequestInterface $request Request for
     * @param string           $remote  Entrypoint for the connection
     * @param boolean          $useSsl  Whether to use ssl or not
     *
     * @throws NetworkException
     *
     * @return resource
     */
    protected function createSocket(RequestInterface $request, $remote, $useSsl)
    {
        $errNo  = null;
        $errMsg = null;
        $socket = @stream_socket_client($remote, $errNo, $errMsg, floor($this->config['timeout'] / 1000), STREAM_CLIENT_CONNECT, $this->config['stream_context']);

        if (false === $socket) {
            throw new NetworkException($errMsg, $request);
        }

        stream_set_timeout($socket, floor($this->config['timeout'] / 1000), $this->config['timeout'] % 1000);

        if ($useSsl) {
            if (false === @stream_socket_enable_crypto($socket, true, $this->config['ssl_method'])) {
                throw new NetworkException(sprintf('Cannot enable tls: %s', error_get_last()['message']), $request);
            }
        }

        return $socket;
    }

    /**
     * Close the socket, used when having an error
     *
     * @param resource $socket
     */
    protected function closeSocket($socket)
    {
        fclose($socket);
    }

    /**
     * Return configuration for the socket client
     *
     * @param array $config Configuration from user
     *
     * @return array Configuration resolved
     */
    protected function configure(array $config = [])
    {
        $resolver = new OptionsResolver();
        $resolver->setDefaults($this->config);
        $resolver->setDefault('stream_context', function (Options $options) {
            return stream_context_create($options['stream_context_options'], $options['stream_context_param']);
        });

        $resolver->setDefault('timeout', ini_get('default_socket_timeout') * 1000);

        $resolver->setAllowedTypes('stream_context_options', 'array');
        $resolver->setAllowedTypes('stream_context_param', 'array');
        $resolver->setAllowedTypes('stream_context', 'resource');
        $resolver->setAllowedTypes('ssl', ['bool', 'null']);

        return $resolver->resolve($config);
    }

    /**
     * Return remote socket from the request
     *
     * @param RequestInterface $request
     *
     * @throws NetworkException When no remote can be determined from the request
     *
     * @return string
     */
    private function determineRemoteFromRequest(RequestInterface $request)
    {
        if ($request->getUri()->getHost() == "" && !$request->hasHeader('Host')) {
            throw new NetworkException("Cannot find connection endpoint for this request", $request);
        }

        $host = $request->getUri()->getHost();
        $port = $request->getUri()->getPort() ?: ($request->getUri()->getScheme() == "https" ? 443 : 80);
        $endpoint = sprintf("%s:%s", $host, $port);

        // If use the host header if present for the endpoint
        if (empty($host) && $request->hasHeader('Host')) {
            $endpoint = $request->getHeaderLine('Host');
        }

        return sprintf('tcp://%s', $endpoint);
    }
}