Redis::isBusy() - Code Metrics - Inspection of "Merge pull request #1 from dazzle-php/dev-travis" - dazzle-php/redis - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 52cc4c...9e125a )

by Kamil
created 2017-07-02 12:10 UTC
Redis::isBusy() A

↳ Parent: Redis
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes
Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1
<?php


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\Command\Enum;
use Dazzle\Redis\Driver\Request;
use Dazzle\Redis\Driver\Driver;
use Dazzle\Redis\Driver\DriverInterface;
use Dazzle\Redis\Command\Builder;
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;

    /**
     * @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)

        {}
        catch (Exception $ex)

        {}

        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()

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

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

    {
        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)

        {
            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);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        }
        catch (Error $ex)

        {}
        catch (Exception $ex)

        {}

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

    public function auth($password)
    {
        $command = Enum::AUTH;
        $args = [$password];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function append($key, $value)
    {
        $command = Enum::APPEND;
        $args = [$key, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function bgRewriteAoF()
    {
        $command = Enum::BGREWRITEAOF;

        return $this->dispatch(Builder::build($command));
    }

    public function bgSave()
    {
        $command = Enum::BGSAVE;

        return $this->dispatch(Builder::build($command));
    }

    public function bitCount($key, $start = 0, $end = 0)
    {
        $command = Enum::BITCOUNT;
        $args = [$key, $start, $end];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function bitField($key, $subCommand = null, ...$param)
    {
        $command = Enum::BITFIELD;
        switch ($subCommand = strtoupper($subCommand)) {
            case 'GET' : {
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                list ($type, $offset) = $param;
                $args = [$subCommand, $type, $offset];
                break;
            }
            case 'SET' : {
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                list ($type, $offset, $value) = $param;
                $args = [$subCommand, $type, $offset, $value];
                break;
            }
            case 'INCRBY' : {
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                list ($type, $offset, $increment) = $param;
                $args = [$type, $offset, $increment];
                break;
            }
            case 'OVERFLOW' : {
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                list ($behavior) = $param;
                $args = [$subCommand, $behavior];
                break;
            }
            default : {
switch ($expr) {
    default: { //wrong
        doSomething();
        break;
    }
}

switch ($expr) {
    default: //right
        doSomething();
        break;
}
                    $args = [];
                    break;
            }
        }
        $args = array_filter($args);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function bitOp($operation, $dstKey, $srcKey, ...$keys)
    {
        $command = Enum::BITOP;
        $args = [$operation, $dstKey, $srcKey];
        $args = array_merge($args, $keys);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function bitPos($key, $bit, $start = 0, $end = 0)
    {
        $command = Enum::BITPOS;
        $args = [$key, $bit, $start, $end];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function blPop(array $keys, $timeout)

    {
        // TODO: Implement blPop() method.
        $command = Enum::BLPOP;
        $keys[] = $timeout;
        $args = $keys;
        $promise = $this->dispatch(Builder::build($command, $args));
        $promise = $promise->then(function ($value) {
            if (is_array($value)) {
                list($k,$v) = $value;

                return [
                    'key'=>$k,
                    'value'=>$v
                ];
            }

            return $value;
        });

        return $promise;
    }

    public function brPop(array $keys, $timeout)

    {
        // TODO: Implement brPop() method.
        $command = Enum::BRPOP;
        $keys[] = $timeout;
        $args = $keys;
        $promise = $this->dispatch(Builder::build($command, $args));
        $promise = $promise->then(function ($value) {
            if (is_array($value)) {
                list($k,$v) = $value;

                return [
                    'key'=>$k,
                    'value'=>$v
                ];
            }

            return $value;
        });

        return $promise;
    }

    public function brPopLPush($src, $dst, $timeout)
    {
        // TODO: Implement brPopLPush() method.
        $command = Enum::BRPOPLPUSH;
        $args = [$src, $dst, $timeout];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function decr($key)

    {
        // TODO: Implement decr() method.
        $command = Enum::DECR;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function decrBy($key, $decrement)
    {
        // TODO: Implement decrBy() method.
        $command = Enum::DECRBY;
        $args = [$key, $decrement];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function del($key,...$keys)

    {
        $command = Enum::DEL;
        $keys[] = $key;
        $args = $keys;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function discard()
    {
        // TODO: Implement discard() method.
        $command = Enum::DISCARD;

        return $this->dispatch(Builder::build($command));
    }

    public function dump($key)

    {
        // TODO: Implement dump() method.
        $command = Enum::DUMP;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function exists($key, ...$keys)
    {
        // TODO: Implement exists() method.
        $command = Enum::EXISTS;
        $args = [$key];
        $args = array_merge($args, $keys);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function expire($key, $seconds)
    {
        // TODO: Implement expire() method.
        $command = Enum::EXPIRE;
        $args = [$key, $seconds];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function expireAt($key, $timestamp)
    {
        // TODO: Implement expireAt() method.
        $command = Enum::EXPIREAT;
        $args = [$key, $timestamp];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function get($key)

    {
        $command = Enum::GET;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function getBit($key, $offset)
    {
        // TODO: Implement getBit() method.
        $command = Enum::GETBIT;
        $args = [$key, $offset];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function getRange($key, $start, $end)
    {
        // TODO: Implement getRange() method.
        $command = Enum::GETRANGE;
        $args = [$key, $start, $end];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function getSet($key, $value)
    {
        // TODO: Implement getSet() method.
        $command = Enum::GETSET;
        $args = [$key, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function incr($key)

    {
        $command = Enum::INCR;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function incrBy($key, $increment)
    {
        // TODO: Implement incrBy() method.
        $command = Enum::INCRBY;
        $args = [$key, $increment];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function incrByFloat($key, $increment)
    {
        // TODO: Implement incrByFloat() method.
        $command = Enum::INCRBYFLOAT;
        $args = [$key, $increment];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function multi()
    {
        // TODO: Implement multi() method.
        $command = Enum::MULTI;

        return $this->dispatch(Builder::build($command));
    }

    public function persist($key)

    {
        $command = Enum::PERSIST;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function pExpire($key, $milliseconds)
    {
        // TODO: Implement pExpire() method.
        $command = Enum::PEXPIRE;
        $args = [$key, $milliseconds];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function pExpireAt($key, $milliseconds)
    {
        // TODO: Implement pExpireAt() method.
        $command = Enum::PEXPIREAT;
        $args = [$key, $milliseconds];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sync()
    {
        // TODO: Implement sync() method.
        $command = Enum::SYNC;

        return $this->dispatch(Builder::build($command));
    }

    public function time()
    {
        // TODO: Implement time() method.
        $command = Enum::TIME;

        return $this->dispatch(Builder::build($command));
    }

    public function touch($key, ...$keys)
    {
        $command = Enum::TOUCH;
        $args = [$key];
        $args = array_merge($args, $keys);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function ttl($key)

    {
        // TODO: Implement ttl() method.
        $command = Enum::TTL;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function type($key)

    {
        $command = Enum::TYPE;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function unLink($key, ...$keys)
    {
        $command = Enum::UNLINK;
        $args = [$key];
        $args = array_merge($args, $keys);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function unWatch()
    {
        // TODO: Implement unWatch() method.
        $command = Enum::UNWATCH;

        return $this->dispatch(Builder::build($command));
    }

    public function wait($numSlaves, $timeout)
    {
        // TODO: Implement wait() method.
        $command = Enum::WAIT;
        $args = [$numSlaves, $timeout];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function watch($key, ...$keys)
    {
        // TODO: Implement watch() method.
        $command = Enum::WATCH;
        $args = [$key];
        $args = array_merge($args, $keys);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function select($index)
    {
        // TODO: Implement select() method.
        $command = Enum::SELECT;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        return $this;
    }

    public function set($key, $value, array $options = [])
    {
        $command = Enum::SET;
        array_unshift($options, $key, $value);
        $args = $options;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function setBit($key, $offset, $value)
    {
        // TODO: Implement setBit() method.
        $command = Enum::SETBIT;
        $args = [$key, $offset, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function setEx($key, $seconds, $value)
    {
        $command = Enum::SETEX;
        $args = [$key, $seconds, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function setNx($key, $value)
    {
        $command = Enum::SETNX;
        $args = [$key, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function randomKey()
    {
        // TODO: Implement randomKey() method.
        $command = Enum::RANDOMKEY;

        return $this->dispatch(Builder::build($command));
    }

    public function readOnly()
    {
        // TODO: Implement readOnly() method.
        $command = Enum::READONLY;

        return $this->dispatch(Builder::build($command));
    }

    public function rename($key, $newKey)
    {
        $command = Enum::RENAME;
        $args = [$key, $newKey];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function renameNx($key, $newKey)
    {
        $command = Enum::RENAMENX;
        $args = [$key, $newKey];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function restore($key, $ttl, $value)
    {
        // TODO: Implement restore() method.
        $command = Enum::RESTORE;
        $args = [$key, $ttl, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function ping($message = 'PING')

    {
        $command = Enum::PING;
        $args = [$message];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function quit()
    {
        $command = Enum::QUIT;

        return $this->dispatch(Builder::build($command));
    }

    public function setRange($key, $offset, $value)
    {
        $command = Enum::SETRANGE;
        $args = [$key, $offset, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function pTtl($key)

    {
        $command = Enum::PTTL;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function pSetEx($key, $milliseconds, $value)
    {
        $command = Enum::PSETEX;
        $args = [$key, $milliseconds, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hDel($key, ...$fields)
    {
        $command = Enum::HDEL;
        $args = [$key];
        $args = array_merge($args, $fields);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hGet($key, $field)
    {
        $command = Enum::HGET;
        $args = [$key, $field];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hGetAll($key)
    {
        $command = Enum::HGETALL;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args))->then(function ($value) {
            if (!empty($value)) {
                $tmp = [];
                $size = count($value);
                for ($i=0; $i<$size; $i+=2) {
                    $field = $value[$i];
                    $val = $value[$i+1];
                    $tmp[$field] = $val;
                }
                $value = $tmp;
            }
        
            return $value;
        });
    }

    public function hIncrBy($key, $field, $increment)
    {
        $command = Enum::HINCRBY;
        $args = [$key, $field, $increment];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hIncrByFloat($key, $field, $increment)
    {
        $command = Enum::HINCRBYFLOAT;
        $args = [$key, $field, $increment];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hKeys($key)

    {
        $command = Enum::HKEYS;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hLen($key)

    {
        $command = Enum::HLEN;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hMGet($key, ...$fields)
    {
        $command = Enum::HMGET;
        $args = [$key];
        $args = array_merge($args, $fields);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hMSet($key, array $fvMap)
    {
        $command = Enum::HMSET;
        $args = [$key];
        if (!empty($fvMap)) {
            foreach ($fvMap as $field => $value) {
                $tmp[] = $field;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
                $tmp[] = $value;
            }
            $fvMap = $tmp;        
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
        }
        $args = array_merge($args, $fvMap);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hSet($key, $field, $value)
    {
        $command = Enum::HSET;
        $args = [$key, $field, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hSetNx($key, $filed, $value)
    {
        $command = Enum::HSETNX;
        $args = [$key, $filed, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hStrLen($key, $field)
    {
        $command = Enum::HSTRLEN;
        $args = [$key, $field];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hVals($key)

    {
        $command = Enum::HVALS;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function geoAdd($key, array $coordinates)
    {
        // TODO: Implement geoAdd() method.
        $command = Enum::GEOADD;
        $args = [$key];
        $args = array_merge($args, $coordinates);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function geoHash($key, ...$members)
    {
        // TODO: Implement geoHash() method.
        $command = Enum::GEOHASH;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
    }

    public function geoPos($key, ...$members)
    {
        // TODO: Implement geoPos() method.
        $command = Enum::GEOPOS;
        $args = [$key];
        $args = array_merge($args, $members);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function geoDist($key, $memberA, $memberB, $unit)
    {
        // TODO: Implement geoDist() method.
        $command = Enum::GEODIST;
        $args = [$key, $memberA, $memberB ,$unit];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function geoRadius($key, $longitude, $latitude, $unit, $command, $count, $sort)

    {
        // TODO: Implement geoRadius() method.
        $command = Enum::GEORADIUS;
        $args = [$key, $longitude, $latitude, $unit, $command, $count, $sort];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function geoRadiusByMember($key, $member, $unit, $command, $count, $sort, $store, $storeDist)

    {
        // TODO: Implement geoRadiusByMember() method.
        $command = Enum::GEORADIUSBYMEMBER;
        $args = [$key, $member, $unit, $command, $count, $sort, $store, $storeDist];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function pSubscribe(...$patterns)
    {
        // TODO: Implement pSubscribe() method.
        $command = Enum::PSUBSCRIBE;
        $args = $patterns;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function pubSub($command, array $args = [])
    {
        // TODO: Implement pubSub() method.
        $command = Enum::PUBSUB;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function publish($channel, $message)

    {
        // TODO: Implement publish() method.
        $command = Enum::PUBLISH;
        $args = [$channel, $message];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function pUnsubscribe(...$patterns)
    {
        // TODO: Implement pUnsubscribe() method.
        $command = Enum::PUNSUBSCRIBE;
        $args = $patterns;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function unSubscribe(...$channels)
    {
        // TODO: Implement unSubscribe() method.
        $command = Enum::UNSUBSCRIBE;
        $args = $channels;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function lIndex($key, $index)
    {
        // TODO: Implement lIndex() method.
        $command = Enum::LINDEX;
        $args = [$key, $index];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function lInsert($key, $action, $pivot, $value)
    {
        // TODO: Implement lInsert() method.
        $command = Enum::LINSERT;
        $args = [$key, $action, $pivot, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function lLen($key)

    {
        // TODO: Implement lLen() method.
        $command = Enum::LLEN;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function lPop($key)

    {
        // TODO: Implement lPop() method.
        $command = Enum::LPOP;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function lPush($key,...$values)
    {
        $command = Enum::LPUSH;
        array_unshift($values, $key);

        return $this->dispatch(Builder::build($command, $values));
    }

    public function lPushX($key, $value)
    {
        $command = Enum::LPUSHX;
        $args = [$key, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function lRange($key, $start = 0, $stop = -1)
    {
        $command = Enum::LRANGE;
        $args = [$key, $start, $stop];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function lRem($key, $count, $value)
    {
        // TODO: Implement lRem() method.
        $command = Enum::LREM;
        $args = [$key, $count, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function lSet($key, $index, $value)
    {
        // TODO: Implement lSet() method.
        $command = Enum::LSET;
        $args = [$key, $index, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function lTrim($key, $start, $stop)
    {
        // TODO: Implement lTrim() method.
        $command = Enum::LTRIM;
        $args = [$key, $start, $stop];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function mGet($key, ...$values)
    {
        // TODO: Implement mGet() method.
        $command = Enum::MGET;
        $args = [$key];
        $args = array_merge($args, $values);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function mSet(array $kvMap)
    {
        // TODO: Implement mSet() method.
        $command = Enum::MSET;
        $args = $kvMap;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function monitor()
    {
        // TODO: Implement monitor() method.
        $command = Enum::MONITOR;

        return $this->dispatch(Builder::build($command));
    }

    public function move($key, $db)
    {
        // TODO: Implement move() method.
        $command = Enum::MOVE;
        $args = [$key, $db];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function mSetNx($kvMap)
    {
        // TODO: Implement mSetNx() method.
        $command = Enum::MSETNX;
        $args = $kvMap;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function rPop($key)

    {
        $command = Enum::RPOP;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function rPopLPush($src, $dst)

    {
        // TODO: Implement rPopLPush() method.
        $command = Enum::RPOPLPUSH;
        $args = [$src, $dst];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function rPush($key, ...$values)
    {
        $command = Enum::RPUSH;
        $args = [$key];
        $args = array_merge($args, $values);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function rPushX($key, $value)
    {
        $command = Enum::RPUSHX;
        $args = [$key, $value];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function pFAdd($key, ...$elements)
    {
        // TODO: Implement pFAdd() method.
        $command = Enum::PFADD;
        $args = [$key];
        $args = array_merge($args, $elements);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function pFCount(...$keys)
    {
        // TODO: Implement pFCount() method.
        $command = Enum::PFCOUNT;
        $args = $keys;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function pFMerge(array $dsKeyMap)
    {
        // TODO: Implement pFMerge() method.
        $command = Enum::PFMERGE;
        $args = $dsKeyMap;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function clusterAddSlots(...$slots)
    {
        // TODO: Implement clusterAddSlots() method.
        $command = Enum::CLUSTER_ADDSLOTS;
        $args = $slots;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function clusterCountFailureReports($nodeId)
    {
        // TODO: Implement clusterCountFailureReports() method.
        $command = Enum::CLUSTER_COUNT_FAILURE_REPORTS;
        $args = [$nodeId];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function clusterCountKeysInSlot($slot)
    {
        // TODO: Implement clusterCountKeysInSlot() method.
        $command = Enum::CLUSTER_COUNTKEYSINSLOT;
        $args = $slot;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function clusterDelSlots(...$slots)
    {
        // TODO: Implement clusterDelSlots() method.
        $command = Enum::CLUSTER_DELSLOTS;
        $args = $slots;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function clusterFailOver($operation)
    {
        // TODO: Implement clusterFailOver() method.
    }

    public function clusterForget($nodeId)
    {
        // TODO: Implement clusterForget() method.
    }

    public function clusterGetKeyInSlot($slot, $count)
    {
        // TODO: Implement clusterGetKeyInSlot() method.
    }

    public function clusterInfo()
    {
        // TODO: Implement clusterInfo() method.
        $command = Enum::CLUSTER_INFO;

        return $this->dispatch(Builder::build($command));
    }

    public function clusterKeySlot($key)

    {
        // TODO: Implement clusterKeySlot() method.
        $command = Enum::CLUSTER_KEYSLOT;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function clusterMeet($ip, $port)
    {
        // TODO: Implement clusterMeet() method.
        $command = Enum::CLUSTER_MEET;
        $args = [$ip, $port];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function clusterNodes()
    {
        // TODO: Implement clusterNodes() method.
    }

    public function clusterReplicate($nodeId)
    {
        // TODO: Implement clusterReplicate() method.
    }

    public function clusterReset($mode)
    {
        // TODO: Implement clusterReset() method.
    }

    public function clusterSaveConfig()
    {
        // TODO: Implement clusterSaveConfig() method.
    }

    /**
     * @inheritDoc
     */
    public function clusterSetConfigEpoch($configEpoch)
    {
        // TODO: Implement clusterSetConfigEpoch() method.
    }

    /**
     * @inheritDoc
     */
    public function clusterSetSlot($command, $nodeId)
    {
        // TODO: Implement clusterSetSlot() method.
        $command = Enum::CLUSTER_SETSLOT;
        $args = [$command, $nodeId];

        return $this->dispatch(Builder::build($command, $args));
    }

    /**
     * @inheritDoc
     */
    public function clusterSlaves($nodeId)
    {
        // TODO: Implement clusterSlaves() method.
        $command = Enum::CLUSTER_SLAVES;
        $args = [$nodeId];

        return $this->dispatch(Builder::build($command, $args));
    }

    /**
     * @inheritDoc
     */
    public function clusterSlots()
    {
        // TODO: Implement clusterSlots() method.
        $command = Enum::CLUSTER_SLOTS;

        return $this->dispatch(Builder::build($command));
    }

    public function flushAll()
    {
        $command = Enum::FLUSHALL;

        return $this->dispatch(Builder::build($command));
    }

    public function flushDb()
    {
        // TODO: Implement flushDb() method.
        $command = Enum::FLUSHDB;

        return $this->dispatch(Builder::build($command));
    }

    public function info($section = [])
    {
        $command = Enum::INFO;

        return $this->dispatch(Builder::build($command, $section))->then(function ($value) {
            if ($value) {
                $ret = explode(PHP_EOL, $value);
                $handled = [];
                $lastKey = '';
                foreach ($ret as $_ => $v) {
                    if (($pos = strpos($v, '#')) !== false) {
                        $lastKey = strtolower(substr($v,$pos+2));
                        $handled[$lastKey] = [];
                        continue;
                    }
                    $statMap = explode(':', $v);
                    if ($statMap[0]) {
                        list($name, $stat) = explode(':', $v);
                        $handled[$lastKey][$name] = $stat;
                    }
                }

                return $handled;
            }

            return $value;
        });
    }

    public function zAdd($key, array $options = [])
    {
        // TODO: Implement zAdd() method.
        $command = Enum::ZADD;
        $args = [$key];
        $args = array_merge($args, $options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zCard($key)

    {
        // TODO: Implement zCard() method.
        $command = Enum::ZCARD;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zCount($key, $min, $max)

    {
        // TODO: Implement zCount() method.
        $command = Enum::ZCOUNT;
        $args = [$key, $min, $max];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zIncrBy($key, $increment, $member)
    {
        // TODO: Implement zIncrBy() method.
        $command = Enum::ZINCRBY;
        $args = [$key, $increment, $member];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zInterStore($dst, $numKeys)
    {
        // TODO: Implement zInterStore() method.
        $command = Enum::ZINTERSTORE;
        $args = [$dst, $numKeys];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zLexCount($key, $min, $max)

    {
        // TODO: Implement zLexCount() method.
        $command = Enum::ZLEXCOUNT;
        $args = [$key, $min, $max];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRange($key, $star, $stop, array $options = [])
    {
        // TODO: Implement zRange() method.
        $command = Enum::ZRANGE;
        $args = [$key, $star,$stop];
        $args = array_merge($args, $options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRangeByLex($key, $min, $max, array $options = [])
    {
        // TODO: Implement zRangeByLex() method.
        $command = Enum::ZRANGEBYLEX;
        $args = [$key, $min, $max];
        $args = array_merge($args,$options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRevRangeByLex($key, $max, $min, array $options = [])
    {
        // TODO: Implement zRevRangeByLex() method.
        $command = Enum::ZREVRANGEBYLEX;
        $args = [$key, $max,$min];
        $args = array_merge($args,$options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRangeByScore($key, $min, $max, array $options = [])
    {
        // TODO: Implement zRangeByScore() method.
        $command = Enum::ZRANGEBYSCORE;
        $args = [$key, $min,$max];
        $args = array_merge($args, $options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRank($key, $member)
    {
        // TODO: Implement zRank() method.
        $command = Enum::ZRANK;
        $args = [$key,$member];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRem($key, ...$members)
    {
        // TODO: Implement zRem() method.
        $command = Enum::ZREM;
        $args = [$key];
        $args = array_merge($args, $members);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRemRangeByLex($key, $min, $max)

    {
        // TODO: Implement zRemRangeByLex() method.
        $command = Enum::ZREMRANGEBYLEX;
        $args = [$key, $min, $max];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRemRangeByRank($key, $start, $stop)
    {
        // TODO: Implement zRemRangeByRank() method.
        $command = Enum::ZREMRANGEBYRANK;
        $args = [$key, $start,$stop];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRemRangeByScore($key, $min, $max)

    {
        // TODO: Implement zRemRangeByScore() method.
        $command = Enum::ZREMRANGEBYSCORE;
        $args = [$key, $min, $max];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRevRange($key, $start, $stop, array $options = [])
    {
        // TODO: Implement zRevRange() method.
        $command = Enum::ZREVRANGE;
        $args = [$key, $start, $stop];
        $args = array_merge($args, $options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRevRangeByScore($key, $max, $min, array $options = [])
    {
        // TODO: Implement zRevRangeByScore() method.
        $command = Enum::ZREVRANGEBYSCORE;
        $args = [$key,$max,$min];
        $args = array_merge($args, $options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zRevRank($key, $member)
    {
        // TODO: Implement zRevRank() method.
        $command = Enum::ZREVRANK;
        $args = [$key,$member];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zScore($key, $member)
    {
        // TODO: Implement zScore() method.
        $command = Enum::ZSCORE;
        $args = [$key,$member];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function scan($cursor, array $options = [])
    {
        $command = Enum::SCAN;
        $args = [$cursor];
        $args = array_merge($args, $options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sScan($key, $cursor, array $options = [])
    {
        // TODO: Implement sScan() method.
        $command = Enum::SSCAN;
        $args = [$key, $cursor];
        $args = array_merge($args, $options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function hScan($key, $cursor, array $options = [])
    {
        // TODO: Implement hScan() method.
        $command = Enum::HSCAN;
        $args = [$key, $cursor];
        $args = array_merge($args, $options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function zScan($key, $cursor, array $options = [])
    {
        // TODO: Implement zScan() method.
        $command = Enum::ZSCAN;
        $args = [$key , $cursor];
        $args = array_merge($args, $options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sInter(...$keys)
    {
        // TODO: Implement sInter() method.
        $command = Enum::SINTER;
        $args = $keys;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sInterStore($dst, ...$keys)
    {
        // TODO: Implement sInterStore() method.
        $command = Enum::SINTERSTORE;
        $args = [$dst];
        $args = array_merge($args, $keys);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sIsMember($key, $member)
    {
        // TODO: Implement sIsMember() method.
        $command = Enum::SISMEMBER;
        $args = [$key ,$member];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function slaveOf($host, $port)

    {
        // TODO: Implement slaveOf() method.
        $command = Enum::SLAVEOF;
        $args = [$host, $port];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sLowLog($command, array $args = [])
    {
        // TODO: Implement sLowLog() method.
        $command = Enum::SLOWLOG;
        $args = array_merge([$command],$args);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sMembers($key)

    {
        // TODO: Implement sMembers() method.
        $command = Enum::SMEMBERS;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sMove($src, $dst, $members)
    {
        // TODO: Implement sMove() method.
        $command = Enum::SMOVE;
        $args = [$src, $dst];
        $args = array_merge( $args, $members);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sort($key, array $options = [])
    {
        // TODO: Implement sort() method.
        $command = Enum::SORT;
        $args = [$key];
        $args = array_merge($args, $options);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sPop($key, $count)

    {
        // TODO: Implement sPop() method.
        $command = Enum::SPOP;
        $args = [$key, $count];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sRandMember($key, $count)

    {
        // TODO: Implement sRandMember() method.
        $command = Enum::SRANDMEMBER;
        $args = [$key, $count];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sRem($key, ...$members)
    {
        // TODO: Implement sRem() method.
        $command = Enum::SREM;
        $args = [$key];
        $args = array_merge($args, $members);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function strLen($key)

    {
        // TODO: Implement strLen() method.
        $command = Enum::STRLEN;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function subscribe(...$channels)
    {
        // TODO: Implement subscribe() method.
        $command = Enum::SUBSCRIBE;
        $args = $channels;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sUnion(...$keys)
    {
        // TODO: Implement sUnion() method.
        $command = Enum::SUNION;
        $args = $keys;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sUnionStore($dst, ...$keys)
    {
        // TODO: Implement sUnionStore() method.
        $command = Enum::SUNIONSTORE;
        $args = [$dst];
        $args = array_merge($args, $keys);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sWapBb($opt, $dst, ...$keys)
    {
        // TODO: Implement sWapBb() method.
        $command = Enum::SWAPDB;
        $args = [$opt, $dst];
        $args = array_merge($args, $keys);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sAdd($key, ...$members)
    {
        // TODO: Implement sAdd() method.
        $command = Enum::SADD;
        $args = [$key];
        $args = array_merge($args, $members);

        return $this->dispatch(Builder::build($command, $args));
    }

    public function save()
    {
        // TODO: Implement save() method.
        $command = Enum::SAVE;

        return $this->dispatch(Builder::build($command));
    }

    public function sCard($key)

    {
        // TODO: Implement sCard() method.
        $command = Enum::SCARD;
        $args = [$key];

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sDiff(...$keys)
    {
        // TODO: Implement sDiff() method.
        $command = Enum::SDIFF;
        $args = $keys;

        return $this->dispatch(Builder::build($command, $args));
    }

    public function sDiffStore($dst, ...$keys)
    {
        // TODO: Implement sDiffStore() method.
        $command = Enum::SDIFFSTORE;
        $args = [$dst];
        $args = array_merge($args, $keys);

        return $this->dispatch(Builder::build($command, $args));
    }

    /**
     * @inheritDoc
     */
    public function hExists($key, $field)
    {
        // TODO: Implement hExists() method.
        $command = Enum::HEXISTS;
        $args = [$key, $field];

        return $this->dispatch(Builder::build($command, $args));
    }

    /**
     * @inheritDoc
     */
    public function readWrite()
    {
        // TODO: Implement readWrite() method.
        $command = Enum::READWRITE;

        return $this->dispatch(Builder::build($command));
    }

    /**
     * @inheritDoc
     */
    public function zUnionScore($dst, $numKeys)
    {
        // TODO: Implement zUnionScore() method.
        $command = Enum::ZUNIIONSCORE;
        $args = [$dst, $numKeys];

        return $this->dispatch(Builder::build($command, $args));
    }
};
1			<?php
			0 ignored issues – show Coding Style Compatibility introduced 2017-07-01 22:13 UTC by Report Bug Copy Issue Report 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 25 and the first side effect is on line 1881. The PSR-1: Basic Coding Standard recommends that a file should either introduce new symbols, that is classes, functions, constants or similar, or have side effects. Side effects are anything that executes logic, like for example printing output, changing ini settings or writing to a file. The idea behind this recommendation is that merely auto-loading a class should not change the state of an application. It also promotes a cleaner style of programming and makes your code less prone to errors, because the logic is not spread out all over the place. To learn more about the PSR-1, please see the PHP-FIG site on the PSR-1. Loading history...
2
3			namespace Dazzle\Redis;
4
5			use Clue\Redis\Protocol\Model\ErrorReply;
6			use Clue\Redis\Protocol\Model\ModelInterface;
7			use Clue\Redis\Protocol\Parser\ParserException;
8			use Dazzle\Event\BaseEventEmitter;
9			use Dazzle\Loop\LoopAwareTrait;
10			use Dazzle\Loop\LoopInterface;
11			use Dazzle\Promise\Deferred;
12			use Dazzle\Promise\PromiseInterface;
13			use Dazzle\Redis\Command\Enum;
14			use Dazzle\Redis\Driver\Request;
15			use Dazzle\Redis\Driver\Driver;
16			use Dazzle\Redis\Driver\DriverInterface;
17			use Dazzle\Redis\Command\Builder;
18			use Dazzle\Socket\Socket;
19			use Dazzle\Socket\SocketInterface;
20			use Dazzle\Throwable\Exception\Runtime\ExecutionException;
21			use Dazzle\Throwable\Exception\Runtime\UnderflowException;
22			use Error;
23			use Exception;
24
25			class Redis extends BaseEventEmitter implements RedisInterface
26			{
27			use LoopAwareTrait;
28
29			/**
30			* @var string
31			*/
32			protected $endpoint;
33
34			/**
35			* @var SocketInterface
36			*/
37			protected $stream;
38
39			/**
dazzle-php / redis

Push — master ( 52cc4c...9e125a )

Redis::isBusy() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like
