From e6761690c270855c9564ccaa1caaa9f53c65a228 Mon Sep 17 00:00:00 2001 From: mgravell Date: Fri, 6 Nov 2026 16:00:44 +0000 Subject: [PATCH 1/2] WithRetry, WithKeyPrefix and the group database ride the context/executor core: RetryDatabase and the KeyPrefixed* family go - WithRetry(IDatabaseAsync) re-contexts via RespRetryExecutor (asyncState now carried; foreign database passes through unchanged); RetryTransaction stays, built by CreateTransaction when the chain retries - MultiGroupDatabase is a slim RedisDatabase over RespGroupExecutor; the 628 generated members go, scans pin to the active member, GetDatabase(-1) resolves from configuration - WithKeyPrefix(IDatabase) re-contexts via AppendKeyPrefix + AppendChannelPrefix and THROWS for a foreign database (silently not prefixing is the wrong keyspace); KeyPrefixed*/KeyPrefixedBatch/KeyPrefixedTransaction deleted - gaps closed: RANDOMKEY refuses under a prefix; SORT BY/GET patterns map (nosort/# exempt); Lua @key ARGV copies prefix via extraction over a WithoutKeyPrefix view; routing questions ask about the prefixed key; AppendKeyPrefix carries topology + cache resolver - the member-by-member wrapper tests (~4,100 lines) become KeyPrefixContextTests over the FakeExecutor RESP-measuring harness --- docs/Execute.md | 2 +- .../AutoDatabaseGenerator.cs | 2 +- src/StackExchange.Redis/AutoDatabase.cs | 3 +- .../Availability/CircuitBreaker.cs | 2 +- .../Availability/DatabaseExtensions.cs | 55 +- .../Availability/MultiGroupDatabase.Scans.cs | 35 +- .../Availability/MultiGroupDatabase.cs | 243 +-- .../Availability/MultiGroupMultiplexer.cs | 19 +- .../Availability/RespRetryExecutor.cs | 57 +- .../Availability/RetryController.cs | 4 +- .../Availability/RetryDatabase.cs | 222 -- .../Availability/RetryTransaction.cs | 10 +- .../Contexts/RespContext.cs | 46 +- .../Contexts/RespGroupExecutor.cs | 12 +- .../Database/RedisDatabase.Scans.cs | 26 +- .../Database/RedisDatabase.Scripts.cs | 41 +- .../Database/RedisDatabase.cs | 68 +- .../Groups/Keys.Methods.cs | 13 +- src/StackExchange.Redis/Groups/Keys.Sort.cs | 23 + .../Interfaces/IInternalDatabaseAsync.cs | 6 +- .../KeyspaceIsolation/DatabaseExtension.cs | 26 +- .../KeyspaceIsolation/KeyPrefixed.Arrays.cs | 76 - .../KeyPrefixed.VectorSets.cs | 76 - .../KeyspaceIsolation/KeyPrefixed.cs | 1261 ----------- .../KeyspaceIsolation/KeyPrefixedBatch.cs | 16 - .../KeyPrefixedDatabase.Arrays.cs | 74 - .../KeyPrefixedDatabase.VectorSets.cs | 72 - .../KeyspaceIsolation/KeyPrefixedDatabase.cs | 935 -------- .../KeyPrefixedTransaction.cs | 29 - src/StackExchange.Redis/RedisKey.cs | 2 - .../AvailabilityConfigTests.cs | 10 +- .../DatabaseSurfaceTests.cs | 4 +- .../KeyPrefixContextTests.cs | 236 ++ .../KeyPrefixedBatchTests.cs | 26 - .../KeyPrefixedDatabaseTests.cs | 1922 ----------------- .../KeyPrefixedTests.cs | 1804 ---------------- .../KeyPrefixedTransactionTests.cs | 132 -- .../KeyPrefixedVectorSetTests.cs | 208 -- .../GroupConfigResolutionTests.cs | 10 +- .../RedisDatabaseTests.cs | 14 +- .../RespGroupExecutorTests.cs | 14 +- .../RespResultTests.cs | 4 +- .../RetryTests/RespRetryExecutorTests.cs | 2 +- .../RetryTests/RetryGuardTests.cs | 26 +- 44 files changed, 691 insertions(+), 7177 deletions(-) delete mode 100644 src/StackExchange.Redis/Availability/RetryDatabase.cs delete mode 100644 src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.Arrays.cs delete mode 100644 src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.VectorSets.cs delete mode 100644 src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.cs delete mode 100644 src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedBatch.cs delete mode 100644 src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.Arrays.cs delete mode 100644 src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.VectorSets.cs delete mode 100644 src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.cs delete mode 100644 src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedTransaction.cs create mode 100644 tests/StackExchange.Redis.Tests/KeyPrefixContextTests.cs delete mode 100644 tests/StackExchange.Redis.Tests/KeyPrefixedBatchTests.cs delete mode 100644 tests/StackExchange.Redis.Tests/KeyPrefixedDatabaseTests.cs delete mode 100644 tests/StackExchange.Redis.Tests/KeyPrefixedTests.cs delete mode 100644 tests/StackExchange.Redis.Tests/KeyPrefixedTransactionTests.cs delete mode 100644 tests/StackExchange.Redis.Tests/KeyPrefixedVectorSetTests.cs diff --git a/docs/Execute.md b/docs/Execute.md index b20fd28146..37adfb174b 100644 --- a/docs/Execute.md +++ b/docs/Execute.md @@ -93,7 +93,7 @@ using RespResult result = db.ExecuteResp("GET", new RedisKeyOrValue[] { (RedisKe // ... ``` -Keys passed this way participate in cluster slot routing and `KeyPrefixed` key-prefixing, just like a key argument to any built-in command. `ExecuteResp` recognizes known command names (applying the same command-map renaming/disabling rules as everything else) and falls back to treating the command as opaque only if it isn't recognized. +Keys passed this way participate in cluster slot routing and `WithKeyPrefix` key-prefixing, just like a key argument to any built-in command. `ExecuteResp` recognizes known command names (applying the same command-map renaming/disabling rules as everything else) and falls back to treating the command as opaque only if it isn't recognized. The `new RedisKeyOrValue[]` above is fine for occasional use, but allocates on every call - see [Leasing the argument buffer](#leasing-the-argument-buffer) below for the low-allocation form once you're on a hot path. diff --git a/eng/StackExchange.Redis.Build/AutoDatabaseGenerator.cs b/eng/StackExchange.Redis.Build/AutoDatabaseGenerator.cs index 1f3913e2a6..5ba2e7a28f 100644 --- a/eng/StackExchange.Redis.Build/AutoDatabaseGenerator.cs +++ b/eng/StackExchange.Redis.Build/AutoDatabaseGenerator.cs @@ -322,7 +322,7 @@ internal enum KnownInterfaces // - generic methods (open type args can't be captured into a concrete state struct) // - the Wait family (synchronization over caller-supplied Tasks, not server calls) // - IsConnected: a synchronous status probe that IDatabaseAsync carries; it would route through the - // sync Execute funnel, which an async-only database (e.g. RetryDatabase) doesn't provide - and a + // sync Execute funnel, which an async-only database (e.g. RetryTransaction) doesn't provide - and a // connection check shouldn't be retried in any case // - IdentifyEndpoint / IdentifyEndpointAsync: a routing lookup ("which endpoint serves this key"), // not a replayable server command; wrappers want their own behaviour here (e.g. a connection-group diff --git a/src/StackExchange.Redis/AutoDatabase.cs b/src/StackExchange.Redis/AutoDatabase.cs index c4ccd6b3c1..a7bcef4ee5 100644 --- a/src/StackExchange.Redis/AutoDatabase.cs +++ b/src/StackExchange.Redis/AutoDatabase.cs @@ -62,7 +62,8 @@ internal interface IMappableRedisArgs // parameter - which is very nearly all of them - so that a funnel holding an opaque TState can still ask the // one question that changes what it must hand back: was this fire-and-forget? // -// It exists for RetryTransaction. That funnel records each call and returns a durable proxy task completed +// It existed for the retired capture-and-replay retry transaction, and remains for any funnel with the +// same need. That funnel recorded each call and returned a durable proxy task completed // later from the attempt, which is wrong for fire-and-forget: a plain RedisTransaction hands back an // *already-completed* task there (the caller has explicitly declined the reply), so without this the same // source awaiting the same result returns instantly on one and hangs on the other. The flags are captured diff --git a/src/StackExchange.Redis/Availability/CircuitBreaker.cs b/src/StackExchange.Redis/Availability/CircuitBreaker.cs index e04c6a9468..a66622640b 100644 --- a/src/StackExchange.Redis/Availability/CircuitBreaker.cs +++ b/src/StackExchange.Redis/Availability/CircuitBreaker.cs @@ -187,7 +187,7 @@ public override void ObserveResult(in FaultContext fault) { } public override void Reset() { } } - // note we leave IsConnectionFault alone - that would impact RetryDatabase, where this is the key + // note we leave IsConnectionFault alone - that would impact RespRetryExecutor, where this is the key } private sealed class DefaultCircuitBreaker : CircuitBreaker { diff --git a/src/StackExchange.Redis/Availability/DatabaseExtensions.cs b/src/StackExchange.Redis/Availability/DatabaseExtensions.cs index 13c1926046..ce02d487f0 100644 --- a/src/StackExchange.Redis/Availability/DatabaseExtensions.cs +++ b/src/StackExchange.Redis/Availability/DatabaseExtensions.cs @@ -1,5 +1,6 @@ using System.Diagnostics.CodeAnalysis; using RESPite; +using StackExchange.Redis.Interfaces; namespace StackExchange.Redis.Availability; @@ -18,8 +19,8 @@ public static class DatabaseExtensions /// SE.Redis concepts, so can respond to server failover events, apply circuit-breaker rules, and /// respect command effect categorization. /// - /// The database to wrap; this must not be a batch, a transaction, an - /// already-retrying database, or a database carrying an asyncState (see remarks). + /// The database to make retrying; this must not be a batch, a transaction, or + /// an already-retrying database. /// /// The policy to apply; when (the default), the policy configured for the /// underlying connection is used - for a connection group, @@ -27,18 +28,40 @@ public static class DatabaseExtensions /// . /// /// - /// asyncState is not supported. A database's asyncState is stamped onto the task - /// produced by a single dispatch, but a retrying database hands back its own task spanning however - /// many attempts the operation takes; the same is true of the per-operation tasks handed out by - /// on such a database. Rather than dropping - /// the state silently, both refuse it: wrapping a database obtained via - /// GetDatabase(db, asyncState) throws, as does supplying an asyncState when creating a - /// transaction from a retrying database. + /// + /// Retry is a link in the dispatch chain, not a wrapper on the database. This re-dispatches + /// through the same executor decorator as : + /// what is replayed is the rendered command, so everything the database carries - the key prefix, the + /// database index, an asyncState, the multi-group failover source - travels unchanged. It used + /// to build a capture-and-replay wrapper, which replayed method calls and therefore had to + /// refuse an asyncState it could not stamp; the re-dispatched form has no such limit. + /// + /// + /// A database this cannot see inside is handed back unchanged. An external + /// implementation exposes no executor to decorate, and there is nothing + /// to capture any more - so rather than failing, such a database is returned as it came, without + /// retry. + /// /// /// If is a batch, a - /// transaction, already retrying, or carries an asyncState. + /// transaction, or already retrying. public static IDatabaseAsync WithRetry(this IDatabaseAsync database, RetryPolicy? retryPolicy = null) - => new RetryDatabase(database, retryPolicy ?? ResolveRetryPolicy(database.Multiplexer)); + { + if (database is null) throw new System.ArgumentNullException(nameof(database)); + + if (database.Context is not { Raw: { Executor: not null } raw }) + { + // nothing to decorate: an external implementation, or a context with no executor; see remarks + return database; + } + + // a batch or a transaction queues rather than dispatches, so there is nothing to retry yet; the + // context overload below refuses nesting, which is the third historical rejection + database.RejectFlags(DatabaseFeatureFlags.Batch | DatabaseFeatureFlags.Transaction); + + var context = new RespDatabaseContext(raw).WithRetry(retryPolicy); + return new RedisDatabase(context, database.Multiplexer, database.GetAsyncState()); + } /// /// A context whose commands are retried when a transient fault says they can be. @@ -75,18 +98,16 @@ public static RespDatabaseContext WithRetry(this RespDatabaseContext context, Re var inner = raw.Executor ?? throw new System.InvalidOperationException( "This context has no executor, so there is nothing to retry through."); - // cannot nest retry, as RetryDatabase.Validate refuses to wrap a retrying database: two loops - // would multiply the attempt counts rather than sharing them + // cannot nest retry: two loops would multiply the attempt counts rather than sharing them if (inner is RespRetryExecutor) { throw new System.InvalidOperationException( "This context is already retrying; a second policy would multiply the attempts rather than replace them."); } - // the failover source comes from the executor chain rather than from an IDatabaseAsync, which is - // what lets a retrying CONTEXT track failover at all: RetryDatabase could always hand its own - // GetNextFailover down, but a context built with WithRetry had nowhere to get one and so silently - // ran with the failover rungs unreachable. Fetched per use, never captured - see GetFailoverSource. + // the failover source comes from the executor chain rather than from an IDatabaseAsync: a + // multi-group chain offers one through GetFailoverSource, and anything else honestly has none. + // Fetched per use, never captured - see GetFailoverSource. return new RespDatabaseContext( raw.WithExecutor(new RespRetryExecutor(inner, retryPolicy ?? ResolveRetryPolicy(raw.Multiplexer), inner.GetFailoverSource()))); } diff --git a/src/StackExchange.Redis/Availability/MultiGroupDatabase.Scans.cs b/src/StackExchange.Redis/Availability/MultiGroupDatabase.Scans.cs index e9fbe96df5..b3a2b8cb32 100644 --- a/src/StackExchange.Redis/Availability/MultiGroupDatabase.Scans.cs +++ b/src/StackExchange.Redis/Availability/MultiGroupDatabase.Scans.cs @@ -1,47 +1,50 @@ -using System.Collections.Generic; +using System.Collections.Generic; namespace StackExchange.Redis.Availability; -// Streaming cursor scans (IEnumerable / IAsyncEnumerable) are deferred-execution and don't fit the -// capture-and-replay shape, so [AutoDatabase] skips them; they forward straight to the active member. +// The cursor scans PIN to the member that is active when the scan starts, by forwarding to its own +// database: a cursor is only meaningful to the server that issued it, so letting the base implementation +// page through the group executor would hand member A's cursor to member B after a failover - a silently +// wrong enumeration rather than a failed one. Pinned, a failover mid-scan faults the scan, which is the +// honest outcome. internal sealed partial class MultiGroupDatabase { - public IEnumerable HashScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) + public override IEnumerable HashScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) => GetActiveDatabase().HashScan(key, pattern, pageSize, flags); - public IEnumerable HashScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public override IEnumerable HashScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => GetActiveDatabase().HashScan(key, pattern, pageSize, cursor, pageOffset, flags); - public IEnumerable HashScanNoValues(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public override IEnumerable HashScanNoValues(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => GetActiveDatabase().HashScanNoValues(key, pattern, pageSize, cursor, pageOffset, flags); - public IEnumerable SetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) + public override IEnumerable SetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) => GetActiveDatabase().SetScan(key, pattern, pageSize, flags); - public IEnumerable SetScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public override IEnumerable SetScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => GetActiveDatabase().SetScan(key, pattern, pageSize, cursor, pageOffset, flags); - public IEnumerable SortedSetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) + public override IEnumerable SortedSetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) => GetActiveDatabase().SortedSetScan(key, pattern, pageSize, flags); - public IEnumerable SortedSetScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public override IEnumerable SortedSetScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => GetActiveDatabase().SortedSetScan(key, pattern, pageSize, cursor, pageOffset, flags); - public IEnumerable VectorSetRangeEnumerate(RedisKey key, RedisValue start = default, RedisValue end = default, long count = 100, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) + public override IEnumerable VectorSetRangeEnumerate(RedisKey key, RedisValue start = default, RedisValue end = default, long count = 100, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => GetActiveDatabase().VectorSetRangeEnumerate(key, start, end, count, exclude, flags); - public IAsyncEnumerable HashScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public override IAsyncEnumerable HashScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => GetActiveDatabase().HashScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); - public IAsyncEnumerable HashScanNoValuesAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public override IAsyncEnumerable HashScanNoValuesAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => GetActiveDatabase().HashScanNoValuesAsync(key, pattern, pageSize, cursor, pageOffset, flags); - public IAsyncEnumerable SetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public override IAsyncEnumerable SetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => GetActiveDatabase().SetScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); - public IAsyncEnumerable SortedSetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public override IAsyncEnumerable SortedSetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => GetActiveDatabase().SortedSetScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); - public IAsyncEnumerable VectorSetRangeEnumerateAsync(RedisKey key, RedisValue start = default, RedisValue end = default, long count = 100, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) + public override IAsyncEnumerable VectorSetRangeEnumerateAsync(RedisKey key, RedisValue start = default, RedisValue end = default, long count = 100, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => GetActiveDatabase().VectorSetRangeEnumerateAsync(key, start, end, count, exclude, flags); } diff --git a/src/StackExchange.Redis/Availability/MultiGroupDatabase.cs b/src/StackExchange.Redis/Availability/MultiGroupDatabase.cs index 0d8b6e0693..3f7557dd03 100644 --- a/src/StackExchange.Redis/Availability/MultiGroupDatabase.cs +++ b/src/StackExchange.Redis/Availability/MultiGroupDatabase.cs @@ -1,98 +1,96 @@ -using System; -using System.Threading; -using System.Threading.Tasks; -using StackExchange.Redis.Interfaces; +using StackExchange.Redis.Interfaces; namespace StackExchange.Redis.Availability; -// The bulk of IDatabase/IDatabaseAsync is generated by [AutoDatabase]: every command is captured into a -// state struct and replayed against the currently-active member via the Execute/ExecuteAsync funnels below -// (so a call always lands on whichever member is active *now*). Only the members the generator deliberately -// skips - the Wait family, IsConnected, the batch/transaction factories, and the streaming scans (see -// MultiGroupDatabase.Scans.cs) - plus the properties and internal plumbing are hand-written here. -[AutoDatabase] -internal sealed partial class MultiGroupDatabase(MultiGroupMultiplexer parent, int database, object? asyncState) - : IDatabase, IInternalDatabaseAsync +/// +/// The group's database: the ordinary funnel over a context whose executor +/// () resolves the currently-active member per send. +/// +/// +/// +/// This used to be 628 generated capture-and-replay members. Every one of them existed to capture a +/// command's arguments, resolve the active member, and replay the call against it - because the decoration +/// happened above the command surface. With the decoration an executor below it, those members have +/// nothing left to do, and what remains here is only what the base funnel cannot know: the group's feature +/// flags and diagnostic name, and the cursor scans, which must pin to one member (see +/// MultiGroupDatabase.Scans.cs). +/// +/// +/// Note what is not here: nothing about connecting, reconnecting, backlogs, slots or routing. +/// The active member is an entire multiplexer with its own executor chain, and the group executor hands +/// the command to it. That is the whole of a group's job, and the reason this is short. +/// +/// +/// The command map comes from configuration, not connection state - each member is configured +/// separately, and the group takes the map from its members' configuration - so the context answers while +/// every member is down. The database index is configuration too: a defaulted index resolves to the +/// members' shared DefaultDatabase, which ValidateConsistentConfiguration demands they agree +/// on - so the context is fully determined, buildable and cacheable with nothing reachable at all. +/// +/// +/// The cache is the active member's, resolved per command. Not a shared group cache: a cached +/// reply is only sound while the connection that produced it is the one being asked and its +/// CLIENT TRACKING registration is still live, so serving member A's values while B is active +/// would be wrong - and silently so. Per-member caches make a switch a no-op for correctness, and the +/// existing "flush when tracking drops" rule already covers the case that actually matters, since a +/// failover usually happens BECAUSE the old member's connection died. A switch away from a healthy +/// member leaves its cache warm for switching back, which nuking a shared cache would throw away. +/// +/// +/// Knowing the replication topology would not change this. The rule is not "the data might +/// differ" - that is incidental - but that a cache entry carries an implicit subscription, and +/// subscriptions do not transfer. CLIENT TRACKING is registered per connection, so +/// inheriting A's entries while talking to B inherits no registration on B: those entries become +/// unfalsifiable rather than merely possibly-stale, even if B's data is byte-identical. Active-active +/// and geo-replication change the invalidation latency (bounded by replication lag rather than +/// a round trip), which bounds a safe maximum age - not what happens on a switch. +/// +/// +/// Our own writes are the exception, and travel to every member's cache +/// (): a write made while B is active reaches A's server only by +/// replication, so without that, failing back could hand a caller the value they replaced. An inactive +/// member's tracking connection is kept honest the same way an active one is: group members always run +/// heartbeat consistency checks, so every endpoint is pinged each heartbeat, a half-open connection trips +/// the dead-socket rule, and the failure flushes that member's cache. +/// +/// +internal sealed partial class MultiGroupDatabase : RedisDatabase { - /// - public RespDatabaseContext Context => new(GetContext()); - - private RespContext? _context; - - /// The context surface over whichever member is currently active. - /// - /// - /// This used to throw. What it needed was an executor that resolves the active member per - /// send rather than at construction - which is what is - because the - /// context is built once and memoised, while the active member is the thing a group exists to change. - /// - /// - /// Note what is not here: nothing about connecting, reconnecting, backlogs, slots or routing. - /// The active member is an entire multiplexer with its own executor chain, and this hands the command - /// to it. That is the whole of a group's job, and the reason this is short. - /// - /// - /// The command map comes from configuration, not connection state - each member is configured - /// separately, and the group takes the map from its members' configuration - so it answers while - /// every member is down. The one thing that may not is the database INDEX: -1 means "whatever - /// the active member defaults to", which needs a member. An explicit index does not, and that context - /// is buildable and cacheable with nothing reachable at all. - /// - /// - /// The cache is the active member's, resolved per command. Not a shared group cache: a cached - /// reply is only sound while the connection that produced it is the one being asked and its - /// CLIENT TRACKING registration is still live, so serving member A's values while B is active - /// would be wrong - and silently so. Per-member caches make a switch a no-op for correctness, and the - /// existing "flush when tracking drops" rule already covers the case that actually matters, since a - /// failover usually happens BECAUSE the old member's connection died. A switch away from a healthy - /// member leaves its cache warm for switching back, which nuking a shared cache would throw away. - /// - /// - /// Knowing the replication topology would not change this. The rule is not "the data might - /// differ" - that is incidental - but that a cache entry carries an implicit subscription, and - /// subscriptions do not transfer. CLIENT TRACKING is registered per connection, so - /// inheriting A's entries while talking to B inherits no registration on B: those entries become - /// unfalsifiable rather than merely possibly-stale, even if B's data is byte-identical. Active-active - /// and geo-replication change the invalidation latency (bounded by replication lag rather than - /// a round trip), which bounds a safe maximum age - not what happens on a switch. - /// - /// - /// Our own writes are the exception, and travel to every member's cache - /// (): a write made while B is active reaches A's server only by - /// replication, so without that, failing back could hand a caller the value they replaced. An inactive - /// member's tracking connection is kept honest the same way an active one is: group members always run - /// heartbeat consistency checks, so every endpoint is pinged each heartbeat, a half-open connection trips - /// the dead-socket rule, and the failure flushes that member's cache. - /// - /// - /// Where the 628 generated forwarding members eventually go. Every one of them exists to - /// capture a command's arguments, resolve the active member, and replay the call against it - because - /// the decoration happens above the command surface. Once the decoration is an executor below it, - /// those members have nothing left to do, and this property is the seam through which they leave. - /// - /// - private RespContext GetContext() + private readonly MultiGroupMultiplexer _parent; + private readonly int _database; + private readonly object? _asyncState; + + /// Create the group's database over a group-executor context. + /// The group this database belongs to. + /// The database index; already resolved, never negative (see + /// MultiGroupMultiplexer.GetDatabase). + /// The async-state stamped onto the tasks this database hands out. + internal MultiGroupDatabase(MultiGroupMultiplexer parent, int database, object? asyncState) + : base(BuildContext(parent, database), parent, asyncState) { - if (_context is { } existing) return existing; + _parent = parent; + _database = database; + _asyncState = asyncState; + } - // `database` is the constructor's, not the Database PROPERTY: the property resolves -1 by asking - // the active member what it defaults to, and therefore throws when the group is down. An explicit - // index needs no member, so that context is fully determined and can be built and memoised while - // nothing is reachable; a defaulted one genuinely cannot be known yet, and throwing there is what - // the Database property already does. - var resolved = database >= 0 ? database : Database; - return _context = new RespContext( + /// The context over whichever member is currently active. + private static RespDatabaseContext BuildContext(MultiGroupMultiplexer parent, int database) => new( + new RespContext( parent.CommandMap, - database: resolved, + database: database, serverType: ServerType.Standalone) - .WithExecutor(new RespGroupExecutor(() => ActiveExecutor, resolved, DescribeUnavailable, parent.GetNextFailover) { Group = parent }) - .WithCacheResolver(() => parent.TryGetActive()?.ClientCache); - } - - private RespExecutorBase? ActiveExecutor - => TryGetActiveDatabase() is IRespTarget target ? target.Context.Executor : null; - - private string DescribeUnavailable() + .WithExecutor(new RespGroupExecutor( + () => ActiveExecutor(parent, database), + database, + () => DescribeUnavailable(parent), + parent.GetNextFailover) + { Group = parent }) + .WithCacheResolver(() => parent.TryGetActive()?.ClientCache)); + + private static RespExecutorBase? ActiveExecutor(MultiGroupMultiplexer parent, int database) + => parent.TryGetActive()?.GetDatabase(database) is IRespTarget target ? target.Context.Executor : null; + + private static string DescribeUnavailable(MultiGroupMultiplexer parent) { // the group's own wording rather than a second copy of it: this asks the same question the facade // asks and reports the answer, so the two cannot drift apart @@ -108,81 +106,22 @@ private string DescribeUnavailable() } /// - RespContext IRespTarget.Context => GetContext(); - - public object? AsyncState => asyncState; - public int Database => database < 0 ? GetActiveDatabase().Database : database; - - public IConnectionMultiplexer Multiplexer => parent; - - CancellationToken IInternalDatabaseAsync.GetNextFailover() => parent.GetNextFailover(); - - DatabaseFeatureFlags IInternalDatabaseAsync.GetFeatures(out string name) + /// Folds in the currently-active member's features (when there is one) and labels with its name. + private protected override DatabaseFeatureFlags GetFeaturesCore(out string name) { - // fold in the currently-active member's features (when there is one) and label with its name var active = TryGetActiveDatabase(); var features = active is null ? DatabaseFeatureFlags.None : active.GetFeatures(out _); - name = ((IConnectionGroup)parent).ActiveMember?.Name ?? ""; + name = ((IConnectionGroup)_parent).ActiveMember?.Name ?? ""; return features | DatabaseFeatureFlags.ConnectionGroup | DatabaseFeatureFlags.Failover; } - // uses the active member's name (via GetFeatures) when a member is active + // uses the active member's name (via GetFeaturesCore) when a member is active public override string ToString() => this.BuildString(); // for high DB numbers this might allocate even for null async-state scenarios; unavoidable for now - private IDatabase GetActiveDatabase() => parent.Active.GetDatabase(database, asyncState); + private IDatabase GetActiveDatabase() => _parent.Active.GetDatabase(_database, _asyncState); // non-throwing twin of GetActiveDatabase: returns null when the group currently has no active // member, for use by members that have an obvious trivial result when disconnected - private IDatabase? TryGetActiveDatabase() => parent.TryGetActive()?.GetDatabase(database, asyncState); - - // ---- [AutoDatabase] funnels --------------------------------------------------------------------- - // the generated explicit interface implementations funnel every captured call through these: we simply - // forward to the currently-active member. Unlike RetryDatabase there is no key mapping to apply (we are - // not rewriting keys), so the captured state's Map/UnMapper is never invoked. - private TResult Execute(in TState state, AutoDatabaseSyncOperation operation) - where TState : struct - => operation(in state, GetActiveDatabase()); - - private void Execute(in TState state, AutoDatabaseSyncOperation operation) - where TState : struct - => operation(in state, GetActiveDatabase()); - - private Task ExecuteAsync(in TState state, AutoDatabaseAsyncOperation operation) - where TState : struct - => operation(in state, GetActiveDatabase()); - - private Task ExecuteAsync(in TState state, AutoDatabaseAsyncOperation operation) - where TState : struct - => operation(in state, GetActiveDatabase()); - - // ---- members the generator deliberately skips (see AutoDatabaseGenerator.SkipMethod) ------------- - public IBatch CreateBatch(object? asyncState = null) - => GetActiveDatabase().CreateBatch(asyncState); - - public ITransaction CreateTransaction(object? asyncState = null) - => GetActiveDatabase().CreateTransaction(asyncState); - - ITransactionAsync IDatabaseAsync.CreateTransaction(object? asyncState) => CreateTransaction(asyncState); - - // status probe, not a server round-trip: trivially "not connected" when there is no active member - public bool IsConnected(RedisKey key, CommandFlags flags = CommandFlags.None) - => TryGetActiveDatabase()?.IsConnected(key, flags) ?? false; - - // routing lookup against the currently-active member; null / NoEndpoint when the group has none - public System.Net.EndPoint? IdentifyEndpoint(RedisKey key = default, CommandFlags flags = CommandFlags.None) - => TryGetActiveDatabase()?.IdentifyEndpoint(key, flags); - - public Task IdentifyEndpointAsync(RedisKey key = default, CommandFlags flags = CommandFlags.None) - => TryGetActiveDatabase()?.IdentifyEndpointAsync(key, flags) ?? MultiGroupMultiplexer.NoEndpoint; - - // the Wait family operates on caller-supplied Tasks, not server calls - // forwarding is not using: these decorators must implement the interface in full, and the - // implementation cannot be dropped while the interface declares it - #pragma warning disable SER308 // Blocking on a task through the library's Wait helpers - public bool TryWait(Task task) => GetActiveDatabase().TryWait(task); - public void Wait(Task task) => GetActiveDatabase().Wait(task); - public T Wait(Task task) => GetActiveDatabase().Wait(task); - public void WaitAll(params Task[] tasks) => GetActiveDatabase().WaitAll(tasks); - #pragma warning restore SER308 + private IDatabase? TryGetActiveDatabase() => _parent.TryGetActive()?.GetDatabase(_database, _asyncState); } diff --git a/src/StackExchange.Redis/Availability/MultiGroupMultiplexer.cs b/src/StackExchange.Redis/Availability/MultiGroupMultiplexer.cs index eb65816b91..b081490c77 100644 --- a/src/StackExchange.Redis/Availability/MultiGroupMultiplexer.cs +++ b/src/StackExchange.Redis/Availability/MultiGroupMultiplexer.cs @@ -1379,7 +1379,14 @@ public ISubscriber GetSubscriber(object? asyncState = null) public IDatabase GetDatabase(int db = -1, object? asyncState = null) { - if ((asyncState is null) & (db >= -1) & (db <= ConnectionMultiplexer.MaxCachedDatabaseInstance)) + if (db < -1) throw new ArgumentOutOfRangeException(nameof(db)); + + // a defaulted index is configuration, not connection state: every member must agree about + // DefaultDatabase (ValidateConsistentConfiguration refuses a group that disagrees), so the + // group's default is member 0's and needs no member to be reachable + if (db < 0) db = DefaultDatabase; + + if ((asyncState is null) & (db <= ConnectionMultiplexer.MaxCachedDatabaseInstance)) { return _databases[db + 1] ??= new MultiGroupDatabase(this, db, null); } @@ -1387,6 +1394,16 @@ public IDatabase GetDatabase(int db = -1, object? asyncState = null) return new MultiGroupDatabase(this, db, asyncState); } + /// The database a defaulted index resolves to; configuration, shared by every member. + internal int DefaultDatabase + { + get + { + var members = _members; + return (members.Length == 0 ? null : members[0].Configuration.DefaultDatabase) ?? 0; + } + } + private readonly IDatabase?[] _databases = new IDatabase?[ConnectionMultiplexer.MaxCachedDatabaseInstance + 2]; diff --git a/src/StackExchange.Redis/Availability/RespRetryExecutor.cs b/src/StackExchange.Redis/Availability/RespRetryExecutor.cs index d72ea1a63b..2cd23b1ff5 100644 --- a/src/StackExchange.Redis/Availability/RespRetryExecutor.cs +++ b/src/StackExchange.Redis/Availability/RespRetryExecutor.cs @@ -12,13 +12,13 @@ namespace StackExchange.Redis.Availability; /// /// /// -/// The same policy as , and a fraction of the code. That one has to -/// capture every argument of every command into a generated state struct so it can replay the call, own -/// pooled copies of any Memory<T> arguments for as long as the replaying lasts, and dispose -/// the capture when the last attempt is done - because what it is replaying is a method call. Here -/// the thing being replayed is a rendered frame that already exists, so there is nothing to capture, -/// nothing to own and nothing to map: the loop is the whole of it. Both call the same -/// , so the two paths cannot disagree about policy. +/// A rendered frame is the thing replayed, which is why this is small. The capture-and-replay +/// wrapper this replaced had to capture every argument of every command into a generated state struct so +/// it could replay the call, own pooled copies of any Memory<T> arguments for as long as the +/// replaying lasted, and dispose the capture when the last attempt was done - because what it replayed +/// was a method call. Here the frame already exists, so there is nothing to capture, nothing to +/// own and nothing to map: the loop is the whole of it, and makes every +/// policy decision. /// /// /// Synchronous too. A synchronous send - which is what a context @@ -29,11 +29,11 @@ namespace StackExchange.Redis.Availability; /// context the one kind that could not serve a library's synchronous methods. /// /// -/// Failover is not wired up yet. takes its next-failover token from -/// IDatabaseAsync.GetNextFailover(); an executor has no equivalent, so this takes an optional -/// source and is built without when there is none - which -/// makes false and the failover rungs unreachable, rather -/// than silently pretending a failover could happen. +/// Failover comes from the executor chain. The source is optional, and this is built without +/// when there is none - which makes +/// false and the failover rungs unreachable, rather than +/// silently pretending a failover could happen. A multi-group chain supplies one +/// (RespGroupExecutor.GetFailoverSource); a single connection has nothing to fail over to. /// /// internal sealed class RespRetryExecutor : RespExecutorBase @@ -43,32 +43,21 @@ internal sealed class RespRetryExecutor : RespExecutorBase private readonly Func? _failoverSource; internal RespRetryExecutor(RespExecutorBase inner, RetryPolicy policy, Func? failoverSource = null) - : this( - inner, - new RetryController( - policy ?? throw new ArgumentNullException(nameof(policy)), - failoverSource is null ? DatabaseFeatureFlags.None : DatabaseFeatureFlags.Failover), - failoverSource) - { - } - - /// Share an existing controller, rather than deriving a second one from the same policy. - /// - /// For , whose context is this executor over the inner one: sharing the - /// controller means the database path and the context path are not merely configured alike, they are - /// configured by the same object - including the failover feature flag, which a policy alone does not - /// carry. - /// - internal RespRetryExecutor(RespExecutorBase inner, RetryController controller, Func? failoverSource) { _inner = inner ?? throw new ArgumentNullException(nameof(inner)); - _controller = controller ?? throw new ArgumentNullException(nameof(controller)); + _controller = new RetryController( + policy ?? throw new ArgumentNullException(nameof(policy)), + failoverSource is null ? DatabaseFeatureFlags.None : DatabaseFeatureFlags.Failover); _failoverSource = failoverSource; } /// The policy in force; read by the tests, which assert how a policy was resolved. internal RetryPolicy Policy => _controller.Policy; + /// The controller, shared with so a transaction created from a + /// retrying database applies exactly the policy the database does. + internal RetryController Controller => _controller; + /// The executor underneath, so a second WithRetry can refuse rather than nest. internal RespExecutorBase Inner => _inner; @@ -208,7 +197,7 @@ internal override RespPayload Send(RespRequest preamble, RespRequest request, IR } } - /// The retry loop, borrowed whole from . + /// The retry loop. /// /// /// Every decision is the controller's: whether the fault is transient, whether attempts remain, @@ -216,9 +205,9 @@ internal override RespPayload Send(RespRequest preamble, RespRequest request, IR /// shape of the loop. /// /// - /// The failover token is captured before the first attempt is awaited, as it is there and for - /// the same reason: taken afterwards, a failover happening between the failure and the fetch would be - /// missed, and the retry would wait for one that had already been and gone. + /// The failover token is captured before the first attempt is awaited: taken afterwards, a + /// failover happening between the failure and the fetch would be missed, and the retry would wait + /// for one that had already been and gone. /// /// private async ValueTask Awaited(ValueTask pending, RespRequest request, CancellationToken cancellationToken) diff --git a/src/StackExchange.Redis/Availability/RetryController.cs b/src/StackExchange.Redis/Availability/RetryController.cs index 97fe6eae28..e115c88e29 100644 --- a/src/StackExchange.Redis/Availability/RetryController.cs +++ b/src/StackExchange.Redis/Availability/RetryController.cs @@ -8,8 +8,8 @@ namespace StackExchange.Redis.Availability; /// /// Holds the retry configuration derived from a (attempt counts, delays, -/// failover gating) and makes the per-attempt retry decision. This is shared by -/// and so the two paths apply identical policy math. +/// failover gating) and makes the per-attempt retry decision, so that +/// is only the shape of the loop. /// internal sealed class RetryController { diff --git a/src/StackExchange.Redis/Availability/RetryDatabase.cs b/src/StackExchange.Redis/Availability/RetryDatabase.cs deleted file mode 100644 index 7aa5fd93ee..0000000000 --- a/src/StackExchange.Redis/Availability/RetryDatabase.cs +++ /dev/null @@ -1,222 +0,0 @@ -using System; -using System.Threading; -using System.Threading.Tasks; -using StackExchange.Redis.Interfaces; - -namespace StackExchange.Redis.Availability; - -[AutoDatabase(Replays = true)] -internal partial class RetryDatabase : IDatabaseAsync, IInternalDatabaseAsync - // IRedisArgsMutator <==== if we ever want to support key-mapping -{ - /// - public RespDatabaseContext Context => new(GetContextCore()); - // Note: we very deliberately do not include synchronous support for retry; it is inherently delay-ish - - // which the context surface inherits: RespRetryExecutor.Send throws rather than quietly not retrying. - - // Note that only transient faults result in retries; this is defined by the RetryPolicy, along with - // understanding the category. The default RetryPolicy works the same as the default CircuitBreaker. - DatabaseFeatureFlags IInternalDatabaseAsync.GetFeatures(out string name) - => _inner.GetFeatures(out name) | DatabaseFeatureFlags.Retry; - - // never: we refuse to wrap a database that carries one (see Validate) - object? IInternalDatabaseAsync.AsyncState => null; - - /// The inner context, with this database's retry decorating its executor. - /// - /// - /// Not the inner context as it stands. Handing that back would compile, read naturally and be - /// wrong: commands composed from it go through the inner executor, so every call through the - /// group surface would quietly lose the retry this wrapper exists to provide - invisibly, because the - /// command still succeeds whenever nothing fails. It threw for exactly that reason until the retry - /// executor existed. - /// - /// - /// The controller is shared rather than rebuilt. The two paths are then not merely configured - /// alike but configured by the same object, including the failover feature flag - which a - /// alone does not carry, because whether failover is available is a fact - /// about the inner database. is handed over for the same reason. - /// - /// - internal RespContext GetContextCore() - => _inner.Raw.WithExecutor( - new RespRetryExecutor(_inner.Raw.Executor ?? ThrowNoExecutor(), _controller, GetNextFailover)); - - private static RespExecutorBase ThrowNoExecutor() => throw new InvalidOperationException( - "The inner database's context has no executor, so there is nothing to retry through."); - - /// - RespContext IRespTarget.Context => GetContextCore(); - - /// - public override string ToString() => this.BuildString(); - - private readonly IDatabaseAsync _inner; - private readonly RetryController _controller; - - internal RetryPolicy Policy => _controller.Policy; - - public CancellationToken GetNextFailover() - => _controller.TracksFailover ? _inner.GetNextFailover() : CancellationToken.None; - - public RetryDatabase(IDatabaseAsync inner, RetryPolicy policy) - : this(inner, policy, Validate(inner)) - { - } - - private static DatabaseFeatureFlags Validate(IDatabaseAsync inner) - { - // cannot nest retry, and cannot issue retries *inside* a batch/transaction - var features = inner.RejectFlags(DatabaseFeatureFlags.Batch | DatabaseFeatureFlags.Transaction | DatabaseFeatureFlags.Retry); - - // async-state is stamped onto the task that a *single* attempt produces; a retrying database hands - // back its own durable task that spans however many attempts it takes, so it cannot preserve the - // state. Refuse rather than dropping it silently. See also CreateTransaction, below. - if (inner.GetAsyncState() is not null) ThrowAsyncState(); - return features; - } - - internal static void ThrowAsyncState() => throw new InvalidOperationException( - "Retrying databases do not support asyncState; the tasks they hand back are not the tasks that were sent to the server."); - - // test-only: supply the inner database's feature set directly (in particular whether failover is - // available), instead of probing a live inner - so that failover behaviour can be exercised over a - // null inner without a full IDatabaseAsync double. - internal RetryDatabase(IDatabaseAsync inner, RetryPolicy policy, DatabaseFeatureFlags features) - { - _controller = new RetryController(policy, features); - _inner = inner; - } - - ITransactionAsync IDatabaseAsync.CreateTransaction(object? asyncState) - { - // as per the constructor: the per-operation tasks handed out at build time are durable proxies - // that outlive any single attempt, so they cannot carry a per-attempt async-state - if (asyncState is not null) ThrowAsyncState(); - - // the inner database creates the "real" (one-shot) transactions we replay against each attempt - return new RetryTransaction(_inner, _controller); - } - - public int Database => _inner.Database; - - public IConnectionMultiplexer Multiplexer => _inner.Multiplexer; - - // the generated explicit interface implementations funnel every call through these two - // overloads: the arguments are captured in a generated state struct and replayed against - // the inner database via a cacheable static projection (no per-call closure). Retry/failover - // policy will live here in due course; for now it is a straight pass-through. - - // async counterparts (Task / Task); these get their own retry/failover policy in due course. - // note: the state cannot be taken by `in` here (async methods forbid by-ref parameters); - // only the projection takes it by readonly-ref, avoiding a copy per attempt - private async Task ExecuteAsync(TState state, AutoDatabaseAsyncOperation operation) - where TState : struct, IDisposable - { - /* key mapping, not used currently - * state.MapInPlace(this); */ - - // the capture owns a pooled copy of any Memory arguments it holds: the caller's own buffer is - // theirs again once the call returns, and we may still be replaying long after that. Disposed here - // rather than by the capture's creator, because this is the only point that knows the last attempt - // is done. The IDisposable constraint makes that call constrained rather than boxed. - try - { - int attempt = 0; - TResult result; - // note we need to capture this *before* the attempt - otherwise the failover could happen - // between the failed attempt and fetching this, and we'd miss it - CancellationToken failover = GetNextFailover(); - while (true) - { - try - { - result = await operation(in state, _inner).ConfigureAwait(false); - break; - } - catch (Exception ex) when (_controller.CanRetry(++attempt, ex, ref failover, out var delay)) - { - await _controller.FailoverOrDelayAsync(delay).ConfigureAwait(false); - } - } - - /* key mapping, not used currently - // post-process results outside the loop - return this.UnMap(state, result);*/ - return result; - } - finally - { - state.Dispose(); - } - } - - private async Task ExecuteAsync(TState state, AutoDatabaseAsyncOperation operation) - where TState : struct, IDisposable - { - /* key mapping, not used currently - * state.MapInPlace(this); */ - - // see the TResult overload - try - { - int attempt = 0; - // note we need to capture this *before* the attempt - otherwise the failover could happen - // between the failed attempt and fetching this, and we'd miss it - CancellationToken failover = GetNextFailover(); - while (true) - { - try - { - await operation(in state, _inner).ConfigureAwait(false); - break; - } - catch (Exception ex) when (_controller.CanRetry(++attempt, ex, ref failover, out var delay)) - { - await _controller.FailoverOrDelayAsync(delay).ConfigureAwait(false); - } - } - - // (nothing to post-process) - } - finally - { - state.Dispose(); - } - } - - // forwarding is not using: these decorators must implement the interface in full, and the - // implementation cannot be dropped while the interface declares it - #pragma warning disable SER308 // Blocking on a task through the library's Wait helpers - void IRedisAsync.Wait(Task task) => _inner.Wait(task); - T IRedisAsync.Wait(Task task) => _inner.Wait(task); - void IRedisAsync.WaitAll(Task[] tasks) => _inner.WaitAll(tasks); - bool IRedisAsync.TryWait(Task task) => _inner.TryWait(task); - #pragma warning restore SER308 - - // Methods the generator deliberately skips (see AutoDatabaseGenerator.SkipMethod): the Wait - // family, the synchronous IsConnected probe, and the streaming IEnumerable/IAsyncEnumerable scans - // don't fit the capture-and-replay shape, so they are implemented by hand. - // IsConnected is a straight pass-through: it is a cheap status check, not a server round-trip to retry. - bool IDatabaseAsync.IsConnected(RedisKey key, CommandFlags flags) => _inner.IsConnected(key, flags); - - // routing lookup, not a replayable server command - forward straight through (no retry) - Task IDatabaseAsync.IdentifyEndpointAsync(RedisKey key, CommandFlags flags) => _inner.IdentifyEndpointAsync(key, flags); - - // Scans are streaming/cursored, so they can't be captured-and-replayed as a single unit; rather than - // failing outright we forward straight to the inner database - giving up retry, but keeping the scan working. - System.Collections.Generic.IAsyncEnumerable IDatabaseAsync.HashScanAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => _inner.HashScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); - System.Collections.Generic.IAsyncEnumerable IDatabaseAsync.HashScanNoValuesAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => _inner.HashScanNoValuesAsync(key, pattern, pageSize, cursor, pageOffset, flags); - System.Collections.Generic.IAsyncEnumerable IDatabaseAsync.SetScanAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => _inner.SetScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); - System.Collections.Generic.IAsyncEnumerable IDatabaseAsync.VectorSetRangeEnumerateAsync(RedisKey key, RedisValue start, RedisValue end, long count, Exclude exclude, CommandFlags flags) => _inner.VectorSetRangeEnumerateAsync(key, start, end, count, exclude, flags); - System.Collections.Generic.IAsyncEnumerable IDatabaseAsync.SortedSetScanAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => _inner.SortedSetScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); - - /* optional: key mapping - RedisKey IRedisArgsMutator.Map(RedisKey key) => key; - - RedisChannel IRedisArgsMutator.Map(RedisChannel channel) => channel; - - RedisKey IRedisArgsMutator.UnMap(RedisKey key) => key; - RedisChannel IRedisArgsMutator.UnMap(RedisChannel channel) => channel; - */ -} diff --git a/src/StackExchange.Redis/Availability/RetryTransaction.cs b/src/StackExchange.Redis/Availability/RetryTransaction.cs index 513d4718b7..351bafb8e0 100644 --- a/src/StackExchange.Redis/Availability/RetryTransaction.cs +++ b/src/StackExchange.Redis/Availability/RetryTransaction.cs @@ -7,7 +7,7 @@ namespace StackExchange.Redis.Availability; -// A retryable transaction. Unlike RetryDatabase - which replays a single captured typed call each attempt - +// A retryable transaction. Unlike RespRetryExecutor - which replays a single rendered frame each attempt - // a transaction is built up across many builder calls plus an Execute, so we *record* each captured call // (the AutoDatabase (state, projection) pair) and hand the caller a durable, still-incomplete proxy task. // Only ExecuteAsync actually runs anything: for each attempt it spins up a fresh, one-shot inner transaction @@ -21,7 +21,7 @@ namespace StackExchange.Redis.Availability; // Execute is sync-over-async (see below). Note that ITransaction : IBatch : IDatabaseAsync, so the only // members this adds over ITransactionAsync are the two Execute overloads. // Replays: the recorded operations are re-run as a unit on every attempt, and a capture is held from the -// moment it is recorded until Execute - longer than RetryDatabase holds one - so the captured arguments must +// moment it is recorded until Execute - longer than a single dispatch holds one - so the captured arguments must // be copies of the caller's memory rather than the caller's own buffer. They are released in ExecuteAsync, // which is the only point that knows an operation will not be replayed again; a transaction that is never // executed keeps its captures, and nothing here could know otherwise. @@ -30,14 +30,14 @@ internal sealed partial class RetryTransaction : IDatabaseAsync, ITransaction { /// public RespDatabaseContext Context => new(GetContextCore()); - // Note: the *command* surface is async-only, exactly like RetryDatabase - retrying is inherently + // Note: the *command* surface is async-only - retrying is inherently // delay-ish; only the terminal Execute is offered synchronously. private readonly IDatabaseAsync _source; private readonly RetryController _controller; /// Refuse to build a context, saying why. /// - /// Still refused, where 's is not. A retrying database replays one + /// Still refused, where a retrying database's is not. A retrying database replays one /// operation, so decorating its executor gives the context surface exactly the same behaviour. A /// retrying transaction replays the whole recorded unit - conditions, queued operations and /// EXEC together - and a retry executor knows nothing of that: it would re-send individual @@ -185,7 +185,7 @@ private async Task ExecuteAsync(CommandFlags flags, List ops, int maxWatchAttempts = conditions is null ? 1 : _controller.MaxWatchConflictAttempts; while (true) { - // no async-state: RetryDatabase refuses one (the durable proxies below cannot carry it) + // no async-state: a retrying transaction refuses one (the durable proxies below cannot carry it) var inner = _source.CreateTransaction(); // replay the recorded constraints and operations onto this fresh, one-shot transaction; the diff --git a/src/StackExchange.Redis/Contexts/RespContext.cs b/src/StackExchange.Redis/Contexts/RespContext.cs index 635c5d171f..1d91a30342 100644 --- a/src/StackExchange.Redis/Contexts/RespContext.cs +++ b/src/StackExchange.Redis/Contexts/RespContext.cs @@ -352,15 +352,9 @@ internal bool TryGetFeatures(RedisCommand command, in RedisKey key, CommandFlags // the key prefix is part of the CONTEXT here, not of the key, and it is applied at write // time - so the key a caller hands us is not yet the key the server will see, and in a // cluster those bytes are what pick the node. Compose first, exactly as AppendFormatted - // will, or we would sample the version of a node that never sees this command. A null key - // means "routes to no particular key" and stays null: prefixing it would invent one. - if (_keyPrefix is { Length: > 0 } && !key.IsNull) - { - var prefixed = RedisKey.WithPrefix(_keyPrefix, key); - return probe.TryGetFeatures(command, in prefixed, flags, out features); - } - - return probe.TryGetFeatures(command, in key, flags, out features); + // will, or we would sample the version of a node that never sees this command. + var prefixed = PrefixKey(in key); + return probe.TryGetFeatures(command, in prefixed, flags, out features); } // no probe: a bare context, a test fake, a hand-wired executor. Nothing is known, and every @@ -384,6 +378,16 @@ internal bool TryGetFeatures(RedisCommand command, in RedisKey key, CommandFlags /// The key prefix as raw bytes, so the writer never pays a conversion per command. internal ReadOnlySpan KeyPrefixSpan => _keyPrefix; + /// The key as the server will see it: the context's prefix applied, exactly as render time will. + /// The key being asked about. + /// + /// For the ROUTING questions - features, connectivity, endpoint identity - which take the key out + /// of band rather than rendering it, and so would otherwise ask about a key the server never sees. + /// A null key means "routes to no particular key" and stays null: prefixing it would invent one. + /// + internal RedisKey PrefixKey(in RedisKey key) + => _keyPrefix is { Length: > 0 } && !key.IsNull ? RedisKey.WithPrefix(_keyPrefix, key) : key; + /// The prefix applied to channels written through this context. /// /// Held as a service rather than a field. As a field it was a - @@ -496,8 +500,8 @@ internal RespContext WithDatabase(int database) /// is true: With says the result differs in this respect, which invites "so the second call /// wins". It does not - AppendKeyPrefix("a").AppendKeyPrefix("b") sends key k as /// abk, and there is deliberately no way back to k. That matches nesting the - /// KeyPrefixed* decorators, and , - /// which folds the two prefixes and re-wraps the inner database. + /// old KeyPrefixed* decorators, and is how + /// composes when called twice. /// /// /// A null or empty prefix appends nothing, rather than resetting. The shipped @@ -507,14 +511,28 @@ internal RespContext WithDatabase(int database) /// /// internal RespContext AppendKeyPrefix(RedisKey keyPrefix) - => new( + => new RespContext( CommandMap, _keyPrefix is null ? keyPrefix : RedisKey.WithPrefix(_keyPrefix, keyPrefix), default, Database, - ServerType, + _serverType, Executor, - _services); + _services).WithSameTopology(this); + + /// A copy of this context with no key prefix at all. + /// + /// Not an escape from isolation, and deliberately unreachable from one. "No way back to + /// k" (see ) is the public contract; this exists for the one + /// internal path that composes the prefix itself - LuaScript parameter extraction, where a + /// key's bytes travel in ARGV and must be prefixed at extraction, keys and arguments together. The + /// keys that path sends are already fully composed, so rendering them through the prefixed context + /// would prefix the KEYS declaration twice while ARGV carried it once. + /// + internal RespContext WithoutKeyPrefix() + => _keyPrefix is null + ? this + : new RespContext(CommandMap, RedisKey.Null, default, Database, _serverType, Executor, _services).WithSameTopology(this); /// /// Returns a context whose channels carry , appended to any diff --git a/src/StackExchange.Redis/Contexts/RespGroupExecutor.cs b/src/StackExchange.Redis/Contexts/RespGroupExecutor.cs index 73a25c6d0b..5ee359bb5a 100644 --- a/src/StackExchange.Redis/Contexts/RespGroupExecutor.cs +++ b/src/StackExchange.Redis/Contexts/RespGroupExecutor.cs @@ -128,6 +128,16 @@ internal override RespPayload Send(RespRequest preamble, RespRequest request, IR internal override RespExecutorBase? ResolveFor(in RedisKey key, RedisCommand command, CommandFlags flags) => _active()?.ResolveFor(in key, command, flags); + /// + /// + /// A router resolves one step and recurses, exactly as does. Without + /// this, a batch or transaction run - which resolves by its folded slot, not by a key - stopped + /// AT the group, whose base implementation declines to write runs, and the transaction reported + /// itself unexecuted without anything having been sent. + /// + internal override RespExecutorBase? ResolveForSlot(int slot, RedisCommand command, CommandFlags flags) + => _active()?.ResolveForSlot(slot, command, flags); + /// /// Null when nothing is active; the same "no honest answer" default as elsewhere. public override ValueTask IdentifyEndpointAsync( @@ -155,7 +165,7 @@ public override ValueTask SendAsync(RespRequest request, Cancellati /// private RespExecutorBase ThrowUnavailable() => throw new RedisConnectionException( - ConnectionFailureType.UnableToResolvePhysicalConnection, + ConnectionFailureType.UnableToConnect, // the facade's classification, so the two agree CommandFlags.CommandRetryNever, _describeUnavailable?.Invoke() ?? "No connection group member is available.", null, diff --git a/src/StackExchange.Redis/Database/RedisDatabase.Scans.cs b/src/StackExchange.Redis/Database/RedisDatabase.Scans.cs index eb6e7d8807..489c9e7867 100644 --- a/src/StackExchange.Redis/Database/RedisDatabase.Scans.cs +++ b/src/StackExchange.Redis/Database/RedisDatabase.Scans.cs @@ -56,29 +56,29 @@ private bool Scannable(RedisCommand command, in RedisKey key, CommandFlags flags // ---- HSCAN -------------------------------------------------------------------------------------- /// - public IEnumerable HashScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) + public virtual IEnumerable HashScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) => HashScan(key, pattern, pageSize, RedisBase.CursorUtils.Origin, 0, flags); /// - public IEnumerable HashScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public virtual IEnumerable HashScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => Scannable(RedisCommand.HSCAN, key, flags) ? _inner.Hashes.ScanCore(key, pattern, pageSize, cursor, pageOffset, flags) : Emulate(() => HashGetAllAsync(key, flags), cursor, pageOffset, RedisCommand.HSCAN, RedisCommand.HGETALL, !pattern.IsNull); /// - public IAsyncEnumerable HashScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public virtual IAsyncEnumerable HashScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => Scannable(RedisCommand.HSCAN, key, flags) ? _inner.Hashes.ScanCore(key, pattern, pageSize, cursor, pageOffset, flags) : EmulateAsync(() => HashGetAllAsync(key, flags), cursor, pageOffset, RedisCommand.HSCAN, RedisCommand.HGETALL, !pattern.IsNull); /// - public IEnumerable HashScanNoValues(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public virtual IEnumerable HashScanNoValues(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => Scannable(RedisCommand.HSCAN, key, flags) ? _inner.Hashes.ScanNoValuesCore(key, pattern, pageSize, cursor, pageOffset, flags) : Emulate(() => HashKeysAsync(key, flags), cursor, pageOffset, RedisCommand.HSCAN, RedisCommand.HKEYS, !pattern.IsNull); /// - public IAsyncEnumerable HashScanNoValuesAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public virtual IAsyncEnumerable HashScanNoValuesAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => Scannable(RedisCommand.HSCAN, key, flags) ? _inner.Hashes.ScanNoValuesCore(key, pattern, pageSize, cursor, pageOffset, flags) : EmulateAsync(() => HashKeysAsync(key, flags), cursor, pageOffset, RedisCommand.HSCAN, RedisCommand.HKEYS, !pattern.IsNull); @@ -86,17 +86,17 @@ public IAsyncEnumerable HashScanNoValuesAsync(RedisKey key, RedisVal // ---- SSCAN -------------------------------------------------------------------------------------- /// - public IEnumerable SetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) + public virtual IEnumerable SetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) => SetScan(key, pattern, pageSize, RedisBase.CursorUtils.Origin, 0, flags); /// - public IEnumerable SetScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public virtual IEnumerable SetScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => Scannable(RedisCommand.SSCAN, key, flags) ? _inner.Sets.ScanCore(key, pattern, pageSize, cursor, pageOffset, flags) : Emulate(() => SetMembersAsync(key, flags), cursor, pageOffset, RedisCommand.SSCAN, RedisCommand.SMEMBERS, !pattern.IsNull); /// - public IAsyncEnumerable SetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public virtual IAsyncEnumerable SetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => Scannable(RedisCommand.SSCAN, key, flags) ? _inner.Sets.ScanCore(key, pattern, pageSize, cursor, pageOffset, flags) : EmulateAsync(() => SetMembersAsync(key, flags), cursor, pageOffset, RedisCommand.SSCAN, RedisCommand.SMEMBERS, !pattern.IsNull); @@ -104,17 +104,17 @@ public IAsyncEnumerable SetScanAsync(RedisKey key, RedisValue patter // ---- ZSCAN -------------------------------------------------------------------------------------- /// - public IEnumerable SortedSetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) + public virtual IEnumerable SortedSetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) => SortedSetScan(key, pattern, pageSize, RedisBase.CursorUtils.Origin, 0, flags); /// - public IEnumerable SortedSetScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public virtual IEnumerable SortedSetScan(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => Scannable(RedisCommand.ZSCAN, key, flags) ? _inner.SortedSets.ScanCore(key, pattern, pageSize, cursor, pageOffset, flags) : Emulate(() => SortedSetRangeByRankWithScoresAsync(key, flags: flags), cursor, pageOffset, RedisCommand.ZSCAN, RedisCommand.ZRANGE, !pattern.IsNull); /// - public IAsyncEnumerable SortedSetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + public virtual IAsyncEnumerable SortedSetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = RedisBase.CursorUtils.DefaultLibraryPageSize, long cursor = RedisBase.CursorUtils.Origin, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => Scannable(RedisCommand.ZSCAN, key, flags) ? _inner.SortedSets.ScanCore(key, pattern, pageSize, cursor, pageOffset, flags) : EmulateAsync(() => SortedSetRangeByRankWithScoresAsync(key, flags: flags), cursor, pageOffset, RedisCommand.ZSCAN, RedisCommand.ZRANGE, !pattern.IsNull); @@ -129,11 +129,11 @@ public IAsyncEnumerable SortedSetScanAsync(RedisKey key, RedisVa // signature is shipped, and spelled `pageSize` on the context surface where it is not. /// - public IEnumerable VectorSetRangeEnumerate(RedisKey key, RedisValue start = default, RedisValue end = default, long count = 100, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) + public virtual IEnumerable VectorSetRangeEnumerate(RedisKey key, RedisValue start = default, RedisValue end = default, long count = 100, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => CanScan ? _inner.VectorSets.RangeEnumerateCore(key, start, end, count, exclude, flags) : throw NoScanning(); /// - public IAsyncEnumerable VectorSetRangeEnumerateAsync(RedisKey key, RedisValue start = default, RedisValue end = default, long count = 100, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) + public virtual IAsyncEnumerable VectorSetRangeEnumerateAsync(RedisKey key, RedisValue start = default, RedisValue end = default, long count = 100, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => CanScan ? _inner.VectorSets.RangeEnumerateCore(key, start, end, count, exclude, flags) : throw NoScanning(); // ---- the pre-SCAN emulation ---------------------------------------------------------------------- diff --git a/src/StackExchange.Redis/Database/RedisDatabase.Scripts.cs b/src/StackExchange.Redis/Database/RedisDatabase.Scripts.cs index 71bc11f959..5f1e65951c 100644 --- a/src/StackExchange.Redis/Database/RedisDatabase.Scripts.cs +++ b/src/StackExchange.Redis/Database/RedisDatabase.Scripts.cs @@ -107,19 +107,52 @@ public Task ScriptEvaluateReadOnlyAsync(byte[] hash, RedisKey[]? ke /// public RedisResult ScriptEvaluate(LuaScript script, object? parameters = null, CommandFlags flags = CommandFlags.None) - => script.Evaluate(this, parameters, null, flags); + => script.Evaluate(ScriptTarget(out var prefix), parameters, prefix, flags); /// public Task ScriptEvaluateAsync(LuaScript script, object? parameters = null, CommandFlags flags = CommandFlags.None) - => script.EvaluateAsync(this, parameters, null, flags); + => script.EvaluateAsync(ScriptTarget(out var prefix), parameters, prefix, flags); /// public RedisResult ScriptEvaluate(LoadedLuaScript script, object? parameters = null, CommandFlags flags = CommandFlags.None) - => script.Evaluate(this, parameters, withKeyPrefix: null, flags); + => script.Evaluate(ScriptTarget(out var prefix), parameters, prefix, flags); /// public Task ScriptEvaluateAsync(LoadedLuaScript script, object? parameters = null, CommandFlags flags = CommandFlags.None) - => script.EvaluateAsync(this, parameters, withKeyPrefix: null, flags); + => script.EvaluateAsync(ScriptTarget(out var prefix), parameters, prefix, flags); + + /// + /// Where a evaluation should be sent from, and the key prefix its parameter + /// extraction must apply. + /// + /// The context's composed key prefix, or null when there is none. + /// + /// + /// The one place a key's bytes travel as a value. A @key hole in the script text becomes + /// ARGV[n], so the key's bytes go out in the ARGV list, where the render-time key prefix cannot + /// see them; only the KEYS declaration is -typed. So the prefix has to be applied + /// where keys and arguments are extracted together - which is what ExtractParameters's prefix + /// parameter is for, and what the old KeyPrefixedDatabase passed its prefix to. + /// + /// + /// The extraction then owns the WHOLE composition: the keys it hands back are already the bytes the + /// server must see, so the send goes through an unprefixed view of the same context, or render time + /// would prefix the KEYS declaration a second time while ARGV kept the single prefix - a mismatch the + /// server cannot flag, because both spell valid keys. + /// + /// + private IDatabase ScriptTarget(out RedisKey? keyPrefix) + { + var raw = _inner.Raw; + if (raw.KeyPrefixSpan.IsEmpty) + { + keyPrefix = null; + return this; + } + + keyPrefix = raw.KeyPrefix; + return new RedisDatabase(new RespDatabaseContext(raw.WithoutKeyPrefix()), multiplexer, AsyncState); + } /// The low-allocation shipped shape, which travels the same uncached route. /// diff --git a/src/StackExchange.Redis/Database/RedisDatabase.cs b/src/StackExchange.Redis/Database/RedisDatabase.cs index 64baaefb5a..acbe9e2f3d 100644 --- a/src/StackExchange.Redis/Database/RedisDatabase.cs +++ b/src/StackExchange.Redis/Database/RedisDatabase.cs @@ -26,8 +26,8 @@ namespace StackExchange.Redis /// Losing it is an improvement, not a regression. A command added to the interface used to /// produce a generated throw and a warning; now it does not compile until it is implemented, which is /// the same guarantee RedisDatabase has always had and a better one than a tripwire. The - /// generator itself stays - RetryDatabase and MultiGroupDatabase are capture-and-replay - /// wrappers, which is what it is really for. + /// generator itself stays - RetryTransaction is a capture-and-replay + /// wrapper, which is what it is really for. /// /// /// There is no fallback. This once forwarded anything not yet moved to the v3 RedisDatabase, and @@ -90,13 +90,24 @@ internal partial class RedisDatabase(RespDatabaseContext inner, IConnectionMulti // Found by trying the GetDatabase swap: nothing failed, which is exactly the problem. /// - /// The cluster flag is read from the context, which is where this surface keeps that fact. - DatabaseFeatureFlags IInternalDatabaseAsync.GetFeatures(out string name) + DatabaseFeatureFlags IInternalDatabaseAsync.GetFeatures(out string name) => GetFeaturesCore(out name); + + /// The features and diagnostic name this database reports. + /// + /// The cluster flag is read from the context, which is where this surface keeps that fact; the + /// retry flag from the executor, because a retrying database IS this type over a retrying chain. + /// Virtual so a database with more to say - MultiGroupDatabase, which folds in the active + /// member's features and reports its name - can say it without re-implementing the interface. + /// + private protected virtual DatabaseFeatureFlags GetFeaturesCore(out string name) { name = multiplexer?.ClientName ?? ""; - return (_inner.Raw.ServerType == ServerType.Cluster + var features = _inner.Raw.ServerType == ServerType.Cluster ? DatabaseFeatureFlags.Cluster - : DatabaseFeatureFlags.None) | OwnFeatures; + : DatabaseFeatureFlags.None; + if (_inner.Raw.Executor is Availability.RespRetryExecutor) features |= DatabaseFeatureFlags.Retry; + if (!_inner.Raw.KeyPrefixSpan.IsEmpty) features |= DatabaseFeatureFlags.KeyPrefix; + return features | OwnFeatures; } /// What THIS wrapper is, as opposed to what the connection underneath can do. @@ -111,10 +122,12 @@ DatabaseFeatureFlags IInternalDatabaseAsync.GetFeatures(out string name) /// /// - /// This surface has no failover notion of its own; the databases that do - RetryDatabase, - /// MultiGroupDatabase - sit above it and hand their own token down. + /// Answered by the executor chain, which is where a failover notion lives when there is one + /// (RespGroupExecutor, read through GetFailoverSource). Fetched per call, never + /// captured: the token is replaced each time a failover happens, which is how it signals. /// - CancellationToken IInternalDatabaseAsync.GetNextFailover() => CancellationToken.None; + CancellationToken IInternalDatabaseAsync.GetNextFailover() + => _inner.Raw.Executor?.GetFailoverSource()?.Invoke() ?? CancellationToken.None; // The [AutoDatabase] funnels used to be here - four of them, the landing place for every member // this class did not implement. They are gone with the attribute: there is no longer a member that @@ -209,6 +222,24 @@ public IBatch CreateBatch(object? asyncState = null) public ITransaction CreateTransaction(object? asyncState = null) { if (this is IBatch) throw new NotSupportedException("Nested transactions are not supported"); + + // A retrying database replays a transaction AS A UNIT - conditions, queued commands and EXEC + // together - which the per-frame retry executor cannot express; that is RetryTransaction's + // job. It records against a plain view over the executor underneath the retry link, building + // a fresh inner transaction per attempt, and the durable proxy tasks it hands out cannot + // carry an asyncState - so one is refused rather than silently dropped. + if (_inner.Raw.Executor is Availability.RespRetryExecutor retry) + { + if ((asyncState ?? AsyncState) is not null) + { + throw new InvalidOperationException( + "Retrying transactions do not support asyncState; the tasks they hand back are not the tasks that were sent to the server."); + } + + var plain = new RedisDatabase(new RespDatabaseContext(_inner.Raw.WithExecutor(retry.Inner)), multiplexer, null); + return new Availability.RetryTransaction(plain, retry.Controller); + } + // CanWriteTransactions, not CanWriteRuns: an executor can write a batch without being able to // hold a connection across MULTI/EXEC, and the old Message shim was exactly that return _inner.Raw.Executor is { CanWriteTransactions: true } @@ -224,9 +255,17 @@ public ITransaction CreateTransaction(object? asyncState = null) /// sent - the question is what routing would do with this key, which is the one thing the /// context cannot answer for itself. An executor with no routing says yes; see /// RespExecutorBase.IsConnected. + /// + /// The key is prefixed first, here and in the other routing questions: a send renders the prefix + /// into the frame, but these take the key out of band, and in a cluster the prefixed bytes are + /// what pick the node. + /// /// public bool IsConnected(RedisKey key, CommandFlags flags = CommandFlags.None) - => Router.IsConnected(in key, flags); + { + key = _inner.Raw.PrefixKey(in key); + return Router.IsConnected(in key, flags); + } /// /// with the detail a boolean cannot carry; internal while the shape settles. @@ -234,19 +273,22 @@ public bool IsConnected(RedisKey key, CommandFlags flags = CommandFlags.None) /// The key whose routing is being asked about; null means "anywhere". /// The flags that would be used; they decide primary versus replica, and so which endpoint is being asked about. internal RespConnectionState GetConnectionState(RedisKey key, CommandFlags flags = CommandFlags.None) - => Router.GetConnectionState(in key, flags); + { + key = _inner.Raw.PrefixKey(in key); + return Router.GetConnectionState(in key, flags); + } internal string RouterKindForTest => Router.GetType().Name; /// /// Off the fallback: the executor is the router, so it is the one that can answer. public System.Net.EndPoint? IdentifyEndpoint(RedisKey key = default, CommandFlags flags = CommandFlags.None) - => Wait(Router.IdentifyEndpointAsync(key, flags)); + => Wait(Router.IdentifyEndpointAsync(_inner.Raw.PrefixKey(in key), flags)); /// /// Off the fallback; see the synchronous twin. public Task IdentifyEndpointAsync(RedisKey key = default, CommandFlags flags = CommandFlags.None) - => Router.IdentifyEndpointAsync(key, flags).AsTask(AsyncState, flags); + => Router.IdentifyEndpointAsync(_inner.Raw.PrefixKey(in key), flags).AsTask(AsyncState, flags); /// /// diff --git a/src/StackExchange.Redis/Groups/Keys.Methods.cs b/src/StackExchange.Redis/Groups/Keys.Methods.cs index db3c812d05..e2705e4f71 100644 --- a/src/StackExchange.Redis/Groups/Keys.Methods.cs +++ b/src/StackExchange.Redis/Groups/Keys.Methods.cs @@ -294,9 +294,20 @@ internal static ValueTask MatchingArray(this RespKeys keys, RedisVal /// and the command names no key, so nothing could ever invalidate an entry for it. Either one alone /// would be enough. /// + /// The context has a key prefix in force. public static ValueTask RandomAsync(this RespKeys keys, CommandFlags flags = CommandFlags.None, CancellationToken cancellationToken = default) - => keys.Context.SendAsync( + { + // RANDOMKEY samples the WHOLE keyspace: a prefixed context cannot restrict it to its own keys, + // and the result comes back un-prefixed, so there is no honest answer to give. The old + // KeyPrefixedDatabase refused this the same way. + if (!keys.Context.KeyPrefixSpan.IsEmpty) + { + throw new NotSupportedException("RANDOMKEY is not supported when a key prefix is in force: it samples the entire keyspace, not the prefixed one."); + } + + return keys.Context.SendAsync( $"{RedisCommand.RANDOMKEY}", flags.NeverCached(), cancellationToken: cancellationToken); + } /// TYPE. /// The key command group. diff --git a/src/StackExchange.Redis/Groups/Keys.Sort.cs b/src/StackExchange.Redis/Groups/Keys.Sort.cs index 5828e2b705..ad78b8e3e9 100644 --- a/src/StackExchange.Redis/Groups/Keys.Sort.cs +++ b/src/StackExchange.Redis/Groups/Keys.Sort.cs @@ -155,6 +155,25 @@ private static ValueTask SortCore( // pattern with a '*' looks anything up: BY nosort, a starless BY, and GET # read nothing else. if (ReadsOtherKeys(by, get)) flags = flags.NeverCached(); + // The patterns name keys, but travel as VALUES, so the render-time key prefix cannot see them; + // a prefixed context maps them here instead, exactly as the old KeyPrefixedDatabase did. The two + // operand spellings are exempt: BY nosort and GET # are instructions, not patterns. + if (!context.KeyPrefixSpan.IsEmpty) + { + if (!by.IsNull && by != RedisLiterals.nosort) by = PrefixPattern(context, by); + if (!get.IsEmpty) + { + var mapped = new RedisValue[get.Length]; + for (var i = 0; i < get.Length; i++) + { + var pattern = get[i]; + mapped[i] = pattern == RedisLiterals.HashSymbol ? pattern : PrefixPattern(context, pattern); + } + + get = mapped; + } + } + var command = SelectCommand(context, in destination, in key, ref flags); // these defaults mean "everything", and the server already assumes them @@ -205,6 +224,10 @@ private static ValueTask SortCore( return context.SendAsync(ref frame, flags, RespHandlers.Inbuilt.Require(), default); } + /// A BY/GET pattern with the context's key prefix prepended. + private static RedisValue PrefixPattern(RespContext context, RedisValue pattern) + => RedisKey.ConcatenateBytes((byte[]?)context.KeyPrefix, null, (byte[]?)pattern); + /// SORT or SORT_RO, and what that means for retries and routing. private static bool ReadsOtherKeys(RedisValue by, ReadOnlySpan get) { diff --git a/src/StackExchange.Redis/Interfaces/IInternalDatabaseAsync.cs b/src/StackExchange.Redis/Interfaces/IInternalDatabaseAsync.cs index 6aea5db572..42626b9c07 100644 --- a/src/StackExchange.Redis/Interfaces/IInternalDatabaseAsync.cs +++ b/src/StackExchange.Redis/Interfaces/IInternalDatabaseAsync.cs @@ -23,9 +23,9 @@ internal interface IInternalDatabaseAsync : IDatabaseAsync CancellationToken GetNextFailover(); /// - /// The async-state that this database stamps onto the tasks it hands out, if any; wrappers that - /// cannot preserve it (see RetryDatabase) need to know when one is present rather than - /// dropping it silently. + /// The async-state that this database stamps onto the tasks it hands out, if any; anything that + /// rebuilds a database over the same context (see WithRetry) reads it here so the state + /// travels rather than being dropped silently. /// object? AsyncState { get; } } diff --git a/src/StackExchange.Redis/KeyspaceIsolation/DatabaseExtension.cs b/src/StackExchange.Redis/KeyspaceIsolation/DatabaseExtension.cs index 742bc06eb7..1e145306b1 100644 --- a/src/StackExchange.Redis/KeyspaceIsolation/DatabaseExtension.cs +++ b/src/StackExchange.Redis/KeyspaceIsolation/DatabaseExtension.cs @@ -1,4 +1,5 @@ using System; +using StackExchange.Redis.Interfaces; namespace StackExchange.Redis.KeyspaceIsolation { @@ -54,14 +55,29 @@ public static IDatabase WithKeyPrefix(this IDatabase database, RedisKey keyPrefi return database; // fine - you can keep using the original, then } - if (database is KeyPrefixedDatabase prefixed) + // The prefix is CONTEXT state, applied to every RedisKey at render time - so the result is a + // plain database over a prefixed context, not a wrapper. Nesting composes the same way the + // old decorators did: the prefixes concatenate, outermost call innermost on the wire. + // + // A foreign IDatabase has no context to re-point, and - unlike WithRetry, where "no retry" is + // merely the behaviour the caller already had - quietly not prefixing would hand every command + // to the WRONG KEYSPACE; that must throw rather than degrade. + if (database.Context is not { Raw: { Executor: not null } raw }) { - // combine the key in advance to minimize indirection - keyPrefix = prefixed.ToInner(keyPrefix); - database = prefixed.Inner; + throw new NotSupportedException( + $"WithKeyPrefix requires a database from this library; {database.GetType().Name} exposes no context to apply the prefix to."); } - return new KeyPrefixedDatabase(database, keyPrefix.AsPrefix()!); + // a batch or transaction cannot be re-contexted into a plain database without silently losing + // what it is; take the prefix BEFORE creating it (the batch inherits the prefixed context) + database.RejectFlags(DatabaseFeatureFlags.Batch | DatabaseFeatureFlags.Transaction); + + // the channel prefix too: the old decorator prefixed the channel on Publish, and a tenant + // boundary that covered keys but not the messages about them would be a silent hole + var context = new RespDatabaseContext(raw + .AppendKeyPrefix(keyPrefix) + .AppendChannelPrefix(new RedisChannel((byte[]?)keyPrefix, RedisChannel.PatternMode.Literal))); + return new RedisDatabase(context, database.Multiplexer, database.GetAsyncState()); } } } diff --git a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.Arrays.cs b/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.Arrays.cs deleted file mode 100644 index 2ad2d6dc82..0000000000 --- a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.Arrays.cs +++ /dev/null @@ -1,76 +0,0 @@ -using System.Threading.Tasks; - -// ReSharper disable once CheckNamespace -namespace StackExchange.Redis.KeyspaceIsolation; - -internal partial class KeyPrefixed -{ - public Task ArraySetAsync(RedisKey key, RedisArrayIndex index, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ArraySetAsync(ToInner(key), index, value, flags); - - public Task ArraySetAsync(RedisKey key, RedisArrayIndex index, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.ArraySetAsync(ToInner(key), index, values, flags); - - public Task ArraySetAsync(RedisKey key, RedisArrayEntry[] values, CommandFlags flags = CommandFlags.None) => - Inner.ArraySetAsync(ToInner(key), values, flags); - - public Task ArrayGetAsync(RedisKey key, RedisArrayIndex index, CommandFlags flags = CommandFlags.None) => - Inner.ArrayGetAsync(ToInner(key), index, flags); - - public Task ArrayGetAsync(RedisKey key, RedisArrayIndex[] indices, CommandFlags flags = CommandFlags.None) => - Inner.ArrayGetAsync(ToInner(key), indices, flags); - - public Task ArrayGetRangeAsync(RedisKey key, RedisArrayIndex start, RedisArrayIndex end, CommandFlags flags = CommandFlags.None) => - Inner.ArrayGetRangeAsync(ToInner(key), start, end, flags); - - public Task ArrayLengthAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ArrayLengthAsync(ToInner(key), flags); - - public Task ArrayCountAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ArrayCountAsync(ToInner(key), flags); - - public Task ArrayDeleteAsync(RedisKey key, RedisArrayIndex index, CommandFlags flags = CommandFlags.None) => - Inner.ArrayDeleteAsync(ToInner(key), index, flags); - - public Task ArrayDeleteAsync(RedisKey key, RedisArrayIndex[] indices, CommandFlags flags = CommandFlags.None) => - Inner.ArrayDeleteAsync(ToInner(key), indices, flags); - - public Task ArrayDeleteRangeAsync(RedisKey key, RedisArrayIndex start, RedisArrayIndex end, CommandFlags flags = CommandFlags.None) => - Inner.ArrayDeleteRangeAsync(ToInner(key), start, end, flags); - - public Task ArrayDeleteRangeAsync(RedisKey key, RedisArrayRange[] ranges, CommandFlags flags = CommandFlags.None) => - Inner.ArrayDeleteRangeAsync(ToInner(key), ranges, flags); - - public Task ArrayScanAsync(RedisKey key, RedisArrayIndex start, RedisArrayIndex end, int limit = 0, CommandFlags flags = CommandFlags.None) => - Inner.ArrayScanAsync(ToInner(key), start, end, limit, flags); - - public Task ArrayGrepAsync(RedisKey key, ArrayGrepRequest request, CommandFlags flags = CommandFlags.None) => - Inner.ArrayGrepAsync(ToInner(key), request, flags); - - public Task ArrayOperationAsync(RedisKey key, RedisArrayIndex start, RedisArrayIndex end, ArrayOperation operation, RedisValue operand = default, CommandFlags flags = CommandFlags.None) => - Inner.ArrayOperationAsync(ToInner(key), start, end, operation, operand, flags); - - public Task ArrayRingAsync(RedisKey key, RedisArrayIndex maxLength, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ArrayRingAsync(ToInner(key), maxLength, value, flags); - - public Task ArrayRingAsync(RedisKey key, RedisArrayIndex maxLength, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.ArrayRingAsync(ToInner(key), maxLength, values, flags); - - public Task ArrayNextAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ArrayNextAsync(ToInner(key), flags); - - public Task ArrayInsertAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ArrayInsertAsync(ToInner(key), value, flags); - - public Task ArrayInsertAsync(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.ArrayInsertAsync(ToInner(key), values, flags); - - public Task ArraySeekAsync(RedisKey key, RedisArrayIndex index, CommandFlags flags = CommandFlags.None) => - Inner.ArraySeekAsync(ToInner(key), index, flags); - - public Task ArrayLastItemsAsync(RedisKey key, int count, bool reverse = false, CommandFlags flags = CommandFlags.None) => - Inner.ArrayLastItemsAsync(ToInner(key), count, reverse, flags); - - public Task ArrayInfoAsync(RedisKey key, bool full = false, CommandFlags flags = CommandFlags.None) => - Inner.ArrayInfoAsync(ToInner(key), full, flags); -} diff --git a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.VectorSets.cs b/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.VectorSets.cs deleted file mode 100644 index 2c4f1b0c3f..0000000000 --- a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.VectorSets.cs +++ /dev/null @@ -1,76 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Threading.Tasks; -using RESPite; - -// ReSharper disable once CheckNamespace -namespace StackExchange.Redis.KeyspaceIsolation; - -internal partial class KeyPrefixed -{ - // Vector Set operations - async methods - public Task VectorSetAddAsync( - RedisKey key, - VectorSetAddRequest request, - CommandFlags flags = CommandFlags.None) => - Inner.VectorSetAddAsync(ToInner(key), request, flags); - - public Task VectorSetLengthAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetLengthAsync(ToInner(key), flags); - - public Task VectorSetDimensionAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetDimensionAsync(ToInner(key), flags); - - public Task?> VectorSetGetApproximateVectorAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetGetApproximateVectorAsync(ToInner(key), member, flags); - - public Task VectorSetGetAttributesJsonAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetGetAttributesJsonAsync(ToInner(key), member, flags); - - public Task VectorSetInfoAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetInfoAsync(ToInner(key), flags); - - public Task VectorSetContainsAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetContainsAsync(ToInner(key), member, flags); - - public Task?> VectorSetGetLinksAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetGetLinksAsync(ToInner(key), member, flags); - - public Task?> VectorSetGetLinksWithScoresAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetGetLinksWithScoresAsync(ToInner(key), member, flags); - - public Task VectorSetRandomMemberAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetRandomMemberAsync(ToInner(key), flags); - - public Task VectorSetRandomMembersAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetRandomMembersAsync(ToInner(key), count, flags); - - public Task VectorSetRemoveAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetRemoveAsync(ToInner(key), member, flags); - - public Task VectorSetSetAttributesJsonAsync(RedisKey key, RedisValue member, string attributesJson, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetSetAttributesJsonAsync(ToInner(key), member, attributesJson, flags); - - public Task?> VectorSetSimilaritySearchAsync( - RedisKey key, - VectorSetSimilaritySearchRequest query, - CommandFlags flags = CommandFlags.None) => - Inner.VectorSetSimilaritySearchAsync(ToInner(key), query, flags); - - public Task?> VectorSetRangeAsync( - RedisKey key, - RedisValue start = default, - RedisValue end = default, - long count = -1, - Exclude exclude = Exclude.None, - CommandFlags flags = CommandFlags.None) => - Inner.VectorSetRangeAsync(ToInner(key), start, end, count, exclude, flags); - - public System.Collections.Generic.IAsyncEnumerable VectorSetRangeEnumerateAsync( - RedisKey key, - RedisValue start = default, - RedisValue end = default, - long count = 100, - Exclude exclude = Exclude.None, - CommandFlags flags = CommandFlags.None) => - Inner.VectorSetRangeEnumerateAsync(ToInner(key), start, end, count, exclude, flags); -} diff --git a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.cs b/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.cs deleted file mode 100644 index 3daa10b6d1..0000000000 --- a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.cs +++ /dev/null @@ -1,1261 +0,0 @@ -using System; -using System.Buffers; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; -using System.Linq; -using System.Net; -using System.Threading; -using System.Threading.Tasks; -using StackExchange.Redis.Interfaces; - -namespace StackExchange.Redis.KeyspaceIsolation -{ - internal partial class KeyPrefixed : IDatabaseAsync, IInternalDatabaseAsync where TInner : IDatabaseAsync - { - internal KeyPrefixed(TInner inner, byte[] keyPrefix) - { - Inner = inner; - Prefix = keyPrefix; - } - - private RespContext? _context; - - /// Build the prefixed context; one clone of the inner one. - /// - /// - /// The worked example from design notes section 8.4: the entire write half of key-prefixing is one - /// context clone. Everything this class does by forwarding ~2600 lines of overrides, the - /// context-based surface gets from this single line - and it sits on the shared base, so a prefixed - /// batch and a prefixed transaction get it too rather than only a prefixed database. - /// - /// - /// Memoised because is a class: that clone used to be a struct copy and is - /// now an allocation, so rebuilding per access would allocate once per command. Both the inner - /// target and the prefix are fixed at construction, so there is nothing for it to go stale against. - /// - /// - private RespContext GetContext() => _context ??= Inner.Raw.AppendKeyPrefix(Prefix); - - /// - RespContext IRespTarget.Context => GetContext(); - - /// - /// Both come from one builder, so a prefixed target cannot disagree with itself. - public RespDatabaseContext Context => new(GetContext()); - - public IConnectionMultiplexer Multiplexer => Inner.Multiplexer; - - public int Database => Inner.Database; - - // default: this wrapper is not a full database (it is the base for the batch/transaction wrappers too), - // so it cannot start a transaction; KeyPrefixedDatabase reimplements this to prefix a real one - ITransactionAsync IDatabaseAsync.CreateTransaction(object? asyncState) - => throw new NotSupportedException("Transactions cannot be created here"); - - internal TInner Inner { get; } - - internal byte[] Prefix { get; } - - DatabaseFeatureFlags IInternalDatabaseAsync.GetFeatures(out string name) - => Inner.GetFeatures(out name) | GetDatabaseFeatures(); - - CancellationToken IInternalDatabaseAsync.GetNextFailover() => Inner.GetNextFailover(); - - // this wrapper does not stamp its own async-state; it inherits whatever the inner database uses - object? IInternalDatabaseAsync.AsyncState => Inner.GetAsyncState(); - - // the flags contributed by this wrapper itself (on top of the inner database); the batch and - // transaction subclasses override to fold in their own flag, mirroring RedisDatabase/RedisBatch/ - // RedisTransaction rather than relying on the inner instance to carry it. - private protected virtual DatabaseFeatureFlags GetDatabaseFeatures() - => DatabaseFeatureFlags.KeyPrefix; - - public override string ToString() => this.BuildString(); - - public Task DebugObjectAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.DebugObjectAsync(ToInner(key), flags); - - public Task GeoAddAsync(RedisKey key, double longitude, double latitude, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.GeoAddAsync(ToInner(key), longitude, latitude, member, flags); - - public Task GeoAddAsync(RedisKey key, GeoEntry value, CommandFlags flags = CommandFlags.None) => - Inner.GeoAddAsync(ToInner(key), value, flags); - - public Task GeoAddAsync(RedisKey key, GeoEntry[] values, CommandFlags flags = CommandFlags.None) => - Inner.GeoAddAsync(ToInner(key), values, flags); - - public Task GeoRemoveAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.GeoRemoveAsync(ToInner(key), member, flags); - - public Task GeoDistanceAsync(RedisKey key, RedisValue member1, RedisValue member2, GeoUnit unit = GeoUnit.Meters, CommandFlags flags = CommandFlags.None) => - Inner.GeoDistanceAsync(ToInner(key), member1, member2, unit, flags); - - public Task GeoHashAsync(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None) => - Inner.GeoHashAsync(ToInner(key), members, flags); - - public Task GeoHashAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.GeoHashAsync(ToInner(key), member, flags); - - public Task GeoPositionAsync(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None) => - Inner.GeoPositionAsync(ToInner(key), members, flags); - - public Task GeoPositionAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.GeoPositionAsync(ToInner(key), member, flags); - - public Task GeoRadiusAsync(RedisKey key, RedisValue member, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => - Inner.GeoRadiusAsync(ToInner(key), member, radius, unit, count, order, options, flags); - - public Task GeoRadiusAsync(RedisKey key, double longitude, double latitude, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => - Inner.GeoRadiusAsync(ToInner(key), longitude, latitude, radius, unit, count, order, options, flags); - - public Task GeoSearchAsync(RedisKey key, RedisValue member, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => - Inner.GeoSearchAsync(ToInner(key), member, shape, count, demandClosest, order, options, flags); - - public Task GeoSearchAsync(RedisKey key, double longitude, double latitude, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => - Inner.GeoSearchAsync(ToInner(key), longitude, latitude, shape, count, demandClosest, order, options, flags); - - public Task GeoSearchAndStoreAsync(RedisKey sourceKey, RedisKey destinationKey, RedisValue member, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, bool storeDistances = false, CommandFlags flags = CommandFlags.None) => - Inner.GeoSearchAndStoreAsync(ToInner(sourceKey), ToInner(destinationKey), member, shape, count, demandClosest, order, storeDistances, flags); - - public Task GeoSearchAndStoreAsync(RedisKey sourceKey, RedisKey destinationKey, double longitude, double latitude, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, bool storeDistances = false, CommandFlags flags = CommandFlags.None) => - Inner.GeoSearchAndStoreAsync(ToInner(sourceKey), ToInner(destinationKey), longitude, latitude, shape, count, demandClosest, order, storeDistances, flags); - - public Task HashDecrementAsync(RedisKey key, RedisValue hashField, double value, CommandFlags flags = CommandFlags.None) => - Inner.HashDecrementAsync(ToInner(key), hashField, value, flags); - - public Task HashDecrementAsync(RedisKey key, RedisValue hashField, long value = 1, CommandFlags flags = CommandFlags.None) => - Inner.HashDecrementAsync(ToInner(key), hashField, value, flags); - - public Task HashDeleteAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None) => - Inner.HashDeleteAsync(ToInner(key), hashFields, flags); - - public Task HashDeleteAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashDeleteAsync(ToInner(key), hashField, flags); - - public Task HashExistsAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashExistsAsync(ToInner(key), hashField, flags); - - public Task HashFieldGetAndDeleteAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndDeleteAsync(ToInner(key), hashField, flags); - - public Task?> HashFieldGetLeaseAndDeleteAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetLeaseAndDeleteAsync(ToInner(key), hashField, flags); - - public Task HashFieldGetAndDeleteAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndDeleteAsync(ToInner(key), hashFields, flags); - - public Task HashFieldGetAndSetExpiryAsync(RedisKey key, RedisValue hashField, TimeSpan? expiry = null, bool persist = false, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndSetExpiryAsync(ToInner(key), hashField, expiry, persist, flags); - - public Task HashFieldGetAndSetExpiryAsync(RedisKey key, RedisValue hashField, DateTime expiry, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndSetExpiryAsync(ToInner(key), hashField, expiry, flags); - - public Task?> HashFieldGetLeaseAndSetExpiryAsync(RedisKey key, RedisValue hashField, TimeSpan? expiry = null, bool persist = false, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetLeaseAndSetExpiryAsync(ToInner(key), hashField, expiry, persist, flags); - - public Task?> HashFieldGetLeaseAndSetExpiryAsync(RedisKey key, RedisValue hashField, DateTime expiry, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetLeaseAndSetExpiryAsync(ToInner(key), hashField, expiry, flags); - - public Task HashFieldGetAndSetExpiryAsync(RedisKey key, RedisValue[] hashFields, TimeSpan? expiry = null, bool persist = false, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndSetExpiryAsync(ToInner(key), hashFields, expiry, persist, flags); - - public Task HashFieldGetAndSetExpiryAsync(RedisKey key, RedisValue[] hashFields, DateTime expiry, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndSetExpiryAsync(ToInner(key), hashFields, expiry, flags); - - public Task HashFieldSetAndSetExpiryAsync(RedisKey key, RedisValue field, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldSetAndSetExpiryAsync(ToInner(key), field, value, expiry, keepTtl, when, flags); - - public Task HashFieldSetAndSetExpiryAsync(RedisKey key, RedisValue field, RedisValue value, DateTime expiry, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldSetAndSetExpiryAsync(ToInner(key), field, value, expiry, when, flags); - - public Task HashFieldSetAndSetExpiryAsync(RedisKey key, HashEntry[] hashFields, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldSetAndSetExpiryAsync(ToInner(key), hashFields, expiry, keepTtl, when, flags); - - public Task HashFieldSetAndSetExpiryAsync(RedisKey key, HashEntry[] hashFields, DateTime expiry, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldSetAndSetExpiryAsync(ToInner(key), hashFields, expiry, when, flags); - - public Task HashFieldExpireAsync(RedisKey key, RedisValue[] hashFields, TimeSpan expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldExpireAsync(ToInner(key), hashFields, expiry, when, flags); - - public Task HashFieldExpireAsync(RedisKey key, RedisValue[] hashFields, DateTime expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldExpireAsync(ToInner(key), hashFields, expiry, when, flags); - - public Task HashFieldGetExpireDateTimeAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags) => - Inner.HashFieldGetExpireDateTimeAsync(ToInner(key), hashFields, flags); - - public Task HashFieldPersistAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags) => - Inner.HashFieldPersistAsync(ToInner(key), hashFields, flags); - - public Task HashFieldGetTimeToLiveAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags) => - Inner.HashFieldGetTimeToLiveAsync(ToInner(key), hashFields, flags); - - public Task HashGetAllAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HashGetAllAsync(ToInner(key), flags); - - public Task HashGetAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None) => - Inner.HashGetAsync(ToInner(key), hashFields, flags); - - public Task HashGetAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashGetAsync(ToInner(key), hashField, flags); - - public Task?> HashGetLeaseAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashGetLeaseAsync(ToInner(key), hashField, flags); - - public Task HashIncrementAsync(RedisKey key, RedisValue hashField, double value, CommandFlags flags = CommandFlags.None) => - Inner.HashIncrementAsync(ToInner(key), hashField, value, flags); - - public Task HashIncrementAsync(RedisKey key, RedisValue hashField, long value = 1, CommandFlags flags = CommandFlags.None) => - Inner.HashIncrementAsync(ToInner(key), hashField, value, flags); - - public Task HashKeysAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HashKeysAsync(ToInner(key), flags); - - public Task HashLengthAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HashLengthAsync(ToInner(key), flags); - - public Task HashRandomFieldAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HashRandomFieldAsync(ToInner(key), flags); - - public Task HashRandomFieldsAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.HashRandomFieldsAsync(ToInner(key), count, flags); - - public Task HashRandomFieldsWithValuesAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.HashRandomFieldsWithValuesAsync(ToInner(key), count, flags); - - public IAsyncEnumerable HashScanAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => - Inner.HashScanAsync(ToInner(key), pattern, pageSize, cursor, pageOffset, flags); - - public IAsyncEnumerable HashScanNoValuesAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => - Inner.HashScanNoValuesAsync(ToInner(key), pattern, pageSize, cursor, pageOffset, flags); - - public Task HashSetAsync(RedisKey key, RedisValue hashField, RedisValue value, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashSetAsync(ToInner(key), hashField, value, when, flags); - - public Task HashStringLengthAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashStringLengthAsync(ToInner(key), hashField, flags); - - public Task HashImportAsync(RedisKey key, HashImport fieldSet, ReadOnlyMemory values, CommandFlags flags = CommandFlags.None) => - Inner.HashImportAsync(ToInner(key), fieldSet, values, flags); - - public Task HashSetAsync(RedisKey key, HashEntry[] hashFields, CommandFlags flags = CommandFlags.None) => - Inner.HashSetAsync(ToInner(key), hashFields, flags); - - public Task HashValuesAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HashValuesAsync(ToInner(key), flags); - - public Task HyperLogLogAddAsync(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogAddAsync(ToInner(key), values, flags); - - public Task HyperLogLogAddAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogAddAsync(ToInner(key), value, flags); - - public Task HyperLogLogLengthAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogLengthAsync(ToInner(key), flags); - - public Task HyperLogLogLengthAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogLengthAsync(ToInner(keys), flags); - - public Task HyperLogLogMergeAsync(RedisKey destination, RedisKey[] sourceKeys, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogMergeAsync(ToInner(destination), ToInner(sourceKeys), flags); - - public Task HyperLogLogMergeAsync(RedisKey destination, RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogMergeAsync(ToInner(destination), ToInner(first), ToInner(second), flags); - - public Task IdentifyEndpointAsync(RedisKey key = default(RedisKey), CommandFlags flags = CommandFlags.None) => - Inner.IdentifyEndpointAsync(ToInner(key), flags); - - public bool IsConnected(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.IsConnected(ToInner(key), flags); - - public Task KeyCopyAsync(RedisKey sourceKey, RedisKey destinationKey, int destinationDatabase = -1, bool replace = false, CommandFlags flags = CommandFlags.None) => - Inner.KeyCopyAsync(ToInner(sourceKey), ToInner(destinationKey), destinationDatabase, replace, flags); - - public Task KeyDeleteAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.KeyDeleteAsync(ToInner(keys), flags); - - public Task KeyDeleteAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyDeleteAsync(ToInner(key), flags); - - public Task KeyDumpAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyDumpAsync(ToInner(key), flags); - - public Task KeyEncodingAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyEncodingAsync(ToInner(key), flags); - - public Task KeyExistsAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyExistsAsync(ToInner(key), flags); - - public Task KeyExistsAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.KeyExistsAsync(ToInner(keys), flags); - - public Task KeyExpireAsync(RedisKey key, DateTime? expiry, CommandFlags flags) => - Inner.KeyExpireAsync(ToInner(key), expiry, flags); - - public Task KeyExpireAsync(RedisKey key, DateTime? expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.KeyExpireAsync(ToInner(key), expiry, when, flags); - - public Task KeyExpireAsync(RedisKey key, TimeSpan? expiry, CommandFlags flags) => - Inner.KeyExpireAsync(ToInner(key), expiry, flags); - - public Task KeyExpireAsync(RedisKey key, TimeSpan? expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.KeyExpireAsync(ToInner(key), expiry, when, flags); - - public Task KeyExpireTimeAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyExpireTimeAsync(ToInner(key), flags); - - public Task KeyFrequencyAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyFrequencyAsync(ToInner(key), flags); - - public Task KeyIdleTimeAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyIdleTimeAsync(ToInner(key), flags); - - public Task KeyMigrateAsync(RedisKey key, EndPoint toServer, int toDatabase = 0, int timeoutMilliseconds = 0, MigrateOptions migrateOptions = MigrateOptions.None, CommandFlags flags = CommandFlags.None) => - Inner.KeyMigrateAsync(ToInner(key), toServer, toDatabase, timeoutMilliseconds, migrateOptions, flags); - - public Task KeyMoveAsync(RedisKey key, int database, CommandFlags flags = CommandFlags.None) => - Inner.KeyMoveAsync(ToInner(key), database, flags); - - public Task KeyPersistAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyPersistAsync(ToInner(key), flags); - - public Task KeyRandomAsync(CommandFlags flags = CommandFlags.None) => - throw new NotSupportedException("RANDOMKEY is not supported when a key-prefix is specified"); - - public Task KeyRefCountAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyRefCountAsync(ToInner(key), flags); - - public Task KeyRenameAsync(RedisKey key, RedisKey newKey, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.KeyRenameAsync(ToInner(key), ToInner(newKey), when, flags); - - public Task KeyRestoreAsync(RedisKey key, byte[] value, TimeSpan? expiry = null, CommandFlags flags = CommandFlags.None) => - Inner.KeyRestoreAsync(ToInner(key), value, expiry, flags); - - public Task KeyTimeToLiveAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyTimeToLiveAsync(ToInner(key), flags); - - public Task KeyTypeAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyTypeAsync(ToInner(key), flags); - - public Task ListGetByIndexAsync(RedisKey key, long index, CommandFlags flags = CommandFlags.None) => - Inner.ListGetByIndexAsync(ToInner(key), index, flags); - - public Task ListInsertAfterAsync(RedisKey key, RedisValue pivot, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ListInsertAfterAsync(ToInner(key), pivot, value, flags); - - public Task ListInsertBeforeAsync(RedisKey key, RedisValue pivot, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ListInsertBeforeAsync(ToInner(key), pivot, value, flags); - - public Task ListLeftPopAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPopAsync(ToInner(key), flags); - - public Task ListLeftPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPopAsync(ToInner(key), count, flags); - - public Task ListLeftPopAsync(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPopAsync(ToInner(keys), count, flags); - - public Task ListPositionAsync(RedisKey key, RedisValue element, long rank = 1, long maxLength = 0, CommandFlags flags = CommandFlags.None) => - Inner.ListPositionAsync(ToInner(key), element, rank, maxLength, flags); - - public Task ListPositionsAsync(RedisKey key, RedisValue element, long count, long rank = 1, long maxLength = 0, CommandFlags flags = CommandFlags.None) => - Inner.ListPositionsAsync(ToInner(key), element, count, rank, maxLength, flags); - - public Task ListLeftPushAsync(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPushAsync(ToInner(key), values, flags); - - public Task ListLeftPushAsync(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPushAsync(ToInner(key), values, when, flags); - - public Task ListLeftPushAsync(RedisKey key, RedisValue value, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPushAsync(ToInner(key), value, when, flags); - - public Task ListLengthAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ListLengthAsync(ToInner(key), flags); - - public Task ListMoveAsync(RedisKey sourceKey, RedisKey destinationKey, ListSide sourceSide, ListSide destinationSide, CommandFlags flags = CommandFlags.None) => - Inner.ListMoveAsync(ToInner(sourceKey), ToInner(destinationKey), sourceSide, destinationSide); - - public Task ListMoveAsync(RedisKey sourceKey, RedisKey destinationKey, ListSide sourceSide, ListSide destinationSide, long count, ListMoveCount mode = ListMoveCount.UpTo, ListMoveOrder order = ListMoveOrder.Bulk, CommandFlags flags = CommandFlags.None) => - Inner.ListMoveAsync(ToInner(sourceKey), ToInner(destinationKey), sourceSide, destinationSide, count, mode, order, flags); - - public Task ListRangeAsync(RedisKey key, long start = 0, long stop = -1, CommandFlags flags = CommandFlags.None) => - Inner.ListRangeAsync(ToInner(key), start, stop, flags); - - public Task ListRemoveAsync(RedisKey key, RedisValue value, long count = 0, CommandFlags flags = CommandFlags.None) => - Inner.ListRemoveAsync(ToInner(key), value, count, flags); - - public Task ListRightPopAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPopAsync(ToInner(key), flags); - - public Task ListRightPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPopAsync(ToInner(key), count, flags); - - public Task ListRightPopAsync(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPopAsync(ToInner(keys), count, flags); - - public Task ListRightPopLeftPushAsync(RedisKey source, RedisKey destination, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPopLeftPushAsync(ToInner(source), ToInner(destination), flags); - - public Task ListRightPushAsync(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPushAsync(ToInner(key), values, flags); - - public Task ListRightPushAsync(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPushAsync(ToInner(key), values, when, flags); - - public Task ListRightPushAsync(RedisKey key, RedisValue value, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPushAsync(ToInner(key), value, when, flags); - - public Task ListSetByIndexAsync(RedisKey key, long index, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ListSetByIndexAsync(ToInner(key), index, value, flags); - - public Task ListTrimAsync(RedisKey key, long start, long stop, CommandFlags flags = CommandFlags.None) => - Inner.ListTrimAsync(ToInner(key), start, stop, flags); - - public Task LockExtendAsync(RedisKey key, RedisValue value, TimeSpan expiry, CommandFlags flags = CommandFlags.None) => - Inner.LockExtendAsync(ToInner(key), value, expiry, flags); - - public Task LockQueryAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.LockQueryAsync(ToInner(key), flags); - - public Task LockReleaseAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.LockReleaseAsync(ToInner(key), value, flags); - - public Task LockTakeAsync(RedisKey key, RedisValue value, TimeSpan expiry, CommandFlags flags = CommandFlags.None) => - Inner.LockTakeAsync(ToInner(key), value, expiry, flags); - - public Task StringLongestCommonSubsequenceAsync(RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None) => - Inner.StringLongestCommonSubsequenceAsync(ToInner(first), ToInner(second), flags); - - public Task StringLongestCommonSubsequenceLengthAsync(RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None) => - Inner.StringLongestCommonSubsequenceLengthAsync(ToInner(first), ToInner(second), flags); - - public Task StringLongestCommonSubsequenceWithMatchesAsync(RedisKey first, RedisKey second, long minLength = 0, CommandFlags flags = CommandFlags.None) => - Inner.StringLongestCommonSubsequenceWithMatchesAsync(ToInner(first), ToInner(second), minLength, flags); - - public Task PublishAsync(RedisChannel channel, RedisValue message, CommandFlags flags = CommandFlags.None) => - Inner.PublishAsync(ToInner(channel), message, flags); - - public Task ExecuteRespAsync(string command, ReadOnlyMemory args, CommandFlags flags = CommandFlags.None) - { - // the callee renders the arguments before it hands back the task, so the lease comes - // home immediately rather than being held for the whole round trip - and there is no - // fire-and-forget special case left, since that path renders too - var inner = ToInnerLease(args, out var lease); - try - { - return Inner.ExecuteRespAsync(command, inner, flags); - } - finally - { - ReturnLease(lease); - } - } - - public Task ExecuteAsync(string command, params object[] args) => - Inner.ExecuteAsync(command, ToInner(args), CommandFlags.None); - - public Task ExecuteAsync(string command, ICollection? args, CommandFlags flags = CommandFlags.None) => - Inner.ExecuteAsync(command, ToInner(args), flags); - - public Task ScriptEvaluateAsync(byte[] hash, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - Inner.ScriptEvaluateAsync(hash, ToInner(keys), values, flags); - - public Task ScriptEvaluateRespAsync(string script, ReadOnlyMemory keys, ReadOnlyMemory values, CommandFlags flags = CommandFlags.None) - { - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - // the callee renders the arguments before it hands back the task, so the lease comes - // home immediately rather than being held for the whole round trip - and there is no - // fire-and-forget special case left, since that path renders too - var inner = ToInnerLease(keys, out var lease); - try - { - return Inner.ScriptEvaluateRespAsync(script, inner, values, flags); - } - finally - { - ReturnLease(lease); - } - } - - public Task ScriptEvaluateAsync(string script, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - Inner.ScriptEvaluateAsync(script: script, keys: ToInner(keys), values: values, flags: flags); - - public Task ScriptEvaluateAsync(LuaScript script, object? parameters = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - script.EvaluateAsync(Inner, parameters, Prefix, flags); - - public Task ScriptEvaluateAsync(LoadedLuaScript script, object? parameters = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - script.EvaluateAsync(Inner, parameters, Prefix, flags); - - public Task ScriptEvaluateReadOnlyAsync(byte[] hash, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - Inner.ScriptEvaluateAsync(hash, ToInner(keys), values, flags); - - public Task ScriptEvaluateReadOnlyRespAsync(string script, ReadOnlyMemory keys, ReadOnlyMemory values, CommandFlags flags = CommandFlags.None) - { - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - // the callee renders the arguments before it hands back the task, so the lease comes - // home immediately rather than being held for the whole round trip - and there is no - // fire-and-forget special case left, since that path renders too - var inner = ToInnerLease(keys, out var lease); - try - { - return Inner.ScriptEvaluateReadOnlyRespAsync(script, inner, values, flags); - } - finally - { - ReturnLease(lease); - } - } - - public Task ScriptEvaluateReadOnlyAsync(string script, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - Inner.ScriptEvaluateAsync(script: script, keys: ToInner(keys), values: values, flags: flags); - - public Task SetAddAsync(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.SetAddAsync(ToInner(key), values, flags); - - public Task SetAddAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.SetAddAsync(ToInner(key), value, flags); - - public Task SetCombineAndStoreAsync(SetOperation operation, RedisKey destination, RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.SetCombineAndStoreAsync(operation, ToInner(destination), ToInner(keys), flags); - - public Task SetCombineAndStoreAsync(SetOperation operation, RedisKey destination, RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None) => - Inner.SetCombineAndStoreAsync(operation, ToInner(destination), ToInner(first), ToInner(second), flags); - - public Task SetCombineAsync(SetOperation operation, RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.SetCombineAsync(operation, ToInner(keys), flags); - - public Task SetCombineAsync(SetOperation operation, RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None) => - Inner.SetCombineAsync(operation, ToInner(first), ToInner(second), flags); - - public Task SetContainsAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.SetContainsAsync(ToInner(key), value, flags); - - public Task SetContainsAsync(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.SetContainsAsync(ToInner(key), values, flags); - - public Task SetIntersectionLengthAsync(RedisKey[] keys, long limit = 0, CommandFlags flags = CommandFlags.None) => - Inner.SetIntersectionLengthAsync(ToInner(keys), limit, flags); - - public Task SetCombineLengthAsync(SetOperation operation, RedisKey[] keys, long limit = 0, bool approximate = false, CommandFlags flags = CommandFlags.None) => - Inner.SetCombineLengthAsync(operation, ToInner(keys), limit, approximate, flags); - - public Task SetLengthAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.SetLengthAsync(ToInner(key), flags); - - public Task SetMembersAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.SetMembersAsync(ToInner(key), flags); - - public Task SetMoveAsync(RedisKey source, RedisKey destination, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.SetMoveAsync(ToInner(source), ToInner(destination), value, flags); - - public Task SetPopAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.SetPopAsync(ToInner(key), flags); - - public Task SetPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.SetPopAsync(ToInner(key), count, flags); - - public Task SetRandomMemberAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.SetRandomMemberAsync(ToInner(key), flags); - - public Task SetRandomMembersAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.SetRandomMembersAsync(ToInner(key), count, flags); - - public Task SetRemoveAsync(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.SetRemoveAsync(ToInner(key), values, flags); - - public IAsyncEnumerable SetScanAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => - Inner.SetScanAsync(ToInner(key), pattern, pageSize, cursor, pageOffset, flags); - - public Task SetRemoveAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.SetRemoveAsync(ToInner(key), value, flags); - - public Task SortAndStoreAsync(RedisKey destination, RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None) => - Inner.SortAndStoreAsync(ToInner(destination), ToInner(key), skip, take, order, sortType, SortByToInner(by), SortGetToInner(get), flags); - - public Task SortAsync(RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None) => - Inner.SortAsync(ToInner(key), skip, take, order, sortType, SortByToInner(by), SortGetToInner(get), flags); - - public Task SortedSetAddAsync(RedisKey key, SortedSetEntry[] values, CommandFlags flags) => - Inner.SortedSetAddAsync(ToInner(key), values, flags); - - public Task SortedSetAddAsync(RedisKey key, SortedSetEntry[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetAddAsync(ToInner(key), values, when, flags); - - public Task SortedSetAddAsync(RedisKey key, SortedSetEntry[] values, SortedSetWhen when = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetAddAsync(ToInner(key), values, when, flags); - - public Task SortedSetAddAsync(RedisKey key, RedisValue member, double score, CommandFlags flags) => - Inner.SortedSetAddAsync(ToInner(key), member, score, flags); - - public Task SortedSetAddAsync(RedisKey key, RedisValue member, double score, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetAddAsync(ToInner(key), member, score, when, flags); - - public Task SortedSetAddAsync(RedisKey key, RedisValue member, double score, SortedSetWhen when = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetAddAsync(ToInner(key), member, score, when, flags); - public Task SortedSetCombineAsync(SetOperation operation, RedisKey[] keys, double[]? weights = null, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetCombineAsync(operation, ToInner(keys), weights, aggregate, flags); - - public Task SortedSetCombineWithScoresAsync(SetOperation operation, RedisKey[] keys, double[]? weights = null, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetCombineWithScoresAsync(operation, ToInner(keys), weights, aggregate, flags); - - public Task SortedSetCombineAndStoreAsync(SetOperation operation, RedisKey destination, RedisKey[] keys, double[]? weights = null, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetCombineAndStoreAsync(operation, ToInner(destination), ToInner(keys), weights, aggregate, flags); - - public Task SortedSetCombineAndStoreAsync(SetOperation operation, RedisKey destination, RedisKey first, RedisKey second, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetCombineAndStoreAsync(operation, ToInner(destination), ToInner(first), ToInner(second), aggregate, flags); - - public Task SortedSetDecrementAsync(RedisKey key, RedisValue member, double value, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetDecrementAsync(ToInner(key), member, value, flags); - - public Task SortedSetIncrementAsync(RedisKey key, RedisValue member, double value, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetIncrementAsync(ToInner(key), member, value, flags); - - public Task SortedSetIncrementAsync(RedisKey key, RedisValue member, double value, ValueCondition when, CommandFlags flags) => - Inner.SortedSetIncrementAsync(ToInner(key), member, value, when, flags); - - public Task SortedSetIntersectionLengthAsync(RedisKey[] keys, long limit = 0, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetIntersectionLengthAsync(ToInner(keys), limit, flags); - - public Task SortedSetLengthAsync(RedisKey key, double min = -1.0 / 0.0, double max = 1.0 / 0.0, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetLengthAsync(ToInner(key), min, max, exclude, flags); - - public Task SortedSetLengthByValueAsync(RedisKey key, RedisValue min, RedisValue max, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetLengthByValueAsync(ToInner(key), min, max, exclude, flags); - - public Task SortedSetRandomMemberAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRandomMemberAsync(ToInner(key), flags); - - public Task SortedSetRandomMembersAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRandomMembersAsync(ToInner(key), count, flags); - - public Task SortedSetRandomMembersWithScoresAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRandomMembersWithScoresAsync(ToInner(key), count, flags); - - public Task SortedSetRangeAndStoreAsync( - RedisKey sourceKey, - RedisKey destinationKey, - RedisValue start, - RedisValue stop, - SortedSetOrder sortedSetOrder = SortedSetOrder.ByRank, - Exclude exclude = Exclude.None, - Order order = Order.Ascending, - long skip = 0, - long? take = null, - CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeAndStoreAsync(ToInner(sourceKey), ToInner(destinationKey), start, stop, sortedSetOrder, exclude, order, skip, take, flags); - - public Task SortedSetRangeByRankAsync(RedisKey key, long start = 0, long stop = -1, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeByRankAsync(ToInner(key), start, stop, order, flags); - - public Task SortedSetRangeByRankWithScoresAsync(RedisKey key, long start = 0, long stop = -1, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeByRankWithScoresAsync(ToInner(key), start, stop, order, flags); - - public Task SortedSetRangeByScoreAsync(RedisKey key, double start = -1.0 / 0.0, double stop = 1.0 / 0.0, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long take = -1, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeByScoreAsync(ToInner(key), start, stop, exclude, order, skip, take, flags); - - public Task SortedSetRangeByScoreWithScoresAsync(RedisKey key, double start = -1.0 / 0.0, double stop = 1.0 / 0.0, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long take = -1, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeByScoreWithScoresAsync(ToInner(key), start, stop, exclude, order, skip, take, flags); - - public Task SortedSetRangeByValueAsync(RedisKey key, RedisValue min, RedisValue max, Exclude exclude, long skip, long take, CommandFlags flags) => - Inner.SortedSetRangeByValueAsync(ToInner(key), min, max, exclude, Order.Ascending, skip, take, flags); - - public Task SortedSetRangeByValueAsync(RedisKey key, RedisValue min = default, RedisValue max = default, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long take = -1, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeByValueAsync(ToInner(key), min, max, exclude, order, skip, take, flags); - - public Task SortedSetRankAsync(RedisKey key, RedisValue member, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRankAsync(ToInner(key), member, order, flags); - - public Task SortedSetRemoveAsync(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRemoveAsync(ToInner(key), members, flags); - - public Task SortedSetRemoveAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRemoveAsync(ToInner(key), member, flags); - - public Task SortedSetRemoveRangeByRankAsync(RedisKey key, long start, long stop, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRemoveRangeByRankAsync(ToInner(key), start, stop, flags); - - public Task SortedSetRemoveRangeByScoreAsync(RedisKey key, double start, double stop, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRemoveRangeByScoreAsync(ToInner(key), start, stop, exclude, flags); - - public Task SortedSetRemoveRangeByValueAsync(RedisKey key, RedisValue min, RedisValue max, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRemoveRangeByValueAsync(ToInner(key), min, max, exclude, flags); - - public Task SortedSetScoreAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetScoreAsync(ToInner(key), member, flags); - - public Task SortedSetScoresAsync(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetScoresAsync(ToInner(key), members, flags); - - public IAsyncEnumerable SortedSetScanAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => - Inner.SortedSetScanAsync(ToInner(key), pattern, pageSize, cursor, pageOffset, flags); - - public Task SortedSetUpdateAsync(RedisKey key, SortedSetEntry[] values, SortedSetWhen when = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetUpdateAsync(ToInner(key), values, when, flags); - - public Task SortedSetUpdateAsync(RedisKey key, RedisValue member, double score, SortedSetWhen when = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetUpdateAsync(ToInner(key), member, score, when, flags); - - public Task SortedSetPopAsync(RedisKey key, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetPopAsync(ToInner(key), order, flags); - - public Task SortedSetPopAsync(RedisKey key, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetPopAsync(ToInner(key), count, order, flags); - - public Task SortedSetPopAsync(RedisKey[] keys, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetPopAsync(ToInner(keys), count, order, flags); - - public Task StreamAcknowledgeAsync(RedisKey key, RedisValue groupName, RedisValue messageId, CommandFlags flags = CommandFlags.None) => - Inner.StreamAcknowledgeAsync(ToInner(key), groupName, messageId, flags); - - public Task StreamAcknowledgeAsync(RedisKey key, RedisValue groupName, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamAcknowledgeAsync(ToInner(key), groupName, messageIds, flags); - - public Task StreamAcknowledgeAndDeleteAsync(RedisKey key, RedisValue groupName, StreamTrimMode mode, RedisValue messageId, CommandFlags flags = CommandFlags.None) => - Inner.StreamAcknowledgeAndDeleteAsync(ToInner(key), groupName, mode, messageId, flags); - - public Task StreamAcknowledgeAndDeleteAsync(RedisKey key, RedisValue groupName, StreamTrimMode mode, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamAcknowledgeAndDeleteAsync(ToInner(key), groupName, mode, messageIds, flags); - - public Task StreamNegativeAcknowledgeAsync(RedisKey key, RedisValue groupName, StreamNackMode mode, RedisValue messageId, CommandFlags flags = CommandFlags.None) => - Inner.StreamNegativeAcknowledgeAsync(ToInner(key), groupName, mode, messageId, flags); - - public Task StreamNegativeAcknowledgeAsync(RedisKey key, RedisValue groupName, StreamNackMode mode, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamNegativeAcknowledgeAsync(ToInner(key), groupName, mode, messageIds, flags); - - public Task StreamAddAsync(RedisKey key, RedisValue streamField, RedisValue streamValue, RedisValue? messageId, int? maxLength, bool useApproximateMaxLength, CommandFlags flags) => - Inner.StreamAddAsync(ToInner(key), streamField, streamValue, messageId, maxLength, useApproximateMaxLength, flags); - - public Task StreamAddAsync(RedisKey key, NameValueEntry[] streamPairs, RedisValue? messageId, int? maxLength, bool useApproximateMaxLength, CommandFlags flags) => - Inner.StreamAddAsync(ToInner(key), streamPairs, messageId, maxLength, useApproximateMaxLength, flags); - - public Task StreamAddAsync(RedisKey key, RedisValue streamField, RedisValue streamValue, RedisValue? messageId = null, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamAddAsync(ToInner(key), streamField, streamValue, messageId, maxLength, useApproximateMaxLength, limit, trimMode, flags); - - public Task StreamAddAsync(RedisKey key, NameValueEntry[] streamPairs, RedisValue? messageId = null, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamAddAsync(ToInner(key), streamPairs, messageId, maxLength, useApproximateMaxLength, limit, trimMode, flags); - - public Task StreamAddAsync(RedisKey key, RedisValue streamField, RedisValue streamValue, StreamIdempotentId idempotentId, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamAddAsync(ToInner(key), streamField, streamValue, idempotentId, maxLength, useApproximateMaxLength, limit, trimMode, flags); - - public Task StreamAddAsync(RedisKey key, NameValueEntry[] streamPairs, StreamIdempotentId idempotentId, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamAddAsync(ToInner(key), streamPairs, idempotentId, maxLength, useApproximateMaxLength, limit, trimMode, flags); - - public Task StreamAddAsync(RedisKey key, RedisValue streamField, RedisValue streamValue, StreamAddOptions options, CommandFlags flags = CommandFlags.None) => - Inner.StreamAddAsync(ToInner(key), streamField, streamValue, options, flags); - - public Task StreamAddAsync(RedisKey key, NameValueEntry[] streamPairs, StreamAddOptions options, CommandFlags flags = CommandFlags.None) => - Inner.StreamAddAsync(ToInner(key), streamPairs, options, flags); - - public Task StreamConfigureAsync(RedisKey key, StreamConfiguration configuration, CommandFlags flags = CommandFlags.None) => - Inner.StreamConfigureAsync(ToInner(key), configuration, flags); - - public Task StreamAutoClaimAsync(RedisKey key, RedisValue consumerGroup, RedisValue claimingConsumer, long minIdleTimeInMs, RedisValue startAtId, int? count = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamAutoClaimAsync(ToInner(key), consumerGroup, claimingConsumer, minIdleTimeInMs, startAtId, count, flags); - - public Task StreamAutoClaimIdsOnlyAsync(RedisKey key, RedisValue consumerGroup, RedisValue claimingConsumer, long minIdleTimeInMs, RedisValue startAtId, int? count = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamAutoClaimIdsOnlyAsync(ToInner(key), consumerGroup, claimingConsumer, minIdleTimeInMs, startAtId, count, flags); - - public Task StreamClaimAsync(RedisKey key, RedisValue consumerGroup, RedisValue claimingConsumer, long minIdleTimeInMs, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamClaimAsync(ToInner(key), consumerGroup, claimingConsumer, minIdleTimeInMs, messageIds, flags); - - public Task StreamClaimIdsOnlyAsync(RedisKey key, RedisValue consumerGroup, RedisValue claimingConsumer, long minIdleTimeInMs, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamClaimIdsOnlyAsync(ToInner(key), consumerGroup, claimingConsumer, minIdleTimeInMs, messageIds, flags); - - public Task StreamConsumerGroupSetPositionAsync(RedisKey key, RedisValue groupName, RedisValue position, CommandFlags flags = CommandFlags.None) => - Inner.StreamConsumerGroupSetPositionAsync(ToInner(key), groupName, position, flags); - - public Task StreamCreateConsumerGroupAsync(RedisKey key, RedisValue groupName, RedisValue? position, CommandFlags flags) => - Inner.StreamCreateConsumerGroupAsync(ToInner(key), groupName, position, flags); - - public Task StreamCreateConsumerGroupAsync(RedisKey key, RedisValue groupName, RedisValue? position = null, bool createStream = true, CommandFlags flags = CommandFlags.None) => - Inner.StreamCreateConsumerGroupAsync(ToInner(key), groupName, position, createStream, flags); - - public Task StreamInfoAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StreamInfoAsync(ToInner(key), flags); - - public Task StreamGroupInfoAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StreamGroupInfoAsync(ToInner(key), flags); - - public Task StreamConsumerInfoAsync(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) => - Inner.StreamConsumerInfoAsync(ToInner(key), groupName, flags); - - public Task StreamLengthAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StreamLengthAsync(ToInner(key), flags); - - public Task StreamDeleteAsync(RedisKey key, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamDeleteAsync(ToInner(key), messageIds, flags); - - public Task StreamDeleteAsync(RedisKey key, RedisValue[] messageIds, StreamTrimMode mode, CommandFlags flags = CommandFlags.None) => - Inner.StreamDeleteAsync(ToInner(key), messageIds, mode, flags); - - public Task StreamDeleteConsumerAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, CommandFlags flags = CommandFlags.None) => - Inner.StreamDeleteConsumerAsync(ToInner(key), groupName, consumerName, flags); - - public Task StreamDeleteConsumerGroupAsync(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) => - Inner.StreamDeleteConsumerGroupAsync(ToInner(key), groupName, flags); - - public Task StreamPendingAsync(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) => - Inner.StreamPendingAsync(ToInner(key), groupName, flags); - - public Task StreamPendingMessagesAsync(RedisKey key, RedisValue groupName, int count, RedisValue consumerName, RedisValue? minId, RedisValue? maxId, CommandFlags flags) => - Inner.StreamPendingMessagesAsync(ToInner(key), groupName, count, consumerName, minId, maxId, flags); - - public Task StreamPendingMessagesAsync(RedisKey key, RedisValue groupName, int count, RedisValue consumerName, RedisValue? minId = null, RedisValue? maxId = null, long? minIdleTimeInMs = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamPendingMessagesAsync(ToInner(key), groupName, count, consumerName, minId, maxId, minIdleTimeInMs, flags); - - public Task StreamRangeAsync(RedisKey key, RedisValue? minId = null, RedisValue? maxId = null, int? count = null, Order messageOrder = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.StreamRangeAsync(ToInner(key), minId, maxId, count, messageOrder, flags); - - public Task StreamReadAsync(RedisKey key, RedisValue position, int? count = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamReadAsync(ToInner(key), position, count, flags); - - public Task StreamReadAsync(StreamPosition[] streamPositions, int? countPerStream, CommandFlags flags) => - Inner.StreamReadAsync(streamPositions, countPerStream, flags); - - public Task StreamReadAsync(StreamPosition[] streamPositions, int? countPerStream = null, int? maxCount = null, int? maxSize = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamReadAsync(streamPositions, countPerStream, maxCount, maxSize, flags); - - public Task StreamReadGroupAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position, int? count, CommandFlags flags) => - Inner.StreamReadGroupAsync(ToInner(key), groupName, consumerName, position, count, flags); - - public Task StreamReadGroupAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, bool noAck = false, CommandFlags flags = CommandFlags.None) => - Inner.StreamReadGroupAsync(ToInner(key), groupName, consumerName, position, count, noAck, flags); - - public Task StreamReadGroupAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, bool noAck = false, TimeSpan? claimMinIdleTime = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamReadGroupAsync(ToInner(key), groupName, consumerName, position, count, noAck, claimMinIdleTime, flags); - - public Task StreamReadGroupAsync(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream, CommandFlags flags) => - Inner.StreamReadGroupAsync(streamPositions, groupName, consumerName, countPerStream, flags); - - public Task StreamReadGroupAsync(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, bool noAck = false, CommandFlags flags = CommandFlags.None) => - Inner.StreamReadGroupAsync(streamPositions, groupName, consumerName, countPerStream, noAck, flags); - - public Task StreamReadGroupAsync(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream, bool noAck, TimeSpan? claimMinIdleTime, CommandFlags flags) => - Inner.StreamReadGroupAsync(streamPositions, groupName, consumerName, countPerStream, noAck, claimMinIdleTime, flags); - - public Task StreamReadGroupAsync(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, bool noAck = false, TimeSpan? claimMinIdleTime = null, int? maxCount = null, int? maxSize = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamReadGroupAsync(streamPositions, groupName, consumerName, countPerStream, noAck, claimMinIdleTime, maxCount, maxSize, flags); - - public Task StreamTrimAsync(RedisKey key, int maxLength, bool useApproximateMaxLength, CommandFlags flags) => - Inner.StreamTrimAsync(ToInner(key), maxLength, useApproximateMaxLength, flags); - - public Task StreamTrimAsync(RedisKey key, long maxLength, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode mode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamTrimAsync(ToInner(key), maxLength, useApproximateMaxLength, limit, mode, flags); - - public Task StreamTrimByMinIdAsync(RedisKey key, RedisValue minId, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode mode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamTrimByMinIdAsync(ToInner(key), minId, useApproximateMaxLength, limit, mode, flags); - - public Task StringAppendAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.StringAppendAsync(ToInner(key), value, flags); - - public Task StringBitCountAsync(RedisKey key, long start, long end, CommandFlags flags) => - Inner.StringBitCountAsync(ToInner(key), start, end, flags); - - public Task StringBitCountAsync(RedisKey key, long start = 0, long end = -1, StringIndexType indexType = StringIndexType.Byte, CommandFlags flags = CommandFlags.None) => - Inner.StringBitCountAsync(ToInner(key), start, end, indexType, flags); - - public Task StringBitFieldAsync(RedisKey key, BitFieldOperation operation, CommandFlags flags = CommandFlags.None) => - Inner.StringBitFieldAsync(ToInner(key), operation, flags); - - public Task> StringBitFieldAsync(RedisKey key, ReadOnlyMemory operations, CommandFlags flags = CommandFlags.None) => - Inner.StringBitFieldAsync(ToInner(key), operations, flags); - - public Task StringBitOperationAsync(Bitwise operation, RedisKey destination, RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.StringBitOperationAsync(operation, ToInner(destination), ToInner(keys), flags); - - public Task StringBitOperationAsync(Bitwise operation, RedisKey destination, RedisKey first, RedisKey second = default, CommandFlags flags = CommandFlags.None) => - Inner.StringBitOperationAsync(operation, ToInner(destination), ToInner(first), ToInnerOrDefault(second), flags); - - public Task StringBitPositionAsync(RedisKey key, bool bit, long start, long end, CommandFlags flags) => - Inner.StringBitPositionAsync(ToInner(key), bit, start, end, flags); - - public Task StringBitPositionAsync(RedisKey key, bool bit, long start = 0, long end = -1, StringIndexType indexType = StringIndexType.Byte, CommandFlags flags = CommandFlags.None) => - Inner.StringBitPositionAsync(ToInner(key), bit, start, end, indexType, flags); - - public Task StringDeleteAsync(RedisKey key, ValueCondition when, CommandFlags flags = CommandFlags.None) => - Inner.StringDeleteAsync(ToInner(key), when, flags); - - public Task StringDecrementAsync(RedisKey key, double value, CommandFlags flags = CommandFlags.None) => - Inner.StringDecrementAsync(ToInner(key), value, flags); - - public Task StringDigestAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringDigestAsync(ToInner(key), flags); - - public Task StringDecrementAsync(RedisKey key, long value = 1, CommandFlags flags = CommandFlags.None) => - Inner.StringDecrementAsync(ToInner(key), value, flags); - - public Task StringGetAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.StringGetAsync(ToInner(keys), flags); - - public Task StringGetAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringGetAsync(ToInner(key), flags); - - public Task StringGetSetExpiryAsync(RedisKey key, TimeSpan? expiry, CommandFlags flags = CommandFlags.None) => - Inner.StringGetSetExpiryAsync(ToInner(key), expiry, flags); - - public Task StringGetSetExpiryAsync(RedisKey key, DateTime expiry, CommandFlags flags = CommandFlags.None) => - Inner.StringGetSetExpiryAsync(ToInner(key), expiry, flags); - - public Task?> StringGetLeaseAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringGetLeaseAsync(ToInner(key), flags); - - public Task StringGetBitAsync(RedisKey key, long offset, CommandFlags flags = CommandFlags.None) => - Inner.StringGetBitAsync(ToInner(key), offset, flags); - - public Task StringGetRangeAsync(RedisKey key, long start, long end, CommandFlags flags = CommandFlags.None) => - Inner.StringGetRangeAsync(ToInner(key), start, end, flags); - - public Task StringGetSetAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.StringGetSetAsync(ToInner(key), value, flags); - - public Task StringGetDeleteAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringGetDeleteAsync(ToInner(key), flags); - - public Task StringGetWithExpiryAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringGetWithExpiryAsync(ToInner(key), flags); - - public Task StringIncrementAsync(RedisKey key, double value, CommandFlags flags = CommandFlags.None) => - Inner.StringIncrementAsync(ToInner(key), value, flags); - - public Task StringIncrementAsync(RedisKey key, long value = 1, CommandFlags flags = CommandFlags.None) => - Inner.StringIncrementAsync(ToInner(key), value, flags); - - public Task> StringIncrementAsync(RedisKey key, double value, Expiration expiry, double? lowerBound = null, double? upperBound = null, IncrementOptions options = IncrementOptions.None, CommandFlags flags = CommandFlags.None) => - Inner.StringIncrementAsync(ToInner(key), value, expiry, lowerBound, upperBound, options, flags); - - public Task> StringIncrementAsync(RedisKey key, long value, Expiration expiry, long? lowerBound = null, long? upperBound = null, IncrementOptions options = IncrementOptions.None, CommandFlags flags = CommandFlags.None) => - Inner.StringIncrementAsync(ToInner(key), value, expiry, lowerBound, upperBound, options, flags); - - public Task StringLengthAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringLengthAsync(ToInner(key), flags); - - public Task StringSetAsync(RedisKey key, RedisValue value, Expiration expiry, ValueCondition when, CommandFlags flags = CommandFlags.None) - => Inner.StringSetAsync(ToInner(key), value, expiry, when, flags); - - public Task StringSetAsync(KeyValuePair[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.StringSetAsync(ToInner(values), when, flags); - - public Task StringSetAsync(KeyValuePair[] values, When when, Expiration expiry, CommandFlags flags) => - Inner.StringSetAsync(ToInner(values), when, expiry, flags); - - public Task StringSetAsync(RedisKey key, RedisValue value, TimeSpan? expiry, When when) => - Inner.StringSetAsync(ToInner(key), value, expiry, when); - public Task StringSetAsync(RedisKey key, RedisValue value, TimeSpan? expiry, When when, CommandFlags flags) => - Inner.StringSetAsync(ToInner(key), value, expiry, when, flags); - public Task StringSetAsync(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.StringSetAsync(ToInner(key), value, expiry, keepTtl, when, flags); - - public Task StringSetAndGetAsync(RedisKey key, RedisValue value, TimeSpan? expiry, When when, CommandFlags flags) => - Inner.StringSetAndGetAsync(ToInner(key), value, expiry, when, flags); - - public Task StringSetAndGetAsync(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.StringSetAndGetAsync(ToInner(key), value, expiry, keepTtl, when, flags); - - public Task StringSetBitAsync(RedisKey key, long offset, bool bit, CommandFlags flags = CommandFlags.None) => - Inner.StringSetBitAsync(ToInner(key), offset, bit, flags); - - public Task StringSetRangeAsync(RedisKey key, long offset, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.StringSetRangeAsync(ToInner(key), offset, value, flags); - - public Task PingAsync(CommandFlags flags = CommandFlags.None) => - Inner.PingAsync(flags); - - public Task KeyTouchAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.KeyTouchAsync(ToInner(keys), flags); - - public Task KeyTouchAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyTouchAsync(ToInner(key), flags); - - public bool TryWait(Task task) => - // forwarding is not using: these decorators must implement the interface in full, and the - // implementation cannot be dropped while the interface declares it - #pragma warning disable SER308 // Blocking on a task through the library's Wait helpers - Inner.TryWait(task); - - public TResult Wait(Task task) => - Inner.Wait(task); - - public void Wait(Task task) => - Inner.Wait(task); - - public void WaitAll(params Task[] tasks) => - Inner.WaitAll(tasks); - #pragma warning restore SER308 - - protected internal RedisKey ToInner(RedisKey outer) => - RedisKey.WithPrefix(Prefix, outer); - - protected RedisKey ToInnerOrDefault(RedisKey outer) => - (outer == default(RedisKey)) ? outer : ToInner(outer); - - [return: NotNullIfNotNull("args")] - protected ICollection? ToInner(ICollection? args) - { - if (args?.Any(x => x is RedisKey || x is RedisChannel) == true) - { - var withPrefix = new object[args.Count]; - int i = 0; - foreach (var oldArg in args) - { - object newArg; - if (oldArg is RedisKey key) - { - newArg = ToInner(key); - } - else if (oldArg is RedisChannel channel) - { - newArg = ToInner(channel); - } - else - { - newArg = oldArg; - } - withPrefix[i++] = newArg; - } - args = withPrefix; - } - return args; - } - - protected ReadOnlyMemory ToInnerCopy(ReadOnlyMemory outer) - { - if (outer.Length > 0) - { - RedisKeyOrValue[] inner = []; - - var span = outer.Span; - var i = 0; - foreach (ref readonly var item in span) - { - var key = item.Key; - if (!key.IsNull) - { - inner = new RedisKeyOrValue[outer.Length]; - inner[i] = ToInner(key); - span.Slice(0, i).CopyTo(inner); - break; - } - i++; - } - - if (inner.Length > 0) - { - i++; - foreach (ref readonly var item in span.Slice(i)) - { - var key = item.Key; - inner[i++] = key.IsNull ? item : ToInner(key); - } - - return inner; - } - } - - return outer; - } - - protected ReadOnlyMemory ToInnerLease(ReadOnlyMemory outer, out RedisKeyOrValue[]? lease) - { - lease = null; - var length = outer.Length; - if (length > 0) - { - var span = outer.Span; - var i = 0; - foreach (ref readonly var item in span) - { - var key = item.Key; - if (!key.IsNull) - { - lease = ArrayPool.Shared.Rent(length); - lease[i] = ToInner(key); - span.Slice(0, i).CopyTo(lease); - break; - } - i++; - } - - if (lease != null) - { - i++; - foreach (ref readonly var item in span.Slice(i)) - { - var key = item.Key; - lease[i++] = key.IsNull ? item : ToInner(key); - } - - return lease.AsMemory(0, length); - } - } - - return outer; - } - - // the pooled buffer can only be recycled once we know the server has fully received and - // processed the write; success and RedisServerException both give that guarantee (the latter - // is still a server response, just an error one) - other exceptions (timeouts, connection - // failures) may mean the write is still in flight for a retry, so the buffer must survive. - private static async Task ReturnAfterResult(Task task, TElement[] lease) - { - var returnLease = true; - try - { - return await task; - } - catch (RedisServerException) - { - throw; - } - catch - { - returnLease = false; - throw; - } - finally - { - if (returnLease) ArrayPool.Shared.Return(lease, clearArray: true); - } - } - - // sync counterpart of ReturnAfterResult - see that method for the return-eligibility rationale. - // takes state + a (typically static) delegate rather than a capturing lambda, so callers can - // avoid allocating a closure and delegate per call; TState carries what the delegate needs - // instead (plain struct, not ValueTuple - this type still targets net461/netstandard2.0). - - /// - /// Hand a rented argument buffer back. Safe to call with null, which is what - /// ToInnerLease reports when there was nothing worth renting for. - /// - /// - /// Unconditional on purpose. The APIs this is used for render their arguments before returning, so - /// there is no longer any question of the callee reading the buffer later - which is what the old - /// shape had to guard against by abandoning the lease whenever an unexpected exception made the - /// answer unknowable. - /// - /// The element type of the rented buffer. - /// The buffer to return, if any. - protected static void ReturnLease(TElement[]? lease) - { - if (lease is not null) ArrayPool.Shared.Return(lease, clearArray: true); - } - - protected ReadOnlyMemory ToInnerCopy(ReadOnlyMemory outer) - { - if (outer.Length == 0) return outer; - - var inner = new RedisKey[outer.Length]; - var span = outer.Span; - for (int i = 0; i < span.Length; i++) - { - inner[i] = ToInner(span[i]); - } - return inner; - } - - protected ReadOnlyMemory ToInnerLease(ReadOnlyMemory outer, out RedisKey[]? lease) - { - if (outer.Length == 0) - { - lease = null; - return outer; - } - - lease = ArrayPool.Shared.Rent(outer.Length); - var span = outer.Span; - for (int i = 0; i < span.Length; i++) - { - lease[i] = ToInner(span[i]); - } - return lease.AsMemory(0, outer.Length); - } - - [return: NotNullIfNotNull("outer")] - protected RedisKey[]? ToInner(RedisKey[]? outer) - { - if (outer == null || outer.Length == 0) - { - return outer; - } - else - { - RedisKey[] inner = new RedisKey[outer.Length]; - - for (int i = 0; i < outer.Length; ++i) - { - inner[i] = ToInner(outer[i]); - } - - return inner; - } - } - - protected KeyValuePair ToInner(KeyValuePair outer) => - new KeyValuePair(ToInner(outer.Key), outer.Value); - - [return: NotNullIfNotNull("outer")] - protected KeyValuePair[]? ToInner(KeyValuePair[]? outer) - { - if (outer == null || outer.Length == 0) - { - return outer; - } - else - { - KeyValuePair[] inner = new KeyValuePair[outer.Length]; - - for (int i = 0; i < outer.Length; ++i) - { - inner[i] = ToInner(outer[i]); - } - - return inner; - } - } - - protected RedisValue ToInner(RedisValue outer) => - RedisKey.ConcatenateBytes(Prefix, null, (byte[]?)outer); - - protected RedisValue SortByToInner(RedisValue outer) => - (outer == RedisLiterals.nosort) ? outer : ToInner(outer); - - protected RedisValue SortGetToInner(RedisValue outer) => - (outer == RedisLiterals.HashSymbol) ? outer : ToInner(outer); - - [return: NotNullIfNotNull("outer")] - protected RedisValue[]? SortGetToInner(RedisValue[]? outer) - { - if (outer == null || outer.Length == 0) - { - return outer; - } - else - { - RedisValue[] inner = new RedisValue[outer.Length]; - - for (int i = 0; i < outer.Length; ++i) - { - inner[i] = SortGetToInner(outer[i]); - } - - return inner; - } - } - - protected RedisChannel ToInner(RedisChannel outer) - { - var combined = RedisKey.ConcatenateBytes(Prefix, null, (byte[]?)outer); - return new RedisChannel(combined, outer.IsPattern ? RedisChannel.PatternMode.Pattern : RedisChannel.PatternMode.Literal); - } - - private Func? mapFunction; - protected Func GetMapFunction() => - // create as a delegate when first required, then re-use - mapFunction ??= new Func(ToInner); - } -} diff --git a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedBatch.cs b/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedBatch.cs deleted file mode 100644 index 710e8cabdf..0000000000 --- a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedBatch.cs +++ /dev/null @@ -1,16 +0,0 @@ -using StackExchange.Redis.Interfaces; - -namespace StackExchange.Redis.KeyspaceIsolation -{ - internal sealed class KeyPrefixedBatch : KeyPrefixed, IBatch - { - public KeyPrefixedBatch(IBatch inner, byte[] prefix) : base(inner, prefix) - { - } - - private protected override DatabaseFeatureFlags GetDatabaseFeatures() - => base.GetDatabaseFeatures() | DatabaseFeatureFlags.Batch; - - public void Execute() => Inner.Execute(); - } -} diff --git a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.Arrays.cs b/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.Arrays.cs deleted file mode 100644 index 3d9f0f03e3..0000000000 --- a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.Arrays.cs +++ /dev/null @@ -1,74 +0,0 @@ -// ReSharper disable once CheckNamespace -namespace StackExchange.Redis.KeyspaceIsolation; - -internal sealed partial class KeyPrefixedDatabase -{ - public bool ArraySet(RedisKey key, RedisArrayIndex index, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ArraySet(ToInner(key), index, value, flags); - - public int ArraySet(RedisKey key, RedisArrayIndex index, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.ArraySet(ToInner(key), index, values, flags); - - public int ArraySet(RedisKey key, RedisArrayEntry[] values, CommandFlags flags = CommandFlags.None) => - Inner.ArraySet(ToInner(key), values, flags); - - public RedisValue ArrayGet(RedisKey key, RedisArrayIndex index, CommandFlags flags = CommandFlags.None) => - Inner.ArrayGet(ToInner(key), index, flags); - - public RedisValue[] ArrayGet(RedisKey key, RedisArrayIndex[] indices, CommandFlags flags = CommandFlags.None) => - Inner.ArrayGet(ToInner(key), indices, flags); - - public RedisValue[] ArrayGetRange(RedisKey key, RedisArrayIndex start, RedisArrayIndex end, CommandFlags flags = CommandFlags.None) => - Inner.ArrayGetRange(ToInner(key), start, end, flags); - - public RedisArrayIndex ArrayLength(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ArrayLength(ToInner(key), flags); - - public RedisArrayIndex ArrayCount(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ArrayCount(ToInner(key), flags); - - public bool ArrayDelete(RedisKey key, RedisArrayIndex index, CommandFlags flags = CommandFlags.None) => - Inner.ArrayDelete(ToInner(key), index, flags); - - public int ArrayDelete(RedisKey key, RedisArrayIndex[] indices, CommandFlags flags = CommandFlags.None) => - Inner.ArrayDelete(ToInner(key), indices, flags); - - public RedisArrayIndex ArrayDeleteRange(RedisKey key, RedisArrayIndex start, RedisArrayIndex end, CommandFlags flags = CommandFlags.None) => - Inner.ArrayDeleteRange(ToInner(key), start, end, flags); - - public RedisArrayIndex ArrayDeleteRange(RedisKey key, RedisArrayRange[] ranges, CommandFlags flags = CommandFlags.None) => - Inner.ArrayDeleteRange(ToInner(key), ranges, flags); - - public RedisArrayEntry[] ArrayScan(RedisKey key, RedisArrayIndex start, RedisArrayIndex end, int limit = 0, CommandFlags flags = CommandFlags.None) => - Inner.ArrayScan(ToInner(key), start, end, limit, flags); - - public RedisArrayEntry[] ArrayGrep(RedisKey key, ArrayGrepRequest request, CommandFlags flags = CommandFlags.None) => - Inner.ArrayGrep(ToInner(key), request, flags); - - public RedisValue ArrayOperation(RedisKey key, RedisArrayIndex start, RedisArrayIndex end, ArrayOperation operation, RedisValue operand = default, CommandFlags flags = CommandFlags.None) => - Inner.ArrayOperation(ToInner(key), start, end, operation, operand, flags); - - public RedisArrayIndex ArrayRing(RedisKey key, RedisArrayIndex maxLength, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ArrayRing(ToInner(key), maxLength, value, flags); - - public RedisArrayIndex ArrayRing(RedisKey key, RedisArrayIndex maxLength, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.ArrayRing(ToInner(key), maxLength, values, flags); - - public RedisArrayIndex? ArrayNext(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ArrayNext(ToInner(key), flags); - - public RedisArrayIndex ArrayInsert(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ArrayInsert(ToInner(key), value, flags); - - public RedisArrayIndex ArrayInsert(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.ArrayInsert(ToInner(key), values, flags); - - public bool ArraySeek(RedisKey key, RedisArrayIndex index, CommandFlags flags = CommandFlags.None) => - Inner.ArraySeek(ToInner(key), index, flags); - - public RedisValue[] ArrayLastItems(RedisKey key, int count, bool reverse = false, CommandFlags flags = CommandFlags.None) => - Inner.ArrayLastItems(ToInner(key), count, reverse, flags); - - public ArrayInfo ArrayInfo(RedisKey key, bool full = false, CommandFlags flags = CommandFlags.None) => - Inner.ArrayInfo(ToInner(key), full, flags); -} diff --git a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.VectorSets.cs b/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.VectorSets.cs deleted file mode 100644 index 0d025dc6c4..0000000000 --- a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.VectorSets.cs +++ /dev/null @@ -1,72 +0,0 @@ -// ReSharper disable once CheckNamespace -namespace StackExchange.Redis.KeyspaceIsolation; - -internal sealed partial class KeyPrefixedDatabase -{ - // Vector Set operations - public bool VectorSetAdd( - RedisKey key, - VectorSetAddRequest request, - CommandFlags flags = CommandFlags.None) => - Inner.VectorSetAdd(ToInner(key), request, flags); - - public long VectorSetLength(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetLength(ToInner(key), flags); - - public int VectorSetDimension(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetDimension(ToInner(key), flags); - - public Lease? VectorSetGetApproximateVector(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetGetApproximateVector(ToInner(key), member, flags); - - public string? VectorSetGetAttributesJson(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetGetAttributesJson(ToInner(key), member, flags); - - public VectorSetInfo? VectorSetInfo(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetInfo(ToInner(key), flags); - - public bool VectorSetContains(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetContains(ToInner(key), member, flags); - - public Lease? VectorSetGetLinks(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetGetLinks(ToInner(key), member, flags); - - public Lease? VectorSetGetLinksWithScores(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetGetLinksWithScores(ToInner(key), member, flags); - - public RedisValue VectorSetRandomMember(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetRandomMember(ToInner(key), flags); - - public RedisValue[] VectorSetRandomMembers(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetRandomMembers(ToInner(key), count, flags); - - public bool VectorSetRemove(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetRemove(ToInner(key), member, flags); - - public bool VectorSetSetAttributesJson(RedisKey key, RedisValue member, string attributesJson, CommandFlags flags = CommandFlags.None) => - Inner.VectorSetSetAttributesJson(ToInner(key), member, attributesJson, flags); - - public Lease? VectorSetSimilaritySearch( - RedisKey key, - VectorSetSimilaritySearchRequest query, - CommandFlags flags = CommandFlags.None) => - Inner.VectorSetSimilaritySearch(ToInner(key), query, flags); - - public Lease VectorSetRange( - RedisKey key, - RedisValue start = default, - RedisValue end = default, - long count = -1, - Exclude exclude = Exclude.None, - CommandFlags flags = CommandFlags.None) => - Inner.VectorSetRange(ToInner(key), start, end, count, exclude, flags); - - public System.Collections.Generic.IEnumerable VectorSetRangeEnumerate( - RedisKey key, - RedisValue start = default, - RedisValue end = default, - long count = 100, - Exclude exclude = Exclude.None, - CommandFlags flags = CommandFlags.None) => - Inner.VectorSetRangeEnumerate(ToInner(key), start, end, count, exclude, flags); -} diff --git a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.cs b/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.cs deleted file mode 100644 index 8ca3bca485..0000000000 --- a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.cs +++ /dev/null @@ -1,935 +0,0 @@ -using System; -using System.Buffers; -using System.Collections.Generic; -using System.Net; -using StackExchange.Redis.Interfaces; - -namespace StackExchange.Redis.KeyspaceIsolation -{ - internal sealed partial class KeyPrefixedDatabase : KeyPrefixed, IDatabase - { - public KeyPrefixedDatabase(IDatabase inner, byte[] prefix) : base(inner, prefix) - { - } - - public IBatch CreateBatch(object? asyncState = null) - { - // reject nesting based on *this* database (the thing being wrapped), not the freshly - // created inner batch - which trivially carries the Batch flag and would always trip - this.RejectFlags(DatabaseFeatureFlags.Batch | DatabaseFeatureFlags.Transaction); - return new KeyPrefixedBatch(Inner.CreateBatch(asyncState), Prefix); - } - - public ITransaction CreateTransaction(object? asyncState = null) - { - this.RejectFlags(DatabaseFeatureFlags.Batch | DatabaseFeatureFlags.Transaction); - return new KeyPrefixedTransaction(Inner.CreateTransaction(asyncState), Prefix); - } - - // reimplement the async-only IDatabaseAsync slot (the base throws); we prefix a real transaction - ITransactionAsync IDatabaseAsync.CreateTransaction(object? asyncState) => CreateTransaction(asyncState); - - public RedisValue DebugObject(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.DebugObject(ToInner(key), flags); - - public bool GeoAdd(RedisKey key, double longitude, double latitude, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.GeoAdd(ToInner(key), longitude, latitude, member, flags); - - public long GeoAdd(RedisKey key, GeoEntry[] values, CommandFlags flags = CommandFlags.None) => - Inner.GeoAdd(ToInner(key), values, flags); - - public bool GeoAdd(RedisKey key, GeoEntry value, CommandFlags flags = CommandFlags.None) => - Inner.GeoAdd(ToInner(key), value, flags); - - public bool GeoRemove(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.GeoRemove(ToInner(key), member, flags); - - public double? GeoDistance(RedisKey key, RedisValue member1, RedisValue member2, GeoUnit unit = GeoUnit.Meters, CommandFlags flags = CommandFlags.None) => - Inner.GeoDistance(ToInner(key), member1, member2, unit, flags); - - public string?[] GeoHash(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None) => - Inner.GeoHash(ToInner(key), members, flags); - - public string? GeoHash(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.GeoHash(ToInner(key), member, flags); - - public GeoPosition?[] GeoPosition(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None) => - Inner.GeoPosition(ToInner(key), members, flags); - - public GeoPosition? GeoPosition(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.GeoPosition(ToInner(key), member, flags); - - public GeoRadiusResult[] GeoRadius(RedisKey key, RedisValue member, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => - Inner.GeoRadius(ToInner(key), member, radius, unit, count, order, options, flags); - - public GeoRadiusResult[] GeoRadius(RedisKey key, double longitude, double latitude, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => - Inner.GeoRadius(ToInner(key), longitude, latitude, radius, unit, count, order, options, flags); - - public GeoRadiusResult[] GeoSearch(RedisKey key, RedisValue member, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => - Inner.GeoSearch(ToInner(key), member, shape, count, demandClosest, order, options, flags); - - public GeoRadiusResult[] GeoSearch(RedisKey key, double longitude, double latitude, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => - Inner.GeoSearch(ToInner(key), longitude, latitude, shape, count, demandClosest, order, options, flags); - - public long GeoSearchAndStore(RedisKey sourceKey, RedisKey destinationKey, RedisValue member, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, bool storeDistances = false, CommandFlags flags = CommandFlags.None) => - Inner.GeoSearchAndStore(ToInner(sourceKey), ToInner(destinationKey), member, shape, count, demandClosest, order, storeDistances, flags); - - public long GeoSearchAndStore(RedisKey sourceKey, RedisKey destinationKey, double longitude, double latitude, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, bool storeDistances = false, CommandFlags flags = CommandFlags.None) => - Inner.GeoSearchAndStore(ToInner(sourceKey), ToInner(destinationKey), longitude, latitude, shape, count, demandClosest, order, storeDistances, flags); - - public double HashDecrement(RedisKey key, RedisValue hashField, double value, CommandFlags flags = CommandFlags.None) => - Inner.HashDecrement(ToInner(key), hashField, value, flags); - - public long HashDecrement(RedisKey key, RedisValue hashField, long value = 1, CommandFlags flags = CommandFlags.None) => - Inner.HashDecrement(ToInner(key), hashField, value, flags); - - public long HashDelete(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None) => - Inner.HashDelete(ToInner(key), hashFields, flags); - - public bool HashDelete(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashDelete(ToInner(key), hashField, flags); - - public bool HashExists(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashExists(ToInner(key), hashField, flags); - - public RedisValue HashFieldGetAndDelete(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndDelete(ToInner(key), hashField, flags); - - public Lease? HashFieldGetLeaseAndDelete(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetLeaseAndDelete(ToInner(key), hashField, flags); - - public RedisValue[] HashFieldGetAndDelete(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndDelete(ToInner(key), hashFields, flags); - - public RedisValue HashFieldGetAndSetExpiry(RedisKey key, RedisValue hashField, TimeSpan? expiry = null, bool persist = false, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndSetExpiry(ToInner(key), hashField, expiry, persist, flags); - - public RedisValue HashFieldGetAndSetExpiry(RedisKey key, RedisValue hashField, DateTime expiry, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndSetExpiry(ToInner(key), hashField, expiry, flags); - - public Lease? HashFieldGetLeaseAndSetExpiry(RedisKey key, RedisValue hashField, TimeSpan? expiry = null, bool persist = false, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetLeaseAndSetExpiry(ToInner(key), hashField, expiry, persist, flags); - - public Lease? HashFieldGetLeaseAndSetExpiry(RedisKey key, RedisValue hashField, DateTime expiry, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetLeaseAndSetExpiry(ToInner(key), hashField, expiry, flags); - - public RedisValue[] HashFieldGetAndSetExpiry(RedisKey key, RedisValue[] hashFields, TimeSpan? expiry = null, bool persist = false, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndSetExpiry(ToInner(key), hashFields, expiry, persist, flags); - - public RedisValue[] HashFieldGetAndSetExpiry(RedisKey key, RedisValue[] hashFields, DateTime expiry, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldGetAndSetExpiry(ToInner(key), hashFields, expiry, flags); - - public RedisValue HashFieldSetAndSetExpiry(RedisKey key, RedisValue field, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldSetAndSetExpiry(ToInner(key), field, value, expiry, keepTtl, when, flags); - - public RedisValue HashFieldSetAndSetExpiry(RedisKey key, RedisValue field, RedisValue value, DateTime expiry, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldSetAndSetExpiry(ToInner(key), field, value, expiry, when, flags); - - public RedisValue HashFieldSetAndSetExpiry(RedisKey key, HashEntry[] hashFields, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldSetAndSetExpiry(ToInner(key), hashFields, expiry, keepTtl, when, flags); - - public RedisValue HashFieldSetAndSetExpiry(RedisKey key, HashEntry[] hashFields, DateTime expiry, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldSetAndSetExpiry(ToInner(key), hashFields, expiry, when, flags); - - public ExpireResult[] HashFieldExpire(RedisKey key, RedisValue[] hashFields, TimeSpan expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldExpire(ToInner(key), hashFields, expiry, when, flags); - - public ExpireResult[] HashFieldExpire(RedisKey key, RedisValue[] hashFields, DateTime expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashFieldExpire(ToInner(key), hashFields, expiry, when, flags); - - public long[] HashFieldGetExpireDateTime(RedisKey key, RedisValue[] hashFields, CommandFlags flags) => - Inner.HashFieldGetExpireDateTime(ToInner(key), hashFields, flags); - - public PersistResult[] HashFieldPersist(RedisKey key, RedisValue[] hashFields, CommandFlags flags) => - Inner.HashFieldPersist(ToInner(key), hashFields, flags); - - public long[] HashFieldGetTimeToLive(RedisKey key, RedisValue[] hashFields, CommandFlags flags) => - Inner.HashFieldGetTimeToLive(ToInner(key), hashFields, flags); - - public HashEntry[] HashGetAll(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HashGetAll(ToInner(key), flags); - - public RedisValue[] HashGet(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None) => - Inner.HashGet(ToInner(key), hashFields, flags); - - public RedisValue HashGet(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashGet(ToInner(key), hashField, flags); - - public Lease? HashGetLease(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashGetLease(ToInner(key), hashField, flags); - - public double HashIncrement(RedisKey key, RedisValue hashField, double value, CommandFlags flags = CommandFlags.None) => - Inner.HashIncrement(ToInner(key), hashField, value, flags); - - public long HashIncrement(RedisKey key, RedisValue hashField, long value = 1, CommandFlags flags = CommandFlags.None) => - Inner.HashIncrement(ToInner(key), hashField, value, flags); - - public RedisValue[] HashKeys(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HashKeys(ToInner(key), flags); - - public long HashLength(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HashLength(ToInner(key), flags); - - public RedisValue HashRandomField(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HashRandomField(ToInner(key), flags); - - public RedisValue[] HashRandomFields(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.HashRandomFields(ToInner(key), count, flags); - - public HashEntry[] HashRandomFieldsWithValues(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.HashRandomFieldsWithValues(ToInner(key), count, flags); - - public bool HashSet(RedisKey key, RedisValue hashField, RedisValue value, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.HashSet(ToInner(key), hashField, value, when, flags); - - public long HashStringLength(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) => - Inner.HashStringLength(ToInner(key), hashField, flags); - - public void HashImport(RedisKey key, HashImport fieldSet, ReadOnlyMemory values, CommandFlags flags = CommandFlags.None) => - Inner.HashImport(ToInner(key), fieldSet, values, flags); - - public void HashSet(RedisKey key, HashEntry[] hashFields, CommandFlags flags = CommandFlags.None) => - Inner.HashSet(ToInner(key), hashFields, flags); - - public RedisValue[] HashValues(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HashValues(ToInner(key), flags); - - public bool HyperLogLogAdd(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogAdd(ToInner(key), values, flags); - - public bool HyperLogLogAdd(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogAdd(ToInner(key), value, flags); - - public long HyperLogLogLength(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogLength(ToInner(key), flags); - - public long HyperLogLogLength(RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogLength(ToInner(keys), flags); - - public void HyperLogLogMerge(RedisKey destination, RedisKey[] sourceKeys, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogMerge(ToInner(destination), ToInner(sourceKeys), flags); - - public void HyperLogLogMerge(RedisKey destination, RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None) => - Inner.HyperLogLogMerge(ToInner(destination), ToInner(first), ToInner(second), flags); - - public EndPoint? IdentifyEndpoint(RedisKey key = default, CommandFlags flags = CommandFlags.None) => - Inner.IdentifyEndpoint(ToInner(key), flags); - - public bool KeyCopy(RedisKey sourceKey, RedisKey destinationKey, int destinationDatabase = -1, bool replace = false, CommandFlags flags = CommandFlags.None) => - Inner.KeyCopy(ToInner(sourceKey), ToInner(destinationKey), destinationDatabase, replace, flags); - - public long KeyDelete(RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.KeyDelete(ToInner(keys), flags); - - public bool KeyDelete(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyDelete(ToInner(key), flags); - - public byte[]? KeyDump(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyDump(ToInner(key), flags); - - public string? KeyEncoding(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyEncoding(ToInner(key), flags); - - public bool KeyExists(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyExists(ToInner(key), flags); - public long KeyExists(RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.KeyExists(ToInner(keys), flags); - - public bool KeyExpire(RedisKey key, DateTime? expiry, CommandFlags flags) => - Inner.KeyExpire(ToInner(key), expiry, flags); - - public bool KeyExpire(RedisKey key, DateTime? expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.KeyExpire(ToInner(key), expiry, when, flags); - - public bool KeyExpire(RedisKey key, TimeSpan? expiry, CommandFlags flags) => - Inner.KeyExpire(ToInner(key), expiry, flags); - - public bool KeyExpire(RedisKey key, TimeSpan? expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.KeyExpire(ToInner(key), expiry, when, flags); - - public DateTime? KeyExpireTime(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyExpireTime(ToInner(key), flags); - - public long? KeyFrequency(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyFrequency(ToInner(key), flags); - - public TimeSpan? KeyIdleTime(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyIdleTime(ToInner(key), flags); - - public void KeyMigrate(RedisKey key, EndPoint toServer, int toDatabase = 0, int timeoutMilliseconds = 0, MigrateOptions migrateOptions = MigrateOptions.None, CommandFlags flags = CommandFlags.None) => - Inner.KeyMigrate(ToInner(key), toServer, toDatabase, timeoutMilliseconds, migrateOptions, flags); - - public bool KeyMove(RedisKey key, int database, CommandFlags flags = CommandFlags.None) => - Inner.KeyMove(ToInner(key), database, flags); - - public bool KeyPersist(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyPersist(ToInner(key), flags); - - public RedisKey KeyRandom(CommandFlags flags = CommandFlags.None) => - throw new NotSupportedException("RANDOMKEY is not supported when a key-prefix is specified"); - - public long? KeyRefCount(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyRefCount(ToInner(key), flags); - - public bool KeyRename(RedisKey key, RedisKey newKey, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.KeyRename(ToInner(key), ToInner(newKey), when, flags); - - public void KeyRestore(RedisKey key, byte[] value, TimeSpan? expiry = null, CommandFlags flags = CommandFlags.None) => - Inner.KeyRestore(ToInner(key), value, expiry, flags); - - public TimeSpan? KeyTimeToLive(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyTimeToLive(ToInner(key), flags); - - public RedisType KeyType(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyType(ToInner(key), flags); - - public RedisValue ListGetByIndex(RedisKey key, long index, CommandFlags flags = CommandFlags.None) => - Inner.ListGetByIndex(ToInner(key), index, flags); - - public long ListInsertAfter(RedisKey key, RedisValue pivot, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ListInsertAfter(ToInner(key), pivot, value, flags); - - public long ListInsertBefore(RedisKey key, RedisValue pivot, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ListInsertBefore(ToInner(key), pivot, value, flags); - - public RedisValue ListLeftPop(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPop(ToInner(key), flags); - - public RedisValue[] ListLeftPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPop(ToInner(key), count, flags); - - public ListPopResult ListLeftPop(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPop(ToInner(keys), count, flags); - - public long ListPosition(RedisKey key, RedisValue element, long rank = 1, long maxLength = 0, CommandFlags flags = CommandFlags.None) => - Inner.ListPosition(ToInner(key), element, rank, maxLength, flags); - - public long[] ListPositions(RedisKey key, RedisValue element, long count, long rank = 1, long maxLength = 0, CommandFlags flags = CommandFlags.None) => - Inner.ListPositions(ToInner(key), element, count, rank, maxLength, flags); - - public long ListLeftPush(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPush(ToInner(key), values, flags); - - public long ListLeftPush(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPush(ToInner(key), values, when, flags); - - public long ListLeftPush(RedisKey key, RedisValue value, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.ListLeftPush(ToInner(key), value, when, flags); - - public long ListLength(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ListLength(ToInner(key), flags); - - public RedisValue ListMove(RedisKey sourceKey, RedisKey destinationKey, ListSide sourceSide, ListSide destinationSide, CommandFlags flags = CommandFlags.None) => - Inner.ListMove(ToInner(sourceKey), ToInner(destinationKey), sourceSide, destinationSide); - - public RedisValue[]? ListMove(RedisKey sourceKey, RedisKey destinationKey, ListSide sourceSide, ListSide destinationSide, long count, ListMoveCount mode = ListMoveCount.UpTo, ListMoveOrder order = ListMoveOrder.Bulk, CommandFlags flags = CommandFlags.None) => - Inner.ListMove(ToInner(sourceKey), ToInner(destinationKey), sourceSide, destinationSide, count, mode, order, flags); - - public RedisValue[] ListRange(RedisKey key, long start = 0, long stop = -1, CommandFlags flags = CommandFlags.None) => - Inner.ListRange(ToInner(key), start, stop, flags); - - public long ListRemove(RedisKey key, RedisValue value, long count = 0, CommandFlags flags = CommandFlags.None) => - Inner.ListRemove(ToInner(key), value, count, flags); - - public RedisValue ListRightPop(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPop(ToInner(key), flags); - - public RedisValue[] ListRightPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPop(ToInner(key), count, flags); - - public ListPopResult ListRightPop(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPop(ToInner(keys), count, flags); - - public RedisValue ListRightPopLeftPush(RedisKey source, RedisKey destination, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPopLeftPush(ToInner(source), ToInner(destination), flags); - - public long ListRightPush(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPush(ToInner(key), values, flags); - - public long ListRightPush(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPush(ToInner(key), values, when, flags); - - public long ListRightPush(RedisKey key, RedisValue value, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.ListRightPush(ToInner(key), value, when, flags); - - public void ListSetByIndex(RedisKey key, long index, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.ListSetByIndex(ToInner(key), index, value, flags); - - public void ListTrim(RedisKey key, long start, long stop, CommandFlags flags = CommandFlags.None) => - Inner.ListTrim(ToInner(key), start, stop, flags); - - public bool LockExtend(RedisKey key, RedisValue value, TimeSpan expiry, CommandFlags flags = CommandFlags.None) => - Inner.LockExtend(ToInner(key), value, expiry, flags); - - public RedisValue LockQuery(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.LockQuery(ToInner(key), flags); - - public bool LockRelease(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.LockRelease(ToInner(key), value, flags); - - public bool LockTake(RedisKey key, RedisValue value, TimeSpan expiry, CommandFlags flags = CommandFlags.None) => - Inner.LockTake(ToInner(key), value, expiry, flags); - - public string? StringLongestCommonSubsequence(RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None) => - Inner.StringLongestCommonSubsequence(ToInner(first), ToInner(second), flags); - - public long StringLongestCommonSubsequenceLength(RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None) => - Inner.StringLongestCommonSubsequenceLength(ToInner(first), ToInner(second), flags); - - public LCSMatchResult StringLongestCommonSubsequenceWithMatches(RedisKey first, RedisKey second, long minLength = 0, CommandFlags flags = CommandFlags.None) => - Inner.StringLongestCommonSubsequenceWithMatches(ToInner(first), ToInner(second), minLength, flags); - - public long Publish(RedisChannel channel, RedisValue message, CommandFlags flags = CommandFlags.None) => - Inner.Publish(ToInner(channel), message, flags); - - public RespResult ExecuteResp(string command, ReadOnlyMemory args, CommandFlags flags = CommandFlags.None) - { - // the callee renders the arguments before it returns, so the lease is ours again the moment - // the call comes back - however it comes back. No fire-and-forget special case (that path - // renders too, it just does not wait for a reply) and no suppressing the return on unexpected - // exceptions, which is what the old shape had to do when it could not know. - var inner = ToInnerLease(args, out var lease); - try - { - return Inner.ExecuteResp(command, inner, flags); - } - finally - { - ReturnLease(lease); - } - } - - public RedisResult Execute(string command, params object[] args) - => Inner.Execute(command, ToInner(args), CommandFlags.None); - - public RedisResult Execute(string command, ICollection args, CommandFlags flags = CommandFlags.None) - => Inner.Execute(command, ToInner(args), flags); - - public RedisResult ScriptEvaluate(byte[] hash, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - Inner.ScriptEvaluate(hash, ToInner(keys), values, flags); - - public RespResult ScriptEvaluateResp(string script, ReadOnlyMemory keys, ReadOnlyMemory values, CommandFlags flags = CommandFlags.None) - { - // note the Resp API explicitly doesn't unprefix keys - // see ExecuteResp - var inner = ToInnerLease(keys, out var lease); - try - { - return Inner.ScriptEvaluateResp(script, inner, values, flags); - } - finally - { - ReturnLease(lease); - } - } - - public RedisResult ScriptEvaluate(string script, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - Inner.ScriptEvaluate(script: script, keys: ToInner(keys), values: values, flags: flags); - - public RedisResult ScriptEvaluate(LuaScript script, object? parameters = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - script.Evaluate(Inner, parameters, Prefix, flags); - - public RedisResult ScriptEvaluate(LoadedLuaScript script, object? parameters = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - script.Evaluate(Inner, parameters, Prefix, flags); - - public RedisResult ScriptEvaluateReadOnly(byte[] hash, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - Inner.ScriptEvaluateReadOnly(hash, ToInner(keys), values, flags); - - public RespResult ScriptEvaluateReadOnlyResp(string script, ReadOnlyMemory keys, ReadOnlyMemory values, CommandFlags flags = CommandFlags.None) - { - // note the Resp API explicitly doesn't unprefix keys - // see ExecuteResp - var inner = ToInnerLease(keys, out var lease); - try - { - return Inner.ScriptEvaluateReadOnlyResp(script, inner, values, flags); - } - finally - { - ReturnLease(lease); - } - } - - public RedisResult ScriptEvaluateReadOnly(string script, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None) => - // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those? - Inner.ScriptEvaluateReadOnly(script, ToInner(keys), values, flags); - - public long SetAdd(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.SetAdd(ToInner(key), values, flags); - - public bool SetAdd(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.SetAdd(ToInner(key), value, flags); - - public long SetCombineAndStore(SetOperation operation, RedisKey destination, RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.SetCombineAndStore(operation, ToInner(destination), ToInner(keys), flags); - - public long SetCombineAndStore(SetOperation operation, RedisKey destination, RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None) => - Inner.SetCombineAndStore(operation, ToInner(destination), ToInner(first), ToInner(second), flags); - - public RedisValue[] SetCombine(SetOperation operation, RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.SetCombine(operation, ToInner(keys), flags); - - public RedisValue[] SetCombine(SetOperation operation, RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None) => - Inner.SetCombine(operation, ToInner(first), ToInner(second), flags); - - public bool SetContains(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.SetContains(ToInner(key), value, flags); - - public bool[] SetContains(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.SetContains(ToInner(key), values, flags); - - public long SetIntersectionLength(RedisKey[] keys, long limit = 0, CommandFlags flags = CommandFlags.None) => - Inner.SetIntersectionLength(ToInner(keys), limit, flags); - - public long SetCombineLength(SetOperation operation, RedisKey[] keys, long limit = 0, bool approximate = false, CommandFlags flags = CommandFlags.None) => - Inner.SetCombineLength(operation, ToInner(keys), limit, approximate, flags); - - public long SetLength(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.SetLength(ToInner(key), flags); - - public RedisValue[] SetMembers(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.SetMembers(ToInner(key), flags); - - public bool SetMove(RedisKey source, RedisKey destination, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.SetMove(ToInner(source), ToInner(destination), value, flags); - - public RedisValue SetPop(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.SetPop(ToInner(key), flags); - - public RedisValue[] SetPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.SetPop(ToInner(key), count, flags); - - public RedisValue SetRandomMember(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.SetRandomMember(ToInner(key), flags); - - public RedisValue[] SetRandomMembers(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.SetRandomMembers(ToInner(key), count, flags); - - public long SetRemove(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None) => - Inner.SetRemove(ToInner(key), values, flags); - - public bool SetRemove(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.SetRemove(ToInner(key), value, flags); - - public long SortAndStore(RedisKey destination, RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None) => - Inner.SortAndStore(ToInner(destination), ToInner(key), skip, take, order, sortType, SortByToInner(by), SortGetToInner(get), flags); - - public RedisValue[] Sort(RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None) => - Inner.Sort(ToInner(key), skip, take, order, sortType, SortByToInner(by), SortGetToInner(get), flags); - - public long SortedSetAdd(RedisKey key, SortedSetEntry[] values, CommandFlags flags) => - Inner.SortedSetAdd(ToInner(key), values, flags); - - public long SortedSetAdd(RedisKey key, SortedSetEntry[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetAdd(ToInner(key), values, when, flags); - - public long SortedSetAdd(RedisKey key, SortedSetEntry[] values, SortedSetWhen when = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetAdd(ToInner(key), values, when, flags); - - public bool SortedSetAdd(RedisKey key, RedisValue member, double score, CommandFlags flags) => - Inner.SortedSetAdd(ToInner(key), member, score, flags); - - public bool SortedSetAdd(RedisKey key, RedisValue member, double score, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetAdd(ToInner(key), member, score, when, flags); - - public bool SortedSetAdd(RedisKey key, RedisValue member, double score, SortedSetWhen when = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetAdd(ToInner(key), member, score, when, flags); - - public RedisValue[] SortedSetCombine(SetOperation operation, RedisKey[] keys, double[]? weights = null, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetCombine(operation, ToInner(keys), weights, aggregate, flags); - - public SortedSetEntry[] SortedSetCombineWithScores(SetOperation operation, RedisKey[] keys, double[]? weights = null, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetCombineWithScores(operation, ToInner(keys), weights, aggregate, flags); - - public long SortedSetCombineAndStore(SetOperation operation, RedisKey destination, RedisKey[] keys, double[]? weights = null, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetCombineAndStore(operation, ToInner(destination), ToInner(keys), weights, aggregate, flags); - - public long SortedSetCombineAndStore(SetOperation operation, RedisKey destination, RedisKey first, RedisKey second, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetCombineAndStore(operation, ToInner(destination), ToInner(first), ToInner(second), aggregate, flags); - - public double SortedSetDecrement(RedisKey key, RedisValue member, double value, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetDecrement(ToInner(key), member, value, flags); - - public double SortedSetIncrement(RedisKey key, RedisValue member, double value, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetIncrement(ToInner(key), member, value, flags); - - public double? SortedSetIncrement(RedisKey key, RedisValue member, double value, ValueCondition when, CommandFlags flags) => - Inner.SortedSetIncrement(ToInner(key), member, value, when, flags); - - public long SortedSetIntersectionLength(RedisKey[] keys, long limit = 0, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetIntersectionLength(ToInner(keys), limit, flags); - - public long SortedSetLength(RedisKey key, double min = -1.0 / 0.0, double max = 1.0 / 0.0, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetLength(ToInner(key), min, max, exclude, flags); - - public long SortedSetLengthByValue(RedisKey key, RedisValue min, RedisValue max, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetLengthByValue(ToInner(key), min, max, exclude, flags); - - public RedisValue SortedSetRandomMember(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRandomMember(ToInner(key), flags); - - public RedisValue[] SortedSetRandomMembers(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRandomMembers(ToInner(key), count, flags); - - public SortedSetEntry[] SortedSetRandomMembersWithScores(RedisKey key, long count, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRandomMembersWithScores(ToInner(key), count, flags); - - public RedisValue[] SortedSetRangeByRank(RedisKey key, long start = 0, long stop = -1, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeByRank(ToInner(key), start, stop, order, flags); - - public long SortedSetRangeAndStore( - RedisKey sourceKey, - RedisKey destinationKey, - RedisValue start, - RedisValue stop, - SortedSetOrder sortedSetOrder = SortedSetOrder.ByRank, - Exclude exclude = Exclude.None, - Order order = Order.Ascending, - long skip = 0, - long? take = null, - CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeAndStore(ToInner(sourceKey), ToInner(destinationKey), start, stop, sortedSetOrder, exclude, order, skip, take, flags); - - public SortedSetEntry[] SortedSetRangeByRankWithScores(RedisKey key, long start = 0, long stop = -1, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeByRankWithScores(ToInner(key), start, stop, order, flags); - - public RedisValue[] SortedSetRangeByScore(RedisKey key, double start = -1.0 / 0.0, double stop = 1.0 / 0.0, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long take = -1, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeByScore(ToInner(key), start, stop, exclude, order, skip, take, flags); - - public SortedSetEntry[] SortedSetRangeByScoreWithScores(RedisKey key, double start = -1.0 / 0.0, double stop = 1.0 / 0.0, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long take = -1, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeByScoreWithScores(ToInner(key), start, stop, exclude, order, skip, take, flags); - - public RedisValue[] SortedSetRangeByValue(RedisKey key, RedisValue min, RedisValue max, Exclude exclude, long skip, long take, CommandFlags flags) => - Inner.SortedSetRangeByValue(ToInner(key), min, max, exclude, Order.Ascending, skip, take, flags); - - public RedisValue[] SortedSetRangeByValue(RedisKey key, RedisValue min = default, RedisValue max = default, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long take = -1, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRangeByValue(ToInner(key), min, max, exclude, order, skip, take, flags); - - public long? SortedSetRank(RedisKey key, RedisValue member, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRank(ToInner(key), member, order, flags); - - public long SortedSetRemove(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRemove(ToInner(key), members, flags); - - public bool SortedSetRemove(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRemove(ToInner(key), member, flags); - - public long SortedSetRemoveRangeByRank(RedisKey key, long start, long stop, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRemoveRangeByRank(ToInner(key), start, stop, flags); - - public long SortedSetRemoveRangeByScore(RedisKey key, double start, double stop, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRemoveRangeByScore(ToInner(key), start, stop, exclude, flags); - - public long SortedSetRemoveRangeByValue(RedisKey key, RedisValue min, RedisValue max, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetRemoveRangeByValue(ToInner(key), min, max, exclude, flags); - - public double? SortedSetScore(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetScore(ToInner(key), member, flags); - - public double?[] SortedSetScores(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetScores(ToInner(key), members, flags); - - public long SortedSetUpdate(RedisKey key, SortedSetEntry[] values, SortedSetWhen when = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetUpdate(ToInner(key), values, when, flags); - - public bool SortedSetUpdate(RedisKey key, RedisValue member, double score, SortedSetWhen when = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetUpdate(ToInner(key), member, score, when, flags); - - public SortedSetEntry? SortedSetPop(RedisKey key, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetPop(ToInner(key), order, flags); - - public SortedSetEntry[] SortedSetPop(RedisKey key, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetPop(ToInner(key), count, order, flags); - - public SortedSetPopResult SortedSetPop(RedisKey[] keys, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.SortedSetPop(ToInner(keys), count, order, flags); - - public long StreamAcknowledge(RedisKey key, RedisValue groupName, RedisValue messageId, CommandFlags flags = CommandFlags.None) => - Inner.StreamAcknowledge(ToInner(key), groupName, messageId, flags); - - public long StreamAcknowledge(RedisKey key, RedisValue groupName, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamAcknowledge(ToInner(key), groupName, messageIds, flags); - - public StreamTrimResult StreamAcknowledgeAndDelete(RedisKey key, RedisValue groupName, StreamTrimMode mode, RedisValue messageId, CommandFlags flags = CommandFlags.None) => - Inner.StreamAcknowledgeAndDelete(ToInner(key), groupName, mode, messageId, flags); - - public StreamTrimResult[] StreamAcknowledgeAndDelete(RedisKey key, RedisValue groupName, StreamTrimMode mode, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamAcknowledgeAndDelete(ToInner(key), groupName, mode, messageIds, flags); - - public long StreamNegativeAcknowledge(RedisKey key, RedisValue groupName, StreamNackMode mode, RedisValue messageId, CommandFlags flags = CommandFlags.None) => - Inner.StreamNegativeAcknowledge(ToInner(key), groupName, mode, messageId, flags); - - public long StreamNegativeAcknowledge(RedisKey key, RedisValue groupName, StreamNackMode mode, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamNegativeAcknowledge(ToInner(key), groupName, mode, messageIds, flags); - - public RedisValue StreamAdd(RedisKey key, RedisValue streamField, RedisValue streamValue, RedisValue? messageId, int? maxLength, bool useApproximateMaxLength, CommandFlags flags) => - Inner.StreamAdd(ToInner(key), streamField, streamValue, messageId, maxLength, useApproximateMaxLength, flags); - - public RedisValue StreamAdd(RedisKey key, NameValueEntry[] streamPairs, RedisValue? messageId, int? maxLength, bool useApproximateMaxLength, CommandFlags flags) => - Inner.StreamAdd(ToInner(key), streamPairs, messageId, maxLength, useApproximateMaxLength, flags); - - public RedisValue StreamAdd(RedisKey key, RedisValue streamField, RedisValue streamValue, RedisValue? messageId = null, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamAdd(ToInner(key), streamField, streamValue, messageId, maxLength, useApproximateMaxLength, limit, trimMode, flags); - - public RedisValue StreamAdd(RedisKey key, NameValueEntry[] streamPairs, RedisValue? messageId = null, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamAdd(ToInner(key), streamPairs, messageId, maxLength, useApproximateMaxLength, limit, trimMode, flags); - - public RedisValue StreamAdd(RedisKey key, RedisValue streamField, RedisValue streamValue, StreamIdempotentId idempotentId, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamAdd(ToInner(key), streamField, streamValue, idempotentId, maxLength, useApproximateMaxLength, limit, trimMode, flags); - - public RedisValue StreamAdd(RedisKey key, NameValueEntry[] streamPairs, StreamIdempotentId idempotentId, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamAdd(ToInner(key), streamPairs, idempotentId, maxLength, useApproximateMaxLength, limit, trimMode, flags); - - public RedisValue StreamAdd(RedisKey key, RedisValue streamField, RedisValue streamValue, StreamAddOptions options, CommandFlags flags = CommandFlags.None) => - Inner.StreamAdd(ToInner(key), streamField, streamValue, options, flags); - - public RedisValue StreamAdd(RedisKey key, NameValueEntry[] streamPairs, StreamAddOptions options, CommandFlags flags = CommandFlags.None) => - Inner.StreamAdd(ToInner(key), streamPairs, options, flags); - - public void StreamConfigure(RedisKey key, StreamConfiguration configuration, CommandFlags flags = CommandFlags.None) => - Inner.StreamConfigure(ToInner(key), configuration, flags); - - public StreamAutoClaimResult StreamAutoClaim(RedisKey key, RedisValue consumerGroup, RedisValue claimingConsumer, long minIdleTimeInMs, RedisValue startAtId, int? count = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamAutoClaim(ToInner(key), consumerGroup, claimingConsumer, minIdleTimeInMs, startAtId, count, flags); - - public StreamAutoClaimIdsOnlyResult StreamAutoClaimIdsOnly(RedisKey key, RedisValue consumerGroup, RedisValue claimingConsumer, long minIdleTimeInMs, RedisValue startAtId, int? count = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamAutoClaimIdsOnly(ToInner(key), consumerGroup, claimingConsumer, minIdleTimeInMs, startAtId, count, flags); - - public StreamEntry[] StreamClaim(RedisKey key, RedisValue consumerGroup, RedisValue claimingConsumer, long minIdleTimeInMs, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamClaim(ToInner(key), consumerGroup, claimingConsumer, minIdleTimeInMs, messageIds, flags); - - public RedisValue[] StreamClaimIdsOnly(RedisKey key, RedisValue consumerGroup, RedisValue claimingConsumer, long minIdleTimeInMs, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamClaimIdsOnly(ToInner(key), consumerGroup, claimingConsumer, minIdleTimeInMs, messageIds, flags); - - public bool StreamConsumerGroupSetPosition(RedisKey key, RedisValue groupName, RedisValue position, CommandFlags flags = CommandFlags.None) => - Inner.StreamConsumerGroupSetPosition(ToInner(key), groupName, position, flags); - - public bool StreamCreateConsumerGroup(RedisKey key, RedisValue groupName, RedisValue? position, CommandFlags flags) => - Inner.StreamCreateConsumerGroup(ToInner(key), groupName, position, flags); - - public bool StreamCreateConsumerGroup(RedisKey key, RedisValue groupName, RedisValue? position = null, bool createStream = true, CommandFlags flags = CommandFlags.None) => - Inner.StreamCreateConsumerGroup(ToInner(key), groupName, position, createStream, flags); - - public StreamInfo StreamInfo(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StreamInfo(ToInner(key), flags); - - public StreamGroupInfo[] StreamGroupInfo(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StreamGroupInfo(ToInner(key), flags); - - public StreamConsumerInfo[] StreamConsumerInfo(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) => - Inner.StreamConsumerInfo(ToInner(key), groupName, flags); - - public long StreamLength(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StreamLength(ToInner(key), flags); - - public long StreamDelete(RedisKey key, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) => - Inner.StreamDelete(ToInner(key), messageIds, flags); - - public StreamTrimResult[] StreamDelete(RedisKey key, RedisValue[] messageIds, StreamTrimMode mode, CommandFlags flags = CommandFlags.None) => - Inner.StreamDelete(ToInner(key), messageIds, mode, flags); - - public long StreamDeleteConsumer(RedisKey key, RedisValue groupName, RedisValue consumerName, CommandFlags flags = CommandFlags.None) => - Inner.StreamDeleteConsumer(ToInner(key), groupName, consumerName, flags); - - public bool StreamDeleteConsumerGroup(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) => - Inner.StreamDeleteConsumerGroup(ToInner(key), groupName, flags); - - public StreamPendingInfo StreamPending(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) => - Inner.StreamPending(ToInner(key), groupName, flags); - - public StreamPendingMessageInfo[] StreamPendingMessages(RedisKey key, RedisValue groupName, int count, RedisValue consumerName, RedisValue? minId, RedisValue? maxId, CommandFlags flags) => - Inner.StreamPendingMessages(ToInner(key), groupName, count, consumerName, minId, maxId, flags); - - public StreamPendingMessageInfo[] StreamPendingMessages(RedisKey key, RedisValue groupName, int count, RedisValue consumerName, RedisValue? minId = null, RedisValue? maxId = null, long? minIdleTimeInMs = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamPendingMessages(ToInner(key), groupName, count, consumerName, minId, maxId, minIdleTimeInMs, flags); - - public StreamEntry[] StreamRange(RedisKey key, RedisValue? minId = null, RedisValue? maxId = null, int? count = null, Order messageOrder = Order.Ascending, CommandFlags flags = CommandFlags.None) => - Inner.StreamRange(ToInner(key), minId, maxId, count, messageOrder, flags); - - public StreamEntry[] StreamRead(RedisKey key, RedisValue position, int? count = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamRead(ToInner(key), position, count, flags); - - public RedisStream[] StreamRead(StreamPosition[] streamPositions, int? countPerStream, CommandFlags flags) => - Inner.StreamRead(streamPositions, countPerStream, flags); - - public RedisStream[] StreamRead(StreamPosition[] streamPositions, int? countPerStream = null, int? maxCount = null, int? maxSize = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamRead(streamPositions, countPerStream, maxCount, maxSize, flags); - - public StreamEntry[] StreamReadGroup(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position, int? count, CommandFlags flags) => - Inner.StreamReadGroup(ToInner(key), groupName, consumerName, position, count, flags); - - public StreamEntry[] StreamReadGroup(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, bool noAck = false, CommandFlags flags = CommandFlags.None) => - Inner.StreamReadGroup(ToInner(key), groupName, consumerName, position, count, noAck, flags); - - public StreamEntry[] StreamReadGroup(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, bool noAck = false, TimeSpan? claimMinIdleTime = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamReadGroup(ToInner(key), groupName, consumerName, position, count, noAck, claimMinIdleTime, flags); - - public RedisStream[] StreamReadGroup(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream, CommandFlags flags) => - Inner.StreamReadGroup(streamPositions, groupName, consumerName, countPerStream, flags); - - public RedisStream[] StreamReadGroup(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, bool noAck = false, CommandFlags flags = CommandFlags.None) => - Inner.StreamReadGroup(streamPositions, groupName, consumerName, countPerStream, noAck, flags); - - public RedisStream[] StreamReadGroup(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream, bool noAck, TimeSpan? claimMinIdleTime, CommandFlags flags) => - Inner.StreamReadGroup(streamPositions, groupName, consumerName, countPerStream, noAck, claimMinIdleTime, flags); - - public RedisStream[] StreamReadGroup(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, bool noAck = false, TimeSpan? claimMinIdleTime = null, int? maxCount = null, int? maxSize = null, CommandFlags flags = CommandFlags.None) => - Inner.StreamReadGroup(streamPositions, groupName, consumerName, countPerStream, noAck, claimMinIdleTime, maxCount, maxSize, flags); - - public long StreamTrim(RedisKey key, int maxLength, bool useApproximateMaxLength, CommandFlags flags) => - Inner.StreamTrim(ToInner(key), maxLength, useApproximateMaxLength, flags); - - public long StreamTrim(RedisKey key, long maxLength, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode mode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamTrim(ToInner(key), maxLength, useApproximateMaxLength, limit, mode, flags); - - public long StreamTrimByMinId(RedisKey key, RedisValue minId, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode mode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None) => - Inner.StreamTrimByMinId(ToInner(key), minId, useApproximateMaxLength, limit, mode, flags); - - public long StringAppend(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.StringAppend(ToInner(key), value, flags); - - public long StringBitCount(RedisKey key, long start, long end, CommandFlags flags) => - Inner.StringBitCount(ToInner(key), start, end, flags); - - public long StringBitCount(RedisKey key, long start = 0, long end = -1, StringIndexType indexType = StringIndexType.Byte, CommandFlags flags = CommandFlags.None) => - Inner.StringBitCount(ToInner(key), start, end, indexType, flags); - - public long? StringBitField(RedisKey key, BitFieldOperation operation, CommandFlags flags = CommandFlags.None) => - Inner.StringBitField(ToInner(key), operation, flags); - - public Lease StringBitField(RedisKey key, ReadOnlyMemory operations, CommandFlags flags = CommandFlags.None) => - Inner.StringBitField(ToInner(key), operations, flags); - - public long StringBitOperation(Bitwise operation, RedisKey destination, RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.StringBitOperation(operation, ToInner(destination), ToInner(keys), flags); - - public long StringBitOperation(Bitwise operation, RedisKey destination, RedisKey first, RedisKey second = default, CommandFlags flags = CommandFlags.None) => - Inner.StringBitOperation(operation, ToInner(destination), ToInner(first), ToInnerOrDefault(second), flags); - - public long StringBitPosition(RedisKey key, bool bit, long start, long end, CommandFlags flags) => - Inner.StringBitPosition(ToInner(key), bit, start, end, flags); - - public long StringBitPosition(RedisKey key, bool bit, long start = 0, long end = -1, StringIndexType indexType = StringIndexType.Byte, CommandFlags flags = CommandFlags.None) => - Inner.StringBitPosition(ToInner(key), bit, start, end, indexType, flags); - - public bool StringDelete(RedisKey key, ValueCondition when, CommandFlags flags = CommandFlags.None) => - Inner.StringDelete(ToInner(key), when, flags); - - public double StringDecrement(RedisKey key, double value, CommandFlags flags = CommandFlags.None) => - Inner.StringDecrement(ToInner(key), value, flags); - - public ValueCondition? StringDigest(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringDigest(ToInner(key), flags); - - public long StringDecrement(RedisKey key, long value = 1, CommandFlags flags = CommandFlags.None) => - Inner.StringDecrement(ToInner(key), value, flags); - - public RedisValue[] StringGet(RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.StringGet(ToInner(keys), flags); - - public RedisValue StringGet(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringGet(ToInner(key), flags); - - public RedisValue StringGetSetExpiry(RedisKey key, TimeSpan? expiry, CommandFlags flags = CommandFlags.None) => - Inner.StringGetSetExpiry(ToInner(key), expiry, flags); - - public RedisValue StringGetSetExpiry(RedisKey key, DateTime expiry, CommandFlags flags = CommandFlags.None) => - Inner.StringGetSetExpiry(ToInner(key), expiry, flags); - - public Lease? StringGetLease(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringGetLease(ToInner(key), flags); - - public bool StringGetBit(RedisKey key, long offset, CommandFlags flags = CommandFlags.None) => - Inner.StringGetBit(ToInner(key), offset, flags); - - public RedisValue StringGetRange(RedisKey key, long start, long end, CommandFlags flags = CommandFlags.None) => - Inner.StringGetRange(ToInner(key), start, end, flags); - - public RedisValue StringGetSet(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.StringGetSet(ToInner(key), value, flags); - - public RedisValue StringGetDelete(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringGetDelete(ToInner(key), flags); - - public RedisValueWithExpiry StringGetWithExpiry(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringGetWithExpiry(ToInner(key), flags); - - public double StringIncrement(RedisKey key, double value, CommandFlags flags = CommandFlags.None) => - Inner.StringIncrement(ToInner(key), value, flags); - - public long StringIncrement(RedisKey key, long value = 1, CommandFlags flags = CommandFlags.None) => - Inner.StringIncrement(ToInner(key), value, flags); - - public StringIncrementResult StringIncrement(RedisKey key, double value, Expiration expiry, double? lowerBound = null, double? upperBound = null, IncrementOptions options = IncrementOptions.None, CommandFlags flags = CommandFlags.None) => - Inner.StringIncrement(ToInner(key), value, expiry, lowerBound, upperBound, options, flags); - - public StringIncrementResult StringIncrement(RedisKey key, long value, Expiration expiry, long? lowerBound = null, long? upperBound = null, IncrementOptions options = IncrementOptions.None, CommandFlags flags = CommandFlags.None) => - Inner.StringIncrement(ToInner(key), value, expiry, lowerBound, upperBound, options, flags); - - public long StringLength(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.StringLength(ToInner(key), flags); - - public bool StringSet(RedisKey key, RedisValue value, Expiration expiry, ValueCondition when, CommandFlags flags = CommandFlags.None) - => Inner.StringSet(ToInner(key), value, expiry, when, flags); - - public bool StringSet(KeyValuePair[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.StringSet(ToInner(values), when, flags); - - public bool StringSet(KeyValuePair[] values, When when, Expiration expiry, CommandFlags flags) => - Inner.StringSet(ToInner(values), when, expiry, flags); - - public bool StringSet(RedisKey key, RedisValue value, TimeSpan? expiry, When when) => - Inner.StringSet(ToInner(key), value, expiry, when); - public bool StringSet(RedisKey key, RedisValue value, TimeSpan? expiry, When when, CommandFlags flags) => - Inner.StringSet(ToInner(key), value, expiry, when, flags); - public bool StringSet(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.StringSet(ToInner(key), value, expiry, keepTtl, when, flags); - - public RedisValue StringSetAndGet(RedisKey key, RedisValue value, TimeSpan? expiry, When when, CommandFlags flags) => - Inner.StringSetAndGet(ToInner(key), value, expiry, when, flags); - - public RedisValue StringSetAndGet(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) => - Inner.StringSetAndGet(ToInner(key), value, expiry, keepTtl, when, flags); - - public bool StringSetBit(RedisKey key, long offset, bool bit, CommandFlags flags = CommandFlags.None) => - Inner.StringSetBit(ToInner(key), offset, bit, flags); - - public RedisValue StringSetRange(RedisKey key, long offset, RedisValue value, CommandFlags flags = CommandFlags.None) => - Inner.StringSetRange(ToInner(key), offset, value, flags); - - public TimeSpan Ping(CommandFlags flags = CommandFlags.None) => - Inner.Ping(flags); - - IEnumerable IDatabase.HashScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) - => Inner.HashScan(ToInner(key), pattern, pageSize, flags); - - IEnumerable IDatabase.HashScan(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) - => Inner.HashScan(ToInner(key), pattern, pageSize, cursor, pageOffset, flags); - - IEnumerable IDatabase.HashScanNoValues(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) - => Inner.HashScanNoValues(ToInner(key), pattern, pageSize, cursor, pageOffset, flags); - - IEnumerable IDatabase.SetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) - => Inner.SetScan(ToInner(key), pattern, pageSize, flags); - - IEnumerable IDatabase.SetScan(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) - => Inner.SetScan(ToInner(key), pattern, pageSize, cursor, pageOffset, flags); - - IEnumerable IDatabase.SortedSetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags) - => Inner.SortedSetScan(ToInner(key), pattern, pageSize, flags); - - IEnumerable IDatabase.SortedSetScan(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) - => Inner.SortedSetScan(ToInner(key), pattern, pageSize, cursor, pageOffset, flags); - - public bool KeyTouch(RedisKey key, CommandFlags flags = CommandFlags.None) => - Inner.KeyTouch(ToInner(key), flags); - - public long KeyTouch(RedisKey[] keys, CommandFlags flags = CommandFlags.None) => - Inner.KeyTouch(ToInner(keys), flags); - } -} diff --git a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedTransaction.cs b/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedTransaction.cs deleted file mode 100644 index 3658d65ee9..0000000000 --- a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedTransaction.cs +++ /dev/null @@ -1,29 +0,0 @@ -using System.Threading.Tasks; -using StackExchange.Redis.Interfaces; - -namespace StackExchange.Redis.KeyspaceIsolation -{ - internal sealed class KeyPrefixedTransaction : KeyPrefixed, ITransaction, IInternalTransaction - { - public KeyPrefixedTransaction(ITransaction inner, byte[] prefix) : base(inner, prefix) - { - } - - private protected override DatabaseFeatureFlags GetDatabaseFeatures() - => base.GetDatabaseFeatures() | DatabaseFeatureFlags.Transaction; - - CommandFlags IInternalTransaction.GetAggregateRetryCategory() - => Inner is IInternalTransaction it ? it.GetAggregateRetryCategory() : CommandFlags.CommandRetryNever; - - /// - public bool WasWatchConflict => Inner.WasWatchConflict; - - public ConditionResult AddCondition(Condition condition) => Inner.AddCondition(condition.MapKeys(GetMapFunction())); - - public bool Execute(CommandFlags flags = CommandFlags.None) => Inner.Execute(flags); - - public Task ExecuteAsync(CommandFlags flags = CommandFlags.None) => Inner.ExecuteAsync(flags); - - public void Execute() => Inner.Execute(); - } -} diff --git a/src/StackExchange.Redis/RedisKey.cs b/src/StackExchange.Redis/RedisKey.cs index 31abd7c9aa..b7c0b2d9d5 100644 --- a/src/StackExchange.Redis/RedisKey.cs +++ b/src/StackExchange.Redis/RedisKey.cs @@ -23,8 +23,6 @@ internal RedisKey(byte[]? keyPrefix, object? keyValue) /// public RedisKey(string? key) : this(null, key) { } - internal RedisKey AsPrefix() => new RedisKey((byte[]?)this, null); - internal bool IsNull => KeyPrefix == null && KeyValue == null; internal static RedisKey Null { get; } = new RedisKey(null, null); diff --git a/tests/StackExchange.Redis.Tests/AvailabilityConfigTests.cs b/tests/StackExchange.Redis.Tests/AvailabilityConfigTests.cs index 4894f30fdf..417a81c4e0 100644 --- a/tests/StackExchange.Redis.Tests/AvailabilityConfigTests.cs +++ b/tests/StackExchange.Redis.Tests/AvailabilityConfigTests.cs @@ -329,8 +329,9 @@ public async Task WithRetry_UsesConfiguredPolicyForASingleConnection() config.AbortOnConnectFail = false; await using var muxer = await ConnectionMultiplexer.ConnectAsync(config); - var retrying = Assert.IsType(muxer.GetDatabase().WithRetry()); - Assert.Same(configured, retrying.Policy); + var retrying = muxer.GetDatabase().WithRetry(); + var executor = Assert.IsType(retrying.Context.Raw.Executor); + Assert.Same(configured, executor.Policy); } [Fact] @@ -340,8 +341,9 @@ public async Task WithRetry_FallsBackToDefaultWhenNoneConfigured() config.AbortOnConnectFail = false; await using var muxer = await ConnectionMultiplexer.ConnectAsync(config); - var retrying = Assert.IsType(muxer.GetDatabase().WithRetry()); - Assert.Same(RetryPolicy.Default, retrying.Policy); + var retrying = muxer.GetDatabase().WithRetry(); + var executor = Assert.IsType(retrying.Context.Raw.Executor); + Assert.Same(RetryPolicy.Default, executor.Policy); } // ---- the context's multiplexer, and WithRetry() on a context ---- diff --git a/tests/StackExchange.Redis.Tests/DatabaseSurfaceTests.cs b/tests/StackExchange.Redis.Tests/DatabaseSurfaceTests.cs index 371a8180a5..6b77d1269c 100644 --- a/tests/StackExchange.Redis.Tests/DatabaseSurfaceTests.cs +++ b/tests/StackExchange.Redis.Tests/DatabaseSurfaceTests.cs @@ -218,13 +218,13 @@ public void NothingIsGeneratedForTheRedisDatabaseAnyMore() /// "nothing is generated" means nothing is generated rather than "the query stopped working". /// /// - /// is [AutoDatabase(Replays = true)] and is generated + /// RetryTransaction is [AutoDatabase(Replays = true)] and is generated /// on purpose - capture-and-replay wrappers are what the generator is for, and it keeps that /// job after the transitional database stops needing it. So this control cannot go stale by being /// right, which is how the previous one kept failing. /// [Fact] public void TheGeneratedQueryCanStillSeeAGeneratedMember() - => Assert.NotEmpty(Generated(typeof(Availability.RetryDatabase), "String", typeof(IDatabaseAsync))); + => Assert.NotEmpty(Generated(typeof(Availability.RetryTransaction), "String", typeof(IDatabaseAsync))); } diff --git a/tests/StackExchange.Redis.Tests/KeyPrefixContextTests.cs b/tests/StackExchange.Redis.Tests/KeyPrefixContextTests.cs new file mode 100644 index 0000000000..4c390cc205 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/KeyPrefixContextTests.cs @@ -0,0 +1,236 @@ +using System; +using System.Linq; +using System.Threading.Tasks; +using NSubstitute; +using StackExchange.Redis.Interfaces; +using StackExchange.Redis.KeyspaceIsolation; +using Xunit; + +namespace StackExchange.Redis.Tests; + +/// +/// WithKeyPrefix as context state: the prefix is applied by the frame writer, to every +/// hole, at render time. +/// +/// +/// +/// These replace four thousand lines of member-by-member wrapper tests +/// (KeyPrefixedTests, KeyPrefixedDatabaseTests and friends), and the reduction is the +/// point rather than a loss: those pinned a hand-written per-member argument mapping, which could be +/// wrong per member and so needed a test per member. The context prefix has no per-member mapping to +/// get wrong - a key reaches the wire only through a -typed interpolation hole, +/// and the writer prefixes every one of them in one place - so what needs pinning is that one +/// mechanism, plus the enumerable exceptions where a key travels as something other than a key: +/// SORT's BY/GET patterns (values), RANDOMKEY (no key at all, and an un-mappable reply), +/// and the out-of-band routing questions (IsConnected and friends, which never render). +/// +/// +/// Measured at the executor, which sees the final frame: what is asserted is the RESP the server +/// would receive, not what any intermediate layer promised to do. +/// +/// +public class KeyPrefixContextTests +{ + private static IDatabase Target(FakeExecutor executor) + => new RedisDatabase(new RespDatabaseContext(new RespContext().WithExecutor(executor)), null!, null); + + [Fact] + public void ASingleKeyIsPrefixedAndValuesAreNot() + { + var executor = new FakeExecutor("+OK\r\n"); + var db = Target(executor).WithKeyPrefix("p:"); + + db.StringSet("k", "v"); + + Assert.Equal("*3|$3|SET|$3|p:k|$1|v|", Assert.Single(executor.Sent)); + } + + [Fact] + public void EveryKeyInAMultiKeyCommandIsPrefixed() + { + var executor = new FakeExecutor(":2\r\n"); + var db = Target(executor).WithKeyPrefix("p:"); + + db.KeyDelete(["a", "b"]); + + Assert.Equal("*3|$3|DEL|$3|p:a|$3|p:b|", Assert.Single(executor.Sent)); + } + + [Fact] + public void HashFieldsAreNotKeysAndAreNotPrefixed() + { + var executor = new FakeExecutor(":1\r\n"); + var db = Target(executor).WithKeyPrefix("p:"); + + db.HashSet("k", "f", "v"); + + Assert.Equal("*4|$4|HSET|$3|p:k|$1|f|$1|v|", Assert.Single(executor.Sent)); + } + + [Fact] + public void NestedPrefixesComposeOutermostFirst() + { + var executor = new FakeExecutor("$1\r\nv\r\n"); + var db = Target(executor).WithKeyPrefix("a:").WithKeyPrefix("b:"); + + db.StringGet("k"); + + // the same order the nested decorators produced: outer call outermost on the wire + Assert.Equal("*2|$3|GET|$5|a:b:k|", Assert.Single(executor.Sent)); + } + + [Fact] + public void AnEmptyPrefixIsTheSameDatabase() + { + var db = Target(new FakeExecutor("+OK\r\n")); + Assert.Same(db, db.WithKeyPrefix("")); + } + + [Fact] + public void ANullPrefixIsACallerError() + { + var db = Target(new FakeExecutor("+OK\r\n")); + Assert.Throws(() => db.WithKeyPrefix((string?)null)); + } + + /// + /// A database from outside this library has no context to re-point - and unlike WithRetry, + /// where "no retry" is the behaviour the caller already had, quietly not prefixing would send every + /// command to the wrong keyspace. It throws. + /// + [Fact] + public void AForeignDatabaseIsRefusedRatherThanSilentlyUnprefixed() + { + var foreign = Substitute.For(); + Assert.Throws(() => foreign.WithKeyPrefix("p:")); + } + + [Fact] + public async Task KeyRandomRefusesBecauseTheReplyCannotBeMapped() + { + var db = Target(new FakeExecutor("$3\r\nkey\r\n")).WithKeyPrefix("p:"); + + Assert.Throws(() => db.KeyRandom()); + await Assert.ThrowsAsync(() => db.KeyRandomAsync()); + } + + [Fact] + public void TheNewSurfaceRefusesRandomTheSameWay() + { + var executor = new FakeExecutor("$3\r\nkey\r\n"); + var context = new RespDatabaseContext(new RespContext().WithExecutor(executor)).AppendKeyPrefix("p:"); + + Assert.Throws(() => context.Keys.RandomAsync()); + Assert.False(executor.HasSent); + } + + [Fact] + public void SortByAndGetPatternsArePrefixedWithTheOperandSpellingsExempt() + { + var executor = new FakeExecutor("*1\r\n$1\r\na\r\n"); + var db = Target(executor).WithKeyPrefix("p:"); + + // BY names keys via a pattern, so the pattern is prefixed; GET # is an operand and passes through + db.Sort("k", by: "w_*", get: ["#", "x_*"]); + + Assert.Equal( + "*8|$4|SORT|$3|p:k|$2|BY|$5|p:w_*|$3|GET|$1|#|$3|GET|$5|p:x_*|", + Assert.Single(executor.Sent)); + } + + [Fact] + public void SortByNosortIsAnOperandAndIsNotPrefixed() + { + var executor = new FakeExecutor("*1\r\n$1\r\na\r\n"); + var db = Target(executor).WithKeyPrefix("p:"); + + db.Sort("k", by: "nosort"); + + Assert.Equal("*4|$4|SORT|$3|p:k|$2|BY|$6|nosort|", Assert.Single(executor.Sent)); + } + + [Fact] + public void SortAndStorePrefixesBothKeys() + { + var executor = new FakeExecutor(":0\r\n"); + var db = Target(executor).WithKeyPrefix("p:"); + + db.SortAndStore("dest", "k"); + + Assert.Equal("*4|$4|SORT|$3|p:k|$5|STORE|$6|p:dest|", Assert.Single(executor.Sent)); + } + + [Fact] + public void AdHocExecutePrefixesKeyArgumentsAndOnlyThose() + { + var executor = new FakeExecutor("$1\r\nv\r\n"); + var db = Target(executor).WithKeyPrefix("p:"); + + // a RedisKey goes through the key path (prefixed, routes, invalidates); a string is a value + db.Execute("GETEX", new object[] { (RedisKey)"k", "PERSIST" }); + + Assert.Equal("*3|$5|GETEX|$3|p:k|$7|PERSIST|", Assert.Single(executor.Sent)); + } + + [Fact] + public void ScriptKeysArePrefixedAndScriptValuesAreNot() + { + var executor = new FakeExecutor(":1\r\n") { CaptureKeys = true }; + var db = Target(executor).WithKeyPrefix("p:"); + + db.ScriptEvaluate("return 1", [(RedisKey)"k"], ["v"]); + + // asserted via the writer's own key marks, which survive whatever EVAL/EVALSHA shape was + // chosen (here a SCRIPT LOAD + EVALSHA pair; the key rides on the EVALSHA) + var frame = executor.Sent[executor.Sent.Count - 1]; // (no Index on net481) + Assert.Equal("p:k", Assert.Single(executor.Keys)); + Assert.Contains("|p:k|", frame); + Assert.Contains("|v|", frame); + } + + /// + /// The routing questions never render a frame, so the render-time prefix cannot reach them; they + /// prefix the key before asking, or in a cluster they would answer about a slot no command uses. + /// + [Fact] + public void RoutingQuestionsAskAboutThePrefixedKey() + { + var executor = new RoutingProbe(); + var db = Target(executor).WithKeyPrefix("p:"); + + Assert.True(db.IsConnected("k")); + Assert.Equal("p:k", executor.LastRoutedKey); + + db.IdentifyEndpoint("k"); + Assert.Equal("p:k", executor.LastRoutedKey); + } + + [Fact] + public void APrefixedDatabaseSaysSoInItsFeatures() + { + var db = Target(new FakeExecutor("+OK\r\n")).WithKeyPrefix("p:"); + Assert.True(db.GetFeatures(out _).HasFlag(DatabaseFeatureFlags.KeyPrefix)); + } + + [Fact] + public void ThePrefixAppliesToTheAsyncSurfaceIdentically() + { + var executor = new FakeExecutor("$1\r\nv\r\n"); + var db = Target(executor).WithKeyPrefix("p:"); + + Assert.True(db.StringGetAsync("k").IsCompleted); // the fake answers inline + + Assert.Equal("*2|$3|GET|$3|p:k|", Assert.Single(executor.Sent)); + } + + private sealed class RoutingProbe() : FakeExecutor("+PONG\r\n") + { + public string? LastRoutedKey; + + internal override RespExecutorBase? ResolveFor(in RedisKey key, RedisCommand command, CommandFlags flags) + { + LastRoutedKey = key; + return base.ResolveFor(in key, command, flags); + } + } +} diff --git a/tests/StackExchange.Redis.Tests/KeyPrefixedBatchTests.cs b/tests/StackExchange.Redis.Tests/KeyPrefixedBatchTests.cs deleted file mode 100644 index e92a7a2279..0000000000 --- a/tests/StackExchange.Redis.Tests/KeyPrefixedBatchTests.cs +++ /dev/null @@ -1,26 +0,0 @@ -using System.Text; -using NSubstitute; -using StackExchange.Redis.KeyspaceIsolation; -using Xunit; - -namespace StackExchange.Redis.Tests; - -[Collection(nameof(SubstituteDependentCollection))] -public sealed class KeyPrefixedBatchTests -{ - private readonly IBatch mock; - private readonly KeyPrefixedBatch prefixed; - - public KeyPrefixedBatchTests() - { - mock = Substitute.For(); - prefixed = new KeyPrefixedBatch(mock, Encoding.UTF8.GetBytes("prefix:")); - } - - [Fact] - public void Execute() - { - prefixed.Execute(); - mock.Received(1).Execute(); - } -} diff --git a/tests/StackExchange.Redis.Tests/KeyPrefixedDatabaseTests.cs b/tests/StackExchange.Redis.Tests/KeyPrefixedDatabaseTests.cs deleted file mode 100644 index 108bd5ef7d..0000000000 --- a/tests/StackExchange.Redis.Tests/KeyPrefixedDatabaseTests.cs +++ /dev/null @@ -1,1922 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Linq.Expressions; -using System.Net; -using System.Text; -using NSubstitute; -using StackExchange.Redis.KeyspaceIsolation; -using Xunit; - -namespace StackExchange.Redis.Tests; - -[CollectionDefinition(nameof(SubstituteDependentCollection), DisableParallelization = true)] -public class SubstituteDependentCollection { } - -[Collection(nameof(SubstituteDependentCollection))] -public sealed class KeyPrefixedDatabaseTests -{ - private readonly IDatabase mock; - private readonly IDatabase prefixed; - - internal static RedisKey[] IsKeys(params RedisKey[] expected) => IsRaw(expected); - internal static RedisValue[] IsValues(params RedisValue[] expected) => IsRaw(expected); - private static T[] IsRaw(T[] expected) - { - Expression> lambda = actual => actual.Length == expected.Length && expected.SequenceEqual(actual); - return Arg.Is(lambda); - } - - internal static ReadOnlyMemory IsValueMemory(params RedisValue[] expected) => IsRawMemory(expected); - private static ReadOnlyMemory IsRawMemory(T[] expected) - { - // NB: can't touch .Span inside the expression tree - Span/ReadOnlySpan are ref structs, - // which can't appear in an expression tree; ToArray() sidesteps that. - Expression>> lambda = actual => actual.Length == expected.Length && expected.SequenceEqual(actual.ToArray()); - return Arg.Is(lambda); - } - - public KeyPrefixedDatabaseTests() - { - mock = Substitute.For(); - prefixed = new KeyPrefixedDatabase(mock, Encoding.UTF8.GetBytes("prefix:")); - } - - [Fact] - public void CreateBatch() - { - object asyncState = new(); - IBatch innerBatch = Substitute.For(); - mock.CreateBatch(asyncState).Returns(innerBatch); - IBatch wrappedBatch = prefixed.CreateBatch(asyncState); - mock.Received().CreateBatch(asyncState); - Assert.IsType(wrappedBatch); - Assert.Same(innerBatch, ((KeyPrefixedBatch)wrappedBatch).Inner); - } - - [Fact] - public void CreateTransaction() - { - object asyncState = new(); - ITransaction innerTransaction = Substitute.For(); - mock.CreateTransaction(asyncState).Returns(innerTransaction); - ITransaction wrappedTransaction = prefixed.CreateTransaction(asyncState); - mock.Received().CreateTransaction(asyncState); - Assert.IsType(wrappedTransaction); - Assert.Same(innerTransaction, ((KeyPrefixedTransaction)wrappedTransaction).Inner); - } - - [Fact] - public void DebugObject() - { - prefixed.DebugObject("key", CommandFlags.None); - mock.Received().DebugObject("prefix:key", CommandFlags.None); - } - - [Fact] - public void HashDecrement_1() - { - prefixed.HashDecrement("key", "hashField", 123, CommandFlags.None); - mock.Received().HashDecrement("prefix:key", "hashField", 123, CommandFlags.None); - } - - [Fact] - public void HashDecrement_2() - { - prefixed.HashDecrement("key", "hashField", 1.23, CommandFlags.None); - mock.Received().HashDecrement("prefix:key", "hashField", 1.23, CommandFlags.None); - } - - [Fact] - public void HashDelete_1() - { - prefixed.HashDelete("key", "hashField", CommandFlags.None); - mock.Received().HashDelete("prefix:key", "hashField", CommandFlags.None); - } - - [Fact] - public void HashDelete_2() - { - RedisValue[] hashFields = Array.Empty(); - prefixed.HashDelete("key", hashFields, CommandFlags.None); - mock.Received().HashDelete("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public void HashExists() - { - prefixed.HashExists("key", "hashField", CommandFlags.None); - mock.Received().HashExists("prefix:key", "hashField", CommandFlags.None); - } - - [Fact] - public void HashGet_1() - { - prefixed.HashGet("key", "hashField", CommandFlags.None); - mock.Received().HashGet("prefix:key", "hashField", CommandFlags.None); - } - - [Fact] - public void HashGet_2() - { - RedisValue[] hashFields = Array.Empty(); - prefixed.HashGet("key", hashFields, CommandFlags.None); - mock.Received().HashGet("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public void HashGetAll() - { - prefixed.HashGetAll("key", CommandFlags.None); - mock.Received().HashGetAll("prefix:key", CommandFlags.None); - } - - [Fact] - public void HashIncrement_1() - { - prefixed.HashIncrement("key", "hashField", 123, CommandFlags.None); - mock.Received().HashIncrement("prefix:key", "hashField", 123, CommandFlags.None); - } - - [Fact] - public void HashIncrement_2() - { - prefixed.HashIncrement("key", "hashField", 1.23, CommandFlags.None); - mock.Received().HashIncrement("prefix:key", "hashField", 1.23, CommandFlags.None); - } - - [Fact] - public void HashKeys() - { - prefixed.HashKeys("key", CommandFlags.None); - mock.Received().HashKeys("prefix:key", CommandFlags.None); - } - - [Fact] - public void HashLength() - { - prefixed.HashLength("key", CommandFlags.None); - mock.Received().HashLength("prefix:key", CommandFlags.None); - } - - [Fact] - public void HashScan() - { - prefixed.HashScan("key", "pattern", 123, flags: CommandFlags.None); - mock.Received().HashScan("prefix:key", "pattern", 123, CommandFlags.None); - } - - [Fact] - public void HashScan_Full() - { - prefixed.HashScan("key", "pattern", 123, 42, 64, flags: CommandFlags.None); - mock.Received().HashScan("prefix:key", "pattern", 123, 42, 64, CommandFlags.None); - } - - [Fact] - public void HashScanNoValues() - { - prefixed.HashScanNoValues("key", "pattern", 123, flags: CommandFlags.None); - mock.Received().HashScanNoValues("prefix:key", "pattern", 123, flags: CommandFlags.None); - } - - [Fact] - public void HashScanNoValues_Full() - { - prefixed.HashScanNoValues("key", "pattern", 123, 42, 64, flags: CommandFlags.None); - mock.Received().HashScanNoValues("prefix:key", "pattern", 123, 42, 64, CommandFlags.None); - } - - [Fact] - public void HashSet_1() - { - HashEntry[] hashFields = Array.Empty(); - prefixed.HashSet("key", hashFields, CommandFlags.None); - mock.Received().HashSet("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public void HashSet_2() - { - prefixed.HashSet("key", "hashField", "value", When.Exists, CommandFlags.None); - mock.Received().HashSet("prefix:key", "hashField", "value", When.Exists, CommandFlags.None); - } - - [Fact] - public void HashStringLength() - { - prefixed.HashStringLength("key", "field", CommandFlags.None); - mock.Received().HashStringLength("prefix:key", "field", CommandFlags.None); - } - - [Fact] - public void HashValues() - { - prefixed.HashValues("key", CommandFlags.None); - mock.Received().HashValues("prefix:key", CommandFlags.None); - } - - [Fact] - public void HyperLogLogAdd_1() - { - prefixed.HyperLogLogAdd("key", "value", CommandFlags.None); - mock.Received().HyperLogLogAdd("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public void HyperLogLogAdd_2() - { - RedisValue[] values = Array.Empty(); - prefixed.HyperLogLogAdd("key", values, CommandFlags.None); - mock.Received().HyperLogLogAdd("prefix:key", values, CommandFlags.None); - } - - [Fact] - public void HyperLogLogLength() - { - prefixed.HyperLogLogLength("key", CommandFlags.None); - mock.Received().HyperLogLogLength("prefix:key", CommandFlags.None); - } - - [Fact] - public void HyperLogLogMerge_1() - { - prefixed.HyperLogLogMerge("destination", "first", "second", CommandFlags.None); - mock.Received().HyperLogLogMerge("prefix:destination", "prefix:first", "prefix:second", CommandFlags.None); - } - - [Fact] - public void HyperLogLogMerge_2() - { - prefixed.HyperLogLogMerge("destination", ["a", "b"], CommandFlags.None); - mock.Received().HyperLogLogMerge("prefix:destination", IsKeys(["prefix:a", "prefix:b"]), CommandFlags.None); - } - - [Fact] - public void IdentifyEndpoint() - { - prefixed.IdentifyEndpoint("key", CommandFlags.None); - mock.Received().IdentifyEndpoint("prefix:key", CommandFlags.None); - } - - [Fact] - public void KeyCopy() - { - prefixed.KeyCopy("key", "destination", flags: CommandFlags.None); - mock.Received().KeyCopy("prefix:key", "prefix:destination", -1, false, CommandFlags.None); - } - - [Fact] - public void KeyDelete_1() - { - prefixed.KeyDelete("key", CommandFlags.None); - mock.Received().KeyDelete("prefix:key", CommandFlags.None); - } - - [Fact] - public void KeyDelete_2() - { - prefixed.KeyDelete(["a", "b"], CommandFlags.None); - mock.Received().KeyDelete(IsKeys(["prefix:a", "prefix:b"]), CommandFlags.None); - } - - [Fact] - public void KeyDump() - { - prefixed.KeyDump("key", CommandFlags.None); - mock.Received().KeyDump("prefix:key", CommandFlags.None); - } - - [Fact] - public void KeyEncoding() - { - prefixed.KeyEncoding("key", CommandFlags.None); - mock.Received().KeyEncoding("prefix:key", CommandFlags.None); - } - - [Fact] - public void KeyExists() - { - prefixed.KeyExists("key", CommandFlags.None); - mock.Received().KeyExists("prefix:key", CommandFlags.None); - } - - [Fact] - public void KeyExpire_1() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - prefixed.KeyExpire("key", expiry, CommandFlags.None); - mock.Received().KeyExpire("prefix:key", expiry, CommandFlags.None); - } - - [Fact] - public void KeyExpire_2() - { - DateTime expiry = DateTime.Now; - prefixed.KeyExpire("key", expiry, CommandFlags.None); - mock.Received().KeyExpire("prefix:key", expiry, CommandFlags.None); - } - - [Fact] - public void KeyExpire_3() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - prefixed.KeyExpire("key", expiry, ExpireWhen.HasNoExpiry, CommandFlags.None); - mock.Received().KeyExpire("prefix:key", expiry, ExpireWhen.HasNoExpiry, CommandFlags.None); - } - - [Fact] - public void KeyExpire_4() - { - DateTime expiry = DateTime.Now; - prefixed.KeyExpire("key", expiry, ExpireWhen.HasNoExpiry, CommandFlags.None); - mock.Received().KeyExpire("prefix:key", expiry, ExpireWhen.HasNoExpiry, CommandFlags.None); - } - - [Fact] - public void KeyExpireTime() - { - prefixed.KeyExpireTime("key", CommandFlags.None); - mock.Received().KeyExpireTime("prefix:key", CommandFlags.None); - } - - [Fact] - public void KeyFrequency() - { - prefixed.KeyFrequency("key", CommandFlags.None); - mock.Received().KeyFrequency("prefix:key", CommandFlags.None); - } - - [Fact] - public void KeyMigrate() - { - EndPoint toServer = new IPEndPoint(IPAddress.Loopback, 123); - prefixed.KeyMigrate("key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.None); - mock.Received().KeyMigrate("prefix:key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.None); - } - - [Fact] - public void KeyMove() - { - prefixed.KeyMove("key", 123, CommandFlags.None); - mock.Received().KeyMove("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public void KeyPersist() - { - prefixed.KeyPersist("key", CommandFlags.None); - mock.Received().KeyPersist("prefix:key", CommandFlags.None); - } - - [Fact] - public void KeyRandom() - { - Assert.Throws(() => prefixed.KeyRandom()); - } - - [Fact] - public void KeyRefCount() - { - prefixed.KeyRefCount("key", CommandFlags.None); - mock.Received().KeyRefCount("prefix:key", CommandFlags.None); - } - - [Fact] - public void KeyRename() - { - prefixed.KeyRename("key", "newKey", When.Exists, CommandFlags.None); - mock.Received().KeyRename("prefix:key", "prefix:newKey", When.Exists, CommandFlags.None); - } - - [Fact] - public void KeyRestore() - { - byte[] value = Array.Empty(); - TimeSpan expiry = TimeSpan.FromSeconds(123); - prefixed.KeyRestore("key", value, expiry, CommandFlags.None); - mock.Received().KeyRestore("prefix:key", value, expiry, CommandFlags.None); - } - - [Fact] - public void KeyTimeToLive() - { - prefixed.KeyTimeToLive("key", CommandFlags.None); - mock.Received().KeyTimeToLive("prefix:key", CommandFlags.None); - } - - [Fact] - public void KeyType() - { - prefixed.KeyType("key", CommandFlags.None); - mock.Received().KeyType("prefix:key", CommandFlags.None); - } - - [Fact] - public void ListGetByIndex() - { - prefixed.ListGetByIndex("key", 123, CommandFlags.None); - mock.Received().ListGetByIndex("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public void ListInsertAfter() - { - prefixed.ListInsertAfter("key", "pivot", "value", CommandFlags.None); - mock.Received().ListInsertAfter("prefix:key", "pivot", "value", CommandFlags.None); - } - - [Fact] - public void ListInsertBefore() - { - prefixed.ListInsertBefore("key", "pivot", "value", CommandFlags.None); - mock.Received().ListInsertBefore("prefix:key", "pivot", "value", CommandFlags.None); - } - - [Fact] - public void ListLeftPop() - { - prefixed.ListLeftPop("key", CommandFlags.None); - mock.Received().ListLeftPop("prefix:key", CommandFlags.None); - } - - [Fact] - public void ListLeftPop_1() - { - prefixed.ListLeftPop("key", 123, CommandFlags.None); - mock.Received().ListLeftPop("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public void ListLeftPush_1() - { - prefixed.ListLeftPush("key", "value", When.Exists, CommandFlags.None); - mock.Received().ListLeftPush("prefix:key", "value", When.Exists, CommandFlags.None); - } - - [Fact] - public void ListLeftPush_2() - { - RedisValue[] values = Array.Empty(); - prefixed.ListLeftPush("key", values, CommandFlags.None); - mock.Received().ListLeftPush("prefix:key", values, CommandFlags.None); - } - - [Fact] - public void ListLeftPush_3() - { - RedisValue[] values = ["value1", "value2"]; - prefixed.ListLeftPush("key", values, When.Exists, CommandFlags.None); - mock.Received().ListLeftPush("prefix:key", values, When.Exists, CommandFlags.None); - } - - [Fact] - public void ListLength() - { - prefixed.ListLength("key", CommandFlags.None); - mock.Received().ListLength("prefix:key", CommandFlags.None); - } - - [Fact] - public void ListMove() - { - prefixed.ListMove("key", "destination", ListSide.Left, ListSide.Right, CommandFlags.None); - mock.Received().ListMove("prefix:key", "prefix:destination", ListSide.Left, ListSide.Right, CommandFlags.None); - } - - [Fact] - public void ListRange() - { - prefixed.ListRange("key", 123, 456, CommandFlags.None); - mock.Received().ListRange("prefix:key", 123, 456, CommandFlags.None); - } - - [Fact] - public void ListRemove() - { - prefixed.ListRemove("key", "value", 123, CommandFlags.None); - mock.Received().ListRemove("prefix:key", "value", 123, CommandFlags.None); - } - - [Fact] - public void ListRightPop() - { - prefixed.ListRightPop("key", CommandFlags.None); - mock.Received().ListRightPop("prefix:key", CommandFlags.None); - } - - [Fact] - public void ListRightPop_1() - { - prefixed.ListRightPop("key", 123, CommandFlags.None); - mock.Received().ListRightPop("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public void ListRightPopLeftPush() - { - prefixed.ListRightPopLeftPush("source", "destination", CommandFlags.None); - mock.Received().ListRightPopLeftPush("prefix:source", "prefix:destination", CommandFlags.None); - } - - [Fact] - public void ListRightPush_1() - { - prefixed.ListRightPush("key", "value", When.Exists, CommandFlags.None); - mock.Received().ListRightPush("prefix:key", "value", When.Exists, CommandFlags.None); - } - - [Fact] - public void ListRightPush_2() - { - RedisValue[] values = Array.Empty(); - prefixed.ListRightPush("key", values, CommandFlags.None); - mock.Received().ListRightPush("prefix:key", values, CommandFlags.None); - } - - [Fact] - public void ListRightPush_3() - { - RedisValue[] values = ["value1", "value2"]; - prefixed.ListRightPush("key", values, When.Exists, CommandFlags.None); - mock.Received().ListRightPush("prefix:key", values, When.Exists, CommandFlags.None); - } - - [Fact] - public void ListSetByIndex() - { - prefixed.ListSetByIndex("key", 123, "value", CommandFlags.None); - mock.Received().ListSetByIndex("prefix:key", 123, "value", CommandFlags.None); - } - - [Fact] - public void ListTrim() - { - prefixed.ListTrim("key", 123, 456, CommandFlags.None); - mock.Received().ListTrim("prefix:key", 123, 456, CommandFlags.None); - } - - [Fact] - public void LockExtend() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - prefixed.LockExtend("key", "value", expiry, CommandFlags.None); - mock.Received().LockExtend("prefix:key", "value", expiry, CommandFlags.None); - } - - [Fact] - public void LockQuery() - { - prefixed.LockQuery("key", CommandFlags.None); - mock.Received().LockQuery("prefix:key", CommandFlags.None); - } - - [Fact] - public void LockRelease() - { - prefixed.LockRelease("key", "value", CommandFlags.None); - mock.Received().LockRelease("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public void LockTake() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - prefixed.LockTake("key", "value", expiry, CommandFlags.None); - mock.Received().LockTake("prefix:key", "value", expiry, CommandFlags.None); - } - - [Fact] - public void Publish() - { -#pragma warning disable CS0618 - prefixed.Publish("channel", "message", CommandFlags.None); - mock.Received().Publish("prefix:channel", "message", CommandFlags.None); -#pragma warning restore CS0618 - } - - [Fact] - public void ScriptEvaluate_1() - { - byte[] hash = Array.Empty(); - RedisValue[] values = Array.Empty(); - RedisKey[] keys = ["a", "b"]; - prefixed.ScriptEvaluate(hash, keys, values, CommandFlags.None); - mock.Received().ScriptEvaluate(hash, IsKeys(["prefix:a", "prefix:b"]), values, CommandFlags.None); - } - - [Fact] - public void ScriptEvaluate_2() - { - RedisValue[] values = Array.Empty(); - RedisKey[] keys = ["a", "b"]; - prefixed.ScriptEvaluate(script: "script", keys: keys, values: values, flags: CommandFlags.None); - mock.Received().ScriptEvaluate(script: "script", keys: IsKeys(["prefix:a", "prefix:b"]), values: values, flags: CommandFlags.None); - } - - [Fact] - public void ScriptEvaluateResp_1() - { - // NB: ScriptEvaluateResp rents its inner RedisKey[] from the ArrayPool and returns it - // (clearArray: true) as soon as the (mocked) inner call completes, so by the time - // mock.Received() re-evaluates its argument matcher, the array backing the recorded - // ReadOnlyMemory has already been zeroed. Capture a copy at call time instead. - RedisKey[]? captured = null; - mock.ScriptEvaluateResp( - Arg.Any(), - Arg.Do>(m => captured = m.ToArray()), - Arg.Any>(), - Arg.Any()); - - RedisValue[] values = ["v1", "v2"]; - RedisKey[] keys = ["a", "b"]; - prefixed.ScriptEvaluateResp("script", keys, values, CommandFlags.None); - - mock.Received().ScriptEvaluateResp("script", Arg.Any>(), IsValueMemory("v1", "v2"), CommandFlags.None); - Assert.NotNull(captured); - Assert.Equal(["prefix:a", "prefix:b"], captured); - } - - [Fact] - public void ScriptEvaluateReadOnlyResp_1() - { - // see ScriptEvaluateResp_1 for why keys must be captured at call time, not verified after the fact. - RedisKey[]? captured = null; - mock.ScriptEvaluateReadOnlyResp( - Arg.Any(), - Arg.Do>(m => captured = m.ToArray()), - Arg.Any>(), - Arg.Any()); - - RedisValue[] values = ["v1", "v2"]; - RedisKey[] keys = ["a", "b"]; - prefixed.ScriptEvaluateReadOnlyResp("script", keys, values, CommandFlags.None); - - mock.Received().ScriptEvaluateReadOnlyResp("script", Arg.Any>(), IsValueMemory("v1", "v2"), CommandFlags.None); - Assert.NotNull(captured); - Assert.Equal(["prefix:a", "prefix:b"], captured); - } - - [Fact] - public void SetAdd_1() - { - prefixed.SetAdd("key", "value", CommandFlags.None); - mock.Received().SetAdd("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public void SetAdd_2() - { - RedisValue[] values = Array.Empty(); - prefixed.SetAdd("key", values, CommandFlags.None); - mock.Received().SetAdd("prefix:key", values, CommandFlags.None); - } - - [Fact] - public void SetCombine_1() - { - prefixed.SetCombine(SetOperation.Intersect, "first", "second", CommandFlags.None); - mock.Received().SetCombine(SetOperation.Intersect, "prefix:first", "prefix:second", CommandFlags.None); - } - - [Fact] - public void SetCombine_2() - { - RedisKey[] keys = ["a", "b"]; - prefixed.SetCombine(SetOperation.Intersect, keys, CommandFlags.None); - mock.Received().SetCombine(SetOperation.Intersect, IsKeys(["prefix:a", "prefix:b"]), CommandFlags.None); - } - - [Fact] - public void SetCombineAndStore_1() - { - prefixed.SetCombineAndStore(SetOperation.Intersect, "destination", "first", "second", CommandFlags.None); - mock.Received().SetCombineAndStore(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.None); - } - - [Fact] - public void SetCombineAndStore_2() - { - RedisKey[] keys = ["a", "b"]; - prefixed.SetCombineAndStore(SetOperation.Intersect, "destination", keys, CommandFlags.None); - mock.Received().SetCombineAndStore(SetOperation.Intersect, "prefix:destination", IsKeys(["prefix:a", "prefix:b"]), CommandFlags.None); - } - - [Fact] - public void SetContains() - { - prefixed.SetContains("key", "value", CommandFlags.None); - mock.Received().SetContains("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public void SetContains_2() - { - RedisValue[] values = ["value1", "value2"]; - prefixed.SetContains("key", values, CommandFlags.None); - mock.Received().SetContains("prefix:key", values, CommandFlags.None); - } - - [Fact] - public void SetIntersectionLength() - { - prefixed.SetIntersectionLength(["key1", "key2"]); - mock.Received().SetIntersectionLength(IsKeys(["prefix:key1", "prefix:key2"]), 0, CommandFlags.None); - } - - [Fact] - public void SetCombineLength() - { - prefixed.SetCombineLength(SetOperation.Union, ["key1", "key2"]); - mock.Received().SetCombineLength(SetOperation.Union, IsKeys(["prefix:key1", "prefix:key2"]), 0, false, CommandFlags.None); - } - - [Fact] - public void SetLength() - { - prefixed.SetLength("key", CommandFlags.None); - mock.Received().SetLength("prefix:key", CommandFlags.None); - } - - [Fact] - public void SetMembers() - { - prefixed.SetMembers("key", CommandFlags.None); - mock.Received().SetMembers("prefix:key", CommandFlags.None); - } - - [Fact] - public void SetMove() - { - prefixed.SetMove("source", "destination", "value", CommandFlags.None); - mock.Received().SetMove("prefix:source", "prefix:destination", "value", CommandFlags.None); - } - - [Fact] - public void SetPop_1() - { - prefixed.SetPop("key", CommandFlags.None); - mock.Received().SetPop("prefix:key", CommandFlags.None); - - prefixed.SetPop("key", 5, CommandFlags.None); - mock.Received().SetPop("prefix:key", 5, CommandFlags.None); - } - - [Fact] - public void SetPop_2() - { - prefixed.SetPop("key", 5, CommandFlags.None); - mock.Received().SetPop("prefix:key", 5, CommandFlags.None); - } - - [Fact] - public void SetRandomMember() - { - prefixed.SetRandomMember("key", CommandFlags.None); - mock.Received().SetRandomMember("prefix:key", CommandFlags.None); - } - - [Fact] - public void SetRandomMembers() - { - prefixed.SetRandomMembers("key", 123, CommandFlags.None); - mock.Received().SetRandomMembers("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public void SetRemove_1() - { - prefixed.SetRemove("key", "value", CommandFlags.None); - mock.Received().SetRemove("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public void SetRemove_2() - { - RedisValue[] values = Array.Empty(); - prefixed.SetRemove("key", values, CommandFlags.None); - mock.Received().SetRemove("prefix:key", values, CommandFlags.None); - } - - [Fact] - public void SetScan() - { - prefixed.SetScan("key", "pattern", 123, flags: CommandFlags.None); - mock.Received().SetScan("prefix:key", "pattern", 123, CommandFlags.None); - } - - [Fact] - public void SetScan_Full() - { - prefixed.SetScan("key", "pattern", 123, 42, 64, flags: CommandFlags.None); - mock.Received().SetScan("prefix:key", "pattern", 123, 42, 64, CommandFlags.None); - } - - [Fact] - public void Sort() - { - RedisValue[] get = ["a", "#"]; - - prefixed.Sort("key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.None); - prefixed.Sort("key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.None); - - mock.Received().Sort("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", IsValues(["prefix:a", "#"]), CommandFlags.None); - mock.Received().Sort("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", IsValues(["prefix:a", "#"]), CommandFlags.None); - } - - [Fact] - public void SortAndStore() - { - RedisValue[] get = ["a", "#"]; - - prefixed.SortAndStore("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.None); - prefixed.SortAndStore("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.None); - - mock.Received().SortAndStore("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", IsValues(["prefix:a", "#"]), CommandFlags.None); - mock.Received().SortAndStore("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", IsValues(["prefix:a", "#"]), CommandFlags.None); - } - - [Fact] - public void SortedSetAdd_1() - { - prefixed.SortedSetAdd("key", "member", 1.23, When.Exists, CommandFlags.None); - mock.Received().SortedSetAdd("prefix:key", "member", 1.23, When.Exists, CommandFlags.None); - } - - [Fact] - public void SortedSetAdd_2() - { - SortedSetEntry[] values = Array.Empty(); - prefixed.SortedSetAdd("key", values, When.Exists, CommandFlags.None); - mock.Received().SortedSetAdd("prefix:key", values, When.Exists, CommandFlags.None); - } - - [Fact] - public void SortedSetAdd_3() - { - SortedSetEntry[] values = Array.Empty(); - prefixed.SortedSetAdd("key", values, SortedSetWhen.GreaterThan, CommandFlags.None); - mock.Received().SortedSetAdd("prefix:key", values, SortedSetWhen.GreaterThan, CommandFlags.None); - } - - [Fact] - public void SortedSetCombine() - { - RedisKey[] keys = ["a", "b"]; - prefixed.SortedSetCombine(SetOperation.Intersect, ["a", "b"]); - mock.Received().SortedSetCombine(SetOperation.Intersect, IsKeys(["prefix:a", "prefix:b"]), null, Aggregate.Sum, CommandFlags.None); - } - - [Fact] - public void SortedSetCombineWithScores() - { - prefixed.SortedSetCombineWithScores(SetOperation.Intersect, ["a", "b"]); - mock.Received().SortedSetCombineWithScores(SetOperation.Intersect, IsKeys("prefix:a", "prefix:b"), null, Aggregate.Sum, CommandFlags.None); - } - - [Fact] - public void SortedSetCombineAndStore_1() - { - prefixed.SortedSetCombineAndStore(SetOperation.Intersect, "destination", "first", "second", Aggregate.Max, CommandFlags.None); - mock.Received().SortedSetCombineAndStore(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", Aggregate.Max, CommandFlags.None); - } - - [Fact] - public void SortedSetCombineAndStore_2() - { - RedisKey[] keys = ["a", "b"]; - prefixed.SetCombineAndStore(SetOperation.Intersect, "destination", keys, CommandFlags.None); - mock.Received().SetCombineAndStore(SetOperation.Intersect, "prefix:destination", IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - - [Fact] - public void SortedSetDecrement() - { - prefixed.SortedSetDecrement("key", "member", 1.23, CommandFlags.None); - mock.Received().SortedSetDecrement("prefix:key", "member", 1.23, CommandFlags.None); - } - - [Fact] - public void SortedSetIncrement() - { - prefixed.SortedSetIncrement("key", "member", 1.23, CommandFlags.None); - mock.Received().SortedSetIncrement("prefix:key", "member", 1.23, CommandFlags.None); - } - - [Fact] - public void SortedSetIncrement_When() - { - prefixed.SortedSetIncrement("key", "member", 1.23, ValueCondition.Exists, CommandFlags.None); - mock.Received().SortedSetIncrement("prefix:key", "member", 1.23, ValueCondition.Exists, CommandFlags.None); - } - - [Fact] - public void SortedSetIntersectionLength() - { - prefixed.SortedSetIntersectionLength(["a", "b"], 1, CommandFlags.None); - mock.Received().SortedSetIntersectionLength(IsKeys("prefix:a", "prefix:b"), 1, CommandFlags.None); - } - - [Fact] - public void SortedSetLength() - { - prefixed.SortedSetLength("key", 1.23, 1.23, Exclude.Start, CommandFlags.None); - mock.Received().SortedSetLength("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.None); - } - - [Fact] - public void SortedSetRandomMember() - { - prefixed.SortedSetRandomMember("key", CommandFlags.None); - mock.Received().SortedSetRandomMember("prefix:key", CommandFlags.None); - } - - [Fact] - public void SortedSetRandomMembers() - { - prefixed.SortedSetRandomMembers("key", 2, CommandFlags.None); - mock.Received().SortedSetRandomMembers("prefix:key", 2, CommandFlags.None); - } - - [Fact] - public void SortedSetRandomMembersWithScores() - { - prefixed.SortedSetRandomMembersWithScores("key", 2, CommandFlags.None); - mock.Received().SortedSetRandomMembersWithScores("prefix:key", 2, CommandFlags.None); - } - - [Fact] - public void SortedSetLengthByValue() - { - prefixed.SortedSetLengthByValue("key", "min", "max", Exclude.Start, CommandFlags.None); - mock.Received().SortedSetLengthByValue("prefix:key", "min", "max", Exclude.Start, CommandFlags.None); - } - - [Fact] - public void SortedSetRangeByRank() - { - prefixed.SortedSetRangeByRank("key", 123, 456, Order.Descending, CommandFlags.None); - mock.Received().SortedSetRangeByRank("prefix:key", 123, 456, Order.Descending, CommandFlags.None); - } - - [Fact] - public void SortedSetRangeByRankWithScores() - { - prefixed.SortedSetRangeByRankWithScores("key", 123, 456, Order.Descending, CommandFlags.None); - mock.Received().SortedSetRangeByRankWithScores("prefix:key", 123, 456, Order.Descending, CommandFlags.None); - } - - [Fact] - public void SortedSetRangeByScore() - { - prefixed.SortedSetRangeByScore("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - mock.Received().SortedSetRangeByScore("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - } - - [Fact] - public void SortedSetRangeByScoreWithScores() - { - prefixed.SortedSetRangeByScoreWithScores("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - mock.Received().SortedSetRangeByScoreWithScores("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - } - - [Fact] - public void SortedSetRangeByValue() - { - prefixed.SortedSetRangeByValue("key", "min", "max", Exclude.Start, 123, 456, CommandFlags.None); - mock.Received().SortedSetRangeByValue("prefix:key", "min", "max", Exclude.Start, Order.Ascending, 123, 456, CommandFlags.None); - } - - [Fact] - public void SortedSetRangeByValueDesc() - { - prefixed.SortedSetRangeByValue("key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - mock.Received().SortedSetRangeByValue("prefix:key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - } - - [Fact] - public void SortedSetRank() - { - prefixed.SortedSetRank("key", "member", Order.Descending, CommandFlags.None); - mock.Received().SortedSetRank("prefix:key", "member", Order.Descending, CommandFlags.None); - } - - [Fact] - public void SortedSetRemove_1() - { - prefixed.SortedSetRemove("key", "member", CommandFlags.None); - mock.Received().SortedSetRemove("prefix:key", "member", CommandFlags.None); - } - - [Fact] - public void SortedSetRemove_2() - { - RedisValue[] members = Array.Empty(); - prefixed.SortedSetRemove("key", members, CommandFlags.None); - mock.Received().SortedSetRemove("prefix:key", members, CommandFlags.None); - } - - [Fact] - public void SortedSetRemoveRangeByRank() - { - prefixed.SortedSetRemoveRangeByRank("key", 123, 456, CommandFlags.None); - mock.Received().SortedSetRemoveRangeByRank("prefix:key", 123, 456, CommandFlags.None); - } - - [Fact] - public void SortedSetRemoveRangeByScore() - { - prefixed.SortedSetRemoveRangeByScore("key", 1.23, 1.23, Exclude.Start, CommandFlags.None); - mock.Received().SortedSetRemoveRangeByScore("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.None); - } - - [Fact] - public void SortedSetRemoveRangeByValue() - { - prefixed.SortedSetRemoveRangeByValue("key", "min", "max", Exclude.Start, CommandFlags.None); - mock.Received().SortedSetRemoveRangeByValue("prefix:key", "min", "max", Exclude.Start, CommandFlags.None); - } - - [Fact] - public void SortedSetScan() - { - prefixed.SortedSetScan("key", "pattern", 123, flags: CommandFlags.None); - mock.Received().SortedSetScan("prefix:key", "pattern", 123, CommandFlags.None); - } - - [Fact] - public void SortedSetScan_Full() - { - prefixed.SortedSetScan("key", "pattern", 123, 42, 64, flags: CommandFlags.None); - mock.Received().SortedSetScan("prefix:key", "pattern", 123, 42, 64, CommandFlags.None); - } - - [Fact] - public void SortedSetScore() - { - prefixed.SortedSetScore("key", "member", CommandFlags.None); - mock.Received().SortedSetScore("prefix:key", "member", CommandFlags.None); - } - - [Fact] - public void SortedSetScore_Multiple() - { - var values = new RedisValue[] { "member1", "member2" }; - prefixed.SortedSetScores("key", values, CommandFlags.None); - mock.Received().SortedSetScores("prefix:key", values, CommandFlags.None); - } - - [Fact] - public void SortedSetUpdate() - { - SortedSetEntry[] values = Array.Empty(); - prefixed.SortedSetUpdate("key", values, SortedSetWhen.GreaterThan, CommandFlags.None); - mock.Received().SortedSetUpdate("prefix:key", values, SortedSetWhen.GreaterThan, CommandFlags.None); - } - - [Fact] - public void StreamAcknowledge_1() - { - prefixed.StreamAcknowledge("key", "group", "0-0", CommandFlags.None); - mock.Received().StreamAcknowledge("prefix:key", "group", "0-0", CommandFlags.None); - } - - [Fact] - public void StreamAcknowledge_2() - { - var messageIds = new RedisValue[] { "0-0", "0-1", "0-2" }; - prefixed.StreamAcknowledge("key", "group", messageIds, CommandFlags.None); - mock.Received().StreamAcknowledge("prefix:key", "group", messageIds, CommandFlags.None); - } - - [Fact] - public void StreamNegativeAcknowledge_1() - { - prefixed.StreamNegativeAcknowledge("key", "group", StreamNackMode.Fail, "0-0", CommandFlags.None); - mock.Received().StreamNegativeAcknowledge("prefix:key", "group", StreamNackMode.Fail, "0-0", CommandFlags.None); - } - - [Fact] - public void StreamNegativeAcknowledge_2() - { - var messageIds = new RedisValue[] { "0-0", "0-1", "0-2" }; - prefixed.StreamNegativeAcknowledge("key", "group", StreamNackMode.Fail, messageIds, CommandFlags.None); - mock.Received().StreamNegativeAcknowledge("prefix:key", "group", StreamNackMode.Fail, messageIds, CommandFlags.None); - } - - [Fact] - public void StreamAdd_1() - { - prefixed.StreamAdd("key", "field1", "value1", "*", 1000, true, CommandFlags.None); - mock.Received().StreamAdd("prefix:key", "field1", "value1", "*", 1000, true, CommandFlags.None); - } - - [Fact] - public void StreamAdd_2() - { - var fields = Array.Empty(); - prefixed.StreamAdd("key", fields, "*", 1000, true, CommandFlags.None); - mock.Received().StreamAdd("prefix:key", fields, "*", 1000, true, CommandFlags.None); - } - - [Fact] - public void StreamAutoClaim() - { - prefixed.StreamAutoClaim("key", "group", "consumer", 0, "0-0", 100, CommandFlags.None); - mock.Received().StreamAutoClaim("prefix:key", "group", "consumer", 0, "0-0", 100, CommandFlags.None); - } - - [Fact] - public void StreamAutoClaimIdsOnly() - { - prefixed.StreamAutoClaimIdsOnly("key", "group", "consumer", 0, "0-0", 100, CommandFlags.None); - mock.Received().StreamAutoClaimIdsOnly("prefix:key", "group", "consumer", 0, "0-0", 100, CommandFlags.None); - } - - [Fact] - public void StreamClaimMessages() - { - var messageIds = Array.Empty(); - prefixed.StreamClaim("key", "group", "consumer", 1000, messageIds, CommandFlags.None); - mock.Received().StreamClaim("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.None); - } - - [Fact] - public void StreamClaimMessagesReturningIds() - { - var messageIds = Array.Empty(); - prefixed.StreamClaimIdsOnly("key", "group", "consumer", 1000, messageIds, CommandFlags.None); - mock.Received().StreamClaimIdsOnly("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.None); - } - - [Fact] - public void StreamConsumerGroupSetPosition() - { - prefixed.StreamConsumerGroupSetPosition("key", "group", StreamPosition.Beginning, CommandFlags.None); - mock.Received().StreamConsumerGroupSetPosition("prefix:key", "group", StreamPosition.Beginning, CommandFlags.None); - } - - [Fact] - public void StreamConsumerInfoGet() - { - prefixed.StreamConsumerInfo("key", "group", CommandFlags.None); - mock.Received().StreamConsumerInfo("prefix:key", "group", CommandFlags.None); - } - - [Fact] - public void StreamCreateConsumerGroup() - { - prefixed.StreamCreateConsumerGroup("key", "group", StreamPosition.Beginning, false, CommandFlags.None); - mock.Received().StreamCreateConsumerGroup("prefix:key", "group", StreamPosition.Beginning, false, CommandFlags.None); - } - - [Fact] - public void StreamGroupInfoGet() - { - prefixed.StreamGroupInfo("key", CommandFlags.None); - mock.Received().StreamGroupInfo("prefix:key", CommandFlags.None); - } - - [Fact] - public void StreamInfoGet() - { - prefixed.StreamInfo("key", CommandFlags.None); - mock.Received().StreamInfo("prefix:key", CommandFlags.None); - } - - [Fact] - public void StreamLength() - { - prefixed.StreamLength("key", CommandFlags.None); - mock.Received().StreamLength("prefix:key", CommandFlags.None); - } - - [Fact] - public void StreamMessagesDelete() - { - var messageIds = Array.Empty(); - prefixed.StreamDelete("key", messageIds, CommandFlags.None); - mock.Received().StreamDelete("prefix:key", messageIds, CommandFlags.None); - } - - [Fact] - public void StreamDeleteConsumer() - { - prefixed.StreamDeleteConsumer("key", "group", "consumer", CommandFlags.None); - mock.Received().StreamDeleteConsumer("prefix:key", "group", "consumer", CommandFlags.None); - } - - [Fact] - public void StreamDeleteConsumerGroup() - { - prefixed.StreamDeleteConsumerGroup("key", "group", CommandFlags.None); - mock.Received().StreamDeleteConsumerGroup("prefix:key", "group", CommandFlags.None); - } - - [Fact] - public void StreamPendingInfoGet() - { - prefixed.StreamPending("key", "group", CommandFlags.None); - mock.Received().StreamPending("prefix:key", "group", CommandFlags.None); - } - - [Fact] - public void StreamPendingMessageInfoGet() - { - prefixed.StreamPendingMessages("key", "group", 10, RedisValue.Null, "-", "+", 1000, CommandFlags.None); - mock.Received().StreamPendingMessages("prefix:key", "group", 10, RedisValue.Null, "-", "+", 1000, CommandFlags.None); - } - - [Fact] - public void StreamRange() - { - prefixed.StreamRange("key", "-", "+", null, Order.Ascending, CommandFlags.None); - mock.Received().StreamRange("prefix:key", "-", "+", null, Order.Ascending, CommandFlags.None); - } - - [Fact] - public void StreamRead_1() - { - var streamPositions = Array.Empty(); - prefixed.StreamRead(streamPositions, null, CommandFlags.None); - mock.Received().StreamRead(streamPositions, null, CommandFlags.None); - } - - [Fact] - public void StreamRead_2() - { - prefixed.StreamRead("key", "0-0", null, CommandFlags.None); - mock.Received().StreamRead("prefix:key", "0-0", null, CommandFlags.None); - } - - [Fact] - public void StreamStreamReadGroup_1() - { - prefixed.StreamReadGroup("key", "group", "consumer", "0-0", 10, false, CommandFlags.None); - mock.Received().StreamReadGroup("prefix:key", "group", "consumer", "0-0", 10, false, CommandFlags.None); - } - - [Fact] - public void StreamStreamReadGroup_2() - { - var streamPositions = Array.Empty(); - prefixed.StreamReadGroup(streamPositions, "group", "consumer", 10, false, CommandFlags.None); - mock.Received().StreamReadGroup(streamPositions, "group", "consumer", 10, false, CommandFlags.None); - } - - [Fact] - public void StreamTrim() - { - prefixed.StreamTrim("key", 1000, true, CommandFlags.None); - mock.Received().StreamTrim("prefix:key", 1000, true, CommandFlags.None); - } - - [Fact] - public void StreamTrimByMinId() - { - prefixed.StreamTrimByMinId("key", 1111111111); - mock.Received().StreamTrimByMinId("prefix:key", 1111111111); - } - - [Fact] - public void StreamTrimByMinIdWithApproximate() - { - prefixed.StreamTrimByMinId("key", 1111111111, useApproximateMaxLength: true); - mock.Received().StreamTrimByMinId("prefix:key", 1111111111, useApproximateMaxLength: true); - } - - [Fact] - public void StreamTrimByMinIdWithApproximateAndLimit() - { - prefixed.StreamTrimByMinId("key", 1111111111, useApproximateMaxLength: true, limit: 100); - mock.Received().StreamTrimByMinId("prefix:key", 1111111111, useApproximateMaxLength: true, limit: 100); - } - - [Fact] - public void StringAppend() - { - prefixed.StringAppend("key", "value", CommandFlags.None); - mock.Received().StringAppend("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public void StringBitCount() - { - prefixed.StringBitCount("key", 123, 456, CommandFlags.None); - mock.Received().StringBitCount("prefix:key", 123, 456, CommandFlags.None); - } - - [Fact] - public void StringBitCount_2() - { - prefixed.StringBitCount("key", 123, 456, StringIndexType.Byte, CommandFlags.None); - mock.Received().StringBitCount("prefix:key", 123, 456, StringIndexType.Byte, CommandFlags.None); - } - - [Fact] - public void StringBitOperation_1() - { - prefixed.StringBitOperation(Bitwise.Xor, "destination", "first", "second", CommandFlags.None); - mock.Received().StringBitOperation(Bitwise.Xor, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.None); - } - - [Fact] - public void StringBitOperation_2() - { - RedisKey[] keys = ["a", "b"]; - prefixed.StringBitOperation(Bitwise.Xor, "destination", keys, CommandFlags.None); - mock.Received().StringBitOperation(Bitwise.Xor, "prefix:destination", IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - - [Fact] - public void StringBitOperation_Diff() - { - RedisKey[] keys = ["x", "y1", "y2"]; - prefixed.StringBitOperation(Bitwise.Diff, "destination", keys, CommandFlags.None); - mock.Received().StringBitOperation(Bitwise.Diff, "prefix:destination", IsKeys("prefix:x", "prefix:y1", "prefix:y2"), CommandFlags.None); - } - - [Fact] - public void StringBitOperation_Diff1() - { - RedisKey[] keys = ["x", "y1", "y2"]; - prefixed.StringBitOperation(Bitwise.Diff1, "destination", keys, CommandFlags.None); - mock.Received().StringBitOperation(Bitwise.Diff1, "prefix:destination", IsKeys("prefix:x", "prefix:y1", "prefix:y2"), CommandFlags.None); - } - - [Fact] - public void StringBitOperation_AndOr() - { - RedisKey[] keys = ["x", "y1", "y2"]; - prefixed.StringBitOperation(Bitwise.AndOr, "destination", keys, CommandFlags.None); - mock.Received().StringBitOperation(Bitwise.AndOr, "prefix:destination", IsKeys("prefix:x", "prefix:y1", "prefix:y2"), CommandFlags.None); - } - - [Fact] - public void StringBitOperation_One() - { - RedisKey[] keys = ["a", "b", "c"]; - prefixed.StringBitOperation(Bitwise.One, "destination", keys, CommandFlags.None); - mock.Received().StringBitOperation(Bitwise.One, "prefix:destination", IsKeys("prefix:a", "prefix:b", "prefix:c"), CommandFlags.None); - } - - [Fact] - public void StringBitPosition() - { - prefixed.StringBitPosition("key", true, 123, 456, CommandFlags.None); - mock.Received().StringBitPosition("prefix:key", true, 123, 456, CommandFlags.None); - } - - [Fact] - public void StringBitPosition_2() - { - prefixed.StringBitPosition("key", true, 123, 456, StringIndexType.Byte, CommandFlags.None); - mock.Received().StringBitPosition("prefix:key", true, 123, 456, StringIndexType.Byte, CommandFlags.None); - } - - [Fact] - public void StringDecrement_1() - { - prefixed.StringDecrement("key", 123, CommandFlags.None); - mock.Received().StringDecrement("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public void StringDecrement_2() - { - prefixed.StringDecrement("key", 1.23, CommandFlags.None); - mock.Received().StringDecrement("prefix:key", 1.23, CommandFlags.None); - } - - [Fact] - public void StringGet_1() - { - prefixed.StringGet("key", CommandFlags.None); - mock.Received().StringGet("prefix:key", CommandFlags.None); - } - - [Fact] - public void StringGet_2() - { - RedisKey[] keys = ["a", "b"]; - prefixed.StringGet(keys, CommandFlags.None); - mock.Received().StringGet(IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - - [Fact] - public void StringGetBit() - { - prefixed.StringGetBit("key", 123, CommandFlags.None); - mock.Received().StringGetBit("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public void StringGetRange() - { - prefixed.StringGetRange("key", 123, 456, CommandFlags.None); - mock.Received().StringGetRange("prefix:key", 123, 456, CommandFlags.None); - } - - [Fact] - public void StringGetSet() - { - prefixed.StringGetSet("key", "value", CommandFlags.None); - mock.Received().StringGetSet("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public void StringGetDelete() - { - prefixed.StringGetDelete("key", CommandFlags.None); - mock.Received().StringGetDelete("prefix:key", CommandFlags.None); - } - - [Fact] - public void StringGetWithExpiry() - { - prefixed.StringGetWithExpiry("key", CommandFlags.None); - mock.Received().StringGetWithExpiry("prefix:key", CommandFlags.None); - } - - [Fact] - public void StringIncrement_1() - { - prefixed.StringIncrement("key", 123, CommandFlags.None); - mock.Received().StringIncrement("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public void StringIncrement_2() - { - prefixed.StringIncrement("key", 1.23, CommandFlags.None); - mock.Received().StringIncrement("prefix:key", 1.23, CommandFlags.None); - } - - [Fact] - public void StringIncrement_3() - { - prefixed.StringIncrement("key", 123L, TimeSpan.FromSeconds(5), lowerBound: 10, upperBound: 200, flags: CommandFlags.None, options: IncrementOptions.None); - mock.Received().StringIncrement("prefix:key", 123L, TimeSpan.FromSeconds(5), 10, 200, IncrementOptions.None, CommandFlags.None); - } - - [Fact] - public void StringIncrement_4() - { - prefixed.StringIncrement("key", 1.23, TimeSpan.FromSeconds(5), lowerBound: -1.0, upperBound: 2.0, flags: CommandFlags.None, options: IncrementOptions.Saturate); - mock.Received().StringIncrement("prefix:key", 1.23, TimeSpan.FromSeconds(5), -1.0, 2.0, IncrementOptions.Saturate, CommandFlags.None); - } - - [Fact] - public void StringLength() - { - prefixed.StringLength("key", CommandFlags.None); - mock.Received().StringLength("prefix:key", CommandFlags.None); - } - - [Fact] - public void StringSet_1() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - prefixed.StringSet("key", "value", expiry, When.Exists, CommandFlags.None); - mock.Received().StringSet("prefix:key", "value", expiry, When.Exists, CommandFlags.None); - } - - [Fact] - public void StringSet_2() - { - TimeSpan? expiry = null; - prefixed.StringSet("key", "value", expiry, true, When.Exists, CommandFlags.None); - mock.Received().StringSet("prefix:key", "value", expiry, true, When.Exists, CommandFlags.None); - } - - [Fact] - public void StringSet_3() - { - KeyValuePair[] values = [new KeyValuePair("a", "x"), new KeyValuePair("b", "y")]; - Expression[]>> valid = _ => _.Length == 2 && _[0].Key == "prefix:a" && _[0].Value == "x" && _[1].Key == "prefix:b" && _[1].Value == "y"; - prefixed.StringSet(values, When.Exists, CommandFlags.None); - mock.Received().StringSet(Arg.Is(valid), When.Exists, CommandFlags.None); - } - - [Fact] - public void StringSet_Compat() - { - TimeSpan? expiry = null; - prefixed.StringSet("key", "value", expiry, When.Exists); - mock.Received().StringSet("prefix:key", "value", expiry, When.Exists); - } - - [Fact] - public void StringSetBit() - { - prefixed.StringSetBit("key", 123, true, CommandFlags.None); - mock.Received().StringSetBit("prefix:key", 123, true, CommandFlags.None); - } - - [Fact] - public void StringSetRange() - { - prefixed.StringSetRange("key", 123, "value", CommandFlags.None); - mock.Received().StringSetRange("prefix:key", 123, "value", CommandFlags.None); - } - - [Fact] - public void Execute_1() - { - prefixed.Execute("CUSTOM", "arg1", (RedisKey)"arg2"); - mock.Received().Execute("CUSTOM", Arg.Is(args => args.Length == 2 && args[0].Equals("arg1") && args[1].Equals((RedisKey)"prefix:arg2")), CommandFlags.None); - } - - [Fact] - public void Execute_2() - { - var args = new List { "arg1", (RedisKey)"arg2" }; - prefixed.Execute("CUSTOM", args, CommandFlags.None); - mock.Received().Execute("CUSTOM", Arg.Is>(a => a.Count == 2 && a.ElementAt(0).Equals("arg1") && a.ElementAt(1).Equals((RedisKey)"prefix:arg2"))!, CommandFlags.None); - } - - [Fact] - public void ExecuteResp_1() - { - // NB: ExecuteResp rents its inner RedisKeyOrValue[] from the ArrayPool and returns it - // (clearArray: true) as soon as the (mocked) inner call completes, so by the time - // mock.Received() re-evaluates its argument matcher, the array backing the recorded - // ReadOnlyMemory has already been zeroed. Capture a copy at call time instead. - RedisKeyOrValue[]? captured = null; - mock.ExecuteResp( - Arg.Any(), - Arg.Do>(m => captured = m.ToArray()), - Arg.Any()); - - RedisKeyOrValue[] args = [(RedisValue)"value1", (RedisKey)"key1", (RedisKey)"key2"]; - prefixed.ExecuteResp("CUSTOM", args, CommandFlags.None); - - mock.Received().ExecuteResp("CUSTOM", Arg.Any>(), CommandFlags.None); - Assert.NotNull(captured); - Assert.Equal( - [(RedisValue)"value1", (RedisKey)"prefix:key1", (RedisKey)"prefix:key2"], - captured); - } - - [Fact] - public void GeoAdd_1() - { - prefixed.GeoAdd("key", 1.23, 4.56, "member", CommandFlags.None); - mock.Received().GeoAdd("prefix:key", 1.23, 4.56, "member", CommandFlags.None); - } - - [Fact] - public void GeoAdd_2() - { - var geoEntry = new GeoEntry(1.23, 4.56, "member"); - prefixed.GeoAdd("key", geoEntry, CommandFlags.None); - mock.Received().GeoAdd("prefix:key", geoEntry, CommandFlags.None); - } - - [Fact] - public void GeoAdd_3() - { - var geoEntries = new GeoEntry[] { new GeoEntry(1.23, 4.56, "member1") }; - prefixed.GeoAdd("key", geoEntries, CommandFlags.None); - mock.Received().GeoAdd("prefix:key", geoEntries, CommandFlags.None); - } - - [Fact] - public void GeoRemove() - { - prefixed.GeoRemove("key", "member", CommandFlags.None); - mock.Received().GeoRemove("prefix:key", "member", CommandFlags.None); - } - - [Fact] - public void GeoDistance() - { - prefixed.GeoDistance("key", "member1", "member2", GeoUnit.Meters, CommandFlags.None); - mock.Received().GeoDistance("prefix:key", "member1", "member2", GeoUnit.Meters, CommandFlags.None); - } - - [Fact] - public void GeoHash_1() - { - prefixed.GeoHash("key", "member", CommandFlags.None); - mock.Received().GeoHash("prefix:key", "member", CommandFlags.None); - } - - [Fact] - public void GeoHash_2() - { - var members = new RedisValue[] { "member1", "member2" }; - prefixed.GeoHash("key", members, CommandFlags.None); - mock.Received().GeoHash("prefix:key", members, CommandFlags.None); - } - - [Fact] - public void GeoPosition_1() - { - prefixed.GeoPosition("key", "member", CommandFlags.None); - mock.Received().GeoPosition("prefix:key", "member", CommandFlags.None); - } - - [Fact] - public void GeoPosition_2() - { - var members = new RedisValue[] { "member1", "member2" }; - prefixed.GeoPosition("key", members, CommandFlags.None); - mock.Received().GeoPosition("prefix:key", members, CommandFlags.None); - } - - [Fact] - public void GeoRadius_1() - { - prefixed.GeoRadius("key", "member", 100, GeoUnit.Meters, 10, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - mock.Received().GeoRadius("prefix:key", "member", 100, GeoUnit.Meters, 10, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - } - - [Fact] - public void GeoRadius_2() - { - prefixed.GeoRadius("key", 1.23, 4.56, 100, GeoUnit.Meters, 10, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - mock.Received().GeoRadius("prefix:key", 1.23, 4.56, 100, GeoUnit.Meters, 10, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - } - - [Fact] - public void GeoSearch_1() - { - var shape = new GeoSearchCircle(100, GeoUnit.Meters); - prefixed.GeoSearch("key", "member", shape, 10, true, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - mock.Received().GeoSearch("prefix:key", "member", shape, 10, true, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - } - - [Fact] - public void GeoSearch_2() - { - var shape = new GeoSearchCircle(100, GeoUnit.Meters); - prefixed.GeoSearch("key", 1.23, 4.56, shape, 10, true, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - mock.Received().GeoSearch("prefix:key", 1.23, 4.56, shape, 10, true, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - } - - [Fact] - public void GeoSearchAndStore_1() - { - var shape = new GeoSearchCircle(100, GeoUnit.Meters); - prefixed.GeoSearchAndStore("source", "destination", "member", shape, 10, true, Order.Ascending, false, CommandFlags.None); - mock.Received().GeoSearchAndStore("prefix:source", "prefix:destination", "member", shape, 10, true, Order.Ascending, false, CommandFlags.None); - } - - [Fact] - public void GeoSearchAndStore_2() - { - var shape = new GeoSearchCircle(100, GeoUnit.Meters); - prefixed.GeoSearchAndStore("source", "destination", 1.23, 4.56, shape, 10, true, Order.Ascending, false, CommandFlags.None); - mock.Received().GeoSearchAndStore("prefix:source", "prefix:destination", 1.23, 4.56, shape, 10, true, Order.Ascending, false, CommandFlags.None); - } - - [Fact] - public void HashFieldExpire_1() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - var expiry = TimeSpan.FromSeconds(60); - prefixed.HashFieldExpire("key", hashFields, expiry, ExpireWhen.Always, CommandFlags.None); - mock.Received().HashFieldExpire("prefix:key", hashFields, expiry, ExpireWhen.Always, CommandFlags.None); - } - - [Fact] - public void HashFieldExpire_2() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - var expiry = DateTime.Now.AddMinutes(1); - prefixed.HashFieldExpire("key", hashFields, expiry, ExpireWhen.Always, CommandFlags.None); - mock.Received().HashFieldExpire("prefix:key", hashFields, expiry, ExpireWhen.Always, CommandFlags.None); - } - - [Fact] - public void HashFieldGetExpireDateTime() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - prefixed.HashFieldGetExpireDateTime("key", hashFields, CommandFlags.None); - mock.Received().HashFieldGetExpireDateTime("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public void HashFieldPersist() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - prefixed.HashFieldPersist("key", hashFields, CommandFlags.None); - mock.Received().HashFieldPersist("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public void HashFieldGetTimeToLive() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - prefixed.HashFieldGetTimeToLive("key", hashFields, CommandFlags.None); - mock.Received().HashFieldGetTimeToLive("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public void HashGetLease() - { - prefixed.HashGetLease("key", "field", CommandFlags.None); - mock.Received().HashGetLease("prefix:key", "field", CommandFlags.None); - } - - [Fact] - public void HashFieldGetAndDelete_1() - { - prefixed.HashFieldGetAndDelete("key", "field", CommandFlags.None); - mock.Received().HashFieldGetAndDelete("prefix:key", "field", CommandFlags.None); - } - - [Fact] - public void HashFieldGetAndDelete_2() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - prefixed.HashFieldGetAndDelete("key", hashFields, CommandFlags.None); - mock.Received().HashFieldGetAndDelete("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public void HashFieldGetLeaseAndDelete() - { - prefixed.HashFieldGetLeaseAndDelete("key", "field", CommandFlags.None); - mock.Received().HashFieldGetLeaseAndDelete("prefix:key", "field", CommandFlags.None); - } - - [Fact] - public void HashFieldGetAndSetExpiry_1() - { - var expiry = TimeSpan.FromMinutes(5); - prefixed.HashFieldGetAndSetExpiry("key", "field", expiry, false, CommandFlags.None); - mock.Received().HashFieldGetAndSetExpiry("prefix:key", "field", expiry, false, CommandFlags.None); - } - - [Fact] - public void HashFieldGetAndSetExpiry_2() - { - var expiry = DateTime.Now.AddMinutes(5); - prefixed.HashFieldGetAndSetExpiry("key", "field", expiry, CommandFlags.None); - mock.Received().HashFieldGetAndSetExpiry("prefix:key", "field", expiry, CommandFlags.None); - } - - [Fact] - public void HashFieldGetLeaseAndSetExpiry_1() - { - var expiry = TimeSpan.FromMinutes(5); - prefixed.HashFieldGetLeaseAndSetExpiry("key", "field", expiry, false, CommandFlags.None); - mock.Received().HashFieldGetLeaseAndSetExpiry("prefix:key", "field", expiry, false, CommandFlags.None); - } - - [Fact] - public void HashFieldGetLeaseAndSetExpiry_2() - { - var expiry = DateTime.Now.AddMinutes(5); - prefixed.HashFieldGetLeaseAndSetExpiry("key", "field", expiry, CommandFlags.None); - mock.Received().HashFieldGetLeaseAndSetExpiry("prefix:key", "field", expiry, CommandFlags.None); - } - [Fact] - public void StringGetLease() - { - prefixed.StringGetLease("key", CommandFlags.None); - mock.Received().StringGetLease("prefix:key", CommandFlags.None); - } - - [Fact] - public void StringGetSetExpiry_1() - { - var expiry = TimeSpan.FromMinutes(5); - prefixed.StringGetSetExpiry("key", expiry, CommandFlags.None); - mock.Received().StringGetSetExpiry("prefix:key", expiry, CommandFlags.None); - } - - [Fact] - public void StringGetSetExpiry_2() - { - var expiry = DateTime.Now.AddMinutes(5); - prefixed.StringGetSetExpiry("key", expiry, CommandFlags.None); - mock.Received().StringGetSetExpiry("prefix:key", expiry, CommandFlags.None); - } - - [Fact] - public void StringSetAndGet_1() - { - var expiry = TimeSpan.FromMinutes(5); - prefixed.StringSetAndGet("key", "value", expiry, When.Always, CommandFlags.None); - mock.Received().StringSetAndGet("prefix:key", "value", expiry, When.Always, CommandFlags.None); - } - - [Fact] - public void StringSetAndGet_2() - { - var expiry = TimeSpan.FromMinutes(5); - prefixed.StringSetAndGet("key", "value", expiry, false, When.Always, CommandFlags.None); - mock.Received().StringSetAndGet("prefix:key", "value", expiry, false, When.Always, CommandFlags.None); - } - [Fact] - public void StringLongestCommonSubsequence() - { - prefixed.StringLongestCommonSubsequence("key1", "key2", CommandFlags.None); - mock.Received().StringLongestCommonSubsequence("prefix:key1", "prefix:key2", CommandFlags.None); - } - - [Fact] - public void StringLongestCommonSubsequenceLength() - { - prefixed.StringLongestCommonSubsequenceLength("key1", "key2", CommandFlags.None); - mock.Received().StringLongestCommonSubsequenceLength("prefix:key1", "prefix:key2", CommandFlags.None); - } - - [Fact] - public void StringLongestCommonSubsequenceWithMatches() - { - prefixed.StringLongestCommonSubsequenceWithMatches("key1", "key2", 5, CommandFlags.None); - mock.Received().StringLongestCommonSubsequenceWithMatches("prefix:key1", "prefix:key2", 5, CommandFlags.None); - } - [Fact] - public void IsConnected() - { - prefixed.IsConnected("key", CommandFlags.None); - mock.Received().IsConnected("prefix:key", CommandFlags.None); - } - [Fact] - public void StreamAdd_WithTrimMode_1() - { - prefixed.StreamAdd("key", "field", "value", "*", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - mock.Received().StreamAdd("prefix:key", "field", "value", "*", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - } - - [Fact] - public void StreamAdd_WithTrimMode_2() - { - var fields = new NameValueEntry[] { new NameValueEntry("field", "value") }; - prefixed.StreamAdd("key", fields, "*", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - mock.Received().StreamAdd("prefix:key", fields, "*", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - } - - [Fact] - public void StreamAdd_WithOptions_1() - { - var options = new StreamAddOptions { MaxLength = 1000, CreateStream = false }; - prefixed.StreamAdd("key", "field", "value", options, CommandFlags.None); - mock.Received().StreamAdd("prefix:key", "field", "value", options, CommandFlags.None); - } - - [Fact] - public void StreamAdd_WithOptions_2() - { - var fields = new NameValueEntry[] { new NameValueEntry("field", "value") }; - var options = new StreamAddOptions { MinId = "5-5", CreateStream = false }; - prefixed.StreamAdd("key", fields, options, CommandFlags.None); - mock.Received().StreamAdd("prefix:key", fields, options, CommandFlags.None); - } - - [Fact] - public void StreamTrim_WithMode() - { - prefixed.StreamTrim("key", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - mock.Received().StreamTrim("prefix:key", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - } - - [Fact] - public void StreamTrimByMinId_WithMode() - { - prefixed.StreamTrimByMinId("key", "1111111111", false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - mock.Received().StreamTrimByMinId("prefix:key", "1111111111", false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - } - - [Fact] - public void StreamReadGroup_WithNoAck_1() - { - prefixed.StreamReadGroup("key", "group", "consumer", "0-0", 10, true, CommandFlags.None); - mock.Received().StreamReadGroup("prefix:key", "group", "consumer", "0-0", 10, true, CommandFlags.None); - } - - [Fact] - public void StreamReadGroup_WithNoAck_2() - { - var streamPositions = new StreamPosition[] { new StreamPosition("key", "0-0") }; - prefixed.StreamReadGroup(streamPositions, "group", "consumer", 10, true, CommandFlags.None); - mock.Received().StreamReadGroup(streamPositions, "group", "consumer", 10, true, CommandFlags.None); - } - - [Fact] - public void StreamTrim_Simple() - { - prefixed.StreamTrim("key", 1000, true, CommandFlags.None); - mock.Received().StreamTrim("prefix:key", 1000, true, CommandFlags.None); - } - - [Fact] - public void StreamReadGroup_Simple_1() - { - prefixed.StreamReadGroup("key", "group", "consumer", "0-0", 10, CommandFlags.None); - mock.Received().StreamReadGroup("prefix:key", "group", "consumer", "0-0", 10, CommandFlags.None); - } - - [Fact] - public void StreamReadGroup_Simple_2() - { - var streamPositions = new StreamPosition[] { new StreamPosition("key", "0-0") }; - prefixed.StreamReadGroup(streamPositions, "group", "consumer", 10, CommandFlags.None); - mock.Received().StreamReadGroup(streamPositions, "group", "consumer", 10, CommandFlags.None); - } -} diff --git a/tests/StackExchange.Redis.Tests/KeyPrefixedTests.cs b/tests/StackExchange.Redis.Tests/KeyPrefixedTests.cs deleted file mode 100644 index 5df1b380d7..0000000000 --- a/tests/StackExchange.Redis.Tests/KeyPrefixedTests.cs +++ /dev/null @@ -1,1804 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Linq.Expressions; -using System.Net; -using System.Text; -using System.Threading.Tasks; -using NSubstitute; -using StackExchange.Redis.KeyspaceIsolation; -using Xunit; -using static StackExchange.Redis.Tests.KeyPrefixedDatabaseTests; // for IsKeys etc - -namespace StackExchange.Redis.Tests -{ - [Collection(nameof(SubstituteDependentCollection))] - public sealed class KeyPrefixedTests - { - private readonly IDatabaseAsync mock; - private readonly KeyPrefixed prefixed; - - public KeyPrefixedTests() - { - mock = Substitute.For(); - prefixed = new KeyPrefixed(mock, Encoding.UTF8.GetBytes("prefix:")); - } - - [Fact] - public async Task DebugObjectAsync() - { - await prefixed.DebugObjectAsync("key", CommandFlags.None); - await mock.Received().DebugObjectAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task HashDecrementAsync_1() - { - await prefixed.HashDecrementAsync("key", "hashField", 123, CommandFlags.None); - await mock.Received().HashDecrementAsync("prefix:key", "hashField", 123, CommandFlags.None); - } - - [Fact] - public async Task HashDecrementAsync_2() - { - await prefixed.HashDecrementAsync("key", "hashField", 1.23, CommandFlags.None); - await mock.Received().HashDecrementAsync("prefix:key", "hashField", 1.23, CommandFlags.None); - } - - [Fact] - public async Task HashDeleteAsync_1() - { - await prefixed.HashDeleteAsync("key", "hashField", CommandFlags.None); - await mock.Received().HashDeleteAsync("prefix:key", "hashField", CommandFlags.None); - } - - [Fact] - public async Task HashDeleteAsync_2() - { - RedisValue[] hashFields = Array.Empty(); - await prefixed.HashDeleteAsync("key", hashFields, CommandFlags.None); - await mock.Received().HashDeleteAsync("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public async Task HashExistsAsync() - { - await prefixed.HashExistsAsync("key", "hashField", CommandFlags.None); - await mock.Received().HashExistsAsync("prefix:key", "hashField", CommandFlags.None); - } - - [Fact] - public async Task HashGetAllAsync() - { - await prefixed.HashGetAllAsync("key", CommandFlags.None); - await mock.Received().HashGetAllAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task HashGetAsync_1() - { - await prefixed.HashGetAsync("key", "hashField", CommandFlags.None); - await mock.Received().HashGetAsync("prefix:key", "hashField", CommandFlags.None); - } - - [Fact] - public async Task HashGetAsync_2() - { - RedisValue[] hashFields = Array.Empty(); - await prefixed.HashGetAsync("key", hashFields, CommandFlags.None); - await mock.Received().HashGetAsync("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public async Task HashIncrementAsync_1() - { - await prefixed.HashIncrementAsync("key", "hashField", 123, CommandFlags.None); - await mock.Received().HashIncrementAsync("prefix:key", "hashField", 123, CommandFlags.None); - } - - [Fact] - public async Task HashIncrementAsync_2() - { - await prefixed.HashIncrementAsync("key", "hashField", 1.23, CommandFlags.None); - await mock.Received().HashIncrementAsync("prefix:key", "hashField", 1.23, CommandFlags.None); - } - - [Fact] - public async Task StringIncrementAsync_3() - { - await prefixed.StringIncrementAsync("key", 123L, TimeSpan.FromSeconds(5), lowerBound: 10, upperBound: 200, flags: CommandFlags.None, options: IncrementOptions.None); - await mock.Received().StringIncrementAsync("prefix:key", 123L, TimeSpan.FromSeconds(5), 10, 200, IncrementOptions.None, CommandFlags.None); - } - - [Fact] - public async Task StringIncrementAsync_4() - { - await prefixed.StringIncrementAsync("key", 1.23, TimeSpan.FromSeconds(5), lowerBound: -1.0, upperBound: 2.0, flags: CommandFlags.None, options: IncrementOptions.Saturate); - await mock.Received().StringIncrementAsync("prefix:key", 1.23, TimeSpan.FromSeconds(5), -1.0, 2.0, IncrementOptions.Saturate, CommandFlags.None); - } - - [Fact] - public async Task HashKeysAsync() - { - await prefixed.HashKeysAsync("key", CommandFlags.None); - await mock.Received().HashKeysAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task HashLengthAsync() - { - await prefixed.HashLengthAsync("key", CommandFlags.None); - await mock.Received().HashLengthAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task HashSetAsync_1() - { - HashEntry[] hashFields = Array.Empty(); - await prefixed.HashSetAsync("key", hashFields, CommandFlags.None); - await mock.Received().HashSetAsync("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public async Task HashSetAsync_2() - { - await prefixed.HashSetAsync("key", "hashField", "value", When.Exists, CommandFlags.None); - await mock.Received().HashSetAsync("prefix:key", "hashField", "value", When.Exists, CommandFlags.None); - } - - [Fact] - public async Task HashStringLengthAsync() - { - await prefixed.HashStringLengthAsync("key", "field", CommandFlags.None); - await mock.Received().HashStringLengthAsync("prefix:key", "field", CommandFlags.None); - } - - [Fact] - public async Task HashValuesAsync() - { - await prefixed.HashValuesAsync("key", CommandFlags.None); - await mock.Received().HashValuesAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task HyperLogLogAddAsync_1() - { - await prefixed.HyperLogLogAddAsync("key", "value", CommandFlags.None); - await mock.Received().HyperLogLogAddAsync("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public async Task HyperLogLogAddAsync_2() - { - var values = Array.Empty(); - await prefixed.HyperLogLogAddAsync("key", values, CommandFlags.None); - await mock.Received().HyperLogLogAddAsync("prefix:key", values, CommandFlags.None); - } - - [Fact] - public async Task HyperLogLogLengthAsync() - { - await prefixed.HyperLogLogLengthAsync("key", CommandFlags.None); - await mock.Received().HyperLogLogLengthAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task HyperLogLogMergeAsync_1() - { - await prefixed.HyperLogLogMergeAsync("destination", "first", "second", CommandFlags.None); - await mock.Received().HyperLogLogMergeAsync("prefix:destination", "prefix:first", "prefix:second", CommandFlags.None); - } - - [Fact] - public async Task HyperLogLogMergeAsync_2() - { - RedisKey[] keys = ["a", "b"]; - await prefixed.HyperLogLogMergeAsync("destination", keys, CommandFlags.None); - await mock.Received().HyperLogLogMergeAsync("prefix:destination", IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - - [Fact] - public async Task IdentifyEndpointAsync() - { - await prefixed.IdentifyEndpointAsync("key", CommandFlags.None); - await mock.Received().IdentifyEndpointAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public void IsConnected() - { - prefixed.IsConnected("key", CommandFlags.None); - mock.Received().IsConnected("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task KeyCopyAsync() - { - await prefixed.KeyCopyAsync("key", "destination", flags: CommandFlags.None); - await mock.Received().KeyCopyAsync("prefix:key", "prefix:destination", -1, false, CommandFlags.None); - } - - [Fact] - public async Task KeyDeleteAsync_1() - { - await prefixed.KeyDeleteAsync("key", CommandFlags.None); - await mock.Received().KeyDeleteAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task KeyDeleteAsync_2() - { - RedisKey[] keys = ["a", "b"]; - await prefixed.KeyDeleteAsync(keys, CommandFlags.None); - await mock.Received().KeyDeleteAsync(IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - - [Fact] - public async Task KeyDumpAsync() - { - await prefixed.KeyDumpAsync("key", CommandFlags.None); - await mock.Received().KeyDumpAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task KeyEncodingAsync() - { - await prefixed.KeyEncodingAsync("key", CommandFlags.None); - await mock.Received().KeyEncodingAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task KeyExistsAsync() - { - await prefixed.KeyExistsAsync("key", CommandFlags.None); - await mock.Received().KeyExistsAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task KeyExpireAsync_1() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - await prefixed.KeyExpireAsync("key", expiry, CommandFlags.None); - await mock.Received().KeyExpireAsync("prefix:key", expiry, CommandFlags.None); - } - - [Fact] - public async Task KeyExpireAsync_2() - { - DateTime expiry = DateTime.Now; - await prefixed.KeyExpireAsync("key", expiry, CommandFlags.None); - await mock.Received().KeyExpireAsync("prefix:key", expiry, CommandFlags.None); - } - - [Fact] - public async Task KeyExpireAsync_3() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - await prefixed.KeyExpireAsync("key", expiry, ExpireWhen.HasNoExpiry, CommandFlags.None); - await mock.Received().KeyExpireAsync("prefix:key", expiry, ExpireWhen.HasNoExpiry, CommandFlags.None); - } - - [Fact] - public async Task KeyExpireAsync_4() - { - DateTime expiry = DateTime.Now; - await prefixed.KeyExpireAsync("key", expiry, ExpireWhen.HasNoExpiry, CommandFlags.None); - await mock.Received().KeyExpireAsync("prefix:key", expiry, ExpireWhen.HasNoExpiry, CommandFlags.None); - } - - [Fact] - public async Task KeyExpireTimeAsync() - { - await prefixed.KeyExpireTimeAsync("key", CommandFlags.None); - await mock.Received().KeyExpireTimeAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task KeyFrequencyAsync() - { - await prefixed.KeyFrequencyAsync("key", CommandFlags.None); - await mock.Received().KeyFrequencyAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task KeyMigrateAsync() - { - EndPoint toServer = new IPEndPoint(IPAddress.Loopback, 123); - await prefixed.KeyMigrateAsync("key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.None); - await mock.Received().KeyMigrateAsync("prefix:key", toServer, 123, 456, MigrateOptions.Copy, CommandFlags.None); - } - - [Fact] - public async Task KeyMoveAsync() - { - await prefixed.KeyMoveAsync("key", 123, CommandFlags.None); - await mock.Received().KeyMoveAsync("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public async Task KeyPersistAsync() - { - await prefixed.KeyPersistAsync("key", CommandFlags.None); - await mock.Received().KeyPersistAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public Task KeyRandomAsync() - { - return Assert.ThrowsAsync(() => prefixed.KeyRandomAsync()); - } - - [Fact] - public async Task KeyRefCountAsync() - { - await prefixed.KeyRefCountAsync("key", CommandFlags.None); - await mock.Received().KeyRefCountAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task KeyRenameAsync() - { - await prefixed.KeyRenameAsync("key", "newKey", When.Exists, CommandFlags.None); - await mock.Received().KeyRenameAsync("prefix:key", "prefix:newKey", When.Exists, CommandFlags.None); - } - - [Fact] - public async Task KeyRestoreAsync() - { - byte[] value = Array.Empty(); - TimeSpan expiry = TimeSpan.FromSeconds(123); - await prefixed.KeyRestoreAsync("key", value, expiry, CommandFlags.None); - await mock.Received().KeyRestoreAsync("prefix:key", value, expiry, CommandFlags.None); - } - - [Fact] - public async Task KeyTimeToLiveAsync() - { - await prefixed.KeyTimeToLiveAsync("key", CommandFlags.None); - await mock.Received().KeyTimeToLiveAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task KeyTypeAsync() - { - await prefixed.KeyTypeAsync("key", CommandFlags.None); - await mock.Received().KeyTypeAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task ListGetByIndexAsync() - { - await prefixed.ListGetByIndexAsync("key", 123, CommandFlags.None); - await mock.Received().ListGetByIndexAsync("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public async Task ListInsertAfterAsync() - { - await prefixed.ListInsertAfterAsync("key", "pivot", "value", CommandFlags.None); - await mock.Received().ListInsertAfterAsync("prefix:key", "pivot", "value", CommandFlags.None); - } - - [Fact] - public async Task ListInsertBeforeAsync() - { - await prefixed.ListInsertBeforeAsync("key", "pivot", "value", CommandFlags.None); - await mock.Received().ListInsertBeforeAsync("prefix:key", "pivot", "value", CommandFlags.None); - } - - [Fact] - public async Task ListLeftPopAsync() - { - await prefixed.ListLeftPopAsync("key", CommandFlags.None); - await mock.Received().ListLeftPopAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task ListLeftPopAsync_1() - { - await prefixed.ListLeftPopAsync("key", 123, CommandFlags.None); - await mock.Received().ListLeftPopAsync("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public async Task ListLeftPushAsync_1() - { - await prefixed.ListLeftPushAsync("key", "value", When.Exists, CommandFlags.None); - await mock.Received().ListLeftPushAsync("prefix:key", "value", When.Exists, CommandFlags.None); - } - - [Fact] - public async Task ListLeftPushAsync_2() - { - RedisValue[] values = Array.Empty(); - await prefixed.ListLeftPushAsync("key", values, CommandFlags.None); - await mock.Received().ListLeftPushAsync("prefix:key", values, CommandFlags.None); - } - - [Fact] - public async Task ListLeftPushAsync_3() - { - RedisValue[] values = ["value1", "value2"]; - await prefixed.ListLeftPushAsync("key", values, When.Exists, CommandFlags.None); - await mock.Received().ListLeftPushAsync("prefix:key", values, When.Exists, CommandFlags.None); - } - - [Fact] - public async Task ListLengthAsync() - { - await prefixed.ListLengthAsync("key", CommandFlags.None); - await mock.Received().ListLengthAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task ListMoveAsync() - { - await prefixed.ListMoveAsync("key", "destination", ListSide.Left, ListSide.Right, CommandFlags.None); - await mock.Received().ListMoveAsync("prefix:key", "prefix:destination", ListSide.Left, ListSide.Right, CommandFlags.None); - } - - [Fact] - public async Task ListRangeAsync() - { - await prefixed.ListRangeAsync("key", 123, 456, CommandFlags.None); - await mock.Received().ListRangeAsync("prefix:key", 123, 456, CommandFlags.None); - } - - [Fact] - public async Task ListRemoveAsync() - { - await prefixed.ListRemoveAsync("key", "value", 123, CommandFlags.None); - await mock.Received().ListRemoveAsync("prefix:key", "value", 123, CommandFlags.None); - } - - [Fact] - public async Task ListRightPopAsync() - { - await prefixed.ListRightPopAsync("key", CommandFlags.None); - await mock.Received().ListRightPopAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task ListRightPopAsync_1() - { - await prefixed.ListRightPopAsync("key", 123, CommandFlags.None); - await mock.Received().ListRightPopAsync("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public async Task ListRightPopLeftPushAsync() - { - await prefixed.ListRightPopLeftPushAsync("source", "destination", CommandFlags.None); - await mock.Received().ListRightPopLeftPushAsync("prefix:source", "prefix:destination", CommandFlags.None); - } - - [Fact] - public async Task ListRightPushAsync_1() - { - await prefixed.ListRightPushAsync("key", "value", When.Exists, CommandFlags.None); - await mock.Received().ListRightPushAsync("prefix:key", "value", When.Exists, CommandFlags.None); - } - - [Fact] - public async Task ListRightPushAsync_2() - { - RedisValue[] values = Array.Empty(); - await prefixed.ListRightPushAsync("key", values, CommandFlags.None); - await mock.Received().ListRightPushAsync("prefix:key", values, CommandFlags.None); - } - - [Fact] - public async Task ListRightPushAsync_3() - { - RedisValue[] values = ["value1", "value2"]; - await prefixed.ListRightPushAsync("key", values, When.Exists, CommandFlags.None); - await mock.Received().ListRightPushAsync("prefix:key", values, When.Exists, CommandFlags.None); - } - - [Fact] - public async Task ListSetByIndexAsync() - { - await prefixed.ListSetByIndexAsync("key", 123, "value", CommandFlags.None); - await mock.Received().ListSetByIndexAsync("prefix:key", 123, "value", CommandFlags.None); - } - - [Fact] - public async Task ListTrimAsync() - { - await prefixed.ListTrimAsync("key", 123, 456, CommandFlags.None); - await mock.Received().ListTrimAsync("prefix:key", 123, 456, CommandFlags.None); - } - - [Fact] - public async Task LockExtendAsync() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - await prefixed.LockExtendAsync("key", "value", expiry, CommandFlags.None); - await mock.Received().LockExtendAsync("prefix:key", "value", expiry, CommandFlags.None); - } - - [Fact] - public async Task LockQueryAsync() - { - await prefixed.LockQueryAsync("key", CommandFlags.None); - await mock.Received().LockQueryAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task LockReleaseAsync() - { - await prefixed.LockReleaseAsync("key", "value", CommandFlags.None); - await mock.Received().LockReleaseAsync("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public async Task LockTakeAsync() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - await prefixed.LockTakeAsync("key", "value", expiry, CommandFlags.None); - await mock.Received().LockTakeAsync("prefix:key", "value", expiry, CommandFlags.None); - } - - [Fact] - public async Task PublishAsync() - { - await prefixed.PublishAsync(RedisChannel.Literal("channel"), "message", CommandFlags.None); - await mock.Received().PublishAsync(RedisChannel.Literal("prefix:channel"), "message", CommandFlags.None); - } - - [Fact] - public async Task ScriptEvaluateAsync_1() - { - byte[] hash = Array.Empty(); - RedisValue[] values = Array.Empty(); - RedisKey[] keys = ["a", "b"]; - await prefixed.ScriptEvaluateAsync(hash, keys, values, CommandFlags.None); - await mock.Received().ScriptEvaluateAsync(hash, IsKeys("prefix:a", "prefix:b"), values, CommandFlags.None); - } - - [Fact] - public async Task ScriptEvaluateAsync_2() - { - RedisValue[] values = Array.Empty(); - RedisKey[] keys = ["a", "b"]; - await prefixed.ScriptEvaluateAsync("script", keys, values, CommandFlags.None); - await mock.Received().ScriptEvaluateAsync(script: "script", keys: IsKeys("prefix:a", "prefix:b"), values: values, flags: CommandFlags.None); - } - - [Fact] - public async Task SetAddAsync_1() - { - await prefixed.SetAddAsync("key", "value", CommandFlags.None); - await mock.Received().SetAddAsync("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public async Task SetAddAsync_2() - { - RedisValue[] values = Array.Empty(); - await prefixed.SetAddAsync("key", values, CommandFlags.None); - await mock.Received().SetAddAsync("prefix:key", values, CommandFlags.None); - } - - [Fact] - public async Task SetCombineAndStoreAsync_1() - { - await prefixed.SetCombineAndStoreAsync(SetOperation.Intersect, "destination", "first", "second", CommandFlags.None); - await mock.Received().SetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.None); - } - - [Fact] - public async Task SetCombineAndStoreAsync_2() - { - RedisKey[] keys = ["a", "b"]; - await prefixed.SetCombineAndStoreAsync(SetOperation.Intersect, "destination", keys, CommandFlags.None); - await mock.Received().SetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - - [Fact] - public async Task SetCombineAsync_1() - { - await prefixed.SetCombineAsync(SetOperation.Intersect, "first", "second", CommandFlags.None); - await mock.Received().SetCombineAsync(SetOperation.Intersect, "prefix:first", "prefix:second", CommandFlags.None); - } - - [Fact] - public async Task SetCombineAsync_2() - { - RedisKey[] keys = ["a", "b"]; - await prefixed.SetCombineAsync(SetOperation.Intersect, keys, CommandFlags.None); - await mock.Received().SetCombineAsync(SetOperation.Intersect, IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - - [Fact] - public async Task SetContainsAsync() - { - await prefixed.SetContainsAsync("key", "value", CommandFlags.None); - await mock.Received().SetContainsAsync("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public async Task SetContainsAsync_2() - { - RedisValue[] values = ["value1", "value2"]; - await prefixed.SetContainsAsync("key", values, CommandFlags.None); - await mock.Received().SetContainsAsync("prefix:key", values, CommandFlags.None); - } - - [Fact] - public async Task SetIntersectionLengthAsync() - { - await prefixed.SetIntersectionLengthAsync(["key1", "key2"]); - await mock.Received().SetIntersectionLengthAsync(IsKeys("prefix:key1", "prefix:key2"), 0, CommandFlags.None); - } - - [Fact] - public async Task SetCombineLengthAsync() - { - await prefixed.SetCombineLengthAsync(SetOperation.Union, ["key1", "key2"]); - await mock.Received().SetCombineLengthAsync(SetOperation.Union, IsKeys("prefix:key1", "prefix:key2"), 0, false, CommandFlags.None); - } - - [Fact] - public async Task SetLengthAsync() - { - await prefixed.SetLengthAsync("key", CommandFlags.None); - await mock.Received().SetLengthAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task SetMembersAsync() - { - await prefixed.SetMembersAsync("key", CommandFlags.None); - await mock.Received().SetMembersAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task SetMoveAsync() - { - await prefixed.SetMoveAsync("source", "destination", "value", CommandFlags.None); - await mock.Received().SetMoveAsync("prefix:source", "prefix:destination", "value", CommandFlags.None); - } - - [Fact] - public async Task SetPopAsync_1() - { - await prefixed.SetPopAsync("key", CommandFlags.None); - await mock.Received().SetPopAsync("prefix:key", CommandFlags.None); - - await prefixed.SetPopAsync("key", 5, CommandFlags.None); - await mock.Received().SetPopAsync("prefix:key", 5, CommandFlags.None); - } - - [Fact] - public async Task SetPopAsync_2() - { - await prefixed.SetPopAsync("key", 5, CommandFlags.None); - await mock.Received().SetPopAsync("prefix:key", 5, CommandFlags.None); - } - - [Fact] - public async Task SetRandomMemberAsync() - { - await prefixed.SetRandomMemberAsync("key", CommandFlags.None); - await mock.Received().SetRandomMemberAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task SetRandomMembersAsync() - { - await prefixed.SetRandomMembersAsync("key", 123, CommandFlags.None); - await mock.Received().SetRandomMembersAsync("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public async Task SetRemoveAsync_1() - { - await prefixed.SetRemoveAsync("key", "value", CommandFlags.None); - await mock.Received().SetRemoveAsync("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public async Task SetRemoveAsync_2() - { - RedisValue[] values = Array.Empty(); - await prefixed.SetRemoveAsync("key", values, CommandFlags.None); - await mock.Received().SetRemoveAsync("prefix:key", values, CommandFlags.None); - } - - [Fact] - public async Task SortAndStoreAsync() - { - RedisValue[] get = ["a", "#"]; - - await prefixed.SortAndStoreAsync("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.None); - await prefixed.SortAndStoreAsync("destination", "key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.None); - - await mock.Received().SortAndStoreAsync("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", IsValues("prefix:a", "#"), CommandFlags.None); - await mock.Received().SortAndStoreAsync("prefix:destination", "prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", IsValues("prefix:a", "#"), CommandFlags.None); - } - - [Fact] - public async Task SortAsync() - { - RedisValue[] get = ["a", "#"]; - - await prefixed.SortAsync("key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", get, CommandFlags.None); - await prefixed.SortAsync("key", 123, 456, Order.Descending, SortType.Alphabetic, "by", get, CommandFlags.None); - - await mock.Received().SortAsync("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "nosort", IsValues("prefix:a", "#"), CommandFlags.None); - await mock.Received().SortAsync("prefix:key", 123, 456, Order.Descending, SortType.Alphabetic, "prefix:by", IsValues("prefix:a", "#"), CommandFlags.None); - } - - [Fact] - public async Task SortedSetAddAsync_1() - { - await prefixed.SortedSetAddAsync("key", "member", 1.23, When.Exists, CommandFlags.None); - await mock.Received().SortedSetAddAsync("prefix:key", "member", 1.23, When.Exists, CommandFlags.None); - } - - [Fact] - public async Task SortedSetAddAsync_2() - { - SortedSetEntry[] values = Array.Empty(); - await prefixed.SortedSetAddAsync("key", values, When.Exists, CommandFlags.None); - await mock.Received().SortedSetAddAsync("prefix:key", values, When.Exists, CommandFlags.None); - } - - [Fact] - public async Task SortedSetAddAsync_3() - { - SortedSetEntry[] values = Array.Empty(); - await prefixed.SortedSetAddAsync("key", values, SortedSetWhen.GreaterThan, CommandFlags.None); - await mock.Received().SortedSetAddAsync("prefix:key", values, SortedSetWhen.GreaterThan, CommandFlags.None); - } - - [Fact] - public async Task SortedSetCombineAsync() - { - await prefixed.SortedSetCombineAsync(SetOperation.Intersect, ["a", "b"]); - await mock.Received().SortedSetCombineAsync(SetOperation.Intersect, IsKeys("prefix:a", "prefix:b"), null, Aggregate.Sum, CommandFlags.None); - } - - [Fact] - public async Task SortedSetCombineWithScoresAsync() - { - await prefixed.SortedSetCombineWithScoresAsync(SetOperation.Intersect, ["a", "b"]); - await mock.Received().SortedSetCombineWithScoresAsync(SetOperation.Intersect, IsKeys("prefix:a", "prefix:b"), null, Aggregate.Sum, CommandFlags.None); - } - - [Fact] - public async Task SortedSetCombineAndStoreAsync_1() - { - await prefixed.SortedSetCombineAndStoreAsync(SetOperation.Intersect, "destination", "first", "second", Aggregate.Max, CommandFlags.None); - await mock.Received().SortedSetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", "prefix:first", "prefix:second", Aggregate.Max, CommandFlags.None); - } - - [Fact] - public async Task SortedSetCombineAndStoreAsync_2() - { - RedisKey[] keys = ["a", "b"]; - await prefixed.SetCombineAndStoreAsync(SetOperation.Intersect, "destination", keys, CommandFlags.None); - await mock.Received().SetCombineAndStoreAsync(SetOperation.Intersect, "prefix:destination", IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - - [Fact] - public async Task SortedSetDecrementAsync() - { - await prefixed.SortedSetDecrementAsync("key", "member", 1.23, CommandFlags.None); - await mock.Received().SortedSetDecrementAsync("prefix:key", "member", 1.23, CommandFlags.None); - } - - [Fact] - public async Task SortedSetIncrementAsync() - { - await prefixed.SortedSetIncrementAsync("key", "member", 1.23, CommandFlags.None); - await mock.Received().SortedSetIncrementAsync("prefix:key", "member", 1.23, CommandFlags.None); - } - - [Fact] - public async Task SortedSetIncrementAsync_When() - { - await prefixed.SortedSetIncrementAsync("key", "member", 1.23, ValueCondition.Exists, CommandFlags.None); - await mock.Received().SortedSetIncrementAsync("prefix:key", "member", 1.23, ValueCondition.Exists, CommandFlags.None); - } - - [Fact] - public async Task SortedSetIntersectionLengthAsync() - { - await prefixed.SortedSetIntersectionLengthAsync(["a", "b"], 1, CommandFlags.None); - await mock.Received().SortedSetIntersectionLengthAsync(IsKeys("prefix:a", "prefix:b"), 1, CommandFlags.None); - } - - [Fact] - public async Task SortedSetLengthAsync() - { - await prefixed.SortedSetLengthAsync("key", 1.23, 1.23, Exclude.Start, CommandFlags.None); - await mock.Received().SortedSetLengthAsync("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.None); - } - - [Fact] - public async Task SortedSetLengthByValueAsync() - { - await prefixed.SortedSetLengthByValueAsync("key", "min", "max", Exclude.Start, CommandFlags.None); - await mock.Received().SortedSetLengthByValueAsync("prefix:key", "min", "max", Exclude.Start, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRandomMemberAsync() - { - await prefixed.SortedSetRandomMemberAsync("key", CommandFlags.None); - await mock.Received().SortedSetRandomMemberAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task SortedSetRandomMembersAsync() - { - await prefixed.SortedSetRandomMembersAsync("key", 2, CommandFlags.None); - await mock.Received().SortedSetRandomMembersAsync("prefix:key", 2, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRandomMemberWithScoresAsync() - { - await prefixed.SortedSetRandomMembersWithScoresAsync("key", 2, CommandFlags.None); - await mock.Received().SortedSetRandomMembersWithScoresAsync("prefix:key", 2, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRangeByRankAsync() - { - await prefixed.SortedSetRangeByRankAsync("key", 123, 456, Order.Descending, CommandFlags.None); - await mock.Received().SortedSetRangeByRankAsync("prefix:key", 123, 456, Order.Descending, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRangeByRankWithScoresAsync() - { - await prefixed.SortedSetRangeByRankWithScoresAsync("key", 123, 456, Order.Descending, CommandFlags.None); - await mock.Received().SortedSetRangeByRankWithScoresAsync("prefix:key", 123, 456, Order.Descending, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRangeByScoreAsync() - { - await prefixed.SortedSetRangeByScoreAsync("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - await mock.Received().SortedSetRangeByScoreAsync("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRangeByScoreWithScoresAsync() - { - await prefixed.SortedSetRangeByScoreWithScoresAsync("key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - await mock.Received().SortedSetRangeByScoreWithScoresAsync("prefix:key", 1.23, 1.23, Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRangeByValueAsync() - { - await prefixed.SortedSetRangeByValueAsync("key", "min", "max", Exclude.Start, 123, 456, CommandFlags.None); - await mock.Received().SortedSetRangeByValueAsync("prefix:key", "min", "max", Exclude.Start, Order.Ascending, 123, 456, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRangeByValueDescAsync() - { - await prefixed.SortedSetRangeByValueAsync("key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - await mock.Received().SortedSetRangeByValueAsync("prefix:key", "min", "max", Exclude.Start, Order.Descending, 123, 456, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRankAsync() - { - await prefixed.SortedSetRankAsync("key", "member", Order.Descending, CommandFlags.None); - await mock.Received().SortedSetRankAsync("prefix:key", "member", Order.Descending, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRemoveAsync_1() - { - await prefixed.SortedSetRemoveAsync("key", "member", CommandFlags.None); - await mock.Received().SortedSetRemoveAsync("prefix:key", "member", CommandFlags.None); - } - - [Fact] - public async Task SortedSetRemoveAsync_2() - { - RedisValue[] members = Array.Empty(); - await prefixed.SortedSetRemoveAsync("key", members, CommandFlags.None); - await mock.Received().SortedSetRemoveAsync("prefix:key", members, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRemoveRangeByRankAsync() - { - await prefixed.SortedSetRemoveRangeByRankAsync("key", 123, 456, CommandFlags.None); - await mock.Received().SortedSetRemoveRangeByRankAsync("prefix:key", 123, 456, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRemoveRangeByScoreAsync() - { - await prefixed.SortedSetRemoveRangeByScoreAsync("key", 1.23, 1.23, Exclude.Start, CommandFlags.None); - await mock.Received().SortedSetRemoveRangeByScoreAsync("prefix:key", 1.23, 1.23, Exclude.Start, CommandFlags.None); - } - - [Fact] - public async Task SortedSetRemoveRangeByValueAsync() - { - await prefixed.SortedSetRemoveRangeByValueAsync("key", "min", "max", Exclude.Start, CommandFlags.None); - await mock.Received().SortedSetRemoveRangeByValueAsync("prefix:key", "min", "max", Exclude.Start, CommandFlags.None); - } - - [Fact] - public async Task SortedSetScoreAsync() - { - await prefixed.SortedSetScoreAsync("key", "member", CommandFlags.None); - await mock.Received().SortedSetScoreAsync("prefix:key", "member", CommandFlags.None); - } - - [Fact] - public async Task SortedSetScoreAsync_Multiple() - { - var values = new RedisValue[] { "member1", "member2" }; - await prefixed.SortedSetScoresAsync("key", values, CommandFlags.None); - await mock.Received().SortedSetScoresAsync("prefix:key", values, CommandFlags.None); - } - - [Fact] - public async Task SortedSetUpdateAsync() - { - SortedSetEntry[] values = Array.Empty(); - await prefixed.SortedSetUpdateAsync("key", values, SortedSetWhen.GreaterThan, CommandFlags.None); - await mock.Received().SortedSetUpdateAsync("prefix:key", values, SortedSetWhen.GreaterThan, CommandFlags.None); - } - - [Fact] - public async Task StreamAcknowledgeAsync_1() - { - await prefixed.StreamAcknowledgeAsync("key", "group", "0-0", CommandFlags.None); - await mock.Received().StreamAcknowledgeAsync("prefix:key", "group", "0-0", CommandFlags.None); - } - - [Fact] - public async Task StreamAcknowledgeAsync_2() - { - var messageIds = new RedisValue[] { "0-0", "0-1", "0-2" }; - await prefixed.StreamAcknowledgeAsync("key", "group", messageIds, CommandFlags.None); - await mock.Received().StreamAcknowledgeAsync("prefix:key", "group", messageIds, CommandFlags.None); - } - - [Fact] - public async Task StreamNegativeAcknowledgeAsync_1() - { - await prefixed.StreamNegativeAcknowledgeAsync("key", "group", StreamNackMode.Fail, "0-0", CommandFlags.None); - await mock.Received().StreamNegativeAcknowledgeAsync("prefix:key", "group", StreamNackMode.Fail, "0-0", CommandFlags.None); - } - - [Fact] - public async Task StreamNegativeAcknowledgeAsync_2() - { - var messageIds = new RedisValue[] { "0-0", "0-1", "0-2" }; - await prefixed.StreamNegativeAcknowledgeAsync("key", "group", StreamNackMode.Fail, messageIds, CommandFlags.None); - await mock.Received().StreamNegativeAcknowledgeAsync("prefix:key", "group", StreamNackMode.Fail, messageIds, CommandFlags.None); - } - - [Fact] - public async Task StreamAddAsync_1() - { - await prefixed.StreamAddAsync("key", "field1", "value1", "*", 1000, true, CommandFlags.None); - await mock.Received().StreamAddAsync("prefix:key", "field1", "value1", "*", 1000, true, CommandFlags.None); - } - - [Fact] - public async Task StreamAddAsync_2() - { - var fields = Array.Empty(); - await prefixed.StreamAddAsync("key", fields, "*", 1000, true, CommandFlags.None); - await mock.Received().StreamAddAsync("prefix:key", fields, "*", 1000, true, CommandFlags.None); - } - - [Fact] - public async Task StreamAutoClaimAsync() - { - await prefixed.StreamAutoClaimAsync("key", "group", "consumer", 0, "0-0", 100, CommandFlags.None); - await mock.Received().StreamAutoClaimAsync("prefix:key", "group", "consumer", 0, "0-0", 100, CommandFlags.None); - } - - [Fact] - public async Task StreamAutoClaimIdsOnlyAsync() - { - await prefixed.StreamAutoClaimIdsOnlyAsync("key", "group", "consumer", 0, "0-0", 100, CommandFlags.None); - await mock.Received().StreamAutoClaimIdsOnlyAsync("prefix:key", "group", "consumer", 0, "0-0", 100, CommandFlags.None); - } - - [Fact] - public async Task StreamClaimMessagesAsync() - { - var messageIds = Array.Empty(); - await prefixed.StreamClaimAsync("key", "group", "consumer", 1000, messageIds, CommandFlags.None); - await mock.Received().StreamClaimAsync("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.None); - } - - [Fact] - public async Task StreamClaimMessagesReturningIdsAsync() - { - var messageIds = Array.Empty(); - await prefixed.StreamClaimIdsOnlyAsync("key", "group", "consumer", 1000, messageIds, CommandFlags.None); - await mock.Received().StreamClaimIdsOnlyAsync("prefix:key", "group", "consumer", 1000, messageIds, CommandFlags.None); - } - - [Fact] - public async Task StreamConsumerInfoGetAsync() - { - await prefixed.StreamConsumerInfoAsync("key", "group", CommandFlags.None); - await mock.Received().StreamConsumerInfoAsync("prefix:key", "group", CommandFlags.None); - } - - [Fact] - public async Task StreamConsumerGroupSetPositionAsync() - { - await prefixed.StreamConsumerGroupSetPositionAsync("key", "group", StreamPosition.Beginning, CommandFlags.None); - await mock.Received().StreamConsumerGroupSetPositionAsync("prefix:key", "group", StreamPosition.Beginning, CommandFlags.None); - } - - [Fact] - public async Task StreamCreateConsumerGroupAsync() - { - await prefixed.StreamCreateConsumerGroupAsync("key", "group", "0-0", false, CommandFlags.None); - await mock.Received().StreamCreateConsumerGroupAsync("prefix:key", "group", "0-0", false, CommandFlags.None); - } - - [Fact] - public async Task StreamGroupInfoGetAsync() - { - await prefixed.StreamGroupInfoAsync("key", CommandFlags.None); - await mock.Received().StreamGroupInfoAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task StreamInfoGetAsync() - { - await prefixed.StreamInfoAsync("key", CommandFlags.None); - await mock.Received().StreamInfoAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task StreamLengthAsync() - { - await prefixed.StreamLengthAsync("key", CommandFlags.None); - await mock.Received().StreamLengthAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task StreamMessagesDeleteAsync() - { - var messageIds = Array.Empty(); - await prefixed.StreamDeleteAsync("key", messageIds, CommandFlags.None); - await mock.Received().StreamDeleteAsync("prefix:key", messageIds, CommandFlags.None); - } - - [Fact] - public async Task StreamDeleteConsumerAsync() - { - await prefixed.StreamDeleteConsumerAsync("key", "group", "consumer", CommandFlags.None); - await mock.Received().StreamDeleteConsumerAsync("prefix:key", "group", "consumer", CommandFlags.None); - } - - [Fact] - public async Task StreamDeleteConsumerGroupAsync() - { - await prefixed.StreamDeleteConsumerGroupAsync("key", "group", CommandFlags.None); - await mock.Received().StreamDeleteConsumerGroupAsync("prefix:key", "group", CommandFlags.None); - } - - [Fact] - public async Task StreamPendingInfoGetAsync() - { - await prefixed.StreamPendingAsync("key", "group", CommandFlags.None); - await mock.Received().StreamPendingAsync("prefix:key", "group", CommandFlags.None); - } - - [Fact] - public async Task StreamPendingMessageInfoGetAsync() - { - await prefixed.StreamPendingMessagesAsync("key", "group", 10, RedisValue.Null, "-", "+", 1000, CommandFlags.None); - await mock.Received().StreamPendingMessagesAsync("prefix:key", "group", 10, RedisValue.Null, "-", "+", 1000, CommandFlags.None); - } - - [Fact] - public async Task StreamRangeAsync() - { - await prefixed.StreamRangeAsync("key", "-", "+", null, Order.Ascending, CommandFlags.None); - await mock.Received().StreamRangeAsync("prefix:key", "-", "+", null, Order.Ascending, CommandFlags.None); - } - - [Fact] - public async Task StreamReadAsync_1() - { - var streamPositions = Array.Empty(); - await prefixed.StreamReadAsync(streamPositions, null, CommandFlags.None); - await mock.Received().StreamReadAsync(streamPositions, null, CommandFlags.None); - } - - [Fact] - public async Task StreamReadAsync_2() - { - await prefixed.StreamReadAsync("key", "0-0", null, CommandFlags.None); - await mock.Received().StreamReadAsync("prefix:key", "0-0", null, CommandFlags.None); - } - - [Fact] - public async Task StreamReadGroupAsync_1() - { - await prefixed.StreamReadGroupAsync("key", "group", "consumer", StreamPosition.Beginning, 10, false, CommandFlags.None); - await mock.Received().StreamReadGroupAsync("prefix:key", "group", "consumer", StreamPosition.Beginning, 10, false, CommandFlags.None); - } - - [Fact] - public async Task StreamStreamReadGroupAsync_2() - { - var streamPositions = Array.Empty(); - await prefixed.StreamReadGroupAsync(streamPositions, "group", "consumer", 10, false, CommandFlags.None); - await mock.Received().StreamReadGroupAsync(streamPositions, "group", "consumer", 10, false, CommandFlags.None); - } - - [Fact] - public async Task StreamTrimAsync() - { - await prefixed.StreamTrimAsync("key", 1000, true, CommandFlags.None); - await mock.Received().StreamTrimAsync("prefix:key", 1000, true, CommandFlags.None); - } - - [Fact] - public async Task StreamTrimByMinIdAsync() - { - await prefixed.StreamTrimByMinIdAsync("key", 1111111111); - await mock.Received().StreamTrimByMinIdAsync("prefix:key", 1111111111); - } - - [Fact] - public async Task StreamTrimByMinIdAsyncWithApproximate() - { - await prefixed.StreamTrimByMinIdAsync("key", 1111111111, useApproximateMaxLength: true); - await mock.Received().StreamTrimByMinIdAsync("prefix:key", 1111111111, useApproximateMaxLength: true); - } - - [Fact] - public async Task StreamTrimByMinIdAsyncWithApproximateAndLimit() - { - await prefixed.StreamTrimByMinIdAsync("key", 1111111111, useApproximateMaxLength: true, limit: 100); - await mock.Received().StreamTrimByMinIdAsync("prefix:key", 1111111111, useApproximateMaxLength: true, limit: 100); - } - - [Fact] - public async Task StringAppendAsync() - { - await prefixed.StringAppendAsync("key", "value", CommandFlags.None); - await mock.Received().StringAppendAsync("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public async Task StringBitCountAsync() - { - await prefixed.StringBitCountAsync("key", 123, 456, CommandFlags.None); - await mock.Received().StringBitCountAsync("prefix:key", 123, 456, CommandFlags.None); - } - - [Fact] - public async Task StringBitCountAsync_2() - { - await prefixed.StringBitCountAsync("key", 123, 456, StringIndexType.Byte, CommandFlags.None); - await mock.Received().StringBitCountAsync("prefix:key", 123, 456, StringIndexType.Byte, CommandFlags.None); - } - - [Fact] - public async Task StringBitOperationAsync_1() - { - await prefixed.StringBitOperationAsync(Bitwise.Xor, "destination", "first", "second", CommandFlags.None); - await mock.Received().StringBitOperationAsync(Bitwise.Xor, "prefix:destination", "prefix:first", "prefix:second", CommandFlags.None); - } - - [Fact] - public async Task StringBitOperationAsync_2() - { - RedisKey[] keys = ["a", "b"]; - await prefixed.StringBitOperationAsync(Bitwise.Xor, "destination", keys, CommandFlags.None); - await mock.Received().StringBitOperationAsync(Bitwise.Xor, "prefix:destination", IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - - [Fact] - public async Task StringBitOperationAsync_Diff() - { - RedisKey[] keys = ["x", "y1", "y2"]; - await prefixed.StringBitOperationAsync(Bitwise.Diff, "destination", keys, CommandFlags.None); - await mock.Received().StringBitOperationAsync(Bitwise.Diff, "prefix:destination", IsKeys("prefix:x", "prefix:y1", "prefix:y2"), CommandFlags.None); - } - - [Fact] - public async Task StringBitOperationAsync_Diff1() - { - RedisKey[] keys = ["x", "y1", "y2"]; - await prefixed.StringBitOperationAsync(Bitwise.Diff1, "destination", keys, CommandFlags.None); - await mock.Received().StringBitOperationAsync(Bitwise.Diff1, "prefix:destination", IsKeys("prefix:x", "prefix:y1", "prefix:y2"), CommandFlags.None); - } - - [Fact] - public async Task StringBitOperationAsync_AndOr() - { - RedisKey[] keys = ["x", "y1", "y2"]; - await prefixed.StringBitOperationAsync(Bitwise.AndOr, "destination", keys, CommandFlags.None); - await mock.Received().StringBitOperationAsync(Bitwise.AndOr, "prefix:destination", IsKeys("prefix:x", "prefix:y1", "prefix:y2"), CommandFlags.None); - } - - [Fact] - public async Task StringBitOperationAsync_One() - { - RedisKey[] keys = ["a", "b", "c"]; - await prefixed.StringBitOperationAsync(Bitwise.One, "destination", keys, CommandFlags.None); - await mock.Received().StringBitOperationAsync(Bitwise.One, "prefix:destination", IsKeys("prefix:a", "prefix:b", "prefix:c"), CommandFlags.None); - } - - [Fact] - public async Task StringBitPositionAsync() - { - await prefixed.StringBitPositionAsync("key", true, 123, 456, CommandFlags.None); - await mock.Received().StringBitPositionAsync("prefix:key", true, 123, 456, CommandFlags.None); - } - - [Fact] - public async Task StringBitPositionAsync_2() - { - await prefixed.StringBitPositionAsync("key", true, 123, 456, StringIndexType.Byte, CommandFlags.None); - await mock.Received().StringBitPositionAsync("prefix:key", true, 123, 456, StringIndexType.Byte, CommandFlags.None); - } - - [Fact] - public async Task StringDecrementAsync_1() - { - await prefixed.StringDecrementAsync("key", 123, CommandFlags.None); - await mock.Received().StringDecrementAsync("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public async Task StringDecrementAsync_2() - { - await prefixed.StringDecrementAsync("key", 1.23, CommandFlags.None); - await mock.Received().StringDecrementAsync("prefix:key", 1.23, CommandFlags.None); - } - - [Fact] - public async Task StringGetAsync_1() - { - await prefixed.StringGetAsync("key", CommandFlags.None); - await mock.Received().StringGetAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task StringGetAsync_2() - { - RedisKey[] keys = ["a", "b"]; - await prefixed.StringGetAsync(keys, CommandFlags.None); - await mock.Received().StringGetAsync(IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - - [Fact] - public async Task StringGetBitAsync() - { - await prefixed.StringGetBitAsync("key", 123, CommandFlags.None); - await mock.Received().StringGetBitAsync("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public async Task StringGetRangeAsync() - { - await prefixed.StringGetRangeAsync("key", 123, 456, CommandFlags.None); - await mock.Received().StringGetRangeAsync("prefix:key", 123, 456, CommandFlags.None); - } - - [Fact] - public async Task StringGetSetAsync() - { - await prefixed.StringGetSetAsync("key", "value", CommandFlags.None); - await mock.Received().StringGetSetAsync("prefix:key", "value", CommandFlags.None); - } - - [Fact] - public async Task StringGetDeleteAsync() - { - await prefixed.StringGetDeleteAsync("key", CommandFlags.None); - await mock.Received().StringGetDeleteAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task StringGetWithExpiryAsync() - { - await prefixed.StringGetWithExpiryAsync("key", CommandFlags.None); - await mock.Received().StringGetWithExpiryAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task StringIncrementAsync_1() - { - await prefixed.StringIncrementAsync("key", 123, CommandFlags.None); - await mock.Received().StringIncrementAsync("prefix:key", 123, CommandFlags.None); - } - - [Fact] - public async Task StringIncrementAsync_2() - { - await prefixed.StringIncrementAsync("key", 1.23, CommandFlags.None); - await mock.Received().StringIncrementAsync("prefix:key", 1.23, CommandFlags.None); - } - - [Fact] - public async Task StringLengthAsync() - { - await prefixed.StringLengthAsync("key", CommandFlags.None); - await mock.Received().StringLengthAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task StringSetAsync_1() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - await prefixed.StringSetAsync("key", "value", expiry, When.Exists, CommandFlags.None); - await mock.Received().StringSetAsync("prefix:key", "value", expiry, When.Exists, CommandFlags.None); - } - - [Fact] - public async Task StringSetAsync_2() - { - TimeSpan? expiry = null; - await prefixed.StringSetAsync("key", "value", expiry, true, When.Exists, CommandFlags.None); - await mock.Received().StringSetAsync("prefix:key", "value", expiry, true, When.Exists, CommandFlags.None); - } - - [Fact] - public async Task StringSetAsync_3() - { - KeyValuePair[] values = [new KeyValuePair("a", "x"), new KeyValuePair("b", "y")]; - Expression[]>> valid = _ => _.Length == 2 && _[0].Key == "prefix:a" && _[0].Value == "x" && _[1].Key == "prefix:b" && _[1].Value == "y"; - await prefixed.StringSetAsync(values, When.Exists, CommandFlags.None); - await mock.Received().StringSetAsync(Arg.Is(valid), When.Exists, CommandFlags.None); - } - - [Fact] - public async Task StringSetAsync_Compat() - { - TimeSpan expiry = TimeSpan.FromSeconds(123); - await prefixed.StringSetAsync("key", "value", expiry, When.Exists); - await mock.Received().StringSetAsync("prefix:key", "value", expiry, When.Exists); - } - - [Fact] - public async Task StringSetBitAsync() - { - await prefixed.StringSetBitAsync("key", 123, true, CommandFlags.None); - await mock.Received().StringSetBitAsync("prefix:key", 123, true, CommandFlags.None); - } - - [Fact] - public async Task StringSetRangeAsync() - { - await prefixed.StringSetRangeAsync("key", 123, "value", CommandFlags.None); - await mock.Received().StringSetRangeAsync("prefix:key", 123, "value", CommandFlags.None); - } - - [Fact] - public async Task KeyTouchAsync_1() - { - await prefixed.KeyTouchAsync("key", CommandFlags.None); - await mock.Received().KeyTouchAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task KeyTouchAsync_2() - { - RedisKey[] keys = ["a", "b"]; - await prefixed.KeyTouchAsync(keys, CommandFlags.None); - await mock.Received().KeyTouchAsync(IsKeys("prefix:a", "prefix:b"), CommandFlags.None); - } - [Fact] - public async Task ExecuteAsync_1() - { - await prefixed.ExecuteAsync("CUSTOM", "arg1", (RedisKey)"arg2"); - await mock.Received().ExecuteAsync("CUSTOM", Arg.Is(args => args.Length == 2 && args[0].Equals("arg1") && args[1].Equals((RedisKey)"prefix:arg2")), CommandFlags.None); - } - - [Fact] - public async Task ExecuteAsync_2() - { - var args = new List { "arg1", (RedisKey)"arg2" }; - await prefixed.ExecuteAsync("CUSTOM", args, CommandFlags.None); - await mock.Received().ExecuteAsync("CUSTOM", Arg.Is?>(a => a != null && a.Count == 2 && a.ElementAt(0).Equals("arg1") && a.ElementAt(1).Equals((RedisKey)"prefix:arg2")), CommandFlags.None); - } - [Fact] - public async Task GeoAddAsync_1() - { - await prefixed.GeoAddAsync("key", 1.23, 4.56, "member", CommandFlags.None); - await mock.Received().GeoAddAsync("prefix:key", 1.23, 4.56, "member", CommandFlags.None); - } - - [Fact] - public async Task GeoAddAsync_2() - { - var geoEntry = new GeoEntry(1.23, 4.56, "member"); - await prefixed.GeoAddAsync("key", geoEntry, CommandFlags.None); - await mock.Received().GeoAddAsync("prefix:key", geoEntry, CommandFlags.None); - } - - [Fact] - public async Task GeoAddAsync_3() - { - var geoEntries = new GeoEntry[] { new GeoEntry(1.23, 4.56, "member1") }; - await prefixed.GeoAddAsync("key", geoEntries, CommandFlags.None); - await mock.Received().GeoAddAsync("prefix:key", geoEntries, CommandFlags.None); - } - - [Fact] - public async Task GeoRemoveAsync() - { - await prefixed.GeoRemoveAsync("key", "member", CommandFlags.None); - await mock.Received().GeoRemoveAsync("prefix:key", "member", CommandFlags.None); - } - - [Fact] - public async Task GeoDistanceAsync() - { - await prefixed.GeoDistanceAsync("key", "member1", "member2", GeoUnit.Meters, CommandFlags.None); - await mock.Received().GeoDistanceAsync("prefix:key", "member1", "member2", GeoUnit.Meters, CommandFlags.None); - } - - [Fact] - public async Task GeoHashAsync_1() - { - await prefixed.GeoHashAsync("key", "member", CommandFlags.None); - await mock.Received().GeoHashAsync("prefix:key", "member", CommandFlags.None); - } - - [Fact] - public async Task GeoHashAsync_2() - { - var members = new RedisValue[] { "member1", "member2" }; - await prefixed.GeoHashAsync("key", members, CommandFlags.None); - await mock.Received().GeoHashAsync("prefix:key", members, CommandFlags.None); - } - - [Fact] - public async Task GeoPositionAsync_1() - { - await prefixed.GeoPositionAsync("key", "member", CommandFlags.None); - await mock.Received().GeoPositionAsync("prefix:key", "member", CommandFlags.None); - } - - [Fact] - public async Task GeoPositionAsync_2() - { - var members = new RedisValue[] { "member1", "member2" }; - await prefixed.GeoPositionAsync("key", members, CommandFlags.None); - await mock.Received().GeoPositionAsync("prefix:key", members, CommandFlags.None); - } - - [Fact] - public async Task GeoRadiusAsync_1() - { - await prefixed.GeoRadiusAsync("key", "member", 100, GeoUnit.Meters, 10, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - await mock.Received().GeoRadiusAsync("prefix:key", "member", 100, GeoUnit.Meters, 10, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - } - - [Fact] - public async Task GeoRadiusAsync_2() - { - await prefixed.GeoRadiusAsync("key", 1.23, 4.56, 100, GeoUnit.Meters, 10, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - await mock.Received().GeoRadiusAsync("prefix:key", 1.23, 4.56, 100, GeoUnit.Meters, 10, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - } - - [Fact] - public async Task GeoSearchAsync_1() - { - var shape = new GeoSearchCircle(100, GeoUnit.Meters); - await prefixed.GeoSearchAsync("key", "member", shape, 10, true, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - await mock.Received().GeoSearchAsync("prefix:key", "member", shape, 10, true, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - } - - [Fact] - public async Task GeoSearchAsync_2() - { - var shape = new GeoSearchCircle(100, GeoUnit.Meters); - await prefixed.GeoSearchAsync("key", 1.23, 4.56, shape, 10, true, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - await mock.Received().GeoSearchAsync("prefix:key", 1.23, 4.56, shape, 10, true, Order.Ascending, GeoRadiusOptions.Default, CommandFlags.None); - } - - [Fact] - public async Task GeoSearchAndStoreAsync_1() - { - var shape = new GeoSearchCircle(100, GeoUnit.Meters); - await prefixed.GeoSearchAndStoreAsync("source", "destination", "member", shape, 10, true, Order.Ascending, false, CommandFlags.None); - await mock.Received().GeoSearchAndStoreAsync("prefix:source", "prefix:destination", "member", shape, 10, true, Order.Ascending, false, CommandFlags.None); - } - - [Fact] - public async Task GeoSearchAndStoreAsync_2() - { - var shape = new GeoSearchCircle(100, GeoUnit.Meters); - await prefixed.GeoSearchAndStoreAsync("source", "destination", 1.23, 4.56, shape, 10, true, Order.Ascending, false, CommandFlags.None); - await mock.Received().GeoSearchAndStoreAsync("prefix:source", "prefix:destination", 1.23, 4.56, shape, 10, true, Order.Ascending, false, CommandFlags.None); - } - [Fact] - public async Task HashFieldExpireAsync_1() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - var expiry = TimeSpan.FromSeconds(60); - await prefixed.HashFieldExpireAsync("key", hashFields, expiry, ExpireWhen.Always, CommandFlags.None); - await mock.Received().HashFieldExpireAsync("prefix:key", hashFields, expiry, ExpireWhen.Always, CommandFlags.None); - } - - [Fact] - public async Task HashFieldExpireAsync_2() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - var expiry = DateTime.Now.AddMinutes(1); - await prefixed.HashFieldExpireAsync("key", hashFields, expiry, ExpireWhen.Always, CommandFlags.None); - await mock.Received().HashFieldExpireAsync("prefix:key", hashFields, expiry, ExpireWhen.Always, CommandFlags.None); - } - - [Fact] - public async Task HashFieldGetExpireDateTimeAsync() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - await prefixed.HashFieldGetExpireDateTimeAsync("key", hashFields, CommandFlags.None); - await mock.Received().HashFieldGetExpireDateTimeAsync("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public async Task HashFieldPersistAsync() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - await prefixed.HashFieldPersistAsync("key", hashFields, CommandFlags.None); - await mock.Received().HashFieldPersistAsync("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public async Task HashFieldGetTimeToLiveAsync() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - await prefixed.HashFieldGetTimeToLiveAsync("key", hashFields, CommandFlags.None); - await mock.Received().HashFieldGetTimeToLiveAsync("prefix:key", hashFields, CommandFlags.None); - } - [Fact] - public async Task HashGetLeaseAsync() - { - await prefixed.HashGetLeaseAsync("key", "field", CommandFlags.None); - await mock.Received().HashGetLeaseAsync("prefix:key", "field", CommandFlags.None); - } - - [Fact] - public async Task HashFieldGetAndDeleteAsync_1() - { - await prefixed.HashFieldGetAndDeleteAsync("key", "field", CommandFlags.None); - await mock.Received().HashFieldGetAndDeleteAsync("prefix:key", "field", CommandFlags.None); - } - - [Fact] - public async Task HashFieldGetAndDeleteAsync_2() - { - var hashFields = new RedisValue[] { "field1", "field2" }; - await prefixed.HashFieldGetAndDeleteAsync("key", hashFields, CommandFlags.None); - await mock.Received().HashFieldGetAndDeleteAsync("prefix:key", hashFields, CommandFlags.None); - } - - [Fact] - public async Task HashFieldGetLeaseAndDeleteAsync() - { - await prefixed.HashFieldGetLeaseAndDeleteAsync("key", "field", CommandFlags.None); - await mock.Received().HashFieldGetLeaseAndDeleteAsync("prefix:key", "field", CommandFlags.None); - } - - [Fact] - public async Task HashFieldGetAndSetExpiryAsync_1() - { - var expiry = TimeSpan.FromMinutes(5); - await prefixed.HashFieldGetAndSetExpiryAsync("key", "field", expiry, false, CommandFlags.None); - await mock.Received().HashFieldGetAndSetExpiryAsync("prefix:key", "field", expiry, false, CommandFlags.None); - } - - [Fact] - public async Task HashFieldGetAndSetExpiryAsync_2() - { - var expiry = DateTime.Now.AddMinutes(5); - await prefixed.HashFieldGetAndSetExpiryAsync("key", "field", expiry, CommandFlags.None); - await mock.Received().HashFieldGetAndSetExpiryAsync("prefix:key", "field", expiry, CommandFlags.None); - } - - [Fact] - public async Task HashFieldGetLeaseAndSetExpiryAsync_1() - { - var expiry = TimeSpan.FromMinutes(5); - await prefixed.HashFieldGetLeaseAndSetExpiryAsync("key", "field", expiry, false, CommandFlags.None); - await mock.Received().HashFieldGetLeaseAndSetExpiryAsync("prefix:key", "field", expiry, false, CommandFlags.None); - } - - [Fact] - public async Task HashFieldGetLeaseAndSetExpiryAsync_2() - { - var expiry = DateTime.Now.AddMinutes(5); - await prefixed.HashFieldGetLeaseAndSetExpiryAsync("key", "field", expiry, CommandFlags.None); - await mock.Received().HashFieldGetLeaseAndSetExpiryAsync("prefix:key", "field", expiry, CommandFlags.None); - } - [Fact] - public async Task StringGetLeaseAsync() - { - await prefixed.StringGetLeaseAsync("key", CommandFlags.None); - await mock.Received().StringGetLeaseAsync("prefix:key", CommandFlags.None); - } - - [Fact] - public async Task StringGetSetExpiryAsync_1() - { - var expiry = TimeSpan.FromMinutes(5); - await prefixed.StringGetSetExpiryAsync("key", expiry, CommandFlags.None); - await mock.Received().StringGetSetExpiryAsync("prefix:key", expiry, CommandFlags.None); - } - - [Fact] - public async Task StringGetSetExpiryAsync_2() - { - var expiry = DateTime.Now.AddMinutes(5); - await prefixed.StringGetSetExpiryAsync("key", expiry, CommandFlags.None); - await mock.Received().StringGetSetExpiryAsync("prefix:key", expiry, CommandFlags.None); - } - - [Fact] - public async Task StringSetAndGetAsync_1() - { - var expiry = TimeSpan.FromMinutes(5); - await prefixed.StringSetAndGetAsync("key", "value", expiry, When.Always, CommandFlags.None); - await mock.Received().StringSetAndGetAsync("prefix:key", "value", expiry, When.Always, CommandFlags.None); - } - - [Fact] - public async Task StringSetAndGetAsync_2() - { - var expiry = TimeSpan.FromMinutes(5); - await prefixed.StringSetAndGetAsync("key", "value", expiry, false, When.Always, CommandFlags.None); - await mock.Received().StringSetAndGetAsync("prefix:key", "value", expiry, false, When.Always, CommandFlags.None); - } - [Fact] - public async Task StringLongestCommonSubsequenceAsync() - { - await prefixed.StringLongestCommonSubsequenceAsync("key1", "key2", CommandFlags.None); - await mock.Received().StringLongestCommonSubsequenceAsync("prefix:key1", "prefix:key2", CommandFlags.None); - } - - [Fact] - public async Task StringLongestCommonSubsequenceLengthAsync() - { - await prefixed.StringLongestCommonSubsequenceLengthAsync("key1", "key2", CommandFlags.None); - await mock.Received().StringLongestCommonSubsequenceLengthAsync("prefix:key1", "prefix:key2", CommandFlags.None); - } - - [Fact] - public async Task StringLongestCommonSubsequenceWithMatchesAsync() - { - await prefixed.StringLongestCommonSubsequenceWithMatchesAsync("key1", "key2", 5, CommandFlags.None); - await mock.Received().StringLongestCommonSubsequenceWithMatchesAsync("prefix:key1", "prefix:key2", 5, CommandFlags.None); - } - [Fact] - public async Task KeyIdleTimeAsync() - { - await prefixed.KeyIdleTimeAsync("key", CommandFlags.None); - await mock.Received().KeyIdleTimeAsync("prefix:key", CommandFlags.None); - } - [Fact] - public async Task StreamAddAsync_WithTrimMode_1() - { - await prefixed.StreamAddAsync("key", "field", "value", "*", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - await mock.Received().StreamAddAsync("prefix:key", "field", "value", "*", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - } - - [Fact] - public async Task StreamAddAsync_WithTrimMode_2() - { - var fields = new NameValueEntry[] { new NameValueEntry("field", "value") }; - await prefixed.StreamAddAsync("key", fields, "*", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - await mock.Received().StreamAddAsync("prefix:key", fields, "*", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - } - - [Fact] - public async Task StreamAddAsync_WithOptions_1() - { - var options = new StreamAddOptions { MaxLength = 1000, CreateStream = false }; - await prefixed.StreamAddAsync("key", "field", "value", options, CommandFlags.None); - await mock.Received().StreamAddAsync("prefix:key", "field", "value", options, CommandFlags.None); - } - - [Fact] - public async Task StreamAddAsync_WithOptions_2() - { - var fields = new NameValueEntry[] { new NameValueEntry("field", "value") }; - var options = new StreamAddOptions { MinId = "5-5", CreateStream = false }; - await prefixed.StreamAddAsync("key", fields, options, CommandFlags.None); - await mock.Received().StreamAddAsync("prefix:key", fields, options, CommandFlags.None); - } - - [Fact] - public async Task StreamTrimAsync_WithMode() - { - await prefixed.StreamTrimAsync("key", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - await mock.Received().StreamTrimAsync("prefix:key", 1000, false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - } - - [Fact] - public async Task StreamTrimByMinIdAsync_WithMode() - { - await prefixed.StreamTrimByMinIdAsync("key", "1111111111", false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - await mock.Received().StreamTrimByMinIdAsync("prefix:key", "1111111111", false, 100, StreamTrimMode.KeepReferences, CommandFlags.None); - } - - [Fact] - public async Task StreamReadGroupAsync_WithNoAck_1() - { - await prefixed.StreamReadGroupAsync("key", "group", "consumer", "0-0", 10, true, CommandFlags.None); - await mock.Received().StreamReadGroupAsync("prefix:key", "group", "consumer", "0-0", 10, true, CommandFlags.None); - } - - [Fact] - public async Task StreamReadGroupAsync_WithNoAck_2() - { - var streamPositions = new StreamPosition[] { new StreamPosition("key", "0-0") }; - await prefixed.StreamReadGroupAsync(streamPositions, "group", "consumer", 10, true, CommandFlags.None); - await mock.Received().StreamReadGroupAsync(streamPositions, "group", "consumer", 10, true, CommandFlags.None); - } - - [Fact] - public async Task StreamTrimAsync_Simple() - { - await prefixed.StreamTrimAsync("key", 1000, true, CommandFlags.None); - await mock.Received().StreamTrimAsync("prefix:key", 1000, true, CommandFlags.None); - } - - [Fact] - public async Task StreamReadGroupAsync_Simple_1() - { - await prefixed.StreamReadGroupAsync("key", "group", "consumer", "0-0", 10, CommandFlags.None); - await mock.Received().StreamReadGroupAsync("prefix:key", "group", "consumer", "0-0", 10, CommandFlags.None); - } - - [Fact] - public async Task StreamReadGroupAsync_Simple_2() - { - var streamPositions = new StreamPosition[] { new StreamPosition("key", "0-0") }; - await prefixed.StreamReadGroupAsync(streamPositions, "group", "consumer", 10, CommandFlags.None); - await mock.Received().StreamReadGroupAsync(streamPositions, "group", "consumer", 10, CommandFlags.None); - } - - [Fact] - public void HashScanAsync() - { - var result = prefixed.HashScanAsync("key", "pattern*", 10, 1, 2, CommandFlags.None); - _ = mock.Received().HashScanAsync("prefix:key", "pattern*", 10, 1, 2, CommandFlags.None); - } - - [Fact] - public void HashScanNoValuesAsync() - { - var result = prefixed.HashScanNoValuesAsync("key", "pattern*", 10, 1, 2, CommandFlags.None); - _ = mock.Received().HashScanNoValuesAsync("prefix:key", "pattern*", 10, 1, 2, CommandFlags.None); - } - - [Fact] - public void SetScanAsync() - { - var result = prefixed.SetScanAsync("key", "pattern*", 10, 1, 2, CommandFlags.None); - _ = mock.Received().SetScanAsync("prefix:key", "pattern*", 10, 1, 2, CommandFlags.None); - } - - [Fact] - public void SortedSetScanAsync() - { - var result = prefixed.SortedSetScanAsync("key", "pattern*", 10, 1, 2, CommandFlags.None); - _ = mock.Received().SortedSetScanAsync("prefix:key", "pattern*", 10, 1, 2, CommandFlags.None); - } - } -} diff --git a/tests/StackExchange.Redis.Tests/KeyPrefixedTransactionTests.cs b/tests/StackExchange.Redis.Tests/KeyPrefixedTransactionTests.cs deleted file mode 100644 index 04a9748084..0000000000 --- a/tests/StackExchange.Redis.Tests/KeyPrefixedTransactionTests.cs +++ /dev/null @@ -1,132 +0,0 @@ -using System.Text; -using System.Threading.Tasks; -using NSubstitute; -using StackExchange.Redis.KeyspaceIsolation; -using Xunit; - -namespace StackExchange.Redis.Tests; - -[Collection(nameof(SubstituteDependentCollection))] -public sealed class KeyPrefixedTransactionTests -{ - private readonly ITransaction mock; - private readonly KeyPrefixedTransaction prefixed; - - public KeyPrefixedTransactionTests() - { - mock = Substitute.For(); - prefixed = new KeyPrefixedTransaction(mock, Encoding.UTF8.GetBytes("prefix:")); - } - - [Fact] - public void AddCondition_HashEqual() - { - prefixed.AddCondition(Condition.HashEqual("key", "field", "value")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key Hash > field == value" == value.ToString())); - } - - [Fact] - public void AddCondition_HashNotEqual() - { - prefixed.AddCondition(Condition.HashNotEqual("key", "field", "value")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key Hash > field != value" == value.ToString())); - } - - [Fact] - public void AddCondition_HashExists() - { - prefixed.AddCondition(Condition.HashExists("key", "field")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key Hash > field exists" == value.ToString())); - } - - [Fact] - public void AddCondition_HashNotExists() - { - prefixed.AddCondition(Condition.HashNotExists("key", "field")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key Hash > field does not exists" == value.ToString())); - } - - [Fact] - public void AddCondition_KeyExists() - { - prefixed.AddCondition(Condition.KeyExists("key")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key exists" == value.ToString())); - } - - [Fact] - public void AddCondition_KeyNotExists() - { - prefixed.AddCondition(Condition.KeyNotExists("key")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key does not exists" == value.ToString())); - } - - [Fact] - public void AddCondition_StringEqual() - { - prefixed.AddCondition(Condition.StringEqual("key", "value")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key == value" == value.ToString())); - } - - [Fact] - public void AddCondition_StringNotEqual() - { - prefixed.AddCondition(Condition.StringNotEqual("key", "value")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key != value" == value.ToString())); - } - - [Fact] - public void AddCondition_SortedSetEqual() - { - prefixed.AddCondition(Condition.SortedSetEqual("key", "member", "score")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key SortedSet > member == score" == value.ToString())); - } - - [Fact] - public void AddCondition_SortedSetNotEqual() - { - prefixed.AddCondition(Condition.SortedSetNotEqual("key", "member", "score")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key SortedSet > member != score" == value.ToString())); - } - - [Fact] - public void AddCondition_SortedSetScoreExists() - { - prefixed.AddCondition(Condition.SortedSetScoreExists("key", "score")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key not contains 0 members with score: score" == value.ToString())); - } - - [Fact] - public void AddCondition_SortedSetScoreNotExists() - { - prefixed.AddCondition(Condition.SortedSetScoreNotExists("key", "score")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key contains 0 members with score: score" == value.ToString())); - } - - [Fact] - public void AddCondition_SortedSetScoreCountExists() - { - prefixed.AddCondition(Condition.SortedSetScoreExists("key", "score", "count")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key contains count members with score: score" == value.ToString())); - } - - [Fact] - public void AddCondition_SortedSetScoreCountNotExists() - { - prefixed.AddCondition(Condition.SortedSetScoreNotExists("key", "score", "count")); - mock.Received().AddCondition(Arg.Is(value => "prefix:key not contains count members with score: score" == value.ToString())); - } - - [Fact] - public async Task ExecuteAsync() - { - await prefixed.ExecuteAsync(CommandFlags.None); - await mock.Received(1).ExecuteAsync(CommandFlags.None); - } - - [Fact] - public void Execute() - { - prefixed.Execute(CommandFlags.None); - mock.Received(1).Execute(CommandFlags.None); - } -} diff --git a/tests/StackExchange.Redis.Tests/KeyPrefixedVectorSetTests.cs b/tests/StackExchange.Redis.Tests/KeyPrefixedVectorSetTests.cs deleted file mode 100644 index 034905adca..0000000000 --- a/tests/StackExchange.Redis.Tests/KeyPrefixedVectorSetTests.cs +++ /dev/null @@ -1,208 +0,0 @@ -using System; -using System.Text; -using NSubstitute; -using Xunit; - -namespace StackExchange.Redis.Tests -{ - [Collection(nameof(SubstituteDependentCollection))] - public sealed class KeyPrefixedVectorSetTests - { - private readonly IDatabase mock; - private readonly IDatabase prefixed; - - public KeyPrefixedVectorSetTests() - { - mock = Substitute.For(); - prefixed = new KeyspaceIsolation.KeyPrefixedDatabase(mock, Encoding.UTF8.GetBytes("prefix:")); - } - - [Fact] - public void VectorSetAdd_Fp32() - { - if (BitConverter.IsLittleEndian) - { - Assert.True(VectorSetAddRequest.CanUseFp32); - } - else - { - Assert.False(VectorSetAddRequest.CanUseFp32); - } - } - - [Fact] - public void VectorSetAdd_BasicCall() - { - var vector = new[] { 1.0f, 2.0f, 3.0f }.AsMemory(); - - var request = VectorSetAddRequest.Member("element1", vector); - prefixed.VectorSetAdd("vectorset", request); - - mock.Received().VectorSetAdd( - "prefix:vectorset", - request); - } - - [Fact] - public void VectorSetAdd_WithAllParameters() - { - var vector = new[] { 1.0f, 2.0f, 3.0f }.AsMemory(); - var attributes = """{"category":"test"}"""; - - var request = VectorSetAddRequest.Member( - "element1", - vector, - attributes); - request.ReducedDimensions = 64; - request.Quantization = VectorSetQuantization.Binary; - request.BuildExplorationFactor = 300; - request.MaxConnections = 32; - request.UseCheckAndSet = true; - prefixed.VectorSetAdd( - "vectorset", - request, - flags: CommandFlags.FireAndForget); - - mock.Received().VectorSetAdd( - "prefix:vectorset", - request, - CommandFlags.FireAndForget); - } - - [Fact] - public void VectorSetLength() - { - prefixed.VectorSetLength("vectorset"); - mock.Received().VectorSetLength("prefix:vectorset"); - } - - [Fact] - public void VectorSetDimension() - { - prefixed.VectorSetDimension("vectorset"); - mock.Received().VectorSetDimension("prefix:vectorset"); - } - - [Fact] - public void VectorSetGetApproximateVector() - { - prefixed.VectorSetGetApproximateVector("vectorset", "member1"); - mock.Received().VectorSetGetApproximateVector("prefix:vectorset", "member1"); - } - - [Fact] - public void VectorSetGetAttributesJson() - { - prefixed.VectorSetGetAttributesJson("vectorset", "member1"); - mock.Received().VectorSetGetAttributesJson("prefix:vectorset", "member1"); - } - - [Fact] - public void VectorSetInfo() - { - prefixed.VectorSetInfo("vectorset"); - mock.Received().VectorSetInfo("prefix:vectorset"); - } - - [Fact] - public void VectorSetContains() - { - prefixed.VectorSetContains("vectorset", "member1"); - mock.Received().VectorSetContains("prefix:vectorset", "member1"); - } - - [Fact] - public void VectorSetGetLinks() - { - prefixed.VectorSetGetLinks("vectorset", "member1"); - mock.Received().VectorSetGetLinks("prefix:vectorset", "member1"); - } - - [Fact] - public void VectorSetGetLinksWithScores() - { - prefixed.VectorSetGetLinksWithScores("vectorset", "member1"); - mock.Received().VectorSetGetLinksWithScores("prefix:vectorset", "member1"); - } - - [Fact] - public void VectorSetRandomMember() - { - prefixed.VectorSetRandomMember("vectorset"); - mock.Received().VectorSetRandomMember("prefix:vectorset"); - } - - [Fact] - public void VectorSetRandomMembers() - { - prefixed.VectorSetRandomMembers("vectorset", 5); - mock.Received().VectorSetRandomMembers("prefix:vectorset", 5); - } - - [Fact] - public void VectorSetRemove() - { - prefixed.VectorSetRemove("vectorset", "member1"); - mock.Received().VectorSetRemove("prefix:vectorset", "member1"); - } - - [Fact] - public void VectorSetSetAttributesJson() - { - var attributes = """{"category":"test"}"""; - - prefixed.VectorSetSetAttributesJson("vectorset", "member1", attributes); - mock.Received().VectorSetSetAttributesJson("prefix:vectorset", "member1", attributes); - } - - [Fact] - public void VectorSetSimilaritySearchByVector() - { - var vector = new[] { 1.0f, 2.0f, 3.0f }.AsMemory(); - - var query = VectorSetSimilaritySearchRequest.ByVector(vector); - prefixed.VectorSetSimilaritySearch( - "vectorset", - query); - mock.Received().VectorSetSimilaritySearch( - "prefix:vectorset", - query); - } - - [Fact] - public void VectorSetSimilaritySearchByMember() - { - var query = VectorSetSimilaritySearchRequest.ByMember("member1"); - query.Count = 5; - query.WithScores = true; - query.WithAttributes = true; - query.Epsilon = 0.1; - query.SearchExplorationFactor = 400; - query.FilterExpression = "category='test'"; - query.MaxFilteringEffort = 1000; - query.UseExactSearch = true; - query.DisableThreading = true; - prefixed.VectorSetSimilaritySearch( - "vectorset", - query, - CommandFlags.FireAndForget); - mock.Received().VectorSetSimilaritySearch( - "prefix:vectorset", - query, - CommandFlags.FireAndForget); - } - - [Fact] - public void VectorSetSimilaritySearchByVector_DefaultParameters() - { - var vector = new[] { 1.0f, 2.0f }.AsMemory(); - - // Test that default parameters work correctly - var query = VectorSetSimilaritySearchRequest.ByVector(vector); - prefixed.VectorSetSimilaritySearch("vectorset", query); - mock.Received().VectorSetSimilaritySearch( - "prefix:vectorset", - query); - } - } -} diff --git a/tests/StackExchange.Redis.Tests/MultiGroupTests/GroupConfigResolutionTests.cs b/tests/StackExchange.Redis.Tests/MultiGroupTests/GroupConfigResolutionTests.cs index 68cbac36b2..29cb0159db 100644 --- a/tests/StackExchange.Redis.Tests/MultiGroupTests/GroupConfigResolutionTests.cs +++ b/tests/StackExchange.Redis.Tests/MultiGroupTests/GroupConfigResolutionTests.cs @@ -44,13 +44,15 @@ public async Task WithRetryUsesTheGroupPolicy() await using var conn = await ConnectionMultiplexer.ConnectGroupAsync(members, options); // the parameterless overload resolves the policy from the group it is attached to - var retrying = Assert.IsType(conn.GetDatabase().WithRetry()); - Assert.Same(groupPolicy, retrying.Policy); + var retrying = conn.GetDatabase().WithRetry(); + var executor = Assert.IsType(retrying.Context.Raw.Executor); + Assert.Same(groupPolicy, executor.Policy); // ...and an explicit policy still wins RetryPolicy explicitPolicy = new RetryPolicy.Builder { MaxAttempts = 2 }; - var explicitlyRetrying = Assert.IsType(conn.GetDatabase().WithRetry(explicitPolicy)); - Assert.Same(explicitPolicy, explicitlyRetrying.Policy); + var explicitlyRetrying = conn.GetDatabase().WithRetry(explicitPolicy); + var explicitExecutor = Assert.IsType(explicitlyRetrying.Context.Raw.Executor); + Assert.Same(explicitPolicy, explicitExecutor.Policy); } [Fact] diff --git a/tests/StackExchange.Redis.Tests/RedisDatabaseTests.cs b/tests/StackExchange.Redis.Tests/RedisDatabaseTests.cs index 2686147869..146feffd5a 100644 --- a/tests/StackExchange.Redis.Tests/RedisDatabaseTests.cs +++ b/tests/StackExchange.Redis.Tests/RedisDatabaseTests.cs @@ -175,16 +175,14 @@ public void TheFullSetOverloadRendersItsOptionalArguments() /// /// /// - /// There are two prefixing mechanisms now, and they overlap: KeyPrefixedDatabase wraps an - /// and rewrites every as it forwards, while - /// carries a prefix the frame writer applies. A caller who reaches the - /// context through a wrapper touches both, which is the shape a double prefix would take - and - /// a double prefix is silent: every read and write agrees with every other, against the wrong keys. + /// There is ONE prefixing mechanism - carries the prefix and the frame + /// writer applies it - and two surfaces that reach it: the shipped and the + /// context surface underneath it. A double prefix is the silent failure shape: every read and write + /// agrees with every other, against the wrong keys. /// /// - /// They do compose correctly, and this pins why rather than merely that. The wrapper's context is its - /// inner context plus the prefix, not its own - so the prefix is contributed once, by whichever - /// mechanism is actually in the path, and never by both. + /// This pins that WithKeyPrefix contributes the prefix once, to the context, and that both + /// surfaces then see the same keyspace. /// /// [Fact] diff --git a/tests/StackExchange.Redis.Tests/RespGroupExecutorTests.cs b/tests/StackExchange.Redis.Tests/RespGroupExecutorTests.cs index 5e30bf4dfa..9921646ebd 100644 --- a/tests/StackExchange.Redis.Tests/RespGroupExecutorTests.cs +++ b/tests/StackExchange.Redis.Tests/RespGroupExecutorTests.cs @@ -180,14 +180,16 @@ public async Task TheGroupsContextExistsBeforeAnyMemberConnects() } [Fact] - public async Task ADefaultedDatabaseIndexStillNeedsAMember() + public async Task ADefaultedDatabaseIndexIsConfiguration() { - // the honest asymmetry: -1 means "whatever the active member defaults to", which cannot be known - // with nothing connected. Throwing matches what the Database property itself already does, so the - // context surface is not inventing a new failure mode here. + // -1 used to mean "whatever the active member defaults to", which needed a member - but the group + // REFUSES construction when members disagree about DefaultDatabase, so the default is member 0's + // configuration and is fully determined with nothing reachable. Both the property and the context + // answer while everything is down. var config = ConfigurationOptions.Parse("127.0.0.1:6399"); config.AbortOnConnectFail = false; config.ConnectTimeout = 500; + config.DefaultDatabase = 3; IConnectionGroup group; try @@ -203,8 +205,8 @@ public async Task ADefaultedDatabaseIndexStillNeedsAMember() await using var owner = group; var db = group.GetDatabase(); - Assert.Throws(() => db.Database); // the shipped property - Assert.Throws(() => _ = db.Context); // and the context agrees + Assert.Equal(3, db.Database); + Assert.Equal(3, db.Context.Database); } [Fact] diff --git a/tests/StackExchange.Redis.Tests/RespResultTests.cs b/tests/StackExchange.Redis.Tests/RespResultTests.cs index 6d1795c8d7..b703f43e4b 100644 --- a/tests/StackExchange.Redis.Tests/RespResultTests.cs +++ b/tests/StackExchange.Redis.Tests/RespResultTests.cs @@ -203,11 +203,11 @@ public async Task ExecuteResp_ArrayReply_MGET() public async Task ExecuteResp_KeyPrefixed_ShortKey_IsPrefixedCorrectly() { // regression coverage: RedisKeyOrValue must round-trip a short (<=8 byte) key value through - // KeyPrefixed without it getting folded into RedisValue's inline ShortBlob/Simplify form. + // a prefixed database without it getting folded into RedisValue's inline ShortBlob/Simplify form. await using var conn = Create(); var raw = conn.GetDatabase(); string prefixText = Me() + ":"; - IDatabase db = new KeyPrefixedDatabase(raw, Encoding.UTF8.GetBytes(prefixText)); + IDatabase db = raw.WithKeyPrefix(prefixText); RedisKey shortKey = "abc"; // <= 8 bytes - would be eligible for ShortBlob packing as a RedisValue RedisKey directKey = prefixText + "abc"; diff --git a/tests/StackExchange.Redis.Tests/RetryTests/RespRetryExecutorTests.cs b/tests/StackExchange.Redis.Tests/RetryTests/RespRetryExecutorTests.cs index 21f2a1ca7f..f4af6c2f7f 100644 --- a/tests/StackExchange.Redis.Tests/RetryTests/RespRetryExecutorTests.cs +++ b/tests/StackExchange.Redis.Tests/RetryTests/RespRetryExecutorTests.cs @@ -361,7 +361,7 @@ public async Task WrappingDoesNotChangeTheOriginalContext() /// /// A retrying context gets its next-failover token from the executor chain, so failover-aware - /// retry works without going through . + /// retry works without any database wrapper involved. /// /// /// diff --git a/tests/StackExchange.Redis.Tests/RetryTests/RetryGuardTests.cs b/tests/StackExchange.Redis.Tests/RetryTests/RetryGuardTests.cs index 065da0a9f5..d13c65e861 100644 --- a/tests/StackExchange.Redis.Tests/RetryTests/RetryGuardTests.cs +++ b/tests/StackExchange.Redis.Tests/RetryTests/RetryGuardTests.cs @@ -28,28 +28,34 @@ public async Task WithRetry_RefusesBatchTransactionAndNesting() Assert.Throws(() => db.WithRetry(Policy()).WithRetry(Policy())); } - // A database's asyncState is stamped onto the task produced by a single dispatch. A retrying database - // hands back its own task spanning however many attempts it takes, so it cannot carry that state - - // and silently dropping it would be worse than refusing. + // A database's asyncState used to be REFUSED here: the capture-and-replay wrapper handed back its own + // tasks, spanning however many attempts an operation took, and those could not carry the state. The + // re-dispatched form returns the ordinary database's tasks - retry happens beneath the dispatch - so + // the state simply travels. [Fact] - public async Task WithRetry_RefusesAsyncState() + public async Task WithRetry_CarriesAsyncState() { using var server = new InProcessTestServer(Output); await using var conn = await server.ConnectAsync(log: Writer); object state = new(); - var ex = Assert.Throws(() => conn.GetDatabase(0, state).WithRetry(Policy())); - Log(ex.Message); + var task = conn.GetDatabase(0, state).WithRetry(Policy()).PingAsync(); + Assert.Same(state, task.AsyncState); + await task; // ...including via a key-prefixed view of such a database, which inherits the inner state - Assert.Throws(() => conn.GetDatabase(0, state).WithKeyPrefix("p:").WithRetry(Policy())); + task = conn.GetDatabase(0, state).WithKeyPrefix("p:").WithRetry(Policy()).PingAsync(); + Assert.Same(state, task.AsyncState); + await task; - // and the same applies to a transaction created *from* a retrying database + // a transaction created *from* a retrying database still refuses one: it replays as a unit, + // handing out durable proxy tasks that are not the tasks sent to the server, so the state + // cannot be carried - and dropping it silently would be worse than refusing var retryDb = conn.GetDatabase().WithRetry(Policy()); - Assert.Throws(() => retryDb.CreateTransaction(state)); + var ex = Assert.Throws(() => retryDb.CreateTransaction(state)); + Log(ex.Message); // no state: fine - Assert.NotNull(conn.GetDatabase().WithKeyPrefix("p:").WithRetry(Policy())); Assert.NotNull(retryDb.CreateTransaction()); } From f6bd83ab291e8a7a0f856d600d241b6d10a7ca24 Mon Sep 17 00:00:00 2001 From: Marc Gravell Date: Fri, 13 Nov 2026 11:51:40 +0000 Subject: [PATCH 2/2] A retrying transaction replays rendered frames, like everything else: RetryTransaction and the [AutoDatabase] generator go (#3339) RespRetryTransactionExecutor records each queued command's rendered RespRequest plus a durable caller proxy, then replays the frames into a fresh one-shot RespTransactionExecutor per attempt, sharing the database's RetryController. Fresh attempt operations per replay are what dodge the real blocker: enrolled pooled operations are faulted directly by connection teardown, so re-enrolling one races pool recycling. With its last consumer gone, the capture-and-replay tier is deleted whole: RetryTransaction, AutoDatabase.cs, CapturedArgs.cs, the AutoDatabaseGenerator, SER352, and IInternalTransaction. Nothing on IDatabase is source-generated any more. Deliberate behavior changes: a retrying transaction now carries asyncState (previously refused) and exposes a working context that queues into the recorded unit (previously threw). Reuse after execute is still refused. Fire-and-forget parity is now real rather than claimed: both transaction executors hand every declined reply the one shared completed-default task, and TaskBridge passes a completed fire-and-forget task through untouched instead of rewrapping it. --- docs/rules/SER352.md | 35 - docs/rules/index.md | 1 - .../AnalyzerReleases.Unshipped.md | 1 - .../AutoDatabaseGenerator.cs | 722 ------------------ eng/StackExchange.Redis.Build/Diagnostics.cs | 27 - src/StackExchange.Redis/AutoDatabase.cs | 294 ------- .../Availability/RespRetryExecutor.cs | 4 +- .../RespRetryTransactionExecutor.cs | 631 +++++++++++++++ .../Availability/RetryTransaction.cs | 537 ------------- src/StackExchange.Redis/CapturedArgs.cs | 88 --- .../Contexts/RespTransaction.cs | 35 +- .../Database/RedisDatabase.Scans.cs | 8 +- .../Database/RedisDatabase.Strings.cs | 7 +- .../Database/RedisDatabase.cs | 24 +- .../Database/RedisTransaction.cs | 42 +- .../Database/TaskBridge.cs | 11 +- .../Interfaces/IInternalDatabaseAsync.cs | 13 - .../DatabaseSurfaceTests.cs | 19 +- .../QueuedResultTests.cs | 12 +- .../RespEndToEndTests.cs | 21 +- .../RetryTests/RetryEndToEndTests.cs | 4 +- .../RetryTests/RetryGuardTests.cs | 16 +- .../StackExchange.Redis.Tests/ScanGapTests.cs | 12 +- 23 files changed, 760 insertions(+), 1804 deletions(-) delete mode 100644 docs/rules/SER352.md delete mode 100644 eng/StackExchange.Redis.Build/AutoDatabaseGenerator.cs delete mode 100644 src/StackExchange.Redis/AutoDatabase.cs create mode 100644 src/StackExchange.Redis/Availability/RespRetryTransactionExecutor.cs delete mode 100644 src/StackExchange.Redis/Availability/RetryTransaction.cs delete mode 100644 src/StackExchange.Redis/CapturedArgs.cs diff --git a/docs/rules/SER352.md b/docs/rules/SER352.md deleted file mode 100644 index b4c0dd7be0..0000000000 --- a/docs/rules/SER352.md +++ /dev/null @@ -1,35 +0,0 @@ -# SER352: generated database members are not implemented - -A type marked `[AutoDatabase(WarnIfIncomplete = true)]` still has members that the generator supplied, and -those members throw rather than doing anything. The count is how many. - -This is a **transition tripwire**, not a code-quality rule. `[AutoDatabase]` fills in every member of -`IDatabase`/`IDatabaseAsync` that the type does not implement itself, funnelling them through the type's own -`Execute`/`ExecuteAsync`. For most users of the attribute those generated members genuinely work - they -forward to an inner database - and this rule is off for them. It is opt-in precisely because "generated" and -"unimplemented" are only the same thing for a type whose funnel throws, which is the shape of a type being -migrated to a new implementation one command at a time. - -## Fixing it - -Implement the member on the type. That is the whole fix, and it is self-maintaining: the generator skips -whatever the class declares itself, so the member stops being generated and the count goes down. When the -count reaches zero the warning disappears on its own. - -There is nothing to add to a list, and no list to forget to update - which is the reason the generated half -exists at all. - -## Why Release only - -The inner development loop is exactly when the type is *expected* to be incomplete, and a warning that fires -on every build during the work it is describing is a warning people learn to skip past. It is reported when -the `DEBUG` preprocessor symbol is absent, which is how the SDK's own `Release` configuration is defined. - -## Suppressing - -Do not suppress it to make it quiet - it is counting something real, and something that will throw in front -of a user. - -Do consider `SER352` while the migration is in progress: in a -build with `TreatWarningsAsErrors` this rule is otherwise fatal, which blocks the very work it is tracking. -Removing that line once the migration is close is what makes shipping an incomplete type impossible. diff --git a/docs/rules/index.md b/docs/rules/index.md index 1bb6322ee5..bb44ab6072 100644 --- a/docs/rules/index.md +++ b/docs/rules/index.md @@ -51,7 +51,6 @@ Unlike everything under [Usage](#usage), these describe code that does not do wh - [SER350](SER350) - language version too low for generated code - [SER351](SER351) - a `[Resp]` declaration the fragment generator cannot implement -- [SER352](SER352) - generated database members that are not implemented and will throw ## When these rules stay quiet diff --git a/eng/StackExchange.Redis.Build/AnalyzerReleases.Unshipped.md b/eng/StackExchange.Redis.Build/AnalyzerReleases.Unshipped.md index e0733f289d..1e5213fe00 100644 --- a/eng/StackExchange.Redis.Build/AnalyzerReleases.Unshipped.md +++ b/eng/StackExchange.Redis.Build/AnalyzerReleases.Unshipped.md @@ -18,4 +18,3 @@ SER308 | Usage | Warning | QueuedResultAnalyzer: calling the library's own SER309 | Usage | Warning | RespInterpolationAnalyzer: literal text in a RESP interpolated command is parsed and encoded on every call, where a fragment or resolved command is prepared once SER310 | Usage | Info | CancellationAnalyzer: a redis call that cannot honour the CancellationToken parameter its enclosing method accepts SER351 | Build | Warning | RespFragmentGenerator: a [Resp] declaration that cannot be implemented, which would otherwise be skipped silently -SER352 | Build | Warning | AutoDatabaseGenerator: an [AutoDatabase(WarnIfIncomplete = true)] type still has generated members that only throw; Release builds only diff --git a/eng/StackExchange.Redis.Build/AutoDatabaseGenerator.cs b/eng/StackExchange.Redis.Build/AutoDatabaseGenerator.cs deleted file mode 100644 index 5ba2e7a28f..0000000000 --- a/eng/StackExchange.Redis.Build/AutoDatabaseGenerator.cs +++ /dev/null @@ -1,722 +0,0 @@ -using System; -using System.Collections.Immutable; -using System.Reflection.Metadata.Ecma335; -using System.Text; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp.Syntax; - -// readable names for the info we gather; kept as tuples (+ BasicArray) so they have -// value equality and play nicely with incremental generator caching. -using ParamInfo = (string Name, string Type, Microsoft.CodeAnalysis.RefKind RefKind, bool IsParams, bool IsOptional, bool HasDefault, string? Default); -using MethodInfo = (string Name, string ReturnType, StackExchange.Redis.Build.BasicArray<(string Name, string Type, Microsoft.CodeAnalysis.RefKind RefKind, bool IsParams, bool IsOptional, bool HasDefault, string? Default)> Parameters, StackExchange.Redis.Build.BasicArray TypeArgs); -using InterfaceInfo = (string Name, string Namespace, StackExchange.Redis.Build.AutoDatabaseGenerator.KnownInterfaces KnownType, StackExchange.Redis.Build.BasicArray<(string Name, string ReturnType, StackExchange.Redis.Build.BasicArray<(string Name, string Type, Microsoft.CodeAnalysis.RefKind RefKind, bool IsParams, bool IsOptional, bool HasDefault, string? Default)> Parameters, StackExchange.Redis.Build.BasicArray TypeArgs)> Methods); -using ClassInfo = (string Name, string Namespace, StackExchange.Redis.Build.AutoDatabaseGenerator.KnownInterfaces Interfaces, bool IsMutator, bool Replays, StackExchange.Redis.Build.BasicArray Declared, bool WarnIfIncomplete); - -namespace StackExchange.Redis.Build; - -[Generator(LanguageNames.CSharp)] -public class AutoDatabaseGenerator : IIncrementalGenerator -{ - public void Initialize(IncrementalGeneratorInitializationContext ctx) - { - var interfaces = ctx.SyntaxProvider - .CreateSyntaxProvider( - static (node, _) => node is InterfaceDeclarationSyntax decl && FastIndexFilter(decl), ExtractInterfaceMethods) - .Where(pair => pair.Name is { Length: > 0 }) - .Collect(); - - var classes = ctx.SyntaxProvider - .CreateSyntaxProvider( - static (node, _) => node is ClassDeclarationSyntax decl && FastClassFilter(decl), ExtractClasses) - .Where(pair => pair.Name is { Length: > 0 }) - .Collect(); - - // Release is "no DEBUG symbol", which is what the SDK's own configuration does; a generator has no - // other reliable view of $(Configuration) without the project opting the property in. - var isRelease = ctx.ParseOptionsProvider.Select( - static (options, _) => !options.PreprocessorSymbolNames.Contains("DEBUG")); - - ctx.RegisterSourceOutput( - interfaces.Combine(classes).Combine(isRelease), - static (ctx, content) => Generate(ctx, content.Left.Left, content.Left.Right, content.Right)); - } - - /// - /// The only assembly this generator has anything to say about. - /// - /// - /// This is repo-internal machinery, but it now ships as an analyzer inside the StackExchange.Redis package - /// (for AsciiHashGenerator's benefit), so it is loaded by every consumer. It can never generate - /// anything useful for them - the semantic checks below reject anything that isn't our own - /// StackExchange.Redis declaration - so short-circuit on the assembly name first, and skip even the - /// semantic-model query for the consumers who happen to declare a type called IDatabase. - /// - private const string OwningAssembly = "StackExchange.Redis"; - - static KnownInterfaces Identify(string type) => type switch - { - "IDatabase" => KnownInterfaces.IDatabase, - "IDatabaseAsync" => KnownInterfaces.IDatabaseAsync, - "IRedis" => KnownInterfaces.IRedis, - "IRedisAsync" => KnownInterfaces.IRedisAsync, - _ => KnownInterfaces.None, - }; - - private static bool FastIndexFilter(InterfaceDeclarationSyntax decl) // limit to IDatabase, IDatabaseAsync - => Identify(decl.Identifier.ValueText) is not 0; - - private static bool FastClassFilter(ClassDeclarationSyntax decl) // limit to IDatabase, IDatabaseAsync - => decl.AttributeLists.Any(x => x.Attributes.Any(x => x.Name.ToString() is "AutoDatabase" or "AutoDatabaseAttribute")); - - // does this auto-database rewrite keys/channels? if not, the captured-args structs need no mapping members - private static bool IsMutatorInterface(INamedTypeSymbol symbol) => - symbol is - { - TypeKind: TypeKind.Interface, - Name: "IRedisArgsMutator", - ContainingType: null, - ContainingNamespace: - { - Name: "Redis", - ContainingNamespace: - { - Name: "StackExchange", - ContainingNamespace.IsGlobalNamespace: true - } - } - }; - - private static bool IsOurInterface(INamedTypeSymbol symbol) => - symbol is - { - TypeKind: TypeKind.Interface, - Name: "IDatabase" or "IDatabaseAsync" or "IRedis" or "IRedisAsync", - ContainingType: null, - ContainingNamespace: - { - Name: "Redis", - ContainingNamespace: - { - Name: "StackExchange", - ContainingNamespace.IsGlobalNamespace: true - } - } - }; - - private static InterfaceInfo ExtractInterfaceMethods(GeneratorSyntaxContext context, CancellationToken cancel) - { - if (context.SemanticModel.Compilation.AssemblyName is not OwningAssembly) return default; - - // note: we deliberately do NOT interpret anything here - just capture the raw shape of every - // method (name, return type, and per-parameter name/type/modifiers/optionality/default) so that - // later passes have everything they might need. - if (context.SemanticModel.GetDeclaredSymbol(context.Node, cancel) is not INamedTypeSymbol iface - || !IsOurInterface(iface)) - { - return default; - } - - var knownType = Identify(iface.Name); - if (knownType is KnownInterfaces.None) return default; - - var methods = new List(); - foreach (var member in iface.GetMembers()) - { - cancel.ThrowIfCancellationRequested(); - if (member is not IMethodSymbol { MethodKind: MethodKind.Ordinary } method) continue; - - var parameters = BasicArray.From(method.Parameters, static p => ( - Name: p.Name, - Type: p.Type.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat), - RefKind: p.RefKind, - IsParams: p.IsParams, - IsOptional: p.IsOptional, - HasDefault: p.HasExplicitDefaultValue, - Default: p.HasExplicitDefaultValue ? FormatDefault(p.ExplicitDefaultValue) : null)); - - BasicArray typeArgs = default; - if (method.IsGenericMethod) - { - typeArgs = BasicArray.From(method.TypeParameters, p => p.Name); - } - methods.Add(( - Name: method.Name, - ReturnType: method.ReturnType.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat), - Parameters: parameters, - TypeArgs: typeArgs)); - } - - var ns = iface.ContainingNamespace.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat); - return (iface.Name, ns, knownType, BasicArray.From(methods)); - } - - private ClassInfo ExtractClasses(GeneratorSyntaxContext context, CancellationToken cancel) - { - if (context.SemanticModel.Compilation.AssemblyName is not OwningAssembly) return default; - - // note: we deliberately do NOT interpret anything here - just capture the raw shape of every - // method (name, return type, and per-parameter name/type/modifiers/optionality/default) so that - // later passes have everything they might need. - if (context.SemanticModel.GetDeclaredSymbol(context.Node, cancel) is not INamedTypeSymbol cls - || !HasAutoDatabaseAttrib(cls)) - { - return default; - } - - static bool HasAutoDatabaseAttrib(INamedTypeSymbol symbol) - { - var attribs = symbol.GetAttributes(); - foreach (var attrib in attribs) - { - if (attrib.AttributeClass is - { - Name: "AutoDatabaseAttribute", - ContainingType: null, - ContainingNamespace: - { - Name: "Redis", - ContainingNamespace: - { - Name: "StackExchange", - ContainingNamespace.IsGlobalNamespace: true - } - } - }) - { - return true; - } - } - - return false; - } - - // AllInterfaces, not Interfaces: IBatch and ITransaction ARE IDatabaseAsync (IBatch : IDatabaseAsync, - // ITransaction : IBatch), so a class declaring one of those implements every async command member - // and wants exactly the same generated set. Matching only the directly-declared name generated - // nothing for them, silently - the class compiled, and the members it had not written were simply - // absent rather than throwing. The union below is idempotent, so a class that declares IDatabase - // directly is unaffected by also seeing it here transitively. - KnownInterfaces known = 0; - foreach (var iFace in cls.AllInterfaces) - { - if (IsOurInterface(iFace)) - { - switch (iFace.Name) - { - case "IDatabase": - known |= KnownInterfaces.IDatabase | KnownInterfaces.IDatabaseAsync | - KnownInterfaces.IRedis | KnownInterfaces.IRedisAsync; - break; - case "IDatabaseAsync": - known |= KnownInterfaces.IDatabaseAsync | KnownInterfaces.IRedisAsync; - break; - case "IRedis": - known |= KnownInterfaces.IRedis | KnownInterfaces.IRedisAsync; - break; - case "IRedisAsync": - known |= KnownInterfaces.IRedisAsync; - break; - } - } - } - - if (known is KnownInterfaces.None) return default; // nothing to do! - - // AllInterfaces (not Interfaces) so an inherited/explicit implementation still counts - bool isMutator = false; - foreach (var iFace in cls.AllInterfaces) - { - if (IsMutatorInterface(iFace)) - { - isMutator = true; - break; - } - } - - // [AutoDatabase(Replays = true)] - the owning database can invoke a captured operation more than - // once, so captured Memory arguments have to be copies rather than the caller's own buffer - bool replays = false, warnIfIncomplete = false; - foreach (var attrib in cls.GetAttributes()) - { - if (attrib.AttributeClass?.Name is not ("AutoDatabaseAttribute" or "AutoDatabase")) continue; - foreach (var named in attrib.NamedArguments) - { - if (named.Key == "Replays" && named.Value.Value is bool b) replays = b; - if (named.Key == "WarnIfIncomplete" && named.Value.Value is bool w) warnIfIncomplete = w; - } - } - - // What the class already implements by hand, so generation can stand back. The generator emits - // EXPLICIT interface implementations, which means a hand-written member does NOT collide - both - // compile, and interface dispatch silently prefers the generated one. So this is a correctness - // check, not a convenience: without it, a partial that implements StringGet for real would still - // see IDatabase.StringGet route to the funnel. - // - // Other partials are ordinary source and therefore visible here; this generator's own output is - // not part of the compilation it sees, so there is nothing to exclude. - var declared = new List(); - foreach (var member in cls.GetMembers()) - { - cancel.ThrowIfCancellationRequested(); - if (member is not IMethodSymbol { MethodKind: MethodKind.Ordinary or MethodKind.ExplicitInterfaceImplementation } method) continue; - declared.Add(SignatureKey(method)); - } - - var ns = cls.ContainingNamespace.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat); - return (cls.Name, ns, known, isMutator, replays, BasicArray.From(declared), warnIfIncomplete); - } - - /// - /// Name plus parameter types, formatted exactly as the interface side formats them so the two can be - /// compared as strings. - /// - /// - /// An explicit implementation's Name is the fully-qualified Namespace.IFace.Member, so - /// the implemented member's own name is used instead - a hand-written explicit implementation and a - /// hand-written public one mean the same thing here: "do not generate this". - /// - private static string SignatureKey(IMethodSymbol method) - { - var name = method.ExplicitInterfaceImplementations.Length > 0 - ? method.ExplicitInterfaceImplementations[0].Name - : method.Name; - - var sb = new StringBuilder(name).Append('('); - bool first = true; - foreach (var p in method.Parameters) - { - if (!first) sb.Append(','); - first = false; - sb.Append(p.Type.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)); - } - - return sb.Append(')').ToString(); - } - - /// The same key, from the interface-side shape. - private static string SignatureKey(MethodInfo method) - { - var sb = new StringBuilder(method.Name).Append('('); - bool first = true; - foreach (var p in method.Parameters.Span) - { - if (!first) sb.Append(','); - first = false; - sb.Append(p.Type); - } - - return sb.Append(')').ToString(); - } - - [Flags] - internal enum KnownInterfaces - { - None = 0, - IDatabase = 1, - IDatabaseAsync = 2, - IRedis = 4, - IRedisAsync = 8, - } - - // methods that don't fit the capture-and-replay shape are left for the caller to implement manually: - // - generic methods (open type args can't be captured into a concrete state struct) - // - the Wait family (synchronization over caller-supplied Tasks, not server calls) - // - IsConnected: a synchronous status probe that IDatabaseAsync carries; it would route through the - // sync Execute funnel, which an async-only database (e.g. RetryTransaction) doesn't provide - and a - // connection check shouldn't be retried in any case - // - IdentifyEndpoint / IdentifyEndpointAsync: a routing lookup ("which endpoint serves this key"), - // not a replayable server command; wrappers want their own behaviour here (e.g. a connection-group - // resolving against the currently-active member and returning null when there is none) - // - streaming returns (IEnumerable / IAsyncEnumerable) whose execution is deferred - // Memory/ReadOnlyMemory arguments still belong to the caller once the call returns; a database - // that replays has to capture a copy. Matched on the open generic prefix so a nullable or an array *of* - // them - neither of which is the caller's own buffer in the same way - does not match. - private static bool IsMemoryArg(string type) - => type.StartsWith("System.ReadOnlyMemory<", StringComparison.Ordinal) - || type.StartsWith("System.Memory<", StringComparison.Ordinal); - - // the element type, for the ArrayPool we rent the copy from - private static string MemoryElement(string type) - => type.Substring(type.IndexOf('<') + 1, type.Length - type.IndexOf('<') - 2); - - private static bool SkipMethod(MethodInfo method) - => !method.TypeArgs.IsEmpty - || method.Name.Contains("Wait") - || method.Name == "IsConnected" - || method.Name.Contains("IdentifyEndpoint") - // transaction/batch factories are not server round-trips and cannot be captured-and-replayed; - // the (few) databases that offer them implement them by hand - || method.Name == "CreateTransaction" - || method.Name == "CreateBatch" - || method.ReturnType.StartsWith("System.Collections.Generic.IEnumerable<", StringComparison.Ordinal) - || method.ReturnType.StartsWith("System.Collections.Generic.IAsyncEnumerable<", StringComparison.Ordinal); - - private const string TaskType = "System.Threading.Tasks.Task"; - - // Task / Task returns route through ExecuteAsync (its own retry policy); everything else - // uses Execute. - private static bool IsAsync(string returnType) - => returnType.StartsWith(TaskType, StringComparison.Ordinal); - - // the retry machinery unwraps the Task and only ever sees the inner result, so key/channel - // (un)mapping must be decided on T, not Task; this strips the Task<...> wrapper from an async - // return type. A bare (non-generic) Task has no result and is returned unchanged (as is any - // non-async return type), which is harmless since neither matches NeedsMap. - private static string StripTask(string returnType) - => IsAsync(returnType) && returnType.StartsWith(TaskType + "<", StringComparison.Ordinal) - ? returnType.Substring(TaskType.Length + 1, returnType.Length - TaskType.Length - 2) - : returnType; - - private static string FormatDefault(object? value) => value switch - { - null => "null", - string s => $"\"{s}\"", - bool b => b ? "true" : "false", - _ => value.ToString() ?? "null", - }; - - private static void Generate(SourceProductionContext ctx, ImmutableArray interfaces, ImmutableArray classes, bool isRelease) - { - if (interfaces.IsDefaultOrEmpty | classes.IsDefaultOrEmpty) return; // nothing to do - - // each interface is declared across several partial files, so we get one (identical) entry per - // partial declaration; structural equality lets us collapse those down to one per interface. - var iKeyed = new Dictionary(); - foreach (var t in interfaces) - { - if (t.KnownType is KnownInterfaces.None) continue; - if (!iKeyed.ContainsKey(t.KnownType)) iKeyed.Add(t.KnownType, t); - } - - var sb = new StringBuilder(); - var writer = new CodeWriter(sb); - writer.NewLine().Append("// "); - writer.NewLine().Append("// AutoDatabaseGenerator - explicit interface implementations that funnel every"); - writer.NewLine().Append("// call through Execute(state, projection), capturing the arguments in a generated"); - writer.NewLine().Append("// state struct (one per unique parameter-type signature) to avoid per-call closures."); - writer.NewLine().Append("#nullable enable"); // this needs to be explicit for code-gen - writer.NewLine(); - foreach (var cls in classes.Distinct()) - { - if (!string.IsNullOrWhiteSpace(cls.Namespace)) - { - writer.NewLine().Append("namespace ").Append(cls.Namespace).NewLine().Append("{").Indent(); - } - - // what this class implements by hand, and therefore must NOT have generated for it - var declared = new HashSet(StringComparer.Ordinal); - foreach (var signature in cls.Declared) declared.Add(signature); - - // how many members this class did NOT implement, for the SER352 tripwire below - int generated = 0; - - // unique parameter-type signatures encountered while emitting this class's methods; - // keyed on the '|'-joined parameter types so distinct methods with the same shape share - // one state struct. tupleDefs[i] holds a representative parameter list for _tuple{i}. - var tupleIndex = new Dictionary(); - var tupleDefs = new List>(); - - // every unique key/channel-bearing result type across all shapes; a single shared - // singleton (emitted after the tuples) implements IRedisArgsResult for each, so - // tuples expose unmap dispatch via UnMapper without ever being cast to an interface - var allReturns = new HashSet(); - - bool isFirst = true; - writer.NewLine().Append("partial class ").Append(cls.Name); - AppendInterfaceDeclaration(KnownInterfaces.IDatabase); - AppendInterfaceDeclaration(KnownInterfaces.IDatabaseAsync); - AppendInterfaceDeclaration(KnownInterfaces.IRedis); - AppendInterfaceDeclaration(KnownInterfaces.IRedisAsync); - writer.NewLine().Append("{").Indent(); - AppendInterfaceMethods(KnownInterfaces.IDatabase); - AppendInterfaceMethods(KnownInterfaces.IDatabaseAsync); - AppendInterfaceMethods(KnownInterfaces.IRedis); - AppendInterfaceMethods(KnownInterfaces.IRedisAsync); - AppendTupleTypes(); - - // The tripwire: a type opted into WarnIfIncomplete is mid-transition, and every member still - // generated for it is one the class has not taken over. Release only, so the inner loop is - // quiet and the noise arrives exactly when someone is preparing something that ships. - if (isRelease && cls.WarnIfIncomplete && generated > 0) - { - var fqn = string.IsNullOrWhiteSpace(cls.Namespace) ? cls.Name : cls.Namespace + "." + cls.Name; - ctx.ReportDiagnostic(Diagnostic.Create(Diagnostics.AutoDatabaseIncomplete, Location.None, generated, fqn)); - } - - writer.Outdent().NewLine().Append("}"); - - if (!string.IsNullOrWhiteSpace(cls.Namespace)) - { - writer.Outdent().NewLine().Append("}"); - } - writer.NewLine(); - - - void AppendInterfaceDeclaration(KnownInterfaces knownType) - { - if ((cls.Interfaces & knownType) is 0 | !iKeyed.TryGetValue(knownType, out var iType)) return; - writer.Append(isFirst ? " : " : ", ").Append("global::") - .Append(iType.Namespace).Append('.') .Append(iType.Name); - isFirst = false; - } - - void AppendInterfaceMethods(KnownInterfaces knownType) - { - if ((cls.Interfaces & knownType) is 0 | !iKeyed.TryGetValue(knownType, out var iType)) return; - foreach (var method in iType.Methods) - { - if (SkipMethod(method)) continue; // wonky by nature - left for the caller to implement manually - if (declared.Contains(SignatureKey(method))) continue; // the class implements this itself - generated++; - - writer.NewLine().Append(method.ReturnType).Append(" global::") - .Append(iType.Namespace).Append('.').Append(iType.Name).Append('.').Append(method.Name).Append("("); - bool firstParam = true; - foreach (var p in method.Parameters.Span) - { - if (firstParam) firstParam = false; - else writer.Append(", "); - writer.Append(p.Type).Append(" ").Append(p.Name); - } - writer.Append(')').Indent().NewLine(); - - // async methods route to ExecuteAsync (its own retry policy); everything else uses - // Execute. The state struct is shared regardless of return type - keyed on parameter - // types only - so e.g. ArraySet and ArraySetAsync land on the same _tupleN. The return - // type is Task-stripped so unmapping is keyed on the inner result the retry machinery - // actually sees, not the Task wrapper. - bool isAsync = IsAsync(method.ReturnType); - var simpleResult = StripTask(method.ReturnType); - bool needsMap = NeedsMap(simpleResult); - if (needsMap) allReturns.Add(simpleResult); - int tuple = GetTupleIndex(method.Parameters, needsMap); - writer.Append(isAsync ? "=> ExecuteAsync(new _tuple" : "=> Execute(new _tuple").Append(tuple).Append("("); - firstParam = true; - foreach (var p in method.Parameters.Span) - { - if (firstParam) firstParam = false; - else writer.Append(", "); - writer.Append(p.Name); - } - // the funnels take the state by readonly-ref (see AutoDatabase{Sync|Async}Operation) to avoid - // copying the larger state structs; a lambda only binds to an `in` parameter if it says so, - // hence the explicit modifier (C# 14 allows it without also naming the type) - writer.Append("), static (in state, inner) => inner.").Append(method.Name).Append("("); - for (int i = 0; i < method.Parameters.Length; i++) - { - if (i != 0) writer.Append(", "); - writer.Append("state.Arg").Append(i); - } - writer.Append("));").Outdent().NewLine(); - } - } - - static string GetTupleKey(BasicArray parameters) - { - var keyBuilder = new StringBuilder(); - foreach (var p in parameters.Span) - { - keyBuilder.Append(p.Type).Append('|'); // types-only key; no ref/out on this surface, so type is sufficient - } - - return keyBuilder.ToString(); - } - - bool TupleNeedsMap(BasicArray parameters) => - tupleIndex.TryGetValue(GetTupleKey(parameters), out var found) && found.NeedsMap; - - int GetTupleIndex(BasicArray parameters, bool needsMap) - { - var key = GetTupleKey(parameters); - int index; - if (tupleIndex.TryGetValue(key, out var found)) - { - index = found.Index; - if (needsMap && !found.NeedsMap) - { - found.NeedsMap = true; - tupleIndex[key] = found; - } - } - else - { - index = tupleDefs.Count; - tupleIndex.Add(key, (index, needsMap)); - tupleDefs.Add(parameters); - } - - return index; - } - - const string CommandFlagsType = "StackExchange.Redis.CommandFlags"; - const string RedisKeyType = "StackExchange.Redis.RedisKey"; - const string RedisChannelType = "StackExchange.Redis.RedisChannel"; - // types that carry key(s) internally without "RedisKey" in their name, so the - // substring check below won't catch them; they rely on a Map extension method - const string StreamPositionType = "StackExchange.Redis.StreamPosition"; - // the Execute/ExecuteAsync escape hatch boxes keys/channels inside a loosely-typed - // arg list; these route through a Map extension that unboxes and rewrites matches - const string ScriptArgArrayType = "object[]"; - const string ScriptArgCollectionType = "System.Collections.Generic.ICollection"; - - static bool NeedsMap(string name) => - name.IndexOf(RedisKeyType, StringComparison.Ordinal) >= 0 - || name.IndexOf(RedisChannelType, StringComparison.Ordinal) >= 0 - || name.IndexOf(StreamPositionType, StringComparison.Ordinal) >= 0 - || name == ScriptArgArrayType - || name == ScriptArgCollectionType - || name.IndexOf("ListPopResult", StringComparison.Ordinal) >= 0 - || name.IndexOf("SortedSetPopResult", StringComparison.Ordinal) >= 0 - || name == ScriptArgCollectionType + "?"; - - void AppendTupleTypes() - { - for (int i = 0; i < tupleDefs.Count; i++) - { - var raw = tupleDefs[i]; - bool needsMap = TupleNeedsMap(raw); - var parameters = raw.Span; - - // key/channel-bearing fields are mutable only when something can rewrite them (i.e. the - // owning database is an IRedisArgsMutator); otherwise every field is readonly - // a non-mutator's captured args never change after capture, so the struct itself can be - // readonly - which also guarantees no defensive copies when read through an `in` ref - writer.NewLine().NewLine().Append(cls.IsMutator ? "private struct _tuple" : "private readonly struct _tuple").Append(i).Append("("); - for (int p = 0; p < parameters.Length; p++) - { - if (p != 0) writer.Append(", "); - writer.Append(parameters[p].Type).Append(" arg").Append(p); - } - - // captured args are a plain struct unless the owning database rewrites keys, in which - // case the mapping members - and the interface that carries them - are emitted below. - // A captured CommandFlags is surfaced through IFlaggedRedisArgs regardless, so that a - // funnel holding an opaque TState can still see fire-and-forget; the two compose. - writer.Append(")"); - int flagsArg = -1; - for (int p = 0; p < parameters.Length; p++) - { - // suffix rather than substring: this must not match a nullable, an array, or a - // container *of* flags, none of which the funnel could read as a plain value - if (parameters[p].Type.EndsWith(CommandFlagsType, StringComparison.Ordinal)) - { - flagsArg = p; - break; - } - } - - bool firstBase = true; - if (cls.IsMutator) - { - writer.Append(" : global::StackExchange.Redis.IMappableRedisArgs"); - firstBase = false; - } - - if (flagsArg >= 0) - { - writer.Append(firstBase ? " : " : ", ").Append("global::StackExchange.Redis.IFlaggedRedisArgs"); - firstBase = false; - } - - // a replaying funnel constrains its TState to IDisposable so it can give cloned - // arguments back; every one of its captures implements it, most as a no-op - if (cls.Replays) - { - writer.Append(firstBase ? " : " : ", ").Append("global::System.IDisposable"); - } - writer.NewLine().Append("{").Indent(); - for (int p = 0; p < parameters.Length; p++) - { - var clone = cls.Replays && IsMemoryArg(parameters[p].Type); - writer.NewLine().Append("public ").Append(cls.IsMutator && NeedsMap(parameters[p].Type) ? "" : "readonly ").Append(parameters[p].Type) - .Append(" Arg").Append(p).Append(" = ") - .Append(clone ? "global::StackExchange.Redis.CapturedArgs.Clone(arg" : "arg").Append(p).Append(clone ? ");" : ";"); - } - - if (flagsArg >= 0) - { - // explicit implementation, so it cannot collide with a captured argument's own name; - // readonly only on a mutator's struct, since a readonly struct's members already are - writer.NewLine().Append(cls.IsMutator ? "readonly " : "") - .Append("global::StackExchange.Redis.CommandFlags global::StackExchange.Redis.IFlaggedRedisArgs.Flags => Arg") - .Append(flagsArg).Append(";"); - } - - if (cls.Replays) - { - // emitted even when there is nothing to give back: the funnel's TState constraint - // needs every capture to satisfy it, and an empty one inlines away - writer.NewLine().Append(cls.IsMutator ? "readonly " : "").Append("public void Dispose()").NewLine().Append("{").Indent(); - for (int p = 0; p < parameters.Length; p++) - { - if (!IsMemoryArg(parameters[p].Type)) continue; - writer.NewLine().Append("global::StackExchange.Redis.CapturedArgs.Release(in Arg").Append(p).Append(");"); - } - writer.Outdent().NewLine().Append("}"); - } - - if (!cls.IsMutator) - { - // nothing rewrites keys here, so there is no Map/UnMapper to emit at all - writer.Outdent().NewLine().Append("}"); - continue; - } - - // Map rewrites each scalar key/channel field directly, and defers container or - // loosely-typed fields to a matching Map extension method - writer.NewLine().Append("public void Map(global::StackExchange.Redis.IRedisArgsMutator mutator)") - .NewLine().Append("{").Indent(); - for (int p = 0; p < parameters.Length; p++) - { - if (NeedsMap(parameters[p].Type)) - { - // key/channel-bearing container (or the loosely-typed script arg list); it - // is the library's job to ensure a suitable Map extension method exists - writer.NewLine().Append("Arg").Append(p).Append(" = mutator.Map(Arg").Append(p).Append(");"); - } - } - writer.Outdent().NewLine().Append("}"); - - // tuples with key/channel-bearing results point UnMapper at the shared singleton - // (which knows how to unmap every such result type); the rest return null so the - // Execute helper skips unmapping entirely - and neither path boxes the struct - writer.NewLine().Append("public readonly object? UnMapper => ") - .Append(needsMap ? "_UnMapper.Instance;" : "null;"); - - writer.Outdent().NewLine().Append("}"); - } - - if (cls.IsMutator && allReturns.Count is not 0) - { - // sorted for deterministic (cache-stable) output - var ordered = new List(allReturns); - ordered.Sort(StringComparer.Ordinal); - - writer.NewLine().NewLine().Append("private sealed class _UnMapper").Indent(); - bool firstIface = true; - foreach (var retType in ordered) - { - writer.NewLine().Append(firstIface ? ": " : ", ") - .Append("global::StackExchange.Redis.IRedisArgsResult<").Append(retType).Append(">"); - firstIface = false; - } - writer.Outdent().NewLine().Append("{").Indent(); - writer.NewLine().Append("public static readonly _UnMapper Instance = new();"); - foreach (var retType in ordered) - { - writer.NewLine().NewLine().Append(retType).Append(' ') - .Append("global::StackExchange.Redis.IRedisArgsResult<") - .Append(retType) - .Append(">.UnMap(global::StackExchange.Redis.IRedisArgsMutator mutator, ") - .Append(retType).Append(" value)") - .Indent().NewLine().Append("=> mutator.UnMap(value);").Outdent(); - } - writer.Outdent().NewLine().Append("}"); - } - } - } - writer.NewLine(); - - ctx.AddSource("AutoDatabase.generated.cs", sb.ToString()); - } -} diff --git a/eng/StackExchange.Redis.Build/Diagnostics.cs b/eng/StackExchange.Redis.Build/Diagnostics.cs index 949388f43c..06a0828a76 100644 --- a/eng/StackExchange.Redis.Build/Diagnostics.cs +++ b/eng/StackExchange.Redis.Build/Diagnostics.cs @@ -383,32 +383,5 @@ internal static class Diagnostics description: "The RespFragment generator implements [Resp] partial properties of type RespFragment or RespCommand; a declaration it cannot match is skipped, which would otherwise appear only as a missing implementation part.", helpLinkUri: HelpLink("SER351")); - /// - /// An [AutoDatabase(WarnIfIncomplete = true)] type still has members that only throw. - /// - /// - /// - /// A transition tripwire, not a code-quality rule. A type being migrated to a new implementation one - /// command at a time has the rest generated as throwing stubs; that is fine while the work is in - /// progress and not fine in something that ships, and the difference is invisible at a glance - /// because the whole point of the generated half is that nobody writes or reads it. - /// - /// - /// Reported only for Release builds (detected by the absence of the DEBUG preprocessor - /// symbol) so the inner development loop stays quiet, and only where the attribute opts in - the other - /// [AutoDatabase] users generate members that genuinely work by forwarding, and counting those - /// as "not implemented" would be both wrong and deafening. - /// - /// - public static readonly DiagnosticDescriptor AutoDatabaseIncomplete = new( - id: "SER352", - title: "Generated database members are not implemented", - messageFormat: "{0} member(s) of '{1}' are not implemented and will throw at run time", - category: BuildCategory, - defaultSeverity: DiagnosticSeverity.Warning, - isEnabledByDefault: true, - description: "A type generated by [AutoDatabase(WarnIfIncomplete = true)] still has members that only throw; it is mid-transition and should not ship in that state.", - helpLinkUri: HelpLink("SER352")); - private static string HelpLink(string id) => string.Format(HelpLinkFormat, id); } diff --git a/src/StackExchange.Redis/AutoDatabase.cs b/src/StackExchange.Redis/AutoDatabase.cs deleted file mode 100644 index a7bcef4ee5..0000000000 --- a/src/StackExchange.Redis/AutoDatabase.cs +++ /dev/null @@ -1,294 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Diagnostics; -using System.Diagnostics.CodeAnalysis; -using System.Runtime.CompilerServices; -using System.Threading.Tasks; - -namespace StackExchange.Redis; - -[Conditional("DEBUG")] -[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)] -internal sealed class AutoDatabaseAttribute : Attribute -{ - /// - /// Warn (SER352) on Release builds while any member of the decorated type is still generated - /// rather than implemented by the type itself. - /// - /// - /// For a type that is mid-transition, where the generated members throw rather than forward. Off by - /// default, because the other users of this attribute generate members that genuinely work - counting - /// those as unimplemented would be both wrong and deafening. - /// - public bool WarnIfIncomplete { get; set; } - - /// - /// Whether the owning database can invoke a captured operation more than once, i.e. it replays. - /// - /// - /// A replaying database outlives the call it captured: it re-invokes with the same captured arguments - /// after the caller has long since regained control. Arguments passed as Memory/ReadOnlyMemory - /// still belong to the caller, who is entitled to reuse that buffer once the call returns - so a replay - /// would read whatever is in it by then. When this is set, the generated capture takes a pooled shallow - /// copy of those arguments and the funnel disposes it; when it is not, the arguments are captured as-is, - /// because a single forward cannot outlive the call. - /// - public bool Replays { get; set; } -} - -// Implemented by a generated captured-arguments struct only when the owning auto-database implements -// IRedisArgsMutator - i.e. only when something actually rewrites keys/channels. Everything else captures its -// arguments into a plain readonly struct with no interface at all; a funnel that wants to map opts in by -// constraining its TState to this (which is how KeyPrefixedDatabase will work once it moves onto -// [AutoDatabase]). -// -// Map mutates the struct in place, so a funnel that maps MUST take its state BY VALUE - never by `in`, because -// calling a non-readonly member through an `in` reference silently takes a defensive copy, mutates that, and -// throws it away. Invoke it via RedisArgsMutatorExtensions.MapInPlace, which makes that mistake a compile -// error (CS8329) instead of a silent loss of prefixing. (`ref` on the funnel is not an alternative: the -// generated call site passes a constructed temporary, which `ref` rejects with CS1510, and async funnels -// cannot have by-ref parameters at all.) The by-value copy is not waste here - a mapping funnel needs its own -// mutable copy by definition. Only non-mapping funnels take `in`, and their structs are readonly, so for them -// no defensive copy is even possible. -internal interface IMappableRedisArgs -{ - [Obsolete("Use MapInPlace instead; calling Map directly does nothing when the state is held by `in`.")] - void Map(IRedisArgsMutator mutator); - - object? UnMapper { get; } -} - -// Implemented by a generated captured-arguments struct whenever the captured call has a CommandFlags -// parameter - which is very nearly all of them - so that a funnel holding an opaque TState can still ask the -// one question that changes what it must hand back: was this fire-and-forget? -// -// It existed for the retired capture-and-replay retry transaction, and remains for any funnel with the -// same need. That funnel recorded each call and returned a durable proxy task completed -// later from the attempt, which is wrong for fire-and-forget: a plain RedisTransaction hands back an -// *already-completed* task there (the caller has explicitly declined the reply), so without this the same -// source awaiting the same result returns instantly on one and hangs on the other. The flags are captured -// inside TState and are otherwise invisible to a funnel, which is the whole reason this interface is needed -// rather than the funnel simply reading a parameter. -internal interface IFlaggedRedisArgs -{ - CommandFlags Flags { get; } -} - -// The projections used by the auto-database funnels. There are exactly four real shapes, so each is named -// rather than being expressed generically over the target/return type: that lets the type system encode the -// invariants (sync goes to IDatabase, async goes to IDatabaseAsync and returns a Task) instead of leaving -// nonsense combinations like "sync database, Task result" expressible. -// -// They exist at all (rather than Func<,,>/Action<,>) purely to pass the captured state by readonly-reference: -// some of the generated state structs are chunky (a dozen-plus arguments), and by-value would copy the whole -// thing on every call. Note that a lambda only binds to an `in` parameter if it says so - the generator emits -// `static (in state, inner) => ...` accordingly. -// -// TState is necessarily invariant: it is passed by readonly-ref, and variant type parameters cannot carry -// the struct constraint. TResult is covariant on the sync projection (it is the direct return); it cannot be -// on the async one, because there it appears inside the invariant Task. -internal delegate void AutoDatabaseSyncOperation(in TState state, IDatabase database) - where TState : struct; - -internal delegate TResult AutoDatabaseSyncOperation(in TState state, IDatabase database) - where TState : struct; - -internal delegate Task AutoDatabaseAsyncOperation(in TState state, IDatabaseAsync database) - where TState : struct; - -internal delegate Task AutoDatabaseAsyncOperation(in TState state, IDatabaseAsync database) - where TState : struct; - -internal interface IRedisArgsMutator -{ - RedisKey Map(RedisKey key); - RedisChannel Map(RedisChannel channel); - - RedisKey UnMap(RedisKey key); - RedisChannel UnMap(RedisChannel channel); -} - -internal interface IRedisArgsResult -{ - T UnMap(IRedisArgsMutator mutator, T value); -} - -internal static class RedisArgsMutatorExtensions -{ - // these are used by the generated tuple-types via auto-database: each maps the key-bearing parts - // of an argument through the supplied mutator. They hang off IRedisArgsMutator (rather than the - // argument) so a call site reads consistently with the interface's own MapKey/MapChannel. - public static KeyValuePair Map( - this IRedisArgsMutator mutator, - KeyValuePair value) => - new(mutator.Map(value.Key), value.Value); - - // Funnels should map via this rather than calling state.Map(mutator) directly. Mapping mutates the struct - // in place, so it is only correct on a writable variable; the `ref this` here means that applying it to an - // `in` parameter fails to compile (CS8329) instead of silently taking a defensive copy, mutating that, and - // discarding it - which would leave keys unprefixed, i.e. a wrong-keyspace bug rather than a perf nit. - // (Deliberately not named Map: an extension cannot shadow the instance member, so the guard would be lost.) - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static void MapInPlace(this ref TState state, IRedisArgsMutator mutator) - where TState : struct, IMappableRedisArgs -#pragma warning disable CS0618 // the one sanctioned call site: `state` is a genuine `ref`, so this mutates in place - => state.Map(mutator); -#pragma warning restore CS0618 - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static TResult UnMap(this IRedisArgsMutator mutator, in TState state, TResult result) - where TState : struct, IMappableRedisArgs - { - // note JIT will elide these tests using per-TResult value-type rules - if (typeof(TResult) == typeof(RedisKey)) - { - var tmp = mutator.UnMap(Unsafe.As(ref result)); - return Unsafe.As(ref tmp); - } - - if (typeof(TResult) == typeof(RedisChannel)) - { - var tmp = mutator.UnMap(Unsafe.As(ref result)); - return Unsafe.As(ref tmp); - } - - if (typeof(TResult) == typeof(RedisValue)) - { - return result; // never mapped - } - - return state.UnMapper is IRedisArgsResult unmap ? unmap.UnMap(mutator, result) : result; - } - - [return: NotNullIfNotNull("keys")] - public static RedisKey[]? Map(this IRedisArgsMutator mutator, RedisKey[]? keys) - { - if (keys is null || keys.Length is 0) return keys; - var arr = new RedisKey[keys.Length]; - for (int i = 0; i < arr.Length; i++) - { - arr[i] = mutator.Map(keys[i]); - } - return arr; - } - - // ScriptEvaluateResp's keys parameter - every element is a key (unlike RedisKeyOrValue below), - // mirroring the RedisKey[]? overload above but for the ReadOnlyMemory shape. - public static ReadOnlyMemory Map(this IRedisArgsMutator mutator, ReadOnlyMemory keys) - { - if (keys.Length is 0) return keys; - var arr = new RedisKey[keys.Length]; - var span = keys.Span; - for (int i = 0; i < arr.Length; i++) - { - arr[i] = mutator.Map(span[i]); - } - return arr; - } - - // the ExecuteResp escape hatch mixes keys and values in one collection (mirroring KeyPrefixed.ToInner); - // rewrite only the key-shaped entries, copying only when there is something to rewrite so the common - // all-values call allocates nothing. - public static ReadOnlyMemory Map(this IRedisArgsMutator mutator, ReadOnlyMemory args) - { - if (args.Length is 0) return args; - var span = args.Span; - RedisKeyOrValue[]? copy = null; - for (int i = 0; i < span.Length; i++) - { - if (span[i].IsKey) - { - (copy ??= span.ToArray())[i] = RedisKeyOrValue.FromKey(mutator.Map(span[i].Key)); - } - } - return copy ?? args; - } - - [return: NotNullIfNotNull("pairs")] - public static KeyValuePair[]? Map( - this IRedisArgsMutator mutator, - KeyValuePair[]? pairs) - { - if (pairs is null || pairs.Length is 0) return pairs; - var arr = new KeyValuePair[pairs.Length]; - for (int i = 0; i < arr.Length; i++) - { - ref readonly KeyValuePair pair = ref pairs[i]; - arr[i] = new(mutator.Map(pair.Key), pair.Value); - } - return arr; - } - - public static StreamPosition Map(this IRedisArgsMutator mutator, StreamPosition value) => - new(mutator.Map(value.Key), value.Position); - - [return: NotNullIfNotNull("positions")] - public static StreamPosition[]? Map(this IRedisArgsMutator mutator, StreamPosition[]? positions) - { - if (positions is null || positions.Length is 0) return positions; - var arr = new StreamPosition[positions.Length]; - for (int i = 0; i < arr.Length; i++) - { - ref readonly StreamPosition position = ref positions[i]; - arr[i] = new(mutator.Map(position.Key), position.Position); - } - return arr; - } - - // the Execute/ExecuteAsync escape hatch takes a loosely-typed arg list in which any element may - // be a boxed RedisKey or RedisChannel; these rewrite just those entries (mirroring - // KeyPrefixed.ToInner), copying only when there is something to rewrite so the common call allocates nothing. - [return: NotNullIfNotNull("args")] - public static object[]? Map(this IRedisArgsMutator mutator, object[]? args) - { - if (args is null || args.Length is 0) return args; - object[]? copy = null; - for (int i = 0; i < args.Length; i++) - { - if (args[i] is RedisKey key) - { - (copy ??= (object[])args.Clone())[i] = mutator.Map(key); - } - else if (args[i] is RedisChannel channel) - { - (copy ??= (object[])args.Clone())[i] = mutator.Map(channel); - } - } - return copy ?? args; - } - - [return: NotNullIfNotNull("args")] - public static ICollection? Map(this IRedisArgsMutator mutator, ICollection? args) - { - if (args is null || args.Count is 0) return args; - bool any = false; - foreach (var arg in args) - { - if (arg is RedisKey or RedisChannel) - { - any = true; - break; - } - } - if (!any) return args; - - var copy = new object[args.Count]; - int i = 0; - foreach (var arg in args) - { - copy[i++] = arg switch - { - RedisKey key => mutator.Map(key), - RedisChannel channel => mutator.Map(channel), - _ => arg, - }; - } - return copy; - } - - public static SortedSetPopResult UnMap(this IRedisArgsMutator mutator, SortedSetPopResult value) => - value.IsNull ? SortedSetPopResult.Null : new(mutator.Map(value.Key), value.Entries); - - public static ListPopResult UnMap(this IRedisArgsMutator mutator, ListPopResult value) => - value.IsNull ? ListPopResult.Null : new(mutator.Map(value.Key), value.Values); -} diff --git a/src/StackExchange.Redis/Availability/RespRetryExecutor.cs b/src/StackExchange.Redis/Availability/RespRetryExecutor.cs index 2cd23b1ff5..c9f2fbae2f 100644 --- a/src/StackExchange.Redis/Availability/RespRetryExecutor.cs +++ b/src/StackExchange.Redis/Availability/RespRetryExecutor.cs @@ -54,8 +54,8 @@ internal RespRetryExecutor(RespExecutorBase inner, RetryPolicy policy, FuncThe policy in force; read by the tests, which assert how a policy was resolved. internal RetryPolicy Policy => _controller.Policy; - /// The controller, shared with so a transaction created from a - /// retrying database applies exactly the policy the database does. + /// The controller, shared with so a transaction + /// created from a retrying database applies exactly the policy the database does. internal RetryController Controller => _controller; /// The executor underneath, so a second WithRetry can refuse rather than nest. diff --git a/src/StackExchange.Redis/Availability/RespRetryTransactionExecutor.cs b/src/StackExchange.Redis/Availability/RespRetryTransactionExecutor.cs new file mode 100644 index 0000000000..4236ca5645 --- /dev/null +++ b/src/StackExchange.Redis/Availability/RespRetryTransactionExecutor.cs @@ -0,0 +1,631 @@ +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; +using StackExchange.Redis.Protocol; + +namespace StackExchange.Redis.Availability; + +/// +/// A transaction that replays as a unit: the frame-level successor to the capture-and-replay +/// RetryTransaction. +/// +/// +/// +/// What is stored is the rendered request, not the method call. Where RetryTransaction +/// recorded every builder invocation into a generated state struct and replayed it against a fresh +/// , this accumulates what the command surface already produced - the rendered +/// , its handler, and the conditions in semantic form - and each attempt feeds +/// them into a fresh, one-shot . Same unit, same loop, no generator. +/// +/// +/// Why replay cannot reuse the attempt's operations. Once a run is written, each queued operation +/// is a pooled, single-completion source enrolled with that connection: the connection's own teardown +/// faults it, and a second enrollment while the first may still touch it is a use-after-release on the +/// pool. So the operations enrolled per attempt are the attempt's own, and the caller holds durable +/// proxies that settle only when the unit has finished for good - exactly the shape +/// RetryTransaction used, one layer down. +/// +/// +/// Why replaying the unit is safe at all: the WATCH constraints live in the conditions, not the +/// queue, and each attempt re-issues them on its own connection - so a replay re-adjudicates against +/// fresh state rather than running with a dead connection's guard silently gone. The queued commands +/// run only if the re-issued conditions hold and the EXEC commits. An EXEC that was +/// written and never answered is NOT replayed blindly: the fault carries the queue's aggregate retry +/// category, so the shared policy gates the whole transaction exactly like one command. +/// +/// +internal sealed class RespRetryTransactionExecutor : RespExecutorBase, ITransactionExecutor +{ + private readonly RespExecutorBase _inner; + private readonly RespContext _context; + private readonly RetryController _controller; + private readonly Func? _failoverSource; + private readonly object _sync = new(); + + private List? _recorded; + private List? _conditions; + private int _executed; + private volatile bool _watchConflict; + + /// Create a retrying transaction over an executor. + /// The executor underneath the retry link; each attempt resolves through it. + /// The context conditions render through; it must NOT carry the retry link. + /// The shared retry controller, from the database's RespRetryExecutor. + internal RespRetryTransactionExecutor(RespExecutorBase inner, RespContext context, RetryController controller) + { + _inner = inner ?? throw new ArgumentNullException(nameof(inner)); + _context = context ?? throw new ArgumentNullException(nameof(context)); + _controller = controller ?? throw new ArgumentNullException(nameof(controller)); + _failoverSource = inner.GetFailoverSource(); + } + + /// + internal override bool Accumulates => true; + + /// + internal override bool Transactional => true; + + /// + public override int Database => _inner.Database; + + /// + internal override IConnectionMultiplexer? ExposedMultiplexer => _inner.ExposedMultiplexer; + + /// + internal override RespExecutorBase? ResolveFor(in RedisKey key, RedisCommand command, CommandFlags flags) + => _inner.ResolveFor(in key, command, flags); + + /// + /// Yes: the recorded request is this executor's own reference (or copy) by the time this returns. + internal override bool CopiesRequestOnSend => true; + + /// + public bool WasWatchConflict => _watchConflict; + + /// + public override RespPayload Send(in RespRequest request) + => throw new NotSupportedException("A queued command cannot be waited on before the transaction is executed."); + + /// + /// + /// The payload shape: the recorded command owns no handler, and the final attempt's payload is handed + /// to the caller intact rather than parsed - the same contract as the plain executor's untyped path. + /// The request is NOT retained here: by that path's convention the caller holds its reference until + /// the returned task completes, which is exactly the final attempt. + /// + public override ValueTask SendAsync(RespRequest request, CancellationToken cancellationToken = default) + { + if ((request.Flags & CommandFlags.FireAndForget) != 0) + { + Record(new RecordedPayload(request, ownsRequest: false, proxy: null, cancellationToken)); + return default; + } + + var proxy = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + Record(new RecordedPayload(request, ownsRequest: false, proxy, cancellationToken)); + return new ValueTask(proxy.Task); + } + + /// + internal override ValueTask SendTypedAsync( + RespRequest request, IRespHandler handler, CancellationToken cancellationToken) + { + // the same special case as the plain executor: a payload-typed result goes the untyped route + if (typeof(TResult) == typeof(RespPayload)) return RespExecutor.AwaitUncached(this, request, handler, cancellationToken); + + // ToOwned: a borrowed request is copied, an owned one is kept - this path's convention + // (CopiesRequestOnSend) makes the incoming reference ours to keep, and Release gives it back + var owned = request.ToOwned(); + + if ((owned.Flags & CommandFlags.FireAndForget) != 0) + { + Record(new Recorded(owned, ownsRequest: true, handler, proxy: null, _inner, cancellationToken)); + + // the one shared completed-default task, as the plain transaction hands out for the same case + return new ValueTask(CompletedTask.Default(null)!); + } + + var proxy = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + Record(new Recorded(owned, ownsRequest: true, handler, proxy, _inner, cancellationToken)); + return new ValueTask(proxy.Task); + } + + /// + internal override ValueTask SendVoidAsync(RespRequest request, IRespHandler handler, CancellationToken cancellationToken) + { + var pending = SendTypedAsync(request, handler, cancellationToken); + if (pending.IsCompletedSuccessfully) + { + _ = pending.Result; + return default; + } + + return new ValueTask(pending.AsTask()); + } + + private void Record(IRecorded recorded) + { + lock (_sync) + { + if (_executed != 0) throw new InvalidOperationException("This transaction has already been executed."); + (_recorded ??= []).Add(recorded); + } + } + + /// + public void AddCondition(Condition condition, Action? onVerdict = null) + { + if (condition is null) throw new ArgumentNullException(nameof(condition)); + lock (_sync) + { + if (_executed != 0) throw new InvalidOperationException("Operations cannot be added after the transaction has been executed."); + (_conditions ??= []).Add(new RecordedCondition(condition, onVerdict)); + } + } + + /// + /// The fold the retry policy gates the whole unit with; see the plain executor's twin. + public CommandFlags AggregateRetryCategory + { + get + { + var result = CommandFlags.None; + lock (_sync) + { + if (_recorded is { } recorded) + { + foreach (var op in recorded) + { + var category = op.Flags & CommandFlagsInternal.MaskRetryCategory; + if (category > result) result = category; + } + } + } + + return result; + } + } + + /// + public async Task ExecuteAsync(CommandFlags flags = CommandFlags.None) + { + List? recorded; + List? conditions; + lock (_sync) + { + if (_executed != 0) throw new InvalidOperationException("This transaction has already been executed."); + _executed = 1; + + // taken under the lock, so the loops below run over lists nothing can still be adding to + recorded = _recorded; + conditions = _conditions; + _recorded = null; + _conditions = null; + } + + try + { + return await ExecuteCoreAsync(flags, recorded ?? [], conditions).ConfigureAwait(false); + } + finally + { + if (recorded is not null) + { + foreach (var op in recorded) op.Release(); + } + } + } + + private async Task ExecuteCoreAsync(CommandFlags flags, List recorded, List? conditions) + { + var attemptCount = 0; + + // captured BEFORE the first attempt - otherwise a failover between a failed attempt and + // re-reading the token could be missed (same reasoning as RespRetryExecutor) + var failover = _controller.TracksFailover ? (_failoverSource?.Invoke() ?? CancellationToken.None) : CancellationToken.None; + + // watch contention gets its own budget; only meaningful when there are conditions to WATCH + var watchAttempt = 0; + var maxWatchAttempts = conditions is null ? 1 : _controller.MaxWatchConflictAttempts; + while (true) + { + // a fresh, one-shot unit per attempt: the conditions re-render and re-WATCH on whatever + // connection this attempt lands on, and the queued frames re-enroll as that attempt's own + // operations - the durable proxies the caller holds are settled only at the end + var attempt = new RespTransactionExecutor(_inner, _context, reusable: false); + if (conditions is not null) + { + foreach (var condition in conditions) condition.Replay(attempt); + } + + foreach (var op in recorded) op.Replay(attempt); + + // the aggregate category rides on the EXEC's flags, so the fault it reports carries it and + // the shared policy gates the whole transaction exactly like one command + var effectiveFlags = (flags & ~CommandFlagsInternal.MaskRetryCategory) | attempt.AggregateRetryCategory; + + try + { + var committed = await attempt.ExecuteAsync(effectiveFlags).ConfigureAwait(false); + _watchConflict = attempt.WasWatchConflict; + + // the server rejected an EXEC we really did issue because a watched key changed under us: + // contention rather than a fault, so it has its own budget, waits its own delay, and the + // side-effect category does not apply - nothing happened + if (!committed && _watchConflict && ++watchAttempt < maxWatchAttempts) + { + DiscardAttempt(recorded, conditions); + await _controller.WatchConflictDelayAsync().ConfigureAwait(false); + continue; + } + + // clean completion (committed, or electively aborted): forward the per-attempt outcomes + // onto the durable proxies - settled before we return, unless the caller declined the + // EXEC's own reply, in which case waiting is the opposite of what they asked + if (conditions is not null) + { + foreach (var condition in conditions) condition.Forward(); + } + + List? settling = null; + foreach (var op in recorded) + { + if (op.ForwardOutcome() is { } pending) (settling ??= []).Add(pending); + } + + if (settling is not null && (effectiveFlags & CommandFlags.FireAndForget) == 0) + { + foreach (var pending in settling) + { + await pending.ConfigureAwait(false); // never faults: the forwarders catch and settle the proxy + } + } + + return committed; + } + catch (Exception ex) + { + if (_controller.CanRetry(++attemptCount, ex, ref failover, out var delay)) + { + DiscardAttempt(recorded, conditions); + await _controller.FailoverOrDelayAsync(delay).ConfigureAwait(false); + continue; + } + + // out of road: fault the durable proxies and surface the failure to the caller + foreach (var op in recorded) op.Fault(ex); + throw; + } + } + } + + /// Consume a discarded attempt's results and reset for the next. + private static void DiscardAttempt(List recorded, List? conditions) + { + foreach (var op in recorded) op.Drain(); + if (conditions is not null) + { + foreach (var condition in conditions) condition.Reset(); + } + } + + // ---- recorded work ----------------------------------------------------------------------------- + private interface IRecorded + { + /// The recorded request's flags, for the aggregate retry category. + CommandFlags Flags { get; } + + /// Queue the recorded request onto this attempt's unit. + void Replay(RespTransactionExecutor attempt); + + /// + /// Copy this attempt's outcome onto the durable proxy; the returned task is the settling still in + /// flight (a fire-and-forget EXEC completes before the replies land), or null when it is done. + /// + Task? ForwardOutcome(); + + /// Consume a discarded attempt's result, so a pooled source is released and a fault is observed. + void Drain(); + + /// Fault the durable proxy; the unit is out of attempts. + void Fault(Exception ex); + + /// Give back the recorded request, once, after the unit has finished with it for good. + void Release(); + } + + /// A recorded command whose caller wants a parsed . + private sealed class Recorded : IRecorded + { + private readonly RespRequest _request; + private readonly bool _ownsRequest; + private readonly IRespHandler _handler; + private readonly TaskCompletionSource? _proxy; // null: fire-and-forget declined the reply + private readonly RespExecutorBase _authSource; + private readonly CancellationToken _cancellationToken; + private ValueTask _attempt; + private bool _hasAttempt; + + public Recorded( + in RespRequest request, + bool ownsRequest, + IRespHandler handler, + TaskCompletionSource? proxy, + RespExecutorBase authSource, + CancellationToken cancellationToken) + { + _request = request; + _ownsRequest = ownsRequest; + _handler = handler; + _proxy = proxy; + _authSource = authSource; + _cancellationToken = cancellationToken; + } + + public CommandFlags Flags => _request.Flags; + + public void Replay(RespTransactionExecutor attempt) + { + _attempt = attempt.SendAsync(_request, _cancellationToken); + _hasAttempt = true; + } + + public Task? ForwardOutcome() + { + if (_proxy is null) + { + Drain(); // fire-and-forget: nothing to carry, but a pooled source still has to be consumed + return null; + } + + if (!_hasAttempt) return null; // loud failure below would hide the real bug; Replay always precedes + var attempt = _attempt; + _attempt = default; + _hasAttempt = false; + if (attempt.IsCompleted) + { + Forward(attempt); + return null; + } + + return ForwardAsync(attempt); + } + + private void Forward(ValueTask attempt) + { + RespPayload? payload = null; + try + { + payload = attempt.GetAwaiter().GetResult(); + _proxy!.TrySetResult(RespExecutor.Parse(_handler, payload)); + } + catch (OperationCanceledException) + { + _proxy!.TrySetCanceled(); + } + catch (RedisServerException ex) when (RespExecutor.AuthFault(_authSource, ex) is { } authFault) + { + _proxy!.TrySetException(authFault); + } + catch (Exception ex) + { + _proxy!.TrySetException(ex); + } + finally + { + payload?.Release(); + } + } + + private async Task ForwardAsync(ValueTask attempt) + { + RespPayload? payload = null; + try + { + payload = await attempt.ConfigureAwait(false); + _proxy!.TrySetResult(RespExecutor.Parse(_handler, payload)); + } + catch (OperationCanceledException) + { + _proxy!.TrySetCanceled(); + } + catch (RedisServerException ex) when (RespExecutor.AuthFault(_authSource, ex) is { } authFault) + { + _proxy!.TrySetException(authFault); + } + catch (Exception ex) + { + _proxy!.TrySetException(ex); + } + finally + { + payload?.Release(); + } + } + + public void Drain() + { + if (!_hasAttempt) return; + var attempt = _attempt; + _attempt = default; + _hasAttempt = false; + DrainCore(attempt); + } + + public void Fault(Exception ex) + { + Drain(); + _proxy?.TrySetException(ex); + } + + public void Release() + { + if (_ownsRequest) _request.Dispose(); + } + } + + /// A recorded command whose caller wants the raw payload, handed over intact. + private sealed class RecordedPayload : IRecorded + { + private readonly RespRequest _request; + private readonly bool _ownsRequest; + private readonly TaskCompletionSource? _proxy; + private readonly CancellationToken _cancellationToken; + private ValueTask _attempt; + private bool _hasAttempt; + + public RecordedPayload(in RespRequest request, bool ownsRequest, TaskCompletionSource? proxy, CancellationToken cancellationToken) + { + _request = request; + _ownsRequest = ownsRequest; + _proxy = proxy; + _cancellationToken = cancellationToken; + } + + public CommandFlags Flags => _request.Flags; + + public void Replay(RespTransactionExecutor attempt) + { + _attempt = attempt.SendAsync(_request, _cancellationToken); + _hasAttempt = true; + } + + public Task? ForwardOutcome() + { + if (_proxy is null) + { + Drain(); + return null; + } + + if (!_hasAttempt) return null; + var attempt = _attempt; + _attempt = default; + _hasAttempt = false; + if (attempt.IsCompleted) + { + Forward(attempt); + return null; + } + + return ForwardAsync(attempt); + } + + // ownership transfers to the caller: the payload is NOT released here + private void Forward(ValueTask attempt) + { + try + { + _proxy!.TrySetResult(attempt.GetAwaiter().GetResult()); + } + catch (OperationCanceledException) + { + _proxy!.TrySetCanceled(); + } + catch (Exception ex) + { + _proxy!.TrySetException(ex); + } + } + + private async Task ForwardAsync(ValueTask attempt) + { + try + { + _proxy!.TrySetResult(await attempt.ConfigureAwait(false)); + } + catch (OperationCanceledException) + { + _proxy!.TrySetCanceled(); + } + catch (Exception ex) + { + _proxy!.TrySetException(ex); + } + } + + public void Drain() + { + if (!_hasAttempt) return; + var attempt = _attempt; + _attempt = default; + _hasAttempt = false; + DrainCore(attempt); + } + + public void Fault(Exception ex) + { + Drain(); + _proxy?.TrySetException(ex); + } + + public void Release() + { + if (_ownsRequest) _request.Dispose(); + } + } + + /// Consume a discarded attempt's result: release any payload, observe any fault. + private static void DrainCore(ValueTask attempt) + { + if (attempt.IsCompleted) + { + try + { + attempt.GetAwaiter().GetResult()?.Release(); + } + catch + { + // a discarded attempt; the outcome that matters is the retry decision already made + } + + return; + } + + _ = Awaited(attempt); + + static async Task Awaited(ValueTask pending) + { + try + { + (await pending.ConfigureAwait(false))?.Release(); + } + catch + { + // observed; see above + } + } + } + + /// A condition, re-issued per attempt, whose durable verdict sink hears only the final attempt. + private sealed class RecordedCondition + { + private readonly Condition _condition; + private readonly Action? _sink; + private bool _hasVerdict; + private bool _verdict; + + public RecordedCondition(Condition condition, Action? sink) + { + _condition = condition; + _sink = sink; + } + + public void Replay(RespTransactionExecutor attempt) + => attempt.AddCondition(_condition, OnVerdict); + + private void OnVerdict(bool satisfied) + { + _verdict = satisfied; + _hasVerdict = true; + } + + public void Reset() => _hasVerdict = false; + + public void Forward() + { + if (_hasVerdict) _sink?.Invoke(_verdict); + } + } +} diff --git a/src/StackExchange.Redis/Availability/RetryTransaction.cs b/src/StackExchange.Redis/Availability/RetryTransaction.cs deleted file mode 100644 index 351bafb8e0..0000000000 --- a/src/StackExchange.Redis/Availability/RetryTransaction.cs +++ /dev/null @@ -1,537 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Runtime.CompilerServices; -using System.Threading; -using System.Threading.Tasks; -using StackExchange.Redis.Interfaces; - -namespace StackExchange.Redis.Availability; - -// A retryable transaction. Unlike RespRetryExecutor - which replays a single rendered frame each attempt - -// a transaction is built up across many builder calls plus an Execute, so we *record* each captured call -// (the AutoDatabase (state, projection) pair) and hand the caller a durable, still-incomplete proxy task. -// Only ExecuteAsync actually runs anything: for each attempt it spins up a fresh, one-shot inner transaction -// against the underlying database (which, for a multi-group connection, resolves the currently-active member, -// so a retry after failover lands on the new member), replays every recorded operation and constraint onto -// it, and awaits it. On a clean execution the per-attempt results are forwarded onto the durable proxies; on -// a transient fault the whole attempt is discarded and replayed; on terminal failure the proxies are faulted. -// -// ITransaction (rather than just ITransactionAsync) so that callers written against the long-standing -// interface can move to a retrying database without rewriting their transaction code; the synchronous -// Execute is sync-over-async (see below). Note that ITransaction : IBatch : IDatabaseAsync, so the only -// members this adds over ITransactionAsync are the two Execute overloads. -// Replays: the recorded operations are re-run as a unit on every attempt, and a capture is held from the -// moment it is recorded until Execute - longer than a single dispatch holds one - so the captured arguments must -// be copies of the caller's memory rather than the caller's own buffer. They are released in ExecuteAsync, -// which is the only point that knows an operation will not be replayed again; a transaction that is never -// executed keeps its captures, and nothing here could know otherwise. -[AutoDatabase(Replays = true)] -internal sealed partial class RetryTransaction : IDatabaseAsync, ITransaction -{ - /// - public RespDatabaseContext Context => new(GetContextCore()); - // Note: the *command* surface is async-only - retrying is inherently - // delay-ish; only the terminal Execute is offered synchronously. - private readonly IDatabaseAsync _source; - private readonly RetryController _controller; - - /// Refuse to build a context, saying why. - /// - /// Still refused, where a retrying database's is not. A retrying database replays one - /// operation, so decorating its executor gives the context surface exactly the same behaviour. A - /// retrying transaction replays the whole recorded unit - conditions, queued operations and - /// EXEC together - and a retry executor knows nothing of that: it would re-send individual - /// frames inside a transaction, which is not a retry of anything the caller asked for. Retry arrives - /// here when the context surface has transactions, and not before. - /// - internal static RespContext GetContextCore() - => throw new NotImplementedException( - "The context surface does not support retrying transactions; a transaction is replayed as a " - + "unit, which a per-frame retry executor cannot express."); - - /// - RespContext IRespTarget.Context => GetContextCore(); - - // not readonly, and null until something is recorded: ExecuteAsync takes it and clears it, so the - // replay loop below runs over a list nothing else can still be adding to. A caller doing something - // strange - recording from another thread while executing - then gets an empty transaction rather than - // a collection mutated mid-enumeration, and the captures it recorded are its own to lose. - private List? _ops; - private List? _conditions; - private int _executed; - private volatile bool _watchConflict; - - /// - // reports the *final* attempt's outcome: false if we eventually committed (or aborted electively), - // true if we ran out of watch-conflict attempts still losing the race - public bool WasWatchConflict => _watchConflict; - - public RetryTransaction(IDatabaseAsync source, RetryController controller) - { - _source = source; - _controller = controller; - } - - public int Database => _source.Database; - - public IConnectionMultiplexer Multiplexer => _source.Multiplexer; - - /// - public override string ToString() => "retry-transaction: " + _source; - - // the generated explicit interface implementations funnel every builder call through these two - // overloads, capturing the arguments in a generated state struct plus a cacheable static projection - // (no per-call closure). Here we simply *record* them and return a durable proxy task. - private Task ExecuteAsync(in TState state, AutoDatabaseAsyncOperation operation) - where TState : struct, IDisposable - { - CheckNotExecuted(); - var op = new RecordedOp(state, operation, IsFireAndForget(in state)); - (_ops ??= new List()).Add(op); - return op.Proxy; - } - - private Task ExecuteAsync(in TState state, AutoDatabaseAsyncOperation operation) - where TState : struct, IDisposable - { - CheckNotExecuted(); - var op = new RecordedVoidOp(state, operation, IsFireAndForget(in state)); - (_ops ??= new List()).Add(op); - return op.Proxy; - } - - // A fire-and-forget operation must hand back an already-completed task, because that is what a plain - // RedisTransaction does (see its ExecuteAsync: F+F never gets a TaskCompletionSource at all). Without this - // the durable proxy stays incomplete until Execute, so identical caller code returns instantly on a plain - // transaction and blocks for good on a retrying one - which defeats this class's stated goal of letting - // ITransaction code move onto a retrying database unchanged. - // - // The op is still recorded and replayed like any other: fire-and-forget declines the *reply*, not the - // command. What it does not get is a proxy - see RecordedOp - so forwarding and faulting both become - // no-ops for it, and a discarded attempt can never fault a result the caller was told not to expect. - // - // The flags are captured inside TState, so this is the one thing the generated struct is asked to expose - // (IFlaggedRedisArgs). Testing a generic value against an interface boxes in IL, and this sits on every - // queued operation - but value-type generics are not shared, so the JIT knows the exact TState and - // compiles the whole thing to a field load with no allocator call at all (11 bytes of machine code). - // - // Measured on net10.0 rather than reasoned about, because none of it is obvious - bytes per call: - // - // `is` pattern, tier-0 ......... 24 `is` pattern, optimized ....... 0 - // cast instead of `is` ......... 24 ...with AggressiveOptimization 0 - // - // Two findings worth keeping. Rewriting the `is` pattern as a cast does *not* avoid the box - both - // spellings emit the same one - so the attribute below is the fix rather than a different expression. - // And a TState *without* the interface costs nothing even in tier-0: the test folds to a constant and - // the dead box is removed, so the states that captured no flags never pay for this at all. - - // skips tiering, so the above is free from the first call rather than only after tier-1 promotion -#if NET - [MethodImpl(MethodImplOptions.AggressiveOptimization)] -#endif - private static bool IsFireAndForget(in TState state) - where TState : struct - => state is IFlaggedRedisArgs flagged && (flagged.Flags & CommandFlags.FireAndForget) != 0; - - public ConditionResult AddCondition(Condition condition) - { - if (condition is null) throw new ArgumentNullException(nameof(condition)); - CheckNotExecuted(); - var recorded = new RecordedCondition(condition); - (_conditions ??= new List()).Add(recorded); - return recorded.Result; - } - - public async Task ExecuteAsync(CommandFlags flags = CommandFlags.None) - { - if (Interlocked.CompareExchange(ref _executed, 1, 0) != 0) - { - throw new InvalidOperationException("This transaction has already been executed"); - } - - // take the recordings off the instance before replaying any of them, so the loops below run over - // lists nothing else can still be adding to; a caller recording from another thread mid-execution - // then gets left out rather than mutating a collection under enumeration. The operations' captured - // arguments are released once we are done with them, however that turns out - though a transaction - // that is never executed keeps its captures, since nothing here could know. - var ops = _ops; - var conditions = _conditions; - _ops = null; - _conditions = null; - try - { - return await ExecuteAsync(flags, ops ?? EmptyOps, conditions).ConfigureAwait(false); - } - finally - { - if (ops is not null) - { - foreach (var op in ops) op.Release(); - } - } - } - - private static readonly List EmptyOps = new(); - - private async Task ExecuteAsync(CommandFlags flags, List ops, List? conditions) - { - int attempt = 0; - // capture the next-failover token *before* the first attempt - otherwise a failover between a - // failed attempt and re-reading the token could be missed - CancellationToken failover = _controller.TracksFailover ? _source.GetNextFailover() : CancellationToken.None; - - // watch contention gets its own budget; only meaningful when there are conditions to WATCH - int watchAttempt = 0; - int maxWatchAttempts = conditions is null ? 1 : _controller.MaxWatchConflictAttempts; - while (true) - { - // no async-state: a retrying transaction refuses one (the durable proxies below cannot carry it) - var inner = _source.CreateTransaction(); - - // replay the recorded constraints and operations onto this fresh, one-shot transaction; the - // per-attempt tasks they return are forwarded to the durable proxies only on a clean execution - if (conditions is not null) - { - foreach (var c in conditions) c.Replay(inner); - } - foreach (var op in ops) op.Replay(inner); - - // inject the aggregate retry category onto the EXEC flags so the resulting fault carries it, and - // the shared RetryPolicy/FaultContext logic gates the whole transaction exactly like one command - var category = inner is IInternalTransaction it ? it.GetAggregateRetryCategory() : CommandFlags.CommandRetryNever; - var effectiveFlags = (flags & ~CommandFlagsInternal.MaskRetryCategory) | category; - - try - { - bool committed = await inner.ExecuteAsync(effectiveFlags).ConfigureAwait(false); - _watchConflict = inner.WasWatchConflict; // surfaced to our own caller, per attempt - - // The server rejected an EXEC we really did issue, because another connection changed a - // watched key: the conditions still held, nothing was applied, and we simply lost a race. - // Re-read and try again (which re-issues the WATCH constraints, so a condition that has - // genuinely stopped holding converges on an elective abort instead of looping). This is - // contention rather than a fault, so it neither consumes the fault budget nor waits for a - // failover, and the side-effect category does not apply - nothing happened. - if (!committed - && _watchConflict - && ++watchAttempt < maxWatchAttempts) - { - foreach (var op in ops) op.Observe(); - await _controller.WatchConflictDelayAsync().ConfigureAwait(false); - continue; - } - - // clean completion (committed, or aborted); forward the per-attempt outcomes onto the - // durable proxies and we're done - if (conditions is not null) - { - foreach (var c in conditions) c.ForwardSuccess(); - } - List? settling = null; - foreach (var op in ops) - { - if (op.ForwardSuccess() is { } pending) (settling ??= new()).Add(pending); - } - - // SETTLED before we return, not merely scheduled - unless the caller declined the EXEC's own - // reply, in which case there is nothing to wait for and waiting would be the opposite of what - // they asked. Faults are swallowed here on purpose: they belong on the per-command proxy, - // where the caller reads them, and must not fail the transaction as a whole. - if (settling is not null && (effectiveFlags & CommandFlags.FireAndForget) == 0) - { - foreach (var pending in settling) - { - try - { - await pending.ConfigureAwait(false); - } - catch - { - // carried by the proxy; see above - } - } - } - - return committed; - } - catch (Exception ex) - { - if (_controller.CanRetry(++attempt, ex, ref failover, out var delay)) - { - // discard this attempt; observe its faulted per-attempt tasks so they don't surface as - // unobserved, then wait / failover and replay from the recorded snapshot - foreach (var op in ops) op.Observe(); - await _controller.FailoverOrDelayAsync(delay).ConfigureAwait(false); - continue; - } - - // out of road: fault the durable proxies and surface the failure to the caller - foreach (var op in ops) op.Fault(ex); - throw; - } - } - } - - // ---- the synchronous ITransaction surface ------------------------------------------------------- - // Both are explicit implementations: they exist purely so that callers written against ITransaction can - // move onto a retrying database, so they should be reachable only *through* that interface - internal - // code (which has ExecuteAsync) has no business blocking, and this also keeps Execute() and - // Execute(flags) from competing in overload resolution on the concrete type. - - /// - // The IBatch shape: enqueue, and don't ask about the outcome. Mirrors RedisTransaction by mapping onto - // fire-and-forget - which for a *retrying* transaction means there is nothing for the retry machinery to - // observe (no reply is requested, so no fault is ever reported) and it collapses to a single attempt: - // the trade-off fire-and-forget always makes, here extending to the retries as well. - void IBatch.Execute() => ((ITransaction)this).Execute(CommandFlags.FireAndForget); - - /// - // Sync-over-async, deliberately: retrying is inherently delay-ish, which is why the *command* surface - // here is async-only - but a caller written against ITransaction has no async alternative for the - // terminal Execute, and refusing it would mean such code cannot adopt a retrying database at all. - // Blocking here is safe against a captured synchronization context: every await in ExecuteAsync (and in - // RetryController) is ConfigureAwait(false), and the per-operation proxies complete asynchronously. - // - // The wait is *not* bounded by the multiplexer's SyncTimeout - the whole point of a retry is to outlast - // the fault, so the delays between attempts are expected to exceed it. Each individual attempt is still - // bounded by the inner connection's own timeout, so the total remains bounded by the attempt budget. - // GetResult (rather than Wait) so the original exception surfaces, not an AggregateException wrapping it. - bool ITransaction.Execute(CommandFlags flags) => ExecuteAsync(flags).GetAwaiter().GetResult(); - - private void CheckNotExecuted() - { - if (Volatile.Read(ref _executed) != 0) - { - throw new InvalidOperationException("Operations cannot be added after the transaction has been executed"); - } - } - - // ---- recorded work ------------------------------------------------------------------------------- - private interface IRecordedOp - { - void Replay(IDatabaseAsync inner); - - // Copy this attempt's outcome onto the durable proxy, and say whether that had to be DEFERRED: the - // returned task is the attempt whose completion will settle the proxy, or null when it already has. - // - // A *replied* EXEC populates every queued operation's result before its own task completes - // (TransactionProcessor does both while processing that one reply), so the outcome is normally - // available inline. Two cases are not: - // - // - a fire-and-forget EXEC completes as soon as it has been written, with the replies still in - // flight. Waiting there would block for a round trip the caller explicitly declined, which is - // what F+F means and what a plain RedisTransaction does in the same situation - so the caller - // ignores the returned task; - // - the NEW core sets those results inline too, but publishes each caller-facing task through a - // queued continuation, deliberately, so that a reply never runs user code on the IO thread. The - // result is there and the Task has not caught up, which is a distinction no caller should be able - // to see: `await ExecuteAsync()` has always meant the per-command tasks are settled. So the - // caller waits on what is returned, unless the EXEC itself was declined. - Task? ForwardSuccess(); - void Fault(Exception ex); - void Observe(); - - /// - /// Give back anything the captured arguments own. Called once, after the transaction has finished - /// with this operation for good - not per attempt, since every attempt replays the same capture. - /// - void Release(); - } - - private sealed class RecordedOp : IRecordedOp - where TState : struct, IDisposable - { - // not readonly: releasing clears the capture in place, which a defensive copy would not - private TState _state; - private readonly AutoDatabaseAsyncOperation _operation; - private readonly TaskCompletionSource? _proxy; - private Task? _attempt; - - public RecordedOp(in TState state, AutoDatabaseAsyncOperation operation, bool fireAndForget) - { - _state = state; - _operation = operation; - - // Fire-and-forget declines the reply, so there is nothing for a proxy to carry and none is built - - // saving *both* objects, the TaskCompletionSource and the Task it creates in its own constructor, - // on every fire-and-forget operation queued. Proxy hands back the shared completed task instead, - // which is the same instance a plain RedisTransaction returns for this case. - // - // The value is default(TResult) rather than the command's own "no reply" value, which lives inside - // the command implementation and is not reachable from here - a distinction without a difference, - // since neither is an answer from the server. - _proxy = fireAndForget ? null : new(TaskCreationOptions.RunContinuationsAsynchronously); - } - - // the ! is an annotation artifact, not a null: TResult is unconstrained, so Task and - // Task are the same type - Default simply spells its return the other way round - public Task Proxy => _proxy?.Task ?? CompletedTask.Default(null)!; - - public void Replay(IDatabaseAsync inner) => _attempt = _operation(in _state, inner); - - public Task? ForwardSuccess() - { - // fire-and-forget: Forward guards too, so this is here to skip the continuation below rather than - // for correctness - there is no point registering one to settle a proxy that does not exist - if (_proxy is null) return null; - - // ForwardSuccess only runs after Replay, so this cannot be null; `?? throw` says that to the - // compiler as well as the reader, and keeps the failure loud if the order ever changes - var attempt = _attempt ?? throw new InvalidOperationException("Cannot forward a result before the operation has been replayed"); - if (attempt.IsCompleted) - { - Forward(attempt); - return null; - } - - ForwardLater(attempt); - return attempt; - } - - private void ForwardLater(Task attempt) => attempt.ContinueWith( - static (completed, state) => ((RecordedOp)state!).Forward(completed), - this, - CancellationToken.None, - TaskContinuationOptions.ExecuteSynchronously, - TaskScheduler.Default); - - private void Forward(Task attempt) - { - // a null proxy is fire-and-forget; `?.` then skips the argument too, including the Exception - // access that would otherwise observe a fault. Safe only because such an attempt is the shared - // completed task RedisTransaction hands back for F+F, so it cannot fault - see Observe for the - // attempts that can. - if (attempt.IsCanceled) _proxy?.TrySetCanceled(); - else if (attempt.IsFaulted) _proxy?.TrySetException(attempt.Exception!.InnerExceptions); - else _proxy?.TrySetResult(attempt.GetAwaiter().GetResult()); - } - - // observe the (faulted) inner attempt before faulting the durable proxy, so the discarded - // per-attempt task doesn't surface as an unobserved exception - public void Fault(Exception ex) - { - Observe(); - _proxy?.TrySetException(ex); - } - - public void Observe() => _ = _attempt?.Exception; - - public void Release() => _state.Dispose(); - } - - private sealed class RecordedVoidOp : IRecordedOp - where TState : struct, IDisposable - { - // not readonly: releasing clears the capture in place, which a defensive copy would not - private TState _state; - private readonly AutoDatabaseAsyncOperation _operation; - private readonly TaskCompletionSource? _proxy; - private Task? _attempt; - - public RecordedVoidOp(in TState state, AutoDatabaseAsyncOperation operation, bool fireAndForget) - { - _state = state; - _operation = operation; - _proxy = fireAndForget ? null : new(TaskCreationOptions.RunContinuationsAsynchronously); // see RecordedOp - } - - public Task Proxy => _proxy?.Task ?? Task.CompletedTask; - - public void Replay(IDatabaseAsync inner) => _attempt = _operation(in _state, inner); - - public Task? ForwardSuccess() - { - if (_proxy is null) return null; // fire-and-forget: see RecordedOp.ForwardSuccess - - // ForwardSuccess only runs after Replay, so this cannot be null; `?? throw` says that to the - // compiler as well as the reader, and keeps the failure loud if the order ever changes - var attempt = _attempt ?? throw new InvalidOperationException("Cannot forward a result before the operation has been replayed"); - if (attempt.IsCompleted) - { - Forward(attempt); - return null; - } - - ForwardLater(attempt); - return attempt; - } - - private void ForwardLater(Task attempt) => attempt.ContinueWith( - static (completed, state) => ((RecordedVoidOp)state!).Forward(completed), - this, - CancellationToken.None, - TaskContinuationOptions.ExecuteSynchronously, - TaskScheduler.Default); - - private void Forward(Task attempt) - { - // see RecordedOp.Forward for why `?.` is safe here - if (attempt.IsCanceled) _proxy?.TrySetCanceled(); - else if (attempt.IsFaulted) _proxy?.TrySetException(attempt.Exception!.InnerExceptions); - else _proxy?.TrySetResult(true); - } - - // observe the (faulted) inner attempt before faulting the durable proxy, so the discarded - // per-attempt task doesn't surface as an unobserved exception - public void Fault(Exception ex) - { - Observe(); - _proxy?.TrySetException(ex); - } - - public void Observe() => _ = _attempt?.Exception; - - public void Release() => _state.Dispose(); - } - - private sealed class RecordedCondition - { - private readonly Condition _condition; - private ConditionResult? _attempt; - - public RecordedCondition(Condition condition) - { - _condition = condition; - Result = new ConditionResult(condition); - } - - // the durable result handed back to the caller from AddCondition - public ConditionResult Result { get; } - - public void Replay(ITransactionAsync inner) => _attempt = inner.AddCondition(_condition); - - // Unlike the operations, this needs no deferral for a fire-and-forget EXEC: a conditional transaction - // has to know whether its constraints held before it can decide between EXEC and DISCARD, so the - // condition replies are resolved as part of writing it - even when the EXEC itself wants no reply. - public void ForwardSuccess() - { - if (_attempt is not null) Result.SetSatisfied(_attempt.WasSatisfied); - } - } - - // ---- hand-implemented members the generator deliberately skips ---------------------------------- - // (the Wait family, the synchronous IsConnected probe, and the streaming scans). Wait/IsConnected are - // straight pass-throughs; scans cannot participate in a transaction. - // forwarding is not using: these decorators must implement the interface in full, and the - // implementation cannot be dropped while the interface declares it - #pragma warning disable SER308 // Blocking on a task through the library's Wait helpers - void IRedisAsync.Wait(Task task) => _source.Wait(task); - T IRedisAsync.Wait(Task task) => _source.Wait(task); - void IRedisAsync.WaitAll(Task[] tasks) => _source.WaitAll(tasks); - bool IRedisAsync.TryWait(Task task) => _source.TryWait(task); - #pragma warning restore SER308 - - bool IDatabaseAsync.IsConnected(RedisKey key, CommandFlags flags) => _source.IsConnected(key, flags); - - // routing lookup against the underlying database, not a queued transaction operation - Task IDatabaseAsync.IdentifyEndpointAsync(RedisKey key, CommandFlags flags) => _source.IdentifyEndpointAsync(key, flags); - - // nested transactions are not supported (mirrors RedisTransaction) - ITransactionAsync IDatabaseAsync.CreateTransaction(object? asyncState) => throw new NotSupportedException("Nested transactions are not supported"); - - IAsyncEnumerable IDatabaseAsync.HashScanAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => throw new NotSupportedException("Scans cannot be used inside a transaction"); - IAsyncEnumerable IDatabaseAsync.HashScanNoValuesAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => throw new NotSupportedException("Scans cannot be used inside a transaction"); - IAsyncEnumerable IDatabaseAsync.SetScanAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => throw new NotSupportedException("Scans cannot be used inside a transaction"); - IAsyncEnumerable IDatabaseAsync.VectorSetRangeEnumerateAsync(RedisKey key, RedisValue start, RedisValue end, long count, Exclude exclude, CommandFlags flags) => throw new NotSupportedException("Scans cannot be used inside a transaction"); - IAsyncEnumerable IDatabaseAsync.SortedSetScanAsync(RedisKey key, RedisValue pattern, int pageSize, long cursor, int pageOffset, CommandFlags flags) => throw new NotSupportedException("Scans cannot be used inside a transaction"); -} diff --git a/src/StackExchange.Redis/CapturedArgs.cs b/src/StackExchange.Redis/CapturedArgs.cs deleted file mode 100644 index dcdd6fbb3c..0000000000 --- a/src/StackExchange.Redis/CapturedArgs.cs +++ /dev/null @@ -1,88 +0,0 @@ -using System; -using System.Buffers; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; - -namespace StackExchange.Redis; - -/// -/// Helpers for the captured-argument structs emitted by [AutoDatabase(Replays = true)]. -/// -/// -/// A database that replays re-invokes with the same captured arguments after the caller has regained -/// control, and a argument still belongs to that caller - who is entitled to reuse -/// the buffer once the call returns. So a replaying capture takes a shallow copy and gives it back when the -/// operation is finally done with. -/// -/// Shallow: the elements are copied, not anything they refer to. A wrapping a -/// caller's Memory<byte> still points at the caller's bytes, so mutating *those* would still -/// be seen by a replay. That gap closes when serialization moves to the calling thread; this covers the -/// buffer the caller is most likely to reuse. -/// -/// -internal static class CapturedArgs -{ - /// Take a pooled shallow copy of a captured argument. - /// The element type. - /// The caller's memory to copy. - /// A copy owned by us, to be given back via . - public static ReadOnlyMemory Clone(ReadOnlyMemory value) - { - if (value.IsEmpty) return default; // nothing rented, so nothing for Release to give back - - var rented = ArrayPool.Shared.Rent(value.Length); - value.Span.CopyTo(rented); - return new ReadOnlyMemory(rented, 0, value.Length); - } - - /// - public static Memory Clone(Memory value) - { - if (value.IsEmpty) return default; - - var rented = ArrayPool.Shared.Rent(value.Length); - value.Span.CopyTo(rented); - return new Memory(rented, 0, value.Length); - } - - /// Give a cloned argument back to the pool. - /// The element type. - /// The captured field, cleared as it is released. - /// - /// Clears the field first, so a second call has nothing to give back. Returning the same array twice is - /// not an error the pool reports - it simply pools it twice, and two later rents then hand out the same - /// array to different callers - so this is worth the cheek of writing through a readonly field. - /// - /// Sequential only: the clear is not atomic with the read. That is sufficient here because a captured - /// state is a local within a single async flow, never shared. Note also that calling this on a - /// defensive copy - i.e. via a readonly holder - would clear the copy and leak; the generated - /// funnels hold their state in a plain local. - /// - /// - public static void Release(in ReadOnlyMemory field) - { - var captured = field; - Unsafe.AsRef(in field) = default; - Return(captured); - } - - /// - public static void Release(in Memory field) - { - var captured = field; - Unsafe.AsRef(in field) = default; - Return(captured); - } - - private static void Return(ReadOnlyMemory captured) - { - // note the Length check rather than a null check: an empty ReadOnlyMemory reports a non-null, - // zero-length array through TryGetArray, so testing for null here would never be true - if (MemoryMarshal.TryGetArray(captured, out var segment) && segment.Array is { Length: > 0 }) - { - // cleared on return: these elements can hold references (RedisValue, RedisKeyOrValue), and a - // pooled array would otherwise keep the caller's keys and values alive indefinitely - ArrayPool.Shared.Return(segment.Array, clearArray: true); - } - } -} diff --git a/src/StackExchange.Redis/Contexts/RespTransaction.cs b/src/StackExchange.Redis/Contexts/RespTransaction.cs index 6f71f2c8fd..834f484875 100644 --- a/src/StackExchange.Redis/Contexts/RespTransaction.cs +++ b/src/StackExchange.Redis/Contexts/RespTransaction.cs @@ -36,7 +36,28 @@ namespace StackExchange.Redis /// exactly this distinction, and §7f, where the handshake collapsed the same way. /// /// - internal sealed class RespTransactionExecutor : RespExecutorBase + /// + /// What needs from the executor underneath it, beyond + /// : the shape is shared by the plain one-connection unit + /// () and the retrying one that replays the unit per attempt + /// (RespRetryTransactionExecutor). + /// + internal interface ITransactionExecutor + { + /// + void AddCondition(Condition condition, Action? onVerdict = null); + + /// + Task ExecuteAsync(CommandFlags flags = CommandFlags.None); + + /// + bool WasWatchConflict { get; } + + /// + CommandFlags AggregateRetryCategory { get; } + } + + internal sealed class RespTransactionExecutor : RespExecutorBase, ITransactionExecutor { private readonly RespExecutorBase _inner; private readonly RespContext _context; @@ -89,7 +110,7 @@ internal RespTransactionExecutor(RespExecutorBase inner, RespContext? context = /// retry: a failed condition means the state is not what you wanted, where a watch conflict means /// it was, and somebody moved first. Only the second is worth re-reading and trying again. /// - internal bool WasWatchConflict => _watchConflict; + public bool WasWatchConflict => _watchConflict; /// Whether this transaction has been executed or discarded; either way, nothing more will be sent. internal bool IsSent @@ -133,7 +154,9 @@ internal override ValueTask SendTypedAsync( var operation = RespPayloadOperation.Rent(handler, this); try { - if (!Enqueue(operation, in request, cancellationToken)) return new ValueTask(default(TResult)!); + // the SHARED completed-default task, not a fresh default(TResult): a declined reply has + // nothing per-call to carry, and TaskBridge hands the backing task out untouched + if (!Enqueue(operation, in request, cancellationToken)) return new ValueTask(CompletedTask.Default(null)!); } catch (Exception ex) { @@ -220,7 +243,7 @@ private bool Enqueue(RespPayloadOperation operation, in RespRequest request, Can /// surface hands the caller a ConditionResult when the condition is added and fills it in /// later, so "which one failed?" stays answerable; a single overall bool cannot say that. /// - internal void AddCondition(Condition condition, Action? onVerdict = null) + public void AddCondition(Condition condition, Action? onVerdict = null) { if (condition is null) throw new ArgumentNullException(nameof(condition)); lock (_sync) @@ -240,7 +263,7 @@ internal void AddCondition(Condition condition, Action? onVerdict = null) /// does it: they live in the conditions rather than the queue, and re-issuing them is what makes a /// replay safe in the first place. /// - internal CommandFlags AggregateRetryCategory + public CommandFlags AggregateRetryCategory { get { @@ -278,7 +301,7 @@ internal CommandFlags AggregateRetryCategory /// Monitor handshakes on result boxes inside the write lock to get the same effect. /// /// - internal async Task ExecuteAsync(CommandFlags flags = CommandFlags.None) + public async Task ExecuteAsync(CommandFlags flags = CommandFlags.None) { List? queue; List? conditions; diff --git a/src/StackExchange.Redis/Database/RedisDatabase.Scans.cs b/src/StackExchange.Redis/Database/RedisDatabase.Scans.cs index 489c9e7867..e7080b5dfb 100644 --- a/src/StackExchange.Redis/Database/RedisDatabase.Scans.cs +++ b/src/StackExchange.Redis/Database/RedisDatabase.Scans.cs @@ -10,10 +10,10 @@ namespace StackExchange.Redis; /// /// /// -/// These are hand-written because [AutoDatabase] skips them, and it skips them for a real -/// reason: deferred execution does not fit capture-and-replay, so an -returning -/// member cannot be generated. That also means the generator cannot see whether they are implemented, so -/// SER352 has never counted them - ScanGapTests is what watches this file instead. +/// These were hand-written from the first day, because [AutoDatabase] skipped them - deferred +/// execution does not fit capture-and-replay, so an -returning member could not +/// be generated. That also meant the generator could not see whether they were implemented, so SER352 never +/// counted them. Generator and rule are both gone now; ScanGapTests still watches this file. /// /// /// Each pair of members returns the same object, because the shipped contract says a scan is both diff --git a/src/StackExchange.Redis/Database/RedisDatabase.Strings.cs b/src/StackExchange.Redis/Database/RedisDatabase.Strings.cs index 502af10c6c..51e347de88 100644 --- a/src/StackExchange.Redis/Database/RedisDatabase.Strings.cs +++ b/src/StackExchange.Redis/Database/RedisDatabase.Strings.cs @@ -16,9 +16,10 @@ namespace StackExchange.Redis /// visibly not. /// /// - /// Implementing a member here removes it from the generated set automatically, because - /// [AutoDatabase] skips whatever the class declares itself - so nothing has to be deleted from - /// a list of stubs, and SER352's count falls by itself. + /// During the port, implementing a member here removed it from the generated set automatically, + /// because [AutoDatabase] skipped whatever the class declared itself - so nothing had to be + /// deleted from a list of stubs, and SER352's count fell by itself until both hit zero and the + /// generator was deleted. The per-group layout it drove remains. /// /// /// Note how little each one is. The body is the whole implementation - no message type, no result diff --git a/src/StackExchange.Redis/Database/RedisDatabase.cs b/src/StackExchange.Redis/Database/RedisDatabase.cs index acbe9e2f3d..73c75acd15 100644 --- a/src/StackExchange.Redis/Database/RedisDatabase.cs +++ b/src/StackExchange.Redis/Database/RedisDatabase.cs @@ -26,8 +26,9 @@ namespace StackExchange.Redis /// Losing it is an improvement, not a regression. A command added to the interface used to /// produce a generated throw and a warning; now it does not compile until it is implemented, which is /// the same guarantee RedisDatabase has always had and a better one than a tripwire. The - /// generator itself stays - RetryTransaction is a capture-and-replay - /// wrapper, which is what it is really for. + /// generator itself is gone too: its last consumer, the capture-and-replay RetryTransaction, + /// was replaced by RespRetryTransactionExecutor, which replays rendered frames instead of + /// method calls and needs nothing generated. /// /// /// There is no fallback. This once forwarded anything not yet moved to the v3 RedisDatabase, and @@ -184,7 +185,7 @@ CancellationToken IInternalDatabaseAsync.GetNextFailover() /// The operation to wait for. private void Wait(ValueTask pending) => SyncWait.Wait(pending, multiplexer); - // ---- members the generator deliberately skips (see AutoDatabaseGenerator.SkipMethod) ------------- + // ---- members the (now deleted) [AutoDatabase] generator deliberately skipped ------------- /// /// @@ -224,20 +225,13 @@ public ITransaction CreateTransaction(object? asyncState = null) if (this is IBatch) throw new NotSupportedException("Nested transactions are not supported"); // A retrying database replays a transaction AS A UNIT - conditions, queued commands and EXEC - // together - which the per-frame retry executor cannot express; that is RetryTransaction's - // job. It records against a plain view over the executor underneath the retry link, building - // a fresh inner transaction per attempt, and the durable proxy tasks it hands out cannot - // carry an asyncState - so one is refused rather than silently dropped. + // together - which the per-frame retry executor cannot express. RespRetryTransactionExecutor + // records the rendered frames and the conditions, replays them into a fresh one-shot unit per + // attempt, and settles the durable tasks it handed out only when the unit has finished for + // good - which is also why asyncState works here: the tasks the caller holds are ours. if (_inner.Raw.Executor is Availability.RespRetryExecutor retry) { - if ((asyncState ?? AsyncState) is not null) - { - throw new InvalidOperationException( - "Retrying transactions do not support asyncState; the tasks they hand back are not the tasks that were sent to the server."); - } - - var plain = new RedisDatabase(new RespDatabaseContext(_inner.Raw.WithExecutor(retry.Inner)), multiplexer, null); - return new Availability.RetryTransaction(plain, retry.Controller); + return RedisTransaction.CreateRetryingTransaction(_inner, retry, multiplexer, asyncState ?? AsyncState); } // CanWriteTransactions, not CanWriteRuns: an executor can write a batch without being able to diff --git a/src/StackExchange.Redis/Database/RedisTransaction.cs b/src/StackExchange.Redis/Database/RedisTransaction.cs index 4dbf8a06d2..14ee0d69a9 100644 --- a/src/StackExchange.Redis/Database/RedisTransaction.cs +++ b/src/StackExchange.Redis/Database/RedisTransaction.cs @@ -23,7 +23,7 @@ namespace StackExchange.Redis /// notes §3c and §7r. /// /// - internal sealed class RedisTransaction : RedisBatch, ITransaction, IInternalTransaction + internal sealed class RedisTransaction : RedisBatch, ITransaction { /// /// @@ -32,11 +32,11 @@ internal sealed class RedisTransaction : RedisBatch, ITransaction, IInternalTran /// private protected sealed override DatabaseFeatureFlags OwnFeatures => DatabaseFeatureFlags.Transaction; - private readonly RespTransactionExecutor _executor; + private readonly ITransactionExecutor _executor; private RedisTransaction( RespDatabaseContext queueing, - RespTransactionExecutor executor, + ITransactionExecutor executor, IConnectionMultiplexer multiplexer, object? asyncState) : base(queueing, executor: null, multiplexer, asyncState) @@ -53,6 +53,33 @@ internal static RedisTransaction CreateTransaction(RespDatabaseContext source, I return new RedisTransaction(new RespDatabaseContext(raw.WithExecutor(executor)), executor, multiplexer, asyncState); } + /// Wrap a retrying context so its transaction replays as a unit. + /// + /// + /// The queueing context keeps everything the database's context had EXCEPT the retry link - the + /// unit is what retries, so a per-frame retry inside it would re-send individual queued commands, + /// which is not a retry of anything the caller asked for. The retrying executor shares the + /// database's , so budgets and failover tracking are the + /// same ones a plain command sees. + /// + /// + /// Not reusable, where the plain transaction is: a replayed unit releases its recorded + /// requests when it finishes, so "execute, then queue more onto the same object" has nothing left + /// to compose onto. The capture-replay RetryTransaction made the same call. + /// + /// + internal static RedisTransaction CreateRetryingTransaction( + RespDatabaseContext source, + Availability.RespRetryExecutor retry, + IConnectionMultiplexer multiplexer, + object? asyncState) + { + var raw = source.Raw; + var plain = raw.WithExecutor(retry.Inner); + var executor = new Availability.RespRetryTransactionExecutor(retry.Inner, plain, retry.Controller); + return new RedisTransaction(new RespDatabaseContext(raw.WithExecutor(executor)), executor, multiplexer, asyncState); + } + /// /// /// The result is handed back now and filled in when the check is answered, which is what @@ -72,15 +99,6 @@ public ConditionResult AddCondition(Condition condition) /// public bool WasWatchConflict => _executor.WasWatchConflict; - /// - /// - /// Without this the retry layer cannot retry a transaction at all. It asks the transaction - /// what a replay would do, and a transaction that does not answer is assumed to be - /// - so a transient fault the caller explicitly asked - /// to ride out is rethrown instead, and their retry policy silently does nothing. - /// - CommandFlags IInternalTransaction.GetAggregateRetryCategory() => _executor.AggregateRetryCategory; - /// /// /// Sync-over-async, suppressed for the same reason and with the same reservations as diff --git a/src/StackExchange.Redis/Database/TaskBridge.cs b/src/StackExchange.Redis/Database/TaskBridge.cs index a79cdde96d..2d0981b6d9 100644 --- a/src/StackExchange.Redis/Database/TaskBridge.cs +++ b/src/StackExchange.Redis/Database/TaskBridge.cs @@ -59,7 +59,16 @@ internal static class TaskBridge /// internal static Task AsTask(this ValueTask pending, object? asyncState, CommandFlags flags) { - if ((flags & CommandFlags.FireAndForget) != 0) asyncState = null; + if ((flags & CommandFlags.FireAndForget) != 0) + { + asyncState = null; + + // a declined reply that is already answered travels exactly as the executor shaped it, + // which is what lets a transaction hand every fire-and-forget caller ONE shared completed + // task instead of a fresh Task.FromResult per queued command; a result-backed ValueTask + // comes out of AsTask as Task.FromResult anyway, so nothing else changes + if (pending.IsCompletedSuccessfully) return pending.AsTask(); + } if (pending.IsCompletedSuccessfully) { diff --git a/src/StackExchange.Redis/Interfaces/IInternalDatabaseAsync.cs b/src/StackExchange.Redis/Interfaces/IInternalDatabaseAsync.cs index 42626b9c07..b6eb0cea38 100644 --- a/src/StackExchange.Redis/Interfaces/IInternalDatabaseAsync.cs +++ b/src/StackExchange.Redis/Interfaces/IInternalDatabaseAsync.cs @@ -30,19 +30,6 @@ internal interface IInternalDatabaseAsync : IDatabaseAsync object? AsyncState { get; } } -/// -/// Exposes transaction-level detail needed by the retry machinery. Implemented by the concrete -/// transaction types so a RetryTransaction can inspect the transaction it is replaying against. -/// -internal interface IInternalTransaction -{ - /// - /// The most side-effecting retry category across all queued operations (excluding WATCH - /// constraints); this describes what replaying the whole transaction would do. - /// - CommandFlags GetAggregateRetryCategory(); -} - internal static class InternalDatabaseExtension { internal static DatabaseFeatureFlags GetFeatures(this IDatabaseAsync database, out string name) diff --git a/tests/StackExchange.Redis.Tests/DatabaseSurfaceTests.cs b/tests/StackExchange.Redis.Tests/DatabaseSurfaceTests.cs index 6b77d1269c..511836a8a0 100644 --- a/tests/StackExchange.Redis.Tests/DatabaseSurfaceTests.cs +++ b/tests/StackExchange.Redis.Tests/DatabaseSurfaceTests.cs @@ -14,7 +14,7 @@ namespace StackExchange.Redis.Tests; /// at all, if a command were quietly still being forwarded. So these assert the other half: that the /// members those suites call are implemented by the class itself rather than generated. /// -/// [AutoDatabase] emits EXPLICIT interface implementations, so the interface map is what tells the +/// [AutoDatabase] emitted EXPLICIT interface implementations, so the interface map is what told the /// two apart - a hand-written member maps to a public method, a generated one to a private explicit one. /// Nothing else can see the difference, which is the same reason RedisDatabaseTests goes through /// IDatabase rather than the concrete type. @@ -213,18 +213,9 @@ public void NothingIsGeneratedForTheRedisDatabaseAnyMore() Assert.Equal(["CreateTransaction(Object)"], Generated(string.Empty, typeof(IDatabaseAsync))); } - /// - /// The control for every Assert.Empty above: the query really can see a generated member, so - /// "nothing is generated" means nothing is generated rather than "the query stopped working". - /// - /// - /// RetryTransaction is [AutoDatabase(Replays = true)] and is generated - /// on purpose - capture-and-replay wrappers are what the generator is for, and it keeps that - /// job after the transitional database stops needing it. So this control cannot go stale by being - /// right, which is how the previous one kept failing. - /// - [Fact] - public void TheGeneratedQueryCanStillSeeAGeneratedMember() - => Assert.NotEmpty(Generated(typeof(Availability.RetryTransaction), "String", typeof(IDatabaseAsync))); + // The control that used to sit here - "the query really can see a generated member" - went with the + // [AutoDatabase] generator itself: its last consumer, RetryTransaction, was replaced by the frame-level + // RespRetryTransactionExecutor, so NOTHING in the assembly is generated and the Assert.Empty pins above + // now guard against hand-written explicit implementations creeping back rather than generated ones. } diff --git a/tests/StackExchange.Redis.Tests/QueuedResultTests.cs b/tests/StackExchange.Redis.Tests/QueuedResultTests.cs index 69dde2699b..bb0fcb5ab6 100644 --- a/tests/StackExchange.Redis.Tests/QueuedResultTests.cs +++ b/tests/StackExchange.Redis.Tests/QueuedResultTests.cs @@ -93,16 +93,16 @@ public async Task TransactionQueuedFireAndForgetStillExecutes() /// /// /// - /// This is a regression test for a real divergence. RetryTransaction records every queued call and - /// hands back a durable proxy task; it used to do so without regard to the flags - which it could not see, - /// as they are captured inside the generated per-command state - so a fire-and-forget result stayed - /// incomplete until ExecuteAsync forwarded it. + /// This is a regression test for a real divergence. A retrying transaction records every queued call and + /// hands back a durable proxy task; the capture-replay wrapper this started life against used to do so + /// without regard to the flags - which it could not see, as they were captured inside generated + /// per-command state - so a fire-and-forget result stayed incomplete until ExecuteAsync forwarded it. /// /// /// The effect was that identical caller code returned instantly on a plain transaction and blocked for /// good on a retrying one, which is precisely the drop-in substitution WithRetry is meant to - /// support. The generated state now exposes its CommandFlags (IFlaggedRedisArgs) so the two - /// agree. + /// support. RespRetryTransactionExecutor sees the flags on the rendered request, so the two agree + /// by construction - and this pins that they stay agreeing. /// /// [Fact] diff --git a/tests/StackExchange.Redis.Tests/RespEndToEndTests.cs b/tests/StackExchange.Redis.Tests/RespEndToEndTests.cs index 4c713beffa..210b304550 100644 --- a/tests/StackExchange.Redis.Tests/RespEndToEndTests.cs +++ b/tests/StackExchange.Redis.Tests/RespEndToEndTests.cs @@ -567,23 +567,28 @@ public async Task ABatchOfOneStillWorks() Assert.Equal("solo", (string?)await context.Strings.GetAsync(key)); } - /// A retrying TRANSACTION still refuses, and for a reason of its own. + /// A retrying TRANSACTION exposes a working context too, and it queues rather than sends. /// - /// A retrying database replays one operation, so decorating its executor reproduces it exactly. A - /// retrying transaction replays the whole recorded unit - conditions, queued operations and - /// EXEC together - which a per-frame retry executor cannot express: it would re-send individual - /// frames inside a transaction, retrying something nobody asked for. + /// This used to assert a refusal: the capture-and-replay wrapper recorded method calls, so a + /// context - which produces rendered frames - had nothing to record into, and asking for one threw. + /// The frame-replaying executor records rendered frames, which is exactly what a context emits, so the + /// refusal went with the wrapper: a command queued through the context here is recorded, replayed and + /// answered through the same durable proxy as an interface call. /// [Fact] - public async Task ARetryingTransactionStillRefusesAContext() + public async Task ARetryingTransactionContextQueuesInsteadOfSending() { await using var conn = Create(); + var key = Me(); var retrying = conn.GetDatabase().WithRetry( new RetryPolicy.Builder { MaxAttempts = 3, RetryDelay = TimeSpan.Zero, JitterMax = TimeSpan.Zero }); + await retrying.StringSetAsync(key, "tranned"); var tran = retrying.CreateTransaction(); - var ex = Assert.Throws(() => ((IRespKeyspaceTarget)tran).Context); - Assert.Contains("replayed as a unit", ex.Message); + var pending = ((IRespKeyspaceTarget)tran).Context.Strings.GetAsync(key); + Assert.False(pending.IsCompleted, "DEFERRED-OK: transaction did not send immediately"); + Assert.True(await tran.ExecuteAsync(), "EXEC-OK"); + Assert.Equal("tranned", (string?)await pending); } /// And so does a transaction's, for an ordinary single-frame command. diff --git a/tests/StackExchange.Redis.Tests/RetryTests/RetryEndToEndTests.cs b/tests/StackExchange.Redis.Tests/RetryTests/RetryEndToEndTests.cs index 0d49de0c8d..d8f3b2847b 100644 --- a/tests/StackExchange.Redis.Tests/RetryTests/RetryEndToEndTests.cs +++ b/tests/StackExchange.Redis.Tests/RetryTests/RetryEndToEndTests.cs @@ -481,8 +481,8 @@ public async Task WithRetry_Transaction_PerOpError_FaultsOnlyThatProxy() } // Multi-group + a retryable transaction: A fails every EXEC and is knocked out, so the group reroutes to B. - // Because RetryTransaction builds a *fresh* inner transaction against the currently-active member on each - // attempt, the replay lands on B and commits there - the transaction analogue of the single-command + // Because the retrying executor builds a *fresh* attempt transaction against the currently-active member + // on each replay, the retry lands on B and commits there - the transaction analogue of the single-command // WithRetry_FailsOverBetweenGroupsOnLoading test. [Fact] public async Task WithRetry_Transaction_FailsOverBetweenGroups() diff --git a/tests/StackExchange.Redis.Tests/RetryTests/RetryGuardTests.cs b/tests/StackExchange.Redis.Tests/RetryTests/RetryGuardTests.cs index d13c65e861..113edd653d 100644 --- a/tests/StackExchange.Redis.Tests/RetryTests/RetryGuardTests.cs +++ b/tests/StackExchange.Redis.Tests/RetryTests/RetryGuardTests.cs @@ -48,15 +48,15 @@ public async Task WithRetry_CarriesAsyncState() Assert.Same(state, task.AsyncState); await task; - // a transaction created *from* a retrying database still refuses one: it replays as a unit, - // handing out durable proxy tasks that are not the tasks sent to the server, so the state - // cannot be carried - and dropping it silently would be worse than refusing + // ...and a transaction created *from* a retrying database carries it too. The capture-and-replay + // wrapper refused one - its durable proxies could not take a state - but the frame-level replay's + // durable tasks are built by the same AsTask bridge as everything else, so the state travels. var retryDb = conn.GetDatabase().WithRetry(Policy()); - var ex = Assert.Throws(() => retryDb.CreateTransaction(state)); - Log(ex.Message); - - // no state: fine - Assert.NotNull(retryDb.CreateTransaction()); + var tran = retryDb.CreateTransaction(state); + var queued = tran.StringSetAsync("asyncstate:key", "value"); + Assert.Same(state, queued.AsyncState); + Assert.True(await tran.ExecuteAsync()); + Assert.True(await queued); } // Key-prefixing composes with retry: the prefix is applied when the operation is captured, so it diff --git a/tests/StackExchange.Redis.Tests/ScanGapTests.cs b/tests/StackExchange.Redis.Tests/ScanGapTests.cs index 6484e1146b..3d9034b1d6 100644 --- a/tests/StackExchange.Redis.Tests/ScanGapTests.cs +++ b/tests/StackExchange.Redis.Tests/ScanGapTests.cs @@ -11,14 +11,16 @@ namespace StackExchange.Redis.Tests; /// -/// The deferred-execution members on , which SER352 cannot see. +/// The deferred-execution members on , which SER352 could not see. /// /// /// -/// [AutoDatabase] skips every IEnumerable<T>/IAsyncEnumerable<T> member - -/// deferred execution does not fit capture-and-replay - so these are hand-written, and the generator has -/// no way to tell a real implementation from a forwarding throw. To it they are simply "declared", so the -/// SER352 count omits them entirely. This file is the tripwire in the one place that can see them. +/// [AutoDatabase] skipped every IEnumerable<T>/IAsyncEnumerable<T> member - +/// deferred execution does not fit capture-and-replay - so these were hand-written, and the generator had +/// no way to tell a real implementation from a forwarding throw. To it they were simply "declared", so the +/// SER352 count omitted them entirely. This file was the tripwire in the one place that could see them, +/// and it outlives the generator: the members are still forwarded one at a time, so the gap it watches +/// is still a gap something has to watch. /// /// /// It earned that description immediately: wiring the scans to the context surface made the previous