Tarantool\Client\Connection\StreamConnection

Complexity

Total Complexity

21

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	createUds()	0	4	1
A	__construct()	0	5	1
A	createTcp()	0	10	2
A	create()	0	6	2
B	open()	0	42	7
A	close()	0	10	2
A	isClosed()	0	4	1
A	send()	0	12	2
A	read()	0	11	3

<?php

/**
 * This file is part of the Tarantool Client package.
 *
 * (c) Eugene Leonovich <gen.work@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Tarantool\Client\Connection;

use Tarantool\Client\Exception\CommunicationFailed;
use Tarantool\Client\Exception\ConnectionFailed;
use Tarantool\Client\Packer\PacketLength;

final class StreamConnection implements Connection
{
    public const DEFAULT_URI = 'tcp://127.0.0.1:3301';

    private const DEFAULT_OPTIONS = [
        'connect_timeout' => 5,
        'socket_timeout' => 5,
        'tcp_nodelay' => true,
        'persistent' => false,
    ];

    /** @var resource|null */
    private $stream;

    /** @var resource|null */
    private $streamContext;

    /** @var string */
    private $uri;

    /** @var non-empty-array<string, mixed> */
    private $options;

    /** @var Greeting|null */
    private $greeting;

    /**
     * @param string $uri
     * @param array<string, mixed> $options
     */
    private function __construct($uri, $options)
    {
        $this->uri = $uri;
        $this->options = $options + self::DEFAULT_OPTIONS;
    }

    public static function createTcp(string $uri = self::DEFAULT_URI, array $options = []) : self
    {
        $self = new self($uri, $options);

        if ($self->options['tcp_nodelay'] ?? false) {
            $self->streamContext = \stream_context_create(['socket' => ['tcp_nodelay' => true]]);
        }

        return $self;
    }

    public static function createUds(string $uri, array $options = []) : self
    {
        return new self($uri, $options);
    }

    public static function create(string $uri, array $options = []) : self
    {
        return 0 === \strpos($uri, 'unix://')
            ? self::createUds($uri, $options)
            : self::createTcp($uri, $options);
    }

    /**
     * @see https://github.com/vimeo/psalm/issues/3021
     * @psalm-suppress InvalidNullableReturnType
     */
    public function open() : Greeting
    {
        if (\is_resource($this->stream)) {
            /** @see https://github.com/vimeo/psalm/issues/3021 */
            /** @psalm-suppress NullableReturnStatement */
            return $this->greeting;
        }

        $flags = $this->options['persistent']
            ? \STREAM_CLIENT_CONNECT | \STREAM_CLIENT_PERSISTENT
            : \STREAM_CLIENT_CONNECT;

        $stream = $this->streamContext ? @\stream_socket_client(
            $this->uri,
            $errorCode,
            $errorMessage,
            (float) $this->options['connect_timeout'],
            $flags,
            $this->streamContext
        ) : @\stream_socket_client(
            $this->uri,
            $errorCode,
            $errorMessage,
            (float) $this->options['connect_timeout'],
            $flags
        );

        if (false === $stream) {
            throw ConnectionFailed::fromUriAndReason($this->uri, $errorMessage);
        }

        $this->stream = $stream;
        \stream_set_timeout($this->stream, $this->options['socket_timeout']);

        if ($this->options['persistent'] && \ftell($this->stream)) {
            return $this->greeting = Greeting::unknown();

It seems like \Tarantool\Client\Connection\Greeting::unknown() of type object<self> is incompatible with the declared type object<Tarantool\Client\Connection\Greeting>|null of property $greeting.

        }

        $greeting = $this->read(Greeting::SIZE_BYTES, 'Unable to read greeting');

        return $this->greeting = Greeting::parse($greeting);

It seems like \Tarantool\Client\Connection\Greeting::parse($greeting) of type object<self> is incompatible with the declared type object<Tarantool\Client\Connection\Greeting>|null of property $greeting.

    }

    public function close() : void
    {
        if (\is_resource($this->stream)) {
            /** @psalm-suppress InvalidPropertyAssignmentValue */
            \fclose($this->stream);
        }

        $this->stream = null;
        $this->greeting = null;
    }

    public function isClosed() : bool
    {
        return !\is_resource($this->stream);
    }

    public function send(string $data) : string
    {
        /** @psalm-suppress PossiblyNullArgument */
        if (!\fwrite($this->stream, $data)) {
            throw new CommunicationFailed('Unable to write request');
        }

        $length = $this->read(PacketLength::SIZE_BYTES, 'Unable to read response length');
        $length = PacketLength::unpack($length);

        return $this->read($length, 'Unable to read response');
    }

    private function read(int $length, string $errorMessage) : string
    {
        /** @psalm-suppress PossiblyNullArgument */
        if ($data = \stream_get_contents($this->stream, $length)) {
            return $data;
        }

        /** @psalm-suppress PossiblyNullArgument */
        $meta = \stream_get_meta_data($this->stream);
        throw new CommunicationFailed($meta['timed_out'] ? 'Read timed out' : $errorMessage);
    }
}