AsyncSockets\RequestExecutor\Metadata\SocketBag

Complexity

Total Complexity

21

Size/Duplication

Total Lines	196
Duplicated Lines	9.18 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

91.89%

Importance

Changes	7
Bugs	0	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	count()	0	4	1
A	getSocketOperation()	0	4	1
A	setSocketOperation()	0	4	1
A	removeSocket()	0	14	4
A	__construct()	0	7	1
B	addSocket()	0	30	3
A	hasSocket()	0	5	1
A	postponeSocket()	9	9	2
A	getSocketMetaData()	0	4	1
A	setSocketMetaData()	0	17	2
A	getOperationStorageKey()	0	4	1
A	requireOperation()	9	9	2
A	getItems()	0	4	1

<?php
/**
 * Async sockets
 *
 * @copyright Copyright (c) 2015, Efimov Evgenij <edefimov.it@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */
namespace AsyncSockets\RequestExecutor\Metadata;

use AsyncSockets\Operation\OperationInterface;
use AsyncSockets\RequestExecutor\EventHandlerInterface;
use AsyncSockets\RequestExecutor\RequestExecutorInterface;
use AsyncSockets\RequestExecutor\SocketBagInterface;
use AsyncSockets\Socket\SocketInterface;

/**
 * Class SocketBag
 */
class SocketBag implements SocketBagInterface
{
    /**
     * RequestExecutorInterface
     *
     * @var RequestExecutorInterface
     */
    private $executor;

    /**
     * Target metadata items
     *
     * @var OperationMetadata[]
     */
    private $items;

    /**
     * Default connection timeout
     *
     * @var double
     */
    private $connectTimeout;

    /**
     * Default I/O timeout
     *
     * @var double
     */
    private $ioTimeout;

    /**
     * SocketBag constructor.
     *
     * @param RequestExecutorInterface $executor Owner RequestExecutor
     * @param double                   $connectTimeout Default connection timeout
     * @param double                   $ioTimeout Default I/O timeout
     */
    public function __construct(RequestExecutorInterface $executor, $connectTimeout, $ioTimeout)
    {
        $this->executor       = $executor;
        $this->items          = [ ];
        $this->connectTimeout = $connectTimeout;
        $this->ioTimeout      = $ioTimeout;
    }

    /** {@inheritdoc} */
    public function count()
    {
        return count($this->items);
    }


    /** {@inheritdoc} */
    public function addSocket(
        SocketInterface $socket,
        OperationInterface $operation,
        array $metadata = null,
        EventHandlerInterface $eventHandlers = null
    ) {
        $hash = $this->getOperationStorageKey($socket);
        if (isset($this->items[$hash])) {
            throw new \LogicException('Can not add socket twice.');
        }

        $meta = array_merge(
            [
                RequestExecutorInterface::META_ADDRESS               => null,
                RequestExecutorInterface::META_USER_CONTEXT          => null,
                RequestExecutorInterface::META_SOCKET_STREAM_CONTEXT => null,
                RequestExecutorInterface::META_CONNECTION_TIMEOUT    => $this->connectTimeout,
                RequestExecutorInterface::META_IO_TIMEOUT            => $this->ioTimeout,
            ],
            $metadata ?: [],
            [
                RequestExecutorInterface::META_CONNECTION_START_TIME  => null,
                RequestExecutorInterface::META_CONNECTION_FINISH_TIME => null,
                RequestExecutorInterface::META_LAST_IO_START_TIME     => null,
                RequestExecutorInterface::META_REQUEST_COMPLETE       => false,
            ]
        );

        $this->items[$hash] = new OperationMetadata($socket, $operation, $meta, $eventHandlers);
    }

    /** {@inheritdoc} */
    public function getSocketOperation(SocketInterface $socket)
    {
        return $this->requireOperation($socket)->getOperation();
    }

    /** {@inheritdoc} */
    public function setSocketOperation(SocketInterface $socket, OperationInterface $operation)
    {
        $this->requireOperation($socket)->setOperation($operation);
    }


    /** {@inheritdoc} */
    public function hasSocket(SocketInterface $socket)
    {
        $hash = $this->getOperationStorageKey($socket);
        return isset($this->items[$hash]);
    }

    /** {@inheritdoc} */
    public function removeSocket(SocketInterface $socket)
    {
        $key = $this->getOperationStorageKey($socket);
        if (!isset($this->items[$key])) {
            return;
        }

        $meta = $this->items[$key]->getMetadata();
        if (!$meta[RequestExecutorInterface::META_REQUEST_COMPLETE] && $this->executor->isExecuting()) {
            throw new \LogicException('Can not remove unprocessed socket during request processing.');
        }

        unset($this->items[$key]);
    }

    /** {@inheritdoc} */
    public function postponeSocket(SocketInterface $socket)

This method seems to be duplicated in your project.

    {
        $key = $this->getOperationStorageKey($socket);
        if (!isset($this->items[$key])) {
            return;
        }

        $this->items[$key]->postpone();
    }

    /** {@inheritdoc} */
    public function getSocketMetaData(SocketInterface $socket)
    {
        return $this->requireOperation($socket)->getMetadata();
    }

    /** {@inheritdoc} */
    public function setSocketMetaData(SocketInterface $socket, $key, $value = null)
    {
        $writableKeys = [
            RequestExecutorInterface::META_ADDRESS               => 1,
            RequestExecutorInterface::META_USER_CONTEXT          => 1,
            RequestExecutorInterface::META_CONNECTION_TIMEOUT    => 1,
            RequestExecutorInterface::META_IO_TIMEOUT            => 1,
            RequestExecutorInterface::META_SOCKET_STREAM_CONTEXT => 1,
        ];

        if (!is_array($key)) {
            $key = [ $key => $value ];
        }

        $key = array_intersect_key($key, $writableKeys);
        $this->requireOperation($socket)->setMetadata($key);
    }

    /**
     * Return socket key in internal storage
     *
     * @param SocketInterface $socket Socket object
     *
     * @return string
     */
    private function getOperationStorageKey(SocketInterface $socket)
    {
        return spl_object_hash($socket);
    }

    /**
     * Require operation metadata for given socket
     *
     * @param SocketInterface $socket Socket object
     *
     * @return OperationMetadata
     * @throws \OutOfBoundsException
     */
    private function requireOperation(SocketInterface $socket)

This method seems to be duplicated in your project.

    {
        $hash = $this->getOperationStorageKey($socket);
        if (!isset($this->items[$hash])) {
            throw new \OutOfBoundsException('Trying to perform operation on not added socket.');
        }

        return $this->items[$hash];
    }

    /**
     * Return metadata items
     *
     * @return OperationMetadata[]
     */
    public function getItems()
    {
        return $this->items;
    }
}