Merge pull request #70 from utopia-php/swoole-tcp-redis-multiplex

feat: add Redis\Multiplexing adapter over Swoole TCP
This commit is contained in:
Luke B. Silver authored and GitHub committed 2026-05-12 16:03:23 +01:00
commit fc3b9ae33c
33 files changed
+1659 -85

No files matched your search

+2 -2
View File
@@ -7,7 +7,7 @@ jobs:
runs-on: ubuntu-latest
strategy:
matrix:
php-versions: ['8.2', '8.3', '8.4']
php-versions: ['8.3', '8.4', '8.5']
steps:
- name: Checkout repository
@@ -25,4 +25,4 @@ jobs:
sleep 10
- name: Run Tests
run: docker compose exec tests vendor/bin/phpunit --configuration phpunit.xml tests
run: docker compose exec tests vendor/bin/phpunit --configuration phpunit.xml tests
+4 -9
View File
@@ -1,4 +1,4 @@
FROM composer:2.0 as step0
FROM composer:2.7 as step0
ARG TESTING=false
ENV TESTING=$TESTING
@@ -10,10 +10,10 @@ COPY composer.json /usr/local/src/
RUN composer update --ignore-platform-reqs --optimize-autoloader \
--no-plugins --no-scripts --prefer-dist
FROM appwrite/utopia-base:php-8.3-0.1.2 as final
ENV PHP_MEMCACHED_VERSION=v3.2.0
FROM appwrite/utopia-base:php-8.3-2.0.0 as final
ENV PHP_MEMCACHED_VERSION=v3.4.0
LABEL maintainer="team@appwrite.io"
@@ -23,10 +23,6 @@ RUN \
apk update \
&& apk add --no-cache make automake autoconf g++ gcc zlib-dev libmemcached-dev docker-cli \
&& rm -rf /var/cache/apk/*
RUN echo extension=redis.so >> /usr/local/etc/php/conf.d/redis.ini
RUN \
# Memcached Extension
@@ -41,7 +37,6 @@ RUN echo extension=memcached.so >> /usr/local/etc/php/conf.d/memcached.ini
WORKDIR /usr/src/code
# Add Source Code
COPY ./ /usr/src/code
COPY --from=step0 /usr/local/src/vendor /usr/src/code/vendor
+4 -9
View File
@@ -1,4 +1,4 @@
FROM composer:2.0 as step0
FROM composer:2.7 as step0
ARG TESTING=false
ENV TESTING=$TESTING
@@ -10,10 +10,10 @@ COPY composer.json /usr/local/src/
RUN composer update --ignore-platform-reqs --optimize-autoloader \
--no-plugins --no-scripts --prefer-dist
FROM appwrite/utopia-base:php-8.4-1.0.0 as final
ENV PHP_MEMCACHED_VERSION=v3.2.0
FROM appwrite/utopia-base:php-8.4-2.0.0 as final
ENV PHP_MEMCACHED_VERSION=v3.4.0
LABEL maintainer="team@appwrite.io"
@@ -23,10 +23,6 @@ RUN \
apk update \
&& apk add --no-cache make automake autoconf g++ gcc zlib-dev libmemcached-dev docker-cli \
&& rm -rf /var/cache/apk/*
RUN echo extension=redis.so >> /usr/local/etc/php/conf.d/redis.ini
RUN \
# Memcached Extension
@@ -41,7 +37,6 @@ RUN echo extension=memcached.so >> /usr/local/etc/php/conf.d/memcached.ini
WORKDIR /usr/src/code
# Add Source Code
COPY ./ /usr/src/code
COPY --from=step0 /usr/local/src/vendor /usr/src/code/vendor
+4 -6
View File
@@ -1,4 +1,4 @@
FROM composer:2.0 as step0
FROM composer:2.7 as step0
ARG TESTING=false
ENV TESTING=$TESTING
@@ -10,10 +10,10 @@ COPY composer.json /usr/local/src/
RUN composer update --ignore-platform-reqs --optimize-autoloader \
--no-plugins --no-scripts --prefer-dist
FROM appwrite/utopia-base:php-8.2-0.1.2 as final
ENV PHP_MEMCACHED_VERSION=v3.2.0
FROM appwrite/utopia-base:php-8.5-2.0.0 as final
ENV PHP_MEMCACHED_VERSION=v3.4.0
LABEL maintainer="team@appwrite.io"
@@ -23,7 +23,6 @@ RUN \
apk update \
&& apk add --no-cache make automake autoconf g++ gcc zlib-dev libmemcached-dev docker-cli \
&& rm -rf /var/cache/apk/*
RUN \
# Memcached Extension
@@ -38,7 +37,6 @@ RUN echo extension=memcached.so >> /usr/local/etc/php/conf.d/memcached.ini
WORKDIR /usr/src/code
# Add Source Code
COPY ./ /usr/src/code
COPY --from=step0 /usr/local/src/vendor /usr/src/code/vendor
+2 -1
View File
@@ -17,7 +17,7 @@
"psr-4": {"Utopia\\Tests\\": "tests/Cache"}
},
"require": {
"php": ">=8.2",
"php": ">=8.3",
"ext-json": "*",
"ext-memcached": "*",
"ext-redis": "*",
@@ -29,6 +29,7 @@
"laravel/pint": "1.2.*",
"phpstan/phpstan": "^1.12",
"phpunit/phpunit": "^9.3",
"swoole/ide-helper": "^6.0",
"vimeo/psalm": "4.13.1"
},
"config": {
Generated
+36 -4
View File
@@ -4,7 +4,7 @@
"Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
"This file is @generated automatically"
],
"content-hash": "1d0ace4df177cb2519358831ae65ec36",
"content-hash": "c0bbfaba8e8700ddb517078d445cb0ec",
"packages": [
{
"name": "brick/math",
@@ -4774,6 +4774,38 @@
],
"time": "2020-09-28T06:39:44+00:00"
},
{
"name": "swoole/ide-helper",
"version": "6.0.2",
"source": {
"type": "git",
"url": "https://github.com/swoole/ide-helper.git",
"reference": "6f12243dce071714c5febe059578d909698f9a52"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/swoole/ide-helper/zipball/6f12243dce071714c5febe059578d909698f9a52",
"reference": "6f12243dce071714c5febe059578d909698f9a52",
"shasum": ""
},
"type": "library",
"notification-url": "https://packagist.org/downloads/",
"license": [
"Apache-2.0"
],
"authors": [
{
"name": "Team Swoole",
"email": "team@swoole.com"
}
],
"description": "IDE help files for Swoole.",
"support": {
"issues": "https://github.com/swoole/ide-helper/issues",
"source": "https://github.com/swoole/ide-helper/tree/6.0.2"
},
"time": "2025-03-23T07:31:41+00:00"
},
{
"name": "symfony/console",
"version": "v6.4.31",
@@ -5485,10 +5517,10 @@
"prefer-stable": false,
"prefer-lowest": false,
"platform": {
"php": ">=8.2",
"php": ">=8.4",
"ext-json": "*",
"ext-redis": "*",
"ext-memcached": "*"
"ext-memcached": "*",
"ext-redis": "*"
},
"platform-dev": {},
"plugin-api-version": "2.9.0"
+1 -1
View File
@@ -3,7 +3,7 @@ services:
container_name: tests
build:
context: .
dockerfile: Dockerfile.php-${PHP_VERSION:-8.3}
dockerfile: Dockerfile.php-${PHP_VERSION:-8.4}
networks:
- database
volumes:
+82
View File
@@ -0,0 +1,82 @@
# Redis Multiplexing Adapter
A Redis cache adapter for Swoole that serves many concurrent coroutines from a
single Redis TCP connection.
## When to use it vs. a connection pool
Most Swoole apps reach for a pool (`Adapter\Pool` wrapping `Adapter\Redis`):
each request checks out one connection, runs its commands, returns it. Pool
size = max concurrent commands.
`Redis\Multiplexing` is the alternative for *cache* traffic specifically:
- One TCP socket serving thousands of concurrent commands.
- No pool sizing to tune, no checkout backpressure on bursts.
- Lower memory: ~1 connection per worker, not N.
You'd still want a pool for transactions, pub/sub, blocking commands, or any
workload where commands are not independent. Many Swoole apps end up using
both — multiplex the cache, pool the rest.
## Quick start
```php
use Swoole\Coroutine;
use Utopia\Cache\Cache;
use Utopia\Cache\Adapter\Redis\Multiplexing;
Coroutine\run(function () {
$adapter = new Multiplexing(host: 'redis');
$cache = new Cache($adapter);
$cache->save('user:42', ['name' => 'Ada'], 'profile');
$cache->load('user:42', ttl: 60, hash: 'profile');
$adapter->disconnect();
});
```
Construct once at worker start, share across requests, `disconnect()` on
`WorkerStop`. The adapter must be constructed inside a Swoole coroutine.
## Constructor
```php
new Multiplexing(
host: 'redis',
port: 6379,
timeout: 1.0, // connect timeout (s)
readTimeout: 0.25, // per-command response timeout (s)
auth: null, // string password, [user, password], or null
dbIndex: 0,
);
```
`readTimeout` defaults to **250 ms**. A timeout fails the command *and tears
down the connection* — every other in-flight command on it also fails with
`ConnectionException`, and the next command reconnects. This is intentional:
caches should fail fast and let callers fall through to the source of truth.
Per-request resync would add significant complexity for little gain.
## Errors
- `\RedisException` — Redis-side error (`WRONGTYPE`, `NOAUTH`, …). Connection
is fine; the command was wrong. Not retried.
- `Utopia\Cache\Adapter\Redis\ConnectionException` — transport failure
(timeout, socket closed, send failed). Connection has been discarded.
Retried if `setMaxRetries(n)` was called.
## Telemetry
Implements `Cache\Feature\Telemetry`. Emits a
`cache.redis_multiplexing.pending.depth` gauge after each enqueue — non-zero
steady-state means callers are queueing faster than Redis is replying. Wire
up via `Cache::setTelemetry()`.
## Limitations
- Swoole coroutine context required.
- No pub/sub, transactions, blocking commands, or pipelining APIs.
- No Redis Cluster (use `Adapter\RedisCluster`).
- One Redis host per adapter instance; one connection per worker process.
+7
View File
@@ -0,0 +1,7 @@
parameters:
level: max
paths:
- src
- tests
scanDirectories:
- vendor/swoole/ide-helper
+6 -9
View File
@@ -9,14 +9,11 @@
stopOnFailure="false"
>
<testsuites>
<testsuite name="Application Test Suite">
<file>./tests/Cache/FilesystemTest.php</file>
<file>./tests/Cache/MemoryTest.php</file>
<file>./tests/Cache/NoneTest.php</file>
<file>./tests/Cache/RedisTest.php</file>
<file>./tests/Cache/ShardingTest.php</file>
<file>./tests/Cache/HazelcastTest.php</file>
<file>./tests/Cache/MemcachedTest.php</file>
<testsuite name="unit">
<directory>./tests/Cache/Unit</directory>
</testsuite>
<testsuite name="e2e">
<directory>./tests/Cache/E2E</directory>
</testsuite>
</testsuites>
</phpunit>
</phpunit>
+11 -32
View File
@@ -6,6 +6,7 @@ use Exception;
use Redis as Client;
use Throwable;
use Utopia\Cache\Adapter;
use Utopia\Cache\Adapter\Redis\Envelope;
class Redis implements Adapter
{
@@ -57,8 +58,9 @@ class Redis implements Adapter
$this->persistent = $this->persistentId !== null;
$this->dbIndex = $redis->getDbNum();
if (! empty($redis->getAuth())) {
$this->auth = $redis->getAuth();
$auth = $redis->getAuth();
if ($auth !== null && $auth !== false) {
$this->auth = $auth;
}
$this->redis = $redis;
@@ -100,22 +102,11 @@ class Redis implements Adapter
$redis_string = $this->execute(fn () => $this->redis->hGet($key, $hash));
if ($redis_string === false || $redis_string === null) {
if (! is_string($redis_string)) {
return false;
}
if (gettype($redis_string) !== 'string') {
return false;
}
/** @var array{time: int, data: string} */
$cache = json_decode($redis_string, true);
if ($cache['time'] + $ttl > time()) { // Cache is valid
return $cache['data'];
}
return false;
return Envelope::decode($redis_string, $ttl, time());
}
/**
@@ -135,15 +126,7 @@ class Redis implements Adapter
}
try {
$value = json_encode([
'time' => \time(),
'data' => $data,
], flags: JSON_THROW_ON_ERROR);
} catch (Throwable $th) {
return false;
}
try {
$value = Envelope::encode($data, time());
$this->execute(fn () => $this->redis->hSet($key, $hash, $value));
return $data;
@@ -165,16 +148,12 @@ class Redis implements Adapter
$redis_string = $this->execute(fn () => $this->redis->hGet($key, $hash));
if ($redis_string === false || $redis_string === null || ! is_string($redis_string)) {
if (! is_string($redis_string)) {
return false;
}
try {
/** @var array{time: int, data: mixed} $cache */
$cache = json_decode($redis_string, true, flags: JSON_THROW_ON_ERROR);
$cache['time'] = time();
$value = json_encode($cache, flags: JSON_THROW_ON_ERROR);
} catch (Throwable $th) {
$value = Envelope::touch($redis_string, time());
if ($value === false) {
return false;
}
@@ -360,7 +339,7 @@ class Redis implements Adapter
);
}
if (! empty($this->auth)) {
if ($this->auth !== null) {
$newRedis->auth($this->auth);
}
+217
View File
@@ -0,0 +1,217 @@
<?php
namespace Utopia\Cache\Adapter\Redis;
use Swoole\Coroutine\Client as SwooleClient;
use Throwable;
/**
* Thin wrapper around a Swoole coroutine TCP client speaking Redis RESP2.
*
* Owns the socket and the unread byte buffer. Exposes a synchronous
* request/response method for connection-time handshake (AUTH, SELECT) plus
* raw send/recv for the asynchronous multiplexer that runs after handshake.
*/
class Client
{
/**
* Sentinel returned from parse() when the buffer does not yet hold a full frame.
*/
public const INCOMPLETE = "\0__INCOMPLETE__\0";
private SwooleClient $client;
private string $buffer = '';
public function __construct(string $host, int $port, float $timeout)
{
$this->client = new SwooleClient(SWOOLE_SOCK_TCP);
$this->client->set([
'open_eof_check' => false,
'package_max_length' => 64 * 1024 * 1024,
'open_tcp_nodelay' => true,
]);
if (! $this->client->connect($host, $port, $timeout)) {
$errMsg = $this->client->errMsg;
$this->close();
throw new ConnectionException('Failed to connect to Redis: '.$errMsg);
}
}
/**
* Synchronous command: encode, send, block until a frame arrives. Used
* during connection handshake before the reader coroutine takes over.
* Any extra bytes the kernel hands us after the frame stay in the
* internal buffer and can be drained later via takeBuffer().
*
* @param array<int|string> $args
*/
public function command(array $args, float $readTimeout): mixed
{
$this->send(self::encode($args));
while (true) {
$offset = 0;
$value = self::parse($this->buffer, $offset);
if ($value !== self::INCOMPLETE) {
$this->buffer = substr($this->buffer, $offset);
if ($value instanceof RedisError) {
throw $value->exception;
}
return $value;
}
$chunk = $this->client->recv($readTimeout);
if ($chunk === false || $chunk === '') {
throw new ConnectionException('Timed out waiting for Redis response');
}
$this->buffer .= $chunk;
}
}
public function send(string $payload): void
{
$written = $this->client->send($payload);
if ($written === strlen($payload)) {
return;
}
$message = $written === false
? ($this->client->errMsg ?: 'send failed')
: 'partial send';
throw new ConnectionException('Redis send failed: '.$message);
}
public function recv(float $timeout): string|false
{
return $this->client->recv($timeout);
}
/**
* Drain and return any bytes the kernel delivered past the last parsed
* frame. The reader coroutine seeds itself with these so handshake
* leftovers are not lost.
*/
public function takeBuffer(): string
{
$buffer = $this->buffer;
$this->buffer = '';
return $buffer;
}
public function close(): void
{
try {
$this->client->close();
} catch (Throwable $th) {
// ignore
}
}
/**
* Recursively rethrow any RedisError / ConnectionError values produced by
* parse() so callers see plain PHP types and exceptions. Arrays are walked
* so that an error nested inside a multi-bulk reply still surfaces.
*/
public static function unwrap(mixed $value): mixed
{
if ($value instanceof RedisError) {
throw $value->exception;
}
if ($value instanceof ConnectionError) {
throw $value->exception;
}
if (! is_array($value)) {
return $value;
}
foreach ($value as $key => $child) {
$value[$key] = self::unwrap($child);
}
return $value;
}
/**
* Encode an array of arguments as a RESP array of bulk strings.
*
* @param array<int|string> $args
*/
public static function encode(array $args): string
{
$out = '*'.count($args)."\r\n";
foreach ($args as $arg) {
$arg = (string) $arg;
$out .= '$'.strlen($arg)."\r\n".$arg."\r\n";
}
return $out;
}
/**
* Parse a single RESP value from $buffer starting at $offset. Advances
* $offset past the consumed bytes. Returns INCOMPLETE if not enough data
* is present. Redis error frames are returned wrapped in RedisError.
*/
public static function parse(string $buffer, int &$offset): mixed
{
if (! isset($buffer[$offset])) {
return self::INCOMPLETE;
}
$type = $buffer[$offset];
$lineEnd = strpos($buffer, "\r\n", $offset + 1);
if ($lineEnd === false) {
return self::INCOMPLETE;
}
$line = substr($buffer, $offset + 1, $lineEnd - $offset - 1);
$offset = $lineEnd + 2;
switch ($type) {
case '+': // simple string
return $line;
case '-': // error
return new RedisError(new \RedisException($line));
case ':': // integer
return (int) $line;
case '$': // bulk string
$len = (int) $line;
if ($len === -1) {
return null;
}
if (strlen($buffer) < $offset + $len + 2) {
return self::INCOMPLETE;
}
$value = substr($buffer, $offset, $len);
$offset += $len + 2;
return $value;
case '*': // array
$count = (int) $line;
if ($count === -1) {
return null;
}
$items = [];
for ($i = 0; $i < $count; $i++) {
$item = self::parse($buffer, $offset);
if ($item === self::INCOMPLETE) {
return self::INCOMPLETE;
}
$items[] = $item;
}
return $items;
default:
throw new \RedisException('Unknown RESP type: '.$type);
}
}
}
@@ -0,0 +1,17 @@
<?php
namespace Utopia\Cache\Adapter\Redis;
use SplQueue;
class ConnectionContext
{
/**
* @param SplQueue<\Swoole\Coroutine\Channel<mixed>> $pending
*/
public function __construct(
public Client $client,
public SplQueue $pending,
) {
}
}
@@ -0,0 +1,11 @@
<?php
namespace Utopia\Cache\Adapter\Redis;
final class ConnectionError
{
public function __construct(
public ConnectionException $exception,
) {
}
}
@@ -0,0 +1,12 @@
<?php
namespace Utopia\Cache\Adapter\Redis;
/**
* Thrown by Multiplexing when the underlying Redis connection is
* unhealthy and the operation should be retried (or surfaced as a connection
* error rather than a Redis-level error).
*/
class ConnectionException extends \RedisException
{
}
+71
View File
@@ -0,0 +1,71 @@
<?php
namespace Utopia\Cache\Adapter\Redis;
use JsonException;
/**
* Cache envelope codec shared by the Redis-family adapters.
*
* Stored payload is `{"time": <unix>, "data": <value>}`. Encoding adds the
* timestamp; decoding enforces TTL relative to a caller-supplied `now`.
*/
final class Envelope
{
/**
* @param array<int|string, mixed>|string $data
*
* @throws JsonException
*/
public static function encode(array|string $data, int $time): string
{
return json_encode([
'time' => $time,
'data' => $data,
], flags: JSON_THROW_ON_ERROR);
}
/**
* Decode a stored envelope. Returns the wrapped data if the envelope is
* well-formed and not yet expired (`time + ttl > now`); returns false
* otherwise. Never throws — malformed JSON / shape is treated as a miss.
*/
public static function decode(string $value, int $ttl, int $now): mixed
{
$cache = json_decode($value, true);
if (! is_array($cache) || ! isset($cache['time'], $cache['data']) || ! is_int($cache['time'])) {
return false;
}
if ($cache['time'] + $ttl > $now) {
return $cache['data'];
}
return false;
}
/**
* Re-stamp an existing envelope with a new timestamp, preserving its data.
* Returns the rewritten JSON, or false if the input is not a valid envelope.
*/
public static function touch(string $value, int $newTime): string|false
{
try {
$cache = json_decode($value, true, flags: JSON_THROW_ON_ERROR);
} catch (JsonException) {
return false;
}
if (! is_array($cache) || ! array_key_exists('data', $cache)) {
return false;
}
$cache['time'] = $newTime;
try {
return json_encode($cache, flags: JSON_THROW_ON_ERROR);
} catch (JsonException) {
return false;
}
}
}
+493
View File
@@ -0,0 +1,493 @@
<?php
namespace Utopia\Cache\Adapter\Redis;
use SplQueue;
use Swoole\Coroutine;
use Swoole\Coroutine\Channel;
use Swoole\Coroutine\Lock;
use Throwable;
use Utopia\Cache\Adapter;
use Utopia\Cache\Feature\Telemetry as TelemetryFeature;
use Utopia\Telemetry\Adapter as Telemetry;
use Utopia\Telemetry\Adapter\None as NoTelemetry;
use Utopia\Telemetry\Gauge;
/**
* Redis\Multiplexing adapter.
*
* Multiplexes many Swoole coroutines over a single Redis TCP connection. Each
* caller takes a connection-wide Lock, pushes its response Channel onto the
* FIFO `pending` queue, sends its RESP frame, and releases the lock — so the
* order of registrations exactly matches the order of bytes on the wire. A
* single reader coroutine parses inbound frames and dispatches each one to
* the next pending Channel, exploiting Redis's guarantee of in-order replies.
*/
class Multiplexing implements Adapter, TelemetryFeature
{
private int $maxRetries = 0;
private int $retryDelay = 1000; // milliseconds
private ?ConnectionContext $connection = null;
/**
* Serializes pending enqueue + send so the FIFO invariant holds even when
* many coroutines issue commands concurrently.
*/
private Lock $sendLock;
private ?Gauge $pendingDepth = null;
/**
* @param string $host
* @param int $port
* @param float $timeout connect timeout in seconds
* @param float $readTimeout read timeout in seconds — caches should
* fail fast, default 0.25s
* @param string|array<string>|null $auth password or [username, password]
* @param int $dbIndex
*/
public function __construct(
private string $host,
private int $port = 6379,
private float $timeout = 1.0,
private float $readTimeout = 0.25,
private string|array|null $auth = null,
private int $dbIndex = 0,
) {
if ($this->timeout <= 0) {
throw new \InvalidArgumentException('timeout must be greater than 0');
}
if ($this->readTimeout <= 0) {
throw new \InvalidArgumentException('readTimeout must be greater than 0');
}
$this->sendLock = new Lock();
$this->setTelemetry(new NoTelemetry());
$locked = $this->lockSend();
try {
$this->connect();
} finally {
$this->unlockSend($locked);
}
}
/**
* Wire a telemetry adapter for connection-level metrics. The current
* pending-queue depth is recorded after each enqueue — a steady-state
* non-zero value means callers are queueing faster than Redis is
* replying.
*/
public function setTelemetry(Telemetry $telemetry): void
{
$this->pendingDepth = $telemetry->createGauge(
'cache.redis_multiplexing.pending.depth',
description: 'Pending response channels awaiting RESP frames on the multiplexed connection.',
);
}
/**
* Explicitly close the multiplexed connection. Required for clean shutdown
* because the reader coroutine holds a reference to this adapter.
*/
public function disconnect(): void
{
$this->shutdown();
}
public function setMaxRetries(int $maxRetries): self
{
$this->maxRetries = max(self::MIN_RETRIES, min($maxRetries, self::MAX_RETRIES));
return $this;
}
public function setRetryDelay(int $retryDelay): self
{
$this->retryDelay = $retryDelay;
return $this;
}
public function getMaxRetries(): int
{
return $this->maxRetries;
}
public function getRetryDelay(): int
{
return $this->retryDelay;
}
public function load(string $key, int $ttl, string $hash = ''): mixed
{
if (empty($hash)) {
$hash = $key;
}
$value = $this->command(['HGET', $key, $hash]);
if (! is_string($value)) {
return false;
}
return Envelope::decode($value, $ttl, time());
}
public function save(string $key, array|string $data, string $hash = ''): bool|string|array
{
if (empty($key) || empty($data)) {
return false;
}
if (empty($hash)) {
$hash = $key;
}
try {
$value = Envelope::encode($data, time());
$this->command(['HSET', $key, $hash, $value]);
return $data;
} catch (Throwable $th) {
return false;
}
}
public function touch(string $key, string $hash = ''): bool
{
if (empty($hash)) {
$hash = $key;
}
$value = $this->command(['HGET', $key, $hash]);
if (! is_string($value)) {
return false;
}
$payload = Envelope::touch($value, time());
if ($payload === false) {
return false;
}
return $this->command(['HSET', $key, $hash, $payload]) !== false;
}
/**
* @return string[]
*/
public function list(string $key): array
{
$keys = $this->command(['HKEYS', $key]);
if (! is_array($keys)) {
return [];
}
/** @var string[] $keys */
return $keys;
}
public function purge(string $key, string $hash = ''): bool
{
if (! empty($hash)) {
return (bool) $this->command(['HDEL', $key, $hash]);
}
return (bool) $this->command(['DEL', $key]);
}
public function flush(): bool
{
return $this->command(['FLUSHDB']) === 'OK';
}
public function ping(): bool
{
try {
return $this->command(['PING']) === 'PONG';
} catch (Throwable $th) {
return false;
}
}
public function getSize(): int
{
$size = $this->command(['DBSIZE']);
return is_int($size) ? $size : 0;
}
public function getName(?string $key = null): string
{
return 'redis-multiplexing';
}
/**
* Send a Redis command and block the calling coroutine until the response arrives.
*
* @param array<int|string> $args
*/
private function command(array $args): mixed
{
$attempts = 0;
$maxAttempts = 1 + $this->maxRetries;
while (true) {
try {
return $this->dispatch($args);
} catch (ConnectionException $th) {
if (++$attempts >= $maxAttempts) {
throw $th;
}
Coroutine::sleep($this->retryDelaySeconds());
$this->ensureConnected();
}
}
}
private function retryDelaySeconds(): float
{
$baseDelay = max(0, $this->retryDelay) / 1000;
if ($baseDelay === 0.0) {
return 0.0;
}
return $baseDelay + mt_rand(0, 100) / 1000;
}
/**
* Send a single command on the current connection and wait for its response.
* Acquires the send lock; do not call from a context that already holds it.
*
* @param array<int|string> $args
*/
private function dispatch(array $args): mixed
{
$locked = $this->lockSend();
try {
$context = $this->connection;
if ($context === null) {
throw new ConnectionException('Redis connection is not open');
}
$response = new Channel(1);
$error = null;
$context->pending->enqueue($response);
$this->pendingDepth?->record($context->pending->count());
try {
$context->client->send(Client::encode($args));
} catch (ConnectionException $sendError) {
$error = $sendError;
}
} finally {
$this->unlockSend($locked);
}
if ($error !== null) {
$this->teardownIfCurrent($context, $error);
throw $error;
}
return $this->awaitResponse($context, $response);
}
/**
* @param Channel<mixed> $response
*/
private function awaitResponse(ConnectionContext $context, Channel $response): mixed
{
$result = $response->pop($this->readTimeout);
if ($result === false && $response->errCode !== 0) {
$error = new ConnectionException('Timed out waiting for Redis response');
$this->teardownIfCurrent($context, $error);
throw $error;
}
return Client::unwrap($result);
}
private function ensureConnected(): void
{
$locked = $this->lockSend();
try {
if ($this->connection === null) {
$this->connect();
}
} finally {
$this->unlockSend($locked);
}
}
/**
* Caller must hold $sendLock when running inside a coroutine.
*/
private function connect(): void
{
$client = new Client($this->host, $this->port, $this->timeout);
try {
if ($this->auth !== null) {
$authArgs = is_array($this->auth)
? array_merge(['AUTH'], array_values($this->auth))
: ['AUTH', $this->auth];
if ($client->command($authArgs, $this->readTimeout) !== 'OK') {
throw new \RedisException('Redis AUTH failed');
}
}
if ($this->dbIndex !== 0) {
if ($client->command(['SELECT', (string) $this->dbIndex], $this->readTimeout) !== 'OK') {
throw new \RedisException('Redis SELECT failed');
}
}
} catch (Throwable $th) {
$client->close();
throw $th;
}
/** @var SplQueue<Channel<mixed>> $pending */
$pending = new SplQueue();
$context = new ConnectionContext($client, $pending);
$this->connection = $context;
Coroutine::create(function () use ($context) {
$this->readerLoop($context);
});
}
private function shutdown(): void
{
$context = null;
$locked = $this->lockSend();
try {
if ($this->connection !== null) {
$context = $this->connection;
$this->connection = null;
}
} finally {
$this->unlockSend($locked);
}
if ($context !== null) {
$this->finishTeardown($context, new ConnectionException('Connection closed'));
}
}
/**
* Stop the connection and fail every coroutine still waiting on a response.
*/
private function finishTeardown(ConnectionContext $context, ConnectionException $error): void
{
while (! $context->pending->isEmpty()) {
$ch = $context->pending->dequeue();
if ($ch instanceof Channel) {
$ch->push(new ConnectionError($error));
}
}
$context->client->close();
}
private function teardownIfCurrent(ConnectionContext $context, ConnectionException $error): void
{
$shouldTeardown = false;
$locked = $this->lockSend();
try {
if ($this->connection === $context) {
$this->connection = null;
$shouldTeardown = true;
}
} finally {
$this->unlockSend($locked);
}
if ($shouldTeardown) {
$this->finishTeardown($context, $error);
}
}
private function lockSend(): bool
{
if (Coroutine::getCid() < 0) {
return false;
}
$this->sendLock->lock();
return true;
}
private function unlockSend(bool $locked): void
{
if ($locked) {
$this->sendLock->unlock();
}
}
private function readerLoop(ConnectionContext $context): void
{
$readBuffer = $context->client->takeBuffer();
while (true) {
while ($readBuffer !== '') {
$offset = 0;
try {
$value = Client::parse($readBuffer, $offset);
} catch (Throwable $th) {
$this->teardownIfCurrent($context, new ConnectionException('Redis protocol parse failed: '.$th->getMessage()));
return;
}
if ($value === Client::INCOMPLETE) {
break;
}
$readBuffer = substr($readBuffer, $offset);
if (! $this->isCurrentContext($context)) {
return;
}
// A complete frame implies a prior pending enqueue.
$waiting = $context->pending->isEmpty() ? null : $context->pending->dequeue();
if ($waiting instanceof Channel) {
$waiting->push($value);
} else {
// Should never happen given the send-lock invariant. Log
// and tear down so the next caller reconnects on a clean
// socket rather than continuing to misroute frames.
error_log('Redis\\Multiplexing: unexpected RESP frame with no pending request; tearing down connection');
$this->teardownIfCurrent($context, new ConnectionException('Unexpected RESP frame with no pending request'));
return;
}
}
$chunk = $context->client->recv(-1);
if ($chunk === false || $chunk === '') {
$this->teardownIfCurrent($context, new ConnectionException('Redis connection closed'));
return;
}
$readBuffer .= $chunk;
}
}
private function isCurrentContext(ConnectionContext $context): bool
{
$locked = $this->lockSend();
try {
return $this->connection === $context;
} finally {
$this->unlockSend($locked);
}
}
}
+11
View File
@@ -0,0 +1,11 @@
<?php
namespace Utopia\Cache\Adapter\Redis;
final class RedisError
{
public function __construct(
public \RedisException $exception,
) {
}
}
@@ -1,6 +1,6 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E;
use PHPUnit\Framework\TestCase;
use Utopia\Cache\Cache;
@@ -1,6 +1,6 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E;
use PHPUnit\Framework\TestCase;
use RuntimeException;
@@ -1,6 +1,6 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E;
use Utopia\Cache\Adapter\Filesystem;
use Utopia\Cache\Cache;
@@ -1,6 +1,6 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E;
use Memcached as Memcached;
use Utopia\Cache\Adapter\Hazelcast as HazelcastAdapter;
@@ -1,6 +1,6 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E;
use Memcached as Memcached;
use Utopia\Cache\Adapter\Memcached as MemcachedAdapter;
@@ -1,6 +1,6 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E;
use Utopia\Cache\Adapter\Memory;
use Utopia\Cache\Cache;
@@ -1,6 +1,6 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E;
use Utopia\Cache\Adapter\None;
use Utopia\Cache\Cache;
@@ -1,6 +1,6 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E;
use Utopia\Cache\Adapter\Filesystem;
use Utopia\Cache\Adapter\Pool;
+288
View File
@@ -0,0 +1,288 @@
<?php
namespace Utopia\Tests\E2E\Redis;
use PHPUnit\Framework\TestCase;
use Swoole\Coroutine;
use function Swoole\Coroutine\run;
use Swoole\Coroutine\WaitGroup;
use Utopia\Cache\Adapter\Redis\Multiplexing as RedisMultiplexing;
use Utopia\Cache\Cache;
class MultiplexingTest extends TestCase
{
protected string $key = 'test-key-for-cache';
protected string $data = 'test data string';
/** @var array<string> */
protected array $dataArray = ['test', 'data', 'string'];
/**
* Run the entire test body inside a Swoole coroutine context.
*/
private function runCo(callable $fn): void
{
$error = null;
run(function () use ($fn, &$error) {
try {
$fn();
} catch (\Throwable $th) {
$error = $th;
} finally {
$this->close();
}
});
if ($error !== null) {
throw $error;
}
}
private RedisMultiplexing $adapter;
private function makeCache(): Cache
{
$this->adapter = new RedisMultiplexing('redis', 6379);
return new Cache($this->adapter);
}
private function close(): void
{
if (isset($this->adapter)) {
$this->adapter->disconnect();
}
}
public function testCacheSave(): void
{
$this->runCo(function () {
$cache = $this->makeCache();
$cache->flush();
$result = $cache->save($this->key, $this->dataArray, $this->key);
$this->assertEquals($this->dataArray, $result);
$result = $cache->save($this->key, $this->data, $this->key);
$this->assertEquals($this->data, $result);
$loaded = $cache->load($this->key, 60, $this->key);
$this->assertEquals($this->data, $loaded);
});
}
public function testCachePurge(): void
{
$this->runCo(function () {
$cache = $this->makeCache();
$cache->save($this->key, $this->data, $this->key);
$loaded = $cache->load($this->key, 60, $this->key);
$this->assertEquals($this->data, $loaded);
$this->assertTrue($cache->purge($this->key));
$this->assertFalse($cache->load($this->key, 60, $this->key));
});
}
public function testCacheTouch(): void
{
$this->runCo(function () {
$cache = $this->makeCache();
$cache->save('touch-key', 'touch data', 'touch-key');
sleep(3);
$this->assertFalse($cache->load('touch-key', 2, 'touch-key'));
$this->assertTrue($cache->touch('touch-key', 'touch-key'));
$this->assertEquals('touch data', $cache->load('touch-key', 2, 'touch-key'));
$this->assertFalse($cache->touch('missing-touch-key', 'missing-touch-key'));
$cache->purge('touch-key');
});
}
public function testPing(): void
{
$this->runCo(function () {
$cache = $this->makeCache();
$this->assertTrue($cache->ping());
});
}
public function testFlush(): void
{
$this->runCo(function () {
$cache = $this->makeCache();
$cache->save('x', 'x', 'x');
$cache->save('y', 'y', 'y');
$this->assertEquals('x', $cache->load('x', 100, 'x'));
$this->assertEquals('y', $cache->load('y', 100, 'y'));
$this->assertTrue($cache->flush());
$this->assertFalse($cache->load('x', 100, 'x'));
$this->assertFalse($cache->load('y', 100, 'y'));
});
}
public function testGetSize(): void
{
$this->runCo(function () {
$cache = $this->makeCache();
$cache->flush();
$cache->save('test:file33', 'file33', 'test:file33');
$cache->save('test:file34', 'file34', 'test:file34');
$cache->save('test:file35', 'file35', 'test:file35');
$this->assertEquals(3, $cache->getSize());
});
}
public function testJsonData(): void
{
$this->runCo(function () {
$cache = $this->makeCache();
$cache->flush();
$payload = [
'id' => 'doc-42',
'title' => 'Hello, "world"',
'tags' => ['php', 'redis', 'swoole'],
'meta' => [
'count' => 7,
'ratio' => 0.125,
'flag' => true,
'missing' => null,
],
'unicode' => 'café — 日本語 — 🚀',
'nested' => [
'a' => ['b' => ['c' => ['d' => 'deep']]],
],
'binary-ish' => "line1\nline2\twith\ttabs\r\nand crlf",
];
$saved = $cache->save('json:doc', $payload, 'json:doc');
$this->assertEquals($payload, $saved);
$loaded = $cache->load('json:doc', 60, 'json:doc');
$this->assertEquals($payload, $loaded);
$jsonString = json_encode($payload, JSON_THROW_ON_ERROR);
$this->assertNotFalse($jsonString);
$this->assertEquals($jsonString, $cache->save('json:string', $jsonString, 'json:string'));
$this->assertEquals($jsonString, $cache->load('json:string', 60, 'json:string'));
});
}
public function testLargeJsonPayload(): void
{
$this->runCo(function () {
$cache = $this->makeCache();
$cache->flush();
$rows = [];
for ($i = 0; $i < 1000; $i++) {
$rows[] = [
'i' => $i,
'name' => 'row-'.$i,
'value' => str_repeat('x', 64),
];
}
$payload = ['rows' => $rows];
$saved = $cache->save('json:large', $payload, 'json:large');
$this->assertEquals($payload, $saved);
$loaded = $cache->load('json:large', 60, 'json:large');
$this->assertEquals($payload, $loaded);
});
}
public function testConcurrentJsonMultiplexing(): void
{
$this->runCo(function () {
$cache = $this->makeCache();
$cache->flush();
$count = 50;
$wg = new WaitGroup();
$errors = [];
for ($i = 0; $i < $count; $i++) {
$wg->add();
Coroutine::create(function () use ($cache, $i, $wg, &$errors) {
try {
$key = 'json-mux:'.$i;
$value = [
'i' => $i,
'tags' => ['a', 'b', 'c-'.$i],
'meta' => ['nested' => ['count' => $i * 2]],
'text' => 'café 🚀 row '.$i,
];
$saved = $cache->save($key, $value, $key);
if ($saved !== $value) {
$errors[] = "save mismatch for $i";
}
$loaded = $cache->load($key, 60, $key);
if ($loaded != $value) {
$errors[] = "load mismatch for $i: ".var_export($loaded, true);
}
} catch (\Throwable $th) {
$errors[] = $th->getMessage();
} finally {
$wg->done();
}
});
}
$wg->wait();
$this->assertEmpty($errors, 'Concurrent errors: '.implode('; ', $errors));
$this->assertEquals($count, $cache->getSize());
});
}
/**
* Concurrent multiplexing: many coroutines hitting the same connection.
*/
public function testConcurrentMultiplexing(): void
{
$this->runCo(function () {
$cache = $this->makeCache();
$cache->flush();
$count = 50;
$wg = new WaitGroup();
$errors = [];
for ($i = 0; $i < $count; $i++) {
$wg->add();
Coroutine::create(function () use ($cache, $i, $wg, &$errors) {
try {
$key = 'mux:'.$i;
$value = 'value-'.$i;
$saved = $cache->save($key, $value, $key);
if ($saved !== $value) {
$errors[] = "save mismatch for $i: ".var_export($saved, true);
}
$loaded = $cache->load($key, 60, $key);
if ($loaded !== $value) {
$errors[] = "load mismatch for $i: ".var_export($loaded, true);
}
} catch (\Throwable $th) {
$errors[] = $th->getMessage();
} finally {
$wg->done();
}
});
}
$wg->wait();
$this->assertEmpty($errors, 'Concurrent errors: '.implode('; ', $errors));
$this->assertEquals($count, $cache->getSize());
});
}
}
@@ -1,10 +1,11 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E\Redis;
use RedisCluster as RedisCluster;
use Utopia\Cache\Adapter\RedisCluster as RedisAdapter;
use Utopia\Cache\Cache;
use Utopia\Tests\E2E\Base;
const SEEDS = [
'redis-cluster:7000',
@@ -1,10 +1,11 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E\Redis;
use Redis as Redis;
use Utopia\Cache\Adapter\Redis as RedisAdapter;
use Utopia\Cache\Cache;
use Utopia\Tests\E2E\Base;
class RedisTest extends Base
{
@@ -17,6 +18,7 @@ class RedisTest extends Base
public function testGetSize(): void
{
self::$cache->flush();
self::$cache->save('test:file33', 'file33', 'test:file33');
self::$cache->save('test:file34', 'file34', 'test:file34');
self::$cache->save('test:file35', 'file35', 'test:file35');
@@ -1,6 +1,6 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E;
use Redis as Redis;
use Throwable;
@@ -1,6 +1,6 @@
<?php
namespace Utopia\Tests;
namespace Utopia\Tests\E2E;
use PHPUnit\Framework\TestCase;
use Utopia\Cache\Adapter\Memory;
+249
View File
@@ -0,0 +1,249 @@
<?php
namespace Utopia\Tests\Unit\Redis;
use PHPUnit\Framework\TestCase;
use Utopia\Cache\Adapter\Redis\Client;
use Utopia\Cache\Adapter\Redis\ConnectionError;
use Utopia\Cache\Adapter\Redis\ConnectionException;
use Utopia\Cache\Adapter\Redis\RedisError;
class ClientTest extends TestCase
{
public function testEncodeBuildsRespArrayOfBulkStrings(): void
{
$this->assertSame(
"*1\r\n\$4\r\nPING\r\n",
Client::encode(['PING'])
);
$this->assertSame(
"*3\r\n\$3\r\nSET\r\n\$3\r\nfoo\r\n\$3\r\nbar\r\n",
Client::encode(['SET', 'foo', 'bar'])
);
}
public function testEncodeCoercesIntegersToStrings(): void
{
$this->assertSame(
"*2\r\n\$6\r\nSELECT\r\n\$1\r\n3\r\n",
Client::encode(['SELECT', 3])
);
}
public function testEncodePreservesBinaryPayloadByByteLength(): void
{
$payload = "café\n\0bytes";
$encoded = Client::encode(['SET', 'k', $payload]);
$this->assertSame(
"*3\r\n\$3\r\nSET\r\n\$1\r\nk\r\n\$".strlen($payload)."\r\n".$payload."\r\n",
$encoded
);
}
public function testParseSimpleString(): void
{
$offset = 0;
$this->assertSame('OK', Client::parse("+OK\r\n", $offset));
$this->assertSame(5, $offset);
}
public function testParseInteger(): void
{
$offset = 0;
$this->assertSame(42, Client::parse(":42\r\n", $offset));
$this->assertSame(5, $offset);
}
public function testParseNegativeInteger(): void
{
$offset = 0;
$this->assertSame(-7, Client::parse(":-7\r\n", $offset));
}
public function testParseBulkString(): void
{
$offset = 0;
$this->assertSame('hello', Client::parse("\$5\r\nhello\r\n", $offset));
$this->assertSame(11, $offset);
}
public function testParseBulkStringWithEmbeddedCrlf(): void
{
$offset = 0;
$payload = "line1\r\nline2";
$this->assertSame(
$payload,
Client::parse('$'.strlen($payload)."\r\n".$payload."\r\n", $offset)
);
}
public function testParseEmptyBulkString(): void
{
$offset = 0;
$this->assertSame('', Client::parse("\$0\r\n\r\n", $offset));
$this->assertSame(6, $offset);
}
public function testParseNullBulkString(): void
{
$offset = 0;
$this->assertNull(Client::parse("\$-1\r\n", $offset));
$this->assertSame(5, $offset);
}
public function testParseArrayOfMixedTypes(): void
{
$offset = 0;
$buffer = "*3\r\n\$3\r\nfoo\r\n:42\r\n+OK\r\n";
$this->assertSame(['foo', 42, 'OK'], Client::parse($buffer, $offset));
$this->assertSame(strlen($buffer), $offset);
}
public function testParseEmptyArray(): void
{
$offset = 0;
$this->assertSame([], Client::parse("*0\r\n", $offset));
}
public function testParseNullArray(): void
{
$offset = 0;
$this->assertNull(Client::parse("*-1\r\n", $offset));
}
public function testParseNestedArrays(): void
{
$offset = 0;
$buffer = "*2\r\n*2\r\n:1\r\n:2\r\n*1\r\n\$1\r\nx\r\n";
$this->assertSame([[1, 2], ['x']], Client::parse($buffer, $offset));
$this->assertSame(strlen($buffer), $offset);
}
public function testParseRedisErrorIsWrappedNotThrown(): void
{
$offset = 0;
$value = Client::parse("-WRONGTYPE wrong kind\r\n", $offset);
$this->assertInstanceOf(RedisError::class, $value);
$this->assertSame('WRONGTYPE wrong kind', $value->exception->getMessage());
}
public function testParseReturnsIncompleteWhenBufferEmpty(): void
{
$offset = 0;
$this->assertSame(Client::INCOMPLETE, Client::parse('', $offset));
}
public function testParseReturnsIncompleteWhenLineUnterminated(): void
{
$offset = 0;
$this->assertSame(Client::INCOMPLETE, Client::parse('+OK', $offset));
}
public function testParseReturnsIncompleteForTruncatedBulkString(): void
{
$offset = 0;
// header says 5 bytes, payload is short
$this->assertSame(Client::INCOMPLETE, Client::parse("\$5\r\nhel", $offset));
}
public function testParseReturnsIncompleteForBulkStringMissingTrailingCrlf(): void
{
$offset = 0;
$this->assertSame(Client::INCOMPLETE, Client::parse("\$5\r\nhello", $offset));
}
public function testParseReturnsIncompleteForPartiallyDeliveredArrayElement(): void
{
$offset = 0;
$this->assertSame(Client::INCOMPLETE, Client::parse("*2\r\n:1\r\n:", $offset));
}
public function testParseAdvancesOffsetExactlyOneFrame(): void
{
$offset = 0;
$buffer = "+OK\r\n+SECOND\r\n";
$this->assertSame('OK', Client::parse($buffer, $offset));
$this->assertSame(5, $offset);
$this->assertSame('SECOND', Client::parse($buffer, $offset));
$this->assertSame(strlen($buffer), $offset);
}
public function testParseUnknownTypeThrows(): void
{
$this->expectException(\RedisException::class);
$offset = 0;
Client::parse("?nope\r\n", $offset);
}
public function testEncodeAndParseRoundTripFlattenedToServerEcho(): void
{
// The server's HSET reply for a new field is :1 — confirm we can
// round-trip from encode -> ... -> parse for what we'd read back.
$offset = 0;
$this->assertSame(1, Client::parse(":1\r\n", $offset));
// And that encode produces what a real Redis would expect.
$this->assertSame(
"*4\r\n\$4\r\nHSET\r\n\$1\r\nk\r\n\$1\r\nf\r\n\$1\r\nv\r\n",
Client::encode(['HSET', 'k', 'f', 'v'])
);
}
public function testUnwrapPassesThroughScalars(): void
{
$this->assertSame('OK', Client::unwrap('OK'));
$this->assertSame(42, Client::unwrap(42));
$this->assertNull(Client::unwrap(null));
$this->assertSame('', Client::unwrap(''));
}
public function testUnwrapPassesThroughArraysOfScalars(): void
{
$this->assertSame(['a', 1, null], Client::unwrap(['a', 1, null]));
}
public function testUnwrapThrowsRedisErrorAtTopLevel(): void
{
$this->expectException(\RedisException::class);
$this->expectExceptionMessage('WRONGTYPE');
Client::unwrap(new RedisError(new \RedisException('WRONGTYPE')));
}
public function testUnwrapThrowsConnectionErrorAtTopLevel(): void
{
$this->expectException(ConnectionException::class);
$this->expectExceptionMessage('connection lost');
Client::unwrap(new ConnectionError(new ConnectionException('connection lost')));
}
public function testUnwrapThrowsRedisErrorNestedInArray(): void
{
$this->expectException(\RedisException::class);
$this->expectExceptionMessage('NOAUTH');
// Element 1 is an error frame; the unwrap must walk into it.
Client::unwrap(['ok', new RedisError(new \RedisException('NOAUTH'))]);
}
public function testUnwrapThrowsErrorNestedInsideNestedArray(): void
{
$this->expectException(\RedisException::class);
$this->expectExceptionMessage('deep');
Client::unwrap([
['nested', ['deeper', new RedisError(new \RedisException('deep'))]],
]);
}
public function testUnwrapReturnsArrayUnchangedWhenNoErrors(): void
{
$input = [['a', 1], ['b', null], 'c'];
$this->assertSame($input, Client::unwrap($input));
}
public function testUnwrapHandlesEmptyArray(): void
{
$this->assertSame([], Client::unwrap([]));
}
}
+116
View File
@@ -0,0 +1,116 @@
<?php
namespace Utopia\Tests\Unit\Redis;
use PHPUnit\Framework\TestCase;
use Utopia\Cache\Adapter\Redis\Envelope;
class EnvelopeTest extends TestCase
{
public function testEncodeWrapsDataAndTime(): void
{
$encoded = Envelope::encode('hello', 1700000000);
$this->assertSame('{"time":1700000000,"data":"hello"}', $encoded);
}
public function testEncodeArrayPayload(): void
{
$encoded = Envelope::encode(['a' => 1], 42);
$this->assertSame('{"time":42,"data":{"a":1}}', $encoded);
}
public function testDecodeReturnsDataWhenFresh(): void
{
$encoded = Envelope::encode(['x' => 1], 100);
$this->assertSame(['x' => 1], Envelope::decode($encoded, ttl: 60, now: 130));
}
public function testDecodeReturnsFalseWhenStale(): void
{
$encoded = Envelope::encode('value', 100);
// 100 + 60 = 160; now = 161 → stale
$this->assertFalse(Envelope::decode($encoded, ttl: 60, now: 161));
}
public function testDecodeBoundaryIsExclusive(): void
{
$encoded = Envelope::encode('value', 100);
// time + ttl > now means strictly greater; equal counts as stale
$this->assertFalse(Envelope::decode($encoded, ttl: 60, now: 160));
$this->assertSame('value', Envelope::decode($encoded, ttl: 60, now: 159));
}
public function testDecodeTreatsMalformedJsonAsMiss(): void
{
$this->assertFalse(Envelope::decode('not json', 60, 0));
$this->assertFalse(Envelope::decode('', 60, 0));
$this->assertFalse(Envelope::decode('null', 60, 0));
}
public function testDecodeRejectsMissingFields(): void
{
$this->assertFalse(Envelope::decode('{"time":100}', 60, 0));
$this->assertFalse(Envelope::decode('{"data":"x"}', 60, 0));
$this->assertFalse(Envelope::decode('{}', 60, 0));
}
public function testDecodeRejectsNonIntegerTime(): void
{
$this->assertFalse(Envelope::decode('{"time":"100","data":"x"}', 60, 0));
$this->assertFalse(Envelope::decode('{"time":1.5,"data":"x"}', 60, 0));
}
public function testDecodePreservesNullData(): void
{
// isset() rejects null, so null-data envelopes are treated as a miss.
// This matches existing adapter behavior; documenting via test.
$this->assertFalse(Envelope::decode('{"time":100,"data":null}', 60, 130));
}
public function testDecodePreservesNestedArrayData(): void
{
$data = ['a' => ['b' => ['c' => 'deep']], 'list' => [1, 2, 3]];
$encoded = Envelope::encode($data, 100);
$this->assertSame($data, Envelope::decode($encoded, 60, 130));
}
public function testTouchRewritesTime(): void
{
$encoded = Envelope::encode('value', 100);
$touched = Envelope::touch($encoded, 200);
$this->assertIsString($touched);
$this->assertSame('value', Envelope::decode($touched, 60, 250));
// Original timestamp would have made this stale
$this->assertFalse(Envelope::decode($encoded, 60, 250));
}
public function testTouchPreservesArrayData(): void
{
$data = ['x' => 1, 'y' => [2, 3]];
$encoded = Envelope::encode($data, 100);
$touched = Envelope::touch($encoded, 200);
$this->assertIsString($touched);
$this->assertSame($data, Envelope::decode($touched, 60, 230));
}
public function testTouchReturnsFalseOnMalformedJson(): void
{
$this->assertFalse(Envelope::touch('not json', 200));
}
public function testTouchReturnsFalseWhenDataKeyMissing(): void
{
$this->assertFalse(Envelope::touch('{"time":100}', 200));
$this->assertFalse(Envelope::touch('{}', 200));
}
public function testTouchAcceptsEnvelopeWithoutPriorTimeField(): void
{
// touch() only requires a 'data' key — re-stamping is the whole point.
$touched = Envelope::touch('{"data":"x"}', 200);
$this->assertIsString($touched);
$this->assertSame('x', Envelope::decode($touched, 60, 230));
}
}