redb.Route.Redis 4.1.0

redb.Route.Redis

Redis transport for redb.Route. Pub/Sub, Streams, key-value, lists, sorted sets — every Redis data structure is reachable as an endpoint URI via StackExchange.Redis; the builder has factories for keys, Pub/Sub, streams and lists, and Redis.Command(operation, key) for the rest.

Installation

dotnet add package redb.Route.Redis

Usage

URI Format

redis:OPERATION:resource?connectionString=localhost:6379&...

The operation is the first path segment (SET, GET, PUBLISH, SUBSCRIBE, XADD, XREAD, BLPOP, …), the resource — key, channel or stream — follows it: redis:SET:session:42?ttl=300, redis:SUBSCRIBE:notifications. redis:SET/session/42 works too. A parameter the endpoint cannot read (a misspelt option, a value of the wrong type) is refused by name when the endpoint is created.

Fluent DSL

using redb.Route.Redis;

// Pub/Sub — subscribe
From(Redis.Subscribe("notifications").Connection("localhost:6379"))
    .Log("Received: ${body}")
    .To("direct://process");

// Pub/Sub — publish
From("direct://outbound")
    .To(Redis.Publish("events").Connection("localhost:6379"));

// Streams — consumer group
From(Redis.XRead("order-stream")
        .Connection("localhost:6379")
        .ConsumerGroup("processors")
        .ConsumerName("node-1")
        .StreamReadCount(100))
    .To("direct://handle");

// Key-Value
From("direct://cache")
    .To(Redis.Set("session:user-123")
        .Connection("localhost:6379")
        .Ttl(3600));

// Lists
From("direct://enqueue")
    .To(Redis.LPush("task-queue").Connection("localhost:6379"));

Fluent Builder API

Most builder methods accept both constant values and IExpression for runtime resolution via the expression engine.

Redis.Command(operation, key) names an operation of this connector. The COMMAND operation is something else: a raw Redis command, named with .CustomCommand("PING") (or the redbRedis.Command header) and run through ExecuteAsync.

Consumers and delivery

streamClaimMinIdleMs must exceed the longest time a route takes: a slower route would have its entry claimed by another consumer while it still works on it.

Transactions

Redis is a store first, so inside a route's .Transacted() block only the operations that announce work wait for the commit:

• PUBLISH and XADD follow the block like a broker send: they run once the database has committed and are dropped if the block rolls back. The entry id (redbRedis.Stream.MessageId) and the recipient count reach the exchange headers after the commit. .Transacted(false) runs them at once.
• Other writes (SET, INCR, SETNX, lists, hashes, sets) run at once: they exist for their effect and their result right now. .Transacted() holds one back until the commit; the route then does not get its result.
• Reads and pops (GET, LPOP and the like) exist for what they return and refuse .Transacted() when the route starts.

A deferred operation is the same operation, run after the commit on a snapshot of the exchange taken at the step: the same key, body, fields, headers and TTL. Outside a block, .Transacted() fails the step instead of losing the write.

Part of

redb.Route — ESB & EIP Framework for .NET

Named connection factory

Keep credentials out of the route URI: register a factory in the context registry and reference it by name. A set-but-unknown name fails loud at startup — a typo can never silently fall back to inline URI parameters.

context.AddToRegistry("prod", new RedisConnectionFactory
{
    ConnectionString = "redis.internal:6379",
    Password = secrets.RedisPassword,
});
// redis:GET:cache?connectionFactory=prod