Waiting client

Author: WyriHaximus

etc/di/redis-client.php

@@ -0,0 +1,12 @@
+<?php
+
+use Clue\React\Redis\Client;
+use PHPDIDefinitions\Clue\Redis\Client\WaitingClient;
+use Psr\Log\LoggerInterface;
+use React\EventLoop\LoopInterface;
+
+return [
+    Client::class => function (LoopInterface $loop, string $dsn, LoggerInterface $logger = null) {
+        return WaitingClient::create($loop, $dsn, $logger);
+    },
+];

src/WaitingClient.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace PHPDIDefinitions\Clue\Redis\Client;
+
+use Clue\React\Redis\Client;
+use Clue\React\Redis\Factory;
+use Evenement\EventEmitterTrait;
+use Psr\Log\LoggerInterface;
+use Psr\Log\NullLogger;
+use React\EventLoop\LoopInterface;
+use React\Promise\Deferred;
+use SplQueue;
+use WyriHaximus\PSR3\CallableThrowableLogger\CallableThrowableLogger;
+
+final class WaitingClient implements Client
+{
+    use EventEmitterTrait;
+
+    /**
+     * @var Client
+     */
+    private $redis;
+
+    /**
+     * @var SplQueue
+     */
+    private $callQueue;
+
+    public static function create(LoopInterface $loop, string $dsn, LoggerInterface $logger = null): self
+    {
+        return new self(new Factory($loop), $dsn, $logger ?? new NullLogger());
+    }
+
+    /**
+     * @param Factory $factory
+     * @param string $dsn
+     * @param LoggerInterface $logger
+     *
+     * @internal
+     */
+    public function __construct(Factory $factory, string $dsn, LoggerInterface $logger)
+    {
+        $this->callQueue = new \SplQueue();
+        $logger->debug('Connecting');
+        $factory->createClient($dsn)->done(function (Client $client) use ($logger) {
+            $logger->debug('Connected');
+            $this->redis = $client;
+
+            $logger->debug('Executing ' . $this->callQueue->count() . ' waiting call(s)');
+            while ($this->callQueue->count() > 0) {
+                $call = $this->callQueue->dequeue();
+                $name = $call['name'];
+                $args = $call['args'];
+                $call['deferred']->resolve($this->redis->$name(...$args));
+            }
+            $logger->debug('Executed all waiting calls, any new calls will be send to Redis directly');
+        }, CallableThrowableLogger::create($logger));
+    }
+
+    public function __call($name, $args)
+    {
+        if ($this->redis instanceof Client) {
+            return $this->redis->$name(...$args);
+        }
+
+        $deferred = new Deferred();
+
+        $this->callQueue->enqueue([
+            'deferred' => $deferred,
+            'name' => $name,
+            'args' => $args,
+        ]);
+
+        return $deferred->promise();
+    }
+
+    public function end()
+    {
+        // TODO: Implement end() method.
+    }
+
+    public function close()
+    {
+        // TODO: Implement close() method.
+    }
+}

tests/RedisClient.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PHPDIDefinitions\Tests\Clue\Redis\Client;
+
+use Clue\React\Redis\Client;
+use Evenement\EventEmitterTrait;
+
+class RedisClient implements Client
+{
+    use EventEmitterTrait;
+
+    public function incr(...$args)
+    {
+
+    }
+
+    public function __call($name, $args)
+    {
+        // TODO: Implement __call() method.
+    }
+
+    public function end()
+    {
+        // TODO: Implement end() method.
+    }
+
+    public function close()
+    {
+        // TODO: Implement close() method.
+    }
+}

tests/WaitingClientTest.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace PHPDIDefinitions\Tests\Clue\Redis\Client;
+
+use ApiClients\Tools\TestUtilities\TestCase;
+use Clue\React\Redis\Client;
+use Clue\React\Redis\Factory;
+use PHPDIDefinitions\Clue\Redis\Client\WaitingClient;
+use Prophecy\Argument;
+use Psr\Log\LoggerInterface;
+use React\EventLoop\LoopInterface;
+use React\Promise\Deferred;
+use function React\Promise\resolve;
+
+final class WaitingClientTest extends TestCase
+{
+    private const DSN = 'redis://::1/13';
+
+    public function testCreate()
+    {
+        $loop = $this->prophesize(LoopInterface::class);
+
+        $logger = $this->prophesize(LoggerInterface::class);
+        $logger->debug('Connecting')->shouldBeCalled();
+        $logger->debug('Connected')->shouldNotBeCalled();
+        $logger->debug('Executing 0 waiting call(s)')->shouldNotBeCalled();
+        $logger->debug('Executed all waiting calls, any new calls will be send to Redis directly')->shouldNotBeCalled();
+
+        WaitingClient::create($loop->reveal(), self::DSN, $logger->reveal());
+    }
+
+    public function testLogging()
+    {
+        $logger = $this->prophesize(LoggerInterface::class);
+        $logger->debug('Connecting')->shouldBeCalled();
+        $logger->debug('Connected')->shouldBeCalled();
+        $logger->debug('Executing 0 waiting call(s)')->shouldBeCalled();
+        $logger->debug('Executed all waiting calls, any new calls will be send to Redis directly')->shouldBeCalled();
+
+        $redisFactory = $this->prophesize(Factory::class);
+        $redisFactory->createClient(self::DSN)->shouldbeCalled()->willReturn(resolve($this->prophesize(Client::class)->reveal()));
+
+        new WaitingClient($redisFactory->reveal(), self::DSN, $logger->reveal());
+    }
+
+    public function testCalls()
+    {
+        $logger = $this->prophesize(LoggerInterface::class);
+        $logger->debug(Argument::type('string'))->shouldBeCalled();
+        $logger->debug('Executing 1 waiting call(s)')->shouldBeCalled();
+
+        $deferred = new Deferred();
+
+        $redis = $this->prophesize(RedisClient::class);
+        $redis->incr('key')->shouldBeCalled()->willReturn(resolve(true));
+        $redis->incr('sleutel')->shouldBeCalled()->willReturn(resolve(true));
+
+        $redisFactory = $this->prophesize(Factory::class);
+        $redisFactory->createClient(self::DSN)->shouldbeCalled()->willReturn($deferred->promise());
+
+        $waitingClient = new WaitingClient($redisFactory->reveal(), self::DSN, $logger->reveal());
+
+        $waitingClient->incr('key');
+
+        $deferred->resolve($redis->reveal());
+
+        $waitingClient->incr('sleutel');
+    }
+}