Dazzle\Redis\Redis

Complexity

Total Complexity

33

Size/Duplication

Total Lines	307
Duplicated Lines	5.21 %

Coupling/Cohesion

Components	1
Dependencies	22

Test Coverage

Coverage

60.61%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	__destruct()	0	4	1
A	isStarted()	0	4	1
A	isBusy()	0	4	1
B	start()	0	34	5
B	stop()	0	26	3
A	end()	0	11	3
A	dispatch()	0	17	2
A	handleStart()	8	8	2
A	handleStop()	8	8	2
B	handleMessage()	0	23	5
A	createClient()	0	15	3
B	handleData()	0	27	4

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 23 and the first side effect is on line 329.

namespace Dazzle\Redis;

use Clue\Redis\Protocol\Model\ErrorReply;
use Clue\Redis\Protocol\Model\ModelInterface;
use Clue\Redis\Protocol\Parser\ParserException;
use Dazzle\Event\BaseEventEmitter;
use Dazzle\Loop\LoopAwareTrait;
use Dazzle\Loop\LoopInterface;
use Dazzle\Promise\Deferred;
use Dazzle\Promise\PromiseInterface;
use Dazzle\Redis\Driver\Request;
use Dazzle\Redis\Driver\Driver;
use Dazzle\Redis\Driver\DriverInterface;
use Dazzle\Socket\Socket;
use Dazzle\Socket\SocketInterface;
use Dazzle\Throwable\Exception\Runtime\ExecutionException;
use Dazzle\Throwable\Exception\Runtime\UnderflowException;
use Error;
use Exception;

class Redis extends BaseEventEmitter implements RedisInterface
{
    use LoopAwareTrait;
    use Command\Compose\ApiChannelTrait;
    use Command\Compose\ApiClusterTrait;
    use Command\Compose\ApiConnTrait;
    use Command\Compose\ApiCoreTrait;
    use Command\Compose\ApiGeospatialTrait;
    use Command\Compose\ApiHyperLogTrait;
    use Command\Compose\ApiKeyValTrait;
    use Command\Compose\ApiListTrait;
    use Command\Compose\ApiSetTrait;
    use Command\Compose\ApiSetHashTrait;
    use Command\Compose\ApiSetSortedTrait;
    use Command\Compose\ApiTransactionTrait;

    /**
     * @var string
     */
    protected $endpoint;

    /**
     * @var SocketInterface
     */
    protected $stream;

    /**
     * @var DriverInterface
     */
    protected $driver;

    /**
     * @var bool
     */
    protected $isConnected;

    /**
     * @var bool
     */
    protected $isBeingDisconnected;

    /**
     * @var array
     */
    private $reqs;

    /**
     * @param string $endpoint
     * @param LoopInterface $loop
     */
    public function __construct($endpoint, LoopInterface $loop)
    {
        $this->endpoint = $endpoint;
        $this->loop = $loop;
        $this->stream = null;
        $this->driver = new Driver();

        $this->isConnected = false;
        $this->isBeingDisconnected = false;

        $this->reqs = [];
    }

    /**
     *
     */
    public function __destruct()
    {
        $this->stop();
    }

    /**
     * @override
     * @inheritDoc
     */
    public function isStarted()
    {
        return $this->isConnected;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function isBusy()
    {
        return !empty($this->reqs);
    }

    /**
     * @override
     * @inheritDoc
     */
    public function start()
    {
        if ($this->isStarted())
        {
            return false;
        }

        $ex = null;
        $stream = null;

        try
        {
            $stream = $this->createClient($this->endpoint);
        }
        catch (Error $ex)

Consider adding a comment why this CATCH block is empty.

        {}
        catch (Exception $ex)

Consider adding a comment why this CATCH block is empty.

        {}

        if ($ex !== null)
        {
            return false;
        }

        $this->isConnected = true;
        $this->isBeingDisconnected = false;
        $this->stream = $stream;

        // TODO patch missing pub/sub, pipeline, auth
        $this->handleStart();
        $this->emit('start', [ $this ]);

        return true;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function stop()
    {
        if (!$this->isStarted())
        {
            return false;
        }

        $this->isBeingDisconnected = true;
        $this->isConnected = false;

        $this->stream->close();
        $this->stream = null;

        foreach ($this->reqs as $req)
        {
            $req->reject(new ExecutionException('Connection has been closed!'));
        }

        $this->reqs = [];

         // TODO patch missing pub/sub, pipeline, auth
        $this->handleStop();
        $this->emit('stop', [ $this ]);

        return true;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function end()
    {
        if (!$this->isStarted() || $this->isBeingDisconnected)
        {
            return false;
        }

        $this->isBeingDisconnected = true;

        return true;
    }

    /**
     * Dispatch Redis request.
     *
     * @param Request $command
     * @return PromiseInterface
     */
    protected function dispatch(Request $command)
    {
        $request = new Deferred();
        $promise = $request->getPromise();

        if ($this->isBeingDisconnected)
        {
            $request->reject(new ExecutionException('Redis client connection is being stopped now.'));
        }
        else
        {
            $this->stream->write($this->driver->commands($command));
            $this->reqs[] = $request;
        }

        return $promise;
    }

    /**
     * @internal
     */
    protected function handleStart()

This method seems to be duplicated in your project.

    {
        if ($this->stream !== null)
        {
            $this->stream->on('data', [ $this, 'handleData' ]);
            $this->stream->on('close', [ $this, 'stop' ]);
        }
    }

    /**
     * @internal
     */
    protected function handleStop()

This method seems to be duplicated in your project.

    {
        if ($this->stream !== null)
        {
            $this->stream->removeListener('data', [ $this, 'handleData' ]);
            $this->stream->removeListener('close', [ $this, 'stop' ]);
        }
    }

    /**
     * @internal
     * @param SocketInterface $stream
     * @param string $chunk
     */
    public function handleData($stream, $chunk)
    {
        try
        {
            $models = $this->driver->parseResponse($chunk);
        }
        catch (ParserException $error)
        {
            $this->emit('error', [ $this, $error ]);
            $this->stop();
            return;
        }

        foreach ($models as $data)
        {
            try
            {
                $this->handleMessage($data);
            }
            catch (UnderflowException $error)
            {
                $this->emit('error', [ $this, $error ]);
                $this->stop();
                return;
            }
        }
    }

    /**
     * @internal
     * @param ModelInterface $message
     */
    protected function handleMessage(ModelInterface $message)
    {
        if (!$this->reqs)

The expression $this->reqs of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

        {
            throw new UnderflowException('Unexpected reply received, no matching request found');
        }

        $request = array_shift($this->reqs);

        if ($message instanceof ErrorReply)
        {
            $request->reject($message);
        }
        else
        {
            $request->resolve($message->getValueNative());
        }

        if ($this->isBeingDisconnected && !$this->isBusy())
        {
            $this->stop();
        }
    }

    /**
     * Create socket client with connection to Redis database.
     *
     * @param string $endpoint
     * @return SocketInterface
     * @throws ExecutionException
     */
    protected function createClient($endpoint)
    {
        $ex = null;

        try
        {
            return new Socket($endpoint, $this->loop);

It seems like $this->loop can be null; however, __construct() does not accept null, maybe add an additional type check?

        }
        catch (Error $ex)

Consider adding a comment why this CATCH block is empty.

        {}
        catch (Exception $ex)

Consider adding a comment why this CATCH block is empty.

        {}

        throw new ExecutionException('Redis connection socket could not be created!', 0, $ex);
    }
};