Skip to content

HydraCache 0.63.0

Choose a tag to compare

View all tags
@github-actions github-actions released this 13 Jul 08:54
· 931 commits to main since this release
v0.63.0
e599bca

HydraCache 0.63.0

0.63.0 introduces the optional Redis RESP edge facade foundation for the
cache subset. The facade is off by default, speaks RESP2 and RESP3, and translates
supported Redis cache commands into the HydraCache client protocol and
client-surface execution path. The expanded release registers additive
hydracache-client-protocol v3 TTL metadata/expiry operations so Redis TTL
commands can be supported without bypassing the client surface. It also adds
Redis AUTH/HELLO AUTH support for auth-required listeners and native
rediss:// transport security for the RESP listener. The final 0.63 scope also
includes the narrow single-endpoint, node-local Redis lock subset needed by
redis-py Lock and Node redlock single-resource migrations. It does not make
HydraCache a Redis clone or a distributed Redis data plane.

Highlights

  • Added hydracache-redis-compat, an edge crate containing the RESP2/RESP3 codec,
    parser-neutral command model, translator, reducers, connection handler, and
    golden/fuzz gates.
  • Documented the 0.63 Redis deployment posture as single-endpoint and
    node-local: RESP state and Redis lock state belong to the selected daemon
    listener, not to a load-balanced Redis Service/VIP spanning multiple daemons.
  • Added off-by-default server config and startup wiring for redis_api, with
    distinct-address validation, real TCP listener evidence, and drain gating.
  • Implemented supported cache-subset translation for PING, ECHO, QUIT,
    HELLO 2, HELLO 3, COMMAND, INFO, SELECT 0, TYPE, GET, SET, MGET, MSET, DEL, and EXISTS.
  • Added the single-logical-database contract: SELECT 0 is a no-op for Redis
    client URL compatibility, while non-zero or invalid DB indexes fail loud before
    mutation and never change the connection keyspace.
  • Added RESP3 negotiation for the same cache subset: HELLO 3 switches the
    connection to RESP3 replies, RESP3 command arrays are decoded, and unsupported
    aggregate command frames still fail before mutation.
  • Added atomic MSET coverage: batch arity/limits are validated before
    mutation, duplicate keys follow Redis last-value-wins ordering, and rejected
    batches leave touched keys unchanged.
  • Added protocol v3 TTL/expiry coverage for SET EX/PX, SETEX/PSETEX, EXPIRE, PEXPIRE,
    PERSIST, TTL, and PTTL, including client-surface expiry enforcement,
    v2 compatibility, remaining-TTL metadata, non-positive/missing-key expiry
    return edges, and bounded real-Redis oracle tolerance.
  • Added protocol v4 lock-conditional coverage for the narrow Redis lock subset:
    SET NX PX/EX acquire is atomic and returns OK/nil like Redis, token-safe
    release/extend are accepted only for reviewed Lua fingerprints, unknown Lua
    fails before mutation, redis-py Lock and Node redlock@5.0.0-beta.2
    single-resource API rows are in the Docker-gated matrix, redis-py
    replace_ttl=False extend adds to the remaining TTL instead of replacing it,
    and the release does not claim Redlock quorum, Redis Cluster, or general Lua
    compatibility.
  • Added minimal health/probe coverage: INFO returns only honest RESP facade
    fields, and TYPE returns string for existing cache values or none for
    misses. INFO intentionally omits Redis memory, DB keyspace, replication, and
    cluster sections.
  • Added HC.INVALIDATE as a HydraCache extension backed by native
    ClientRequest::Invalidate.
  • Classified HC.STATS and HC.DIAGNOSTICS as tenant-scoped extension
    requests and served them from bounded, redacted listener diagnostics.
  • Added HydraCache-only HC.NAMESPACE, HC.TAG, HC.SETTAGS, and
    HC.INVALIDATE_TAG. Namespace selection is listener-scoped, tag metadata is
    RESP-listener-local and in-memory, tags attach only to existing live keys, and
    tag invalidation removes live tagged keys through ClientSurfaceState without
    scanning the keyspace or claiming Redis Cluster/global tag semantics.
  • Added fail-loud guardrails for unsupported, candidate, and admin-disabled
    commands; Redis Cluster remains intentionally unsupported, CLUSTER *
    returns a stable unsupported error, and no hash slots, topology, MOVED, or
    ASK redirects are emitted.
  • Added RESP golden fixtures, partial/coalesced frame tests, fuzz smoke,
    frame/array/bulk-size limits, real TCP startup/drain tests, and gated
    redis_clients / resp_resource_smoke targets for pre-release proof.
  • Added Redis AUTH/HELLO AUTH for auth-required listeners, including
    Redis-shaped NOAUTH, WRONGPASS, and OK responses, credential redaction,
    hardened password comparison without prefix-dependent byte equality,
    connection-local authenticated state, server config wiring, and mainstream
    client gate coverage for auth-required startup.
  • Added native rediss:// support for the RESP listener by reusing server TLS
    certificate/key material. Redis AUTH remains required for auth-required
    listeners above the TLS transport.

Not Shipped In 0.63.0

  • Redis Cluster: no CLUSTER SLOTS, CLUSTER NODES, hash slots, topology,
    MOVED, or ASK. Cluster-aware clients must use standalone mode.
  • Cross-daemon Redis key visibility: a value written through one HydraCache RESP
    endpoint is not claimed to be visible through another endpoint in 0.63.0.
  • Multi-endpoint Redis lock mutual exclusion: SET NX PX/EX and allowlisted
    lock scripts are claimed only for one selected RESP endpoint. Do not use a
    load-balanced Redis VIP across multiple HydraCache daemons for Redis locks.
  • Redis multi-db isolation: no DB 1..N keyspaces. Use SELECT 0 or omit
    SELECT; non-zero DB indexes return a stable error.
  • Redis ROLE, DBSIZE, and SCAN: these remain unsupported because Redis
    replication role, exact keyspace size, and iterable keyspace behavior are not
    honest RESP-edge claims for HydraCache.
  • Redis CONFIG, FLUSHDB, and FLUSHALL: these are recognized but
    admin-disabled by default. CONFIG must not fabricate Redis server
    configuration, and destructive flush commands must return stable NOPERM
    before mutation.
  • Redis conditional/retention SET options outside the lock subset: SET NX
    without TTL, SET ... XX, SET ... GET, and SET ... KEEPTTL are not
    supported in 0.63. They return Redis-shaped errors before dispatch and leave
    keys unchanged. SET NX PX/EX is the only conditional SET shape claimed.
  • General Redis Lua remains unsupported. Only the reviewed lock-script allowlist
    is accepted for redis-py Lock pinned to redis-py==5.2.1, simple token-safe
    release/extend, and Node redis@4.7.0 + redlock@5.0.0-beta.2
    single-resource scripts. redis-py release/extend/reacquire exact SHA1
    fingerprints are fast-tested; unknown or changed scripts fail loud before
    mutation. Redisson full locks, Redlock quorum semantics, multi-key locks,
    transactions, modules, pub/sub, streams, and Redis data structures remain out
    of scope.
  • Redis absolute-expiry SET options: SET ... EXAT and SET ... PXAT are
    also not supported in 0.63. They are deferred candidates, separate from lock
    semantics, because they need an explicit server-clock/past-timestamp/overflow
    and TTL-tolerance contract with pinned Redis oracle coverage.
  • Cross-listener, persisted, or HydraCache-core-wide tag metadata for
    HC.TAG/HC.SETTAGS/HC.INVALIDATE_TAG. The 0.63 extension path is
    deliberately edge-local to the RESP listener.
  • General Redis data structures, transactions, modules, pub/sub, streams, or
    Redis administrative commands.

Verification

Fast gates for this release:

cargo xtask doc-check
cargo test -p xtask --test doc_check redis_compat --locked
cargo test -p hydracache-redis-compat --locked
cargo test -p hydracache-server --test server_lifecycle redis --locked
cargo clippy -p hydracache-redis-compat --all-targets --locked -- -D warnings

Gated pre-release proof:

$env:HYDRACACHE_RUN_REDIS_COMPAT_CLIENTS = '1'
$env:HYDRACACHE_REQUIRE_REDIS_ORACLE = '1'
cargo test -p hydracache-redis-compat --test redis_clients --locked -- --ignored --nocapture
$env:HYDRACACHE_RUN_REDIS_COMPAT_RESOURCE_SMOKE = '1'
cargo test -p hydracache-redis-compat --test resp_resource_smoke --locked -- --ignored --nocapture

The GitHub Actions Redis Compatibility Release Proof job runs this Redis
pre-release proof on workflow_dispatch and scheduled CI, including required
Docker oracle/client rows and the resource smoke, so maintainers do not need to
run the full Redis matrix on a workstation.

The client/oracle matrix must use the pinned Redis images in
docs/integrations/redis_compat_conformance.json and compare the supported
subset, including RESP3 negotiation, MSET, TTL commands, auth-required startup,
TTL return edges, SET NX PX/EX lock acquire/contention, token-safe lock
release/extend/reacquire scripts, redis-py Lock, Node redlock single-resource API,
SELECT 0, health/probe commands, HydraCache-only tag extensions, and the
rediss:// startup path,
against real Redis after documented normalization.
When local Python/Node/JVM client dependencies are absent, the matrix falls
back to pinned Docker client images (python:3.13.7-slim,
node:24.6.0-bookworm-slim, and maven:3.9.11-eclipse-temurin-17) before
treating the row as skipped. The Go row uses the local Go toolchain with
go-redis/v9 v9.7.0. The Node Docker row pins
redis@4.7.0 redlock@5.0.0-beta.2; the Python row pins redis==5.2.1.
Set HYDRACACHE_FORCE_REDIS_CLIENT_DOCKER=1 with the client gate to prove the
containerized Python/Node/JVM paths explicitly.
Skip-only green is not sufficient for the redis-py/redlock lock-library claim;
one release-proof run must execute the pinned Docker/client/oracle matrix.

The Redis multi-node daemon E2E gate proves listener lifecycle and selected-endpoint
survival across a neighboring member drain/restart. It does not prove
cross-daemon Redis data replication or distributed Redis lock safety; those are
future distributed-backend work.

Release Status

Implementation branch in progress. The Redis AUTH/HELLO AUTH, native
rediss://, and RESP3 scope is implemented in code, docs, and targeted tests:
auth-required listeners use Redis-shaped auth errors, TLS-enabled RESP listeners
accept rediss:// while rejecting plaintext before mutation, and HELLO 3
switches the connection to RESP3 for the supported cache subset. SELECT 0 is
implemented as the only accepted Redis logical database selector; non-zero DB
selection fails loud. INFO and TYPE are implemented with targeted tests, while
ROLE, DBSIZE, and SCAN remain stable unsupported rows. HC.NAMESPACE and
the edge-local tag extension path are implemented with targeted tests and
Docker/client matrix coverage.

Assets 2
Loading