diff --git a/.github/actions/run-tests/action.yml b/.github/actions/run-tests/action.yml index e52cd7a2f..dfb80ffa2 100644 --- a/.github/actions/run-tests/action.yml +++ b/.github/actions/run-tests/action.yml @@ -66,6 +66,7 @@ runs: run: >- dotnet test tests/StackExchange.Redis.Tests/StackExchange.Redis.Tests.csproj -c Release + -f net10.0 --logger trx --logger "GitHubActions;summary-include-passed=false;summary-include-skipped=false" --results-directory ./test-results/ diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 9089f65c0..3a56437b0 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -119,7 +119,15 @@ jobs: - name: .NET Build run: dotnet build Build.csproj -c Release /p:CI=true - name: StackExchange.Redis.Tests - run: dotnet test tests/StackExchange.Redis.Tests/StackExchange.Redis.Tests.csproj -c Release --logger trx --logger GitHubActions --results-directory ./test-results/ /p:CI=true + run: | + $exitCode = 0 + foreach ($tfm in @("net10.0", "net481")) { + dotnet test tests/StackExchange.Redis.Tests/StackExchange.Redis.Tests.csproj -c Release -f $tfm --logger trx --logger GitHubActions --results-directory ./test-results/ /p:CI=true + if ($LASTEXITCODE -ne 0) { + $exitCode = $LASTEXITCODE + } + } + exit $exitCode - uses: dorny/test-reporter@v3 continue-on-error: true if: success() || failure() @@ -127,10 +135,10 @@ jobs: name: Tests Results - Windows Server 2022 path: 'test-results/*.trx' reporter: dotnet-trx - # Package and upload to MyGet only on pushes to main, not on PRs + # Package and upload to MyGet only on pushes to main/v3, not on PRs - name: .NET Pack - if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main' + if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/v3') run: dotnet pack Build.csproj --no-build -c Release /p:PackageOutputPath=${env:GITHUB_WORKSPACE}\.nupkgs /p:CI=true - name: Upload to MyGet - if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main' + if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/v3') run: dotnet nuget push ${env:GITHUB_WORKSPACE}\.nupkgs\*.nupkg -s https://www.myget.org/F/stackoverflow/api/v2/package -k ${{ secrets.MYGET_API_KEY }} diff --git a/Directory.Build.props b/Directory.Build.props index 4e62d5e0f..7d2e9c6c5 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -26,6 +26,7 @@ true false true + true 00240000048000009400000006020000002400005253413100040000010001007791a689e9d8950b44a9a8886baad2ea180e7a8a854f158c9b98345ca5009cdd2362c84f368f1c3658c132b3c0f74e44ff16aeb2e5b353b6e0fe02f923a050470caeac2bde47a2238a9c7125ed7dab14f486a5a64558df96640933b9f2b6db188fc4a820f96dce963b662fa8864adbff38e5b4542343f162ecdc6dad16912fff diff --git a/Directory.Packages.props b/Directory.Packages.props index 71230ccbf..759993786 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -1,44 +1,40 @@ - - - + + - + - - + + + - - + - - + - - + + - - - - - + + + + + - + - - - + + - - - - - + + + + \ No newline at end of file diff --git a/StackExchange.Redis.sln.DotSettings b/StackExchange.Redis.sln.DotSettings index 8dd9095d9..339a73c59 100644 --- a/StackExchange.Redis.sln.DotSettings +++ b/StackExchange.Redis.sln.DotSettings @@ -26,4 +26,5 @@ True True True - True \ No newline at end of file + True + True \ No newline at end of file diff --git a/StackExchange.Redis.slnx b/StackExchange.Redis.slnx index 02f110acd..f981b8ef0 100644 --- a/StackExchange.Redis.slnx +++ b/StackExchange.Redis.slnx @@ -24,6 +24,7 @@ + diff --git a/docs/Configuration.md b/docs/Configuration.md index 43e48cfc7..ce3ab93f6 100644 --- a/docs/Configuration.md +++ b/docs/Configuration.md @@ -72,11 +72,11 @@ var conn = ConnectionMultiplexer.Connect("contoso5.redis.cache.windows.net,ssl=t The `ConfigurationOptions` object has a wide range of properties, all of which are fully documented in intellisense. Some of the more common options to use include: | Configuration string | `ConfigurationOptions` | Default | Meaning | -| ---------------------- | ---------------------- | ---------------------------- | --------------------------------------------------------------------------------------------------------- | +| ---------------------- | ---------------------- |------------------------------| --------------------------------------------------------------------------------------------------------- | | abortConnect={bool} | `AbortOnConnectFail` | `true` (`false` on Azure) | If true, `Connect` will not create a connection while no servers are available | | allowAdmin={bool} | `AllowAdmin` | `false` | Enables a range of commands that are considered risky | | channelPrefix={string} | `ChannelPrefix` | `null` | Optional channel prefix for all pub/sub operations | -| checkCertificateRevocation={bool} | `CheckCertificateRevocation` | `true` | A Boolean value that specifies whether the certificate revocation list is checked during authentication. | +| checkCertificateRevocation={bool} | `CheckCertificateRevocation` | `true` | A Boolean value that specifies whether the certificate revocation list is checked during authentication. | | connectRetry={int} | `ConnectRetry` | `3` | The number of times to repeat connect attempts during initial `Connect` | | connectTimeout={int} | `ConnectTimeout` | `5000` | Timeout (ms) for connect operations | | configChannel={string} | `ConfigurationChannel` | `__Booksleeve_MasterChanged` | Broadcast channel name for communicating configuration changes | @@ -96,7 +96,7 @@ The `ConfigurationOptions` object has a wide range of properties, all of which a | syncTimeout={int} | `SyncTimeout` | `5000` | Time (ms) to allow for synchronous operations | | asyncTimeout={int} | `AsyncTimeout` | `SyncTimeout` | Time (ms) to allow for asynchronous operations | | tiebreaker={string} | `TieBreaker` | `__Booksleeve_TieBreak` | Key to use for selecting a server in an ambiguous primary scenario | -| version={string} | `DefaultVersion` | (`4.0` in Azure, else `2.0`) | Redis version level (useful when the server does not make this available) | +| version={string} | `DefaultVersion` | (`7.4` in AMR, else `6.0`) | Redis version level (useful when the server does not make this available) | | tunnel={string} | `Tunnel` | `null` | Tunnel for connections (use `http:{proxy url}` for "connect"-based proxy server) | | setlib={bool} | `SetClientLibrary` | `true` | Whether to attempt to use `CLIENT SETINFO` to set the library name/version on the connection | | protocol={string} | `Protocol` | `null` | Redis protocol to use; see section below | diff --git a/docs/ReleaseNotes.md b/docs/ReleaseNotes.md index e23d492b2..5a752e7bb 100644 --- a/docs/ReleaseNotes.md +++ b/docs/ReleaseNotes.md @@ -6,7 +6,14 @@ Current package versions: | ------------ | ----------------- | ----- | | [![StackExchange.Redis](https://img.shields.io/nuget/v/StackExchange.Redis.svg)](https://www.nuget.org/packages/StackExchange.Redis/) | [![StackExchange.Redis](https://img.shields.io/nuget/vpre/StackExchange.Redis.svg)](https://www.nuget.org/packages/StackExchange.Redis/) | [![StackExchange.Redis MyGet](https://img.shields.io/myget/stackoverflow/vpre/StackExchange.Redis.svg)](https://www.myget.org/feed/stackoverflow/package/nuget/StackExchange.Redis) | -## Unreleased +## 3.0 + +From 3.0, [release notes will be maintained in GitHub only](https://github.com/StackExchange/StackExchange.Redis/releases) to avoid duplication. + +--- + + +## 2.12.14 - (none) diff --git a/docs/exp/SER004.md b/docs/exp/SER004.md new file mode 100644 index 000000000..91f5d87c4 --- /dev/null +++ b/docs/exp/SER004.md @@ -0,0 +1,15 @@ +# RESPite + +RESPite is an experimental library that provides high-performance low-level RESP (Redis, etc) parsing and serialization. +It is used as the IO core for StackExchange.Redis v3+. You should not (yet) use it directly unless you have a very +good reason to do so. + +```xml +$(NoWarn);SER004 +``` + +or more granularly / locally in C#: + +``` c# +#pragma warning disable SER004 +``` diff --git a/docs/exp/SER005.md b/docs/exp/SER005.md new file mode 100644 index 000000000..03e7b7bb4 --- /dev/null +++ b/docs/exp/SER005.md @@ -0,0 +1,21 @@ +# Unit Testing + +Unit testing is great! Yay, do more of that! + +This type is provided for external unit testing, in particular by people using modules or server features +not directly implemented by SE.Redis - for example to verify messsage parsing or formatting without +talking to a RESP server. + +These types are considered slightly more... *mercurial*. We encourage you to use them, but *occasionally* +(not just for fun) you might need to update your test code if we tweak something. This should not impact +"real" library usage. + +```xml +$(NoWarn);SER005 +``` + +or more granularly / locally in C#: + +``` c# +#pragma warning disable SER005 +``` diff --git a/src/RESPite.Benchmark/BenchmarkBase.cs b/src/RESPite.Benchmark/BenchmarkBase.cs new file mode 100644 index 000000000..50994b23f --- /dev/null +++ b/src/RESPite.Benchmark/BenchmarkBase.cs @@ -0,0 +1,690 @@ +using System; +using System.Buffers; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Threading; +using System.Threading.Tasks; + +// influenced by redis-benchmark, see .md file +namespace RESPite.Benchmark; + +public abstract class BenchmarkBase : IDisposable +{ + protected const string + GetSetKey = "key:__rand_int__", + CounterKey = "counter:__rand_int__", + ListKey = "mylist", + SetKey = "myset", + HashKey = "myhash", + SortedSetKey = "myzset", + StreamKey = "mystream"; + + public PipelineStrategy PipelineMode { get; } = + PipelineStrategy.Batch; // the default, for parity with how redis-benchmark works + + public enum PipelineStrategy + { + /// + /// Build a batch of operations, send them all at once. + /// + Batch, + + /// + /// Use a queue to pipeline operations - when we hit the pipeline depth, we pop one, push one, await the popped. + /// + Queue, + } + + private readonly HashSet _tests = new(StringComparer.OrdinalIgnoreCase); + protected bool RunTest(string name) => _tests.Count == 0 || _tests.Contains(name); + public virtual void Dispose() => GC.SuppressFinalize(this); + public int Port { get; } = 6379; + public string HostName { get; } = "127.0.0.1"; + public int PipelineDepth { get; } = 1; + public bool Multiplexed { get; } + public bool SupportCancel { get; } + public int? WriteMode { get; } + public bool Loop { get; } + public bool Quiet { get; } + public int ClientCount { get; } = 50; + private int _operationsPerClient; + public int OperationsPerClient(int divisor = 1) => _operationsPerClient / divisor; + + public int TotalOperations(int divisor = 1) => OperationsPerClient(divisor) * ClientCount; + + protected readonly byte[] Payload; + + protected BenchmarkBase(string[] args) + { + int operations = 100_000; + + string tests = ""; + for (int i = 0; i < args.Length; i++) + { + switch (args[i]) + { + case "-h" when i != args.Length - 1: + HostName = args[++i]; + break; + case "-p" when i != args.Length - 1 && int.TryParse(args[++i], out int tmp) && tmp > 0: + Port = tmp; + break; + case "-c" when i != args.Length - 1 && int.TryParse(args[++i], out int tmp) && tmp > 0: + ClientCount = tmp; + break; + case "-n" when i != args.Length - 1 && int.TryParse(args[++i], out int tmp) && tmp > 0: + operations = tmp; + break; + case "-P" when i != args.Length - 1 && int.TryParse(args[++i], out int tmp) && tmp > 0: + PipelineDepth = tmp; + break; + case "-w" when i != args.Length - 1 && int.TryParse(args[++i], out int tmp): + WriteMode = tmp; + break; + case "+m": + Multiplexed = true; + break; + case "-m": + Multiplexed = false; + break; + case "+x": + SupportCancel = true; + break; + case "-x": + SupportCancel = false; + break; + case "-l": + Loop = true; + break; + case "-q": + Quiet = true; + break; + case "-t" when i != args.Length - 1: + tests = args[++i]; + break; + case "--batch": + PipelineMode = PipelineStrategy.Batch; + break; + case "--queue": + PipelineMode = PipelineStrategy.Queue; + break; + } + } + + if (!string.IsNullOrWhiteSpace(tests)) + { + foreach (var test in tests.Split(',')) + { + var t = test.Trim(); + if (!string.IsNullOrWhiteSpace(t)) _tests.Add(t); + } + } + + _operationsPerClient = operations / ClientCount; + + Payload = "abc"u8.ToArray(); + } + + public abstract Task RunAll(); + + public async Task RunBasicLoopAsync() + { + await DeleteAsync(CounterKey).ConfigureAwait(false); + + if (ClientCount <= 1) + { + await RunBasicLoopAsync(0); + } + else + { + Task[] tasks = new Task[ClientCount]; + for (int i = 0; i < ClientCount; i++) + { + var loopSnapshot = i; + tasks[i] = Task.Run(() => RunBasicLoopAsync(loopSnapshot)); + } + + await Task.WhenAll(tasks); + } + } + + protected abstract Task RunBasicLoopAsync(int clientId); + protected abstract Task DeleteAsync(string key); +} + +public abstract class BenchmarkBase(string[] args) : BenchmarkBase(args) +{ + protected override Task DeleteAsync(string key) => DeleteAsync(GetClient(0), key); + + protected virtual Task OnCleanupAsync(TClient client) => Task.CompletedTask; + + protected virtual Task InitAsync(TClient client) => Task.CompletedTask; + + public async Task CleanupAsync() + { + try + { + var client = GetClient(0); + await DeleteAsync(client, GetSetKey).ConfigureAwait(false); + await DeleteAsync(client, CounterKey).ConfigureAwait(false); + await DeleteAsync(client, ListKey).ConfigureAwait(false); + await DeleteAsync(client, SetKey).ConfigureAwait(false); + await DeleteAsync(client, HashKey).ConfigureAwait(false); + await DeleteAsync(client, SortedSetKey).ConfigureAwait(false); + await DeleteAsync(client, StreamKey).ConfigureAwait(false); + await OnCleanupAsync(client).ConfigureAwait(false); + } + catch (Exception ex) + { + await Console.Error.WriteLineAsync($"Cleanup: {ex.Message}"); + } + } + + protected virtual ValueTask Flush(TClient client) => default; + protected virtual void PrepareBatch(TClient client, int count) { } + + private async Task PipelineUntyped( + TClient client, + Func operation, + int divisor) + { + var opsPerClient = OperationsPerClient(divisor); + int i = 0; + try + { + if (PipelineDepth <= 1) + { + for (; i < opsPerClient; i++) + { + await operation(client).ConfigureAwait(false); + } + } + else if (PipelineMode == PipelineStrategy.Queue) + { + var queue = new Queue(opsPerClient); + for (; i < opsPerClient; i++) + { + if (queue.Count == opsPerClient) + { + await queue.Dequeue().ConfigureAwait(false); + } + + queue.Enqueue(operation(client)); + } + + while (queue.Count > 0) + { + await queue.Dequeue().ConfigureAwait(false); + } + } + else if (PipelineMode == PipelineStrategy.Batch) + { + int count = 0; + var oversized = ArrayPool.Shared.Rent(PipelineDepth); + PrepareBatch(client, Math.Min(opsPerClient, PipelineDepth)); + for (; i < opsPerClient; i++) + { + oversized[count++] = operation(client); + if (count == PipelineDepth) + { + await Flush(client).ConfigureAwait(false); + PrepareBatch(client, Math.Min(opsPerClient - i, PipelineDepth)); + for (int j = 0; j < count; j++) + { + await oversized[j].ConfigureAwait(false); + } + + count = 0; + } + } + + await Flush(client).ConfigureAwait(false); + for (int j = 0; j < count; j++) + { + await oversized[j].ConfigureAwait(false); + } + + ArrayPool.Shared.Return(oversized); + } + else + { + throw new InvalidOperationException($"Unexpected pipeline mode: {PipelineMode}"); + } + } + catch (Exception ex) + { + await Console.Error.WriteLineAsync($"{operation.Method.Name} failed after {i} operations"); + Program.WriteException(ex); + } + + return DBNull.Value; + } + + private async Task PipelineTyped(TClient client, Func> operation, int divisor) + { + var opsPerClient = OperationsPerClient(divisor); + int i = 0; + T result = default!; + try + { + if (PipelineDepth == 1) + { + for (; i < opsPerClient; i++) + { + result = await operation(client).ConfigureAwait(false); + } + } + else if (PipelineMode == PipelineStrategy.Queue) + { + var queue = new Queue>(opsPerClient); + for (; i < opsPerClient; i++) + { + if (queue.Count == opsPerClient) + { + _ = await queue.Dequeue().ConfigureAwait(false); + } + + queue.Enqueue(operation(client)); + } + + while (queue.Count > 0) + { + result = await queue.Dequeue().ConfigureAwait(false); + } + } + else if (PipelineMode == PipelineStrategy.Batch) + { + int count = 0; + var oversized = ArrayPool>.Shared.Rent(PipelineDepth); + PrepareBatch(client, Math.Min(opsPerClient, PipelineDepth)); + for (; i < opsPerClient; i++) + { + oversized[count++] = operation(client); + if (count == PipelineDepth) + { + await Flush(client).ConfigureAwait(false); + PrepareBatch(client, Math.Min(opsPerClient - (i + 1), PipelineDepth)); + for (int j = 0; j < count; j++) + { + result = await oversized[j].ConfigureAwait(false); + } + + count = 0; + } + } + + await Flush(client).ConfigureAwait(false); + for (int j = 0; j < count; j++) + { + result = await oversized[j].ConfigureAwait(false); + } + + ArrayPool>.Shared.Return(oversized); + } + else + { + throw new InvalidOperationException($"Unexpected pipeline mode: {PipelineMode}"); + } + } + catch (Exception ex) + { + await Console.Error.WriteLineAsync($"{operation.Method.Name} failed after {i} operations"); + Program.WriteException(ex); + } + + return result; + } + + public async Task InitAsync() + { + for (int i = 0; i < ClientCount; i++) + { + await InitAsync(GetClient(i)).ConfigureAwait(false); + } + } + + protected abstract TClient GetClient(int index); + protected virtual TClient WithCancellation(TClient client, CancellationToken cancellationToken) => client; + protected abstract Task DeleteAsync(TClient client, string key); + + protected abstract TClient CreateBatch(TClient client); + + protected Task RunAsync( + string? key, + Func> action, + bool deleteKey, + int divisor = 1) + => RunAsyncCore( + key, + GetNameCore(action, out var desc), + desc, + client => action(client).AsUntypedValueTask(), + client => PipelineTyped(client, action, divisor), + [], + deleteKey, + divisor); + + protected Task RunAsync( + string? key, + Func> action, + params string[] consumers) + => RunAsyncCore( + key, + GetNameCore(action, out var desc), + desc, + client => action(client).AsUntypedValueTask(), + client => PipelineTyped(client, action, 1), + consumers, + consumers.Length != 0, + 1); + + protected Task RunAsync( + string? key, + Func action, + bool deleteKey, + int divisor = 1) + => RunAsyncCore( + key, + GetNameCore(action, out var desc), + desc, + action, + client => PipelineUntyped(client, action, divisor), + [], + deleteKey, + divisor); + + protected Task RunAsync( + string? key, + Func action, + params string[] consumers) + => RunAsyncCore( + key, + GetNameCore(action, out var desc), + desc, + action, + client => PipelineUntyped(client, action, 1), + consumers, + consumers.Length != 0, + 1); + + private static string GetNameCore(Delegate underlyingAction, out string description) + { + string name = underlyingAction.Method.Name; + + if (underlyingAction.Method.GetCustomAttribute(typeof(DisplayNameAttribute)) is DisplayNameAttribute + { + DisplayName: { Length: > 0 } + } dna) + { + name = dna.DisplayName; + } + + description = ""; + if (underlyingAction.Method.GetCustomAttribute(typeof(DescriptionAttribute)) is DescriptionAttribute + { + Description: { Length: > 0 } + } da) + { + description = da.Description; + } + + return name; + } + + protected static string GetName(Func> action) => GetNameCore(action, out _); + protected static string GetName(Func action) => GetNameCore(action, out _); + + private async Task RunAsyncCore( + string? key, + string name, + string description, + Func test, + Func> pipeline, + string[] consumers, + bool deleteKey, + int divisor) + { + // skip test if not needed + string auxReason = ""; + if (!RunTest(name)) + { + auxReason = string.Join(", ", consumers.Where(x => RunTest(x))); + if (auxReason.Length == 0) return; // not needed by any consumers either + auxReason = $" (required for {auxReason})"; + } + + // include additional test metadata + if (description is { Length: > 0 }) + { + description = $" ({description})"; + } + + if (Quiet) + { + Console.Write($"{name}:"); + } + else + { + Console.Write( + $"====== {name}{description}{auxReason} ====== (clients: {ClientCount:#,##0}, ops: {TotalOperations(divisor):#,##0}"); + if (Multiplexed) + { + Console.Write(", mux"); + } + + if (SupportCancel) + { + Console.Write(", cancel"); + } + + Console.Write(PipelineDepth > 1 ? $", {PipelineMode}: {PipelineDepth:#,##0}" : ", sequential"); + + Console.WriteLine(")"); + } + + bool didNotRun = false; + try + { + if (key is not null && deleteKey) + { + await DeleteAsync(GetClient(0), key).ConfigureAwait(false); + } + + try + { + await test(GetClient(0)).ConfigureAwait(false); + } + catch (Exception ex) + { + await Console.Error.WriteLineAsync($"\t{ex.Message}"); + didNotRun = true; + return; + } + + var pending = new Task[ClientCount]; + int index = 0; +#if DEBUG && NEWCORE + Internal.DebugCounters.Flush(); +#endif + // optionally support cancellation, applied per-test + CancellationToken cancellationToken = CancellationToken.None; + using var cts = SupportCancel ? new CancellationTokenSource(TimeSpan.FromSeconds(20)) : null; + if (SupportCancel) cancellationToken = cts!.Token; + + var watch = Stopwatch.StartNew(); + for (int i = 0; i < ClientCount; i++) + { + var client = GetClient(i); + if (PipelineMode == PipelineStrategy.Batch && PipelineDepth > 1) + { + client = CreateBatch(client); + } + + pending[index++] = Task.Run( + () => pipeline(WithCancellation(client, cancellationToken)), + cancellationToken); + } + + await Task.WhenAll(pending).ConfigureAwait(false); + watch.Stop(); + + var seconds = watch.Elapsed.TotalSeconds; + // ReSharper disable once PossibleLossOfFraction + var rate = TotalOperations(divisor) / seconds; + if (Quiet) + { + Console.WriteLine($"\t{rate:###,###,##0} requests per second"); + return; + } + else + { + Console.WriteLine( + $"{TotalOperations(divisor):###,###,##0} requests completed in {seconds:0.00} seconds, {rate:###,###,##0} ops/sec"); + } + + if (!Quiet & typeof(T) != typeof(DBNull)) + { + const string format = "Typical result: {0}"; + + T result = await pending[^1]; + Console.WriteLine(format, result); + } + } + catch (Exception ex) + { + if (Quiet) Console.WriteLine(); + Program.WriteException(ex, name); + } + finally + { + _ = didNotRun; +#if DEBUG && NEWCORE + var counters = Internal.DebugCounters.Flush(); // flush even if not showing + if (!Quiet & !didNotRun) + { + if (counters.WriteBytes != 0) + { + Console.Write($"Write: {FormatBytes(counters.WriteBytes)}"); + if (counters.SyncWriteCount != 0) Console.Write($"; {counters.SyncWriteCount:#,##0} sync"); + if (counters.AsyncWriteInlineCount != 0) + Console.Write($"; {counters.AsyncWriteInlineCount:#,##0} async-inline"); + if (counters.AsyncWriteCount != 0) Console.Write($"; {counters.AsyncWriteCount:#,##0} full-async"); + Console.WriteLine(); + } + + if (counters.ReadBytes != 0) + { + Console.Write($"Read: {FormatBytes(counters.ReadBytes)}"); + if (counters.ReadCount != 0) Console.Write($"; {counters.ReadCount:#,##0} sync"); + if (counters.AsyncReadInlineCount != 0) + Console.Write($"; {counters.AsyncReadInlineCount:#,##0} async-inline"); + if (counters.AsyncReadCount != 0) Console.Write($"; {counters.AsyncReadCount:#,##0} full-async"); + Console.WriteLine(); + } + + if (counters.DiscardFullCount + counters.DiscardPartialCount != 0) + { + Console.Write($"Discard average: {FormatBytes(counters.DiscardAverage)}"); + if (counters.DiscardFullCount != 0) Console.Write($"; {counters.DiscardFullCount} full"); + if (counters.DiscardPartialCount != 0) Console.Write($"; {counters.DiscardPartialCount} partial"); + Console.WriteLine(); + } + + if (counters.CopyOutCount != 0) + { + Console.WriteLine( + $"Copy out: {FormatBytes(counters.CopyOutBytes)}; {counters.CopyOutCount:#,##0} times"); + } + + if (counters.PipelineFullAsyncCount != 0 + | counters.PipelineSendAsyncCount != 0 + | counters.PipelineFullSyncCount != 0) + { + Console.Write("Pipelining"); + if (counters.PipelineFullSyncCount != 0) + Console.Write($"; full sync: {counters.PipelineFullSyncCount:#,##0}"); + if (counters.PipelineSendAsyncCount != 0) + Console.Write($"; send async: {counters.PipelineSendAsyncCount:#,##0}"); + if (counters.PipelineFullAsyncCount != 0) + Console.Write($"; full async: {counters.PipelineFullAsyncCount:#,##0}"); + Console.WriteLine(); + } + + if (counters.BatchWriteCount != 0) + { + Console.Write($"Batching; {counters.BatchWriteCount:#,##0} batches"); + if (counters.BatchWriteFullPageCount != 0) + Console.Write($"; {counters.BatchWriteFullPageCount:#,###,##0} full pages"); + if (counters.BatchWritePartialPageCount != 0) + Console.Write($"; {counters.BatchWritePartialPageCount:#,###,##0} partial pages"); + if (counters.BatchWriteMessageCount != 0) + Console.Write($"; {counters.BatchWriteMessageCount:#,###,##0} messages"); + Console.WriteLine(); + } + + if (counters.BatchGrowCount != 0) + { + Console.WriteLine( + $"Batch growth; {counters.BatchGrowCount:#,##0} events, {counters.BatchGrowCopyCount:#,###,##0} elements copied"); + } + + if (counters.BatchBufferLeaseCount != 0 | counters.BatchMultiRootMessageCount != 0) + { + Console.Write( + $"Multi-message batching: {counters.BatchMultiRootMessageCount:#,###,##0} batches, {counters.BatchMultiChildMessageCount:#,###,##0} sub-messages"); + if (counters.BatchBufferLeaseCount != 0) + { + Console.Write( + $"; {counters.BatchBufferLeaseCount:#,###,##0} blocks leased, {counters.BatchBufferReturnCount:#,###,##0} blocks returned, {counters.BatchBufferElementsOutstanding:#,###,##0} elements outstanding"); + } + Console.WriteLine(); + } + + if (counters.BufferCreatedCount != 0 || + counters.BufferRecycledCount != 0 | counters.BufferMessageCount != 0) + { + Console.Write("Buffers"); + if (counters.BufferCreatedCount != 0) + { + Console.Write( + $"; created: {counters.BufferCreatedCount:#,###,##0}, {FormatBytes(counters.BufferTotalBytes)}"); + // always write recycled count - it being zero is important + Console.Write( + $"; recycled: {counters.BufferRecycledCount:#,###,##0}, {FormatBytes(counters.BufferRecycledBytes)}"); + } + + if (counters.BufferMessageCount != 0) + { + Console.Write( + $"; {counters.BufferMessageCount:#,###,##0} messages, {FormatBytes(counters.BufferMessageBytes)}"); + } + + Console.Write( + $"; max working {FormatBytes(counters.BufferMaxOutstandingBytes)}; {counters.BufferPinCount:#,###,##0} pins; {counters.BufferLeakCount:#,###,##0} leaks"); + Console.WriteLine(); + } + + static string FormatBytes(long bytes) + { + // ReSharper disable InconsistentNaming + const long k = 1024, M = k * k, G = M * k, T = G * k; + + // ReSharper restore InconsistentNaming + return bytes switch + { + < k => $"{bytes:#,##0} B", + < M => $"{bytes / (double)k:#,##0.00} KiB", + < G => $"{bytes / (double)M:#,##0.00} MiB", + < T => $"{bytes / (double)G:#,##0.00} GiB", + _ => $"{bytes / (double)T:#,##0.00} TiB", + }; + } + } +#endif + if (!Quiet) Console.WriteLine(); + } + } +} diff --git a/src/RESPite.Benchmark/BridgeBenchmark.cs b/src/RESPite.Benchmark/BridgeBenchmark.cs new file mode 100644 index 000000000..0e530050f --- /dev/null +++ b/src/RESPite.Benchmark/BridgeBenchmark.cs @@ -0,0 +1,17 @@ +#if NEWCORE +using RESPite.StackExchange.Redis; +using StackExchange.Redis; + +namespace RESPite.Benchmark; + +public sealed class BridgeBenchmark(string[] args) : OldCoreBenchmarkBase(args) +{ + public override string ToString() => "bridge SE.Redis"; + protected override IConnectionMultiplexer Create(int port) + { + var obj = new RespMultiplexer(); + obj.Connect("{HostName}:{Port}"); + return obj; + } +} +#endif diff --git a/src/RESPite.Benchmark/NewCoreBenchmark.cs b/src/RESPite.Benchmark/NewCoreBenchmark.cs new file mode 100644 index 000000000..649b0b984 --- /dev/null +++ b/src/RESPite.Benchmark/NewCoreBenchmark.cs @@ -0,0 +1,435 @@ +#if NEWCORE +using System; +using System.ComponentModel; +using System.Diagnostics; +using System.Threading; +using System.Threading.Tasks; +using RESPite.Connections; +using RESPite.Messages; + +namespace RESPite.Benchmark; + +public sealed class NewCoreBenchmark : BenchmarkBase +{ + public override string ToString() => "new IO core"; + + private readonly RespConnectionPool _connectionPool; + + private readonly RespContext[] _clients; + private readonly (string Key, byte[] Value)[] _pairs; + + protected override RespContext GetClient(int index) => _clients[index]; + + protected override Task DeleteAsync(RespContext client, string key) => client.DelAsync(key).AsTask(); + + protected override RespContext WithCancellation(RespContext client, CancellationToken cancellationToken) + => client.WithCancellationToken(cancellationToken); + + protected override Task InitAsync(RespContext client) => client.PingAsync().AsTask(); + + public NewCoreBenchmark(string[] args) : base(args) + { + _clients = new RespContext[ClientCount]; + + _connectionPool = new(count: Multiplexed ? 1 : ClientCount); + _connectionPool.ConnectionError += (_, e) => Program.WriteException(e.Exception, e.Operation); + _pairs = new (string, byte[])[10]; + + for (var i = 0; i < 10; i++) + { + _pairs[i] = ($"key:__rand_int__{i}", Payload); + } + + if (Multiplexed) + { + var conn = _connectionPool.GetConnection().Synchronized(); + var ctx = conn.Context; + for (int i = 0; i < ClientCount; i++) // init all + { + _clients[i] = ctx; + } + } + else + { + for (int i = 0; i < ClientCount; i++) // init all + { + var conn = _connectionPool.GetConnection(); + if (PipelineDepth > 1) + { + conn = conn.Synchronized(); + } + + _clients[i] = conn.Context; + } + } + } + + public override void Dispose() + { + _connectionPool.Dispose(); + foreach (var client in _clients) + { + client.Connection.Dispose(); + } + } + + protected override async Task OnCleanupAsync(RespContext client) + { + foreach (var pair in _pairs) + { + await client.DelAsync(pair.Key).ConfigureAwait(false); + } + } + + public override async Task RunAll() + { + await InitAsync().ConfigureAwait(false); + // await RunAsync(PingInline).ConfigureAwait(false); + await RunAsync(null, PingBulk).ConfigureAwait(false); + + await RunAsync(GetSetKey, Set, GetName(Get)).ConfigureAwait(false); + await RunAsync(GetSetKey, Get).ConfigureAwait(false); + + await RunAsync(CounterKey, Incr, true).ConfigureAwait(false); + + await RunAsync(ListKey, LPush, GetName(LPop)).ConfigureAwait(false); + await RunAsync(ListKey, LPop).ConfigureAwait(false); + + await RunAsync(ListKey, RPush, GetName(RPop)).ConfigureAwait(false); + await RunAsync(ListKey, RPop).ConfigureAwait(false); + + await RunAsync(SetKey, SAdd, GetName(SPop)).ConfigureAwait(false); + await RunAsync(SetKey, SPop).ConfigureAwait(false); + + await RunAsync(HashKey, HSet).ConfigureAwait(false); + + await RunAsync(SortedSetKey, ZAdd, GetName(ZPopMin)).ConfigureAwait(false); + await RunAsync(SortedSetKey, ZPopMin).ConfigureAwait(false); + + await RunAsync(null, MSet).ConfigureAwait(false); + await RunAsync(StreamKey, XAdd).ConfigureAwait(false); + + // leave until last, they're slower + if (RunTest(GetName(LRange100)) || + RunTest(GetName(LRange300)) || + RunTest(GetName(LRange500)) || + RunTest(GetName(LRange600))) + { + await LRangeInit650(GetClient(0)).ConfigureAwait(false); + await RunAsync(ListKey, LRange100, false, 10).ConfigureAwait(false); + await RunAsync(ListKey, LRange300, false, 10).ConfigureAwait(false); + await RunAsync(ListKey, LRange500, false, 10).ConfigureAwait(false); + await RunAsync(ListKey, LRange600, false, 10).ConfigureAwait(false); + } + + await CleanupAsync().ConfigureAwait(false); + } + + protected override RespContext CreateBatch(RespContext client) => client.CreateBatch(PipelineDepth).Context; + + protected override ValueTask Flush(RespContext client) + { + if (client.Connection is RespBatch batch) + { + return new(batch.FlushAsync()); + } + + return default; + } + + protected override void PrepareBatch(RespContext client, int count) + { + if (client.Connection is RespBatch batch) + { + batch.EnsureCapacity(count); + } + } + + [DisplayName("PING_INLINE")] + // ReSharper disable once UnusedMember.Local + private ValueTask PingInline(RespContext ctx) => ctx.PingInlineAsync(Payload); + + [DisplayName("PING_BULK")] + private ValueTask PingBulk(RespContext ctx) => ctx.PingAsync(Payload); + + [DisplayName("INCR")] + private ValueTask Incr(RespContext ctx) => ctx.IncrAsync(CounterKey); + + [DisplayName("GET")] + private ValueTask Get(RespContext ctx) => ctx.GetAsync(GetSetKey); + + [DisplayName("SET")] + private ValueTask Set(RespContext ctx) => ctx.SetAsync(GetSetKey, Payload); + + [DisplayName("LPUSH")] + private ValueTask LPush(RespContext ctx) => ctx.LPushAsync(ListKey, Payload); + + [DisplayName("RPUSH")] + private ValueTask RPush(RespContext ctx) => ctx.RPushAsync(ListKey, Payload); + + [DisplayName("LRANGE_100")] + private ValueTask LRange100(RespContext ctx) => ctx.LRangeAsync(ListKey, 0, 99); + + [DisplayName("LRANGE_300")] + private ValueTask LRange300(RespContext ctx) => ctx.LRangeAsync(ListKey, 0, 299); + + [DisplayName("LRANGE_500")] + private ValueTask LRange500(RespContext ctx) => ctx.LRangeAsync(ListKey, 0, 499); + + [DisplayName("LRANGE_600")] + private ValueTask LRange600(RespContext ctx) => ctx.LRangeAsync(ListKey, 0, 599); + + [DisplayName("LPOP")] + private ValueTask LPop(RespContext ctx) => ctx.LPopAsync(ListKey); + + [DisplayName("RPOP")] + private ValueTask RPop(RespContext ctx) => ctx.RPopAsync(ListKey); + + [DisplayName("SADD")] + private ValueTask SAdd(RespContext ctx) => ctx.SAddAsync(SetKey, "element:__rand_int__"); + + [DisplayName("HSET")] + private ValueTask HSet(RespContext ctx) => ctx.HSetAsync(HashKey, "element:__rand_int__", Payload); + + [DisplayName("ZADD")] + private ValueTask ZAdd(RespContext ctx) => ctx.ZAddAsync(SortedSetKey, 0, "element:__rand_int__"); + + [DisplayName("ZPOPMIN")] + private ValueTask ZPopMin(RespContext ctx) => ctx.ZPopMinAsync(SortedSetKey); + + [DisplayName("SPOP")] + private ValueTask SPop(RespContext ctx) => ctx.SPopAsync(SetKey); + + [DisplayName("MSET"), Description("10 keys")] + private ValueTask MSet(RespContext ctx) => ctx.MSetAsync(_pairs); + + private async ValueTask LRangeInit650(RespContext ctx) + { + await ctx.DelAsync(ListKey).ConfigureAwait(false); + await ctx.LPushAsync(ListKey, Payload, 650); + if (await ctx.LLenAsync(ListKey).ConfigureAwait(false) != 650) + { + throw new InvalidOperationException(); + } + } + + [DisplayName("XADD")] + private ValueTask XAdd(RespContext ctx) => + ctx.XAddAsync(StreamKey, "*", "myfield", Payload); + + protected override async Task RunBasicLoopAsync(int clientId) + { + // The purpose of this is to represent a more realistic loop using natural code + // rather than code that is drowning in test infrastructure. + var client = GetClient(clientId); + var depth = PipelineDepth; + int tickCount = 0; // this is just so we don't query DateTime. + long previousValue = (await client.GetInt32Async(CounterKey).ConfigureAwait(false)) ?? 0, + currentValue = previousValue; + var watch = Stopwatch.StartNew(); + long previousMillis = watch.ElapsedMilliseconds; + + bool Tick() + { + var currentMillis = watch.ElapsedMilliseconds; + var elapsedMillis = currentMillis - previousMillis; + if (elapsedMillis >= 1000) + { + if (clientId == 0) // only one client needs to update the UI + { + var qty = currentValue - previousValue; + var seconds = elapsedMillis / 1000.0; + Console.WriteLine( + $"{qty:#,###,##0} ops in {seconds:#0.00}s, {qty / seconds:#,###,##0}/s\ttotal: {currentValue:#,###,###,##0}"); + + // reset for next UI update + previousValue = currentValue; + previousMillis = currentMillis; + } + + if (currentMillis >= 20_000) + { + if (clientId == 0) + { + Console.WriteLine(); + Console.WriteLine( + $"\t Overall: {currentValue:#,###,###,##0} ops in {currentMillis / 1000:#0.00}s, {currentValue / (currentMillis / 1000.0):#,###,##0}/s"); + Console.WriteLine(); + } + + return true; // stop after some time + } + } + + tickCount = 0; + return false; + } + + if (depth <= 1) + { + while (true) + { + currentValue = await client.IncrAsync(CounterKey).ConfigureAwait(false); + + if (++tickCount >= 1000 && Tick()) break; // only check whether to output every N iterations + } + } + else + { + ValueTask[] pending = new ValueTask[depth]; + await using var batch = client.CreateBatch(depth); + var ctx = batch.Context; + while (true) + { + for (int i = 0; i < depth; i++) + { + pending[i] = ctx.IncrAsync(CounterKey); + } + + await batch.FlushAsync().ConfigureAwait(false); + batch.EnsureCapacity(depth); // batches don't assume re-use + for (var i = 0; i < depth; i++) + { + currentValue = await pending[i].ConfigureAwait(false); + } + + tickCount += depth; + if (tickCount >= 1000 && Tick()) break; // only check whether to output every N iterations + } + } + } +} + +internal static partial class RedisCommands +{ + [RespCommand] + internal static partial RespParsers.ResponseSummary Ping(this in RespContext ctx); + + [RespCommand] + internal static partial RespParsers.ResponseSummary SPop(this in RespContext ctx, string key); + + [RespCommand] + internal static partial int SAdd(this in RespContext ctx, string key, string payload); + + [RespCommand] + internal static partial RespParsers.ResponseSummary Set(this in RespContext ctx, string key, byte[] payload); + + [RespCommand] + internal static partial int LLen(this in RespContext ctx, string key); + + [RespCommand] + internal static partial int LPush(this in RespContext ctx, string key, byte[] payload); + + [RespCommand(Formatter = LPushFormatter.Name)] + internal static partial int LPush(this in RespContext ctx, string key, byte[] payload, int count); + + private sealed class LPushFormatter : IRespFormatter<(string Key, byte[] Payload, int Count)> + { + public const string Name = $"{nameof(LPushFormatter)}.{nameof(Instance)}"; + private LPushFormatter() { } + public static readonly LPushFormatter Instance = new(); + + public void Format( + scoped ReadOnlySpan command, + ref RespWriter writer, + in (string Key, byte[] Payload, int Count) request) + { + writer.WriteCommand(command, request.Count + 1); + writer.WriteKey(request.Key); + for (int i = 0; i < request.Count; i++) + { + // duplicate for lazy bulk load + writer.WriteBulkString(request.Payload); + } + } + } + + [RespCommand] + internal static partial int RPush(this in RespContext ctx, string key, byte[] payload); + + [RespCommand] + internal static partial RespParsers.ResponseSummary LPop(this in RespContext ctx, string key); + + [RespCommand] + internal static partial RespParsers.ResponseSummary RPop(this in RespContext ctx, string key); + + [RespCommand] + internal static partial RespParsers.ResponseSummary + LRange(this in RespContext ctx, string key, int start, int stop); + + [RespCommand] + internal static partial int HSet(this in RespContext ctx, string key, string field, byte[] payload); + + [RespCommand] + internal static partial RespParsers.ResponseSummary Ping(this in RespContext ctx, byte[] payload); + + [RespCommand] + internal static partial int Incr(this in RespContext ctx, string key); + + [RespCommand] + internal static partial RespParsers.ResponseSummary Del(this in RespContext ctx, string key); + + [RespCommand] + internal static partial RespParsers.ResponseSummary ZPopMin(this in RespContext ctx, string key); + + [RespCommand] + internal static partial int ZAdd(this in RespContext ctx, string key, double score, string payload); + + [RespCommand("get")] + internal static partial int? GetInt32(this in RespContext ctx, string key); + + [RespCommand] + internal static partial RespParsers.ResponseSummary XAdd( + this in RespContext ctx, + string key, + string id, + string field, + byte[] value); + + [RespCommand] + internal static partial RespParsers.ResponseSummary Get(this in RespContext ctx, string key); + + [RespCommand(Formatter = PairsFormatter.Name)] // custom command formatter + internal static partial bool MSet(this in RespContext ctx, (string, byte[])[] pairs); + + internal static RespParsers.ResponseSummary PingInline(this in RespContext ctx, byte[] payload) + => ctx.Command("ping"u8, payload, InlinePingFormatter.Instance).Wait(RespParsers.ResponseSummary.Parser); + + internal static ValueTask PingInlineAsync(this in RespContext ctx, byte[] payload) + => ctx.Command("ping"u8, payload, InlinePingFormatter.Instance) + .Send(RespParsers.ResponseSummary.Parser); + + private sealed class InlinePingFormatter : IRespFormatter + { + private InlinePingFormatter() { } + public static readonly InlinePingFormatter Instance = new(); + + public void Format(scoped ReadOnlySpan command, ref RespWriter writer, in byte[] request) + { + writer.WriteRaw(command); + writer.WriteRaw(" "u8); + writer.WriteRaw(request); + writer.WriteRaw("\r\n"u8); + } + } + + private sealed class PairsFormatter : IRespFormatter<(string Key, byte[] Value)[]> + { + public const string Name = $"{nameof(PairsFormatter)}.{nameof(Instance)}"; + public static readonly PairsFormatter Instance = new PairsFormatter(); + + public void Format( + scoped ReadOnlySpan command, + ref RespWriter writer, + in (string Key, byte[] Value)[] request) + { + writer.WriteCommand(command, 2 * request.Length); + foreach (var pair in request) + { + writer.WriteKey(pair.Key); + writer.WriteBulkString(pair.Value); + } + } + } +} +#endif diff --git a/src/RESPite.Benchmark/OldCoreBenchmark.cs b/src/RESPite.Benchmark/OldCoreBenchmark.cs new file mode 100644 index 000000000..6f1039330 --- /dev/null +++ b/src/RESPite.Benchmark/OldCoreBenchmark.cs @@ -0,0 +1,36 @@ +using System; +using System.Reflection; +using StackExchange.Redis; + +namespace RESPite.Benchmark; + +public sealed class OldCoreBenchmark(string[] args) : OldCoreBenchmarkBase(args) +{ + private static readonly string withVersion = $"classic SE.Redis {GetLibVersion()}"; + public override string ToString() => withVersion; + + protected override IConnectionMultiplexer Create(int port) + { + var options = ConfigurationOptions.Parse($"{HostName}:{Port}"); + if (WriteMode is { } wm && options.GetType().GetProperty( + "WriteMode", + BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) is { CanWrite: true, CanRead: true } prop) + { + prop.SetValue(options, wm); + Console.WriteLine($"Set WriteMode to {prop.GetValue(options)}"); + } + return ConnectionMultiplexer.Connect(options); + } + + private static string? _libVersion; + internal static string GetLibVersion() + { + if (_libVersion == null) + { + var assembly = typeof(ConnectionMultiplexer).Assembly; + _libVersion = ((AssemblyFileVersionAttribute)Attribute.GetCustomAttribute(assembly, typeof(AssemblyFileVersionAttribute))!)?.Version + ?? assembly.GetName().Version!.ToString(); + } + return _libVersion; + } +} diff --git a/src/RESPite.Benchmark/OldCoreBenchmarkBase.cs b/src/RESPite.Benchmark/OldCoreBenchmarkBase.cs new file mode 100644 index 000000000..0bab0ea4c --- /dev/null +++ b/src/RESPite.Benchmark/OldCoreBenchmarkBase.cs @@ -0,0 +1,299 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; +using System.Threading.Tasks; +using StackExchange.Redis; + +namespace RESPite.Benchmark; + +public abstract class OldCoreBenchmarkBase : BenchmarkBase +{ + private readonly IConnectionMultiplexer _connectionMultiplexer; + private readonly IDatabase _client; + private readonly KeyValuePair[] _pairs; + + public OldCoreBenchmarkBase(string[] args) : base(args) + { + // ReSharper disable once VirtualMemberCallInConstructor + _connectionMultiplexer = Create(Port); + _client = _connectionMultiplexer.GetDatabase(); + _pairs = new KeyValuePair[10]; + + for (var i = 0; i < 10; i++) + { + _pairs[i] = new($"{"key:__rand_int__"}{i}", Payload); + } + } + + protected abstract IConnectionMultiplexer Create(int port); + + protected override async Task OnCleanupAsync(IDatabaseAsync client) + { + foreach (var pair in _pairs) + { + await client.KeyDeleteAsync(pair.Key); + } + } + + protected override Task InitAsync(IDatabaseAsync client) => client.PingAsync(); + + public override void Dispose() + { + _connectionMultiplexer.Dispose(); + } + + protected override IDatabaseAsync GetClient(int index) => _client; + protected override Task DeleteAsync(IDatabaseAsync client, string key) => client.KeyDeleteAsync(key); + + public override async Task RunAll() + { + await InitAsync().ConfigureAwait(false); + // await RunAsync(PingInline).ConfigureAwait(false); + await RunAsync(null, PingBulk).ConfigureAwait(false); + + await RunAsync(GetSetKey, Set, GetName(Get)).ConfigureAwait(false); + await RunAsync(GetSetKey, Get).ConfigureAwait(false); + + await RunAsync(CounterKey, Incr, true).ConfigureAwait(false); + + await RunAsync(ListKey, LPush, GetName(LPop)).ConfigureAwait(false); + await RunAsync(ListKey, LPop).ConfigureAwait(false); + + await RunAsync(ListKey, RPush, GetName(RPop)).ConfigureAwait(false); + await RunAsync(ListKey, RPop).ConfigureAwait(false); + + await RunAsync(SetKey, SAdd, GetName(SPop)).ConfigureAwait(false); + await RunAsync(SetKey, SPop).ConfigureAwait(false); + + await RunAsync(HashKey, HSet).ConfigureAwait(false); + + await RunAsync(SortedSetKey, ZAdd, GetName(ZPopMin)).ConfigureAwait(false); + await RunAsync(SortedSetKey, ZPopMin).ConfigureAwait(false); + + await RunAsync(null, MSet).ConfigureAwait(false); + await RunAsync(StreamKey, XAdd).ConfigureAwait(false); + + // leave until last, they're slower + if (RunTest(GetName(LRange100)) || + RunTest(GetName(LRange300)) || + RunTest(GetName(LRange500)) || + RunTest(GetName(LRange600))) + { + await LRangeInit650(GetClient(0)).ConfigureAwait(false); + await RunAsync(ListKey, LRange100, false, 10).ConfigureAwait(false); + await RunAsync(ListKey, LRange300, false, 10).ConfigureAwait(false); + await RunAsync(ListKey, LRange500, false, 10).ConfigureAwait(false); + await RunAsync(ListKey, LRange600, false, 10).ConfigureAwait(false); + } + + await CleanupAsync().ConfigureAwait(false); + } + + protected override IDatabaseAsync CreateBatch(IDatabaseAsync client) => ((IDatabase)client).CreateBatch(); + + protected override ValueTask Flush(IDatabaseAsync client) + { + if (client is IBatch batch) + { + batch.Execute(); + } + + return default; + } + + protected override async Task RunBasicLoopAsync(int clientId) + { + // The purpose of this is to represent a more realistic loop using natural code + // rather than code that is drowning in test infrastructure. + var client = (IDatabase)GetClient(clientId); // need IDatabase for CreateBatch + var depth = PipelineDepth; + int tickCount = 0; // this is just so we don't query DateTime. + var tmp = await client.StringGetAsync(CounterKey).ConfigureAwait(false); + long previousValue = tmp.IsNull ? 0 : (long)tmp, currentValue = previousValue; + var watch = Stopwatch.StartNew(); + long previousMillis = watch.ElapsedMilliseconds; + + bool Tick() + { + var currentMillis = watch.ElapsedMilliseconds; + var elapsedMillis = currentMillis - previousMillis; + if (elapsedMillis >= 1000) + { + if (clientId == 0) // only one client needs to update the UI + { + var qty = currentValue - previousValue; + var seconds = elapsedMillis / 1000.0; + Console.WriteLine( + $"{qty:#,###,##0} ops in {seconds:#0.00}s, {qty / seconds:#,###,##0}/s\ttotal: {currentValue:#,###,###,##0}"); + + // reset for next UI update + previousValue = currentValue; + previousMillis = currentMillis; + } + + if (currentMillis >= 20_000) + { + if (clientId == 0) + { + Console.WriteLine(); + Console.WriteLine( + $"\t Overall: {currentValue:#,###,###,##0} ops in {currentMillis / 1000:#0.00}s, {currentValue / (currentMillis / 1000.0):#,###,##0}/s"); + Console.WriteLine(); + } + + return true; // stop after some time + } + } + + tickCount = 0; + return false; + } + + if (depth <= 1) + { + while (true) + { + currentValue = await client.StringIncrementAsync(CounterKey).ConfigureAwait(false); + + if (++tickCount >= 1000 && Tick()) break; // only check whether to output every N iterations + } + } + else + { + Task[] pending = new Task[depth]; + var batch = client.CreateBatch(depth); + while (true) + { + for (int i = 0; i < depth; i++) + { + pending[i] = batch.StringIncrementAsync(CounterKey); + } + + batch.Execute(); + for (int i = 0; i < depth; i++) + { + currentValue = await pending[i].ConfigureAwait(false); + } + + tickCount += depth; + if (tickCount >= 1000 && Tick()) break; // only check whether to output every N iterations + } + } + } + + [DisplayName("GET")] + private ValueTask Get(IDatabaseAsync client) => GetAndMeasureString(client); + + private async ValueTask GetAndMeasureString(IDatabaseAsync client) + { + using var lease = await client.StringGetLeaseAsync(GetSetKey).ConfigureAwait(false); + return lease?.Length ?? -1; + } + + [DisplayName("SET")] + private ValueTask Set(IDatabaseAsync client) => client.StringSetAsync(GetSetKey, Payload).AsValueTask(); + + [DisplayName("PING_BULK")] + private ValueTask PingBulk(IDatabaseAsync client) => client.PingAsync().AsValueTask(); + + [DisplayName("INCR")] + private ValueTask Incr(IDatabaseAsync client) => client.StringIncrementAsync(CounterKey).AsValueTask(); + + [DisplayName("HSET")] + private ValueTask HSet(IDatabaseAsync client) => + client.HashSetAsync(HashKey, "element:__rand_int__", Payload).AsValueTask(); + + [DisplayName("SADD")] + private ValueTask SAdd(IDatabaseAsync client) => + client.SetAddAsync(SetKey, "element:__rand_int__").AsValueTask(); + + [DisplayName("LPUSH")] + private ValueTask LPush(IDatabaseAsync client) => client.ListLeftPushAsync(ListKey, Payload).AsValueTask(); + + [DisplayName("RPUSH")] + private ValueTask RPush(IDatabaseAsync client) => client.ListRightPushAsync(ListKey, Payload).AsValueTask(); + + [DisplayName("LPOP")] + private ValueTask LPop(IDatabaseAsync client) => client.ListLeftPopAsync(ListKey).AsValueTask(); + + [DisplayName("RPOP")] + private ValueTask RPop(IDatabaseAsync client) => client.ListRightPopAsync(ListKey).AsValueTask(); + + [DisplayName("SPOP")] + private ValueTask SPop(IDatabaseAsync client) => client.SetPopAsync(SetKey).AsValueTask(); + + [DisplayName("ZADD")] + private ValueTask ZAdd(IDatabaseAsync client) => + client.SortedSetAddAsync(SortedSetKey, "element:__rand_int__", 0).AsValueTask(); + + [DisplayName("ZPOPMIN")] + private ValueTask ZPopMin(IDatabaseAsync client) => HasSortedSetElement(client.SortedSetPopAsync(SortedSetKey)); + + private async ValueTask HasSortedSetElement(Task pending) + { + var result = await pending.ConfigureAwait(false); + return result.HasValue ? 1 : 0; + } + + [DisplayName("MSET")] + private ValueTask MSet(IDatabaseAsync client) => client.StringSetAsync(_pairs).AsValueTask(); + + [DisplayName("XADD")] + private ValueTask XAdd(IDatabaseAsync client) => + client.StreamAddAsync(StreamKey, "myfield", Payload).AsValueTask(); + + [DisplayName("LRANGE_100")] + private ValueTask LRange100(IDatabaseAsync client) => CountAsync(client.ListRangeAsync(ListKey, 0, 99)); + + [DisplayName("LRANGE_300")] + private ValueTask LRange300(IDatabaseAsync client) => CountAsync(client.ListRangeAsync(ListKey, 0, 299)); + + [DisplayName("LRANGE_500")] + private ValueTask LRange500(IDatabaseAsync client) => CountAsync(client.ListRangeAsync(ListKey, 0, 499)); + + [DisplayName("LRANGE_600")] + private ValueTask LRange600(IDatabaseAsync client) => + CountAsync(client.ListRangeAsync(ListKey, 0, 599)); + + private static ValueTask CountAsync(Task task) => task.ContinueWith( + t => t.Result.Length, TaskContinuationOptions.ExecuteSynchronously).AsValueTask(); + + private async ValueTask LRangeInit650(IDatabaseAsync client) + { + var batch = CreateBatch(client); + _ = batch.KeyDeleteAsync(ListKey, flags: CommandFlags.FireAndForget); + for (int i = 0; i < 650; i++) + { + _ = batch.ListLeftPushAsync(ListKey, Payload, flags: CommandFlags.FireAndForget); + } + + await Flush(batch).ConfigureAwait(false); + if (await client.ListLengthAsync(ListKey).ConfigureAwait(false) != 650) + { + throw new InvalidOperationException(); + } + } +} + +internal static class TaskExtensions +{ + public static ValueTask AsValueTask(this Task task) => new(task); + + /* + public static ValueTask AsUntypedValueTask(this Task task) => new(task); + public static ValueTask AsValueTask(this Task task) => new(task); + */ + + public static ValueTask AsUntypedValueTask(this ValueTask task) + { + if (!task.IsCompleted) return Awaited(task); + task.GetAwaiter().GetResult(); + return default; + + static async ValueTask Awaited(ValueTask task) + { + await task.ConfigureAwait(false); + } + } +} diff --git a/src/RESPite.Benchmark/Program.cs b/src/RESPite.Benchmark/Program.cs new file mode 100644 index 000000000..a0797b787 --- /dev/null +++ b/src/RESPite.Benchmark/Program.cs @@ -0,0 +1,109 @@ +using System; +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using System.Threading.Tasks; + +namespace RESPite.Benchmark; + +internal static class Program +{ + private static async Task Main(string[] args) + { + bool basic = false; + try + { + List benchmarks = []; + foreach (var arg in args) + { + switch (arg) + { + case "--old": + benchmarks.Add(new OldCoreBenchmark(args)); + break; +#if NEWCORE + case "--bridge": + benchmarks.Add(new BridgeBenchmark(args)); + break; + case "--new": + benchmarks.Add(new NewCoreBenchmark(args)); + break; +#endif + case "--basic": + basic = true; + break; + } + } + + if (benchmarks.Count == 0) + { +#if NEWCORE + benchmarks.Add(new NewCoreBenchmark(args)); +#else + benchmarks.Add(new OldCoreBenchmark(args)); +#endif + } + +#if DEBUG + Console.WriteLine("### Debug ###"); +#endif + bool isFirst = true; + do + { + foreach (var bench in benchmarks) + { + if (benchmarks.Count > 1 || isFirst) + { + Console.WriteLine($"### {bench} ###"); + isFirst = false; + } + + if (basic) + { + await bench.RunBasicLoopAsync().ConfigureAwait(false); + } + else + { + await bench.RunAll().ConfigureAwait(false); + } + } + } + // ReSharper disable once LoopVariableIsNeverChangedInsideLoop + while (benchmarks[0].Loop); + + foreach (var bench in benchmarks) + { + bench.Dispose(); + } + return 0; + } + catch (Exception ex) + { + WriteException(ex); + return -1; + } + } + + internal static void WriteException(Exception? ex, [CallerMemberName] string operation = "") + { + Console.Error.WriteLine(); + Console.Error.WriteLine($"### EXCEPTION: {operation}"); + while (ex is not null) + { + Console.Error.WriteLine(); + Console.Error.WriteLine($"{ex.GetType().Name}: {ex.Message}"); + Console.Error.WriteLine($"\t{ex.StackTrace}"); + var data = ex.Data; + // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract + if (data is not null) + { + foreach (var key in data.Keys) + { + Console.Error.WriteLine($"\t{key}: {data[key]}"); + } + } + + ex = ex.InnerException; + } + Console.Error.WriteLine(); + } +} diff --git a/src/RESPite.Benchmark/RESPite.Benchmark.csproj b/src/RESPite.Benchmark/RESPite.Benchmark.csproj new file mode 100644 index 000000000..b9047024f --- /dev/null +++ b/src/RESPite.Benchmark/RESPite.Benchmark.csproj @@ -0,0 +1,44 @@ + + + + enable + + Exe + net8.0;net10.0 + resp-benchmark + true + command-line "RESP" benchmark client, comparable to redis-benchmark + True + readme.md + False + false + false + 2025 - $([System.DateTime]::Now.Year) Marc Gravell + + 3 + + + + + + + + + + + + + + + + + + + + diff --git a/src/RESPite.Benchmark/RespBenchmark.md b/src/RESPite.Benchmark/RespBenchmark.md new file mode 100644 index 000000000..b579d84de --- /dev/null +++ b/src/RESPite.Benchmark/RespBenchmark.md @@ -0,0 +1,352 @@ +# Influenced by redis-benchmark, which has typical output (with the default config) as below. + +Keys used (by default): + +- `key:__rand_int__` +- `counter:__rand_int__` +- `mylist` + +====== PING_INLINE ====== +100000 requests completed in 2.45 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +98.22% <= 1 milliseconds +99.88% <= 2 milliseconds +99.93% <= 3 milliseconds +99.99% <= 4 milliseconds +100.00% <= 5 milliseconds +100.00% <= 5 milliseconds +40849.68 requests per second + +====== PING_BULK ====== +100000 requests completed in 2.45 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +97.27% <= 1 milliseconds +99.86% <= 2 milliseconds +99.92% <= 3 milliseconds +99.94% <= 4 milliseconds +99.95% <= 23 milliseconds +99.96% <= 24 milliseconds +99.98% <= 25 milliseconds +100.00% <= 25 milliseconds +40866.37 requests per second + +====== SET ====== +100000 requests completed in 2.46 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +96.99% <= 1 milliseconds +99.47% <= 2 milliseconds +99.71% <= 3 milliseconds +99.86% <= 4 milliseconds +99.87% <= 9 milliseconds +99.88% <= 10 milliseconds +99.92% <= 11 milliseconds +99.93% <= 12 milliseconds +99.94% <= 13 milliseconds +99.96% <= 14 milliseconds +99.97% <= 15 milliseconds +99.97% <= 16 milliseconds +100.00% <= 27 milliseconds +40650.41 requests per second + +====== GET ====== +100000 requests completed in 3.00 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +90.56% <= 1 milliseconds +98.90% <= 2 milliseconds +99.46% <= 3 milliseconds +99.61% <= 4 milliseconds +99.70% <= 5 milliseconds +99.73% <= 6 milliseconds +99.75% <= 7 milliseconds +99.75% <= 9 milliseconds +99.77% <= 10 milliseconds +99.79% <= 12 milliseconds +99.80% <= 14 milliseconds +99.80% <= 15 milliseconds +99.83% <= 16 milliseconds +99.90% <= 17 milliseconds +99.93% <= 18 milliseconds +99.96% <= 19 milliseconds +99.98% <= 20 milliseconds +99.98% <= 22 milliseconds +99.98% <= 30 milliseconds +99.99% <= 31 milliseconds +100.00% <= 31 milliseconds +33377.84 requests per second + +====== INCR ====== +100000 requests completed in 2.94 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +93.21% <= 1 milliseconds +99.21% <= 2 milliseconds +99.70% <= 3 milliseconds +99.81% <= 4 milliseconds +99.86% <= 5 milliseconds +99.89% <= 6 milliseconds +99.93% <= 7 milliseconds +99.94% <= 8 milliseconds +99.96% <= 11 milliseconds +99.96% <= 12 milliseconds +99.96% <= 13 milliseconds +99.97% <= 14 milliseconds +99.97% <= 24 milliseconds +100.00% <= 24 milliseconds +34048.35 requests per second + +====== LPUSH ====== +100000 requests completed in 2.98 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +92.58% <= 1 milliseconds +99.21% <= 2 milliseconds +99.57% <= 3 milliseconds +99.71% <= 4 milliseconds +99.82% <= 5 milliseconds +99.85% <= 6 milliseconds +99.85% <= 7 milliseconds +99.88% <= 9 milliseconds +99.93% <= 10 milliseconds +99.93% <= 13 milliseconds +99.93% <= 14 milliseconds +99.95% <= 16 milliseconds +99.95% <= 31 milliseconds +99.99% <= 32 milliseconds +100.00% <= 32 milliseconds +33512.07 requests per second + +====== LPOP ====== +100000 requests completed in 2.91 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +92.81% <= 1 milliseconds +99.33% <= 2 milliseconds +99.89% <= 3 milliseconds +99.94% <= 4 milliseconds +99.96% <= 5 milliseconds +99.97% <= 15 milliseconds +99.98% <= 16 milliseconds +100.00% <= 17 milliseconds +34317.09 requests per second + +====== SADD ====== +100000 requests completed in 2.87 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +94.26% <= 1 milliseconds +99.58% <= 2 milliseconds +99.87% <= 3 milliseconds +99.93% <= 4 milliseconds +99.98% <= 17 milliseconds +99.98% <= 18 milliseconds +100.00% <= 19 milliseconds +34855.35 requests per second + +====== SPOP ====== +100000 requests completed in 2.99 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +91.00% <= 1 milliseconds +99.30% <= 2 milliseconds +99.69% <= 3 milliseconds +99.80% <= 4 milliseconds +99.85% <= 5 milliseconds +99.85% <= 8 milliseconds +99.86% <= 9 milliseconds +99.89% <= 10 milliseconds +99.92% <= 13 milliseconds +99.94% <= 14 milliseconds +99.95% <= 16 milliseconds +100.00% <= 16 milliseconds +33456.00 requests per second + +====== LPUSH (needed to benchmark LRANGE) ====== +100000 requests completed in 2.92 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +93.25% <= 1 milliseconds +99.45% <= 2 milliseconds +99.75% <= 3 milliseconds +99.86% <= 4 milliseconds +99.89% <= 5 milliseconds +99.91% <= 6 milliseconds +99.93% <= 9 milliseconds +99.95% <= 10 milliseconds +99.96% <= 11 milliseconds +99.97% <= 14 milliseconds +99.98% <= 15 milliseconds +99.99% <= 17 milliseconds +100.00% <= 18 milliseconds +100.00% <= 20 milliseconds +100.00% <= 20 milliseconds +34258.31 requests per second + +====== LRANGE_100 (first 100 elements) ====== +100000 requests completed in 4.33 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +35.50% <= 1 milliseconds +98.90% <= 2 milliseconds +99.61% <= 3 milliseconds +99.76% <= 4 milliseconds +99.83% <= 5 milliseconds +99.83% <= 7 milliseconds +99.84% <= 8 milliseconds +99.88% <= 9 milliseconds +99.88% <= 10 milliseconds +99.91% <= 11 milliseconds +99.91% <= 12 milliseconds +99.91% <= 13 milliseconds +99.96% <= 15 milliseconds +99.96% <= 34 milliseconds +99.97% <= 35 milliseconds +100.00% <= 39 milliseconds +100.00% <= 39 milliseconds +23089.36 requests per second + +====== LRANGE_300 (first 300 elements) ====== +100000 requests completed in 7.12 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +0.01% <= 1 milliseconds +84.00% <= 2 milliseconds +98.64% <= 3 milliseconds +99.44% <= 4 milliseconds +99.65% <= 5 milliseconds +99.70% <= 6 milliseconds +99.72% <= 7 milliseconds +99.75% <= 8 milliseconds +99.77% <= 9 milliseconds +99.81% <= 10 milliseconds +99.85% <= 11 milliseconds +99.87% <= 12 milliseconds +99.89% <= 13 milliseconds +99.90% <= 14 milliseconds +99.92% <= 15 milliseconds +99.96% <= 16 milliseconds +99.97% <= 17 milliseconds +99.99% <= 18 milliseconds +99.99% <= 26 milliseconds +99.99% <= 32 milliseconds +100.00% <= 37 milliseconds +100.00% <= 38 milliseconds +100.00% <= 39 milliseconds +14039.03 requests per second + +====== LRANGE_500 (first 450 elements) ====== +100000 requests completed in 8.32 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +0.71% <= 1 milliseconds +49.73% <= 2 milliseconds +96.81% <= 3 milliseconds +99.35% <= 4 milliseconds +99.79% <= 5 milliseconds +99.83% <= 6 milliseconds +99.84% <= 7 milliseconds +99.85% <= 8 milliseconds +99.91% <= 9 milliseconds +99.91% <= 10 milliseconds +99.91% <= 12 milliseconds +99.91% <= 27 milliseconds +99.91% <= 28 milliseconds +99.92% <= 29 milliseconds +99.93% <= 30 milliseconds +99.96% <= 31 milliseconds +99.96% <= 49 milliseconds +99.96% <= 50 milliseconds +99.98% <= 99 milliseconds +99.98% <= 100 milliseconds +100.00% <= 100 milliseconds +12022.12 requests per second + +====== LRANGE_600 (first 600 elements) ====== +100000 requests completed in 10.27 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +0.15% <= 1 milliseconds +28.15% <= 2 milliseconds +72.35% <= 3 milliseconds +96.20% <= 4 milliseconds +98.96% <= 5 milliseconds +99.68% <= 6 milliseconds +99.80% <= 7 milliseconds +99.85% <= 8 milliseconds +99.87% <= 9 milliseconds +99.88% <= 10 milliseconds +99.88% <= 11 milliseconds +99.88% <= 12 milliseconds +99.89% <= 13 milliseconds +99.89% <= 14 milliseconds +99.89% <= 15 milliseconds +99.90% <= 16 milliseconds +99.91% <= 17 milliseconds +99.91% <= 18 milliseconds +99.91% <= 19 milliseconds +99.92% <= 20 milliseconds +99.93% <= 21 milliseconds +99.95% <= 22 milliseconds +99.95% <= 23 milliseconds +99.96% <= 24 milliseconds +99.97% <= 25 milliseconds +99.97% <= 26 milliseconds +99.98% <= 27 milliseconds +100.00% <= 28 milliseconds +100.00% <= 29 milliseconds +100.00% <= 29 milliseconds +9736.15 requests per second + +====== MSET (10 keys) ====== +100000 requests completed in 2.94 seconds +50 parallel clients +3 bytes payload +keep alive: 1 + +92.48% <= 1 milliseconds +99.33% <= 2 milliseconds +99.91% <= 3 milliseconds +99.93% <= 4 milliseconds +99.94% <= 6 milliseconds +99.94% <= 11 milliseconds +99.96% <= 12 milliseconds +99.97% <= 13 milliseconds +99.98% <= 14 milliseconds +99.98% <= 17 milliseconds +99.99% <= 18 milliseconds +99.99% <= 19 milliseconds +99.99% <= 25 milliseconds +100.00% <= 30 milliseconds +100.00% <= 30 milliseconds +34059.95 requests per second \ No newline at end of file diff --git a/src/RESPite.Benchmark/readme.md b/src/RESPite.Benchmark/readme.md new file mode 100644 index 000000000..ea8fe2105 --- /dev/null +++ b/src/RESPite.Benchmark/readme.md @@ -0,0 +1,55 @@ +# resp-benchmark + +The `resp-benchmark` tool is a command-line "RESP" benchmark client, comparable to `redis-benchmark`, and +many of the arguments are the same. This is mostly for internal team usage, but is included here for +reference. + +Example usage: + +``` bash +> dotnet tool install -g RESPite.Benchmark + +# basic usage +> resp-benchmark + +# 50 clients, pipeline to 100, multiplexed, 1M operations, only test incr, loop +> resp-benchmark -c 50 -P 100 -n 1000000 +m -t incr -l + +``` + +## Options supported from `redis-benchmark` + +Basic options, for parity: + +- `-h ` Server hostname (default 127.0.0.1) +- `-p ` Server port (default 6379) +- `-c ` Number of parallel connections (default 50). +- `-n ` Total number of requests (default 100000) +- `-P ` Pipeline requests. Default 1 (no pipeline). +- `-l` Loop. Run the tests forever +- `-q` Quiet. Just show query/sec values +- `-t ` Only run the comma separated list of tests. The test names are the same as the ones produced as output. + +## Custom options + +Additional options specific to this tool: + +- `+m` / `-m`: enable or disable (default) multiplexing: when enabled clients share a connection, otherwise each client has a separate connection +- `--batch` / `--queue` pipelining should using batching (default) or queueing strategy +- `--basic` : perform basic typical IO operations rather than synthetic benchmarks + + +## Internal options + +These exist mostly for Marc's benefit: + +- `-w ` Specify the internal write-mode +- `+x` / `-x`: enable or disable (default) cancellation support (irrelevant until later v3 tranche) + +## Local example + +To build and run from source, `dotnet run` can be used with everything after `--` being args to the command: + +``` +dotnet run -p:TargetVer=3 -f net10.0 -c Release -- -q +m --batch -n 500000 +``` \ No newline at end of file diff --git a/src/RESPite/Messages/RespReader.Utils.cs b/src/RESPite/Messages/RespReader.Utils.cs index 9aca671fb..4a504ec1f 100644 --- a/src/RESPite/Messages/RespReader.Utils.cs +++ b/src/RESPite/Messages/RespReader.Utils.cs @@ -103,7 +103,21 @@ private readonly void ThrowProtocolFailure(string message) internal static void ThrowEof() => throw new EndOfStreamException(); [MethodImpl(MethodImplOptions.NoInlining), DoesNotReturn] - private static void ThrowFormatException() => throw new FormatException(); + private readonly void ThrowFormatException(string type) + { + var msg = $"Invalid format parsing {Prefix} as {type}"; +#if DEBUG + if (IsScalar && ScalarLength() <= 64) + { + try { msg += $": '{ReadString()}'"; } + catch (Exception ex) + { + Debug.WriteLine(ex); + } + } +#endif + throw new FormatException(msg); + } private int RawTryReadByte() { diff --git a/src/RESPite/Messages/RespReader.cs b/src/RESPite/Messages/RespReader.cs index 2c93185ea..86ff08f40 100644 --- a/src/RESPite/Messages/RespReader.cs +++ b/src/RESPite/Messages/RespReader.cs @@ -746,7 +746,6 @@ private readonly unsafe bool TryParseSlow( /// The parsed value if successful. /// true if parsing succeeded; otherwise, false. #pragma warning disable RS0016, RS0027 // public API - [Experimental(Experiments.Respite, UrlFormat = Experiments.UrlFormat)] [MethodImpl(MethodImplOptions.AggressiveInlining)] #if DEBUG [Obsolete("Please prefer the function-pointer API for library-internal use.")] @@ -758,6 +757,52 @@ public readonly bool TryParseScalar(ScalarParser parser, out T value return TryGetSpan(out var span) ? parser(span, out value) : TryParseSlow(parser, out value); } + private readonly ReadOnlySpan BufferChars(Span target, out char[]? lease) + { + byte[] byteLease = []; + var bytes = Buffer(ref byteLease, byteLease); + + int len = RespConstants.UTF8.GetMaxCharCount(bytes.Length); + if (len <= target.Length) + { + lease = null; + } + else + { + target = lease = ArrayPool.Shared.Rent(len); + } + len = RespConstants.UTF8.GetChars(bytes, target); + return target.Slice(0, len); + } + + /// + /// Tries to read the current scalar element using a parser callback. + /// + /// The type of data being parsed. + /// The parser callback. + /// The parsed value if successful. + /// true if parsing succeeded; otherwise, false. + public readonly bool TryParseScalar(ScalarParser parser, out T value) + { + // note: no benefit in a function-ptr overload, after we've dealt with decoding bytes etc + var buffer = BufferChars(stackalloc char[128], out var lease); + try + { + return parser(buffer, out value); + } + finally + { + if (lease is not null) ArrayPool.Shared.Return(lease); + } + } + + /// + /// Tries to read the current scalar element using a parser callback. + /// + /// The type of data being parsed. + /// The parser callback. + /// The parsed value if successful. + /// true if parsing succeeded; otherwise, false. [MethodImpl(MethodImplOptions.NoInlining)] private readonly bool TryParseSlow(ScalarParser parser, out T value) { @@ -1682,7 +1727,7 @@ public readonly long ReadInt64() && Utf8Parser.TryParse(span, out value, out int bytes) && bytes == span.Length)) { - ThrowFormatException(); + ThrowFormatException(nameof(Int64)); value = 0; } @@ -1716,7 +1761,7 @@ public readonly int ReadInt32() && Utf8Parser.TryParse(span, out value, out int bytes) && bytes == span.Length)) { - ThrowFormatException(); + ThrowFormatException(nameof(Int32)); value = 0; } @@ -1764,7 +1809,7 @@ public readonly double ReadDouble() return double.NegativeInfinity; } - ThrowFormatException(); + ThrowFormatException(nameof(Double)); return 0; } @@ -1844,7 +1889,7 @@ public readonly decimal ReadDecimal() && Utf8Parser.TryParse(span, out value, out int bytes) && bytes == span.Length)) { - ThrowFormatException(); + ThrowFormatException(nameof(Decimal)); value = 0; } @@ -1895,7 +1940,7 @@ public readonly bool ReadBoolean() { if (!TryReadBoolean(out var value)) { - ThrowFormatException(); + ThrowFormatException(nameof(Boolean)); } return value; } diff --git a/src/RESPite/PublicAPI/PublicAPI.Unshipped.txt b/src/RESPite/PublicAPI/PublicAPI.Unshipped.txt index ab058de62..9acf1fc40 100644 --- a/src/RESPite/PublicAPI/PublicAPI.Unshipped.txt +++ b/src/RESPite/PublicAPI/PublicAPI.Unshipped.txt @@ -1 +1,6 @@ #nullable enable +[SER004]RESPite.Messages.RespReader.TryParseScalar(RESPite.Messages.RespReader.ScalarParser! parser, out T value) -> bool +[SER004]static RESPite.AsciiHash.EqualsCI(System.ReadOnlySpan first, System.ReadOnlySpan second) -> bool +[SER004]static RESPite.AsciiHash.EqualsCI(System.ReadOnlySpan first, System.ReadOnlySpan second) -> bool +[SER004]static RESPite.AsciiHash.SequenceEqualsCI(System.ReadOnlySpan first, System.ReadOnlySpan second) -> bool +[SER004]static RESPite.AsciiHash.SequenceEqualsCI(System.ReadOnlySpan first, System.ReadOnlySpan second) -> bool diff --git a/src/RESPite/PublicAPI/net6.0/PublicAPI.Shipped.txt b/src/RESPite/PublicAPI/net6.0/PublicAPI.Shipped.txt new file mode 100644 index 000000000..ab058de62 --- /dev/null +++ b/src/RESPite/PublicAPI/net6.0/PublicAPI.Shipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/src/RESPite/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/src/RESPite/PublicAPI/net6.0/PublicAPI.Unshipped.txt new file mode 100644 index 000000000..ab058de62 --- /dev/null +++ b/src/RESPite/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/src/RESPite/RESPite.csproj b/src/RESPite/RESPite.csproj index fef03625b..6b9798b0e 100644 --- a/src/RESPite/RESPite.csproj +++ b/src/RESPite/RESPite.csproj @@ -46,6 +46,4 @@ - - diff --git a/src/RESPite/Shared/AsciiHash.Public.cs b/src/RESPite/Shared/AsciiHash.Public.cs deleted file mode 100644 index dd31cb415..000000000 --- a/src/RESPite/Shared/AsciiHash.Public.cs +++ /dev/null @@ -1,10 +0,0 @@ -namespace RESPite; - -// in the shared file, these are declared without accessibility modifiers -public sealed partial class AsciiHashAttribute -{ -} - -public readonly partial struct AsciiHash -{ -} diff --git a/src/RESPite/Shared/AsciiHash.cs b/src/RESPite/Shared/AsciiHash.cs index 37b3c5734..f0f134872 100644 --- a/src/RESPite/Shared/AsciiHash.cs +++ b/src/RESPite/Shared/AsciiHash.cs @@ -1,4 +1,3 @@ -using System; using System.Buffers.Binary; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; @@ -7,8 +6,6 @@ namespace RESPite; -#pragma warning disable SA1205 // deliberately omit accessibility - see AsciiHash.Public.cs - /// /// This type is intended to provide fast hashing functions for small ASCII strings, for example well-known /// RESP literals that are usually identifiable by their length and initial bytes; it is not intended @@ -22,7 +19,7 @@ namespace RESPite; Inherited = false)] [Conditional("DEBUG")] // evaporate in release [Experimental(Experiments.Respite, UrlFormat = Experiments.UrlFormat)] -sealed partial class AsciiHashAttribute(string token = "") : Attribute +public sealed partial class AsciiHashAttribute(string token = "") : Attribute { /// /// The token expected when parsing data, if different from the implied value. The implied @@ -38,7 +35,7 @@ sealed partial class AsciiHashAttribute(string token = "") : Attribute // note: instance members are in AsciiHash.Instance.cs. [Experimental(Experiments.Respite, UrlFormat = Experiments.UrlFormat)] -readonly partial struct AsciiHash +public readonly partial struct AsciiHash { /// /// In-place ASCII upper-case conversion. @@ -85,6 +82,9 @@ public static bool EqualsCI(ReadOnlySpan first, ReadOnlySpan second) return len <= MaxBytesHashed ? HashUC(first) == HashUC(second) : SequenceEqualsCI(first, second); } + public static bool EqualsCI(ReadOnlySpan first, ReadOnlySpan second) + => EqualsCI(second, first); + public static unsafe bool SequenceEqualsCI(ReadOnlySpan first, ReadOnlySpan second) { var len = first.Length; @@ -120,6 +120,9 @@ public static unsafe bool SequenceEqualsCI(ReadOnlySpan first, ReadOnlySpa } } + public static bool SequenceEqualsCI(ReadOnlySpan first, ReadOnlySpan second) + => SequenceEqualsCI(second, first); + public static bool EqualsCS(ReadOnlySpan first, ReadOnlySpan second) { var len = first.Length; @@ -139,6 +142,14 @@ public static bool EqualsCI(ReadOnlySpan first, ReadOnlySpan second) return len <= MaxBytesHashed ? HashUC(first) == HashUC(second) : SequenceEqualsCI(first, second); } + public static bool EqualsCI(ReadOnlySpan first, ReadOnlySpan second) + { + var len = first.Length; + if (len != second.Length) return false; + // for very short values, the UC hash performs CI equality + return len <= MaxBytesHashed ? HashUC(first) == HashUC(second) : SequenceEqualsCI(first, second); + } + public static unsafe bool SequenceEqualsCI(ReadOnlySpan first, ReadOnlySpan second) { var len = first.Length; @@ -174,6 +185,41 @@ public static unsafe bool SequenceEqualsCI(ReadOnlySpan first, ReadOnlySpa } } + public static unsafe bool SequenceEqualsCI(ReadOnlySpan first, ReadOnlySpan second) + { + var len = first.Length; + if (len != second.Length) return false; + + // OK, don't be clever (SIMD, etc); the purpose of FashHash is to compare RESP key tokens, which are + // typically relatively short, think 3-20 bytes. That wouldn't even touch a SIMD vector, so: + // just loop (the exact thing we'd need to do *anyway* in a SIMD implementation, to mop up the non-SIMD + // trailing bytes). + fixed (char* firstPtr = &MemoryMarshal.GetReference(first)) + { + fixed (byte* secondPtr = &MemoryMarshal.GetReference(second)) + { + const int CS_MASK = 0b0101_1111; + for (int i = 0; i < len; i++) + { + int x = (byte)firstPtr[i]; + var xCI = x & CS_MASK; + if (xCI >= 'A' & xCI <= 'Z') + { + // alpha mismatch + if (xCI != (secondPtr[i] & CS_MASK)) return false; + } + else if (x != secondPtr[i]) + { + // non-alpha mismatch + return false; + } + } + + return true; + } + } + } + public static void Hash(scoped ReadOnlySpan value, out long cs, out long uc) { cs = HashCS(value); diff --git a/src/RESPite/Shared/FrameworkShims.Encoding.cs b/src/RESPite/Shared/FrameworkShims.Encoding.cs index 2f2c2e89d..b5937dd17 100644 --- a/src/RESPite/Shared/FrameworkShims.Encoding.cs +++ b/src/RESPite/Shared/FrameworkShims.Encoding.cs @@ -1,3 +1,5 @@ +using System.Runtime.InteropServices; + #if !NET // ReSharper disable once CheckNamespace namespace System.Text @@ -7,7 +9,7 @@ internal static class EncodingExtensions public static unsafe int GetBytes(this Encoding encoding, ReadOnlySpan source, Span destination) { if (source.IsEmpty) return 0; - fixed (byte* bPtr = destination) + fixed (byte* bPtr = &MemoryMarshal.GetReference(destination)) { fixed (char* cPtr = source) { @@ -19,9 +21,9 @@ public static unsafe int GetBytes(this Encoding encoding, ReadOnlySpan sou public static unsafe int GetChars(this Encoding encoding, ReadOnlySpan source, Span destination) { if (source.IsEmpty) return 0; - fixed (byte* bPtr = source) + fixed (byte* bPtr = &MemoryMarshal.GetReference(source)) { - fixed (char* cPtr = destination) + fixed (char* cPtr = &MemoryMarshal.GetReference(destination)) { return encoding.GetChars(bPtr, source.Length, cPtr, destination.Length); } @@ -31,7 +33,7 @@ public static unsafe int GetChars(this Encoding encoding, ReadOnlySpan sou public static unsafe int GetCharCount(this Encoding encoding, ReadOnlySpan source) { if (source.IsEmpty) return 0; - fixed (byte* bPtr = source) + fixed (byte* bPtr = &MemoryMarshal.GetReference(source)) { return encoding.GetCharCount(bPtr, source.Length); } @@ -40,7 +42,7 @@ public static unsafe int GetCharCount(this Encoding encoding, ReadOnlySpan public static unsafe string GetString(this Encoding encoding, ReadOnlySpan source) { if (source.IsEmpty) return ""; - fixed (byte* bPtr = source) + fixed (byte* bPtr = &MemoryMarshal.GetReference(source)) { return encoding.GetString(bPtr, source.Length); } diff --git a/src/RESPite/Shared/FrameworkShims.Sockets.cs b/src/RESPite/Shared/FrameworkShims.Sockets.cs new file mode 100644 index 000000000..25eccd0a2 --- /dev/null +++ b/src/RESPite/Shared/FrameworkShims.Sockets.cs @@ -0,0 +1,163 @@ +#if !NET +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// ReSharper disable once CheckNamespace +namespace System.Net.Sockets; + +internal static class SocketExtensions +{ + internal static async ValueTask ConnectAsync(this Socket socket, EndPoint remoteEP, CancellationToken cancellationToken = default) + { + // this API is only used during handshake, *not* core IO, so: we're not concerned about alloc overhead + using var args = new SocketAwaitableEventArgs(SocketFlags.None, cancellationToken); + args.RemoteEndPoint = remoteEP; + if (!socket.ConnectAsync(args)) + { + args.Complete(); + } + await args; // .ConfigureAwait(false) does not apply here + } + + internal static async ValueTask SendAsync(this Socket socket, ReadOnlyMemory buffer, SocketFlags socketFlags, CancellationToken cancellationToken = default) + { + // this API is only used during handshake, *not* core IO, so: we're not concerned about alloc overhead + using var args = new SocketAwaitableEventArgs(socketFlags, cancellationToken); + args.SetBuffer(buffer); + if (!socket.SendAsync(args)) + { + args.Complete(); + } + + return await args; // .ConfigureAwait(false) does not apply here + } + + internal static async ValueTask ReceiveAsync(this Socket socket, Memory buffer, SocketFlags socketFlags, CancellationToken cancellationToken = default) + { + // this API is only used during handshake, *not* core IO, so: we're not concerned about alloc overhead + using var args = new SocketAwaitableEventArgs(socketFlags, cancellationToken); + args.SetBuffer(buffer); + if (!socket.ReceiveAsync(args)) + { + args.Complete(); + } + + return await args; // .ConfigureAwait(false) does not apply here + } + + /// + /// Awaitable SocketAsyncEventArgs, where awaiting the args yields either the BytesTransferred or throws the relevant socket exception, + /// plus support for cancellation via . + /// + private sealed class SocketAwaitableEventArgs : SocketAsyncEventArgs, ICriticalNotifyCompletion, IDisposable + { + public new void Dispose() + { + cancelRegistration.Dispose(); + base.Dispose(); + } + + private CancellationTokenRegistration cancelRegistration; + public SocketAwaitableEventArgs(SocketFlags socketFlags, CancellationToken cancellationToken) + { + SocketFlags = socketFlags; + if (cancellationToken.CanBeCanceled) + { + cancellationToken.ThrowIfCancellationRequested(); + cancelRegistration = cancellationToken.Register(Timeout); + } + } + + public void SetBuffer(ReadOnlyMemory buffer) + { + if (!MemoryMarshal.TryGetArray(buffer, out var segment)) ThrowNotSupported(); + SetBuffer(segment.Array ?? [], segment.Offset, segment.Count); + + [DoesNotReturn] + static void ThrowNotSupported() => throw new NotSupportedException("Only array-backed buffers are supported"); + } + + public void Timeout() => Abort(SocketError.TimedOut); + + public void Abort(SocketError error) + { + _forcedError = error; + OnCompleted(this); + } + + private volatile SocketError _forcedError; // Success = 0, no field init required + + // ReSharper disable once InconsistentNaming + private static readonly Action _callbackCompleted = () => { }; + + private Action? _callback; + + public SocketAwaitableEventArgs GetAwaiter() => this; + + /// + /// Indicates whether the current operation is complete; used as part of "await". + /// + public bool IsCompleted => ReferenceEquals(_callback, _callbackCompleted); + + /// + /// Gets the result of the async operation is complete; used as part of "await". + /// + public int GetResult() + { + Debug.Assert(ReferenceEquals(_callback, _callbackCompleted)); + + _callback = null; + + var error = _forcedError; + if (error is SocketError.Success) error = SocketError; + if (error is not SocketError.Success) ThrowSocketException(error); + + return BytesTransferred; + + static void ThrowSocketException(SocketError e) => throw new SocketException((int)e); + } + + /// + /// Schedules a continuation for this operation; used as part of "await". + /// + public void OnCompleted(Action continuation) + { + if (ReferenceEquals(Volatile.Read(ref _callback), _callbackCompleted) + || ReferenceEquals(Interlocked.CompareExchange(ref _callback, continuation, null), _callbackCompleted)) + { + // this is the rare "kinda already complete" case; push to worker to prevent possible stack dive, + // but prefer the custom scheduler when possible + RunOnThreadPool(continuation); + } + } + + /// + /// Schedules a continuation for this operation; used as part of "await". + /// + public void UnsafeOnCompleted(Action continuation) => OnCompleted(continuation); + + /// + /// Marks the operation as complete - this should be invoked whenever a SocketAsyncEventArgs operation returns false. + /// + public void Complete() => OnCompleted(this); + + private static void RunOnThreadPool(Action action) + => ThreadPool.QueueUserWorkItem(static state => ((Action)state).Invoke(), action); + + /// + /// Invoked automatically when an operation completes asynchronously. + /// + protected override void OnCompleted(SocketAsyncEventArgs e) + { + var continuation = Interlocked.Exchange(ref _callback, _callbackCompleted); + if (continuation is not null) + { + // continue on the thread-pool + RunOnThreadPool(continuation); + } + } + } +} +#endif diff --git a/src/StackExchange.Redis/APITypes/LatencyHistoryEntry.cs b/src/StackExchange.Redis/APITypes/LatencyHistoryEntry.cs index 003708e6a..0daa00377 100644 --- a/src/StackExchange.Redis/APITypes/LatencyHistoryEntry.cs +++ b/src/StackExchange.Redis/APITypes/LatencyHistoryEntry.cs @@ -1,4 +1,5 @@ using System; +using RESPite.Messages; namespace StackExchange.Redis; @@ -11,18 +12,14 @@ public readonly struct LatencyHistoryEntry private sealed class Processor : ArrayResultProcessor { - protected override bool TryParse(in RawResult raw, out LatencyHistoryEntry parsed) + protected override bool TryParse(ref RespReader reader, out LatencyHistoryEntry parsed) { - if (raw.Resp2TypeArray == ResultType.Array) + if (reader.IsAggregate + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var timestamp) + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var duration)) { - var items = raw.GetItems(); - if (items.Length >= 2 - && items[0].TryGetInt64(out var timestamp) - && items[1].TryGetInt64(out var duration)) - { - parsed = new LatencyHistoryEntry(timestamp, duration); - return true; - } + parsed = new LatencyHistoryEntry(timestamp, duration); + return true; } parsed = default; return false; diff --git a/src/StackExchange.Redis/APITypes/LatencyLatestEntry.cs b/src/StackExchange.Redis/APITypes/LatencyLatestEntry.cs index d1bc70e42..c1f012495 100644 --- a/src/StackExchange.Redis/APITypes/LatencyLatestEntry.cs +++ b/src/StackExchange.Redis/APITypes/LatencyLatestEntry.cs @@ -1,4 +1,5 @@ using System; +using RESPite.Messages; namespace StackExchange.Redis; @@ -11,17 +12,17 @@ public readonly struct LatencyLatestEntry private sealed class Processor : ArrayResultProcessor { - protected override bool TryParse(in RawResult raw, out LatencyLatestEntry parsed) + protected override bool TryParse(ref RespReader reader, out LatencyLatestEntry parsed) { - if (raw.Resp2TypeArray == ResultType.Array) + if (reader.IsAggregate && reader.TryMoveNext() && reader.IsScalar) { - var items = raw.GetItems(); - if (items.Length >= 4 - && items[1].TryGetInt64(out var timestamp) - && items[2].TryGetInt64(out var duration) - && items[3].TryGetInt64(out var maxDuration)) + var eventName = reader.ReadString()!; + + if (reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var timestamp) + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var duration) + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var maxDuration)) { - parsed = new LatencyLatestEntry(items[0].GetString()!, timestamp, duration, maxDuration); + parsed = new LatencyLatestEntry(eventName, timestamp, duration, maxDuration); return true; } } diff --git a/src/StackExchange.Redis/ArrayGrepRequest.cs b/src/StackExchange.Redis/ArrayGrepRequest.cs index 642f6a060..5fd7b0dd2 100644 --- a/src/StackExchange.Redis/ArrayGrepRequest.cs +++ b/src/StackExchange.Redis/ArrayGrepRequest.cs @@ -253,7 +253,7 @@ internal Message CreateMessage(int db, RedisKey key, CommandFlags flags) public abstract class Predicate { internal virtual int ArgCount => 2; - internal abstract void WriteTo(PhysicalConnection physical); + internal abstract void WriteTo(in MessageWriter writer); private protected Predicate() { } /// @@ -288,10 +288,10 @@ private sealed class ExactPredicate(RedisValue value) : Predicate { public override string ToString() => $"EXACT '{value}'"; - internal override void WriteTo(PhysicalConnection physical) + internal override void WriteTo(in MessageWriter writer) { - physical.WriteRaw("$5\r\nEXACT\r\n"u8); - physical.WriteBulkString(value); + writer.WriteRaw("$5\r\nEXACT\r\n"u8); + writer.WriteBulkString(value); } } @@ -299,10 +299,10 @@ private sealed class MatchPredicate(string pattern) : Predicate { public override string ToString() => $"MATCH '{pattern}'"; - internal override void WriteTo(PhysicalConnection physical) + internal override void WriteTo(in MessageWriter writer) { - physical.WriteRaw("$5\r\nMATCH\r\n"u8); - physical.WriteBulkString(pattern); + writer.WriteRaw("$5\r\nMATCH\r\n"u8); + writer.WriteBulkString(pattern); } } @@ -310,10 +310,10 @@ private sealed class GlobPredicate(string pattern) : Predicate { public override string ToString() => $"GLOB '{pattern}'"; - internal override void WriteTo(PhysicalConnection physical) + internal override void WriteTo(in MessageWriter writer) { - physical.WriteRaw("$4\r\nGLOB\r\n"u8); - physical.WriteBulkString(pattern); + writer.WriteRaw("$4\r\nGLOB\r\n"u8); + writer.WriteBulkString(pattern); } } @@ -321,10 +321,10 @@ private sealed class RegexPredicate(string re) : Predicate { public override string ToString() => $"RE '{re}'"; - internal override void WriteTo(PhysicalConnection physical) + internal override void WriteTo(in MessageWriter writer) { - physical.WriteRaw("$2\r\nRE\r\n"u8); - physical.WriteBulkString(re); + writer.WriteRaw("$2\r\nRE\r\n"u8); + writer.WriteBulkString(re); } } } @@ -352,45 +352,46 @@ public override int ArgCount } } - private static void AddIndex(PhysicalConnection physical, RedisArrayIndex? index, ReadOnlySpan fallback) + private static void AddIndex(in MessageWriter writer, RedisArrayIndex? index, ReadOnlySpan fallback) { if (index.HasValue) { - physical.WriteBulkString(index.GetValueOrDefault().Value); + writer.WriteBulkString(index.GetValueOrDefault().Value); } else { - physical.WriteRaw(fallback); + writer.WriteRaw(fallback); } } - protected override void WriteImpl(PhysicalConnection physical) + + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.WriteBulkString(key); + writer.WriteHeader(Command, ArgCount); + writer.WriteBulkString(key); if (request.IsReversed) { - AddIndex(physical, request.End, "$1\r\n+\r\n"u8); - AddIndex(physical, request.Start, "$1\r\n-\r\n"u8); + AddIndex(writer, request.End, "$1\r\n+\r\n"u8); + AddIndex(writer, request.Start, "$1\r\n-\r\n"u8); } else { - AddIndex(physical, request.Start, "$1\r\n-\r\n"u8); - AddIndex(physical, request.End, "$1\r\n+\r\n"u8); + AddIndex(writer, request.Start, "$1\r\n-\r\n"u8); + AddIndex(writer, request.End, "$1\r\n+\r\n"u8); } var pCount = request.Count; for (int i = 0; i < pCount; i++) { - request[i].WriteTo(physical); + request[i].WriteTo(in writer); } - if (request.IsIntersection) physical.WriteRaw("$3\r\nAND\r\n"u8); - if (request.IsCaseInsensitive) physical.WriteRaw("$6\r\nNOCASE\r\n"u8); - if (request.IncludeValues) physical.WriteRaw("$10\r\nWITHVALUES\r\n"u8); + if (request.IsIntersection) writer.WriteRaw("$3\r\nAND\r\n"u8); + if (request.IsCaseInsensitive) writer.WriteRaw("$6\r\nNOCASE\r\n"u8); + if (request.IncludeValues) writer.WriteRaw("$10\r\nWITHVALUES\r\n"u8); var limit = request.Limit; if (limit.HasValue) { - physical.WriteRaw("$5\r\nLIMIT\r\n"u8); - physical.WriteBulkString(limit.GetValueOrDefault()); + writer.WriteRaw("$5\r\nLIMIT\r\n"u8); + writer.WriteBulkString(limit.GetValueOrDefault()); } } } diff --git a/src/StackExchange.Redis/AwaitableMutex.cs b/src/StackExchange.Redis/AwaitableMutex.cs new file mode 100644 index 000000000..9bc054804 --- /dev/null +++ b/src/StackExchange.Redis/AwaitableMutex.cs @@ -0,0 +1,22 @@ +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace StackExchange.Redis; + +// abstract over the concept of awaiable mutex between platforms +internal readonly partial struct AwaitableMutex : IDisposable +{ + // ReSharper disable once ConvertToAutoProperty + public partial int TimeoutMilliseconds { get; } + public static AwaitableMutex Create(int timeoutMilliseconds) => new(timeoutMilliseconds); + + // define the API first here (think .h file) + private partial AwaitableMutex(int timeoutMilliseconds); + public partial void Dispose(); + public partial bool IsAvailable { get; } + public partial bool TryTakeInstant(); + public partial ValueTask TryTakeAsync(CancellationToken cancellationToken = default); + public partial bool TryTakeSync(); + public partial void Release(); +} diff --git a/src/StackExchange.Redis/AwaitableMutex.net.cs b/src/StackExchange.Redis/AwaitableMutex.net.cs new file mode 100644 index 000000000..501b6af36 --- /dev/null +++ b/src/StackExchange.Redis/AwaitableMutex.net.cs @@ -0,0 +1,36 @@ +using System.Threading; +using System.Threading.Tasks; + +#if NET +namespace StackExchange.Redis; + +internal partial struct AwaitableMutex +{ + private readonly int _timeoutMilliseconds; + + // note: this does not guarantee "fairness", but that's OK for our use-case - we mostly just want + // a sync+async awaitable mutex, which this does; the .NET Framework version has a hand-written + // implementation (see .netfx.cx for reasons), which *is* fair, but we'd rather not pay that overhead + // here. Good-enough-is. + private readonly SemaphoreSlim _mutex; + + private partial AwaitableMutex(int timeoutMilliseconds) + { + _timeoutMilliseconds = timeoutMilliseconds; + _mutex = new(1, 1); + } + + public partial void Dispose() => _mutex?.Dispose(); + public partial bool IsAvailable => _mutex.CurrentCount != 0; + public partial int TimeoutMilliseconds => _timeoutMilliseconds; + + public partial bool TryTakeInstant() => _mutex.Wait(0); + + public partial ValueTask TryTakeAsync(CancellationToken cancellationToken) + => new(_mutex.WaitAsync(_timeoutMilliseconds, cancellationToken)); + + public partial bool TryTakeSync() => _mutex.Wait(_timeoutMilliseconds); + + public partial void Release() => _mutex.Release(); +} +#endif diff --git a/src/StackExchange.Redis/AwaitableMutex.netfx.cs b/src/StackExchange.Redis/AwaitableMutex.netfx.cs new file mode 100644 index 000000000..7267f8043 --- /dev/null +++ b/src/StackExchange.Redis/AwaitableMutex.netfx.cs @@ -0,0 +1,389 @@ +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +#if !NET +namespace StackExchange.Redis; + +/* +Compensating for the fact that netfx SemaphoreSlim is kinda janky (https://blog.marcgravell.com/2019/02/fun-with-spiral-of-death.html). + +This uses a simple queue of sync/async callers, and assumes a reasonable caller (the original MutexSlim is more defensive, as +a general purpose public API). +*/ + +internal partial struct AwaitableMutex +{ + private readonly State _state; + + private partial AwaitableMutex(int timeoutMilliseconds) + { + _state = new(timeoutMilliseconds); + } + + public partial void Dispose() => _state?.Dispose(); + + public partial bool IsAvailable => _state.IsAvailable; + public partial int TimeoutMilliseconds => _state.TimeoutMilliseconds; + + public partial bool TryTakeInstant() => _state.TryTakeInstant(); + + public partial ValueTask TryTakeAsync(CancellationToken cancellationToken) + => _state.TryTakeAsync(cancellationToken); + + public partial bool TryTakeSync() => _state.TryTakeSync(); + + public partial void Release() => _state.Release(); + + private sealed class State : IDisposable + { + private readonly Queue _queue = new(); + private bool _isHeld; + private bool _isDisposed; + + public State(int timeoutMilliseconds) + { + if (timeoutMilliseconds < Timeout.Infinite) ThrowOutOfRangeException(); + TimeoutMilliseconds = timeoutMilliseconds; + + static void ThrowOutOfRangeException() => throw new ArgumentOutOfRangeException(nameof(timeoutMilliseconds)); + } + + public int TimeoutMilliseconds { get; } + + public bool IsAvailable + { + get + { + lock (_queue) + { + return !_isDisposed && !_isHeld && _queue.Count == 0; + } + } + } + + public bool TryTakeInstant() + { + bool lockTaken = false; + try + { + Monitor.TryEnter(_queue, 0, ref lockTaken); + if (!lockTaken) return false; + + return TryTakeInsideLock(); + } + finally + { + if (lockTaken) Monitor.Exit(_queue); + } + } + + public bool TryTakeSync() + { + bool lockTaken = false; + try + { + // try to acquire uncontested lock - that way we can avoid checking the time + Monitor.TryEnter(_queue, 0, ref lockTaken); + if (lockTaken && TryTakeInsideLock()) return true; + } + finally + { + if (lockTaken) Monitor.Exit(_queue); + } + + return TryTakeSyncSlow(); + } + + public ValueTask TryTakeAsync(CancellationToken cancellationToken) + { + bool lockTaken = false; + try + { + // try to acquire uncontested lock - that way we can avoid allocating the pending caller + Monitor.TryEnter(_queue, 0, ref lockTaken); + if (lockTaken) + { + if (_isDisposed) return DisposedAsync(); + if (cancellationToken.IsCancellationRequested) + { + return CanceledAsync(cancellationToken); + } + + if (TryTakeInsideLockCore()) return new ValueTask(true); + } + } + finally + { + if (lockTaken) Monitor.Exit(_queue); + } + + return TryTakeAsyncSlow(cancellationToken); + } + + private ValueTask TryTakeAsyncSlow(CancellationToken cancellationToken) + { + lock (_queue) + { + if (_isDisposed) return DisposedAsync(); + if (cancellationToken.IsCancellationRequested) + { + return CanceledAsync(cancellationToken); + } + + if (TryTakeInsideLockCore()) return new ValueTask(true); + if (TimeoutMilliseconds == 0) return new ValueTask(false); + if (cancellationToken.IsCancellationRequested) return CanceledAsync(cancellationToken); + + var pending = new AsyncPendingCaller(TimeoutMilliseconds, cancellationToken); + _queue.Enqueue(pending); + return new ValueTask(pending.Task); + } + } + + public void Release() + { + lock (_queue) + { + ThrowIfDisposed(); + if (!_isHeld) ThrowNotHeld(); + + while (_queue.Count != 0) + { + if (_queue.Dequeue().TryGrant()) return; + } + + _isHeld = false; + } + + static void ThrowNotHeld() => throw new SemaphoreFullException(); + } + + private bool TryTakeInsideLock() + { + ThrowIfDisposed(); + return TryTakeInsideLockCore(); + } + + private bool TryTakeInsideLockCore() + { + if (_isHeld || _queue.Count != 0) return false; + _isHeld = true; + return true; + } + + private bool TryTakeSyncSlow() + { + if (TimeoutMilliseconds == 0) return false; + + var start = GetTime(); + SyncPendingCaller? pending = null; + bool lockTaken = false; + try + { + Monitor.TryEnter(_queue, TimeoutMilliseconds, ref lockTaken); + if (!lockTaken) return false; + if (TryTakeInsideLock()) return true; + + var remaining = GetRemainingTimeout(start, TimeoutMilliseconds); + if (remaining == 0) return false; + + pending = new SyncPendingCaller(start, TimeoutMilliseconds); + _queue.Enqueue(pending); + } + finally + { + if (lockTaken) Monitor.Exit(_queue); + } + + return pending!.Wait(); + } + + public void Dispose() + { + if (_isDisposed) return; + _isDisposed = true; + + lock (_queue) + { + _isHeld = false; + while (_queue.Count != 0) + { + _queue.Dequeue().Abort(); + } + } + } + + private void ThrowIfDisposed() + { + if (_isDisposed) ThrowDisposed(); + } + + private static void ThrowDisposed() => throw new ObjectDisposedException(nameof(AwaitableMutex)); + + private static ValueTask DisposedAsync() + => new(Task.FromException(new ObjectDisposedException(nameof(AwaitableMutex)))); + + private static ValueTask CanceledAsync(CancellationToken cancellationToken) + => new(Task.FromCanceled(cancellationToken)); + + private static uint GetTime() => (uint)Environment.TickCount; + + private static int GetRemainingTimeout(uint startTime, int originalTimeoutMilliseconds) + { + if (originalTimeoutMilliseconds == Timeout.Infinite) return Timeout.Infinite; + + var elapsedMilliseconds = GetTime() - startTime; + if (elapsedMilliseconds > int.MaxValue) return 0; + + var remaining = originalTimeoutMilliseconds - (int)elapsedMilliseconds; + return remaining <= 0 ? 0 : remaining; + } + + private interface IPendingCaller + { + bool TryGrant(); + void Abort(); + } + + private sealed class SyncPendingCaller : IPendingCaller + { + private readonly uint _start; + private readonly int _timeoutMilliseconds; + private bool _isComplete; + private bool _wasGranted; + private bool _wasAborted; + + public SyncPendingCaller(uint start, int timeoutMilliseconds) + { + _start = start; + _timeoutMilliseconds = timeoutMilliseconds; + } + + public bool Wait() + { + lock (this) + { + while (!_isComplete) + { + var remaining = GetRemainingTimeout(_start, _timeoutMilliseconds); + if (remaining == 0) + { + _isComplete = true; + return false; + } + + if (remaining == Timeout.Infinite) + { + Monitor.Wait(this); + } + else + { + Monitor.Wait(this, remaining); + } + } + + if (_wasAborted) ThrowDisposed(); + return _wasGranted; + } + } + + public bool TryGrant() + { + lock (this) + { + if (_isComplete) return false; + _wasGranted = true; + _isComplete = true; + Monitor.Pulse(this); + return true; + } + } + + public void Abort() + { + lock (this) + { + if (_isComplete) return; + _wasAborted = true; + _isComplete = true; + Monitor.Pulse(this); + } + } + } + + private sealed class AsyncPendingCaller : TaskCompletionSource, IPendingCaller + { + private static readonly TimerCallback s_onTimeout = state => ((AsyncPendingCaller)state!).TryComplete(CompletionState.TimedOut); + private static readonly Action s_onCanceled = state => ((AsyncPendingCaller)state!).TryComplete(CompletionState.Canceled); + + private readonly CancellationToken _cancellationToken; + private readonly CancellationTokenRegistration _cancellation; + private readonly Timer? _timeout; + private int _completionState; + + public AsyncPendingCaller(int timeoutMilliseconds, CancellationToken cancellationToken) + : base(TaskCreationOptions.RunContinuationsAsynchronously) + { + _cancellationToken = cancellationToken; + if (timeoutMilliseconds != Timeout.Infinite) + { + _timeout = new Timer(s_onTimeout, this, timeoutMilliseconds, Timeout.Infinite); + } + + if (cancellationToken.CanBeCanceled) + { + _cancellation = cancellationToken.Register(s_onCanceled, this); + } + } + + public bool TryGrant() => TryComplete(CompletionState.Granted); + + public void Abort() => TryComplete(CompletionState.Disposed); + + private bool TryComplete(CompletionState completionState) + { + var newState = (int)completionState; + if (Interlocked.CompareExchange(ref _completionState, newState, (int)CompletionState.Pending) != (int)CompletionState.Pending) + { + return false; + } + + if (completionState != CompletionState.TimedOut) _timeout?.Dispose(); + if (completionState != CompletionState.Canceled) _cancellation.Dispose(); + Complete(completionState); + return true; + } + + private void Complete(CompletionState completionState) + { + switch (completionState) + { + case CompletionState.Granted: + TrySetResult(true); + break; + case CompletionState.TimedOut: + TrySetResult(false); + break; + case CompletionState.Canceled: + TrySetCanceled(_cancellationToken); + break; + case CompletionState.Disposed: + TrySetException(new ObjectDisposedException(nameof(AwaitableMutex))); + break; + } + } + + private enum CompletionState + { + Pending = 0, + Granted = 1, + TimedOut = 2, + Canceled = 3, + Disposed = 4, + } + } + } +} +#endif diff --git a/src/StackExchange.Redis/BufferedStreamWriter.Async.cs b/src/StackExchange.Redis/BufferedStreamWriter.Async.cs new file mode 100644 index 000000000..58d54be47 --- /dev/null +++ b/src/StackExchange.Redis/BufferedStreamWriter.Async.cs @@ -0,0 +1,158 @@ +using System; +using System.IO; +using System.Threading; +using System.Threading.Tasks; +using System.Threading.Tasks.Sources; + +namespace StackExchange.Redis; + +internal sealed class BufferedAsyncStreamWriter : CycleBufferStreamWriter, IValueTaskSource +{ + private ManualResetValueTaskSourceCore _readerTask; + + public BufferedAsyncStreamWriter(Stream target, CancellationToken cancellationToken = default) + : base(target, cancellationToken) + { + WriteComplete = Task.Run(CopyOutAsync, cancellationToken); + _readerTask.RunContinuationsAsynchronously = true; // we never want the flusher to take over the copying + } + + public override Task WriteComplete { get; } + + private async Task CopyOutAsync() + { + bool lockTaken = false; + try + { + while (true) + { + ValueTask pending = AwaitWake(); + if (!pending.IsCompleted) + { + TakeLock(ref lockTaken); + // double-checked marking inactive + if (!pending.IsCompleted) RemoveStateFlagInsideLock(StateFlags.ActiveWriter); + ReleaseLock(ref lockTaken); + } + // await activation and check status; + await pending.ConfigureAwait(false); + + StateFlags stateFlags; + while (true) + { + ReadOnlyMemory memory; + TakeLock(ref lockTaken); + stateFlags = State; + var minBytes = (stateFlags & StateFlags.Flush) == 0 ? -1 : 1; + if (!GetFirstChunkInsideLock(minBytes, out memory)) + { + // out of data; remove flush flag and wait for more work + RemoveStateFlagInsideLock(StateFlags.Flush | StateFlags.ActiveWriter); + stateFlags = State; + ReleaseLock(ref lockTaken); + break; + } + ReleaseLock(ref lockTaken); + + if (IsFaulted) ThrowCompleteOrFaulted(); // this is cheap to check ongoing + if (!memory.IsEmpty) + { + OnWritten(memory.Length); + OnDebugBufferLog(memory); + + await Target.WriteAsync(memory, CancellationToken).ConfigureAwait(false); + } + + TakeLock(ref lockTaken); + DiscardCommitted(memory.Length); + ReleaseLock(ref lockTaken); + } + await Target.FlushAsync(CancellationToken).ConfigureAwait(false); + + if ((stateFlags & StateFlags.Closed) != 0) break; + } + + // recycle on clean exit (only), since we know the buffers aren't being used + TakeLock(ref lockTaken); + ReleaseBuffer(); + ReleaseLock(ref lockTaken); + } + catch (Exception ex) + { + Complete(ex); + throw; // ensure visible via WriteComplete + } + finally + { + ReleaseLock(ref lockTaken); + } + // note we do *not* close the stream here - we have to settle for flushing; Close is explicit + } + + private ValueTask AwaitWake() + { + bool lockTaken = false; + try + { + TakeLock(ref lockTaken); // guard all transitions + return new(this, _readerTask.Version); + } + finally + { + ReleaseLock(ref lockTaken); + } + } + + void IValueTaskSource.GetResult(short token) + { + bool lockTaken = false; + try + { + TakeLock(ref lockTaken); // guard all transitions + _readerTask.GetResult(token); // may throw, note + _readerTask.Reset(); + } + finally + { + ReleaseLock(ref lockTaken); + } + } + + ValueTaskSourceStatus IValueTaskSource.GetStatus(short token) + { + bool lockTaken = false; + try + { + TakeLock(ref lockTaken); // guard all transitions + return _readerTask.GetStatus(token); + } + finally + { + ReleaseLock(ref lockTaken); + } + } + + void IValueTaskSource.OnCompleted( + Action continuation, + object? state, + short token, + ValueTaskSourceOnCompletedFlags flags) + { + bool lockTaken = false; + try + { + TakeLock(ref lockTaken); // guard all transitions + _readerTask.OnCompleted(continuation, state, token, flags); + } + finally + { + ReleaseLock(ref lockTaken); + } + } + + protected override void OnWakeReaderInsideLock() + { + System.Diagnostics.Debug.Assert(Monitor.IsEntered(this), $"{nameof(OnWakeReaderInsideLock)} must be called while holding the writer lock."); + _readerTask.SetResult(true); + } +} diff --git a/src/StackExchange.Redis/BufferedStreamWriter.Pipe.cs b/src/StackExchange.Redis/BufferedStreamWriter.Pipe.cs new file mode 100644 index 000000000..50ad143b0 --- /dev/null +++ b/src/StackExchange.Redis/BufferedStreamWriter.Pipe.cs @@ -0,0 +1,66 @@ +using System; +using System.IO; +using System.IO.Pipelines; +using System.Threading; +using System.Threading.Tasks; + +namespace StackExchange.Redis; + +internal sealed class PipeStreamWriter : BufferedStreamWriter +{ + private readonly PipeWriter _writer; + + public PipeStreamWriter(Stream target, CancellationToken cancellationToken = default) + : base(target, cancellationToken) + { + var pipe = new Pipe(); + _writer = pipe.Writer; + WriteComplete = CopyToAsync(pipe.Reader, pipe.Writer, Target, cancellationToken); + } + + public override Task WriteComplete { get; } + + private static async Task CopyToAsync(PipeReader reader, PipeWriter writer, Stream target, CancellationToken cancellationToken) + { + try + { + await reader.CopyToAsync(target, cancellationToken).ConfigureAwait(false); + } + catch (Exception ex) + { + writer.Complete(ex); + throw; + } + } + + private long _nonFlushed; + public override void Advance(int count) + { + _nonFlushed += count; + _writer.Advance(count); + } + + public override void Flush() + { + var tmp = _nonFlushed; + _nonFlushed = 0; + OnWritten(tmp); + var pending = _writer.FlushAsync(); + if (pending.IsCompleted) + { + pending.GetAwaiter().GetResult(); + } + else + { + // this is bad, but: this type is a temporary kludge while I fix a bug; + // this only happens during back-pressure events, which should be rare + pending.AsTask().Wait(CancellationToken); + } + } + + public override Memory GetMemory(int sizeHint = 0) => _writer.GetMemory(sizeHint); + + public override Span GetSpan(int sizeHint = 0) => _writer.GetSpan(sizeHint); + + public override void Complete(Exception? exception = null) => _writer.Complete(exception); +} diff --git a/src/StackExchange.Redis/BufferedStreamWriter.Sync.cs b/src/StackExchange.Redis/BufferedStreamWriter.Sync.cs new file mode 100644 index 000000000..b9a72d169 --- /dev/null +++ b/src/StackExchange.Redis/BufferedStreamWriter.Sync.cs @@ -0,0 +1,114 @@ +using System; +using System.IO; +using System.Threading; +using System.Threading.Tasks; + +namespace StackExchange.Redis; + +internal sealed class BufferedSyncStreamWriter : CycleBufferStreamWriter +{ + public override bool IsSync => true; + + private readonly TaskCompletionSource _completion = new(TaskCreationOptions.RunContinuationsAsynchronously); + + public BufferedSyncStreamWriter(Stream target, CancellationToken cancellationToken = default) + : base(target, cancellationToken) + { + Thread thread = new Thread(static s => ((BufferedSyncStreamWriter)s!).CopyOutSync()) + { + IsBackground = true, + Priority = ThreadPriority.AboveNormal, + Name = "SE.Redis Sync Writer", + }; + thread.Start(this); + } + + public override Task WriteComplete => _completion.Task; + + private bool _signalled; + + private void CopyOutSync() + { + bool lockTaken = false; + try + { + while (true) + { + CancellationToken.ThrowIfCancellationRequested(); + TakeLock(ref lockTaken); + if (!_signalled) + { + RemoveStateFlagInsideLock(StateFlags.ActiveWriter); + // even if not pulsed, wake periodically to check for hard exit + Monitor.Wait(this, 10_000); + CancellationToken.ThrowIfCancellationRequested(); + } + _signalled = false; + ReleaseLock(ref lockTaken); + + StateFlags stateFlags; + while (true) + { + ReadOnlyMemory memory; + TakeLock(ref lockTaken); + stateFlags = State; + var minBytes = (stateFlags & StateFlags.Flush) == 0 ? -1 : 1; + if (!GetFirstChunkInsideLock(minBytes, out memory)) + { + // out of data; remove flush flag and wait for more work + RemoveStateFlagInsideLock(StateFlags.Flush | StateFlags.ActiveWriter); + stateFlags = State; + ReleaseLock(ref lockTaken); + break; + } + ReleaseLock(ref lockTaken); + + if (IsFaulted) ThrowCompleteOrFaulted(); // this is cheap to check ongoing + if (!memory.IsEmpty) + { + OnWritten(memory.Length); + OnDebugBufferLog(memory); + +#if NET + Target.Write(memory.Span); +#else + Target.Write(memory); +#endif + } + + TakeLock(ref lockTaken); + DiscardCommitted(memory.Length); + ReleaseLock(ref lockTaken); + } + + Target.Flush(); + + if ((stateFlags & StateFlags.Closed) != 0) break; + } + + // recycle on clean exit (only), since we know the buffers aren't being used + TakeLock(ref lockTaken); + ReleaseBuffer(); + ReleaseLock(ref lockTaken); + + _completion.TrySetResult(true); + } + catch (Exception ex) + { + Complete(ex); + _completion.TrySetException(ex); + } + finally + { + ReleaseLock(ref lockTaken); + } + // note we do *not* close the stream here - we have to settle for flushing; Close is explicit + } + + protected override void OnWakeReaderInsideLock() + { + System.Diagnostics.Debug.Assert(Monitor.IsEntered(this), $"{nameof(OnWakeReaderInsideLock)} must be called while holding the writer lock."); + _signalled = true; + Monitor.Pulse(this); + } +} diff --git a/src/StackExchange.Redis/BufferedStreamWriter.cs b/src/StackExchange.Redis/BufferedStreamWriter.cs new file mode 100644 index 000000000..a60b8cab3 --- /dev/null +++ b/src/StackExchange.Redis/BufferedStreamWriter.cs @@ -0,0 +1,315 @@ +using System; +using System.Buffers; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.IO; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using RESPite.Buffers; + +namespace StackExchange.Redis; + +internal abstract class BufferedStreamWriter(Stream target, CancellationToken cancellationToken) + : IBufferWriter, IDisposable, IAsyncDisposable +{ + /* What is this? + * + * Basically, an abstraction similar to Pipe - it has a separate write and read head, etc, but + * the key difference is that it is focused on reducing context switches: + * + * - explicit flush is *synchronous*, simply marking the tail buffer as "ready to read"; this is actually pretty + * similar to Pipe if we ignore back-pressure, which it kinda does by default + * - implicit flush is implicit - i.e. when committed work fills a page, that page is flushed automatically + * - the consumption API allows fully synchronous consumption, if desired + * + * At the moment, 3 concrete implementations are provided: + * - BufferedAsyncStreamWriter: uses the thread-pool and async I/O to copy data to the target stream + * - BufferedSyncStreamWriter: uses a dedicated thread to copy data to the target stream using sync IO + * - PipeStreamWriter: uses the pre-existing Pipe API and pre-built PipeWriter.CopyTo(Stream) + * + * The intention is that: + * - pub/sub always uses BufferedAsyncStreamWriter + * - interactive uses BufferedSyncStreamWriter in low-connection-count scenarios, + * and BufferedAsyncStreamWriter in high-connection-count scenarios (there's some missing work here in + * tracking the count and transitioning from sync to async as we cross some threshold) + * + * So why the Pipe version? and why not *just* use Pipe? The custom sync/async versions out-perform Pipe, but + * there's a dangling bug where occasionally it will stall - presumably some edge-case where the wake logic + * is borked. When I debug that, I'll make the other versions the defaults, but for now: Pipe is the default, + * with the others only available to me for testing. + * + * Threading model: this type assumes a single producer/writer and a single + * consumer/reader. The monitor protects the non-thread-safe CycleBuffer and + * shared state transitions between those two roles; it is not intended to + * support multiple concurrent producers. + */ + + public enum WriteMode + { + Default, + Sync, + Async, + Pipe, + } + + public virtual bool IsSync => false; + + public static BufferedStreamWriter Create(WriteMode mode, ConnectionType connectionType, Stream target, CancellationToken cancellationToken) + { + if (connectionType is ConnectionType.Subscription | mode is WriteMode.Default) + { + // sync-mode targets latency; pub/sub never needs that; + // default write-mode should use async + mode = WriteMode.Async; + } + return mode switch + { + WriteMode.Sync => new BufferedSyncStreamWriter(target, cancellationToken), + WriteMode.Async => new BufferedAsyncStreamWriter(target, cancellationToken), + WriteMode.Pipe => new PipeStreamWriter(target, cancellationToken), + _ => throw new ArgumentOutOfRangeException(nameof(mode)), + }; + } + + // ReSharper disable once ReplaceWithFieldKeyword + private readonly CancellationToken _cancellationToken = cancellationToken; + protected ref readonly CancellationToken CancellationToken => ref _cancellationToken; + protected Stream Target { get; } = target; + + public abstract Task WriteComplete { get; } + + protected void OnWritten(long count) => _totalBytesWritten += count; // single-writer; this is fine + protected void OnWritten(int count) => _totalBytesWritten += count; // single-writer; this is fine + private long _totalBytesWritten; + public long TotalBytesWritten => Volatile.Read(ref _totalBytesWritten); + + public abstract void Complete(Exception? exception = null); + public void Dispose() => Target.Dispose(); + + public ValueTask DisposeAsync() + { + if (Target is IAsyncDisposable asyncDisposable) + { + return asyncDisposable.DisposeAsync(); + } + Target.Dispose(); + return default; + } + + public abstract void Advance(int count); + + public abstract Memory GetMemory(int sizeHint = 0); + + public abstract Span GetSpan(int sizeHint = 0); + + [Conditional("DEBUG")] + public virtual void DebugSetLog(Action log) { } + + public abstract void Flush(); +} + +internal abstract class CycleBufferStreamWriter : BufferedStreamWriter, ICycleBufferCallback +{ + protected CycleBufferStreamWriter(Stream target, CancellationToken cancellationToken) + : base(target, cancellationToken) + { + _buffer = CycleBuffer.Create(callback: this); + } + + private CycleBuffer _buffer; + private StateFlags _stateFlags; + private Exception? _exception; + + protected bool IsFaulted => Volatile.Read(ref _exception) is not null; + + [Flags] + internal enum StateFlags + { + None = 0, + Flush = 1 << 0, // allow reading incomplete pages + ActiveWriter = 1 << 1, + Closed = 1 << 2, + } + + protected bool GetFirstChunkInsideLock(int minBytes, out ReadOnlyMemory memory) + { + Debug.Assert(Monitor.IsEntered(this), $"{nameof(GetFirstChunkInsideLock)} must be called while holding the writer lock."); + return _buffer.TryGetFirstCommittedMemory(minBytes, out memory); + } + + protected void ReleaseBuffer() => _buffer.Release(); + + protected void DiscardCommitted(int count) => _buffer.DiscardCommitted(count); + + /// + /// Activate the writer if necessary, but only consume complete pages. + /// + void ICycleBufferCallback.PageComplete() => OnActivate(StateFlags.None); + + /// + /// Activate the writer if necessary, and indicate that all committed data can be consumed, even incomplete pages. + /// + public override void Flush() => OnActivate(StateFlags.Flush); + + public override void Complete(Exception? exception = null) + { + if (exception is not null) Interlocked.CompareExchange(ref _exception, exception, null); + OnActivate(StateFlags.Flush | StateFlags.Closed); + } + + private void OnActivate(StateFlags newFlags) + { + bool lockTaken = false; + try + { + TakeLock(ref lockTaken); + var state = _stateFlags; + if ((state & StateFlags.Closed) != 0) return; + state |= newFlags & ~StateFlags.ActiveWriter; + if ((state & StateFlags.ActiveWriter) == 0) + { + state |= StateFlags.ActiveWriter; + _stateFlags = state; + OnWakeReaderInsideLock(); + } + else + { + _stateFlags = state; + } + } + finally + { + ReleaseLock(ref lockTaken); + } + } + + protected abstract void OnWakeReaderInsideLock(); + + [Conditional("DEBUG")] + protected void OnDebugBufferLog(ReadOnlyMemory memory) + { +#if DEBUG + if (_log is not null) + { + const string CR = "\u240D", LF = "\u240A", CRLF = CR + LF; + string raw = Encoding.UTF8.GetString(memory.Span) + .Replace("\r\n", CRLF).Replace("\r", CR).Replace("\n", LF); + string s = $"{id}.{fragment++}: {raw}"; + OnDebugLog(s); + } +#endif + } + + protected void TakeLock(ref bool lockTaken) + { + if (!lockTaken) + { + Monitor.TryEnter(this, 10_000, ref lockTaken); + if (!lockTaken) Throw(); + } + static void Throw() => throw new TimeoutException("Unable to acquire writer lock"); + } + + protected void ReleaseLock(ref bool lockTaken) + { + if (lockTaken) + { + Monitor.Exit(this); + lockTaken = false; + } + } + + public override void Advance(int count) + { + bool lockTaken = false; + try + { + TakeLock(ref lockTaken); + ThrowIfComplete(); + _buffer.Commit(count); + } + finally + { + ReleaseLock(ref lockTaken); + } + } + + public override Memory GetMemory(int sizeHint = 0) + { + bool lockTaken = false; + try + { + TakeLock(ref lockTaken); + ThrowIfComplete(); + return _buffer.GetUncommittedMemory(sizeHint); + } + finally + { + ReleaseLock(ref lockTaken); + } + } + + public override Span GetSpan(int sizeHint = 0) + { + bool lockTaken = false; + try + { + TakeLock(ref lockTaken); + ThrowIfComplete(); + return _buffer.GetUncommittedSpan(sizeHint); + } + finally + { + ReleaseLock(ref lockTaken); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + protected void ThrowIfComplete() + { + // prevents a writer continuing to write to a dead pipe + if ((_stateFlags & StateFlags.Closed) != 0) ThrowCompleteOrFaulted(); + } + + [MethodImpl(MethodImplOptions.NoInlining), DoesNotReturn] + protected void ThrowCompleteOrFaulted() + { + var ex = Volatile.Read(ref _exception); + if (ex is null) throw new InvalidOperationException("Output has been completed successfully."); + throw new InvalidOperationException($"Output has been completed with fault: " + ex.Message, ex); + } + + internal StateFlags State => _stateFlags; + protected void RemoveStateFlagInsideLock(StateFlags flags) + { + Debug.Assert(Monitor.IsEntered(this), $"{nameof(RemoveStateFlagInsideLock)} must be called while holding the writer lock."); + _stateFlags &= ~flags; + } + +#if DEBUG + private readonly int id = Interlocked.Increment(ref s_id); + private int fragment; + private static int s_id; +#endif + + [Conditional("DEBUG")] + protected void OnDebugLog(string message) + { +#if DEBUG + // deliberately get away from the working thread + ThreadPool.QueueUserWorkItem(_ => _log?.Invoke(message)); +#endif + } + + public override void DebugSetLog(Action log) + { +#if DEBUG + _log = log; +#endif + } +#if DEBUG + private Action? _log; +#endif +} diff --git a/src/StackExchange.Redis/ChannelMessageQueue.cs b/src/StackExchange.Redis/ChannelMessageQueue.cs index 65cd170b9..7defc35cc 100644 --- a/src/StackExchange.Redis/ChannelMessageQueue.cs +++ b/src/StackExchange.Redis/ChannelMessageQueue.cs @@ -255,7 +255,7 @@ private async Task OnMessageAsyncImpl() try { var task = handler?.Invoke(next); - if (task != null && task.Status != TaskStatus.RanToCompletion) await task.ForAwait(); + if (task != null && !task.IsCompletedSuccessfully) await task.ForAwait(); } catch { } // matches MessageCompletable } diff --git a/src/StackExchange.Redis/ClientInfo.cs b/src/StackExchange.Redis/ClientInfo.cs index d743affff..511aee723 100644 --- a/src/StackExchange.Redis/ClientInfo.cs +++ b/src/StackExchange.Redis/ClientInfo.cs @@ -2,6 +2,7 @@ using System.Diagnostics.CodeAnalysis; using System.IO; using System.Net; +using RESPite.Messages; namespace StackExchange.Redis { @@ -289,18 +290,16 @@ private static void AddFlag(ref ClientFlags value, string raw, ClientFlags toAdd private sealed class ClientInfoProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.Prefix is RespPrefix.BulkString or RespPrefix.VerbatimString) { - case ResultType.BulkString: - var raw = result.GetString(); - if (TryParse(raw, out var clients)) - { - SetResult(message, clients); - return true; - } - break; + var raw = reader.ReadString(); + if (TryParse(raw, out var clients)) + { + SetResult(message, clients); + return true; + } } return false; } diff --git a/src/StackExchange.Redis/CommandBytes.cs b/src/StackExchange.Redis/CommandBytes.cs deleted file mode 100644 index 19a69549b..000000000 --- a/src/StackExchange.Redis/CommandBytes.cs +++ /dev/null @@ -1,207 +0,0 @@ -using System; -using System.Buffers; -using System.Text; - -namespace StackExchange.Redis -{ - internal readonly struct CommandBytes : IEquatable - { - private static Encoding Encoding => Encoding.UTF8; - - internal static unsafe CommandBytes TrimToFit(string value) - { - if (string.IsNullOrWhiteSpace(value)) return default; - value = value.Trim(); - var len = Encoding.GetByteCount(value); - if (len <= MaxLength) return new CommandBytes(value); // all fits - - fixed (char* c = value) - { - byte* b = stackalloc byte[ChunkLength * sizeof(ulong)]; - var encoder = PhysicalConnection.GetPerThreadEncoder(); - encoder.Convert(c, value.Length, b, MaxLength, true, out var maxLen, out _, out var isComplete); - if (!isComplete) maxLen--; - return new CommandBytes(value.Substring(0, maxLen)); - } - } - - // Uses [n=4] x UInt64 values to store a command payload, - // allowing allocation free storage and efficient - // equality tests. If you're glancing at this and thinking - // "that's what fixed buffers are for", please see: - // https://github.com/dotnet/coreclr/issues/19149 - // - // note: this tries to use case insensitive comparison - private readonly ulong _0, _1, _2, _3; - private const int ChunkLength = 4; // must reflect qty above - - public const int MaxLength = (ChunkLength * sizeof(ulong)) - 1; - - public override int GetHashCode() - { - var hashCode = -1923861349; - hashCode = (hashCode * -1521134295) + _0.GetHashCode(); - hashCode = (hashCode * -1521134295) + _1.GetHashCode(); - hashCode = (hashCode * -1521134295) + _2.GetHashCode(); - hashCode = (hashCode * -1521134295) + _3.GetHashCode(); - return hashCode; - } - - public override bool Equals(object? obj) => obj is CommandBytes cb && Equals(cb); - - bool IEquatable.Equals(CommandBytes other) => _0 == other._0 && _1 == other._1 && _2 == other._2 && _3 == other._3; - - public bool Equals(in CommandBytes other) => _0 == other._0 && _1 == other._1 && _2 == other._2 && _3 == other._3; - - // note: don't add == operators; with the implicit op above, that invalidates "==null" compiler checks (which should report a failure!) - public static implicit operator CommandBytes(string value) => new CommandBytes(value); - - public override unsafe string ToString() - { - fixed (ulong* uPtr = &_0) - { - var bPtr = (byte*)uPtr; - int len = *bPtr; - return len == 0 ? "" : Encoding.GetString(bPtr + 1, *bPtr); - } - } - public unsafe int Length - { - get - { - fixed (ulong* uPtr = &_0) - { - return *(byte*)uPtr; - } - } - } - - public bool IsEmpty => _0 == 0L; // cheap way of checking zero length - - public unsafe void CopyTo(Span target) - { - fixed (ulong* uPtr = &_0) - { - byte* bPtr = (byte*)uPtr; - new Span(bPtr + 1, *bPtr).CopyTo(target); - } - } - - public unsafe byte this[int index] - { - get - { - fixed (ulong* uPtr = &_0) - { - byte* bPtr = (byte*)uPtr; - int len = *bPtr; - if (index < 0 || index >= len) throw new IndexOutOfRangeException(); - return bPtr[index + 1]; - } - } - } - - public unsafe CommandBytes(string? value) - { - _0 = _1 = _2 = _3 = 0L; - if (value.IsNullOrEmpty()) return; - - var len = Encoding.GetByteCount(value); - if (len > MaxLength) throw new ArgumentOutOfRangeException($"Command '{value}' exceeds library limit of {MaxLength} bytes"); - fixed (ulong* uPtr = &_0) - { - byte* bPtr = (byte*)uPtr; - fixed (char* cPtr = value) - { - len = Encoding.GetBytes(cPtr, value.Length, bPtr + 1, MaxLength); - } - *bPtr = (byte)UpperCasify(len, bPtr + 1); - } - } - - public unsafe CommandBytes(ReadOnlySpan value) - { - if (value.Length > MaxLength) throw new ArgumentOutOfRangeException("Maximum command length exceeded: " + value.Length + " bytes"); - _0 = _1 = _2 = _3 = 0L; - fixed (ulong* uPtr = &_0) - { - byte* bPtr = (byte*)uPtr; - value.CopyTo(new Span(bPtr + 1, value.Length)); - *bPtr = (byte)UpperCasify(value.Length, bPtr + 1); - } - } - - public unsafe CommandBytes(in ReadOnlySequence value) - { - if (value.Length > MaxLength) throw new ArgumentOutOfRangeException(nameof(value), "Maximum command length exceeded"); - int len = unchecked((int)value.Length); - _0 = _1 = _2 = _3 = 0L; - fixed (ulong* uPtr = &_0) - { - byte* bPtr = (byte*)uPtr; - var target = new Span(bPtr + 1, len); - - if (value.IsSingleSegment) - { - value.First.Span.CopyTo(target); - } - else - { - foreach (var segment in value) - { - segment.Span.CopyTo(target); - target = target.Slice(segment.Length); - } - } - *bPtr = (byte)UpperCasify(len, bPtr + 1); - } - } - private unsafe int UpperCasify(int len, byte* bPtr) - { - const ulong HighBits = 0x8080808080808080; - if (((_0 | _1 | _2 | _3) & HighBits) == 0) - { - // no Unicode; use ASCII bit bricks - for (int i = 0; i < len; i++) - { - *bPtr = ToUpperInvariantAscii(*bPtr++); - } - return len; - } - else - { - return UpperCasifyUnicode(len, bPtr); - } - } - - private static unsafe int UpperCasifyUnicode(int oldLen, byte* bPtr) - { - const int MaxChars = ChunkLength * sizeof(ulong); // leave rounded up; helps stackalloc - char* workspace = stackalloc char[MaxChars]; - int charCount = Encoding.GetChars(bPtr, oldLen, workspace, MaxChars); - char* c = workspace; - for (int i = 0; i < charCount; i++) - { - *c = char.ToUpperInvariant(*c++); - } - int newLen = Encoding.GetBytes(workspace, charCount, bPtr, MaxLength); - // don't forget to zero any shrink - for (int i = newLen; i < oldLen; i++) - { - bPtr[i] = 0; - } - return newLen; - } - - private static byte ToUpperInvariantAscii(byte b) => b >= 'a' && b <= 'z' ? (byte)(b - 32) : b; - - internal unsafe byte[] ToArray() - { - fixed (ulong* uPtr = &_0) - { - byte* bPtr = (byte*)uPtr; - return new Span(bPtr + 1, *bPtr).ToArray(); - } - } - } -} diff --git a/src/StackExchange.Redis/CommandMap.cs b/src/StackExchange.Redis/CommandMap.cs index 683e51219..24a1aec97 100644 --- a/src/StackExchange.Redis/CommandMap.cs +++ b/src/StackExchange.Redis/CommandMap.cs @@ -1,6 +1,8 @@ using System; using System.Collections.Generic; +using System.Runtime.CompilerServices; using System.Text; +using RESPite; namespace StackExchange.Redis { @@ -10,8 +12,13 @@ namespace StackExchange.Redis public sealed class CommandMap { private readonly CommandBytes[] map; + private readonly byte[] bytes; - internal CommandMap(CommandBytes[] map) => this.map = map; + private CommandMap(CommandBytes[] map, byte[] bytes) + { + this.map = map; + this.bytes = bytes; + } /// /// The default commands specified by redis. @@ -132,7 +139,7 @@ public static CommandMap Create(HashSet commands, bool available = true) { var dictionary = new Dictionary(StringComparer.OrdinalIgnoreCase); // nix everything - foreach (RedisCommand command in (RedisCommand[])Enum.GetValues(typeof(RedisCommand))) + foreach (RedisCommand command in AllCommands) { dictionary[command.ToString()] = null; } @@ -154,7 +161,7 @@ public static CommandMap Create(HashSet commands, bool available = true) // nix the things that are specified foreach (var command in commands) { - if (Enum.TryParse(command, true, out RedisCommand parsed)) + if (RedisCommandMetadata.TryParseCI(command, out RedisCommand parsed)) { (exclusions ??= new HashSet()).Add(parsed); } @@ -177,63 +184,149 @@ public override string ToString() internal void AppendDeltas(StringBuilder sb) { + var all = AllCommands; for (int i = 0; i < map.Length; i++) { - var keyString = ((RedisCommand)i).ToString(); - var keyBytes = new CommandBytes(keyString); + var knownCmd = all[i]; + if (knownCmd is RedisCommand.UNKNOWN) continue; + var keyString = knownCmd.ToString(); var value = map[i]; - if (!keyBytes.Equals(value)) + var valueBytes = value.GetCommandBytes(bytes); + if (!AsciiHash.EqualsCI(keyString, valueBytes)) { if (sb.Length != 0) sb.Append(','); - sb.Append('$').Append(keyString).Append('=').Append(value); + sb.Append('$').Append(keyString).Append('='); + if (!valueBytes.IsEmpty) + { + sb.Append(Encoding.ASCII.GetString(valueBytes)); + } } } } internal void AssertAvailable(RedisCommand command) { - if (map[(int)command].IsEmpty) throw ExceptionFactory.CommandDisabled(command); + if (map[(int)command].IsEmpty) ThrowCommandDisabled(command); + + [MethodImpl(MethodImplOptions.NoInlining)] + static void ThrowCommandDisabled(RedisCommand command) => throw ExceptionFactory.CommandDisabled(command); } - internal CommandBytes GetBytes(RedisCommand command) => map[(int)command]; + internal ReadOnlySpan GetCommandBytes(RedisCommand command) => map[(int)command].GetCommandBytes(bytes); - internal CommandBytes GetBytes(string command) - { - if (command == null) return default; - if (Enum.TryParse(command, true, out RedisCommand cmd)) - { - // we know that one! - return map[(int)cmd]; - } - return new CommandBytes(command); - } + internal ReadOnlySpan GetResp(RedisCommand command) => map[(int)command].GetResp(bytes); internal bool IsAvailable(RedisCommand command) => !map[(int)command].IsEmpty; + private static RedisCommand[]? s_AllCommands; + + private static ReadOnlySpan AllCommands => s_AllCommands ??= (RedisCommand[])Enum.GetValues(typeof(RedisCommand)); + private static CommandMap CreateImpl(Dictionary? caseInsensitiveOverrides, HashSet? exclusions) { - var commands = (RedisCommand[])Enum.GetValues(typeof(RedisCommand)); + var commands = AllCommands; + int totalLength = 0; + for (int i = 0; i < commands.Length; i++) + { + var value = GetCommandValue(commands[i], caseInsensitiveOverrides, exclusions); + if (string.IsNullOrEmpty(value)) continue; + + totalLength += GetBulkStringLength(Encoding.ASCII.GetByteCount(value)); + } + + // Store all mapped command names as RESP bulk-string fragments in one buffer - everything is then + // ready to throw directly into the stream. var map = new CommandBytes[commands.Length]; + + // Currently (8.8-ish) this is approx 3k; that's very reasonable to avoid a ton of CPU cycles in + // the most common write path. + var bytes = totalLength == 0 ? Array.Empty() : new byte[totalLength]; + int offset = 0; for (int i = 0; i < commands.Length; i++) { - int idx = (int)commands[i]; - string? name = commands[i].ToString(), value = name; + var command = commands[i]; + var value = GetCommandValue(command, caseInsensitiveOverrides, exclusions); + if (string.IsNullOrEmpty(value)) continue; + + int payloadLength = Encoding.ASCII.GetByteCount(value); + int respLength = GetBulkStringLength(payloadLength); + map[(int)command] = new CommandBytes(offset, respLength, GetPayloadOffset(payloadLength)); + + var span = bytes.AsSpan(offset, respLength); + span[0] = (byte)'$'; + int payloadOffset = MessageWriter.WriteRaw(span, payloadLength, offset: 1); + var payload = span.Slice(payloadOffset, payloadLength); + int written = Encoding.ASCII.GetBytes(value.AsSpan(), payload); + if (written != payloadLength) ThrowAsciiEncodeLengthCheckFailure(); + AsciiHash.ToUpper(payload); + MessageWriter.WriteCrlf(span, payloadOffset + payloadLength); + offset += respLength; + } + return new CommandMap(map, bytes); - if (exclusions?.Contains(commands[i]) == true) - { - map[idx] = default; - } - else - { - if (caseInsensitiveOverrides != null && caseInsensitiveOverrides.TryGetValue(name, out string? tmp)) - { - value = tmp; - } - map[idx] = new CommandBytes(value); - } + [MethodImpl(MethodImplOptions.NoInlining)] + static void ThrowAsciiEncodeLengthCheckFailure() => throw new InvalidOperationException("ASCII encode length check failure"); + } + + private static string? GetCommandValue( + RedisCommand command, + Dictionary? caseInsensitiveOverrides, + HashSet? exclusions) + { + if (command is RedisCommand.UNKNOWN || exclusions?.Contains(command) == true) return null; + + var name = command.ToString(); + if (caseInsensitiveOverrides != null && caseInsensitiveOverrides.TryGetValue(name, out string? value)) + { + return value; + } + + return name; + } + + // ${N}\r\n{RAW}\r\n + private static int GetBulkStringLength(int payloadLength) => 5 + GetDigitCount(payloadLength) + payloadLength; + + // ${N}\r\n + private static byte GetPayloadOffset(int payloadLength) => checked((byte)(3 + GetDigitCount(payloadLength))); + + private static int GetDigitCount(int value) + { + if (value < 10) return 1; + if (value < 100) return 2; + int digits = 1; + while ((value /= 10) != 0) + { + digits++; + } + return digits; + } + + private readonly struct CommandBytes(int offset, int length, byte payloadOffset) + { + // Tracks position inside a shared buffer; given + // $3\r\nFOO\r\n$3\r\nBAR\r\n we have the positions (for BAR): + // ^ a ^ b ^c + // We know that the trailer is always exactly 2 bytes, so we don't need to store the + // length of the command itself - we can infer from the other values. + // offset is a, payloadOffset is a-to-b, length is a-to-c + private readonly uint offset = checked((uint)offset); + private readonly ushort length = checked((ushort)length); + + public bool IsEmpty => length == 0; + + // this will be fine even for a default instance + public ReadOnlySpan GetResp(byte[] bytes) => new(bytes, (int)offset, length); + + public ReadOnlySpan GetCommandBytes(byte[] bytes) + { + if (IsEmpty) return default; + return new ReadOnlySpan( + bytes, + checked((int)offset) + payloadOffset, + length - payloadOffset - 2); } - return new CommandMap(map); } } } diff --git a/src/StackExchange.Redis/CommandTrace.cs b/src/StackExchange.Redis/CommandTrace.cs index a61499f0c..7125bc7b3 100644 --- a/src/StackExchange.Redis/CommandTrace.cs +++ b/src/StackExchange.Redis/CommandTrace.cs @@ -1,4 +1,5 @@ using System; +using RESPite.Messages; namespace StackExchange.Redis { @@ -71,25 +72,37 @@ internal CommandTrace(long uniqueId, long time, long duration, RedisValue[] argu private sealed class CommandTraceProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + // see: SLOWLOG GET + if (reader.IsAggregate) { - case ResultType.Array: - var parts = result.GetItems(); - CommandTrace[] arr = new CommandTrace[parts.Length]; - int i = 0; - foreach (var item in parts) + var arr = reader.ReadPastArray(ParseOne, scalar: false)!; + if (arr.AnyNull()) return false; + + SetResult(message, arr); + return true; + } + + return false; + + static CommandTrace ParseOne(ref RespReader reader) + { + CommandTrace result = null!; + if (reader.IsAggregate) + { + long uniqueId = 0, time = 0, duration = 0; + if (reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out uniqueId) + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out time) + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out duration) + && reader.TryMoveNext() && reader.IsAggregate) { - var subParts = item.GetItems(); - if (!subParts[0].TryGetInt64(out long uniqueid) || !subParts[1].TryGetInt64(out long time) || !subParts[2].TryGetInt64(out long duration)) - return false; - arr[i++] = new CommandTrace(uniqueid, time, duration, subParts[3].GetItemsAsValues()!); + var values = reader.ReadPastRedisValues() ?? []; + result = new CommandTrace(uniqueId, time, duration, values); } - SetResult(message, arr); - return true; + } + return result; } - return false; } } } diff --git a/src/StackExchange.Redis/Condition.cs b/src/StackExchange.Redis/Condition.cs index ec7ee53b6..fa7e76299 100644 --- a/src/StackExchange.Redis/Condition.cs +++ b/src/StackExchange.Redis/Condition.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using RESPite.Messages; namespace StackExchange.Redis { @@ -372,7 +373,8 @@ public static Condition StringNotEqual(RedisKey key, RedisValue value) internal abstract IEnumerable CreateMessages(int db, IResultBox? resultBox); internal abstract int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy); - internal abstract bool TryValidate(in RawResult result, out bool value); + + internal abstract bool TryValidate(ref RespReader reader, out bool value); internal sealed class ConditionProcessor : ResultProcessor { @@ -387,13 +389,12 @@ public static Message CreateMessage(Condition condition, int db, CommandFlags fl public static Message CreateMessage(Condition condition, int db, CommandFlags flags, RedisCommand command, in RedisKey key, in RedisValue value, in RedisValue value1, in RedisValue value2, in RedisValue value3, in RedisValue value4) => new ConditionMessage(condition, db, flags, command, key, value, value1, value2, value3, value4); - [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0071:Simplify interpolation", Justification = "Allocations (string.Concat vs. string.Format)")] - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - connection?.BridgeCouldBeNull?.Multiplexer?.OnTransactionLog($"condition '{message.CommandAndKey}' got '{result.ToString()}'"); + connection?.BridgeCouldBeNull?.Multiplexer?.OnTransactionLog($"condition '{message.CommandAndKey}' got '{reader.GetOverview()}'"); var msg = message as ConditionMessage; var condition = msg?.Condition; - if (condition != null && condition.TryValidate(result, out bool final)) + if (condition != null && condition.TryValidate(ref reader, out bool final)) { SetResult(message, final); return true; @@ -432,26 +433,26 @@ public ConditionMessage(Condition condition, int db, CommandFlags flags, RedisCo this.value4 = value4; // note no assert here } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { if (value.IsNull) { - physical.WriteHeader(command, 1); - physical.Write(Key); + writer.WriteHeader(command, 1); + writer.Write(Key); } else { - physical.WriteHeader(command, value1.IsNull ? 2 : value2.IsNull ? 3 : value3.IsNull ? 4 : value4.IsNull ? 5 : 6); - physical.Write(Key); - physical.WriteBulkString(value); + writer.WriteHeader(command, value1.IsNull ? 2 : value2.IsNull ? 3 : value3.IsNull ? 4 : value4.IsNull ? 5 : 6); + writer.Write(Key); + writer.WriteBulkString(value); if (!value1.IsNull) - physical.WriteBulkString(value1); + writer.WriteBulkString(value1); if (!value2.IsNull) - physical.WriteBulkString(value2); + writer.WriteBulkString(value2); if (!value3.IsNull) - physical.WriteBulkString(value3); + writer.WriteBulkString(value3); if (!value4.IsNull) - physical.WriteBulkString(value4); + writer.WriteBulkString(value4); } } public override int ArgCount => value.IsNull ? 1 : value1.IsNull ? 2 : value2.IsNull ? 3 : value3.IsNull ? 4 : value4.IsNull ? 5 : 6; @@ -510,19 +511,20 @@ internal override IEnumerable CreateMessages(int db, IResultBox? result internal override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => serverSelectionStrategy.HashSlot(key); - internal override bool TryValidate(in RawResult result, out bool value) + internal override bool TryValidate(ref RespReader reader, out bool value) { switch (type) { case RedisType.SortedSet: - var parsedValue = result.AsRedisValue(); - value = parsedValue.IsNull != expectedResult; - ConnectionMultiplexer.TraceWithoutContext("exists: " + parsedValue + "; expected: " + expectedResult + "; voting: " + value); + // ZSCORE returns bulk string (score) or null + var parsedValue = reader.IsNull; + value = parsedValue != expectedResult; + ConnectionMultiplexer.TraceWithoutContext("exists: " + !parsedValue + "; expected: " + expectedResult + "; voting: " + value); return true; default: - bool parsed; - if (ResultProcessor.DemandZeroOrOneProcessor.TryGet(result, out parsed)) + // EXISTS, HEXISTS, SISMEMBER return integer 0 or 1 + if (ResultProcessor.DemandZeroOrOneProcessor.TryGet(ref reader, out bool parsed)) { value = parsed == expectedResult; ConnectionMultiplexer.TraceWithoutContext("exists: " + parsed + "; expected: " + expectedResult + "; voting: " + value); @@ -586,12 +588,30 @@ internal override IEnumerable CreateMessages(int db, IResultBox? result internal override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => serverSelectionStrategy.HashSlot(key); - internal override bool TryValidate(in RawResult result, out bool value) + internal override bool TryValidate(ref RespReader reader, out bool value) { - value = result.ItemsCount == 1 && result[0].AsRedisValue().StartsWith(prefix); - - if (!expectedResult) value = !value; - return true; + // ZRANGEBYLEX returns an array with 0 or 1 elements + if (reader.IsAggregate) + { + var count = reader.AggregateLength(); + if (count == 1) + { + // Check if the first element starts with prefix + if (reader.TryMoveNext() && reader.IsScalar) + { + value = reader.ReadRedisValue().StartsWith(prefix); + if (!expectedResult) value = !value; + return true; + } + } + else if (count == 0) + { + value = !expectedResult; // No match found + return true; + } + } + value = false; + return false; } } @@ -640,13 +660,21 @@ internal override IEnumerable CreateMessages(int db, IResultBox? result internal override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => serverSelectionStrategy.HashSlot(key); - internal override bool TryValidate(in RawResult result, out bool value) + internal override bool TryValidate(ref RespReader reader, out bool value) { + // All commands (ZSCORE, GET, HGET) return scalar values + if (!reader.IsScalar) + { + value = false; + return false; + } + switch (type) { case RedisType.SortedSet: + // ZSCORE returns bulk string (score as double) or null var parsedValue = RedisValue.Null; - if (!result.IsNull && result.TryGetDouble(out var val)) + if (!reader.IsNull && reader.TryReadDouble(out var val)) { parsedValue = val; } @@ -657,19 +685,12 @@ internal override bool TryValidate(in RawResult result, out bool value) return true; default: - switch (result.Resp2TypeBulkString) - { - case ResultType.BulkString: - case ResultType.SimpleString: - case ResultType.Integer: - var parsed = result.AsRedisValue(); - value = (parsed == expectedValue) == expectedEqual; - ConnectionMultiplexer.TraceWithoutContext("actual: " + (string?)parsed + "; expected: " + (string?)expectedValue + - "; wanted: " + (expectedEqual ? "==" : "!=") + "; voting: " + value); - return true; - } - value = false; - return false; + // GET or HGET returns bulk string, simple string, or integer + var parsed = reader.ReadRedisValue(); + value = (parsed == expectedValue) == expectedEqual; + ConnectionMultiplexer.TraceWithoutContext("actual: " + (string?)parsed + "; expected: " + (string?)expectedValue + + "; wanted: " + (expectedEqual ? "==" : "!=") + "; voting: " + value); + return true; } } } @@ -711,26 +732,24 @@ internal override IEnumerable CreateMessages(int db, IResultBox? result internal override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => serverSelectionStrategy.HashSlot(key); - internal override bool TryValidate(in RawResult result, out bool value) + internal override bool TryValidate(ref RespReader reader, out bool value) { - switch (result.Resp2TypeBulkString) + // LINDEX returns bulk string, simple string, or integer + if (reader.IsScalar) { - case ResultType.BulkString: - case ResultType.SimpleString: - case ResultType.Integer: - var parsed = result.AsRedisValue(); - if (expectedValue.HasValue) - { - value = (parsed == expectedValue.Value) == expectedResult; - ConnectionMultiplexer.TraceWithoutContext("actual: " + (string?)parsed + "; expected: " + (string?)expectedValue.Value + - "; wanted: " + (expectedResult ? "==" : "!=") + "; voting: " + value); - } - else - { - value = parsed.IsNull != expectedResult; - ConnectionMultiplexer.TraceWithoutContext("exists: " + parsed + "; expected: " + expectedResult + "; voting: " + value); - } - return true; + var parsed = reader.ReadRedisValue(); + if (expectedValue.HasValue) + { + value = (parsed == expectedValue.Value) == expectedResult; + ConnectionMultiplexer.TraceWithoutContext("actual: " + (string?)parsed + "; expected: " + (string?)expectedValue.Value + + "; wanted: " + (expectedResult ? "==" : "!=") + "; voting: " + value); + } + else + { + value = parsed.IsNull != expectedResult; + ConnectionMultiplexer.TraceWithoutContext("exists: " + parsed + "; expected: " + expectedResult + "; voting: " + value); + } + return true; } value = false; return false; @@ -784,18 +803,15 @@ internal override IEnumerable CreateMessages(int db, IResultBox? result internal override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => serverSelectionStrategy.HashSlot(key); - internal override bool TryValidate(in RawResult result, out bool value) + internal override bool TryValidate(ref RespReader reader, out bool value) { - switch (result.Resp2TypeBulkString) + // Length commands (HLEN, SCARD, LLEN, ZCARD, XLEN, STRLEN) return integer + if (reader.IsScalar && reader.TryReadInt64(out var parsed)) { - case ResultType.BulkString: - case ResultType.SimpleString: - case ResultType.Integer: - var parsed = result.AsRedisValue(); - value = parsed.IsInteger && (expectedLength.CompareTo((long)parsed) == compareToResult); - ConnectionMultiplexer.TraceWithoutContext("actual: " + (string?)parsed + "; expected: " + expectedLength + - "; wanted: " + GetComparisonString() + "; voting: " + value); - return true; + value = expectedLength.CompareTo(parsed) == compareToResult; + ConnectionMultiplexer.TraceWithoutContext("actual: " + parsed + "; expected: " + expectedLength + + "; wanted: " + GetComparisonString() + "; voting: " + value); + return true; } value = false; return false; @@ -841,18 +857,16 @@ internal override IEnumerable CreateMessages(int db, IResultBox? result internal override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => serverSelectionStrategy.HashSlot(key); - internal override bool TryValidate(in RawResult result, out bool value) + internal override bool TryValidate(ref RespReader reader, out bool value) { - switch (result.Resp2TypeBulkString) + // Length commands (HLEN, SCARD, LLEN, ZCARD, XLEN, STRLEN) return integer + if (reader.IsScalar) { - case ResultType.BulkString: - case ResultType.SimpleString: - case ResultType.Integer: - var parsed = result.AsRedisValue(); - value = parsed.IsInteger && (expectedLength.CompareTo((long)parsed) == compareToResult); - ConnectionMultiplexer.TraceWithoutContext("actual: " + (string?)parsed + "; expected: " + expectedLength + - "; wanted: " + GetComparisonString() + "; voting: " + value); - return true; + var parsed = reader.ReadRedisValue(); + value = parsed.IsInteger && (expectedLength.CompareTo((long)parsed) == compareToResult); + ConnectionMultiplexer.TraceWithoutContext("actual: " + (string?)parsed + "; expected: " + expectedLength + + "; wanted: " + GetComparisonString() + "; voting: " + value); + return true; } value = false; return false; @@ -898,17 +912,16 @@ internal override IEnumerable CreateMessages(int db, IResultBox? result internal override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => serverSelectionStrategy.HashSlot(key); - internal override bool TryValidate(in RawResult result, out bool value) + internal override bool TryValidate(ref RespReader reader, out bool value) { - switch (result.Resp2TypeBulkString) + // ZCOUNT returns integer + if (reader.IsScalar) { - case ResultType.Integer: - var parsedValue = result.AsRedisValue(); - value = (parsedValue == expectedValue) == expectedEqual; - ConnectionMultiplexer.TraceWithoutContext("actual: " + (string?)parsedValue + "; expected: " + (string?)expectedValue + "; wanted: " + (expectedEqual ? "==" : "!=") + "; voting: " + value); - return true; + var parsedValue = reader.ReadRedisValue(); + value = (parsedValue == expectedValue) == expectedEqual; + ConnectionMultiplexer.TraceWithoutContext("actual: " + (string?)parsedValue + "; expected: " + (string?)expectedValue + "; wanted: " + (expectedEqual ? "==" : "!=") + "; voting: " + value); + return true; } - value = false; return false; } diff --git a/src/StackExchange.Redis/ConfigField.cs b/src/StackExchange.Redis/ConfigField.cs new file mode 100644 index 000000000..b39e1e029 --- /dev/null +++ b/src/StackExchange.Redis/ConfigField.cs @@ -0,0 +1,49 @@ +using System; +using RESPite; + +namespace StackExchange.Redis; + +/// +/// Fields that can appear in a CONFIG GET command response. +/// +internal enum ConfigField +{ + /// + /// Unknown or unrecognized field. + /// + [AsciiHash("")] + Unknown = 0, + + /// + /// Timeout configuration. + /// + [AsciiHash("timeout")] + Timeout, + + /// + /// Number of databases. + /// + [AsciiHash("databases")] + Databases, + + /// + /// Replica read-only setting (slave-read-only). + /// + [AsciiHash("slave-read-only")] + SlaveReadOnly, + + /// + /// Replica read-only setting (replica-read-only). + /// + [AsciiHash("replica-read-only")] + ReplicaReadOnly, +} + +/// +/// Metadata and parsing methods for ConfigField. +/// +internal static partial class ConfigFieldMetadata +{ + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out ConfigField field); +} diff --git a/src/StackExchange.Redis/Configuration/DefaultOptionsProvider.cs b/src/StackExchange.Redis/Configuration/DefaultOptionsProvider.cs index d911db0e3..afcce011f 100644 --- a/src/StackExchange.Redis/Configuration/DefaultOptionsProvider.cs +++ b/src/StackExchange.Redis/Configuration/DefaultOptionsProvider.cs @@ -140,7 +140,10 @@ public static DefaultOptionsProvider GetProvider(EndPoint endpoint) /// /// The server version to assume. /// - public virtual Version DefaultVersion => RedisFeatures.v3_0_0; + public virtual Version DefaultVersion => BaseDefaultVersion; + + // this exists primarily to be queryable from tests + internal static Version BaseDefaultVersion = RedisFeatures.v6_0_0; /// /// Controls how often the connection heartbeats. A heartbeat includes: diff --git a/src/StackExchange.Redis/Configuration/LoggingTunnel.cs b/src/StackExchange.Redis/Configuration/LoggingTunnel.cs index 18216c1f2..a89911dc4 100644 --- a/src/StackExchange.Redis/Configuration/LoggingTunnel.cs +++ b/src/StackExchange.Redis/Configuration/LoggingTunnel.cs @@ -3,15 +3,15 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.IO; -using System.IO.Pipelines; using System.Net; using System.Net.Security; using System.Net.Sockets; using System.Text; using System.Threading; using System.Threading.Tasks; -using Pipelines.Sockets.Unofficial; -using Pipelines.Sockets.Unofficial.Arenas; +using RESPite; +using RESPite.Buffers; +using RESPite.Messages; using static StackExchange.Redis.PhysicalConnection; namespace StackExchange.Redis.Configuration; @@ -27,25 +27,158 @@ public abstract class LoggingTunnel : Tunnel private readonly bool _ssl; private readonly Tunnel? _tail; + internal sealed class StreamRespReader(Stream source, bool isInbound) : IDisposable + { + private CycleBuffer _readBuffer = CycleBuffer.Create(); + private RespScanState _state; + private bool _reading, _disposed; // we need to track the state of the reader to avoid releasing the buffer while it's in use + + public long Position { get; private set; } + internal bool TryTakeOne(out ContextualRedisResult result, bool withData = true) + { + var fullBuffer = _readBuffer.GetAllCommitted(); + var newData = fullBuffer.Slice(_state.TotalBytes); + var status = RespFrameScanner.Default.TryRead(ref _state, newData); + switch (status) + { + case OperationStatus.Done: + var frame = fullBuffer.Slice(0, _state.TotalBytes); + var reader = new RespReader(frame); + reader.MovePastBof(); + bool isOutOfBand = reader.Prefix is RespPrefix.Push + || (isInbound && reader.IsAggregate && + !IsArrayOutOfBand(in reader)); + + RedisResult? parsed; + if (withData) + { + if (!RedisResult.TryCreate(null, ref reader, out parsed)) + { + ThrowInvalidReadStatus(OperationStatus.InvalidData); + } + } + else + { + parsed = null; + } + result = new(parsed, isOutOfBand); + Position += _state.TotalBytes; + _readBuffer.DiscardCommitted((int)_state.TotalBytes); + _state = default; + return true; + case OperationStatus.NeedMoreData: + result = default; + return false; + default: + ThrowInvalidReadStatus(status); + goto case OperationStatus.NeedMoreData; // never reached + } + } + + private static bool IsArrayOutOfBand(in RespReader source) + { + var reader = source; + int len; + if (!reader.IsStreaming + && (len = reader.AggregateLength()) >= 2 + && (reader.SafeTryMoveNext() & reader.IsInlineScalar & !reader.IsError)) + { + const int MAX_TYPE_LEN = 16; + var span = reader.TryGetSpan(out var tmp) + ? tmp + : StackCopyLengthChecked(in reader, stackalloc byte[MAX_TYPE_LEN]); + + if (PushKindMetadata.TryParse(span, out var kind)) + { + return kind switch + { + PushKind.Message => len >= 3, + PushKind.PMessage => len >= 4, + PushKind.SMessage => len >= 3, + _ => false, + }; + } + } + + return false; + } + + public ValueTask ReadOneAsync(CancellationToken cancellationToken = default) + => TryTakeOne(out var result) ? new(result) : ReadMoreAsync(cancellationToken); + + [DoesNotReturn] + private static void ThrowInvalidReadStatus(OperationStatus status) + => throw new InvalidOperationException($"Unexpected read status: {status}"); + + private async ValueTask ReadMoreAsync(CancellationToken cancellationToken) + { + while (true) + { + var buffer = _readBuffer.GetUncommittedMemory(); + Debug.Assert(!buffer.IsEmpty, "rule out zero-length reads"); + _reading = true; + var read = await source.ReadAsync(buffer, cancellationToken).ForAwait(); + _reading = false; + if (read <= 0) + { + // EOF + return default; + } + _readBuffer.Commit(read); + + if (TryTakeOne(out var result)) return result; + } + } + + public void Dispose() + { + bool disposed = _disposed; + _disposed = true; + _state = default; + + if (!(_reading | disposed)) _readBuffer.Release(); + _readBuffer = default; + if (!disposed) source.Dispose(); + } + + public async ValueTask ValidateAsync(CancellationToken cancellationToken = default) + { + long count = 0; + while (true) + { + var buffer = _readBuffer.GetUncommittedMemory(); + Debug.Assert(!buffer.IsEmpty, "rule out zero-length reads"); + _reading = true; + var read = await source.ReadAsync(buffer, cancellationToken).ForAwait(); + _reading = false; + if (read <= 0) + { + // EOF + return count; + } + _readBuffer.Commit(read); + while (TryTakeOne(out _, withData: false)) count++; + } + } + } + /// /// Replay the RESP messages for a pair of streams, invoking a callback per operation. /// public static async Task ReplayAsync(Stream @out, Stream @in, Action pair) { - using Arena arena = new(); - var outPipe = StreamConnection.GetReader(@out); - var inPipe = StreamConnection.GetReader(@in); - long count = 0; + using var outReader = new StreamRespReader(@out, isInbound: false); + using var inReader = new StreamRespReader(@in, isInbound: true); while (true) { - var sent = await ReadOneAsync(outPipe, arena, isInbound: false).ForAwait(); + if (!outReader.TryTakeOne(out var sent)) sent = await outReader.ReadOneAsync().ForAwait(); ContextualRedisResult received; try { do { - received = await ReadOneAsync(inPipe, arena, isInbound: true).ForAwait(); + if (!inReader.TryTakeOne(out received)) received = await inReader.ReadOneAsync().ForAwait(); if (received.IsOutOfBand && received.Result is not null) { // spoof an empty request for OOB messages @@ -93,26 +226,6 @@ public static async Task ReplayAsync(string path, Action ReadOneAsync(PipeReader input, Arena arena, bool isInbound) - { - while (true) - { - var readResult = await input.ReadAsync().ForAwait(); - var buffer = readResult.Buffer; - int handled = 0; - var result = buffer.IsEmpty ? default : ProcessBuffer(arena, ref buffer, isInbound); - input.AdvanceTo(buffer.Start, buffer.End); - - if (result.Result is not null) return result; - - if (handled == 0 && readResult.IsCompleted) - { - break; // no more data, or trailing incomplete messages - } - } - return default; - } - /// /// Validate a RESP stream and return the number of top-level RESP fragments. /// @@ -152,63 +265,11 @@ public static async Task ValidateAsync(string path) /// public static async Task ValidateAsync(Stream stream) { - using var arena = new Arena(); - var input = StreamConnection.GetReader(stream); - long total = 0, position = 0; - while (true) - { - var readResult = await input.ReadAsync().ForAwait(); - var buffer = readResult.Buffer; - int handled = 0; - if (!buffer.IsEmpty) - { - try - { - ProcessBuffer(arena, ref buffer, ref position, ref handled); // updates buffer.Start - } - catch (Exception ex) - { - throw new InvalidOperationException($"Invalid fragment starting at {position} (fragment {total + handled})", ex); - } - total += handled; - } - - input.AdvanceTo(buffer.Start, buffer.End); - - if (handled == 0 && readResult.IsCompleted) - { - break; // no more data, or trailing incomplete messages - } - } - return total; - } - private static void ProcessBuffer(Arena arena, ref ReadOnlySequence buffer, ref long position, ref int messageCount) - { - while (!buffer.IsEmpty) - { - var reader = new BufferReader(buffer); - try - { - var result = TryParseResult(true, arena, in buffer, ref reader, true, null); - if (result.HasValue) - { - buffer = reader.SliceFromCurrent(); - position += reader.TotalConsumed; - messageCount++; - } - else - { - break; // remaining buffer isn't enough; give up - } - } - finally - { - arena.Reset(); - } - } + using var reader = new StreamRespReader(stream, isInbound: false); + return await reader.ValidateAsync().ForAwait(); } - private readonly struct ContextualRedisResult + internal readonly struct ContextualRedisResult { public readonly RedisResult? Result; public readonly bool IsOutOfBand; @@ -219,42 +280,6 @@ public ContextualRedisResult(RedisResult? result, bool isOutOfBand) } } - private static ContextualRedisResult ProcessBuffer(Arena arena, ref ReadOnlySequence buffer, bool isInbound) - { - if (!buffer.IsEmpty) - { - var reader = new BufferReader(buffer); - try - { - var result = TryParseResult(true, arena, in buffer, ref reader, true, null); - bool isOutOfBand = result.Resp3Type == ResultType.Push - || (isInbound && result.Resp2TypeArray == ResultType.Array && IsArrayOutOfBand(result)); - if (result.HasValue) - { - buffer = reader.SliceFromCurrent(); - if (!RedisResult.TryCreate(null, result, out var parsed)) - { - throw new InvalidOperationException("Unable to parse raw result to RedisResult"); - } - return new(parsed, isOutOfBand); - } - } - finally - { - arena.Reset(); - } - } - return default; - - static bool IsArrayOutOfBand(in RawResult result) - { - var items = result.GetItems(); - return (items.Length >= 3 && (items[0].IsEqual(message) || items[0].IsEqual(smessage))) - || (items.Length >= 4 && items[0].IsEqual(pmessage)); - } - } - private static readonly CommandBytes message = "message", pmessage = "pmessage", smessage = "smessage"; - /// /// Create a new instance of a . /// @@ -504,9 +529,9 @@ public override void Flush() public override async Task FlushAsync(CancellationToken cancellationToken) { - var writesTask = _writes.FlushAsync().ForAwait(); + var writesTask = _writes.FlushAsync(); await _inner.FlushAsync().ForAwait(); - await writesTask; + await writesTask.ForAwait(); } protected override void Dispose(bool disposing) @@ -609,9 +634,9 @@ public override void Write(byte[] buffer, int offset, int count) } public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) { - var writesTask = _writes.WriteAsync(buffer, offset, count, cancellationToken).ForAwait(); + var writesTask = _writes.WriteAsync(buffer, offset, count, cancellationToken); await _inner.WriteAsync(buffer, offset, count, cancellationToken).ForAwait(); - await writesTask; + await writesTask.ForAwait(); } #if NET public override void Write(ReadOnlySpan buffer) @@ -619,11 +644,12 @@ public override void Write(ReadOnlySpan buffer) _writes.Write(buffer); _inner.Write(buffer); } + // ReSharper disable once OptionalParameterHierarchyMismatch public override async ValueTask WriteAsync(ReadOnlyMemory buffer, CancellationToken cancellationToken) { - var writesTask = _writes.WriteAsync(buffer, cancellationToken).ForAwait(); + var writesTask = _writes.WriteAsync(buffer, cancellationToken); await _inner.WriteAsync(buffer, cancellationToken).ForAwait(); - await writesTask; + await writesTask.ForAwait(); } #endif } diff --git a/src/StackExchange.Redis/Configuration/Tunnel.cs b/src/StackExchange.Redis/Configuration/Tunnel.cs index beebff2dc..9c28cbd2d 100644 --- a/src/StackExchange.Redis/Configuration/Tunnel.cs +++ b/src/StackExchange.Redis/Configuration/Tunnel.cs @@ -6,7 +6,6 @@ using System.Text; using System.Threading; using System.Threading.Tasks; -using Pipelines.Sockets.Unofficial; namespace StackExchange.Redis.Configuration { @@ -58,47 +57,29 @@ private sealed class HttpProxyTunnel : Tunnel offset += encoding.GetBytes(ep, 0, ep.Length, chunk, offset); offset += encoding.GetBytes(Suffix, 0, Suffix.Length, chunk, offset); - static void SafeAbort(object? obj) - { - try - { - (obj as SocketAwaitableEventArgs)?.Abort(SocketError.TimedOut); - } - catch { } // best effort only - } - - using (var args = new SocketAwaitableEventArgs()) - using (cancellationToken.Register(static s => SafeAbort(s), args)) - { - args.SetBuffer(chunk, 0, offset); - if (!socket.SendAsync(args)) args.Complete(); - await args; + await socket.SendAsync(chunk.AsMemory(0, offset), SocketFlags.None, cancellationToken).ForAwait(); - // we expect to see: "HTTP/1.1 200 OK\n"; note our buffer is definitely big enough already - int toRead = Math.Max(encoding.GetByteCount(ExpectedResponse1), encoding.GetByteCount(ExpectedResponse2)), read; - offset = 0; + // we expect to see: "HTTP/1.1 200 OK\n"; note our buffer is definitely big enough already + int toRead = Math.Max(encoding.GetByteCount(ExpectedResponse1), encoding.GetByteCount(ExpectedResponse2)), read; + offset = 0; - var actualResponse = ""; - while (toRead > 0 && !actualResponse.EndsWith("\r\n\r\n")) - { - args.SetBuffer(chunk, offset, toRead); - if (!socket.ReceiveAsync(args)) args.Complete(); - read = await args; - - if (read <= 0) break; // EOF (since we're never doing zero-length reads) - toRead -= read; - offset += read; + var actualResponse = ""; + while (toRead > 0 && !actualResponse.EndsWith("\r\n\r\n")) + { + read = await socket.ReceiveAsync(chunk.AsMemory(offset, toRead), SocketFlags.None, cancellationToken).ForAwait(); + if (read <= 0) break; // EOF (since we're never doing zero-length reads) + toRead -= read; + offset += read; - actualResponse = encoding.GetString(chunk, 0, offset); - } - if (toRead != 0 && !actualResponse.EndsWith("\r\n\r\n")) throw new EndOfStreamException("EOF negotiating HTTP tunnel"); - // lazy - if (ExpectedResponse1 != actualResponse && ExpectedResponse2 != actualResponse) - { - throw new InvalidOperationException("Unexpected response negotiating HTTP tunnel"); - } - ArrayPool.Shared.Return(chunk); + actualResponse = encoding.GetString(chunk, 0, offset); + } + if (toRead != 0 && !actualResponse.EndsWith("\r\n\r\n")) throw new EndOfStreamException("EOF negotiating HTTP tunnel"); + // lazy + if (ExpectedResponse1 != actualResponse && ExpectedResponse2 != actualResponse) + { + throw new InvalidOperationException("Unexpected response negotiating HTTP tunnel"); } + ArrayPool.Shared.Return(chunk); } return default; // no need for custom stream wrapper here } diff --git a/src/StackExchange.Redis/ConfigurationOptions.cs b/src/StackExchange.Redis/ConfigurationOptions.cs index a0a10791c..e8114cdb6 100644 --- a/src/StackExchange.Redis/ConfigurationOptions.cs +++ b/src/StackExchange.Redis/ConfigurationOptions.cs @@ -162,21 +162,60 @@ public static string TryNormalize(string value) private DefaultOptionsProvider? defaultOptions; - private bool? allowAdmin, abortOnConnectFail, resolveDns, ssl, checkCertificateRevocation, heartbeatConsistencyChecks, - includeDetailInExceptions, includePerformanceCountersInExceptions, setClientLibrary, highIntegrity; + [Flags] + private enum OptionFlags : ulong + { + None = 0, + AllowAdminHasValue = 1UL << 0, + AllowAdminValue = 1UL << 1, + AbortOnConnectFailHasValue = 1UL << 2, + AbortOnConnectFailValue = 1UL << 3, + ResolveDnsHasValue = 1UL << 4, + ResolveDnsValue = 1UL << 5, + SslHasValue = 1UL << 6, + SslValue = 1UL << 7, + CheckCertificateRevocationHasValue = 1UL << 8, + CheckCertificateRevocationValue = 1UL << 9, + HeartbeatConsistencyChecksHasValue = 1UL << 10, + HeartbeatConsistencyChecksValue = 1UL << 11, + IncludeDetailInExceptionsHasValue = 1UL << 12, + IncludeDetailInExceptionsValue = 1UL << 13, + IncludePerformanceCountersInExceptionsHasValue = 1UL << 14, + IncludePerformanceCountersInExceptionsValue = 1UL << 15, + SetClientLibraryHasValue = 1UL << 16, + SetClientLibraryValue = 1UL << 17, + HighIntegrityHasValue = 1UL << 18, + HighIntegrityValue = 1UL << 19, + TcpKeepAliveHasValue = 1UL << 20, + TcpKeepAliveValue = 1UL << 21, + HeartbeatIntervalHasValue = 1UL << 22, + KeepAliveHasValue = 1UL << 23, + AsyncTimeoutHasValue = 1UL << 24, + SyncTimeoutHasValue = 1UL << 25, + ConnectTimeoutHasValue = 1UL << 26, + ResponseTimeoutHasValue = 1UL << 27, + ConnectRetryHasValue = 1UL << 28, + ConfigCheckSecondsHasValue = 1UL << 29, + ProxyHasValue = 1UL << 30, + DefaultDatabaseHasValue = 1UL << 31, + SslProtocolsHasValue = 1UL << 32, + ProtocolHasValue = 1UL << 33, + AllowSimulateConnectionFailure = 1UL << 34, + } + + private OptionFlags optionFlags; private string? tieBreaker, sslHost, configChannel, user, password; - private TimeSpan? heartbeatInterval; + private TimeSpan heartbeatInterval; private CommandMap? commandMap; private Version? defaultVersion; - private int? keepAlive, asyncTimeout, syncTimeout, connectTimeout, responseTimeout, connectRetry, configCheckSeconds; - private bool? tcpKeepAlive; + private int keepAlive, asyncTimeout, syncTimeout, connectTimeout, responseTimeout, connectRetry, configCheckSeconds, defaultDatabase; - private Proxy? proxy; + private Proxy proxy; private IReconnectRetryPolicy? reconnectRetryPolicy; @@ -184,6 +223,61 @@ public static string TryNormalize(string value) private ILoggerFactory? loggerFactory; + private SslProtocols sslProtocols; + + private RedisProtocol _protocol; + + private bool HasValue(OptionFlags hasValue) => (optionFlags & hasValue) != 0; + + private bool IsSet(OptionFlags value) => (optionFlags & value) != 0; + + private void SetBooleanWithValue(OptionFlags hasValue, OptionFlags valueFlag, bool value) + { + optionFlags |= hasValue; + if (value) + { + optionFlags |= valueFlag; + } + else + { + optionFlags &= ~valueFlag; + } + } + + private void SetFlag(OptionFlags flag, bool value) + { + if (value) + { + optionFlags |= flag; + } + else + { + optionFlags &= ~flag; + } + } + + private T? Get(OptionFlags hasValue, in T value) where T : struct + => HasValue(hasValue) ? value : null; + + private void Set(OptionFlags hasValue, ref T storage, T? value) where T : struct + { + if (value.HasValue) + { + SetWithValue(hasValue, ref storage, value.GetValueOrDefault()); + } + else + { + optionFlags &= ~hasValue; + storage = default; + } + } + + private void SetWithValue(OptionFlags hasValue, ref T storage, T value) where T : struct + { + optionFlags |= hasValue; + storage = value; + } + /// /// A LocalCertificateSelectionCallback delegate responsible for selecting the certificate used for authentication; note /// that this cannot be specified in the configuration-string. @@ -221,8 +315,8 @@ public DefaultOptionsProvider Defaults /// public bool AbortOnConnectFail { - get => abortOnConnectFail ?? Defaults.AbortOnConnectFail; - set => abortOnConnectFail = value; + get => HasValue(OptionFlags.AbortOnConnectFailHasValue) ? IsSet(OptionFlags.AbortOnConnectFailValue) : Defaults.AbortOnConnectFail; + set => SetBooleanWithValue(OptionFlags.AbortOnConnectFailHasValue, OptionFlags.AbortOnConnectFailValue, value); } /// @@ -230,8 +324,8 @@ public bool AbortOnConnectFail /// public bool AllowAdmin { - get => allowAdmin ?? Defaults.AllowAdmin; - set => allowAdmin = value; + get => HasValue(OptionFlags.AllowAdminHasValue) ? IsSet(OptionFlags.AllowAdminValue) : Defaults.AllowAdmin; + set => SetBooleanWithValue(OptionFlags.AllowAdminHasValue, OptionFlags.AllowAdminValue, value); } /// @@ -239,8 +333,8 @@ public bool AllowAdmin /// public int AsyncTimeout { - get => asyncTimeout ?? SyncTimeout; - set => asyncTimeout = value; + get => HasValue(OptionFlags.AsyncTimeoutHasValue) ? asyncTimeout : SyncTimeout; + set => SetWithValue(OptionFlags.AsyncTimeoutHasValue, ref asyncTimeout, value); } /// @@ -260,8 +354,8 @@ public bool UseSsl /// public bool SetClientLibrary { - get => setClientLibrary ?? Defaults.SetClientLibrary; - set => setClientLibrary = value; + get => HasValue(OptionFlags.SetClientLibraryHasValue) ? IsSet(OptionFlags.SetClientLibraryValue) : Defaults.SetClientLibrary; + set => SetBooleanWithValue(OptionFlags.SetClientLibraryHasValue, OptionFlags.SetClientLibraryValue, value); } /// @@ -282,8 +376,8 @@ public bool SetClientLibrary /// public bool CheckCertificateRevocation { - get => checkCertificateRevocation ?? Defaults.CheckCertificateRevocation; - set => checkCertificateRevocation = value; + get => HasValue(OptionFlags.CheckCertificateRevocationHasValue) ? IsSet(OptionFlags.CheckCertificateRevocationValue) : Defaults.CheckCertificateRevocation; + set => SetBooleanWithValue(OptionFlags.CheckCertificateRevocationHasValue, OptionFlags.CheckCertificateRevocationValue, value); } /// @@ -297,8 +391,8 @@ public bool CheckCertificateRevocation /// public bool HighIntegrity { - get => highIntegrity ?? Defaults.HighIntegrity; - set => highIntegrity = value; + get => HasValue(OptionFlags.HighIntegrityHasValue) ? IsSet(OptionFlags.HighIntegrityValue) : Defaults.HighIntegrity; + set => SetBooleanWithValue(OptionFlags.HighIntegrityHasValue, OptionFlags.HighIntegrityValue, value); } /// @@ -336,9 +430,9 @@ internal static LocalCertificateSelectionCallback CreatePemUserCertificateCallba { // PEM handshakes not universally supported and causes a runtime error about ephemeral certificates; to avoid, export as PFX using var pem = X509Certificate2.CreateFromPemFile(userCertificatePath, userKeyPath); -#pragma warning disable SYSLIB0057 // Type or member is obsolete +#pragma warning disable SYSLIB0057 // X509 loading var pfx = new X509Certificate2(pem.Export(X509ContentType.Pfx)); -#pragma warning restore SYSLIB0057 // Type or member is obsolete +#pragma warning restore SYSLIB0057 // X509 loading return (sender, targetHost, localCertificates, remoteCertificate, acceptableIssuers) => pfx; } @@ -346,9 +440,9 @@ internal static LocalCertificateSelectionCallback CreatePemUserCertificateCallba internal static LocalCertificateSelectionCallback CreatePfxUserCertificateCallback(string userCertificatePath, string? password, X509KeyStorageFlags storageFlags = X509KeyStorageFlags.DefaultKeySet) { -#pragma warning disable SYSLIB0057 +#pragma warning disable SYSLIB0057 // X509 loading var pfx = new X509Certificate2(userCertificatePath, password ?? "", storageFlags); -#pragma warning restore SYSLIB0057 +#pragma warning restore SYSLIB0057 // X509 loading return (sender, targetHost, localCertificates, remoteCertificate, acceptableIssuers) => pfx; } @@ -359,9 +453,10 @@ internal static LocalCertificateSelectionCallback CreatePfxUserCertificateCallba public void TrustIssuer(X509Certificate2 issuer) => CertificateValidationCallback = TrustIssuerCallback(issuer); internal static RemoteCertificateValidationCallback TrustIssuerCallback(string issuerCertificatePath) -#pragma warning disable SYSLIB0057 +#pragma warning disable SYSLIB0057 // X509 loading => TrustIssuerCallback(new X509Certificate2(issuerCertificatePath)); -#pragma warning restore SYSLIB0057 +#pragma warning restore SYSLIB0057 // X509 loading + private static RemoteCertificateValidationCallback TrustIssuerCallback(X509Certificate2 issuer) { if (issuer == null) throw new ArgumentNullException(nameof(issuer)); @@ -455,8 +550,8 @@ private static bool CheckTrustedIssuer(X509Certificate2 certificateToValidate, X /// public int ConnectRetry { - get => connectRetry ?? Defaults.ConnectRetry; - set => connectRetry = value; + get => HasValue(OptionFlags.ConnectRetryHasValue) ? connectRetry : Defaults.ConnectRetry; + set => SetWithValue(OptionFlags.ConnectRetryHasValue, ref connectRetry, value); } /// @@ -504,14 +599,23 @@ public string ConfigurationChannel /// public int ConnectTimeout { - get => connectTimeout ?? ((int?)Defaults.ConnectTimeout?.TotalMilliseconds) ?? Math.Max(5000, SyncTimeout); - set => connectTimeout = value; + get + { + if (HasValue(OptionFlags.ConnectTimeoutHasValue)) return connectTimeout; + var defaultTimeout = Defaults.ConnectTimeout; + return defaultTimeout.HasValue ? (int)defaultTimeout.GetValueOrDefault().TotalMilliseconds : Math.Max(5000, SyncTimeout); + } + set => SetWithValue(OptionFlags.ConnectTimeoutHasValue, ref connectTimeout, value); } /// /// Specifies the default database to be used when calling without any parameters. /// - public int? DefaultDatabase { get; set; } + public int? DefaultDatabase + { + get => Get(OptionFlags.DefaultDatabaseHasValue, in defaultDatabase); + set => Set(OptionFlags.DefaultDatabaseHasValue, ref defaultDatabase, value); + } /// /// The server version to assume. @@ -537,8 +641,8 @@ public Version DefaultVersion /// public bool HeartbeatConsistencyChecks { - get => heartbeatConsistencyChecks ?? Defaults.HeartbeatConsistencyChecks; - set => heartbeatConsistencyChecks = value; + get => HasValue(OptionFlags.HeartbeatConsistencyChecksHasValue) ? IsSet(OptionFlags.HeartbeatConsistencyChecksValue) : Defaults.HeartbeatConsistencyChecks; + set => SetBooleanWithValue(OptionFlags.HeartbeatConsistencyChecksHasValue, OptionFlags.HeartbeatConsistencyChecksValue, value); } /// @@ -555,8 +659,8 @@ public bool HeartbeatConsistencyChecks /// public TimeSpan HeartbeatInterval { - get => heartbeatInterval ?? Defaults.HeartbeatInterval; - set => heartbeatInterval = value; + get => HasValue(OptionFlags.HeartbeatIntervalHasValue) ? heartbeatInterval : Defaults.HeartbeatInterval; + set => SetWithValue(OptionFlags.HeartbeatIntervalHasValue, ref heartbeatInterval, value); } /// @@ -576,8 +680,8 @@ public bool HighPrioritySocketThreads /// public bool IncludeDetailInExceptions { - get => includeDetailInExceptions ?? Defaults.IncludeDetailInExceptions; - set => includeDetailInExceptions = value; + get => HasValue(OptionFlags.IncludeDetailInExceptionsHasValue) ? IsSet(OptionFlags.IncludeDetailInExceptionsValue) : Defaults.IncludeDetailInExceptions; + set => SetBooleanWithValue(OptionFlags.IncludeDetailInExceptionsHasValue, OptionFlags.IncludeDetailInExceptionsValue, value); } /// @@ -588,8 +692,8 @@ public bool IncludeDetailInExceptions /// public bool IncludePerformanceCountersInExceptions { - get => includePerformanceCountersInExceptions ?? Defaults.IncludePerformanceCountersInExceptions; - set => includePerformanceCountersInExceptions = value; + get => HasValue(OptionFlags.IncludePerformanceCountersInExceptionsHasValue) ? IsSet(OptionFlags.IncludePerformanceCountersInExceptionsValue) : Defaults.IncludePerformanceCountersInExceptions; + set => SetBooleanWithValue(OptionFlags.IncludePerformanceCountersInExceptionsHasValue, OptionFlags.IncludePerformanceCountersInExceptionsValue, value); } /// @@ -598,8 +702,8 @@ public bool IncludePerformanceCountersInExceptions /// public int KeepAlive { - get => keepAlive ?? (int)Defaults.KeepAliveInterval.TotalSeconds; - set => keepAlive = value; + get => HasValue(OptionFlags.KeepAliveHasValue) ? keepAlive : (int)Defaults.KeepAliveInterval.TotalSeconds; + set => SetWithValue(OptionFlags.KeepAliveHasValue, ref keepAlive, value); } /// @@ -607,8 +711,8 @@ public int KeepAlive /// public bool TcpKeepAlive { - get => tcpKeepAlive ?? Defaults.TcpKeepAlive; - set => tcpKeepAlive = value; + get => HasValue(OptionFlags.TcpKeepAliveHasValue) ? IsSet(OptionFlags.TcpKeepAliveValue) : Defaults.TcpKeepAlive; + set => SetBooleanWithValue(OptionFlags.TcpKeepAliveHasValue, OptionFlags.TcpKeepAliveValue, value); } /// @@ -655,8 +759,8 @@ public bool PreserveAsyncOrder /// public Proxy Proxy { - get => proxy ?? Defaults.Proxy; - set => proxy = value; + get => HasValue(OptionFlags.ProxyHasValue) ? proxy : Defaults.Proxy; + set => SetWithValue(OptionFlags.ProxyHasValue, ref proxy, value); } /// @@ -683,8 +787,8 @@ public BacklogPolicy BacklogPolicy /// public bool ResolveDns { - get => resolveDns ?? Defaults.ResolveDns; - set => resolveDns = value; + get => HasValue(OptionFlags.ResolveDnsHasValue) ? IsSet(OptionFlags.ResolveDnsValue) : Defaults.ResolveDns; + set => SetBooleanWithValue(OptionFlags.ResolveDnsHasValue, OptionFlags.ResolveDnsValue, value); } /// @@ -711,6 +815,7 @@ public int ResponseTimeout /// This is only used when a is created. /// Modifying it afterwards will have no effect on already-created multiplexers. /// + [Obsolete("SocketManager is no longer used by StackExchange.Redis")] public SocketManager? SocketManager { get; set; } #if NET @@ -726,8 +831,8 @@ public int ResponseTimeout /// public bool Ssl { - get => ssl ?? Defaults.GetDefaultSsl(EndPoints); - set => ssl = value; + get => HasValue(OptionFlags.SslHasValue) ? IsSet(OptionFlags.SslValue) : Defaults.GetDefaultSsl(EndPoints); + set => SetBooleanWithValue(OptionFlags.SslHasValue, OptionFlags.SslValue, value); } /// @@ -742,15 +847,19 @@ public string? SslHost /// /// Configures which SSL/TLS protocols should be allowed. If not set, defaults are chosen by the .NET framework. /// - public SslProtocols? SslProtocols { get; set; } + public SslProtocols? SslProtocols + { + get => Get(OptionFlags.SslProtocolsHasValue, in sslProtocols); + set => Set(OptionFlags.SslProtocolsHasValue, ref sslProtocols, value); + } /// /// Specifies the time in milliseconds that the system should allow for synchronous operations (defaults to 5 seconds). /// public int SyncTimeout { - get => syncTimeout ?? (int)Defaults.SyncTimeout.TotalMilliseconds; - set => syncTimeout = value; + get => HasValue(OptionFlags.SyncTimeoutHasValue) ? syncTimeout : (int)Defaults.SyncTimeout.TotalMilliseconds; + set => SetWithValue(OptionFlags.SyncTimeoutHasValue, ref syncTimeout, value); } /// @@ -791,8 +900,8 @@ internal RemoteCertificateValidationCallback? CertificateValidationCallback /// public int ConfigCheckSeconds { - get => configCheckSeconds ?? (int)Defaults.ConfigCheckInterval.TotalSeconds; - set => configCheckSeconds = value; + get => HasValue(OptionFlags.ConfigCheckSecondsHasValue) ? configCheckSeconds : (int)Defaults.ConfigCheckInterval.TotalSeconds; + set => SetWithValue(OptionFlags.ConfigCheckSecondsHasValue, ref configCheckSeconds, value); } /// @@ -819,36 +928,34 @@ public static ConfigurationOptions Parse(string configuration, bool ignoreUnknow public ConfigurationOptions Clone() => new ConfigurationOptions { defaultOptions = defaultOptions, + optionFlags = this.optionFlags, ClientName = ClientName, ServiceName = ServiceName, keepAlive = keepAlive, syncTimeout = syncTimeout, asyncTimeout = asyncTimeout, - allowAdmin = allowAdmin, defaultVersion = defaultVersion, connectTimeout = connectTimeout, user = user, password = password, tieBreaker = tieBreaker, - ssl = ssl, sslHost = sslHost, configChannel = configChannel, - abortOnConnectFail = abortOnConnectFail, - resolveDns = resolveDns, proxy = proxy, commandMap = commandMap, CertificateValidationCallback = CertificateValidationCallback, CertificateSelectionCallback = CertificateSelectionCallback, ChannelPrefix = ChannelPrefix.Clone(), +#pragma warning disable CS0618 // Type or member is obsolete SocketManager = SocketManager, +#pragma warning restore CS0618 // Type or member is obsolete connectRetry = connectRetry, configCheckSeconds = configCheckSeconds, responseTimeout = responseTimeout, - DefaultDatabase = DefaultDatabase, + defaultDatabase = defaultDatabase, reconnectRetryPolicy = reconnectRetryPolicy, backlogPolicy = backlogPolicy, - SslProtocols = SslProtocols, - checkCertificateRevocation = checkCertificateRevocation, + sslProtocols = sslProtocols, BeforeSocketConnect = BeforeSocketConnect, EndPoints = EndPoints.Clone(), LoggerFactory = LoggerFactory, @@ -856,13 +963,13 @@ public static ConfigurationOptions Parse(string configuration, bool ignoreUnknow SslClientAuthenticationOptions = SslClientAuthenticationOptions, #endif Tunnel = Tunnel, - setClientLibrary = setClientLibrary, LibraryName = LibraryName, _protocol = _protocol, heartbeatInterval = heartbeatInterval, - heartbeatConsistencyChecks = heartbeatConsistencyChecks, - highIntegrity = highIntegrity, - tcpKeepAlive = tcpKeepAlive, + WriteMode = WriteMode, +#if DEBUG + OutputLog = OutputLog, +#endif }; /// @@ -920,32 +1027,32 @@ public string ToString(bool includePassword) } Append(sb, OptionKeys.ClientName, ClientName); Append(sb, OptionKeys.ServiceName, ServiceName); - Append(sb, OptionKeys.KeepAlive, keepAlive); - Append(sb, OptionKeys.SyncTimeout, syncTimeout); - Append(sb, OptionKeys.AsyncTimeout, asyncTimeout); - Append(sb, OptionKeys.AllowAdmin, allowAdmin); + Append(sb, OptionKeys.KeepAlive, OptionFlags.KeepAliveHasValue, in keepAlive); + Append(sb, OptionKeys.SyncTimeout, OptionFlags.SyncTimeoutHasValue, in syncTimeout); + Append(sb, OptionKeys.AsyncTimeout, OptionFlags.AsyncTimeoutHasValue, in asyncTimeout); + Append(sb, OptionKeys.AllowAdmin, OptionFlags.AllowAdminHasValue, OptionFlags.AllowAdminValue); Append(sb, OptionKeys.Version, defaultVersion); - Append(sb, OptionKeys.ConnectTimeout, connectTimeout); + Append(sb, OptionKeys.ConnectTimeout, OptionFlags.ConnectTimeoutHasValue, in connectTimeout); Append(sb, OptionKeys.User, user); Append(sb, OptionKeys.Password, (includePassword || string.IsNullOrEmpty(password)) ? password : "*****"); Append(sb, OptionKeys.TieBreaker, tieBreaker); - Append(sb, OptionKeys.Ssl, ssl); - Append(sb, OptionKeys.SslProtocols, SslProtocols?.ToString().Replace(',', '|')); - Append(sb, OptionKeys.CheckCertificateRevocation, checkCertificateRevocation); + Append(sb, OptionKeys.Ssl, OptionFlags.SslHasValue, OptionFlags.SslValue); + if (HasValue(OptionFlags.SslProtocolsHasValue)) Append(sb, OptionKeys.SslProtocols, sslProtocols.ToString().Replace(',', '|')); + Append(sb, OptionKeys.CheckCertificateRevocation, OptionFlags.CheckCertificateRevocationHasValue, OptionFlags.CheckCertificateRevocationValue); Append(sb, OptionKeys.SslHost, sslHost); Append(sb, OptionKeys.ConfigChannel, configChannel); - Append(sb, OptionKeys.AbortOnConnectFail, abortOnConnectFail); - Append(sb, OptionKeys.ResolveDns, resolveDns); + Append(sb, OptionKeys.AbortOnConnectFail, OptionFlags.AbortOnConnectFailHasValue, OptionFlags.AbortOnConnectFailValue); + Append(sb, OptionKeys.ResolveDns, OptionFlags.ResolveDnsHasValue, OptionFlags.ResolveDnsValue); Append(sb, OptionKeys.ChannelPrefix, (string?)ChannelPrefix); - Append(sb, OptionKeys.ConnectRetry, connectRetry); - Append(sb, OptionKeys.Proxy, proxy); - Append(sb, OptionKeys.ConfigCheckSeconds, configCheckSeconds); - Append(sb, OptionKeys.ResponseTimeout, responseTimeout); - Append(sb, OptionKeys.DefaultDatabase, DefaultDatabase); - Append(sb, OptionKeys.SetClientLibrary, setClientLibrary); - Append(sb, OptionKeys.HighIntegrity, highIntegrity); - Append(sb, OptionKeys.Protocol, FormatProtocol(_protocol)); - Append(sb, OptionKeys.TcpKeepAlive, tcpKeepAlive); + Append(sb, OptionKeys.ConnectRetry, OptionFlags.ConnectRetryHasValue, in connectRetry); + Append(sb, OptionKeys.Proxy, OptionFlags.ProxyHasValue, in proxy); + Append(sb, OptionKeys.ConfigCheckSeconds, OptionFlags.ConfigCheckSecondsHasValue, in configCheckSeconds); + Append(sb, OptionKeys.ResponseTimeout, OptionFlags.ResponseTimeoutHasValue, in responseTimeout); + Append(sb, OptionKeys.DefaultDatabase, OptionFlags.DefaultDatabaseHasValue, in defaultDatabase); + Append(sb, OptionKeys.SetClientLibrary, OptionFlags.SetClientLibraryHasValue, OptionFlags.SetClientLibraryValue); + Append(sb, OptionKeys.HighIntegrity, OptionFlags.HighIntegrityHasValue, OptionFlags.HighIntegrityValue); + if (HasValue(OptionFlags.ProtocolHasValue)) Append(sb, OptionKeys.Protocol, FormatProtocol(_protocol)); + Append(sb, OptionKeys.TcpKeepAlive, OptionFlags.TcpKeepAliveHasValue, OptionFlags.TcpKeepAliveValue); if (Tunnel is { IsInbuilt: true } tunnel) { Append(sb, OptionKeys.Tunnel, tunnel.ToString()); @@ -953,54 +1060,117 @@ public string ToString(bool includePassword) commandMap?.AppendDeltas(sb); return sb.ToString(); - static string? FormatProtocol(RedisProtocol? protocol) => protocol switch { - null => null, + static string FormatProtocol(RedisProtocol protocol) => protocol switch { RedisProtocol.Resp2 => "resp2", RedisProtocol.Resp3 => "resp3", - _ => protocol.GetValueOrDefault().ToString(), + _ => protocol.ToString(), }; } - private static void Append(StringBuilder sb, object value) + private static void Append(StringBuilder sb, string? value) { - if (value == null) return; - string s = Format.ToString(value); - if (!string.IsNullOrWhiteSpace(s)) + if (!string.IsNullOrWhiteSpace(value)) { if (sb.Length != 0) sb.Append(','); - sb.Append(s); + sb.Append(value); } } - private static void Append(StringBuilder sb, string prefix, object? value) + private static void Append(StringBuilder sb, string prefix, string? value) { - string? s = value?.ToString(); - if (!string.IsNullOrWhiteSpace(s)) + if (!string.IsNullOrWhiteSpace(value)) { - if (sb.Length != 0) sb.Append(','); - if (!string.IsNullOrEmpty(prefix)) - { - sb.Append(prefix).Append('='); - } - sb.Append(s); + AppendPrefix(sb, prefix); + sb.Append(value); + } + } + + private static void Append(StringBuilder sb, string prefix, int value) + { + AppendPrefix(sb, prefix); + sb.Append(Format.ToString(value)); + } + + private static void Append(StringBuilder sb, string prefix, bool value) + { + AppendPrefix(sb, prefix); + sb.Append(value); + } + + private static void Append(StringBuilder sb, string prefix, Version? value) + { + if (value is not null) + { + Append(sb, prefix, Format.ToString(value)); + } + } + + private static void AppendPrefix(StringBuilder sb, string prefix) + { + if (sb.Length != 0) sb.Append(','); + if (!string.IsNullOrEmpty(prefix)) + { + sb.Append(prefix).Append('='); + } + } + + private void Append(StringBuilder sb, string prefix, OptionFlags hasValue, OptionFlags valueFlag) + { + if (HasValue(hasValue)) + { + Append(sb, prefix, IsSet(valueFlag)); + } + } + + private void Append(StringBuilder sb, string prefix, OptionFlags hasValue, in int value) + { + if (HasValue(hasValue)) + { + Append(sb, prefix, value); + } + } + + private void Append(StringBuilder sb, string prefix, OptionFlags hasValue, in Proxy value) + { + if (HasValue(hasValue)) + { + Append(sb, prefix, value.ToString()); } } private void Clear() { + defaultOptions = null; + optionFlags = OptionFlags.None; ClientName = ServiceName = user = password = tieBreaker = sslHost = configChannel = null; - keepAlive = syncTimeout = asyncTimeout = connectTimeout = connectRetry = configCheckSeconds = DefaultDatabase = null; - allowAdmin = abortOnConnectFail = resolveDns = ssl = setClientLibrary = highIntegrity = null; - SslProtocols = null; + keepAlive = syncTimeout = asyncTimeout = connectTimeout = responseTimeout = connectRetry = configCheckSeconds = defaultDatabase = 0; + sslProtocols = default; defaultVersion = null; + heartbeatInterval = default; EndPoints.Clear(); commandMap = null; + proxy = default; + reconnectRetryPolicy = null; + backlogPolicy = null; + loggerFactory = null; CertificateSelection = null; CertificateValidation = null; + BeforeSocketConnect = null; ChannelPrefix = default; + LibraryName = null; +#pragma warning disable CS0618 // Type or member is obsolete SocketManager = null; +#pragma warning restore CS0618 // Type or member is obsolete +#if NET + SslClientAuthenticationOptions = null; +#endif Tunnel = null; + _protocol = default; + WriteMode = default; +#if DEBUG + OutputLog = null; +#endif } object ICloneable.Clone() => Clone(); @@ -1141,7 +1311,7 @@ private ConfigurationOptions DoParse(string configuration, bool ignoreUnknown) } break; case OptionKeys.Protocol: - _protocol = OptionKeys.ParseRedisProtocol(key, value); + SetWithValue(OptionFlags.ProtocolHasValue, ref _protocol, OptionKeys.ParseRedisProtocol(key, value)); break; // Deprecated options we ignore... case OptionKeys.HighPrioritySocketThreads: @@ -1191,31 +1361,29 @@ private ConfigurationOptions DoParse(string configuration, bool ignoreUnknown) /// public RedisProtocol? Protocol { - get => _protocol ?? Defaults.Protocol; - set => _protocol = value; + get => HasValue(OptionFlags.ProtocolHasValue) ? _protocol : Defaults.Protocol; + set => Set(OptionFlags.ProtocolHasValue, ref _protocol, value); } - private RedisProtocol? _protocol; + internal BufferedStreamWriter.WriteMode WriteMode { get; set; } + internal bool AllowSimulateConnectionFailure + { + get => IsSet(OptionFlags.AllowSimulateConnectionFailure); + set => SetFlag(OptionFlags.AllowSimulateConnectionFailure, value); + } // for testing; **only** available via internal API +#if DEBUG + internal Action? OutputLog; +#endif internal bool TryResp3() { + // if Protocol specified: fine, otherwise lean on the server version var protocol = Protocol; - // note: deliberately leaving the IsAvailable duplicated to use short-circuit - - // if (protocol is null) - // { - // // if not specified, lean on the server version and whether HELLO is available - // return new RedisFeatures(DefaultVersion).Resp3 && CommandMap.IsAvailable(RedisCommand.HELLO); - // } - // else - // ^^^ left for context; originally our intention was to auto-enable RESP3 by default *if* the server version - // is >= 6; however, it turns out (see extensive conversation here https://github.com/StackExchange/StackExchange.Redis/pull/2396) - // that tangential undocumented API breaks were made at the same time; this means that even if we fix every - // edge case in the library itself, the break is still visible to external callers via Execute[Async]; with an - // abundance of caution, we are therefore making RESP3 explicit opt-in only for now; we may revisit this in a major - { - return protocol.GetValueOrDefault() >= RedisProtocol.Resp3 && CommandMap.IsAvailable(RedisCommand.HELLO); - } + bool use3 = protocol is null + ? new RedisFeatures(DefaultVersion).Resp3 + : protocol.GetValueOrDefault() >= RedisProtocol.Resp3; + // either way, it requires HELLO + return use3 && CommandMap.IsAvailable(RedisCommand.HELLO); } internal static bool TryParseRedisProtocol(string? value, out RedisProtocol protocol) diff --git a/src/StackExchange.Redis/ConnectionMultiplexer.ReaderWriter.cs b/src/StackExchange.Redis/ConnectionMultiplexer.ReaderWriter.cs deleted file mode 100644 index a30da7865..000000000 --- a/src/StackExchange.Redis/ConnectionMultiplexer.ReaderWriter.cs +++ /dev/null @@ -1,19 +0,0 @@ -using System.Diagnostics.CodeAnalysis; - -namespace StackExchange.Redis; - -public partial class ConnectionMultiplexer -{ - internal SocketManager? SocketManager { get; private set; } - - [MemberNotNull(nameof(SocketManager))] - private void OnCreateReaderWriter(ConfigurationOptions configuration) - { - SocketManager = configuration.SocketManager ?? SocketManager.Shared; - } - - private void OnCloseReaderWriter() - { - SocketManager = null; - } -} diff --git a/src/StackExchange.Redis/ConnectionMultiplexer.Sentinel.cs b/src/StackExchange.Redis/ConnectionMultiplexer.Sentinel.cs index 35276347d..1fe17599a 100644 --- a/src/StackExchange.Redis/ConnectionMultiplexer.Sentinel.cs +++ b/src/StackExchange.Redis/ConnectionMultiplexer.Sentinel.cs @@ -6,7 +6,6 @@ using System.Threading; using System.Threading.Tasks; using Microsoft.Extensions.Logging; -using Pipelines.Sockets.Unofficial; namespace StackExchange.Redis; @@ -106,7 +105,7 @@ public static Task SentinelConnectAsync(string configurat /// The to log to. public static ConnectionMultiplexer SentinelConnect(ConfigurationOptions configuration, TextWriter? log = null) { - SocketConnection.AssertDependencies(); + Dependencies.Assert(); Validate(configuration); return ConnectImpl(configuration, log, ServerType.Sentinel); @@ -119,7 +118,7 @@ public static ConnectionMultiplexer SentinelConnect(ConfigurationOptions configu /// The to log to. public static Task SentinelConnectAsync(ConfigurationOptions configuration, TextWriter? log = null) { - SocketConnection.AssertDependencies(); + Dependencies.Assert(); Validate(configuration); return ConnectImplAsync(configuration, log, ServerType.Sentinel); diff --git a/src/StackExchange.Redis/ConnectionMultiplexer.Threading.cs b/src/StackExchange.Redis/ConnectionMultiplexer.Threading.cs index a4ad1a025..a2a502039 100644 --- a/src/StackExchange.Redis/ConnectionMultiplexer.Threading.cs +++ b/src/StackExchange.Redis/ConnectionMultiplexer.Threading.cs @@ -1,6 +1,5 @@ using System; using System.Threading; -using Pipelines.Sockets.Unofficial; namespace StackExchange.Redis; diff --git a/src/StackExchange.Redis/ConnectionMultiplexer.cs b/src/StackExchange.Redis/ConnectionMultiplexer.cs index 84ec3480c..20c8576eb 100644 --- a/src/StackExchange.Redis/ConnectionMultiplexer.cs +++ b/src/StackExchange.Redis/ConnectionMultiplexer.cs @@ -12,7 +12,6 @@ using System.Threading; using System.Threading.Tasks; using Microsoft.Extensions.Logging; -using Pipelines.Sockets.Unofficial; using StackExchange.Redis.Profiling; namespace StackExchange.Redis @@ -147,7 +146,6 @@ private ConnectionMultiplexer(ConfigurationOptions configuration, ServerType? se map.AssertAvailable(RedisCommand.EXISTS); } - OnCreateReaderWriter(configuration); ServerSelectionStrategy = new ServerSelectionStrategy(this); var configChannel = configuration.ConfigurationChannel; @@ -352,7 +350,7 @@ internal void CheckMessage(Message message) } // using >= here because we will be adding 1 for the command itself (which is an argument for the purposes of the multi-bulk protocol) - if (message.ArgCount >= PhysicalConnection.REDIS_MAX_ARGS) + if (message.ArgCount >= MessageWriter.REDIS_MAX_ARGS) { throw ExceptionFactory.TooManyArgs(message.CommandAndKey, message.ArgCount); } @@ -569,7 +567,7 @@ public static Task ConnectAsync(string configuration, Act /// Note: For Sentinel, do not specify a - this is handled automatically. public static Task ConnectAsync(ConfigurationOptions configuration, TextWriter? log = null) { - SocketConnection.AssertDependencies(); + Dependencies.Assert(); Validate(configuration); return configuration.IsSentinel @@ -657,7 +655,7 @@ public static ConnectionMultiplexer Connect(string configuration, ActionNote: For Sentinel, do not specify a - this is handled automatically. public static ConnectionMultiplexer Connect(ConfigurationOptions configuration, TextWriter? log = null) { - SocketConnection.AssertDependencies(); + Dependencies.Assert(); Validate(configuration); return configuration.IsSentinel @@ -2307,7 +2305,6 @@ public void Close(bool allowCommandsToComplete = true) WaitAllIgnoreErrors(quits); } DisposeAndClearServers(); - OnCloseReaderWriter(); OnClosing(true); Interlocked.Increment(ref _connectionCloseCount); } diff --git a/src/StackExchange.Redis/CursorEnumerable.cs b/src/StackExchange.Redis/CursorEnumerable.cs index 921d83ce0..8f9863bb3 100644 --- a/src/StackExchange.Redis/CursorEnumerable.cs +++ b/src/StackExchange.Redis/CursorEnumerable.cs @@ -55,6 +55,17 @@ internal readonly struct ScanResult public readonly T[]? ValuesOversized; public readonly int Count; public readonly bool IsPooled; + public ReadOnlySpan Values => ValuesOversized is null ? [] : ValuesOversized.AsSpan(0, Count); + + public void Recycle() + { + if (IsPooled && ValuesOversized != null) + { + ArrayPool.Shared.Return(ValuesOversized); + } + + Unsafe.AsRef(in this) = default; // best effort wipe + } public ScanResult(RedisValue cursor, T[]? valuesOversized, int count, bool isPooled) { Cursor = cursor; diff --git a/src/StackExchange.Redis/Delegates.cs b/src/StackExchange.Redis/Delegates.cs new file mode 100644 index 000000000..66e97adec --- /dev/null +++ b/src/StackExchange.Redis/Delegates.cs @@ -0,0 +1,245 @@ +#if NET8_0_OR_GREATER +#define UNSAFE_ACCESSOR // retain ability to disable easily +#endif + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Runtime.CompilerServices; + +#if !UNSAFE_ACCESSOR +using System.Reflection; +using System.Reflection.Emit; +#endif + +namespace StackExchange.Redis; + +/// +/// Provides utility methods for working *efficiently* with multicast delegates. +/// +internal static class Delegates +{ + /// + /// Iterate over the individual elements of a multicast delegate (without allocation). + /// + /// The type of delegate being enumerated. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static DelegateEnumerator GetEnumerator(this T? handler) where T : MulticastDelegate + => handler is null ? default : new(handler); + + /// + /// Iterate over the individual elements of a multicast delegate (without allocation). + /// + /// The type of delegate being enumerated. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static DelegateEnumerable AsEnumerable(this T? handler) where T : MulticastDelegate + => new(handler); + + /// + /// Indicates whether a particular delegate is known to be a single-target delegate. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool IsSingle(this MulticastDelegate handler) + { +#if UNSAFE_ACCESSOR + return s_getArr(handler) is null; +#else + if (s_isAvailable) + { + if (s_getArr is not null) + { + return s_getArr(handler) is null; + } + + return s_delegates!(handler) is null; + } + return handler.GetInvocationList().Length == 1; +#endif + } + + /// + /// Indicates whether optimized usage is supported on this environment; without this, it may still + /// work, but with additional overheads at runtime. + /// + public static bool IsSupported => s_isAvailable; + +#if UNSAFE_ACCESSOR +#pragma warning disable SA1300 + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_invocationList")] + private static extern ref readonly object? s_getArr(MulticastDelegate handler); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_invocationCount")] + private static extern ref readonly nint s_getCount(MulticastDelegate handler); + + // ReSharper disable once InconsistentNaming +#pragma warning disable SA1303 + private const bool s_isAvailable = true; +#pragma warning restore SA1303 + +#pragma warning restore SA1300 +#else +#pragma warning disable SA1300 + private static readonly Func? s_getArr; + private static readonly Func? s_getCount; + private static readonly Func? s_delegates; + + private static readonly bool s_isAvailable = IsAvailable(out s_getArr, out s_getCount, out s_delegates); + + private static bool IsAvailable( + out Func? getArr, + out Func? getCount, + out Func? delegates) + { + // look for .NET's convention + getArr = GetGetter("_invocationList"); + getCount = GetGetter("_invocationCount"); + if (getArr is not null & getCount is not null) + { + delegates = null; + return true; + } + + // try for Mono + getArr = null; + getCount = null; + delegates = GetGetter("delegates"); + return delegates is not null; + } + +#pragma warning restore SA1300 + + private static Func? GetGetter(string fieldName) + { + try + { + var field = typeof(MulticastDelegate).GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance); + + if (field is null || field.FieldType != typeof(T)) return null; + +#if !NETSTANDARD2_0 + try // we can try use ref-emit + { + var dm = new DynamicMethod(fieldName, typeof(T), new[] { typeof(MulticastDelegate) }, typeof(MulticastDelegate), true); + var il = dm.GetILGenerator(); + il.Emit(OpCodes.Ldarg_0); + il.Emit(OpCodes.Ldfld, field); + il.Emit(OpCodes.Ret); + return (Func)dm.CreateDelegate(typeof(Func)); + } + catch { } +#endif + return GetViaReflection(field); + } + catch + { + return null; + } + } + private static Func GetViaReflection(FieldInfo field) + => handler => (T)field.GetValue(handler)!; +#endif + + /// + /// Allows allocation-free enumerator over the individual elements of a multicast delegate. + /// + /// The type of delegate being enumerated. + public readonly struct DelegateEnumerable : IEnumerable where T : MulticastDelegate + { + private readonly T? _handler; + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal DelegateEnumerable(T? handler) => _handler = handler; + + /// + /// Iterate over the individual elements of a multicast delegate (without allocation). + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public DelegateEnumerator GetEnumerator() + => _handler is null ? default : new DelegateEnumerator(_handler); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } + + /// + /// Allows allocation-free enumerator over the individual elements of a multicast delegate. + /// + /// The type of delegate being enumerated. + public struct DelegateEnumerator : IEnumerator where T : MulticastDelegate + { + private readonly T _handler; + private readonly object[]? _arr; + private readonly int _count; + private int _index; + private T? _current; + internal DelegateEnumerator(T handler) + { + // Debug.Assert(handler is not null); + _handler = handler; +#if UNSAFE_ACCESSOR + _arr = s_getArr(handler) as object[]; + _count = _arr is null ? 1 : (int)s_getCount(handler); +#else + if (s_isAvailable) + { + if (s_delegates is null) + { + _arr = s_getArr!(handler) as object[]; + _count = _arr is null ? 1 : (int)s_getCount!(handler); + } + else + { + // ReSharper disable once CoVariantArrayConversion + _arr = s_delegates(handler); + _count = _arr?.Length ?? 1; + } + } + else + { + // ReSharper disable once CoVariantArrayConversion + _arr = handler.GetInvocationList(); + _count = _arr.Length; + } +#endif + _current = null; + _index = -1; + } + + /// + /// Provides the current value of the sequence. + /// + public T Current + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get => _current!; + } + + object? IEnumerator.Current => Current; + + void IDisposable.Dispose() { } + + /// + /// Move to the next item in the sequence. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool MoveNext() + { + var next = _index + 1; + if (next >= _count) + { + _current = null; + return false; + } + _current = _arr is null ? _handler : (T)_arr[next]; + _index = next; + return true; + } + + /// + /// Reset the enumerator, allowing the sequence to be repeated. + /// + public void Reset() + { + _current = null; + _index = -1; + } + } +} diff --git a/src/StackExchange.Redis/Dependencies.cs b/src/StackExchange.Redis/Dependencies.cs new file mode 100644 index 000000000..5c16015da --- /dev/null +++ b/src/StackExchange.Redis/Dependencies.cs @@ -0,0 +1,120 @@ +using System; +using System.Buffers; +using System.Collections.Generic; +using System.IO.Pipelines; +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Text.RegularExpressions; +using System.Threading.Channels; + +namespace StackExchange.Redis; + +internal static class Dependencies +{ + internal static void Assert() + { + string err = GetAssemblyFailureMessage(); + if (!string.IsNullOrEmpty(err)) Throw(err); + static void Throw(string message) => throw new InvalidOperationException(message); + } + + // ReSharper disable once InconsistentNaming + private static string? s_assemblyFailureMessssage; + + private static string GetAssemblyFailureMessage() + { + static string ComputeAssemblyFailureMessage() + { + List? failures = null; + void AddFailure(string assembly) + { + if (failures is null) failures = new List(); + failures.Add(assembly); + } + + try { CheckBclAsync(); } catch { AddFailure("Microsoft.Bcl.AsyncInterfaces"); } + try { CheckBuffers(); } catch { AddFailure("System.Buffers"); } + try { CheckMemory(); } catch { AddFailure("System.Memory"); } + try { CheckUnsafe(); } catch { AddFailure("System.Runtime.CompilerServices.Unsafe"); } + try { CheckNumerics(); } catch { AddFailure("System.Numerics.Vectors"); } + try { CheckPipe(); } catch { AddFailure("System.IO.Pipelines"); } + try { CheckChannels(); } catch { AddFailure("System.Threading.Channels"); } + + try + { + ExecutePipe(out var assembly); + if (assembly is not null) AddFailure(assembly); + } + catch (Exception ex) + { + // things went bad, but not in a way we expected + return ex.Message; + } + + if (failures is null || failures.Count == 0) return ""; + + return "The assembly for " + string.Join(" + ", failures) + " could not be loaded; this usually means a missing assembly binding redirect - try checking this, and adding any that are missing;" + + " note that it is not always possible to add this redirects - for example 'azure functions v1'; it looks like you may need to use 'azure functions v2' for that - sorry, but that's out of our control"; + } + return s_assemblyFailureMessssage ??= ComputeAssemblyFailureMessage(); + + [MethodImpl(MethodImplOptions.NoInlining)] + static void ExecutePipe(out string? assembly) + { + // try everything combined + assembly = null; + try + { + var pipe = new Pipe(); + pipe.Writer.GetSpan(4); + pipe.Writer.Advance(4); + pipe.Writer.Complete(); + pipe.Reader.TryRead(out var _); + } + catch (Exception ex) + { + // look (non-greedy) for either 'System.Blah' or 'System.Blah,... + var match = Regex.Match(ex.Message, @"'(System\..*?)[,']"); + if (match.Success) + { + assembly = match.Groups[1].Value; + } + else + { + throw; + } + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static void CheckBclAsync() => GC.KeepAlive(typeof(IAsyncDisposable)); + + [MethodImpl(MethodImplOptions.NoInlining)] + static void CheckChannels() => GC.KeepAlive(typeof(Channel)); + + [MethodImpl(MethodImplOptions.NoInlining)] + static void CheckPipe() => GC.KeepAlive(PipeOptions.Default); + + [MethodImpl(MethodImplOptions.NoInlining)] + static void CheckBuffers() + { + var arr = ArrayPool.Shared.Rent(64); + GC.KeepAlive(arr); + ArrayPool.Shared.Return(arr); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static void CheckMemory() + { + var buffer = MemoryPool.Shared.Rent(64); + GC.KeepAlive(buffer); + buffer.Dispose(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static void CheckUnsafe() => _ = Unsafe.SizeOf(); + + [MethodImpl(MethodImplOptions.NoInlining)] + static void CheckNumerics() => _ = Vector.IsHardwareAccelerated; + } +} diff --git a/src/StackExchange.Redis/Enums/CommandFlags.cs b/src/StackExchange.Redis/Enums/CommandFlags.cs index 90021e791..ff69fb750 100644 --- a/src/StackExchange.Redis/Enums/CommandFlags.cs +++ b/src/StackExchange.Redis/Enums/CommandFlags.cs @@ -106,7 +106,7 @@ public enum CommandFlags /// NoScriptCache = 512, - // 1024: Removed - was used for async timeout checks; never user-specified, so not visible on the public API + // 1024: used for "no flush"; never user-specified, so not visible on the public API // 2048: Use subscription connection type; never user-specified, so not visible on the public API diff --git a/src/StackExchange.Redis/Enums/RedisType.cs b/src/StackExchange.Redis/Enums/RedisType.cs index 7ab7b8ab1..6117d7c2e 100644 --- a/src/StackExchange.Redis/Enums/RedisType.cs +++ b/src/StackExchange.Redis/Enums/RedisType.cs @@ -1,4 +1,5 @@ -using System.Diagnostics.CodeAnalysis; +using System; +using System.Diagnostics.CodeAnalysis; using RESPite; namespace StackExchange.Redis @@ -12,6 +13,7 @@ public enum RedisType /// /// The specified key does not exist. /// + [AsciiHash("")] None, /// @@ -20,6 +22,7 @@ public enum RedisType /// A String value can be at max 512 Megabytes in length. /// /// + [AsciiHash("string")] String, /// @@ -28,6 +31,7 @@ public enum RedisType /// on the tail (on the right) of the list. /// /// + [AsciiHash("list")] List, /// @@ -38,6 +42,7 @@ public enum RedisType /// Practically speaking this means that adding a member does not require a check if exists then add operation. /// /// + [AsciiHash("set")] Set, /// @@ -47,6 +52,7 @@ public enum RedisType /// While members are unique, scores may be repeated. /// /// + [AsciiHash("zset")] SortedSet, /// @@ -54,6 +60,7 @@ public enum RedisType /// to represent objects (e.g. A User with a number of fields like name, surname, age, and so forth). /// /// + [AsciiHash("hash")] Hash, /// @@ -62,6 +69,7 @@ public enum RedisType /// stream contains a unique message ID and a list of name/value pairs containing the entry's data. /// /// + [AsciiHash("stream")] Stream, /// @@ -73,12 +81,23 @@ public enum RedisType /// Vector sets are a data type similar to sorted sets, but instead of a score, /// vector set elements have a string representation of a vector. /// + [AsciiHash("vectorset")] VectorSet, /// /// Redis Arrays are sparse arrays of arbitrary values with a notional write head. /// [Experimental(Experiments.Server_8_8, UrlFormat = Experiments.UrlFormat)] + [AsciiHash("array")] Array, } + + /// + /// Metadata and parsing methods for RedisType. + /// + internal static partial class RedisTypeMetadata + { + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out RedisType redisType); + } } diff --git a/src/StackExchange.Redis/Enums/ServerType.cs b/src/StackExchange.Redis/Enums/ServerType.cs index e37d38b08..f364765e9 100644 --- a/src/StackExchange.Redis/Enums/ServerType.cs +++ b/src/StackExchange.Redis/Enums/ServerType.cs @@ -47,6 +47,9 @@ internal static partial class ServerTypeMetadata [AsciiHash] internal static partial bool TryParse(ReadOnlySpan value, out ServerType serverType); + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out ServerType serverType); + internal static bool TryParse(string? val, out ServerType serverType) { if (val is not null) return TryParse(val.AsSpan().Trim(), out serverType); @@ -67,7 +70,7 @@ internal static class ServerTypeExtensions }; /// - /// Whether a server type supports . + /// Whether a server type supports . /// internal static bool SupportsAutoConfigure(this ServerType type) => type switch { diff --git a/src/StackExchange.Redis/ExceptionFactory.cs b/src/StackExchange.Redis/ExceptionFactory.cs index 434abce17..a6e86036b 100644 --- a/src/StackExchange.Redis/ExceptionFactory.cs +++ b/src/StackExchange.Redis/ExceptionFactory.cs @@ -28,7 +28,7 @@ internal static Exception CommandDisabled(string command) => new RedisCommandException("This operation has been disabled in the command-map and cannot be used: " + command); internal static Exception TooManyArgs(string command, int argCount) - => new RedisCommandException($"This operation would involve too many arguments ({argCount + 1} vs the redis limit of {PhysicalConnection.REDIS_MAX_ARGS}): {command}"); + => new RedisCommandException($"This operation would involve too many arguments ({argCount + 1} vs the redis limit of {MessageWriter.REDIS_MAX_ARGS}): {command}"); internal static Exception ConnectionFailure(bool includeDetail, ConnectionFailureType failureType, string message, ServerEndPoint? server) { @@ -367,7 +367,6 @@ private static void AddCommonDetail( Add(data, sb, "Abort-On-Connect", "aoc", multiplexer.RawConfig.AbortOnConnectFail ? "1" : "0"); } Add(data, sb, "Multiplexer-Connects", "mc", $"{multiplexer._connectAttemptCount}/{multiplexer._connectCompletedCount}/{multiplexer._connectionCloseCount}"); - Add(data, sb, "Manager", "mgr", multiplexer.SocketManager?.GetState()); Add(data, sb, "Client-Name", "clientName", multiplexer.ClientName); if (message != null) diff --git a/src/StackExchange.Redis/Expiration.cs b/src/StackExchange.Redis/Expiration.cs index c1a874331..9c747f1bf 100644 --- a/src/StackExchange.Redis/Expiration.cs +++ b/src/StackExchange.Redis/Expiration.cs @@ -237,12 +237,12 @@ internal RedisValue GetOperand(out long value) if (IsPersist) return RedisLiterals.PERSIST; if ((_flags & ExpirationState.HasExpiration) == 0) return RedisValue.Null; - return (IsAbsolute, IsMilliseconds) switch + return (_flags & (ExpirationState.IsAbsolute | ExpirationState.IsMillis)) switch { - (false, false) => RedisLiterals.EX, - (false, true) => RedisLiterals.PX, - (true, false) => RedisLiterals.EXAT, - (true, true) => RedisLiterals.PXAT, + ExpirationState.IsAbsolute | ExpirationState.IsMillis => RedisLiterals.PXAT, + ExpirationState.IsAbsolute => RedisLiterals.EXAT, + ExpirationState.IsMillis => RedisLiterals.PX, + _ => RedisLiterals.EX, }; } @@ -252,7 +252,7 @@ public override string ToString() if (IsNone) return ""; if (IsKeepTtl) return "KEEPTTL"; if (IsPersist) return "PERSIST"; - return IsExpireIfNotExists ? $"{Operand} {Value} {RedisLiterals.ENX}" : $"{Operand} {Value}"; + return IsExpireIfNotExists ? $"{Operand} {Value} ENX" : $"{Operand} {Value}"; } /// @@ -275,7 +275,7 @@ internal int GetTokenCount(bool allowEnx) static int ThrowEnxNotSupported() => throw new NotSupportedException("ENX is not supported for this command."); } - internal void WriteTo(PhysicalConnection physical) + internal void WriteTo(in MessageWriter writer) { if (IsNone) { @@ -284,27 +284,27 @@ internal void WriteTo(PhysicalConnection physical) if (IsKeepTtl) { - physical.WriteBulkString("KEEPTTL"u8); + writer.WriteRaw("$7\r\nKEEPTTL\r\n"u8); return; } if (IsPersist) { - physical.WriteBulkString("PERSIST"u8); + writer.WriteRaw("$7\r\nPERSIST\r\n"u8); return; } - physical.WriteBulkString((IsAbsolute, IsMilliseconds) switch + writer.WriteRaw((_flags & (ExpirationState.IsAbsolute | ExpirationState.IsMillis)) switch { - (false, false) => "EX"u8, - (false, true) => "PX"u8, - (true, false) => "EXAT"u8, - (true, true) => "PXAT"u8, + ExpirationState.IsAbsolute | ExpirationState.IsMillis => "$4\r\nPXAT\r\n"u8, + ExpirationState.IsAbsolute => "$4\r\nEXAT\r\n"u8, + ExpirationState.IsMillis => "$2\r\nPX\r\n"u8, + _ => "$2\r\nEX\r\n"u8, }); - physical.WriteBulkString(Value); + writer.WriteBulkString(Value); if (IsExpireIfNotExists) { - physical.WriteBulkString("ENX"u8); + writer.WriteRaw("$3\r\nENX\r\n"u8); } } } diff --git a/src/StackExchange.Redis/ExtensionMethods.Internal.cs b/src/StackExchange.Redis/ExtensionMethods.Internal.cs index 34a83b33b..09affa657 100644 --- a/src/StackExchange.Redis/ExtensionMethods.Internal.cs +++ b/src/StackExchange.Redis/ExtensionMethods.Internal.cs @@ -1,6 +1,8 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.Diagnostics.CodeAnalysis; +using System.Net.Sockets; namespace StackExchange.Redis { diff --git a/src/StackExchange.Redis/ExtensionMethods.cs b/src/StackExchange.Redis/ExtensionMethods.cs index e5a5c4d4d..2052e3838 100644 --- a/src/StackExchange.Redis/ExtensionMethods.cs +++ b/src/StackExchange.Redis/ExtensionMethods.cs @@ -7,8 +7,10 @@ using System.Security.Authentication; using System.Security.Cryptography.X509Certificates; using System.Text; +using System.Threading; using System.Threading.Tasks; -using Pipelines.Sockets.Unofficial.Arenas; +using RESPite; +using RESPite.Messages; namespace StackExchange.Redis { @@ -329,13 +331,5 @@ internal static int VectorSafeIndexOfCRLF(this ReadOnlySpan span) return -1; } #endif - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal static T[]? ToArray(in this RawResult result, Projection selector) - => result.IsNull ? null : result.GetItems().ToArray(selector); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal static TTo[]? ToArray(in this RawResult result, Projection selector, in TState state) - => result.IsNull ? null : result.GetItems().ToArray(selector, in state); } } diff --git a/src/StackExchange.Redis/Format.cs b/src/StackExchange.Redis/Format.cs index c7dc1e0a7..e28913e90 100644 --- a/src/StackExchange.Redis/Format.cs +++ b/src/StackExchange.Redis/Format.cs @@ -5,6 +5,7 @@ using System.Globalization; using System.Net; using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; using System.Text; #if UNIX_SOCKET @@ -409,7 +410,7 @@ internal static unsafe string GetString(ReadOnlySpan span) #if NET return Encoding.UTF8.GetString(span); #else - fixed (byte* ptr = span) + fixed (byte* ptr = &MemoryMarshal.GetReference(span)) { return Encoding.UTF8.GetString(ptr, span.Length); } diff --git a/src/StackExchange.Redis/FrameworkShims.IsExternalInit.cs b/src/StackExchange.Redis/FrameworkShims.IsExternalInit.cs new file mode 100644 index 000000000..417975050 --- /dev/null +++ b/src/StackExchange.Redis/FrameworkShims.IsExternalInit.cs @@ -0,0 +1,15 @@ +using System.ComponentModel; + +#if NET5_0_OR_GREATER +// context: https://github.com/StackExchange/StackExchange.Redis/issues/2619 +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.CompilerServices.IsExternalInit))] +#else + +// To support { get; init; } properties +// ReSharper disable once CheckNamespace +namespace System.Runtime.CompilerServices +{ + [EditorBrowsable(EditorBrowsableState.Never)] + internal static class IsExternalInit { } +} +#endif diff --git a/src/StackExchange.Redis/FrameworkShims.cs b/src/StackExchange.Redis/FrameworkShims.cs deleted file mode 100644 index 8907d33dc..000000000 --- a/src/StackExchange.Redis/FrameworkShims.cs +++ /dev/null @@ -1,80 +0,0 @@ -#pragma warning disable SA1403 // single namespace - -#if NET -// context: https://github.com/StackExchange/StackExchange.Redis/issues/2619 -[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.CompilerServices.IsExternalInit))] -#else -// To support { get; init; } properties -using System.ComponentModel; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Text; - -namespace System.Runtime.CompilerServices -{ - [EditorBrowsable(EditorBrowsableState.Never)] - internal static class IsExternalInit { } -} -#endif - -#if !NET10_0_OR_GREATER -namespace System.Runtime.CompilerServices -{ - // see https://learn.microsoft.com/dotnet/api/system.runtime.compilerservices.overloadresolutionpriorityattribute - [AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, Inherited = false)] - internal sealed class OverloadResolutionPriorityAttribute(int priority) : Attribute - { - public int Priority => priority; - } -} -#endif - -#if !NET - -namespace System.Text -{ - internal static class EncodingExtensions - { - public static unsafe int GetBytes(this Encoding encoding, ReadOnlySpan source, Span destination) - { - fixed (byte* bPtr = &MemoryMarshal.GetReference(destination)) - { - fixed (char* cPtr = &MemoryMarshal.GetReference(source)) - { - return encoding.GetBytes(cPtr, source.Length, bPtr, destination.Length); - } - } - } - - public static unsafe int GetChars(this Encoding encoding, ReadOnlySpan source, Span destination) - { - fixed (byte* bPtr = &MemoryMarshal.GetReference(source)) - { - fixed (char* cPtr = &MemoryMarshal.GetReference(destination)) - { - return encoding.GetChars(bPtr, source.Length, cPtr, destination.Length); - } - } - } - - public static unsafe int GetCharCount(this Encoding encoding, ReadOnlySpan source) - { - fixed (byte* bPtr = &MemoryMarshal.GetReference(source)) - { - return encoding.GetCharCount(bPtr, source.Length); - } - } - - public static unsafe string GetString(this Encoding encoding, ReadOnlySpan source) - { - fixed (byte* bPtr = &MemoryMarshal.GetReference(source)) - { - return encoding.GetString(bPtr, source.Length); - } - } - } -} -#endif - - -#pragma warning restore SA1403 diff --git a/src/StackExchange.Redis/HelloField.cs b/src/StackExchange.Redis/HelloField.cs new file mode 100644 index 000000000..e5d730ce4 --- /dev/null +++ b/src/StackExchange.Redis/HelloField.cs @@ -0,0 +1,55 @@ +using System; +using RESPite; + +namespace StackExchange.Redis; + +/// +/// Fields that can appear in a HELLO command response. +/// +internal enum HelloField +{ + /// + /// Unknown or unrecognized field. + /// + [AsciiHash("")] + Unknown = 0, + + /// + /// Redis server version. + /// + [AsciiHash("version")] + Version, + + /// + /// Protocol version (2 or 3). + /// + [AsciiHash("proto")] + Proto, + + /// + /// Connection ID. + /// + [AsciiHash("id")] + Id, + + /// + /// Server mode (standalone, cluster, sentinel). + /// + [AsciiHash("mode")] + Mode, + + /// + /// Server role (master/primary, slave/replica). + /// + [AsciiHash("role")] + Role, +} + +/// +/// Metadata and parsing methods for HelloField. +/// +internal static partial class HelloFieldMetadata +{ + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out HelloField field); +} diff --git a/src/StackExchange.Redis/HotKeys.ResultProcessor.cs b/src/StackExchange.Redis/HotKeys.ResultProcessor.cs index 71644c010..10b2d6357 100644 --- a/src/StackExchange.Redis/HotKeys.ResultProcessor.cs +++ b/src/StackExchange.Redis/HotKeys.ResultProcessor.cs @@ -1,4 +1,8 @@ -namespace StackExchange.Redis; +using System; +using RESPite; +using RESPite.Messages; + +namespace StackExchange.Redis; public sealed partial class HotKeysResult { @@ -6,21 +10,22 @@ public sealed partial class HotKeysResult private sealed class HotKeysResultProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.IsNull) + if (reader.IsNull) { SetResult(message, null); return true; } // an array with a single element that *is* an array/map that is the results - if (result is { Resp2TypeArray: ResultType.Array, ItemsCount: 1 }) + if (reader.IsAggregate && reader.AggregateLengthIs(1)) { - ref readonly RawResult inner = ref result[0]; - if (inner is { Resp2TypeArray: ResultType.Array, IsNull: false }) + var iter = reader.AggregateChildren(); + iter.DemandNext(); + if (iter.Value.IsAggregate && !iter.Value.IsNull) { - var hotKeys = new HotKeysResult(in inner); + var hotKeys = new HotKeysResult(ref iter.Value); SetResult(message, hotKeys); return true; } @@ -30,160 +35,146 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes } } - private HotKeysResult(in RawResult result) + private HotKeysResult(ref RespReader reader) { var metrics = HotKeysMetrics.None; // we infer this from the keys present - var iter = result.GetItems().GetEnumerator(); - while (iter.MoveNext()) + int count = reader.AggregateLength(); + if ((count & 1) != 0) return; // must be even (key-value pairs) + + while (reader.TryMoveNext() && reader.IsScalar) { - if (!iter.Current.TryParse(HotKeysFieldMetadata.TryParse, out HotKeysField field)) - field = HotKeysField.Unknown; + HotKeysField field; + unsafe + { + if (!reader.TryParseScalar(&HotKeysFieldMetadata.TryParse, out field)) + { + field = HotKeysField.Unknown; + } + } - if (!iter.MoveNext()) break; // lies about the length! - ref readonly RawResult value = ref iter.Current; + // Move to value + if (!reader.TryMoveNext()) break; long i64; switch (field) { case HotKeysField.TrackingActive: - TrackingActive = value.GetBoolean(); + TrackingActive = reader.ReadBoolean(); break; - case HotKeysField.SampleRatio when value.TryGetInt64(out i64): + case HotKeysField.SampleRatio when reader.TryReadInt64(out i64): SampleRatio = i64; break; - case HotKeysField.SelectedSlots when value.Resp2TypeArray is ResultType.Array: - var len = value.ItemsCount; - if (len == 0) - { - _selectedSlots = []; - continue; - } - - var items = value.GetItems().GetEnumerator(); - var slots = len == 1 ? null : new SlotRange[len]; - for (int i = 0; i < len && items.MoveNext(); i++) - { - ref readonly RawResult pair = ref items.Current; - if (pair.Resp2TypeArray is ResultType.Array) + case HotKeysField.SelectedSlots when reader.IsAggregate: + var slotRanges = reader.ReadPastArray( + static (ref RespReader slotReader) => { + if (!slotReader.IsAggregate) return default; + + int pairLen = slotReader.AggregateLength(); long from = -1, to = -1; - switch (pair.ItemsCount) - { - case 1 when pair[0].TryGetInt64(out from): - to = from; // single slot - break; - case 2 when pair[0].TryGetInt64(out from) && pair[1].TryGetInt64(out to): - break; - } - if (from < SlotRange.MinSlot) - { - // skip invalid ranges - } - else if (len == 1 & from == SlotRange.MinSlot & to == SlotRange.MaxSlot) + var pairIter = slotReader.AggregateChildren(); + if (pairLen >= 1 && pairIter.MoveNext() && pairIter.Value.TryReadInt64(out from)) { - // this is the "normal" case when no slot filter was applied - slots = SlotRange.SharedAllSlots; // avoid the alloc + to = from; // single slot + if (pairLen >= 2 && pairIter.MoveNext() && pairIter.Value.TryReadInt64(out to)) + { + // to is now set + } } - else - { - slots ??= new SlotRange[len]; - slots[i] = new((int)from, (int)to); - } - } + + return from >= SlotRange.MinSlot ? new SlotRange((int)from, (int)to) : default; + }, + scalar: false); + + if (slotRanges is { Length: 1 } && slotRanges[0].From == SlotRange.MinSlot && slotRanges[0].To == SlotRange.MaxSlot) + { + // this is the "normal" case when no slot filter was applied + _selectedSlots = SlotRange.SharedAllSlots; // avoid the alloc + } + else + { + _selectedSlots = slotRanges ?? []; } - _selectedSlots = slots; break; - case HotKeysField.AllCommandsAllSlotsUs when value.TryGetInt64(out i64): + case HotKeysField.AllCommandsAllSlotsUs when reader.TryReadInt64(out i64): AllCommandsAllSlotsMicroseconds = i64; break; - case HotKeysField.AllCommandsSelectedSlotsUs when value.TryGetInt64(out i64): + case HotKeysField.AllCommandsSelectedSlotsUs when reader.TryReadInt64(out i64): AllCommandSelectedSlotsMicroseconds = i64; break; - case HotKeysField.SampledCommandSelectedSlotsUs when value.TryGetInt64(out i64): - case HotKeysField.SampledCommandsSelectedSlotsUs when value.TryGetInt64(out i64): + case HotKeysField.SampledCommandSelectedSlotsUs when reader.TryReadInt64(out i64): + case HotKeysField.SampledCommandsSelectedSlotsUs when reader.TryReadInt64(out i64): SampledCommandsSelectedSlotsMicroseconds = i64; break; - case HotKeysField.NetBytesAllCommandsAllSlots when value.TryGetInt64(out i64): + case HotKeysField.NetBytesAllCommandsAllSlots when reader.TryReadInt64(out i64): AllCommandsAllSlotsNetworkBytes = i64; break; - case HotKeysField.NetBytesAllCommandsSelectedSlots when value.TryGetInt64(out i64): + case HotKeysField.NetBytesAllCommandsSelectedSlots when reader.TryReadInt64(out i64): NetworkBytesAllCommandsSelectedSlotsRaw = i64; break; - case HotKeysField.NetBytesSampledCommandsSelectedSlots when value.TryGetInt64(out i64): + case HotKeysField.NetBytesSampledCommandsSelectedSlots when reader.TryReadInt64(out i64): NetworkBytesSampledCommandsSelectedSlotsRaw = i64; break; - case HotKeysField.CollectionStartTimeUnixMs when value.TryGetInt64(out i64): + case HotKeysField.CollectionStartTimeUnixMs when reader.TryReadInt64(out i64): CollectionStartTimeUnixMilliseconds = i64; break; - case HotKeysField.CollectionDurationMs when value.TryGetInt64(out i64): + case HotKeysField.CollectionDurationMs when reader.TryReadInt64(out i64): CollectionDurationMicroseconds = i64 * 1000; // ms vs us is in question: support both, and abstract it from the caller break; - case HotKeysField.CollectionDurationUs when value.TryGetInt64(out i64): + case HotKeysField.CollectionDurationUs when reader.TryReadInt64(out i64): CollectionDurationMicroseconds = i64; break; - case HotKeysField.TotalCpuTimeSysMs when value.TryGetInt64(out i64): + case HotKeysField.TotalCpuTimeSysMs when reader.TryReadInt64(out i64): metrics |= HotKeysMetrics.Cpu; TotalCpuTimeSystemMicroseconds = i64 * 1000; // ms vs us is in question: support both, and abstract it from the caller break; - case HotKeysField.TotalCpuTimeSysUs when value.TryGetInt64(out i64): + case HotKeysField.TotalCpuTimeSysUs when reader.TryReadInt64(out i64): metrics |= HotKeysMetrics.Cpu; TotalCpuTimeSystemMicroseconds = i64; break; - case HotKeysField.TotalCpuTimeUserMs when value.TryGetInt64(out i64): + case HotKeysField.TotalCpuTimeUserMs when reader.TryReadInt64(out i64): metrics |= HotKeysMetrics.Cpu; TotalCpuTimeUserMicroseconds = i64 * 1000; // ms vs us is in question: support both, and abstract it from the caller break; - case HotKeysField.TotalCpuTimeUserUs when value.TryGetInt64(out i64): + case HotKeysField.TotalCpuTimeUserUs when reader.TryReadInt64(out i64): metrics |= HotKeysMetrics.Cpu; TotalCpuTimeUserMicroseconds = i64; break; - case HotKeysField.TotalNetBytes when value.TryGetInt64(out i64): + case HotKeysField.TotalNetBytes when reader.TryReadInt64(out i64): metrics |= HotKeysMetrics.Network; TotalNetworkBytesRaw = i64; break; - case HotKeysField.ByCpuTimeUs when value.Resp2TypeArray is ResultType.Array: + case HotKeysField.ByCpuTimeUs when reader.IsAggregate: metrics |= HotKeysMetrics.Cpu; - len = value.ItemsCount / 2; - if (len == 0) + int cpuLen = reader.AggregateLength() / 2; + var cpuTime = new MetricKeyCpu[cpuLen]; + var cpuIter = reader.AggregateChildren(); + int cpuIdx = 0; + while (cpuIter.MoveNext() && cpuIdx < cpuLen) { - _cpuByKey = []; - continue; - } - - var cpuTime = new MetricKeyCpu[len]; - items = value.GetItems().GetEnumerator(); - for (int i = 0; i < len && items.MoveNext(); i++) - { - var metricKey = items.Current.AsRedisKey(); - if (items.MoveNext() && items.Current.TryGetInt64(out var metricValue)) + var metricKey = cpuIter.Value.ReadRedisKey(); + if (cpuIter.MoveNext() && cpuIter.Value.TryReadInt64(out var metricValue)) { - cpuTime[i] = new(metricKey, metricValue); + cpuTime[cpuIdx++] = new(metricKey, metricValue); } } - _cpuByKey = cpuTime; break; - case HotKeysField.ByNetBytes when value.Resp2TypeArray is ResultType.Array: + case HotKeysField.ByNetBytes when reader.IsAggregate: metrics |= HotKeysMetrics.Network; - len = value.ItemsCount / 2; - if (len == 0) + int netLen = reader.AggregateLength() / 2; + var netBytes = new MetricKeyBytes[netLen]; + var netIter = reader.AggregateChildren(); + int netIdx = 0; + while (netIter.MoveNext() && netIdx < netLen) { - _networkBytesByKey = []; - continue; - } - - var netBytes = new MetricKeyBytes[len]; - items = value.GetItems().GetEnumerator(); - for (int i = 0; i < len && items.MoveNext(); i++) - { - var metricKey = items.Current.AsRedisKey(); - if (items.MoveNext() && items.Current.TryGetInt64(out var metricValue)) + var metricKey = netIter.Value.ReadRedisKey(); + if (netIter.MoveNext() && netIter.Value.TryReadInt64(out var metricValue)) { - netBytes[i] = new(metricKey, metricValue); + netBytes[netIdx++] = new(metricKey, metricValue); } } - _networkBytesByKey = netBytes; break; } // switch diff --git a/src/StackExchange.Redis/HotKeys.StartMessage.cs b/src/StackExchange.Redis/HotKeys.StartMessage.cs index a869945b2..9a4bc0f5a 100644 --- a/src/StackExchange.Redis/HotKeys.StartMessage.cs +++ b/src/StackExchange.Redis/HotKeys.StartMessage.cs @@ -12,7 +12,7 @@ internal sealed class HotKeysStartMessage( long sampleRatio, int[]? slots) : Message(-1, flags, RedisCommand.HOTKEYS) { - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { /* HOTKEYS START @@ -22,41 +22,41 @@ [DURATION duration] [SAMPLE ratio] [SLOTS count slot…] */ - physical.WriteHeader(Command, ArgCount); - physical.WriteBulkString("START"u8); - physical.WriteBulkString("METRICS"u8); + writer.WriteHeader(Command, ArgCount); + writer.WriteRaw("$5\r\nSTART\r\n"u8); + writer.WriteRaw("$7\r\nMETRICS\r\n"u8); var metricCount = 0; if ((metrics & HotKeysMetrics.Cpu) != 0) metricCount++; if ((metrics & HotKeysMetrics.Network) != 0) metricCount++; - physical.WriteBulkString(metricCount); - if ((metrics & HotKeysMetrics.Cpu) != 0) physical.WriteBulkString("CPU"u8); - if ((metrics & HotKeysMetrics.Network) != 0) physical.WriteBulkString("NET"u8); + writer.WriteBulkString(metricCount); + if ((metrics & HotKeysMetrics.Cpu) != 0) writer.WriteRaw("$3\r\nCPU\r\n"u8); + if ((metrics & HotKeysMetrics.Network) != 0) writer.WriteRaw("$3\r\nNET\r\n"u8); if (count != 0) { - physical.WriteBulkString("COUNT"u8); - physical.WriteBulkString(count); + writer.WriteRaw("$5\r\nCOUNT\r\n"u8); + writer.WriteBulkString(count); } if (duration != TimeSpan.Zero) { - physical.WriteBulkString("DURATION"u8); - physical.WriteBulkString(Math.Ceiling(duration.TotalSeconds)); + writer.WriteRaw("$8\r\nDURATION\r\n"u8); + writer.WriteBulkString(Math.Ceiling(duration.TotalSeconds)); } if (sampleRatio != 1) { - physical.WriteBulkString("SAMPLE"u8); - physical.WriteBulkString(sampleRatio); + writer.WriteRaw("$6\r\nSAMPLE\r\n"u8); + writer.WriteBulkString(sampleRatio); } if (slots is { Length: > 0 }) { - physical.WriteBulkString("SLOTS"u8); - physical.WriteBulkString(slots.Length); + writer.WriteRaw("$5\r\nSLOTS\r\n"u8); + writer.WriteBulkString(slots.Length); foreach (var slot in slots) { - physical.WriteBulkString(slot); + writer.WriteBulkString(slot); } } } diff --git a/src/StackExchange.Redis/Increx.IncrexMessage.cs b/src/StackExchange.Redis/Increx.IncrexMessage.cs index f8cab9bc0..dc8421c24 100644 --- a/src/StackExchange.Redis/Increx.IncrexMessage.cs +++ b/src/StackExchange.Redis/Increx.IncrexMessage.cs @@ -26,27 +26,27 @@ public override int ArgCount private int OptionsArgCount => Options == IncrementOptions.Saturate ? 1 : 0; protected abstract int BoundsArgCount { get; } - protected abstract void WriteIncrementKindAndValue(PhysicalConnection physical); - protected abstract void WriteBounds(PhysicalConnection physical); + protected abstract void WriteIncrementKindAndValue(in MessageWriter writer); + protected abstract void WriteBounds(in MessageWriter writer); - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.WriteBulkString(Key); - WriteIncrementKindAndValue(physical); - WriteBounds(physical); - WriteOptions(physical); - Expiry.WriteTo(physical); + writer.WriteHeader(Command, ArgCount); + writer.WriteBulkString(Key); + WriteIncrementKindAndValue(writer); + WriteBounds(writer); + WriteOptions(writer); + Expiry.WriteTo(writer); } - private void WriteOptions(PhysicalConnection physical) + private void WriteOptions(in MessageWriter writer) { switch (Options) { case IncrementOptions.None: break; case IncrementOptions.Saturate: - physical.WriteRaw("$8\r\nSATURATE\r\n"u8); + writer.WriteRaw("$8\r\nSATURATE\r\n"u8); break; default: throw new ArgumentOutOfRangeException(nameof(Options)); @@ -66,23 +66,23 @@ internal sealed class IncrexInt64Message( { protected override int BoundsArgCount => (lowerBound.HasValue ? 2 : 0) + (upperBound.HasValue ? 2 : 0); - protected override void WriteIncrementKindAndValue(PhysicalConnection physical) + protected override void WriteIncrementKindAndValue(in MessageWriter writer) { - physical.WriteBulkString("BYINT"u8); - physical.WriteBulkString(value); + writer.WriteRaw("$5\r\nBYINT\r\n"u8); + writer.WriteBulkString(value); } - protected override void WriteBounds(PhysicalConnection physical) + protected override void WriteBounds(in MessageWriter writer) { if (lowerBound.HasValue) { - physical.WriteBulkString("LBOUND"u8); - physical.WriteBulkString(lowerBound.GetValueOrDefault()); + writer.WriteRaw("$6\r\nLBOUND\r\n"u8); + writer.WriteBulkString(lowerBound.GetValueOrDefault()); } if (upperBound.HasValue) { - physical.WriteBulkString("UBOUND"u8); - physical.WriteBulkString(upperBound.GetValueOrDefault()); + writer.WriteRaw("$6\r\nUBOUND\r\n"u8); + writer.WriteBulkString(upperBound.GetValueOrDefault()); } } } @@ -99,23 +99,23 @@ internal sealed class IncrexDoubleMessage( { protected override int BoundsArgCount => (lowerBound.HasValue ? 2 : 0) + (upperBound.HasValue ? 2 : 0); - protected override void WriteIncrementKindAndValue(PhysicalConnection physical) + protected override void WriteIncrementKindAndValue(in MessageWriter writer) { - physical.WriteBulkString("BYFLOAT"u8); - physical.WriteBulkString(value); + writer.WriteRaw("$7\r\nBYFLOAT\r\n"u8); + writer.WriteBulkString(value); } - protected override void WriteBounds(PhysicalConnection physical) + protected override void WriteBounds(in MessageWriter writer) { if (lowerBound.HasValue) { - physical.WriteBulkString("LBOUND"u8); - physical.WriteBulkString(lowerBound.GetValueOrDefault()); + writer.WriteRaw("$6\r\nLBOUND\r\n"u8); + writer.WriteBulkString(lowerBound.GetValueOrDefault()); } if (upperBound.HasValue) { - physical.WriteBulkString("UBOUND"u8); - physical.WriteBulkString(upperBound.GetValueOrDefault()); + writer.WriteRaw("$6\r\nUBOUND\r\n"u8); + writer.WriteBulkString(upperBound.GetValueOrDefault()); } } } diff --git a/src/StackExchange.Redis/Increx.ResultProcessor.cs b/src/StackExchange.Redis/Increx.ResultProcessor.cs index dca1395ba..42fea6ff3 100644 --- a/src/StackExchange.Redis/Increx.ResultProcessor.cs +++ b/src/StackExchange.Redis/Increx.ResultProcessor.cs @@ -1,3 +1,5 @@ +using RESPite.Messages; + namespace StackExchange.Redis; internal static class IncrexResultProcessor @@ -7,16 +9,14 @@ internal static class IncrexResultProcessor private sealed class Int64ResultProcessor : ResultProcessor> { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array && result.ItemsCount >= 2) + if (reader.IsAggregate + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out long value) + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out long appliedIncrement)) { - var items = result.GetItems(); - if (items[0].TryGetInt64(out long value) && items[1].TryGetInt64(out long appliedIncrement)) - { - SetResult(message, new StringIncrementResult(value, appliedIncrement)); - return true; - } + SetResult(message, new StringIncrementResult(value, appliedIncrement)); + return true; } return false; } @@ -24,16 +24,14 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class DoubleResultProcessor : ResultProcessor> { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array && result.ItemsCount >= 2) + if (reader.IsAggregate + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadDouble(out double value) + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadDouble(out double appliedIncrement)) { - var items = result.GetItems(); - if (items[0].TryGetDouble(out double value) && items[1].TryGetDouble(out double appliedIncrement)) - { - SetResult(message, new StringIncrementResult(value, appliedIncrement)); - return true; - } + SetResult(message, new StringIncrementResult(value, appliedIncrement)); + return true; } return false; } diff --git a/src/StackExchange.Redis/Interfaces/IDatabase.VectorSets.cs b/src/StackExchange.Redis/Interfaces/IDatabase.VectorSets.cs index e1947d324..28f45851f 100644 --- a/src/StackExchange.Redis/Interfaces/IDatabase.VectorSets.cs +++ b/src/StackExchange.Redis/Interfaces/IDatabase.VectorSets.cs @@ -1,4 +1,5 @@ -using System.Diagnostics.CodeAnalysis; +using System.Diagnostics.CodeAnalysis; +using RESPite; // ReSharper disable once CheckNamespace namespace StackExchange.Redis; diff --git a/src/StackExchange.Redis/Interfaces/IServer.cs b/src/StackExchange.Redis/Interfaces/IServer.cs index faeb20e93..1959f15d8 100644 --- a/src/StackExchange.Redis/Interfaces/IServer.cs +++ b/src/StackExchange.Redis/Interfaces/IServer.cs @@ -821,7 +821,11 @@ internal static class IServerExtensions /// The type of failure(s) to simulate. internal static void SimulateConnectionFailure(this IServer server, SimulatedFailureType failureType) => (server as RedisServer)?.SimulateConnectionFailure(failureType); - // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract - internal static bool CanSimulateConnectionFailure(this IServer server) => server is not null; // this changes in v3 + /// + /// For testing only: Check if the server can simulate connection failure. + /// + /// The server to check. + internal static bool CanSimulateConnectionFailure(this IServer server) => + (server as RedisServer)?.CanSimulateConnectionFailure == true; } } diff --git a/src/StackExchange.Redis/KeyNotification.cs b/src/StackExchange.Redis/KeyNotification.cs index 899775090..e52b8ead5 100644 --- a/src/StackExchange.Redis/KeyNotification.cs +++ b/src/StackExchange.Redis/KeyNotification.cs @@ -167,7 +167,7 @@ public static bool TryParse(scoped in RedisChannel channel, scoped in RedisValue { case KeyEventPrefix.HashCS when KeyEventPrefix.IsCS(prefix, hashCS): // check that there is *something* non-empty after the prefix, with __: as the suffix (we don't verify *what*) - if (span.Slice(KeySpacePrefix.Length).IndexOf("__:"u8) > 0) + if (span.Slice(KeyEventPrefix.Length).IndexOf("__:"u8) > 0) { notification = new KeyNotification(in channel, in value, KeyNotificationKind.KeyEvent); return true; diff --git a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.VectorSets.cs b/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.VectorSets.cs index 06ca59acc..2c4f1b0c3 100644 --- a/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.VectorSets.cs +++ b/src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.VectorSets.cs @@ -1,4 +1,6 @@ -using System.Threading.Tasks; +using System.Diagnostics.CodeAnalysis; +using System.Threading.Tasks; +using RESPite; // ReSharper disable once CheckNamespace namespace StackExchange.Redis.KeyspaceIsolation; diff --git a/src/StackExchange.Redis/KnownRole.cs b/src/StackExchange.Redis/KnownRole.cs index 6823d7a7c..ede282b1f 100644 --- a/src/StackExchange.Redis/KnownRole.cs +++ b/src/StackExchange.Redis/KnownRole.cs @@ -32,12 +32,27 @@ internal enum KnownRole /// internal static partial class KnownRoleMetadata { + [AsciiHash] + private static partial bool TryParseCore(ReadOnlySpan value, out KnownRole role); + [AsciiHash] private static partial bool TryParseCore(ReadOnlySpan value, out KnownRole role); + internal static bool TryParse(ReadOnlySpan value, out bool isReplica) + { + if (!TryParseCore(value, out var role)) + { + isReplica = false; + return false; + } + + isReplica = role is KnownRole.Replica or KnownRole.Slave; + return true; + } + internal static bool TryParse(ReadOnlySpan value, out bool isReplica) { - if (!TryParseCore(value.Trim(), out var role)) + if (!TryParseCore(value, out var role)) { isReplica = false; return false; @@ -46,9 +61,10 @@ internal static bool TryParse(ReadOnlySpan value, out bool isReplica) isReplica = role is KnownRole.Replica or KnownRole.Slave; return true; } - internal static bool TryParse(string? val, out bool isReplica) + + internal static bool TryParse(string? value, out bool isReplica) { - if (val is not null) return TryParse(val.AsSpan(), out isReplica); + if (value is not null) return TryParse(value.AsSpan(), out isReplica); isReplica = false; return false; } diff --git a/src/StackExchange.Redis/LCSField.cs b/src/StackExchange.Redis/LCSField.cs new file mode 100644 index 000000000..2e2dbd8d0 --- /dev/null +++ b/src/StackExchange.Redis/LCSField.cs @@ -0,0 +1,37 @@ +using System; +using RESPite; + +namespace StackExchange.Redis; + +/// +/// Fields that can appear in an LCS (Longest Common Subsequence) command response. +/// +internal enum LCSField +{ + /// + /// Unknown or unrecognized field. + /// + [AsciiHash("")] + Unknown = 0, + + /// + /// The matches array. + /// + [AsciiHash("matches")] + Matches, + + /// + /// The length value. + /// + [AsciiHash("len")] + Len, +} + +/// +/// Metadata and parsing methods for LCSField. +/// +internal static partial class LCSFieldMetadata +{ + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out LCSField field); +} diff --git a/src/StackExchange.Redis/LoggerExtensions.cs b/src/StackExchange.Redis/LoggerExtensions.cs index 4a43514e4..381ee4426 100644 --- a/src/StackExchange.Redis/LoggerExtensions.cs +++ b/src/StackExchange.Redis/LoggerExtensions.cs @@ -494,7 +494,7 @@ internal static void LogWithThreadPoolStats(this ILogger? log, string message) Level = LogLevel.Information, EventId = 71, Message = "Response from {BridgeName} / {CommandAndKey}: {Result}")] - internal static partial void LogInformationResponse(this ILogger logger, string? bridgeName, string commandAndKey, RawResult result); + internal static partial void LogInformationResponse(this ILogger logger, string? bridgeName, string commandAndKey, string result); [LoggerMessage( Level = LogLevel.Information, diff --git a/src/StackExchange.Redis/Message.ValueCondition.cs b/src/StackExchange.Redis/Message.ValueCondition.cs index 931553913..cefd1df0e 100644 --- a/src/StackExchange.Redis/Message.ValueCondition.cs +++ b/src/StackExchange.Redis/Message.ValueCondition.cs @@ -20,11 +20,11 @@ private sealed class KeyConditionMessage( public override int ArgCount => 1 + _when.TokenCount; - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - _when.WriteTo(physical); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + _when.WriteTo(writer); } } @@ -44,13 +44,13 @@ private sealed class KeyValueExpiryConditionMessage( public override int ArgCount => 2 + _expiry.GetTokenCount(allowEnx: false) + _when.TokenCount; - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - physical.WriteBulkString(_value); - _expiry.WriteTo(physical); - _when.WriteTo(physical); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + writer.WriteBulkString(_value); + _expiry.WriteTo(writer); + _when.WriteTo(writer); } } } diff --git a/src/StackExchange.Redis/Message.cs b/src/StackExchange.Redis/Message.cs index 2d11f30f3..17ded6c20 100644 --- a/src/StackExchange.Redis/Message.cs +++ b/src/StackExchange.Redis/Message.cs @@ -7,8 +7,12 @@ using System.Text; using System.Threading; using Microsoft.Extensions.Logging; +using RESPite.Internal; +using RESPite.Messages; using StackExchange.Redis.Profiling; +#pragma warning disable SA1117 // params all same line; just noise here + namespace StackExchange.Redis { internal sealed class LoggingMessage : Message @@ -34,15 +38,12 @@ private LoggingMessage(ILogger log, Message tail) : base(tail.Db, tail.Flags, ta public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => tail.GetHashSlot(serverSelectionStrategy); - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - try - { - var bridge = physical.BridgeCouldBeNull; - log?.LogTrace($"{bridge?.Name}: Writing: {tail.CommandAndKey}"); - } - catch { } - tail.WriteTo(physical); +#if VERBOSE + log?.LogTrace($"Writing: {tail.CommandAndKey}"); +#endif + tail.WriteTo(writer); } public override int ArgCount => tail.ArgCount; @@ -55,7 +56,9 @@ internal abstract partial class Message : ICompletable private uint _highIntegrityToken; - internal const CommandFlags InternalCallFlag = (CommandFlags)128; + internal const CommandFlags + InternalCallFlag = (CommandFlags)128, + NoFlushFlag = (CommandFlags)1024; protected RedisCommand command; @@ -65,21 +68,23 @@ internal abstract partial class Message : ICompletable HandshakeCompletionFlag = (CommandFlags)4096; private const CommandFlags MaskPrimaryServerPreference = CommandFlags.DemandMaster - | CommandFlags.DemandReplica - | CommandFlags.PreferMaster - | CommandFlags.PreferReplica; + | CommandFlags.DemandReplica + | CommandFlags.PreferMaster + | CommandFlags.PreferReplica; private const CommandFlags UserSelectableFlags = CommandFlags.None - | CommandFlags.DemandMaster - | CommandFlags.DemandReplica - | CommandFlags.PreferMaster - | CommandFlags.PreferReplica + | CommandFlags.DemandMaster + | CommandFlags.DemandReplica + | CommandFlags.PreferMaster + | CommandFlags.PreferReplica #pragma warning disable CS0618 // Type or member is obsolete - | CommandFlags.HighPriority + | CommandFlags.HighPriority #pragma warning restore CS0618 - | CommandFlags.FireAndForget - | CommandFlags.NoRedirect - | CommandFlags.NoScriptCache; + | CommandFlags.FireAndForget + | CommandFlags.NoRedirect + | CommandFlags.NoScriptCache + | NoFlushFlag; // we'll allow this one even though not advertised + private IResultBox? resultBox; private ResultProcessor? resultProcessor; @@ -231,37 +236,46 @@ public static Message Create(int db, CommandFlags flags, RedisCommand command) public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key) => new CommandKeyMessage(db, flags, command, key); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key0, in RedisKey key1) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key0, + in RedisKey key1) => new CommandKeyKeyMessage(db, flags, command, key0, key1); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key0, in RedisKey key1, in RedisValue value) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key0, + in RedisKey key1, in RedisValue value) => new CommandKeyKeyValueMessage(db, flags, command, key0, key1, value); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key0, in RedisKey key1, in RedisKey key2) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key0, + in RedisKey key1, in RedisKey key2) => new CommandKeyKeyKeyMessage(db, flags, command, key0, key1, key2); public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value) => new CommandValueMessage(db, flags, command, value); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, in RedisValue value) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + in RedisValue value) => new CommandKeyValueMessage(db, flags, command, key, value); public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisChannel channel) => new CommandChannelMessage(db, flags, command, channel); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisChannel channel, in RedisValue value) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisChannel channel, + in RedisValue value) => new CommandChannelValueMessage(db, flags, command, channel, value); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value, in RedisChannel channel) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value, + in RedisChannel channel) => new CommandValueChannelMessage(db, flags, command, value, channel); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, in RedisValue value0, in RedisValue value1) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + in RedisValue value0, in RedisValue value1) => new CommandKeyValueValueMessage(db, flags, command, key, value0, value1); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, in RedisValue value0, in RedisValue value1, in RedisValue value2) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + in RedisValue value0, in RedisValue value1, in RedisValue value2) => new CommandKeyValueValueValueMessage(db, flags, command, key, value0, value1, value2); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, GeoEntry[] values) + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + GeoEntry[] values) { #if NET ArgumentNullException.ThrowIfNull(values); @@ -272,11 +286,13 @@ public static Message Create(int db, CommandFlags flags, RedisCommand command, i { throw new ArgumentOutOfRangeException(nameof(values)); } + if (values.Length == 1) { var value = values[0]; return Create(db, flags, command, key, value.Longitude, value.Latitude, value.Member); } + var arr = new RedisValue[3 * values.Length]; int index = 0; foreach (var value in values) @@ -285,34 +301,50 @@ public static Message Create(int db, CommandFlags flags, RedisCommand command, i arr[index++] = value.Latitude; arr[index++] = value.Member; } + return new CommandKeyValuesMessage(db, flags, command, key, arr); } - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, in RedisValue value0, in RedisValue value1, in RedisValue value2, in RedisValue value3) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + in RedisValue value0, in RedisValue value1, in RedisValue value2, in RedisValue value3) => new CommandKeyValueValueValueValueMessage(db, flags, command, key, value0, value1, value2, value3); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, in RedisValue value0, in RedisValue value1, in RedisValue value2, in RedisValue value3, in RedisValue value4) => - new CommandKeyValueValueValueValueValueMessage(db, flags, command, key, value0, value1, value2, value3, value4); - - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, in RedisValue value0, in RedisValue value1, in RedisValue value2, in RedisValue value3, in RedisValue value4, in RedisValue value5) => - new CommandKeyValueValueValueValueValueValueMessage(db, flags, command, key, value0, value1, value2, value3, value4, value5); - - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, in RedisValue value0, in RedisValue value1, in RedisValue value2, in RedisValue value3, in RedisValue value4, in RedisValue value5, in RedisValue value6) => - new CommandKeyValueValueValueValueValueValueValueMessage(db, flags, command, key, value0, value1, value2, value3, value4, value5, value6); - - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value0, in RedisValue value1) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + in RedisValue value0, in RedisValue value1, in RedisValue value2, in RedisValue value3, + in RedisValue value4) => + new CommandKeyValueValueValueValueValueMessage(db, flags, command, key, value0, value1, value2, value3, + value4); + + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + in RedisValue value0, in RedisValue value1, in RedisValue value2, in RedisValue value3, + in RedisValue value4, in RedisValue value5) => + new CommandKeyValueValueValueValueValueValueMessage(db, flags, command, key, value0, value1, value2, value3, + value4, value5); + + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + in RedisValue value0, in RedisValue value1, in RedisValue value2, in RedisValue value3, + in RedisValue value4, in RedisValue value5, in RedisValue value6) => + new CommandKeyValueValueValueValueValueValueValueMessage(db, flags, command, key, value0, value1, value2, + value3, value4, value5, value6); + + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value0, + in RedisValue value1) => new CommandValueValueMessage(db, flags, command, value0, value1); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value, in RedisKey key) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value, + in RedisKey key) => new CommandValueKeyMessage(db, flags, command, value, key); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value0, in RedisValue value1, in RedisValue value2) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value0, + in RedisValue value1, in RedisValue value2) => new CommandValueValueValueMessage(db, flags, command, value0, value1, value2); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value0, in RedisValue value1, in RedisValue value2, in RedisValue value3, in RedisValue value4) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisValue value0, + in RedisValue value1, in RedisValue value2, in RedisValue value3, in RedisValue value4) => new CommandValueValueValueValueValueMessage(db, flags, command, value0, value1, value2, value3, value4); - public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, in RedisValue value0, in RedisValue value1, in RedisValue[] values) => + public static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + in RedisValue value0, in RedisValue value1, in RedisValue[] values) => new CommandKeyValueValueValuesMessage(db, flags, command, key, value0, value1, values); public static Message Create( @@ -346,7 +378,8 @@ public static Message Create( in RedisValue value1, in RedisValue value2, in RedisValue value3) => - new CommandKeyKeyValueValueValueValueMessage(db, flags, command, key0, key1, value0, value1, value2, value3); + new CommandKeyKeyValueValueValueValueMessage(db, flags, command, key0, key1, value0, value1, value2, + value3); public static Message Create( int db, @@ -359,7 +392,8 @@ public static Message Create( in RedisValue value2, in RedisValue value3, in RedisValue value4) => - new CommandKeyKeyValueValueValueValueValueMessage(db, flags, command, key0, key1, value0, value1, value2, value3, value4); + new CommandKeyKeyValueValueValueValueValueMessage(db, flags, command, key0, key1, value0, value1, value2, + value3, value4); public static Message Create( int db, @@ -373,7 +407,8 @@ public static Message Create( in RedisValue value3, in RedisValue value4, in RedisValue value5) => - new CommandKeyKeyValueValueValueValueValueValueMessage(db, flags, command, key0, key1, value0, value1, value2, value3, value4, value5); + new CommandKeyKeyValueValueValueValueValueValueMessage(db, flags, command, key0, key1, value0, value1, + value2, value3, value4, value5); public static Message Create( int db, @@ -388,9 +423,11 @@ public static Message Create( in RedisValue value4, in RedisValue value5, in RedisValue value6) => - new CommandKeyKeyValueValueValueValueValueValueValueMessage(db, flags, command, key0, key1, value0, value1, value2, value3, value4, value5, value6); + new CommandKeyKeyValueValueValueValueValueValueValueMessage(db, flags, command, key0, key1, value0, value1, + value2, value3, value4, value5, value6); - public static Message CreateInSlot(int db, int slot, CommandFlags flags, RedisCommand command, RedisValue[] values) => + public static Message CreateInSlot(int db, int slot, CommandFlags flags, RedisCommand command, + RedisValue[] values) => new CommandSlotValuesMessage(db, slot, flags, command, values); // The key here is used only to route the message in cluster mode; it is not written as an argument. @@ -398,7 +435,8 @@ public static Message CreateInSlot(int db, int slot, CommandFlags flags, RedisCo public static Message CreateInKeySlot(int db, in RedisKey key, CommandFlags flags, RedisCommand command, RedisValue[] values) => new CommandKeySlotValuesMessage(db, flags, command, key, values); - public static Message Create(int db, CommandFlags flags, RedisCommand command, KeyValuePair[] values, Expiration expiry, When when) + public static Message Create(int db, CommandFlags flags, RedisCommand command, + KeyValuePair[] values, Expiration expiry, When when) => new MultiSetMessage(db, flags, command, values, expiry, when); /// Gets whether this is primary-only. @@ -415,7 +453,8 @@ public virtual void AppendStormLog(StringBuilder sb) sb.Append(CommandAndKey); } - public virtual int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => ServerSelectionStrategy.NoSlot; + public virtual int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => + ServerSelectionStrategy.NoSlot; /// /// This does a few important things: @@ -461,7 +500,8 @@ public void Complete() internal bool ResultBoxIsAsync => Volatile.Read(ref resultBox)?.IsAsync == true; - internal static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, RedisKey[] keys) => keys.Length switch + internal static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + RedisKey[] keys) => keys.Length switch { 0 => new CommandKeyMessage(db, flags, command, key), 1 => new CommandKeyKeyMessage(db, flags, command, key, keys[0]), @@ -469,27 +509,31 @@ public void Complete() _ => new CommandKeyKeysMessage(db, flags, command, key, keys), }; - internal static Message Create(int db, CommandFlags flags, RedisCommand command, IList keys) => keys.Count switch - { - 0 => new CommandMessage(db, flags, command), - 1 => new CommandKeyMessage(db, flags, command, keys[0]), - 2 => new CommandKeyKeyMessage(db, flags, command, keys[0], keys[1]), - 3 => new CommandKeyKeyKeyMessage(db, flags, command, keys[0], keys[1], keys[2]), - _ => new CommandKeysMessage(db, flags, command, (keys as RedisKey[]) ?? keys.ToArray()), - }; + internal static Message Create(int db, CommandFlags flags, RedisCommand command, IList keys) => + keys.Count switch + { + 0 => new CommandMessage(db, flags, command), + 1 => new CommandKeyMessage(db, flags, command, keys[0]), + 2 => new CommandKeyKeyMessage(db, flags, command, keys[0], keys[1]), + 3 => new CommandKeyKeyKeyMessage(db, flags, command, keys[0], keys[1], keys[2]), + _ => new CommandKeysMessage(db, flags, command, (keys as RedisKey[]) ?? keys.ToArray()), + }; - internal static Message Create(int db, CommandFlags flags, RedisCommand command, IList values) => values.Count switch - { - 0 => new CommandMessage(db, flags, command), - 1 => new CommandValueMessage(db, flags, command, values[0]), - 2 => new CommandValueValueMessage(db, flags, command, values[0], values[1]), - 3 => new CommandValueValueValueMessage(db, flags, command, values[0], values[1], values[2]), - // no 4; not worth adding - 5 => new CommandValueValueValueValueValueMessage(db, flags, command, values[0], values[1], values[2], values[3], values[4]), - _ => new CommandValuesMessage(db, flags, command, (values as RedisValue[]) ?? values.ToArray()), - }; + internal static Message Create(int db, CommandFlags flags, RedisCommand command, IList values) => + values.Count switch + { + 0 => new CommandMessage(db, flags, command), + 1 => new CommandValueMessage(db, flags, command, values[0]), + 2 => new CommandValueValueMessage(db, flags, command, values[0], values[1]), + 3 => new CommandValueValueValueMessage(db, flags, command, values[0], values[1], values[2]), + // no 4; not worth adding + 5 => new CommandValueValueValueValueValueMessage(db, flags, command, values[0], values[1], values[2], + values[3], values[4]), + _ => new CommandValuesMessage(db, flags, command, (values as RedisValue[]) ?? values.ToArray()), + }; - internal static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, RedisValue[] values) + internal static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key, + RedisValue[] values) { #if NET ArgumentNullException.ThrowIfNull(values); @@ -502,12 +546,14 @@ internal static Message Create(int db, CommandFlags flags, RedisCommand command, 1 => new CommandKeyValueMessage(db, flags, command, key, values[0]), 2 => new CommandKeyValueValueMessage(db, flags, command, key, values[0], values[1]), 3 => new CommandKeyValueValueValueMessage(db, flags, command, key, values[0], values[1], values[2]), - 4 => new CommandKeyValueValueValueValueMessage(db, flags, command, key, values[0], values[1], values[2], values[3]), + 4 => new CommandKeyValueValueValueValueMessage(db, flags, command, key, values[0], values[1], values[2], + values[3]), _ => new CommandKeyValuesMessage(db, flags, command, key, values), }; } - internal static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key0, in RedisKey key1, RedisValue[] values) + internal static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key0, + in RedisKey key1, RedisValue[] values) { #if NET ArgumentNullException.ThrowIfNull(values); @@ -519,16 +565,22 @@ internal static Message Create(int db, CommandFlags flags, RedisCommand command, 0 => new CommandKeyKeyMessage(db, flags, command, key0, key1), 1 => new CommandKeyKeyValueMessage(db, flags, command, key0, key1, values[0]), 2 => new CommandKeyKeyValueValueMessage(db, flags, command, key0, key1, values[0], values[1]), - 3 => new CommandKeyKeyValueValueValueMessage(db, flags, command, key0, key1, values[0], values[1], values[2]), - 4 => new CommandKeyKeyValueValueValueValueMessage(db, flags, command, key0, key1, values[0], values[1], values[2], values[3]), - 5 => new CommandKeyKeyValueValueValueValueValueMessage(db, flags, command, key0, key1, values[0], values[1], values[2], values[3], values[4]), - 6 => new CommandKeyKeyValueValueValueValueValueValueMessage(db, flags, command, key0, key1, values[0], values[1], values[2], values[3], values[4], values[5]), - 7 => new CommandKeyKeyValueValueValueValueValueValueValueMessage(db, flags, command, key0, key1, values[0], values[1], values[2], values[3], values[4], values[5], values[6]), + 3 => new CommandKeyKeyValueValueValueMessage(db, flags, command, key0, key1, values[0], values[1], + values[2]), + 4 => new CommandKeyKeyValueValueValueValueMessage(db, flags, command, key0, key1, values[0], values[1], + values[2], values[3]), + 5 => new CommandKeyKeyValueValueValueValueValueMessage(db, flags, command, key0, key1, values[0], + values[1], values[2], values[3], values[4]), + 6 => new CommandKeyKeyValueValueValueValueValueValueMessage(db, flags, command, key0, key1, values[0], + values[1], values[2], values[3], values[4], values[5]), + 7 => new CommandKeyKeyValueValueValueValueValueValueValueMessage(db, flags, command, key0, key1, + values[0], values[1], values[2], values[3], values[4], values[5], values[6]), _ => new CommandKeyKeyValuesMessage(db, flags, command, key0, key1, values), }; } - internal static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key0, RedisValue[] values, in RedisKey key1) + internal static Message Create(int db, CommandFlags flags, RedisCommand command, in RedisKey key0, + RedisValue[] values, in RedisKey key1) { #if NET ArgumentNullException.ThrowIfNull(values); @@ -600,34 +652,55 @@ internal static bool RequiresDatabase(RedisCommand command) internal static CommandFlags SetPrimaryReplicaFlags(CommandFlags everything, CommandFlags primaryReplica) { // take away the two flags we don't want, and add back the ones we care about - return (everything & ~(CommandFlags.DemandMaster | CommandFlags.DemandReplica | CommandFlags.PreferMaster | CommandFlags.PreferReplica)) - | primaryReplica; + return (everything & ~(CommandFlags.DemandMaster | CommandFlags.DemandReplica | CommandFlags.PreferMaster | + CommandFlags.PreferReplica)) + | primaryReplica; } internal void Cancel() => resultBox?.Cancel(); // true if ready to be completed (i.e. false if re-issued to another server) - internal bool ComputeResult(PhysicalConnection connection, in RawResult result) + internal bool ComputeResult(PhysicalConnection connection, ref RespReader reader) { + var prefix = RespPrefix.None; + + // intentionally "frame" is an isolated copy var box = resultBox; try { - if (box != null && box.IsFaulted) return false; // already failed (timeout, etc) - if (resultProcessor == null) return true; + // we don't want to mutate reader, so that processors can consume attributes; however, + // we also don't want to force the entire reader to copy each time, so: snapshot + // just the prefix + prefix = reader.GetFirstPrefix(); + + if (box != null && box.IsFaulted) + { + connection.OnDetailLog($"already faulted for {Command}"); + return false; // already failed (timeout, etc) + } + + if (resultProcessor == null) + { + connection.OnDetailLog($"no result processor for {Command}"); + return true; + } // false here would be things like resends (MOVED) - the message is not yet complete - return resultProcessor.SetResult(connection, this, result); + connection.OnDetailLog($"computing result for {Command} with {resultProcessor.GetType().Name}"); + return resultProcessor.SetResult(connection, this, ref reader); } catch (Exception ex) { - ex.Data.Add("got", result.ToString()); + connection.OnDetailLog($"{ex.GetType().Name}: {ex.Message}"); + ex.Data.Add("got", prefix.ToString()); connection?.BridgeCouldBeNull?.Multiplexer?.OnMessageFaulted(this, ex); box?.SetException(ex); return box != null; // we still want to pulse/complete } } - internal void Fail(ConnectionFailureType failure, Exception? innerException, string? annotation, ConnectionMultiplexer? muxer) + internal void Fail(ConnectionFailureType failure, Exception? innerException, string? annotation, + ConnectionMultiplexer? muxer) { PhysicalConnection.IdentifyFailureType(innerException, ref failure); resultProcessor?.ConnectionFail(this, failure, innerException, annotation, muxer); @@ -646,6 +719,7 @@ internal bool TrySetResult(T value) typed.SetResult(value); return true; } + return false; } @@ -713,8 +787,11 @@ internal void SetRequestSent() [MethodImpl(MethodImplOptions.AggressiveInlining)] internal void SetWriteTime() { - _writeTickCount = Environment.TickCount; // note this might be reset if we resend a message, cluster-moved etc; I'm OK with that + _writeTickCount = + Environment + .TickCount; // note this might be reset if we resend a message, cluster-moved etc; I'm OK with that } + private int _writeTickCount; public int GetWriteTime() => Volatile.Read(ref _writeTickCount); @@ -726,6 +803,11 @@ internal void SetWriteTime() public virtual string CommandString => Command.ToString(); + internal bool IsFlushRequiredAsync => (Flags & NoFlushFlag) == 0; + + // for sync to skip flush, we need *both* NoFlush and FireAndForget; we absolutely need to flush if someone is doing a sync call + internal bool IsFlushRequiredSync => (Flags & (NoFlushFlag | CommandFlags.FireAndForget)) != (NoFlushFlag | CommandFlags.FireAndForget); + public bool IsHandshakeCompletion => (Flags & HandshakeCompletionFlag) != 0; /// @@ -785,13 +867,51 @@ internal void SetSource(IResultBox resultBox, ResultProcessor? resultPr this.resultProcessor = resultProcessor; } - protected abstract void WriteImpl(PhysicalConnection physical); + internal void WriteTo(in MessageWriter writer) => WriteImpl(in writer); + protected abstract void WriteImpl(in MessageWriter writer); + + internal string GetRespString(PhysicalConnection connection) + { + MessageWriter writer = new MessageWriter(connection, BlockBufferSerializer.Shared); + try + { + WriteImpl(in writer); + var bytes = MessageWriter.FlushBlockBuffer(); + string s = Encoding.UTF8.GetString(bytes.Span); + MessageWriter.ReleaseBlockBuffer(bytes); + return s; + } + finally + { + MessageWriter.RevertBlockBuffer(); + } + } internal void WriteTo(PhysicalConnection physical) { + MessageWriter writer = new MessageWriter(physical, physical.Output); try { - WriteImpl(physical); + WriteImpl(in writer); + } + catch (Exception ex) when (ex is not RedisCommandException) // these have specific meaning; don't wrap + { + physical?.OnInternalError(ex); + Fail(ConnectionFailureType.InternalFailure, ex, null, physical?.BridgeCouldBeNull?.Multiplexer); + // Re-throw so the outer write path (PhysicalBridge.HandleWriteException) can tear down the + // connection. A partial write would otherwise leave bytes on the wire while the response + // queue still considers the slot healthy, allowing a subsequent reply to match the wrong + // in-flight message. + throw; + } + } + + internal void WriteTo(PhysicalConnection physical, CommandMap commandMap, byte[]? channelPrefix) + { + MessageWriter writer = new MessageWriter(channelPrefix, commandMap, physical.Output); + try + { + WriteImpl(in writer); } catch (Exception ex) when (ex is not RedisCommandException) // these have specific meaning; don't wrap { @@ -810,15 +930,16 @@ internal void WriteTo(PhysicalConnection physical) internal void WriteHighIntegrityChecksumRequest(PhysicalConnection physical) { Debug.Assert(IsHighIntegrity, "should only be used for high-integrity"); + var writer = new MessageWriter(physical, physical.Output); try { - physical.WriteHeader(RedisCommand.ECHO, 1); // use WriteHeader to allow command-rewrite + writer.WriteHeader(RedisCommand.ECHO, 1); // use WriteHeader to allow command-rewrite Span chk = stackalloc byte[10]; Debug.Assert(ChecksumTemplate.Length == chk.Length, "checksum template length error"); ChecksumTemplate.CopyTo(chk); BinaryPrimitives.WriteUInt32LittleEndian(chk.Slice(4, 4), _highIntegrityToken); - physical.WriteRaw(chk); + writer.WriteRaw(chk); } catch (Exception ex) { @@ -856,20 +977,20 @@ public override int ArgCount return count; } } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.WriteBulkString(_protocolVersion); + writer.WriteHeader(Command, ArgCount); + writer.WriteBulkString(_protocolVersion); if (!string.IsNullOrWhiteSpace(_password)) { - physical.WriteBulkString("AUTH"u8); - physical.WriteBulkString(string.IsNullOrWhiteSpace(_username) ? RedisLiterals.@default : _username); - physical.WriteBulkString(_password); + writer.WriteRaw("$4\r\nAUTH\r\n"u8); + writer.WriteBulkString(string.IsNullOrWhiteSpace(_username) ? RedisLiterals.@default : _username); + writer.WriteBulkString(_password); } if (!string.IsNullOrWhiteSpace(_clientName)) { - physical.WriteBulkString("SETNAME"u8); - physical.WriteBulkString(_clientName); + writer.WriteRaw("$7\r\nSETNAME\r\n"u8); + writer.WriteBulkString(_clientName); } } } @@ -910,10 +1031,10 @@ private sealed class CommandChannelMessage : CommandChannelBase public CommandChannelMessage(int db, CommandFlags flags, RedisCommand command, in RedisChannel channel) : base(db, flags, command, channel) { } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 1); - physical.Write(Channel); + writer.WriteHeader(Command, 1); + writer.Write(Channel); } public override int ArgCount => 1; } @@ -928,11 +1049,11 @@ public CommandChannelValueMessage(int db, CommandFlags flags, RedisCommand comma this.value = value; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 2); - physical.Write(Channel); - physical.WriteBulkString(value); + writer.WriteHeader(Command, 2); + writer.Write(Channel); + writer.WriteBulkString(value); } public override int ArgCount => 2; } @@ -955,12 +1076,12 @@ public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) return serverSelectionStrategy.CombineSlot(slot, key2); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 3); - physical.Write(Key); - physical.Write(key1); - physical.Write(key2); + writer.WriteHeader(Command, 3); + writer.Write(Key); + writer.Write(key1); + writer.Write(key2); } public override int ArgCount => 3; } @@ -980,11 +1101,11 @@ public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) return serverSelectionStrategy.CombineSlot(slot, key1); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 2); - physical.Write(Key); - physical.Write(key1); + writer.WriteHeader(Command, 2); + writer.Write(Key); + writer.Write(key1); } public override int ArgCount => 2; } @@ -1003,13 +1124,13 @@ public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) return serverSelectionStrategy.CombineSlot(slot, keys); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(command, keys.Length + 1); - physical.Write(Key); + writer.WriteHeader(command, keys.Length + 1); + writer.Write(Key); for (int i = 0; i < keys.Length; i++) { - physical.Write(keys[i]); + writer.Write(keys[i]); } } public override int ArgCount => keys.Length + 1; @@ -1024,12 +1145,12 @@ public CommandKeyKeyValueMessage(int db, CommandFlags flags, RedisCommand comman this.value = value; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 3); - physical.Write(Key); - physical.Write(key1); - physical.WriteBulkString(value); + writer.WriteHeader(Command, 3); + writer.Write(Key); + writer.Write(key1); + writer.WriteBulkString(value); } public override int ArgCount => 3; @@ -1039,10 +1160,10 @@ private sealed class CommandKeyMessage : CommandKeyBase { public CommandKeyMessage(int db, CommandFlags flags, RedisCommand command, in RedisKey key) : base(db, flags, command, key) { } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 1); - physical.Write(Key); + writer.WriteHeader(Command, 1); + writer.Write(Key); } public override int ArgCount => 1; } @@ -1055,12 +1176,12 @@ public CommandValuesMessage(int db, CommandFlags flags, RedisCommand command, Re this.values = values.AssertAllNonNull(); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(command, values.Length); + writer.WriteHeader(command, values.Length); for (int i = 0; i < values.Length; i++) { - physical.WriteBulkString(values[i]); + writer.WriteBulkString(values[i]); } } public override int ArgCount => values.Length; @@ -1076,12 +1197,12 @@ public CommandKeysMessage(int db, CommandFlags flags, RedisCommand command, Redi public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => serverSelectionStrategy.HashSlot(keys); - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(command, keys.Length); + writer.WriteHeader(command, keys.Length); for (int i = 0; i < keys.Length; i++) { - physical.Write(keys[i]); + writer.Write(keys[i]); } } public override int ArgCount => keys.Length; @@ -1096,11 +1217,11 @@ public CommandKeyValueMessage(int db, CommandFlags flags, RedisCommand command, this.value = value; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 2); - physical.Write(Key); - physical.WriteBulkString(value); + writer.WriteHeader(Command, 2); + writer.Write(Key); + writer.WriteBulkString(value); } public override int ArgCount => 2; } @@ -1122,12 +1243,12 @@ public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) return serverSelectionStrategy.CombineSlot(slot, key1); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, values.Length + 2); - physical.Write(Key); - for (int i = 0; i < values.Length; i++) physical.WriteBulkString(values[i]); - physical.Write(key1); + writer.WriteHeader(Command, values.Length + 2); + writer.Write(Key); + for (int i = 0; i < values.Length; i++) writer.WriteBulkString(values[i]); + writer.Write(key1); } public override int ArgCount => values.Length + 2; } @@ -1140,11 +1261,11 @@ public CommandKeyValuesMessage(int db, CommandFlags flags, RedisCommand command, this.values = values.AssertAllNonNull(); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, values.Length + 1); - physical.Write(Key); - for (int i = 0; i < values.Length; i++) physical.WriteBulkString(values[i]); + writer.WriteHeader(Command, values.Length + 1); + writer.Write(Key); + for (int i = 0; i < values.Length; i++) writer.WriteBulkString(values[i]); } public override int ArgCount => values.Length + 1; } @@ -1160,12 +1281,12 @@ public CommandKeyKeyValuesMessage(int db, CommandFlags flags, RedisCommand comma this.values = values.AssertAllNonNull(); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, values.Length + 2); - physical.Write(Key); - physical.Write(key1); - for (int i = 0; i < values.Length; i++) physical.WriteBulkString(values[i]); + writer.WriteHeader(Command, values.Length + 2); + writer.Write(Key); + writer.Write(key1); + for (int i = 0; i < values.Length; i++) writer.WriteBulkString(values[i]); } public override int ArgCount => values.Length + 1; } @@ -1184,13 +1305,13 @@ public CommandKeyValueValueValuesMessage(int db, CommandFlags flags, RedisComman this.values = values.AssertAllNonNull(); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, values.Length + 3); - physical.Write(Key); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - for (int i = 0; i < values.Length; i++) physical.WriteBulkString(values[i]); + writer.WriteHeader(Command, values.Length + 3); + writer.Write(Key); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + for (int i = 0; i < values.Length; i++) writer.WriteBulkString(values[i]); } public override int ArgCount => values.Length + 3; } @@ -1206,12 +1327,12 @@ public CommandKeyValueValueMessage(int db, CommandFlags flags, RedisCommand comm this.value1 = value1; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 3); - physical.Write(Key); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); + writer.WriteHeader(Command, 3); + writer.Write(Key); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); } public override int ArgCount => 3; } @@ -1229,13 +1350,13 @@ public CommandKeyValueValueValueMessage(int db, CommandFlags flags, RedisCommand this.value2 = value2; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 4); - physical.Write(Key); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); + writer.WriteHeader(Command, 4); + writer.Write(Key); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); } public override int ArgCount => 4; } @@ -1255,14 +1376,14 @@ public CommandKeyValueValueValueValueMessage(int db, CommandFlags flags, RedisCo this.value3 = value3; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 5); - physical.Write(Key); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); - physical.WriteBulkString(value3); + writer.WriteHeader(Command, 5); + writer.Write(Key); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); + writer.WriteBulkString(value3); } public override int ArgCount => 5; } @@ -1284,15 +1405,15 @@ public CommandKeyValueValueValueValueValueMessage(int db, CommandFlags flags, Re this.value4 = value4; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 6); - physical.Write(Key); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); - physical.WriteBulkString(value3); - physical.WriteBulkString(value4); + writer.WriteHeader(Command, 6); + writer.Write(Key); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); + writer.WriteBulkString(value3); + writer.WriteBulkString(value4); } public override int ArgCount => 6; } @@ -1317,16 +1438,16 @@ public CommandKeyValueValueValueValueValueValueMessage(int db, CommandFlags flag this.value5 = value5; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); - physical.WriteBulkString(value3); - physical.WriteBulkString(value4); - physical.WriteBulkString(value5); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); + writer.WriteBulkString(value3); + writer.WriteBulkString(value4); + writer.WriteBulkString(value5); } public override int ArgCount => 7; } @@ -1353,17 +1474,17 @@ public CommandKeyValueValueValueValueValueValueValueMessage(int db, CommandFlags this.value6 = value6; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); - physical.WriteBulkString(value3); - physical.WriteBulkString(value4); - physical.WriteBulkString(value5); - physical.WriteBulkString(value6); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); + writer.WriteBulkString(value3); + writer.WriteBulkString(value4); + writer.WriteBulkString(value5); + writer.WriteBulkString(value6); } public override int ArgCount => 8; } @@ -1390,13 +1511,13 @@ public CommandKeyKeyValueValueMessage( this.value1 = value1; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - physical.Write(key1); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + writer.Write(key1); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); } public override int ArgCount => 4; @@ -1427,14 +1548,14 @@ public CommandKeyKeyValueValueValueMessage( this.value2 = value2; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - physical.Write(key1); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + writer.Write(key1); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); } public override int ArgCount => 5; @@ -1468,15 +1589,15 @@ public CommandKeyKeyValueValueValueValueMessage( this.value3 = value3; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - physical.Write(key1); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); - physical.WriteBulkString(value3); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + writer.Write(key1); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); + writer.WriteBulkString(value3); } public override int ArgCount => 6; @@ -1513,16 +1634,16 @@ public CommandKeyKeyValueValueValueValueValueMessage( this.value4 = value4; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - physical.Write(key1); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); - physical.WriteBulkString(value3); - physical.WriteBulkString(value4); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + writer.Write(key1); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); + writer.WriteBulkString(value3); + writer.WriteBulkString(value4); } public override int ArgCount => 7; @@ -1562,17 +1683,17 @@ public CommandKeyKeyValueValueValueValueValueValueMessage( this.value5 = value5; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - physical.Write(key1); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); - physical.WriteBulkString(value3); - physical.WriteBulkString(value4); - physical.WriteBulkString(value5); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + writer.Write(key1); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); + writer.WriteBulkString(value3); + writer.WriteBulkString(value4); + writer.WriteBulkString(value5); } public override int ArgCount => 8; @@ -1615,18 +1736,18 @@ public CommandKeyKeyValueValueValueValueValueValueValueMessage( this.value6 = value6; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - physical.Write(key1); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); - physical.WriteBulkString(value3); - physical.WriteBulkString(value4); - physical.WriteBulkString(value5); - physical.WriteBulkString(value6); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + writer.Write(key1); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); + writer.WriteBulkString(value3); + writer.WriteBulkString(value4); + writer.WriteBulkString(value5); + writer.WriteBulkString(value6); } public override int ArgCount => 9; @@ -1635,9 +1756,9 @@ protected override void WriteImpl(PhysicalConnection physical) private sealed class CommandMessage : Message { public CommandMessage(int db, CommandFlags flags, RedisCommand command) : base(db, flags, command) { } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 0); + writer.WriteHeader(Command, 0); } public override int ArgCount => 0; } @@ -1656,12 +1777,12 @@ public CommandSlotValuesMessage(int db, int slot, CommandFlags flags, RedisComma public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => slot; - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(command, values.Length); + writer.WriteHeader(command, values.Length); for (int i = 0; i < values.Length; i++) { - physical.WriteBulkString(values[i]); + writer.WriteBulkString(values[i]); } } public override int ArgCount => values.Length; @@ -1678,12 +1799,12 @@ public CommandKeySlotValuesMessage(int db, CommandFlags flags, RedisCommand comm this.values = values.AssertAllNonNull(); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(command, values.Length); + writer.WriteHeader(command, values.Length); for (int i = 0; i < values.Length; i++) { - physical.WriteBulkString(values[i]); + writer.WriteBulkString(values[i]); } } public override int ArgCount => values.Length; @@ -1706,32 +1827,32 @@ public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) // - MSETNX {key1} {value1} [{key2} {value2}...] // - MSETEX {count} {key1} {value1} [{key2} {value2}...] [standard-expiry-tokens] public override int ArgCount => Command == RedisCommand.MSETEX - ? (1 + (2 * values.Length) + expiry.GetTokenCount(allowEnx: false) + (when is When.Exists or When.NotExists ? 1 : 0)) + ? (1 + (2 * values.Length) + expiry.GetTokenCount(false) + (when is When.Exists or When.NotExists ? 1 : 0)) : (2 * values.Length); // MSET/MSETNX only support simple syntax - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { var cmd = Command; - physical.WriteHeader(cmd, ArgCount); + writer.WriteHeader(cmd, ArgCount); if (cmd == RedisCommand.MSETEX) // need count prefix { - physical.WriteBulkString(values.Length); + writer.WriteBulkString(values.Length); } for (int i = 0; i < values.Length; i++) { - physical.Write(values[i].Key); - physical.WriteBulkString(values[i].Value); + writer.Write(values[i].Key); + writer.WriteBulkString(values[i].Value); } if (cmd == RedisCommand.MSETEX) // allow expiry/mode tokens { - expiry.WriteTo(physical); + expiry.WriteTo(writer); switch (when) { case When.Exists: - physical.WriteBulkString("XX"u8); + writer.WriteRaw("$2\r\nXX\r\n"u8); break; case When.NotExists: - physical.WriteBulkString("NX"u8); + writer.WriteRaw("$2\r\nNX\r\n"u8); break; } } @@ -1748,11 +1869,11 @@ public CommandValueChannelMessage(int db, CommandFlags flags, RedisCommand comma this.value = value; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 2); - physical.WriteBulkString(value); - physical.Write(Channel); + writer.WriteHeader(Command, 2); + writer.WriteBulkString(value); + writer.Write(Channel); } public override int ArgCount => 2; } @@ -1773,11 +1894,11 @@ public override void AppendStormLog(StringBuilder sb) sb.Append(" (").Append((string?)value).Append(')'); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 2); - physical.WriteBulkString(value); - physical.Write(Key); + writer.WriteHeader(Command, 2); + writer.WriteBulkString(value); + writer.Write(Key); } public override int ArgCount => 2; } @@ -1791,10 +1912,10 @@ public CommandValueMessage(int db, CommandFlags flags, RedisCommand command, in this.value = value; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 1); - physical.WriteBulkString(value); + writer.WriteHeader(Command, 1); + writer.WriteBulkString(value); } public override int ArgCount => 1; } @@ -1810,11 +1931,11 @@ public CommandValueValueMessage(int db, CommandFlags flags, RedisCommand command this.value1 = value1; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 2); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); + writer.WriteHeader(Command, 2); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); } public override int ArgCount => 2; } @@ -1832,12 +1953,12 @@ public CommandValueValueValueMessage(int db, CommandFlags flags, RedisCommand co this.value2 = value2; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 3); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); + writer.WriteHeader(Command, 3); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); } public override int ArgCount => 3; } @@ -1859,14 +1980,14 @@ public CommandValueValueValueValueValueMessage(int db, CommandFlags flags, Redis this.value4 = value4; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 5); - physical.WriteBulkString(value0); - physical.WriteBulkString(value1); - physical.WriteBulkString(value2); - physical.WriteBulkString(value3); - physical.WriteBulkString(value4); + writer.WriteHeader(Command, 5); + writer.WriteBulkString(value0); + writer.WriteBulkString(value1); + writer.WriteBulkString(value2); + writer.WriteBulkString(value3); + writer.WriteBulkString(value4); } public override int ArgCount => 5; } @@ -1877,10 +1998,10 @@ public SelectMessage(int db, CommandFlags flags) : base(db, flags, RedisCommand. { } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 1); - physical.WriteBulkString(Db); + writer.WriteHeader(Command, 1); + writer.WriteBulkString(Db); } public override int ArgCount => 1; } @@ -1892,7 +2013,9 @@ internal sealed class UnknownMessage : Message public static UnknownMessage Instance { get; } = new(); private UnknownMessage() : base(0, CommandFlags.None, RedisCommand.UNKNOWN) { } public override int ArgCount => 0; - protected override void WriteImpl(PhysicalConnection physical) => throw new InvalidOperationException("This message cannot be written"); + protected override void WriteImpl(in MessageWriter writer) => throw new InvalidOperationException("This message cannot be written"); } + + public void SetNoFlush() => Flags |= NoFlushFlag; } } diff --git a/src/StackExchange.Redis/MessageCompletable.cs b/src/StackExchange.Redis/MessageCompletable.cs index 8f4737943..67e00a4e7 100644 --- a/src/StackExchange.Redis/MessageCompletable.cs +++ b/src/StackExchange.Redis/MessageCompletable.cs @@ -1,6 +1,5 @@ using System; using System.Text; -using Pipelines.Sockets.Unofficial; namespace StackExchange.Redis { diff --git a/src/StackExchange.Redis/MessageWriter.cs b/src/StackExchange.Redis/MessageWriter.cs new file mode 100644 index 000000000..1b654532d --- /dev/null +++ b/src/StackExchange.Redis/MessageWriter.cs @@ -0,0 +1,623 @@ +using System; +using System.Buffers; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Text; +using RESPite; +using RESPite.Internal; +using RESPite.Messages; + +namespace StackExchange.Redis; + +internal readonly ref struct MessageWriter +{ + private readonly CommandMap _map; + private readonly byte[]? _channelPrefix; + + public MessageWriter(byte[]? channelPrefix, CommandMap? map, IBufferWriter writer) + { + // ReSharper disable once NullCoalescingConditionIsAlwaysNotNullAccordingToAPIContract + _map = map ?? CommandMap.Default; + _channelPrefix = channelPrefix; + _writer = writer; + } + + public static IBufferWriter BlockBuffer => BlockBufferSerializer.Shared; + + public MessageWriter(PhysicalConnection connection, IBufferWriter writer) + { + if (connection.BridgeCouldBeNull is { } bridge) + { + _map = bridge.Multiplexer.CommandMap; + _channelPrefix = connection.ChannelPrefix; + } + else + { + _map = CommandMap.Default; + _channelPrefix = null; + } + + _writer = writer ?? connection.Output; + } + + private readonly IBufferWriter _writer; + + public static ReadOnlyMemory FlushBlockBuffer() => + BlockBufferSerializer.BlockBuffer.FinalizeMessage(BlockBufferSerializer.Shared); + + public static void RevertBlockBuffer() => BlockBufferSerializer.Shared.Revert(); + + public static void ReleaseBlockBuffer(ReadOnlyMemory memory) + { + if (MemoryMarshal.TryGetMemoryManager( + memory, out var block)) + { + block.Release(); + } + } + + public static void ReleaseBlockBuffer(in ReadOnlySequence request) => + BlockBufferSerializer.BlockBuffer.Release(in request); + + public void Write(in RedisKey key) + { + var val = key.KeyValue; + if (val is string s) + { + WriteUnifiedPrefixedString(_writer, key.KeyPrefix, s); + } + else + { + WriteUnifiedPrefixedBlob(_writer, key.KeyPrefix, (byte[]?)val); + } + } + + internal void Write(in RedisChannel channel) + => WriteUnifiedPrefixedBlob(_writer, channel.IgnoreChannelPrefix ? null : _channelPrefix, channel.Value); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal void WriteBulkString(in RedisValue value) + => WriteBulkString(value, _writer); + + internal static void WriteBulkString(in RedisValue value, IBufferWriter writer) + { + switch (value.Type) + { + case RedisValue.StorageType.Null: + WriteUnifiedBlob(writer, (byte[]?)null); + break; + case RedisValue.StorageType.Int64: + WriteUnifiedInt64(writer, value.OverlappedValueInt64); + break; + case RedisValue.StorageType.UInt64: + WriteUnifiedUInt64(writer, value.OverlappedValueUInt64); + break; + case RedisValue.StorageType.Double: + WriteUnifiedDouble(writer, value.OverlappedValueDouble); + break; + case RedisValue.StorageType.String: + WriteUnifiedPrefixedString(writer, null, value.RawString()); + break; + case RedisValue.StorageType.MemoryManager or RedisValue.StorageType.ByteArray: + WriteUnifiedSpan(writer, value.RawSpan()); + break; + default: + throw new InvalidOperationException($"Unexpected {value.Type} value: '{value}'"); + } + } + + internal void WriteBulkString(ReadOnlySpan value) => WriteUnifiedSpan(_writer, value); + + internal const int + REDIS_MAX_ARGS = + 1024 * 1024; // there is a <= 1024*1024 max constraint inside redis itself: https://github.com/antirez/redis/blob/6c60526db91e23fb2d666fc52facc9a11780a2a3/src/networking.c#L1024 + + internal void WriteHeader(string command, int arguments) + { + byte[]? lease = null; + try + { + int bytes = Encoding.ASCII.GetMaxByteCount(command.Length); + Span buffer = command.Length <= 32 ? stackalloc byte[32] : (lease = ArrayPool.Shared.Rent(bytes)); + bytes = Encoding.ASCII.GetBytes(command, buffer); + var span = buffer.Slice(0, bytes); + AsciiHash.ToUpper(span); + WriteHeader(RedisCommand.UNKNOWN, arguments, span); + } + finally + { + if (lease is not null) ArrayPool.Shared.Return(lease); + } + } + + internal void WriteHeader(RedisCommand command, int arguments) + { + // using >= here because we will be adding 1 for the command itself (which is an arg for the purposes of the multi-bulk protocol) + if (arguments >= REDIS_MAX_ARGS) throw ExceptionFactory.TooManyArgs(command.ToString(), arguments); + + // in theory we should never see this; CheckMessage dealt with "regular" messages, and + // ExecuteMessage should have dealt with everything else + var commandBytes = _map.GetResp(command); + if (commandBytes.IsEmpty) throw ExceptionFactory.CommandDisabled(command); + + // *{argCount}\r\n = 3 + MaxInt32TextLen + // ${cmd-len}\r\n = precomputed + // {cmd}\r\n = precomputed + var span = _writer.GetSpan(commandBytes.Length + 3 + Format.MaxInt32TextLen); + span[0] = (byte)'*'; + + int offset = WriteRaw(span, arguments + 1, offset: 1); + commandBytes.CopyTo(span.Slice(offset)); + offset += commandBytes.Length; + + _writer.Advance(offset); + } + + internal void WriteHeader(RedisCommand command, int arguments, ReadOnlySpan commandBytes) + { + // using >= here because we will be adding 1 for the command itself (which is an arg for the purposes of the multi-bulk protocol) + if (arguments >= REDIS_MAX_ARGS) throw ExceptionFactory.TooManyArgs(command.ToString(), arguments); + + // in theory we should never see this; CheckMessage dealt with "regular" messages, and + // ExecuteMessage should have dealt with everything else + if (commandBytes.IsEmpty) throw ExceptionFactory.CommandDisabled(command); + + // *{argCount}\r\n = 3 + MaxInt32TextLen + // ${cmd-len}\r\n = 3 + MaxInt32TextLen + // {cmd}\r\n = 2 + commandBytes.Length + var span = _writer.GetSpan(commandBytes.Length + 8 + Format.MaxInt32TextLen + Format.MaxInt32TextLen); + span[0] = (byte)'*'; + + int offset = WriteRaw(span, arguments + 1, offset: 1); + span[offset++] = (byte)'$'; + offset = AppendToSpan(span, commandBytes, offset: offset); + + _writer.Advance(offset); + } + + internal static void WriteMultiBulkHeader(IBufferWriter writer, long count) + { + // *{count}\r\n = 3 + MaxInt32TextLen + var span = writer.GetSpan(3 + Format.MaxInt32TextLen); + span[0] = (byte)'*'; + int offset = WriteRaw(span, count, offset: 1); + writer.Advance(offset); + } + + internal static void WriteMultiBulkHeader(IBufferWriter writer, long count, RespPrefix prefix) + { + // *{count}\r\n = 3 + MaxInt32TextLen + var span = writer.GetSpan(3 + Format.MaxInt32TextLen); + span[0] = (byte)prefix; + if ((prefix is RespPrefix.Map or RespPrefix.Attribute) & count > 0) + { + if ((count & 1) != 0) Throw(prefix, count); + count >>= 1; + static void Throw(RespPrefix type, long count) => throw new ArgumentOutOfRangeException( + paramName: nameof(count), + message: $"{type} data must be in pairs; got {count}"); + } + int offset = WriteRaw(span, count, offset: 1); + writer.Advance(offset); + } + + private static ReadOnlySpan NullBulkString => "$-1\r\n"u8; + private static ReadOnlySpan EmptyBulkString => "$0\r\n\r\n"u8; + + internal static void WriteUnifiedPrefixedString(IBufferWriter writer, byte[]? prefix, string? value) + { + if (value == null) + { + // special case + writer.Write(NullBulkString); + } + else + { + // ${total-len}\r\n 3 + MaxInt32TextLen + // {prefix}{value}\r\n + int encodedLength = Encoding.UTF8.GetByteCount(value), + prefixLength = prefix?.Length ?? 0, + totalLength = prefixLength + encodedLength; + + if (totalLength == 0) + { + // special-case + writer.Write(EmptyBulkString); + } + else + { + var span = writer.GetSpan(3 + Format.MaxInt32TextLen); + span[0] = (byte)'$'; + int bytes = WriteRaw(span, totalLength, offset: 1); + writer.Advance(bytes); + + if (prefixLength != 0) writer.Write(prefix); + if (encodedLength != 0) WriteRaw(writer, value, encodedLength); + WriteCrlf(writer); + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static int WriteCrlf(Span span, int offset) + { + span[offset++] = (byte)'\r'; + span[offset++] = (byte)'\n'; + return offset; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void WriteCrlf(IBufferWriter writer) + { + var span = writer.GetSpan(2); + span[0] = (byte)'\r'; + span[1] = (byte)'\n'; + writer.Advance(2); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal void WriteRaw(ReadOnlySpan value) => _writer.Write(value); + + internal static int WriteRaw(Span span, long value, bool withLengthPrefix = false, int offset = 0) + { + if (value >= 0 && value <= 9) + { + if (withLengthPrefix) + { + span[offset++] = (byte)'1'; + offset = WriteCrlf(span, offset); + } + + span[offset++] = (byte)((int)'0' + (int)value); + } + else if (value >= 10 && value < 100) + { + if (withLengthPrefix) + { + span[offset++] = (byte)'2'; + offset = WriteCrlf(span, offset); + } + + span[offset++] = (byte)((int)'0' + ((int)value / 10)); + span[offset++] = (byte)((int)'0' + ((int)value % 10)); + } + else if (value >= 100 && value < 1000) + { + int v = (int)value; + int units = v % 10; + v /= 10; + int tens = v % 10, hundreds = v / 10; + if (withLengthPrefix) + { + span[offset++] = (byte)'3'; + offset = WriteCrlf(span, offset); + } + + span[offset++] = (byte)((int)'0' + hundreds); + span[offset++] = (byte)((int)'0' + tens); + span[offset++] = (byte)((int)'0' + units); + } + else if (value < 0 && value >= -9) + { + if (withLengthPrefix) + { + span[offset++] = (byte)'2'; + offset = WriteCrlf(span, offset); + } + + span[offset++] = (byte)'-'; + span[offset++] = (byte)((int)'0' - (int)value); + } + else if (value <= -10 && value > -100) + { + if (withLengthPrefix) + { + span[offset++] = (byte)'3'; + offset = WriteCrlf(span, offset); + } + + value = -value; + span[offset++] = (byte)'-'; + span[offset++] = (byte)((int)'0' + ((int)value / 10)); + span[offset++] = (byte)((int)'0' + ((int)value % 10)); + } + else + { + // we're going to write it, but *to the wrong place* + var availableChunk = span.Slice(offset); + var formattedLength = Format.FormatInt64(value, availableChunk); + if (withLengthPrefix) + { + // now we know how large the prefix is: write the prefix, then write the value + var prefixLength = Format.FormatInt32(formattedLength, availableChunk); + offset += prefixLength; + offset = WriteCrlf(span, offset); + + availableChunk = span.Slice(offset); + var finalLength = Format.FormatInt64(value, availableChunk); + offset += finalLength; + Debug.Assert(finalLength == formattedLength); + } + else + { + offset += formattedLength; + } + } + + return WriteCrlf(span, offset); + } + + [ThreadStatic] + private static Encoder? s_PerThreadEncoder; + + internal static Encoder GetPerThreadEncoder() + { + var encoder = s_PerThreadEncoder; + if (encoder == null) + { + s_PerThreadEncoder = encoder = Encoding.UTF8.GetEncoder(); + } + else + { + encoder.Reset(); + } + + return encoder; + } + + internal static unsafe void WriteRaw(IBufferWriter writer, string value, int expectedLength) + { + const int MaxQuickEncodeSize = 512; + + fixed (char* cPtr = value) + { + int totalBytes; + if (expectedLength <= MaxQuickEncodeSize) + { + // encode directly in one hit + var span = writer.GetSpan(expectedLength); + fixed (byte* bPtr = &MemoryMarshal.GetReference(span)) + { + totalBytes = Encoding.UTF8.GetBytes( + cPtr, + value.Length, + bPtr, + expectedLength); + } + + writer.Advance(expectedLength); + } + else + { + // use an encoder in a loop + var encoder = GetPerThreadEncoder(); + int charsRemaining = value.Length, charOffset = 0; + totalBytes = 0; + + bool final = false; + while (true) + { + var span = writer + .GetSpan(5); // get *some* memory - at least enough for 1 character (but hopefully lots more) + + int charsUsed, bytesUsed; + bool completed; + fixed (byte* bPtr = &MemoryMarshal.GetReference(span)) + { + encoder.Convert( + cPtr + charOffset, + charsRemaining, + bPtr, + span.Length, + final, + out charsUsed, + out bytesUsed, + out completed); + } + + writer.Advance(bytesUsed); + totalBytes += bytesUsed; + charOffset += charsUsed; + charsRemaining -= charsUsed; + + if (charsRemaining <= 0) + { + if (charsRemaining < 0) throw new InvalidOperationException("String encode went negative"); + if (completed) break; // fine + if (final) throw new InvalidOperationException("String encode failed to complete"); + final = true; // flush the encoder to one more span, then exit + } + } + } + + if (totalBytes != expectedLength) throw new InvalidOperationException("String encode length check failure"); + } + } + + private static void WriteUnifiedPrefixedBlob(IBufferWriter writer, byte[]? prefix, byte[]? value) + { + // ${total-len}\r\n + // {prefix}{value}\r\n + if (prefix == null || prefix.Length == 0 || value == null) + { + // if no prefix, just use the non-prefixed version; + // even if prefixed, a null value writes as null, so can use the non-prefixed version + WriteUnifiedBlob(writer, value); + } + else + { + var span = writer.GetSpan(3 + + Format + .MaxInt32TextLen); // note even with 2 max-len, we're still in same text range + span[0] = (byte)'$'; + int bytes = WriteRaw(span, prefix.LongLength + value.LongLength, offset: 1); + writer.Advance(bytes); + + writer.Write(prefix); + writer.Write(value); + + span = writer.GetSpan(2); + WriteCrlf(span, 0); + writer.Advance(2); + } + } + + private static void WriteUnifiedInt64(IBufferWriter writer, long value) + { + // note from specification: A client sends to the Redis server a RESP Array consisting of just Bulk Strings. + // (i.e. we can't just send ":123\r\n", we need to send "$3\r\n123\r\n" + + // ${asc-len}\r\n = 4/5 (asc-len at most 2 digits) + // {asc}\r\n = MaxInt64TextLen + 2 + var span = writer.GetSpan(7 + Format.MaxInt64TextLen); + + span[0] = (byte)'$'; + var bytes = WriteRaw(span, value, withLengthPrefix: true, offset: 1); + writer.Advance(bytes); + } + + private static void WriteUnifiedUInt64(IBufferWriter writer, ulong value) + { + // note from specification: A client sends to the Redis server a RESP Array consisting of just Bulk Strings. + // (i.e. we can't just send ":123\r\n", we need to send "$3\r\n123\r\n" + Span valueSpan = stackalloc byte[Format.MaxInt64TextLen]; + + var len = Format.FormatUInt64(value, valueSpan); + // ${asc-len}\r\n = 4/5 (asc-len at most 2 digits) + // {asc}\r\n = {len} + 2 + var span = writer.GetSpan(7 + len); + span[0] = (byte)'$'; + int offset = WriteRaw(span, len, withLengthPrefix: false, offset: 1); + valueSpan.Slice(0, len).CopyTo(span.Slice(offset)); + offset += len; + offset = WriteCrlf(span, offset); + writer.Advance(offset); + } + + private static void WriteUnifiedDouble(IBufferWriter writer, double value) + { +#if NET8_0_OR_GREATER + Span valueSpan = stackalloc byte[Format.MaxDoubleTextLen]; + var len = Format.FormatDouble(value, valueSpan); + + // ${asc-len}\r\n = 4/5 (asc-len at most 2 digits) + // {asc}\r\n = {len} + 2 + var span = writer.GetSpan(7 + len); + span[0] = (byte)'$'; + int offset = WriteRaw(span, len, withLengthPrefix: false, offset: 1); + valueSpan.Slice(0, len).CopyTo(span.Slice(offset)); + offset += len; + offset = WriteCrlf(span, offset); + writer.Advance(offset); +#else + // fallback: drop to string + WriteUnifiedPrefixedString(writer, null, Format.ToString(value)); +#endif + } + + internal static void WriteInteger(IBufferWriter writer, long value) + { + // note: client should never write integer; only server does this + // :{asc}\r\n = MaxInt64TextLen + 3 + var span = writer.GetSpan(3 + Format.MaxInt64TextLen); + + span[0] = (byte)':'; + var bytes = WriteRaw(span, value, withLengthPrefix: false, offset: 1); + writer.Advance(bytes); + } + + private static void WriteUnifiedBlob(IBufferWriter writer, byte[]? value) + { + if (value is null) + { + // special case: + writer.Write(NullBulkString); + } + else + { + WriteUnifiedSpan(writer, new ReadOnlySpan(value)); + } + } + + private static void WriteUnifiedSpan(IBufferWriter writer, ReadOnlySpan value) + { + // ${len}\r\n = 3 + MaxInt32TextLen + // {value}\r\n = 2 + value.Length + const int MaxQuickSpanSize = 512; + if (value.Length == 0) + { + // special case: + writer.Write(EmptyBulkString); + } + else if (value.Length <= MaxQuickSpanSize) + { + var span = writer.GetSpan(5 + Format.MaxInt32TextLen + value.Length); + span[0] = (byte)'$'; + int bytes = AppendToSpan(span, value, 1); + writer.Advance(bytes); + } + else + { + // too big to guarantee can do in a single span + var span = writer.GetSpan(3 + Format.MaxInt32TextLen); + span[0] = (byte)'$'; + int bytes = WriteRaw(span, value.Length, offset: 1); + writer.Advance(bytes); + + writer.Write(value); + + WriteCrlf(writer); + } + } + + private static int AppendToSpan(Span span, ReadOnlySpan value, int offset = 0) + { + offset = WriteRaw(span, value.Length, offset: offset); + value.CopyTo(span.Slice(offset, value.Length)); + offset += value.Length; + return WriteCrlf(span, offset); + } + + internal void WriteSha1AsHex(byte[]? value) + { + var writer = _writer; + if (value is null) + { + writer.Write(NullBulkString); + } + else if (value.Length == ResultProcessor.ScriptLoadProcessor.Sha1HashLength) + { + // $40\r\n = 5 + // {40 bytes}\r\n = 42 + var span = writer.GetSpan(47); + span[0] = (byte)'$'; + span[1] = (byte)'4'; + span[2] = (byte)'0'; + span[3] = (byte)'\r'; + span[4] = (byte)'\n'; + + int offset = 5; + for (int i = 0; i < value.Length; i++) + { + var b = value[i]; + span[offset++] = ToHexNibble(b >> 4); + span[offset++] = ToHexNibble(b & 15); + } + + span[offset++] = (byte)'\r'; + span[offset++] = (byte)'\n'; + + writer.Advance(offset); + } + else + { + throw new InvalidOperationException("Invalid SHA1 length: " + value.Length); + } + } + + internal static byte ToHexNibble(int value) + { + return value < 10 ? (byte)('0' + value) : (byte)('a' - 10 + value); + } +} diff --git a/src/StackExchange.Redis/NullableHacks.cs b/src/StackExchange.Redis/NullableHacks.cs deleted file mode 100644 index 4ebebf73b..000000000 --- a/src/StackExchange.Redis/NullableHacks.cs +++ /dev/null @@ -1,148 +0,0 @@ -// https://github.com/dotnet/runtime/blob/527f9ae88a0ee216b44d556f9bdc84037fe0ebda/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/NullableAttributes.cs - -#pragma warning disable -#define INTERNAL_NULLABLE_ATTRIBUTES - -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -namespace System.Diagnostics.CodeAnalysis -{ -#if !NET - /// Specifies that null is allowed as an input even if the corresponding type disallows it. - [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)] - internal sealed class AllowNullAttribute : Attribute { } - - /// Specifies that null is disallowed as an input even if the corresponding type allows it. - [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)] - internal sealed class DisallowNullAttribute : Attribute { } - - /// Specifies that an output may be null even if the corresponding type disallows it. - [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)] - internal sealed class MaybeNullAttribute : Attribute { } - - /// Specifies that an output will not be null even if the corresponding type allows it. Specifies that an input argument was not null when the call returns. - [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)] - internal sealed class NotNullAttribute : Attribute { } - - /// Specifies that when a method returns , the parameter may be null even if the corresponding type disallows it. - [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] - internal sealed class MaybeNullWhenAttribute : Attribute - { - /// Initializes the attribute with the specified return value condition. - /// - /// The return value condition. If the method returns this value, the associated parameter may be null. - /// - public MaybeNullWhenAttribute(bool returnValue) => ReturnValue = returnValue; - - /// Gets the return value condition. - public bool ReturnValue { get; } - } - - /// Specifies that when a method returns , the parameter will not be null even if the corresponding type allows it. - [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] - internal sealed class NotNullWhenAttribute : Attribute - { - /// Initializes the attribute with the specified return value condition. - /// - /// The return value condition. If the method returns this value, the associated parameter will not be null. - /// - public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue; - - /// Gets the return value condition. - public bool ReturnValue { get; } - } - - /// Specifies that the output will be non-null if the named parameter is non-null. - [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)] - internal sealed class NotNullIfNotNullAttribute : Attribute - { - /// Initializes the attribute with the associated parameter name. - /// - /// The associated parameter name. The output will be non-null if the argument to the parameter specified is non-null. - /// - public NotNullIfNotNullAttribute(string parameterName) => ParameterName = parameterName; - - /// Gets the associated parameter name. - public string ParameterName { get; } - } - - /// Applied to a method that will never return under any circumstance. - [AttributeUsage(AttributeTargets.Method, Inherited = false)] - internal sealed class DoesNotReturnAttribute : Attribute { } - - /// Specifies that the method will not return if the associated Boolean parameter is passed the specified value. - [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] - internal sealed class DoesNotReturnIfAttribute : Attribute - { - /// Initializes the attribute with the specified parameter value. - /// - /// The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to - /// the associated parameter matches this value. - /// - public DoesNotReturnIfAttribute(bool parameterValue) => ParameterValue = parameterValue; - - /// Gets the condition parameter value. - public bool ParameterValue { get; } - } -#endif - -#if !NET - /// Specifies that the method or property will ensure that the listed field and property members have not-null values. - [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)] - internal sealed class MemberNotNullAttribute : Attribute - { - /// Initializes the attribute with a field or property member. - /// - /// The field or property member that is promised to be not-null. - /// - public MemberNotNullAttribute(string member) => Members = new[] { member }; - - /// Initializes the attribute with the list of field and property members. - /// - /// The list of field and property members that are promised to be not-null. - /// - public MemberNotNullAttribute(params string[] members) => Members = members; - - /// Gets field or property member names. - public string[] Members { get; } - } - - /// Specifies that the method or property will ensure that the listed field and property members have not-null values when returning with the specified return value condition. - [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)] - internal sealed class MemberNotNullWhenAttribute : Attribute - { - /// Initializes the attribute with the specified return value condition and a field or property member. - /// - /// The return value condition. If the method returns this value, the associated parameter will not be null. - /// - /// - /// The field or property member that is promised to be not-null. - /// - public MemberNotNullWhenAttribute(bool returnValue, string member) - { - ReturnValue = returnValue; - Members = new[] { member }; - } - - /// Initializes the attribute with the specified return value condition and list of field and property members. - /// - /// The return value condition. If the method returns this value, the associated parameter will not be null. - /// - /// - /// The list of field and property members that are promised to be not-null. - /// - public MemberNotNullWhenAttribute(bool returnValue, params string[] members) - { - ReturnValue = returnValue; - Members = members; - } - - /// Gets the return value condition. - public bool ReturnValue { get; } - - /// Gets field or property member names. - public string[] Members { get; } - } -#endif -} diff --git a/src/StackExchange.Redis/PhysicalBridge.cs b/src/StackExchange.Redis/PhysicalBridge.cs index 96e0a17e9..21047efa2 100644 --- a/src/StackExchange.Redis/PhysicalBridge.cs +++ b/src/StackExchange.Redis/PhysicalBridge.cs @@ -8,10 +8,6 @@ using System.Threading; using System.Threading.Tasks; using Microsoft.Extensions.Logging; -#if !NETCOREAPP -using Pipelines.Sockets.Unofficial.Threading; -using static Pipelines.Sockets.Unofficial.Threading.MutexSlim; -#endif namespace StackExchange.Redis { @@ -64,11 +60,7 @@ internal sealed class PhysicalBridge : IDisposable internal long? ConnectionId => physical?.ConnectionId; -#if NET - private readonly SemaphoreSlim _singleWriterMutex = new(1, 1); -#else - private readonly MutexSlim _singleWriterMutex; -#endif + private readonly AwaitableMutex _singleWriter; internal string? PhysicalName => physical?.ToString(); @@ -82,10 +74,7 @@ public PhysicalBridge(ServerEndPoint serverEndPoint, ConnectionType type, int ti ConnectionType = type; Multiplexer = serverEndPoint.Multiplexer; Name = Format.ToString(serverEndPoint.EndPoint) + "/" + ConnectionType.ToString(); - TimeoutMilliseconds = timeoutMilliseconds; -#if !NETCOREAPP - _singleWriterMutex = new MutexSlim(timeoutMilliseconds: timeoutMilliseconds); -#endif + _singleWriter = AwaitableMutex.Create(timeoutMilliseconds: timeoutMilliseconds); if (type == ConnectionType.Interactive && Multiplexer.RawConfig.HighIntegrity) { // we just need this to be non-zero to enable tracking @@ -93,8 +82,6 @@ public PhysicalBridge(ServerEndPoint serverEndPoint, ConnectionType type, int ti } } - private readonly int TimeoutMilliseconds; - public enum State : byte { Connecting, @@ -357,11 +344,7 @@ public override string ToString() => { MessagesSinceLastHeartbeat = (int)(Interlocked.Read(ref operationCount) - Interlocked.Read(ref profileLastLog)), ConnectedAt = ConnectedAt, -#if NET - IsWriterActive = _singleWriterMutex.CurrentCount == 0, -#else - IsWriterActive = !_singleWriterMutex.IsAvailable, -#endif + IsWriterActive = !_singleWriter.IsAvailable, BacklogMessagesPending = _backlog.Count, BacklogMessagesPendingCounter = Volatile.Read(ref _backlogCurrentEnqueued), BacklogStatus = _backlogStatus, @@ -592,10 +575,15 @@ internal void OnHeartbeat(bool ifConnectedOnly) long newSampleCount = Interlocked.Read(ref operationCount); Interlocked.Exchange(ref profileLog[index % ProfileLogSamples], newSampleCount); Interlocked.Exchange(ref profileLastLog, newSampleCount); - Trace("OnHeartbeat: " + (State)state); + +#pragma warning disable CS0420 // A reference to a volatile field will not be treated as volatile + // ReSharper disable once LocalVariableHidesMember + ref State state = ref Unsafe.As(ref this.state); +#pragma warning restore CS0420 // A reference to a volatile field will not be treated as volatile + Trace("OnHeartbeat: " + state); switch (state) { - case (int)State.Connecting: + case State.Connecting: if (DueForConnectRetry()) { Interlocked.Increment(ref connectTimeoutRetryCount); @@ -610,17 +598,17 @@ internal void OnHeartbeat(bool ifConnectedOnly) TryConnect(null); } break; - case (int)State.ConnectedEstablishing: + case State.ConnectedEstablishing: // (Fall through) Happens when we successfully connected via TCP, but no Redis handshake completion yet. // This can happen brief (usual) or when the server never answers (rare). When we're in this state, // a socket is open and reader likely listening indefinitely for incoming data on an async background task. // We need to time that out and cleanup the PhysicalConnection if needed, otherwise that reader and socket will remain open // for the lifetime of the application due to being orphaned, yet still referenced by the active task doing the pipe read. - case (int)State.ConnectedEstablished: + case State.ConnectedEstablished: var tmp = physical; if (tmp != null) { - if (state == (int)State.ConnectedEstablished) + if (state is State.ConnectedEstablished) { // Track that we should reset the count on the next disconnect, but not do so in a loop, reset // the connect-retry-count (used for backoff decay etc), and remove any non-responsive flag. @@ -632,7 +620,7 @@ internal void OnHeartbeat(bool ifConnectedOnly) int writeEverySeconds = ServerEndPoint.WriteEverySeconds; bool configCheckDue = ServerEndPoint.ConfigCheckSeconds > 0 && ServerEndPoint.LastInfoReplicationCheckSecondsAgo >= ServerEndPoint.ConfigCheckSeconds; - if (state == (int)State.ConnectedEstablished && ConnectionType == ConnectionType.Interactive + if (state is State.ConnectedEstablished && ConnectionType == ConnectionType.Interactive && tmp.BridgeCouldBeNull?.Multiplexer.RawConfig.HeartbeatConsistencyChecks == true) { // If HeartbeatConsistencyChecks are enabled, we're sending a PING (expecting PONG) or ECHO (expecting UniqueID back) every single @@ -647,7 +635,7 @@ internal void OnHeartbeat(bool ifConnectedOnly) ServerEndPoint.CheckInfoReplication(); } } - else if (state == (int)State.ConnectedEstablished && ConnectionType == ConnectionType.Interactive + else if (state is State.ConnectedEstablished && ConnectionType == ConnectionType.Interactive && configCheckDue && ServerEndPoint.CheckInfoReplication()) { @@ -656,7 +644,7 @@ internal void OnHeartbeat(bool ifConnectedOnly) else if (writeEverySeconds > 0 && tmp.LastWriteSecondsAgo >= writeEverySeconds) { Trace("OnHeartbeat - overdue"); - if (state == (int)State.ConnectedEstablished) + if (state is State.ConnectedEstablished) { KeepAlive(); } @@ -692,7 +680,7 @@ internal void OnHeartbeat(bool ifConnectedOnly) } } break; - case (int)State.Disconnected: + case State.Disconnected: // Only if we should reset the connection count // This should only happen after a successful reconnection, and not every time we bounce from BeginConnectAsync -> Disconnected // in a failure loop case that happens when a node goes missing forever. @@ -822,20 +810,11 @@ internal WriteResult WriteMessageTakingWriteLockSync(PhysicalConnection physical return WriteResult.Success; // queued counts as success } -#if NET bool gotLock = false; -#else - LockToken token = default; -#endif try { -#if NET - gotLock = _singleWriterMutex.Wait(0); + gotLock = _singleWriter.TryTakeInstant(); if (!gotLock) -#else - token = _singleWriterMutex.TryWait(WaitOptions.NoDelay); - if (!token.Success) -#endif { // If we can't get it *instantaneously*, pass it to the backlog for throughput if (TryPushToBacklog(message, onlyIfExists: false)) @@ -846,20 +825,15 @@ internal WriteResult WriteMessageTakingWriteLockSync(PhysicalConnection physical // no backlog... try to wait with the timeout; // if we *still* can't get it: that counts as // an actual timeout -#if NET - gotLock = _singleWriterMutex.Wait(TimeoutMilliseconds); + gotLock = _singleWriter.TryTakeSync(); if (!gotLock) return TimedOutBeforeWrite(message); -#else - token = _singleWriterMutex.TryWait(); - if (!token.Success) return TimedOutBeforeWrite(message); -#endif } var result = WriteMessageInsideLock(physical, message); - if (result == WriteResult.Success) + if (result == WriteResult.Success & message.IsFlushRequiredSync) { - result = physical.FlushSync(false, TimeoutMilliseconds); + physical.Flush(); } physical.SetIdle(); @@ -869,14 +843,10 @@ internal WriteResult WriteMessageTakingWriteLockSync(PhysicalConnection physical finally { UnmarkActiveMessage(message); -#if NET if (gotLock) { - _singleWriterMutex.Release(); + _singleWriter.Release(); } -#else - token.Dispose(); -#endif } } @@ -996,7 +966,7 @@ private void StartBacklogProcessor() private void CheckBacklogForTimeouts() { var now = Environment.TickCount; - var timeout = TimeoutMilliseconds; + var timeout = _singleWriter.TimeoutMilliseconds; // Because peeking at the backlog, checking message and then dequeuing, is not thread-safe, we do have to use // a lock here, for mutual exclusion of backlog DEQUEUERS. Unfortunately. @@ -1147,11 +1117,7 @@ private void ProcessBridgeBacklog() { // Importantly: don't assume we have a physical connection here // We are very likely to hit a state where it's not re-established or even referenced here -#if NET bool gotLock = false; -#else - LockToken token = default; -#endif _backlogAutoReset.Reset(); try { @@ -1169,20 +1135,16 @@ private void ProcessBridgeBacklog() if (_backlog.IsEmpty) return; // nothing to do // try and get the lock; if unsuccessful, retry -#if NET - gotLock = _singleWriterMutex.Wait(TimeoutMilliseconds); + gotLock = _singleWriter.TryTakeSync(); if (gotLock) break; // got the lock; now go do something with it -#else - token = _singleWriterMutex.TryWait(); - if (token.Success) break; // got the lock; now go do something with it -#endif } _backlogStatus = BacklogStatus.Started; // Only execute if we're connected. // Timeouts are handled above, so we're exclusively into backlog items eligible to write at this point. // If we can't write them, abort and wait for the next heartbeat or activation to try this again. - while (IsConnected && physical?.HasOutputPipe == true) + bool flush = false; + while (IsConnected && physical is { HasOutputPipe: true }) { Message? message; _backlogStatus = BacklogStatus.CheckingForWork; @@ -1202,13 +1164,8 @@ private void ProcessBridgeBacklog() _backlogStatus = BacklogStatus.WritingMessage; var result = WriteMessageInsideLock(physical, message); - if (result == WriteResult.Success) - { - _backlogStatus = BacklogStatus.Flushing; -#pragma warning disable CS0618 // Type or member is obsolete - result = physical.FlushSync(false, TimeoutMilliseconds); -#pragma warning restore CS0618 // Type or member is obsolete - } + // use flush logic that assumes a sync caller + if (!flush) flush = message.IsFlushRequiredSync; _backlogStatus = BacklogStatus.MarkingInactive; if (result != WriteResult.Success) @@ -1228,20 +1185,24 @@ private void ProcessBridgeBacklog() UnmarkActiveMessage(message); } } + + if (flush && IsConnected && physical is { HasOutputPipe: true }) + { + // at least one message wants flushing + _backlogStatus = BacklogStatus.Flushing; + physical?.Flush(); + } + _backlogStatus = BacklogStatus.SettingIdle; physical?.SetIdle(); _backlogStatus = BacklogStatus.Inactive; } finally { -#if NET if (gotLock) { - _singleWriterMutex.Release(); + _singleWriter.Release(); } -#else - token.Dispose(); -#endif } } @@ -1285,22 +1246,12 @@ internal ValueTask WriteMessageTakingWriteLockAsync(PhysicalConnect } bool releaseLock = true; // fine to default to true, as it doesn't matter until token is a "success" -#if NET bool gotLock = false; -#else - LockToken token = default; -#endif try { // try to acquire it synchronously -#if NET - gotLock = _singleWriterMutex.Wait(0); + gotLock = _singleWriter.TryTakeInstant(); if (!gotLock) -#else - // note: timeout is specified in mutex-constructor - token = _singleWriterMutex.TryWait(options: WaitOptions.NoDelay); - if (!token.Success) -#endif { // If we can't get it *instantaneously*, pass it to the backlog for throughput if (TryPushToBacklog(message, onlyIfExists: false, bypassBacklog: bypassBacklog)) @@ -1311,35 +1262,16 @@ internal ValueTask WriteMessageTakingWriteLockAsync(PhysicalConnect // no backlog... try to wait with the timeout; // if we *still* can't get it: that counts as // an actual timeout -#if NET - var pending = _singleWriterMutex.WaitAsync(TimeoutMilliseconds); - if (pending.Status != TaskStatus.RanToCompletion) return WriteMessageTakingWriteLockAsync_Awaited(pending, physical, message); - - gotLock = pending.Result; // fine since we know we got a result - if (!gotLock) return new ValueTask(TimedOutBeforeWrite(message)); -#else - var pending = _singleWriterMutex.TryWaitAsync(options: WaitOptions.DisableAsyncContext); + var pending = _singleWriter.TryTakeAsync(); if (!pending.IsCompletedSuccessfully) return WriteMessageTakingWriteLockAsync_Awaited(pending, physical, message); - token = pending.Result; // fine since we know we got a result - if (!token.Success) return new ValueTask(TimedOutBeforeWrite(message)); -#endif + gotLock = pending.GetAwaiter().GetResult(); // fine since we know we got a result + if (!gotLock) return new ValueTask(TimedOutBeforeWrite(message)); } var result = WriteMessageInsideLock(physical, message); - if (result == WriteResult.Success) + if (result == WriteResult.Success & message.IsFlushRequiredAsync) { - var flush = physical.FlushAsync(false); - if (!flush.IsCompletedSuccessfully) - { - releaseLock = false; // so we don't release prematurely -#if NET - return CompleteWriteAndReleaseLockAsync(physical, flush, message); -#else - return CompleteWriteAndReleaseLockAsync(token, physical, flush, message); -#endif - } - - result = flush.Result; // .Result: we know it was completed, so this is fine + physical.Flush(); } physical.SetIdle(); @@ -1352,52 +1284,33 @@ internal ValueTask WriteMessageTakingWriteLockAsync(PhysicalConnect } finally { -#if NET if (gotLock) -#else - if (token.Success) -#endif { UnmarkActiveMessage(message); if (releaseLock) { -#if NET - _singleWriterMutex.Release(); -#else - token.Dispose(); -#endif + _singleWriter.Release(); } } } } private async ValueTask WriteMessageTakingWriteLockAsync_Awaited( -#if NET - Task pending, -#else - ValueTask pending, -#endif + ValueTask pending, PhysicalConnection physical, Message message) { -#if NET bool gotLock = false; -#endif - try { -#if NET gotLock = await pending.ForAwait(); if (!gotLock) return TimedOutBeforeWrite(message); -#else - using var token = await pending.ForAwait(); -#endif var result = WriteMessageInsideLock(physical, message); if (result == WriteResult.Success) { - result = await physical.FlushAsync(false).ForAwait(); + physical.Flush(); } physical.SetIdle(); @@ -1411,27 +1324,18 @@ private async ValueTask WriteMessageTakingWriteLockAsync_Awaited( finally { UnmarkActiveMessage(message); -#if NET if (gotLock) { - _singleWriterMutex.Release(); + _singleWriter.Release(); } -#endif } } [SuppressMessage("StyleCop.CSharp.LayoutRules", "SA1519:Braces should not be omitted from multi-line child statement", Justification = "Detector is confused with the #ifdefs here")] private async ValueTask CompleteWriteAndReleaseLockAsync( -#if !NETCOREAPP - LockToken lockToken, -#endif - PhysicalConnection physical, ValueTask flush, Message message) { -#if !NETCOREAPP - using (lockToken) -#endif try { var result = await flush.ForAwait(); @@ -1444,9 +1348,7 @@ private async ValueTask CompleteWriteAndReleaseLockAsync( } finally { -#if NET - _singleWriterMutex.Release(); -#endif + _singleWriter.Release(); } } @@ -1504,7 +1406,7 @@ private bool ChangeState(State oldState, State newState) Interlocked.Exchange(ref connectStartTicks, Environment.TickCount); // separate creation and connection for case when connection completes synchronously // in that case PhysicalConnection will call back to PhysicalBridge, and most PhysicalBridge methods assume that physical is not null; - physical = new PhysicalConnection(this); + physical = new PhysicalConnection(this, Multiplexer.RawConfig.WriteMode); physical.BeginConnectAsync(log).RedisFireAndForget(); } @@ -1724,6 +1626,8 @@ private uint NextHighIntegrityTokenInsideLock() } } + internal bool CanSimulateConnectionFailure => Multiplexer.RawConfig.AllowAdmin && physical?.CanSimulateConnectionFailure == true; + /// /// For testing only. /// diff --git a/src/StackExchange.Redis/PhysicalConnection.Read.cs b/src/StackExchange.Redis/PhysicalConnection.Read.cs new file mode 100644 index 000000000..29f2ef6db --- /dev/null +++ b/src/StackExchange.Redis/PhysicalConnection.Read.cs @@ -0,0 +1,838 @@ +using System; +using System.Buffers; +using System.Buffers.Binary; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.IO; +using System.Net; +using System.Threading; +using System.Threading.Tasks; +using RESPite; +using RESPite.Buffers; +using RESPite.Internal; +using RESPite.Messages; + +namespace StackExchange.Redis; + +internal sealed partial class PhysicalConnection +{ + private long totalBytesReceived; + + internal static PhysicalConnection Dummy(Stream stream, BufferedStreamWriter.WriteMode writeMode = BufferedStreamWriter.WriteMode.Default) + => new(ioStream: stream, writeMode: writeMode); + + private volatile ReadStatus _readStatus = ReadStatus.NotStarted; + internal ReadStatus GetReadStatus() => _readStatus; + + private BufferedStreamWriter.WriteMode WriteMode { get; } + + internal void StartReading(CancellationToken cancellation = default) + { + if (cancellation.CanBeCanceled && cancellation != InputCancel) + { + cancellation.ThrowIfCancellationRequested(); + if (InputCancel.CanBeCanceled) + { + cancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellation, InputCancel).Token; + } + } + else + { + cancellation = InputCancel; + } + + if (_output is { IsSync: true }) + { + StartReadingSync(this, cancellation); + static void StartReadingSync(PhysicalConnection conn, CancellationToken cancellation) + { + // this method exists purely to limit capture context scope + Thread thread = new Thread(() => conn.ReadAllSync(cancellation)) + { + IsBackground = true, + Priority = ThreadPriority.AboveNormal, + Name = "SE.Redis Sync Writer", + }; + thread.Start(); + } + } + else + { + ReadAllAsync(cancellation).RedisFireAndForget(); + } + } + + private async Task ReadAllAsync(CancellationToken cancellationToken) + { + var tail = _ioStream ?? Stream.Null; + _readStatus = ReadStatus.Init; + _readState = default; + _readBuffer = CycleBuffer.Create(); + try + { + int read; + do + { + _readStatus = ReadStatus.ReadAsync; + var buffer = _readBuffer.GetUncommittedMemory(); + var pending = tail.ReadAsync(buffer, cancellationToken); +#if DEBUG + bool inline = pending.IsCompleted; +#endif + read = await pending.ConfigureAwait(false); + _readStatus = ReadStatus.UpdateWriteTime; + UpdateLastReadTime(); +#if DEBUG + DebugCounters.OnAsyncRead(read, inline); +#endif + _readStatus = ReadStatus.TryParseResult; + } + // another formatter glitch + while (CommitAndParseFrames(read) && !ForceReconnect); + + _readStatus = ReadStatus.ProcessBufferComplete; + + // Volatile.Write(ref _readStatus, ReaderCompleted); + _readBuffer.Release(); // clean exit, we can recycle + _readStatus = ReadStatus.RanToCompletion; + RecordConnectionFailed(ConnectionFailureType.SocketClosed); + } + catch (EndOfStreamException) when (_readStatus is ReadStatus.ReadAsync) + { + _readStatus = ReadStatus.RanToCompletion; + RecordConnectionFailed(ConnectionFailureType.SocketClosed); + } + catch (OperationCanceledException) when (_readStatus is ReadStatus.ReadAsync) + { + _readStatus = ReadStatus.RanToCompletion; + RecordConnectionFailed(ConnectionFailureType.SocketClosed); + } + catch (Exception ex) + { + _readStatus = ReadStatus.Faulted; + RecordConnectionFailed(ConnectionFailureType.InternalFailure, ex); + } + finally + { + _readBuffer = default; // wipe, however we exited + } + } + + private void ReadAllSync(CancellationToken cancellationToken) + { + var tail = _ioStream ?? Stream.Null; + _readStatus = ReadStatus.Init; + _readState = default; + _readBuffer = CycleBuffer.Create(); + try + { + int read; + do + { + _readStatus = ReadStatus.ReadAsync; + var buffer = _readBuffer.GetUncommittedMemory(); + cancellationToken.ThrowIfCancellationRequested(); +#if NET + read = tail.Read(buffer.Span); +#else + read = tail.Read(buffer); +#endif + + _readStatus = ReadStatus.UpdateWriteTime; + UpdateLastReadTime(); + + DebugCounters.OnSyncRead(read); + _readStatus = ReadStatus.TryParseResult; + } + // another formatter glitch + while (CommitAndParseFrames(read) && !ForceReconnect); + + _readStatus = ReadStatus.ProcessBufferComplete; + + // Volatile.Write(ref _readStatus, ReaderCompleted); + _readBuffer.Release(); // clean exit, we can recycle + _readStatus = ReadStatus.RanToCompletion; + RecordConnectionFailed(ConnectionFailureType.SocketClosed); + } + catch (EndOfStreamException) when (_readStatus is ReadStatus.ReadAsync) + { + _readStatus = ReadStatus.RanToCompletion; + RecordConnectionFailed(ConnectionFailureType.SocketClosed); + } + catch (OperationCanceledException) when (_readStatus is ReadStatus.ReadAsync) + { + _readStatus = ReadStatus.RanToCompletion; + RecordConnectionFailed(ConnectionFailureType.SocketClosed); + } + catch (Exception ex) + { + _readStatus = ReadStatus.Faulted; + RecordConnectionFailed(ConnectionFailureType.InternalFailure, ex); + } + finally + { + _readBuffer = default; // wipe, however we exited + } + } + + private bool ForceReconnect => BridgeCouldBeNull?.NeedsReconnect == true; + + private static byte[]? SharedNoLease; + + private CycleBuffer _readBuffer; + private RespScanState _readState = default; + + private long GetReadCommittedLength() + { + try + { + var len = _readBuffer.GetCommittedLength(); + return len < 0 ? -1 : len; + } + catch + { + return -1; + } + } + + private bool CommitAndParseFrames(int bytesRead) + { + if (bytesRead <= 0) + { + return false; + } + ref RespScanState state = ref _readState; // avoid a ton of ldarg0 + + totalBytesReceived += bytesRead; +#if PARSE_DETAIL + string src = $"parse {bytesRead}"; + try +#endif + { + Debug.Assert(_readBuffer.GetCommittedLength() >= 0, "multi-segment running-indices are corrupt"); +#if PARSE_DETAIL + src += $" ({_readBuffer.GetCommittedLength()}+{bytesRead}-{state.TotalBytes})"; +#endif + Debug.Assert( + bytesRead <= _readBuffer.UncommittedAvailable, + $"Insufficient bytes in {nameof(CommitAndParseFrames)}; got {bytesRead}, Available={_readBuffer.UncommittedAvailable}"); + _readBuffer.Commit(bytesRead); +#if PARSE_DETAIL + src += $",total {_readBuffer.GetCommittedLength()}"; +#endif + var scanner = RespFrameScanner.Default; + + OperationStatus status = OperationStatus.NeedMoreData; + if (_readBuffer.TryGetCommitted(out var fullSpan)) + { + int fullyConsumed = 0; + var toParse = fullSpan.Slice((int)state.TotalBytes); // skip what we've already parsed + OnDetailLog($"parsing {toParse.Length} bytes, single buffer"); + + Debug.Assert(!toParse.IsEmpty); + while (true) + { +#if PARSE_DETAIL + src += $",span {toParse.Length}"; +#endif + int totalBytesBefore = (int)state.TotalBytes; + if (toParse.Length < RespScanState.MinBytes + || (status = scanner.TryRead(ref state, toParse)) != OperationStatus.Done) + { + break; + } + + Debug.Assert( + state is + { + IsComplete: true, TotalBytes: >= RespScanState.MinBytes, Prefix: not RespPrefix.None + }, + "Invalid RESP read state"); + + // extract the frame + var bytes = (int)state.TotalBytes; +#if PARSE_DETAIL + src += $",frame {bytes}"; +#endif + // send the frame somewhere (note this is the *full* frame, not just the bit we just parsed) + OnDetailLog($"found {state.Prefix} frame, {bytes} bytes"); + OnResponseFrame(state.Prefix, fullSpan.Slice(fullyConsumed, bytes), ref SharedNoLease); + UpdateBufferStats(bytes, toParse.Length); + + // update our buffers to the unread potions and reset for a new RESP frame + fullyConsumed += bytes; + toParse = toParse.Slice(bytes - totalBytesBefore); // move past the extra bytes we just read + state = default; + status = OperationStatus.NeedMoreData; + } + OnDetailLog($"discarding {fullyConsumed} bytes"); + _readBuffer.DiscardCommitted(fullyConsumed); + } + else // the same thing again, but this time with multi-segment sequence + { + var fullSequence = _readBuffer.GetAllCommitted(); + Debug.Assert( + fullSequence is { IsEmpty: false, IsSingleSegment: false }, + "non-trivial sequence expected"); + + long fullyConsumed = 0; + var toParse = fullSequence.Slice((int)state.TotalBytes); // skip what we've already parsed + OnDetailLog($"parsing {toParse.Length} bytes, multi-buffer"); + + while (true) + { +#if PARSE_DETAIL + src += $",ros {toParse.Length}"; +#endif + int totalBytesBefore = (int)state.TotalBytes; + if (toParse.Length < RespScanState.MinBytes + || (status = scanner.TryRead(ref state, toParse)) != OperationStatus.Done) + { + break; + } + + Debug.Assert( + state is + { + IsComplete: true, TotalBytes: >= RespScanState.MinBytes, Prefix: not RespPrefix.None + }, + "Invalid RESP read state"); + + // extract the frame + var bytes = (int)state.TotalBytes; +#if PARSE_DETAIL + src += $",frame {bytes}"; +#endif + // send the frame somewhere (note this is the *full* frame, not just the bit we just parsed) + OnDetailLog($"found {state.Prefix} frame, {bytes} bytes"); + OnResponseFrame(state.Prefix, fullSequence.Slice(fullyConsumed, bytes)); + UpdateBufferStats(bytes, toParse.Length); + + // update our buffers to the unread potions and reset for a new RESP frame + fullyConsumed += bytes; + toParse = toParse.Slice(bytes - totalBytesBefore); // move past the extra bytes we just read + state = default; + status = OperationStatus.NeedMoreData; + } + + OnDetailLog($"discarding {fullyConsumed} bytes"); + _readBuffer.DiscardCommitted(fullyConsumed); + } + + if (status != OperationStatus.NeedMoreData) + { + ThrowStatus(status); + + static void ThrowStatus(OperationStatus status) => + throw new InvalidOperationException($"Unexpected operation status: {status}"); + } + + return true; + } +#if PARSE_DETAIL + catch (Exception ex) + { + OnDetailLog($"{nameof(CommitAndParseFrames)}: {ex.Message}"); + OnDetailLog(src); + if (Debugger.IsAttached) Debugger.Break(); + throw new InvalidOperationException($"{src} lead to {ex.Message}", ex); + } +#endif + } + + [Conditional("PARSE_DETAIL")] + internal void OnDetailLog(string message) + { +#if PARSE_DETAIL + message = $"[{id}] {message}"; + lock (LogLock) + { + Console.WriteLine(message); + Debug.WriteLine(message); + File.AppendAllText("verbose.log", message + Environment.NewLine); + } +#endif + } + +#if PARSE_DETAIL + private static int s_id; + private readonly int id = Interlocked.Increment(ref s_id); + private static readonly object LogLock = new(); +#endif + + private void OnResponseFrame(RespPrefix prefix, ReadOnlySequence payload) + { + if (payload.IsSingleSegment) + { +#if NET + OnResponseFrame(prefix, payload.FirstSpan, ref SharedNoLease); +#else + OnResponseFrame(prefix, payload.First.Span, ref SharedNoLease); +#endif + } + else + { + var len = checked((int)payload.Length); + byte[]? oversized = ArrayPool.Shared.Rent(len); + payload.CopyTo(oversized); + OnResponseFrame(prefix, new(oversized, 0, len), ref oversized); + + // the lease could have been claimed by the activation code (to prevent another memcpy); otherwise, free + if (oversized is not null) + { + ArrayPool.Shared.Return(oversized); + } + } + } + + private void UpdateBufferStats(int lastResult, long inBuffer) + { + // Track the last result size *after* processing for the *next* error message + bytesInBuffer = inBuffer; + bytesLastResult = lastResult; + } + + private void OnResponseFrame(RespPrefix prefix, ReadOnlySpan frame, ref byte[]? lease) + { + DebugValidateSingleFrame(frame); + _readStatus = ReadStatus.MatchResult; + + switch (prefix) + { + case RespPrefix.Push: // explicit RESP3 push message + case RespPrefix.Array when (_protocol is RedisProtocol.Resp2 & connectionType is ConnectionType.Subscription) + && !IsArrayPong(frame): // could be a RESP2 pub/sub payload + // out-of-band; pub/sub etc + if (OnOutOfBand(frame, ref lease)) + { + OnDetailLog($"out-of-band message, not dequeuing: {prefix}"); + return; + } + break; + } + + // request/response; match to inbound + MatchNextResult(frame); + + static bool IsArrayPong(ReadOnlySpan payload) + { + if (payload.Length >= sizeof(ulong)) + { + var hash = AsciiHash.HashCS(payload); + switch (hash) + { + case ArrayPong_LC_Bulk.HashCS when payload.StartsWith(ArrayPong_LC_Bulk.U8): + case ArrayPong_UC_Bulk.HashCS when payload.StartsWith(ArrayPong_UC_Bulk.U8): + case ArrayPong_LC_Simple.HashCS when payload.StartsWith(ArrayPong_LC_Simple.U8): + case ArrayPong_UC_Simple.HashCS when payload.StartsWith(ArrayPong_UC_Simple.U8): + var reader = new RespReader(payload); + return reader.SafeTryMoveNext() // have root + && reader.Prefix == RespPrefix.Array // root is array + && reader.SafeTryMoveNext() // have first child + && (reader.IsInlneCpuUInt32(pong) || reader.IsInlneCpuUInt32(PONG)); // pong + } + } + + return false; + } + } + + internal enum PushKind + { + [AsciiHash("")] + None, + [AsciiHash("message")] + Message, + [AsciiHash("pmessage")] + PMessage, + [AsciiHash("smessage")] + SMessage, + [AsciiHash("subscribe")] + Subscribe, + [AsciiHash("psubscribe")] + PSubscribe, + [AsciiHash("ssubscribe")] + SSubscribe, + [AsciiHash("unsubscribe")] + Unsubscribe, + [AsciiHash("punsubscribe")] + PUnsubscribe, + [AsciiHash("sunsubscribe")] + SUnsubscribe, + } + + internal static partial class PushKindMetadata + { + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out PushKind result); + } + + internal static ReadOnlySpan StackCopyLengthChecked(scoped in RespReader reader, Span buffer) + { + var len = reader.CopyTo(buffer); + if (len == buffer.Length && reader.ScalarLength() > len) return default; // too small + return buffer.Slice(0, len); + } + + private bool OnOutOfBand(ReadOnlySpan payload, ref byte[]? lease) + { + var muxer = BridgeCouldBeNull?.Multiplexer; + if (muxer is null) return true; // consume it blindly + + var reader = new RespReader(payload); + + // read the message kind from the first element + if (reader.SafeTryMoveNext() & reader.IsAggregate & !reader.IsStreaming + && reader.AggregateLength() >= 2 + && (reader.SafeTryMoveNext() & reader.IsInlineScalar & !reader.IsError)) + { + PushKind kind; + unsafe + { + if (!reader.TryParseScalar(&PushKindMetadata.TryParse, out kind)) kind = PushKind.None; + } + + RedisChannel.RedisChannelOptions channelOptions = kind switch + { + PushKind.PMessage or PushKind.PSubscribe or PushKind.PUnsubscribe => RedisChannel.RedisChannelOptions.Pattern, + PushKind.SMessage or PushKind.SSubscribe or PushKind.SUnsubscribe => RedisChannel.RedisChannelOptions.Sharded, + _ => RedisChannel.RedisChannelOptions.None, + }; + + static bool TryMoveNextString(ref RespReader reader) + => reader.SafeTryMoveNext() & reader.IsInlineScalar & + reader.Prefix is RespPrefix.BulkString or RespPrefix.SimpleString; + + if (kind is PushKind.None || !TryMoveNextString(ref reader)) return false; + + // the channel is always the second element + var subscriptionChannel = AsRedisChannel(reader, channelOptions); + + switch (kind) + { + case (PushKind.Message or PushKind.SMessage) when reader.SafeTryMoveNext(): + _readStatus = kind is PushKind.Message ? ReadStatus.PubSubMessage : ReadStatus.PubSubSMessage; + + // special-case the configuration change broadcasts (we don't keep that in the usual pub/sub registry) + var configChanged = muxer.ConfigurationChangedChannel; + if (configChanged != null && reader.Prefix is RespPrefix.BulkString or RespPrefix.SimpleString && subscriptionChannel.Span.SequenceEqual(configChanged)) + { + EndPoint? blame = null; + try + { + if (!reader.Is("*"u8)) + { + // We don't want to fail here, just trying to identify + _ = Format.TryParseEndPoint(reader.ReadString(), out blame); + } + } + catch + { + /* no biggie */ + } + + Trace("Configuration changed: " + Format.ToString(blame)); + _readStatus = ReadStatus.Reconfigure; + muxer.ReconfigureIfNeeded(blame, true, "broadcast"); + } + + // invoke the handlers + if (!subscriptionChannel.IsNull) + { + Trace($"{kind}: {subscriptionChannel}"); + OnMessage(muxer, subscriptionChannel, subscriptionChannel, in reader); + } + + return true; + case PushKind.PMessage when TryMoveNextString(ref reader): + _readStatus = ReadStatus.PubSubPMessage; + + var messageChannel = AsRedisChannel(reader, RedisChannel.RedisChannelOptions.None); + if (!messageChannel.IsNull && reader.SafeTryMoveNext()) + { + Trace($"{kind}: {messageChannel} via {subscriptionChannel}"); + OnMessage(muxer, subscriptionChannel, messageChannel, in reader); + } + + return true; + case PushKind.SUnsubscribe when !PeekChannelMessage(RedisCommand.SUNSUBSCRIBE, subscriptionChannel): + // then it was *unsolicited* - this probably means the slot was migrated + // (otherwise, we'll let the command-processor deal with it) + _readStatus = ReadStatus.PubSubUnsubscribe; + var server = BridgeCouldBeNull?.ServerEndPoint; + if (server is not null && muxer.TryGetSubscription(subscriptionChannel, out var subscription)) + { + // wipe and reconnect; but: to where? + // counter-intuitively, the only server we *know* already knows the new route is: + // the outgoing server, since it had to change to MIGRATING etc; the new INCOMING server + // knows, but *we don't know who that is*, and other nodes: aren't guaranteed to know (yet) + muxer.DefaultSubscriber.ResubscribeToServer(subscription, subscriptionChannel, server, cause: "sunsubscribe"); + } + return true; + } + } + return false; + } + + private void OnMessage( + ConnectionMultiplexer muxer, + in RedisChannel subscriptionChannel, + in RedisChannel messageChannel, + in RespReader reader) + { + // note: this could be multi-message: https://github.com/StackExchange/StackExchange.Redis/issues/2507 + _readStatus = ReadStatus.InvokePubSub; + switch (reader.Prefix) + { + case RespPrefix.BulkString: + case RespPrefix.SimpleString: + muxer.OnMessage(subscriptionChannel, messageChannel, reader.ReadRedisValue()); + break; + case RespPrefix.Array: + var iter = reader.AggregateChildren(); + while (iter.MoveNext()) + { + muxer.OnMessage(subscriptionChannel, messageChannel, iter.Value.ReadRedisValue()); + } + + break; + } + } + + private void MatchNextResult(ReadOnlySpan frame) + { + Trace("Matching result..."); + + Message? msg = null; + // check whether we're waiting for a high-integrity mode post-response checksum (using cheap null-check first) + if (_awaitingToken is not null && (msg = Interlocked.Exchange(ref _awaitingToken, null)) is not null) + { + _readStatus = ReadStatus.ResponseSequenceCheck; + if (!ProcessHighIntegrityResponseToken(msg, frame, BridgeCouldBeNull)) + { + RecordConnectionFailed(ConnectionFailureType.ResponseIntegrityFailure, origin: nameof(ReadStatus.ResponseSequenceCheck)); + } + return; + } + + _readStatus = ReadStatus.DequeueResult; + lock (_writtenAwaitingResponse) + { + if (msg is not null) + { + _awaitingToken = null; + } + + if (!_writtenAwaitingResponse.TryDequeue(out msg)) + { + Throw(frame, connectionType, _protocol); + + [DoesNotReturn] + static void Throw(ReadOnlySpan frame, ConnectionType connection, RedisProtocol protocol) + { + var prefix = RespReaderExtensions.GetRespPrefix(frame); + throw new InvalidOperationException($"Received {connection}/{protocol} response with no message waiting: " + prefix.ToString()); + } + } + } + _activeMessage = msg; + + Trace("Response to: " + msg); + _readStatus = ReadStatus.ComputeResult; + var reader = new RespReader(frame); + + OnDetailLog($"computing result for {msg.CommandAndKey} ({RespReaderExtensions.GetRespPrefix(frame)})"); + + // need to capture HIT promptly, as -MOVED could cause a resend with a new high-integrity token + // (a lazy approach would be to not rotate, but: we'd rather avoid that; the -MOVED case is rare) + var highIntegrityToken = msg.HighIntegrityToken; + bool computed = msg.ComputeResult(this, ref reader); + if (computed) + { + OnDetailLog($"> complete: {msg.CommandAndKey}"); + _readStatus = msg.ResultBoxIsAsync ? ReadStatus.CompletePendingMessageAsync : ReadStatus.CompletePendingMessageSync; + if (highIntegrityToken is 0) + { + // can't complete yet if needs checksum + msg.Complete(); + } + } + else + { + OnDetailLog($"> incomplete: {msg.CommandAndKey}"); + } + if (highIntegrityToken is not 0) + { + // stash this for the next non-OOB response, retaining the old HIT iff we had a -MOVED etc + Volatile.Write(ref _awaitingToken, computed ? msg : new DummyHighIntegrityMessage(msg, highIntegrityToken)); + } + + _readStatus = ReadStatus.MatchResultComplete; + _activeMessage = null; + + static bool ProcessHighIntegrityResponseToken(Message message, ReadOnlySpan frame, PhysicalBridge? bridge) + { + bool isValid = false; + var reader = new RespReader(frame); + if ((reader.SafeTryMoveNext() & reader.IsScalar) + && reader.ScalarLength() is 4) + { + uint interpreted; + if (reader.TryGetSpan(out var span)) + { + interpreted = BinaryPrimitives.ReadUInt32LittleEndian(span); + } + else + { + Span tmp = stackalloc byte[4]; + reader.CopyTo(tmp); + interpreted = BinaryPrimitives.ReadUInt32LittleEndian(tmp); + } + isValid = interpreted == message.HighIntegrityToken; + } + if (isValid) + { + message.Complete(); + return true; + } + else + { + message.SetExceptionAndComplete(new InvalidOperationException("High-integrity mode detected possible protocol de-sync"), bridge); + return false; + } + } + } + + private bool PeekChannelMessage(RedisCommand command, in RedisChannel channel) + { + Message? msg; + bool haveMsg; + lock (_writtenAwaitingResponse) + { + haveMsg = _writtenAwaitingResponse.TryPeek(out msg); + } + + return haveMsg && msg is Message.CommandChannelBase typed + && typed.Command == command && typed.Channel == channel; + } + + internal RedisChannel AsRedisChannel(in RespReader reader, RedisChannel.RedisChannelOptions options) + { + var channelPrefix = ChannelPrefix; + if (channelPrefix is null) + { + // no channel-prefix enabled, just use as-is + return new RedisChannel(reader.ReadByteArray(), options); + } + + byte[] lease = []; + var span = reader.TryGetSpan(out var tmp) ? tmp : reader.Buffer(ref lease, stackalloc byte[256]); + + if (span.StartsWith(channelPrefix)) + { + // we have a channel-prefix, and it matches; strip it + span = span.Slice(channelPrefix.Length); + } + else if (IsServerDefinedChannel(span)) + { + // Server-defined channels should ignore our channel-prefix rules. + // we shouldn't get unexpected events, so to get here: we've received a notification + // on a channel that doesn't match our prefix; this *should* be limited to + // key notifications (see: IgnoreChannelPrefix), but: we need to be sure + + // leave alone + } + else + { + // no idea what this is + span = default; + } + + RedisChannel channel = span.IsEmpty ? default : new(span.ToArray(), options); + if (lease.Length != 0) ArrayPool.Shared.Return(lease); + return channel; + } + + private static bool IsServerDefinedChannel(ReadOnlySpan span) + { + var hash = AsciiHash.HashCS(span); + return hash switch + { + KeyspaceChannelPrefix.HashCS when span.StartsWith(KeyspaceChannelPrefix.U8) => true, + KeyeventChannelPrefix.HashCS when span.StartsWith(KeyeventChannelPrefix.U8) => true, + SubkeyspaceChannelPrefix.HashCS when span.StartsWith(SubkeyspaceChannelPrefix.U8) => true, + SubkeyeventChannelPrefix.HashCS when span.StartsWith(SubkeyeventChannelPrefix.U8) => true, + SubkeyspaceItemChannelPrefix.HashCS when span.StartsWith(SubkeyspaceItemChannelPrefix.U8) => true, + SubkeyspaceEventChannelPrefix.HashCS when span.StartsWith(SubkeyspaceEventChannelPrefix.U8) => true, + _ => false, + }; + } + + [AsciiHash("__keyspace@")] + private static partial class KeyspaceChannelPrefix { } + [AsciiHash("__keyevent@")] + private static partial class KeyeventChannelPrefix { } + [AsciiHash("__subkeyspace@")] + private static partial class SubkeyspaceChannelPrefix { } + [AsciiHash("__subkeyevent@")] + private static partial class SubkeyeventChannelPrefix { } + [AsciiHash("__subkeyspaceitem@")] + private static partial class SubkeyspaceItemChannelPrefix { } + [AsciiHash("__subkeyspaceevent@")] + private static partial class SubkeyspaceEventChannelPrefix { } + + [AsciiHash("*2\r\n$4\r\npong\r\n$")] + private static partial class ArrayPong_LC_Bulk { } + [AsciiHash("*2\r\n$4\r\nPONG\r\n$")] + private static partial class ArrayPong_UC_Bulk { } + [AsciiHash("*2\r\n+pong\r\n$")] + private static partial class ArrayPong_LC_Simple { } + [AsciiHash("*2\r\n+PONG\r\n$")] + private static partial class ArrayPong_UC_Simple { } + + // ReSharper disable InconsistentNaming + private static readonly uint + pong = RespConstants.UnsafeCpuUInt32("pong"u8), + PONG = RespConstants.UnsafeCpuUInt32("PONG"u8); + + // ReSharper restore InconsistentNaming + [Conditional("DEBUG")] + private static void DebugValidateSingleFrame(ReadOnlySpan payload) + { + var reader = new RespReader(payload); + if (!reader.TryMoveNext(checkError: false)) + { + throw new InvalidOperationException("No root RESP element"); + } + reader.SkipChildren(); + +#pragma warning disable CS0618 // we don't expect *any* additional data, even attributes + if (reader.TryReadNext()) +#pragma warning restore CS0618 + { + throw new InvalidOperationException($"Unexpected trailing {reader.Prefix}"); + } + + if (reader.ProtocolBytesRemaining != 0) + { + var copy = reader; // leave reader alone for inspection + var prefix = copy.SafeTryMoveNext() ? copy.Prefix : RespPrefix.None; + throw new InvalidOperationException( + $"Unexpected additional {reader.ProtocolBytesRemaining} bytes remaining, {prefix}"); + } + } + + internal sealed class DummyHighIntegrityMessage : Message + { + // note: we don't create this message very often - only when a HIT gets a -MOVED or similar + public DummyHighIntegrityMessage(Message msg, uint highIntegrityToken) : base(msg.Db, msg.Flags, msg.Command) + { + WithHighIntegrity(highIntegrityToken); + } + + public override int ArgCount => 0; + + protected override void WriteImpl(in MessageWriter writer) + => throw new NotSupportedException("This message cannot be written; it is a place-holder for high-integrity scenarios."); + } +} diff --git a/src/StackExchange.Redis/PhysicalConnection.Write.cs b/src/StackExchange.Redis/PhysicalConnection.Write.cs new file mode 100644 index 000000000..84d3430e1 --- /dev/null +++ b/src/StackExchange.Redis/PhysicalConnection.Write.cs @@ -0,0 +1,42 @@ +using System; +using System.Buffers; +using System.IO; +using System.Threading.Tasks; + +namespace StackExchange.Redis; + +internal partial class PhysicalConnection +{ + private BufferedStreamWriter? _output; + private long TotalBytesSent => _output?.TotalBytesWritten ?? 0; + public IBufferWriter Output + { + get + { + return _output ?? Throw(); + static IBufferWriter Throw() => throw new InvalidOperationException("Output pipe not initialized"); + } + } + + private void InitOutput(Stream? stream) + { + if (stream is null) return; + _ioStream = stream; + _output = BufferedStreamWriter.Create(WriteMode, connectionType, stream, OutputCancel); +#if DEBUG + if (BridgeCouldBeNull?.Multiplexer.RawConfig.OutputLog is { } log) + { + _output.DebugSetLog(log); + } +#endif + } + + internal bool HasOutputPipe => _output is not null; + + internal Task CompleteOutputAsync(Exception? exception = null) + { + if (_output is not { } output) return Task.CompletedTask; + output.Complete(exception); + return output.WriteComplete; + } +} diff --git a/src/StackExchange.Redis/PhysicalConnection.cs b/src/StackExchange.Redis/PhysicalConnection.cs index ab075a304..5a036cc22 100644 --- a/src/StackExchange.Redis/PhysicalConnection.cs +++ b/src/StackExchange.Redis/PhysicalConnection.cs @@ -1,11 +1,8 @@ using System; -using System.Buffers; -using System.Buffers.Binary; using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.IO; -using System.IO.Pipelines; using System.Linq; using System.Net; using System.Net.Security; @@ -17,15 +14,19 @@ using System.Threading; using System.Threading.Tasks; using Microsoft.Extensions.Logging; -using Pipelines.Sockets.Unofficial; -using Pipelines.Sockets.Unofficial.Arenas; -using RESPite; + using static StackExchange.Redis.Message; namespace StackExchange.Redis { internal sealed partial class PhysicalConnection : IDisposable { + // infrastructure to simulate connection death; opt-in only (for tests) + private readonly CancellationTokenSource? _inputCancel, _outputCancel; + + internal CancellationToken InputCancel => _inputCancel?.Token ?? CancellationToken.None; + internal CancellationToken OutputCancel => _outputCancel?.Token ?? CancellationToken.None; + internal readonly byte[]? ChannelPrefix; private const int DefaultRedisDatabaseCount = 16; @@ -64,44 +65,96 @@ private static readonly Message internal void GetBytes(out long sent, out long received) { - if (_ioPipe is IMeasuredDuplexPipe sc) - { - sent = sc.TotalBytesSent; - received = sc.TotalBytesReceived; - } - else - { - sent = received = -1; - } + sent = TotalBytesSent; + received = totalBytesReceived; } /// /// Nullable because during simulation of failure, we'll null out. /// ...but in those cases, we'll accept any null ref in a race - it's fine. /// - private IDuplexPipe? _ioPipe; - internal bool HasOutputPipe => _ioPipe?.Output != null; + private Stream? _ioStream; private Socket? _socket; internal Socket? VolatileSocket => Volatile.Read(ref _socket); - public PhysicalConnection(PhysicalBridge bridge) + // used for dummy test connections + public PhysicalConnection( + ConnectionType connectionType = ConnectionType.Interactive, + RedisProtocol protocol = RedisProtocol.Resp2, + Stream? ioStream = null, + BufferedStreamWriter.WriteMode writeMode = BufferedStreamWriter.WriteMode.Default, + [CallerMemberName] string name = "") + { + lastWriteTickCount = lastReadTickCount = Environment.TickCount; + lastBeatTickCount = 0; + this.connectionType = connectionType; + WriteMode = writeMode; + _protocol = protocol; + _bridge = new WeakReference(null); + _physicalName = name; + InitOutput(ioStream); + OnCreateEcho(); + } + + public PhysicalConnection(PhysicalBridge bridge, BufferedStreamWriter.WriteMode writeMode) { lastWriteTickCount = lastReadTickCount = Environment.TickCount; lastBeatTickCount = 0; connectionType = bridge.ConnectionType; + WriteMode = writeMode; _bridge = new WeakReference(bridge); ChannelPrefix = bridge.Multiplexer.ChannelPrefix; if (ChannelPrefix?.Length == 0) ChannelPrefix = null; // null tests are easier than null+empty var endpoint = bridge.ServerEndPoint.EndPoint; _physicalName = connectionType + "#" + Interlocked.Increment(ref totalCount) + "@" + Format.ToString(endpoint); - + if (bridge.Multiplexer.RawConfig.AllowSimulateConnectionFailure) + { + _inputCancel = new(); + _outputCancel = new(); + } OnCreateEcho(); } // *definitely* multi-database; this can help identify some unusual config scenarios internal bool MultiDatabasesOverride { get; set; } // switch to flags-enum if more needed later +#if NET + private static CancellationTokenSource? _spareTimeoutSource; +#endif + + private static CancellationTokenSource GetTimeout(int milliseconds) + { +#if NET + var source = Interlocked.Exchange(ref _spareTimeoutSource, null) ?? new(); +#else + var source = new CancellationTokenSource(); +#endif + source.CancelAfter(milliseconds); + return source; + } + + private static void DiscardTimeout(ref CancellationTokenSource? source) + { + #if NET // can try to recycle + if (source is not null + && source.TryReset() + && Interlocked.CompareExchange(ref _spareTimeoutSource, source, null) is null) + { + // reusable and stashed, nice + source = null; + } + #endif + + if (source is not null) + { + try { source.Dispose(); } + catch { } + + source = null; + } + } + internal async Task BeginConnectAsync(ILogger? log) { var bridge = BridgeCouldBeNull; @@ -122,7 +175,9 @@ internal async Task BeginConnectAsync(ILogger? log) } if (connectTo is not null) { + #pragma warning disable CS0618 _socket = SocketManager.CreateSocket(connectTo, rawConfig.TcpKeepAlive); + #pragma warning restore CS0618 } if (_socket is not null) @@ -140,85 +195,67 @@ internal async Task BeginConnectAsync(ILogger? log) CancellationTokenSource? timeoutSource = null; try { - using (var args = connectTo is null ? null : new SocketAwaitableEventArgs + ValueTask pendingConnect; + if (connectTo is not null && VolatileSocket is { } socket) { - RemoteEndPoint = connectTo, - }) + timeoutSource = GetTimeout(bridge.Multiplexer.RawConfig.ConnectTimeout); + pendingConnect = socket.ConnectAsync(connectTo, timeoutSource.Token); + } + else { - var x = VolatileSocket; - if (x == null) - { - args?.Abort(); - } - else if (args is not null && x.ConnectAsync(args)) - { - // asynchronous operation is pending - timeoutSource = ConfigureTimeout(args, bridge.Multiplexer.RawConfig.ConnectTimeout); - } - else - { - // completed synchronously - args?.Complete(); - } + pendingConnect = default; + } - // Complete connection - try - { - // If we're told to ignore connect, abort here - if (BridgeCouldBeNull?.Multiplexer?.IgnoreConnect ?? false) return; + // Complete connection + try + { + // If we're told to ignore connect, abort here + if (BridgeCouldBeNull?.Multiplexer?.IgnoreConnect ?? false) return; - if (args is not null) - { - await args; // wait for the connect to complete or fail (will throw) - } - if (timeoutSource != null) - { - timeoutSource.Cancel(); - timeoutSource.Dispose(); - } + await pendingConnect.ForAwait(); // wait for the connect to complete or fail (will throw) + DiscardTimeout(ref timeoutSource); - x = VolatileSocket; - if (x == null && args is not null) - { - ConnectionMultiplexer.TraceWithoutContext("Socket was already aborted"); - } - else if (await ConnectedAsync(x, log, bridge.Multiplexer.SocketManager!).ForAwait()) + socket = VolatileSocket; + if (socket is null && connectTo is not null) + { + ConnectionMultiplexer.TraceWithoutContext("Socket was already aborted"); + } + else if (await ConnectedAsync(socket, log).ForAwait()) + { + log?.LogInformationStartingRead(new(endpoint)); + try { - log?.LogInformationStartingRead(new(endpoint)); - try - { - StartReading(); - // Normal return - } - catch (Exception ex) - { - ConnectionMultiplexer.TraceWithoutContext(ex.Message); - Shutdown(); - } + StartReading(CancellationToken.None); // this already includes InputCancel + // Normal return } - else + catch (Exception ex) { - ConnectionMultiplexer.TraceWithoutContext("Aborting socket"); + ConnectionMultiplexer.TraceWithoutContext(ex.Message); Shutdown(); } } - catch (ObjectDisposedException ex) + else { - log?.LogErrorSocketShutdown(ex, new(endpoint)); - try { RecordConnectionFailed(ConnectionFailureType.UnableToConnect, isInitialConnect: true); } - catch (Exception inner) - { - ConnectionMultiplexer.TraceWithoutContext(inner.Message); - } + ConnectionMultiplexer.TraceWithoutContext("Aborting socket"); + Shutdown(); } - catch (Exception outer) + } + catch (ObjectDisposedException ex) + { + log?.LogErrorSocketShutdown(ex, new(endpoint)); + try { RecordConnectionFailed(ConnectionFailureType.UnableToConnect, isInitialConnect: true); } + catch (Exception inner) { - ConnectionMultiplexer.TraceWithoutContext(outer.Message); - try { RecordConnectionFailed(ConnectionFailureType.UnableToConnect, isInitialConnect: true); } - catch (Exception inner) - { - ConnectionMultiplexer.TraceWithoutContext(inner.Message); - } + ConnectionMultiplexer.TraceWithoutContext(inner.Message); + } + } + catch (Exception outer) + { + ConnectionMultiplexer.TraceWithoutContext(outer.Message); + try { RecordConnectionFailed(ConnectionFailureType.UnableToConnect, isInitialConnect: true); } + catch (Exception inner) + { + ConnectionMultiplexer.TraceWithoutContext(inner.Message); } } } @@ -232,25 +269,6 @@ internal async Task BeginConnectAsync(ILogger? log) } } - private static CancellationTokenSource ConfigureTimeout(SocketAwaitableEventArgs args, int timeoutMilliseconds) - { - var cts = new CancellationTokenSource(); - var timeout = Task.Delay(timeoutMilliseconds, cts.Token); - timeout.ContinueWith( - (_, state) => - { - try - { - var a = (SocketAwaitableEventArgs)state!; - a.Abort(SocketError.TimedOut); - Socket.CancelConnectAsync(a); - } - catch { } - }, - args); - return cts; - } - private enum ReadMode : byte { NotSpecified, @@ -276,7 +294,7 @@ private enum ReadMode : byte private RedisProtocol _protocol; // note starts at **zero**, not RESP2 public RedisProtocol? Protocol => _protocol == 0 ? null : _protocol; - internal void SetProtocol(RedisProtocol value) + public void SetProtocol(RedisProtocol value) { _protocol = value; BridgeCouldBeNull?.SetProtocol(value); @@ -285,18 +303,14 @@ internal void SetProtocol(RedisProtocol value) [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "Trust me yo")] internal void Shutdown(ConnectionFailureType failureType = ConnectionFailureType.ConnectionDisposed) { - var ioPipe = Interlocked.Exchange(ref _ioPipe, null); // compare to the critical read + var output = Interlocked.Exchange(ref _output, null); // compare to the critical read var socket = Interlocked.Exchange(ref _socket, null); - if (ioPipe != null) + if (output != null) { Trace("Disconnecting..."); try { BridgeCouldBeNull?.OnDisconnected(failureType, this, out _, out _); } catch { } - try { ioPipe.Input?.CancelPendingRead(); } catch { } - try { ioPipe.Input?.Complete(); } catch { } - try { ioPipe.Output?.CancelPendingFlush(); } catch { } - try { ioPipe.Output?.Complete(); } catch { } - try { using (ioPipe as IDisposable) { } } catch { } + try { output.Complete(); } catch { } } if (socket != null) @@ -317,66 +331,32 @@ public void Dispose() RecordConnectionFailed(ConnectionFailureType.ConnectionDisposed); } OnCloseEcho(); - _arena.Dispose(); - _reusableFlushSyncTokenSource?.Dispose(); + // ReSharper disable once GCSuppressFinalizeForTypeWithoutDestructor GC.SuppressFinalize(this); } - private async Task AwaitedFlush(ValueTask flush) - { - await flush.ForAwait(); - _writeStatus = WriteStatus.Flushed; - UpdateLastWriteTime(); - } internal void UpdateLastWriteTime() => Interlocked.Exchange(ref lastWriteTickCount, Environment.TickCount); - public Task FlushAsync() - { - var tmp = _ioPipe?.Output; - if (tmp != null) - { - _writeStatus = WriteStatus.Flushing; - var flush = tmp.FlushAsync(); - if (!flush.IsCompletedSuccessfully) - { - return AwaitedFlush(flush); - } - _writeStatus = WriteStatus.Flushed; - UpdateLastWriteTime(); - } - return Task.CompletedTask; - } + + internal bool CanSimulateConnectionFailure => _inputCancel is not null | _outputCancel is not null; internal void SimulateConnectionFailure(SimulatedFailureType failureType) { - var raiseFailed = false; - if (connectionType == ConnectionType.Interactive) - { - if (failureType.HasFlag(SimulatedFailureType.InteractiveInbound)) - { - _ioPipe?.Input.Complete(new Exception("Simulating interactive input failure")); - raiseFailed = true; - } - if (failureType.HasFlag(SimulatedFailureType.InteractiveOutbound)) - { - _ioPipe?.Output.Complete(new Exception("Simulating interactive output failure")); - raiseFailed = true; - } - } - else if (connectionType == ConnectionType.Subscription) + bool killInput = false, killOutput = false; + switch (connectionType) { - if (failureType.HasFlag(SimulatedFailureType.SubscriptionInbound)) - { - _ioPipe?.Input.Complete(new Exception("Simulating subscription input failure")); - raiseFailed = true; - } - if (failureType.HasFlag(SimulatedFailureType.SubscriptionOutbound)) - { - _ioPipe?.Output.Complete(new Exception("Simulating subscription output failure")); - raiseFailed = true; - } + case ConnectionType.Interactive: + killInput = failureType.HasFlag(SimulatedFailureType.InteractiveInbound); + killOutput = failureType.HasFlag(SimulatedFailureType.InteractiveOutbound); + break; + case ConnectionType.Subscription: + killInput = failureType.HasFlag(SimulatedFailureType.SubscriptionInbound); + killOutput = failureType.HasFlag(SimulatedFailureType.SubscriptionOutbound); + break; } - if (raiseFailed) + if (killInput | killOutput) { + if (killInput) _inputCancel?.Cancel(); + if (killOutput) _outputCancel?.Cancel(); RecordConnectionFailed(ConnectionFailureType.SocketFailure); } } @@ -386,15 +366,14 @@ public void RecordConnectionFailed( Exception? innerException = null, [CallerMemberName] string? origin = null, bool isInitialConnect = false, - IDuplexPipe? connectingPipe = null) + Stream? connectingStream = null) { - bool weAskedForThis; Exception? outerException = innerException; IdentifyFailureType(innerException, ref failureType); var bridge = BridgeCouldBeNull; Message? nextMessage; - if (_ioPipe != null || isInitialConnect) // if *we* didn't burn the pipe: flag it + if (_ioStream is not null || isInitialConnect) // if *we* didn't burn the pipe: flag it { if (failureType == ConnectionFailureType.InternalFailure && innerException is not null) { @@ -434,9 +413,10 @@ public void RecordConnectionFailed( var exMessage = new StringBuilder(failureType.ToString()); // If the reason for the shutdown was we asked for the socket to die, don't log it as an error (only informational) - weAskedForThis = Volatile.Read(ref clientSentQuit) != 0; + var weAskedForThis = Volatile.Read(ref clientSentQuit) != 0; - var pipe = connectingPipe ?? _ioPipe; + /* + var pipe = connectingStream ?? _ioStream; if (pipe is SocketConnection sc) { exMessage.Append(" (").Append(sc.ShutdownKind); @@ -455,9 +435,14 @@ public void RecordConnectionFailed( if (sent == 0) { exMessage.Append(recd == 0 ? " (0-read, 0-sent)" : " (0-sent)"); } else if (recd == 0) { exMessage.Append(" (0-read)"); } } + */ + + long sent = TotalBytesSent, recd = totalBytesReceived; + if (sent == 0) { exMessage.Append(recd == 0 ? " (0-read, 0-sent)" : " (0-sent)"); } + else if (recd == 0) { exMessage.Append(" (0-read)"); } var data = new List>(); - void AddData(string lk, string sk, string? v) + void AddData(string? lk, string? sk, string? v) { if (lk != null) data.Add(Tuple.Create(lk, v)); if (sk != null) exMessage.Append(", ").Append(sk).Append(": ").Append(v); @@ -482,7 +467,6 @@ void AddData(string lk, string sk, string? v) if (unansweredWriteTime != 0) AddData("Unanswered-Write", "unanswered-write", (unchecked(now - unansweredWriteTime) / 1000) + "s ago"); AddData("Keep-Alive", "keep-alive", bridge.ServerEndPoint?.WriteEverySeconds + "s"); AddData("Previous-Physical-State", "state", oldState.ToString()); - AddData("Manager", "mgr", bridge.Multiplexer.SocketManager?.GetState()); if (connStatus.BytesAvailableOnSocket >= 0) AddData("Inbound-Bytes", "in", connStatus.BytesAvailableOnSocket.ToString()); if (connStatus.BytesInReadPipe >= 0) AddData("Inbound-Pipe-Bytes", "in-pipe", connStatus.BytesInReadPipe.ToString()); if (connStatus.BytesInWritePipe >= 0) AddData("Outbound-Pipe-Bytes", "out-pipe", connStatus.BytesInWritePipe.ToString()); @@ -601,10 +585,10 @@ internal static void IdentifyFailureType(Exception? exception, ref ConnectionFai } } - internal void EnqueueInsideWriteLock(Message next) + internal void EnqueueInsideWriteLock(Message next, bool enforceMuxer = true) { var multiplexer = BridgeCouldBeNull?.Multiplexer; - if (multiplexer is null) + if (multiplexer is null & enforceMuxer) // note: this should only be false for testing { // multiplexer already collected? then we're almost certainly doomed; // we can still process it to avoid making things worse/more complex, @@ -822,773 +806,150 @@ internal void SetUnknownDatabase() currentDatabase = -1; } - internal void Write(in RedisKey key) - { - var val = key.KeyValue; - if (val is string s) - { - WriteUnifiedPrefixedString(_ioPipe?.Output, key.KeyPrefix, s); - } - else - { - WriteUnifiedPrefixedBlob(_ioPipe?.Output, key.KeyPrefix, (byte[]?)val); - } - } - - internal void Write(in RedisChannel channel) - => WriteUnifiedPrefixedBlob(_ioPipe?.Output, channel.IgnoreChannelPrefix ? null : ChannelPrefix, channel.Value); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal void WriteBulkString(in RedisValue value) - => WriteBulkString(value, _ioPipe?.Output); - internal static void WriteBulkString(in RedisValue value, IBufferWriter? maybeNullWriter) + internal void RecordQuit() { - if (maybeNullWriter is not { } writer) - { - return; // Prevent null refs during disposal - } - - switch (value.Type) - { - case RedisValue.StorageType.Null: - WriteUnifiedBlob(writer, (byte[]?)null); - break; - case RedisValue.StorageType.Int64: - WriteUnifiedInt64(writer, value.OverlappedValueInt64); - break; - case RedisValue.StorageType.UInt64: - WriteUnifiedUInt64(writer, value.OverlappedValueUInt64); - break; - case RedisValue.StorageType.Double: - WriteUnifiedDouble(writer, value.OverlappedValueDouble); - break; - case RedisValue.StorageType.String: - WriteUnifiedPrefixedString(writer, null, (string?)value); - break; - case RedisValue.StorageType.Raw: - WriteUnifiedSpan(writer, ((ReadOnlyMemory)value).Span); - break; - default: - throw new InvalidOperationException($"Unexpected {value.Type} value: '{value}'"); - } + // don't blame redis if we fired the first shot + Volatile.Write(ref clientSentQuit, 1); + // (_ioPipe as SocketConnection)?.TrySetProtocolShutdown(PipeShutdownKind.ProtocolExitClient); } - internal void WriteBulkString(ReadOnlySpan value) + internal void Flush() { - if (_ioPipe?.Output is { } writer) - { - WriteUnifiedSpan(writer, value); - } + var tmp = _output; + if (tmp is null) Throw(); + _writeStatus = WriteStatus.Flushing; + tmp.Flush(); + _writeStatus = WriteStatus.Flushed; + UpdateLastWriteTime(); + [DoesNotReturn] + static void Throw() => throw new InvalidOperationException("Output pipe not initialized"); } - internal const int REDIS_MAX_ARGS = 1024 * 1024; // there is a <= 1024*1024 max constraint inside redis itself: https://github.com/antirez/redis/blob/6c60526db91e23fb2d666fc52facc9a11780a2a3/src/networking.c#L1024 - - internal void WriteHeader(RedisCommand command, int arguments, CommandBytes commandBytes = default) + internal readonly struct ConnectionStatus { - if (_ioPipe?.Output is not PipeWriter writer) - { - return; // Prevent null refs during disposal - } - - var bridge = BridgeCouldBeNull ?? throw new ObjectDisposedException(ToString()); + /// + /// Number of messages sent outbound, but we don't yet have a response for. + /// + public int MessagesSentAwaitingResponse { get; init; } - if (command == RedisCommand.UNKNOWN) - { - // using >= here because we will be adding 1 for the command itself (which is an arg for the purposes of the multi-bulk protocol) - if (arguments >= REDIS_MAX_ARGS) throw ExceptionFactory.TooManyArgs(commandBytes.ToString(), arguments); - } - else - { - // using >= here because we will be adding 1 for the command itself (which is an arg for the purposes of the multi-bulk protocol) - if (arguments >= REDIS_MAX_ARGS) throw ExceptionFactory.TooManyArgs(command.ToString(), arguments); + /// + /// Bytes available on the socket, not yet read into the pipe. + /// + public long BytesAvailableOnSocket { get; init; } - // for everything that isn't custom commands: ask the muxer for the actual bytes - commandBytes = bridge.Multiplexer.CommandMap.GetBytes(command); - } + /// + /// Bytes read from the socket, pending in the reader pipe. + /// + public long BytesInReadPipe { get; init; } - // in theory we should never see this; CheckMessage dealt with "regular" messages, and - // ExecuteMessage should have dealt with everything else - if (commandBytes.IsEmpty) throw ExceptionFactory.CommandDisabled(command); + /// + /// Bytes in the writer pipe, waiting to be written to the socket. + /// + public long BytesInWritePipe { get; init; } - // *{argCount}\r\n = 3 + MaxInt32TextLen - // ${cmd-len}\r\n = 3 + MaxInt32TextLen - // {cmd}\r\n = 2 + commandBytes.Length - var span = writer.GetSpan(commandBytes.Length + 8 + Format.MaxInt32TextLen + Format.MaxInt32TextLen); - span[0] = (byte)'*'; + /// + /// Byte size of the last result we processed. + /// + public long BytesLastResult { get; init; } - int offset = WriteRaw(span, arguments + 1, offset: 1); + /// + /// Byte size on the buffer that isn't processed yet. + /// + public long BytesInBuffer { get; init; } - offset = AppendToSpanCommand(span, commandBytes, offset: offset); + /// + /// The inbound pipe reader status. + /// + public ReadStatus ReadStatus { get; init; } - writer.Advance(offset); - } + /// + /// The outbound pipe writer status. + /// + public WriteStatus WriteStatus { get; init; } - internal void WriteRaw(ReadOnlySpan bytes) => _ioPipe?.Output?.Write(bytes); + public override string ToString() => + $"SentAwaitingResponse: {MessagesSentAwaitingResponse}, AvailableOnSocket: {BytesAvailableOnSocket} byte(s), InReadPipe: {BytesInReadPipe} byte(s), InWritePipe: {BytesInWritePipe} byte(s), ReadStatus: {ReadStatus}, WriteStatus: {WriteStatus}"; - internal void RecordQuit() - { - // don't blame redis if we fired the first shot - Volatile.Write(ref clientSentQuit, 1); - (_ioPipe as SocketConnection)?.TrySetProtocolShutdown(PipeShutdownKind.ProtocolExitClient); - } + /// + /// The default connection stats, notable *not* the same as default since initializers don't run. + /// + public static ConnectionStatus Default { get; } = new() + { + BytesAvailableOnSocket = -1, + BytesInReadPipe = -1, + BytesInWritePipe = -1, + ReadStatus = ReadStatus.NA, + WriteStatus = WriteStatus.NA, + }; - internal static void WriteMultiBulkHeader(IBufferWriter output, long count) - { - // *{count}\r\n = 3 + MaxInt32TextLen - var span = output.GetSpan(3 + Format.MaxInt32TextLen); - span[0] = (byte)'*'; - int offset = WriteRaw(span, count, offset: 1); - output.Advance(offset); + /// + /// The zeroed connection stats, which we want to display as zero for default exception cases. + /// + public static ConnectionStatus Zero { get; } = new() + { + BytesAvailableOnSocket = 0, + BytesInReadPipe = 0, + BytesInWritePipe = 0, + ReadStatus = ReadStatus.NA, + WriteStatus = WriteStatus.NA, + }; } - internal static void WriteMultiBulkHeader(IBufferWriter output, long count, ResultType type) + public ConnectionStatus GetStatus() { - // *{count}\r\n = 3 + MaxInt32TextLen - var span = output.GetSpan(3 + Format.MaxInt32TextLen); - span[0] = type switch + // Fall back to bytes waiting on the socket if we can + int socketBytes; + try { - ResultType.Push => (byte)'>', - ResultType.Attribute => (byte)'|', - ResultType.Map => (byte)'%', - ResultType.Set => (byte)'~', - _ => (byte)'*', - }; - if ((type is ResultType.Map or ResultType.Attribute) & count > 0) + socketBytes = VolatileSocket?.Available ?? -1; + } + catch { - if ((count & 1) != 0) Throw(type, count); - count >>= 1; - static void Throw(ResultType type, long count) => throw new ArgumentOutOfRangeException( - paramName: nameof(count), - message: $"{type} data must be in pairs; got {count}"); + // If this fails, we're likely in a race disposal situation and do not want to blow sky high here. + socketBytes = -1; } - int offset = WriteRaw(span, count, offset: 1); - output.Advance(offset); - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal static int WriteCrlf(Span span, int offset) - { - span[offset++] = (byte)'\r'; - span[offset++] = (byte)'\n'; - return offset; - } - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal static void WriteCrlf(IBufferWriter writer) - { - var span = writer.GetSpan(2); - span[0] = (byte)'\r'; - span[1] = (byte)'\n'; - writer.Advance(2); + return new ConnectionStatus() + { + BytesAvailableOnSocket = socketBytes, + BytesInReadPipe = GetReadCommittedLength(), + BytesInWritePipe = -1, + ReadStatus = _readStatus, + WriteStatus = _writeStatus, + BytesLastResult = bytesLastResult, + BytesInBuffer = bytesInBuffer, + }; } - internal static int WriteRaw(Span span, long value, bool withLengthPrefix = false, int offset = 0) + internal static RemoteCertificateValidationCallback? GetAmbientIssuerCertificateCallback() { - if (value >= 0 && value <= 9) + try { - if (withLengthPrefix) - { - span[offset++] = (byte)'1'; - offset = WriteCrlf(span, offset); - } - span[offset++] = (byte)((int)'0' + (int)value); + var issuerPath = Environment.GetEnvironmentVariable("SERedis_IssuerCertPath"); + if (!string.IsNullOrEmpty(issuerPath)) return ConfigurationOptions.TrustIssuerCallback(issuerPath); } - else if (value >= 10 && value < 100) + catch (Exception ex) { - if (withLengthPrefix) - { - span[offset++] = (byte)'2'; - offset = WriteCrlf(span, offset); - } - span[offset++] = (byte)((int)'0' + ((int)value / 10)); - span[offset++] = (byte)((int)'0' + ((int)value % 10)); + Debug.WriteLine(ex.Message); } - else if (value >= 100 && value < 1000) + return null; + } + internal static LocalCertificateSelectionCallback? GetAmbientClientCertificateCallback() + { + try { - int v = (int)value; - int units = v % 10; - v /= 10; - int tens = v % 10, hundreds = v / 10; - if (withLengthPrefix) + var certificatePath = Environment.GetEnvironmentVariable("SERedis_ClientCertPfxPath"); + if (!string.IsNullOrEmpty(certificatePath) && File.Exists(certificatePath)) { - span[offset++] = (byte)'3'; - offset = WriteCrlf(span, offset); - } - span[offset++] = (byte)((int)'0' + hundreds); - span[offset++] = (byte)((int)'0' + tens); - span[offset++] = (byte)((int)'0' + units); - } - else if (value < 0 && value >= -9) - { - if (withLengthPrefix) - { - span[offset++] = (byte)'2'; - offset = WriteCrlf(span, offset); - } - span[offset++] = (byte)'-'; - span[offset++] = (byte)((int)'0' - (int)value); - } - else if (value <= -10 && value > -100) - { - if (withLengthPrefix) - { - span[offset++] = (byte)'3'; - offset = WriteCrlf(span, offset); - } - value = -value; - span[offset++] = (byte)'-'; - span[offset++] = (byte)((int)'0' + ((int)value / 10)); - span[offset++] = (byte)((int)'0' + ((int)value % 10)); - } - else - { - // we're going to write it, but *to the wrong place* - var availableChunk = span.Slice(offset); - var formattedLength = Format.FormatInt64(value, availableChunk); - if (withLengthPrefix) - { - // now we know how large the prefix is: write the prefix, then write the value - var prefixLength = Format.FormatInt32(formattedLength, availableChunk); - offset += prefixLength; - offset = WriteCrlf(span, offset); - - availableChunk = span.Slice(offset); - var finalLength = Format.FormatInt64(value, availableChunk); - offset += finalLength; - Debug.Assert(finalLength == formattedLength); - } - else - { - offset += formattedLength; - } - } - - return WriteCrlf(span, offset); - } - - [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "DEBUG uses instance data")] - private async ValueTask FlushAsync_Awaited(PhysicalConnection connection, ValueTask flush, bool throwOnFailure) - { - try - { - await flush.ForAwait(); - connection._writeStatus = WriteStatus.Flushed; - connection.UpdateLastWriteTime(); - return WriteResult.Success; - } - catch (ConnectionResetException ex) when (!throwOnFailure) - { - connection.RecordConnectionFailed(ConnectionFailureType.SocketClosed, ex); - return WriteResult.WriteFailure; - } - } - - private CancellationTokenSource? _reusableFlushSyncTokenSource; - [Obsolete("this is an anti-pattern; work to reduce reliance on this is in progress")] - [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0062:Make local function 'static'", Justification = "DEBUG uses instance data")] - internal WriteResult FlushSync(bool throwOnFailure, int millisecondsTimeout) - { - var cts = _reusableFlushSyncTokenSource ??= new CancellationTokenSource(); - var flush = FlushAsync(throwOnFailure, cts.Token); - if (!flush.IsCompletedSuccessfully) - { - // only schedule cancellation if it doesn't complete synchronously; at this point, it is doomed - _reusableFlushSyncTokenSource = null; - cts.CancelAfter(TimeSpan.FromMilliseconds(millisecondsTimeout)); - try - { - // here lies the evil - flush.AsTask().Wait(); - } - catch (AggregateException ex) when (ex.InnerExceptions.Any(e => e is TaskCanceledException)) - { - ThrowTimeout(); - } - finally - { - cts.Dispose(); - } - } - return flush.Result; - - void ThrowTimeout() - { - throw new TimeoutException("timeout while synchronously flushing"); - } - } - internal ValueTask FlushAsync(bool throwOnFailure, CancellationToken cancellationToken = default) - { - var tmp = _ioPipe?.Output; - if (tmp == null) return new ValueTask(WriteResult.NoConnectionAvailable); - try - { - _writeStatus = WriteStatus.Flushing; - var flush = tmp.FlushAsync(cancellationToken); - if (!flush.IsCompletedSuccessfully) return FlushAsync_Awaited(this, flush, throwOnFailure); - _writeStatus = WriteStatus.Flushed; - UpdateLastWriteTime(); - return new ValueTask(WriteResult.Success); - } - catch (ConnectionResetException ex) when (!throwOnFailure) - { - RecordConnectionFailed(ConnectionFailureType.SocketClosed, ex); - return new ValueTask(WriteResult.WriteFailure); - } - } - - private static readonly ReadOnlyMemory NullBulkString = Encoding.ASCII.GetBytes("$-1\r\n"), EmptyBulkString = Encoding.ASCII.GetBytes("$0\r\n\r\n"); - - private static void WriteUnifiedBlob(IBufferWriter writer, byte[]? value) - { - if (value == null) - { - // special case: - writer.Write(NullBulkString.Span); - } - else - { - WriteUnifiedSpan(writer, new ReadOnlySpan(value)); - } - } - - private static void WriteUnifiedSpan(IBufferWriter writer, ReadOnlySpan value) - { - // ${len}\r\n = 3 + MaxInt32TextLen - // {value}\r\n = 2 + value.Length - const int MaxQuickSpanSize = 512; - if (value.Length == 0) - { - // special case: - writer.Write(EmptyBulkString.Span); - } - else if (value.Length <= MaxQuickSpanSize) - { - var span = writer.GetSpan(5 + Format.MaxInt32TextLen + value.Length); - span[0] = (byte)'$'; - int bytes = AppendToSpan(span, value, 1); - writer.Advance(bytes); - } - else - { - // too big to guarantee can do in a single span - var span = writer.GetSpan(3 + Format.MaxInt32TextLen); - span[0] = (byte)'$'; - int bytes = WriteRaw(span, value.Length, offset: 1); - writer.Advance(bytes); - - writer.Write(value); - - WriteCrlf(writer); - } - } - - private static int AppendToSpanCommand(Span span, in CommandBytes value, int offset = 0) - { - span[offset++] = (byte)'$'; - int len = value.Length; - offset = WriteRaw(span, len, offset: offset); - value.CopyTo(span.Slice(offset, len)); - offset += value.Length; - return WriteCrlf(span, offset); - } - - private static int AppendToSpan(Span span, ReadOnlySpan value, int offset = 0) - { - offset = WriteRaw(span, value.Length, offset: offset); - value.CopyTo(span.Slice(offset, value.Length)); - offset += value.Length; - return WriteCrlf(span, offset); - } - - internal void WriteSha1AsHex(byte[] value) - { - if (_ioPipe?.Output is not PipeWriter writer) - { - return; // Prevent null refs during disposal - } - - if (value == null) - { - writer.Write(NullBulkString.Span); - } - else if (value.Length == ResultProcessor.ScriptLoadProcessor.Sha1HashLength) - { - // $40\r\n = 5 - // {40 bytes}\r\n = 42 - var span = writer.GetSpan(47); - span[0] = (byte)'$'; - span[1] = (byte)'4'; - span[2] = (byte)'0'; - span[3] = (byte)'\r'; - span[4] = (byte)'\n'; - - int offset = 5; - for (int i = 0; i < value.Length; i++) - { - var b = value[i]; - span[offset++] = ToHexNibble(b >> 4); - span[offset++] = ToHexNibble(b & 15); - } - span[offset++] = (byte)'\r'; - span[offset++] = (byte)'\n'; - - writer.Advance(offset); - } - else - { - throw new InvalidOperationException("Invalid SHA1 length: " + value.Length); - } - } - - internal static byte ToHexNibble(int value) - { - return value < 10 ? (byte)('0' + value) : (byte)('a' - 10 + value); - } - - internal static void WriteUnifiedPrefixedString(IBufferWriter? maybeNullWriter, byte[]? prefix, string? value) - { - if (maybeNullWriter is not { } writer) - { - return; // Prevent null refs during disposal - } - - if (value == null) - { - // special case - writer.Write(NullBulkString.Span); - } - else - { - // ${total-len}\r\n 3 + MaxInt32TextLen - // {prefix}{value}\r\n - int encodedLength = Encoding.UTF8.GetByteCount(value), - prefixLength = prefix?.Length ?? 0, - totalLength = prefixLength + encodedLength; - - if (totalLength == 0) - { - // special-case - writer.Write(EmptyBulkString.Span); - } - else - { - var span = writer.GetSpan(3 + Format.MaxInt32TextLen); - span[0] = (byte)'$'; - int bytes = WriteRaw(span, totalLength, offset: 1); - writer.Advance(bytes); - - if (prefixLength != 0) writer.Write(prefix); - if (encodedLength != 0) WriteRaw(writer, value, encodedLength); - WriteCrlf(writer); - } - } - } - - [ThreadStatic] - private static Encoder? s_PerThreadEncoder; - internal static Encoder GetPerThreadEncoder() - { - var encoder = s_PerThreadEncoder; - if (encoder == null) - { - s_PerThreadEncoder = encoder = Encoding.UTF8.GetEncoder(); - } - else - { - encoder.Reset(); - } - return encoder; - } - - internal static unsafe void WriteRaw(IBufferWriter writer, string value, int expectedLength) - { - const int MaxQuickEncodeSize = 512; - - fixed (char* cPtr = value) - { - int totalBytes; - if (expectedLength <= MaxQuickEncodeSize) - { - // encode directly in one hit - var span = writer.GetSpan(expectedLength); - fixed (byte* bPtr = span) - { - totalBytes = Encoding.UTF8.GetBytes(cPtr, value.Length, bPtr, expectedLength); - } - writer.Advance(expectedLength); - } - else - { - // use an encoder in a loop - var encoder = GetPerThreadEncoder(); - int charsRemaining = value.Length, charOffset = 0; - totalBytes = 0; - - bool final = false; - while (true) - { - var span = writer.GetSpan(5); // get *some* memory - at least enough for 1 character (but hopefully lots more) - - int charsUsed, bytesUsed; - bool completed; - fixed (byte* bPtr = span) - { - encoder.Convert(cPtr + charOffset, charsRemaining, bPtr, span.Length, final, out charsUsed, out bytesUsed, out completed); - } - writer.Advance(bytesUsed); - totalBytes += bytesUsed; - charOffset += charsUsed; - charsRemaining -= charsUsed; - - if (charsRemaining <= 0) - { - if (charsRemaining < 0) throw new InvalidOperationException("String encode went negative"); - if (completed) break; // fine - if (final) throw new InvalidOperationException("String encode failed to complete"); - final = true; // flush the encoder to one more span, then exit - } - } - } - if (totalBytes != expectedLength) throw new InvalidOperationException("String encode length check failure"); - } - } - - private static void WriteUnifiedPrefixedBlob(PipeWriter? maybeNullWriter, byte[]? prefix, byte[]? value) - { - if (maybeNullWriter is not PipeWriter writer) - { - return; // Prevent null refs during disposal - } - - // ${total-len}\r\n - // {prefix}{value}\r\n - if (prefix == null || prefix.Length == 0 || value == null) - { - // if no prefix, just use the non-prefixed version; - // even if prefixed, a null value writes as null, so can use the non-prefixed version - WriteUnifiedBlob(writer, value); - } - else - { - var span = writer.GetSpan(3 + Format.MaxInt32TextLen); // note even with 2 max-len, we're still in same text range - span[0] = (byte)'$'; - int bytes = WriteRaw(span, prefix.LongLength + value.LongLength, offset: 1); - writer.Advance(bytes); - - writer.Write(prefix); - writer.Write(value); - - span = writer.GetSpan(2); - WriteCrlf(span, 0); - writer.Advance(2); - } - } - - private static void WriteUnifiedInt64(IBufferWriter writer, long value) - { - // note from specification: A client sends to the Redis server a RESP Array consisting of just Bulk Strings. - // (i.e. we can't just send ":123\r\n", we need to send "$3\r\n123\r\n" - - // ${asc-len}\r\n = 4/5 (asc-len at most 2 digits) - // {asc}\r\n = MaxInt64TextLen + 2 - var span = writer.GetSpan(7 + Format.MaxInt64TextLen); - - span[0] = (byte)'$'; - var bytes = WriteRaw(span, value, withLengthPrefix: true, offset: 1); - writer.Advance(bytes); - } - - private static void WriteUnifiedUInt64(IBufferWriter writer, ulong value) - { - // note from specification: A client sends to the Redis server a RESP Array consisting of just Bulk Strings. - // (i.e. we can't just send ":123\r\n", we need to send "$3\r\n123\r\n" - Span valueSpan = stackalloc byte[Format.MaxInt64TextLen]; - - var len = Format.FormatUInt64(value, valueSpan); - // ${asc-len}\r\n = 4/5 (asc-len at most 2 digits) - // {asc}\r\n = {len} + 2 - var span = writer.GetSpan(7 + len); - span[0] = (byte)'$'; - int offset = WriteRaw(span, len, withLengthPrefix: false, offset: 1); - valueSpan.Slice(0, len).CopyTo(span.Slice(offset)); - offset += len; - offset = WriteCrlf(span, offset); - writer.Advance(offset); - } - - private static void WriteUnifiedDouble(IBufferWriter writer, double value) - { -#if NET8_0_OR_GREATER - Span valueSpan = stackalloc byte[Format.MaxDoubleTextLen]; - var len = Format.FormatDouble(value, valueSpan); - - // ${asc-len}\r\n = 4/5 (asc-len at most 2 digits) - // {asc}\r\n = {len} + 2 - var span = writer.GetSpan(7 + len); - span[0] = (byte)'$'; - int offset = WriteRaw(span, len, withLengthPrefix: false, offset: 1); - valueSpan.Slice(0, len).CopyTo(span.Slice(offset)); - offset += len; - offset = WriteCrlf(span, offset); - writer.Advance(offset); -#else - // fallback: drop to string - WriteUnifiedPrefixedString(writer, null, Format.ToString(value)); -#endif - } - - internal static void WriteInteger(IBufferWriter writer, long value) - { - // note: client should never write integer; only server does this - // :{asc}\r\n = MaxInt64TextLen + 3 - var span = writer.GetSpan(3 + Format.MaxInt64TextLen); - - span[0] = (byte)':'; - var bytes = WriteRaw(span, value, withLengthPrefix: false, offset: 1); - writer.Advance(bytes); - } - - internal readonly struct ConnectionStatus - { - /// - /// Number of messages sent outbound, but we don't yet have a response for. - /// - public int MessagesSentAwaitingResponse { get; init; } - - /// - /// Bytes available on the socket, not yet read into the pipe. - /// - public long BytesAvailableOnSocket { get; init; } - - /// - /// Bytes read from the socket, pending in the reader pipe. - /// - public long BytesInReadPipe { get; init; } - - /// - /// Bytes in the writer pipe, waiting to be written to the socket. - /// - public long BytesInWritePipe { get; init; } - - /// - /// Byte size of the last result we processed. - /// - public long BytesLastResult { get; init; } - - /// - /// Byte size on the buffer that isn't processed yet. - /// - public long BytesInBuffer { get; init; } - - /// - /// The inbound pipe reader status. - /// - public ReadStatus ReadStatus { get; init; } - - /// - /// The outbound pipe writer status. - /// - public WriteStatus WriteStatus { get; init; } - - public override string ToString() => - $"SentAwaitingResponse: {MessagesSentAwaitingResponse}, AvailableOnSocket: {BytesAvailableOnSocket} byte(s), InReadPipe: {BytesInReadPipe} byte(s), InWritePipe: {BytesInWritePipe} byte(s), ReadStatus: {ReadStatus}, WriteStatus: {WriteStatus}"; - - /// - /// The default connection stats, notable *not* the same as default since initializers don't run. - /// - public static ConnectionStatus Default { get; } = new() - { - BytesAvailableOnSocket = -1, - BytesInReadPipe = -1, - BytesInWritePipe = -1, - ReadStatus = ReadStatus.NA, - WriteStatus = WriteStatus.NA, - }; - - /// - /// The zeroed connection stats, which we want to display as zero for default exception cases. - /// - public static ConnectionStatus Zero { get; } = new() - { - BytesAvailableOnSocket = 0, - BytesInReadPipe = 0, - BytesInWritePipe = 0, - ReadStatus = ReadStatus.NA, - WriteStatus = WriteStatus.NA, - }; - } - - public ConnectionStatus GetStatus() - { - if (_ioPipe is SocketConnection conn) - { - var counters = conn.GetCounters(); - return new ConnectionStatus() - { - MessagesSentAwaitingResponse = GetSentAwaitingResponseCount(), - BytesAvailableOnSocket = counters.BytesAvailableOnSocket, - BytesInReadPipe = counters.BytesWaitingToBeRead, - BytesInWritePipe = counters.BytesWaitingToBeSent, - ReadStatus = _readStatus, - WriteStatus = _writeStatus, - BytesLastResult = bytesLastResult, - BytesInBuffer = bytesInBuffer, - }; - } - - // Fall back to bytes waiting on the socket if we can - int fallbackBytesAvailable; - try - { - fallbackBytesAvailable = VolatileSocket?.Available ?? -1; - } - catch - { - // If this fails, we're likely in a race disposal situation and do not want to blow sky high here. - fallbackBytesAvailable = -1; - } - - return new ConnectionStatus() - { - BytesAvailableOnSocket = fallbackBytesAvailable, - BytesInReadPipe = -1, - BytesInWritePipe = -1, - ReadStatus = _readStatus, - WriteStatus = _writeStatus, - BytesLastResult = bytesLastResult, - BytesInBuffer = bytesInBuffer, - }; - } - - internal static RemoteCertificateValidationCallback? GetAmbientIssuerCertificateCallback() - { - try - { - var issuerPath = Environment.GetEnvironmentVariable("SERedis_IssuerCertPath"); - if (!string.IsNullOrEmpty(issuerPath)) return ConfigurationOptions.TrustIssuerCallback(issuerPath); - } - catch (Exception ex) - { - Debug.WriteLine(ex.Message); - } - return null; - } - internal static LocalCertificateSelectionCallback? GetAmbientClientCertificateCallback() - { - try - { - var certificatePath = Environment.GetEnvironmentVariable("SERedis_ClientCertPfxPath"); - if (!string.IsNullOrEmpty(certificatePath) && File.Exists(certificatePath)) - { - var password = Environment.GetEnvironmentVariable("SERedis_ClientCertPassword"); - var pfxStorageFlags = Environment.GetEnvironmentVariable("SERedis_ClientCertStorageFlags"); - X509KeyStorageFlags storageFlags = X509KeyStorageFlags.DefaultKeySet; - if (!string.IsNullOrEmpty(pfxStorageFlags) && Enum.TryParse(pfxStorageFlags, true, out var typedFlags)) - { - storageFlags = typedFlags; - } - - return ConfigurationOptions.CreatePfxUserCertificateCallback(certificatePath, password, storageFlags); + var password = Environment.GetEnvironmentVariable("SERedis_ClientCertPassword"); + var pfxStorageFlags = Environment.GetEnvironmentVariable("SERedis_ClientCertStorageFlags"); + X509KeyStorageFlags storageFlags = X509KeyStorageFlags.DefaultKeySet; + if (!string.IsNullOrEmpty(pfxStorageFlags) && Enum.TryParse(pfxStorageFlags, true, out var typedFlags)) + { + storageFlags = typedFlags; + } + + return ConfigurationOptions.CreatePfxUserCertificateCallback(certificatePath, password, storageFlags); } #if NET @@ -1607,12 +968,12 @@ public ConnectionStatus GetStatus() return null; } - internal async ValueTask ConnectedAsync(Socket? socket, ILogger? log, SocketManager manager) + internal async ValueTask ConnectedAsync(Socket? socket, ILogger? log) { var bridge = BridgeCouldBeNull; if (bridge == null) return false; - IDuplexPipe? pipe = null; + Stream? stream = null; try { // disallow connection in some cases @@ -1624,12 +985,14 @@ internal async ValueTask ConnectedAsync(Socket? socket, ILogger? log, Sock var config = bridge.Multiplexer.RawConfig; var tunnel = config.Tunnel; - Stream? stream = null; if (tunnel is not null) { stream = await tunnel.BeforeAuthenticateAsync(bridge.ServerEndPoint.EndPoint, bridge.ConnectionType, socket, CancellationToken.None).ForAwait(); } + static Stream DemandSocketStream(Socket? socket) + => new NetworkStream(socket ?? throw new InvalidOperationException("No socket or stream available - possibly a tunnel error")); + if (config.Ssl) { log?.LogInformationConfiguringTLS(); @@ -1639,7 +1002,7 @@ internal async ValueTask ConnectedAsync(Socket? socket, ILogger? log, Sock host = Format.ToStringHostOnly(bridge.ServerEndPoint.EndPoint); } - stream ??= new NetworkStream(socket ?? throw new InvalidOperationException("No socket or stream available - possibly a tunnel error")); + stream ??= DemandSocketStream(socket); var ssl = new SslStream( innerStream: stream, leaveInnerStreamOpen: false, @@ -1682,17 +1045,10 @@ internal async ValueTask ConnectedAsync(Socket? socket, ILogger? log, Sock stream = ssl; } - if (stream is not null) - { - pipe = StreamConnection.GetDuplex(stream, manager.SendPipeOptions, manager.ReceivePipeOptions, name: bridge.Name); - } - else - { - pipe = SocketConnection.Create(socket, manager.SendPipeOptions, manager.ReceivePipeOptions, name: bridge.Name); - } - OnWrapForLogging(ref pipe, _physicalName, manager); + stream ??= DemandSocketStream(socket); + OnWrapForLogging(ref stream, _physicalName); - _ioPipe = pipe; + InitOutput(stream); log?.LogInformationConnected(bridge.Name); @@ -1701,324 +1057,12 @@ internal async ValueTask ConnectedAsync(Socket? socket, ILogger? log, Sock } catch (Exception ex) { - RecordConnectionFailed(ConnectionFailureType.InternalFailure, ex, isInitialConnect: true, connectingPipe: pipe); // includes a bridge.OnDisconnected + RecordConnectionFailed(ConnectionFailureType.InternalFailure, ex, isInitialConnect: true, connectingStream: stream); // includes a bridge.OnDisconnected bridge.Multiplexer.Trace("Could not connect: " + ex.Message, ToString()); return false; } } - internal enum PushKind - { - [AsciiHash("")] - None, - [AsciiHash("message")] - Message, - [AsciiHash("pmessage")] - PMessage, - [AsciiHash("smessage")] - SMessage, - [AsciiHash("subscribe")] - Subscribe, - [AsciiHash("psubscribe")] - PSubscribe, - [AsciiHash("ssubscribe")] - SSubscribe, - [AsciiHash("unsubscribe")] - Unsubscribe, - [AsciiHash("punsubscribe")] - PUnsubscribe, - [AsciiHash("sunsubscribe")] - SUnsubscribe, - } - - internal static partial class PushKindMetadata - { - [AsciiHash] - internal static partial bool TryParse(ReadOnlySpan value, out PushKind result); - } - - private PushKind GetPushKind(in Sequence result, out RedisChannel channel) - { - var len = result.Length; - if (len < 2) - { - // for supported cases, we demand at least the kind and the subscription channel - channel = default; - return PushKind.None; - } - - if (result[0].TryParse(PushKindMetadata.TryParse, out PushKind kind) && kind is not PushKind.None) - { - RedisChannel.RedisChannelOptions channelOptions = RedisChannel.RedisChannelOptions.None; - switch (kind) - { - case PushKind.Message when len >= 3: - break; - case PushKind.PMessage when len >= 4: - channelOptions = RedisChannel.RedisChannelOptions.Pattern; - break; - case PushKind.SMessage when len >= 3: - channelOptions = RedisChannel.RedisChannelOptions.Sharded; - break; - case PushKind.Subscribe: - break; - case PushKind.PSubscribe: - channelOptions = RedisChannel.RedisChannelOptions.Pattern; - break; - case PushKind.SSubscribe: - channelOptions = RedisChannel.RedisChannelOptions.Sharded; - break; - case PushKind.Unsubscribe: - break; - case PushKind.PUnsubscribe: - channelOptions = RedisChannel.RedisChannelOptions.Pattern; - break; - case PushKind.SUnsubscribe: - channelOptions = RedisChannel.RedisChannelOptions.Sharded; - break; - default: - kind = PushKind.None; - break; - } - - if (kind != PushKind.None) - { - // the channel is always the second element - channel = result[1].AsRedisChannel(ChannelPrefix, channelOptions); - return kind; - } - } - channel = default; - return PushKind.None; - } - - private void MatchResult(in RawResult result) - { - // check to see if it could be an out-of-band pubsub message - if ((connectionType == ConnectionType.Subscription && result.Resp2TypeArray == ResultType.Array) || result.Resp3Type == ResultType.Push) - { - var muxer = BridgeCouldBeNull?.Multiplexer; - if (muxer == null) return; - - // out of band message does not match to a queued message - var items = result.GetItems(); - var kind = GetPushKind(items, out var subscriptionChannel); - switch (kind) - { - case PushKind.Message: - case PushKind.SMessage: - _readStatus = kind is PushKind.Message ? ReadStatus.PubSubMessage : ReadStatus.PubSubSMessage; - - // special-case the configuration change broadcasts (we don't keep that in the usual pub/sub registry) - var configChanged = muxer.ConfigurationChangedChannel; - if (configChanged != null && items[1].IsEqual(configChanged)) - { - EndPoint? blame = null; - try - { - if (!items[2].IsEqual(CommonReplies.wildcard)) - { - // We don't want to fail here, just trying to identify - _ = Format.TryParseEndPoint(items[2].GetString(), out blame); - } - } - catch - { - /* no biggie */ - } - - Trace("Configuration changed: " + Format.ToString(blame)); - _readStatus = ReadStatus.Reconfigure; - muxer.ReconfigureIfNeeded(blame, true, "broadcast"); - } - - // invoke the handlers - if (!subscriptionChannel.IsNull) - { - Trace($"{kind}: {subscriptionChannel}"); - if (TryGetPubSubPayload(items[2], out var payload)) - { - _readStatus = ReadStatus.InvokePubSub; - muxer.OnMessage(subscriptionChannel, subscriptionChannel, payload); - } - // could be multi-message: https://github.com/StackExchange/StackExchange.Redis/issues/2507 - else if (TryGetMultiPubSubPayload(items[2], out var payloads)) - { - _readStatus = ReadStatus.InvokePubSub; - muxer.OnMessage(subscriptionChannel, subscriptionChannel, payloads); - } - } - return; // and stop processing - case PushKind.PMessage: - _readStatus = ReadStatus.PubSubPMessage; - - var messageChannel = items[2].AsRedisChannel(ChannelPrefix, RedisChannel.RedisChannelOptions.None); - if (!messageChannel.IsNull) - { - Trace($"{kind}: {messageChannel} via {subscriptionChannel}"); - if (TryGetPubSubPayload(items[3], out var payload)) - { - _readStatus = ReadStatus.InvokePubSub; - muxer.OnMessage(subscriptionChannel, messageChannel, payload); - } - else if (TryGetMultiPubSubPayload(items[3], out var payloads)) - { - _readStatus = ReadStatus.InvokePubSub; - muxer.OnMessage(subscriptionChannel, messageChannel, payloads); - } - } - return; // and stop processing - case PushKind.SUnsubscribe when !PeekChannelMessage(RedisCommand.SUNSUBSCRIBE, subscriptionChannel): - // then it was *unsolicited* - this probably means the slot was migrated - // (otherwise, we'll let the command-processor deal with it) - _readStatus = ReadStatus.PubSubUnsubscribe; - var server = BridgeCouldBeNull?.ServerEndPoint; - if (server is not null && muxer.TryGetSubscription(subscriptionChannel, out var subscription)) - { - // wipe and reconnect; but: to where? - // counter-intuitively, the only server we *know* already knows the new route is: - // the outgoing server, since it had to change to MIGRATING etc; the new INCOMING server - // knows, but *we don't know who that is*, and other nodes: aren't guaranteed to know (yet) - muxer.DefaultSubscriber.ResubscribeToServer(subscription, subscriptionChannel, server, cause: "sunsubscribe"); - } - return; // and STOP PROCESSING; unsolicited - } - } - Trace("Matching result..."); - - Message? msg = null; - // check whether we're waiting for a high-integrity mode post-response checksum (using cheap null-check first) - if (_awaitingToken is not null && (msg = Interlocked.Exchange(ref _awaitingToken, null)) is not null) - { - _readStatus = ReadStatus.ResponseSequenceCheck; - if (!ProcessHighIntegrityResponseToken(msg, in result, BridgeCouldBeNull)) - { - RecordConnectionFailed(ConnectionFailureType.ResponseIntegrityFailure, origin: nameof(ReadStatus.ResponseSequenceCheck)); - } - return; - } - - _readStatus = ReadStatus.DequeueResult; - lock (_writtenAwaitingResponse) - { - if (msg is not null) - { - _awaitingToken = null; - } - - if (!_writtenAwaitingResponse.TryDequeue(out msg)) - { - throw new InvalidOperationException("Received response with no message waiting: " + result.ToString()); - } - } - _activeMessage = msg; - - Trace("Response to: " + msg); - _readStatus = ReadStatus.ComputeResult; - - // need to capture HIT promptly, as -MOVED could cause a resend with a new high-integrity token - // (a lazy approach would be to not rotate, but: we'd rather avoid that; the -MOVED case is rare) - var highIntegrityToken = msg.HighIntegrityToken; - - bool computed = msg.ComputeResult(this, result); - if (computed) - { - _readStatus = msg.ResultBoxIsAsync ? ReadStatus.CompletePendingMessageAsync : ReadStatus.CompletePendingMessageSync; - if (highIntegrityToken == 0) - { - // can't complete yet if needs checksum - msg.Complete(); - } - } - if (highIntegrityToken != 0) - { - // stash this for the next non-OOB response, retaining the old HIT iff we had a -MOVED etc - Volatile.Write(ref _awaitingToken, computed ? msg : new DummyHighIntegrityMessage(msg, highIntegrityToken)); - } - - _readStatus = ReadStatus.MatchResultComplete; - _activeMessage = null; - - static bool ProcessHighIntegrityResponseToken(Message message, in RawResult result, PhysicalBridge? bridge) - { - bool isValid = false; - if (result.Resp2TypeBulkString == ResultType.BulkString) - { - var payload = result.Payload; - if (payload.Length == 4) - { - uint interpreted; - if (payload.IsSingleSegment) - { - interpreted = BinaryPrimitives.ReadUInt32LittleEndian(payload.First.Span); - } - else - { - Span span = stackalloc byte[4]; - payload.CopyTo(span); - interpreted = BinaryPrimitives.ReadUInt32LittleEndian(span); - } - isValid = interpreted == message.HighIntegrityToken; - } - } - if (isValid) - { - message.Complete(); - return true; - } - else - { - message.SetExceptionAndComplete(new InvalidOperationException("High-integrity mode detected possible protocol de-sync"), bridge); - return false; - } - } - - static bool TryGetPubSubPayload(in RawResult value, out RedisValue parsed, bool allowArraySingleton = true) - { - if (value.IsNull) - { - parsed = RedisValue.Null; - return true; - } - switch (value.Resp2TypeBulkString) - { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - parsed = value.AsRedisValue(); - return true; - case ResultType.Array when allowArraySingleton && value.ItemsCount == 1: - return TryGetPubSubPayload(in value[0], out parsed, allowArraySingleton: false); - } - parsed = default; - return false; - } - - static bool TryGetMultiPubSubPayload(in RawResult value, out Sequence parsed) - { - if (value.Resp2TypeArray == ResultType.Array && value.ItemsCount != 0) - { - parsed = value.GetItems(); - return true; - } - parsed = default; - return false; - } - } - - private bool PeekChannelMessage(RedisCommand command, in RedisChannel channel) - { - Message? msg; - bool haveMsg; - lock (_writtenAwaitingResponse) - { - haveMsg = _writtenAwaitingResponse.TryPeek(out msg); - } - - return haveMsg && msg is CommandChannelBase typed - && typed.Command == command && typed.Channel == channel; - } - private volatile Message? _activeMessage; internal void GetHeadMessages(out Message? now, out Message? next) @@ -2057,234 +1101,9 @@ private void OnDebugAbort() } } - partial void OnWrapForLogging(ref IDuplexPipe pipe, string name, SocketManager mgr); + partial void OnWrapForLogging(ref Stream stream, string name); internal void UpdateLastReadTime() => Interlocked.Exchange(ref lastReadTickCount, Environment.TickCount); - private async Task ReadFromPipe() - { - bool allowSyncRead = true, isReading = false; - try - { - _readStatus = ReadStatus.Init; - while (true) - { - var input = _ioPipe?.Input; - if (input == null) break; - - // note: TryRead will give us back the same buffer in a tight loop - // - so: only use that if we're making progress - isReading = true; - _readStatus = ReadStatus.ReadSync; - if (!(allowSyncRead && input.TryRead(out var readResult))) - { - _readStatus = ReadStatus.ReadAsync; - readResult = await input.ReadAsync().ForAwait(); - } - isReading = false; - _readStatus = ReadStatus.UpdateWriteTime; - UpdateLastReadTime(); - - _readStatus = ReadStatus.ProcessBuffer; - var buffer = readResult.Buffer; - int handled = 0; - if (!buffer.IsEmpty) - { - handled = ProcessBuffer(ref buffer); // updates buffer.Start - } - - allowSyncRead = handled != 0; - - _readStatus = ReadStatus.MarkProcessed; - Trace($"Processed {handled} messages"); - input.AdvanceTo(buffer.Start, buffer.End); - - if ((handled == 0 && readResult.IsCompleted) || BridgeCouldBeNull?.NeedsReconnect == true) - { - break; // no more data, trailing incomplete messages, or reconnection required - } - } - Trace("EOF"); - RecordConnectionFailed(ConnectionFailureType.SocketClosed); - _readStatus = ReadStatus.RanToCompletion; - } - catch (Exception ex) - { - _readStatus = ReadStatus.Faulted; - // this CEX is just a hardcore "seriously, read the actual value" - there's no - // convenient "Thread.VolatileRead(ref T field) where T : class", and I don't - // want to make the field volatile just for this one place that needs it - if (isReading) - { - var pipe = Volatile.Read(ref _ioPipe); - if (pipe == null) - { - return; - // yeah, that's fine... don't worry about it; we nuked it - } - - // check for confusing read errors - no need to present "Reading is not allowed after reader was completed." - if (pipe is SocketConnection sc && sc.ShutdownKind == PipeShutdownKind.ReadEndOfStream) - { - RecordConnectionFailed(ConnectionFailureType.SocketClosed, new EndOfStreamException()); - return; - } - } - Trace("Faulted"); - RecordConnectionFailed(ConnectionFailureType.InternalFailure, ex); - } - } - - private static readonly ArenaOptions s_arenaOptions = new ArenaOptions(); - private readonly Arena _arena = new Arena(s_arenaOptions); - - private int ProcessBuffer(ref ReadOnlySequence buffer) - { - int messageCount = 0; - bytesInBuffer = buffer.Length; - - while (!buffer.IsEmpty) - { - _readStatus = ReadStatus.TryParseResult; - var reader = new BufferReader(buffer); - var result = TryParseResult(_protocol >= RedisProtocol.Resp3, _arena, in buffer, ref reader, IncludeDetailInExceptions, this); - try - { - if (result.HasValue) - { - buffer = reader.SliceFromCurrent(); - - messageCount++; - Trace(result.ToString()); - _readStatus = ReadStatus.MatchResult; - MatchResult(result); - - // Track the last result size *after* processing for the *next* error message - bytesInBuffer = buffer.Length; - bytesLastResult = result.Payload.Length; - } - else - { - break; // remaining buffer isn't enough; give up - } - } - finally - { - _readStatus = ReadStatus.ResetArena; - _arena.Reset(); - } - } - _readStatus = ReadStatus.ProcessBufferComplete; - return messageCount; - } - - private static RawResult.ResultFlags AsNull(RawResult.ResultFlags flags) => flags & ~RawResult.ResultFlags.NonNull; - - private static RawResult ReadArray(ResultType resultType, RawResult.ResultFlags flags, Arena arena, in ReadOnlySequence buffer, ref BufferReader reader, bool includeDetailInExceptions, ServerEndPoint? server) - { - var itemCount = ReadLineTerminatedString(ResultType.Integer, flags, ref reader); - if (itemCount.HasValue) - { - if (!itemCount.TryGetInt64(out long i64)) - { - throw ExceptionFactory.ConnectionFailure( - includeDetailInExceptions, - ConnectionFailureType.ProtocolFailure, - itemCount.Is('?') ? "Streamed aggregate types not yet implemented" : "Invalid array length", - server); - } - - int itemCountActual = checked((int)i64); - - if (itemCountActual < 0) - { - // for null response by command like EXEC, RESP array: *-1\r\n - return new RawResult(resultType, items: default, AsNull(flags)); - } - else if (itemCountActual == 0) - { - // for zero array response by command like SCAN, Resp array: *0\r\n - return new RawResult(resultType, items: default, flags); - } - - if (resultType == ResultType.Map) itemCountActual <<= 1; // if it says "3", it means 3 pairs, i.e. 6 values - - var oversized = arena.Allocate(itemCountActual); - var result = new RawResult(resultType, oversized, flags); - - if (oversized.IsSingleSegment) - { - var span = oversized.FirstSpan; - for (int i = 0; i < span.Length; i++) - { - if (!(span[i] = TryParseResult(flags, arena, in buffer, ref reader, includeDetailInExceptions, server)).HasValue) - { - return RawResult.Nil; - } - } - } - else - { - foreach (var span in oversized.Spans) - { - for (int i = 0; i < span.Length; i++) - { - if (!(span[i] = TryParseResult(flags, arena, in buffer, ref reader, includeDetailInExceptions, server)).HasValue) - { - return RawResult.Nil; - } - } - } - } - return result; - } - return RawResult.Nil; - } - - private static RawResult ReadBulkString(ResultType type, RawResult.ResultFlags flags, ref BufferReader reader, bool includeDetailInExceptions, ServerEndPoint? server) - { - var prefix = ReadLineTerminatedString(ResultType.Integer, flags, ref reader); - if (prefix.HasValue) - { - if (!prefix.TryGetInt64(out long i64)) - { - throw ExceptionFactory.ConnectionFailure( - includeDetailInExceptions, - ConnectionFailureType.ProtocolFailure, - prefix.Is('?') ? "Streamed strings not yet implemented" : "Invalid bulk string length", - server); - } - int bodySize = checked((int)i64); - if (bodySize < 0) - { - return new RawResult(type, ReadOnlySequence.Empty, AsNull(flags)); - } - - if (reader.TryConsumeAsBuffer(bodySize, out var payload)) - { - switch (reader.TryConsumeCRLF()) - { - case ConsumeResult.NeedMoreData: - break; // see NilResult below - case ConsumeResult.Success: - return new RawResult(type, payload, flags); - default: - throw ExceptionFactory.ConnectionFailure(includeDetailInExceptions, ConnectionFailureType.ProtocolFailure, "Invalid bulk string terminator", server); - } - } - } - return RawResult.Nil; - } - - private static RawResult ReadLineTerminatedString(ResultType type, RawResult.ResultFlags flags, ref BufferReader reader) - { - int crlfOffsetFromCurrent = BufferReader.FindNextCrLf(reader); - if (crlfOffsetFromCurrent < 0) return RawResult.Nil; - - var payload = reader.ConsumeAsBuffer(crlfOffsetFromCurrent); - reader.Consume(2); - - return new RawResult(type, payload, flags); - } internal enum ReadStatus { @@ -2315,122 +1134,6 @@ internal enum ReadStatus PubSubUnsubscribe, NA = -1, } - private volatile ReadStatus _readStatus; - internal ReadStatus GetReadStatus() => _readStatus; - - internal void StartReading() => ReadFromPipe().RedisFireAndForget(); - - internal static RawResult TryParseResult( - bool isResp3, - Arena arena, - in ReadOnlySequence buffer, - ref BufferReader reader, - bool includeDetilInExceptions, - PhysicalConnection? connection, - bool allowInlineProtocol = false) - { - return TryParseResult( - isResp3 ? (RawResult.ResultFlags.Resp3 | RawResult.ResultFlags.NonNull) : RawResult.ResultFlags.NonNull, - arena, - buffer, - ref reader, - includeDetilInExceptions, - connection?.BridgeCouldBeNull?.ServerEndPoint, - allowInlineProtocol); - } - - private static RawResult TryParseResult( - RawResult.ResultFlags flags, - Arena arena, - in ReadOnlySequence buffer, - ref BufferReader reader, - bool includeDetilInExceptions, - ServerEndPoint? server, - bool allowInlineProtocol = false) - { - int prefix; - do // this loop is just to allow us to parse (skip) attributes without doing a stack-dive - { - prefix = reader.PeekByte(); - if (prefix < 0) return RawResult.Nil; // EOF - switch (prefix) - { - // RESP2 - case '+': // simple string - reader.Consume(1); - return ReadLineTerminatedString(ResultType.SimpleString, flags, ref reader); - case '-': // error - reader.Consume(1); - return ReadLineTerminatedString(ResultType.Error, flags, ref reader); - case ':': // integer - reader.Consume(1); - return ReadLineTerminatedString(ResultType.Integer, flags, ref reader); - case '$': // bulk string - reader.Consume(1); - return ReadBulkString(ResultType.BulkString, flags, ref reader, includeDetilInExceptions, server); - case '*': // array - reader.Consume(1); - return ReadArray(ResultType.Array, flags, arena, in buffer, ref reader, includeDetilInExceptions, server); - // RESP3 - case '_': // null - reader.Consume(1); - return ReadLineTerminatedString(ResultType.Null, flags, ref reader); - case ',': // double - reader.Consume(1); - return ReadLineTerminatedString(ResultType.Double, flags, ref reader); - case '#': // boolean - reader.Consume(1); - return ReadLineTerminatedString(ResultType.Boolean, flags, ref reader); - case '!': // blob error - reader.Consume(1); - return ReadBulkString(ResultType.BlobError, flags, ref reader, includeDetilInExceptions, server); - case '=': // verbatim string - reader.Consume(1); - return ReadBulkString(ResultType.VerbatimString, flags, ref reader, includeDetilInExceptions, server); - case '(': // big number - reader.Consume(1); - return ReadLineTerminatedString(ResultType.BigInteger, flags, ref reader); - case '%': // map - reader.Consume(1); - return ReadArray(ResultType.Map, flags, arena, in buffer, ref reader, includeDetilInExceptions, server); - case '~': // set - reader.Consume(1); - return ReadArray(ResultType.Set, flags, arena, in buffer, ref reader, includeDetilInExceptions, server); - case '|': // attribute - reader.Consume(1); - var arr = ReadArray(ResultType.Attribute, flags, arena, in buffer, ref reader, includeDetilInExceptions, server); - if (!arr.HasValue) return RawResult.Nil; // failed to parse attribute data - - // for now, we want to just skip attribute data; so - // drop whatever we parsed on the floor and keep looking - break; // exits the SWITCH, not the DO/WHILE - case '>': // push - reader.Consume(1); - return ReadArray(ResultType.Push, flags, arena, in buffer, ref reader, includeDetilInExceptions, server); - } - } - while (prefix == '|'); - - if (allowInlineProtocol) return ParseInlineProtocol(flags, arena, ReadLineTerminatedString(ResultType.SimpleString, flags, ref reader)); - throw new InvalidOperationException("Unexpected response prefix: " + (char)prefix); - } - - private static RawResult ParseInlineProtocol(RawResult.ResultFlags flags, Arena arena, in RawResult line) - { - if (!line.HasValue) return RawResult.Nil; // incomplete line - - int count = 0; - foreach (var _ in line.GetInlineTokenizer()) count++; - var block = arena.Allocate(count); - - var iter = block.GetEnumerator(); - foreach (var token in line.GetInlineTokenizer()) - { - // this assigns *via a reference*, returned via the iterator; just... sweet - iter.GetNext() = new RawResult(line.Resp3Type, token, flags); // spoof RESP2 from RESP1 - } - return new RawResult(ResultType.Array, block, flags); // spoof RESP2 from RESP1 - } internal bool HasPendingCallerFacingItems() { @@ -2472,7 +1175,7 @@ public DummyHighIntegrityMessage(Message msg, uint highIntegrityToken) : base(ms } public override int ArgCount => 0; - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) => throw new NotSupportedException("This message cannot be written; it is a place-holder for high-integrity scenarios."); } } diff --git a/src/StackExchange.Redis/PublicAPI/PublicAPI.Unshipped.txt b/src/StackExchange.Redis/PublicAPI/PublicAPI.Unshipped.txt index ab058de62..56c23463e 100644 --- a/src/StackExchange.Redis/PublicAPI/PublicAPI.Unshipped.txt +++ b/src/StackExchange.Redis/PublicAPI/PublicAPI.Unshipped.txt @@ -1 +1,19 @@ #nullable enable +[SER005]StackExchange.Redis.TestHarness +[SER005]StackExchange.Redis.TestHarness.BufferValidator +[SER005]StackExchange.Redis.TestHarness.ChannelPrefix.get -> StackExchange.Redis.RedisChannel +[SER005]StackExchange.Redis.TestHarness.CommandMap.get -> StackExchange.Redis.CommandMap! +[SER005]StackExchange.Redis.TestHarness.KeyPrefix.get -> StackExchange.Redis.RedisKey +[SER005]StackExchange.Redis.TestHarness.Read(System.ReadOnlySpan value) -> StackExchange.Redis.RedisResult! +[SER005]StackExchange.Redis.TestHarness.TestHarness(StackExchange.Redis.CommandMap? commandMap = null, StackExchange.Redis.RedisChannel channelPrefix = default(StackExchange.Redis.RedisChannel), StackExchange.Redis.RedisKey keyPrefix = default(StackExchange.Redis.RedisKey)) -> void +[SER005]StackExchange.Redis.TestHarness.ValidateResp(System.ReadOnlySpan expected, string! command, params System.Collections.Generic.ICollection! args) -> void +[SER005]StackExchange.Redis.TestHarness.ValidateResp(string! expected, string! command, params System.Collections.Generic.ICollection! args) -> void +[SER005]StackExchange.Redis.TestHarness.ValidateRouting(in StackExchange.Redis.RedisKey expected, params System.Collections.Generic.ICollection! args) -> void +[SER005]StackExchange.Redis.TestHarness.Write(System.Buffers.IBufferWriter! target, string! command, params System.Collections.Generic.ICollection! args) -> void +[SER005]StackExchange.Redis.TestHarness.Write(string! command, params System.Collections.Generic.ICollection! args) -> byte[]! +[SER005]static StackExchange.Redis.TestHarness.AssertEqual(System.ReadOnlySpan expected, System.ReadOnlySpan actual, System.Action, System.ReadOnlyMemory>! handler) -> void +[SER005]static StackExchange.Redis.TestHarness.AssertEqual(string! expected, System.ReadOnlySpan actual, System.Action! handler) -> void +[SER005]virtual StackExchange.Redis.TestHarness.BufferValidator.Invoke(scoped System.ReadOnlySpan buffer) -> void +[SER005]virtual StackExchange.Redis.TestHarness.OnValidateFail(System.ReadOnlyMemory expected, System.ReadOnlyMemory actual) -> void +[SER005]virtual StackExchange.Redis.TestHarness.OnValidateFail(in StackExchange.Redis.RedisKey expected, in StackExchange.Redis.RedisKey actual) -> void +[SER005]virtual StackExchange.Redis.TestHarness.OnValidateFail(string! expected, string! actual) -> void diff --git a/src/StackExchange.Redis/PublicAPI/net6.0/PublicAPI.Shipped.txt b/src/StackExchange.Redis/PublicAPI/net6.0/PublicAPI.Shipped.txt index fae4f65ce..bec516e5c 100644 --- a/src/StackExchange.Redis/PublicAPI/net6.0/PublicAPI.Shipped.txt +++ b/src/StackExchange.Redis/PublicAPI/net6.0/PublicAPI.Shipped.txt @@ -1,4 +1,5 @@ -StackExchange.Redis.ConfigurationOptions.SslClientAuthenticationOptions.get -> System.Func? +#nullable enable +StackExchange.Redis.ConfigurationOptions.SslClientAuthenticationOptions.get -> System.Func? StackExchange.Redis.ConfigurationOptions.SslClientAuthenticationOptions.set -> void System.Runtime.CompilerServices.IsExternalInit (forwarded, contained in System.Runtime) -StackExchange.Redis.ConfigurationOptions.SetUserPemCertificate(string! userCertificatePath, string? userKeyPath = null) -> void \ No newline at end of file +StackExchange.Redis.ConfigurationOptions.SetUserPemCertificate(string! userCertificatePath, string? userKeyPath = null) -> void diff --git a/src/StackExchange.Redis/RawResult.cs b/src/StackExchange.Redis/RawResult.cs deleted file mode 100644 index 300535ad4..000000000 --- a/src/StackExchange.Redis/RawResult.cs +++ /dev/null @@ -1,551 +0,0 @@ -using System; -using System.Buffers; -using System.Runtime.CompilerServices; -using System.Text; -using Pipelines.Sockets.Unofficial.Arenas; - -namespace StackExchange.Redis -{ - internal readonly struct RawResult - { - internal ref RawResult this[int index] => ref GetItems()[index]; - - internal int ItemsCount => (int)_items.Length; - - public delegate bool ScalarParser(scoped ReadOnlySpan span, out T value); - - internal bool TryParse(ScalarParser parser, out T value) - => _payload.IsSingleSegment ? parser(_payload.First.Span, out value) : TryParseSlow(parser, out value); - - private bool TryParseSlow(ScalarParser parser, out T value) - { - // linearize a multi-segment payload into a single span for parsing - const int MAX_STACK = 64; - var len = checked((int)_payload.Length); - byte[]? lease = null; - try - { - Span span = - (len <= MAX_STACK ? stackalloc byte[MAX_STACK] : (lease = ArrayPool.Shared.Rent(len))) - .Slice(0, len); - _payload.CopyTo(span); - return parser(span, out value); - } - finally - { - if (lease is not null) ArrayPool.Shared.Return(lease); - } - } - - private readonly ReadOnlySequence _payload; - internal ReadOnlySequence Payload => _payload; - - internal static readonly RawResult Nil = default; - // Note: can't use Memory here - struct recursion breaks runtime - private readonly Sequence _items; - private readonly ResultType _resultType; - private readonly ResultFlags _flags; - - [Flags] - internal enum ResultFlags - { - None = 0, - HasValue = 1 << 0, // simply indicates "not the default" (always set in .ctor) - NonNull = 1 << 1, // defines explicit null; isn't "IsNull" because we want default to be null - Resp3 = 1 << 2, // was the connection in RESP3 mode? - } - - public RawResult(ResultType resultType, in ReadOnlySequence payload, ResultFlags flags) - { - switch (resultType) - { - case ResultType.SimpleString: - case ResultType.Error: - case ResultType.Integer: - case ResultType.BulkString: - case ResultType.Double: - case ResultType.Boolean: - case ResultType.BlobError: - case ResultType.VerbatimString: - case ResultType.BigInteger: - break; - case ResultType.Null: - flags &= ~ResultFlags.NonNull; - break; - default: - ThrowInvalidType(resultType); - break; - } - _resultType = resultType; - _flags = flags | ResultFlags.HasValue; - _payload = payload; - _items = default; - } - - public RawResult(ResultType resultType, Sequence items, ResultFlags flags) - { - switch (resultType) - { - case ResultType.Array: - case ResultType.Map: - case ResultType.Set: - case ResultType.Attribute: - case ResultType.Push: - break; - case ResultType.Null: - flags &= ~ResultFlags.NonNull; - break; - default: - ThrowInvalidType(resultType); - break; - } - _resultType = resultType; - _flags = flags | ResultFlags.HasValue; - _payload = default; - _items = items.Untyped(); - } - - private static void ThrowInvalidType(ResultType resultType) - => throw new ArgumentOutOfRangeException(nameof(resultType), $"Invalid result-type: {resultType}"); - - public bool IsError => _resultType.IsError(); - - public ResultType Resp3Type => _resultType; - - // if null, assume string - public ResultType Resp2TypeBulkString => _resultType == ResultType.Null ? ResultType.BulkString : _resultType.ToResp2(); - // if null, assume array - public ResultType Resp2TypeArray => _resultType == ResultType.Null ? ResultType.Array : _resultType.ToResp2(); - - internal bool IsNull => (_flags & ResultFlags.NonNull) == 0; - - public bool HasValue => (_flags & ResultFlags.HasValue) != 0; - - public bool IsResp3 => (_flags & ResultFlags.Resp3) != 0; - - public override string ToString() - { - if (IsNull) return "(null)"; - - return _resultType.ToResp2() switch - { - ResultType.SimpleString or ResultType.Integer or ResultType.Error => $"{Resp3Type}: {GetString()}", - ResultType.BulkString => $"{Resp3Type}: {Payload.Length} bytes", - ResultType.Array => $"{Resp3Type}: {ItemsCount} items", - _ => $"(unknown: {Resp3Type})", - }; - } - - public Tokenizer GetInlineTokenizer() => new Tokenizer(Payload); - - internal ref struct Tokenizer - { - // tokenizes things according to the inline protocol - // specifically; the line: abc "def ghi" jkl - // is 3 tokens: "abc", "def ghi" and "jkl" - public Tokenizer GetEnumerator() => this; - private BufferReader _value; - - public Tokenizer(scoped in ReadOnlySequence value) - { - _value = new BufferReader(value); - Current = default; - } - - public bool MoveNext() - { - Current = default; - // take any white-space - while (_value.PeekByte() == (byte)' ') { _value.Consume(1); } - - byte terminator = (byte)' '; - var first = _value.PeekByte(); - if (first < 0) return false; // EOF - - switch (first) - { - case (byte)'"': - case (byte)'\'': - // start of string - terminator = (byte)first; - _value.Consume(1); - break; - } - - int end = BufferReader.FindNext(_value, terminator); - if (end < 0) - { - Current = _value.ConsumeToEnd(); - } - else - { - Current = _value.ConsumeAsBuffer(end); - _value.Consume(1); // drop the terminator itself; - } - return true; - } - public ReadOnlySequence Current { get; private set; } - } - - internal RedisChannel AsRedisChannel(byte[]? channelPrefix, RedisChannel.RedisChannelOptions options) - { - switch (Resp2TypeBulkString) - { - case ResultType.SimpleString: - case ResultType.BulkString: - if (channelPrefix is null) - { - // no channel-prefix enabled, just use as-is - return new RedisChannel(GetBlob(), options); - } - if (StartsWith(channelPrefix)) - { - // we have a channel-prefix, and it matches; strip it - byte[] copy = Payload.Slice(channelPrefix.Length).ToArray(); - - return new RedisChannel(copy, options); - } - - // we shouldn't get unexpected events, so to get here: we've received a notification - // on a channel that doesn't match our prefix; this *should* be limited to - // key notifications (see: IgnoreChannelPrefix), but: we need to be sure - if (StartsWith("__"u8) && (StartsWith("__keyspace@"u8) || StartsWith("__keyevent@"u8) || - StartsWith("__subkeyspace@"u8) || StartsWith("__subkeyevent@"u8) || - StartsWith("__subkeyspaceitem@"u8) || StartsWith("__subkeyspaceevent@"u8))) - { - // use as-is - return new RedisChannel(GetBlob(), options); - } - return default; - default: - throw new InvalidCastException("Cannot convert to RedisChannel: " + Resp3Type); - } - } - - internal RedisKey AsRedisKey() - { - return Resp2TypeBulkString switch - { - ResultType.SimpleString or ResultType.BulkString => (RedisKey)GetBlob(), - _ => throw new InvalidCastException("Cannot convert to RedisKey: " + Resp3Type), - }; - } - - internal RedisValue AsRedisValue() - { - if (IsNull) return RedisValue.Null; - if (Resp3Type == ResultType.Boolean && Payload.Length == 1) - { - switch (Payload.First.Span[0]) - { - case (byte)'t': return (RedisValue)true; - case (byte)'f': return (RedisValue)false; - } - } - switch (Resp2TypeBulkString) - { - case ResultType.Integer: - long i64; - if (TryGetInt64(out i64)) return (RedisValue)i64; - break; - case ResultType.SimpleString: - case ResultType.BulkString: - return (RedisValue)GetBlob(); - } - throw new InvalidCastException("Cannot convert to RedisValue: " + Resp3Type); - } - - internal Lease? AsLease() - { - if (IsNull) return null; - switch (Resp2TypeBulkString) - { - case ResultType.SimpleString: - case ResultType.BulkString: - var payload = Payload; - var lease = Lease.Create(checked((int)payload.Length), false); - payload.CopyTo(lease.Span); - return lease; - } - throw new InvalidCastException("Cannot convert to Lease: " + Resp3Type); - } - - internal bool IsEqual(in CommandBytes expected) - { - if (expected.Length != Payload.Length) return false; - return new CommandBytes(Payload).Equals(expected); - } - - internal bool IsEqual(byte[]? expected) - { - if (expected == null) throw new ArgumentNullException(nameof(expected)); - return IsEqual(new ReadOnlySpan(expected)); - } - - internal bool IsEqual(ReadOnlySpan expected) - { - var rangeToCheck = Payload; - - if (expected.Length != rangeToCheck.Length) return false; - if (rangeToCheck.IsSingleSegment) return rangeToCheck.First.Span.SequenceEqual(expected); - - int offset = 0; - foreach (var segment in rangeToCheck) - { - var from = segment.Span; - var to = expected.Slice(offset, from.Length); - if (!from.SequenceEqual(to)) return false; - - offset += from.Length; - } - return true; - } - - internal bool StartsWith(in CommandBytes expected) - { - var len = expected.Length; - if (len > Payload.Length) return false; - - var rangeToCheck = Payload.Slice(0, len); - return new CommandBytes(rangeToCheck).Equals(expected); - } - internal bool StartsWith(ReadOnlySpan expected) - { - if (expected.Length > Payload.Length) return false; - - var rangeToCheck = Payload.Slice(0, expected.Length); - if (rangeToCheck.IsSingleSegment) return rangeToCheck.First.Span.SequenceEqual(expected); - - int offset = 0; - foreach (var segment in rangeToCheck) - { - var from = segment.Span; - var to = expected.Slice(offset, from.Length); - if (!from.SequenceEqual(to)) return false; - - offset += from.Length; - } - return true; - } - - internal byte[]? GetBlob() - { - if (IsNull) return null; - - if (Payload.IsEmpty) return Array.Empty(); - - return Payload.ToArray(); - } - - internal bool GetBoolean() - { - if (Payload.Length != 1) throw new InvalidCastException(); - if (Resp3Type == ResultType.Boolean) - { - return Payload.First.Span[0] switch - { - (byte)'t' => true, - (byte)'f' => false, - _ => throw new InvalidCastException(), - }; - } - return Payload.First.Span[0] switch - { - (byte)'1' => true, - (byte)'0' => false, - _ => throw new InvalidCastException(), - }; - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal Sequence GetItems() => _items.Cast(); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal double?[]? GetItemsAsDoubles() => this.ToArray((in RawResult x) => x.TryGetDouble(out double val) ? val : null); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal RedisKey[]? GetItemsAsKeys() => this.ToArray((in RawResult x) => x.AsRedisKey()); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal RedisValue[]? GetItemsAsValues() => this.ToArray((in RawResult x) => x.AsRedisValue()); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal string?[]? GetItemsAsStrings() => this.ToArray((in RawResult x) => (string?)x.AsRedisValue()); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal string[]? GetItemsAsStringsNotNullable() => this.ToArray((in RawResult x) => (string)x.AsRedisValue()!); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal bool[]? GetItemsAsBooleans() => this.ToArray((in RawResult x) => (bool)x.AsRedisValue()); - - internal GeoPosition? GetItemsAsGeoPosition() - { - var items = GetItems(); - if (IsNull || items.Length == 0) - { - return null; - } - - ref RawResult root = ref items[0]; - if (root.IsNull) - { - return null; - } - return AsGeoPosition(root.GetItems()); - } - - internal SortedSetEntry[]? GetItemsAsSortedSetEntryArray() => this.ToArray((in RawResult item) => AsSortedSetEntry(item.GetItems())); - - private static SortedSetEntry AsSortedSetEntry(in Sequence elements) - { - if (elements.IsSingleSegment) - { - var span = elements.FirstSpan; - return new SortedSetEntry(span[0].AsRedisValue(), span[1].TryGetDouble(out double val) ? val : double.NaN); - } - else - { - return new SortedSetEntry(elements[0].AsRedisValue(), elements[1].TryGetDouble(out double val) ? val : double.NaN); - } - } - - private static GeoPosition AsGeoPosition(in Sequence coords) - { - double longitude, latitude; - if (coords.IsSingleSegment) - { - var span = coords.FirstSpan; - longitude = (double)span[0].AsRedisValue(); - latitude = (double)span[1].AsRedisValue(); - } - else - { - longitude = (double)coords[0].AsRedisValue(); - latitude = (double)coords[1].AsRedisValue(); - } - - return new GeoPosition(longitude, latitude); - } - - internal GeoPosition?[]? GetItemsAsGeoPositionArray() - => this.ToArray((in RawResult item) => item.IsNull ? default : AsGeoPosition(item.GetItems())); - - internal unsafe string? GetString() => GetString(out _); - internal unsafe string? GetString(out ReadOnlySpan verbatimPrefix) - { - verbatimPrefix = default; - if (IsNull) return null; - if (Payload.IsEmpty) return ""; - - string s; - if (Payload.IsSingleSegment) - { - s = Format.GetString(Payload.First.Span); - return Resp3Type == ResultType.VerbatimString ? GetVerbatimString(s, out verbatimPrefix) : s; - } -#if NET - // use system-provided sequence decoder - return Encoding.UTF8.GetString(in _payload); -#else - var decoder = Encoding.UTF8.GetDecoder(); - int charCount = 0; - foreach (var segment in Payload) - { - var span = segment.Span; - if (span.IsEmpty) continue; - - fixed (byte* bPtr = span) - { - charCount += decoder.GetCharCount(bPtr, span.Length, false); - } - } - - decoder.Reset(); - - s = new string((char)0, charCount); - fixed (char* sPtr = s) - { - char* cPtr = sPtr; - foreach (var segment in Payload) - { - var span = segment.Span; - if (span.IsEmpty) continue; - - fixed (byte* bPtr = span) - { - var written = decoder.GetChars(bPtr, span.Length, cPtr, charCount, false); - if (written < 0 || written > charCount) Throw(); // protect against hypothetical cPtr weirdness - cPtr += written; - charCount -= written; - } - } - } - - return Resp3Type == ResultType.VerbatimString ? GetVerbatimString(s, out verbatimPrefix) : s; - - static void Throw() => throw new InvalidOperationException("Invalid result from GetChars"); -#endif - static string? GetVerbatimString(string? value, out ReadOnlySpan type) - { - // The first three bytes provide information about the format of the following string, which - // can be txt for plain text, or mkd for markdown. The fourth byte is always `:`. - // Then the real string follows. - if (value is not null - && value.Length >= 4 && value[3] == ':') - { - type = value.AsSpan().Slice(0, 3); - value = value.Substring(4); - } - else - { - type = default; - } - return value; - } - } - - internal bool TryGetDouble(out double val) - { - if (IsNull || Payload.IsEmpty) - { - val = 0; - return false; - } - if (TryGetInt64(out long i64)) - { - val = i64; - return true; - } - - if (Payload.IsSingleSegment) return Format.TryParseDouble(Payload.First.Span, out val); - if (Payload.Length < 64) - { - Span span = stackalloc byte[(int)Payload.Length]; - Payload.CopyTo(span); - return Format.TryParseDouble(span, out val); - } - return Format.TryParseDouble(GetString(), out val); - } - - internal bool TryGetInt64(out long value) - { - if (IsNull || Payload.IsEmpty || Payload.Length > Format.MaxInt64TextLen) - { - value = 0; - return false; - } - - if (Payload.IsSingleSegment) return Format.TryParseInt64(Payload.First.Span, out value); - - Span span = stackalloc byte[(int)Payload.Length]; // we already checked the length was <= MaxInt64TextLen - Payload.CopyTo(span); - return Format.TryParseInt64(span, out value); - } - - internal bool Is(char value) - { - var span = Payload.First.Span; - return span.Length == 1 && (char)span[0] == value && Payload.IsSingleSegment; - } - } -} diff --git a/src/StackExchange.Redis/RedisBatch.cs b/src/StackExchange.Redis/RedisBatch.cs index 0ef97f365..beda224af 100644 --- a/src/StackExchange.Redis/RedisBatch.cs +++ b/src/StackExchange.Redis/RedisBatch.cs @@ -50,7 +50,11 @@ public void Execute() } lastBridge = bridge; lastList = list; - + var count = list.Count; + if (count != 0) + { + list[count - 1].SetNoFlush(); + } list.Add(message); } diff --git a/src/StackExchange.Redis/RedisDatabase.VectorSets.cs b/src/StackExchange.Redis/RedisDatabase.VectorSets.cs index f10693dc5..bcaa0e6c0 100644 --- a/src/StackExchange.Redis/RedisDatabase.VectorSets.cs +++ b/src/StackExchange.Redis/RedisDatabase.VectorSets.cs @@ -280,7 +280,7 @@ async IAsyncEnumerable WithCancellationSupport([EnumeratorCancellati while (true) { cancellationToken.ThrowIfCancellationRequested(); - using var batch = await VectorSetRangeAsync(key, start, end, count, exclude, flags); + using var batch = await VectorSetRangeAsync(key, start, end, count, exclude, flags).ForAwait(); exclude |= Exclude.Start; // on subsequent iterations, exclude the start (we've already yielded it) if (batch is null || batch.IsEmpty) yield break; diff --git a/src/StackExchange.Redis/RedisDatabase.cs b/src/StackExchange.Redis/RedisDatabase.cs index e068bd7b4..f06bcc699 100644 --- a/src/StackExchange.Redis/RedisDatabase.cs +++ b/src/StackExchange.Redis/RedisDatabase.cs @@ -5,7 +5,7 @@ using System.Net; using System.Runtime.CompilerServices; using System.Threading.Tasks; -using Pipelines.Sockets.Unofficial.Arenas; +using RESPite.Messages; namespace StackExchange.Redis { @@ -1326,18 +1326,18 @@ public KeyMigrateCommandMessage(int db, RedisKey key, EndPoint toServer, int toD this.migrateOptions = migrateOptions; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { bool isCopy = (migrateOptions & MigrateOptions.Copy) != 0; bool isReplace = (migrateOptions & MigrateOptions.Replace) != 0; - physical.WriteHeader(Command, 5 + (isCopy ? 1 : 0) + (isReplace ? 1 : 0)); - physical.WriteBulkString(toHost); - physical.WriteBulkString(toPort); - physical.Write(Key); - physical.WriteBulkString(toDatabase); - physical.WriteBulkString(timeoutMilliseconds); - if (isCopy) physical.WriteBulkString("COPY"u8); - if (isReplace) physical.WriteBulkString("REPLACE"u8); + writer.WriteHeader(Command, 5 + (isCopy ? 1 : 0) + (isReplace ? 1 : 0)); + writer.WriteBulkString(toHost); + writer.WriteBulkString(toPort); + writer.Write(Key); + writer.WriteBulkString(toDatabase); + writer.WriteBulkString(timeoutMilliseconds); + if (isCopy) writer.WriteRaw("$4\r\nCOPY\r\n"u8); + if (isReplace) writer.WriteRaw("$7\r\nREPLACE\r\n"u8); } public override int ArgCount @@ -4278,38 +4278,38 @@ public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) return slot; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, argCount); - physical.WriteBulkString("GROUP"u8); - physical.WriteBulkString(groupName); - physical.WriteBulkString(consumerName); + writer.WriteHeader(Command, argCount); + writer.WriteRaw("$5\r\nGROUP\r\n"u8); + writer.WriteBulkString(groupName); + writer.WriteBulkString(consumerName); if (countPerStream.HasValue) { - physical.WriteBulkString("COUNT"u8); - physical.WriteBulkString(countPerStream.Value); + writer.WriteRaw("$5\r\nCOUNT\r\n"u8); + writer.WriteBulkString(countPerStream.Value); } if (noAck) { - physical.WriteBulkString("NOACK"u8); + writer.WriteRaw("$5\r\nNOACK\r\n"u8); } if (claimMinIdleTime.HasValue) { - physical.WriteBulkString("CLAIM"u8); - physical.WriteBulkString(claimMinIdleTime.Value.TotalMilliseconds); + writer.WriteRaw("$5\r\nCLAIM\r\n"u8); + writer.WriteBulkString(claimMinIdleTime.Value.TotalMilliseconds); } - physical.WriteBulkString("STREAMS"u8); + writer.WriteRaw("$7\r\nSTREAMS\r\n"u8); for (int i = 0; i < streamPositions.Length; i++) { - physical.Write(streamPositions[i].Key); + writer.Write(streamPositions[i].Key); } for (int i = 0; i < streamPositions.Length; i++) { - physical.WriteBulkString(StreamPosition.Resolve(streamPositions[i].Position, RedisCommand.XREADGROUP)); + writer.WriteBulkString(StreamPosition.Resolve(streamPositions[i].Position, RedisCommand.XREADGROUP)); } } @@ -4358,24 +4358,24 @@ public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) return slot; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, argCount); + writer.WriteHeader(Command, argCount); if (countPerStream.HasValue) { - physical.WriteBulkString("COUNT"u8); - physical.WriteBulkString(countPerStream.Value); + writer.WriteRaw("$5\r\nCOUNT\r\n"u8); + writer.WriteBulkString(countPerStream.Value); } - physical.WriteBulkString("STREAMS"u8); + writer.WriteRaw("$7\r\nSTREAMS\r\n"u8); for (int i = 0; i < streamPositions.Length; i++) { - physical.Write(streamPositions[i].Key); + writer.Write(streamPositions[i].Key); } for (int i = 0; i < streamPositions.Length; i++) { - physical.WriteBulkString(StreamPosition.Resolve(streamPositions[i].Position, RedisCommand.XREADGROUP)); + writer.WriteBulkString(StreamPosition.Resolve(streamPositions[i].Position, RedisCommand.XREADGROUP)); } } @@ -4981,33 +4981,33 @@ public SingleStreamReadGroupCommandMessage(int db, CommandFlags flags, RedisKey argCount = 6 + (count.HasValue ? 2 : 0) + (noAck ? 1 : 0) + (claimMinIdleTime.HasValue ? 2 : 0); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, argCount); - physical.WriteBulkString("GROUP"u8); - physical.WriteBulkString(groupName); - physical.WriteBulkString(consumerName); + writer.WriteHeader(Command, argCount); + writer.WriteRaw("$5\r\nGROUP\r\n"u8); + writer.WriteBulkString(groupName); + writer.WriteBulkString(consumerName); if (count.HasValue) { - physical.WriteBulkString("COUNT"u8); - physical.WriteBulkString(count.Value); + writer.WriteRaw("$5\r\nCOUNT\r\n"u8); + writer.WriteBulkString(count.Value); } if (noAck) { - physical.WriteBulkString("NOACK"u8); + writer.WriteRaw("$5\r\nNOACK\r\n"u8); } if (claimMinIdleTime.HasValue) { - physical.WriteBulkString("CLAIM"u8); - physical.WriteBulkString(claimMinIdleTime.Value.TotalMilliseconds); + writer.WriteRaw("$5\r\nCLAIM\r\n"u8); + writer.WriteBulkString(claimMinIdleTime.Value.TotalMilliseconds); } - physical.WriteBulkString("STREAMS"u8); - physical.Write(Key); - physical.WriteBulkString(afterId); + writer.WriteRaw("$7\r\nSTREAMS\r\n"u8); + writer.Write(Key); + writer.WriteBulkString(afterId); } public override int ArgCount => argCount; @@ -5037,19 +5037,19 @@ public SingleStreamReadCommandMessage(int db, CommandFlags flags, RedisKey key, argCount = count.HasValue ? 5 : 3; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, argCount); + writer.WriteHeader(Command, argCount); if (count.HasValue) { - physical.WriteBulkString("COUNT"u8); - physical.WriteBulkString(count.Value); + writer.WriteRaw("$5\r\nCOUNT\r\n"u8); + writer.WriteBulkString(count.Value); } - physical.WriteBulkString("STREAMS"u8); - physical.Write(Key); - physical.WriteBulkString(afterId); + writer.WriteRaw("$7\r\nSTREAMS\r\n"u8); + writer.Write(Key); + writer.WriteBulkString(afterId); } public override int ArgCount => argCount; @@ -5476,45 +5476,44 @@ public ScriptLoadMessage(CommandFlags flags, string script) Script = script ?? throw new ArgumentNullException(nameof(script)); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 2); - physical.WriteBulkString("LOAD"u8); - physical.WriteBulkString((RedisValue)Script); + writer.WriteHeader(Command, 2); + writer.WriteRaw("$4\r\nLOAD\r\n"u8); + writer.WriteBulkString((RedisValue)Script); } public override int ArgCount => 2; } - private sealed class HashScanResultProcessor : ScanResultProcessor + internal sealed class HashScanResultProcessor : ScanResultProcessor { public static readonly ResultProcessor.ScanResult> Default = new HashScanResultProcessor(); - private HashScanResultProcessor() { } - protected override HashEntry[]? Parse(in RawResult result, out int count) - => HashEntryArray.TryParse(result, out HashEntry[]? pairs, true, out count) ? pairs : null; + internal HashScanResultProcessor() { } + protected override HashEntry[]? Parse(ref RespReader reader, RedisProtocol protocol, out int count) + => HashEntryArray.ParseArray(ref reader, protocol, true, out count, null); } - private abstract class ScanResultProcessor : ResultProcessor.ScanResult> + internal abstract class ScanResultProcessor : ResultProcessor.ScanResult> { - protected abstract T[]? Parse(in RawResult result, out int count); + protected abstract T[]? Parse(ref RespReader reader, RedisProtocol protocol, out int count); - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + // AggregateLengthIs also handles null (equivalent to zero, in terms of length) + if (reader.IsAggregate && reader.AggregateLengthIs(2)) { - case ResultType.Array: - var arr = result.GetItems(); - if (arr.Length == 2) + var iter = reader.AggregateChildren(); + if (iter.MoveNext() && iter.Value.TryReadInt64(out var i64) && iter.MoveNext()) + { + var innerReader = iter.Value; + if (innerReader.IsAggregate) { - ref RawResult inner = ref arr[1]; - if (inner.Resp2TypeArray == ResultType.Array && arr[0].TryGetInt64(out var i64)) - { - T[]? oversized = Parse(inner, out int count); - var sscanResult = new ScanEnumerable.ScanResult(i64, oversized, count, true); - SetResult(message, sscanResult); - return true; - } + T[]? oversized = Parse(ref innerReader, connection.Protocol.GetValueOrDefault(), out int count); + var sscanResult = new ScanEnumerable.ScanResult(i64, oversized, count, true); + SetResult(message, sscanResult); + return true; } - break; + } } return false; } @@ -5523,43 +5522,77 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes internal sealed class ExecuteMessage : Message { private readonly ICollection _args; - public new CommandBytes Command { get; } + private string _unknownCommand; - public ExecuteMessage(CommandMap? map, int db, CommandFlags flags, string command, ICollection? args) : base(db, flags, RedisCommand.UNKNOWN) + private static int RemoveDbIfNotRequired(int suggestedDb, string adhocCommand, out RedisCommand knownCommand) { - if (args != null && args.Count >= PhysicalConnection.REDIS_MAX_ARGS) // using >= here because we will be adding 1 for the command itself (which is an arg for the purposes of the multi-bulk protocol) + // attempt to parse the ad-hoc command to a known command, so we can apply correct aliasing, etc + if (!RedisCommandMetadata.TryParseCI(adhocCommand, out knownCommand)) + { + knownCommand = RedisCommand.UNKNOWN; + } + if ((knownCommand is not RedisCommand.UNKNOWN & suggestedDb >= 0) && !Message.RequiresDatabase(knownCommand)) + { + // strip the DB; historically we didn't enforce this when IDatabase was + // used to issue known commands as strings, so: don't complain now + // (this is only an issue *because* we now recognise the known commands) + suggestedDb = -1; + } + return suggestedDb; + } + + public ExecuteMessage(CommandMap? map, int db, CommandFlags flags, string command, ICollection? args) + : base(RemoveDbIfNotRequired(db, command, out var knownCommand), flags, knownCommand) + { + if (args != null && args.Count >= MessageWriter.REDIS_MAX_ARGS) // using >= here because we will be adding 1 for the command itself (which is an arg for the purposes of the multi-bulk protocol) { throw ExceptionFactory.TooManyArgs(command, args.Count); } - Command = map?.GetBytes(command) ?? default; - if (Command.IsEmpty) throw ExceptionFactory.CommandDisabled(command); + + map ??= CommandMap.Default; + _unknownCommand = ""; + if (Command is RedisCommand.UNKNOWN) + { + _unknownCommand = command; + } + else if (!map.IsAvailable(Command)) + { + throw ExceptionFactory.CommandDisabled(command); + } _args = args ?? Array.Empty(); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(RedisCommand.UNKNOWN, _args.Count, Command); + if (Command is RedisCommand.UNKNOWN) + { + writer.WriteHeader(_unknownCommand, _args.Count); + } + else + { + writer.WriteHeader(Command, _args.Count); + } foreach (object arg in _args) { if (arg is RedisKey key) { - physical.Write(key); + writer.Write(key); } else if (arg is RedisChannel channel) { - physical.Write(channel); + writer.Write(channel); } else { // recognises well-known types var val = RedisValue.TryParse(arg, out var valid); if (!valid) throw new InvalidCastException($"Unable to parse value: '{arg}'"); - physical.WriteBulkString(val); + writer.WriteBulkString(val); } } } - public override string CommandString => Command.ToString(); - public override string CommandAndKey => Command.ToString(); + public override string CommandString => Command is RedisCommand.UNKNOWN ? _unknownCommand : base.CommandString; + public override string CommandAndKey => CommandString; public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) { @@ -5632,47 +5665,55 @@ public IEnumerable GetMessages(PhysicalConnection connection) yield return this; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { if (hexHash != null) { - physical.WriteHeader(RedisCommand.EVALSHA, 2 + keys.Length + values.Length); - physical.WriteSha1AsHex(hexHash); + writer.WriteHeader(RedisCommand.EVALSHA, 2 + keys.Length + values.Length); + writer.WriteSha1AsHex(hexHash); } else if (asciiHash != null) { - physical.WriteHeader(RedisCommand.EVALSHA, 2 + keys.Length + values.Length); - physical.WriteBulkString((RedisValue)asciiHash); + writer.WriteHeader(RedisCommand.EVALSHA, 2 + keys.Length + values.Length); + writer.WriteBulkString((RedisValue)asciiHash); } else { - physical.WriteHeader(RedisCommand.EVAL, 2 + keys.Length + values.Length); - physical.WriteBulkString((RedisValue)script); + writer.WriteHeader(RedisCommand.EVAL, 2 + keys.Length + values.Length); + writer.WriteBulkString((RedisValue)script); } - physical.WriteBulkString(keys.Length); + writer.WriteBulkString(keys.Length); for (int i = 0; i < keys.Length; i++) - physical.Write(keys[i]); + writer.Write(keys[i]); for (int i = 0; i < values.Length; i++) - physical.WriteBulkString(values[i]); + writer.WriteBulkString(values[i]); } public override int ArgCount => 2 + keys.Length + values.Length; } - private sealed class SetScanResultProcessor : ScanResultProcessor + internal sealed class SetScanResultProcessor : ScanResultProcessor { public static readonly ResultProcessor.ScanResult> Default = new SetScanResultProcessor(); - private SetScanResultProcessor() { } - protected override RedisValue[] Parse(in RawResult result, out int count) + internal SetScanResultProcessor() { } + protected override RedisValue[] Parse(ref RespReader reader, RedisProtocol protocol, out int count) { - var items = result.GetItems(); - if (items.IsEmpty) + if (reader.IsNull) { count = 0; return Array.Empty(); } - count = (int)items.Length; + count = reader.AggregateLength(); + if (count == 0) + { + return Array.Empty(); + } RedisValue[] arr = ArrayPool.Shared.Rent(count); - items.CopyTo(arr, (in RawResult r) => r.AsRedisValue()); + var iter = reader.AggregateChildren(); + for (int i = 0; i < count; i++) + { + iter.DemandNext(); + arr[i] = iter.Value.ReadRedisValue(); + } return arr; } } @@ -5759,25 +5800,25 @@ public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) return serverSelectionStrategy.CombineSlot(slot, keys); } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, 2 + keys.Length + values.Length); - physical.Write(Key); - physical.WriteBulkString(keys.Length); + writer.WriteHeader(Command, 2 + keys.Length + values.Length); + writer.Write(Key); + writer.WriteBulkString(keys.Length); for (int i = 0; i < keys.Length; i++) - physical.Write(keys[i]); + writer.Write(keys[i]); for (int i = 0; i < values.Length; i++) - physical.WriteBulkString(values[i]); + writer.WriteBulkString(values[i]); } public override int ArgCount => 2 + keys.Length + values.Length; } - private sealed class SortedSetScanResultProcessor : ScanResultProcessor + internal sealed class SortedSetScanResultProcessor : ScanResultProcessor { public static readonly ResultProcessor.ScanResult> Default = new SortedSetScanResultProcessor(); - private SortedSetScanResultProcessor() { } - protected override SortedSetEntry[]? Parse(in RawResult result, out int count) - => SortedSetWithScores.TryParse(result, out SortedSetEntry[]? pairs, true, out count) ? pairs : null; + internal SortedSetScanResultProcessor() { } + protected override SortedSetEntry[]? Parse(ref RespReader reader, RedisProtocol protocol, out int count) + => SortedSetWithScores.ParseArray(ref reader, protocol, true, out count, null); } private sealed class StringGetWithExpiryMessage : Message.CommandKeyBase, IMultiMessage @@ -5816,10 +5857,10 @@ public bool UnwrapValue(out TimeSpan? value, out Exception? ex) return false; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(command, 1); - physical.Write(Key); + writer.WriteHeader(command, 1); + writer.Write(Key); } public override int ArgCount => 1; } @@ -5828,27 +5869,23 @@ private sealed class StringGetWithExpiryProcessor : ResultProcessor Default = new StringGetWithExpiryProcessor(); private StringGetWithExpiryProcessor() { } - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - RedisValue value = result.AsRedisValue(); - if (message is StringGetWithExpiryMessage sgwem && sgwem.UnwrapValue(out var expiry, out var ex)) + RedisValue value = reader.ReadRedisValue(); + if (message is StringGetWithExpiryMessage sgwem && sgwem.UnwrapValue(out var expiry, out var ex)) + { + if (ex == null) { - if (ex == null) - { - SetResult(message, new RedisValueWithExpiry(value, expiry)); - } - else - { - SetException(message, ex); - } - return true; + SetResult(message, new RedisValueWithExpiry(value, expiry)); } - break; + else + { + SetException(message, ex); + } + return true; + } } return false; } diff --git a/src/StackExchange.Redis/RedisKey.cs b/src/StackExchange.Redis/RedisKey.cs index 2d192c244..7550e7087 100644 --- a/src/StackExchange.Redis/RedisKey.cs +++ b/src/StackExchange.Redis/RedisKey.cs @@ -2,6 +2,7 @@ using System.Buffers; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; +using System.Runtime.InteropServices; using System.Text; namespace StackExchange.Redis @@ -424,7 +425,7 @@ internal int CopyTo(Span destination) #else unsafe { - fixed (byte* bPtr = destination) + fixed (byte* bPtr = &MemoryMarshal.GetReference(destination)) { fixed (char* cPtr = s) { diff --git a/src/StackExchange.Redis/RedisLiterals.cs b/src/StackExchange.Redis/RedisLiterals.cs index 68240af00..52790f187 100644 --- a/src/StackExchange.Redis/RedisLiterals.cs +++ b/src/StackExchange.Redis/RedisLiterals.cs @@ -4,220 +4,180 @@ namespace StackExchange.Redis { #pragma warning disable SA1310 // Field names should not contain underscore #pragma warning disable SA1311 // Static readonly fields should begin with upper-case letter - internal static partial class CommonReplies - { - public static readonly CommandBytes - ASK = "ASK ", - authFail_trimmed = CommandBytes.TrimToFit("ERR operation not permitted"), - backgroundSavingStarted_trimmed = CommandBytes.TrimToFit("Background saving started"), - backgroundSavingAOFStarted_trimmed = - CommandBytes.TrimToFit("Background append only file rewriting started"), - databases = "databases", - loading = "LOADING ", - MOVED = "MOVED ", - NOAUTH = "NOAUTH ", - NOSCRIPT = "NOSCRIPT ", - no = "no", - OK = "OK", - one = "1", - PONG = "PONG", - QUEUED = "QUEUED", - READONLY = "READONLY ", - replica_read_only = "replica-read-only", - slave_read_only = "slave-read-only", - timeout = "timeout", - wildcard = "*", - WRONGPASS = "WRONGPASS", - yes = "yes", - zero = "0", - - // HELLO - version = "version", - proto = "proto", - role = "role", - mode = "mode", - id = "id"; - } - internal static class RedisLiterals { // unlike primary commands, these do not get altered by the command-map; we may as // well compute the bytes once and share them public static readonly RedisValue - ACLCAT = "ACLCAT", - ADDR = "ADDR", - AFTER = "AFTER", - AGGREGATE = "AGGREGATE", - ALPHA = "ALPHA", - AND = "AND", - ANDOR = "ANDOR", - ANY = "ANY", - ASC = "ASC", - BEFORE = "BEFORE", - BIT = "BIT", - BYFLOAT = "BYFLOAT", - BYINT = "BYINT", - BY = "BY", - BYLEX = "BYLEX", - BYSCORE = "BYSCORE", - BYTE = "BYTE", - CH = "CH", - CHANNELS = "CHANNELS", - COUNT = "COUNT", - DB = "DB", - @default = "default", - DESC = "DESC", - DIFF = "DIFF", - DIFF1 = "DIFF1", - DOCTOR = "DOCTOR", - ENX = "ENX", - ENCODING = "ENCODING", - EX = "EX", - EXAT = "EXAT", - EXISTS = "EXISTS", - FIELDS = "FIELDS", - FILTERBY = "FILTERBY", - FLUSH = "FLUSH", - FNX = "FNX", - FREQ = "FREQ", - FULL = "FULL", - FXX = "FXX", - GET = "GET", - GETKEYS = "GETKEYS", - GETNAME = "GETNAME", - GT = "GT", - HISTORY = "HISTORY", - ID = "ID", - IDX = "IDX", - IDLETIME = "IDLETIME", - IDMP = "IDMP", - IDMPAUTO = "IDMPAUTO", - IDMP_DURATION = "IDMP-DURATION", - IDMP_MAXSIZE = "IDMP-MAXSIZE", - KEEPTTL = "KEEPTTL", - KILL = "KILL", - LADDR = "LADDR", - LATEST = "LATEST", - LEFT = "LEFT", - LEN = "LEN", - lib_name = "lib-name", - lib_ver = "lib-ver", - LIMIT = "LIMIT", - LIST = "LIST", - LT = "LT", - LBOUND = "LBOUND", - MATCH = "MATCH", - MALLOC_STATS = "MALLOC-STATS", - MAX = "MAX", - MAXAGE = "MAXAGE", - MAXLEN = "MAXLEN", - MIN = "MIN", - MINMATCHLEN = "MINMATCHLEN", - MODULE = "MODULE", - NODES = "NODES", - NOSAVE = "NOSAVE", - NOT = "NOT", - NOVALUES = "NOVALUES", - NUMPAT = "NUMPAT", - NUMSUB = "NUMSUB", - NX = "NX", - OBJECT = "OBJECT", - ONE = "ONE", - OR = "OR", - PATTERN = "PATTERN", - PAUSE = "PAUSE", - PERSIST = "PERSIST", - PING = "PING", - PURGE = "PURGE", - PX = "PX", - PXAT = "PXAT", - RANK = "RANK", - REFCOUNT = "REFCOUNT", - REPLACE = "REPLACE", - RESET = "RESET", - RESETSTAT = "RESETSTAT", - REV = "REV", - REWRITE = "REWRITE", - RIGHT = "RIGHT", - SAVE = "SAVE", - SEGFAULT = "SEGFAULT", - SET = "SET", - SETINFO = "SETINFO", - SETNAME = "SETNAME", - SKIPME = "SKIPME", - STATS = "STATS", - STOP = "STOP", - STORE = "STORE", - SUM = "SUM", - TYPE = "TYPE", - UBOUND = "UBOUND", - USERNAME = "USERNAME", - USED = "USED", - WEIGHTS = "WEIGHTS", - WITHMATCHLEN = "WITHMATCHLEN", - WITHSCORES = "WITHSCORES", - WITHVALUES = "WITHVALUES", - XOR = "XOR", - XX = "XX", + ACLCAT = RedisValue.FromRaw("ACLCAT"u8), + ADDR = RedisValue.FromRaw("ADDR"u8), + AFTER = RedisValue.FromRaw("AFTER"u8), + AGGREGATE = RedisValue.FromRaw("AGGREGATE"u8), + ALPHA = RedisValue.FromRaw("ALPHA"u8), + AND = RedisValue.FromRaw("AND"u8), + ANDOR = RedisValue.FromRaw("ANDOR"u8), + ANY = RedisValue.FromRaw("ANY"u8), + ASC = RedisValue.FromRaw("ASC"u8), + BEFORE = RedisValue.FromRaw("BEFORE"u8), + BIT = RedisValue.FromRaw("BIT"u8), + BY = RedisValue.FromRaw("BY"u8), + BYLEX = RedisValue.FromRaw("BYLEX"u8), + BYSCORE = RedisValue.FromRaw("BYSCORE"u8), + BYTE = RedisValue.FromRaw("BYTE"u8), + CH = RedisValue.FromRaw("CH"u8), + CHANNELS = RedisValue.FromRaw("CHANNELS"u8), + COUNT = RedisValue.FromRaw("COUNT"u8), + DB = RedisValue.FromRaw("DB"u8), + @default = RedisValue.FromRaw("default"u8), + DESC = RedisValue.FromRaw("DESC"u8), + DIFF = RedisValue.FromRaw("DIFF"u8), + DIFF1 = RedisValue.FromRaw("DIFF1"u8), + DOCTOR = RedisValue.FromRaw("DOCTOR"u8), + ENCODING = RedisValue.FromRaw("ENCODING"u8), + EX = RedisValue.FromRaw("EX"u8), + EXAT = RedisValue.FromRaw("EXAT"u8), + EXISTS = RedisValue.FromRaw("EXISTS"u8), + FIELDS = RedisValue.FromRaw("FIELDS"u8), + FILTERBY = RedisValue.FromRaw("FILTERBY"u8), + FLUSH = RedisValue.FromRaw("FLUSH"u8), + FNX = RedisValue.FromRaw("FNX"u8), + FREQ = RedisValue.FromRaw("FREQ"u8), + FULL = RedisValue.FromRaw("FULL"u8), + FXX = RedisValue.FromRaw("FXX"u8), + GET = RedisValue.FromRaw("GET"u8), + GETKEYS = RedisValue.FromRaw("GETKEYS"u8), + GETNAME = RedisValue.FromRaw("GETNAME"u8), + GT = RedisValue.FromRaw("GT"u8), + HISTORY = RedisValue.FromRaw("HISTORY"u8), + ID = RedisValue.FromRaw("ID"u8), + IDX = RedisValue.FromRaw("IDX"u8), + IDLETIME = RedisValue.FromRaw("IDLETIME"u8), + IDMP = RedisValue.FromRaw("IDMP"u8), + IDMPAUTO = RedisValue.FromRaw("IDMPAUTO"u8), + IDMP_DURATION = RedisValue.FromRaw("IDMP-DURATION"u8), + IDMP_MAXSIZE = RedisValue.FromRaw("IDMP-MAXSIZE"u8), + KEEPTTL = RedisValue.FromRaw("KEEPTTL"u8), + KILL = RedisValue.FromRaw("KILL"u8), + LADDR = RedisValue.FromRaw("LADDR"u8), + LATEST = RedisValue.FromRaw("LATEST"u8), + LEFT = RedisValue.FromRaw("LEFT"u8), + LEN = RedisValue.FromRaw("LEN"u8), + lib_name = RedisValue.FromRaw("lib-name"u8), + lib_ver = RedisValue.FromRaw("lib-ver"u8), + LIMIT = RedisValue.FromRaw("LIMIT"u8), + LIST = RedisValue.FromRaw("LIST"u8), + LT = RedisValue.FromRaw("LT"u8), + MATCH = RedisValue.FromRaw("MATCH"u8), + MALLOC_STATS = RedisValue.FromRaw("MALLOC-STATS"u8), + MAX = RedisValue.FromRaw("MAX"u8), + MAXAGE = RedisValue.FromRaw("MAXAGE"u8), + MAXLEN = RedisValue.FromRaw("MAXLEN"u8), + MIN = RedisValue.FromRaw("MIN"u8), + MINMATCHLEN = RedisValue.FromRaw("MINMATCHLEN"u8), + MODULE = RedisValue.FromRaw("MODULE"u8), + NODES = RedisValue.FromRaw("NODES"u8), + NOSAVE = RedisValue.FromRaw("NOSAVE"u8), + NOT = RedisValue.FromRaw("NOT"u8), + NOVALUES = RedisValue.FromRaw("NOVALUES"u8), + NUMPAT = RedisValue.FromRaw("NUMPAT"u8), + NUMSUB = RedisValue.FromRaw("NUMSUB"u8), + NX = RedisValue.FromRaw("NX"u8), + OBJECT = RedisValue.FromRaw("OBJECT"u8), + ONE = RedisValue.FromRaw("ONE"u8), + OR = RedisValue.FromRaw("OR"u8), + PATTERN = RedisValue.FromRaw("PATTERN"u8), + PAUSE = RedisValue.FromRaw("PAUSE"u8), + PERSIST = RedisValue.FromRaw("PERSIST"u8), + PING = RedisValue.FromRaw("PING"u8), + PURGE = RedisValue.FromRaw("PURGE"u8), + PX = RedisValue.FromRaw("PX"u8), + PXAT = RedisValue.FromRaw("PXAT"u8), + RANK = RedisValue.FromRaw("RANK"u8), + REFCOUNT = RedisValue.FromRaw("REFCOUNT"u8), + REPLACE = RedisValue.FromRaw("REPLACE"u8), + RESET = RedisValue.FromRaw("RESET"u8), + RESETSTAT = RedisValue.FromRaw("RESETSTAT"u8), + REV = RedisValue.FromRaw("REV"u8), + REWRITE = RedisValue.FromRaw("REWRITE"u8), + RIGHT = RedisValue.FromRaw("RIGHT"u8), + SAVE = RedisValue.FromRaw("SAVE"u8), + SEGFAULT = RedisValue.FromRaw("SEGFAULT"u8), + SET = RedisValue.FromRaw("SET"u8), + SETINFO = RedisValue.FromRaw("SETINFO"u8), + SETNAME = RedisValue.FromRaw("SETNAME"u8), + SKIPME = RedisValue.FromRaw("SKIPME"u8), + STATS = RedisValue.FromRaw("STATS"u8), + STOP = RedisValue.FromRaw("STOP"u8), + STORE = RedisValue.FromRaw("STORE"u8), + SUM = RedisValue.FromRaw("SUM"u8), + TYPE = RedisValue.FromRaw("TYPE"u8), + USED = RedisValue.FromRaw("USED"u8), + USERNAME = RedisValue.FromRaw("USERNAME"u8), + WEIGHTS = RedisValue.FromRaw("WEIGHTS"u8), + WITHMATCHLEN = RedisValue.FromRaw("WITHMATCHLEN"u8), + WITHSCORES = RedisValue.FromRaw("WITHSCORES"u8), + WITHVALUES = RedisValue.FromRaw("WITHVALUES"u8), + XOR = RedisValue.FromRaw("XOR"u8), + XX = RedisValue.FromRaw("XX"u8), // Sentinel Literals - MASTERS = "MASTERS", - MASTER = "MASTER", - REPLICAS = "REPLICAS", - SLAVES = "SLAVES", - GETMASTERADDRBYNAME = "GET-MASTER-ADDR-BY-NAME", - // RESET = "RESET", - FAILOVER = "FAILOVER", - SENTINELS = "SENTINELS", + MASTERS = RedisValue.FromRaw("MASTERS"u8), + MASTER = RedisValue.FromRaw("MASTER"u8), + REPLICAS = RedisValue.FromRaw("REPLICAS"u8), + SLAVES = RedisValue.FromRaw("SLAVES"u8), + GETMASTERADDRBYNAME = RedisValue.FromRaw("GET-MASTER-ADDR-BY-NAME"u8), + // RESET = RedisValue.FromRaw("RESET"u8), + FAILOVER = RedisValue.FromRaw("FAILOVER"u8), + SENTINELS = RedisValue.FromRaw("SENTINELS"u8), // Sentinel Literals as of 2.8.4 - MONITOR = "MONITOR", - REMOVE = "REMOVE", - // SET = "SET", + MONITOR = RedisValue.FromRaw("MONITOR"u8), + REMOVE = RedisValue.FromRaw("REMOVE"u8), + // SET = RedisValue.FromRaw("SET"u8), // replication states - connect = "connect", - connected = "connected", - connecting = "connecting", - handshake = "handshake", - none = "none", - sync = "sync", + connect = RedisValue.FromRaw("connect"u8), + connected = RedisValue.FromRaw("connected"u8), + connecting = RedisValue.FromRaw("connecting"u8), + handshake = RedisValue.FromRaw("handshake"u8), + none = RedisValue.FromRaw("none"u8), + sync = RedisValue.FromRaw("sync"u8), - MinusSymbol = "-", - PlusSymbol = "+", - Wildcard = "*", + MinusSymbol = RedisValue.FromRaw("-"u8), + PlusSymbol = RedisValue.FromRaw("+"u8), + Wildcard = RedisValue.FromRaw("*"u8), // Geo Radius/Search Literals - BYBOX = "BYBOX", - BYRADIUS = "BYRADIUS", - FROMMEMBER = "FROMMEMBER", - FROMLONLAT = "FROMLONLAT", - STOREDIST = "STOREDIST", - WITHCOORD = "WITHCOORD", - WITHDIST = "WITHDIST", - WITHHASH = "WITHHASH", + BYBOX = RedisValue.FromRaw("BYBOX"u8), + BYRADIUS = RedisValue.FromRaw("BYRADIUS"u8), + FROMMEMBER = RedisValue.FromRaw("FROMMEMBER"u8), + FROMLONLAT = RedisValue.FromRaw("FROMLONLAT"u8), + STOREDIST = RedisValue.FromRaw("STOREDIST"u8), + WITHCOORD = RedisValue.FromRaw("WITHCOORD"u8), + WITHDIST = RedisValue.FromRaw("WITHDIST"u8), + WITHHASH = RedisValue.FromRaw("WITHHASH"u8), // geo units - ft = "ft", - km = "km", - m = "m", - mi = "mi", + ft = RedisValue.FromRaw("ft"u8), + km = RedisValue.FromRaw("km"u8), + m = RedisValue.FromRaw("m"u8), + mi = RedisValue.FromRaw("mi"u8), // misc (config, etc) - databases = "databases", - master = "master", - no = "no", - normal = "normal", - pubsub = "pubsub", - replica = "replica", - replica_read_only = "replica-read-only", - replication = "replication", - sentinel = "sentinel", - server = "server", - slave = "slave", - slave_read_only = "slave-read-only", - timeout = "timeout", - yes = "yes"; + databases = RedisValue.FromRaw("databases"u8), + master = RedisValue.FromRaw("master"u8), + no = RedisValue.FromRaw("no"u8), + normal = RedisValue.FromRaw("normal"u8), + pubsub = RedisValue.FromRaw("pubsub"u8), + replica = RedisValue.FromRaw("replica"u8), + replica_read_only = RedisValue.FromRaw("replica-read-only"u8), + replication = RedisValue.FromRaw("replication"u8), + sentinel = RedisValue.FromRaw("sentinel"u8), + server = RedisValue.FromRaw("server"u8), + slave = RedisValue.FromRaw("slave"u8), + slave_read_only = RedisValue.FromRaw("slave-read-only"u8), + timeout = RedisValue.FromRaw("timeout"u8), + yes = RedisValue.FromRaw("yes"u8); internal static RedisValue Get(Bitwise operation) => operation switch { diff --git a/src/StackExchange.Redis/RedisResult.cs b/src/StackExchange.Redis/RedisResult.cs index 4a1644c36..78ed649bc 100644 --- a/src/StackExchange.Redis/RedisResult.cs +++ b/src/StackExchange.Redis/RedisResult.cs @@ -3,6 +3,7 @@ using System.ComponentModel; using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; +using RESPite.Messages; namespace StackExchange.Redis { @@ -102,55 +103,64 @@ public static RedisResult Create(RedisResult[] values, ResultType resultType) public abstract string? ToString(out string? type); /// - /// Internally, this is very similar to RawResult, except it is designed to be usable, - /// outside of the IO-processing pipeline: the buffers are standalone, etc. + /// Designed to be usable outside of the IO-processing pipeline: the buffers are standalone, etc. /// - internal static bool TryCreate(PhysicalConnection? connection, in RawResult result, [NotNullWhen(true)] out RedisResult? redisResult) + internal static bool TryCreate(PhysicalConnection? connection, ref RespReader reader, [NotNullWhen(true)] out RedisResult? redisResult) { + reader.MovePastBof(); try { - switch (result.Resp2TypeBulkString) + var type = reader.Prefix.ToResultType(); + if (reader.Prefix is RespPrefix.Null) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - redisResult = new SingleRedisResult(result.AsRedisValue(), result.Resp3Type); + redisResult = NullSingle; + return true; + } + + if (reader.IsError) + { + redisResult = new ErrorRedisResult(reader.ReadString(), type); + return true; + } + + if (reader.IsScalar) + { + redisResult = new SingleRedisResult(reader.ReadRedisValue(), type); + return true; + } + + if (reader.IsAggregate) + { + if (reader.IsNull) + { + redisResult = new ArrayRedisResult(null, type); return true; - case ResultType.Array: - if (result.IsNull) - { - redisResult = NullArray; - return true; - } - var items = result.GetItems(); - if (items.Length == 0) - { - redisResult = EmptyArray(result.Resp3Type); - return true; - } - var arr = new RedisResult[items.Length]; - int i = 0; - foreach (ref RawResult item in items) + } + + var arr = reader.ReadPastArray( + ref connection, + static (ref PhysicalConnection? conn, ref RespReader r) => { - if (TryCreate(connection, in item, out var next)) - { - arr[i++] = next; - } - else + if (!TryCreate(conn, ref r, out var result)) { - redisResult = null; - return false; + return null!; // Will be caught by null check below } - } - redisResult = new ArrayRedisResult(arr, result.Resp3Type); - return true; - case ResultType.Error: - redisResult = new ErrorRedisResult(result.GetString(), result.Resp3Type); - return true; - default: + return result; + }, + scalar: false); + + if (arr is null || arr.AnyNull()) + { redisResult = null; return false; + } + + redisResult = new ArrayRedisResult(arr, type); + return true; } + + redisResult = null; + return false; } catch (Exception ex) { diff --git a/src/StackExchange.Redis/RedisServer.cs b/src/StackExchange.Redis/RedisServer.cs index de7c03385..ef58d3bbf 100644 --- a/src/StackExchange.Redis/RedisServer.cs +++ b/src/StackExchange.Redis/RedisServer.cs @@ -8,7 +8,7 @@ using System.Security.Cryptography; using System.Text; using System.Threading.Tasks; -using Pipelines.Sockets.Unofficial.Arenas; +using RESPite.Messages; namespace StackExchange.Redis { @@ -893,34 +893,39 @@ private protected override Message CreateMessage(in RedisValue cursor) public static readonly ResultProcessor processor = new ScanResultProcessor(); private sealed class ScanResultProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + if (reader.IsAggregate && reader.AggregateLengthIs(2)) { - case ResultType.Array: - var arr = result.GetItems(); - RawResult inner; - if (arr.Length == 2 && (inner = arr[1]).Resp2TypeArray == ResultType.Array) + // SCAN returns [cursor, [keys...]] + var iter = reader.AggregateChildren(); + if (!iter.MoveNext()) return false; + var cursor = iter.Value.ReadRedisValue(); + + if (iter.MoveNext() && iter.Value.IsAggregate) + { + RedisKey[] keys; + int count; + if (iter.Value.IsNull || iter.Value.AggregateLengthIs(0)) { - var items = inner.GetItems(); - RedisKey[] keys; - int count; - if (items.IsEmpty) - { - keys = Array.Empty(); - count = 0; - } - else + keys = Array.Empty(); + count = 0; + } + else + { + count = iter.Value.AggregateLength(); + keys = ArrayPool.Shared.Rent(count); + var keysIter = iter.Value.AggregateChildren(); + for (int i = 0; i < count; i++) { - count = (int)items.Length; - keys = ArrayPool.Shared.Rent(count); - items.CopyTo(keys, (in RawResult r) => r.AsRedisKey()); + keysIter.DemandNext(); + keys[i] = keysIter.Value.ReadRedisKey(); } - var keysResult = new ScanResult(arr[0].AsRedisValue(), keys, count, true); - SetResult(message, keysResult); - return true; } - break; + var keysResult = new ScanResult(cursor, keys, count, true); + SetResult(message, keysResult); + return true; + } } return false; } @@ -1061,6 +1066,11 @@ public Task ExecuteAsync(int? database, string command, ICollection return ExecuteAsync(msg, ResultProcessor.ScriptResult, defaultValue: RedisResult.NullSingle); } + /// + /// For testing only: Check if the server can simulate connection failure. + /// + internal bool CanSimulateConnectionFailure => server.CanSimulateConnectionFailure; + /// /// For testing only. /// diff --git a/src/StackExchange.Redis/RedisSubscriber.cs b/src/StackExchange.Redis/RedisSubscriber.cs index bd2434771..ef9d42d22 100644 --- a/src/StackExchange.Redis/RedisSubscriber.cs +++ b/src/StackExchange.Redis/RedisSubscriber.cs @@ -3,7 +3,6 @@ using System.Diagnostics.CodeAnalysis; using System.Net; using System.Threading.Tasks; -using Pipelines.Sockets.Unofficial.Arenas; using static StackExchange.Redis.ConnectionMultiplexer; namespace StackExchange.Redis @@ -94,24 +93,6 @@ internal void OnMessage(in RedisChannel subscription, in RedisChannel channel, i } } - internal void OnMessage(in RedisChannel subscription, in RedisChannel channel, Sequence payload) - { - if (payload.IsSingleSegment) - { - foreach (var message in payload.FirstSpan) - { - OnMessage(subscription, channel, message.AsRedisValue()); - } - } - else - { - foreach (var message in payload) - { - OnMessage(subscription, channel, message.AsRedisValue()); - } - } - } - /// /// Updates all subscriptions re-evaluating their state. /// This clears the current server if it's not connected, prepping them to reconnect. diff --git a/src/StackExchange.Redis/RedisTransaction.cs b/src/StackExchange.Redis/RedisTransaction.cs index f0a9600fa..0c369e988 100644 --- a/src/StackExchange.Redis/RedisTransaction.cs +++ b/src/StackExchange.Redis/RedisTransaction.cs @@ -1,8 +1,10 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.Text; using System.Threading; using System.Threading.Tasks; +using RESPite.Messages; namespace StackExchange.Redis { @@ -166,6 +168,7 @@ private void QueueMessage(Message message) return Message.Create(-1, flags, RedisCommand.PING); } processor = TransactionProcessor.Default; + return new TransactionMessage(Database, flags, cond, work); } @@ -186,9 +189,9 @@ public bool WasQueued set => wasQueued = value; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - Wrapped.WriteTo(physical); + Wrapped.WriteTo(writer); Wrapped.SetRequestSent(); } public override int ArgCount => Wrapped.ArgCount; @@ -201,16 +204,21 @@ private sealed class QueuedProcessor : ResultProcessor { public static readonly ResultProcessor Default = new QueuedProcessor(); - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeBulkString == ResultType.SimpleString && result.IsEqual(CommonReplies.QUEUED)) + if (reader.Prefix == RespPrefix.SimpleString && reader.IsScalar) { - if (message is QueuedMessage q) + Span buffer = stackalloc byte[8]; + var span = reader.TryGetSpan(out var tmp) ? tmp : reader.Buffer(buffer); + if (span.SequenceEqual("QUEUED"u8)) { - connection?.BridgeCouldBeNull?.Multiplexer?.OnTransactionLog("Observed QUEUED for " + q.Wrapped?.CommandAndKey); - q.WasQueued = true; + if (message is QueuedMessage q) + { + connection?.BridgeCouldBeNull?.Multiplexer?.OnTransactionLog("Observed QUEUED for " + q.Wrapped?.CommandAndKey); + q.WasQueued = true; + } + return true; } - return true; } return false; } @@ -320,9 +328,7 @@ public IEnumerable GetMessages(PhysicalConnection connection) sb.AppendLine("checking conditions in the *early* path"); // need to get those sent ASAP; if they are stuck in the buffers, we die multiplexer.Trace("Flushing and waiting for precondition responses"); -#pragma warning disable CS0618 // Type or member is obsolete - connection.FlushSync(true, multiplexer.TimeoutMilliseconds); // make sure they get sent, so we can check for QUEUED (and the preconditions if necessary) -#pragma warning restore CS0618 + connection.Flush(); // make sure they get sent, so we can check for QUEUED (and the preconditions if necessary) if (Monitor.Wait(lastBox, multiplexer.TimeoutMilliseconds)) { @@ -380,9 +386,7 @@ public IEnumerable GetMessages(PhysicalConnection connection) sb.AppendLine("checking conditions in the *late* path"); multiplexer.Trace("Flushing and waiting for precondition+queued responses"); -#pragma warning disable CS0618 // Type or member is obsolete - connection.FlushSync(true, multiplexer.TimeoutMilliseconds); // make sure they get sent, so we can check for QUEUED (and the preconditions if necessary) -#pragma warning restore CS0618 + connection.Flush(); // make sure they get sent, so we can check for QUEUED (and the preconditions if necessary) if (Monitor.Wait(lastBox, multiplexer.TimeoutMilliseconds)) { if (!AreAllConditionsSatisfied(multiplexer)) @@ -441,7 +445,7 @@ public IEnumerable GetMessages(PhysicalConnection connection) } } - protected override void WriteImpl(PhysicalConnection physical) => physical.WriteHeader(Command, 0); + protected override void WriteImpl(in MessageWriter writer) => writer.WriteHeader(Command, 0); public override int ArgCount => 0; @@ -469,11 +473,13 @@ private sealed class TransactionProcessor : ResultProcessor { public static readonly TransactionProcessor Default = new(); - public override bool SetResult(PhysicalConnection connection, Message message, in RawResult result) + public override bool SetResult(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.IsError && message is TransactionMessage tran) + var copy = reader; + reader.MovePastBof(); + if (reader.IsError && message is TransactionMessage tran) { - string error = result.GetString()!; + string error = reader.ReadString()!; foreach (var op in tran.InnerOperations) { var inner = op.Wrapped; @@ -481,78 +487,68 @@ public override bool SetResult(PhysicalConnection connection, Message message, i inner.Complete(); } } - return base.SetResult(connection, message, result); + return base.SetResult(connection, message, ref copy); } - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { var muxer = connection.BridgeCouldBeNull?.Multiplexer; - muxer?.OnTransactionLog($"got {result} for {message.CommandAndKey}"); + muxer?.OnTransactionLog($"got {reader.GetOverview()} for {message.CommandAndKey}"); if (message is TransactionMessage tran) { var wrapped = tran.InnerOperations; - switch (result.Resp2TypeArray) + + if (reader.IsNull) // EXEC returned with a NULL { - case ResultType.SimpleString: - if (tran.IsAborted && result.IsEqual(CommonReplies.OK)) + if (tran.IsAborted) + { + muxer?.OnTransactionLog("Aborting wrapped messages (failed watch)"); + connection.Trace("Server aborted due to failed WATCH"); + foreach (var op in wrapped) { - connection.Trace("Acknowledging UNWATCH (aborted electively)"); - SetResult(message, false); - return true; + var inner = op.Wrapped; + inner.Cancel(); + inner.Complete(); } - // EXEC returned with a NULL - if (!tran.IsAborted && result.IsNull) + } + SetResult(message, false); + return true; + } + if (reader.IsScalar && (tran.IsAborted & reader.IsOK())) + { + connection.Trace("Acknowledging UNWATCH (aborted electively)"); + SetResult(message, false); + return true; + } + + if (reader.IsAggregate && !tran.IsAborted) + { + var len = reader.AggregateLength(); + if (len == wrapped.Length) + { + connection.Trace("Server committed; processing nested replies"); + muxer?.OnTransactionLog($"Processing {len} wrapped messages"); + + var iter = reader.AggregateChildren(); + int i = 0; + // using "raw" to leave reader ahead of content + // (so errors and attributes can be consumed appropriately) + while (iter.MoveNextRaw()) { - connection.Trace("Server aborted due to failed EXEC"); - // cancel the commands in the transaction and mark them as complete with the completion manager - foreach (var op in wrapped) + var inner = wrapped[i++].Wrapped; + muxer?.OnTransactionLog($"> got {iter.Value.GetOverview()} for {inner.CommandAndKey}"); + if (inner.ComputeResult(connection, ref iter.Value)) { - var inner = op.Wrapped; - inner.Cancel(); inner.Complete(); } - SetResult(message, false); - return true; } - break; - case ResultType.Array: - if (!tran.IsAborted) - { - var arr = result.GetItems(); - if (result.IsNull) - { - muxer?.OnTransactionLog("Aborting wrapped messages (failed watch)"); - connection.Trace("Server aborted due to failed WATCH"); - foreach (var op in wrapped) - { - var inner = op.Wrapped; - inner.Cancel(); - inner.Complete(); - } - SetResult(message, false); - return true; - } - else if (wrapped.Length == arr.Length) - { - connection.Trace("Server committed; processing nested replies"); - muxer?.OnTransactionLog($"Processing {arr.Length} wrapped messages"); - int i = 0; - foreach (ref RawResult item in arr) - { - var inner = wrapped[i++].Wrapped; - muxer?.OnTransactionLog($"> got {item} for {inner.CommandAndKey}"); - if (inner.ComputeResult(connection, in item)) - { - inner.Complete(); - } - } - SetResult(message, true); - return true; - } - } - break; + Debug.Assert(i == len, "we pre-checked the lengths"); + SetResult(message, true); + return true; + } } + // even if we didn't fully understand the result, we still need to do something with // the pending tasks foreach (var op in wrapped) diff --git a/src/StackExchange.Redis/RedisValue.cs b/src/StackExchange.Redis/RedisValue.cs index 5b8bfe58f..ac9274fcd 100644 --- a/src/StackExchange.Redis/RedisValue.cs +++ b/src/StackExchange.Redis/RedisValue.cs @@ -16,43 +16,150 @@ namespace StackExchange.Redis /// /// Represents values that can be stored in redis. /// + [StructLayout(LayoutKind.Explicit)] public readonly struct RedisValue : IEquatable, IComparable, IComparable, IConvertible { + // Note that this allocates a byte[]; fine when used for a static field from a u8 literal, but + // not a good option to call every time. + internal static RedisValue FromRaw(ReadOnlySpan bytes) => bytes.ToArray(); + internal static readonly RedisValue[] EmptyArray = Array.Empty(); - private readonly object? _objectOrSentinel; - private readonly ReadOnlyMemory _memory; - private readonly long _overlappedBits64; +#pragma warning disable SA1134 + [FieldOffset(0)] private readonly int _index; + [FieldOffset(4)] private readonly int _length; + + // these should only be used if the value of _obj is the appropriate sentinel + [FieldOffset(0)] private readonly long _valueInt64; + [FieldOffset(0)] private readonly ulong _valueUInt64; + [FieldOffset(0)] private readonly double _valueDouble; + + [FieldOffset(8)] private readonly object? _obj; +#pragma warning restore SA1134 + + private RedisValue(byte[]? value) + { + if (value is null) + { + this = default; + } + else if (value.Length == 0) + { + this = EmptyString; + } + else + { + Unsafe.SkipInit(out this); + _index = 0; + _length = value.Length; + _obj = value; + } + } + + private RedisValue(ReadOnlyMemory value) + { + Unsafe.SkipInit(out this); + if (value.IsEmpty) + { + this = EmptyString; + } + else if (MemoryMarshal.TryGetArray(value, out var segment)) + { + _index = segment.Offset; + _length = segment.Count; + _obj = segment.Array; + } + else if (MemoryMarshal.TryGetMemoryManager>(value, out var manager, out var index, out var length)) + { + _index = index; + _length = length; + _obj = manager; + } + else + { + Throw(); + static void Throw() => throw new ArgumentException("Unrecognized memory type"); + } + } - private RedisValue(long overlappedValue64, ReadOnlyMemory memory, object? objectOrSentinel) + private RedisValue(long value) { - _overlappedBits64 = overlappedValue64; - _memory = memory; - _objectOrSentinel = objectOrSentinel; + Unsafe.SkipInit(out this); + _valueInt64 = value; + _obj = Sentinel_SignedInteger; } - internal RedisValue(object obj, long overlappedBits) + private RedisValue(ulong value) { - // this creates a bodged RedisValue which should **never** - // be seen directly; the contents are ... unexpected - _overlappedBits64 = overlappedBits; - _objectOrSentinel = obj; - _memory = default; + Unsafe.SkipInit(out this); + if (value <= long.MaxValue) + { + _valueInt64 = (long)value; + _obj = Sentinel_SignedInteger; + } + else + { + _valueUInt64 = value; + _obj = Sentinel_UnsignedInteger; + } + } + + private RedisValue(double value) + { + Unsafe.SkipInit(out this); + try + { + var i64 = (long)value; + // note: double doesn't offer integer accuracy at 64 bits, so we know it can't be unsigned (only use that for 64-bit) + // ReSharper disable once CompareOfFloatsByEqualityOperator + if (value == i64) + { + _valueInt64 = i64; + _obj = Sentinel_SignedInteger; + return; + } + } + catch + { + // ignored + } + + _valueDouble = value; + _obj = Sentinel_Double; } /// /// Creates a from a string. /// - public RedisValue(string value) : this(0, default, value) { } + public RedisValue(string value) + { + // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract + if (value is null) + { + // I have trust issues + this = default; + } + else + { + Unsafe.SkipInit(out this); + _index = 0; + _length = value.Length; + _obj = value; + } + } + +#pragma warning disable RCS1085 // use auto-prop + // ReSharper disable ConvertToAutoProperty + internal double OverlappedValueDouble => _valueDouble; + + internal long OverlappedValueInt64 => _valueInt64; - [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1085:Use auto-implemented property.", Justification = "Intentional field ref")] - internal object? DirectObject => _objectOrSentinel; - [System.Diagnostics.CodeAnalysis.SuppressMessage("Roslynator", "RCS1085:Use auto-implemented property.", Justification = "Intentional field ref")] - internal long DirectOverlappedBits64 => _overlappedBits64; + internal ulong OverlappedValueUInt64 => _valueUInt64; + // ReSharper restore ConvertToAutoProperty +#pragma warning restore RCS1085 // use auto-prop private static readonly object Sentinel_SignedInteger = new(); private static readonly object Sentinel_UnsignedInteger = new(); - private static readonly object Sentinel_Raw = new(); private static readonly object Sentinel_Double = new(); /// @@ -60,8 +167,8 @@ public RedisValue(string value) : this(0, default, value) { } /// public object? Box() { - var obj = _objectOrSentinel; - if (obj is null || obj is string || obj is byte[]) return obj; + var obj = _obj; + if (obj is null || obj is string || (obj is byte[] b && _index == 0 && _length == b.Length)) return obj; if (obj == Sentinel_SignedInteger) { var l = OverlappedValueInt64; @@ -80,7 +187,6 @@ public RedisValue(string value) : this(0, default, value) { } if (double.IsNaN(d)) return s_DoubleNAN; return d; } - if (obj == Sentinel_Raw && _memory.IsEmpty) return s_EmptyString; return this; } @@ -98,7 +204,7 @@ public static RedisValue Unbox(object? value) /// /// Represents the string "". /// - public static RedisValue EmptyString { get; } = new RedisValue(0, default, Sentinel_Raw); + public static RedisValue EmptyString { get; } = new(""); // note: it is *really important* that this s_EmptyString assignment happens *after* the EmptyString initializer above! private static readonly object s_DoubleNAN = double.NaN, s_DoublePosInf = double.PositiveInfinity, s_DoubleNegInf = double.NegativeInfinity, @@ -108,7 +214,7 @@ public static RedisValue Unbox(object? value) /// /// A null value. /// - public static RedisValue Null { get; } = new RedisValue(0, default, null); + public static RedisValue Null { get; } = default; /// /// Indicates whether the **underlying** value is a primitive integer (signed or unsigned); this is **not** @@ -116,12 +222,12 @@ public static RedisValue Unbox(object? value) /// and , which is usually the more appropriate test. /// [Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced)] // hide it, because this *probably* isn't what callers need - public bool IsInteger => _objectOrSentinel == Sentinel_SignedInteger || _objectOrSentinel == Sentinel_UnsignedInteger; + public bool IsInteger => _obj == Sentinel_SignedInteger || _obj == Sentinel_UnsignedInteger; /// /// Indicates whether the value should be considered a null value. /// - public bool IsNull => _objectOrSentinel == null; + public bool IsNull => _obj is null; /// /// Indicates whether the value is either null or a zero-length value. @@ -130,11 +236,10 @@ public bool IsNullOrEmpty { get { - if (IsNull) return true; - if (_objectOrSentinel == Sentinel_Raw && _memory.IsEmpty) return true; - if (_objectOrSentinel is string s && s.Length == 0) return true; - if (_objectOrSentinel is byte[] arr && arr.Length == 0) return true; - return false; + // primitives are never null + if (_obj == Sentinel_Double || _obj == Sentinel_SignedInteger || _obj == Sentinel_UnsignedInteger) return false; + // everything else either null or a buffer or some kind; can use length + return _length == 0; } } @@ -150,23 +255,22 @@ public bool IsNullOrEmpty /// The second to compare. public static bool operator !=(RedisValue x, RedisValue y) => !(x == y); - internal double OverlappedValueDouble + internal ReadOnlySpan RawSpan() { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => BitConverter.Int64BitsToDouble(_overlappedBits64); + if (_obj is byte[] b) return new ReadOnlySpan(b, _index, _length); + if (_obj is MemoryManager m) return m.GetSpan().Slice(_index, _length); + ThrowRawType(); + return default; } - internal long OverlappedValueInt64 + internal string RawString() { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => _overlappedBits64; + if (_obj is string s) return s; + ThrowRawType(); + return ""; } - internal ulong OverlappedValueUInt64 - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => unchecked((ulong)_overlappedBits64); - } + private static void ThrowRawType() => throw new InvalidOperationException("Invalid raw operation."); /// /// Indicates whether two RedisValue values are equivalent. @@ -187,14 +291,15 @@ internal ulong OverlappedValueUInt64 switch (xType) { case StorageType.Double: // make sure we use double equality rules + // ReSharper disable once CompareOfFloatsByEqualityOperator return x.OverlappedValueDouble == y.OverlappedValueDouble; case StorageType.Int64: case StorageType.UInt64: // as long as xType == yType, only need to check the bits - return x._overlappedBits64 == y._overlappedBits64; + return x._valueInt64 == y._valueInt64; case StorageType.String: - return (string?)x._objectOrSentinel == (string?)y._objectOrSentinel; - case StorageType.Raw: - return x._memory.Span.SequenceEqual(y._memory.Span); + return x.RawString() == y.RawString(); + case StorageType.ByteArray or StorageType.MemoryManager: + return x.RawSpan().SequenceEqual(y.RawSpan()); } } @@ -246,9 +351,9 @@ private static int GetHashCode(RedisValue x) { StorageType.Null => -1, StorageType.Double => x.OverlappedValueDouble.GetHashCode(), - StorageType.Int64 or StorageType.UInt64 => x._overlappedBits64.GetHashCode(), - StorageType.Raw => ((string)x!).GetHashCode(), // to match equality - _ => x._objectOrSentinel!.GetHashCode(), + StorageType.Int64 or StorageType.UInt64 => x._valueInt64.GetHashCode(), + StorageType.String => x.RawString().GetHashCode(), + _ => ((string)x!).GetHashCode(), // to match equality }; } @@ -317,24 +422,59 @@ internal enum StorageType Int64, UInt64, Double, - Raw, + MemoryManager, + ByteArray, String, + Unknown, } internal StorageType Type { get { - var objectOrSentinel = _objectOrSentinel; - if (objectOrSentinel == null) return StorageType.Null; - if (objectOrSentinel == Sentinel_SignedInteger) return StorageType.Int64; - if (objectOrSentinel == Sentinel_Double) return StorageType.Double; - if (objectOrSentinel == Sentinel_Raw) return StorageType.Raw; - if (objectOrSentinel is string) return StorageType.String; - if (objectOrSentinel is byte[]) return StorageType.Raw; // doubled-up, but retaining the array - if (objectOrSentinel == Sentinel_UnsignedInteger) return StorageType.UInt64; - throw new InvalidOperationException("Unknown type"); + var obj = _obj; + if (obj is null) return StorageType.Null; + if (obj == Sentinel_SignedInteger) return StorageType.Int64; + if (obj == Sentinel_Double) return StorageType.Double; + if (obj is string) return StorageType.String; + if (obj is byte[]) return StorageType.ByteArray; + if (obj == Sentinel_UnsignedInteger) return StorageType.UInt64; + if (obj is MemoryManager) return StorageType.MemoryManager; + return StorageType.Unknown; + } + } + + // used in the toy server only! + internal static RedisValue CreateForeign(T value, int index, int length) where T : class + { + if (typeof(T) == typeof(string) || typeof(T) == typeof(byte[])) Throw(); + return new RedisValue(value, index, length); + static void Throw() => throw new InvalidOperationException(); + } + + private RedisValue(object obj, int index, int length) + { + Unsafe.SkipInit(out this); + _index = index; + _length = length; + _obj = obj; + } + + // used in the toy server only! + internal bool TryGetForeign([NotNullWhen(true)] out T? value, out int index, out int length) + where T : class + { + if (typeof(T) != typeof(string) && typeof(T) != typeof(byte[]) && _obj is T found) + { + index = _index; + length = _length; + value = found; + return true; } + value = null; + index = 0; + length = 0; + return false; } /// @@ -343,8 +483,8 @@ internal StorageType Type public long Length() => Type switch { StorageType.Null => 0, - StorageType.Raw => _memory.Length, - StorageType.String => Encoding.UTF8.GetByteCount((string)_objectOrSentinel!), + StorageType.MemoryManager or StorageType.ByteArray => _length, + StorageType.String => Encoding.UTF8.GetByteCount(RawString()), StorageType.Int64 => Format.MeasureInt64(OverlappedValueInt64), StorageType.UInt64 => Format.MeasureUInt64(OverlappedValueUInt64), StorageType.Double => Format.MeasureDouble(OverlappedValueDouble), @@ -379,9 +519,9 @@ private static int CompareTo(RedisValue x, RedisValue y) case StorageType.UInt64: return x.OverlappedValueUInt64.CompareTo(y.OverlappedValueUInt64); case StorageType.String: - return string.CompareOrdinal((string)x._objectOrSentinel!, (string)y._objectOrSentinel!); - case StorageType.Raw: - return x._memory.Span.SequenceCompareTo(y._memory.Span); + return string.CompareOrdinal(x.RawString(), y.RawString()); + case StorageType.MemoryManager or StorageType.ByteArray: + return x.RawSpan().SequenceCompareTo(y.RawSpan()); } } @@ -450,75 +590,59 @@ internal static RedisValue TryParse(object? obj, out bool valid) /// Creates a new from an . /// /// The to convert to a . - public static implicit operator RedisValue(int value) => new RedisValue(value, default, Sentinel_SignedInteger); + public static implicit operator RedisValue(int value) => new(value); /// /// Creates a new from an . /// /// The to convert to a . - public static implicit operator RedisValue(int? value) => value == null ? Null : (RedisValue)value.GetValueOrDefault(); + public static implicit operator RedisValue(int? value) => value == null ? Null : new(value.GetValueOrDefault()); /// /// Creates a new from an . /// /// The to convert to a . - public static implicit operator RedisValue(long value) => new RedisValue(value, default, Sentinel_SignedInteger); + public static implicit operator RedisValue(long value) => new(value); /// /// Creates a new from an . /// /// The to convert to a . - public static implicit operator RedisValue(long? value) => value == null ? Null : (RedisValue)value.GetValueOrDefault(); + public static implicit operator RedisValue(long? value) => value == null ? Null : new(value.GetValueOrDefault()); /// /// Creates a new from an . /// /// The to convert to a . [CLSCompliant(false)] - public static implicit operator RedisValue(ulong value) - { - const ulong MSB = 1UL << 63; - return (value & MSB) == 0 - ? new RedisValue((long)value, default, Sentinel_SignedInteger) // prefer signed whenever we can - : new RedisValue(unchecked((long)value), default, Sentinel_UnsignedInteger); // with unsigned as the fallback - } + public static implicit operator RedisValue(ulong value) => new(value); /// /// Creates a new from an . /// /// The to convert to a . [CLSCompliant(false)] - public static implicit operator RedisValue(ulong? value) => value == null ? Null : (RedisValue)value.GetValueOrDefault(); + public static implicit operator RedisValue(ulong? value) => value == null ? Null : new(value.GetValueOrDefault()); /// /// Creates a new from an . /// /// The to convert to a . [CLSCompliant(false)] - public static implicit operator RedisValue(uint value) => new RedisValue(value, default, Sentinel_SignedInteger); // 32-bits always fits as signed + public static implicit operator RedisValue(uint value) => new(value); /// /// Creates a new from an . /// /// The to convert to a . [CLSCompliant(false)] - public static implicit operator RedisValue(uint? value) => value == null ? Null : (RedisValue)value.GetValueOrDefault(); + public static implicit operator RedisValue(uint? value) => value == null ? Null : new(value.GetValueOrDefault()); /// /// Creates a new from an . /// /// The to convert to a . - public static implicit operator RedisValue(double value) - { - try - { - var i64 = (long)value; - // note: double doesn't offer integer accuracy at 64 bits, so we know it can't be unsigned (only use that for 64-bit) - if (value == i64) return new RedisValue(i64, default, Sentinel_SignedInteger); - } - catch { } - return new RedisValue(BitConverter.DoubleToInt64Bits(value), default, Sentinel_Double); - } + public static implicit operator RedisValue(double value) => new(value); /// /// Creates a new from an . @@ -530,51 +654,38 @@ public static implicit operator RedisValue(double value) /// Creates a new from a . /// /// The to convert to a . - public static implicit operator RedisValue(ReadOnlyMemory value) - { - if (value.Length == 0) return EmptyString; - return new RedisValue(0, value, Sentinel_Raw); - } + public static implicit operator RedisValue(ReadOnlyMemory value) => new(value); /// /// Creates a new from a . /// /// The to convert to a . - public static implicit operator RedisValue(Memory value) => (ReadOnlyMemory)value; + public static implicit operator RedisValue(Memory value) => new(value); /// /// Creates a new from an . /// /// The to convert to a . - public static implicit operator RedisValue(string? value) - { - if (value == null) return Null; - if (value.Length == 0) return EmptyString; - return new RedisValue(0, default, value); - } + public static implicit operator RedisValue(string? value) => value is null ? Null : new(value); /// /// Creates a new from an . /// /// The to convert to a . - public static implicit operator RedisValue(byte[]? value) - { - if (value == null) return Null; - if (value.Length == 0) return EmptyString; - return new RedisValue(0, new Memory(value), value); - } + public static implicit operator RedisValue(byte[]? value) => new(value); /// /// Creates a new from an . /// /// The to convert to a . - public static implicit operator RedisValue(bool value) => new RedisValue(value ? 1 : 0, default, Sentinel_SignedInteger); + public static implicit operator RedisValue(bool value) => new RedisValue(value ? 1 : 0); /// /// Creates a new from an . /// /// The to convert to a . - public static implicit operator RedisValue(bool? value) => value == null ? Null : (RedisValue)value.GetValueOrDefault(); + public static implicit operator RedisValue(bool? value) => value == null ? Null + : new(value.GetValueOrDefault() ? 1 : 0); /// /// Converts a to a . @@ -658,8 +769,8 @@ public static explicit operator double(RedisValue value) StorageType.UInt64 => value.OverlappedValueUInt64, StorageType.Double => value.OverlappedValueDouble, // special values like NaN/Inf are deliberately not handled by Simplify, but need to be considered for casting - StorageType.String when Format.TryParseDouble((string)value._objectOrSentinel!, out var d) => d, - StorageType.Raw when TryParseDouble(value._memory.Span, out var d) => d, + StorageType.String when Format.TryParseDouble(value.RawString(), out var d) => d, + StorageType.MemoryManager or StorageType.ByteArray when TryParseDouble(value.RawSpan(), out var d) => d, // anything else: fail _ => throw new InvalidCastException($"Unable to cast from {value.Type} to double: '{value}'"), }; @@ -781,9 +892,9 @@ private static bool TryParseDouble(ReadOnlySpan blob, out double value) case StorageType.Double: return Format.ToString(value.OverlappedValueDouble); case StorageType.Int64: return Format.ToString(value.OverlappedValueInt64); case StorageType.UInt64: return Format.ToString(value.OverlappedValueUInt64); - case StorageType.String: return (string)value._objectOrSentinel!; - case StorageType.Raw: - var span = value._memory.Span; + case StorageType.String: return value.RawString(); + case StorageType.MemoryManager or StorageType.ByteArray: + var span = value.RawSpan(); if (span.IsEmpty) return ""; if (span.Length == 2 && span[0] == (byte)'O' && span[1] == (byte)'K') return "OK"; // frequent special-case try @@ -835,17 +946,11 @@ private static string ToHex(ReadOnlySpan src) switch (value.Type) { case StorageType.Null: return null; - case StorageType.Raw: - if (value._objectOrSentinel is byte[] arr) return arr; - - if (MemoryMarshal.TryGetArray(value._memory, out var segment) - && segment.Offset == 0 - && segment.Count == (segment.Array?.Length ?? -1)) - { - return segment.Array; // the memory is backed by an array, and we're reading all of it - } - - return value._memory.ToArray(); + case StorageType.ByteArray when value._obj is byte[] arr && value._index is 0 && value._length == arr.Length: + // the memory is backed by an array, and we're reading all of it + return arr; + case StorageType.ByteArray or StorageType.MemoryManager: + return value.RawSpan().ToArray(); case StorageType.Int64: Debug.Assert(Format.MaxInt64TextLen <= 24); Span span = stackalloc byte[24]; @@ -861,7 +966,7 @@ private static string ToHex(ReadOnlySpan src) len = Format.FormatDouble(value.OverlappedValueDouble, span); return span.Slice(0, len).ToArray(); case StorageType.String: - return Encoding.UTF8.GetBytes((string)value._objectOrSentinel!); + return Encoding.UTF8.GetBytes(value.RawString()); } // fallback: stringify and encode return Encoding.UTF8.GetBytes((string)value!); @@ -873,8 +978,8 @@ private static string ToHex(ReadOnlySpan src) public int GetByteCount() => Type switch { StorageType.Null => 0, - StorageType.Raw => _memory.Length, - StorageType.String => Encoding.UTF8.GetByteCount((string)_objectOrSentinel!), + StorageType.MemoryManager or StorageType.ByteArray => _length, + StorageType.String => Encoding.UTF8.GetByteCount(RawString()), StorageType.Int64 => Format.MeasureInt64(OverlappedValueInt64), StorageType.UInt64 => Format.MeasureUInt64(OverlappedValueUInt64), StorageType.Double => Format.MeasureDouble(OverlappedValueDouble), @@ -887,8 +992,8 @@ private static string ToHex(ReadOnlySpan src) internal int GetMaxByteCount() => Type switch { StorageType.Null => 0, - StorageType.Raw => _memory.Length, - StorageType.String => Encoding.UTF8.GetMaxByteCount(((string)_objectOrSentinel!).Length), + StorageType.MemoryManager or StorageType.ByteArray => _length, + StorageType.String => Encoding.UTF8.GetMaxByteCount(RawString().Length), StorageType.Int64 => Format.MaxInt64TextLen, StorageType.UInt64 => Format.MaxInt64TextLen, StorageType.Double => Format.MaxDoubleTextLen, @@ -901,8 +1006,8 @@ private static string ToHex(ReadOnlySpan src) internal int GetCharCount() => Type switch { StorageType.Null => 0, - StorageType.Raw => Encoding.UTF8.GetCharCount(_memory.Span), - StorageType.String => ((string)_objectOrSentinel!).Length, + StorageType.MemoryManager or StorageType.ByteArray => Encoding.UTF8.GetCharCount(RawSpan()), + StorageType.String => _length, StorageType.Int64 => Format.MeasureInt64(OverlappedValueInt64), StorageType.UInt64 => Format.MeasureUInt64(OverlappedValueUInt64), StorageType.Double => Format.MeasureDouble(OverlappedValueDouble), @@ -915,8 +1020,8 @@ private static string ToHex(ReadOnlySpan src) internal int GetMaxCharCount() => Type switch { StorageType.Null => 0, - StorageType.Raw => Encoding.UTF8.GetMaxCharCount(_memory.Length), - StorageType.String => ((string)_objectOrSentinel!).Length, + StorageType.MemoryManager or StorageType.ByteArray => Encoding.UTF8.GetMaxCharCount(_length), + StorageType.String => _length, StorageType.Int64 => Format.MaxInt64TextLen, StorageType.UInt64 => Format.MaxInt64TextLen, StorageType.Double => Format.MaxDoubleTextLen, @@ -941,12 +1046,11 @@ public int CopyTo(Span destination) { case StorageType.Null: return 0; - case StorageType.Raw: - var srcBytes = _memory.Span; - srcBytes.CopyTo(destination); - return srcBytes.Length; + case StorageType.MemoryManager or StorageType.ByteArray: + RawSpan().CopyTo(destination); + return _length; case StorageType.String: - return Encoding.UTF8.GetBytes(((string)_objectOrSentinel!).AsSpan(), destination); + return Encoding.UTF8.GetBytes(RawString().AsSpan(), destination); case StorageType.Int64: return Format.FormatInt64(OverlappedValueInt64, destination); case StorageType.UInt64: @@ -967,11 +1071,10 @@ internal int CopyTo(Span destination) { case StorageType.Null: return 0; - case StorageType.Raw: - var srcBytes = _memory.Span; - return Encoding.UTF8.GetChars(srcBytes, destination); + case StorageType.MemoryManager or StorageType.ByteArray: + return Encoding.UTF8.GetChars(RawSpan(), destination); case StorageType.String: - var span = ((string)_objectOrSentinel!).AsSpan(); + var span = RawString().AsSpan(); span.CopyTo(destination); return span.Length; case StorageType.Int64: @@ -990,7 +1093,12 @@ internal int CopyTo(Span destination) /// /// The to convert. public static implicit operator ReadOnlyMemory(RedisValue value) - => value.Type == StorageType.Raw ? value._memory : (byte[]?)value; + { + if (value._obj is byte[] arr) return new ReadOnlyMemory(arr, value._index, value._length); + if (value._obj is MemoryManager manager) return manager.Memory.Slice(value._index, value._length); + if (value._obj is null) return default; + return (byte[]?)value; + } TypeCode IConvertible.GetTypeCode() => TypeCode.Object; @@ -1054,7 +1162,7 @@ internal RedisValue Simplify() switch (Type) { case StorageType.String: - string s = (string)_objectOrSentinel!; + string s = RawString(); if (Format.CouldBeInteger(s)) { if (Format.TryParseInt64(s, out i64)) return i64; @@ -1063,8 +1171,8 @@ internal RedisValue Simplify() // note: don't simplify inf/nan, as that causes equality semantic problems if (Format.TryParseDouble(s, out var f64) && !IsSpecialDouble(f64)) return f64; break; - case StorageType.Raw: - var b = _memory.Span; + case StorageType.MemoryManager or StorageType.ByteArray: + var b = RawSpan(); if (Format.CouldBeInteger(b)) { if (Format.TryParseInt64(b, out i64)) return i64; @@ -1101,9 +1209,9 @@ public bool TryParse(out long val) val = default; return false; case StorageType.String: - return Format.TryParseInt64((string)_objectOrSentinel!, out val); - case StorageType.Raw: - return Format.TryParseInt64(_memory.Span, out val); + return Format.TryParseInt64(RawString(), out val); + case StorageType.MemoryManager or StorageType.ByteArray: + return Format.TryParseInt64(RawSpan(), out val); case StorageType.Double: var d = OverlappedValueDouble; try @@ -1161,9 +1269,9 @@ public bool TryParse(out double val) val = OverlappedValueDouble; return true; case StorageType.String: - return Format.TryParseDouble((string)_objectOrSentinel!, out val); - case StorageType.Raw: - return TryParseDouble(_memory.Span, out val); + return Format.TryParseDouble(RawString(), out val); + case StorageType.MemoryManager or StorageType.ByteArray: + return TryParseDouble(RawSpan(), out val); case StorageType.Null: // in redis-land 0 approx. equal null; so roll with it val = 0; @@ -1224,27 +1332,24 @@ public bool StartsWith(RedisValue value) if (value.IsNullOrEmpty) return true; if (IsNullOrEmpty) return false; - ReadOnlyMemory rawThis, rawOther; var thisType = Type; if (thisType == value.Type) // same? can often optimize { switch (thisType) { case StorageType.String: - var sThis = (string)_objectOrSentinel!; - var sOther = (string)value._objectOrSentinel!; + var sThis = RawString(); + var sOther = value.RawString(); return sThis.StartsWith(sOther, StringComparison.Ordinal); - case StorageType.Raw: - rawThis = _memory; - rawOther = value._memory; - return rawThis.Span.StartsWith(rawOther.Span); + case StorageType.MemoryManager or StorageType.ByteArray: + return RawSpan().StartsWith(value.RawSpan()); } } byte[]? arr0 = null, arr1 = null; try { - rawThis = AsMemory(out arr0); - rawOther = value.AsMemory(out arr1); + var rawThis = AsMemory(out arr0); + var rawOther = value.AsMemory(out arr1); return rawThis.Span.StartsWith(rawOther.Span); } @@ -1259,11 +1364,14 @@ private ReadOnlyMemory AsMemory(out byte[]? leased) { switch (Type) { - case StorageType.Raw: + case StorageType.MemoryManager: leased = null; - return _memory; + return ((MemoryManager)_obj!).Memory.Slice(_index, _length); + case StorageType.ByteArray: + leased = null; + return new ReadOnlyMemory((byte[])_obj!, _index, _length); case StorageType.String: - string s = (string)_objectOrSentinel!; + string s = RawString(); HaveString: if (s.Length == 0) { @@ -1278,7 +1386,7 @@ private ReadOnlyMemory AsMemory(out byte[]? leased) goto HaveString; case StorageType.Int64: leased = ArrayPool.Shared.Rent(Format.MaxInt64TextLen + 2); // reused code has CRLF terminator - len = PhysicalConnection.WriteRaw(leased, OverlappedValueInt64) - 2; // drop the CRLF + len = MessageWriter.WriteRaw(leased, OverlappedValueInt64) - 2; // drop the CRLF return new ReadOnlyMemory(leased, 0, len); case StorageType.UInt64: leased = ArrayPool.Shared.Rent(Format.MaxInt64TextLen); // reused code has CRLF terminator @@ -1298,8 +1406,8 @@ internal ValueCondition Digest() { switch (Type) { - case StorageType.Raw: - return ValueCondition.CalculateDigest(_memory.Span); + case StorageType.MemoryManager or StorageType.ByteArray: + return ValueCondition.CalculateDigest(RawSpan()); case StorageType.Null: return ValueCondition.NotExists; // interpret === null as "not exists" default: @@ -1315,9 +1423,14 @@ internal ValueCondition Digest() internal bool TryGetSpan(out ReadOnlySpan span) { - if (_objectOrSentinel == Sentinel_Raw) + if (_obj is MemoryManager manager) + { + span = manager.Memory.Span.Slice(_index, _length); + return true; + } + if (_obj is byte[] bytes) { - span = _memory.Span; + span = new ReadOnlySpan(bytes, _index, _length); return true; } span = default; @@ -1338,8 +1451,8 @@ public bool StartsWith(ReadOnlySpan value) int len; switch (Type) { - case StorageType.Raw: - return _memory.Span.StartsWith(value); + case StorageType.MemoryManager or StorageType.ByteArray: + return RawSpan().StartsWith(value); case StorageType.Int64: Span buffer = stackalloc byte[Format.MaxInt64TextLen]; len = Format.FormatInt64(OverlappedValueInt64, buffer); @@ -1353,7 +1466,7 @@ public bool StartsWith(ReadOnlySpan value) len = Format.FormatDouble(OverlappedValueDouble, buffer); return buffer.Slice(0, len).StartsWith(value); case StorageType.String: - var s = ((string)_objectOrSentinel!).AsSpan(); + var s = RawString().AsSpan(); if (s.Length < value.Length) return false; // not enough characters to match if (s.Length > value.Length) s = s.Slice(0, value.Length); // only need to match the prefix var maxBytes = Encoding.UTF8.GetMaxByteCount(s.Length); @@ -1368,31 +1481,5 @@ public bool StartsWith(ReadOnlySpan value) return false; } } - - // used by the toy server to smuggle weird vectors; on their own heads... not used by SE.Redis itself - // (these additions just formalize the usage in the older server code) - internal bool TryGetForeign([NotNullWhen(true)] out T? value, out int index, out int length) - where T : class - { - if (typeof(T) != typeof(string) && typeof(T) != typeof(byte[]) && DirectObject is T found) - { - index = 0; - length = checked((int)DirectOverlappedBits64); - value = found; - return true; - } - value = null; - index = 0; - length = 0; - return false; - } - - internal static RedisValue CreateForeign(T obj, int offset, int count) where T : class - { - // non-zero offset isn't supported until v3, left here for API parity - if (typeof(T) == typeof(string) || typeof(T) == typeof(byte[]) || offset != 0) Throw(); - return new RedisValue(obj, count); - static void Throw() => throw new InvalidOperationException(); - } } } diff --git a/src/StackExchange.Redis/ReplicationState.cs b/src/StackExchange.Redis/ReplicationState.cs new file mode 100644 index 000000000..e0194954e --- /dev/null +++ b/src/StackExchange.Redis/ReplicationState.cs @@ -0,0 +1,62 @@ +using System; +using RESPite; + +namespace StackExchange.Redis; + +/// +/// Redis replication states. +/// +// [AsciiHash(nameof(ReplicationStateMetadata))] +internal enum ReplicationState +{ + /// + /// Unknown or unrecognized state. + /// + [AsciiHash("")] + Unknown = 0, + + /// + /// Connect state. + /// + [AsciiHash("connect")] + Connect, + + /// + /// Connecting state. + /// + [AsciiHash("connecting")] + Connecting, + + /// + /// Sync state. + /// + [AsciiHash("sync")] + Sync, + + /// + /// Connected state. + /// + [AsciiHash("connected")] + Connected, + + /// + /// None state. + /// + [AsciiHash("none")] + None, + + /// + /// Handshake state. + /// + [AsciiHash("handshake")] + Handshake, +} + +/// +/// Metadata and parsing methods for ReplicationState. +/// +internal static partial class ReplicationStateMetadata +{ + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out ReplicationState state); +} diff --git a/toys/StackExchange.Redis.Server/RespReaderExtensions.cs b/src/StackExchange.Redis/RespReaderExtensions.cs similarity index 93% rename from toys/StackExchange.Redis.Server/RespReaderExtensions.cs rename to src/StackExchange.Redis/RespReaderExtensions.cs index 8ee5f921c..a5bb77bdd 100644 --- a/toys/StackExchange.Redis.Server/RespReaderExtensions.cs +++ b/src/StackExchange.Redis/RespReaderExtensions.cs @@ -1,11 +1,9 @@ -#nullable enable -extern alias seredis; using System; using System.Diagnostics; using System.Threading.Tasks; using RESPite.Messages; -namespace StackExchange.Redis; // this really belongs in SE.Redis, will be moved in v3 +namespace StackExchange.Redis; internal static class RespReaderExtensions { @@ -20,8 +18,6 @@ public RedisValue ReadRedisValue() { RespPrefix.Boolean => reader.ReadBoolean(), RespPrefix.Integer => reader.ReadInt64(), - _ when reader.TryReadInt64(out var i64) => i64, - _ when reader.TryReadDouble(out var fp64) => fp64, _ => reader.ReadByteArray(), }; } @@ -139,15 +135,15 @@ public void MovePastBof() public RedisValue[]? ReadPastRedisValues() => reader.ReadPastArray(static (ref r) => r.ReadRedisValue(), scalar: true); - public seredis::StackExchange.Redis.Lease? AsLease() + public Lease? AsLease() { if (!reader.IsScalar) throw new InvalidCastException("Cannot convert to Lease: " + reader.Prefix); if (reader.IsNull) return null; var length = reader.ScalarLength(); - if (length == 0) return seredis::StackExchange.Redis.Lease.Empty; + if (length == 0) return Lease.Empty; - var lease = seredis::StackExchange.Redis.Lease.Create(length, clear: false); + var lease = Lease.Create(length, clear: false); if (reader.TryGetSpan(out var span)) { span.CopyTo(lease.Span); diff --git a/src/StackExchange.Redis/ResultProcessor.Arrays.cs b/src/StackExchange.Redis/ResultProcessor.Arrays.cs index 865bbb1ed..f08c03c78 100644 --- a/src/StackExchange.Redis/ResultProcessor.Arrays.cs +++ b/src/StackExchange.Redis/ResultProcessor.Arrays.cs @@ -2,6 +2,7 @@ using System.Buffers; using System.Collections.Generic; using System.Diagnostics; +using RESPite.Messages; // ReSharper disable once CheckNamespace namespace StackExchange.Redis; @@ -23,19 +24,18 @@ public static readonly ResultProcessor public static readonly ResultProcessor ArrayInfo = new ArrayInfoProcessor(); - private static bool TryParseArrayIndex(in RawResult result, out RedisArrayIndex index) + private static bool TryParseArrayIndex(ref RespReader reader, out RedisArrayIndex index) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar && !reader.IsNull) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - if (!result.IsNull && result.TryParse(Format.TryParseUInt64, out ulong value)) + unsafe + { + if (reader.TryParseScalar(&Format.TryParseUInt64, out ulong value)) { index = new RedisArrayIndex(value); return true; } - break; + } } index = default; @@ -44,9 +44,9 @@ private static bool TryParseArrayIndex(in RawResult result, out RedisArrayIndex private sealed class RedisArrayIndexProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (TryParseArrayIndex(result, out RedisArrayIndex index)) + if (TryParseArrayIndex(ref reader, out RedisArrayIndex index)) { SetResult(message, index); return true; @@ -58,15 +58,15 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class NullableRedisArrayIndexProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeBulkString == ResultType.BulkString && result.IsNull) + if (reader.IsScalar && reader.IsNull) { SetResult(message, null); return true; } - if (TryParseArrayIndex(result, out RedisArrayIndex index)) + if (TryParseArrayIndex(ref reader, out RedisArrayIndex index)) { SetResult(message, index); return true; @@ -78,20 +78,20 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class RedisArrayEntryArrayProcessor : ValuePairInterleavedProcessorBase { - protected override bool AllowJaggedPairs(in RawResult result) => true; // i.e. even in RESP2 + protected override bool AllowJaggedPairs(RedisProtocol protocol) => true; // i.e. even in RESP2 - protected override RedisArrayEntry Parse(in RawResult first, in RawResult second, object? state) + protected override RedisArrayEntry Parse(ref RespReader first, ref RespReader second, object? state) { - TryParseArrayIndex(first, out RedisArrayIndex index); - return new RedisArrayEntry(index, second.AsRedisValue()); + TryParseArrayIndex(ref first, out RedisArrayIndex index); + return new RedisArrayEntry(index, second.ReadRedisValue()); } } private sealed class RedisArrayIndexEntryArrayProcessor : ArrayResultProcessor { - protected override bool TryParse(in RawResult raw, out RedisArrayEntry parsed) + protected override bool TryParse(ref RespReader reader, out RedisArrayEntry parsed) { - if (TryParseArrayIndex(raw, out RedisArrayIndex index)) + if (TryParseArrayIndex(ref reader, out RedisArrayIndex index)) { parsed = new RedisArrayEntry(index); return true; @@ -104,38 +104,44 @@ protected override bool TryParse(in RawResult raw, out RedisArrayEntry parsed) private sealed class ArrayInfoProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray != ResultType.Array || result.IsNull) + if (!reader.IsAggregate || reader.IsNull) { return false; } - var lease = ArrayPool>.Shared.Rent(result.ItemsCount / 2); + var lease = ArrayPool>.Shared.Rent(reader.AggregateLength() / 2); int count = 0; - var iter = result.GetItems().GetEnumerator(); + var iter = reader.AggregateChildren(); while (iter.MoveNext()) { - // try to parse the field as a known enum, and get the known string for it, otherwise: alloc - if (!(iter.Current.TryParse(ArrayInfoFieldMetadata.TryParse, out ArrayInfoField field) - && ArrayInfoFieldMetadata.TryFormat(field, out var key))) - { - key = iter.Current.GetString() ?? ""; - } - - if (!iter.MoveNext()) - { - break; - } - - try - { - lease[count++] = new(key, iter.Current.AsRedisValue()); - } - catch (Exception ex) + unsafe { - // quietly ignore non-scalar results - Debug.WriteLine(ex.Message); + // try to parse the field as a known enum, and get the known string for it, otherwise: alloc + if (!(iter.Value.TryParseScalar(&ArrayInfoFieldMetadata.TryParse, out ArrayInfoField field) + && ArrayInfoFieldMetadata.TryFormat(field, out var key))) + { + key = iter.Value.ReadString() ?? ""; + } + + if (!iter.MoveNext()) + { + break; + } + + try + { + if (iter.Value.IsScalar) + { + lease[count++] = new(key, iter.Value.ReadRedisValue()); + } + } + catch (Exception ex) + { + // quietly ignore non-scalar results and other oddities + Debug.WriteLine(ex.Message); + } } } diff --git a/src/StackExchange.Redis/ResultProcessor.Digest.cs b/src/StackExchange.Redis/ResultProcessor.Digest.cs index 757009ea5..a0093fbc8 100644 --- a/src/StackExchange.Redis/ResultProcessor.Digest.cs +++ b/src/StackExchange.Redis/ResultProcessor.Digest.cs @@ -1,5 +1,4 @@ -using System; -using System.Buffers; +using RESPite.Messages; namespace StackExchange.Redis; @@ -11,28 +10,18 @@ internal abstract partial class ResultProcessor private sealed class DigestProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.IsNull) // for example, key doesn't exist + if (reader.IsNull) // for example, key doesn't exist { SetResult(message, null); return true; } - if (result.Resp2TypeBulkString == ResultType.BulkString - && result.Payload is { Length: 2 * ValueCondition.DigestBytes } payload) + if (reader.ScalarLengthIs(2 * ValueCondition.DigestBytes)) { - ValueCondition digest; - if (payload.IsSingleSegment) // single chunk - fast path - { - digest = ValueCondition.ParseDigest(payload.First.Span); - } - else // linearize - { - Span buffer = stackalloc byte[2 * ValueCondition.DigestBytes]; - payload.CopyTo(buffer); - digest = ValueCondition.ParseDigest(buffer); - } + var span = reader.TryGetSpan(out var tmp) ? tmp : reader.Buffer(stackalloc byte[2 * ValueCondition.DigestBytes]); + var digest = ValueCondition.ParseDigest(span); SetResult(message, digest); return true; } diff --git a/src/StackExchange.Redis/ResultProcessor.Lease.cs b/src/StackExchange.Redis/ResultProcessor.Lease.cs index c0f9e6d8e..91dfcd2ad 100644 --- a/src/StackExchange.Redis/ResultProcessor.Lease.cs +++ b/src/StackExchange.Redis/ResultProcessor.Lease.cs @@ -1,5 +1,4 @@ -using System.Diagnostics; -using Pipelines.Sockets.Unofficial.Arenas; +using RESPite.Messages; // ReSharper disable once CheckNamespace namespace StackExchange.Redis; @@ -17,181 +16,144 @@ public static readonly ResultProcessor> private abstract class LeaseProcessor : ResultProcessor?> { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray != ResultType.Array) + if (!reader.IsAggregate) { return false; // not an array } // deal with null - if (result.IsNull) + if (reader.IsNull) { - SetResult(message, Lease.Empty); + SetResult(message, null); return true; } // lease and fill - var items = result.GetItems(); - var length = checked((int)items.Length); - var lease = Lease.Create(length, clear: false); // note this handles zero nicely - var target = lease.Span; - int index = 0; - foreach (ref RawResult item in items) - { - if (!TryParse(item, out target[index++])) - { - // something went wrong; recycle and quit - lease.Dispose(); - return false; - } - } - Debug.Assert(index == length, "length mismatch"); - SetResult(message, lease); - return true; - } - - protected abstract bool TryParse(in RawResult raw, out T parsed); - } - - private abstract class InterleavedLeaseProcessor : ResultProcessor?> - { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) - { - if (result.Resp2TypeArray != ResultType.Array) + var length = reader.AggregateLength(); + if (length == 0) { - return false; // not an array + SetResult(message, Lease.Empty); + return true; } - // deal with null - if (result.IsNull) + var lease = Lease.Create(length, clear: false); + try { - SetResult(message, Lease.Empty); + var self = this; + reader.FillAll(lease.Span, ref self, static (ref s, ref r) => s.TryParse(ref r)); + SetResult(message, lease); return true; } - - // lease and fill - var items = result.GetItems(); - var length = checked((int)items.Length) / 2; - var lease = Lease.Create(length, clear: false); // note this handles zero nicely - var target = lease.Span; - - var iter = items.GetEnumerator(); - for (int i = 0; i < target.Length; i++) + catch { - bool ok = iter.MoveNext(); - if (ok) - { - ref readonly RawResult first = ref iter.Current; - ok = iter.MoveNext() && TryParse(in first, in iter.Current, out target[i]); - } - if (!ok) - { - lease.Dispose(); - return false; - } + // something went wrong; recycle and quit + lease.Dispose(); + throw; } - SetResult(message, lease); - return true; } - protected abstract bool TryParse(in RawResult first, in RawResult second, out T parsed); + protected abstract T TryParse(ref RespReader reader); } // takes a nested vector of the form [[A],[B,C],[D]] and exposes it as [A,B,C,D]; this is // especially useful for VLINKS private abstract class FlattenedLeaseProcessor : ResultProcessor?> { - protected virtual long GetArrayLength(in RawResult array) => array.GetItems().Length; + protected virtual long GetArrayLength(in RespReader reader) => reader.AggregateLength(); - protected virtual bool TryReadOne(ref Sequence.Enumerator reader, out T value) - { - if (reader.MoveNext()) - { - return TryReadOne(in reader.Current, out value); - } - value = default!; - return false; - } - - protected virtual bool TryReadOne(in RawResult result, out T value) + protected virtual bool TryReadOne(ref RespReader reader, out T value) { value = default!; return false; } - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray != ResultType.Array) + if (!reader.IsAggregate) { return false; // not an array } - if (result.IsNull) + + // deal with null + if (reader.IsNull) { SetResult(message, Lease.Empty); return true; } - var items = result.GetItems(); - long length = 0; - foreach (ref RawResult item in items) + + // First pass: count total elements across all nested arrays + long totalLength = 0; + var iter = reader.AggregateChildren(); + while (iter.MoveNext()) { - if (item.Resp2TypeArray == ResultType.Array && !item.IsNull) + if (iter.Value.IsAggregate && !iter.Value.IsNull) { - length += GetArrayLength(in item); + totalLength += GetArrayLength(in iter.Value); } } - if (length == 0) + if (totalLength == 0) { SetResult(message, Lease.Empty); return true; } - var lease = Lease.Create(checked((int)length), clear: false); + + // Second pass: fill the lease + var lease = Lease.Create(checked((int)totalLength), clear: false); int index = 0; var target = lease.Span; - foreach (ref RawResult item in items) + + try { - if (item.Resp2TypeArray == ResultType.Array && !item.IsNull) + iter = reader.AggregateChildren(); + while (iter.MoveNext()) { - var iter = item.GetItems().GetEnumerator(); - while (index < target.Length && TryReadOne(ref iter, out target[index])) + if (iter.Value.IsAggregate && !iter.Value.IsNull) { - index++; + var childReader = iter.Value; + while (childReader.TryMoveNext() && index < target.Length) + { + if (!TryReadOne(ref childReader, out target[index])) + { + lease.Dispose(); + return false; + } + index++; + } } } - } - if (index == length) + if (index == totalLength) + { + SetResult(message, lease); + return true; + } + lease.Dispose(); // failed to fill? + return false; + } + catch { - SetResult(message, lease); - return true; + lease.Dispose(); + throw; } - lease.Dispose(); // failed to fill? - return false; } } private sealed class LeaseFloat32Processor : LeaseProcessor { - protected override bool TryParse(in RawResult raw, out float parsed) - { - var result = raw.TryGetDouble(out double val); - parsed = (float)val; - return result; - } + protected override float TryParse(ref RespReader reader) => (float)reader.ReadDouble(); } private sealed class LeaseProcessor : ResultProcessor> { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - SetResult(message, result.AsLease()!); - return true; + SetResult(message, reader.AsLease()!); + return true; } return false; } @@ -199,18 +161,14 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class LeaseFromArrayProcessor : ResultProcessor> { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsAggregate && reader.AggregateLengthIs(1) + && reader.TryMoveNext() && reader.IsScalar) { - case ResultType.Array: - var items = result.GetItems(); - if (items.Length == 1) - { // treat an array of 1 like a single reply - SetResult(message, items[0].AsLease()!); - return true; - } - break; + // treat an array of 1 like a single reply + SetResult(message, reader.AsLease()!); + return true; } return false; } diff --git a/src/StackExchange.Redis/ResultProcessor.Literals.cs b/src/StackExchange.Redis/ResultProcessor.Literals.cs new file mode 100644 index 000000000..7d50cc09e --- /dev/null +++ b/src/StackExchange.Redis/ResultProcessor.Literals.cs @@ -0,0 +1,48 @@ +using RESPite; + +namespace StackExchange.Redis; + +internal partial class ResultProcessor +{ + internal partial class Literals + { +#pragma warning disable CS8981, SA1300, SA1134 // forgive naming etc + // ReSharper disable InconsistentNaming + [AsciiHash] internal static partial class NOAUTH { } + [AsciiHash] internal static partial class WRONGPASS { } + [AsciiHash] internal static partial class NOSCRIPT { } + [AsciiHash] internal static partial class MOVED { } + [AsciiHash] internal static partial class ASK { } + [AsciiHash] internal static partial class READONLY { } + [AsciiHash] internal static partial class LOADING { } + [AsciiHash("ERR operation not permitted")] + internal static partial class ERR_not_permitted { } + + // Result processor literals + [AsciiHash] + internal static partial class OK + { + public static readonly AsciiHash Hash = new(U8); + } + + [AsciiHash] + internal static partial class PONG + { + public static readonly AsciiHash Hash = new(U8); + } + + [AsciiHash("Background saving started")] + internal static partial class background_saving_started + { + public static readonly AsciiHash Hash = new(U8); + } + + [AsciiHash("Background append only file rewriting started")] + internal static partial class background_aof_rewriting_started + { + public static readonly AsciiHash Hash = new(U8); + } + // ReSharper restore InconsistentNaming +#pragma warning restore CS8981, SA1300, SA1134 // forgive naming etc + } +} diff --git a/src/StackExchange.Redis/ResultProcessor.VectorSets.cs b/src/StackExchange.Redis/ResultProcessor.VectorSets.cs index f8f3bed72..df00b2091 100644 --- a/src/StackExchange.Redis/ResultProcessor.VectorSets.cs +++ b/src/StackExchange.Redis/ResultProcessor.VectorSets.cs @@ -1,6 +1,9 @@ -using Pipelines.Sockets.Unofficial.Arenas; +// ReSharper disable once CheckNamespace + +using System; +using RESPite; +using RESPite.Messages; -// ReSharper disable once CheckNamespace namespace StackExchange.Redis; internal abstract partial class ResultProcessor @@ -17,104 +20,128 @@ internal abstract partial class ResultProcessor private sealed class VectorSetLinksWithScoresProcessor : FlattenedLeaseProcessor { - protected override long GetArrayLength(in RawResult array) => array.GetItems().Length / 2; + protected override long GetArrayLength(in RespReader reader) => reader.AggregateLength() / 2; - protected override bool TryReadOne(ref Sequence.Enumerator reader, out VectorSetLink value) + protected override bool TryReadOne(ref RespReader reader, out VectorSetLink value) { - if (reader.MoveNext()) + if (!reader.IsScalar) { - ref readonly RawResult first = ref reader.Current; - if (reader.MoveNext() && reader.Current.TryGetDouble(out var score)) - { - value = new VectorSetLink(first.AsRedisValue(), score); - return true; - } + value = default; + return false; + } + + var member = reader.ReadRedisValue(); + if (!reader.TryMoveNext() || !reader.IsScalar || !reader.TryReadDouble(out var score)) + { + value = default; + return false; } - value = default; - return false; + value = new VectorSetLink(member, score); + return true; } } private sealed class VectorSetLinksProcessor : FlattenedLeaseProcessor { - protected override bool TryReadOne(in RawResult result, out RedisValue value) + protected override bool TryReadOne(ref RespReader reader, out RedisValue value) { - value = result.AsRedisValue(); + if (!reader.IsScalar) + { + value = default; + return false; + } + + value = reader.ReadRedisValue(); return true; } } private sealed class LeaseRedisValueProcessor : LeaseProcessor { - protected override bool TryParse(in RawResult raw, out RedisValue parsed) - { - parsed = raw.AsRedisValue(); - return true; - } + protected override RedisValue TryParse(ref RespReader reader) => reader.ReadRedisValue(); } private sealed partial class VectorSetInfoProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array) + if (!reader.IsAggregate) return false; + + if (reader.IsNull) { - if (result.IsNull) - { - SetResult(message, null); - return true; - } + SetResult(message, null); + return true; + } + + var quantType = VectorSetQuantization.Unknown; + string? quantTypeRaw = null; + int vectorDim = 0, maxLevel = 0; + long resultSize = 0, vsetUid = 0, hnswMaxNodeUid = 0; + + // Iterate through key-value pairs + while (reader.TryMoveNext()) + { + // Read key + if (!reader.IsScalar) break; - var quantType = VectorSetQuantization.Unknown; - string? quantTypeRaw = null; - int vectorDim = 0, maxLevel = 0; - long resultSize = 0, vsetUid = 0, hnswMaxNodeUid = 0; - var iter = result.GetItems().GetEnumerator(); - while (iter.MoveNext()) + VectorSetInfoField field; + unsafe { - if (!iter.Current.TryParse(VectorSetInfoFieldMetadata.TryParse, out VectorSetInfoField field)) + if (!reader.TryParseScalar(&VectorSetInfoFieldMetadata.TryParse, out field)) + { field = VectorSetInfoField.Unknown; + } + } - if (!iter.MoveNext()) break; - ref readonly RawResult value = ref iter.Current; + // Move to value + if (!reader.TryMoveNext()) break; + // Skip non-scalar values (future-proofing) + if (!reader.IsScalar) + { + reader.SkipChildren(); + continue; + } + + unsafe + { switch (field) { - case VectorSetInfoField.Size when value.TryGetInt64(out var i64): + case VectorSetInfoField.Size when reader.TryReadInt64(out var i64): resultSize = i64; break; - case VectorSetInfoField.VsetUid when value.TryGetInt64(out var i64): + case VectorSetInfoField.VsetUid when reader.TryReadInt64(out var i64): vsetUid = i64; break; - case VectorSetInfoField.MaxLevel when value.TryGetInt64(out var i64): + case VectorSetInfoField.MaxLevel when reader.TryReadInt64(out var i64): maxLevel = checked((int)i64); break; - case VectorSetInfoField.VectorDim when value.TryGetInt64(out var i64): + case VectorSetInfoField.VectorDim when reader.TryReadInt64(out var i64): vectorDim = checked((int)i64); break; case VectorSetInfoField.QuantType - when value.TryParse(VectorSetQuantizationMetadata.TryParse, out VectorSetQuantization quantTypeValue) - && quantTypeValue is not VectorSetQuantization.Unknown: + when reader.TryParseScalar( + &VectorSetQuantizationMetadata.TryParse, + out VectorSetQuantization quantTypeValue) + && quantTypeValue is not VectorSetQuantization.Unknown: quantType = quantTypeValue; break; case VectorSetInfoField.QuantType: - quantTypeRaw = value.GetString(); + quantTypeRaw = reader.ReadString(); quantType = VectorSetQuantization.Unknown; break; - case VectorSetInfoField.HnswMaxNodeUid when value.TryGetInt64(out var i64): + case VectorSetInfoField.HnswMaxNodeUid when reader.TryReadInt64(out var i64): hnswMaxNodeUid = i64; break; } } - - SetResult( - message, - new VectorSetInfo(quantType, quantTypeRaw, vectorDim, resultSize, maxLevel, vsetUid, hnswMaxNodeUid)); - return true; } - return false; + SetResult( + message, + new VectorSetInfo(quantType, quantTypeRaw, vectorDim, resultSize, maxLevel, vsetUid, hnswMaxNodeUid)); + return true; } } } diff --git a/src/StackExchange.Redis/ResultProcessor.cs b/src/StackExchange.Redis/ResultProcessor.cs index 8aa7281f3..55b502c40 100644 --- a/src/StackExchange.Redis/ResultProcessor.cs +++ b/src/StackExchange.Redis/ResultProcessor.cs @@ -2,7 +2,6 @@ using System.Buffers; using System.Collections.Generic; using System.Diagnostics; -using System.Diagnostics.CodeAnalysis; using System.IO; using System.Linq; using System.Net; @@ -10,7 +9,8 @@ using System.Text; using System.Text.RegularExpressions; using Microsoft.Extensions.Logging; -using Pipelines.Sockets.Unofficial.Arenas; +using RESPite; +using RESPite.Messages; namespace StackExchange.Redis { @@ -18,15 +18,15 @@ internal abstract partial class ResultProcessor { public static readonly ResultProcessor Boolean = new BooleanProcessor(), - DemandOK = new ExpectBasicStringProcessor(CommonReplies.OK), - DemandPONG = new ExpectBasicStringProcessor(CommonReplies.PONG), + DemandOK = new ExpectBasicStringProcessor(Literals.OK.Hash), + DemandPONG = new ExpectBasicStringProcessor(Literals.PONG.Hash), DemandZeroOrOne = new DemandZeroOrOneProcessor(), AutoConfigure = new AutoConfigureProcessor(), TrackSubscriptions = new TrackSubscriptionsProcessor(null), Tracer = new TracerProcessor(false), EstablishConnection = new TracerProcessor(true), - BackgroundSaveStarted = new ExpectBasicStringProcessor(CommonReplies.backgroundSavingStarted_trimmed, startsWith: true), - BackgroundSaveAOFStarted = new ExpectBasicStringProcessor(CommonReplies.backgroundSavingAOFStarted_trimmed, startsWith: true); + BackgroundSaveStarted = new ExpectBasicStringProcessor(Literals.background_saving_started.Hash, startsWith: true), + BackgroundSaveAOFStarted = new ExpectBasicStringProcessor(Literals.background_aof_rewriting_started.Hash, startsWith: true); public static readonly ResultProcessor ByteArray = new ByteArrayProcessor(); @@ -226,133 +226,153 @@ public static void SetException(Message? message, Exception ex) box?.SetException(ex); } // true if ready to be completed (i.e. false if re-issued to another server) - public virtual bool SetResult(PhysicalConnection connection, Message message, in RawResult result) + public virtual bool SetResult(PhysicalConnection connection, Message message, ref RespReader reader) { + reader.MovePastBof(); + connection.OnDetailLog($"(core result for {message.Command}, '{reader.GetOverview()}')"); var bridge = connection.BridgeCouldBeNull; if (message is LoggingMessage logging) { try { - logging.Log?.LogInformationResponse(bridge?.Name, message.CommandAndKey, result); + logging.Log?.LogInformationResponse(bridge?.Name, message.CommandAndKey, reader.GetOverview()); } - catch { } - } - if (result.IsError) - { - if (result.StartsWith(CommonReplies.NOAUTH)) - { - bridge?.Multiplexer.SetAuthSuspect(new RedisServerException("NOAUTH Returned - connection has not yet authenticated")); - } - else if (result.StartsWith(CommonReplies.WRONGPASS)) + catch (Exception ex) { - bridge?.Multiplexer.SetAuthSuspect(new RedisServerException(result.ToString())); + Debug.WriteLine(ex.Message); } + } + if (reader.IsError) + { + return HandleCommonError(message, reader, connection); + } - var server = bridge?.ServerEndPoint; - bool log = !message.IsInternalCall; - bool isMoved = result.StartsWith(CommonReplies.MOVED); - bool wasNoRedirect = (message.Flags & CommandFlags.NoRedirect) != 0; - string? err = string.Empty; - bool unableToConnectError = false; - if (isMoved || result.StartsWith(CommonReplies.ASK)) - { - message.SetResponseReceived(); + var copy = reader; + if (SetResultCore(connection, message, ref reader)) + { + bridge?.Multiplexer.Trace("Completed with success: " + copy.GetOverview() + " (" + GetType().Name + ")", ToString()); + } + else + { + UnexpectedResponse(message, in copy); + } + return true; + } - log = false; - string[] parts = result.GetString()!.Split(StringSplits.Space, 3); - if (Format.TryParseInt32(parts[1], out int hashSlot) - && Format.TryParseEndPoint(parts[2], out var endpoint)) + private bool HandleCommonError(Message message, RespReader reader, PhysicalConnection connection) + { + connection.OnDetailLog($"applying common error-handling: {reader.GetOverview()}"); + var bridge = connection.BridgeCouldBeNull; + if (reader.StartsWith(Literals.NOAUTH.U8)) + { + bridge?.Multiplexer.SetAuthSuspect(new RedisServerException("NOAUTH Returned - connection has not yet authenticated")); + } + else if (reader.StartsWith(Literals.WRONGPASS.U8)) + { + bridge?.Multiplexer.SetAuthSuspect(new RedisServerException(reader.GetOverview())); + } + + var server = bridge?.ServerEndPoint; + bool log = !message.IsInternalCall; + bool isMoved = reader.StartsWith(Literals.MOVED.U8); + bool wasNoRedirect = (message.Flags & CommandFlags.NoRedirect) != 0; + string? err = string.Empty; + bool unableToConnectError = false; + if (isMoved || reader.StartsWith(Literals.ASK.U8)) + { + connection.OnDetailLog($"redirect via {(isMoved ? "MOVED" : "ASK")} to '{reader.ReadString()}'"); + message.SetResponseReceived(); + + log = false; + string[] parts = reader.ReadString()!.Split(StringSplits.Space, 3); + if (Format.TryParseInt32(parts[1], out int hashSlot) + && Format.TryParseEndPoint(parts[2], out var endpoint)) + { + // Check if MOVED points to same endpoint + bool isSameEndpoint = Equals(server?.EndPoint, endpoint); + if (isSameEndpoint && isMoved) { - // Check if MOVED points to same endpoint - bool isSameEndpoint = Equals(server?.EndPoint, endpoint); - if (isSameEndpoint && isMoved) - { - // MOVED to same endpoint detected. - // This occurs when Redis/Valkey servers are behind DNS records, load balancers, or proxies. - // The MOVED error signals that the client should reconnect to allow the DNS/proxy/load balancer - // to route the connection to a different underlying server host, then retry the command. - // Mark the bridge to reconnect - reader loop will handle disconnection and reconnection. - bridge?.MarkNeedsReconnect(); - } - if (bridge is null) - { - // already toast - } - else if (bridge.Multiplexer.TryResend(hashSlot, message, endpoint, isMoved, isSameEndpoint)) + // MOVED to same endpoint detected. + // This occurs when Redis/Valkey servers are behind DNS records, load balancers, or proxies. + // The MOVED error signals that the client should reconnect to allow the DNS/proxy/load balancer + // to route the connection to a different underlying server host, then retry the command. + // Mark the bridge to reconnect - reader loop will handle disconnection and reconnection. + bridge?.MarkNeedsReconnect(); + } + if (bridge is null) + { + // already toast + connection.OnDetailLog($"no bridge for {message.Command}"); + } + else if (bridge.Multiplexer.TryResend(hashSlot, message, endpoint, isMoved, isSameEndpoint)) + { + connection.OnDetailLog($"re-issued to {Format.ToString(endpoint)}"); + bridge.Multiplexer.Trace(message.Command + " re-issued to " + endpoint, isMoved ? "MOVED" : "ASK"); + return false; + } + else + { + connection.OnDetailLog($"unable to re-issue {message.Command} to {Format.ToString(endpoint)}; treating as error"); + if (isMoved && wasNoRedirect) { - bridge.Multiplexer.Trace(message.Command + " re-issued to " + endpoint, isMoved ? "MOVED" : "ASK"); - return false; + if (bridge.Multiplexer.RawConfig.IncludeDetailInExceptions) + { + err = $"Key has MOVED to Endpoint {endpoint} and hashslot {hashSlot} but CommandFlags.NoRedirect was specified - redirect not followed for {message.CommandAndKey}. "; + } + else + { + err = "Key has MOVED but CommandFlags.NoRedirect was specified - redirect not followed. "; + } } else { - if (isMoved && wasNoRedirect) + unableToConnectError = true; + if (bridge.Multiplexer.RawConfig.IncludeDetailInExceptions) { - if (bridge.Multiplexer.RawConfig.IncludeDetailInExceptions) - { - err = $"Key has MOVED to Endpoint {endpoint} and hashslot {hashSlot} but CommandFlags.NoRedirect was specified - redirect not followed for {message.CommandAndKey}. "; - } - else - { - err = "Key has MOVED but CommandFlags.NoRedirect was specified - redirect not followed. "; - } + err = $"Endpoint {endpoint} serving hashslot {hashSlot} is not reachable at this point of time. Please check connectTimeout value. If it is low, try increasing it to give the ConnectionMultiplexer a chance to recover from the network disconnect. " + + PerfCounterHelper.GetThreadPoolAndCPUSummary(); } else { - unableToConnectError = true; - if (bridge.Multiplexer.RawConfig.IncludeDetailInExceptions) - { - err = $"Endpoint {endpoint} serving hashslot {hashSlot} is not reachable at this point of time. Please check connectTimeout value. If it is low, try increasing it to give the ConnectionMultiplexer a chance to recover from the network disconnect. " - + PerfCounterHelper.GetThreadPoolAndCPUSummary(); - } - else - { - err = "Endpoint is not reachable at this point of time. Please check connectTimeout value. If it is low, try increasing it to give the ConnectionMultiplexer a chance to recover from the network disconnect. "; - } + err = "Endpoint is not reachable at this point of time. Please check connectTimeout value. If it is low, try increasing it to give the ConnectionMultiplexer a chance to recover from the network disconnect. "; } } } } - - if (string.IsNullOrWhiteSpace(err)) - { - err = result.GetString()!; - } - - if (log && server != null) - { - bridge?.Multiplexer.OnErrorMessage(server.EndPoint, err); - } - bridge?.Multiplexer.Trace("Completed with error: " + err + " (" + GetType().Name + ")", ToString()); - if (unableToConnectError) - { - ConnectionFail(message, ConnectionFailureType.UnableToConnect, err); - } else { - ServerFail(message, err); + connection.OnDetailLog($"unable to parse redirect response"); } } + + if (string.IsNullOrWhiteSpace(err)) + { + err = reader.ReadString()!; + } + + if (log && server != null) + { + bridge?.Multiplexer.OnErrorMessage(server.EndPoint, err); + } + bridge?.Multiplexer.Trace("Completed with error: " + err + " (" + GetType().Name + ")", ToString()); + if (unableToConnectError) + { + ConnectionFail(message, ConnectionFailureType.UnableToConnect, err); + } else { - bool coreResult = SetResultCore(connection, message, result); - if (coreResult) - { - bridge?.Multiplexer.Trace("Completed with success: " + result.ToString() + " (" + GetType().Name + ")", ToString()); - } - else - { - UnexpectedResponse(message, result); - } + ServerFail(message, err); } + return true; } - protected abstract bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result); + protected abstract bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader); - private void UnexpectedResponse(Message message, in RawResult result) + private void UnexpectedResponse(Message message, in RespReader reader) { ConnectionMultiplexer.TraceWithoutContext("From " + GetType().Name, "Unexpected Response"); - ConnectionFail(message, ConnectionFailureType.ProtocolFailure, "Unexpected response to " + (message?.CommandString ?? "n/a") + ": " + result.ToString()); + ConnectionFail(message, ConnectionFailureType.ProtocolFailure, "Unexpected response to " + (message?.CommandString ?? "n/a") + ": " + reader.GetOverview()); } public sealed class TimeSpanProcessor : ResultProcessor @@ -363,43 +383,34 @@ public TimeSpanProcessor(bool isMilliseconds) this.isMilliseconds = isMilliseconds; } - public bool TryParse(in RawResult result, out TimeSpan? expiry) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.Integer: - if (result.TryGetInt64(out long time)) + if (reader.IsNull) + { + SetResult(message, null); + return true; + } + + if (reader.TryReadInt64(out long time)) + { + TimeSpan? expiry; + if (time < 0) { - if (time < 0) - { - expiry = null; - } - else if (isMilliseconds) - { - expiry = TimeSpan.FromMilliseconds(time); - } - else - { - expiry = TimeSpan.FromSeconds(time); - } - return true; + expiry = null; } - break; - // e.g. OBJECT IDLETIME on a key that doesn't exist - case ResultType.BulkString when result.IsNull: - expiry = null; + else if (isMilliseconds) + { + expiry = TimeSpan.FromMilliseconds(time); + } + else + { + expiry = TimeSpan.FromSeconds(time); + } + SetResult(message, expiry); return true; - } - expiry = null; - return false; - } - - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) - { - if (TryParse(result, out TimeSpan? expiry)) - { - SetResult(message, expiry); - return true; + } } return false; } @@ -412,30 +423,23 @@ public sealed class TimingProcessor : ResultProcessor public static TimerMessage CreateMessage(int db, CommandFlags flags, RedisCommand command, RedisValue value = default) => new TimerMessage(db, flags, command, value); - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.IsError) + // don't check the actual reply; there are multiple ways of constructing + // a timing message, and we don't actually care about what approach was used + TimeSpan duration; + if (message is TimerMessage timingMessage) { - return false; + var timestampDelta = Stopwatch.GetTimestamp() - timingMessage.StartedWritingTimestamp; + var ticks = (long)(TimestampToTicks * timestampDelta); + duration = new TimeSpan(ticks); } else { - // don't check the actual reply; there are multiple ways of constructing - // a timing message, and we don't actually care about what approach was used - TimeSpan duration; - if (message is TimerMessage timingMessage) - { - var timestampDelta = Stopwatch.GetTimestamp() - timingMessage.StartedWritingTimestamp; - var ticks = (long)(TimestampToTicks * timestampDelta); - duration = new TimeSpan(ticks); - } - else - { - duration = TimeSpan.MaxValue; - } - SetResult(message, duration); - return true; + duration = TimeSpan.MaxValue; } + SetResult(message, duration); + return true; } internal sealed class TimerMessage : Message @@ -448,17 +452,17 @@ public TimerMessage(int db, CommandFlags flags, RedisCommand command, RedisValue this.value = value; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { StartedWritingTimestamp = Stopwatch.GetTimestamp(); if (value.IsNull) { - physical.WriteHeader(command, 0); + writer.WriteHeader(command, 0); } else { - physical.WriteHeader(command, 1); - physical.WriteBulkString(value); + writer.WriteHeader(command, 1); + writer.WriteBulkString(value); } } public override int ArgCount => value.IsNull ? 0 : 1; @@ -470,32 +474,41 @@ public sealed class TrackSubscriptionsProcessor : ResultProcessor private ConnectionMultiplexer.Subscription? Subscription { get; } public TrackSubscriptionsProcessor(ConnectionMultiplexer.Subscription? sub) => Subscription = sub; - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array) + if (reader.IsAggregate) { - var items = result.GetItems(); - if (items.Length >= 3 && items[2].TryGetInt64(out long count)) + int length = reader.AggregateLength(); + if (length >= 3) { - connection.SubscriptionCount = count; - SetResult(message, true); + var iter = reader.AggregateChildren(); + // Skip first two elements + iter.DemandNext(); // [0] + iter.DemandNext(); // [1] + iter.DemandNext(); // [2] - the count - var ep = connection.BridgeCouldBeNull?.ServerEndPoint; - if (ep is not null) + if (iter.Value.TryReadInt64(out long count)) { - switch (message.Command) + connection.SubscriptionCount = count; + SetResult(message, true); + + var ep = connection.BridgeCouldBeNull?.ServerEndPoint; + if (ep is not null) { - case RedisCommand.SUBSCRIBE: - case RedisCommand.SSUBSCRIBE: - case RedisCommand.PSUBSCRIBE: - Subscription?.AddEndpoint(ep); - break; - default: - Subscription?.TryRemoveEndpoint(ep); - break; + switch (message.Command) + { + case RedisCommand.SUBSCRIBE: + case RedisCommand.SSUBSCRIBE: + case RedisCommand.PSUBSCRIBE: + Subscription?.AddEndpoint(ep); + break; + default: + Subscription?.TryRemoveEndpoint(ep); + break; + } } + return true; } - return true; } } SetResult(message, false); @@ -505,32 +518,30 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes internal sealed class DemandZeroOrOneProcessor : ResultProcessor { - public static bool TryGet(in RawResult result, out bool value) + public static bool TryGet(ref RespReader reader, out bool value) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar && reader.ScalarLengthIs(1)) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - if (result.IsEqual(CommonReplies.one)) - { - value = true; - return true; - } - else if (result.IsEqual(CommonReplies.zero)) - { - value = false; - return true; - } - break; + var span = reader.TryGetSpan(out var tmp) ? tmp : reader.Buffer(stackalloc byte[8]); + var byteValue = span[0]; + if (byteValue == (byte)'1') + { + value = true; + return true; + } + if (byteValue == (byte)'0') + { + value = false; + return true; + } } value = false; return false; } - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (TryGet(result, out bool value)) + if (TryGet(ref reader, out bool value)) { SetResult(message, value); return true; @@ -551,7 +562,7 @@ internal sealed class ScriptLoadProcessor : ResultProcessor internal static bool IsSHA1(string? script) => script is not null && script.Length == SHA1Length && sha1.IsMatch(script); internal const int Sha1HashLength = 20; - internal static byte[] ParseSHA1(byte[] value) + internal static byte[] ParseSHA1(ReadOnlySpan value) { static int FromHex(char c) { @@ -561,7 +572,7 @@ static int FromHex(char c) return -1; } - if (value?.Length == Sha1HashLength * 2) + if (value.Length == Sha1HashLength * 2) { var tmp = new byte[Sha1HashLength]; int charIndex = 0; @@ -581,24 +592,31 @@ static int FromHex(char c) // note that top-level error messages still get handled by SetResult, but nested errors // (is that a thing?) will be wrapped in the RedisResult - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + // We expect a scalar with exactly 40 ASCII hex characters (20 bytes when parsed) + if (reader.IsScalar && reader.ScalarLengthIs(Sha1HashLength * 2)) { - case ResultType.BulkString: - var asciiHash = result.GetBlob(); - if (asciiHash == null || asciiHash.Length != (Sha1HashLength * 2)) return false; + var asciiHash = reader.ReadByteArray()!; - // External caller wants the hex bytes, not the ASCII bytes - // For nullability/consistency reasons, we always do the parse here. - byte[] hash = ParseSHA1(asciiHash); + // External caller wants the hex bytes, not the ASCII bytes + // For nullability/consistency reasons, we always do the parse here. + byte[] hash; + try + { + hash = ParseSHA1(asciiHash); + } + catch (ArgumentException) + { + return false; // Invalid hex characters + } - if (message is RedisDatabase.ScriptLoadMessage sl) - { - connection.BridgeCouldBeNull?.ServerEndPoint?.AddScript(sl.Script, asciiHash); - } - SetResult(message, hash); - return true; + if (message is RedisDatabase.ScriptLoadMessage sl) + { + connection.BridgeCouldBeNull?.ServerEndPoint?.AddScript(sl.Script, asciiHash); + } + SetResult(message, hash); + return true; } return false; } @@ -606,59 +624,80 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes internal sealed class SortedSetEntryProcessor : ResultProcessor { - public static bool TryParse(in RawResult result, out SortedSetEntry? entry) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + // Handle array with at least 2 elements: [element, score, ...], or null/empty array + if (reader.IsAggregate) { - case ResultType.Array: - if (result.IsNull || result.ItemsCount < 2) - { - entry = null; - } - else + SortedSetEntry? result = null; + + // Note: null arrays report false for TryMoveNext, so no explicit null check needed + if (reader.TryMoveNext() && reader.IsScalar) + { + var element = reader.ReadRedisValue(); + if (reader.TryMoveNext() && reader.IsScalar) { - var arr = result.GetItems(); - entry = new SortedSetEntry(arr[0].AsRedisValue(), arr[1].TryGetDouble(out double val) ? val : double.NaN); + var score = reader.TryReadDouble(out var val) ? val : double.NaN; + result = new SortedSetEntry(element, score); } - return true; - default: - entry = null; - return false; - } - } + } - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) - { - if (TryParse(result, out SortedSetEntry? entry)) - { - SetResult(message, entry); + SetResult(message, result); return true; } + return false; } } internal sealed class SortedSetEntryArrayProcessor : ValuePairInterleavedProcessorBase { - protected override SortedSetEntry Parse(in RawResult first, in RawResult second, object? state) => - new SortedSetEntry(first.AsRedisValue(), second.TryGetDouble(out double val) ? val : double.NaN); + protected override SortedSetEntry Parse(ref RespReader first, ref RespReader second, object? state) => + new SortedSetEntry(first.ReadRedisValue(), second.TryReadDouble(out double val) ? val : double.NaN); } internal sealed class SortedSetPopResultProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array) + // Handle array of 2: [key, array of SortedSetEntry] or null aggregate + if (reader.IsAggregate) { - if (result.IsNull) + // Handle null (RESP3 pure null or RESP2 null array) + if (reader.IsNull) { SetResult(message, Redis.SortedSetPopResult.Null); return true; } - var arr = result.GetItems(); - SetResult(message, new SortedSetPopResult(arr[0].AsRedisKey(), arr[1].GetItemsAsSortedSetEntryArray()!)); - return true; + if (reader.TryMoveNext() && reader.IsScalar) + { + var key = reader.ReadRedisKey(); + + // Read the second element (array of SortedSetEntry) + if (reader.TryMoveNext() && reader.IsAggregate) + { + var entries = reader.ReadPastArray( + static (ref r) => + { + // Each entry is an array of 2: [element, score] + if (r.IsAggregate && r.TryMoveNext() && r.IsScalar) + { + var element = r.ReadRedisValue(); + if (r.TryMoveNext() && r.IsScalar) + { + var score = r.TryReadDouble(out var val) ? val : double.NaN; + return new SortedSetEntry(element, score); + } + } + return default; + }, + scalar: false); + + SetResult(message, new SortedSetPopResult(key, entries!)); + return true; + } + } } return false; @@ -667,19 +706,30 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes internal sealed class ListPopResultProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array) + // Handle array of 2: [key, array of values] or null aggregate + if (reader.IsAggregate) { - if (result.IsNull) + // Handle null (RESP3 pure null or RESP2 null array) + if (reader.IsNull) { SetResult(message, Redis.ListPopResult.Null); return true; } - var arr = result.GetItems(); - SetResult(message, new ListPopResult(arr[0].AsRedisKey(), arr[1].GetItemsAsValues()!)); - return true; + if (reader.TryMoveNext() && reader.IsScalar) + { + var key = reader.ReadRedisKey(); + + // Read the second element (array of RedisValue) + if (reader.TryMoveNext() && reader.IsAggregate) + { + var values = reader.ReadPastRedisValues(); + SetResult(message, new ListPopResult(key, values!)); + return true; + } + } } return false; @@ -688,8 +738,8 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes internal sealed class HashEntryArrayProcessor : ValuePairInterleavedProcessorBase { - protected override HashEntry Parse(in RawResult first, in RawResult second, object? state) => - new HashEntry(first.AsRedisValue(), second.AsRedisValue()); + protected override HashEntry Parse(ref RespReader first, ref RespReader second, object? state) => + new HashEntry(first.ReadRedisValue(), second.ReadRedisValue()); } internal abstract class ValuePairInterleavedProcessorBase : ResultProcessor @@ -699,123 +749,97 @@ internal abstract class ValuePairInterleavedProcessorBase : ResultProcessor result.IsResp3; + protected virtual bool AllowJaggedPairs(RedisProtocol protocol) => protocol >= RedisProtocol.Resp3; - public bool TryParse(in RawResult result, out T[]? pairs) - => TryParse(result, out pairs, false, out _); + private static bool IsAllJaggedPairsReader(in RespReader reader) + { + // Check whether each child element is an array of exactly length 2 + // Use AggregateChildren to create isolated child iterators without mutating the reader + var iter = reader.AggregateChildren(); + while (iter.MoveNext()) + { + // Check if this child is an array with exactly 2 elements + if (!(iter.Value.IsAggregate && iter.Value.AggregateLengthIs(2))) + { + return false; + } + } + return true; + } - public T[]? ParseArray(in RawResult result, bool allowOversized, out int count, object? state) + public T[]? ParseArray(ref RespReader reader, RedisProtocol protocol, bool allowOversized, out int count, object? state) { - if (result.IsNull) + if (reader.IsNull) { count = 0; return null; } - var arr = result.GetItems(); - count = (int)arr.Length; + // Get the aggregate length first + count = reader.AggregateLength(); if (count == 0) { return []; } - bool interleaved = !(AllowJaggedPairs(result) && IsAllJaggedPairs(arr)); - if (interleaved) count >>= 1; // so: half of that - var pairs = allowOversized ? ArrayPool.Shared.Rent(count) : new T[count]; + // Check if we have jagged pairs (RESP3 style) or interleaved (RESP2 style) + bool isJagged = AllowJaggedPairs(protocol) && IsAllJaggedPairsReader(reader); - if (interleaved) + if (isJagged) { - // linear elements i.e. {key,value,key,value,key,value} - if (arr.IsSingleSegment) - { - var span = arr.FirstSpan; - int offset = 0; - for (int i = 0; i < count; i++) - { - pairs[i] = Parse(span[offset++], span[offset++], state); - } - } - else + // Jagged format: [[k1, v1], [k2, v2], ...] + // Count is the number of pairs (outer array length) + var pairs = allowOversized ? ArrayPool.Shared.Rent(count) : new T[count]; + var iter = reader.AggregateChildren(); + for (int i = 0; i < count; i++) { - var iter = arr.GetEnumerator(); // simplest way of getting successive values - for (int i = 0; i < count; i++) - { - pairs[i] = Parse(iter.GetNext(), iter.GetNext(), state); - } + iter.DemandNext(); + + var pairIter = iter.Value.AggregateChildren(); + pairIter.DemandNext(); + var first = pairIter.Value; + + pairIter.DemandNext(); + var second = pairIter.Value; + + pairs[i] = Parse(ref first, ref second, state); } + return pairs; } else { - // jagged elements i.e. {{key,value},{key,value},{key,value}} - // to get here, we've already asserted that all elements are arrays with length 2 - if (arr.IsSingleSegment) - { - int i = 0; - foreach (var el in arr.FirstSpan) - { - var inner = el.GetItems(); - pairs[i++] = Parse(inner[0], inner[1], state); - } - } - else + // Interleaved format: [k1, v1, k2, v2, ...] + // Count is half the array length (>> 1 discards odd element if present) + count >>= 1; // divide by 2 + var pairs = allowOversized ? ArrayPool.Shared.Rent(count) : new T[count]; + var iter = reader.AggregateChildren(); + + for (int i = 0; i < count; i++) { - var iter = arr.GetEnumerator(); // simplest way of getting successive values - for (int i = 0; i < count; i++) - { - var inner = iter.GetNext().GetItems(); - pairs[i] = Parse(inner[0], inner[1], state); - } - } - } - return pairs; + iter.DemandNext(); + var first = iter.Value; - static bool IsAllJaggedPairs(in Sequence arr) - { - return arr.IsSingleSegment ? CheckSpan(arr.FirstSpan) : CheckSpans(arr); + iter.DemandNext(); + var second = iter.Value; - static bool CheckSpans(in Sequence arr) - { - foreach (var chunk in arr.Spans) - { - if (!CheckSpan(chunk)) return false; - } - return true; - } - static bool CheckSpan(ReadOnlySpan chunk) - { - // check whether each value is actually an array of length 2 - foreach (ref readonly RawResult el in chunk) - { - if (el is not { Resp2TypeArray: ResultType.Array, ItemsCount: 2 }) return false; - } - return true; + pairs[i] = Parse(ref first, ref second, state); } + return pairs; } } - public bool TryParse(in RawResult result, out T[]? pairs, bool allowOversized, out int count) - { - switch (result.Resp2TypeArray) - { - case ResultType.Array: - pairs = ParseArray(in result, allowOversized, out count, null); - return true; - default: - count = 0; - pairs = null; - return false; - } - } + protected abstract T Parse(ref RespReader first, ref RespReader second, object? state); - protected abstract T Parse(in RawResult first, in RawResult second, object? state); - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (TryParse(result, out T[]? arr)) + if (!reader.IsAggregate) { - SetResult(message, arr!); - return true; + return false; } - return false; + + var pairs = ParseArray(ref reader, connection.Protocol.GetValueOrDefault(), false, out _, null); + SetResult(message, pairs!); + return true; } } @@ -824,9 +848,11 @@ internal sealed class AutoConfigureProcessor : ResultProcessor private ILogger? Log { get; } public AutoConfigureProcessor(ILogger? log = null) => Log = log; - public override bool SetResult(PhysicalConnection connection, Message message, in RawResult result) + public override bool SetResult(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.IsError && result.StartsWith(CommonReplies.READONLY)) + var copy = reader; + reader.MovePastBof(); + if (reader.IsError && reader.StartsWith(Literals.READONLY.U8)) { var bridge = connection.BridgeCouldBeNull; if (bridge != null) @@ -837,228 +863,264 @@ public override bool SetResult(PhysicalConnection connection, Message message, i } } - return base.SetResult(connection, message, result); + return base.SetResult(connection, message, ref copy); } - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { var server = connection.BridgeCouldBeNull?.ServerEndPoint; if (server == null) return false; - switch (result.Resp2TypeBulkString) + // Handle CLIENT command (returns integer client ID) + if (message?.Command == RedisCommand.CLIENT && reader.Prefix == RespPrefix.Integer) { - case ResultType.Integer: - if (message?.Command == RedisCommand.CLIENT) + if (reader.TryReadInt64(out long clientId)) + { + connection.ConnectionId = clientId; + Log?.LogInformationAutoConfiguredClientConnectionId(new(server), clientId); + SetResult(message, true); + return true; + } + return false; + } + + // Handle INFO command (returns bulk string) + if (message?.Command == RedisCommand.INFO && reader.IsScalar) + { + string? info = reader.ReadString(); + if (string.IsNullOrWhiteSpace(info)) + { + SetResult(message, true); + return true; + } + string? primaryHost = null, primaryPort = null; + bool roleSeen = false; + ProductVariant productVariant = ProductVariant.Redis; + string productVersion = ""; + + using (var infoReader = new StringReader(info)) + { + while (infoReader.ReadLine() is { } line) { - if (result.TryGetInt64(out long clientId)) + if (string.IsNullOrWhiteSpace(line) || line.StartsWith("# ")) { - connection.ConnectionId = clientId; - Log?.LogInformationAutoConfiguredClientConnectionId(new(server), clientId); - - SetResult(message, true); - return true; + continue; } - } - break; - case ResultType.BulkString: - if (message?.Command == RedisCommand.INFO) - { - string? info = result.GetString(); - if (string.IsNullOrWhiteSpace(info)) + + var idx = line.IndexOf(':'); + if (idx < 0) continue; + + if (!AutoConfigureInfoFieldMetadata.TryParse(line.AsSpan(0, idx), out AutoConfigureInfoField field)) { - SetResult(message, true); - return true; + continue; } - string? primaryHost = null, primaryPort = null; - bool roleSeen = false; - ProductVariant productVariant = ProductVariant.Redis; - string productVersion = ""; + var valSpan = line.AsSpan(idx + 1).Trim(); - using (var reader = new StringReader(info)) + switch (field) { - while (reader.ReadLine() is string line) - { - if (string.IsNullOrWhiteSpace(line) || line.StartsWith("# ")) + case AutoConfigureInfoField.Role: + roleSeen = true; + if (KnownRoleMetadata.TryParse(valSpan, out bool isReplica)) { - continue; + server.IsReplica = isReplica; + Log?.LogInformationAutoConfiguredInfoRole(new(server), isReplica ? "replica" : "primary"); } - - var idx = line.IndexOf(':'); - if (idx < 0) continue; - - if (!AutoConfigureInfoFieldMetadata.TryParse(line.AsSpan(0, idx), out AutoConfigureInfoField field)) + break; + case AutoConfigureInfoField.MasterHost: + primaryHost = valSpan.ToString(); + break; + case AutoConfigureInfoField.MasterPort: + primaryPort = valSpan.ToString(); + break; + case AutoConfigureInfoField.RedisVersion: + if (Format.TryParseVersion(valSpan, out Version? version)) { - continue; + server.Version = version; + Log?.LogInformationAutoConfiguredInfoVersion(new(server), version); } - var valSpan = line.AsSpan(idx + 1).Trim(); - - switch (field) + if (productVariant is ProductVariant.Redis) { - case AutoConfigureInfoField.Role: - roleSeen = true; - if (KnownRoleMetadata.TryParse(valSpan, out bool isReplica)) - { - server.IsReplica = isReplica; - Log?.LogInformationAutoConfiguredInfoRole(new(server), isReplica ? "replica" : "primary"); - } - break; - case AutoConfigureInfoField.MasterHost: - primaryHost = valSpan.ToString(); - break; - case AutoConfigureInfoField.MasterPort: - primaryPort = valSpan.ToString(); - break; - case AutoConfigureInfoField.RedisVersion: - if (Format.TryParseVersion(valSpan, out Version? version)) - { - server.Version = version; - Log?.LogInformationAutoConfiguredInfoVersion(new(server), version); - } - if (productVariant is ProductVariant.Redis) - { - // if we haven't already decided this is Garnet/Valkey, etc: capture the version string. - productVersion = valSpan.ToString(); - } - break; - case AutoConfigureInfoField.RedisMode: - case AutoConfigureInfoField.ServerMode: - if (ServerTypeMetadata.TryParse(valSpan, out var serverType)) - { - server.ServerType = serverType; - Log?.LogInformationAutoConfiguredInfoServerType(new(server), serverType); - } - break; - case AutoConfigureInfoField.RunId: - server.RunId = valSpan.ToString(); - break; - case AutoConfigureInfoField.GarnetVersion: - productVariant = ProductVariant.Garnet; - productVersion = valSpan.ToString(); - break; - case AutoConfigureInfoField.ValkeyVersion: - productVariant = ProductVariant.Valkey; - productVersion = valSpan.ToString(); - break; + // if we haven't already decided this is Garnet/Valkey, etc: capture the version string. + productVersion = valSpan.ToString(); } - } - if (roleSeen && Format.TryParseEndPoint(primaryHost!, primaryPort, out var sep)) - { - // These are in the same section, if present - server.PrimaryEndPoint = sep; - } - } - - // Set the product variant and version (this is deferred because there can be - // both redis_version:6.1.2 and whatever_version:12.3.4, in any order). - if (!string.IsNullOrWhiteSpace(productVersion)) - { - server.SetProductVariant(productVariant, productVersion); + break; + case AutoConfigureInfoField.RedisMode: + case AutoConfigureInfoField.ServerMode: + if (ServerTypeMetadata.TryParse(valSpan, out var serverType)) + { + server.ServerType = serverType; + Log?.LogInformationAutoConfiguredInfoServerType(new(server), serverType); + } + break; + case AutoConfigureInfoField.RunId: + server.RunId = valSpan.ToString(); + break; + case AutoConfigureInfoField.GarnetVersion: + productVariant = ProductVariant.Garnet; + productVersion = valSpan.ToString(); + break; + case AutoConfigureInfoField.ValkeyVersion: + productVariant = ProductVariant.Valkey; + productVersion = valSpan.ToString(); + break; } } - else if (message?.Command == RedisCommand.SENTINEL) + if (roleSeen && Format.TryParseEndPoint(primaryHost!, primaryPort, out var sep)) { - server.ServerType = ServerType.Sentinel; - Log?.LogInformationAutoConfiguredSentinelServerType(new(server)); + // These are in the same section, if present + server.PrimaryEndPoint = sep; } - SetResult(message, true); - return true; - case ResultType.Array: - if (message?.Command == RedisCommand.CONFIG) + } + + // Set the product variant and version (this is deferred because there can be + // both redis_version:6.1.2 and whatever_version:12.3.4, in any order). + if (!string.IsNullOrWhiteSpace(productVersion)) + { + server.SetProductVariant(productVariant, productVersion); + } + } + + // Handle SENTINEL command (returns bulk string) + if (message?.Command == RedisCommand.SENTINEL && reader.IsScalar) + { + server.ServerType = ServerType.Sentinel; + Log?.LogInformationAutoConfiguredSentinelServerType(new(server)); + SetResult(message, true); + return true; + } + + // Handle CONFIG command (returns array of key-value pairs) + if (message?.Command == RedisCommand.CONFIG && reader.IsAggregate) + { + // ReSharper disable once HeuristicUnreachableCode - this is a compile-time Max(...) + var iter = reader.AggregateChildren(); + while (iter.MoveNext()) + { + var key = iter.Value; + ConfigField field; + unsafe { - var iter = result.GetItems().GetEnumerator(); - while (iter.MoveNext()) + if (!key.TryParseScalar(&ConfigFieldMetadata.TryParse, out field)) { - ref RawResult key = ref iter.Current; - if (!iter.MoveNext()) break; - ref RawResult val = ref iter.Current; + field = ConfigField.Unknown; + } + } - if (key.IsEqual(CommonReplies.timeout) && val.TryGetInt64(out long i64)) + if (!iter.MoveNext()) break; + var val = iter.Value; + + switch (field) + { + case ConfigField.Timeout when val.TryReadInt64(out long i64): + // note the configuration is in seconds + int timeoutSeconds = checked((int)i64), targetSeconds; + if (timeoutSeconds > 0) { - // note the configuration is in seconds - int timeoutSeconds = checked((int)i64), targetSeconds; - if (timeoutSeconds > 0) + if (timeoutSeconds >= 60) { - if (timeoutSeconds >= 60) - { - targetSeconds = timeoutSeconds - 20; // time to spare... - } - else - { - targetSeconds = (timeoutSeconds * 3) / 4; - } - Log?.LogInformationAutoConfiguredConfigTimeout(new(server), targetSeconds); - server.WriteEverySeconds = targetSeconds; + targetSeconds = timeoutSeconds - 20; // time to spare... } - } - else if (key.IsEqual(CommonReplies.databases) && val.TryGetInt64(out i64)) - { - int dbCount = checked((int)i64); - Log?.LogInformationAutoConfiguredConfigDatabases(new(server), dbCount); - server.Databases = dbCount; - if (dbCount > 1) + else { - connection.MultiDatabasesOverride = true; + targetSeconds = (timeoutSeconds * 3) / 4; } + Log?.LogInformationAutoConfiguredConfigTimeout(new(server), targetSeconds); + server.WriteEverySeconds = targetSeconds; } - else if (key.IsEqual(CommonReplies.slave_read_only) || key.IsEqual(CommonReplies.replica_read_only)) + break; + case ConfigField.Databases when val.TryReadInt64(out long dbI64): + int dbCount = checked((int)dbI64); + Log?.LogInformationAutoConfiguredConfigDatabases(new(server), dbCount); + server.Databases = dbCount; + if (dbCount > 1) { - if (val.IsEqual(CommonReplies.yes)) - { - server.ReplicaReadOnly = true; - Log?.LogInformationAutoConfiguredConfigReadOnlyReplica(new(server), true); - } - else if (val.IsEqual(CommonReplies.no)) + connection.MultiDatabasesOverride = true; + } + break; + case ConfigField.SlaveReadOnly: + case ConfigField.ReplicaReadOnly: + YesNo yesNo; + unsafe + { + if (val.TryParseScalar(&YesNoMetadata.TryParse, out yesNo)) { - server.ReplicaReadOnly = false; - Log?.LogInformationAutoConfiguredConfigReadOnlyReplica(new(server), false); + switch (yesNo) + { + case YesNo.Yes: + server.ReplicaReadOnly = true; + Log?.LogInformationAutoConfiguredConfigReadOnlyReplica( + new(server), + true); + break; + case YesNo.No: + server.ReplicaReadOnly = false; + Log?.LogInformationAutoConfiguredConfigReadOnlyReplica( + new(server), + false); + break; + } } } - } + + break; } - else if (message?.Command == RedisCommand.HELLO) + } + SetResult(message, true); + return true; + } + + // Handle HELLO command (returns array/map of key-value pairs) + if (message?.Command == RedisCommand.HELLO && reader.IsAggregate) + { + var iter = reader.AggregateChildren(); + while (iter.MoveNext()) + { + HelloField field; + unsafe { - var iter = result.GetItems().GetEnumerator(); - while (iter.MoveNext()) + if (!iter.Value.TryParseScalar(&HelloFieldMetadata.TryParse, out field)) { - ref RawResult key = ref iter.Current; - if (!iter.MoveNext()) break; - ref RawResult val = ref iter.Current; + field = HelloField.Unknown; + } - if (key.IsEqual(CommonReplies.version) && Format.TryParseVersion(val.GetString(), out var version)) - { + if (!iter.MoveNext()) break; + + switch (field) + { + case HelloField.Version when iter.Value.TryParseScalar(Format.TryParseVersion!, out Version version): server.Version = version; Log?.LogInformationAutoConfiguredHelloServerVersion(new(server), version); - } - else if (key.IsEqual(CommonReplies.proto) && val.TryGetInt64(out var i64)) - { + break; + case HelloField.Proto when iter.Value.TryReadInt64(out var i64): connection.SetProtocol(i64 >= 3 ? RedisProtocol.Resp3 : RedisProtocol.Resp2); - Log?.LogInformationAutoConfiguredHelloProtocol(new(server), connection.Protocol ?? RedisProtocol.Resp2); - } - else if (key.IsEqual(CommonReplies.id) && val.TryGetInt64(out i64)) - { + Log?.LogInformationAutoConfiguredHelloProtocol( + new(server), + connection.Protocol ?? RedisProtocol.Resp2); + break; + case HelloField.Id when iter.Value.TryReadInt64(out var i64): connection.ConnectionId = i64; Log?.LogInformationAutoConfiguredHelloConnectionId(new(server), i64); - } - else if (key.IsEqual(CommonReplies.mode) && ServerTypeMetadata.TryParse(val.GetString(), out var serverType)) - { + break; + case HelloField.Mode + when iter.Value.TryParseScalar(&ServerTypeMetadata.TryParse, out ServerType serverType): server.ServerType = serverType; Log?.LogInformationAutoConfiguredHelloServerType(new(server), serverType); - } - else if (key.IsEqual(CommonReplies.role) && KnownRoleMetadata.TryParse(val.GetString(), out bool isReplica)) - { + break; + case HelloField.Role + when iter.Value.TryParseScalar(&KnownRoleMetadata.TryParse, out bool isReplica): server.IsReplica = isReplica; - Log?.LogInformationAutoConfiguredHelloRole(new(server), isReplica ? "replica" : "primary"); - } + Log?.LogInformationAutoConfiguredHelloRole( + new(server), + isReplica ? "replica" : "primary"); + break; } } - else if (message?.Command == RedisCommand.SENTINEL) - { - server.ServerType = ServerType.Sentinel; - Log?.LogInformationAutoConfiguredSentinelServerType(new(server)); - } - SetResult(message, true); - return true; + } + + SetResult(message, true); + return true; } + return false; } @@ -1067,51 +1129,43 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class BooleanProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.IsNull) + if (reader.IsNull) { SetResult(message, false); // lots of ops return (nil) when they mean "no" return true; } - switch (result.Resp2TypeBulkString) + + if (reader.IsScalar) { - case ResultType.SimpleString: - if (result.IsEqual(CommonReplies.OK)) - { - SetResult(message, true); - } - else - { - SetResult(message, result.GetBoolean()); - } - return true; - case ResultType.Integer: - case ResultType.BulkString: - SetResult(message, result.GetBoolean()); + SetResult(message, reader.ReadBoolean()); + return true; + } + + if (reader.IsAggregate && reader.TryMoveNext() && reader.IsScalar) + { + // treat an array of 1 like a single reply (for example, SCRIPT EXISTS) + var value = reader.ReadBoolean(); + if (!reader.TryMoveNext()) + { + SetResult(message, value); return true; - case ResultType.Array: - var items = result.GetItems(); - if (items.Length == 1) - { // treat an array of 1 like a single reply (for example, SCRIPT EXISTS) - SetResult(message, items[0].GetBoolean()); - return true; - } - break; + } } + return false; } } private sealed class ByteArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.BulkString: - SetResult(message, result.GetBlob()); - return true; + SetResult(message, reader.ReadByteArray()); + return true; } return false; } @@ -1128,12 +1182,13 @@ internal static ClusterConfiguration Parse(PhysicalConnection connection, string return config; } - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.BulkString: - string nodes = result.GetString()!; + string? nodes = reader.ReadString(); + if (nodes is not null) + { var bridge = connection.BridgeCouldBeNull; var config = Parse(connection, nodes); @@ -1144,6 +1199,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes } SetResult(message, config); return true; + } } return false; } @@ -1151,24 +1207,24 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class ClusterNodesRawProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - string nodes = result.GetString()!; - try - { - ClusterNodesProcessor.Parse(connection, nodes); - } - catch + var nodes = reader.ReadString(); + try + { + if (!string.IsNullOrWhiteSpace(nodes)) { - /* tralalalala */ + ClusterNodesProcessor.Parse(connection, nodes!); } - SetResult(message, nodes); - return true; + } + catch + { + /* tralalalala */ + } + SetResult(message, nodes); + return true; } return false; } @@ -1176,55 +1232,49 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class ConnectionIdentityProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (connection.BridgeCouldBeNull is PhysicalBridge bridge) - { - SetResult(message, bridge.ServerEndPoint.EndPoint); - return true; - } - return false; + SetResult(message, connection.BridgeCouldBeNull?.ServerEndPoint.EndPoint!); + return true; } } private sealed class DateTimeProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - long unixTime; - switch (result.Resp2TypeArray) + // Handle scalar integer (seconds since Unix epoch) + if (reader.IsScalar && reader.TryReadInt64(out long unixTime)) { - case ResultType.Integer: - if (result.TryGetInt64(out unixTime)) + var time = RedisBase.UnixEpoch.AddSeconds(unixTime); + SetResult(message, time); + return true; + } + + // Handle array (TIME command returns [seconds, microseconds]) + if (reader.IsAggregate && reader.TryMoveNext() && reader.IsScalar) + { + if (reader.TryReadInt64(out unixTime)) + { + // Check if there's a second element (microseconds) + if (!reader.TryMoveNext()) { + // Array of 1: just seconds var time = RedisBase.UnixEpoch.AddSeconds(unixTime); SetResult(message, time); return true; } - break; - case ResultType.Array: - var arr = result.GetItems(); - switch (arr.Length) + + // Array of 2: seconds + microseconds - verify no third element + if (reader.IsScalar && reader.TryReadInt64(out long micros) && !reader.TryMoveNext()) { - case 1: - if (arr.FirstSpan[0].TryGetInt64(out unixTime)) - { - var time = RedisBase.UnixEpoch.AddSeconds(unixTime); - SetResult(message, time); - return true; - } - break; - case 2: - if (arr[0].TryGetInt64(out unixTime) && arr[1].TryGetInt64(out long micros)) - { - var time = RedisBase.UnixEpoch.AddSeconds(unixTime).AddTicks(micros * 10); // DateTime ticks are 100ns - SetResult(message, time); - return true; - } - break; + var time = RedisBase.UnixEpoch.AddSeconds(unixTime).AddTicks(micros * 10); // DateTime ticks are 100ns + SetResult(message, time); + return true; } - break; + } } + return false; } } @@ -1234,11 +1284,20 @@ public sealed class NullableDateTimeProcessor : ResultProcessor private readonly bool isMilliseconds; public NullableDateTimeProcessor(bool fromMilliseconds) => isMilliseconds = fromMilliseconds; - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.Integer when result.TryGetInt64(out var duration): + // Handle null (e.g., OBJECT IDLETIME on a key that doesn't exist) + if (reader.IsNull) + { + SetResult(message, null); + return true; + } + + // Handle integer (TTL/PTTL/EXPIRETIME commands) + if (reader.TryReadInt64(out var duration)) + { DateTime? expiry = duration switch { // -1 means no expiry and -2 means key does not exist @@ -1248,36 +1307,26 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes }; SetResult(message, expiry); return true; - - case ResultType.BulkString when result.IsNull: - SetResult(message, null); - return true; + } } + return false; } } private sealed class DoubleProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.Prefix is RespPrefix.Integer && reader.TryReadInt64(out long i64)) { - case ResultType.Integer: - if (result.TryGetInt64(out long i64)) - { - SetResult(message, i64); - return true; - } - break; - case ResultType.SimpleString: - case ResultType.BulkString: - if (result.TryGetDouble(out double val)) - { - SetResult(message, val); - return true; - } - break; + SetResult(message, i64); + return true; + } + if (reader.IsScalar && reader.TryReadDouble(out double val)) + { + SetResult(message, val); + return true; } return false; } @@ -1285,21 +1334,38 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class ExpectBasicStringProcessor : ResultProcessor { - private readonly CommandBytes _expected; + private readonly AsciiHash _expected; private readonly bool _startsWith; - public ExpectBasicStringProcessor(CommandBytes expected, bool startsWith = false) + + public ExpectBasicStringProcessor(in AsciiHash expected, bool startsWith = false) { _expected = expected; _startsWith = startsWith; } - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (_startsWith ? result.StartsWith(_expected) : result.IsEqual(_expected)) + if (!reader.IsScalar) return false; + + var expectedLength = _expected.Length; + // For exact match, length must be exact + if (_startsWith) + { + if (reader.ScalarLength() < expectedLength) return false; + } + else + { + if (!reader.ScalarLengthIs(expectedLength)) return false; + } + + var bytes = reader.TryGetSpan(out var tmp) ? tmp : reader.Buffer(stackalloc byte[_expected.BufferLength]); + if (_startsWith) bytes = bytes.Slice(0, expectedLength); + if (_expected.IsCS(bytes)) { SetResult(message, true); return true; } + if (message.Command == RedisCommand.AUTH) connection?.BridgeCouldBeNull?.Multiplexer?.SetAuthSuspect(new RedisException("Unknown AUTH exception")); return false; } @@ -1307,17 +1373,16 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class InfoProcessor : ResultProcessor>[]> { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeBulkString == ResultType.BulkString) + if (reader.IsScalar) { string category = Normalize(null); var list = new List>>(); - var raw = result.GetString(); - if (raw is not null) + if (!reader.IsNull) { - using var reader = new StringReader(raw); - while (reader.ReadLine() is string line) + using var stringReader = new StringReader(reader.ReadString()!); + while (stringReader.ReadLine() is string line) { if (string.IsNullOrWhiteSpace(line)) continue; if (line.StartsWith("# ")) @@ -1344,20 +1409,20 @@ private static string Normalize(string? category) => category.IsNullOrWhiteSpace() ? "miscellaneous" : category.Trim(); } - private sealed class Int64DefaultValueProcessor : ResultProcessor + internal sealed class Int64DefaultValueProcessor : ResultProcessor { private readonly long _defaultValue; public Int64DefaultValueProcessor(long defaultValue) => _defaultValue = defaultValue; - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.IsNull) + if (reader.IsNull) { SetResult(message, _defaultValue); return true; } - if (result.Resp2TypeBulkString == ResultType.Integer && result.TryGetInt64(out var i64)) + if (reader.IsScalar && reader.TryReadInt64(out var i64)) { SetResult(message, i64); return true; @@ -1368,19 +1433,12 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private class Int64Processor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar && reader.TryReadInt64(out long i64)) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - if (result.TryGetInt64(out long i64)) - { - SetResult(message, i64); - return true; - } - break; + SetResult(message, i64); + return true; } return false; } @@ -1388,19 +1446,12 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private class Int32Processor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar && reader.TryReadInt64(out long i64)) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - if (result.TryGetInt64(out long i64)) - { - SetResult(message, checked((int)i64)); - return true; - } - break; + SetResult(message, checked((int)i64)); + return true; } return false; } @@ -1417,32 +1468,28 @@ private sealed class Int32EnumProcessor : ResultProcessor where T : unmana private Int32EnumProcessor() { } public static readonly Int32EnumProcessor Instance = new(); - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + // Accept integer, simple string, bulk string, or unit array + long i64; + if (reader.IsScalar && reader.TryReadInt64(out i64)) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - if (result.TryGetInt64(out long i64)) - { - Debug.Assert(Unsafe.SizeOf() == sizeof(int)); - int i32 = (int)i64; - SetResult(message, Unsafe.As(ref i32)); - return true; - } - break; - case ResultType.Array when result.ItemsCount == 1: // pick a single element from a unit vector - if (result.GetItems()[0].TryGetInt64(out i64)) - { - Debug.Assert(Unsafe.SizeOf() == sizeof(int)); - int i32 = (int)i64; - SetResult(message, Unsafe.As(ref i32)); - return true; - } - break; + // Direct scalar read } - return false; + else if (reader.IsAggregate && reader.AggregateLengthIs(1) + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out i64)) + { + // Unit array - read the single element + } + else + { + return false; + } + + Debug.Assert(Unsafe.SizeOf() == sizeof(int)); + int i32 = (int)i64; + SetResult(message, Unsafe.As(ref i32)); + return true; } } @@ -1451,57 +1498,56 @@ private sealed class Int32EnumArrayProcessor : ResultProcessor where T : private Int32EnumArrayProcessor() { } public static readonly Int32EnumArrayProcessor Instance = new(); - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) - { - case ResultType.Array: - T[] arr; - if (result.IsNull) - { - arr = null!; - } - else - { - Debug.Assert(Unsafe.SizeOf() == sizeof(int)); - arr = result.ToArray(static (in RawResult x) => - { - int i32 = (int)x.AsRedisValue(); - return Unsafe.As(ref i32); - })!; - } - SetResult(message, arr); - return true; - } - return false; + if (!reader.IsAggregate) return false; + + Debug.Assert(Unsafe.SizeOf() == sizeof(int)); + var arr = reader.ReadPastArray( + static (ref r) => + { + int i32 = (int)r.ReadInt64(); + return Unsafe.As(ref i32); + }, + scalar: true); + + SetResult(message, arr!); + return true; } } - private sealed class PubSubNumSubProcessor : Int64Processor + private sealed class PubSubNumSubProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array) + if (reader.IsAggregate // name/count pairs + && reader.TryMoveNext() && reader.IsScalar // name, ignored + && reader.TryMoveNext() && reader.IsScalar // count + && reader.TryReadInt64(out long val) // parse the count + && !reader.TryMoveNext()) // no more elements { - var arr = result.GetItems(); - if (arr.Length == 2 && arr[1].TryGetInt64(out long val)) - { - SetResult(message, val); - return true; - } + SetResult(message, val); + return true; } - return base.SetResultCore(connection, message, result); + + return false; } } private sealed class NullableDoubleArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array && !result.IsNull) + if (reader.IsAggregate) { - var arr = result.GetItemsAsDoubles()!; - SetResult(message, arr); + var arr = reader.ReadPastArray( + static (ref r) => + { + if (r.IsNull) return (double?)null; + return r.TryReadDouble(out var val) ? val : null; + }, + scalar: true); + SetResult(message, arr!); return true; } return false; @@ -1510,24 +1556,20 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class NullableDoubleProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - if (result.IsNull) - { - SetResult(message, null); - return true; - } - if (result.TryGetDouble(out double val)) - { - SetResult(message, val); - return true; - } - break; + if (reader.IsNull) + { + SetResult(message, null); + return true; + } + if (reader.TryReadDouble(out double val)) + { + SetResult(message, val); + return true; + } } return false; } @@ -1535,35 +1577,40 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class NullableInt64Processor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) + { + if (reader.IsNull) + { + SetResult(message, null); + return true; + } + + if (reader.TryReadInt64(out var i64)) + { + SetResult(message, i64); + return true; + } + } + + // handle unit arrays with a scalar + if (reader.IsAggregate && reader.TryMoveNext() && reader.IsScalar) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - if (result.IsNull) + if (reader.IsNull) + { + if (!reader.TryMoveNext()) // only if unit, else ignore { SetResult(message, null); return true; } - if (result.TryGetInt64(out long i64)) - { - SetResult(message, i64); - return true; - } - break; - case ResultType.Array: - var items = result.GetItems(); - if (items.Length == 1) - { // treat an array of 1 like a single reply - if (items[0].TryGetInt64(out long value)) - { - SetResult(message, value); - return true; - } - } - break; + } + else if (reader.TryReadInt64(out var i64) && !reader.TryMoveNext()) + { + // treat an array of 1 like a single reply + SetResult(message, i64); + return true; + } } return false; } @@ -1571,13 +1618,18 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class ExpireResultArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array || result.IsNull) + if (reader.IsAggregate) { - var arr = result.ToArray((in RawResult x) => (ExpireResult)(long)x.AsRedisValue())!; - - SetResult(message, arr); + var arr = reader.ReadPastArray( + static (ref r) => + { + r.TryReadInt64(out var val); + return (ExpireResult)val; + }, + scalar: true); + SetResult(message, arr!); return true; } return false; @@ -1586,13 +1638,18 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class PersistResultArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array || result.IsNull) + if (reader.IsAggregate) { - var arr = result.ToArray((in RawResult x) => (PersistResult)(long)x.AsRedisValue())!; - - SetResult(message, arr); + var arr = reader.ReadPastArray( + static (ref r) => + { + r.TryReadInt64(out var val); + return (PersistResult)val; + }, + scalar: true); + SetResult(message, arr!); return true; } return false; @@ -1607,27 +1664,25 @@ public RedisChannelArrayProcessor(RedisChannel.RedisChannelOptions options) this.options = options; } - private readonly struct ChannelState // I would use a value-tuple here, but that is binding hell + // think "value-tuple", just: without the dependency hell on netfx + private readonly struct ChannelState(PhysicalConnection connection, RedisChannel.RedisChannelOptions options) { - public readonly byte[]? Prefix; - public readonly RedisChannel.RedisChannelOptions Options; - public ChannelState(byte[]? prefix, RedisChannel.RedisChannelOptions options) - { - Prefix = prefix; - Options = options; - } + public readonly PhysicalConnection Connection = connection; + public readonly RedisChannel.RedisChannelOptions Options = options; } - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + if (reader.IsAggregate) { - case ResultType.Array: - var final = result.ToArray( - (in RawResult item, in ChannelState state) => item.AsRedisChannel(state.Prefix, state.Options), - new ChannelState(connection.ChannelPrefix, options))!; - - SetResult(message, final); - return true; + var state = new ChannelState(connection, options); + var arr = reader.ReadPastArray( + ref state, + static (ref s, ref r) => + s.Connection.AsRedisChannel(in r, s.Options), + scalar: true); + SetResult(message, arr!); + return true; } return false; } @@ -1635,14 +1690,13 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class RedisKeyArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + if (reader.IsAggregate) { - case ResultType.Array: - var arr = result.GetItemsAsKeys()!; - SetResult(message, arr); - return true; + var arr = reader.ReadPastArray(static (ref r) => r.ReadRedisKey(), scalar: true); + SetResult(message, arr!); + return true; } return false; } @@ -1650,15 +1704,12 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class RedisKeyProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - SetResult(message, result.AsRedisKey()); - return true; + SetResult(message, reader.ReadByteArray()); + return true; } return false; } @@ -1666,18 +1717,24 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class RedisTypeProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.SimpleString: - case ResultType.BulkString: - string s = result.GetString()!; - RedisType value; - if (string.Equals(s, "zset", StringComparison.OrdinalIgnoreCase)) value = Redis.RedisType.SortedSet; - else if (!Enum.TryParse(s, true, out value)) value = global::StackExchange.Redis.RedisType.Unknown; - SetResult(message, value); - return true; + RedisType redisType; + unsafe + { + if (!reader.TryParseScalar(&RedisTypeMetadata.TryParse, out redisType)) + { + // RESP null values and empty strings should map to None rather than Unknown + redisType = (reader.IsNull || reader.ScalarLengthIs(0)) + ? Redis.RedisType.None + : Redis.RedisType.Unknown; + } + } + + SetResult(message, redisType); + return true; } return false; } @@ -1685,22 +1742,23 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class RedisValueArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsAggregate) + { + var arr = reader.ReadPastRedisValues() ?? []; + SetResult(message, arr); + return true; + } + if (reader.IsScalar) { // allow a single item to pass explicitly pretending to be an array; example: SPOP {key} 1 - case ResultType.BulkString: - // If the result is nil, the result should be an empty array - var arr = result.IsNull - ? Array.Empty() - : new[] { result.AsRedisValue() }; - SetResult(message, arr); - return true; - case ResultType.Array: - arr = result.GetItemsAsValues()!; - SetResult(message, arr); - return true; + // If the result is nil, the result should be an empty array + var arr = reader.IsNull + ? Array.Empty() + : new[] { reader.ReadRedisValue() }; + SetResult(message, arr); + return true; } return false; } @@ -1708,12 +1766,12 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class Int64ArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array && !result.IsNull) + if (reader.IsAggregate) { - var arr = result.ToArray((in RawResult x) => (long)x.AsRedisValue())!; - SetResult(message, arr); + var arr = reader.ReadPastArray(static (ref r) => r.ReadInt64(), scalar: true); + SetResult(message, arr!); return true; } @@ -1723,15 +1781,13 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class NullableStringArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + if (reader.IsAggregate) { - case ResultType.Array: - var arr = result.GetItemsAsStrings()!; - - SetResult(message, arr); - return true; + var arr = reader.ReadPastArray(static (ref r) => r.ReadString(), scalar: true); + SetResult(message, arr!); + return true; } return false; } @@ -1739,14 +1795,13 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class StringArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + if (reader.IsAggregate) { - case ResultType.Array: - var arr = result.GetItemsAsStringsNotNullable()!; - SetResult(message, arr); - return true; + var arr = reader.ReadPastArray(static (ref r) => r.ReadString()!, scalar: true); + SetResult(message, arr!); + return true; } return false; } @@ -1754,12 +1809,12 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class BooleanArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray == ResultType.Array && !result.IsNull) + if (reader.IsAggregate) { - var arr = result.GetItemsAsBooleans()!; - SetResult(message, arr); + var arr = reader.ReadPastArray(static (ref r) => r.ReadBoolean(), scalar: true); + SetResult(message, arr!); return true; } return false; @@ -1768,15 +1823,20 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class RedisValueGeoPositionProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + if (reader.IsAggregate) { - case ResultType.Array: - var pos = result.GetItemsAsGeoPosition(); - - SetResult(message, pos); - return true; + if (reader.AggregateLengthIs(1)) + { + reader.MoveNext(); + SetResult(message, ParseGeoPosition(ref reader)); + } + else + { + SetResult(message, null); + } + return true; } return false; } @@ -1784,68 +1844,76 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class RedisValueGeoPositionArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + if (reader.IsAggregate) { - case ResultType.Array: - var arr = result.GetItemsAsGeoPositionArray()!; - - SetResult(message, arr); - return true; + var arr = reader.ReadPastArray(static (ref r) => ParseGeoPosition(ref r)); + SetResult(message, arr!); + return true; } return false; } } - private sealed class GeoRadiusResultArrayProcessor : ResultProcessor + private static GeoPosition? ParseGeoPosition(ref RespReader reader) { - private static readonly GeoRadiusResultArrayProcessor[] instances; - private readonly GeoRadiusOptions options; - - static GeoRadiusResultArrayProcessor() + if (reader.IsAggregate && reader.AggregateLengthIs(2) + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadDouble(out var longitude) + && reader.TryMoveNext() && reader.IsScalar && reader.TryReadDouble(out var latitude) + && !reader.TryMoveNext()) { - instances = new GeoRadiusResultArrayProcessor[8]; - for (int i = 0; i < 8; i++) instances[i] = new GeoRadiusResultArrayProcessor((GeoRadiusOptions)i); + return new GeoPosition(longitude, latitude); } + return null; + } + + private sealed class GeoRadiusResultArrayProcessor : ResultProcessor + { + private static readonly GeoRadiusResultArrayProcessor?[] instances = new GeoRadiusResultArrayProcessor?[8]; + private readonly GeoRadiusOptions options; public static GeoRadiusResultArrayProcessor Get(GeoRadiusOptions options) - { - int i = (int)options; - if (i < 0 || i >= instances.Length) throw new ArgumentOutOfRangeException(nameof(options)); - return instances[i]; - } + => instances[(int)options] ??= new(options); private GeoRadiusResultArrayProcessor(GeoRadiusOptions options) { this.options = options; } - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + if (reader.IsAggregate) { - case ResultType.Array: - var typed = result.ToArray( - (in RawResult item, in GeoRadiusOptions radiusOptions) => Parse(item, radiusOptions), options)!; - SetResult(message, typed); - return true; + var opts = options; + var typed = reader.ReadPastArray( + ref opts, + static (ref options, ref reader) => Parse(ref reader, options), + scalar: options == GeoRadiusOptions.None); + SetResult(message, typed!); + return true; } return false; } - private static GeoRadiusResult Parse(in RawResult item, GeoRadiusOptions options) + private static GeoRadiusResult Parse(ref RespReader reader, GeoRadiusOptions options) { if (options == GeoRadiusOptions.None) { // Without any WITH option specified, the command just returns a linear array like ["New York","Milan","Paris"]. - return new GeoRadiusResult(item.AsRedisValue(), null, null, null); + return new GeoRadiusResult(reader.ReadString(), null, null, null); } + // If WITHCOORD, WITHDIST or WITHHASH options are specified, the command returns an array of arrays, where each sub-array represents a single item. - var iter = item.GetItems().GetEnumerator(); + if (!reader.IsAggregate) + { + return default; + } + + reader.MoveNext(); // Move to first element in the sub-array // the first item in the sub-array is always the name of the returned item. - var member = iter.GetNext().AsRedisValue(); + var member = reader.ReadString(); /* The other information is returned in the following order as successive elements of the sub-array. The distance from the center as a floating point number, in the same unit specified in the radius. @@ -1855,14 +1923,25 @@ The geohash integer. double? distance = null; GeoPosition? position = null; long? hash = null; - if ((options & GeoRadiusOptions.WithDistance) != 0) { distance = (double?)iter.GetNext().AsRedisValue(); } - if ((options & GeoRadiusOptions.WithGeoHash) != 0) { hash = (long?)iter.GetNext().AsRedisValue(); } + + if ((options & GeoRadiusOptions.WithDistance) != 0) + { + reader.MoveNextScalar(); + distance = reader.ReadDouble(); + } + + if ((options & GeoRadiusOptions.WithGeoHash) != 0) + { + reader.MoveNextScalar(); + hash = reader.TryReadInt64(out var h) ? h : null; + } + if ((options & GeoRadiusOptions.WithCoordinates) != 0) { - var coords = iter.GetNext().GetItems(); - double longitude = (double)coords[0].AsRedisValue(), latitude = (double)coords[1].AsRedisValue(); - position = new GeoPosition(longitude, latitude); + reader.MoveNextAggregate(); + position = ParseGeoPosition(ref reader); } + return new GeoRadiusResult(member, distance, hash, position); } } @@ -1884,70 +1963,100 @@ The geohash integer. /// private sealed class LongestCommonSubsequenceProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) - { - switch (result.Resp2TypeArray) - { - case ResultType.Array when TryParse(result, out var value): - SetResult(message, value); - return true; - } - return false; - } - - private static bool TryParse(in RawResult result, out LCSMatchResult value) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - var topItems = result.GetItems(); - var matches = new LCSMatchResult.LCSMatch[topItems[1].GetItems().Length]; - int i = 0; - var matchesRawArray = topItems[1]; // skip the first element (title "matches") - foreach (var match in matchesRawArray.GetItems()) + if (reader.IsAggregate) { - var matchItems = match.GetItems(); + // Top-level array: ["matches", matches_array, "len", length_value] + // Use nominal access instead of positional + LCSMatchResult.LCSMatch[]? matchesArray = null; + long longestMatchLength = 0; - if (TryReadPosition(matchItems[0], out var first) - && TryReadPosition(matchItems[1], out var second) - && matchItems[2].TryGetInt64(out var length)) + var iter = reader.AggregateChildren(); + while (iter.MoveNext() && iter.Value.IsScalar) { - matches[i++] = new LCSMatchResult.LCSMatch(first, second, length); + LCSField field; + unsafe + { + if (!iter.Value.TryParseScalar(&LCSFieldMetadata.TryParse, out field)) + { + field = LCSField.Unknown; + } + } + + if (!iter.MoveNext()) break; // out of data + + switch (field) + { + case LCSField.Matches: + // Read the matches array + if (iter.Value.IsAggregate) + { + bool failed = false; + matchesArray = iter.Value.ReadPastArray(ref failed, static (ref failed, ref reader) => + { + // Don't even bother if we've already failed + if (!failed && reader.IsAggregate) + { + var matchChildren = reader.AggregateChildren(); + if (matchChildren.MoveNext() && TryReadPosition(ref matchChildren.Value, out var firstPos) + && matchChildren.MoveNext() && TryReadPosition(ref matchChildren.Value, out var secondPos) + && matchChildren.MoveNext() && matchChildren.Value.IsScalar && matchChildren.Value.TryReadInt64(out var length)) + { + return new LCSMatchResult.LCSMatch(firstPos, secondPos, length); + } + } + failed = true; + return default; + }); + + // Check if anything went wrong + if (failed) matchesArray = null; + } + break; + + case LCSField.Len: + // Read the length value + if (iter.Value.IsScalar) + { + longestMatchLength = iter.Value.TryReadInt64(out var totalLen) ? totalLen : 0; + } + break; + } } - else + + if (matchesArray is not null) { - value = default; - return false; + SetResult(message, new LCSMatchResult(matchesArray, longestMatchLength)); + return true; } } - var len = (long)topItems[3].AsRedisValue(); - - value = new LCSMatchResult(matches, len); - return true; + return false; } - private static bool TryReadPosition(in RawResult raw, out LCSMatchResult.LCSPosition position) + private static bool TryReadPosition(ref RespReader reader, out LCSMatchResult.LCSPosition position) { // Expecting a 2-element array: [start, end] - if (raw.Resp2TypeArray is ResultType.Array && raw.ItemsCount >= 2 - && raw[0].TryGetInt64(out var start) && raw[1].TryGetInt64(out var end)) - { - position = new LCSMatchResult.LCSPosition(start, end); - return true; - } position = default; - return false; + if (!reader.IsAggregate) return false; + + if (!(reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var start))) return false; + + if (!(reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var end))) return false; + + position = new LCSMatchResult.LCSPosition(start, end); + return true; } } private sealed class RedisValueProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - SetResult(message, result.AsRedisValue()); - return true; + SetResult(message, reader.ReadRedisValue()); + return true; } return false; } @@ -1955,18 +2064,13 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class RedisValueFromArrayProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsAggregate && reader.AggregateLengthIs(1)) { - case ResultType.Array: - var items = result.GetItems(); - if (items.Length == 1) - { // treat an array of 1 like a single reply - SetResult(message, items[0].AsRedisValue()); - return true; - } - break; + reader.MoveNext(); + SetResult(message, reader.ReadRedisValue()); + return true; } return false; } @@ -1974,81 +2078,96 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class RoleProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - var items = result.GetItems(); - if (items.IsEmpty) + // Null, non-aggregate, empty, or non-scalar first element returns null Role + if (!(reader.IsAggregate && !reader.IsNull && reader.TryMoveNext() && reader.IsScalar)) { - return false; + SetResult(message, null!); + return true; + } + + RoleType roleType; + unsafe + { + if (!reader.TryParseScalar(&RoleTypeMetadata.TryParse, out roleType)) + { + roleType = RoleType.Unknown; + } } - ref var val = ref items[0]; - Role? role; - if (val.IsEqual(RedisLiterals.master)) role = ParsePrimary(items); - else if (val.IsEqual(RedisLiterals.slave)) role = ParseReplica(items, RedisLiterals.slave!); - else if (val.IsEqual(RedisLiterals.replica)) role = ParseReplica(items, RedisLiterals.replica!); // for when "slave" is deprecated - else if (val.IsEqual(RedisLiterals.sentinel)) role = ParseSentinel(items); - else role = new Role.Unknown(val.GetString()!); + var role = roleType switch + { + RoleType.Master => ParsePrimary(ref reader), + RoleType.Slave => ParseReplica(ref reader, "slave"), + RoleType.Replica => ParseReplica(ref reader, "replica"), + RoleType.Sentinel => ParseSentinel(ref reader), + _ => new Role.Unknown(reader.ReadString()!), + }; - if (role is null) return false; - SetResult(message, role); + SetResult(message, role!); return true; } - private static Role? ParsePrimary(in Sequence items) + private static Role? ParsePrimary(ref RespReader reader) { - if (items.Length < 3) + // Expect: offset (int64), replicas (array) + if (!(reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var offset))) { return null; } - if (!items[1].TryGetInt64(out var offset)) + if (!(reader.TryMoveNext() && reader.IsAggregate)) { return null; } - var replicaItems = items[2].GetItems(); - ICollection replicas; - if (replicaItems.IsEmpty) - { - replicas = Array.Empty(); - } - else - { - replicas = new List((int)replicaItems.Length); - for (int i = 0; i < replicaItems.Length; i++) + var failed = false; + var replicas = reader.ReadPastArray( + ref failed, + static (ref isFailed, ref r) => { - if (TryParsePrimaryReplica(replicaItems[i].GetItems(), out var replica)) - { - replicas.Add(replica); - } - else + if (isFailed) return default; // bail early if already failed + if (!TryParsePrimaryReplica(ref r, out var replica)) { - return null; + isFailed = true; + return default; } - } - } + return replica; + }, + scalar: false) ?? []; + + if (failed) return null; return new Role.Master(offset, replicas); } - private static bool TryParsePrimaryReplica(in Sequence items, out Role.Master.Replica replica) + private static bool TryParsePrimaryReplica(ref RespReader reader, out Role.Master.Replica replica) { - if (items.Length < 3) + // Expect: [ip, port, offset] + if (!reader.IsAggregate || reader.IsNull) { replica = default; return false; } - var primaryIp = items[0].GetString()!; + // IP + if (!(reader.TryMoveNext() && reader.IsScalar)) + { + replica = default; + return false; + } + var primaryIp = reader.ReadString()!; - if (!items[1].TryGetInt64(out var primaryPort) || primaryPort > int.MaxValue) + // Port + if (!(reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var primaryPort) && primaryPort <= int.MaxValue)) { replica = default; return false; } - if (!items[2].TryGetInt64(out var replicationOffset)) + // Offset + if (!(reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var replicationOffset))) { replica = default; return false; @@ -2058,31 +2177,52 @@ private static bool TryParsePrimaryReplica(in Sequence items, out Rol return true; } - private static Role? ParseReplica(in Sequence items, string role) + private static Role? ParseReplica(ref RespReader reader, string role) { - if (items.Length < 5) + // Expect: masterIp, masterPort, state, offset + + // Master IP + if (!(reader.TryMoveNext() && reader.IsScalar)) { return null; } + var primaryIp = reader.ReadString()!; - var primaryIp = items[1].GetString()!; + // Master Port + if (!(reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var primaryPort) && primaryPort <= int.MaxValue)) + { + return null; + } - if (!items[2].TryGetInt64(out var primaryPort) || primaryPort > int.MaxValue) + // Replication State + if (!(reader.TryMoveNext() && reader.IsScalar)) { return null; } - ref var val = ref items[3]; - string replicationState; - if (val.IsEqual(RedisLiterals.connect)) replicationState = RedisLiterals.connect!; - else if (val.IsEqual(RedisLiterals.connecting)) replicationState = RedisLiterals.connecting!; - else if (val.IsEqual(RedisLiterals.sync)) replicationState = RedisLiterals.sync!; - else if (val.IsEqual(RedisLiterals.connected)) replicationState = RedisLiterals.connected!; - else if (val.IsEqual(RedisLiterals.none)) replicationState = RedisLiterals.none!; - else if (val.IsEqual(RedisLiterals.handshake)) replicationState = RedisLiterals.handshake!; - else replicationState = val.GetString()!; + // this is just a long-winded way of avoiding some string allocs! + ReplicationState state; + unsafe + { + if (!reader.TryParseScalar(&ReplicationStateMetadata.TryParse, out state)) + { + state = ReplicationState.Unknown; + } + } + + var replicationState = state switch + { + ReplicationState.Connect => "connect", + ReplicationState.Connecting => "connecting", + ReplicationState.Sync => "sync", + ReplicationState.Connected => "connected", + ReplicationState.None => "none", + ReplicationState.Handshake => "handshake", + _ => reader.ReadString()!, + }; - if (!items[4].TryGetInt64(out var replicationOffset)) + // Replication Offset + if (!(reader.TryMoveNext() && reader.IsScalar && reader.TryReadInt64(out var replicationOffset))) { return null; } @@ -2090,35 +2230,39 @@ private static bool TryParsePrimaryReplica(in Sequence items, out Rol return new Role.Replica(role, primaryIp, (int)primaryPort, replicationState, replicationOffset); } - private static Role? ParseSentinel(in Sequence items) + private static Role? ParseSentinel(ref RespReader reader) { - if (items.Length < 2) + // Expect: array of master names + if (!(reader.TryMoveNext() && reader.IsAggregate)) { return null; } - var primaries = items[1].GetItemsAsStrings()!; - return new Role.Sentinel(primaries); + + var primaries = reader.ReadPastArray(static (ref r) => r.ReadString(), scalar: true); + return new Role.Sentinel(primaries ?? []); } } private sealed class ScriptResultProcessor : ResultProcessor { - public override bool SetResult(PhysicalConnection connection, Message message, in RawResult result) + public override bool SetResult(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.IsError && result.StartsWith(CommonReplies.NOSCRIPT)) + var copy = reader; + reader.MovePastBof(); + if (reader.IsError && reader.StartsWith(Literals.NOSCRIPT.U8)) { // scripts are not flushed individually, so assume the entire script cache is toast ("SCRIPT FLUSH") connection.BridgeCouldBeNull?.ServerEndPoint?.FlushScriptCache(); message.SetScriptUnavailable(); } // and apply usual processing for the rest - return base.SetResult(connection, message, result); + return base.SetResult(connection, message, ref copy); } // note that top-level error messages still get handled by SetResult, but nested errors // (is that a thing?) will be wrapped in the RedisResult - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (RedisResult.TryCreate(connection, result, out var value)) + if (RedisResult.TryCreate(connection, ref reader, out var value)) { SetResult(message, value); return true; @@ -2139,20 +2283,21 @@ public SingleStreamProcessor(bool skipStreamName = false) /// /// Handles . /// - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.IsNull) + if (reader.IsNull) { // Server returns 'nil' if no entries are returned for the given stream. SetResult(message, []); return true; } - if (result.Resp2TypeArray != ResultType.Array) + if (!reader.IsAggregate) { return false; } + var protocol = connection.Protocol.GetValueOrDefault(); StreamEntry[] entries; if (skipStreamName) @@ -2196,12 +2341,27 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes 6) "46" */ - ref readonly RawResult readResult = ref (result.Resp3Type == ResultType.Map ? ref result[1] : ref result[0][1]); - entries = ParseRedisStreamEntries(readResult); + if (protocol == RedisProtocol.Resp3) + { + // RESP3: map - skip the key, read the value + reader.MoveNext(); // skip key + reader.MoveNext(); // move to value + entries = ParseRedisStreamEntries(ref reader, protocol); + } + else + { + // RESP2: array - first element is array with [name, entries] + var iter = reader.AggregateChildren(); + iter.DemandNext(); // first stream + var streamIter = iter.Value.AggregateChildren(); + streamIter.DemandNext(); // skip stream name + streamIter.DemandNext(); // entries array + entries = ParseRedisStreamEntries(ref streamIter.Value, protocol); + } } else { - entries = ParseRedisStreamEntries(result); + entries = ParseRedisStreamEntries(ref reader, protocol); } SetResult(message, entries); @@ -2246,38 +2406,63 @@ Multibulk array. (note that XREADGROUP may include additional interior elements; see ParseRedisStreamEntries) */ - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.IsNull) + if (reader.IsNull) { // Nothing returned for any of the requested streams. The server returns 'nil'. SetResult(message, []); return true; } - if (result.Resp2TypeArray != ResultType.Array) + if (!reader.IsAggregate) { return false; } + var protocol = connection.Protocol.GetValueOrDefault(); RedisStream[] streams; - if (result.Resp3Type == ResultType.Map) // see SetResultCore for the shape delta between RESP2 and RESP3 + + if (reader.Prefix == RespPrefix.Map) // see SetResultCore for the shape delta between RESP2 and RESP3 { // root is a map of named inner-arrays - streams = RedisStreamInterleavedProcessor.Instance.ParseArray(result, false, out _, this)!; // null-checked + // RedisStreamInterleavedProcessor handles maps via the interleaved processor base + var processor = protocol == RedisProtocol.Resp2 ? RedisStreamInterleavedProcessor.Resp2 : RedisStreamInterleavedProcessor.Resp3; + streams = processor.ParseArray(ref reader, protocol, false, out _, null)!; // null-checked below } else { - streams = result.GetItems().ToArray( - (in RawResult item, in MultiStreamProcessor obj) => + streams = reader.ReadPastArray( + ref protocol, + static (ref protocol, ref itemReader) => { - var details = item.GetItems(); + if (!itemReader.IsAggregate) + { + throw new InvalidOperationException("Expected aggregate for stream"); + } + + // [0] = Name of the Stream + if (!itemReader.TryMoveNext()) + { + throw new InvalidOperationException("Expected stream name"); + } + var key = itemReader.ReadRedisKey(); - // details[0] = Name of the Stream - // details[1] = Multibulk Array of Stream Entries - return new RedisStream(key: details[0].AsRedisKey(), entries: obj.ParseRedisStreamEntries(details[1])!); + // [1] = Multibulk Array of Stream Entries + if (!itemReader.TryMoveNext()) + { + throw new InvalidOperationException("Expected stream entries"); + } + var entries = StreamProcessorBase.ParseRedisStreamEntries(ref itemReader, protocol); + + return new RedisStream(key: key, entries: entries); }, - this); + scalar: false)!; // null-checked below + + if (streams == null) + { + return false; + } } SetResult(message, streams); @@ -2287,15 +2472,21 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class RedisStreamInterleavedProcessor : ValuePairInterleavedProcessorBase { - protected override bool AllowJaggedPairs(in RawResult result) => false; // we only use this on a flattened map + protected override bool AllowJaggedPairs(RedisProtocol protocol) => false; // we only use this on a flattened map + + public static readonly RedisStreamInterleavedProcessor Resp2 = new(RedisProtocol.Resp2); + public static readonly RedisStreamInterleavedProcessor Resp3 = new(RedisProtocol.Resp3); - public static readonly RedisStreamInterleavedProcessor Instance = new(); - private RedisStreamInterleavedProcessor() + private readonly RedisProtocol _protocol; + private RedisStreamInterleavedProcessor(RedisProtocol protocol) { + _protocol = protocol; } - protected override RedisStream Parse(in RawResult first, in RawResult second, object? state) - => new(key: first.AsRedisKey(), entries: ((MultiStreamProcessor)state!).ParseRedisStreamEntries(second)); + protected override RedisStream Parse(ref RespReader first, ref RespReader second, object? state) + { + return new(key: first.ReadRedisKey(), entries: StreamProcessorBase.ParseRedisStreamEntries(ref second, _protocol)); + } } /// @@ -2303,21 +2494,42 @@ protected override RedisStream Parse(in RawResult first, in RawResult second, ob /// internal sealed class StreamAutoClaimProcessor : StreamProcessorBase { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { // See https://redis.io/commands/xautoclaim for command documentation. // Note that the result should never be null, so intentionally treating it as a failure to parse here - if (result.Resp2TypeArray == ResultType.Array && !result.IsNull) + if (reader.IsAggregate && !reader.IsNull) { - var items = result.GetItems(); + int length = reader.AggregateLength(); + if (!(length == 2 || length == 3)) + { + return false; + } + + var iter = reader.AggregateChildren(); + var protocol = connection.Protocol.GetValueOrDefault(); // [0] The next start ID. - var nextStartId = items[0].AsRedisValue(); + iter.DemandNext(); + var nextStartId = iter.Value.ReadRedisValue(); + // [1] The array of StreamEntry's. - var entries = ParseRedisStreamEntries(items[1]); + iter.DemandNext(); + var entries = ParseRedisStreamEntries(ref iter.Value, protocol); + // [2] The array of message IDs deleted from the stream that were in the PEL. // This is not available in 6.2 so we need to be defensive when reading this part of the response. - var deletedIds = (items.Length == 3 ? items[2].GetItemsAsValues() : null) ?? []; + RedisValue[] deletedIds = []; + if (length == 3) + { + iter.DemandNext(); + if (iter.Value.IsAggregate && !iter.Value.IsNull) + { + deletedIds = iter.Value.ReadPastArray( + static (ref RespReader r) => r.ReadRedisValue(), + scalar: true)!; + } + } SetResult(message, new StreamAutoClaimResult(nextStartId, entries, deletedIds)); return true; @@ -2332,21 +2544,47 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes /// internal sealed class StreamAutoClaimIdsOnlyProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { // See https://redis.io/commands/xautoclaim for command documentation. // Note that the result should never be null, so intentionally treating it as a failure to parse here - if (result.Resp2TypeArray == ResultType.Array && !result.IsNull) + if (reader.IsAggregate && !reader.IsNull) { - var items = result.GetItems(); + int length = reader.AggregateLength(); + if (!(length == 2 || length == 3)) + { + return false; + } + + var iter = reader.AggregateChildren(); // [0] The next start ID. - var nextStartId = items[0].AsRedisValue(); + iter.DemandNext(); + var nextStartId = iter.Value.ReadRedisValue(); + // [1] The array of claimed message IDs. - var claimedIds = items[1].GetItemsAsValues() ?? []; + iter.DemandNext(); + RedisValue[] claimedIds = []; + if (iter.Value.IsAggregate && !iter.Value.IsNull) + { + claimedIds = iter.Value.ReadPastArray( + static (ref RespReader r) => r.ReadRedisValue(), + scalar: true)!; + } + // [2] The array of message IDs deleted from the stream that were in the PEL. // This is not available in 6.2 so we need to be defensive when reading this part of the response. - var deletedIds = (items.Length == 3 ? items[2].GetItemsAsValues() : null) ?? []; + RedisValue[] deletedIds = []; + if (length == 3) + { + iter.DemandNext(); + if (iter.Value.IsAggregate && !iter.Value.IsNull) + { + deletedIds = iter.Value.ReadPastArray( + static (ref RespReader r) => r.ReadRedisValue(), + scalar: true)!; + } + } SetResult(message, new StreamAutoClaimIdsOnlyResult(nextStartId, claimedIds, deletedIds)); return true; @@ -2358,7 +2596,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes internal sealed class StreamConsumerInfoProcessor : InterleavedStreamInfoProcessorBase { - protected override StreamConsumerInfo ParseItem(in RawResult result) + protected override StreamConsumerInfo ParseItem(ref RespReader reader) { // Note: the base class passes a single consumer from the response into this method. @@ -2376,88 +2614,49 @@ protected override StreamConsumerInfo ParseItem(in RawResult result) // 4) (integer)1 // 5) idle // 6) (integer)83841983 - var arr = result.GetItems(); + if (!reader.IsAggregate) + { + return default; + } + string? name = default; int pendingMessageCount = default; long idleTimeInMilliseconds = default; - KeyValuePairParser.TryRead(arr, KeyValuePairParser.Name, ref name); - KeyValuePairParser.TryRead(arr, KeyValuePairParser.Pending, ref pendingMessageCount); - KeyValuePairParser.TryRead(arr, KeyValuePairParser.Idle, ref idleTimeInMilliseconds); - - return new StreamConsumerInfo(name!, pendingMessageCount, idleTimeInMilliseconds); - } - } - - private static class KeyValuePairParser - { - internal static readonly CommandBytes - Name = "name", - Consumers = "consumers", - Pending = "pending", - Idle = "idle", - LastDeliveredId = "last-delivered-id", - EntriesRead = "entries-read", - Lag = "lag", - IP = "ip", - Port = "port"; - - internal static bool TryRead(Sequence pairs, in CommandBytes key, ref long value) - { - var len = pairs.Length / 2; - for (int i = 0; i < len; i++) - { - if (pairs[i * 2].IsEqual(key) && pairs[(i * 2) + 1].TryGetInt64(out var tmp)) - { - value = tmp; - return true; - } - } - return false; - } - internal static bool TryRead(Sequence pairs, in CommandBytes key, ref long? value) - { - var len = pairs.Length / 2; - for (int i = 0; i < len; i++) + while (reader.TryMoveNext() && reader.IsScalar) { - if (pairs[i * 2].IsEqual(key) && pairs[(i * 2) + 1].TryGetInt64(out var tmp)) + StreamConsumerInfoField field; + unsafe { - value = tmp; - return true; + if (!reader.TryParseScalar(&StreamConsumerInfoFieldMetadata.TryParse, out field)) + { + field = StreamConsumerInfoField.Unknown; + } } - } - return false; - } - internal static bool TryRead(Sequence pairs, in CommandBytes key, ref int value) - { - long tmp = default; - if (TryRead(pairs, key, ref tmp)) - { - value = checked((int)tmp); - return true; - } - return false; - } + if (!reader.TryMoveNext()) break; - internal static bool TryRead(Sequence pairs, in CommandBytes key, [NotNullWhen(true)] ref string? value) - { - var len = pairs.Length / 2; - for (int i = 0; i < len; i++) - { - if (pairs[i * 2].IsEqual(key)) + switch (field) { - value = pairs[(i * 2) + 1].GetString()!; - return true; + case StreamConsumerInfoField.Name: + name = reader.ReadString(); + break; + case StreamConsumerInfoField.Pending when reader.TryReadInt64(out var pending): + pendingMessageCount = checked((int)pending); + break; + case StreamConsumerInfoField.Idle: + reader.TryReadInt64(out idleTimeInMilliseconds); + break; } } - return false; + + return new StreamConsumerInfo(name!, pendingMessageCount, idleTimeInMilliseconds); } } internal sealed class StreamGroupInfoProcessor : InterleavedStreamInfoProcessorBase { - protected override StreamGroupInfo ParseItem(in RawResult result) + protected override StreamGroupInfo ParseItem(ref RespReader reader) { // Note: the base class passes a single item from the response into this method. @@ -2487,18 +2686,51 @@ protected override StreamGroupInfo ParseItem(in RawResult result) // 10) (integer)1 // 11) "lag" // 12) (integer)1 - var arr = result.GetItems(); + if (!reader.IsAggregate) + { + return default; + } + string? name = default, lastDeliveredId = default; int consumerCount = default, pendingMessageCount = default; long entriesRead = default; long? lag = default; - KeyValuePairParser.TryRead(arr, KeyValuePairParser.Name, ref name); - KeyValuePairParser.TryRead(arr, KeyValuePairParser.Consumers, ref consumerCount); - KeyValuePairParser.TryRead(arr, KeyValuePairParser.Pending, ref pendingMessageCount); - KeyValuePairParser.TryRead(arr, KeyValuePairParser.LastDeliveredId, ref lastDeliveredId); - KeyValuePairParser.TryRead(arr, KeyValuePairParser.EntriesRead, ref entriesRead); - KeyValuePairParser.TryRead(arr, KeyValuePairParser.Lag, ref lag); + while (reader.TryMoveNext() && reader.IsScalar) + { + StreamGroupInfoField field; + unsafe + { + if (!reader.TryParseScalar(&StreamGroupInfoFieldMetadata.TryParse, out field)) + { + field = StreamGroupInfoField.Unknown; + } + } + + if (!reader.TryMoveNext()) break; + + switch (field) + { + case StreamGroupInfoField.Name: + name = reader.ReadString(); + break; + case StreamGroupInfoField.Consumers when reader.TryReadInt64(out var consumers): + consumerCount = checked((int)consumers); + break; + case StreamGroupInfoField.Pending when reader.TryReadInt64(out var pending): + pendingMessageCount = checked((int)pending); + break; + case StreamGroupInfoField.LastDeliveredId: + lastDeliveredId = reader.ReadString(); + break; + case StreamGroupInfoField.EntriesRead: + reader.TryReadInt64(out entriesRead); + break; + case StreamGroupInfoField.Lag when reader.TryReadInt64(out var lagValue): + lag = lagValue; + break; + } + } return new StreamGroupInfo(name!, consumerCount, pendingMessageCount, lastDeliveredId, entriesRead, lag); } @@ -2506,19 +2738,22 @@ protected override StreamGroupInfo ParseItem(in RawResult result) internal abstract class InterleavedStreamInfoProcessorBase : ResultProcessor { - protected abstract T ParseItem(in RawResult result); + protected abstract T ParseItem(ref RespReader reader); - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray != ResultType.Array) + if (!reader.IsAggregate) { return false; } - var arr = result.GetItems(); - var parsedItems = arr.ToArray((in RawResult item, in InterleavedStreamInfoProcessorBase obj) => obj.ParseItem(item), this); + var self = this; + var parsedItems = reader.ReadPastArray( + ref self, + static (ref self, ref r) => self.ParseItem(ref r), + scalar: false); - SetResult(message, parsedItems); + SetResult(message, parsedItems!); return true; } } @@ -2545,15 +2780,15 @@ internal sealed class StreamInfoProcessor : StreamProcessorBase // 12) 1) 1526569544280-0 // 2) 1) "message" // 2) "banana" - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray != ResultType.Array) + if (!reader.IsAggregate) { return false; } - var arr = result.GetItems(); - var max = arr.Length / 2; + int count = reader.AggregateLength(); + if ((count & 1) != 0) return false; // must be even (key-value pairs) long length = -1, radixTreeKeys = -1, radixTreeNodes = -1, groups = -1, entriesAdded = -1, idmpDuration = -1, idmpMaxsize = -1, @@ -2562,64 +2797,74 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes maxDeletedEntryId = Redis.RedisValue.Null, recordedFirstEntryId = Redis.RedisValue.Null; StreamEntry firstEntry = StreamEntry.Null, lastEntry = StreamEntry.Null; - var iter = arr.GetEnumerator(); - for (int i = 0; i < max; i++) + + var protocol = connection.Protocol.GetValueOrDefault(); + + while (reader.TryMoveNext() && reader.IsScalar) { - if (!iter.GetNext().TryParse(StreamInfoFieldMetadata.TryParse, out StreamInfoField field)) - field = StreamInfoField.Unknown; - ref RawResult value = ref iter.GetNext(); + StreamInfoField field; + unsafe + { + if (!reader.TryParseScalar(&StreamInfoFieldMetadata.TryParse, out field)) + { + field = StreamInfoField.Unknown; + } + } + + // Move to value + if (!reader.TryMoveNext()) break; switch (field) { case StreamInfoField.Length: - if (!value.TryGetInt64(out length)) return false; + if (!reader.TryReadInt64(out length)) return false; break; case StreamInfoField.RadixTreeKeys: - if (!value.TryGetInt64(out radixTreeKeys)) return false; + if (!reader.TryReadInt64(out radixTreeKeys)) return false; break; case StreamInfoField.RadixTreeNodes: - if (!value.TryGetInt64(out radixTreeNodes)) return false; + if (!reader.TryReadInt64(out radixTreeNodes)) return false; break; case StreamInfoField.Groups: - if (!value.TryGetInt64(out groups)) return false; + if (!reader.TryReadInt64(out groups)) return false; break; case StreamInfoField.LastGeneratedId: - lastGeneratedId = value.AsRedisValue(); + lastGeneratedId = reader.ReadRedisValue(); break; case StreamInfoField.FirstEntry: - firstEntry = ParseRedisStreamEntry(value); + firstEntry = ParseRedisStreamEntry(ref reader, protocol); break; case StreamInfoField.LastEntry: - lastEntry = ParseRedisStreamEntry(value); + lastEntry = ParseRedisStreamEntry(ref reader, protocol); break; // 7.0 case StreamInfoField.MaxDeletedEntryId: - maxDeletedEntryId = value.AsRedisValue(); + maxDeletedEntryId = reader.ReadRedisValue(); break; case StreamInfoField.RecordedFirstEntryId: - recordedFirstEntryId = value.AsRedisValue(); + recordedFirstEntryId = reader.ReadRedisValue(); break; case StreamInfoField.EntriesAdded: - if (!value.TryGetInt64(out entriesAdded)) return false; + if (!reader.TryReadInt64(out entriesAdded)) return false; break; // 8.6 case StreamInfoField.IdmpDuration: - if (!value.TryGetInt64(out idmpDuration)) return false; + if (!reader.TryReadInt64(out idmpDuration)) return false; break; case StreamInfoField.IdmpMaxsize: - if (!value.TryGetInt64(out idmpMaxsize)) return false; + if (!reader.TryReadInt64(out idmpMaxsize)) return false; break; case StreamInfoField.PidsTracked: - if (!value.TryGetInt64(out pidsTracked)) return false; + if (!reader.TryReadInt64(out pidsTracked)) return false; break; case StreamInfoField.IidsTracked: - if (!value.TryGetInt64(out iidsTracked)) return false; + if (!reader.TryReadInt64(out iidsTracked)) return false; break; case StreamInfoField.IidsAdded: - if (!value.TryGetInt64(out iidsAdded)) return false; + if (!reader.TryReadInt64(out iidsAdded)) return false; break; case StreamInfoField.IidsDuplicates: - if (!value.TryGetInt64(out iidsDuplicates)) return false; + if (!reader.TryReadInt64(out iidsDuplicates)) return false; break; } } @@ -2649,7 +2894,7 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes internal sealed class StreamPendingInfoProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { // Example: // > XPENDING mystream mygroup @@ -2660,38 +2905,66 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes // 2) "2" // 5) 1) 1) "Joe" // 2) "8" - if (result.Resp2TypeArray != ResultType.Array) + if (!(reader.IsAggregate && reader.AggregateLengthIs(4))) { return false; } - var arr = result.GetItems(); + var iter = reader.AggregateChildren(); - if (arr.Length != 4) + // Element 0: pending message count + iter.DemandNext(); + if (!iter.Value.TryReadInt64(out var pendingMessageCount)) { return false; } + // Element 1: lowest ID + iter.DemandNext(); + var lowestId = iter.Value.ReadRedisValue(); + + // Element 2: highest ID + iter.DemandNext(); + var highestId = iter.Value.ReadRedisValue(); + + // Element 3: consumers array (may be null) + iter.DemandNext(); StreamConsumer[]? consumers = null; // If there are no consumers as of yet for the given group, the last // item in the response array will be null. - ref RawResult third = ref arr[3]; - if (!third.IsNull) + if (iter.Value.IsAggregate && !iter.Value.IsNull) { - consumers = third.ToArray((in RawResult item) => - { - var details = item.GetItems(); - return new StreamConsumer( - name: details[0].AsRedisValue(), - pendingMessageCount: (int)details[1].AsRedisValue()); - }); + consumers = iter.Value.ReadPastArray( + static (ref RespReader consumerReader) => + { + if (!(consumerReader.IsAggregate && consumerReader.AggregateLengthIs(2))) + { + throw new InvalidOperationException("Expected array of 2 elements for consumer"); + } + + var consumerIter = consumerReader.AggregateChildren(); + + consumerIter.DemandNext(); + var name = consumerIter.Value.ReadRedisValue(); + + consumerIter.DemandNext(); + if (!consumerIter.Value.TryReadInt64(out var count)) + { + throw new InvalidOperationException("Expected integer for pending message count"); + } + + return new StreamConsumer( + name: name, + pendingMessageCount: checked((int)count)); + }, + scalar: false); } var pendingInfo = new StreamPendingInfo( - pendingMessageCount: (int)arr[0].AsRedisValue(), - lowestId: arr[1].AsRedisValue(), - highestId: arr[2].AsRedisValue(), + pendingMessageCount: checked((int)pendingMessageCount), + lowestId: lowestId, + highestId: highestId, consumers: consumers ?? []); SetResult(message, pendingInfo); @@ -2701,25 +2974,52 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes internal sealed class StreamPendingMessagesProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - if (result.Resp2TypeArray != ResultType.Array) + if (!reader.IsAggregate) { return false; } - var messageInfoArray = result.GetItems().ToArray((in RawResult item) => - { - var details = item.GetItems().GetEnumerator(); + var messageInfoArray = reader.ReadPastArray( + static (ref RespReader itemReader) => + { + if (!(itemReader.IsAggregate && itemReader.AggregateLengthIs(4))) + { + throw new InvalidOperationException("Expected array of 4 elements for pending message"); + } + + if (!itemReader.TryMoveNext()) + { + throw new InvalidOperationException("Expected message ID"); + } + var messageId = itemReader.ReadRedisValue(); + + if (!itemReader.TryMoveNext()) + { + throw new InvalidOperationException("Expected consumer name"); + } + var consumerName = itemReader.ReadRedisValue(); + + if (!itemReader.TryMoveNext() || !itemReader.TryReadInt64(out var idleTimeInMs)) + { + throw new InvalidOperationException("Expected integer for idle time"); + } + + if (!itemReader.TryMoveNext() || !itemReader.TryReadInt64(out var deliveryCount)) + { + throw new InvalidOperationException("Expected integer for delivery count"); + } - return new StreamPendingMessageInfo( - messageId: details.GetNext().AsRedisValue(), - consumerName: details.GetNext().AsRedisValue(), - idleTimeInMs: (long)details.GetNext().AsRedisValue(), - deliveryCount: ParseStreamDeliveryCount((long)details.GetNext().AsRedisValue())); - }); + return new StreamPendingMessageInfo( + messageId: messageId, + consumerName: consumerName, + idleTimeInMs: idleTimeInMs, + deliveryCount: ParseStreamDeliveryCount(deliveryCount)); + }, + scalar: false); - SetResult(message, messageInfoArray); + SetResult(message, messageInfoArray!); return true; } } @@ -2731,8 +3031,8 @@ private StreamNameValueEntryProcessor() { } - protected override NameValueEntry Parse(in RawResult first, in RawResult second, object? state) - => new NameValueEntry(first.AsRedisValue(), second.AsRedisValue()); + protected override NameValueEntry Parse(ref RespReader first, ref RespReader second, object? state) + => new NameValueEntry(first.ReadRedisValue(), second.ReadRedisValue()); } /// @@ -2741,9 +3041,9 @@ protected override NameValueEntry Parse(in RawResult first, in RawResult second, /// The type of the stream result. internal abstract class StreamProcessorBase : ResultProcessor { - protected static StreamEntry ParseRedisStreamEntry(in RawResult item) + protected static StreamEntry ParseRedisStreamEntry(ref RespReader reader, RedisProtocol protocol) { - if (item.IsNull || item.Resp2TypeArray != ResultType.Array) + if (!reader.IsAggregate || reader.IsNull) { return StreamEntry.Null; } @@ -2753,75 +3053,85 @@ protected static StreamEntry ParseRedisStreamEntry(in RawResult item) // optional (XREADGROUP with CLAIM): // [2] = idle time (in milliseconds) // [3] = delivery count - var entryDetails = item.GetItems(); + int length = reader.AggregateLength(); + var iter = reader.AggregateChildren(); + + iter.DemandNext(); + var id = iter.Value.ReadRedisValue(); + + iter.DemandNext(); + var values = ParseStreamEntryValues(ref iter.Value, protocol); - var id = entryDetails[0].AsRedisValue(); - var values = ParseStreamEntryValues(entryDetails[1]); // check for optional fields (XREADGROUP with CLAIM) - if (entryDetails.Length >= 4 && entryDetails[2].TryGetInt64(out var idleTimeInMs) && entryDetails[3].TryGetInt64(out var deliveryCount)) + if (length >= 4) { - return new StreamEntry( - id: id, - values: values, - idleTime: TimeSpan.FromMilliseconds(idleTimeInMs), - deliveryCount: ParseStreamDeliveryCount(deliveryCount)); + iter.DemandNext(); + if (iter.Value.TryReadInt64(out var idleTimeInMs)) + { + iter.DemandNext(); + if (iter.Value.TryReadInt64(out var deliveryCount)) + { + return new StreamEntry( + id: id, + values: values, + idleTime: TimeSpan.FromMilliseconds(idleTimeInMs), + deliveryCount: ParseStreamDeliveryCount(deliveryCount)); + } + } } + return new StreamEntry( id: id, values: values); } - protected internal StreamEntry[] ParseRedisStreamEntries(in RawResult result) => - result.GetItems().ToArray((in RawResult item, in StreamProcessorBase _) => ParseRedisStreamEntry(item), this); - - protected static NameValueEntry[] ParseStreamEntryValues(in RawResult result) - { - // The XRANGE, XREVRANGE, XREAD commands return stream entries - // in the following format. The name/value pairs are interleaved - // in the same fashion as the HGETALL response. - // - // 1) 1) 1518951480106-0 - // 2) 1) "sensor-id" - // 2) "1234" - // 3) "temperature" - // 4) "19.8" - // 2) 1) 1518951482479-0 - // 2) 1) "sensor-id" - // 2) "9999" - // 3) "temperature" - // 4) "18.2" - if (result.Resp2TypeArray != ResultType.Array || result.IsNull) + protected internal static StreamEntry[] ParseRedisStreamEntries(ref RespReader reader, RedisProtocol protocol) + { + if (!reader.IsAggregate || reader.IsNull) + { + return []; + } + + return reader.ReadPastArray( + ref protocol, + static (ref protocol, ref r) => ParseRedisStreamEntry(ref r, protocol), + scalar: false) ?? []; + } + + protected static NameValueEntry[] ParseStreamEntryValues(ref RespReader reader, RedisProtocol protocol) + { + if (!reader.IsAggregate || reader.IsNull) { return []; } - return StreamNameValueEntryProcessor.Instance.ParseArray(result, false, out _, null)!; // ! because we checked null above + return StreamNameValueEntryProcessor.Instance.ParseArray(ref reader, protocol, false, out _, null)!; } } private sealed class StringPairInterleavedProcessor : ValuePairInterleavedProcessorBase> { - protected override KeyValuePair Parse(in RawResult first, in RawResult second, object? state) => - new KeyValuePair(first.GetString()!, second.GetString()!); + protected override KeyValuePair Parse(ref RespReader first, ref RespReader second, object? state) => + new KeyValuePair(first.ReadString()!, second.ReadString()!); } private sealed class StringProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.Integer: - case ResultType.SimpleString: - case ResultType.BulkString: - SetResult(message, result.GetString()); + SetResult(message, reader.ReadString()); + return true; + } + + if (reader.IsAggregate && reader.TryMoveNext() && reader.IsScalar) + { + // treat an array of 1 like a single reply + var value = reader.ReadString(); + if (!reader.TryMoveNext()) + { + SetResult(message, value); return true; - case ResultType.Array: - var arr = result.GetItems(); - if (arr.Length == 1) - { - SetResult(message, arr[0].GetString()); - return true; - } - break; + } } return false; } @@ -2829,25 +3139,14 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class TieBreakerProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeBulkString) + if (reader.IsScalar) { - case ResultType.SimpleString: - case ResultType.BulkString: - var tieBreaker = result.GetString()!; - SetResult(message, tieBreaker); - - try - { - if (connection.BridgeCouldBeNull?.ServerEndPoint is ServerEndPoint endpoint) - { - endpoint.TieBreakerResult = tieBreaker; - } - } - catch { } - - return true; + var tieBreaker = reader.ReadString(); + connection.BridgeCouldBeNull?.ServerEndPoint?.TieBreakerResult = tieBreaker; + SetResult(message, tieBreaker); + return true; } return false; } @@ -2862,23 +3161,29 @@ public TracerProcessor(bool establishConnection) this.establishConnection = establishConnection; } - public override bool SetResult(PhysicalConnection connection, Message message, in RawResult result) + public override bool SetResult(PhysicalConnection connection, Message message, ref RespReader reader) { - connection.BridgeCouldBeNull?.Multiplexer.OnInfoMessage($"got '{result}' for '{message.CommandAndKey}' on '{connection}'"); - var final = base.SetResult(connection, message, result); - if (result.IsError) + reader.MovePastBof(); + bool isError = reader.IsError; + var copy = reader; + + connection.BridgeCouldBeNull?.Multiplexer.OnInfoMessage($"got '{reader.Prefix}' for '{message.CommandAndKey}' on '{connection}'"); + var final = base.SetResult(connection, message, ref reader); + + if (isError) { - if (result.StartsWith(CommonReplies.authFail_trimmed) || result.StartsWith(CommonReplies.NOAUTH)) + reader = copy; // rewind and re-parse + if (reader.StartsWith(Literals.ERR_not_permitted.U8) || reader.StartsWith(Literals.NOAUTH.U8)) { - connection.RecordConnectionFailed(ConnectionFailureType.AuthenticationFailure, new Exception(result.ToString() + " Verify if the Redis password provided is correct. Attempted command: " + message.Command)); + connection.RecordConnectionFailed(ConnectionFailureType.AuthenticationFailure, new Exception(reader.GetOverview() + " Verify if the Redis password provided is correct. Attempted command: " + message.Command)); } - else if (result.StartsWith(CommonReplies.loading)) + else if (reader.StartsWith(Literals.LOADING.U8)) { connection.RecordConnectionFailed(ConnectionFailureType.Loading); } else { - connection.RecordConnectionFailed(ConnectionFailureType.ProtocolFailure, new RedisServerException(result.ToString())); + connection.RecordConnectionFailed(ConnectionFailureType.ProtocolFailure, new RedisServerException(reader.GetOverview())); } } @@ -2900,25 +3205,35 @@ public override bool SetResult(PhysicalConnection connection, Message message, i } [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0071:Simplify interpolation", Justification = "Allocations (string.Concat vs. string.Format)")] - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { bool happy; switch (message.Command) { case RedisCommand.ECHO: - happy = result.Resp2TypeBulkString == ResultType.BulkString && (!establishConnection || result.IsEqual(connection.BridgeCouldBeNull?.Multiplexer?.UniqueId)); + happy = reader.Prefix == RespPrefix.BulkString && (!establishConnection || reader.Is(connection.BridgeCouldBeNull?.Multiplexer?.UniqueId)); break; case RedisCommand.PING: // there are two different PINGs; "interactive" is a +PONG or +{your message}, // but subscriber returns a bulk-array of [ "pong", {your message} ] - switch (result.Resp2TypeArray) + Span buffer = stackalloc byte[8]; + switch (reader.Prefix) { - case ResultType.SimpleString: - happy = result.IsEqual(CommonReplies.PONG); + case RespPrefix.SimpleString: + var span = reader.TryGetSpan(out var tmp) ? tmp : reader.Buffer(buffer); + happy = Literals.PONG.Hash.IsCI(span); break; - case ResultType.Array when result.ItemsCount == 2: - var items = result.GetItems(); - happy = items[0].IsEqual(CommonReplies.PONG) && items[1].Payload.IsEmpty; + case RespPrefix.Array when reader.AggregateLengthIs(2): + var iter = reader.AggregateChildren(); + if (iter.MoveNext() && iter.Value.IsScalar) + { + var pongSpan = iter.Value.TryGetSpan(out var pongTmp) ? pongTmp : iter.Value.Buffer(buffer); + happy = Literals.PONG.Hash.IsCI(pongSpan) && iter.MoveNext() && iter.Value.IsScalar && iter.Value.ScalarIsEmpty(); + } + else + { + happy = false; + } break; default: happy = false; @@ -2926,10 +3241,10 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes } break; case RedisCommand.TIME: - happy = result.Resp2TypeArray == ResultType.Array && result.ItemsCount == 2; + happy = reader.Prefix == RespPrefix.Array && reader.AggregateLengthIs(2); break; case RedisCommand.EXISTS: - happy = result.Resp2TypeBulkString == ResultType.Integer; + happy = reader.Prefix == RespPrefix.Integer; break; default: happy = false; @@ -2944,106 +3259,205 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes { connection.RecordConnectionFailed( ConnectionFailureType.ProtocolFailure, - new InvalidOperationException($"unexpected tracer reply to {message.Command}: {result.ToString()}")); + new InvalidOperationException($"unexpected tracer reply to {message.Command}: {reader.GetOverview()}")); return false; } } } + /// + /// Filters out null values from an endpoint array efficiently. + /// + /// The array to filter, or null. + /// + /// - null if input is null. + /// - original array if no nulls found. + /// - empty array if all nulls. + /// - new array with nulls removed otherwise. + /// + private static EndPoint[]? FilterNullEndpoints(EndPoint?[]? endpoints) + { + if (endpoints is null) return null; + + // Count nulls in a single pass + int nullCount = 0; + for (int i = 0; i < endpoints.Length; i++) + { + if (endpoints[i] is null) nullCount++; + } + + // No nulls - return original array + if (nullCount == 0) return endpoints!; + + // All nulls - return empty array + if (nullCount == endpoints.Length) return []; + + // Some nulls - allocate new array and copy non-nulls + var result = new EndPoint[endpoints.Length - nullCount]; + int writeIndex = 0; + for (int i = 0; i < endpoints.Length; i++) + { + if (endpoints[i] is not null) + { + result[writeIndex++] = endpoints[i]!; + } + } + + return result; + } + private sealed class SentinelGetPrimaryAddressByNameProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) + if (reader.IsAggregate && reader.AggregateLengthIs(2)) { - case ResultType.Array: - var items = result.GetItems(); - if (result.IsNull) - { - return true; - } - else if (items.Length == 2 && items[1].TryGetInt64(out var port)) - { - SetResult(message, Format.ParseEndPoint(items[0].GetString()!, checked((int)port))); - return true; - } - else if (items.Length == 0) - { - SetResult(message, null); - return true; - } - break; + reader.MoveNext(); + var host = reader.ReadString(); + reader.MoveNext(); + if (host is not null && reader.TryReadInt64(out var port)) + { + SetResult(message, Format.ParseEndPoint(host, checked((int)port))); + return true; + } + } + else if (reader.IsNull || (reader.IsAggregate && reader.AggregateLengthIs(0))) + { + SetResult(message, null); + return true; } return false; } } - private sealed class SentinelGetSentinelAddressesProcessor : ResultProcessor + private sealed partial class SentinelGetSentinelAddressesProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - List endPoints = []; - - switch (result.Resp2TypeArray) + if (reader.IsAggregate && !reader.IsNull) { - case ResultType.Array: - foreach (RawResult item in result.GetItems()) + var endpoints = reader.ReadPastArray( + static (ref RespReader itemReader) => { - var pairs = item.GetItems(); - string? ip = null; - int port = default; - if (KeyValuePairParser.TryRead(pairs, in KeyValuePairParser.IP, ref ip) - && KeyValuePairParser.TryRead(pairs, in KeyValuePairParser.Port, ref port)) + if (itemReader.IsAggregate) { - endPoints.Add(Format.ParseEndPoint(ip, port)); + // Parse key-value pairs by name: ["ip", "127.0.0.1", "port", "26379"] + // or ["port", "26379", "ip", "127.0.0.1"] - order doesn't matter + string? host = null; + long portValue = 0; + + while (itemReader.TryMoveNext() && itemReader.IsScalar) + { + SentinelAddressField field; + unsafe + { + if (!itemReader.TryParseScalar( + &SentinelAddressFieldMetadata.TryParse, + out field)) + { + field = SentinelAddressField.Unknown; + } + } + + // Check for second scalar value + if (!(itemReader.TryMoveNext() && itemReader.IsScalar)) break; + + switch (field) + { + case SentinelAddressField.Ip: + host = itemReader.ReadString(); + break; + + case SentinelAddressField.Port: + itemReader.TryReadInt64(out portValue); + break; + } + } + + if (host is not null && portValue > 0) + { + return Format.ParseEndPoint(host, checked((int)portValue)); + } } - } - SetResult(message, endPoints.ToArray()); - return true; + return null; + }, + scalar: false); - case ResultType.SimpleString: - // We don't want to blow up if the primary is not found - if (result.IsNull) - return true; - break; + var filtered = FilterNullEndpoints(endpoints); + if (filtered is not null) + { + SetResult(message, filtered); + return true; + } } return false; } } - private sealed class SentinelGetReplicaAddressesProcessor : ResultProcessor + private sealed partial class SentinelGetReplicaAddressesProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - List endPoints = []; - - switch (result.Resp2TypeArray) + if (reader.IsAggregate) { - case ResultType.Array: - foreach (RawResult item in result.GetItems()) + var endPoints = reader.ReadPastArray( + static (ref RespReader r) => { - var pairs = item.GetItems(); - string? ip = null; - int port = default; - if (KeyValuePairParser.TryRead(pairs, in KeyValuePairParser.IP, ref ip) - && KeyValuePairParser.TryRead(pairs, in KeyValuePairParser.Port, ref port)) + if (r.IsAggregate) { - endPoints.Add(Format.ParseEndPoint(ip, port)); + // Parse key-value pairs by name: ["ip", "127.0.0.1", "port", "6380"] + // or ["port", "6380", "ip", "127.0.0.1"] - order doesn't matter + string? host = null; + long portValue = 0; + + while (r.TryMoveNext() && r.IsScalar) + { + SentinelAddressField field; + unsafe + { + if (!r.TryParseScalar( + &SentinelAddressFieldMetadata.TryParse, + out field)) + { + field = SentinelAddressField.Unknown; + } + } + + // Check for second scalar value + if (!(r.TryMoveNext() && r.IsScalar)) break; + + switch (field) + { + case SentinelAddressField.Ip: + host = r.ReadString(); + break; + + case SentinelAddressField.Port: + r.TryReadInt64(out portValue); + break; + } + } + + if (host is not null && portValue > 0) + { + return Format.ParseEndPoint(host, checked((int)portValue)); + } } - } - break; + return null; + }, + scalar: false); - case ResultType.SimpleString: - // We don't want to blow up if the primary is not found - if (result.IsNull) - return true; - break; + var filtered = FilterNullEndpoints(endPoints); + if (filtered is not null && filtered.Length > 0) + { + SetResult(message, filtered); + return true; + } } - - if (endPoints.Count > 0) + else if (reader.IsScalar && reader.IsNull) { - SetResult(message, endPoints.ToArray()); + // We don't want to blow up if the primary is not found return true; } @@ -3053,34 +3467,38 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes private sealed class SentinelArrayOfArraysProcessor : ResultProcessor[][]> { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + private readonly struct ParseArrayState(StringPairInterleavedProcessor innerProcessor, RedisProtocol protocol, Message message) + { + public readonly StringPairInterleavedProcessor innerProcessor = innerProcessor; + public readonly RedisProtocol protocol = protocol; + public readonly Message message = message; + } + + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { if (StringPairInterleaved is not StringPairInterleavedProcessor innerProcessor) { return false; } - switch (result.Resp2TypeArray) + if (reader.IsAggregate && !reader.IsNull) { - case ResultType.Array: - var arrayOfArrays = result.GetItems(); - - var returnArray = result.ToArray[], StringPairInterleavedProcessor>( - (in RawResult rawInnerArray, in StringPairInterleavedProcessor proc) => + var protocol = connection.Protocol.GetValueOrDefault(); + var state = new ParseArrayState(innerProcessor, protocol, message); + var returnArray = reader.ReadPastArray( + ref state, + static (ref state, ref innerReader) => + { + if (!innerReader.IsAggregate) { - if (proc.TryParse(rawInnerArray, out KeyValuePair[]? kvpArray)) - { - return kvpArray!; - } - else - { - throw new ArgumentOutOfRangeException(nameof(rawInnerArray), $"Error processing {message.CommandAndKey}, could not decode array '{rawInnerArray}'"); - } - }, - innerProcessor)!; + throw new ArgumentOutOfRangeException(nameof(innerReader), $"Error processing {state.message.CommandAndKey}, expected array but got scalar"); + } + return state.innerProcessor.ParseArray(ref innerReader, state.protocol, false, out _, null)!; + }, + scalar: false); - SetResult(message, returnArray); - return true; + SetResult(message, returnArray!); + return true; } return false; } @@ -3101,34 +3519,27 @@ protected static void SetResult(Message? message, T value) internal abstract class ArrayResultProcessor : ResultProcessor { - protected override bool SetResultCore(PhysicalConnection connection, Message message, in RawResult result) + protected override bool SetResultCore(PhysicalConnection connection, Message message, ref RespReader reader) { - switch (result.Resp2TypeArray) - { - case ResultType.Array: - var items = result.GetItems(); - T[] arr; - if (items.IsEmpty) - { - arr = []; - } - else + if (!reader.IsAggregate) return false; + + var self = this; + var arr = reader.ReadPastArray( + ref self, + static (ref s, ref r) => + { + if (!s.TryParse(ref r, out var parsed)) { - arr = new T[checked((int)items.Length)]; - int index = 0; - foreach (ref RawResult inner in items) - { - if (!TryParse(inner, out arr[index++])) - return false; - } + throw new InvalidOperationException("Failed to parse array element"); } - SetResult(message, arr); - return true; - default: - return false; - } + return parsed; + }, + scalar: false); + + SetResult(message, arr!); + return true; } - protected abstract bool TryParse(in RawResult raw, out T parsed); + protected abstract bool TryParse(ref RespReader reader, out T parsed); } } diff --git a/src/StackExchange.Redis/RoleType.cs b/src/StackExchange.Redis/RoleType.cs new file mode 100644 index 000000000..2edbc6618 --- /dev/null +++ b/src/StackExchange.Redis/RoleType.cs @@ -0,0 +1,50 @@ +using System; +using RESPite; + +namespace StackExchange.Redis; + +/// +/// Redis server role types. +/// +// [AsciiHash(nameof(RoleTypeMetadata))] +internal enum RoleType +{ + /// + /// Unknown or unrecognized role. + /// + [AsciiHash("")] + Unknown = 0, + + /// + /// Master role. + /// + [AsciiHash("master")] + Master, + + /// + /// Slave role (deprecated term). + /// + [AsciiHash("slave")] + Slave, + + /// + /// Replica role (preferred term for slave). + /// + [AsciiHash("replica")] + Replica, + + /// + /// Sentinel role. + /// + [AsciiHash("sentinel")] + Sentinel, +} + +/// +/// Metadata and parsing methods for RoleType. +/// +internal static partial class RoleTypeMetadata +{ + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out RoleType role); +} diff --git a/src/StackExchange.Redis/SentinelAddressField.cs b/src/StackExchange.Redis/SentinelAddressField.cs new file mode 100644 index 000000000..bafc2ea0f --- /dev/null +++ b/src/StackExchange.Redis/SentinelAddressField.cs @@ -0,0 +1,37 @@ +using System; +using RESPite; + +namespace StackExchange.Redis; + +/// +/// Sentinel address field names. +/// +internal enum SentinelAddressField +{ + /// + /// Unknown or unrecognized field. + /// + [AsciiHash("")] + Unknown = 0, + + /// + /// IP address field. + /// + [AsciiHash("ip")] + Ip, + + /// + /// Port field. + /// + [AsciiHash("port")] + Port, +} + +/// +/// Metadata for SentinelAddressField enum parsing. +/// +internal static partial class SentinelAddressFieldMetadata +{ + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out SentinelAddressField field); +} diff --git a/src/StackExchange.Redis/ServerEndPoint.cs b/src/StackExchange.Redis/ServerEndPoint.cs index 129cfbfed..55f2a6084 100644 --- a/src/StackExchange.Redis/ServerEndPoint.cs +++ b/src/StackExchange.Redis/ServerEndPoint.cs @@ -387,7 +387,7 @@ internal void AddScript(string script, byte[] hash) } } - internal async Task AutoConfigureAsync(PhysicalConnection? connection, ILogger? log = null) + internal async Task AutoConfigureAsync(PhysicalConnection? connection, ILogger? log = null, CommandFlags extraFlags = CommandFlags.None) { if (!serverType.SupportsAutoConfigure()) { @@ -399,7 +399,7 @@ internal async Task AutoConfigureAsync(PhysicalConnection? connection, ILogger? log?.LogInformationAutoConfiguring(new(this)); var commandMap = Multiplexer.CommandMap; - const CommandFlags flags = CommandFlags.FireAndForget | CommandFlags.NoRedirect; + var flags = CommandFlags.FireAndForget | CommandFlags.NoRedirect | extraFlags; var features = GetFeatures(); Message msg; @@ -409,11 +409,11 @@ internal async Task AutoConfigureAsync(PhysicalConnection? connection, ILogger? { if (Multiplexer.RawConfig.KeepAlive <= 0) { - msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.GET, RedisLiterals.timeout); + msg = Message.Create(-1, flags | Message.NoFlushFlag, RedisCommand.CONFIG, RedisLiterals.GET, RedisLiterals.timeout); msg.SetInternalCall(); await WriteDirectOrQueueFireAndForgetAsync(connection, msg, autoConfigProcessor).ForAwait(); } - msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.GET, features.ReplicaCommands ? RedisLiterals.replica_read_only : RedisLiterals.slave_read_only); + msg = Message.Create(-1, flags | Message.NoFlushFlag, RedisCommand.CONFIG, RedisLiterals.GET, features.ReplicaCommands ? RedisLiterals.replica_read_only : RedisLiterals.slave_read_only); msg.SetInternalCall(); await WriteDirectOrQueueFireAndForgetAsync(connection, msg, autoConfigProcessor).ForAwait(); msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.GET, RedisLiterals.databases); @@ -680,7 +680,7 @@ static async Task OnEstablishingAsyncAwaited(PhysicalConnection connection, Task var handshake = HandshakeAsync(connection, log); - if (handshake.Status != TaskStatus.RanToCompletion) + if (!handshake.IsCompletedSuccessfully) { return OnEstablishingAsyncAwaited(connection, handshake); } @@ -934,6 +934,8 @@ internal ValueTask WriteDirectOrQueueFireAndForgetAsync(PhysicalConnection? c { return Awaited(result); } + // Must consume the ValueTask even on success path + result.GetAwaiter().GetResult(); } return default; } @@ -1000,7 +1002,7 @@ private async Task HandshakeAsync(PhysicalConnection connection, ILogger? log) if (Multiplexer.RawConfig.TryResp3()) // note this includes an availability check on HELLO { log?.LogInformationAuthenticatingViaHello(new(this)); - var hello = Message.CreateHello(3, user, password, clientName, CommandFlags.FireAndForget); + var hello = Message.CreateHello(3, user, password, clientName, CommandFlags.FireAndForget | Message.NoFlushFlag); hello.SetInternalCall(); await WriteDirectOrQueueFireAndForgetAsync(connection, hello, autoConfig ??= ResultProcessor.AutoConfigureProcessor.Create(log)).ForAwait(); @@ -1018,14 +1020,14 @@ private async Task HandshakeAsync(PhysicalConnection connection, ILogger? log) if (!string.IsNullOrWhiteSpace(user) && Multiplexer.CommandMap.IsAvailable(RedisCommand.AUTH)) { log?.LogInformationAuthenticatingUserPassword(new(this)); - msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.AUTH, (RedisValue)user, (RedisValue)password); + msg = Message.Create(-1, CommandFlags.FireAndForget | Message.NoFlushFlag, RedisCommand.AUTH, (RedisValue)user, (RedisValue)password); msg.SetInternalCall(); await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.DemandOK).ForAwait(); } else if (!string.IsNullOrWhiteSpace(password) && Multiplexer.CommandMap.IsAvailable(RedisCommand.AUTH)) { log?.LogInformationAuthenticatingPassword(new(this)); - msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.AUTH, (RedisValue)password); + msg = Message.Create(-1, CommandFlags.FireAndForget | Message.NoFlushFlag, RedisCommand.AUTH, (RedisValue)password); msg.SetInternalCall(); await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.DemandOK).ForAwait(); } @@ -1035,7 +1037,7 @@ private async Task HandshakeAsync(PhysicalConnection connection, ILogger? log) if (!string.IsNullOrWhiteSpace(clientName)) { log?.LogInformationSettingClientName(new(this), clientName); - msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.CLIENT, RedisLiterals.SETNAME, (RedisValue)clientName); + msg = Message.Create(-1, CommandFlags.FireAndForget | Message.NoFlushFlag, RedisCommand.CLIENT, RedisLiterals.SETNAME, (RedisValue)clientName); msg.SetInternalCall(); await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.DemandOK).ForAwait(); } @@ -1049,7 +1051,7 @@ private async Task HandshakeAsync(PhysicalConnection connection, ILogger? log) var libName = Multiplexer.GetFullLibraryName(); if (!string.IsNullOrWhiteSpace(libName)) { - msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.CLIENT, RedisLiterals.SETINFO, RedisLiterals.lib_name, libName); + msg = Message.Create(-1, CommandFlags.FireAndForget | Message.NoFlushFlag, RedisCommand.CLIENT, RedisLiterals.SETINFO, RedisLiterals.lib_name, libName); msg.SetInternalCall(); await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.DemandOK).ForAwait(); } @@ -1057,13 +1059,13 @@ private async Task HandshakeAsync(PhysicalConnection connection, ILogger? log) var version = ClientInfoSanitize(Utils.GetLibVersion()); if (!string.IsNullOrWhiteSpace(version)) { - msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.CLIENT, RedisLiterals.SETINFO, RedisLiterals.lib_ver, version); + msg = Message.Create(-1, CommandFlags.FireAndForget | Message.NoFlushFlag, RedisCommand.CLIENT, RedisLiterals.SETINFO, RedisLiterals.lib_ver, version); msg.SetInternalCall(); await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.DemandOK).ForAwait(); } } - msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.CLIENT, RedisLiterals.ID); + msg = Message.Create(-1, CommandFlags.FireAndForget | Message.NoFlushFlag, RedisCommand.CLIENT, RedisLiterals.ID); msg.SetInternalCall(); await WriteDirectOrQueueFireAndForgetAsync(connection, msg, autoConfig ??= ResultProcessor.AutoConfigureProcessor.Create(log)).ForAwait(); } @@ -1077,9 +1079,10 @@ private async Task HandshakeAsync(PhysicalConnection connection, ILogger? log) var connType = bridge.ConnectionType; if (connType == ConnectionType.Interactive) { - await AutoConfigureAsync(connection, log).ForAwait(); + await AutoConfigureAsync(connection, log, extraFlags: Message.NoFlushFlag).ForAwait(); } + // note that the final messages *are* flushed (no Message.NoFlushFlag) var tracer = GetTracerMessage(true); tracer.SetHandshakeCompletion(); tracer = LoggingMessage.Create(log, tracer); @@ -1100,7 +1103,7 @@ private async Task HandshakeAsync(PhysicalConnection connection, ILogger? log) } } log?.LogInformationFlushingOutboundBuffer(new(this)); - await connection.FlushAsync().ForAwait(); + connection.Flush(); } private void SetConfig(ref T field, T value, [CallerMemberName] string? caller = null) @@ -1123,6 +1126,8 @@ private void ClearMemoized() supportsPrimaryWrites = null; } + internal bool CanSimulateConnectionFailure => interactive?.CanSimulateConnectionFailure == true; + /// /// For testing only. /// diff --git a/src/StackExchange.Redis/ServerSelectionStrategy.cs b/src/StackExchange.Redis/ServerSelectionStrategy.cs index e7917310e..5025b732d 100644 --- a/src/StackExchange.Redis/ServerSelectionStrategy.cs +++ b/src/StackExchange.Redis/ServerSelectionStrategy.cs @@ -2,6 +2,8 @@ using System.Buffers; using System.Diagnostics; using System.Net; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; using System.Threading; namespace StackExchange.Redis @@ -62,42 +64,43 @@ internal sealed class ServerSelectionStrategy public ServerType ServerType { get; set; } = ServerType.Standalone; internal static int TotalSlots => RedisClusterSlotCount; - /// - /// Computes the hash-slot that would be used by the given key. - /// - /// The to determine a slot ID for. - public int HashSlot(in RedisKey key) + internal static int GetHashSlot(in RedisKey key) { - if (ServerType == ServerType.Standalone || key.IsNull) return NoSlot; + if (key.IsNull) return NoSlot; if (key.TryGetSimpleBuffer(out var arr)) // key was constructed from a byte[] { return GetClusterSlot(arr); } + var length = key.TotalLength(); + if (length <= 256) + { + Span span = stackalloc byte[length]; + var written = key.CopyTo(span); + Debug.Assert(written == length, "key length/write error"); + return GetClusterSlot(span); + } else { - var length = key.TotalLength(); - if (length <= 256) - { - Span span = stackalloc byte[length]; - var written = key.CopyTo(span); - Debug.Assert(written == length, "key length/write error"); - return GetClusterSlot(span); - } - else - { - arr = ArrayPool.Shared.Rent(length); - var span = new Span(arr, 0, length); - var written = key.CopyTo(span); - Debug.Assert(written == length, "key length/write error"); - var result = GetClusterSlot(span); - ArrayPool.Shared.Return(arr); - return result; - } + arr = ArrayPool.Shared.Rent(length); + var span = new Span(arr, 0, length); + var written = key.CopyTo(span); + Debug.Assert(written == length, "key length/write error"); + var result = GetClusterSlot(span); + ArrayPool.Shared.Return(arr); + return result; } } private byte[] ChannelPrefix => multiplexer?.ChannelPrefix ?? []; + /// + /// Computes the hash-slot that would be used by the given key. + /// + /// The to determine a slot ID for. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int HashSlot(in RedisKey key) + => ServerType is ServerType.Standalone ? NoSlot : GetHashSlot(key); + /// /// Computes the hash-slot that would be used by the given channel. /// @@ -139,7 +142,7 @@ internal static unsafe int GetClusterSlot(ReadOnlySpan key) { unchecked { - fixed (byte* ptr = key) + fixed (byte* ptr = &MemoryMarshal.GetReference(key)) { fixed (ushort* crc16tab = ServerSelectionStrategy.Crc16tab) { diff --git a/src/StackExchange.Redis/SetOperationCardinalityMessage.cs b/src/StackExchange.Redis/SetOperationCardinalityMessage.cs index 2fbd153ea..511923c40 100644 --- a/src/StackExchange.Redis/SetOperationCardinalityMessage.cs +++ b/src/StackExchange.Redis/SetOperationCardinalityMessage.cs @@ -13,19 +13,19 @@ internal sealed class SetOperationCardinalityMessage( public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => serverSelectionStrategy.HashSlot(_keys); - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.WriteBulkString(_keys.Length); + writer.WriteHeader(Command, ArgCount); + writer.WriteBulkString(_keys.Length); for (var i = 0; i < _keys.Length; i++) { - physical.Write(_keys[i]); + writer.Write(_keys[i]); } if (limit > 0) { - physical.WriteRaw("$5\r\nLIMIT\r\n"u8); - physical.WriteBulkString(limit); + writer.WriteRaw("$5\r\nLIMIT\r\n"u8); + writer.WriteBulkString(limit); } } } diff --git a/src/StackExchange.Redis/SetOperationMessage.cs b/src/StackExchange.Redis/SetOperationMessage.cs index b335cb5a8..a4b55ec49 100644 --- a/src/StackExchange.Redis/SetOperationMessage.cs +++ b/src/StackExchange.Redis/SetOperationMessage.cs @@ -42,21 +42,21 @@ public SetOperationMessage( public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy) => serverSelectionStrategy.HashSlot(_keys); - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.WriteBulkString(_keys.Length); + writer.WriteHeader(Command, ArgCount); + writer.WriteBulkString(_keys.Length); for (var i = 0; i < _keys.Length; i++) { - physical.Write(_keys[i]); + writer.Write(_keys[i]); } if (_weights?.Length > 0) { - physical.WriteRaw("$7\r\nWEIGHTS\r\n"u8); + writer.WriteRaw("$7\r\nWEIGHTS\r\n"u8); for (var i = 0; i < _weights.Length; i++) { - physical.WriteBulkString(_weights[i]); + writer.WriteBulkString(_weights[i]); } } @@ -65,19 +65,19 @@ protected override void WriteImpl(PhysicalConnection physical) case Aggregate.Sum: break; case Aggregate.Min: - physical.WriteRaw("$9\r\nAGGREGATE\r\n$3\r\nMIN\r\n"u8); + writer.WriteRaw("$9\r\nAGGREGATE\r\n$3\r\nMIN\r\n"u8); break; case Aggregate.Max: - physical.WriteRaw("$9\r\nAGGREGATE\r\n$3\r\nMAX\r\n"u8); + writer.WriteRaw("$9\r\nAGGREGATE\r\n$3\r\nMAX\r\n"u8); break; case Aggregate.Count: - physical.WriteRaw("$9\r\nAGGREGATE\r\n$5\r\nCOUNT\r\n"u8); + writer.WriteRaw("$9\r\nAGGREGATE\r\n$5\r\nCOUNT\r\n"u8); break; } if (_withScores) { - physical.WriteRaw("$10\r\nWITHSCORES\r\n"u8); + writer.WriteRaw("$10\r\nWITHSCORES\r\n"u8); } } diff --git a/src/StackExchange.Redis/SocketManager.cs b/src/StackExchange.Redis/SocketManager.cs index d75d473d9..145c5ae06 100644 --- a/src/StackExchange.Redis/SocketManager.cs +++ b/src/StackExchange.Redis/SocketManager.cs @@ -1,11 +1,8 @@ using System; using System.Diagnostics; -using System.IO.Pipelines; using System.Net; using System.Net.Sockets; using System.Runtime.InteropServices; -using System.Threading; -using Pipelines.Sockets.Unofficial; namespace StackExchange.Redis { @@ -14,6 +11,7 @@ namespace StackExchange.Redis /// the Socket.Select API and a dedicated reader-thread, which allows for fast responses /// even when the system is under ambient load. /// + [Obsolete("SocketManager is no longer used by StackExchange.Redis")] public sealed partial class SocketManager : IDisposable { /// @@ -26,7 +24,7 @@ public sealed partial class SocketManager : IDisposable /// /// The name for this . public SocketManager(string name) - : this(name, DEFAULT_WORKERS, SocketManagerOptions.None) { } + : this(name, 0, SocketManagerOptions.None) { } /// /// Creates a new instance. @@ -34,7 +32,7 @@ public SocketManager(string name) /// The name for this . /// Whether this should use high priority sockets. public SocketManager(string name, bool useHighPrioritySocketThreads) - : this(name, DEFAULT_WORKERS, UseHighPrioritySocketThreads(useHighPrioritySocketThreads)) { } + : this(name, 0, UseHighPrioritySocketThreads(useHighPrioritySocketThreads)) { } /// /// Creates a new (optionally named) instance. @@ -79,142 +77,31 @@ public enum SocketManagerOptions public SocketManager(string? name = null, int workerCount = 0, SocketManagerOptions options = SocketManagerOptions.None) { if (name.IsNullOrWhiteSpace()) name = GetType().Name; - if (workerCount <= 0) workerCount = DEFAULT_WORKERS; Name = name; - bool useHighPrioritySocketThreads = (options & SocketManagerOptions.UseHighPrioritySocketThreads) != 0, - useThreadPool = (options & SocketManagerOptions.UseThreadPool) != 0; - - const long Receive_PauseWriterThreshold = 4L * 1024 * 1024 * 1024; // receive: let's give it up to 4GiB of buffer for now - const long Receive_ResumeWriterThreshold = 3L * 1024 * 1024 * 1024; // (large replies get crazy big) - - var defaultPipeOptions = PipeOptions.Default; - - long send_PauseWriterThreshold = Math.Max( - 512 * 1024, // send: let's give it up to 0.5MiB - defaultPipeOptions.PauseWriterThreshold); // or the default, whichever is bigger - long send_ResumeWriterThreshold = Math.Max( - send_PauseWriterThreshold / 2, - defaultPipeOptions.ResumeWriterThreshold); - - Scheduler = PipeScheduler.ThreadPool; - if (!useThreadPool) - { - Scheduler = new DedicatedThreadPoolPipeScheduler( - name: name + ":IO", - workerCount: workerCount, - priority: useHighPrioritySocketThreads ? ThreadPriority.AboveNormal : ThreadPriority.Normal); - } - SendPipeOptions = new PipeOptions( - pool: defaultPipeOptions.Pool, - readerScheduler: Scheduler, - writerScheduler: Scheduler, - pauseWriterThreshold: send_PauseWriterThreshold, - resumeWriterThreshold: send_ResumeWriterThreshold, - minimumSegmentSize: Math.Max(defaultPipeOptions.MinimumSegmentSize, MINIMUM_SEGMENT_SIZE), - useSynchronizationContext: false); - ReceivePipeOptions = new PipeOptions( - pool: defaultPipeOptions.Pool, - readerScheduler: Scheduler, - writerScheduler: Scheduler, - pauseWriterThreshold: Receive_PauseWriterThreshold, - resumeWriterThreshold: Receive_ResumeWriterThreshold, - minimumSegmentSize: Math.Max(defaultPipeOptions.MinimumSegmentSize, MINIMUM_SEGMENT_SIZE), - useSynchronizationContext: false); + _ = workerCount; + _ = options; } /// /// Default / shared socket manager using a dedicated thread-pool. /// - public static SocketManager Shared - { - get - { - var shared = s_shared; - if (shared != null) return shared; - try - { - // note: we'll allow a higher max thread count on the shared one - shared = new SocketManager("DefaultSocketManager", DEFAULT_WORKERS * 2, false); - if (Interlocked.CompareExchange(ref s_shared, shared, null) == null) - shared = null; - } - finally { shared?.Dispose(); } - return Volatile.Read(ref s_shared); - } - } + public static SocketManager Shared => ThreadPool; /// /// Shared socket manager using the main thread-pool. /// - public static SocketManager ThreadPool - { - get - { - var shared = s_threadPool; - if (shared != null) return shared; - try - { - // note: we'll allow a higher max thread count on the shared one - shared = new SocketManager("ThreadPoolSocketManager", options: SocketManagerOptions.UseThreadPool); - if (Interlocked.CompareExchange(ref s_threadPool, shared, null) == null) - shared = null; - } - finally { shared?.Dispose(); } - return Volatile.Read(ref s_threadPool); - } - } + public static SocketManager ThreadPool { get; } = new("ThreadPoolSocketManager", options: SocketManagerOptions.UseThreadPool); /// /// Returns a string that represents the current object. /// /// A string that represents the current object. - public override string ToString() - { - var scheduler = SchedulerPool; - if (scheduler == null) return Name; - return $"{Name} - queue: {scheduler?.TotalServicedByQueue}, pool: {scheduler?.TotalServicedByPool}"; - } - - private static SocketManager? s_shared, s_threadPool; - - private const int DEFAULT_WORKERS = 5, MINIMUM_SEGMENT_SIZE = 8 * 1024; - - internal readonly PipeOptions SendPipeOptions, ReceivePipeOptions; - - internal PipeScheduler Scheduler { get; private set; } - - internal DedicatedThreadPoolPipeScheduler? SchedulerPool => Scheduler as DedicatedThreadPoolPipeScheduler; - - private enum CallbackOperation - { - Read, - Error, - } + public override string ToString() => Name; /// /// Releases all resources associated with this instance. /// - public void Dispose() - { - DisposeRefs(); - GC.SuppressFinalize(this); - OnDispose(); - } - - private void DisposeRefs() - { - // note: the scheduler *can't* be collected by itself - there will - // be threads, and those threads will be rooting the DedicatedThreadPool; - // but: we can lend a hand! We need to do this even in the finalizer - var tmp = SchedulerPool; - Scheduler = PipeScheduler.ThreadPool; - try { tmp?.Dispose(); } catch { } - } - - /// - /// Releases *appropriate* resources associated with this instance. - /// - ~SocketManager() => DisposeRefs(); + public void Dispose() { } internal static Socket CreateSocket(EndPoint endpoint, bool tcpKeepAlive) { @@ -224,17 +111,27 @@ internal static Socket CreateSocket(EndPoint endpoint, bool tcpKeepAlive) var socket = addressFamily == AddressFamily.Unspecified ? new Socket(SocketType.Stream, protocolType) : new Socket(addressFamily, SocketType.Stream, protocolType); - SocketConnection.SetRecommendedClientOptions(socket); + TrySetNoDelay(socket); if (tcpKeepAlive) TryEnableTcpKeepAlive(socket, endpoint); return socket; } - partial void OnDispose(); - - internal string? GetState() + internal static bool TrySetNoDelay(Socket socket) { - var s = SchedulerPool; - return s == null ? null : $"{s.AvailableCount} of {s.WorkerCount} available"; + try + { + if (socket.AddressFamily is not AddressFamily.Unix) + { + socket.NoDelay = true; + return true; + } + } + catch (Exception ex) + { + Debug.WriteLine(ex.Message, nameof(Socket)); + } + + return false; } internal static bool TryEnableTcpKeepAlive(Socket socket, EndPoint endPoint) diff --git a/src/StackExchange.Redis/SortedSetAddMessage.cs b/src/StackExchange.Redis/SortedSetAddMessage.cs index 46f8d97bf..d87960d5a 100644 --- a/src/StackExchange.Redis/SortedSetAddMessage.cs +++ b/src/StackExchange.Redis/SortedSetAddMessage.cs @@ -23,15 +23,15 @@ private abstract class SortedSetAddMessage( protected abstract int EntryCount { get; } - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - WriteOptions(physical); - WriteEntries(physical); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + WriteOptions(writer); + WriteEntries(writer); } - protected abstract void WriteEntries(PhysicalConnection physical); + protected abstract void WriteEntries(in MessageWriter writer); private int GetOptionCount() { @@ -56,31 +56,31 @@ private static SortedSetWhen GetWhen(SortedSetWhen when, bool change, bool incre return when; } - private void WriteOptions(PhysicalConnection physical) + private void WriteOptions(in MessageWriter physical) { if ((_when & SortedSetWhen.NotExists) != 0) { - physical.WriteBulkString("NX"u8); + physical.WriteRaw("$2\r\nNX\r\n"u8); } if ((_when & SortedSetWhen.Exists) != 0) { - physical.WriteBulkString("XX"u8); + physical.WriteRaw("$2\r\nXX\r\n"u8); } if ((_when & SortedSetWhen.GreaterThan) != 0) { - physical.WriteBulkString("GT"u8); + physical.WriteRaw("$2\r\nGT\r\n"u8); } if ((_when & SortedSetWhen.LessThan) != 0) { - physical.WriteBulkString("LT"u8); + physical.WriteRaw("$2\r\nLT\r\n"u8); } if ((_when & Change) != 0) { - physical.WriteBulkString("CH"u8); + physical.WriteRaw("$2\r\nCH\r\n"u8); } if ((_when & Increment) != 0) { - physical.WriteBulkString("INCR"u8); + physical.WriteRaw("$4\r\nINCR\r\n"u8); } } } @@ -100,10 +100,10 @@ private sealed class SingleSortedSetAddMessage( protected override int EntryCount => 1; - protected override void WriteEntries(PhysicalConnection physical) + protected override void WriteEntries(in MessageWriter writer) { - physical.WriteBulkString(_score); - physical.WriteBulkString(_member); + writer.WriteBulkString(_score); + writer.WriteBulkString(_member); } private static RedisValue AssertMember(in RedisValue member) @@ -125,12 +125,12 @@ private sealed class MultipleSortedSetAddMessage( protected override int EntryCount => _values.Length; - protected override void WriteEntries(PhysicalConnection physical) + protected override void WriteEntries(in MessageWriter writer) { for (int i = 0; i < _values.Length; i++) { - physical.WriteBulkString(_values[i].score); - physical.WriteBulkString(_values[i].element); + writer.WriteBulkString(_values[i].score); + writer.WriteBulkString(_values[i].element); } } diff --git a/src/StackExchange.Redis/StackExchange.Redis.csproj b/src/StackExchange.Redis/StackExchange.Redis.csproj index 4bff8ce53..d3dd60aae 100644 --- a/src/StackExchange.Redis/StackExchange.Redis.csproj +++ b/src/StackExchange.Redis/StackExchange.Redis.csproj @@ -12,17 +12,18 @@ $(DefineConstants);VECTOR_SAFE $(DefineConstants);UNIX_SOCKET README.md + + + - - - - + + + - - - + + @@ -55,8 +56,6 @@ - - - + \ No newline at end of file diff --git a/src/StackExchange.Redis/StreamConsumerInfoField.cs b/src/StackExchange.Redis/StreamConsumerInfoField.cs new file mode 100644 index 000000000..3f0816763 --- /dev/null +++ b/src/StackExchange.Redis/StreamConsumerInfoField.cs @@ -0,0 +1,43 @@ +using System; +using RESPite; + +namespace StackExchange.Redis; + +/// +/// Fields that can appear in an XINFO CONSUMERS command response. +/// +internal enum StreamConsumerInfoField +{ + /// + /// Unknown or unrecognized field. + /// + [AsciiHash("")] + Unknown = 0, + + /// + /// Consumer name. + /// + [AsciiHash("name")] + Name, + + /// + /// Number of pending messages. + /// + [AsciiHash("pending")] + Pending, + + /// + /// Idle time in milliseconds. + /// + [AsciiHash("idle")] + Idle, +} + +/// +/// Metadata and parsing methods for StreamConsumerInfoField. +/// +internal static partial class StreamConsumerInfoFieldMetadata +{ + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out StreamConsumerInfoField field); +} diff --git a/src/StackExchange.Redis/StreamGroupInfoField.cs b/src/StackExchange.Redis/StreamGroupInfoField.cs new file mode 100644 index 000000000..091ab3f6a --- /dev/null +++ b/src/StackExchange.Redis/StreamGroupInfoField.cs @@ -0,0 +1,61 @@ +using System; +using RESPite; + +namespace StackExchange.Redis; + +/// +/// Fields that can appear in an XINFO GROUPS command response. +/// +internal enum StreamGroupInfoField +{ + /// + /// Unknown or unrecognized field. + /// + [AsciiHash("")] + Unknown = 0, + + /// + /// Group name. + /// + [AsciiHash("name")] + Name, + + /// + /// Number of consumers in the group. + /// + [AsciiHash("consumers")] + Consumers, + + /// + /// Number of pending messages. + /// + [AsciiHash("pending")] + Pending, + + /// + /// Last delivered ID. + /// + [AsciiHash("last-delivered-id")] + LastDeliveredId, + + /// + /// Number of entries read. + /// + [AsciiHash("entries-read")] + EntriesRead, + + /// + /// Lag value. + /// + [AsciiHash("lag")] + Lag, +} + +/// +/// Metadata and parsing methods for StreamGroupInfoField. +/// +internal static partial class StreamGroupInfoFieldMetadata +{ + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out StreamGroupInfoField field); +} diff --git a/src/StackExchange.Redis/StreamNackMessage.cs b/src/StackExchange.Redis/StreamNackMessage.cs index c562e150a..83b276b2b 100644 --- a/src/StackExchange.Redis/StreamNackMessage.cs +++ b/src/StackExchange.Redis/StreamNackMessage.cs @@ -41,31 +41,31 @@ protected StreamNackMessageBase(int db, CommandFlags flags, in RedisKey key, in protected abstract int Count { get; } - protected abstract void WriteIds(PhysicalConnection physical); + protected abstract void WriteIds(in MessageWriter writer); - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, ArgCount); - physical.Write(Key); - physical.WriteBulkString(groupName); - WriteMode(physical); - physical.WriteBulkString(StreamConstants.Ids); - physical.WriteBulkString(Count); - WriteIds(physical); + writer.WriteHeader(Command, ArgCount); + writer.Write(Key); + writer.WriteBulkString(groupName); + WriteMode(writer); + writer.WriteBulkString(StreamConstants.Ids); + writer.WriteBulkString(Count); + WriteIds(writer); } - private void WriteMode(PhysicalConnection physical) + private void WriteMode(in MessageWriter writer) { switch (mode) { case StreamNackMode.Silent: - physical.WriteBulkString("SILENT"u8); + writer.WriteRaw("$6\r\nSILENT\r\n"u8); break; case StreamNackMode.Fail: - physical.WriteBulkString("FAIL"u8); + writer.WriteRaw("$4\r\nFAIL\r\n"u8); break; case StreamNackMode.Fatal: - physical.WriteBulkString("FATAL"u8); + writer.WriteRaw("$5\r\nFATAL\r\n"u8); break; default: throw new ArgumentOutOfRangeException(nameof(mode)); @@ -88,7 +88,7 @@ public StreamNackMessageSingle(int db, CommandFlags flags, in RedisKey key, in R protected override int Count => 1; - protected override void WriteIds(PhysicalConnection physical) => physical.WriteBulkString(messageId); + protected override void WriteIds(in MessageWriter writer) => writer.WriteBulkString(messageId); } internal sealed class StreamNackMessageMulti : StreamNackMessageBase @@ -109,11 +109,11 @@ public StreamNackMessageMulti(int db, CommandFlags flags, in RedisKey key, in Re protected override int Count => messageIds.Length; - protected override void WriteIds(PhysicalConnection physical) + protected override void WriteIds(in MessageWriter writer) { for (int i = 0; i < messageIds.Length; i++) { - physical.WriteBulkString(messageIds[i]); + writer.WriteBulkString(messageIds[i]); } } } diff --git a/src/StackExchange.Redis/Subscription.cs b/src/StackExchange.Redis/Subscription.cs index 99f3d00cb..cb924a29a 100644 --- a/src/StackExchange.Redis/Subscription.cs +++ b/src/StackExchange.Redis/Subscription.cs @@ -4,7 +4,6 @@ using System.Net; using System.Threading; using System.Threading.Tasks; -using Pipelines.Sockets.Unofficial; namespace StackExchange.Redis; diff --git a/src/StackExchange.Redis/TaskExtensions.cs b/src/StackExchange.Redis/TaskExtensions.cs index 5b5684da1..989c0861e 100644 --- a/src/StackExchange.Redis/TaskExtensions.cs +++ b/src/StackExchange.Redis/TaskExtensions.cs @@ -46,7 +46,7 @@ static async Task Wrap(Task task, CancellationToken cancellationToken) else tcs.TrySetResult(t.Result); }, tcs); - return await tcs.Task; + return await tcs.Task.ForAwait(); } } diff --git a/src/StackExchange.Redis/TestHarness.cs b/src/StackExchange.Redis/TestHarness.cs new file mode 100644 index 000000000..5b4395ffd --- /dev/null +++ b/src/StackExchange.Redis/TestHarness.cs @@ -0,0 +1,278 @@ +using System; +using System.Buffers; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Text; +using RESPite; +using RESPite.Messages; + +namespace StackExchange.Redis; + +/// +/// Allows unit testing RESP formatting and parsing. +/// +[Experimental(Experiments.UnitTesting, UrlFormat = Experiments.UrlFormat)] +public class TestHarness(CommandMap? commandMap = null, RedisChannel channelPrefix = default, RedisKey keyPrefix = default) +{ + /// + /// Channel prefix to use when writing values. + /// + public RedisChannel ChannelPrefix { get; } = channelPrefix; + + /// + /// Channel prefix to use when writing values. + /// + public RedisKey KeyPrefix => _keyPrefix; + private readonly byte[]? _keyPrefix = keyPrefix; + + /// + /// The command map to use when writing root commands. + /// + public CommandMap CommandMap { get; } = commandMap ?? CommandMap.Default; + + /// + /// Write a RESP frame from a command and set of arguments. + /// + public byte[] Write(string command, params ICollection args) + { + var msg = new RedisDatabase.ExecuteMessage(CommandMap, -1, CommandFlags.None, command, Fixup(args)); + var writer = new MessageWriter(ChannelPrefix, CommandMap, MessageWriter.BlockBuffer); + ReadOnlyMemory payload = default; + try + { + msg.WriteTo(writer); + payload = MessageWriter.FlushBlockBuffer(); + return payload.Span.ToArray(); + } + catch + { + MessageWriter.RevertBlockBuffer(); + throw; + } + finally + { + MessageWriter.ReleaseBlockBuffer(payload); + } + } + + /// + /// Write a RESP frame from a command and set of arguments. + /// + public void Write(IBufferWriter target, string command, params ICollection args) + { + // if we're using someone else's buffer writer, then we don't need to worry about our local + // memory-management rules + if (target is null) throw new ArgumentNullException(nameof(target)); + var msg = new RedisDatabase.ExecuteMessage(CommandMap, -1, CommandFlags.None, command, Fixup(args)); + var writer = new MessageWriter(ChannelPrefix, CommandMap, target); + msg.WriteTo(writer); + } + + /// + /// Report a validation failure. + /// + protected virtual void OnValidateFail(in RedisKey expected, in RedisKey actual) + => throw new InvalidOperationException($"Routing key is not equal: '{expected}' vs '{actual}' (hint: override {nameof(OnValidateFail)})"); + + /// + /// Report a validation failure. + /// + protected virtual void OnValidateFail(string expected, string actual) + => throw new InvalidOperationException($"RESP is not equal: '{expected}' vs '{actual}' (hint: override {nameof(OnValidateFail)})"); + + /// + /// Report a validation failure. + /// + protected virtual void OnValidateFail(ReadOnlyMemory expected, ReadOnlyMemory actual) + => OnValidateFail(Encoding.UTF8.GetString(expected.Span), Encoding.UTF8.GetString(actual.Span)); + + /// + /// Write a RESP frame from a command and set of arguments, and allow a callback to validate + /// the RESP content. + /// + public void ValidateResp(ReadOnlySpan expected, string command, params ICollection args) + { + var msg = new RedisDatabase.ExecuteMessage(CommandMap, -1, CommandFlags.None, command, Fixup(args)); + var writer = new MessageWriter(ChannelPrefix, CommandMap, MessageWriter.BlockBuffer); + ReadOnlyMemory actual = default; + byte[]? lease = null; + try + { + msg.WriteTo(writer); + actual = MessageWriter.FlushBlockBuffer(); + if (!expected.SequenceEqual(actual.Span)) + { + lease = ArrayPool.Shared.Rent(expected.Length); + expected.CopyTo(lease); + OnValidateFail(lease.AsMemory(0, expected.Length), lease); + } + } + catch + { + MessageWriter.RevertBlockBuffer(); + throw; + } + finally + { + if (lease is not null) ArrayPool.Shared.Return(lease); + MessageWriter.ReleaseBlockBuffer(actual); + } + } + + private ICollection Fixup(ICollection? args) + { + if (_keyPrefix is { Length: > 0 } && args is { } && args.Any(x => x is RedisKey)) + { + object[] copy = new object[args.Count]; + int i = 0; + foreach (object value in args) + { + if (value is RedisKey key) + { + copy[i++] = RedisKey.WithPrefix(_keyPrefix, key); + } + else + { + copy[i++] = value; + } + } + + return copy; + } + + return args ?? []; + } + + /// + /// Write a RESP frame from a command and set of arguments, and allow a callback to validate + /// the RESP content. + /// + public void ValidateResp(string expected, string command, params ICollection args) + { + var msg = new RedisDatabase.ExecuteMessage(CommandMap, 0, CommandFlags.None, command, Fixup(args)); + var writer = new MessageWriter(ChannelPrefix, CommandMap, MessageWriter.BlockBuffer); + ReadOnlyMemory payload = default; + char[]? lease = null; + try + { + msg.WriteTo(writer); + payload = MessageWriter.FlushBlockBuffer(); + lease = ArrayPool.Shared.Rent(Encoding.UTF8.GetMaxCharCount(payload.Length)); + var chars = Encoding.UTF8.GetChars(payload.Span, lease.AsSpan()); + var actual = lease.AsSpan(0, chars); + if (!actual.SequenceEqual(expected)) + { + OnValidateFail(expected, actual.ToString()); + } + } + catch + { + MessageWriter.RevertBlockBuffer(); + throw; + } + finally + { + if (lease is not null) ArrayPool.Shared.Return(lease); + MessageWriter.ReleaseBlockBuffer(payload); + } + } + + /// + /// A callback with a payload buffer. + /// + public delegate void BufferValidator(scoped ReadOnlySpan buffer); + + /// + /// Deserialize a RESP frame as a . + /// + public RedisResult Read(ReadOnlySpan value) + { + var reader = new RespReader(value); + if (!RedisResult.TryCreate(null, ref reader, out var result)) + { + throw new ArgumentException(nameof(value)); + } + return result; + } + + /// + /// Convenience handler for comparing span fragments, typically used with "Assert.Equal" or similar + /// as the handler. + /// + public static void AssertEqual( + ReadOnlySpan expected, + ReadOnlySpan actual, + Action, ReadOnlyMemory> handler) + { + if (!expected.SequenceEqual(actual)) Fault(expected, actual, handler); + static void Fault( + ReadOnlySpan expected, + ReadOnlySpan actual, + Action, ReadOnlyMemory> handler) + { + var lease = ArrayPool.Shared.Rent(expected.Length + actual.Length); + try + { + var leaseMemory = lease.AsMemory(); + var x = leaseMemory.Slice(0, expected.Length); + var y = leaseMemory.Slice(expected.Length, actual.Length); + expected.CopyTo(x.Span); + actual.CopyTo(y.Span); + handler(x, y); + } + finally + { + ArrayPool.Shared.Return(lease); + } + } + } + + /// + /// Convenience handler for comparing span fragments, typically used with "Assert.Equal" or similar + /// as the handler. + /// + public static void AssertEqual( + string expected, + ReadOnlySpan actual, + Action handler) + { + var lease = ArrayPool.Shared.Rent(Encoding.UTF8.GetMaxByteCount(expected.Length)); + try + { + var bytes = Encoding.UTF8.GetBytes(expected.AsSpan(), lease.AsSpan()); + var span = lease.AsSpan(0, bytes); + if (!span.SequenceEqual(actual)) handler(expected, Encoding.UTF8.GetString(span)); + } + finally + { + ArrayPool.Shared.Return(lease); + } + } + + /// + /// Verify that the routing of a command matches the intent. + /// + public void ValidateRouting(in RedisKey expected, params ICollection args) + { + var expectedWithPrefix = RedisKey.WithPrefix(_keyPrefix, expected); + var actual = ServerSelectionStrategy.NoSlot; + + RedisKey last = RedisKey.Null; + // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract + if (args is not null) + { + foreach (var arg in args) + { + if (arg is RedisKey key) + { + last = RedisKey.WithPrefix(_keyPrefix, key); + var slot = ServerSelectionStrategy.GetHashSlot(last); + actual = ServerSelectionStrategy.CombineSlot(actual, slot); + } + } + } + + if (ServerSelectionStrategy.GetHashSlot(expectedWithPrefix) != actual) OnValidateFail(expectedWithPrefix, last); + } +} diff --git a/src/StackExchange.Redis/TextWriterLogger.cs b/src/StackExchange.Redis/TextWriterLogger.cs index e2514118e..cce88577a 100644 --- a/src/StackExchange.Redis/TextWriterLogger.cs +++ b/src/StackExchange.Redis/TextWriterLogger.cs @@ -23,12 +23,12 @@ public TextWriterLogger(TextWriter writer, ILogger? wrapped) public void Log(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func formatter) { _wrapped?.Log(logLevel, eventId, state, exception, formatter); - if (_writer is TextWriter writer) + if (_writer is { } writer) { lock (writer) { // We check here again because it's possible we've released below, and never want to write past releasing. - if (_writer is TextWriter innerWriter) + if (_writer is { } innerWriter) { innerWriter.Write($"{DateTime.UtcNow:HH:mm:ss.ffff}: "); innerWriter.WriteLine(formatter(state, exception)); diff --git a/src/StackExchange.Redis/ValueCondition.cs b/src/StackExchange.Redis/ValueCondition.cs index c5cf4bd5a..240cdc951 100644 --- a/src/StackExchange.Redis/ValueCondition.cs +++ b/src/StackExchange.Redis/ValueCondition.cs @@ -67,10 +67,10 @@ public override string ToString() case ConditionKind.ValueNotEquals: return $"IFNE {_value}"; case ConditionKind.DigestEquals: - var written = WriteHex(_value.DirectOverlappedBits64, stackalloc char[2 * DigestBytes]); + var written = WriteHex(_value.OverlappedValueInt64, stackalloc char[2 * DigestBytes]); return $"IFDEQ {written.ToString()}"; case ConditionKind.DigestNotEquals: - written = WriteHex(_value.DirectOverlappedBits64, stackalloc char[2 * DigestBytes]); + written = WriteHex(_value.OverlappedValueInt64, stackalloc char[2 * DigestBytes]); return $"IFDNE {written.ToString()}"; case ConditionKind.Always: return ""; @@ -249,33 +249,33 @@ static byte ToNibble(int b) _ => 0, }; - internal void WriteTo(PhysicalConnection physical) + internal void WriteTo(in MessageWriter writer) { switch (_kind) { case ConditionKind.Exists: - physical.WriteBulkString("XX"u8); + writer.WriteRaw("$2\r\nXX\r\n"u8); break; case ConditionKind.NotExists: - physical.WriteBulkString("NX"u8); + writer.WriteRaw("$2\r\nNX\r\n"u8); break; case ConditionKind.ValueEquals: - physical.WriteBulkString("IFEQ"u8); - physical.WriteBulkString(_value); + writer.WriteRaw("$4\r\nIFEQ\r\n"u8); + writer.WriteBulkString(_value); break; case ConditionKind.ValueNotEquals: - physical.WriteBulkString("IFNE"u8); - physical.WriteBulkString(_value); + writer.WriteRaw("$4\r\nIFNE\r\n"u8); + writer.WriteBulkString(_value); break; case ConditionKind.DigestEquals: - physical.WriteBulkString("IFDEQ"u8); - var written = WriteHex(_value.DirectOverlappedBits64, stackalloc byte[2 * DigestBytes]); - physical.WriteBulkString(written); + writer.WriteRaw("$5\r\nIFDEQ\r\n"u8); + var written = WriteHex(_value.OverlappedValueInt64, stackalloc byte[2 * DigestBytes]); + writer.WriteBulkString(written); break; case ConditionKind.DigestNotEquals: - physical.WriteBulkString("IFDNE"u8); - written = WriteHex(_value.DirectOverlappedBits64, stackalloc byte[2 * DigestBytes]); - physical.WriteBulkString(written); + writer.WriteRaw("$5\r\nIFDNE\r\n"u8); + written = WriteHex(_value.OverlappedValueInt64, stackalloc byte[2 * DigestBytes]); + writer.WriteBulkString(written); break; } } diff --git a/src/StackExchange.Redis/VectorSetAddMessage.cs b/src/StackExchange.Redis/VectorSetAddMessage.cs index c833ca5d4..d195299b5 100644 --- a/src/StackExchange.Redis/VectorSetAddMessage.cs +++ b/src/StackExchange.Redis/VectorSetAddMessage.cs @@ -51,30 +51,30 @@ private static bool CheckFp32() // check endianness with a known value return MemoryMarshal.Cast("\0\0(B"u8)[0] == 42; } - protected abstract void WriteElement(PhysicalConnection physical); + protected abstract void WriteElement(in MessageWriter writer); - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { - physical.WriteHeader(Command, GetArgCount()); - physical.Write(key); + writer.WriteHeader(Command, GetArgCount()); + writer.Write(key); if (reducedDimensions.HasValue) { - physical.WriteBulkString("REDUCE"u8); - physical.WriteBulkString(reducedDimensions.GetValueOrDefault()); + writer.WriteRaw("$6\r\nREDUCE\r\n"u8); + writer.WriteBulkString(reducedDimensions.GetValueOrDefault()); } - WriteElement(physical); - if (useCheckAndSet) physical.WriteBulkString("CAS"u8); + WriteElement(writer); + if (useCheckAndSet) writer.WriteRaw("$3\r\nCAS\r\n"u8); switch (quantization) { case VectorSetQuantization.Int8: break; case VectorSetQuantization.None: - physical.WriteBulkString("NOQUANT"u8); + writer.WriteRaw("$7\r\nNOQUANT\r\n"u8); break; case VectorSetQuantization.Binary: - physical.WriteBulkString("BIN"u8); + writer.WriteRaw("$3\r\nBIN\r\n"u8); break; default: throw new ArgumentOutOfRangeException(nameof(quantization)); @@ -82,20 +82,20 @@ protected override void WriteImpl(PhysicalConnection physical) if (buildExplorationFactor.HasValue) { - physical.WriteBulkString("EF"u8); - physical.WriteBulkString(buildExplorationFactor.GetValueOrDefault()); + writer.WriteRaw("$2\r\nEF\r\n"u8); + writer.WriteBulkString(buildExplorationFactor.GetValueOrDefault()); } - WriteAttributes(physical); + WriteAttributes(writer); if (maxConnections.HasValue) { - physical.WriteBulkString("M"u8); - physical.WriteBulkString(maxConnections.GetValueOrDefault()); + writer.WriteRaw("$1\r\nM\r\n"u8); + writer.WriteBulkString(maxConnections.GetValueOrDefault()); } } - protected abstract void WriteAttributes(PhysicalConnection physical); + protected abstract void WriteAttributes(in MessageWriter writer); internal sealed class VectorSetAddMemberMessage( int db, @@ -128,32 +128,32 @@ public override int GetElementArgCount() public override int GetAttributeArgCount() => _attributesJson is null ? 0 : 2; // [SETATTR {attributes}] - protected override void WriteElement(PhysicalConnection physical) + protected override void WriteElement(in MessageWriter writer) { if (UseFp32) { - physical.WriteBulkString("FP32"u8); - physical.WriteBulkString(MemoryMarshal.AsBytes(values.Span)); + writer.WriteRaw("$4\r\nFP32\r\n"u8); + writer.WriteBulkString(MemoryMarshal.AsBytes(values.Span)); } else { - physical.WriteBulkString("VALUES"u8); - physical.WriteBulkString(values.Length); + writer.WriteRaw("$6\r\nVALUES\r\n"u8); + writer.WriteBulkString(values.Length); foreach (var val in values.Span) { - physical.WriteBulkString(val); + writer.WriteBulkString(val); } } - physical.WriteBulkString(element); + writer.WriteBulkString(element); } - protected override void WriteAttributes(PhysicalConnection physical) + protected override void WriteAttributes(in MessageWriter writer) { if (_attributesJson is not null) { - physical.WriteBulkString("SETATTR"u8); - physical.WriteBulkString(_attributesJson); + writer.WriteRaw("$7\r\nSETATTR\r\n"u8); + writer.WriteBulkString(_attributesJson); } } } diff --git a/src/StackExchange.Redis/VectorSetSimilaritySearchMessage.cs b/src/StackExchange.Redis/VectorSetSimilaritySearchMessage.cs index d6b75e079..1c495cde5 100644 --- a/src/StackExchange.Redis/VectorSetSimilaritySearchMessage.cs +++ b/src/StackExchange.Redis/VectorSetSimilaritySearchMessage.cs @@ -1,4 +1,5 @@ using System; +using RESPite.Messages; namespace StackExchange.Redis; @@ -35,20 +36,20 @@ internal sealed class VectorSetSimilaritySearchBySingleVectorMessage( internal override int GetSearchTargetArgCount() => UseFp32 ? 2 : (2 + vector.Length); // FP32 {vector} or VALUES {num} {vector} - internal override void WriteSearchTarget(PhysicalConnection physical) + internal override void WriteSearchTarget(in MessageWriter writer) { if (UseFp32) { - physical.WriteBulkString("FP32"u8); - physical.WriteBulkString(System.Runtime.InteropServices.MemoryMarshal.AsBytes(vector.Span)); + writer.WriteRaw("$4\r\nFP32\r\n"u8); + writer.WriteBulkString(System.Runtime.InteropServices.MemoryMarshal.AsBytes(vector.Span)); } else { - physical.WriteBulkString("VALUES"u8); - physical.WriteBulkString(vector.Length); + writer.WriteRaw("$6\r\nVALUES\r\n"u8); + writer.WriteBulkString(vector.Length); foreach (var val in vector.Span) { - physical.WriteBulkString(val); + writer.WriteBulkString(val); } } } @@ -71,15 +72,15 @@ internal sealed class VectorSetSimilaritySearchByMemberMessage( { internal override int GetSearchTargetArgCount() => 2; // ELE {member} - internal override void WriteSearchTarget(PhysicalConnection physical) + internal override void WriteSearchTarget(in MessageWriter writer) { - physical.WriteBulkString("ELE"u8); - physical.WriteBulkString(member); + writer.WriteRaw("$3\r\nELE\r\n"u8); + writer.WriteBulkString(member); } } internal abstract int GetSearchTargetArgCount(); - internal abstract void WriteSearchTarget(PhysicalConnection physical); + internal abstract void WriteSearchTarget(in MessageWriter writer); public ResultProcessor?> GetResultProcessor() => VectorSetSimilaritySearchProcessor.Instance; @@ -90,11 +91,11 @@ private sealed class VectorSetSimilaritySearchProcessor : ResultProcessor.Create(length, clear: false); var target = lease.Span; int count = 0; - var iter = items.GetEnumerator(); + var iter = reader.AggregateChildren(); for (int i = 0; i < target.Length && iter.MoveNext(); i++) { - var member = iter.Current.AsRedisValue(); + var member = iter.Value.ReadRedisValue(); double score = double.NaN; string? attributesJson = null; if (internalNesting) { - if (!iter.MoveNext() || iter.Current.Resp2TypeArray != ResultType.Array) break; - if (!iter.Current.IsNull) + if (!iter.MoveNext() || !iter.Value.IsAggregate) break; + if (!iter.Value.IsNull) { - var subArray = iter.Current.GetItems(); - if (subArray.Length >= 1 && !subArray[0].TryGetDouble(out score)) break; - if (subArray.Length >= 2) attributesJson = subArray[1].GetString(); + int subLength = iter.Value.AggregateLength(); + var subIter = iter.Value.AggregateChildren(); + if (subLength >= 1 && subIter.MoveNext() && !subIter.Value.TryReadDouble(out score)) break; + if (subLength >= 2 && subIter.MoveNext()) attributesJson = subIter.Value.ReadString(); } } else { if (withScores) { - if (!iter.MoveNext() || !iter.Current.TryGetDouble(out score)) break; + if (!iter.MoveNext() || !iter.Value.TryReadDouble(out score)) break; } if (withAttribs) { if (!iter.MoveNext()) break; - attributesJson = iter.Current.GetString(); + attributesJson = iter.Value.ReadString(); } } @@ -199,66 +201,66 @@ private int GetArgCount() internal bool UseFp32 { get; } = useFp32 & VectorSetAddMessage.CanUseFp32; // evaluated during .ctor - protected override void WriteImpl(PhysicalConnection physical) + protected override void WriteImpl(in MessageWriter writer) { // snapshot to avoid race in debug scenarios - physical.WriteHeader(Command, GetArgCount()); + writer.WriteHeader(Command, GetArgCount()); // Write key - physical.Write(key); + writer.Write(key); // Write search target: either "ELE {member}" or vector data - WriteSearchTarget(physical); + WriteSearchTarget(writer); if (HasFlag(VsimFlags.WithScores)) { - physical.WriteBulkString("WITHSCORES"u8); + writer.WriteRaw("$10\r\nWITHSCORES\r\n"u8); } if (HasFlag(VsimFlags.WithAttributes)) { - physical.WriteBulkString("WITHATTRIBS"u8); + writer.WriteRaw("$11\r\nWITHATTRIBS\r\n"u8); } // Write optional parameters if (HasFlag(VsimFlags.Count)) { - physical.WriteBulkString("COUNT"u8); - physical.WriteBulkString(count); + writer.WriteRaw("$5\r\nCOUNT\r\n"u8); + writer.WriteBulkString(count); } if (HasFlag(VsimFlags.Epsilon)) { - physical.WriteBulkString("EPSILON"u8); - physical.WriteBulkString(epsilon); + writer.WriteRaw("$7\r\nEPSILON\r\n"u8); + writer.WriteBulkString(epsilon); } if (HasFlag(VsimFlags.SearchExplorationFactor)) { - physical.WriteBulkString("EF"u8); - physical.WriteBulkString(searchExplorationFactor); + writer.WriteRaw("$2\r\nEF\r\n"u8); + writer.WriteBulkString(searchExplorationFactor); } if (HasFlag(VsimFlags.FilterExpression)) { - physical.WriteBulkString("FILTER"u8); - physical.WriteBulkString(filterExpression); + writer.WriteRaw("$6\r\nFILTER\r\n"u8); + writer.WriteBulkString(filterExpression); } if (HasFlag(VsimFlags.MaxFilteringEffort)) { - physical.WriteBulkString("FILTER-EF"u8); - physical.WriteBulkString(maxFilteringEffort); + writer.WriteRaw("$9\r\nFILTER-EF\r\n"u8); + writer.WriteBulkString(maxFilteringEffort); } if (HasFlag(VsimFlags.UseExactSearch)) { - physical.WriteBulkString("TRUTH"u8); + writer.WriteRaw("$5\r\nTRUTH\r\n"u8); } if (HasFlag(VsimFlags.DisableThreading)) { - physical.WriteBulkString("NOTHREAD"u8); + writer.WriteRaw("$8\r\nNOTHREAD\r\n"u8); } } diff --git a/src/StackExchange.Redis/YesNo.cs b/src/StackExchange.Redis/YesNo.cs new file mode 100644 index 000000000..0263d298e --- /dev/null +++ b/src/StackExchange.Redis/YesNo.cs @@ -0,0 +1,37 @@ +using System; +using RESPite; + +namespace StackExchange.Redis; + +/// +/// Yes/No values in Redis responses. +/// +internal enum YesNo +{ + /// + /// Unknown or unrecognized value. + /// + [AsciiHash("")] + Unknown = 0, + + /// + /// Yes value. + /// + [AsciiHash("yes")] + Yes, + + /// + /// No value. + /// + [AsciiHash("no")] + No, +} + +/// +/// Metadata and parsing methods for YesNo. +/// +internal static partial class YesNoMetadata +{ + [AsciiHash] + internal static partial bool TryParse(ReadOnlySpan value, out YesNo yesNo); +} diff --git a/tests/BasicTest/Program.cs b/tests/BasicTest/Program.cs index 2977c42c2..a6d82b6fd 100644 --- a/tests/BasicTest/Program.cs +++ b/tests/BasicTest/Program.cs @@ -45,14 +45,13 @@ protected override Job Configure(Job j) [Config(typeof(CustomConfig))] public class RedisBenchmarks : IDisposable { - private SocketManager mgr; private ConnectionMultiplexer connection; private IDatabase db; [GlobalSetup] public void Setup() { - // Pipelines.Sockets.Unofficial.SocketConnection.AssertDependencies(); + // Dependencies.Assert(); var options = ConfigurationOptions.Parse("127.0.0.1:6379"); connection = ConnectionMultiplexer.Connect(options); db = connection.GetDatabase(3); @@ -71,9 +70,7 @@ public void Setup() private static readonly RedisKey GeoKey = "GeoTest", IncrByKey = "counter", StringKey = "string", HashKey = "hash"; void IDisposable.Dispose() { - mgr?.Dispose(); connection?.Dispose(); - mgr = null; db = null; connection = null; GC.SuppressFinalize(this); diff --git a/tests/BasicTestBaseline/BasicTestBaseline.csproj b/tests/BasicTestBaseline/BasicTestBaseline.csproj index a9f75e441..167fd7578 100644 --- a/tests/BasicTestBaseline/BasicTestBaseline.csproj +++ b/tests/BasicTestBaseline/BasicTestBaseline.csproj @@ -19,6 +19,7 @@ + diff --git a/tests/ConsoleTestBaseline/ConsoleTestBaseline.csproj b/tests/ConsoleTestBaseline/ConsoleTestBaseline.csproj index 1a6a7149d..bfb97c06a 100644 --- a/tests/ConsoleTestBaseline/ConsoleTestBaseline.csproj +++ b/tests/ConsoleTestBaseline/ConsoleTestBaseline.csproj @@ -14,5 +14,6 @@ + diff --git a/tests/StackExchange.Redis.Benchmarks/AsciiHashSwitch.generated.cs b/tests/StackExchange.Redis.Benchmarks/AsciiHashSwitch.generated.cs new file mode 100644 index 000000000..935443117 --- /dev/null +++ b/tests/StackExchange.Redis.Benchmarks/AsciiHashSwitch.generated.cs @@ -0,0 +1,252 @@ +/* +using System; +using StackExchange.Redis; +#pragma warning disable CS8981 + +namespace StackExchange.Redis.Benchmarks +{ + partial class FastHashSwitch + { + static partial class key + { + public const int Length = 3; + public const long HashCS = 7955819; + public const long HashCI = 5850443; + public static ReadOnlySpan U8 => "key"u8; + public const string Text = "key"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS & value.Length == Length; + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && (global::RESPite.FastHash.HashCS(value) == HashCS || global::RESPite.FastHash.EqualsCI(value, U8)); + } + static partial class abc + { + public const int Length = 3; + public const long HashCS = 6513249; + public const long HashCI = 4407873; + public static ReadOnlySpan U8 => "abc"u8; + public const string Text = "abc"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS & value.Length == Length; + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && (global::RESPite.FastHash.HashCS(value) == HashCS || global::RESPite.FastHash.EqualsCI(value, U8)); + } + static partial class port + { + public const int Length = 4; + public const long HashCS = 1953656688; + public const long HashCI = 1414680400; + public static ReadOnlySpan U8 => "port"u8; + public const string Text = "port"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS & value.Length == Length; + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && (global::RESPite.FastHash.HashCS(value) == HashCS || global::RESPite.FastHash.EqualsCI(value, U8)); + } + static partial class test + { + public const int Length = 4; + public const long HashCS = 1953719668; + public const long HashCI = 1414743380; + public static ReadOnlySpan U8 => "test"u8; + public const string Text = "test"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS & value.Length == Length; + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && (global::RESPite.FastHash.HashCS(value) == HashCS || global::RESPite.FastHash.EqualsCI(value, U8)); + } + static partial class tracking_active + { + public const int Length = 15; + public const long HashCS = 7453010343294497396; + public const long HashCI = 5138124812476043860; + public static ReadOnlySpan U8 => "tracking-active"u8; + public const string Text = "tracking-active"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class sample_ratio + { + public const int Length = 12; + public const long HashCS = 8227343610692854131; + public const long HashCI = 5912458079874400595; + public static ReadOnlySpan U8 => "sample-ratio"u8; + public const string Text = "sample-ratio"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class selected_slots + { + public const int Length = 14; + public const long HashCS = 7234316346692756851; + public const long HashCI = 4919430815874303315; + public static ReadOnlySpan U8 => "selected-slots"u8; + public const string Text = "selected-slots"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class all_commands_all_slots_us + { + public const int Length = 25; + public const long HashCS = 7885080994350132321; + public const long HashCI = 5570195463531678785; + public static ReadOnlySpan U8 => "all-commands-all-slots-us"u8; + public const string Text = "all-commands-all-slots-us"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class all_commands_selected_slots_us + { + public const int Length = 30; + public const long HashCS = 7885080994350132321; + public const long HashCI = 5570195463531678785; + public static ReadOnlySpan U8 => "all-commands-selected-slots-us"u8; + public const string Text = "all-commands-selected-slots-us"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class sampled_command_selected_slots_us + { + public const int Length = 33; + public const long HashCS = 3270850745794912627; + public const long HashCI = 955965214976459091; + public static ReadOnlySpan U8 => "sampled-command-selected-slots-us"u8; + public const string Text = "sampled-command-selected-slots-us"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class sampled_commands_selected_slots_us + { + public const int Length = 34; + public const long HashCS = 3270850745794912627; + public const long HashCI = 955965214976459091; + public static ReadOnlySpan U8 => "sampled-commands-selected-slots-us"u8; + public const string Text = "sampled-commands-selected-slots-us"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class net_bytes_all_commands_all_slots + { + public const int Length = 32; + public const long HashCS = 7310601557705516398; + public const long HashCI = 4995716026887062862; + public static ReadOnlySpan U8 => "net-bytes-all-commands-all-slots"u8; + public const string Text = "net-bytes-all-commands-all-slots"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class net_bytes_all_commands_selected_slots + { + public const int Length = 37; + public const long HashCS = 7310601557705516398; + public const long HashCI = 4995716026887062862; + public static ReadOnlySpan U8 => "net-bytes-all-commands-selected-slots"u8; + public const string Text = "net-bytes-all-commands-selected-slots"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class net_bytes_sampled_commands_selected_slots + { + public const int Length = 41; + public const long HashCS = 7310601557705516398; + public const long HashCI = 4995716026887062862; + public static ReadOnlySpan U8 => "net-bytes-sampled-commands-selected-slots"u8; + public const string Text = "net-bytes-sampled-commands-selected-slots"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class collection_start_time_unix_ms + { + public const int Length = 29; + public const long HashCS = 7598807758542761827; + public const long HashCI = 5283922227724308291; + public static ReadOnlySpan U8 => "collection-start-time-unix-ms"u8; + public const string Text = "collection-start-time-unix-ms"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class collection_duration_ms + { + public const int Length = 22; + public const long HashCS = 7598807758542761827; + public const long HashCI = 5283922227724308291; + public static ReadOnlySpan U8 => "collection-duration-ms"u8; + public const string Text = "collection-duration-ms"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class collection_duration_us + { + public const int Length = 22; + public const long HashCS = 7598807758542761827; + public const long HashCI = 5283922227724308291; + public static ReadOnlySpan U8 => "collection-duration-us"u8; + public const string Text = "collection-duration-us"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class total_cpu_time_user_ms + { + public const int Length = 22; + public const long HashCS = 8098366498457022324; + public const long HashCI = 5783480967638568788; + public static ReadOnlySpan U8 => "total-cpu-time-user-ms"u8; + public const string Text = "total-cpu-time-user-ms"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class total_cpu_time_user_us + { + public const int Length = 22; + public const long HashCS = 8098366498457022324; + public const long HashCI = 5783480967638568788; + public static ReadOnlySpan U8 => "total-cpu-time-user-us"u8; + public const string Text = "total-cpu-time-user-us"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class total_cpu_time_sys_ms + { + public const int Length = 21; + public const long HashCS = 8098366498457022324; + public const long HashCI = 5783480967638568788; + public static ReadOnlySpan U8 => "total-cpu-time-sys-ms"u8; + public const string Text = "total-cpu-time-sys-ms"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class total_cpu_time_sys_us + { + public const int Length = 21; + public const long HashCS = 8098366498457022324; + public const long HashCI = 5783480967638568788; + public static ReadOnlySpan U8 => "total-cpu-time-sys-us"u8; + public const string Text = "total-cpu-time-sys-us"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class total_net_bytes + { + public const int Length = 15; + public const long HashCS = 7308829188783632244; + public const long HashCI = 4993943657965178708; + public static ReadOnlySpan U8 => "total-net-bytes"u8; + public const string Text = "total-net-bytes"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class by_cpu_time_us + { + public const int Length = 14; + public const long HashCS = 8371476407912331618; + public const long HashCI = 6056590877093878082; + public static ReadOnlySpan U8 => "by-cpu-time-us"u8; + public const string Text = "by-cpu-time-us"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + static partial class by_net_bytes + { + public const int Length = 12; + public const long HashCS = 7074438568657910114; + public const long HashCI = 4759553037839456578; + public static ReadOnlySpan U8 => "by-net-bytes"u8; + public const string Text = "by-net-bytes"; + public static bool IsCS(long hash, ReadOnlySpan value) => hash == HashCS && value.SequenceEqual(U8); + public static bool IsCI(long hash, ReadOnlySpan value) => (hash == HashCI & value.Length == Length) && global::RESPite.FastHash.EqualsCI(value, U8); + } + } +} +*/ diff --git a/tests/StackExchange.Redis.Benchmarks/StackExchange.Redis.Benchmarks.csproj b/tests/StackExchange.Redis.Benchmarks/StackExchange.Redis.Benchmarks.csproj index 47359ac85..c6152af85 100644 --- a/tests/StackExchange.Redis.Benchmarks/StackExchange.Redis.Benchmarks.csproj +++ b/tests/StackExchange.Redis.Benchmarks/StackExchange.Redis.Benchmarks.csproj @@ -1,7 +1,7 @@  StackExchange.Redis MicroBenchmark Suite - net481;net8.0 + net481;net8.0;net10.0 Release Exe true diff --git a/tests/StackExchange.Redis.Tests/AbortOnConnectFailTests.cs b/tests/StackExchange.Redis.Tests/AbortOnConnectFailTests.cs index 25033fa1a..6307f3ccb 100644 --- a/tests/StackExchange.Redis.Tests/AbortOnConnectFailTests.cs +++ b/tests/StackExchange.Redis.Tests/AbortOnConnectFailTests.cs @@ -34,6 +34,7 @@ public async Task NeverEverConnectedNoBacklogThrowsConnectionNotAvailableAsync() } [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task DisconnectAndReconnectThrowsConnectionExceptionSync() { await using var conn = GetWorkingBacklogConn(); @@ -45,6 +46,7 @@ public async Task DisconnectAndReconnectThrowsConnectionExceptionSync() // Disconnect and don't allow re-connection conn.AllowConnect = false; var server = conn.GetServerSnapshot()[0]; + Assert.SkipUnless(server.CanSimulateConnectionFailure, "Skipping because server cannot simulate connection failure"); server.SimulateConnectionFailure(SimulatedFailureType.All); // Exception: The message timed out in the backlog attempting to send because no connection became available (400ms) - Last Connection Exception: SocketFailure (InputReaderCompleted, last-recv: 7) on 127.0.0.1:6379/Interactive, Idle/ReadAsync, last: PING, origin: SimulateConnectionFailure, outstanding: 0, last-read: 0s ago, last-write: 0s ago, keep-alive: 100s, state: ConnectedEstablished, mgr: 10 of 10 available, in: 0, in-pipe: 0, out-pipe: 0, last-heartbeat: never, last-mbeat: 0s ago, global: 0s ago, v: 2.6.120.51136, command=PING, timeout: 100, inst: 13, qu: 1, qs: 0, aw: False, bw: Inactive, last-in: 0, cur-in: 0, sync-ops: 2, async-ops: 0, serverEndpoint: 127.0.0.1:6379, conn-sec: n/a, aoc: 0, mc: 1/1/0, mgr: 10 of 10 available, clientName: CRAVERTOP7(SE.Redis-v2.6.120.51136), IOCP: (Busy=0,Free=1000,Min=16,Max=1000), WORKER: (Busy=2,Free=32765,Min=16,Max=32767), POOL: (Threads=33,QueuedItems=0,CompletedItems=6237,Timers=39), v: 2.6.120.51136 (Please take a look at this article for some common client-side issues that can cause timeouts: https://stackexchange.github.io/StackExchange.Redis/Timeouts) @@ -58,6 +60,7 @@ public async Task DisconnectAndReconnectThrowsConnectionExceptionSync() } [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task DisconnectAndNoReconnectThrowsConnectionExceptionAsync() { await using var conn = GetWorkingBacklogConn(); @@ -69,6 +72,7 @@ public async Task DisconnectAndNoReconnectThrowsConnectionExceptionAsync() // Disconnect and don't allow re-connection conn.AllowConnect = false; var server = conn.GetServerSnapshot()[0]; + Assert.SkipUnless(server.CanSimulateConnectionFailure, "Skipping because server cannot simulate connection failure"); server.SimulateConnectionFailure(SimulatedFailureType.All); // Exception: The message timed out in the backlog attempting to send because no connection became available (400ms) - Last Connection Exception: SocketFailure (InputReaderCompleted, last-recv: 7) on 127.0.0.1:6379/Interactive, Idle/ReadAsync, last: PING, origin: SimulateConnectionFailure, outstanding: 0, last-read: 0s ago, last-write: 0s ago, keep-alive: 100s, state: ConnectedEstablished, mgr: 8 of 10 available, in: 0, in-pipe: 0, out-pipe: 0, last-heartbeat: never, last-mbeat: 0s ago, global: 0s ago, v: 2.6.120.51136, command=PING, timeout: 100, inst: 0, qu: 0, qs: 0, aw: False, bw: CheckingForTimeout, last-in: 0, cur-in: 0, sync-ops: 1, async-ops: 1, serverEndpoint: 127.0.0.1:6379, conn-sec: n/a, aoc: 0, mc: 1/1/0, mgr: 8 of 10 available, clientName: CRAVERTOP7(SE.Redis-v2.6.120.51136), IOCP: (Busy=0,Free=1000,Min=16,Max=1000), WORKER: (Busy=6,Free=32761,Min=16,Max=32767), POOL: (Threads=33,QueuedItems=0,CompletedItems=5547,Timers=60), v: 2.6.120.51136 (Please take a look at this article for some common client-side issues that can cause timeouts: https://stackexchange.github.io/StackExchange.Redis/Timeouts) @@ -84,9 +88,9 @@ private ConnectionMultiplexer GetFailFastConn() => ConnectionMultiplexer.Connect(GetOptions(BacklogPolicy.FailFast, duration: 400, connectTimeout: 500).Apply(o => o.EndPoints.Add($"doesnot.exist.{Guid.NewGuid():N}:6379")), Writer); private ConnectionMultiplexer GetWorkingBacklogConn() => - ConnectionMultiplexer.Connect(GetOptions(BacklogPolicy.Default).Apply(o => o.EndPoints.Add(GetConfiguration())), Writer); + ConnectionMultiplexer.Connect(GetOptions(BacklogPolicy.Default, allowSimulateConnectionFailure: true).Apply(o => o.EndPoints.Add(GetConfiguration())), Writer); - private static ConfigurationOptions GetOptions(BacklogPolicy policy, int duration = 1000, int connectTimeout = 2000) => new ConfigurationOptions() + private static ConfigurationOptions GetOptions(BacklogPolicy policy, int duration = 1000, int connectTimeout = 2000, bool allowSimulateConnectionFailure = false) => new ConfigurationOptions() { AbortOnConnectFail = false, BacklogPolicy = policy, @@ -94,5 +98,6 @@ private ConnectionMultiplexer GetWorkingBacklogConn() => SyncTimeout = duration, KeepAlive = duration, AllowAdmin = true, + AllowSimulateConnectionFailure = allowSimulateConnectionFailure, }.WithoutSubscriptions(); } diff --git a/tests/StackExchange.Redis.Tests/AsciiHashUnitTests.cs b/tests/StackExchange.Redis.Tests/AsciiHashUnitTests.cs index 5e2b9571f..4fbe497a6 100644 --- a/tests/StackExchange.Redis.Tests/AsciiHashUnitTests.cs +++ b/tests/StackExchange.Redis.Tests/AsciiHashUnitTests.cs @@ -150,6 +150,33 @@ public void CaseInsensitiveEquality(string text) Assert.Equal(hashLowerUC, hashUpperUC); } + [Theory] + [InlineData("a")] // length 1 + [InlineData("ab")] // length 2 + [InlineData("abc")] // length 3 + [InlineData("abcd")] // length 4 + [InlineData("abcde")] // length 5 + [InlineData("abcdef")] // length 6 + [InlineData("abcdefg")] // length 7 + [InlineData("abcdefgh")] // length 8 + [InlineData("abcdefghi")] // length 9 + [InlineData("abcdefghij")] // length 10 + [InlineData("abcdefghijklmnop")] // length 16 + [InlineData("abcdefghijklmnopqrst")] // length 20 + public void CaseInsensitiveEquality_MixedBytesAndChars(string text) + { + var lowerChars = text.AsSpan(); + var upperBytes = Encoding.UTF8.GetBytes(text.ToUpperInvariant()); + + Assert.True(AsciiHash.EqualsCI(lowerChars, upperBytes), "CI: chars lower == bytes upper"); + Assert.True(AsciiHash.EqualsCI(upperBytes, lowerChars), "CI: bytes upper == chars lower"); + + Assert.True(AsciiHash.SequenceEqualsCI(lowerChars, upperBytes), "CI sequence: chars lower == bytes upper"); + Assert.True(AsciiHash.SequenceEqualsCI(upperBytes, lowerChars), "CI sequence: bytes upper == chars lower"); + + Assert.False(AsciiHash.EqualsCI((text + "x").AsSpan(), upperBytes), "CI: length mismatch"); + } + [Theory] [InlineData("a")] // length 1 [InlineData("ab")] // length 2 diff --git a/tests/StackExchange.Redis.Tests/AsyncTests.cs b/tests/StackExchange.Redis.Tests/AsyncTests.cs index cba1b1145..1cbce25a3 100644 --- a/tests/StackExchange.Redis.Tests/AsyncTests.cs +++ b/tests/StackExchange.Redis.Tests/AsyncTests.cs @@ -10,12 +10,14 @@ namespace StackExchange.Redis.Tests; public class AsyncTests(ITestOutputHelper output) : TestBase(output) { [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task AsyncTasksReportFailureIfServerUnavailable() { SetExpectedAmbientFailureCount(-1); // this will get messy - await using var conn = Create(allowAdmin: true, shared: false, backlogPolicy: BacklogPolicy.FailFast); + await using var conn = Create(allowAdmin: true, backlogPolicy: BacklogPolicy.FailFast, allowSimulateConnectionFailure: true); var server = conn.GetServer(TestConfig.Current.PrimaryServer, TestConfig.Current.PrimaryPort); + Assert.SkipUnless(server.CanSimulateConnectionFailure(), "Skipping because server cannot simulate connection failure"); RedisKey key = Me(); var db = conn.GetDatabase(); @@ -27,6 +29,7 @@ public async Task AsyncTasksReportFailureIfServerUnavailable() Assert.True(conn.Wait(b)); conn.AllowConnect = false; + server.SimulateConnectionFailure(SimulatedFailureType.All); var c = db.SetAddAsync(key, "c"); @@ -40,8 +43,8 @@ public async Task AsyncTasksReportFailureIfServerUnavailable() [Fact] public async Task AsyncTimeoutIsNoticed() { - await using var conn = Create(syncTimeout: 1000, asyncTimeout: 1000); - await using var pauseConn = Create(); + await using var conn = Create(syncTimeout: 1000, asyncTimeout: 1000, allowAdmin: true); + await using var pauseConn = Create(allowAdmin: true); var opt = ConfigurationOptions.Parse(conn.Configuration); if (!Debugger.IsAttached) { // we max the timeouts if a debugger is detected diff --git a/tests/StackExchange.Redis.Tests/AwaitableMutexTests.cs b/tests/StackExchange.Redis.Tests/AwaitableMutexTests.cs new file mode 100644 index 000000000..f230ff348 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/AwaitableMutexTests.cs @@ -0,0 +1,188 @@ +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; +using Xunit; + +namespace StackExchange.Redis.Tests; + +public class AwaitableMutexTests +{ + private static readonly TimeSpan TestTimeout = TimeSpan.FromSeconds(5); + + [Fact] + public void IsolatedSyncSuccessAndReturn() + { + using var mutex = AwaitableMutex.Create(timeoutMilliseconds: 100); + + for (var i = 0; i < 5; i++) + { + Assert.True(mutex.IsAvailable); + Assert.True(i % 2 == 0 ? mutex.TryTakeInstant() : mutex.TryTakeSync()); + Assert.False(mutex.IsAvailable); + mutex.Release(); + } + + Assert.True(mutex.IsAvailable); + } + + [Fact] + public async Task SyncCallerTimesOutWhileHeld() + { + using var mutex = AwaitableMutex.Create(timeoutMilliseconds: 50); + Assert.True(mutex.TryTakeInstant()); + + var result = await WithTimeout(Task.Run(() => mutex.TryTakeSync())); + + Assert.False(result); + Assert.False(mutex.IsAvailable); + mutex.Release(); + Assert.True(mutex.IsAvailable); + } + + [Fact] + public async Task AsyncCallerTimesOutWhileHeld() + { + using var mutex = AwaitableMutex.Create(timeoutMilliseconds: 50); + Assert.True(mutex.TryTakeInstant()); + + var result = await WithTimeout(mutex.TryTakeAsync().AsTask()); + + Assert.False(result); + Assert.False(mutex.IsAvailable); + mutex.Release(); + Assert.True(mutex.IsAvailable); + } + + [Fact] + public async Task DisposalPreventsNewAcquisitions() + { + var mutex = AwaitableMutex.Create(timeoutMilliseconds: 100); + Assert.True(mutex.TryTakeInstant()); + + mutex.Dispose(); + + Assert.False(mutex.IsAvailable); + Assert.Throws(() => mutex.TryTakeInstant()); + Assert.Throws(() => mutex.TryTakeSync()); + await Assert.ThrowsAsync(async () => await mutex.TryTakeAsync().AsTask()); + Assert.Throws(() => mutex.Release()); + } + + [Fact] + public async Task MixedSyncAndAsyncWaitersAreReleased() + { + const int Iterations = 100; + using var mutex = AwaitableMutex.Create(timeoutMilliseconds: 10_000); + + for (var i = 0; i < Iterations; i++) + { + await Core(i, mutex); + } + + static async Task Core(int iteration, AwaitableMutex mutex) + { + Assert.True(mutex.TryTakeInstant()); + + var order = new List(); + var expected = new[] + { + $"{iteration}:sync-1", + $"{iteration}:async-1", + $"{iteration}:sync-2", + $"{iteration}:async-2", + }; + + var sync1 = StartSyncWaiter(mutex, expected[0], order, out var sync1Thread); + WaitForBlocked(sync1Thread); + + var async1 = StartAsyncWaiter(mutex, expected[1], order); + Assert.False(async1.IsCompleted); + + var sync2 = StartSyncWaiter(mutex, expected[2], order, out var sync2Thread); + WaitForBlocked(sync2Thread); + + var async2 = StartAsyncWaiter(mutex, expected[3], order); + Assert.False(async2.IsCompleted); + + mutex.Release(); + + await WithTimeout(Task.WhenAll(sync1, async1, sync2, async2)); + + // SemaphoreSlim does not guarantee FIFO ordering; this only verifies that every queued waiter arrives. + order.Sort(StringComparer.Ordinal); + Array.Sort(expected, StringComparer.Ordinal); + Assert.Equal(expected, order); + Assert.True(mutex.IsAvailable); + } + } + + private static Task StartSyncWaiter(AwaitableMutex mutex, string name, List order, out Thread thread) + { + var source = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var started = new ManualResetEventSlim(); + thread = new Thread(() => + { + started.Set(); + try + { + if (!mutex.TryTakeSync()) throw new TimeoutException(); + + Add(order, name); + mutex.Release(); + source.TrySetResult(true); + } + catch (Exception ex) + { + source.TrySetException(ex); + } + }) + { + IsBackground = true, + Name = name, + }; + thread.Start(); + + Assert.True(started.Wait(TestTimeout), $"{name} did not start"); + return source.Task; + } + + private static async Task StartAsyncWaiter(AwaitableMutex mutex, string name, List order) + { + if (!await mutex.TryTakeAsync().AsTask()) throw new TimeoutException(); + + Add(order, name); + mutex.Release(); + } + + private static void WaitForBlocked(Thread thread) + { + Assert.True( + SpinWait.SpinUntil(() => (thread.ThreadState & ThreadState.WaitSleepJoin) != 0, TestTimeout), + $"{thread.Name} did not block"); + } + + private static void Add(List order, string name) + { + lock (order) + { + order.Add(name); + } + } + + private static async Task WithTimeout(Task task) + { + var timeout = Task.Delay(TestTimeout); + var first = await Task.WhenAny(task, timeout); + Assert.Same(task, first); + await task; + } + + private static async Task WithTimeout(Task task) + { + var timeout = Task.Delay(TestTimeout); + var first = await Task.WhenAny(task, timeout); + Assert.Same(task, first); + return await task; + } +} diff --git a/tests/StackExchange.Redis.Tests/BacklogTests.cs b/tests/StackExchange.Redis.Tests/BacklogTests.cs index e8ed1daf0..ad30791ca 100644 --- a/tests/StackExchange.Redis.Tests/BacklogTests.cs +++ b/tests/StackExchange.Redis.Tests/BacklogTests.cs @@ -9,6 +9,7 @@ public class BacklogTests(ITestOutputHelper output) : TestBase(output) protected override string GetConfiguration() => TestConfig.Current.PrimaryServerAndPort + "," + TestConfig.Current.ReplicaServerAndPort; [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task FailFast() { void PrintSnapshot(ConnectionMultiplexer muxer) @@ -43,6 +44,7 @@ void PrintSnapshot(ConnectionMultiplexer muxer) KeepAlive = 10000, AsyncTimeout = 5000, AllowAdmin = true, + AllowSimulateConnectionFailure = true, }; options.EndPoints.Add(TestConfig.Current.PrimaryServerAndPort); @@ -53,12 +55,14 @@ void PrintSnapshot(ConnectionMultiplexer muxer) await db.PingAsync(); var server = conn.GetServerSnapshot()[0]; + Assert.SkipUnless(server.CanSimulateConnectionFailure, "Skipping because server cannot simulate connection failure"); var stats = server.GetBridgeStatus(ConnectionType.Interactive); Assert.Equal(0, stats.BacklogMessagesPending); // Everything's normal // Fail the connection Log("Test: Simulating failure"); conn.AllowConnect = false; + server.SimulateConnectionFailure(SimulatedFailureType.All); Assert.False(conn.IsConnected); @@ -101,6 +105,7 @@ void PrintSnapshot(ConnectionMultiplexer muxer) } [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task QueuesAndFlushesAfterReconnectingAsync() { try @@ -115,11 +120,12 @@ public async Task QueuesAndFlushesAfterReconnectingAsync() KeepAlive = 10000, AsyncTimeout = 5000, AllowAdmin = true, - SocketManager = SocketManager.ThreadPool, + AllowSimulateConnectionFailure = true, }; options.EndPoints.Add(TestConfig.Current.PrimaryServerAndPort); await using var conn = await ConnectionMultiplexer.ConnectAsync(options, Writer); + Assert.SkipUnless(conn.IsConnected, "no initial connection"); conn.ErrorMessage += (s, e) => Log($"Error Message {e.EndPoint}: {e.Message}"); conn.InternalError += (s, e) => Log($"Internal Error {e.EndPoint}: {e.Exception.Message}"); conn.ConnectionFailed += (s, a) => Log("Disconnected: " + EndPointCollection.ToString(a.EndPoint)); @@ -130,6 +136,7 @@ public async Task QueuesAndFlushesAfterReconnectingAsync() await db.PingAsync(); var server = conn.GetServerSnapshot()[0]; + Assert.SkipUnless(server.CanSimulateConnectionFailure, "Skipping because server cannot simulate connection failure"); var stats = server.GetBridgeStatus(ConnectionType.Interactive); Assert.Equal(0, stats.BacklogMessagesPending); // Everything's normal @@ -192,6 +199,7 @@ public async Task QueuesAndFlushesAfterReconnectingAsync() } [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task QueuesAndFlushesAfterReconnecting() { try @@ -206,7 +214,7 @@ public async Task QueuesAndFlushesAfterReconnecting() KeepAlive = 10000, AsyncTimeout = 5000, AllowAdmin = true, - SocketManager = SocketManager.ThreadPool, + AllowSimulateConnectionFailure = true, }; options.EndPoints.Add(TestConfig.Current.PrimaryServerAndPort); @@ -221,6 +229,7 @@ public async Task QueuesAndFlushesAfterReconnecting() await db.PingAsync(); var server = conn.GetServerSnapshot()[0]; + Assert.SkipUnless(server.CanSimulateConnectionFailure, "Skipping because server cannot simulate connection failure"); var stats = server.GetBridgeStatus(ConnectionType.Interactive); Assert.Equal(0, stats.BacklogMessagesPending); // Everything's normal @@ -295,6 +304,7 @@ void DisconnectedPings(int id) } [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task QueuesAndFlushesAfterReconnectingClusterAsync() { try @@ -308,9 +318,10 @@ public async Task QueuesAndFlushesAfterReconnectingClusterAsync() options.KeepAlive = 10000; options.AsyncTimeout = 5000; options.AllowAdmin = true; - options.SocketManager = SocketManager.ThreadPool; + options.AllowSimulateConnectionFailure = true; await using var conn = await ConnectionMultiplexer.ConnectAsync(options, Writer); + Assert.SkipUnless(conn.IsConnected, "no initial connection"); conn.ErrorMessage += (s, e) => Log($"Error Message {e.EndPoint}: {e.Message}"); conn.InternalError += (s, e) => Log($"Internal Error {e.EndPoint}: {e.Exception.Message}"); conn.ConnectionFailed += (s, a) => Log("Disconnected: " + EndPointCollection.ToString(a.EndPoint)); @@ -327,6 +338,7 @@ public async Task QueuesAndFlushesAfterReconnectingClusterAsync() await UntilConditionAsync(TimeSpan.FromSeconds(10), () => (server = conn.SelectServer(getMsg)) != null); Assert.NotNull(server); + Assert.SkipUnless(server.CanSimulateConnectionFailure, "Skipping because server cannot simulate connection failure"); var stats = server.GetBridgeStatus(ConnectionType.Interactive); Assert.Equal(0, stats.BacklogMessagesPending); // Everything's normal @@ -400,6 +412,7 @@ static Task PingAsync(ServerEndPoint server, CommandFlags flags = Comm } [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task TotalOutstandingIncludesBacklogQueue() { try @@ -414,7 +427,7 @@ public async Task TotalOutstandingIncludesBacklogQueue() KeepAlive = 10000, AsyncTimeout = 5000, AllowAdmin = true, - SocketManager = SocketManager.ThreadPool, + AllowSimulateConnectionFailure = true, }; options.EndPoints.Add(TestConfig.Current.PrimaryServerAndPort); @@ -424,6 +437,7 @@ public async Task TotalOutstandingIncludesBacklogQueue() await db.PingAsync(); var server = conn.GetServerSnapshot()[0]; + Assert.SkipUnless(server.CanSimulateConnectionFailure, "Skipping because server cannot simulate connection failure"); // Verify TotalOutstanding is 0 when connected and idle Log("Test: asserting connected counters"); diff --git a/tests/StackExchange.Redis.Tests/BasicOpTests.cs b/tests/StackExchange.Redis.Tests/BasicOpTests.cs index 2b045823d..b01e1ebbf 100644 --- a/tests/StackExchange.Redis.Tests/BasicOpTests.cs +++ b/tests/StackExchange.Redis.Tests/BasicOpTests.cs @@ -272,14 +272,15 @@ public async Task GetWithExpiryWrongTypeSync() #if DEBUG [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task TestSevered() { - await using var conn = ConnectFactory(allowAdmin: true, shared: false); + await using var conn = Create(allowAdmin: true, allowSimulateConnectionFailure: true); var db = conn.GetDatabase(); string key = Me(); db.KeyDelete(key, CommandFlags.FireAndForget); - db.StringSet(key, key, flags: CommandFlags.FireAndForget); - var server = GetServer(conn.DefaultClient); + db.StringSet(key, key); + var server = GetServer(conn); Assert.SkipUnless(server.CanSimulateConnectionFailure(), "Skipping because server cannot simulate connection failure"); SetExpectedAmbientFailureCount(2); diff --git a/tests/StackExchange.Redis.Tests/BoxUnboxTests.cs b/tests/StackExchange.Redis.Tests/BoxUnboxUnitTests.cs similarity index 65% rename from tests/StackExchange.Redis.Tests/BoxUnboxTests.cs rename to tests/StackExchange.Redis.Tests/BoxUnboxUnitTests.cs index 033a24839..762618535 100644 --- a/tests/StackExchange.Redis.Tests/BoxUnboxTests.cs +++ b/tests/StackExchange.Redis.Tests/BoxUnboxUnitTests.cs @@ -1,11 +1,12 @@ using System; +using System.Buffers; using System.Collections.Generic; using System.Text; using Xunit; namespace StackExchange.Redis.Tests; -public class BoxUnboxTests +public class BoxUnboxUnitTests { [Theory] [MemberData(nameof(RoundTripValues))] @@ -26,8 +27,9 @@ public void UnboxCommonValues(object value, RedisValue expected) [Theory] [MemberData(nameof(InternedValues))] - public void ReturnInternedBoxesForCommonValues(RedisValue value, bool expectSameReference) + public void ReturnInternedBoxesForCommonValues(RedisValue value, bool expectSameReference, string label) { + _ = label; object? x = value.Box(), y = value.Box(); Assert.Equal(expectSameReference, ReferenceEquals(x, y)); // check we got the right values! @@ -50,7 +52,7 @@ private static void AssertEqualGiveOrTakeNaN(RedisValue expected, RedisValue act Assert.Equal(expected, actual); } - private static readonly byte[] s_abc = Encoding.UTF8.GetBytes("abc"); + private static readonly byte[] s_abc = "abc"u8.ToArray(); public static IEnumerable RoundTripValues => new[] { @@ -138,31 +140,64 @@ public static IEnumerable InternedValues() for (int i = -20; i <= 40; i++) { bool expectInterned = i >= -1 & i <= 20; - yield return new object[] { (RedisValue)i, expectInterned }; - yield return new object[] { (RedisValue)(long)i, expectInterned }; - yield return new object[] { (RedisValue)(float)i, expectInterned }; - yield return new object[] { (RedisValue)(double)i, expectInterned }; + yield return new object[] { (RedisValue)i, expectInterned, "int" }; + yield return new object[] { (RedisValue)(long)i, expectInterned, "long" }; + yield return new object[] { (RedisValue)(float)i, expectInterned, "float" }; + yield return new object[] { (RedisValue)(double)i, expectInterned, "double" }; } - yield return new object[] { (RedisValue)float.NegativeInfinity, true }; - yield return new object[] { (RedisValue)(-0.5F), false }; - yield return new object[] { (RedisValue)0.5F, false }; - yield return new object[] { (RedisValue)float.PositiveInfinity, true }; - yield return new object[] { (RedisValue)float.NaN, true }; - - yield return new object[] { (RedisValue)double.NegativeInfinity, true }; - yield return new object[] { (RedisValue)(-0.5D), false }; - yield return new object[] { (RedisValue)0.5D, false }; - yield return new object[] { (RedisValue)double.PositiveInfinity, true }; - yield return new object[] { (RedisValue)double.NaN, true }; - - yield return new object[] { (RedisValue)true, true }; - yield return new object[] { (RedisValue)false, true }; - yield return new object[] { RedisValue.Null, true }; - yield return new object[] { RedisValue.EmptyString, true }; - yield return new object[] { (RedisValue)"abc", true }; - yield return new object[] { (RedisValue)s_abc, true }; - yield return new object[] { (RedisValue)new Memory(s_abc), false }; - yield return new object[] { (RedisValue)new ReadOnlyMemory(s_abc), false }; + yield return new object[] { (RedisValue)float.NegativeInfinity, true, "float" }; + yield return new object[] { (RedisValue)(-0.5F), false, "float" }; + yield return new object[] { (RedisValue)0.5F, false, "float" }; + yield return new object[] { (RedisValue)float.PositiveInfinity, true, "float" }; + yield return new object[] { (RedisValue)float.NaN, true, "float" }; + + yield return new object[] { (RedisValue)double.NegativeInfinity, true, "double" }; + yield return new object[] { (RedisValue)(-0.5D), false, "double" }; + yield return new object[] { (RedisValue)0.5D, false, "double" }; + yield return new object[] { (RedisValue)double.PositiveInfinity, true, "double" }; + yield return new object[] { (RedisValue)double.NaN, true, "double" }; + + yield return new object[] { (RedisValue)true, true, "bool" }; + yield return new object[] { (RedisValue)false, true, "bool" }; + yield return new object[] { RedisValue.Null, true, "Null" }; + yield return new object[] { RedisValue.EmptyString, true, "EmptyString" }; + yield return new object[] { (RedisValue)"abc", true, "string" }; + yield return new object[] { (RedisValue)s_abc, true, "byte[]" }; + + // memory that is a full array: fine, boxes as the array + Memory memRW = s_abc; + ReadOnlyMemory memRO = memRW; + yield return new object[] { (RedisValue)memRW, true, "byte[] Memory-full" }; + yield return new object[] { (RedisValue)memRO, true, "byte[] ReadOnlyMemory-full" }; + + // memory that is a partial array; boxes raw + memRW = s_abc.AsMemory(1, 2); + memRO = memRW; + yield return new object[] { (RedisValue)memRW, false, "byte[] Memory-partial" }; + yield return new object[] { (RedisValue)memRO, false, "byte[] ReadOnlyMemory-partial" }; + + var custom = new CustomMemoryManager(10); + memRW = custom.Memory; + memRO = memRW; + // memory that is a custom manager, full width; boxes raw + yield return new object[] { (RedisValue)memRW, false, "custom Memory-partial" }; + yield return new object[] { (RedisValue)memRO, false, "custom ReadOnlyMemory-partial" }; + + memRW = custom.Memory.Slice(1, 2); + memRO = memRW; + // memory that is a custom manager, partial width; boxes raw + yield return new object[] { (RedisValue)memRW, false, "custom Memory-partial" }; + yield return new object[] { (RedisValue)memRO, false, "custom ReadOnlyMemory-partial" }; + } + + private sealed class CustomMemoryManager(int size) : MemoryManager + { + private readonly byte[] _data = new byte[size]; + + public override Span GetSpan() => _data; + public override MemoryHandle Pin(int elementIndex = 0) => throw new NotSupportedException(); + public override void Unpin() { } + protected override void Dispose(bool disposing) { } } } diff --git a/tests/StackExchange.Redis.Tests/BufferedStreamWriterTests.cs b/tests/StackExchange.Redis.Tests/BufferedStreamWriterTests.cs new file mode 100644 index 000000000..82e3a7622 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/BufferedStreamWriterTests.cs @@ -0,0 +1,299 @@ +using System; +using System.Diagnostics; +using System.IO; +using System.Threading; +using System.Threading.Tasks; +using Xunit; + +namespace StackExchange.Redis.Tests; + +public class BufferedStreamWriterTests +{ + private const int PageSize = 8 * 1024; + + [Theory] + [InlineData(WriteMode.Sync)] + [InlineData(WriteMode.Async)] + public async Task FlushStateDoesNotLeakIntoNextPageActivation(WriteMode mode) + { + var stream = new ObservedStream(); + var writer = BufferedStreamWriter.Create((BufferedStreamWriter.WriteMode)mode, ConnectionType.Interactive, stream, CancellationToken.None); + try + { + Write(writer, 1, 1); + writer.Flush(); + await stream.WaitForFlushCountAsync(1).ForAwait(); + await WaitForInactiveAsync(writer).ForAwait(); + + stream.BlockNextWrite(); + Write(writer, PageSize, 2); + + var partial = writer.GetMemory(1); + await stream.WaitForBlockedWriteAsync().ForAwait(); + partial.Span[0] = 3; + writer.Advance(1); + + stream.ReleaseBlockedWrite(); + await stream.WaitForFlushCountAsync(2).ForAwait(); + + Assert.Equal(1 + PageSize, stream.BytesWritten); + } + finally + { + await CompleteAsync(writer, stream).ForAwait(); + } + } + + [Theory] + [InlineData(WriteMode.Sync)] + [InlineData(WriteMode.Async)] + public async Task WriterDoesNotLoseFlushRequestedDuringDrainFlush(WriteMode mode) + { + var stream = new ObservedStream(); + var writer = BufferedStreamWriter.Create((BufferedStreamWriter.WriteMode)mode, ConnectionType.Interactive, stream, CancellationToken.None); + try + { + stream.BlockNextFlush(); + Write(writer, 1, 1); + writer.Flush(); + + await stream.WaitForBlockedFlushAsync().ForAwait(); + + Write(writer, 1, 2); + writer.Flush(); + + stream.ReleaseBlockedFlush(); + await stream.WaitForFlushCountAsync(2).ForAwait(); + + Assert.Equal(2, stream.BytesWritten); + } + finally + { + await CompleteAsync(writer, stream).ForAwait(); + } + } + + [Theory] + [InlineData(WriteMode.Sync)] + [InlineData(WriteMode.Async)] + [InlineData(WriteMode.Pipe)] + public async Task WriterFaultsWriteCompleteAfterTargetWriteFailure(WriteMode mode) + { + var failure = new IOException("simulated target write failure"); + var stream = new ObservedStream { WriteException = failure }; + var writer = BufferedStreamWriter.Create((BufferedStreamWriter.WriteMode)mode, ConnectionType.Interactive, stream, CancellationToken.None); + + Write(writer, 1, 1); + writer.Flush(); + + var ex = await Assert.ThrowsAsync( + async () => await WaitWithTimeoutAsync(writer.WriteComplete, TimeSpan.FromSeconds(5)).ForAwait()).ForAwait(); + Assert.Same(failure, ex); + + var closed = Assert.Throws(() => writer.GetSpan(1)); + if (mode is not WriteMode.Pipe) + { + Assert.Same(failure, closed.InnerException); + } + } + + private static void Write(BufferedStreamWriter writer, int count, byte value) + { + var span = writer.GetSpan(count); + span.Slice(0, count).Fill(value); + writer.Advance(count); + } + + private static bool IsActive(BufferedStreamWriter writer) + => writer is CycleBufferStreamWriter cycle + && (cycle.State & CycleBufferStreamWriter.StateFlags.ActiveWriter) != 0; + + private static Task WaitForInactiveAsync(BufferedStreamWriter writer) + => WaitUntilAsync(() => !IsActive(writer), "writer did not become inactive"); + + private static async Task CompleteAsync(BufferedStreamWriter writer, ObservedStream stream) + { + stream.ReleaseBlockedWrite(); + stream.ReleaseBlockedFlush(); + writer.Complete(); + await WaitWithTimeoutAsync(writer.WriteComplete, TimeSpan.FromSeconds(5)).ForAwait(); + } + + private static async Task WaitUntilAsync(Func condition, string message, TimeSpan? timeout = null) + { + var watch = Stopwatch.StartNew(); + var limit = timeout ?? TimeSpan.FromSeconds(5); + while (!condition()) + { + if (watch.Elapsed >= limit) Assert.Fail(message); + await Task.Delay(10).ForAwait(); + } + } + + private static async Task WaitWithTimeoutAsync(Task task, TimeSpan timeout) + { + var delay = Task.Delay(timeout); + var first = await Task.WhenAny(task, delay).ForAwait(); + Assert.Same(task, first); + await task.ForAwait(); + } + + private sealed class ObservedStream : Stream + { + private readonly object _lock = new(); + private long _bytesWritten; + private int _flushCount; + private bool _blockNextWrite, _blockNextFlush; + private TaskCompletionSource? _blockedWrite, _allowWrite; + private TaskCompletionSource? _blockedFlush, _allowFlush; + + public Exception? WriteException { get; set; } + public long BytesWritten => Interlocked.Read(ref _bytesWritten); + + public override bool CanRead => false; + public override bool CanSeek => false; + public override bool CanWrite => true; + public override long Length => throw new NotSupportedException(); + public override long Position + { + get => throw new NotSupportedException(); + set => throw new NotSupportedException(); + } + + public void BlockNextWrite() + { + lock (_lock) + { + _blockNextWrite = true; + _blockedWrite = NewCompletionSource(); + _allowWrite = NewCompletionSource(); + } + } + + public Task WaitForBlockedWriteAsync() + { + lock (_lock) + { + return _blockedWrite?.Task ?? Task.CompletedTask; + } + } + + public void ReleaseBlockedWrite() + { + TaskCompletionSource? allow; + lock (_lock) + { + _blockNextWrite = false; + allow = _allowWrite; + _allowWrite = null; + } + allow?.TrySetResult(true); + } + + public void BlockNextFlush() + { + lock (_lock) + { + _blockNextFlush = true; + _blockedFlush = NewCompletionSource(); + _allowFlush = NewCompletionSource(); + } + } + + public Task WaitForBlockedFlushAsync() + { + lock (_lock) + { + return _blockedFlush?.Task ?? Task.CompletedTask; + } + } + + public void ReleaseBlockedFlush() + { + TaskCompletionSource? allow; + lock (_lock) + { + _blockNextFlush = false; + allow = _allowFlush; + _allowFlush = null; + } + allow?.TrySetResult(true); + } + + public Task WaitForFlushCountAsync(int count) + => WaitUntilAsync(() => Volatile.Read(ref _flushCount) >= count, $"flush count did not reach {count}"); + + public override void Flush() + => BeforeFlush(); + + public override Task FlushAsync(CancellationToken cancellationToken) + => BeforeFlushAsync().AsTask(); + + public override void Write(byte[] buffer, int offset, int count) + { + BeforeWrite(); + AfterWrite(count); + } + + public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) + => WriteAsync(count).AsTask(); + +#if NET + public override void Write(ReadOnlySpan buffer) + { + BeforeWrite(); + AfterWrite(buffer.Length); + } + + public override ValueTask WriteAsync(ReadOnlyMemory buffer, CancellationToken cancellationToken = default) + => WriteAsync(buffer.Length); +#endif + + private void BeforeWrite() + => GetBlockedOperation(ref _blockNextWrite, ref _blockedWrite, ref _allowWrite)?.GetAwaiter().GetResult(); + + private async ValueTask WriteAsync(int count) + { + var blocked = GetBlockedOperation(ref _blockNextWrite, ref _blockedWrite, ref _allowWrite); + if (blocked is not null) await blocked.ForAwait(); + AfterWrite(count); + } + + private void AfterWrite(int count) + { + if (WriteException is not null) throw WriteException; + Interlocked.Add(ref _bytesWritten, count); + } + + private void BeforeFlush() + => BeforeFlushAsync().AsTask().GetAwaiter().GetResult(); + + private async ValueTask BeforeFlushAsync() + { + Interlocked.Increment(ref _flushCount); + var blocked = GetBlockedOperation(ref _blockNextFlush, ref _blockedFlush, ref _allowFlush); + if (blocked is not null) await blocked.ForAwait(); + } + + private Task? GetBlockedOperation( + ref bool blockNext, + ref TaskCompletionSource? blocked, + ref TaskCompletionSource? allow) + { + lock (_lock) + { + if (!blockNext) return null; + blockNext = false; + blocked?.TrySetResult(true); + return allow?.Task; + } + } + + public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException(); + public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); + public override void SetLength(long value) => throw new NotSupportedException(); + + private static TaskCompletionSource NewCompletionSource() + => new(TaskCreationOptions.RunContinuationsAsynchronously); + } +} diff --git a/tests/StackExchange.Redis.Tests/ClusterShardedTests.cs b/tests/StackExchange.Redis.Tests/ClusterShardedTests.cs index c9101fb08..0826df837 100644 --- a/tests/StackExchange.Redis.Tests/ClusterShardedTests.cs +++ b/tests/StackExchange.Redis.Tests/ClusterShardedTests.cs @@ -14,11 +14,12 @@ public class ClusterShardedTests(ITestOutputHelper output) : TestBase(output) protected override string GetConfiguration() => TestConfig.Current.ClusterServersAndPorts + ",connectTimeout=10000"; [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task TestShardedPubsubSubscriberAgainstReconnects() { Skip.UnlessLongRunning(); var channel = RedisChannel.Sharded(Me()); - await using var conn = Create(allowAdmin: true, keepAlive: 1, connectTimeout: 3000, shared: false, require: RedisFeatures.v7_0_0_rc1); + await using var conn = Create(allowAdmin: true, keepAlive: 1, connectTimeout: 3000, require: RedisFeatures.v7_0_0_rc1, allowSimulateConnectionFailure: true); Assert.True(conn.IsConnected); var db = conn.GetDatabase(); Assert.Equal(0, await db.PublishAsync(channel, "noClientReceivesThis")); diff --git a/tests/StackExchange.Redis.Tests/ClusterTests.cs b/tests/StackExchange.Redis.Tests/ClusterTests.cs index e44ee8be4..016480c59 100644 --- a/tests/StackExchange.Redis.Tests/ClusterTests.cs +++ b/tests/StackExchange.Redis.Tests/ClusterTests.cs @@ -147,7 +147,7 @@ public async Task TestIdentity() public async Task IntentionalWrongServer() { static string? StringGet(IServer server, RedisKey key, CommandFlags flags = CommandFlags.None) - => (string?)server.Execute("GET", [key], flags); + => (string?)server.Execute(0, "GET", [key], flags); await using var conn = Create(); @@ -577,7 +577,7 @@ public async Task SScan() { await using var conn = Create(); - RedisKey key = "a"; + RedisKey key = Me(); var db = conn.GetDatabase(); db.KeyDelete(key, CommandFlags.FireAndForget); @@ -832,14 +832,14 @@ public async Task MovedProfiling() Assert.NotNull(rightPrimaryNode); Assert.NotNull(rightPrimaryNode.EndPoint); - string? a = (string?)conn.GetServer(rightPrimaryNode.EndPoint).Execute("GET", key); + string? a = (string?)conn.GetServer(rightPrimaryNode.EndPoint).Execute(0, "GET", [key]); Assert.Equal(Value, a); // right primary var wrongPrimaryNode = config.Nodes.FirstOrDefault(x => !x.IsReplica && x.NodeId != rightPrimaryNode.NodeId); Assert.NotNull(wrongPrimaryNode); Assert.NotNull(wrongPrimaryNode.EndPoint); - string? b = (string?)conn.GetServer(wrongPrimaryNode.EndPoint).Execute("GET", key); + string? b = (string?)conn.GetServer(wrongPrimaryNode.EndPoint).Execute(0, "GET", [key]); Assert.Equal(Value, b); // wrong primary, allow redirect var msgs = profiler.GetSession().FinishProfiling().ToList(); diff --git a/tests/StackExchange.Redis.Tests/CommandTests.cs b/tests/StackExchange.Redis.Tests/CommandTests.cs deleted file mode 100644 index 42df92dd1..000000000 --- a/tests/StackExchange.Redis.Tests/CommandTests.cs +++ /dev/null @@ -1,56 +0,0 @@ -using System.Net; -using Xunit; - -namespace StackExchange.Redis.Tests; - -public class CommandTests -{ - [Fact] - public void CommandByteLength() - { - Assert.Equal(31, CommandBytes.MaxLength); - } - - [Fact] - public void CheckCommandContents() - { - for (int len = 0; len <= CommandBytes.MaxLength; len++) - { - var s = new string('A', len); - CommandBytes b = s; - Assert.Equal(len, b.Length); - - var t = b.ToString(); - Assert.Equal(s, t); - - CommandBytes b2 = t; - Assert.Equal(b, b2); - - Assert.Equal(len == 0, ReferenceEquals(s, t)); - } - } - - [Fact] - public void Basic() - { - var config = ConfigurationOptions.Parse(".,$PING=p"); - Assert.Single(config.EndPoints); - config.SetDefaultPorts(); - Assert.Contains(new DnsEndPoint(".", 6379), config.EndPoints); - var map = config.CommandMap; - Assert.Equal("$PING=P", map.ToString()); - Assert.Equal(".:6379,$PING=P", config.ToString()); - } - - [Theory] - [InlineData("redisql.CREATE_STATEMENT")] - [InlineData("INSERTINTOTABLE1STMT")] - public void CanHandleNonTrivialCommands(string command) - { - var cmd = new CommandBytes(command); - Assert.Equal(command.Length, cmd.Length); - Assert.Equal(command.ToUpperInvariant(), cmd.ToString()); - - Assert.Equal(31, CommandBytes.MaxLength); - } -} diff --git a/tests/StackExchange.Redis.Tests/ConfigTests.cs b/tests/StackExchange.Redis.Tests/ConfigTests.cs index a2527b985..561308d30 100644 --- a/tests/StackExchange.Redis.Tests/ConfigTests.cs +++ b/tests/StackExchange.Redis.Tests/ConfigTests.cs @@ -6,6 +6,7 @@ using System.Net; using System.Net.Sockets; using System.Reflection; +using System.Runtime.CompilerServices; using System.Security.Authentication; using System.Text; using System.Text.RegularExpressions; @@ -13,6 +14,7 @@ using System.Threading.Tasks; using Microsoft.Extensions.Logging.Abstractions; using StackExchange.Redis.Configuration; +using StackExchange.Redis.Tests.Helpers; using Xunit; namespace StackExchange.Redis.Tests; @@ -20,7 +22,31 @@ namespace StackExchange.Redis.Tests; [RunPerProtocol] public class ConfigTests(ITestOutputHelper output, SharedConnectionFixture fixture) : TestBase(output, fixture) { - public Version DefaultVersion = new(3, 0, 0); + private static Version BaseDefaultVersion => DefaultOptionsProvider.BaseDefaultVersion; + + private static void ApplyTestDefaults(ConfigurationOptions options, bool applyProtocol = true) + { + if (applyProtocol) options.Protocol = TestContext.Current.GetProtocol(); + } + + private static string RemoveTestDefaults(string configurationString) + { + var pattern = TestContext.Current.GetProtocol() switch + { + RedisProtocol.Resp2 => ",protocol=resp2(?=,|$)", + RedisProtocol.Resp3 => ",protocol=resp3(?=,|$)", + _ => null, + }; + return pattern is null + ? configurationString + : Regex.Replace(configurationString, pattern, ""); + } + private static ConfigurationOptions Parse(string configuration, bool applyProtocol = true) + { + var options = ConfigurationOptions.Parse(configuration); + ApplyTestDefaults(options, applyProtocol); + return options; + } [Fact] public void ExpectedFields() @@ -37,49 +63,42 @@ orderby name new[] { "_protocol", - "abortOnConnectFail", - "allowAdmin", "asyncTimeout", "backlogPolicy", "BeforeSocketConnect", "CertificateSelection", "CertificateValidation", "ChannelPrefix", - "checkCertificateRevocation", "ClientName", "commandMap", "configChannel", "configCheckSeconds", "connectRetry", "connectTimeout", - "DefaultDatabase", + "defaultDatabase", "defaultOptions", "defaultVersion", "EndPoints", - "heartbeatConsistencyChecks", "heartbeatInterval", - "highIntegrity", - "includeDetailInExceptions", - "includePerformanceCountersInExceptions", "keepAlive", "LibraryName", "loggerFactory", + "optionFlags", +#if DEBUG + "OutputLog", +#endif "password", "proxy", "reconnectRetryPolicy", - "resolveDns", "responseTimeout", "ServiceName", - "setClientLibrary", "SocketManager", - "ssl", #if !NETFRAMEWORK "SslClientAuthenticationOptions", #endif "sslHost", - "SslProtocols", + "sslProtocols", "syncTimeout", - "tcpKeepAlive", "tieBreaker", "Tunnel", "user", @@ -109,14 +128,14 @@ orderby field.Name [Fact] public void SslProtocols_SingleValue() { - var options = ConfigurationOptions.Parse("myhost,sslProtocols=Tls12"); + var options = Parse("myhost,sslProtocols=Tls12"); Assert.Equal(SslProtocols.Tls12, options.SslProtocols.GetValueOrDefault()); } [Fact] public void SslProtocols_MultipleValues() { - var options = ConfigurationOptions.Parse("myhost,sslProtocols=Tls12|Tls13"); + var options = Parse("myhost,sslProtocols=Tls12|Tls13"); Assert.Equal(SslProtocols.Tls12 | SslProtocols.Tls13, options.SslProtocols.GetValueOrDefault()); } @@ -126,7 +145,7 @@ public void SslProtocols_MultipleValues() [InlineData("", true)] public void ConfigurationOption_CheckCertificateRevocation(string conString, bool expectedValue) { - var options = ConfigurationOptions.Parse($"host,{conString}"); + var options = Parse($"host,{conString}"); Assert.Equal(expectedValue, options.CheckCertificateRevocation); var toString = options.ToString(); Assert.Contains(conString, toString, StringComparison.CurrentCultureIgnoreCase); @@ -139,14 +158,14 @@ public void SslProtocols_UsingIntegerValue() // .NET framework version (e.g. .NET 4.0) doesn't define an enum value (e.g. Tls11) // but the OS has been patched with support const int integerValue = (int)(SslProtocols.Tls12 | SslProtocols.Tls13); - var options = ConfigurationOptions.Parse("myhost,sslProtocols=" + integerValue); + var options = Parse("myhost,sslProtocols=" + integerValue); Assert.Equal(SslProtocols.Tls12 | SslProtocols.Tls13, options.SslProtocols.GetValueOrDefault()); } [Fact] public void SslProtocols_InvalidValue() { - Assert.Throws(() => ConfigurationOptions.Parse("myhost,sslProtocols=InvalidSslProtocol")); + Assert.Throws(() => Parse("myhost,sslProtocols=InvalidSslProtocol")); } [Theory] @@ -161,7 +180,7 @@ public void SslProtocols_InvalidValue() public void ConfigurationOptionsDefaultForAzure(string hostAndPort, bool sslShouldBeEnabled) { Version defaultAzureVersion = new(6, 0, 0); - var options = ConfigurationOptions.Parse(hostAndPort); + var options = Parse(hostAndPort); Assert.True(options.DefaultVersion.Equals(defaultAzureVersion)); Assert.False(options.AbortOnConnectFail); Assert.Equal(sslShouldBeEnabled, options.Ssl); @@ -180,7 +199,7 @@ public void ConfigurationOptionsDefaultForAzure(string hostAndPort, bool sslShou public void ConfigurationOptionsDefaultForAzureManagedRedis(string hostAndPort, bool sslShouldBeEnabled) { Version defaultAzureManagedRedisVersion = new(7, 4, 0); - var options = ConfigurationOptions.Parse(hostAndPort); + var options = Parse(hostAndPort); Assert.True(options.DefaultVersion.Equals(defaultAzureManagedRedisVersion)); Assert.False(options.AbortOnConnectFail); Assert.Equal(sslShouldBeEnabled, options.Ssl); @@ -191,17 +210,20 @@ public void ConfigurationOptionsDefaultForAzureManagedRedis(string hostAndPort, [InlineData("contoso.redis.azure.net:10000", RedisProtocol.Resp3, true)] // default [InlineData("contoso.redis.azure.net:10000,protocol=resp2", RedisProtocol.Resp2, false)] // opt-out [InlineData("contoso.redis.azure.net:10000,protocol=resp3", RedisProtocol.Resp3, true)] // opt-in + [InlineData("contoso.redis.azure.net:10000,version=5", RedisProtocol.Resp3, true)] // low version *ignored* (provider wins) // azure redis cache, no overrides (we expect this to change in v3) - [InlineData("contoso.redis.cache.windows.net:6380", null, false)] // default + [InlineData("contoso.redis.cache.windows.net:6380", null, true)] // default [InlineData("contoso.redis.cache.windows.net:6380,protocol=resp2", RedisProtocol.Resp2, false)] // opt-out [InlineData("contoso.redis.cache.windows.net:6380,protocol=resp3", RedisProtocol.Resp3, true)] // opt-in + [InlineData("contoso.redis.cache.windows.net:6380,version=5", null, false)] // low version means resp2 // arbitrary endpoint (we expect this to change in v3) - [InlineData("myserver:6379", null, false)] // default + [InlineData("myserver:6379", null, true)] // default [InlineData("myserver:6379,protocol=resp2", RedisProtocol.Resp2, false)] // opt-out [InlineData("myserver:6379,protocol=resp3", RedisProtocol.Resp3, true)] // opt-in + [InlineData("myserver:6379,version=5", null, false)] // low version means resp2 public void CorrectRespProtocol(string config, RedisProtocol? expected, bool useResp3) { - var options = ConfigurationOptions.Parse(config); + var options = Parse(config, applyProtocol: false); Assert.Equal(expected, options.Protocol); Assert.Equal(useResp3, options.TryResp3()); } @@ -209,7 +231,7 @@ public void CorrectRespProtocol(string config, RedisProtocol? expected, bool use [Fact] public void ConfigurationOptionsForAzureWhenSpecified() { - var options = ConfigurationOptions.Parse("contoso.redis.cache.windows.net,abortConnect=true, version=2.1.1"); + var options = Parse("contoso.redis.cache.windows.net,abortConnect=true, version=2.1.1"); Assert.True(options.DefaultVersion.Equals(new Version(2, 1, 1))); Assert.True(options.AbortOnConnectFail); } @@ -230,8 +252,8 @@ public void ConfigurationOptionsForAzureWhenSpecified() [InlineData("contoso.redis.azure.net:")] // AMR host name with missing port public void ConfigurationOptionsDefaultForNonAzure(string hostAndPort) { - var options = ConfigurationOptions.Parse(hostAndPort); - Assert.True(options.DefaultVersion.Equals(DefaultVersion)); + var options = Parse(hostAndPort); + Assert.True(options.DefaultVersion.Equals(BaseDefaultVersion)); Assert.True(options.AbortOnConnectFail); Assert.False(options.Ssl); } @@ -240,7 +262,7 @@ public void ConfigurationOptionsDefaultForNonAzure(string hostAndPort) public void ConfigurationOptionsDefaultWhenNoEndpointsSpecifiedYet() { var options = new ConfigurationOptions(); - Assert.True(options.DefaultVersion.Equals(DefaultVersion)); + Assert.True(options.DefaultVersion.Equals(BaseDefaultVersion)); Assert.True(options.AbortOnConnectFail); } @@ -251,7 +273,7 @@ public void ConfigurationOptionsSyncTimeout() var options = new ConfigurationOptions(); Assert.Equal(5000, options.SyncTimeout); - options = ConfigurationOptions.Parse("syncTimeout=20"); + options = Parse("syncTimeout=20"); Assert.Equal(20, options.SyncTimeout); } @@ -262,7 +284,7 @@ public void ConfigurationOptionsSyncTimeout() [InlineData("[2a01:9820:1:24::1:1]:6379", AddressFamily.InterNetworkV6, "2a01:9820:1:24::1:1", 6379)] public void ConfigurationOptionsIPv6Parsing(string configString, AddressFamily family, string address, int port) { - var options = ConfigurationOptions.Parse(configString); + var options = Parse(configString); Assert.Single(options.EndPoints); var ep = Assert.IsType(options.EndPoints[0]); Assert.Equal(family, ep.AddressFamily); @@ -275,14 +297,14 @@ public void CanParseAndFormatUnixDomainSocket() { const string ConfigString = "!/some/path,allowAdmin=True"; #if NETFRAMEWORK - var ex = Assert.Throws(() => ConfigurationOptions.Parse(ConfigString)); + var ex = Assert.Throws(() => Parse(ConfigString)); Assert.Equal("Unix domain sockets require .NET Core 3 or above", ex.Message); #else - var config = ConfigurationOptions.Parse(ConfigString); + var config = Parse(ConfigString); Assert.True(config.AllowAdmin); var ep = Assert.IsType(Assert.Single(config.EndPoints)); Assert.Equal("/some/path", ep.ToString()); - Assert.Equal(ConfigString, config.ToString()); + Assert.Equal(ConfigString, RemoveTestDefaults(config.ToString())); #endif } @@ -298,6 +320,7 @@ public async Task TalkToNonsenseServer() }, ConnectTimeout = 200, }; + ApplyTestDefaults(config); var log = new StringWriter(); await using (var conn = ConnectionMultiplexer.Connect(config, log)) { @@ -309,7 +332,7 @@ public async Task TalkToNonsenseServer() [Fact] public async Task TestManualHeartbeat() { - var options = ConfigurationOptions.Parse(GetConfiguration()); + var options = Parse(GetConfiguration()); options.HeartbeatInterval = TimeSpan.FromMilliseconds(100); await using var conn = await ConnectionMultiplexer.ConnectAsync(options); @@ -478,6 +501,7 @@ public async Task GetTime() public async Task DebugObject() { await using var conn = Create(allowAdmin: true); + await AssertDebugCommandEnabledAsync(conn); var db = conn.GetDatabase(); RedisKey key = Me(); @@ -605,33 +629,6 @@ public void EndpointIteratorIsReliableOverChanges() Assert.False(iter.MoveNext()); } - [Fact] - public async Task ThreadPoolManagerIsDetected() - { - var config = new ConfigurationOptions - { - EndPoints = { { IPAddress.Loopback, 6379 } }, - SocketManager = SocketManager.ThreadPool, - }; - - await using var conn = ConnectionMultiplexer.Connect(config); - - Assert.Same(PipeScheduler.ThreadPool, conn.SocketManager?.Scheduler); - } - - [Fact] - public async Task DefaultThreadPoolManagerIsDetected() - { - var config = new ConfigurationOptions - { - EndPoints = { { IPAddress.Loopback, 6379 } }, - }; - - await using var conn = ConnectionMultiplexer.Connect(config); - - Assert.Same(SocketManager.Shared.Scheduler, conn.SocketManager?.Scheduler); - } - [Theory] [InlineData("myDNS:myPort,password=myPassword,connectRetry=3,connectTimeout=15000,syncTimeout=15000,defaultDatabase=0,abortConnect=false,ssl=true,sslProtocols=Tls12", SslProtocols.Tls12)] [InlineData("myDNS:myPort,password=myPassword,abortConnect=false,ssl=true,sslProtocols=Tls12", SslProtocols.Tls12)] @@ -641,7 +638,7 @@ public async Task DefaultThreadPoolManagerIsDetected() [InlineData("myDNS:myPort,password=myPassword,abortConnect=false,ssl=true,sslProtocols=Tls12 ", SslProtocols.Tls12)] public void ParseTlsWithoutTrailingComma(string configString, SslProtocols expected) { - var config = ConfigurationOptions.Parse(configString); + var config = Parse(configString); Assert.Equal(expected, config.SslProtocols); } @@ -654,7 +651,7 @@ public void ParseTlsWithoutTrailingComma(string configString, SslProtocols expec [InlineData("foo,proxy=epoxy", "Keyword 'proxy' requires a proxy value; the value 'epoxy' is not recognised.", "proxy")] public void ConfigStringErrorsGiveMeaningfulMessages(string configString, string expected, string paramName) { - var ex = Assert.Throws(() => ConfigurationOptions.Parse(configString)); + var ex = Assert.Throws(() => Parse(configString)); Assert.StartsWith(expected, ex.Message); // param name gets concatenated sometimes Assert.Equal(paramName, ex.ParamName); // param name gets concatenated sometimes } @@ -662,7 +659,7 @@ public void ConfigStringErrorsGiveMeaningfulMessages(string configString, string [Fact] public void ConfigStringInvalidOptionErrorGiveMeaningfulMessages() { - var ex = Assert.Throws(() => ConfigurationOptions.Parse("foo,flibble=value")); + var ex = Assert.Throws(() => Parse("foo,flibble=value")); Assert.StartsWith("Keyword 'flibble' is not supported.", ex.Message); // param name gets concatenated sometimes Assert.Equal("flibble", ex.ParamName); } @@ -670,7 +667,7 @@ public void ConfigStringInvalidOptionErrorGiveMeaningfulMessages() [Fact] public void NullApply() { - var options = ConfigurationOptions.Parse("127.0.0.1,name=FooApply"); + var options = Parse("127.0.0.1,name=FooApply"); Assert.Equal("FooApply", options.ClientName); // Doesn't go boom @@ -682,7 +679,7 @@ public void NullApply() [Fact] public void Apply() { - var options = ConfigurationOptions.Parse("127.0.0.1,name=FooApply"); + var options = Parse("127.0.0.1,name=FooApply"); Assert.Equal("FooApply", options.ClientName); var randomName = Guid.NewGuid().ToString(); @@ -696,7 +693,7 @@ public void Apply() [Fact] public async Task BeforeSocketConnect() { - var options = ConfigurationOptions.Parse(TestConfig.Current.PrimaryServerAndPort); + var options = Parse(TestConfig.Current.PrimaryServerAndPort); int count = 0; options.BeforeSocketConnect = (endpoint, connType, socket) => { @@ -707,7 +704,7 @@ public async Task BeforeSocketConnect() }; await using var conn = ConnectionMultiplexer.Connect(options); Assert.True(conn.IsConnected); - Assert.Equal(2, count); + Assert.Equal(options.TryResp3() ? 1 : 2, count); var endpoint = conn.GetServerSnapshot()[0]; var interactivePhysical = endpoint.GetBridge(ConnectionType.Interactive)?.TryConnect(null); @@ -721,7 +718,10 @@ public async Task BeforeSocketConnect() Assert.NotNull(subscriptionSocket); Assert.Equal(12, interactiveSocket.Ttl); - Assert.Equal(123, subscriptionSocket.Ttl); + if (!ReferenceEquals(interactiveSocket, subscriptionSocket)) + { + Assert.Equal(123, subscriptionSocket.Ttl); + } Assert.True(interactiveSocket.DontFragment); Assert.True(subscriptionSocket.DontFragment); } @@ -729,13 +729,17 @@ public async Task BeforeSocketConnect() [Fact] public async Task MutableOptions() { - var options = ConfigurationOptions.Parse(TestConfig.Current.PrimaryServerAndPort + ",name=Details"); + var options = Parse(TestConfig.Current.PrimaryServerAndPort + ",name=Details"); options.LoggerFactory = NullLoggerFactory.Instance; var originalConfigChannel = options.ConfigurationChannel = "originalConfig"; var originalUser = options.User = "originalUser"; var originalPassword = options.Password = "originalPassword"; Assert.Equal("Details", options.ClientName); - await using var conn = await ConnectionMultiplexer.ConnectAsync(options); + Assert.SkipWhen(options.TryResp3(), "only validate RESP2"); + Log(options.ToString()); + await using var conn = await ConnectionMultiplexer.ConnectAsync(options, log: Writer); + Assert.NotNull(conn.AuthException); + Log($"auth failure: {conn.AuthException.Message}"); // Same instance Assert.Same(options, conn.RawConfig); @@ -780,6 +784,7 @@ public async Task MutableOptions() var newPass = options.Password = "newPassword"; Assert.Equal(newPass, conn.RawConfig.Password); Assert.Equal(options.LoggerFactory, conn.RawConfig.LoggerFactory); + Log("complete"); } [Theory] @@ -787,7 +792,7 @@ public async Task MutableOptions() [InlineData("http:somewhere:22", "http:somewhere:22")] public void HttpTunnelCanRoundtrip(string input, string expected) { - var config = ConfigurationOptions.Parse($"127.0.0.1:6380,tunnel={input}"); + var config = Parse($"127.0.0.1:6380,tunnel={input}"); var ip = Assert.IsType(Assert.Single(config.EndPoints)); Assert.Equal(6380, ip.Port); Assert.Equal("127.0.0.1", ip.Address.ToString()); @@ -796,7 +801,7 @@ public void HttpTunnelCanRoundtrip(string input, string expected) Assert.Equal(expected, config.Tunnel.ToString()); var cs = config.ToString(); - Assert.Equal($"127.0.0.1:6380,tunnel={expected}", cs); + Assert.Equal($"127.0.0.1:6380,tunnel={expected}", RemoveTestDefaults(cs)); } private sealed class CustomTunnel : Tunnel { } @@ -806,11 +811,11 @@ public void CustomTunnelCanRoundtripMinusTunnel() { // we don't expect to be able to parse custom tunnels, but we should still be able to round-trip // the rest of the config, which means ignoring them *in both directions* (unless first party) - var options = ConfigurationOptions.Parse("127.0.0.1,Ssl=true"); + var options = Parse("127.0.0.1,Ssl=true"); options.Tunnel = new CustomTunnel(); var cs = options.ToString(); - Assert.Equal("127.0.0.1,ssl=True", cs); - options = ConfigurationOptions.Parse(cs); + Assert.Equal("127.0.0.1,ssl=True", RemoveTestDefaults(cs)); + options = Parse(cs); Assert.Null(options.Tunnel); } @@ -820,12 +825,12 @@ public void CustomTunnelCanRoundtripMinusTunnel() [InlineData("server:6379,setlib=False", false)] public void DefaultConfigOptionsForSetLib(string configurationString, bool setlib) { - var options = ConfigurationOptions.Parse(configurationString); + var options = Parse(configurationString); Assert.Equal(setlib, options.SetClientLibrary); - Assert.Equal(configurationString, options.ToString()); + Assert.Equal(configurationString, RemoveTestDefaults(options.ToString())); options = options.Clone(); Assert.Equal(setlib, options.SetClientLibrary); - Assert.Equal(configurationString, options.ToString()); + Assert.Equal(configurationString, RemoveTestDefaults(options.ToString())); } [Theory] @@ -834,17 +839,17 @@ public void DefaultConfigOptionsForSetLib(string configurationString, bool setli [InlineData(true, true, "dummy,highIntegrity=True")] public void CheckHighIntegrity(bool? assigned, bool expected, string cs) { - var options = ConfigurationOptions.Parse("dummy"); + var options = Parse("dummy"); if (assigned.HasValue) options.HighIntegrity = assigned.Value; Assert.Equal(expected, options.HighIntegrity); - Assert.Equal(cs, options.ToString()); + Assert.Equal(cs, RemoveTestDefaults(options.ToString())); var clone = options.Clone(); Assert.Equal(expected, clone.HighIntegrity); - Assert.Equal(cs, clone.ToString()); + Assert.Equal(cs, RemoveTestDefaults(clone.ToString())); - var parsed = ConfigurationOptions.Parse(cs); + var parsed = Parse(cs); Assert.Equal(expected, parsed.HighIntegrity); } diff --git a/tests/StackExchange.Redis.Tests/ConnectFailTimeoutTests.cs b/tests/StackExchange.Redis.Tests/ConnectFailTimeoutTests.cs index 6a7e253d7..5f41103d0 100644 --- a/tests/StackExchange.Redis.Tests/ConnectFailTimeoutTests.cs +++ b/tests/StackExchange.Redis.Tests/ConnectFailTimeoutTests.cs @@ -7,12 +7,14 @@ namespace StackExchange.Redis.Tests; public class ConnectFailTimeoutTests(ITestOutputHelper output) : TestBase(output) { [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task NoticesConnectFail() { SetExpectedAmbientFailureCount(-1); - await using var conn = Create(allowAdmin: true, shared: false, backlogPolicy: BacklogPolicy.FailFast); + await using var conn = Create(allowAdmin: true, backlogPolicy: BacklogPolicy.FailFast, allowSimulateConnectionFailure: true); var server = conn.GetServer(conn.GetEndPoints()[0]); + Assert.SkipUnless(server.CanSimulateConnectionFailure(), "Skipping because server cannot simulate connection failure"); await RunBlockingSynchronousWithExtraThreadAsync(InnerScenario).ForAwait(); diff --git a/tests/StackExchange.Redis.Tests/ConnectingFailDetectionTests.cs b/tests/StackExchange.Redis.Tests/ConnectingFailDetectionTests.cs index a905c613a..10ad1afa0 100644 --- a/tests/StackExchange.Redis.Tests/ConnectingFailDetectionTests.cs +++ b/tests/StackExchange.Redis.Tests/ConnectingFailDetectionTests.cs @@ -10,17 +10,19 @@ public class ConnectingFailDetectionTests(ITestOutputHelper output) : TestBase(o protected override string GetConfiguration() => TestConfig.Current.PrimaryServerAndPort + "," + TestConfig.Current.ReplicaServerAndPort; [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task FastNoticesFailOnConnectingSyncCompletion() { try { - await using var conn = Create(keepAlive: 1, connectTimeout: 10000, allowAdmin: true, shared: false); + await using var conn = Create(keepAlive: 1, connectTimeout: 10000, allowAdmin: true, allowSimulateConnectionFailure: true); conn.RawConfig.ReconnectRetryPolicy = new LinearRetry(200); var db = conn.GetDatabase(); await db.PingAsync(); var server = conn.GetServer(conn.GetEndPoints()[0]); + Assert.SkipUnless(server.CanSimulateConnectionFailure(), "Skipping because server cannot simulate connection failure"); var server2 = conn.GetServer(conn.GetEndPoints()[1]); conn.AllowConnect = false; @@ -50,17 +52,19 @@ public async Task FastNoticesFailOnConnectingSyncCompletion() } [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task FastNoticesFailOnConnectingAsyncCompletion() { try { - await using var conn = Create(keepAlive: 1, connectTimeout: 10000, allowAdmin: true, shared: false); + await using var conn = Create(keepAlive: 1, connectTimeout: 10000, allowAdmin: true, allowSimulateConnectionFailure: true); conn.RawConfig.ReconnectRetryPolicy = new LinearRetry(200); var db = conn.GetDatabase(); await db.PingAsync(); var server = conn.GetServer(conn.GetEndPoints()[0]); + Assert.SkipUnless(server.CanSimulateConnectionFailure(), "Skipping because server cannot simulate connection failure"); var server2 = conn.GetServer(conn.GetEndPoints()[1]); conn.AllowConnect = false; @@ -90,6 +94,7 @@ public async Task FastNoticesFailOnConnectingAsyncCompletion() } [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task Issue922_ReconnectRaised() { var config = ConfigurationOptions.Parse(TestConfig.Current.PrimaryServerAndPort); @@ -99,6 +104,7 @@ public async Task Issue922_ReconnectRaised() config.AsyncTimeout = 1000; config.ReconnectRetryPolicy = new ExponentialRetry(5000); config.AllowAdmin = true; + config.AllowSimulateConnectionFailure = true; config.BacklogPolicy = BacklogPolicy.FailFast; int failCount = 0, restoreCount = 0; @@ -121,16 +127,21 @@ public async Task Issue922_ReconnectRaised() Assert.Equal(0, Volatile.Read(ref restoreCount)); var server = conn.GetServer(TestConfig.Current.PrimaryServerAndPort); + var protocol = server.Protocol; + // RESP2 has interactive+subscriber connections; RESP3 uses one connection for both. + var expectedCount = protocol is RedisProtocol.Resp3 ? 1 : 2; + Log($"Using {protocol.GetString()}; expecting {expectedCount} reconnect event(s)"); + + Assert.SkipUnless(server.CanSimulateConnectionFailure(), "Skipping because server cannot simulate connection failure"); server.SimulateConnectionFailure(SimulatedFailureType.All); - await UntilConditionAsync(TimeSpan.FromSeconds(10), () => Volatile.Read(ref failCount) >= 2 && Volatile.Read(ref restoreCount) >= 2); + await UntilConditionAsync(TimeSpan.FromSeconds(10), () => Volatile.Read(ref failCount) >= expectedCount && Volatile.Read(ref restoreCount) >= expectedCount); - // interactive+subscriber = 2 var failCountSnapshot = Volatile.Read(ref failCount); - Assert.True(failCountSnapshot >= 2, $"failCount {failCountSnapshot} >= 2"); + Assert.True(failCountSnapshot >= expectedCount, $"failCount {failCountSnapshot} >= {expectedCount} ({protocol.GetString()})"); var restoreCountSnapshot = Volatile.Read(ref restoreCount); - Assert.True(restoreCountSnapshot >= 2, $"restoreCount ({restoreCountSnapshot}) >= 2"); + Assert.True(restoreCountSnapshot >= expectedCount, $"restoreCount ({restoreCountSnapshot}) >= {expectedCount} ({protocol.GetString()})"); } [Fact] diff --git a/tests/StackExchange.Redis.Tests/ConnectionFailedErrorsTests.cs b/tests/StackExchange.Redis.Tests/ConnectionFailedErrorsTests.cs index ce1a31980..54dea8b65 100644 --- a/tests/StackExchange.Redis.Tests/ConnectionFailedErrorsTests.cs +++ b/tests/StackExchange.Redis.Tests/ConnectionFailedErrorsTests.cs @@ -167,19 +167,50 @@ public void TryGetAzureRoleInstanceIdNoThrow() Assert.Null(DefaultOptionsProvider.TryGetAzureRoleInstanceIdNoThrow()); } -#if DEBUG [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task CheckFailureRecovered() + { + var options = ConfigurationOptions.Parse(GetConfiguration()); + ConfigureFailureRecovery(options); + + await using var conn = await ConnectionMultiplexer.ConnectAsync(options, Writer); + await CheckFailureRecoveredAsync(conn); + } + + [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] + public async Task CheckFailureRecoveredInProcess() + { + using var server = new InProcessTestServer(Output); + var options = server.GetClientConfig(); + ConfigureFailureRecovery(options); + + await using var conn = await ConnectionMultiplexer.ConnectAsync(options, Writer); + await CheckFailureRecoveredAsync(conn); + } + + private static void ConfigureFailureRecovery(ConfigurationOptions options) + { + options.ConnectTimeout = 10000; + options.AllowAdmin = true; + options.AllowSimulateConnectionFailure = true; + options.Protocol = TestContext.Current.GetProtocol(); + options.KeepAlive = 1; + options.HeartbeatInterval = TimeSpan.FromSeconds(1); + options.ReconnectRetryPolicy = new LinearRetry((int)options.HeartbeatInterval.TotalMilliseconds); + } + + private async Task CheckFailureRecoveredAsync(ConnectionMultiplexer conn) { try { - await using var conn = Create(keepAlive: 1, connectTimeout: 10000, allowAdmin: true, log: Writer, shared: false); - await RunBlockingSynchronousWithExtraThreadAsync(InnerScenario).ForAwait(); void InnerScenario() { conn.GetDatabase(); var server = conn.GetServer(conn.GetEndPoints()[0]); + Assert.SkipUnless(server.CanSimulateConnectionFailure(), "Skipping because server cannot simulate connection failure"); conn.AllowConnect = false; @@ -192,7 +223,8 @@ void InnerScenario() // should reconnect within 1 keepalive interval conn.AllowConnect = true; } - await Task.Delay(2000).ForAwait(); + var recoveryTime = await UntilConditionAsync(TimeSpan.FromSeconds(10), () => conn.GetServerSnapshot()[0].LastException is null).ForAwait(); + Log("Connection failure recovered after {0:N0}ms", recoveryTime.TotalMilliseconds); Assert.Null(conn.GetServerSnapshot()[0].LastException); } @@ -201,5 +233,4 @@ void InnerScenario() ClearAmbientFailures(); } } -#endif } diff --git a/tests/StackExchange.Redis.Tests/ConnectionShutdownTests.cs b/tests/StackExchange.Redis.Tests/ConnectionShutdownTests.cs index 279d8bd23..386a260f0 100644 --- a/tests/StackExchange.Redis.Tests/ConnectionShutdownTests.cs +++ b/tests/StackExchange.Redis.Tests/ConnectionShutdownTests.cs @@ -8,9 +8,10 @@ namespace StackExchange.Redis.Tests; public class ConnectionShutdownTests(ITestOutputHelper output) : TestBase(output) { [Fact(Skip = "Unfriendly")] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task ShutdownRaisesConnectionFailedAndRestore() { - await using var conn = Create(allowAdmin: true, shared: false); + await using var conn = Create(allowAdmin: true, allowSimulateConnectionFailure: true); int failed = 0, restored = 0; Stopwatch watch = Stopwatch.StartNew(); diff --git a/tests/StackExchange.Redis.Tests/DatabaseTests.cs b/tests/StackExchange.Redis.Tests/DatabaseTests.cs index 680f67837..c4e8ba168 100644 --- a/tests/StackExchange.Redis.Tests/DatabaseTests.cs +++ b/tests/StackExchange.Redis.Tests/DatabaseTests.cs @@ -83,10 +83,10 @@ public async Task CountKeys() { Skip.IfMissingDatabase(conn, db1Id); Skip.IfMissingDatabase(conn, db2Id); - RedisKey key = Me(); + var key = Me(); var dba = conn.GetDatabase(db1Id); var dbb = conn.GetDatabase(db2Id); - dba.StringSet("abc", "def", flags: CommandFlags.FireAndForget); + dba.StringSet(key + ":abc", "def", flags: CommandFlags.FireAndForget); dba.StringIncrement(key, flags: CommandFlags.FireAndForget); dbb.StringIncrement(key, flags: CommandFlags.FireAndForget); diff --git a/tests/StackExchange.Redis.Tests/DelegateTests.cs b/tests/StackExchange.Redis.Tests/DelegateTests.cs new file mode 100644 index 000000000..c36dcf79a --- /dev/null +++ b/tests/StackExchange.Redis.Tests/DelegateTests.cs @@ -0,0 +1,54 @@ +using System; +using System.Collections.Generic; +using Xunit; + +namespace StackExchange.Redis.Tests; + +public class DelegateTests +{ + [Theory] + [InlineData(0)] + [InlineData(1)] + [InlineData(2)] + [InlineData(25)] + public void Foo(int count) + { + Assert.True(Delegates.IsSupported); + Action? action = null; + MulticastDelegate? m = action; + List captured = []; + for (int i = 0; i < count; i++) + { + action += Add(captured, i); + static Action Add(List captured, int i) => () => captured.Add(i); + } + + switch (count) + { + case 0: + Assert.Null(action); + break; + case 1: + Assert.NotNull(action); + Assert.True(action.IsSingle()); + break; + default: + Assert.NotNull(action); + Assert.False(action.IsSingle()); + break; + } + + int foreachCount = 0; + foreach (var inner in action.AsEnumerable()) + { + inner.Invoke(); + foreachCount++; + } + Assert.Equal(count, foreachCount); + Assert.Equal(count, captured.Count); + for (int i = 0; i < captured.Count; i++) + { + Assert.Equal(i, captured[i]); + } + } +} diff --git a/tests/StackExchange.Redis.Tests/DigestUnitTests.cs b/tests/StackExchange.Redis.Tests/DigestUnitTests.cs index e1883c13b..414c8c56c 100644 --- a/tests/StackExchange.Redis.Tests/DigestUnitTests.cs +++ b/tests/StackExchange.Redis.Tests/DigestUnitTests.cs @@ -2,6 +2,7 @@ using System.Buffers; using System.Collections.Generic; using System.IO.Hashing; +using System.Runtime.InteropServices; using System.Text; using Xunit; @@ -70,7 +71,7 @@ private static string GetXxh3Hex(string source) int bytes; unsafe { - fixed (byte* bPtr = oversized) + fixed (byte* bPtr = &MemoryMarshal.GetReference(oversized)) { fixed (char* cPtr = source) { diff --git a/tests/StackExchange.Redis.Tests/ExceptionFactoryTests.cs b/tests/StackExchange.Redis.Tests/ExceptionFactoryTests.cs index 65d6946dc..6168f1eff 100644 --- a/tests/StackExchange.Redis.Tests/ExceptionFactoryTests.cs +++ b/tests/StackExchange.Redis.Tests/ExceptionFactoryTests.cs @@ -4,7 +4,7 @@ namespace StackExchange.Redis.Tests; -public class ExceptionFactoryTests(ITestOutputHelper output) : TestBase(output) +public class ExceptionFactoryTests(ITestOutputHelper output, InProcServerFixture fixture) : TestBase(output, fixture) { [Fact] public async Task NullLastException() @@ -21,23 +21,26 @@ public async Task NullLastException() public void CanGetVersion() { var libVer = Utils.GetLibVersion(); - Assert.Matches(@"2\.[0-9]+\.[0-9]+(\.[0-9]+)?", libVer); + Assert.Matches(@"[2-3]\.[0-9]+\.[0-9]+(\.[0-9]+)?", libVer); } #if DEBUG [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task MultipleEndpointsThrowConnectionException() { try { - await using var conn = Create(keepAlive: 1, connectTimeout: 10000, allowAdmin: true, shared: false); + await using var conn = Create(keepAlive: 1, connectTimeout: 10000, allowAdmin: true, allowSimulateConnectionFailure: true); conn.GetDatabase(); conn.AllowConnect = false; foreach (var endpoint in conn.GetEndPoints()) { - conn.GetServer(endpoint).SimulateConnectionFailure(SimulatedFailureType.All); + var server = conn.GetServer(endpoint); + Assert.SkipUnless(server.CanSimulateConnectionFailure(), "Skipping because server cannot simulate connection failure"); + server.SimulateConnectionFailure(SimulatedFailureType.All); } var ex = ExceptionFactory.NoConnectionAvailable(conn.UnderlyingMultiplexer, null, null); @@ -55,16 +58,19 @@ public async Task MultipleEndpointsThrowConnectionException() #endif [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task ServerTakesPrecendenceOverSnapshot() { try { - await using var conn = Create(keepAlive: 1, connectTimeout: 10000, allowAdmin: true, shared: false, backlogPolicy: BacklogPolicy.FailFast); + await using var conn = Create(keepAlive: 1, connectTimeout: 10000, allowAdmin: true, backlogPolicy: BacklogPolicy.FailFast, allowSimulateConnectionFailure: true); conn.GetDatabase(); conn.AllowConnect = false; - conn.GetServer(conn.GetEndPoints()[0]).SimulateConnectionFailure(SimulatedFailureType.All); + var server = conn.GetServer(conn.GetEndPoints()[0]); + Assert.SkipUnless(server.CanSimulateConnectionFailure(), "Skipping because server cannot simulate connection failure"); + server.SimulateConnectionFailure(SimulatedFailureType.All); var ex = ExceptionFactory.NoConnectionAvailable(conn.UnderlyingMultiplexer, null, conn.GetServerSnapshot()[0]); Assert.IsType(ex); @@ -122,7 +128,7 @@ public async Task TimeoutException() Assert.Contains("sync-ops: ", ex.Message); Assert.Contains("async-ops: ", ex.Message); Assert.Contains("conn-sec: n/a", ex.Message); - Assert.Contains("aoc: 1", ex.Message); + Assert.Contains("aoc: 0", ex.Message); #if NET // ...POOL: (Threads=33,QueuedItems=0,CompletedItems=5547,Timers=60)... Assert.Contains("POOL: ", ex.Message); diff --git a/tests/StackExchange.Redis.Tests/FSharpCompatTests.cs b/tests/StackExchange.Redis.Tests/FSharpCompatTests.cs index 192234f2d..bde8c0fcf 100644 --- a/tests/StackExchange.Redis.Tests/FSharpCompatTests.cs +++ b/tests/StackExchange.Redis.Tests/FSharpCompatTests.cs @@ -18,7 +18,7 @@ public void RedisValueConstructor() { Assert.Equal(default, new RedisValue()); Assert.Equal((RedisValue)"MyKey", new RedisValue("MyKey")); - Assert.Equal((RedisValue)"MyKey2", new RedisValue("MyKey2", 0)); + Assert.Equal((RedisValue)"MyKey2", new RedisValue("MyKey2")); } #pragma warning restore SA1129 // Do not use default value type constructor } diff --git a/tests/StackExchange.Redis.Tests/FailoverTests.cs b/tests/StackExchange.Redis.Tests/FailoverTests.cs index 9c330a3f3..e1222394c 100644 --- a/tests/StackExchange.Redis.Tests/FailoverTests.cs +++ b/tests/StackExchange.Redis.Tests/FailoverTests.cs @@ -16,7 +16,7 @@ public class FailoverTests(ITestOutputHelper output) : TestBase(output), IAsyncL public async ValueTask InitializeAsync() { - await using var conn = Create(); + await using var conn = Create(connectTimeout: 10000); var shouldBePrimary = conn.GetServer(TestConfig.Current.FailoverPrimaryServerAndPort); if (shouldBePrimary.IsReplica) @@ -196,9 +196,10 @@ public async Task DereplicateGoesToPrimary() #if DEBUG [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task SubscriptionsSurviveConnectionFailureAsync() { - await using var conn = Create(allowAdmin: true, shared: false, log: Writer, syncTimeout: 1000); + await using var conn = Create(allowAdmin: true, log: Writer, syncTimeout: 1000, allowSimulateConnectionFailure: true); var profiler = conn.AddProfiler(); RedisChannel channel = RedisChannel.Literal(Me()); @@ -222,6 +223,7 @@ public async Task SubscriptionsSurviveConnectionFailureAsync() Assert.Equal(1, counter1); var server = GetServer(conn); + Assert.SkipUnless(server.CanSimulateConnectionFailure(), "Skipping because server cannot simulate connection failure"); var socketCount = server.GetCounters().Subscription.SocketCount; Log($"Expecting 1 socket, got {socketCount}"); Assert.Equal(1, socketCount); diff --git a/tests/StackExchange.Redis.Tests/GarbageCollectionTests.cs b/tests/StackExchange.Redis.Tests/GarbageCollectionTests.cs index f01645cf3..a1042d0a6 100644 --- a/tests/StackExchange.Redis.Tests/GarbageCollectionTests.cs +++ b/tests/StackExchange.Redis.Tests/GarbageCollectionTests.cs @@ -57,6 +57,7 @@ public async Task MuxerIsCollected() } [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task UnrootedBackloggedAsyncTaskIsCompletedOnTimeout() { Skip.UnlessLongRunning(); @@ -75,6 +76,7 @@ public async Task UnrootedBackloggedAsyncTaskIsCompletedOnTimeout() ConnectTimeout = 50, SyncTimeout = 1000, AllowAdmin = true, + AllowSimulateConnectionFailure = true, EndPoints = { GetConfiguration() }, }, Writer); diff --git a/tests/StackExchange.Redis.Tests/GlobalUsings.cs b/tests/StackExchange.Redis.Tests/GlobalUsings.cs deleted file mode 100644 index ca9c34d74..000000000 --- a/tests/StackExchange.Redis.Tests/GlobalUsings.cs +++ /dev/null @@ -1,3 +0,0 @@ -extern alias respite; -global using AsciiHash = respite::RESPite.AsciiHash; -global using AsciiHashAttribute = respite::RESPite.AsciiHashAttribute; diff --git a/tests/StackExchange.Redis.Tests/Helpers/Attributes.cs b/tests/StackExchange.Redis.Tests/Helpers/Attributes.cs index a3386e80c..275101569 100644 --- a/tests/StackExchange.Redis.Tests/Helpers/Attributes.cs +++ b/tests/StackExchange.Redis.Tests/Helpers/Attributes.cs @@ -43,6 +43,12 @@ public class FactAttribute([CallerFilePath] string? sourceFilePath = null, [Call [XunitTestCaseDiscoverer(typeof(TheoryDiscoverer))] public class TheoryAttribute([CallerFilePath] string? sourceFilePath = null, [CallerLineNumber] int sourceLineNumber = -1) : Xunit.TheoryAttribute(sourceFilePath, sourceLineNumber) { } +internal static class TestCategories +{ + public const string Category = "Category"; + public const string SimulatedConnectionFailure = nameof(SimulatedConnectionFailure); +} + public class FactDiscoverer : Xunit.v3.FactDiscoverer { public override ValueTask> Discover(ITestFrameworkDiscoveryOptions discoveryOptions, IXunitTestMethod testMethod, IFactAttribute factAttribute) @@ -59,7 +65,7 @@ protected override ValueTask> CreateTestCase } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false)] -public class RunPerProtocol() : Attribute { } +public class RunPerProtocolAttribute() : Attribute { } public interface IProtocolTestCase { @@ -155,8 +161,8 @@ public static async ValueTask> ExpandAsync(t { var testMethod = testCase.TestMethod; - if ((testMethod.Method.GetCustomAttributes(typeof(RunPerProtocol)).FirstOrDefault() - ?? testMethod.TestClass.Class.GetCustomAttributes(typeof(RunPerProtocol)).FirstOrDefault()) is RunPerProtocol) + if ((testMethod.Method.GetCustomAttributes(typeof(RunPerProtocolAttribute)).FirstOrDefault() + ?? testMethod.TestClass.Class.GetCustomAttributes(typeof(RunPerProtocolAttribute)).FirstOrDefault()) is RunPerProtocolAttribute) { result.Add(CreateTestCase(testCase, RedisProtocol.Resp2)); result.Add(CreateTestCase(testCase, RedisProtocol.Resp3)); diff --git a/tests/StackExchange.Redis.Tests/Helpers/SharedConnectionFixture.cs b/tests/StackExchange.Redis.Tests/Helpers/SharedConnectionFixture.cs index 9656ee45b..8da84bce6 100644 --- a/tests/StackExchange.Redis.Tests/Helpers/SharedConnectionFixture.cs +++ b/tests/StackExchange.Redis.Tests/Helpers/SharedConnectionFixture.cs @@ -17,23 +17,8 @@ namespace StackExchange.Redis.Tests; public class SharedConnectionFixture : IDisposable { - public bool IsEnabled { get; } - - private readonly ConnectionMultiplexer _actualConnection; - public string Configuration { get; } - - public SharedConnectionFixture() - { - IsEnabled = TestConfig.Current.UseSharedConnection; - Configuration = TestBase.GetDefaultConfiguration(); - _actualConnection = TestBase.CreateDefault( - output: null, - clientName: nameof(SharedConnectionFixture), - configuration: Configuration, - allowAdmin: true); - _actualConnection.InternalError += OnInternalError; - _actualConnection.ConnectionFailed += OnConnectionFailed; - } + public bool IsEnabled { get; } = TestConfig.Current.UseSharedConnection; + public string Configuration { get; } = TestBase.GetDefaultConfiguration(); private NonDisposingConnection? resp2, resp3; internal IInternalConnectionMultiplexer GetConnection(TestBase obj, RedisProtocol protocol, [CallerMemberName] string caller = "") @@ -234,8 +219,8 @@ public void ExportConfiguration(Stream destination, ExportOptions options = Expo public void Dispose() { - resp2?.UnderlyingConnection?.Dispose(); - resp3?.UnderlyingConnection?.Dispose(); + try { resp2?.UnderlyingConnection?.Dispose(); } catch { } + try { resp3?.UnderlyingConnection?.Dispose(); } catch { } GC.SuppressFinalize(this); } @@ -273,11 +258,16 @@ public void Teardown(TextWriter output) } // Assert.True(false, $"There were {privateFailCount} private ambient exceptions."); } + TearDown(resp2, output); + TearDown(resp3, output); + } - if (_actualConnection != null) + private void TearDown(IInternalConnectionMultiplexer? connection, TextWriter output) + { + if (connection is { } conn) { - TestBase.Log(output, "Connection Counts: " + _actualConnection.GetCounters().ToString()); - foreach (var ep in _actualConnection.GetServerSnapshot()) + TestBase.Log(output, "Connection Counts: " + conn.GetCounters().ToString()); + foreach (var ep in conn.GetServerSnapshot()) { var interactive = ep.GetBridge(ConnectionType.Interactive); TestBase.Log(output, $" {Format.ToString(interactive)}: {interactive?.GetStatus()}"); diff --git a/tests/StackExchange.Redis.Tests/HighIntegrityMovedUnitTests.cs b/tests/StackExchange.Redis.Tests/HighIntegrityMovedUnitTests.cs index 9826c8f41..2c92d5ae6 100644 --- a/tests/StackExchange.Redis.Tests/HighIntegrityMovedUnitTests.cs +++ b/tests/StackExchange.Redis.Tests/HighIntegrityMovedUnitTests.cs @@ -18,7 +18,7 @@ public async Task HighIntegritySurvivesMovedResponse(bool highIntegrity) using var client = await ConnectionMultiplexer.ConnectAsync(config); RedisKey a = "a", b = "b"; // known to be in different slots - Assert.NotEqual(ServerSelectionStrategy.GetClusterSlot(a), ServerSelectionStrategy.GetClusterSlot(b)); + Assert.NotEqual(ServerSelectionStrategy.GetHashSlot(a), ServerSelectionStrategy.GetHashSlot(b)); var db = client.GetDatabase(); var x = db.StringIncrementAsync(a); diff --git a/tests/StackExchange.Redis.Tests/HttpTunnelConnectTests.cs b/tests/StackExchange.Redis.Tests/HttpTunnelConnectTests.cs index 4099c7b94..a9928501a 100644 --- a/tests/StackExchange.Redis.Tests/HttpTunnelConnectTests.cs +++ b/tests/StackExchange.Redis.Tests/HttpTunnelConnectTests.cs @@ -27,7 +27,7 @@ public async Task Connect(string suffix) await using var conn = await ConnectionMultiplexer.ConnectAsync(config); var db = conn.GetDatabase(); await db.PingAsync(); - RedisKey key = "HttpTunnel"; + RedisKey key = "HttpTunnel:" + Guid.NewGuid().ToString("N"); await db.KeyDeleteAsync(key); // latency test diff --git a/tests/StackExchange.Redis.Tests/HyperLogLogTests.cs b/tests/StackExchange.Redis.Tests/HyperLogLogTests.cs index f4c259854..ee7f690ee 100644 --- a/tests/StackExchange.Redis.Tests/HyperLogLogTests.cs +++ b/tests/StackExchange.Redis.Tests/HyperLogLogTests.cs @@ -12,7 +12,7 @@ public async Task SingleKeyLength() await using var conn = Create(); var db = conn.GetDatabase(); - RedisKey key = "hll1"; + RedisKey key = Me(); db.HyperLogLogAdd(key, "a"); db.HyperLogLogAdd(key, "b"); @@ -27,7 +27,8 @@ public async Task MultiKeyLength() await using var conn = Create(); var db = conn.GetDatabase(); - RedisKey[] keys = ["hll1", "hll2", "hll3"]; + var prefix = Me(); + RedisKey[] keys = [prefix + ":hll1", prefix + ":hll2", prefix + ":hll3"]; db.HyperLogLogAdd(keys[0], "a"); db.HyperLogLogAdd(keys[1], "b"); diff --git a/tests/StackExchange.Redis.Tests/InProcessTestServer.cs b/tests/StackExchange.Redis.Tests/InProcessTestServer.cs index e861bb6d3..7dcc5f7c9 100644 --- a/tests/StackExchange.Redis.Tests/InProcessTestServer.cs +++ b/tests/StackExchange.Redis.Tests/InProcessTestServer.cs @@ -1,5 +1,4 @@ -extern alias respite; -using System; +using System; using System.IO; using System.IO.Pipelines; using System.Net; @@ -13,7 +12,6 @@ using System.Text; using System.Threading; using System.Threading.Tasks; -using respite::RESPite.Messages; using StackExchange.Redis.Configuration; using StackExchange.Redis.Server; using Xunit; @@ -50,8 +48,8 @@ public InProcessTestServer(ITestOutputHelper? log = null, EndPoint? endpoint = n Tunnel = new InProcTunnel(this); } - public Task ConnectAsync(bool withPubSub = true, bool defaultOnly = false /*, WriteMode writeMode = WriteMode.Default */, TextWriter? log = null) - => ConnectionMultiplexer.ConnectAsync(GetClientConfig(withPubSub, defaultOnly /*, writeMode */), log); + public Task ConnectAsync(bool withPubSub = true, bool defaultOnly = false, WriteMode writeMode = WriteMode.Default, TextWriter? log = null) + => ConnectionMultiplexer.ConnectAsync(GetClientConfig(withPubSub, defaultOnly, writeMode), log); // view request/response highlights in the log public override TypedRedisValue Execute(RedisClient client, in RedisRequest request) @@ -83,7 +81,7 @@ public override TypedRedisValue Execute(RedisClient client, in RedisRequest requ return result; } - public ConfigurationOptions GetClientConfig(bool withPubSub = true, bool defaultOnly = false /*, WriteMode writeMode = WriteMode.Default */) + public ConfigurationOptions GetClientConfig(bool withPubSub = true, bool defaultOnly = false, WriteMode writeMode = WriteMode.Default) { var commands = GetCommands(); if (!withPubSub) @@ -109,6 +107,7 @@ public ConfigurationOptions GetClientConfig(bool withPubSub = true, bool default AsyncTimeout = 5000, AllowAdmin = true, Tunnel = Tunnel, + WriteMode = (BufferedStreamWriter.WriteMode)writeMode, Protocol = TestContext.Current.GetProtocol(), // WriteMode = (BufferedStreamWriter.WriteMode)writeMode, }; diff --git a/tests/StackExchange.Redis.Tests/IncrexTestServer.cs b/tests/StackExchange.Redis.Tests/IncrexTestServer.cs index 4a32e350c..79f049eea 100644 --- a/tests/StackExchange.Redis.Tests/IncrexTestServer.cs +++ b/tests/StackExchange.Redis.Tests/IncrexTestServer.cs @@ -1,7 +1,6 @@ -extern alias respite; using System; using System.Globalization; -using respite::RESPite.Messages; +using RESPite.Messages; using StackExchange.Redis.Server; using Xunit; diff --git a/tests/StackExchange.Redis.Tests/Issues/Issue1103Tests.cs b/tests/StackExchange.Redis.Tests/Issues/Issue1103Tests.cs index ab4042042..fb7fbfb5e 100644 --- a/tests/StackExchange.Redis.Tests/Issues/Issue1103Tests.cs +++ b/tests/StackExchange.Redis.Tests/Issues/Issue1103Tests.cs @@ -21,6 +21,7 @@ public async Task LargeUInt64StoredCorrectly(ulong value, int storageType) RedisKey key = Me(); var db = conn.GetDatabase(); RedisValue typed = value; + Assert.Equal(value.ToString(), typed.ToString()); // only need UInt64 for 64-bits Assert.Equal((StorageType)storageType, typed.Type); @@ -28,7 +29,7 @@ public async Task LargeUInt64StoredCorrectly(ulong value, int storageType) var fromRedis = db.StringGet(key); Log($"{fromRedis.Type}: {fromRedis}"); - Assert.Equal(StorageType.Raw, fromRedis.Type); + Assert.Equal(StorageType.ByteArray, fromRedis.Type); Assert.Equal(value, (ulong)fromRedis); Assert.Equal(value.ToString(CultureInfo.InvariantCulture), fromRedis.ToString()); diff --git a/tests/StackExchange.Redis.Tests/Issues/Issue2392Tests.cs b/tests/StackExchange.Redis.Tests/Issues/Issue2392Tests.cs index 39df94021..00cd515f1 100644 --- a/tests/StackExchange.Redis.Tests/Issues/Issue2392Tests.cs +++ b/tests/StackExchange.Redis.Tests/Issues/Issue2392Tests.cs @@ -7,28 +7,28 @@ namespace StackExchange.Redis.Tests.Issues public class Issue2392Tests(ITestOutputHelper output) : TestBase(output) { [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task Execute() { - var options = new ConfigurationOptions() + var options = ConfigurationOptions.Parse(GetConfiguration()); + options.Protocol = TestContext.Current.GetProtocol(); + options.BacklogPolicy = new() { - BacklogPolicy = new() - { - QueueWhileDisconnected = true, - AbortPendingOnConnectionFailure = false, - }, - AbortOnConnectFail = false, - ConnectTimeout = 1, - ConnectRetry = 0, - AsyncTimeout = 1, - SyncTimeout = 1, - AllowAdmin = true, + QueueWhileDisconnected = true, + AbortPendingOnConnectionFailure = false, }; - options.EndPoints.Add("127.0.0.1:1234"); + options.AbortOnConnectFail = false; + options.ConnectRetry = 0; + options.AsyncTimeout = 1; + options.SyncTimeout = 1; + options.AllowAdmin = true; + options.AllowSimulateConnectionFailure = true; await using var conn = await ConnectionMultiplexer.ConnectAsync(options, Writer); var key = Me(); var db = conn.GetDatabase(); var server = conn.GetServerSnapshot()[0]; + Assert.SkipUnless(server.CanSimulateConnectionFailure, "Skipping because server cannot simulate connection failure"); // Fail the connection conn.AllowConnect = false; diff --git a/tests/StackExchange.Redis.Tests/KeyNotificationUnitTests.cs b/tests/StackExchange.Redis.Tests/KeyNotificationUnitTests.cs index eba9d9e4b..3109428eb 100644 --- a/tests/StackExchange.Redis.Tests/KeyNotificationUnitTests.cs +++ b/tests/StackExchange.Redis.Tests/KeyNotificationUnitTests.cs @@ -476,7 +476,7 @@ public void DefaultKeyNotification_HasExpectedProperties() [InlineData("new", KeyNotificationType.New)] [InlineData("overwritten", KeyNotificationType.Overwritten)] [InlineData("type_changed", KeyNotificationType.TypeChanged)] - public unsafe void FastHashParse_AllKnownValues_ParseCorrectly(string raw, KeyNotificationType parsed) + public unsafe void AsciiHashParse_AllKnownValues_ParseCorrectly(string raw, KeyNotificationType parsed) { var arr = ArrayPool.Shared.Rent(Encoding.UTF8.GetMaxByteCount(raw.Length)); int bytes; diff --git a/tests/StackExchange.Redis.Tests/LoggerTests.cs b/tests/StackExchange.Redis.Tests/LoggerTests.cs index 60bc48576..31ed3fae0 100644 --- a/tests/StackExchange.Redis.Tests/LoggerTests.cs +++ b/tests/StackExchange.Redis.Tests/LoggerTests.cs @@ -15,19 +15,20 @@ public class LoggerTests(ITestOutputHelper output) : TestBase(output) [Fact] public async Task BasicLoggerConfig() { - var traceLogger = new TestLogger(LogLevel.Trace, Writer); - var debugLogger = new TestLogger(LogLevel.Debug, Writer); - var infoLogger = new TestLogger(LogLevel.Information, Writer); - var warningLogger = new TestLogger(LogLevel.Warning, Writer); - var errorLogger = new TestLogger(LogLevel.Error, Writer); - var criticalLogger = new TestLogger(LogLevel.Critical, Writer); + var traceLogger = new TestLogger(LogLevel.Trace, TextWriter.Null); + var debugLogger = new TestLogger(LogLevel.Debug, TextWriter.Null); + var infoLogger = new TestLogger(LogLevel.Information, TextWriter.Null); + var warningLogger = new TestLogger(LogLevel.Warning, TextWriter.Null); + var errorLogger = new TestLogger(LogLevel.Error, TextWriter.Null); + var criticalLogger = new TestLogger(LogLevel.Critical, TextWriter.Null); var options = ConfigurationOptions.Parse(GetConfiguration()); options.LoggerFactory = new TestWrapperLoggerFactory(new TestMultiLogger(traceLogger, debugLogger, infoLogger, warningLogger, errorLogger, criticalLogger)); await using var conn = await ConnectionMultiplexer.ConnectAsync(options); - // We expect more at the trace level: GET, ECHO, PING on commands - Assert.True(traceLogger.CallCount > debugLogger.CallCount); + Log($"Trace: {traceLogger.CallCount}, Debug: {debugLogger.CallCount}, Info: {infoLogger.CallCount}, Warning: {warningLogger.CallCount}, Error: {errorLogger.CallCount}"); + // We expect more (or at least: no less) at the trace level: GET, ECHO, PING on commands + Assert.True(traceLogger.CallCount >= debugLogger.CallCount); // Many calls for all log lines - don't set exact here since every addition would break the test Assert.True(debugLogger.CallCount > 30); Assert.True(infoLogger.CallCount > 30); @@ -37,11 +38,32 @@ public async Task BasicLoggerConfig() Assert.Equal(0, criticalLogger.CallCount); } + private sealed class EnabledNullLogger : ILogger, IDisposable + { + private EnabledNullLogger() { } + public static readonly ILogger Instance = new EnabledNullLogger(); + + public bool IsEnabled(LogLevel level) => true; // NullLogger now says "no", which breaks our counting + + public IDisposable? BeginScope(TState state) where TState : notnull => this; + + public void Log( + LogLevel logLevel, + EventId eventId, + TState state, + Exception? exception, + Func formatter) + { + // but do nothing with it + } + void IDisposable.Dispose() { } + } + [Fact] public async Task WrappedLogger() { var options = ConfigurationOptions.Parse(GetConfiguration()); - var wrapped = new TestWrapperLoggerFactory(NullLogger.Instance); + var wrapped = new TestWrapperLoggerFactory(EnabledNullLogger.Instance); options.LoggerFactory = wrapped; await using var conn = await ConnectionMultiplexer.ConnectAsync(options); diff --git a/tests/StackExchange.Redis.Tests/MovedUnitTests.cs b/tests/StackExchange.Redis.Tests/MovedUnitTests.cs index 5618adf27..a3109986b 100644 --- a/tests/StackExchange.Redis.Tests/MovedUnitTests.cs +++ b/tests/StackExchange.Redis.Tests/MovedUnitTests.cs @@ -1,7 +1,5 @@ -using System.Collections.Generic; using System.Runtime.CompilerServices; using System.Threading.Tasks; -using StackExchange.Redis.Configuration; using Xunit; namespace StackExchange.Redis.Tests; @@ -17,16 +15,22 @@ public class MovedUnitTests(ITestOutputHelper log) private RedisKey Me([CallerMemberName] string callerName = "") => callerName; [Theory] - [InlineData(ServerType.Cluster)] - [InlineData(ServerType.Standalone)] - public async Task CrossSlotDisallowed(ServerType serverType) + /* + [InlineData(ServerType.Cluster, WriteMode.Sync)] + [InlineData(ServerType.Standalone, WriteMode.Sync)] + [InlineData(ServerType.Cluster, WriteMode.Async)] + [InlineData(ServerType.Standalone, WriteMode.Async)] + */ + [InlineData(ServerType.Cluster, WriteMode.Pipe)] + [InlineData(ServerType.Standalone, WriteMode.Pipe)] + public async Task CrossSlotDisallowed(ServerType serverType, WriteMode writeMode) { // intentionally sending as strings (not keys) via execute to prevent the // client library from getting in our way string keyA = "abc", keyB = "def"; // known to be on different slots using var server = new InProcessTestServer(log) { ServerType = serverType }; - await using var muxer = await server.ConnectAsync(); + await using var muxer = await server.ConnectAsync(writeMode: writeMode, withPubSub: false); var db = muxer.GetDatabase(); await db.StringSetAsync(keyA, "value", flags: CommandFlags.FireAndForget); @@ -116,7 +120,7 @@ public async Task MovedToSameEndpoint_TriggersReconnectAndRetry_CommandSucceeds( log: log) { ServerType = serverType, }; // Act: Connect to the test server - await using var conn = await testServer.ConnectAsync(); + await using var conn = await testServer.ConnectAsync(withPubSub: false); // Ping the server to ensure it's responsive var server = conn.GetServer(testServer.DefaultEndPoint); diff --git a/tests/StackExchange.Redis.Tests/ParseTests.cs b/tests/StackExchange.Redis.Tests/ParseTests.cs index 2621ddab9..90a8ed6a2 100644 --- a/tests/StackExchange.Redis.Tests/ParseTests.cs +++ b/tests/StackExchange.Redis.Tests/ParseTests.cs @@ -1,8 +1,11 @@ using System; using System.Buffers; using System.Collections.Generic; +using System.IO; +using System.Runtime.InteropServices; using System.Text; -using Pipelines.Sockets.Unofficial.Arenas; +using System.Threading.Tasks; +using StackExchange.Redis.Configuration; using Xunit; namespace StackExchange.Redis.Tests; @@ -27,20 +30,17 @@ public static IEnumerable GetTestData() yield return new object[] { "$4\r\nPING\r\n$4\r\nPONG\r\n$4\r\nPONG\r\n$", 3 }; } - [Theory] + [Theory(Timeout = 1000)] [MemberData(nameof(GetTestData))] - public void ParseAsSingleChunk(string ascii, int expected) + public Task ParseAsSingleChunk(string ascii, int expected) { var buffer = new ReadOnlySequence(Encoding.ASCII.GetBytes(ascii)); - using (var arena = new Arena()) - { - ProcessMessages(arena, buffer, expected); - } + return ProcessMessagesAsync(buffer, expected); } - [Theory] + [Theory(Timeout = 1000)] [MemberData(nameof(GetTestData))] - public void ParseAsLotsOfChunks(string ascii, int expected) + public Task ParseAsLotsOfChunks(string ascii, int expected) { var bytes = Encoding.ASCII.GetBytes(ascii); FragmentedSegment? chain = null, tail = null; @@ -59,23 +59,47 @@ public void ParseAsLotsOfChunks(string ascii, int expected) } var buffer = new ReadOnlySequence(chain!, 0, tail!, 1); Assert.Equal(bytes.Length, buffer.Length); - using (var arena = new Arena()) - { - ProcessMessages(arena, buffer, expected); - } + return ProcessMessagesAsync(buffer, expected); } - private void ProcessMessages(Arena arena, ReadOnlySequence buffer, int expected) + private async Task ProcessMessagesAsync(ReadOnlySequence buffer, int expected, bool isInbound = false) { + var cancel = TestContext.Current.CancellationToken; Log($"chain: {buffer.Length}"); - var reader = new BufferReader(buffer); - RawResult result; + MemoryStream ms; + if (buffer.IsSingleSegment && MemoryMarshal.TryGetArray(buffer.First, out var segment)) + { + // use existing buffer + ms = new MemoryStream(segment.Array!, segment.Offset, (int)buffer.Length, false, true); + } + else + { + ms = new MemoryStream(checked((int)buffer.Length)); + foreach (var chunk in buffer) + { +#if NET + ms.Write(chunk.Span); +#else + ms.Write(chunk); +#endif + } + + ms.Position = 0; + } + +#pragma warning disable CS0618 // Type or member is obsolete + var reader = new LoggingTunnel.StreamRespReader(ms, isInbound: isInbound); +#pragma warning restore CS0618 // Type or member is obsolete int found = 0; - while (!(result = PhysicalConnection.TryParseResult(false, arena, buffer, ref reader, false, null, false)).IsNull) + while (!cancel.IsCancellationRequested) { - Log($"{result} - {result.GetString()}"); + var oldPos = reader.Position; + var result = await reader.ReadOneAsync(cancel).ForAwait(); + if (result.Result is null) break; + Log($"[{oldPos},{reader.Position}): {result} - {result.Result}"); found++; } + cancel.ThrowIfCancellationRequested(); Assert.Equal(expected, found); } diff --git a/tests/StackExchange.Redis.Tests/ProfilingTests.cs b/tests/StackExchange.Redis.Tests/ProfilingTests.cs index 366abd395..2ce18684d 100644 --- a/tests/StackExchange.Redis.Tests/ProfilingTests.cs +++ b/tests/StackExchange.Redis.Tests/ProfilingTests.cs @@ -78,7 +78,7 @@ public async Task Simple() AssertProfiledCommandValues(eval2, conn, dbId); - AssertProfiledCommandValues(echo, conn, dbId); + AssertProfiledCommandValues(echo, conn, -1); // we recognize ECHO as db-free } private static void AssertProfiledCommandValues(IProfiledCommand command, IConnectionMultiplexer conn, int dbId) diff --git a/tests/StackExchange.Redis.Tests/PubSubMultiserverTests.cs b/tests/StackExchange.Redis.Tests/PubSubMultiserverTests.cs index 691232218..f33e125ae 100644 --- a/tests/StackExchange.Redis.Tests/PubSubMultiserverTests.cs +++ b/tests/StackExchange.Redis.Tests/PubSubMultiserverTests.cs @@ -25,12 +25,13 @@ public async Task ChannelSharding() } [Fact] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] public async Task ClusterNodeSubscriptionFailover() { Skip.UnlessLongRunning(); Log("Connecting..."); - await using var conn = Create(allowAdmin: true, shared: false); + await using var conn = Create(allowAdmin: true, allowSimulateConnectionFailure: true); var sub = conn.GetSubscriber(); var channel = RedisChannel.Literal(Me()); @@ -104,6 +105,7 @@ await sub.SubscribeAsync(channel, (_, val) => } [Theory(Skip="TODO: Hostile")] + [Trait(TestCategories.Category, TestCategories.SimulatedConnectionFailure)] [InlineData(CommandFlags.PreferMaster, true)] [InlineData(CommandFlags.PreferReplica, true)] [InlineData(CommandFlags.DemandMaster, false)] @@ -113,7 +115,7 @@ public async Task PrimaryReplicaSubscriptionFailover(CommandFlags flags, bool ex var config = TestConfig.Current.PrimaryServerAndPort + "," + TestConfig.Current.ReplicaServerAndPort; Log("Connecting..."); - await using var conn = Create(configuration: config, shared: false, allowAdmin: true); + await using var conn = Create(configuration: config, allowAdmin: true, allowSimulateConnectionFailure: true); var sub = conn.GetSubscriber(); var channel = RedisChannel.Literal(Me() + flags.ToString()); // Individual channel per case to not overlap publishers diff --git a/tests/StackExchange.Redis.Tests/RawResultTests.cs b/tests/StackExchange.Redis.Tests/RawResultTests.cs deleted file mode 100644 index 9cf578ee1..000000000 --- a/tests/StackExchange.Redis.Tests/RawResultTests.cs +++ /dev/null @@ -1,69 +0,0 @@ -using System.Buffers; -using Xunit; - -namespace StackExchange.Redis.Tests; - -public class RawResultTests -{ - [Fact] - public void TypeLoads() - { - var type = typeof(RawResult); - Assert.Equal(nameof(RawResult), type.Name); - } - - [Theory] - [InlineData(ResultType.BulkString)] - [InlineData(ResultType.Null)] - public void NullWorks(ResultType type) - { - var result = new RawResult(type, ReadOnlySequence.Empty, RawResult.ResultFlags.None); - Assert.Equal(type, result.Resp3Type); - Assert.True(result.HasValue); - Assert.True(result.IsNull); - - var value = result.AsRedisValue(); - - Assert.True(value.IsNull); - string? s = value; - Assert.Null(s); - - byte[]? arr = (byte[]?)value; - Assert.Null(arr); - } - - [Fact] - public void DefaultWorks() - { - var result = RawResult.Nil; - Assert.Equal(ResultType.None, result.Resp3Type); - Assert.False(result.HasValue); - Assert.True(result.IsNull); - - var value = result.AsRedisValue(); - - Assert.True(value.IsNull); - var s = (string?)value; - Assert.Null(s); - - var arr = (byte[]?)value; - Assert.Null(arr); - } - - [Fact] - public void NilWorks() - { - var result = RawResult.Nil; - Assert.Equal(ResultType.None, result.Resp3Type); - Assert.True(result.IsNull); - - var value = result.AsRedisValue(); - - Assert.True(value.IsNull); - var s = (string?)value; - Assert.Null(s); - - var arr = (byte[]?)value; - Assert.Null(arr); - } -} diff --git a/tests/StackExchange.Redis.Tests/RedisValueEquivalencyTests.cs b/tests/StackExchange.Redis.Tests/RedisValueEquivalencyTests.cs index 391a0237a..e68448b54 100644 --- a/tests/StackExchange.Redis.Tests/RedisValueEquivalencyTests.cs +++ b/tests/StackExchange.Redis.Tests/RedisValueEquivalencyTests.cs @@ -5,7 +5,7 @@ namespace StackExchange.Redis.Tests; -public class RedisValueEquivalency +public class RedisValueEquivalencyUnitTests { // internal storage types: null, integer, double, string, raw // public perceived types: int, long, double, bool, memory / byte[] @@ -441,7 +441,7 @@ public void RedisValueLengthUInt64() public void RedisValueLengthRaw() { RedisValue value = new byte[] { 0, 1, 2 }; - Assert.Equal(RedisValue.StorageType.Raw, value.Type); + Assert.Equal(RedisValue.StorageType.ByteArray, value.Type); Assert.Equal(3, value.Length()); } diff --git a/tests/StackExchange.Redis.Tests/Resp3HandshakeTests.cs b/tests/StackExchange.Redis.Tests/Resp3HandshakeTests.cs index 9ae7d556d..167f8996d 100644 --- a/tests/StackExchange.Redis.Tests/Resp3HandshakeTests.cs +++ b/tests/StackExchange.Redis.Tests/Resp3HandshakeTests.cs @@ -65,7 +65,7 @@ public async Task Handshake(RedisProtocol client, ServerResponse server, Handsha config.TieBreaker = (flags & HandshakeFlags.TieBreaker) == 0 ? "" : "tiebreaker_key"; config.ConfigurationChannel = (flags & HandshakeFlags.ConfigChannel) == 0 ? "" : "broadcast_channel"; - using var clientObj = await ConnectionMultiplexer.ConnectAsync(config); + await using var clientObj = await ConnectionMultiplexer.ConnectAsync(config); var sub = clientObj.GetSubscriber(); var db = clientObj.GetDatabase(); @@ -85,7 +85,8 @@ public async Task Handshake(RedisProtocol client, ServerResponse server, Handsha } if (usePubSub) { - await sub.PublishAsync(channel, "msg payload"); + var count = await sub.PublishAsync(channel, "msg payload"); + Assert.Equal(1, count); for (int i = 0; i < 5 && received.IsEmpty; i++) { await Task.Delay(10, TestContext.Current.CancellationToken); diff --git a/tests/StackExchange.Redis.Tests/RespProtocolTests.cs b/tests/StackExchange.Redis.Tests/RespProtocolTests.cs index 855ec96d1..69bd26dbd 100644 --- a/tests/StackExchange.Redis.Tests/RespProtocolTests.cs +++ b/tests/StackExchange.Redis.Tests/RespProtocolTests.cs @@ -18,7 +18,7 @@ public async Task ConnectWithTiming() [Theory] // specify nothing - [InlineData("someserver", false)] + [InlineData("someserver", true)] // specify *just* the protocol; sure, we'll believe you [InlineData("someserver,protocol=resp3", true)] [InlineData("someserver,protocol=resp3,$HELLO=", false)] @@ -43,9 +43,9 @@ public async Task ConnectWithTiming() [InlineData("someserver,version=5.9,protocol=2,$HELLO=", false, "resp2")] [InlineData("someserver,version=5.9,protocol=2,$HELLO=BONJOUR", false, "resp2")] // specify a post-6 version; attempt by default - [InlineData("someserver,version=6.0", false)] + [InlineData("someserver,version=6.0", true)] [InlineData("someserver,version=6.0,$HELLO=", false)] - [InlineData("someserver,version=6.0,$HELLO=BONJOUR", false)] + [InlineData("someserver,version=6.0,$HELLO=BONJOUR", true)] [InlineData("someserver,version=6.0,protocol=resp3", true)] [InlineData("someserver,version=6.0,protocol=resp3,$HELLO=", false)] [InlineData("someserver,version=6.0,protocol=resp3,$HELLO=BONJOUR", true)] @@ -55,9 +55,9 @@ public async Task ConnectWithTiming() [InlineData("someserver,version=6.0,protocol=2", false, "resp2")] [InlineData("someserver,version=6.0,protocol=2,$HELLO=", false, "resp2")] [InlineData("someserver,version=6.0,protocol=2,$HELLO=BONJOUR", false, "resp2")] - [InlineData("someserver,version=7.2", false)] + [InlineData("someserver,version=7.2", true)] [InlineData("someserver,version=7.2,$HELLO=", false)] - [InlineData("someserver,version=7.2,$HELLO=BONJOUR", false)] + [InlineData("someserver,version=7.2,$HELLO=BONJOUR", true)] public void ParseFormatConfigOptions(string configurationString, bool tryResp3, string? formatProtocol = null) { var config = ConfigurationOptions.Parse(configurationString); @@ -315,7 +315,13 @@ public async Task CheckCommandResult(string command, RedisProtocol protocol, Res { var muxer = Create(protocol: protocol); var ep = muxer.GetServerEndPoint(muxer.GetEndPoints().Single()); - if (command == "debug" && args.Length > 0 && args[0] is "protocol" && !ep.GetFeatures().Resp3 /* v6 check */) + var usesDebugCommand = RedisCommandMetadata.TryParseCI(command, out var parsedCommand) + && parsedCommand == RedisCommand.DEBUG; + if (usesDebugCommand) + { + await AssertDebugCommandEnabledAsync(muxer); + } + if (usesDebugCommand && args.Length > 0 && args[0] is "protocol" && !ep.GetFeatures().Resp3 /* v6 check */) { Assert.Skip("debug protocol not available"); } diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/AutoConfigure.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/AutoConfigure.cs new file mode 100644 index 000000000..f8b0daa0d --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/AutoConfigure.cs @@ -0,0 +1,130 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class AutoConfigure(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void ClientId_Integer_Success() + { + // CLIENT ID response + var resp = ":11\r\n"; + var message = Message.Create(-1, default, RedisCommand.CLIENT); + + // Note: This will return false because we don't have a real connection with a server endpoint + // The processor will throw because it can't set the connection ID without a real connection + var success = TryExecute(resp, ResultProcessor.AutoConfigure, out bool result, out var exception, message); + + Assert.False(success); + Assert.NotNull(exception); + Assert.IsType(exception); + } + + [Fact] + public void Info_BulkString_Success() + { + // INFO response with replication info + var info = "# Replication\r\n" + + "role:master\r\n" + + "connected_slaves:0\r\n" + + "master_failover_state:no-failover\r\n" + + "master_replid:8c3e3c3e3c3e3c3e3c3e3c3e3c3e3c3e3c3e3c3e\r\n" + + "master_replid2:0000000000000000000000000000000000000000\r\n" + + "master_repl_offset:0\r\n" + + "second_repl_offset:-1\r\n" + + "repl_backlog_active:0\r\n" + + "repl_backlog_size:1048576\r\n" + + "repl_backlog_first_byte_offset:0\r\n" + + "repl_backlog_histlen:0\r\n"; + + var resp = $"${info.Length}\r\n{info}\r\n"; + var message = Message.Create(-1, default, RedisCommand.INFO); + + // Note: This will return false because we don't have a real connection with a server endpoint + var success = TryExecute(resp, ResultProcessor.AutoConfigure, out bool result, out var exception, message); + + Assert.False(success); + Assert.NotNull(exception); + Assert.IsType(exception); + } + + [Fact] + public void Info_WithVersion_Success() + { + // INFO response with version info + var info = "# Server\r\n" + + "redis_version:7.2.4\r\n" + + "redis_git_sha1:00000000\r\n" + + "redis_mode:standalone\r\n" + + "os:Linux 5.15.0-1-amd64 x86_64\r\n" + + "arch_bits:64\r\n"; + + var resp = $"${info.Length}\r\n{info}\r\n"; + var message = Message.Create(-1, default, RedisCommand.INFO); + + var success = TryExecute(resp, ResultProcessor.AutoConfigure, out bool result, out var exception, message); + + Assert.False(success); + Assert.NotNull(exception); + Assert.IsType(exception); + } + + [Fact] + public void Info_EmptyString_Success() + { + // Empty INFO response + var resp = "$0\r\n\r\n"; + var message = Message.Create(-1, default, RedisCommand.INFO); + + var success = TryExecute(resp, ResultProcessor.AutoConfigure, out bool result, out var exception, message); + + Assert.False(success); + Assert.NotNull(exception); + Assert.IsType(exception); + } + + [Fact] + public void Info_Null_Success() + { + // Null INFO response + var resp = "$-1\r\n"; + var message = Message.Create(-1, default, RedisCommand.INFO); + + var success = TryExecute(resp, ResultProcessor.AutoConfigure, out bool result, out var exception, message); + + Assert.False(success); + Assert.NotNull(exception); + Assert.IsType(exception); + } + + [Fact] + public void Config_Array_Success() + { + // CONFIG GET timeout response + var resp = "*2\r\n" + + "$7\r\ntimeout\r\n" + + "$3\r\n300\r\n"; + var message = Message.Create(-1, default, RedisCommand.CONFIG); + + var success = TryExecute(resp, ResultProcessor.AutoConfigure, out bool result, out var exception, message); + + Assert.False(success); + Assert.NotNull(exception); + Assert.IsType(exception); + } + + [Fact] + public void ReadonlyError_Success() + { + // READONLY error response + var resp = "-READONLY You can't write against a read only replica.\r\n"; + var message = DummyMessage(); + + var success = TryExecute(resp, ResultProcessor.AutoConfigure, out bool result, out var exception, message); + + // Should handle the error - returns RedisServerException for error responses + Assert.False(success); + Assert.NotNull(exception); + Assert.IsType(exception); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/BasicAggregates.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/BasicAggregates.cs new file mode 100644 index 000000000..1ad1886f2 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/BasicAggregates.cs @@ -0,0 +1,229 @@ +using System.Linq; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Tests for basic aggregate result processors (arrays) +/// +public class BasicAggregates(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData("*3\r\n:1\r\n:2\r\n:3\r\n", "1,2,3")] + [InlineData("*?\r\n:1\r\n:2\r\n:3\r\n.\r\n", "1,2,3")] // streaming aggregate + [InlineData("*2\r\n,42\r\n,-99\r\n", "42,-99")] + [InlineData("*0\r\n", "")] + [InlineData("*?\r\n.\r\n", "")] // streaming empty aggregate + [InlineData("*-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n:10\r\n:20\r\n", "10,20")] + public void Int64Array(string resp, string? expected) => Assert.Equal(expected, Join(Execute(resp, ResultProcessor.Int64Array))); + + [Theory] + [InlineData("*3\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$3\r\nbaz\r\n", "foo,bar,baz")] + [InlineData("*?\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$3\r\nbaz\r\n.\r\n", "foo,bar,baz")] // streaming aggregate + [InlineData("*2\r\n+hello\r\n+world\r\n", "hello,world")] + [InlineData("*0\r\n", "")] + [InlineData("*?\r\n.\r\n", "")] // streaming empty aggregate + [InlineData("*-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n$1\r\na\r\n$1\r\nb\r\n", "a,b")] + public void StringArray(string resp, string? expected) => Assert.Equal(expected, Join(Execute(resp, ResultProcessor.StringArray))); + + [Theory] + [InlineData("*3\r\n:1\r\n:0\r\n:1\r\n", "True,False,True")] + [InlineData("*?\r\n:1\r\n:0\r\n:1\r\n.\r\n", "True,False,True")] // streaming aggregate + [InlineData("*2\r\n#t\r\n#f\r\n", "True,False")] + [InlineData("*0\r\n", "")] + [InlineData("*?\r\n.\r\n", "")] // streaming empty aggregate + [InlineData("*-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n:1\r\n:0\r\n", "True,False")] + public void BooleanArray(string resp, string? expected) => Assert.Equal(expected, Join(Execute(resp, ResultProcessor.BooleanArray))); + + [Theory] + [InlineData("*3\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$3\r\nbaz\r\n", "foo,bar,baz")] + [InlineData("*?\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$3\r\nbaz\r\n.\r\n", "foo,bar,baz")] // streaming aggregate + [InlineData("*3\r\n$3\r\nfoo\r\n$-1\r\n$3\r\nbaz\r\n", "foo,,baz")] // null element in middle (RESP2) + [InlineData("*3\r\n$3\r\nfoo\r\n_\r\n$3\r\nbaz\r\n", "foo,,baz")] // null element in middle (RESP3) + [InlineData("*0\r\n", "")] + [InlineData("*?\r\n.\r\n", "")] // streaming empty aggregate + [InlineData("$3\r\nfoo\r\n", "foo")] // single bulk string treated as array + [InlineData("$-1\r\n", "")] // null bulk string treated as empty array + [InlineData(ATTRIB_FOO_BAR + "*2\r\n$1\r\na\r\n:1\r\n", "a,1")] + public void RedisValueArray(string resp, string expected) => Assert.Equal(expected, Join(Execute(resp, ResultProcessor.RedisValueArray))); + + [Theory] + [InlineData("*3\r\n$3\r\nfoo\r\n$-1\r\n$3\r\nbaz\r\n", "foo,,baz")] // null element in middle (RESP2) + [InlineData("*3\r\n$3\r\nfoo\r\n_\r\n$3\r\nbaz\r\n", "foo,,baz")] // null element in middle (RESP3) + [InlineData("*2\r\n$5\r\nhello\r\n$5\r\nworld\r\n", "hello,world")] + [InlineData("*?\r\n$5\r\nhello\r\n$5\r\nworld\r\n.\r\n", "hello,world")] // streaming aggregate + [InlineData("*0\r\n", "")] + [InlineData("*?\r\n.\r\n", "")] // streaming empty aggregate + [InlineData("*-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n$1\r\na\r\n$1\r\nb\r\n", "a,b")] + public void NullableStringArray(string resp, string? expected) => Assert.Equal(expected, Join(Execute(resp, ResultProcessor.NullableStringArray))); + + [Theory] + [InlineData("*3\r\n$3\r\nkey\r\n$4\r\nkey2\r\n$4\r\nkey3\r\n", "key,key2,key3")] + [InlineData("*?\r\n$3\r\nkey\r\n$4\r\nkey2\r\n$4\r\nkey3\r\n.\r\n", "key,key2,key3")] // streaming aggregate + [InlineData("*3\r\n$3\r\nkey\r\n$-1\r\n$4\r\nkey3\r\n", "key,(null),key3")] // null element in middle (RESP2) + [InlineData("*3\r\n$3\r\nkey\r\n_\r\n$4\r\nkey3\r\n", "key,(null),key3")] // null element in middle (RESP3) + [InlineData("*0\r\n", "")] + [InlineData("*?\r\n.\r\n", "")] // streaming empty aggregate + [InlineData("*-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n", "foo,bar")] + public void RedisKeyArray(string resp, string? expected) => Assert.Equal(expected, Join(Execute(resp, ResultProcessor.RedisKeyArray))); + + [Theory] + [InlineData("*2\r\n+foo\r\n:42\r\n", 42)] + [InlineData($"{ATTRIB_FOO_BAR}*2\r\n+foo\r\n:42\r\n", 42)] + [InlineData($"*2\r\n{ATTRIB_FOO_BAR}+foo\r\n:42\r\n", 42)] + [InlineData($"*2\r\n+foo\r\n{ATTRIB_FOO_BAR}:42\r\n", 42)] + public void PubSubNumSub(string resp, long expected) => Assert.Equal(expected, Execute(resp, ResultProcessor.PubSubNumSub)); + + [Theory] + [InlineData("*-1\r\n")] + [InlineData("_\r\n")] + [InlineData(":42\r\n")] + [InlineData("$-1\r\n")] + [InlineData("*3\r\n+foo\r\n:42\r\n+bar\r\n")] + [InlineData("*4\r\n+foo\r\n:42\r\n+bar\r\n:6\r\n")] + public void FailingPubSubNumSub(string resp) => ExecuteUnexpected(resp, ResultProcessor.PubSubNumSub); + + [Theory] + [InlineData("*3\r\n,1.5\r\n,2.5\r\n,3.5\r\n", "1.5,2.5,3.5")] + [InlineData("*?\r\n,1.5\r\n,2.5\r\n,3.5\r\n.\r\n", "1.5,2.5,3.5")] // streaming aggregate + [InlineData("*3\r\n,1.5\r\n_\r\n,3.5\r\n", "1.5,,3.5")] // null element in middle (RESP3) + [InlineData("*3\r\n,1.5\r\n$-1\r\n,3.5\r\n", "1.5,,3.5")] // null element in middle (RESP2) + [InlineData("*0\r\n", "")] + [InlineData("*?\r\n.\r\n", "")] // streaming empty aggregate + [InlineData("*-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n,1.1\r\n,2.2\r\n", "1.1,2.2")] + public void NullableDoubleArray(string resp, string? expected) => Assert.Equal(expected, Join(Execute(resp, ResultProcessor.NullableDoubleArray))); + + [Theory] + [InlineData("*3\r\n:0\r\n:1\r\n:2\r\n", "ConditionNotMet,Success,Due")] + [InlineData("*?\r\n:0\r\n:1\r\n:2\r\n.\r\n", "ConditionNotMet,Success,Due")] // streaming aggregate + [InlineData("*2\r\n:1\r\n:2\r\n", "Success,Due")] + [InlineData("*0\r\n", "")] + [InlineData("*?\r\n.\r\n", "")] // streaming empty aggregate + [InlineData("*-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n:0\r\n:2\r\n", "ConditionNotMet,Due")] + public void ExpireResultArray(string resp, string? expected) => Assert.Equal(expected, Join(Execute(resp, ResultProcessor.ExpireResultArray))); + + [Theory] + [InlineData("*3\r\n:1\r\n:-1\r\n:1\r\n", "Success,ConditionNotMet,Success")] + [InlineData("*?\r\n:1\r\n:-1\r\n:1\r\n.\r\n", "Success,ConditionNotMet,Success")] // streaming aggregate + [InlineData("*2\r\n:1\r\n:-1\r\n", "Success,ConditionNotMet")] + [InlineData("*0\r\n", "")] + [InlineData("*?\r\n.\r\n", "")] // streaming empty aggregate + [InlineData("*-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n:1\r\n:-1\r\n", "Success,ConditionNotMet")] + public void PersistResultArray(string resp, string? expected) => Assert.Equal(expected, Join(Execute(resp, ResultProcessor.PersistResultArray))); + + [Theory] + [InlineData("*2\r\n$3\r\nfoo\r\n,1.5\r\n", "foo: 1.5")] + [InlineData("*2\r\n$3\r\nbar\r\n,2.5\r\n", "bar: 2.5")] + [InlineData("*-1\r\n", null)] // RESP2 null array + [InlineData("_\r\n", null)] // RESP3 pure null + [InlineData("*0\r\n", null)] // empty array (0 elements) + [InlineData("*1\r\n$3\r\nfoo\r\n", null)] // array with 1 element + [InlineData("*3\r\n$3\r\nfoo\r\n,1.5\r\n$3\r\nbar\r\n", "foo: 1.5")] // array with 3 elements - takes first 2 + [InlineData("*?\r\n.\r\n", null)] // RESP3 streaming empty aggregate (0 elements) + [InlineData(ATTRIB_FOO_BAR + "*2\r\n$3\r\nbaz\r\n,3.5\r\n", "baz: 3.5")] + public void SortedSetEntry(string resp, string? expected) + { + var result = Execute(resp, ResultProcessor.SortedSetEntry); + if (expected == null) + { + Assert.Null(result); + } + else + { + Assert.NotNull(result); + Assert.Equal(expected, $"{result.Value.Element}: {result.Value.Score}"); + } + } + + [Theory] + [InlineData(":42\r\n")] + [InlineData("$3\r\nfoo\r\n")] + [InlineData("$-1\r\n")] // null scalar should NOT be treated as null result + public void FailingSortedSetEntry(string resp) => ExecuteUnexpected(resp, ResultProcessor.SortedSetEntry); + + [Theory] + [InlineData("*2\r\n$3\r\nkey\r\n*2\r\n*2\r\n$3\r\nfoo\r\n,1.5\r\n*2\r\n$3\r\nbar\r\n,2.5\r\n", "key", "foo: 1.5, bar: 2.5")] + [InlineData("*2\r\n$4\r\nkey2\r\n*1\r\n*2\r\n$3\r\nbaz\r\n,3.5\r\n", "key2", "baz: 3.5")] + [InlineData("*2\r\n$4\r\nkey3\r\n*0\r\n", "key3", "")] + [InlineData("*-1\r\n", null, null)] + [InlineData("_\r\n", null, null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n$3\r\nkey\r\n*1\r\n*2\r\n$1\r\na\r\n,1.0\r\n", "key", "a: 1")] + public void SortedSetPopResult(string resp, string? key, string? values) + { + var result = Execute(resp, ResultProcessor.SortedSetPopResult); + if (key == null) + { + Assert.True(result.IsNull); + } + else + { + Assert.False(result.IsNull); + Assert.Equal(key, (string?)result.Key); + var entries = string.Join(", ", result.Entries.Select(e => $"{e.Element}: {e.Score}")); + Assert.Equal(values, entries); + } + } + + [Theory] + [InlineData(":42\r\n")] + [InlineData("$3\r\nfoo\r\n")] + [InlineData("*1\r\n$3\r\nkey\r\n")] + [InlineData("$-1\r\n")] // null scalar should NOT be treated as null result + public void FailingSortedSetPopResult(string resp) => ExecuteUnexpected(resp, ResultProcessor.SortedSetPopResult); + + [Theory] + [InlineData("*2\r\n$3\r\nkey\r\n*3\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$3\r\nbaz\r\n", "key", "foo,bar,baz")] + [InlineData("*2\r\n$4\r\nkey2\r\n*1\r\n$1\r\na\r\n", "key2", "a")] + [InlineData("*2\r\n$4\r\nkey3\r\n*0\r\n", "key3", "")] + [InlineData("*-1\r\n", null, null)] + [InlineData("_\r\n", null, null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n$3\r\nkey\r\n*2\r\n$1\r\nx\r\n$1\r\ny\r\n", "key", "x,y")] + public void ListPopResult(string resp, string? key, string? values) + { + var result = Execute(resp, ResultProcessor.ListPopResult); + if (key == null) + { + Assert.True(result.IsNull); + } + else + { + Assert.False(result.IsNull); + Assert.Equal(key, (string?)result.Key); + Assert.Equal(values, Join(result.Values)); + } + } + + [Theory] + [InlineData(":42\r\n")] + [InlineData("$3\r\nfoo\r\n")] + [InlineData("*1\r\n$3\r\nkey\r\n")] + [InlineData("$-1\r\n")] // null scalar should NOT be treated as null result + public void FailingListPopResult(string resp) => ExecuteUnexpected(resp, ResultProcessor.ListPopResult); + + [Theory] + [InlineData("*3\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$3\r\nbaz\r\n", "foo,bar,baz")] + [InlineData("*?\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$3\r\nbaz\r\n.\r\n", "foo,bar,baz")] // streaming aggregate + [InlineData("*2\r\n+hello\r\n+world\r\n", "hello,world")] + [InlineData("*0\r\n", "")] + [InlineData("*?\r\n.\r\n", "")] // streaming empty aggregate + [InlineData("*-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "*2\r\n$1\r\na\r\n$1\r\nb\r\n", "a,b")] + public void RedisChannelArray(string resp, string? expected) => Assert.Equal(expected, Join(Execute(resp, ResultProcessor.RedisChannelArrayLiteral))); +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/BasicScalars.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/BasicScalars.cs new file mode 100644 index 000000000..090b223f3 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/BasicScalars.cs @@ -0,0 +1,281 @@ +using System; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Tests for basic scalar result processors (Int32, Int64, Double, Boolean, String, etc.) +/// +public class BasicScalars(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData(":1\r\n", 1)] + [InlineData("+1\r\n", 1)] + [InlineData("$1\r\n1\r\n", 1)] + [InlineData("$?\r\n;1\r\n1\r\n;0\r\n", 1)] // streaming string + [InlineData(",1\r\n", 1)] + [InlineData(ATTRIB_FOO_BAR + ":1\r\n", 1)] + [InlineData(":-42\r\n", -42)] + [InlineData("+-42\r\n", -42)] + [InlineData("$3\r\n-42\r\n", -42)] + [InlineData("$?\r\n;1\r\n-\r\n;2\r\n42\r\n;0\r\n", -42)] // streaming string + [InlineData(",-42\r\n", -42)] + public void Int32(string resp, int value) => Assert.Equal(value, Execute(resp, ResultProcessor.Int32)); + + [Theory] + [InlineData("+OK\r\n")] + [InlineData("$4\r\nPONG\r\n")] + public void FailingInt32(string resp) => ExecuteUnexpected(resp, ResultProcessor.Int32); + + [Theory] + [InlineData(":1\r\n", 1)] + [InlineData("+1\r\n", 1)] + [InlineData("$1\r\n1\r\n", 1)] + [InlineData("$?\r\n;1\r\n1\r\n;0\r\n", 1)] // streaming string + [InlineData(",1\r\n", 1)] + [InlineData(ATTRIB_FOO_BAR + ":1\r\n", 1)] + [InlineData(":-42\r\n", -42)] + [InlineData("+-42\r\n", -42)] + [InlineData("$3\r\n-42\r\n", -42)] + [InlineData("$?\r\n;1\r\n-\r\n;2\r\n42\r\n;0\r\n", -42)] // streaming string + [InlineData(",-42\r\n", -42)] + public void Int64(string resp, long value) => Assert.Equal(value, Execute(resp, ResultProcessor.Int64)); + + [Theory] + [InlineData("+OK\r\n")] + [InlineData("$4\r\nPONG\r\n")] + public void FailingInt64(string resp) => ExecuteUnexpected(resp, ResultProcessor.Int64); + + [Theory] + [InlineData(":42\r\n", 42.0)] + [InlineData("+3.14\r\n", 3.14)] + [InlineData("$4\r\n3.14\r\n", 3.14)] + [InlineData("$?\r\n;1\r\n3\r\n;3\r\n.14\r\n;0\r\n", 3.14)] // streaming string + [InlineData(",3.14\r\n", 3.14)] + [InlineData(ATTRIB_FOO_BAR + ",3.14\r\n", 3.14)] + [InlineData(":-1\r\n", -1.0)] + [InlineData("+inf\r\n", double.PositiveInfinity)] + [InlineData(",inf\r\n", double.PositiveInfinity)] + [InlineData("$4\r\n-inf\r\n", double.NegativeInfinity)] + [InlineData("$?\r\n;2\r\n-i\r\n;2\r\nnf\r\n;0\r\n", double.NegativeInfinity)] // streaming string + [InlineData(",-inf\r\n", double.NegativeInfinity)] + [InlineData(",nan\r\n", double.NaN)] + public void Double(string resp, double value) => Assert.Equal(value, Execute(resp, ResultProcessor.Double)); + + [Theory] + [InlineData("_\r\n", null)] + [InlineData("$-1\r\n", null)] + [InlineData(":42\r\n", 42L)] + [InlineData("+42\r\n", 42L)] + [InlineData("$2\r\n42\r\n", 42L)] + [InlineData("$?\r\n;1\r\n4\r\n;1\r\n2\r\n;0\r\n", 42L)] // streaming string + [InlineData(",42\r\n", 42L)] + [InlineData(ATTRIB_FOO_BAR + ":42\r\n", 42L)] + public void NullableInt64(string resp, long? value) => Assert.Equal(value, Execute(resp, ResultProcessor.NullableInt64)); + + [Theory] + [InlineData("*1\r\n:99\r\n", 99L)] + [InlineData("*?\r\n:99\r\n.\r\n", 99L)] // streaming aggregate + [InlineData("*1\r\n$-1\r\n", null)] // unit array with RESP2 null bulk string + [InlineData("*1\r\n_\r\n", null)] // unit array with RESP3 null + [InlineData(ATTRIB_FOO_BAR + "*1\r\n:99\r\n", 99L)] + public void NullableInt64ArrayOfOne(string resp, long? value) => Assert.Equal(value, Execute(resp, ResultProcessor.NullableInt64)); + + [Theory] + [InlineData("*-1\r\n")] // null array + [InlineData("*0\r\n")] // empty array + [InlineData("*?\r\n.\r\n")] // streaming empty aggregate + [InlineData("*2\r\n:1\r\n:2\r\n")] // two elements + [InlineData("*?\r\n:1\r\n:2\r\n.\r\n")] // streaming aggregate with two elements + public void FailingNullableInt64ArrayOfNonOne(string resp) => ExecuteUnexpected(resp, ResultProcessor.NullableInt64); + + [Theory] + [InlineData("_\r\n", null)] + [InlineData("$-1\r\n", null)] + [InlineData(":42\r\n", 42.0)] + [InlineData("+3.14\r\n", 3.14)] + [InlineData("$4\r\n3.14\r\n", 3.14)] + [InlineData("$?\r\n;1\r\n3\r\n;3\r\n.14\r\n;0\r\n", 3.14)] // streaming string + [InlineData(",3.14\r\n", 3.14)] + [InlineData(ATTRIB_FOO_BAR + ",3.14\r\n", 3.14)] + public void NullableDouble(string resp, double? value) => Assert.Equal(value, Execute(resp, ResultProcessor.NullableDouble)); + + [Theory] + [InlineData("_\r\n", false)] // null = false + [InlineData(":0\r\n", false)] + [InlineData(":1\r\n", true)] + [InlineData("#f\r\n", false)] + [InlineData("#t\r\n", true)] + [InlineData("+OK\r\n", true)] + [InlineData(ATTRIB_FOO_BAR + ":1\r\n", true)] + public void Boolean(string resp, bool value) => Assert.Equal(value, Execute(resp, ResultProcessor.Boolean)); + + [Theory] + [InlineData("*1\r\n:1\r\n", true)] // SCRIPT EXISTS returns array + [InlineData("*?\r\n:1\r\n.\r\n", true)] // streaming aggregate + [InlineData("*1\r\n:0\r\n", false)] + [InlineData(ATTRIB_FOO_BAR + "*1\r\n:1\r\n", true)] + public void BooleanArrayOfOne(string resp, bool value) => Assert.Equal(value, Execute(resp, ResultProcessor.Boolean)); + + [Theory] + [InlineData("*0\r\n")] // empty array + [InlineData("*?\r\n.\r\n")] // streaming empty aggregate + [InlineData("*2\r\n:1\r\n:0\r\n")] // two elements + [InlineData("*?\r\n:1\r\n:0\r\n.\r\n")] // streaming aggregate with two elements + [InlineData("*1\r\n*1\r\n:1\r\n")] // nested array (not scalar) + public void FailingBooleanArrayOfNonOne(string resp) => ExecuteUnexpected(resp, ResultProcessor.Boolean); + + [Theory] + [InlineData("$5\r\nhello\r\n", "hello")] + [InlineData("$?\r\n;2\r\nhe\r\n;3\r\nllo\r\n;0\r\n", "hello")] // streaming string + [InlineData("$?\r\n;0\r\n", "")] // streaming empty string + [InlineData("+world\r\n", "world")] + [InlineData(":42\r\n", "42")] + [InlineData("$-1\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "$3\r\nfoo\r\n", "foo")] + public void String(string resp, string? value) => Assert.Equal(value, Execute(resp, ResultProcessor.String)); + + [Theory] + [InlineData("*1\r\n$3\r\nbar\r\n", "bar")] + [InlineData("*?\r\n$3\r\nbar\r\n.\r\n", "bar")] // streaming aggregate + [InlineData(ATTRIB_FOO_BAR + "*1\r\n$3\r\nbar\r\n", "bar")] + public void StringArrayOfOne(string resp, string? value) => Assert.Equal(value, Execute(resp, ResultProcessor.String)); + + [Theory] + [InlineData("*-1\r\n")] // null array + [InlineData("*0\r\n")] // empty array + [InlineData("*?\r\n.\r\n")] // streaming empty aggregate + [InlineData("*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n")] // two elements + [InlineData("*?\r\n$3\r\nfoo\r\n$3\r\nbar\r\n.\r\n")] // streaming aggregate with two elements + [InlineData("*1\r\n*1\r\n$3\r\nfoo\r\n")] // nested array (not scalar) + public void FailingStringArrayOfNonOne(string resp) => ExecuteUnexpected(resp, ResultProcessor.String); + + [Theory] + [InlineData("+string\r\n", Redis.RedisType.String)] + [InlineData("+hash\r\n", Redis.RedisType.Hash)] + [InlineData("+zset\r\n", Redis.RedisType.SortedSet)] + [InlineData("+set\r\n", Redis.RedisType.Set)] + [InlineData("+list\r\n", Redis.RedisType.List)] + [InlineData("+stream\r\n", Redis.RedisType.Stream)] + [InlineData("+blah\r\n", Redis.RedisType.Unknown)] + [InlineData("$-1\r\n", Redis.RedisType.None)] + [InlineData("_\r\n", Redis.RedisType.None)] + [InlineData("$0\r\n\r\n", Redis.RedisType.None)] + [InlineData(ATTRIB_FOO_BAR + "$6\r\nstring\r\n", Redis.RedisType.String)] + public void RedisType(string resp, RedisType value) => Assert.Equal(value, Execute(resp, ResultProcessor.RedisType)); + + [Theory] + [InlineData("$5\r\nhello\r\n", "hello")] + [InlineData("$?\r\n;2\r\nhe\r\n;3\r\nllo\r\n;0\r\n", "hello")] // streaming string + [InlineData("+world\r\n", "world")] + [InlineData(":42\r\n", "42")] + [InlineData("$-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "$3\r\nfoo\r\n", "foo")] + public void ByteArray(string resp, string? expected) + { + var result = Execute(resp, ResultProcessor.ByteArray); + if (expected is null) + { + Assert.Null(result); + } + else + { + Assert.Equal(expected, System.Text.Encoding.UTF8.GetString(result!)); + } + } + + [Theory] + [InlineData("*-1\r\n")] // null array + [InlineData("*0\r\n")] // empty array + [InlineData("*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n")] // array + public void FailingByteArray(string resp) => ExecuteUnexpected(resp, ResultProcessor.ByteArray); + + [Theory] + [InlineData("$5\r\nhello\r\n", "hello")] + [InlineData("$?\r\n;2\r\nhe\r\n;3\r\nllo\r\n;0\r\n", "hello")] // streaming string + [InlineData("+world\r\n", "world")] + [InlineData("$-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "$11\r\nclusterinfo\r\n", "clusterinfo")] + // note that this test does not include a valid cluster nodes response + public void ClusterNodesRaw(string resp, string? expected) => Assert.Equal(expected, Execute(resp, ResultProcessor.ClusterNodesRaw)); + + [Theory] + [InlineData("*0\r\n")] // empty array + [InlineData("*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n")] // array + public void FailingClusterNodesRaw(string resp) => ExecuteUnexpected(resp, ResultProcessor.ClusterNodesRaw); + + [Theory] + [InlineData(":42\r\n", 42L)] + [InlineData("+99\r\n", 99L)] + [InlineData("$2\r\n10\r\n", 10L)] + [InlineData("$?\r\n;1\r\n1\r\n;1\r\n0\r\n;0\r\n", 10L)] // streaming string + [InlineData(",123\r\n", 123L)] + [InlineData(ATTRIB_FOO_BAR + ":42\r\n", 42L)] + public void Int64DefaultValue(string resp, long expected) => Assert.Equal(expected, Execute(resp, Int64DefaultValue999)); + + [Theory] + [InlineData("_\r\n", 999L)] // null returns default + [InlineData("$-1\r\n", 999L)] // null returns default + public void Int64DefaultValueNull(string resp, long expected) => Assert.Equal(expected, Execute(resp, Int64DefaultValue999)); + + [Theory] + [InlineData("*0\r\n")] // empty array + [InlineData("*2\r\n:1\r\n:2\r\n")] // array + [InlineData("+notanumber\r\n")] // invalid number + public void FailingInt64DefaultValue(string resp) => ExecuteUnexpected(resp, Int64DefaultValue999); + + [Theory] + [InlineData("$5\r\nhello\r\n", "hello")] + [InlineData("$?\r\n;2\r\nhe\r\n;3\r\nllo\r\n;0\r\n", "hello")] // streaming string + [InlineData("+world\r\n", "world")] + [InlineData(":42\r\n", "42")] + [InlineData("$-1\r\n", "(null)")] + [InlineData("_\r\n", "(null)")] + [InlineData(ATTRIB_FOO_BAR + "$3\r\nfoo\r\n", "foo")] + public void RedisKey(string resp, string expected) + { + var result = Execute(resp, ResultProcessor.RedisKey); + Assert.Equal(expected, result.ToString()); + } + + [Theory] + [InlineData("*0\r\n")] // empty array + [InlineData("*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n")] // array + public void FailingRedisKey(string resp) => ExecuteUnexpected(resp, ResultProcessor.RedisKey); + + [Theory] + [InlineData("$5\r\nhello\r\n", "hello")] + [InlineData("$?\r\n;2\r\nhe\r\n;3\r\nllo\r\n;0\r\n", "hello")] // streaming string + [InlineData("+world\r\n", "world")] + [InlineData(":42\r\n", "42")] + [InlineData("$-1\r\n", "")] + [InlineData("_\r\n", "")] + [InlineData(",3.14\r\n", "3.14")] + [InlineData(ATTRIB_FOO_BAR + "$3\r\nfoo\r\n", "foo")] + public void RedisValue(string resp, string expected) + { + var result = Execute(resp, ResultProcessor.RedisValue); + Assert.Equal(expected, result.ToString()); + } + + [Theory] + [InlineData("*0\r\n")] // empty array + [InlineData("*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n")] // array + public void FailingRedisValue(string resp) => ExecuteUnexpected(resp, ResultProcessor.RedisValue); + + [Theory] + [InlineData("$5\r\nhello\r\n", "hello")] + [InlineData("$?\r\n;2\r\nhe\r\n;3\r\nllo\r\n;0\r\n", "hello")] // streaming string + [InlineData("+world\r\n", "world")] + [InlineData("$-1\r\n", null)] + [InlineData("_\r\n", null)] + [InlineData(ATTRIB_FOO_BAR + "$10\r\ntiebreaker\r\n", "tiebreaker")] + public void TieBreaker(string resp, string? expected) => Assert.Equal(expected, Execute(resp, ResultProcessor.TieBreaker)); + + [Theory] + [InlineData("*0\r\n")] // empty array + [InlineData("*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n")] // array + public void FailingTieBreaker(string resp) => ExecuteUnexpected(resp, ResultProcessor.TieBreaker); +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ClientInfo.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ClientInfo.cs new file mode 100644 index 000000000..086ef0566 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ClientInfo.cs @@ -0,0 +1,93 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class ClientInfo(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void SingleClient_Success() + { + // CLIENT LIST returns a bulk string with newline-separated client information + var content = "id=86 addr=172.17.0.1:40750 laddr=172.17.0.2:3000 fd=22 name= age=7 idle=0 flags=N db=0 sub=0 psub=0 ssub=0 multi=-1 watch=0 qbuf=26 qbuf-free=20448 argv-mem=10 multi-mem=0 rbs=1024 rbp=0 obl=0 oll=0 omem=0 tot-mem=22810 events=r cmd=client|list user=default redir=-1 resp=2 lib-name= lib-ver= io-thread=0 tot-net-in=48 tot-net-out=36 tot-cmds=0\n"; + var resp = $"${content.Length}\r\n{content}\r\n"; + + var result = Execute(resp, StackExchange.Redis.ClientInfo.Processor); + + Assert.NotNull(result); + Assert.Single(result); + Assert.Equal(86, result[0].Id); + Assert.Equal("172.17.0.1:40750", result[0].Address?.ToString()); + Assert.Equal(7, result[0].AgeSeconds); + Assert.Equal(0, result[0].Database); + } + + [Fact] + public void MultipleClients_Success() + { + // Two clients (newline-separated, using \n not \r\n) + var line1 = "id=86 addr=172.17.0.1:40750 laddr=172.17.0.2:3000 fd=22 name= age=39 idle=32 flags=N db=0 sub=0 psub=0 ssub=0 multi=-1 watch=0 qbuf=0 qbuf-free=0 argv-mem=0 multi-mem=0 rbs=1024 rbp=0 obl=0 oll=0 omem=0 tot-mem=2304 events=r cmd=client|list user=default redir=-1 resp=2 lib-name= lib-ver= io-thread=0 tot-net-in=48 tot-net-out=390 tot-cmds=1\n"; + var line2 = "id=87 addr=172.17.0.1:60630 laddr=172.17.0.2:3000 fd=23 name= age=4 idle=0 flags=N db=0 sub=0 psub=0 ssub=0 multi=-1 watch=0 qbuf=26 qbuf-free=20448 argv-mem=10 multi-mem=0 rbs=1024 rbp=7 obl=0 oll=0 omem=0 tot-mem=22810 events=r cmd=client|list user=default redir=-1 resp=2 lib-name= lib-ver= io-thread=0 tot-net-in=40 tot-net-out=7 tot-cmds=1\n"; + var content = line1 + line2; + var resp = $"${content.Length}\r\n{content}\r\n"; + + var result = Execute(resp, StackExchange.Redis.ClientInfo.Processor); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + Assert.Equal(86, result[0].Id); + Assert.Equal(87, result[1].Id); + Assert.Equal("172.17.0.1:40750", result[0].Address?.ToString()); + Assert.Equal("172.17.0.1:60630", result[1].Address?.ToString()); + } + + [Fact] + public void EmptyString_Success() + { + // Empty bulk string + var resp = "$0\r\n\r\n"; + + var result = Execute(resp, StackExchange.Redis.ClientInfo.Processor); + + Assert.NotNull(result); + Assert.Empty(result); + } + + [Fact] + public void NullBulkString_Failure() + { + // Null bulk string should fail + var resp = "$-1\r\n"; + + ExecuteUnexpected(resp, StackExchange.Redis.ClientInfo.Processor); + } + + [Fact] + public void NotBulkString_Failure() + { + // Simple string should fail + var resp = "+OK\r\n"; + + ExecuteUnexpected(resp, StackExchange.Redis.ClientInfo.Processor); + } + + [Fact] + public void VerbatimString_Success() + { + // Verbatim string with TXT encoding - should behave identically to bulk string + // Format: ={len}\r\n{enc}:{payload}\r\n where enc is exactly 3 bytes (e.g., "TXT") + var content = "id=86 addr=172.17.0.1:40750 laddr=172.17.0.2:3000 fd=22 name= age=7 idle=0 flags=N db=0 sub=0 psub=0 ssub=0 multi=-1 watch=0 qbuf=26 qbuf-free=20448 argv-mem=10 multi-mem=0 rbs=1024 rbp=0 obl=0 oll=0 omem=0 tot-mem=22810 events=r cmd=client|list user=default redir=-1 resp=2 lib-name= lib-ver= io-thread=0 tot-net-in=48 tot-net-out=36 tot-cmds=0\n"; + var totalLen = 4 + content.Length; // "TXT:" + content + var resp = $"={totalLen}\r\nTXT:{content}\r\n"; + + var result = Execute(resp, StackExchange.Redis.ClientInfo.Processor); + + // ReadString() automatically strips the "TXT:" encoding prefix, + // so the result should be identical to the bulk string test + Assert.NotNull(result); + Assert.Single(result); + Assert.Equal(86, result[0].Id); + Assert.Equal("172.17.0.1:40750", result[0].Address?.ToString()); + Assert.Equal(7, result[0].AgeSeconds); + Assert.Equal(0, result[0].Database); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ClusterNodes.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ClusterNodes.cs new file mode 100644 index 000000000..91e089c57 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ClusterNodes.cs @@ -0,0 +1,12 @@ +using System.Linq; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class ClusterNodes(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + // NOTE: ClusterNodesProcessor cannot be unit tested in isolation because it requires + // a real PhysicalConnection with a bridge to parse the cluster configuration. + // The processor calls connection.BridgeCouldBeNull which throws ObjectDisposedException + // in the test environment. These tests are covered by integration tests instead. +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ConditionTests.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ConditionTests.cs new file mode 100644 index 000000000..fbce6d4d5 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ConditionTests.cs @@ -0,0 +1,408 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Unit tests for Condition subclasses using the RespReader path. +/// +public class ConditionTests(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + private static Message CreateConditionMessage(Condition condition, RedisCommand command, RedisKey key, params RedisValue[] values) + { + return values.Length switch + { + 0 => Condition.ConditionProcessor.CreateMessage(condition, 0, CommandFlags.None, command, key), + 1 => Condition.ConditionProcessor.CreateMessage(condition, 0, CommandFlags.None, command, key, values[0]), + 2 => Condition.ConditionProcessor.CreateMessage(condition, 0, CommandFlags.None, command, key, values[0], values[1]), + 5 => Condition.ConditionProcessor.CreateMessage(condition, 0, CommandFlags.None, command, key, values[0], values[1], values[2], values[3], values[4]), + _ => throw new System.NotSupportedException($"Unsupported value count: {values.Length}"), + }; + } + + [Fact] + public void ExistsCondition_KeyExists_True() + { + var condition = Condition.KeyExists("mykey"); + var message = CreateConditionMessage(condition, RedisCommand.EXISTS, "mykey"); + var result = Execute(":1\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ExistsCondition_KeyExists_False() + { + var condition = Condition.KeyExists("mykey"); + var message = CreateConditionMessage(condition, RedisCommand.EXISTS, "mykey"); + var result = Execute(":0\r\n", Condition.ConditionProcessor.Default, message); + Assert.False(result); + } + + [Fact] + public void ExistsCondition_KeyNotExists_True() + { + var condition = Condition.KeyNotExists("mykey"); + var message = CreateConditionMessage(condition, RedisCommand.EXISTS, "mykey"); + var result = Execute(":0\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ExistsCondition_KeyNotExists_False() + { + var condition = Condition.KeyNotExists("mykey"); + var message = CreateConditionMessage(condition, RedisCommand.EXISTS, "mykey"); + var result = Execute(":1\r\n", Condition.ConditionProcessor.Default, message); + Assert.False(result); + } + + [Fact] + public void ExistsCondition_HashExists_True() + { + var condition = Condition.HashExists("myhash", "field1"); + var message = CreateConditionMessage(condition, RedisCommand.HEXISTS, "myhash", "field1"); + var result = Execute(":1\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ExistsCondition_HashNotExists_True() + { + var condition = Condition.HashNotExists("myhash", "field1"); + var message = CreateConditionMessage(condition, RedisCommand.HEXISTS, "myhash", "field1"); + var result = Execute(":0\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ExistsCondition_SetContains_True() + { + var condition = Condition.SetContains("myset", "member1"); + var message = CreateConditionMessage(condition, RedisCommand.SISMEMBER, "myset", "member1"); + var result = Execute(":1\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ExistsCondition_SetNotContains_True() + { + var condition = Condition.SetNotContains("myset", "member1"); + var message = CreateConditionMessage(condition, RedisCommand.SISMEMBER, "myset", "member1"); + var result = Execute(":0\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ExistsCondition_SortedSetContains_True() + { + var condition = Condition.SortedSetContains("myzset", "member1"); + var message = CreateConditionMessage(condition, RedisCommand.ZSCORE, "myzset", "member1"); + var result = Execute("$1\r\n5\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ExistsCondition_SortedSetContains_Null_False() + { + var condition = Condition.SortedSetContains("myzset", "member1"); + var message = CreateConditionMessage(condition, RedisCommand.ZSCORE, "myzset", "member1"); + var result = Execute("$-1\r\n", Condition.ConditionProcessor.Default, message); + Assert.False(result); + } + + [Fact] + public void ExistsCondition_SortedSetNotContains_True() + { + var condition = Condition.SortedSetNotContains("myzset", "member1"); + var message = CreateConditionMessage(condition, RedisCommand.ZSCORE, "myzset", "member1"); + var result = Execute("$-1\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void StartsWithCondition_Match_True() + { + var condition = Condition.SortedSetContainsStarting("myzset", "pre"); + var message = CreateConditionMessage(condition, RedisCommand.ZRANGEBYLEX, "myzset", "[pre", "+", "LIMIT", 0, 1); + var result = Execute("*1\r\n$6\r\nprefix\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void StartsWithCondition_NoMatch_False() + { + var condition = Condition.SortedSetContainsStarting("myzset", "pre"); + var message = CreateConditionMessage(condition, RedisCommand.ZRANGEBYLEX, "myzset", "[pre", "+", "LIMIT", 0, 1); + var result = Execute("*0\r\n", Condition.ConditionProcessor.Default, message); + Assert.False(result); + } + + [Fact] + public void StartsWithCondition_NotContainsStarting_True() + { + var condition = Condition.SortedSetNotContainsStarting("myzset", "pre"); + var message = CreateConditionMessage(condition, RedisCommand.ZRANGEBYLEX, "myzset", "[pre", "+", "LIMIT", 0, 1); + var result = Execute("*0\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void EqualsCondition_StringEqual_True() + { + var condition = Condition.StringEqual("mykey", "value1"); + var message = CreateConditionMessage(condition, RedisCommand.GET, "mykey", RedisValue.Null); + var result = Execute("$6\r\nvalue1\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void EqualsCondition_StringEqual_False() + { + var condition = Condition.StringEqual("mykey", "value1"); + var message = CreateConditionMessage(condition, RedisCommand.GET, "mykey", RedisValue.Null); + var result = Execute("$6\r\nvalue2\r\n", Condition.ConditionProcessor.Default, message); + Assert.False(result); + } + + [Fact] + public void EqualsCondition_StringNotEqual_True() + { + var condition = Condition.StringNotEqual("mykey", "value1"); + var message = CreateConditionMessage(condition, RedisCommand.GET, "mykey", RedisValue.Null); + var result = Execute("$6\r\nvalue2\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void EqualsCondition_HashEqual_True() + { + var condition = Condition.HashEqual("myhash", "field1", "value1"); + var message = CreateConditionMessage(condition, RedisCommand.HGET, "myhash", "field1"); + var result = Execute("$6\r\nvalue1\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void EqualsCondition_HashNotEqual_True() + { + var condition = Condition.HashNotEqual("myhash", "field1", "value1"); + var message = CreateConditionMessage(condition, RedisCommand.HGET, "myhash", "field1"); + var result = Execute("$6\r\nvalue2\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void EqualsCondition_SortedSetEqual_True() + { + var condition = Condition.SortedSetEqual("myzset", "member1", 5.0); + var message = CreateConditionMessage(condition, RedisCommand.ZSCORE, "myzset", "member1"); + var result = Execute("$1\r\n5\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void EqualsCondition_SortedSetEqual_False() + { + var condition = Condition.SortedSetEqual("myzset", "member1", 5.0); + var message = CreateConditionMessage(condition, RedisCommand.ZSCORE, "myzset", "member1"); + var result = Execute("$1\r\n3\r\n", Condition.ConditionProcessor.Default, message); + Assert.False(result); + } + + [Fact] + public void EqualsCondition_SortedSetNotEqual_True() + { + var condition = Condition.SortedSetNotEqual("myzset", "member1", 5.0); + var message = CreateConditionMessage(condition, RedisCommand.ZSCORE, "myzset", "member1"); + var result = Execute("$1\r\n3\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ListCondition_IndexEqual_True() + { + var condition = Condition.ListIndexEqual("mylist", 0, "value1"); + var message = CreateConditionMessage(condition, RedisCommand.LINDEX, "mylist", 0); + var result = Execute("$6\r\nvalue1\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ListCondition_IndexEqual_False() + { + var condition = Condition.ListIndexEqual("mylist", 0, "value1"); + var message = CreateConditionMessage(condition, RedisCommand.LINDEX, "mylist", 0); + var result = Execute("$6\r\nvalue2\r\n", Condition.ConditionProcessor.Default, message); + Assert.False(result); + } + + [Fact] + public void ListCondition_IndexNotEqual_True() + { + var condition = Condition.ListIndexNotEqual("mylist", 0, "value1"); + var message = CreateConditionMessage(condition, RedisCommand.LINDEX, "mylist", 0); + var result = Execute("$6\r\nvalue2\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ListCondition_IndexExists_True() + { + var condition = Condition.ListIndexExists("mylist", 0); + var message = CreateConditionMessage(condition, RedisCommand.LINDEX, "mylist", 0); + var result = Execute("$6\r\nvalue1\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void ListCondition_IndexExists_Null_False() + { + var condition = Condition.ListIndexExists("mylist", 0); + var message = CreateConditionMessage(condition, RedisCommand.LINDEX, "mylist", 0); + var result = Execute("$-1\r\n", Condition.ConditionProcessor.Default, message); + Assert.False(result); + } + + [Fact] + public void ListCondition_IndexNotExists_True() + { + var condition = Condition.ListIndexNotExists("mylist", 0); + var message = CreateConditionMessage(condition, RedisCommand.LINDEX, "mylist", 0); + var result = Execute("$-1\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void LengthCondition_StringLengthEqual_True() + { + var condition = Condition.StringLengthEqual("mykey", 10); + var message = CreateConditionMessage(condition, RedisCommand.STRLEN, "mykey"); + var result = Execute(":10\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void LengthCondition_StringLengthEqual_False() + { + var condition = Condition.StringLengthEqual("mykey", 10); + var message = CreateConditionMessage(condition, RedisCommand.STRLEN, "mykey"); + var result = Execute(":5\r\n", Condition.ConditionProcessor.Default, message); + Assert.False(result); + } + + [Fact] + public void LengthCondition_StringLengthLessThan_True() + { + var condition = Condition.StringLengthLessThan("mykey", 10); + var message = CreateConditionMessage(condition, RedisCommand.STRLEN, "mykey"); + var result = Execute(":5\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void LengthCondition_StringLengthGreaterThan_True() + { + var condition = Condition.StringLengthGreaterThan("mykey", 10); + var message = CreateConditionMessage(condition, RedisCommand.STRLEN, "mykey"); + var result = Execute(":15\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void LengthCondition_HashLengthEqual_True() + { + var condition = Condition.HashLengthEqual("myhash", 5); + var message = CreateConditionMessage(condition, RedisCommand.HLEN, "myhash"); + var result = Execute(":5\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void LengthCondition_ListLengthEqual_True() + { + var condition = Condition.ListLengthEqual("mylist", 3); + var message = CreateConditionMessage(condition, RedisCommand.LLEN, "mylist"); + var result = Execute(":3\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void LengthCondition_SetLengthEqual_True() + { + var condition = Condition.SetLengthEqual("myset", 7); + var message = CreateConditionMessage(condition, RedisCommand.SCARD, "myset"); + var result = Execute(":7\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void LengthCondition_SortedSetLengthEqual_True() + { + var condition = Condition.SortedSetLengthEqual("myzset", 4); + var message = CreateConditionMessage(condition, RedisCommand.ZCARD, "myzset"); + var result = Execute(":4\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void LengthCondition_StreamLengthEqual_True() + { + var condition = Condition.StreamLengthEqual("mystream", 10); + var message = CreateConditionMessage(condition, RedisCommand.XLEN, "mystream"); + var result = Execute(":10\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void SortedSetRangeLengthCondition_Equal_True() + { + var condition = Condition.SortedSetLengthEqual("myzset", 5, 0, 10); + var message = CreateConditionMessage(condition, RedisCommand.ZCOUNT, "myzset", 0, 10); + var result = Execute(":5\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void SortedSetRangeLengthCondition_LessThan_True() + { + var condition = Condition.SortedSetLengthLessThan("myzset", 10, 0, 100); + var message = CreateConditionMessage(condition, RedisCommand.ZCOUNT, "myzset", 0, 100); + var result = Execute(":5\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void SortedSetRangeLengthCondition_GreaterThan_True() + { + var condition = Condition.SortedSetLengthGreaterThan("myzset", 3, 0, 100); + var message = CreateConditionMessage(condition, RedisCommand.ZCOUNT, "myzset", 0, 100); + var result = Execute(":10\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void SortedSetScoreCondition_ScoreExists_True() + { + var condition = Condition.SortedSetScoreExists("myzset", 5.0); + var message = CreateConditionMessage(condition, RedisCommand.ZCOUNT, "myzset", 5.0, 5.0); + var result = Execute(":3\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } + + [Fact] + public void SortedSetScoreCondition_ScoreExists_False() + { + var condition = Condition.SortedSetScoreExists("myzset", 5.0); + var message = CreateConditionMessage(condition, RedisCommand.ZCOUNT, "myzset", 5.0, 5.0); + var result = Execute(":0\r\n", Condition.ConditionProcessor.Default, message); + Assert.False(result); + } + + [Fact] + public void SortedSetScoreCondition_ScoreNotExists_True() + { + var condition = Condition.SortedSetScoreNotExists("myzset", 5.0); + var message = CreateConditionMessage(condition, RedisCommand.ZCOUNT, "myzset", 5.0, 5.0); + var result = Execute(":0\r\n", Condition.ConditionProcessor.Default, message); + Assert.True(result); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/DateTime.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/DateTime.cs new file mode 100644 index 000000000..9dc4bc954 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/DateTime.cs @@ -0,0 +1,79 @@ +using System; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Tests for DateTime result processors +/// +public class DateTimeTests(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData(":1609459200\r\n")] // scalar integer (Jan 1, 2021 00:00:00 UTC) + [InlineData("*1\r\n:1609459200\r\n")] // array of 1 (seconds only) + [InlineData("*?\r\n:1609459200\r\n.\r\n")] // streaming aggregate of 1 + [InlineData(ATTRIB_FOO_BAR + ":1609459200\r\n")] + public void DateTime(string resp) + { + var expected = new DateTime(2021, 1, 1, 0, 0, 0, DateTimeKind.Utc); + Assert.Equal(expected, Execute(resp, ResultProcessor.DateTime)); + } + + [Theory] + [InlineData("*2\r\n:1609459200\r\n:500000\r\n")] // array of 2 (seconds + microseconds) + [InlineData("*?\r\n:1609459200\r\n:500000\r\n.\r\n")] // streaming aggregate of 2 + [InlineData(ATTRIB_FOO_BAR + "*2\r\n:1609459200\r\n:500000\r\n")] + public void DateTimeWithMicroseconds(string resp) + { + // 500000 microseconds = 0.5 seconds = 5000000 ticks (100ns each) + var expected = new DateTime(2021, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddTicks(5000000); + Assert.Equal(expected, Execute(resp, ResultProcessor.DateTime)); + } + + [Theory] + [InlineData("*0\r\n")] // empty array + [InlineData("*?\r\n.\r\n")] // streaming empty aggregate + [InlineData("*3\r\n:1\r\n:2\r\n:3\r\n")] // array with 3 elements + [InlineData("$5\r\nhello\r\n")] // bulk string + public void FailingDateTime(string resp) => ExecuteUnexpected(resp, ResultProcessor.DateTime); + + [Theory] + [InlineData(":1609459200\r\n")] // positive value (Jan 1, 2021 00:00:00 UTC) - seconds + [InlineData(",1609459200\r\n")] // RESP3 number + [InlineData(ATTRIB_FOO_BAR + ":1609459200\r\n")] + public void NullableDateTimeFromSeconds(string resp) + { + var expected = new DateTime(2021, 1, 1, 0, 0, 0, DateTimeKind.Utc); + Assert.Equal(expected, Execute(resp, ResultProcessor.NullableDateTimeFromSeconds)); + } + + [Theory] + [InlineData(":1609459200000\r\n")] // positive value (Jan 1, 2021 00:00:00 UTC) - milliseconds + [InlineData(",1609459200000\r\n")] // RESP3 number + [InlineData(ATTRIB_FOO_BAR + ":1609459200000\r\n")] + public void NullableDateTimeFromMilliseconds(string resp) + { + var expected = new DateTime(2021, 1, 1, 0, 0, 0, DateTimeKind.Utc); + Assert.Equal(expected, Execute(resp, ResultProcessor.NullableDateTimeFromMilliseconds)); + } + + [Theory] + [InlineData(":-1\r\n", null)] // -1 means no expiry + [InlineData(":-2\r\n", null)] // -2 means key does not exist + [InlineData("_\r\n", null)] // RESP3 null + [InlineData("$-1\r\n", null)] // RESP2 null bulk string + public void NullableDateTimeNull(string resp, DateTime? expected) + { + Assert.Equal(expected, Execute(resp, ResultProcessor.NullableDateTimeFromSeconds)); + Assert.Equal(expected, Execute(resp, ResultProcessor.NullableDateTimeFromMilliseconds)); + } + + [Theory] + [InlineData("*0\r\n")] // empty array + [InlineData("*2\r\n:1\r\n:2\r\n")] // array + public void FailingNullableDateTime(string resp) + { + ExecuteUnexpected(resp, ResultProcessor.NullableDateTimeFromSeconds); + ExecuteUnexpected(resp, ResultProcessor.NullableDateTimeFromMilliseconds); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/DemandZeroOrOne.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/DemandZeroOrOne.cs new file mode 100644 index 000000000..e5ce63ce6 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/DemandZeroOrOne.cs @@ -0,0 +1,29 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class DemandZeroOrOne(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData(":0\r\n", false)] + [InlineData(":1\r\n", true)] + [InlineData("+0\r\n", false)] + [InlineData("+1\r\n", true)] + [InlineData("$1\r\n0\r\n", false)] + [InlineData("$1\r\n1\r\n", true)] + public void ValidZeroOrOne_Success(string resp, bool expected) + { + var result = Execute(resp, ResultProcessor.DemandZeroOrOne); + Assert.Equal(expected, result); + } + + [Theory] + [InlineData(":2\r\n")] + [InlineData("+OK\r\n")] + [InlineData("*1\r\n:1\r\n")] + [InlineData("$-1\r\n")] + public void InvalidResponse_Failure(string resp) + { + ExecuteUnexpected(resp, ResultProcessor.DemandZeroOrOne); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ExpectBasicString.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ExpectBasicString.cs new file mode 100644 index 000000000..a6fc80a42 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ExpectBasicString.cs @@ -0,0 +1,58 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class ExpectBasicString(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData("+OK\r\n", true)] + [InlineData("$2\r\nOK\r\n", true)] + public void DemandOK_Success(string resp, bool expected) => Assert.Equal(expected, Execute(resp, ResultProcessor.DemandOK)); + + [Theory] + [InlineData("+PONG\r\n", true)] + [InlineData("$4\r\nPONG\r\n", true)] + public void DemandPONG_Success(string resp, bool expected) => Assert.Equal(expected, Execute(resp, ResultProcessor.DemandPONG)); + + [Theory] + [InlineData("+FAIL\r\n")] + [InlineData("$4\r\nFAIL\r\n")] + [InlineData(":1\r\n")] + public void DemandOK_Failure(string resp) => Assert.False(TryExecute(resp, ResultProcessor.DemandOK, out _, out _)); + + [Theory] + [InlineData("+FAIL\r\n")] + [InlineData("$4\r\nFAIL\r\n")] + [InlineData(":1\r\n")] + public void DemandPONG_Failure(string resp) => Assert.False(TryExecute(resp, ResultProcessor.DemandPONG, out _, out _)); + + [Theory] + [InlineData("+Background saving started\r\n", true)] + [InlineData("$25\r\nBackground saving started\r\n", true)] + [InlineData("+Background saving started by parent\r\n", true)] + public void BackgroundSaveStarted_Success(string resp, bool expected) => Assert.Equal(expected, Execute(resp, ResultProcessor.BackgroundSaveStarted)); + + [Theory] + [InlineData("+Background append only file rewriting started\r\n", true)] + [InlineData("$45\r\nBackground append only file rewriting started\r\n", true)] + public void BackgroundSaveAOFStarted_Success(string resp, bool expected) => Assert.Equal(expected, Execute(resp, ResultProcessor.BackgroundSaveAOFStarted)); + + // Case sensitivity tests - these demonstrate that the new implementation is case-sensitive + // The old CommandBytes implementation was case-insensitive (stored uppercase) + [Theory] + [InlineData("+ok\r\n")] // lowercase + [InlineData("+Ok\r\n")] // mixed case + [InlineData("$2\r\nok\r\n")] // lowercase bulk string + public void DemandOK_CaseSensitive_Failure(string resp) => Assert.False(TryExecute(resp, ResultProcessor.DemandOK, out _, out _)); + + [Theory] + [InlineData("+pong\r\n")] // lowercase + [InlineData("+Pong\r\n")] // mixed case + [InlineData("$4\r\npong\r\n")] // lowercase bulk string + public void DemandPONG_CaseSensitive_Failure(string resp) => Assert.False(TryExecute(resp, ResultProcessor.DemandPONG, out _, out _)); + + [Theory] + [InlineData("+background saving started\r\n")] // lowercase + [InlineData("+BACKGROUND SAVING STARTED\r\n")] // uppercase + public void BackgroundSaveStarted_CaseSensitive_Failure(string resp) => Assert.False(TryExecute(resp, ResultProcessor.BackgroundSaveStarted, out _, out _)); +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/GeoPosition.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/GeoPosition.cs new file mode 100644 index 000000000..23436aff8 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/GeoPosition.cs @@ -0,0 +1,118 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class GeoPosition(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void GeoPosition_ValidPosition_ReturnsGeoPosition() + { + var resp = "*1\r\n*2\r\n$18\r\n13.361389338970184\r\n$16\r\n38.1155563954963\r\n"; + var processor = ResultProcessor.RedisGeoPosition; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(13.361389338970184, result.Value.Longitude, 10); + Assert.Equal(38.1155563954963, result.Value.Latitude, 10); + } + + [Fact] + public void GeoPosition_NullElement_ReturnsNull() + { + var resp = "*1\r\n$-1\r\n"; + var processor = ResultProcessor.RedisGeoPosition; + var result = Execute(resp, processor); + + Assert.Null(result); + } + + [Fact] + public void GeoPosition_EmptyArray_ReturnsNull() + { + var resp = "*0\r\n"; + var processor = ResultProcessor.RedisGeoPosition; + var result = Execute(resp, processor); + + Assert.Null(result); + } + + [Fact] + public void GeoPosition_NullArray_ReturnsNull() + { + var resp = "*-1\r\n"; + var processor = ResultProcessor.RedisGeoPosition; + var result = Execute(resp, processor); + + Assert.Null(result); + } + + [Fact] + public void GeoPosition_IntegerCoordinates_ReturnsGeoPosition() + { + var resp = "*1\r\n*2\r\n:13\r\n:38\r\n"; + var processor = ResultProcessor.RedisGeoPosition; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(13.0, result.Value.Longitude); + Assert.Equal(38.0, result.Value.Latitude); + } + + [Fact] + public void GeoPositionArray_MultiplePositions_ReturnsArray() + { + var resp = "*3\r\n" + + "*2\r\n$18\r\n13.361389338970184\r\n$16\r\n38.1155563954963\r\n" + + "*2\r\n$18\r\n15.087267458438873\r\n$17\r\n37.50266842333162\r\n" + + "$-1\r\n"; + var processor = ResultProcessor.RedisGeoPositionArray; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(3, result.Length); + + Assert.NotNull(result[0]); + Assert.Equal(13.361389338970184, result[0]!.Value.Longitude, 10); + Assert.Equal(38.1155563954963, result[0]!.Value.Latitude, 10); + + Assert.NotNull(result[1]); + Assert.Equal(15.087267458438873, result[1]!.Value.Longitude, 10); + Assert.Equal(37.50266842333162, result[1]!.Value.Latitude, 10); + + Assert.Null(result[2]); + } + + [Fact] + public void GeoPositionArray_EmptyArray_ReturnsEmptyArray() + { + var resp = "*0\r\n"; + var processor = ResultProcessor.RedisGeoPositionArray; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Empty(result); + } + + [Fact] + public void GeoPositionArray_NullArray_ReturnsNull() + { + var resp = "*-1\r\n"; + var processor = ResultProcessor.RedisGeoPositionArray; + var result = Execute(resp, processor); + + Assert.Null(result); + } + + [Fact] + public void GeoPositionArray_AllNulls_ReturnsArrayOfNulls() + { + var resp = "*2\r\n$-1\r\n$-1\r\n"; + var processor = ResultProcessor.RedisGeoPositionArray; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + Assert.Null(result[0]); + Assert.Null(result[1]); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/GeoRadius.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/GeoRadius.cs new file mode 100644 index 000000000..049f8013e --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/GeoRadius.cs @@ -0,0 +1,141 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class GeoRadius(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void GeoRadius_None_ReturnsJustMembers() + { + // Without any WITH option: just member names as scalars in array + var resp = "*2\r\n$7\r\nPalermo\r\n$7\r\nCatania\r\n"; + var result = Execute(resp, ResultProcessor.GeoRadiusArray(GeoRadiusOptions.None)); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + Assert.Equal("Palermo", result[0].Member); + Assert.Null(result[0].Distance); + Assert.Null(result[0].Hash); + Assert.Null(result[0].Position); + Assert.Equal("Catania", result[1].Member); + Assert.Null(result[1].Distance); + Assert.Null(result[1].Hash); + Assert.Null(result[1].Position); + } + + [Fact] + public void GeoRadius_WithDistance_ReturnsDistances() + { + // With WITHDIST: each element is [member, distance] + var resp = "*2\r\n" + + "*2\r\n$7\r\nPalermo\r\n$8\r\n190.4424\r\n" + + "*2\r\n$7\r\nCatania\r\n$7\r\n56.4413\r\n"; + var result = Execute(resp, ResultProcessor.GeoRadiusArray(GeoRadiusOptions.WithDistance)); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + Assert.Equal("Palermo", result[0].Member); + Assert.Equal(190.4424, result[0].Distance); + Assert.Null(result[0].Hash); + Assert.Null(result[0].Position); + Assert.Equal("Catania", result[1].Member); + Assert.Equal(56.4413, result[1].Distance); + Assert.Null(result[1].Hash); + Assert.Null(result[1].Position); + } + + [Fact] + public void GeoRadius_WithCoordinates_ReturnsPositions() + { + // With WITHCOORD: each element is [member, [longitude, latitude]] + var resp = "*2\r\n" + + "*2\r\n$7\r\nPalermo\r\n*2\r\n$18\r\n13.361389338970184\r\n$16\r\n38.1155563954963\r\n" + + "*2\r\n$7\r\nCatania\r\n*2\r\n$18\r\n15.087267458438873\r\n$17\r\n37.50266842333162\r\n"; + var result = Execute(resp, ResultProcessor.GeoRadiusArray(GeoRadiusOptions.WithCoordinates)); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + Assert.Equal("Palermo", result[0].Member); + Assert.Null(result[0].Distance); + Assert.Null(result[0].Hash); + Assert.NotNull(result[0].Position); + Assert.Equal(13.361389338970184, result[0].Position!.Value.Longitude); + Assert.Equal(38.1155563954963, result[0].Position!.Value.Latitude); + Assert.Equal("Catania", result[1].Member); + Assert.Null(result[1].Distance); + Assert.Null(result[1].Hash); + Assert.NotNull(result[1].Position); + Assert.Equal(15.087267458438873, result[1].Position!.Value.Longitude); + Assert.Equal(37.50266842333162, result[1].Position!.Value.Latitude); + } + + [Fact] + public void GeoRadius_WithDistanceAndCoordinates_ReturnsBoth() + { + // With WITHDIST WITHCOORD: each element is [member, distance, [longitude, latitude]] + var resp = "*2\r\n" + + "*3\r\n$7\r\nPalermo\r\n$8\r\n190.4424\r\n*2\r\n$18\r\n13.361389338970184\r\n$16\r\n38.1155563954963\r\n" + + "*3\r\n$7\r\nCatania\r\n$7\r\n56.4413\r\n*2\r\n$18\r\n15.087267458438873\r\n$17\r\n37.50266842333162\r\n"; + var result = Execute(resp, ResultProcessor.GeoRadiusArray(GeoRadiusOptions.WithDistance | GeoRadiusOptions.WithCoordinates)); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + Assert.Equal("Palermo", result[0].Member); + Assert.Equal(190.4424, result[0].Distance); + Assert.Null(result[0].Hash); + Assert.NotNull(result[0].Position); + Assert.Equal(13.361389338970184, result[0].Position!.Value.Longitude); + Assert.Equal(38.1155563954963, result[0].Position!.Value.Latitude); + } + + [Fact] + public void GeoRadius_WithHash_ReturnsHash() + { + // With WITHHASH: each element is [member, hash] + var resp = "*2\r\n" + + "*2\r\n$7\r\nPalermo\r\n:3479099956230698\r\n" + + "*2\r\n$7\r\nCatania\r\n:3479447370796909\r\n"; + var result = Execute(resp, ResultProcessor.GeoRadiusArray(GeoRadiusOptions.WithGeoHash)); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + Assert.Equal("Palermo", result[0].Member); + Assert.Null(result[0].Distance); + Assert.Equal(3479099956230698, result[0].Hash); + Assert.Null(result[0].Position); + Assert.Equal("Catania", result[1].Member); + Assert.Null(result[1].Distance); + Assert.Equal(3479447370796909, result[1].Hash); + Assert.Null(result[1].Position); + } + + [Fact] + public void GeoRadius_AllOptions_ReturnsEverything() + { + // With all options: [member, distance, hash, [longitude, latitude]] + var resp = "*1\r\n" + + "*4\r\n$7\r\nPalermo\r\n$8\r\n190.4424\r\n:3479099956230698\r\n*2\r\n$18\r\n13.361389338970184\r\n$16\r\n38.1155563954963\r\n"; + var result = Execute( + resp, + ResultProcessor.GeoRadiusArray(GeoRadiusOptions.WithDistance | GeoRadiusOptions.WithGeoHash | GeoRadiusOptions.WithCoordinates)); + + Assert.NotNull(result); + Assert.Single(result); + Assert.Equal("Palermo", result[0].Member); + Assert.Equal(190.4424, result[0].Distance); + Assert.Equal(3479099956230698, result[0].Hash); + Assert.NotNull(result[0].Position); + Assert.Equal(13.361389338970184, result[0].Position!.Value.Longitude); + Assert.Equal(38.1155563954963, result[0].Position!.Value.Latitude); + } + + [Fact] + public void GeoRadius_EmptyArray_ReturnsEmptyArray() + { + var resp = "*0\r\n"; + var result = Execute(resp, ResultProcessor.GeoRadiusArray(GeoRadiusOptions.None)); + + Assert.NotNull(result); + Assert.Empty(result); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/HotKeys.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/HotKeys.cs new file mode 100644 index 000000000..dc780ae1d --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/HotKeys.cs @@ -0,0 +1,145 @@ +using System; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class HotKeys(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void FullFormat_Success() + { + // HOTKEYS GET - full response with all fields + // Carefully counted byte lengths for each string + var resp = "*1\r\n" + + "*24\r\n" + + "$15\r\ntracking-active\r\n" + + ":0\r\n" + + "$12\r\nsample-ratio\r\n" + + ":1\r\n" + + "$14\r\nselected-slots\r\n" + + "*1\r\n" + + "*2\r\n" + + ":0\r\n" + + ":16383\r\n" + + "$25\r\nall-commands-all-slots-us\r\n" + + ":103\r\n" + + "$32\r\nnet-bytes-all-commands-all-slots\r\n" + + ":2042\r\n" + + "$29\r\ncollection-start-time-unix-ms\r\n" + + ":1770824933147\r\n" + + "$22\r\ncollection-duration-ms\r\n" + + ":0\r\n" + + "$22\r\ntotal-cpu-time-user-ms\r\n" + + ":23\r\n" + + "$21\r\ntotal-cpu-time-sys-ms\r\n" + + ":7\r\n" + + "$15\r\ntotal-net-bytes\r\n" + + ":2038\r\n" + + "$14\r\nby-cpu-time-us\r\n" + + "*10\r\n" + + "$18\r\nhotkey_001_counter\r\n" + + ":29\r\n" + + "$10\r\nhotkey_001\r\n" + + ":25\r\n" + + "$15\r\nhotkey_001_hash\r\n" + + ":11\r\n" + + "$15\r\nhotkey_001_list\r\n" + + ":9\r\n" + + "$14\r\nhotkey_001_set\r\n" + + ":9\r\n" + + "$12\r\nby-net-bytes\r\n" + + "*10\r\n" + + "$10\r\nhotkey_001\r\n" + + ":446\r\n" + + "$10\r\nhotkey_002\r\n" + + ":328\r\n" + + "$15\r\nhotkey_001_hash\r\n" + + ":198\r\n" + + "$14\r\nhotkey_001_set\r\n" + + ":167\r\n" + + "$18\r\nhotkey_001_counter\r\n" + + ":116\r\n"; + + var result = Execute(resp, HotKeysResult.Processor); + + Assert.NotNull(result); + Assert.False(result.TrackingActive); + Assert.Equal(1, result.SampleRatio); + Assert.Equal(103, result.AllCommandsAllSlotsMicroseconds); + Assert.Equal(2042, result.AllCommandsAllSlotsNetworkBytes); + Assert.Equal(1770824933147, result.CollectionStartTimeUnixMilliseconds); + Assert.Equal(0, result.CollectionDurationMicroseconds); + Assert.Equal(23000, result.TotalCpuTimeUserMicroseconds); + Assert.Equal(7000, result.TotalCpuTimeSystemMicroseconds); + Assert.Equal(2038, result.TotalNetworkBytes); + + // Validate TimeSpan properties + // 103 microseconds = 0.103 milliseconds + Assert.Equal(0.103, result.AllCommandsAllSlotsTime.TotalMilliseconds, precision: 10); + Assert.Equal(TimeSpan.Zero, result.CollectionDuration); + // 23000 microseconds = 23 milliseconds + Assert.Equal(23.0, result.TotalCpuTimeUser!.Value.TotalMilliseconds, precision: 10); + // 7000 microseconds = 7 milliseconds + Assert.Equal(7.0, result.TotalCpuTimeSystem!.Value.TotalMilliseconds, precision: 10); + // 30000 microseconds = 30 milliseconds + Assert.Equal(30.0, result.TotalCpuTime!.Value.TotalMilliseconds, precision: 10); + + // Validate by-cpu-time-us array + Assert.Equal(5, result.CpuByKey.Length); + Assert.Equal("hotkey_001_counter", (string?)result.CpuByKey[0].Key); + Assert.Equal(29, result.CpuByKey[0].DurationMicroseconds); + Assert.Equal("hotkey_001", (string?)result.CpuByKey[1].Key); + Assert.Equal(25, result.CpuByKey[1].DurationMicroseconds); + Assert.Equal("hotkey_001_hash", (string?)result.CpuByKey[2].Key); + Assert.Equal(11, result.CpuByKey[2].DurationMicroseconds); + Assert.Equal("hotkey_001_list", (string?)result.CpuByKey[3].Key); + Assert.Equal(9, result.CpuByKey[3].DurationMicroseconds); + Assert.Equal("hotkey_001_set", (string?)result.CpuByKey[4].Key); + Assert.Equal(9, result.CpuByKey[4].DurationMicroseconds); + + // Validate by-net-bytes array + Assert.Equal(5, result.NetworkBytesByKey.Length); + Assert.Equal("hotkey_001", (string?)result.NetworkBytesByKey[0].Key); + Assert.Equal(446, result.NetworkBytesByKey[0].Bytes); + Assert.Equal("hotkey_002", (string?)result.NetworkBytesByKey[1].Key); + Assert.Equal(328, result.NetworkBytesByKey[1].Bytes); + Assert.Equal("hotkey_001_hash", (string?)result.NetworkBytesByKey[2].Key); + Assert.Equal(198, result.NetworkBytesByKey[2].Bytes); + Assert.Equal("hotkey_001_set", (string?)result.NetworkBytesByKey[3].Key); + Assert.Equal(167, result.NetworkBytesByKey[3].Bytes); + Assert.Equal("hotkey_001_counter", (string?)result.NetworkBytesByKey[4].Key); + Assert.Equal(116, result.NetworkBytesByKey[4].Bytes); + } + + [Fact] + public void MinimalFormat_Success() + { + // Minimal HOTKEYS response with just tracking-active + var resp = "*1\r\n" + + "*2\r\n" + + "$15\r\ntracking-active\r\n" + + ":1\r\n"; + + var result = Execute(resp, HotKeysResult.Processor); + + Assert.NotNull(result); + Assert.True(result.TrackingActive); + } + + [Fact] + public void NotArray_Failure() + { + var resp = "$5\r\nhello\r\n"; + + ExecuteUnexpected(resp, HotKeysResult.Processor); + } + + [Fact] + public void Null_Success() + { + var resp = "$-1\r\n"; + + var result = Execute(resp, HotKeysResult.Processor); + Assert.Null(result); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Info.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Info.cs new file mode 100644 index 000000000..82c01c458 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Info.cs @@ -0,0 +1,80 @@ +using System.Linq; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class Info(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void SingleSection_Success() + { + var resp = "$651\r\n# Server\r\nredis_version:8.6.0\r\nredis_git_sha1:00000000\r\nredis_git_dirty:1\r\nredis_build_id:a7d515010e105f80\r\nredis_mode:standalone\r\nos:Linux 6.17.0-14-generic x86_64\r\narch_bits:64\r\nmonotonic_clock:POSIX clock_gettime\r\nmultiplexing_api:epoll\r\natomicvar_api:c11-builtin\r\ngcc_version:14.2.0\r\nprocess_id:16\r\nprocess_supervised:no\r\nrun_id:b5ab1b382ec845e0a6989e550f36c187fdef3bc0\r\ntcp_port:3000\r\nserver_time_usec:1771514460547930\r\nuptime_in_seconds:13\r\nuptime_in_days:0\r\nhz:10\r\nconfigured_hz:10\r\nlru_clock:9906780\r\nexecutable:/data/redis-server\r\nconfig_file:/redis/work/node-0/redis.conf\r\nio_threads_active:0\r\nlistener0:name=tcp,bind=*,bind=-::*,port=3000\r\n\r\n"; + + var result = Execute(resp, ResultProcessor.Info); + + Assert.NotNull(result); + Assert.Single(result); + + var serverSection = result.Single(g => g.Key == "Server"); + Assert.Equal(25, serverSection.Count()); + + var versionPair = serverSection.First(kv => kv.Key == "redis_version"); + Assert.Equal("8.6.0", versionPair.Value); + + var portPair = serverSection.First(kv => kv.Key == "tcp_port"); + Assert.Equal("3000", portPair.Value); + } + + [Fact] + public void MultipleSection_Success() + { + var resp = "$978\r\n# Server\r\nredis_version:8.6.0\r\nredis_git_sha1:00000000\r\nredis_git_dirty:1\r\nredis_build_id:a7d515010e105f80\r\nredis_mode:standalone\r\nos:Linux 6.17.0-14-generic x86_64\r\narch_bits:64\r\nmonotonic_clock:POSIX clock_gettime\r\nmultiplexing_api:epoll\r\natomicvar_api:c11-builtin\r\ngcc_version:14.2.0\r\nprocess_id:16\r\nprocess_supervised:no\r\nrun_id:b5ab1b382ec845e0a6989e550f36c187fdef3bc0\r\ntcp_port:3000\r\nserver_time_usec:1771514577242937\r\nuptime_in_seconds:130\r\nuptime_in_days:0\r\nhz:10\r\nconfigured_hz:10\r\nlru_clock:9906897\r\nexecutable:/data/redis-server\r\nconfig_file:/redis/work/node-0/redis.conf\r\nio_threads_active:0\r\nlistener0:name=tcp,bind=*,bind=-::*,port=3000\r\n\r\n# Clients\r\nconnected_clients:1\r\ncluster_connections:0\r\nmaxclients:10000\r\nclient_recent_max_input_buffer:0\r\nclient_recent_max_output_buffer:0\r\nblocked_clients:0\r\ntracking_clients:0\r\npubsub_clients:0\r\nwatching_clients:0\r\nclients_in_timeout_table:0\r\ntotal_watched_keys:0\r\ntotal_blocking_keys:0\r\ntotal_blocking_keys_on_nokey:0\r\n\r\n"; + + var result = Execute(resp, ResultProcessor.Info); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + + var serverSection = result.Single(g => g.Key == "Server"); + Assert.Equal(25, serverSection.Count()); + + var clientsSection = result.Single(g => g.Key == "Clients"); + Assert.Equal(13, clientsSection.Count()); + + var connectedClients = clientsSection.First(kv => kv.Key == "connected_clients"); + Assert.Equal("1", connectedClients.Value); + } + + [Fact] + public void EmptyString_Success() + { + var resp = "$0\r\n\r\n"; + var result = Execute(resp, ResultProcessor.Info); + + Assert.NotNull(result); + Assert.Empty(result); + } + + [Fact] + public void NullBulkString_Success() + { + var resp = "$-1\r\n"; + var result = Execute(resp, ResultProcessor.Info); + + Assert.NotNull(result); + Assert.Empty(result); + } + + [Fact] + public void NoSectionHeader_UsesDefaultCategory() + { + var resp = "$26\r\nkey1:value1\r\nkey2:value2\r\n\r\n"; + var result = Execute(resp, ResultProcessor.Info); + + Assert.NotNull(result); + Assert.Single(result); + + var miscSection = result.Single(g => g.Key == "miscellaneous"); + Assert.Equal(2, miscSection.Count()); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/InterleavedPairs.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/InterleavedPairs.cs new file mode 100644 index 000000000..5053f5489 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/InterleavedPairs.cs @@ -0,0 +1,200 @@ +using System.Linq; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Tests for ValuePairInterleavedProcessorBase and its derived processors. +/// These processors handle both interleaved (RESP2) and jagged (RESP3) formats. +/// +public class InterleavedPairs(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + // HashEntryArrayProcessor tests + [Theory] + // RESP2 interleaved format: [key, value, key, value, ...] + [InlineData("*4\r\n$3\r\nkey\r\n$5\r\nvalue\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n", "key=value,key2=value2")] + [InlineData("*2\r\n$1\r\na\r\n$1\r\nb\r\n", "a=b")] + [InlineData("*0\r\n", "")] + [InlineData("*-1\r\n", null)] + // RESP3 map format (alternative aggregate type, still linear): %{key: value, key2: value2} + [InlineData("%2\r\n$3\r\nkey\r\n$5\r\nvalue\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n", "key=value,key2=value2", RedisProtocol.Resp3)] + [InlineData("%1\r\n$1\r\na\r\n$1\r\nb\r\n", "a=b", RedisProtocol.Resp3)] + [InlineData("%0\r\n", "", RedisProtocol.Resp3)] + [InlineData("_\r\n", null, RedisProtocol.Resp3)] + // Jagged format (RESP3): [[key, value], [key, value], ...] - array of 2-element arrays + [InlineData("*2\r\n*2\r\n$3\r\nkey\r\n$5\r\nvalue\r\n*2\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n", "key=value,key2=value2", RedisProtocol.Resp3)] + [InlineData("*1\r\n*2\r\n$1\r\na\r\n$1\r\nb\r\n", "a=b", RedisProtocol.Resp3)] + [InlineData("*0\r\n", "", RedisProtocol.Resp3)] + // RESP3 with attributes + [InlineData(ATTRIB_FOO_BAR + "*4\r\n$3\r\nkey\r\n$5\r\nvalue\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n", "key=value,key2=value2")] + public void HashEntryArray(string resp, string? expected, RedisProtocol protocol = RedisProtocol.Resp2) + { + var result = Execute(resp, ResultProcessor.HashEntryArray, protocol: protocol); + if (expected == null) + { + Assert.Null(result); + } + else + { + Assert.NotNull(result); + var formatted = string.Join(",", System.Linq.Enumerable.Select(result, e => $"{e.Name}={e.Value}")); + Assert.Equal(expected, formatted); + } + } + + // SortedSetEntryArrayProcessor tests + [Theory] + // RESP2 interleaved format: [element, score, element, score, ...] + [InlineData("*4\r\n$3\r\nfoo\r\n,1.5\r\n$3\r\nbar\r\n,2.5\r\n", "foo:1.5,bar:2.5")] + [InlineData("*2\r\n$1\r\na\r\n,1.0\r\n", "a:1")] + [InlineData("*0\r\n", "")] + [InlineData("*-1\r\n", null)] + // RESP3 map format (alternative aggregate type, still linear): %{element: score, element2: score2} + [InlineData("%2\r\n$3\r\nfoo\r\n,1.5\r\n$3\r\nbar\r\n,2.5\r\n", "foo:1.5,bar:2.5", RedisProtocol.Resp3)] + [InlineData("%1\r\n$1\r\na\r\n,1.0\r\n", "a:1", RedisProtocol.Resp3)] + [InlineData("%0\r\n", "", RedisProtocol.Resp3)] + [InlineData("_\r\n", null, RedisProtocol.Resp3)] + // Jagged format (RESP3): [[element, score], [element, score], ...] - array of 2-element arrays + [InlineData("*2\r\n*2\r\n$3\r\nfoo\r\n,1.5\r\n*2\r\n$3\r\nbar\r\n,2.5\r\n", "foo:1.5,bar:2.5", RedisProtocol.Resp3)] + [InlineData("*1\r\n*2\r\n$1\r\na\r\n,1.0\r\n", "a:1", RedisProtocol.Resp3)] + [InlineData("*0\r\n", "", RedisProtocol.Resp3)] + // RESP3 with attributes + [InlineData(ATTRIB_FOO_BAR + "*4\r\n$3\r\nfoo\r\n,1.5\r\n$3\r\nbar\r\n,2.5\r\n", "foo:1.5,bar:2.5")] + public void SortedSetEntryArray(string resp, string? expected, RedisProtocol protocol = RedisProtocol.Resp2) + { + var result = Execute(resp, ResultProcessor.SortedSetWithScores, protocol: protocol); + if (expected == null) + { + Assert.Null(result); + } + else + { + Assert.NotNull(result); + var formatted = string.Join(",", System.Linq.Enumerable.Select(result, e => $"{e.Element}:{e.Score}")); + Assert.Equal(expected, formatted); + } + } + + // StreamNameValueEntryProcessor tests + [Theory] + // RESP2 interleaved format: [name, value, name, value, ...] + [InlineData("*4\r\n$4\r\nname\r\n$5\r\nvalue\r\n$5\r\nname2\r\n$6\r\nvalue2\r\n", "name=value,name2=value2")] + [InlineData("*2\r\n$1\r\na\r\n$1\r\nb\r\n", "a=b")] + [InlineData("*0\r\n", "")] + [InlineData("*-1\r\n", null)] + // RESP3 map format (alternative aggregate type, still linear): %{name: value, name2: value2} + [InlineData("%2\r\n$4\r\nname\r\n$5\r\nvalue\r\n$5\r\nname2\r\n$6\r\nvalue2\r\n", "name=value,name2=value2", RedisProtocol.Resp3)] + [InlineData("%1\r\n$1\r\na\r\n$1\r\nb\r\n", "a=b", RedisProtocol.Resp3)] + [InlineData("%0\r\n", "", RedisProtocol.Resp3)] + [InlineData("_\r\n", null, RedisProtocol.Resp3)] + // Jagged format (RESP3): [[name, value], [name, value], ...] - array of 2-element arrays + [InlineData("*2\r\n*2\r\n$4\r\nname\r\n$5\r\nvalue\r\n*2\r\n$5\r\nname2\r\n$6\r\nvalue2\r\n", "name=value,name2=value2", RedisProtocol.Resp3)] + [InlineData("*1\r\n*2\r\n$1\r\na\r\n$1\r\nb\r\n", "a=b", RedisProtocol.Resp3)] + [InlineData("*0\r\n", "", RedisProtocol.Resp3)] + // RESP3 with attributes + [InlineData(ATTRIB_FOO_BAR + "*4\r\n$4\r\nname\r\n$5\r\nvalue\r\n$5\r\nname2\r\n$6\r\nvalue2\r\n", "name=value,name2=value2")] + public void StreamNameValueEntry(string resp, string? expected, RedisProtocol protocol = RedisProtocol.Resp2) + { + var result = Execute(resp, ResultProcessor.StreamNameValueEntryProcessor.Instance, protocol: protocol); + if (expected == null) + { + Assert.Null(result); + } + else + { + Assert.NotNull(result); + var formatted = string.Join(",", System.Linq.Enumerable.Select(result, e => $"{e.Name}={e.Value}")); + Assert.Equal(expected, formatted); + } + } + + // StringPairInterleavedProcessor tests + [Theory] + // RESP2 interleaved format: [key, value, key, value, ...] + [InlineData("*4\r\n$3\r\nkey\r\n$5\r\nvalue\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n", "key=value,key2=value2")] + [InlineData("*2\r\n$1\r\na\r\n$1\r\nb\r\n", "a=b")] + [InlineData("*0\r\n", "")] + [InlineData("*-1\r\n", null)] + // RESP3 map format (alternative aggregate type, still linear): %{key: value, key2: value2} + [InlineData("%2\r\n$3\r\nkey\r\n$5\r\nvalue\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n", "key=value,key2=value2", RedisProtocol.Resp3)] + [InlineData("%1\r\n$1\r\na\r\n$1\r\nb\r\n", "a=b", RedisProtocol.Resp3)] + [InlineData("%0\r\n", "", RedisProtocol.Resp3)] + [InlineData("_\r\n", null, RedisProtocol.Resp3)] + // Jagged format (RESP3): [[key, value], [key, value], ...] - array of 2-element arrays + [InlineData("*2\r\n*2\r\n$3\r\nkey\r\n$5\r\nvalue\r\n*2\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n", "key=value,key2=value2", RedisProtocol.Resp3)] + [InlineData("*1\r\n*2\r\n$1\r\na\r\n$1\r\nb\r\n", "a=b", RedisProtocol.Resp3)] + [InlineData("*0\r\n", "", RedisProtocol.Resp3)] + // RESP3 with attributes + [InlineData(ATTRIB_FOO_BAR + "*4\r\n$3\r\nkey\r\n$5\r\nvalue\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n", "key=value,key2=value2")] + public void StringPairInterleaved(string resp, string? expected, RedisProtocol protocol = RedisProtocol.Resp2) + { + var result = Execute(resp, ResultProcessor.StringPairInterleaved, protocol: protocol); + if (expected == null) + { + Assert.Null(result); + } + else + { + Assert.NotNull(result); + var formatted = string.Join(",", System.Linq.Enumerable.Select(result, kvp => $"{kvp.Key}={kvp.Value}")); + Assert.Equal(expected, formatted); + } + } + + // Failing tests - non-array inputs + [Theory] + [InlineData(":42\r\n")] + [InlineData("$3\r\nfoo\r\n")] + [InlineData("+OK\r\n")] + public void FailingHashEntryArray(string resp) => ExecuteUnexpected(resp, ResultProcessor.HashEntryArray); + + [Theory] + [InlineData(":42\r\n")] + [InlineData("$3\r\nfoo\r\n")] + [InlineData("+OK\r\n")] + public void FailingSortedSetEntryArray(string resp) => ExecuteUnexpected(resp, ResultProcessor.SortedSetWithScores); + + // Malformed jagged arrays (inner arrays not exactly length 2) + // Uniform odd counts: IsAllJaggedPairsReader returns false, falls back to interleaved, processes even pairs (discards odd element) + // Mixed lengths: IsAllJaggedPairsReader returns false, falls back to interleaved, throws when trying to read arrays as scalars + + // HashEntry tests that succeed with malformed data (uniform odd counts - not detected as jagged, processes as interleaved) + [Theory] + [InlineData("*1\r\n*1\r\n$1\r\na\r\n", RedisProtocol.Resp3)] // Inner array has 1 element - uniform, processes 0 pairs (1 >> 1 = 0) + [InlineData("*1\r\n*3\r\n$1\r\na\r\n$1\r\nb\r\n$1\r\nc\r\n", RedisProtocol.Resp3)] // Inner array has 3 elements - uniform, processes 1 pair (3 >> 1 = 1), discards 'c' + public void HashEntryArrayMalformedJaggedSucceeds(string resp, RedisProtocol protocol) + { + var result = Execute(resp, ResultProcessor.HashEntryArray, protocol: protocol); + Log($"Malformed jagged (uniform) result: {(result == null ? "null" : string.Join(",", result.Select(static e => $"{e.Name}={e.Value}")))}"); + } + + // HashEntry tests that throw (mixed lengths - fallback to interleaved tries to read arrays as scalars) + [Theory] + [InlineData("*2\r\n*2\r\n$1\r\na\r\n$1\r\nb\r\n*1\r\n$1\r\nc\r\n", RedisProtocol.Resp3)] // Mixed: first has 2, second has 1 + [InlineData("*2\r\n*2\r\n$1\r\na\r\n$1\r\nb\r\n*3\r\n$1\r\nc\r\n$1\r\nd\r\n$1\r\ne\r\n", RedisProtocol.Resp3)] // Mixed: first has 2, second has 3 + public void HashEntryArrayMalformedJaggedThrows(string resp, RedisProtocol protocol) + { + var ex = Assert.Throws(() => Execute(resp, ResultProcessor.HashEntryArray, protocol: protocol)); + Log($"Malformed jagged threw: {ex.GetType().Name}: {ex.Message}"); + } + + // SortedSetEntry tests that succeed with malformed data (uniform odd counts - not detected as jagged, processes as interleaved) + [Theory] + [InlineData("*1\r\n*1\r\n$1\r\na\r\n", RedisProtocol.Resp3)] // Inner array has 1 element - uniform, processes 0 pairs (1 >> 1 = 0) + [InlineData("*1\r\n*3\r\n$1\r\na\r\n,1.0\r\n$1\r\nb\r\n", RedisProtocol.Resp3)] // Inner array has 3 elements - uniform, processes 1 pair (3 >> 1 = 1), discards 'b' + public void SortedSetEntryArrayMalformedJaggedSucceeds(string resp, RedisProtocol protocol) + { + var result = Execute(resp, ResultProcessor.SortedSetWithScores, protocol: protocol); + Log($"Malformed jagged (uniform) result: {(result == null ? "null" : string.Join(",", result.Select(static e => $"{e.Element}:{e.Score}")))}"); + } + + // SortedSetEntry tests that throw (mixed lengths - fallback to interleaved tries to read arrays as scalars) + [Theory] + [InlineData("*2\r\n*2\r\n$1\r\na\r\n,1.0\r\n*1\r\n$1\r\nb\r\n", RedisProtocol.Resp3)] // Mixed: first has 2, second has 1 + [InlineData("*2\r\n*2\r\n$1\r\na\r\n,1.0\r\n*3\r\n$1\r\nb\r\n,2.0\r\n$1\r\nc\r\n", RedisProtocol.Resp3)] // Mixed: first has 2, second has 3 + public void SortedSetEntryArrayMalformedJaggedThrows(string resp, RedisProtocol protocol) + { + var ex = Assert.Throws(() => Execute(resp, ResultProcessor.SortedSetWithScores, protocol: protocol)); + Log($"Malformed jagged threw: {ex.GetType().Name}: {ex.Message}"); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Latency.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Latency.cs new file mode 100644 index 000000000..724e44417 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Latency.cs @@ -0,0 +1,96 @@ +using System; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Tests for Latency result processors. +/// +public class Latency(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData("*0\r\n", 0)] // empty array + [InlineData("*1\r\n*4\r\n$7\r\ncommand\r\n:1405067976\r\n:251\r\n:1001\r\n", 1)] // single entry + [InlineData("*2\r\n*4\r\n$7\r\ncommand\r\n:1405067976\r\n:251\r\n:1001\r\n*4\r\n$4\r\nfast\r\n:1405067980\r\n:100\r\n:500\r\n", 2)] // two entries + public void LatencyLatestEntry_ValidInput(string resp, int expectedCount) + { + var processor = LatencyLatestEntry.ToArray; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(expectedCount, result.Length); + } + + [Fact] + public void LatencyLatestEntry_ValidatesContent() + { + // Single entry: ["command", 1405067976, 251, 1001] + var resp = "*1\r\n*4\r\n$7\r\ncommand\r\n:1405067976\r\n:251\r\n:1001\r\n"; + var processor = LatencyLatestEntry.ToArray; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Single(result); + + var entry = result[0]; + Assert.Equal("command", entry.EventName); + Assert.Equal(RedisBase.UnixEpoch.AddSeconds(1405067976), entry.Timestamp); + Assert.Equal(251, entry.DurationMilliseconds); + Assert.Equal(1001, entry.MaxDurationMilliseconds); + } + + [Theory] + [InlineData("*-1\r\n")] // null array (RESP2) + [InlineData("_\r\n")] // null (RESP3) + public void LatencyLatestEntry_NullArray(string resp) + { + var processor = LatencyLatestEntry.ToArray; + var result = Execute(resp, processor); + + Assert.Null(result); + } + + [Theory] + [InlineData("*0\r\n", 0)] // empty array + [InlineData("*1\r\n*2\r\n:1405067822\r\n:251\r\n", 1)] // single entry + [InlineData("*2\r\n*2\r\n:1405067822\r\n:251\r\n*2\r\n:1405067941\r\n:1001\r\n", 2)] // two entries (from redis-cli example) + public void LatencyHistoryEntry_ValidInput(string resp, int expectedCount) + { + var processor = LatencyHistoryEntry.ToArray; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(expectedCount, result.Length); + } + + [Fact] + public void LatencyHistoryEntry_ValidatesContent() + { + // Two entries from redis-cli example + var resp = "*2\r\n*2\r\n:1405067822\r\n:251\r\n*2\r\n:1405067941\r\n:1001\r\n"; + var processor = LatencyHistoryEntry.ToArray; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + + var entry1 = result[0]; + Assert.Equal(RedisBase.UnixEpoch.AddSeconds(1405067822), entry1.Timestamp); + Assert.Equal(251, entry1.DurationMilliseconds); + + var entry2 = result[1]; + Assert.Equal(RedisBase.UnixEpoch.AddSeconds(1405067941), entry2.Timestamp); + Assert.Equal(1001, entry2.DurationMilliseconds); + } + + [Theory] + [InlineData("*-1\r\n")] // null array (RESP2) + [InlineData("_\r\n")] // null (RESP3) + public void LatencyHistoryEntry_NullArray(string resp) + { + var processor = LatencyHistoryEntry.ToArray; + var result = Execute(resp, processor); + + Assert.Null(result); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Lease.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Lease.cs new file mode 100644 index 000000000..356d583e9 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Lease.cs @@ -0,0 +1,100 @@ +using System; +using System.Text; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Tests for Lease result processors. +/// +public class Lease(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData("*0\r\n", 0)] // empty array + [InlineData("*3\r\n,1.5\r\n,2.5\r\n,3.5\r\n", 3)] // 3 floats + [InlineData("*2\r\n:1\r\n:2\r\n", 2)] // integers converted to floats + [InlineData("*1\r\n$3\r\n1.5\r\n", 1)] // bulk string converted to float + [InlineData("*?\r\n,1.5\r\n,2.5\r\n,3.5\r\n.\r\n", 3)] // streaming aggregate with 3 floats + [InlineData("*?\r\n.\r\n", 0)] // streaming empty array + public void LeaseFloat32Processor_ValidInput(string resp, int expectedCount) + { + var processor = ResultProcessor.LeaseFloat32; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(expectedCount, result.Length); + } + + [Fact] + public void LeaseFloat32Processor_ValidatesContent() + { + // Array of 3 floats: 1.5, 2.5, 3.5 + var resp = "*3\r\n,1.5\r\n,2.5\r\n,3.5\r\n"; + var processor = ResultProcessor.LeaseFloat32; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(3, result.Length); + Assert.Equal(1.5f, result.Span[0]); + Assert.Equal(2.5f, result.Span[1]); + Assert.Equal(3.5f, result.Span[2]); + } + + [Theory] + [InlineData("*-1\r\n")] // null array (RESP2) + [InlineData("_\r\n")] // null (RESP3) + public void LeaseFloat32Processor_NullArray(string resp) + { + var processor = ResultProcessor.LeaseFloat32; + var result = Execute(resp, processor); + + Assert.Null(result); + } + + [Theory] + [InlineData("$5\r\nhello\r\n")] // scalar string (not an array) + [InlineData(":42\r\n")] // scalar integer (not an array) + public void LeaseFloat32Processor_InvalidInput(string resp) + { + var processor = ResultProcessor.LeaseFloat32; + ExecuteUnexpected(resp, processor); + } + + [Theory] + [InlineData("$5\r\nhello\r\n", "hello")] // bulk string + [InlineData("+world\r\n", "world")] // simple string + [InlineData(":42\r\n", "42")] // integer + public void LeaseProcessor_ValidInput(string resp, string expected) + { + var processor = ResultProcessor.Lease; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + + var str = Encoding.UTF8.GetString(result.Span); + Assert.Equal(expected, str); + } + + [Theory] + [InlineData("*1\r\n$5\r\nhello\r\n", "hello")] // array of 1 bulk string + [InlineData("*1\r\n+world\r\n", "world")] // array of 1 simple string + public void LeaseFromArrayProcessor_ValidInput(string resp, string expected) + { + var processor = ResultProcessor.LeaseFromArray; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + + var str = Encoding.UTF8.GetString(result.Span); + Assert.Equal(expected, str); + } + + [Theory] + [InlineData("*0\r\n")] // empty array + [InlineData("*2\r\n$5\r\nhello\r\n$5\r\nworld\r\n")] // array of 2 (not 1) + public void LeaseFromArrayProcessor_InvalidInput(string resp) + { + var processor = ResultProcessor.LeaseFromArray; + ExecuteUnexpected(resp, processor); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/LeaseRedisValue.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/LeaseRedisValue.cs new file mode 100644 index 000000000..329d8890e --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/LeaseRedisValue.cs @@ -0,0 +1,89 @@ +using System; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Tests for LeaseRedisValue result processor. +/// +public class LeaseRedisValue(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData("*0\r\n", 0)] // empty array (key doesn't exist) + [InlineData("*1\r\n$5\r\nhello\r\n", 1)] // array with 1 element + [InlineData("*3\r\n$3\r\naaa\r\n$3\r\nbbb\r\n$3\r\nccc\r\n", 3)] // array with 3 elements in lexicographical order + [InlineData("*2\r\n$4\r\ntest\r\n$5\r\nvalue\r\n", 2)] // array with 2 elements + [InlineData("*?\r\n$5\r\nhello\r\n$5\r\nworld\r\n.\r\n", 2)] // streaming aggregate with 2 elements + [InlineData("*?\r\n.\r\n", 0)] // streaming empty array + public void LeaseRedisValueProcessor_ValidInput(string resp, int expectedCount) + { + var processor = ResultProcessor.LeaseRedisValue; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(expectedCount, result.Length); + } + + [Fact] + public void LeaseRedisValueProcessor_ValidatesContent() + { + // Array of 3 RedisValues: "aaa", "bbb", "ccc" + var resp = "*3\r\n$3\r\naaa\r\n$3\r\nbbb\r\n$3\r\nccc\r\n"; + var processor = ResultProcessor.LeaseRedisValue; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(3, result.Length); + Assert.Equal("aaa", result.Span[0].ToString()); + Assert.Equal("bbb", result.Span[1].ToString()); + Assert.Equal("ccc", result.Span[2].ToString()); + } + + [Fact] + public void LeaseRedisValueProcessor_EmptyArray() + { + // Empty array (key doesn't exist) + var resp = "*0\r\n"; + var processor = ResultProcessor.LeaseRedisValue; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(0, result.Length); + } + + [Theory] + [InlineData("*-1\r\n")] // null array (RESP2) + [InlineData("_\r\n")] // null (RESP3) + public void LeaseRedisValueProcessor_NullArray(string resp) + { + var processor = ResultProcessor.LeaseRedisValue; + var result = Execute(resp, processor); + + Assert.Null(result); + } + + [Theory] + [InlineData("$5\r\nhello\r\n")] // scalar string (not an array) + [InlineData(":42\r\n")] // scalar integer (not an array) + [InlineData("+OK\r\n")] // simple string (not an array) + public void LeaseRedisValueProcessor_InvalidInput(string resp) + { + var processor = ResultProcessor.LeaseRedisValue; + ExecuteUnexpected(resp, processor); + } + + [Fact] + public void LeaseRedisValueProcessor_MixedTypes() + { + // Array with mixed types: bulk string, simple string, integer + var resp = "*3\r\n$5\r\nhello\r\n+world\r\n:42\r\n"; + var processor = ResultProcessor.LeaseRedisValue; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(3, result.Length); + Assert.Equal("hello", result.Span[0].ToString()); + Assert.Equal("world", result.Span[1].ToString()); + Assert.Equal("42", result.Span[2].ToString()); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/LongestCommonSubsequence.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/LongestCommonSubsequence.cs new file mode 100644 index 000000000..46e7d15aa --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/LongestCommonSubsequence.cs @@ -0,0 +1,105 @@ +using System.Linq; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class LongestCommonSubsequence(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void SingleMatch_Success() + { + // LCS key1 key2 IDX MINMATCHLEN 4 WITHMATCHLEN + // 1) "matches" + // 2) 1) 1) 1) (integer) 4 + // 2) (integer) 7 + // 2) 1) (integer) 5 + // 2) (integer) 8 + // 3) (integer) 4 + // 3) "len" + // 4) (integer) 6 + var resp = "*4\r\n$7\r\nmatches\r\n*1\r\n*3\r\n*2\r\n:4\r\n:7\r\n*2\r\n:5\r\n:8\r\n:4\r\n$3\r\nlen\r\n:6\r\n"; + var result = Execute(resp, ResultProcessor.LCSMatchResult); + + Assert.Equal(6, result.LongestMatchLength); + Assert.Single(result.Matches); + + // Verify backward-compatible properties + Assert.Equal(4, result.Matches[0].FirstStringIndex); + Assert.Equal(5, result.Matches[0].SecondStringIndex); + Assert.Equal(4, result.Matches[0].Length); + + // Verify new Position properties + Assert.Equal(4, result.Matches[0].First.Start); + Assert.Equal(7, result.Matches[0].First.End); + Assert.Equal(5, result.Matches[0].Second.Start); + Assert.Equal(8, result.Matches[0].Second.End); + } + + [Fact] + public void TwoMatches_Success() + { + // LCS key1 key2 IDX MINMATCHLEN 0 WITHMATCHLEN + // 1) "matches" + // 2) 1) 1) 1) (integer) 4 + // 2) (integer) 7 + // 2) 1) (integer) 5 + // 2) (integer) 8 + // 3) (integer) 4 + // 2) 1) 1) (integer) 2 + // 2) (integer) 3 + // 2) 1) (integer) 0 + // 2) (integer) 1 + // 3) (integer) 2 + // 3) "len" + // 4) (integer) 6 + var resp = "*4\r\n$7\r\nmatches\r\n*2\r\n*3\r\n*2\r\n:4\r\n:7\r\n*2\r\n:5\r\n:8\r\n:4\r\n*3\r\n*2\r\n:2\r\n:3\r\n*2\r\n:0\r\n:1\r\n:2\r\n$3\r\nlen\r\n:6\r\n"; + var result = Execute(resp, ResultProcessor.LCSMatchResult); + + Assert.Equal(6, result.LongestMatchLength); + Assert.Equal(2, result.Matches.Length); + + // First match - verify backward-compatible properties + Assert.Equal(4, result.Matches[0].FirstStringIndex); + Assert.Equal(5, result.Matches[0].SecondStringIndex); + Assert.Equal(4, result.Matches[0].Length); + + // First match - verify new Position properties + Assert.Equal(4, result.Matches[0].First.Start); + Assert.Equal(7, result.Matches[0].First.End); + Assert.Equal(5, result.Matches[0].Second.Start); + Assert.Equal(8, result.Matches[0].Second.End); + + // Second match - verify backward-compatible properties + Assert.Equal(2, result.Matches[1].FirstStringIndex); + Assert.Equal(0, result.Matches[1].SecondStringIndex); + Assert.Equal(2, result.Matches[1].Length); + + // Second match - verify new Position properties + Assert.Equal(2, result.Matches[1].First.Start); + Assert.Equal(3, result.Matches[1].First.End); + Assert.Equal(0, result.Matches[1].Second.Start); + Assert.Equal(1, result.Matches[1].Second.End); + } + + [Fact] + public void NoMatches_Success() + { + // LCS key1 key2 IDX + // 1) "matches" + // 2) (empty array) + // 3) "len" + // 4) (integer) 0 + var resp = "*4\r\n$7\r\nmatches\r\n*0\r\n$3\r\nlen\r\n:0\r\n"; + var result = Execute(resp, ResultProcessor.LCSMatchResult); + + Assert.Equal(0, result.LongestMatchLength); + Assert.Empty(result.Matches); + } + + [Fact] + public void NotArray_Failure() + { + var resp = "+OK\r\n"; + ExecuteUnexpected(resp, ResultProcessor.LCSMatchResult); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Misc.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Misc.cs new file mode 100644 index 000000000..1794cc2ed --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Misc.cs @@ -0,0 +1,92 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class Misc(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData(":1\r\n", StreamTrimResult.Deleted)] // Integer 1 + [InlineData(":-1\r\n", StreamTrimResult.NotFound)] // Integer -1 + [InlineData(":2\r\n", StreamTrimResult.NotDeleted)] // Integer 2 + [InlineData("+1\r\n", StreamTrimResult.Deleted)] // Simple string "1" + [InlineData("$1\r\n1\r\n", StreamTrimResult.Deleted)] // Bulk string "1" + [InlineData("*1\r\n:1\r\n", StreamTrimResult.Deleted)] // Unit array with integer 1 + public void Int32EnumProcessor_StreamTrimResult(string resp, StreamTrimResult expected) + { + var processor = ResultProcessor.StreamTrimResult; + var result = Execute(resp, processor); + Assert.Equal(expected, result); + } + + [Fact] + public void Int32EnumArrayProcessor_StreamTrimResult_EmptyArray() + { + var resp = "*0\r\n"; + var processor = ResultProcessor.StreamTrimResultArray; + var result = Execute(resp, processor); + Assert.NotNull(result); + Assert.Empty(result); + } + + [Fact] + public void Int32EnumArrayProcessor_StreamTrimResult_NullArray() + { + var resp = "*-1\r\n"; + var processor = ResultProcessor.StreamTrimResultArray; + var result = Execute(resp, processor); + Assert.Null(result); + } + + [Fact] + public void Int32EnumArrayProcessor_StreamTrimResult_MultipleValues() + { + // Array with 3 elements: [1, -1, 2] + var resp = "*3\r\n:1\r\n:-1\r\n:2\r\n"; + var processor = ResultProcessor.StreamTrimResultArray; + var result = Execute(resp, processor); + Assert.NotNull(result); + Assert.Equal(3, result.Length); + Assert.Equal(StreamTrimResult.Deleted, result[0]); + Assert.Equal(StreamTrimResult.NotFound, result[1]); + Assert.Equal(StreamTrimResult.NotDeleted, result[2]); + } + + [Fact] + public void ConnectionIdentityProcessor_ReturnsEndPoint() + { + // ConnectionIdentityProcessor doesn't actually read from the RESP response, + // it just returns the endpoint from the connection (or null if no bridge). + var resp = "+OK\r\n"; + var processor = ResultProcessor.ConnectionIdentity; + var result = Execute(resp, processor); + + // No bridge in test helper means result is null, but that's OK + Assert.Null(result); + } + + [Fact] + public void DigestProcessor_ValidDigest() + { + // DigestProcessor reads a scalar string containing a hex digest + // Example: XXh3 digest of "asdfasd" is "91d2544ff57ccca3" + var resp = "$16\r\n91d2544ff57ccca3\r\n"; + var processor = ResultProcessor.Digest; + var result = Execute(resp, processor); + Assert.NotNull(result); + Assert.True(result.HasValue); + + // Parse the expected digest and verify equality + var expected = ValueCondition.ParseDigest("91d2544ff57ccca3"); + Assert.Equal(expected, result.Value); + } + + [Fact] + public void DigestProcessor_NullDigest() + { + // DigestProcessor should handle null responses + var resp = "$-1\r\n"; + var processor = ResultProcessor.Digest; + var result = Execute(resp, processor); + Assert.Null(result); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/RedisValueFromArray.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/RedisValueFromArray.cs new file mode 100644 index 000000000..7966a9a7c --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/RedisValueFromArray.cs @@ -0,0 +1,34 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class RedisValueFromArray(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void SingleElementArray_String() + { + var result = Execute("*1\r\n$5\r\nhello\r\n", ResultProcessor.RedisValueFromArray); + Assert.Equal("hello", (string?)result); + } + + [Fact] + public void SingleElementArray_Integer() + { + var result = Execute("*1\r\n:42\r\n", ResultProcessor.RedisValueFromArray); + Assert.Equal(42, (long)result); + } + + [Fact] + public void SingleElementArray_Null() + { + var result = Execute("*1\r\n$-1\r\n", ResultProcessor.RedisValueFromArray); + Assert.True(result.IsNull); + } + + [Fact] + public void SingleElementArray_EmptyString() + { + var result = Execute("*1\r\n$0\r\n\r\n", ResultProcessor.RedisValueFromArray); + Assert.Equal("", (string?)result); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ResultProcessorUnitTest.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ResultProcessorUnitTest.cs new file mode 100644 index 000000000..a0f378b68 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ResultProcessorUnitTest.cs @@ -0,0 +1,91 @@ +using System; +using System.Buffers; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using System.Text; +using RESPite.Messages; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Base class for ResultProcessor unit tests. +/// Tests are organized into subclass files by category. +/// +public abstract class ResultProcessorUnitTest(ITestOutputHelper log) +{ + private protected const string ATTRIB_FOO_BAR = "|1\r\n+foo\r\n+bar\r\n"; + private protected static readonly ResultProcessor.Int64DefaultValueProcessor Int64DefaultValue999 = new(999); + + [return: NotNullIfNotNull(nameof(array))] + protected static string? Join(T[]? array, string separator = ",") + { + if (array is null) return null; + return string.Join(separator, array); + } + + public void Log(string message) => log?.WriteLine(message); + + private protected static Message DummyMessage() + => Message.Create(0, default, RedisCommand.UNKNOWN); + + private protected void ExecuteUnexpected( + string resp, + ResultProcessor processor, + Message? message = null, + ConnectionType connectionType = ConnectionType.Interactive, + RedisProtocol protocol = RedisProtocol.Resp2, + [CallerMemberName] string caller = "") + { + Assert.False(TryExecute(resp, processor, out _, out var ex, message, connectionType, protocol, caller), caller); + if (ex is not null) Log(ex.Message); + Assert.StartsWith("Unexpected response to UNKNOWN:", Assert.IsType(ex).Message); + } + private protected static T? Execute( + string resp, + ResultProcessor processor, + Message? message = null, + ConnectionType connectionType = ConnectionType.Interactive, + RedisProtocol protocol = RedisProtocol.Resp2, + [CallerMemberName] string caller = "") + { + Assert.True(TryExecute(resp, processor, out var value, out var ex, message, connectionType, protocol, caller)); + Assert.Null(ex); + return value; + } + + private protected static bool TryExecute( + string resp, + ResultProcessor processor, + out T? value, + out Exception? exception, + Message? message = null, + ConnectionType connectionType = ConnectionType.Interactive, + RedisProtocol protocol = RedisProtocol.Resp2, + [CallerMemberName] string caller = "") + { + byte[]? lease = null; + try + { + var maxLen = Encoding.UTF8.GetMaxByteCount(resp.Length); + const int MAX_STACK = 128; + Span oversized = maxLen <= MAX_STACK + ? stackalloc byte[MAX_STACK] + : (lease = ArrayPool.Shared.Rent(maxLen)); + + message ??= DummyMessage(); + var box = SimpleResultBox.Get(); + message.SetSource(processor, box); + + var reader = new RespReader(oversized.Slice(0, Encoding.UTF8.GetBytes(resp, oversized))); + PhysicalConnection connection = new(connectionType, protocol, name: caller); + Assert.True(processor.SetResult(connection, message, ref reader)); + value = box.GetResult(out exception, canRecycle: true); + return exception is null; + } + finally + { + if (lease is not null) ArrayPool.Shared.Return(lease); + } + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Role.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Role.cs new file mode 100644 index 000000000..943a444e2 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Role.cs @@ -0,0 +1,159 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class RoleTests(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void Role_Master_NoReplicas() + { + // 1) "master" + // 2) (integer) 3129659 + // 3) (empty array) + var resp = "*3\r\n$6\r\nmaster\r\n:3129659\r\n*0\r\n"; + var processor = ResultProcessor.Role; + var result = Execute(resp, processor); + + Assert.NotNull(result); + var master = Assert.IsType(result); + Assert.Equal("master", master.Value); + Assert.Equal(3129659, master.ReplicationOffset); + Assert.NotNull(master.Replicas); + Assert.Empty(master.Replicas); + } + + [Fact] + public void Role_Master_WithReplicas() + { + // 1) "master" + // 2) (integer) 3129659 + // 3) 1) 1) "127.0.0.1" + // 2) "9001" + // 3) "3129242" + // 2) 1) "127.0.0.1" + // 2) "9002" + // 3) "3129543" + var resp = "*3\r\n" + + "$6\r\nmaster\r\n" + + ":3129659\r\n" + + "*2\r\n" + + "*3\r\n$9\r\n127.0.0.1\r\n$4\r\n9001\r\n$7\r\n3129242\r\n" + + "*3\r\n$9\r\n127.0.0.1\r\n$4\r\n9002\r\n$7\r\n3129543\r\n"; + var processor = ResultProcessor.Role; + var result = Execute(resp, processor); + + Assert.NotNull(result); + var master = Assert.IsType(result); + Assert.Equal("master", master.Value); + Assert.Equal(3129659, master.ReplicationOffset); + Assert.NotNull(master.Replicas); + Assert.Equal(2, master.Replicas.Count); + + var replicas = new System.Collections.Generic.List(master.Replicas); + Assert.Equal("127.0.0.1", replicas[0].Ip); + Assert.Equal(9001, replicas[0].Port); + Assert.Equal(3129242, replicas[0].ReplicationOffset); + + Assert.Equal("127.0.0.1", replicas[1].Ip); + Assert.Equal(9002, replicas[1].Port); + Assert.Equal(3129543, replicas[1].ReplicationOffset); + } + + [Theory] + [InlineData("slave")] + [InlineData("replica")] + public void Role_Replica_Connected(string roleType) + { + // 1) "slave" (or "replica") + // 2) "127.0.0.1" + // 3) (integer) 9000 + // 4) "connected" + // 5) (integer) 3167038 + var resp = $"*5\r\n${roleType.Length}\r\n{roleType}\r\n$9\r\n127.0.0.1\r\n:9000\r\n$9\r\nconnected\r\n:3167038\r\n"; + var processor = ResultProcessor.Role; + var result = Execute(resp, processor); + + Assert.NotNull(result); + var replica = Assert.IsType(result); + Assert.Equal(roleType, replica.Value); + Assert.Equal("127.0.0.1", replica.MasterIp); + Assert.Equal(9000, replica.MasterPort); + Assert.Equal("connected", replica.State); + Assert.Equal(3167038, replica.ReplicationOffset); + } + + [Theory] + [InlineData("connect")] + [InlineData("connecting")] + [InlineData("sync")] + [InlineData("connected")] + [InlineData("none")] + [InlineData("handshake")] + public void Role_Replica_VariousStates(string state) + { + var resp = $"*5\r\n$5\r\nslave\r\n$9\r\n127.0.0.1\r\n:9000\r\n${state.Length}\r\n{state}\r\n:3167038\r\n"; + var processor = ResultProcessor.Role; + var result = Execute(resp, processor); + + Assert.NotNull(result); + var replica = Assert.IsType(result); + Assert.Equal(state, replica.State); + } + + [Fact] + public void Role_Sentinel() + { + // 1) "sentinel" + // 2) 1) "resque-master" + // 2) "html-fragments-master" + // 3) "stats-master" + // 4) "metadata-master" + var resp = "*2\r\n" + + "$8\r\nsentinel\r\n" + + "*4\r\n" + + "$13\r\nresque-master\r\n" + + "$21\r\nhtml-fragments-master\r\n" + + "$12\r\nstats-master\r\n" + + "$15\r\nmetadata-master\r\n"; + var processor = ResultProcessor.Role; + var result = Execute(resp, processor); + + Assert.NotNull(result); + var sentinel = Assert.IsType(result); + Assert.Equal("sentinel", sentinel.Value); + Assert.NotNull(sentinel.MonitoredMasters); + Assert.Equal(4, sentinel.MonitoredMasters.Count); + + var masters = new System.Collections.Generic.List(sentinel.MonitoredMasters); + Assert.Equal("resque-master", masters[0]); + Assert.Equal("html-fragments-master", masters[1]); + Assert.Equal("stats-master", masters[2]); + Assert.Equal("metadata-master", masters[3]); + } + + [Theory] + [InlineData("unknown", false)] // Short value - tests TryGetSpan path + [InlineData("unknown", true)] + [InlineData("long_value_to_test_buffer_size", true)] // Streaming scalar - tests Buffer path (TryGetSpan fails on non-contiguous) + public void Role_Unknown(string roleName, bool streaming) + { + var resp = streaming + ? $"*1\r\n$?\r\n;{roleName.Length}\r\n{roleName}\r\n;6\r\n_extra\r\n;0\r\n" // force an extra chunk + : $"*1\r\n${roleName.Length}\r\n{roleName}\r\n"; + var processor = ResultProcessor.Role; + var result = Execute(resp, processor); + + Assert.NotNull(result); + var unknown = Assert.IsType(result); + Assert.Equal(roleName + (streaming ? "_extra" : ""), unknown.Value); + } + + [Fact] + public void Role_EmptyArray_ReturnsNull() + { + var resp = "*0\r\n"; + var processor = ResultProcessor.Role; + var result = Execute(resp, processor); + Assert.Null(result); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Scan.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Scan.cs new file mode 100644 index 000000000..feae87a42 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Scan.cs @@ -0,0 +1,132 @@ +using System; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class Scan(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + // SCAN/SSCAN format: array of 2 elements [cursor, array of keys] + // Example: *2\r\n$1\r\n0\r\n*3\r\n$3\r\nkey1\r\n$3\r\nkey2\r\n$3\r\nkey3\r\n + [Theory] + [InlineData("*2\r\n$1\r\n0\r\n*0\r\n", 0L, 0)] // cursor 0, empty array + [InlineData("*2\r\n$1\r\n5\r\n*0\r\n", 5L, 0)] // cursor 5, empty array + [InlineData("*2\r\n$1\r\n0\r\n*1\r\n$3\r\nfoo\r\n", 0L, 1)] // cursor 0, 1 key + [InlineData("*2\r\n$1\r\n0\r\n*3\r\n$4\r\nkey1\r\n$4\r\nkey2\r\n$4\r\nkey3\r\n", 0L, 3)] // cursor 0, 3 keys + [InlineData("*2\r\n$2\r\n42\r\n*2\r\n$4\r\ntest\r\n$5\r\nhello\r\n", 42L, 2)] // cursor 42, 2 keys + public void SetScanResultProcessor_ValidInput(string resp, long expectedCursor, int expectedCount) + { + var processor = RedisDatabase.SetScanResultProcessor.Default; + var result = Execute(resp, processor); + + Assert.Equal(expectedCursor, result.Cursor); + Assert.Equal(expectedCount, result.Count); + } + + [Fact] + public void SetScanResultProcessor_ValidatesContent() + { + // cursor 0, 3 keys: "key1", "key2", "key3" + var resp = "*2\r\n$1\r\n0\r\n*3\r\n$4\r\nkey1\r\n$4\r\nkey2\r\n$4\r\nkey3\r\n"; + var processor = RedisDatabase.SetScanResultProcessor.Default; + var result = Execute(resp, processor); + + Assert.Equal(0L, result.Cursor); + Assert.Equal(3, result.Count); + + // Access the values through the result + var values = result.Values; + Assert.Equal(3, values.Length); + Assert.Equal("key1", (string?)values[0]); + Assert.Equal("key2", (string?)values[1]); + Assert.Equal("key3", (string?)values[2]); + + result.Recycle(); + } + + // HSCAN format: array of 2 elements [cursor, interleaved array of field/value pairs] + // Example: *2\r\n$1\r\n0\r\n*4\r\n$6\r\nfield1\r\n$6\r\nvalue1\r\n$6\r\nfield2\r\n$6\r\nvalue2\r\n + [Theory] + [InlineData("*2\r\n$1\r\n0\r\n*0\r\n", 0L, 0)] // cursor 0, empty array + [InlineData("*2\r\n$1\r\n7\r\n*0\r\n", 7L, 0)] // cursor 7, empty array + [InlineData("*2\r\n$1\r\n0\r\n*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n", 0L, 1)] // cursor 0, 1 pair + [InlineData("*2\r\n$1\r\n0\r\n*4\r\n$2\r\nf1\r\n$2\r\nv1\r\n$2\r\nf2\r\n$2\r\nv2\r\n", 0L, 2)] // cursor 0, 2 pairs + [InlineData("*2\r\n$2\r\n99\r\n*6\r\n$1\r\na\r\n$1\r\n1\r\n$1\r\nb\r\n$1\r\n2\r\n$1\r\nc\r\n$1\r\n3\r\n", 99L, 3)] // cursor 99, 3 pairs + public void HashScanResultProcessor_ValidInput(string resp, long expectedCursor, int expectedCount) + { + var processor = RedisDatabase.HashScanResultProcessor.Default; + var result = Execute(resp, processor); + + Assert.Equal(expectedCursor, result.Cursor); + Assert.Equal(expectedCount, result.Count); + } + + [Fact] + public void HashScanResultProcessor_ValidatesContent() + { + // cursor 0, 2 pairs: "field1"="value1", "field2"="value2" + var resp = "*2\r\n$1\r\n0\r\n*4\r\n$6\r\nfield1\r\n$6\r\nvalue1\r\n$6\r\nfield2\r\n$6\r\nvalue2\r\n"; + var processor = RedisDatabase.HashScanResultProcessor.Default; + var result = Execute(resp, processor); + + Assert.Equal(0L, result.Cursor); + Assert.Equal(2, result.Count); + + var entries = result.Values; + Assert.Equal(2, entries.Length); + Assert.Equal("field1", (string?)entries[0].Name); + Assert.Equal("value1", (string?)entries[0].Value); + Assert.Equal("field2", (string?)entries[1].Name); + Assert.Equal("value2", (string?)entries[1].Value); + + result.Recycle(); + } + + // ZSCAN format: array of 2 elements [cursor, interleaved array of member/score pairs] + // Example: *2\r\n$1\r\n0\r\n*4\r\n$7\r\nmember1\r\n$3\r\n1.5\r\n$7\r\nmember2\r\n$3\r\n2.5\r\n + [Theory] + [InlineData("*2\r\n$1\r\n0\r\n*0\r\n", 0L, 0)] // cursor 0, empty array + [InlineData("*2\r\n$2\r\n10\r\n*0\r\n", 10L, 0)] // cursor 10, empty array + [InlineData("*2\r\n$1\r\n0\r\n*2\r\n$3\r\nfoo\r\n$1\r\n1\r\n", 0L, 1)] // cursor 0, 1 pair + [InlineData("*2\r\n$1\r\n0\r\n*4\r\n$2\r\nm1\r\n$3\r\n1.5\r\n$2\r\nm2\r\n$3\r\n2.5\r\n", 0L, 2)] // cursor 0, 2 pairs + [InlineData("*2\r\n$2\r\n88\r\n*6\r\n$1\r\na\r\n$1\r\n1\r\n$1\r\nb\r\n$1\r\n2\r\n$1\r\nc\r\n$1\r\n3\r\n", 88L, 3)] // cursor 88, 3 pairs + public void SortedSetScanResultProcessor_ValidInput(string resp, long expectedCursor, int expectedCount) + { + var processor = RedisDatabase.SortedSetScanResultProcessor.Default; + var result = Execute(resp, processor); + + Assert.Equal(expectedCursor, result.Cursor); + Assert.Equal(expectedCount, result.Count); + } + + [Fact] + public void SortedSetScanResultProcessor_ValidatesContent() + { + // cursor 0, 2 pairs: "member1"=1.5, "member2"=2.5 + var resp = "*2\r\n$1\r\n0\r\n*4\r\n$7\r\nmember1\r\n$3\r\n1.5\r\n$7\r\nmember2\r\n$3\r\n2.5\r\n"; + var processor = RedisDatabase.SortedSetScanResultProcessor.Default; + var result = Execute(resp, processor); + + Assert.Equal(0L, result.Cursor); + Assert.Equal(2, result.Count); + + var entries = result.Values; + Assert.Equal(2, entries.Length); + Assert.Equal("member1", (string?)entries[0].Element); + Assert.Equal(1.5, entries[0].Score); + Assert.Equal("member2", (string?)entries[1].Element); + Assert.Equal(2.5, entries[1].Score); + + result.Recycle(); + } + + [Theory] + [InlineData("*1\r\n$1\r\n0\r\n")] // only 1 element instead of 2 + [InlineData("*3\r\n$1\r\n0\r\n*0\r\n$4\r\nextra\r\n")] // 3 elements instead of 2 + [InlineData("$1\r\n0\r\n")] // scalar instead of array + public void ScanProcessors_InvalidFormat(string resp) + { + ExecuteUnexpected(resp, RedisDatabase.SetScanResultProcessor.Default, caller: nameof(RedisDatabase.SetScanResultProcessor)); + ExecuteUnexpected(resp, RedisDatabase.HashScanResultProcessor.Default, caller: nameof(RedisDatabase.HashScanResultProcessor)); + ExecuteUnexpected(resp, RedisDatabase.SortedSetScanResultProcessor.Default, caller: nameof(RedisDatabase.SortedSetScanResultProcessor)); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ScriptLoad.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ScriptLoad.cs new file mode 100644 index 000000000..6940e3d45 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/ScriptLoad.cs @@ -0,0 +1,52 @@ +using System.Linq; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Tests for ScriptLoadProcessor. +/// SCRIPT LOAD returns a bulk string containing the SHA1 hash (40 hex characters). +/// +public class ScriptLoad(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData("$40\r\n829c3804401b0727f70f73d4415e162400cbe57b\r\n", "829c3804401b0727f70f73d4415e162400cbe57b")] + [InlineData("$40\r\n0000000000000000000000000000000000000000\r\n", "0000000000000000000000000000000000000000")] + [InlineData("$40\r\nffffffffffffffffffffffffffffffffffffffff\r\n", "ffffffffffffffffffffffffffffffffffffffff")] + [InlineData("$40\r\nABCDEF1234567890abcdef1234567890ABCDEF12\r\n", "ABCDEF1234567890abcdef1234567890ABCDEF12")] + public void ScriptLoadProcessor_ValidHash(string resp, string expectedAsciiHash) + { + var processor = ResultProcessor.ScriptLoad; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(20, result.Length); // SHA1 is 20 bytes + + // Convert the byte array back to hex string to verify + var actualHex = string.Concat(result.Select(b => b.ToString("x2"))); + Assert.Equal(expectedAsciiHash.ToLowerInvariant(), actualHex); + } + + [Theory] + [InlineData("$41\r\n829c3804401b0727f70f73d4415e162400cbe57bb\r\n")] // 41 chars instead of 40 + [InlineData("$0\r\n\r\n")] // empty string + [InlineData("$-1\r\n")] // null bulk string + [InlineData(":42\r\n")] // integer instead of bulk string + [InlineData("+OK\r\n")] // simple string instead of bulk string + [InlineData("*1\r\n$40\r\n829c3804401b0727f70f73d4415e162400cbe57b\r\n")] // array instead of bulk string + public void ScriptLoadProcessor_InvalidFormat(string resp) + { + var processor = ResultProcessor.ScriptLoad; + ExecuteUnexpected(resp, processor); + } + + [Theory] + [InlineData("$40\r\n829c3804401b0727f70f73d4415e162400cbe5zz\r\n")] // invalid hex chars (zz) + [InlineData("$40\r\n829c3804401b0727f70f73d4415e162400cbe5!!\r\n")] // invalid hex chars (!!) + [InlineData("$40\r\n829c3804401b0727f70f73d4415e162400cbe5 \r\n")] // spaces instead of hex + public void ScriptLoadProcessor_InvalidHexCharacters(string resp) + { + var processor = ResultProcessor.ScriptLoad; + ExecuteUnexpected(resp, processor); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/SentinelGetPrimaryAddressByName.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/SentinelGetPrimaryAddressByName.cs new file mode 100644 index 000000000..341e0c1ed --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/SentinelGetPrimaryAddressByName.cs @@ -0,0 +1,84 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class SentinelGetPrimaryAddressByName(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void ValidHostAndPort_Success() + { + // Array with 2 elements: host (bulk string) and port (integer) + var resp = "*2\r\n$9\r\n127.0.0.1\r\n:6379\r\n"; + var result = Execute(resp, ResultProcessor.SentinelPrimaryEndpoint); + + Assert.NotNull(result); + var ipEndpoint = Assert.IsType(result); + Assert.Equal("127.0.0.1", ipEndpoint.Address.ToString()); + Assert.Equal(6379, ipEndpoint.Port); + } + + [Fact] + public void DomainNameAndPort_Success() + { + // Array with 2 elements: domain name (bulk string) and port (integer) + var resp = "*2\r\n$17\r\nredis.example.com\r\n:6380\r\n"; + var result = Execute(resp, ResultProcessor.SentinelPrimaryEndpoint); + + Assert.NotNull(result); + var dnsEndpoint = Assert.IsType(result); + Assert.Equal("redis.example.com", dnsEndpoint.Host); + Assert.Equal(6380, dnsEndpoint.Port); + } + + [Fact] + public void NullArray_Success() + { + // Null array - primary doesn't exist + var resp = "*-1\r\n"; + var result = Execute(resp, ResultProcessor.SentinelPrimaryEndpoint); + + Assert.Null(result); + } + + [Fact] + public void EmptyArray_Success() + { + // Empty array - primary doesn't exist + var resp = "*0\r\n"; + var result = Execute(resp, ResultProcessor.SentinelPrimaryEndpoint); + + Assert.Null(result); + } + + [Fact] + public void NotArray_Failure() + { + // Simple string instead of array + var resp = "+OK\r\n"; + ExecuteUnexpected(resp, ResultProcessor.SentinelPrimaryEndpoint); + } + + [Fact] + public void ArrayWithOneElement_Failure() + { + // Array with only 1 element (missing port) + var resp = "*1\r\n$9\r\n127.0.0.1\r\n"; + ExecuteUnexpected(resp, ResultProcessor.SentinelPrimaryEndpoint); + } + + [Fact] + public void ArrayWithThreeElements_Failure() + { + // Array with 3 elements (too many) + var resp = "*3\r\n$9\r\n127.0.0.1\r\n:6379\r\n$5\r\nextra\r\n"; + ExecuteUnexpected(resp, ResultProcessor.SentinelPrimaryEndpoint); + } + + [Fact] + public void ArrayWithNonIntegerPort_Failure() + { + // Array with 2 elements but port is not an integer + var resp = "*2\r\n$9\r\n127.0.0.1\r\n$4\r\nport\r\n"; + ExecuteUnexpected(resp, ResultProcessor.SentinelPrimaryEndpoint); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/SentinelGetReplicaAddresses.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/SentinelGetReplicaAddresses.cs new file mode 100644 index 000000000..172c79322 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/SentinelGetReplicaAddresses.cs @@ -0,0 +1,88 @@ +using System.Net; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class SentinelGetReplicaAddresses(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void SingleReplica_Success() + { + var resp = "*1\r\n*4\r\n$2\r\nip\r\n$9\r\n127.0.0.1\r\n$4\r\nport\r\n$4\r\n6380\r\n"; + var result = Execute(resp, ResultProcessor.SentinelReplicaEndPoints); + + Assert.NotNull(result); + Assert.Single(result); + + var endpoint = Assert.IsType(result[0]); + Assert.Equal("127.0.0.1", endpoint.Address.ToString()); + Assert.Equal(6380, endpoint.Port); + } + + [Fact] + public void MultipleReplicas_Success() + { + var resp = "*2\r\n*4\r\n$2\r\nip\r\n$9\r\n127.0.0.1\r\n$4\r\nport\r\n$4\r\n6380\r\n*4\r\n$2\r\nip\r\n$9\r\n127.0.0.2\r\n$4\r\nport\r\n$4\r\n6381\r\n"; + var result = Execute(resp, ResultProcessor.SentinelReplicaEndPoints); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + + var endpoint1 = Assert.IsType(result[0]); + Assert.Equal("127.0.0.1", endpoint1.Address.ToString()); + Assert.Equal(6380, endpoint1.Port); + + var endpoint2 = Assert.IsType(result[1]); + Assert.Equal("127.0.0.2", endpoint2.Address.ToString()); + Assert.Equal(6381, endpoint2.Port); + } + + [Fact] + public void DnsEndpoint_Success() + { + var resp = "*1\r\n*4\r\n$2\r\nip\r\n$17\r\nredis.example.com\r\n$4\r\nport\r\n$4\r\n6380\r\n"; + var result = Execute(resp, ResultProcessor.SentinelReplicaEndPoints); + + Assert.NotNull(result); + Assert.Single(result); + + var endpoint = Assert.IsType(result[0]); + Assert.Equal("redis.example.com", endpoint.Host); + Assert.Equal(6380, endpoint.Port); + } + + [Fact] + public void ReversedOrder_Success() + { + // Test that order doesn't matter - port before ip + var resp = "*1\r\n*4\r\n$4\r\nport\r\n$4\r\n6380\r\n$2\r\nip\r\n$9\r\n127.0.0.1\r\n"; + var result = Execute(resp, ResultProcessor.SentinelReplicaEndPoints); + + Assert.NotNull(result); + Assert.Single(result); + var endpoint = Assert.IsType(result[0]); + Assert.Equal("127.0.0.1", endpoint.Address.ToString()); + Assert.Equal(6380, endpoint.Port); + } + + [Fact] + public void EmptyArray_Failure() + { + var resp = "*0\r\n"; + ExecuteUnexpected(resp, ResultProcessor.SentinelReplicaEndPoints); + } + + [Fact] + public void NullArray_Failure() + { + var resp = "*-1\r\n"; + ExecuteUnexpected(resp, ResultProcessor.SentinelReplicaEndPoints); + } + + [Fact] + public void NotArray_Failure() + { + var resp = "+OK\r\n"; + ExecuteUnexpected(resp, ResultProcessor.SentinelReplicaEndPoints); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/SentinelGetSentinelAddresses.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/SentinelGetSentinelAddresses.cs new file mode 100644 index 000000000..98360d13a --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/SentinelGetSentinelAddresses.cs @@ -0,0 +1,90 @@ +using System.Net; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class SentinelGetSentinelAddresses(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void SingleSentinel_Success() + { + var resp = "*1\r\n*4\r\n$2\r\nip\r\n$9\r\n127.0.0.1\r\n$4\r\nport\r\n$5\r\n26379\r\n"; + var result = Execute(resp, ResultProcessor.SentinelAddressesEndPoints); + + Assert.NotNull(result); + Assert.Single(result); + var endpoint = Assert.IsType(result[0]); + Assert.Equal("127.0.0.1", endpoint.Address.ToString()); + Assert.Equal(26379, endpoint.Port); + } + + [Fact] + public void MultipleSentinels_Success() + { + var resp = "*2\r\n*4\r\n$2\r\nip\r\n$9\r\n127.0.0.1\r\n$4\r\nport\r\n$5\r\n26379\r\n*4\r\n$2\r\nip\r\n$9\r\n127.0.0.2\r\n$4\r\nport\r\n$5\r\n26380\r\n"; + var result = Execute(resp, ResultProcessor.SentinelAddressesEndPoints); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + + var endpoint1 = Assert.IsType(result[0]); + Assert.Equal("127.0.0.1", endpoint1.Address.ToString()); + Assert.Equal(26379, endpoint1.Port); + + var endpoint2 = Assert.IsType(result[1]); + Assert.Equal("127.0.0.2", endpoint2.Address.ToString()); + Assert.Equal(26380, endpoint2.Port); + } + + [Fact] + public void DnsEndpoint_Success() + { + var resp = "*1\r\n*4\r\n$2\r\nip\r\n$20\r\nsentinel.example.com\r\n$4\r\nport\r\n$5\r\n26379\r\n"; + var result = Execute(resp, ResultProcessor.SentinelAddressesEndPoints); + + Assert.NotNull(result); + Assert.Single(result); + var endpoint = Assert.IsType(result[0]); + Assert.Equal("sentinel.example.com", endpoint.Host); + Assert.Equal(26379, endpoint.Port); + } + + [Fact] + public void ReversedOrder_Success() + { + var resp = "*1\r\n*4\r\n$4\r\nport\r\n$5\r\n26379\r\n$2\r\nip\r\n$9\r\n127.0.0.1\r\n"; + var result = Execute(resp, ResultProcessor.SentinelAddressesEndPoints); + + Assert.NotNull(result); + Assert.Single(result); + var endpoint = Assert.IsType(result[0]); + Assert.Equal("127.0.0.1", endpoint.Address.ToString()); + Assert.Equal(26379, endpoint.Port); + } + + [Fact] + public void EmptyArray_Success() + { + var resp = "*0\r\n"; + var result = Execute(resp, ResultProcessor.SentinelAddressesEndPoints); + + Assert.NotNull(result); + Assert.Empty(result); + } + + [Fact] + public void NullBulkString_Failure() + { + var resp = "$-1\r\n"; + var success = TryExecute(resp, ResultProcessor.SentinelAddressesEndPoints, out var result, out var exception); + + Assert.False(success); + } + + [Fact] + public void NotArray_Failure() + { + var resp = "+OK\r\n"; + ExecuteUnexpected(resp, ResultProcessor.SentinelAddressesEndPoints); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamAutoClaim.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamAutoClaim.cs new file mode 100644 index 000000000..7b80f4ad8 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamAutoClaim.cs @@ -0,0 +1,122 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class StreamAutoClaim(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void WithEntries_ThreeElements_Success() + { + // XAUTOCLAIM mystream mygroup Alice 3600000 0-0 COUNT 25 + // 1) "0-0" + // 2) 1) 1) "1609338752495-0" + // 2) 1) "field" + // 2) "value" + // 3) (empty array) + var resp = "*3\r\n" + + "$3\r\n0-0\r\n" + + "*1\r\n" + // Array of 1 entry + "*2\r\n" + // Entry: [id, fields] + "$15\r\n1609338752495-0\r\n" + + "*2\r\n" + // Fields array + "$5\r\nfield\r\n" + + "$5\r\nvalue\r\n" + + "*0\r\n"; // Empty deleted IDs array + + var result = Execute(resp, ResultProcessor.StreamAutoClaim); + + Assert.Equal("0-0", result.NextStartId.ToString()); + Assert.Single(result.ClaimedEntries); + Assert.Equal("1609338752495-0", result.ClaimedEntries[0].Id.ToString()); + Assert.Equal("value", result.ClaimedEntries[0]["field"]); + Assert.Empty(result.DeletedIds); + } + + [Fact] + public void WithEntries_TwoElements_OlderServer_Success() + { + // Older Redis 6.2 - only returns 2 elements (no deleted IDs) + var resp = "*2\r\n" + + "$3\r\n0-0\r\n" + + "*1\r\n" + + "*2\r\n" + + "$15\r\n1609338752495-0\r\n" + + "*2\r\n" + + "$5\r\nfield\r\n" + + "$5\r\nvalue\r\n"; + + var result = Execute(resp, ResultProcessor.StreamAutoClaim); + + Assert.Equal("0-0", result.NextStartId.ToString()); + Assert.Single(result.ClaimedEntries); + Assert.Empty(result.DeletedIds); + } + + [Fact] + public void EmptyEntries_Success() + { + // No entries claimed + var resp = "*3\r\n" + + "$3\r\n0-0\r\n" + + "*0\r\n" + // Empty entries array + "*0\r\n"; // Empty deleted IDs array + + var result = Execute(resp, ResultProcessor.StreamAutoClaim); + + Assert.Equal("0-0", result.NextStartId.ToString()); + Assert.Empty(result.ClaimedEntries); + Assert.Empty(result.DeletedIds); + } + + [Fact] + public void NullEntries_Success() + { + // Null entries array (alternative representation) + var resp = "*3\r\n" + + "$3\r\n0-0\r\n" + + "$-1\r\n" + // Null entries + "*0\r\n"; + + var result = Execute(resp, ResultProcessor.StreamAutoClaim); + + Assert.Equal("0-0", result.NextStartId.ToString()); + Assert.Empty(result.ClaimedEntries); + Assert.Empty(result.DeletedIds); + } + + [Fact] + public void WithDeletedIds_Success() + { + // Some entries were deleted + var resp = "*3\r\n" + + "$3\r\n0-0\r\n" + + "*0\r\n" + // No claimed entries + "*2\r\n" + // 2 deleted IDs + "$15\r\n1609338752495-0\r\n" + + "$15\r\n1609338752496-0\r\n"; + + var result = Execute(resp, ResultProcessor.StreamAutoClaim); + + Assert.Equal("0-0", result.NextStartId.ToString()); + Assert.Empty(result.ClaimedEntries); + Assert.Equal(2, result.DeletedIds.Length); + Assert.Equal("1609338752495-0", result.DeletedIds[0].ToString()); + Assert.Equal("1609338752496-0", result.DeletedIds[1].ToString()); + } + + [Fact] + public void NotArray_Failure() + { + var resp = "$5\r\nhello\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamAutoClaim); + } + + [Fact] + public void Null_Failure() + { + var resp = "$-1\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamAutoClaim); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamAutoClaimIdsOnly.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamAutoClaimIdsOnly.cs new file mode 100644 index 000000000..355c8aa95 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamAutoClaimIdsOnly.cs @@ -0,0 +1,117 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class StreamAutoClaimIdsOnly(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void WithIds_ThreeElements_Success() + { + // XAUTOCLAIM mystream mygroup Alice 3600000 0-0 COUNT 25 JUSTID + // 1) "0-0" + // 2) 1) "1609338752495-0" + // 2) "1609338752496-0" + // 3) (empty array) + var resp = "*3\r\n" + + "$3\r\n0-0\r\n" + + "*2\r\n" + // Array of 2 claimed IDs + "$15\r\n1609338752495-0\r\n" + + "$15\r\n1609338752496-0\r\n" + + "*0\r\n"; // Empty deleted IDs array + + var result = Execute(resp, ResultProcessor.StreamAutoClaimIdsOnly); + + Assert.Equal("0-0", result.NextStartId.ToString()); + Assert.Equal(2, result.ClaimedIds.Length); + Assert.Equal("1609338752495-0", result.ClaimedIds[0].ToString()); + Assert.Equal("1609338752496-0", result.ClaimedIds[1].ToString()); + Assert.Empty(result.DeletedIds); + } + + [Fact] + public void WithIds_TwoElements_OlderServer_Success() + { + // Older Redis 6.2 - only returns 2 elements (no deleted IDs) + var resp = "*2\r\n" + + "$3\r\n0-0\r\n" + + "*2\r\n" + + "$15\r\n1609338752495-0\r\n" + + "$15\r\n1609338752496-0\r\n"; + + var result = Execute(resp, ResultProcessor.StreamAutoClaimIdsOnly); + + Assert.Equal("0-0", result.NextStartId.ToString()); + Assert.Equal(2, result.ClaimedIds.Length); + Assert.Empty(result.DeletedIds); + } + + [Fact] + public void EmptyIds_Success() + { + // No IDs claimed + var resp = "*3\r\n" + + "$3\r\n0-0\r\n" + + "*0\r\n" + // Empty claimed IDs array + "*0\r\n"; // Empty deleted IDs array + + var result = Execute(resp, ResultProcessor.StreamAutoClaimIdsOnly); + + Assert.Equal("0-0", result.NextStartId.ToString()); + Assert.Empty(result.ClaimedIds); + Assert.Empty(result.DeletedIds); + } + + [Fact] + public void NullIds_Success() + { + // Null IDs array (alternative representation) + var resp = "*3\r\n" + + "$3\r\n0-0\r\n" + + "$-1\r\n" + // Null claimed IDs + "*0\r\n"; + + var result = Execute(resp, ResultProcessor.StreamAutoClaimIdsOnly); + + Assert.Equal("0-0", result.NextStartId.ToString()); + Assert.Empty(result.ClaimedIds); + Assert.Empty(result.DeletedIds); + } + + [Fact] + public void WithDeletedIds_Success() + { + // Some entries were deleted + var resp = "*3\r\n" + + "$3\r\n0-0\r\n" + + "*1\r\n" + // 1 claimed ID + "$15\r\n1609338752495-0\r\n" + + "*2\r\n" + // 2 deleted IDs + "$15\r\n1609338752496-0\r\n" + + "$15\r\n1609338752497-0\r\n"; + + var result = Execute(resp, ResultProcessor.StreamAutoClaimIdsOnly); + + Assert.Equal("0-0", result.NextStartId.ToString()); + Assert.Single(result.ClaimedIds); + Assert.Equal("1609338752495-0", result.ClaimedIds[0].ToString()); + Assert.Equal(2, result.DeletedIds.Length); + Assert.Equal("1609338752496-0", result.DeletedIds[0].ToString()); + Assert.Equal("1609338752497-0", result.DeletedIds[1].ToString()); + } + + [Fact] + public void NotArray_Failure() + { + var resp = "$5\r\nhello\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamAutoClaimIdsOnly); + } + + [Fact] + public void Null_Failure() + { + var resp = "$-1\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamAutoClaimIdsOnly); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamInfo.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamInfo.cs new file mode 100644 index 000000000..5b33f0563 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamInfo.cs @@ -0,0 +1,123 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class StreamInfo(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void BasicFormat_Success() + { + // XINFO STREAM mystream (basic format, not FULL) + // Interleaved key-value array with entries like first-entry and last-entry as nested arrays + var resp = "*32\r\n" + + "$6\r\nlength\r\n" + + ":2\r\n" + + "$15\r\nradix-tree-keys\r\n" + + ":1\r\n" + + "$16\r\nradix-tree-nodes\r\n" + + ":2\r\n" + + "$17\r\nlast-generated-id\r\n" + + "$15\r\n1638125141232-0\r\n" + + "$20\r\nmax-deleted-entry-id\r\n" + + "$3\r\n0-0\r\n" + + "$13\r\nentries-added\r\n" + + ":2\r\n" + + "$23\r\nrecorded-first-entry-id\r\n" + + "$15\r\n1719505260513-0\r\n" + + "$13\r\nidmp-duration\r\n" + + ":100\r\n" + + "$12\r\nidmp-maxsize\r\n" + + ":100\r\n" + + "$12\r\npids-tracked\r\n" + + ":1\r\n" + + "$12\r\niids-tracked\r\n" + + ":1\r\n" + + "$10\r\niids-added\r\n" + + ":1\r\n" + + "$15\r\niids-duplicates\r\n" + + ":0\r\n" + + "$6\r\ngroups\r\n" + + ":1\r\n" + + "$11\r\nfirst-entry\r\n" + + "*2\r\n" + + "$15\r\n1638125133432-0\r\n" + + "*2\r\n" + + "$7\r\nmessage\r\n" + + "$5\r\napple\r\n" + + "$10\r\nlast-entry\r\n" + + "*2\r\n" + + "$15\r\n1638125141232-0\r\n" + + "*2\r\n" + + "$7\r\nmessage\r\n" + + "$6\r\nbanana\r\n"; + + var result = Execute(resp, ResultProcessor.StreamInfo); + + Assert.Equal(2, result.Length); + Assert.Equal(1, result.RadixTreeKeys); + Assert.Equal(2, result.RadixTreeNodes); + Assert.Equal(1, result.ConsumerGroupCount); + Assert.Equal("1638125141232-0", result.LastGeneratedId.ToString()); + Assert.Equal("0-0", result.MaxDeletedEntryId.ToString()); + Assert.Equal(2, result.EntriesAdded); + Assert.Equal("1719505260513-0", result.RecordedFirstEntryId.ToString()); + Assert.Equal(100, result.IdmpDuration); + Assert.Equal(100, result.IdmpMaxSize); + Assert.Equal(1, result.PidsTracked); + Assert.Equal(1, result.IidsTracked); + Assert.Equal(1, result.IidsAdded); + Assert.Equal(0, result.IidsDuplicates); + + Assert.Equal("1638125133432-0", result.FirstEntry.Id.ToString()); + Assert.Equal("apple", result.FirstEntry["message"]); + + Assert.Equal("1638125141232-0", result.LastEntry.Id.ToString()); + Assert.Equal("banana", result.LastEntry["message"]); + } + + [Fact] + public void MinimalFormat_Success() + { + // Minimal XINFO STREAM response with just required fields + var resp = "*14\r\n" + + "$6\r\nlength\r\n" + + ":0\r\n" + + "$15\r\nradix-tree-keys\r\n" + + ":1\r\n" + + "$16\r\nradix-tree-nodes\r\n" + + ":1\r\n" + + "$6\r\ngroups\r\n" + + ":0\r\n" + + "$11\r\nfirst-entry\r\n" + + "$-1\r\n" + + "$10\r\nlast-entry\r\n" + + "$-1\r\n" + + "$17\r\nlast-generated-id\r\n" + + "$3\r\n0-0\r\n"; + + var result = Execute(resp, ResultProcessor.StreamInfo); + + Assert.Equal(0, result.Length); + Assert.Equal(1, result.RadixTreeKeys); + Assert.Equal(1, result.RadixTreeNodes); + Assert.Equal(0, result.ConsumerGroupCount); + Assert.True(result.FirstEntry.IsNull); + Assert.True(result.LastEntry.IsNull); + } + + [Fact] + public void NotArray_Failure() + { + var resp = "$5\r\nhello\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamInfo); + } + + [Fact] + public void Null_Failure() + { + var resp = "$-1\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamInfo); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamPendingInfo.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamPendingInfo.cs new file mode 100644 index 000000000..6655c6c08 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamPendingInfo.cs @@ -0,0 +1,113 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class StreamPendingInfo(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void SingleConsumer_Success() + { + // XPENDING mystream group55 + // 1) (integer) 1 + // 2) 1526984818136-0 + // 3) 1526984818136-0 + // 4) 1) 1) "consumer-123" + // 2) "1" + var resp = "*4\r\n" + + ":1\r\n" + + "$15\r\n1526984818136-0\r\n" + + "$15\r\n1526984818136-0\r\n" + + "*1\r\n" + // Array of 1 consumer + "*2\r\n" + // Each consumer is an array of 2 elements + "$12\r\nconsumer-123\r\n" + // Consumer name + "$1\r\n1\r\n"; // Pending count as string + + var result = Execute(resp, ResultProcessor.StreamPendingInfo); + + Assert.Equal(1, result.PendingMessageCount); + Assert.Equal("1526984818136-0", result.LowestPendingMessageId); + Assert.Equal("1526984818136-0", result.HighestPendingMessageId); + Assert.Single(result.Consumers); + Assert.Equal("consumer-123", result.Consumers[0].Name); + Assert.Equal(1, result.Consumers[0].PendingMessageCount); + } + + [Fact] + public void MultipleConsumers_Success() + { + // XPENDING mystream mygroup + // 1) (integer) 10 + // 2) 1526569498055-0 + // 3) 1526569506935-0 + // 4) 1) 1) "Bob" + // 2) "2" + // 2) 1) "Joe" + // 2) "8" + var resp = "*4\r\n" + + ":10\r\n" + + "$15\r\n1526569498055-0\r\n" + + "$15\r\n1526569506935-0\r\n" + + "*2\r\n" + // Array of 2 consumers + "*2\r\n" + // First consumer array + "$3\r\nBob\r\n" + + "$1\r\n2\r\n" + + "*2\r\n" + // Second consumer array + "$3\r\nJoe\r\n" + + "$1\r\n8\r\n"; + + var result = Execute(resp, ResultProcessor.StreamPendingInfo); + + Assert.Equal(10, result.PendingMessageCount); + Assert.Equal("1526569498055-0", result.LowestPendingMessageId); + Assert.Equal("1526569506935-0", result.HighestPendingMessageId); + Assert.Equal(2, result.Consumers.Length); + Assert.Equal("Bob", result.Consumers[0].Name); + Assert.Equal(2, result.Consumers[0].PendingMessageCount); + Assert.Equal("Joe", result.Consumers[1].Name); + Assert.Equal(8, result.Consumers[1].PendingMessageCount); + } + + [Fact] + public void NoConsumers_Success() + { + // When there are no consumers yet, the 4th element is null + var resp = "*4\r\n" + + ":0\r\n" + + "$15\r\n1526569498055-0\r\n" + + "$15\r\n1526569506935-0\r\n" + + "$-1\r\n"; // null + + var result = Execute(resp, ResultProcessor.StreamPendingInfo); + + Assert.Equal(0, result.PendingMessageCount); + Assert.Empty(result.Consumers); + } + + [Fact] + public void WrongArrayLength_Failure() + { + // Array with wrong length (3 instead of 4) + var resp = "*3\r\n" + + ":1\r\n" + + "$15\r\n1526984818136-0\r\n" + + "$15\r\n1526984818136-0\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamPendingInfo); + } + + [Fact] + public void NotArray_Failure() + { + var resp = "$5\r\nhello\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamPendingInfo); + } + + [Fact] + public void Null_Failure() + { + var resp = "$-1\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamPendingInfo); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamPendingMessages.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamPendingMessages.cs new file mode 100644 index 000000000..48357a3f8 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/StreamPendingMessages.cs @@ -0,0 +1,99 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class StreamPendingMessages(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void SingleMessage_Success() + { + // XPENDING mystream group55 - + 10 + // 1) 1) 1526984818136-0 + // 2) "consumer-123" + // 3) (integer) 196415 + // 4) (integer) 1 + var resp = "*1\r\n" + // Array of 1 message + "*4\r\n" + // Each message is an array of 4 elements + "$15\r\n1526984818136-0\r\n" + // Message ID + "$12\r\nconsumer-123\r\n" + // Consumer name + ":196415\r\n" + // Idle time in ms + ":1\r\n"; // Delivery count + + var result = Execute(resp, ResultProcessor.StreamPendingMessages); + + Assert.NotNull(result); + Assert.Single(result); + Assert.Equal("1526984818136-0", result[0].MessageId); + Assert.Equal("consumer-123", result[0].ConsumerName); + Assert.Equal(196415, result[0].IdleTimeInMilliseconds); + Assert.Equal(1, result[0].DeliveryCount); + } + + [Fact] + public void MultipleMessages_Success() + { + // XPENDING mystream group55 - + 10 + // 1) 1) 1526984818136-0 + // 2) "consumer-123" + // 3) (integer) 196415 + // 4) (integer) 1 + // 2) 1) 1526984818137-0 + // 2) "consumer-456" + // 3) (integer) 5000 + // 4) (integer) 3 + var resp = "*2\r\n" + // Array of 2 messages + "*4\r\n" + // First message + "$15\r\n1526984818136-0\r\n" + + "$12\r\nconsumer-123\r\n" + + ":196415\r\n" + + ":1\r\n" + + "*4\r\n" + // Second message + "$15\r\n1526984818137-0\r\n" + + "$12\r\nconsumer-456\r\n" + + ":5000\r\n" + + ":3\r\n"; + + var result = Execute(resp, ResultProcessor.StreamPendingMessages); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + + Assert.Equal("1526984818136-0", result[0].MessageId); + Assert.Equal("consumer-123", result[0].ConsumerName); + Assert.Equal(196415, result[0].IdleTimeInMilliseconds); + Assert.Equal(1, result[0].DeliveryCount); + + Assert.Equal("1526984818137-0", result[1].MessageId); + Assert.Equal("consumer-456", result[1].ConsumerName); + Assert.Equal(5000, result[1].IdleTimeInMilliseconds); + Assert.Equal(3, result[1].DeliveryCount); + } + + [Fact] + public void EmptyArray_Success() + { + // No pending messages + var resp = "*0\r\n"; + + var result = Execute(resp, ResultProcessor.StreamPendingMessages); + + Assert.NotNull(result); + Assert.Empty(result); + } + + [Fact] + public void NotArray_Failure() + { + var resp = "$5\r\nhello\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamPendingMessages); + } + + [Fact] + public void Null_Failure() + { + var resp = "$-1\r\n"; + + ExecuteUnexpected(resp, ResultProcessor.StreamPendingMessages); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Streams.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Streams.cs new file mode 100644 index 000000000..b011f0e9e --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Streams.cs @@ -0,0 +1,195 @@ +using System; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class Streams(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + // MultiStreamProcessor tests - XREAD command + // Format: array of [stream_name, array of entries] + // Each entry is [id, array of name/value pairs] + [Fact] + public void MultiStreamProcessor_EmptyResult() + { + // Server returns nil when no data available + var resp = "*-1\r\n"; + var processor = ResultProcessor.MultiStream; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Empty(result); + } + + [Fact] + public void MultiStreamProcessor_EmptyArray() + { + // Server returns empty array + var resp = "*0\r\n"; + var processor = ResultProcessor.MultiStream; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Empty(result); + } + + [Fact] + public void MultiStreamProcessor_SingleStreamSingleEntry() + { + // XREAD COUNT 1 STREAMS mystream 0-0 + // 1) 1) "mystream" + // 2) 1) 1) "1526984818136-0" + // 2) 1) "duration" + // 2) "1532" + // 3) "event-id" + // 4) "5" + var resp = "*1\r\n" + // 1 stream + "*2\r\n" + // [stream_name, entries] + "$8\r\nmystream\r\n" + // stream name + "*1\r\n" + // 1 entry + "*2\r\n" + // [id, values] + "$15\r\n1526984818136-0\r\n" + // entry id + "*4\r\n" + // 2 name/value pairs (interleaved) + "$8\r\nduration\r\n" + + "$4\r\n1532\r\n" + + "$8\r\nevent-id\r\n" + + "$1\r\n5\r\n"; + + var processor = ResultProcessor.MultiStream; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Single(result); + Assert.Equal("mystream", (string?)result[0].Key); + Assert.Single(result[0].Entries); + Assert.Equal("1526984818136-0", (string?)result[0].Entries[0].Id); + Assert.Equal(2, result[0].Entries[0].Values.Length); + Assert.Equal("duration", (string?)result[0].Entries[0].Values[0].Name); + Assert.Equal("1532", (string?)result[0].Entries[0].Values[0].Value); + Assert.Equal("event-id", (string?)result[0].Entries[0].Values[1].Name); + Assert.Equal("5", (string?)result[0].Entries[0].Values[1].Value); + } + + [Fact] + public void MultiStreamProcessor_MultipleStreamsMultipleEntries() + { + // XREAD COUNT 2 STREAMS mystream writers 0-0 0-0 + // (see ResultProcessor.cs lines 2336-2358 for the redis-cli format) + var resp = "*2\r\n" + // 2 streams + // First stream: mystream + "*2\r\n" + + "$8\r\nmystream\r\n" + + "*2\r\n" + // 2 entries + "*2\r\n" + + "$15\r\n1526984818136-0\r\n" + + "*4\r\n" + + "$8\r\nduration\r\n$4\r\n1532\r\n$8\r\nevent-id\r\n$1\r\n5\r\n" + + "*2\r\n" + + "$15\r\n1526999352406-0\r\n" + + "*4\r\n" + + "$8\r\nduration\r\n$3\r\n812\r\n$8\r\nevent-id\r\n$1\r\n9\r\n" + + // Second stream: writers + "*2\r\n" + + "$7\r\nwriters\r\n" + + "*2\r\n" + // 2 entries + "*2\r\n" + + "$15\r\n1526985676425-0\r\n" + + "*4\r\n" + + "$4\r\nname\r\n$8\r\nVirginia\r\n$7\r\nsurname\r\n$5\r\nWoolf\r\n" + + "*2\r\n" + + "$15\r\n1526985685298-0\r\n" + + "*4\r\n" + + "$4\r\nname\r\n$4\r\nJane\r\n$7\r\nsurname\r\n$6\r\nAusten\r\n"; + + var processor = ResultProcessor.MultiStream; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(2, result.Length); + + // First stream: mystream + Assert.Equal("mystream", (string?)result[0].Key); + Assert.Equal(2, result[0].Entries.Length); + Assert.Equal("1526984818136-0", (string?)result[0].Entries[0].Id); + Assert.Equal("duration", (string?)result[0].Entries[0].Values[0].Name); + Assert.Equal("1532", (string?)result[0].Entries[0].Values[0].Value); + Assert.Equal("event-id", (string?)result[0].Entries[0].Values[1].Name); + Assert.Equal("5", (string?)result[0].Entries[0].Values[1].Value); + Assert.Equal("1526999352406-0", (string?)result[0].Entries[1].Id); + Assert.Equal("duration", (string?)result[0].Entries[1].Values[0].Name); + Assert.Equal("812", (string?)result[0].Entries[1].Values[0].Value); + + // Second stream: writers + Assert.Equal("writers", (string?)result[1].Key); + Assert.Equal(2, result[1].Entries.Length); + Assert.Equal("1526985676425-0", (string?)result[1].Entries[0].Id); + Assert.Equal("name", (string?)result[1].Entries[0].Values[0].Name); + Assert.Equal("Virginia", (string?)result[1].Entries[0].Values[0].Value); + Assert.Equal("surname", (string?)result[1].Entries[0].Values[1].Name); + Assert.Equal("Woolf", (string?)result[1].Entries[0].Values[1].Value); + Assert.Equal("1526985685298-0", (string?)result[1].Entries[1].Id); + Assert.Equal("name", (string?)result[1].Entries[1].Values[0].Name); + Assert.Equal("Jane", (string?)result[1].Entries[1].Values[0].Value); + Assert.Equal("surname", (string?)result[1].Entries[1].Values[1].Name); + Assert.Equal("Austen", (string?)result[1].Entries[1].Values[1].Value); + } + + // XREADGROUP tests - same format as XREAD (uses MultiStream processor) + // RESP2: Array reply with [stream_name, array of entries] + // RESP3: Map reply with key-value pairs + [Theory] + [InlineData(RedisProtocol.Resp2, "*1\r\n*2\r\n$8\r\nmystream\r\n*1\r\n*2\r\n$3\r\n1-0\r\n*2\r\n$7\r\nmyfield\r\n$6\r\nmydata\r\n")] + [InlineData(RedisProtocol.Resp3, "%1\r\n$8\r\nmystream\r\n*1\r\n*2\r\n$3\r\n1-0\r\n*2\r\n$7\r\nmyfield\r\n$6\r\nmydata\r\n")] + public void MultiStreamProcessor_XReadGroup_SingleStreamSingleEntry(RedisProtocol protocol, string resp) + { + // XREADGROUP GROUP mygroup myconsumer STREAMS mystream > + // 1) 1) "mystream" + // 2) 1) 1) "1-0" + // 2) 1) "myfield" + // 2) "mydata" + var processor = ResultProcessor.MultiStream; + var result = Execute(resp, processor, protocol: protocol); + + Assert.NotNull(result); + Assert.Single(result); + Assert.Equal("mystream", (string?)result[0].Key); + Assert.Single(result[0].Entries); + Assert.Equal("1-0", (string?)result[0].Entries[0].Id); + Assert.Single(result[0].Entries[0].Values); + Assert.Equal("myfield", (string?)result[0].Entries[0].Values[0].Name); + Assert.Equal("mydata", (string?)result[0].Entries[0].Values[0].Value); + } + + [Theory] + [InlineData(RedisProtocol.Resp2, "*1\r\n*2\r\n$8\r\nmystream\r\n*1\r\n*2\r\n$3\r\n1-0\r\n*-1\r\n")] + [InlineData(RedisProtocol.Resp3, "%1\r\n$8\r\nmystream\r\n*1\r\n*2\r\n$3\r\n1-0\r\n_\r\n")] + public void MultiStreamProcessor_XReadGroup_PendingMessageWithNilValues(RedisProtocol protocol, string resp) + { + // XREADGROUP GROUP mygroup myconsumer STREAMS mystream 0 + // Reading pending messages returns nil for values if already acknowledged + // 1) 1) "mystream" + // 2) 1) 1) "1-0" + // 2) (nil) + var processor = ResultProcessor.MultiStream; + var result = Execute(resp, processor, protocol: protocol); + + Assert.NotNull(result); + Assert.Single(result); + Assert.Equal("mystream", (string?)result[0].Key); + Assert.Single(result[0].Entries); + Assert.Equal("1-0", (string?)result[0].Entries[0].Id); + Assert.Empty(result[0].Entries[0].Values); // nil becomes empty array + } + + [Theory] + [InlineData(RedisProtocol.Resp2, "*-1\r\n")] + [InlineData(RedisProtocol.Resp3, "_\r\n")] + public void MultiStreamProcessor_XReadGroup_Timeout(RedisProtocol protocol, string resp) + { + // XREADGROUP with BLOCK that times out returns nil/null + var processor = ResultProcessor.MultiStream; + var result = Execute(resp, processor, protocol: protocol); + + Assert.NotNull(result); + Assert.Empty(result); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/TimeSpan.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/TimeSpan.cs new file mode 100644 index 000000000..daf173300 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/TimeSpan.cs @@ -0,0 +1,100 @@ +using System; +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +/// +/// Tests for TimeSpanProcessor +/// +public class TimeSpanTests(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData(":0\r\n", 0)] + [InlineData(":1\r\n", 1)] + [InlineData(":1000\r\n", 1000)] + [InlineData(":60\r\n", 60)] + [InlineData(":3600\r\n", 3600)] + public void TimeSpanFromSeconds_ValidInteger(string resp, long seconds) + { + var processor = ResultProcessor.TimeSpanFromSeconds; + var result = Execute(resp, processor); + Assert.NotNull(result); + Assert.Equal(TimeSpan.FromSeconds(seconds), result.Value); + } + + [Theory] + [InlineData(":0\r\n", 0)] + [InlineData(":1\r\n", 1)] + [InlineData(":1000\r\n", 1000)] + [InlineData(":60000\r\n", 60000)] + [InlineData(":3600000\r\n", 3600000)] + public void TimeSpanFromMilliseconds_ValidInteger(string resp, long milliseconds) + { + var processor = ResultProcessor.TimeSpanFromMilliseconds; + var result = Execute(resp, processor); + Assert.NotNull(result); + Assert.Equal(TimeSpan.FromMilliseconds(milliseconds), result.Value); + } + + [Theory] + [InlineData(":-1\r\n")] + [InlineData(":-2\r\n")] + [InlineData(":-100\r\n")] + public void TimeSpanFromSeconds_NegativeInteger_ReturnsNull(string resp) + { + var processor = ResultProcessor.TimeSpanFromSeconds; + var result = Execute(resp, processor); + Assert.Null(result); + } + + [Theory] + [InlineData(":-1\r\n")] + [InlineData(":-2\r\n")] + [InlineData(":-100\r\n")] + public void TimeSpanFromMilliseconds_NegativeInteger_ReturnsNull(string resp) + { + var processor = ResultProcessor.TimeSpanFromMilliseconds; + var result = Execute(resp, processor); + Assert.Null(result); + } + + [Theory] + [InlineData("$-1\r\n")] // RESP2 null bulk string + [InlineData("_\r\n")] // RESP3 null + public void TimeSpanFromSeconds_Null_ReturnsNull(string resp) + { + var processor = ResultProcessor.TimeSpanFromSeconds; + var result = Execute(resp, processor); + Assert.Null(result); + } + + [Theory] + [InlineData("$-1\r\n")] // RESP2 null bulk string + [InlineData("_\r\n")] // RESP3 null + public void TimeSpanFromMilliseconds_Null_ReturnsNull(string resp) + { + var processor = ResultProcessor.TimeSpanFromMilliseconds; + var result = Execute(resp, processor); + Assert.Null(result); + } + + [Theory] + [InlineData("+OK\r\n")] + [InlineData("$2\r\nOK\r\n")] + [InlineData("*2\r\n:1\r\n:2\r\n")] + public void TimeSpanFromSeconds_InvalidType(string resp) + { + var processor = ResultProcessor.TimeSpanFromSeconds; + ExecuteUnexpected(resp, processor); + } + + [Theory] + [InlineData("+OK\r\n")] + [InlineData("$2\r\nOK\r\n")] + [InlineData("*2\r\n:1\r\n:2\r\n")] + public void TimeSpanFromMilliseconds_InvalidType(string resp) + { + var processor = ResultProcessor.TimeSpanFromMilliseconds; + ExecuteUnexpected(resp, processor); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Timing.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Timing.cs new file mode 100644 index 000000000..644ca9ef2 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/Timing.cs @@ -0,0 +1,27 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class Timing(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData("+OK\r\n")] + [InlineData(":42\r\n")] + [InlineData(":0\r\n")] + [InlineData(":-1\r\n")] + [InlineData("$5\r\nhello\r\n")] + [InlineData("$0\r\n\r\n")] + [InlineData("$-1\r\n")] + [InlineData("*2\r\n:1\r\n:2\r\n")] + [InlineData("*0\r\n")] + [InlineData("_\r\n")] + public void Timing_ValidResponse_ReturnsTimeSpan(string resp) + { + var processor = ResultProcessor.ResponseTimer; + var message = ResultProcessor.TimingProcessor.CreateMessage(-1, CommandFlags.None, RedisCommand.PING); + var result = Execute(resp, processor, message); + + Assert.NotEqual(System.TimeSpan.MaxValue, result); + Assert.True(result >= System.TimeSpan.Zero); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/TracerProcessor.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/TracerProcessor.cs new file mode 100644 index 000000000..606f51242 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/TracerProcessor.cs @@ -0,0 +1,30 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class TracerProcessor(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Fact] + public void Ping_Pong_Success() + { + // PING response - simple string + var resp = "+PONG\r\n"; + var message = Message.Create(-1, default, RedisCommand.PING); + + var result = Execute(resp, ResultProcessor.Tracer, message); + + Assert.True(result); + } + + [Fact] + public void Time_Success() + { + // TIME response - array of 2 elements + var resp = "*2\r\n$10\r\n1609459200\r\n$6\r\n123456\r\n"; + var message = Message.Create(-1, default, RedisCommand.TIME); + + var result = Execute(resp, ResultProcessor.Tracer, message); + + Assert.True(result); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/TrackSubscriptions.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/TrackSubscriptions.cs new file mode 100644 index 000000000..ceb82cb25 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/TrackSubscriptions.cs @@ -0,0 +1,19 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class TrackSubscriptions(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData("*3\r\n$9\r\nsubscribe\r\n$7\r\nchannel\r\n:1\r\n", 1)] // SUBSCRIBE response with count 1 + [InlineData("*3\r\n$9\r\nsubscribe\r\n$7\r\nchannel\r\n:5\r\n", 5)] // SUBSCRIBE response with count 5 + [InlineData("*3\r\n$11\r\nunsubscribe\r\n$7\r\nchannel\r\n:0\r\n", 0)] // UNSUBSCRIBE response with count 0 + [InlineData("*3\r\n$10\r\npsubscribe\r\n$8\r\npattern*\r\n:2\r\n", 2)] // PSUBSCRIBE response with count 2 + public void TrackSubscriptions_Success(string resp, int expectedCount) + { + var processor = ResultProcessor.TrackSubscriptions; + var result = Execute(resp, processor); + Assert.True(result); + Log($"Successfully parsed subscription response with count {expectedCount}"); + } +} diff --git a/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/VectorSet.cs b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/VectorSet.cs new file mode 100644 index 000000000..8b54e2e2e --- /dev/null +++ b/tests/StackExchange.Redis.Tests/ResultProcessorUnitTests/VectorSet.cs @@ -0,0 +1,190 @@ +using Xunit; + +namespace StackExchange.Redis.Tests.ResultProcessorUnitTests; + +public class VectorSet(ITestOutputHelper log) : ResultProcessorUnitTest(log) +{ + [Theory] + [InlineData("*0\r\n")] // empty array + [InlineData("*12\r\n$4\r\nsize\r\n:100\r\n$8\r\nvset-uid\r\n:42\r\n$9\r\nmax-level\r\n:5\r\n$10\r\nvector-dim\r\n:128\r\n$10\r\nquant-type\r\n$4\r\nint8\r\n$17\r\nhnsw-max-node-uid\r\n:99\r\n")] // full info with int8 + public void VectorSetInfo_ValidInput(string resp) + { + var processor = ResultProcessor.VectorSetInfo; + var result = Execute(resp, processor); + + Assert.NotNull(result); + } + + [Fact] + public void VectorSetInfo_EmptyArray_ReturnsDefaults() + { + // Empty array should return VectorSetInfo with default values + var resp = "*0\r\n"; + var processor = ResultProcessor.VectorSetInfo; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(VectorSetQuantization.Unknown, result.Value.Quantization); + Assert.Null(result.Value.QuantizationRaw); + Assert.Equal(0, result.Value.Dimension); + Assert.Equal(0, result.Value.Length); + Assert.Equal(0, result.Value.MaxLevel); + Assert.Equal(0, result.Value.VectorSetUid); + Assert.Equal(0, result.Value.HnswMaxNodeUid); + } + + [Theory] + [InlineData("*-1\r\n")] // null array (RESP2) + [InlineData("_\r\n")] // null (RESP3) + public void VectorSetInfo_NullArray(string resp) + { + var processor = ResultProcessor.VectorSetInfo; + var result = Execute(resp, processor); + + Assert.Null(result); + } + + [Fact] + public void VectorSetInfo_ValidatesContent_Int8() + { + // VINFO response with int8 quantization + var resp = "*12\r\n$4\r\nsize\r\n:100\r\n$8\r\nvset-uid\r\n:42\r\n$9\r\nmax-level\r\n:5\r\n$10\r\nvector-dim\r\n:128\r\n$10\r\nquant-type\r\n$4\r\nint8\r\n$17\r\nhnsw-max-node-uid\r\n:99\r\n"; + var processor = ResultProcessor.VectorSetInfo; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(VectorSetQuantization.Int8, result.Value.Quantization); + Assert.Null(result.Value.QuantizationRaw); + Assert.Equal(128, result.Value.Dimension); + Assert.Equal(100, result.Value.Length); + Assert.Equal(5, result.Value.MaxLevel); + Assert.Equal(42, result.Value.VectorSetUid); + Assert.Equal(99, result.Value.HnswMaxNodeUid); + } + + [Fact] + public void VectorSetInfo_SkipsNonScalarValues() + { + // Response with a non-scalar value (array) that should be skipped + // Format: size:100, unknown-field:[1,2,3], vset-uid:42 + var resp = "*6\r\n$4\r\nsize\r\n:100\r\n$13\r\nunknown-field\r\n*3\r\n:1\r\n:2\r\n:3\r\n$8\r\nvset-uid\r\n:42\r\n"; + var processor = ResultProcessor.VectorSetInfo; + var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(100, result.Value.Length); + Assert.Equal(42, result.Value.VectorSetUid); + // Other fields should have default values + Assert.Equal(VectorSetQuantization.Unknown, result.Value.Quantization); + Assert.Equal(0, result.Value.Dimension); + } + + [Fact] + public void VectorSetLinks_EmptyArray() + { + // VLINKS returns empty array + var resp = "*0\r\n"; + var processor = ResultProcessor.VectorSetLinks; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(0, result.Length); + } + + [Theory] + [InlineData("*-1\r\n")] // null array (RESP2) + [InlineData("_\r\n")] // null (RESP3) + public void VectorSetLinks_NullArray(string resp) + { + var processor = ResultProcessor.VectorSetLinks; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(0, result.Length); + } + + [Fact] + public void VectorSetLinks_SingleNestedArray() + { + // VLINKS returns [[element1]] + var resp = "*1\r\n*1\r\n$8\r\nelement1\r\n"; + var processor = ResultProcessor.VectorSetLinks; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(1, result.Length); + Assert.Equal("element1", result.Span[0].ToString()); + } + + [Fact] + public void VectorSetLinks_MultipleNestedArrays() + { + // VLINKS returns [[element1], [element2, element3], [element4]] + var resp = "*3\r\n*1\r\n$8\r\nelement1\r\n*2\r\n$8\r\nelement2\r\n$8\r\nelement3\r\n*1\r\n$8\r\nelement4\r\n"; + var processor = ResultProcessor.VectorSetLinks; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(4, result.Length); + Assert.Equal("element1", result.Span[0].ToString()); + Assert.Equal("element2", result.Span[1].ToString()); + Assert.Equal("element3", result.Span[2].ToString()); + Assert.Equal("element4", result.Span[3].ToString()); + } + + [Fact] + public void VectorSetLinksWithScores_EmptyArray() + { + // VLINKS WITHSCORES returns empty array + var resp = "*0\r\n"; + var processor = ResultProcessor.VectorSetLinksWithScores; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(0, result.Length); + } + + [Theory] + [InlineData("*-1\r\n")] // null array (RESP2) + [InlineData("_\r\n")] // null (RESP3) + public void VectorSetLinksWithScores_NullArray(string resp) + { + var processor = ResultProcessor.VectorSetLinksWithScores; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(0, result.Length); + } + + [Fact] + public void VectorSetLinksWithScores_SingleNestedArray() + { + // VLINKS WITHSCORES returns [[element1, score1]] + var resp = "*1\r\n*2\r\n$8\r\nelement1\r\n$3\r\n1.5\r\n"; + var processor = ResultProcessor.VectorSetLinksWithScores; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(1, result.Length); + Assert.Equal("element1", result.Span[0].Member.ToString()); + Assert.Equal(1.5, result.Span[0].Score); + } + + [Fact] + public void VectorSetLinksWithScores_MultipleNestedArrays() + { + // VLINKS WITHSCORES returns [[element1, score1], [element2, score2], [element3, score3]] + var resp = "*3\r\n*2\r\n$8\r\nelement1\r\n$3\r\n1.5\r\n*2\r\n$8\r\nelement2\r\n$3\r\n2.5\r\n*2\r\n$8\r\nelement3\r\n$3\r\n3.5\r\n"; + var processor = ResultProcessor.VectorSetLinksWithScores; + using var result = Execute(resp, processor); + + Assert.NotNull(result); + Assert.Equal(3, result.Length); + Assert.Equal("element1", result.Span[0].Member.ToString()); + Assert.Equal(1.5, result.Span[0].Score); + Assert.Equal("element2", result.Span[1].Member.ToString()); + Assert.Equal(2.5, result.Span[1].Score); + Assert.Equal("element3", result.Span[2].Member.ToString()); + Assert.Equal(3.5, result.Span[2].Score); + } +} diff --git a/tests/StackExchange.Redis.Tests/RoundTripUnitTests/AdhocMessageRoundTrip.cs b/tests/StackExchange.Redis.Tests/RoundTripUnitTests/AdhocMessageRoundTrip.cs new file mode 100644 index 000000000..34d41e884 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/RoundTripUnitTests/AdhocMessageRoundTrip.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Threading.Tasks; +using Xunit; + +namespace StackExchange.Redis.Tests.RoundTripUnitTests; + +public class AdHocMessageRoundTrip(ITestOutputHelper log) +{ + public enum MapMode + { + Null, + Default, + Disabled, + Renamed, + } + + [Theory(Timeout = 1000)] + [InlineData(MapMode.Null, "", "*1\r\n$4\r\nECHO\r\n")] + [InlineData(MapMode.Default, "", "*1\r\n$4\r\nECHO\r\n")] + [InlineData(MapMode.Disabled, "", "")] + [InlineData(MapMode.Renamed, "", "*1\r\n$5\r\nECHO2\r\n")] + [InlineData(MapMode.Null, "hello", "*2\r\n$4\r\nECHO\r\n$5\r\nhello\r\n")] + [InlineData(MapMode.Default, "hello", "*2\r\n$4\r\nECHO\r\n$5\r\nhello\r\n")] + [InlineData(MapMode.Disabled, "hello", "")] + [InlineData(MapMode.Renamed, "hello", "*2\r\n$5\r\nECHO2\r\n$5\r\nhello\r\n")] + public async Task EchoRoundTripTest(MapMode mode, string payload, string requestResp) + { + var map = GetMap(mode); + + object[] args = string.IsNullOrEmpty(payload) ? [] : [payload]; + if (mode is MapMode.Disabled) + { + var ex = Assert.Throws(() => new RedisDatabase.ExecuteMessage(map, -1, CommandFlags.None, "echo", args)); + Assert.StartsWith(ex.Message, "This operation has been disabled in the command-map and cannot be used: echo"); + } + else + { + var msg = new RedisDatabase.ExecuteMessage(map, -1, CommandFlags.None, "echo", args); + Assert.Equal(RedisCommand.ECHO, msg.Command); // in v3: this is recognized correctly + + Assert.Equal("ECHO", msg.CommandAndKey); + Assert.Equal("ECHO", msg.CommandString); + var result = + await TestConnection.ExecuteAsync(msg, ResultProcessor.ScriptResult, requestResp, ":5\r\n", commandMap: map, log: log); + Assert.Equal(ResultType.Integer, result.Resp3Type); + Assert.Equal(5, result.AsInt32()); + } + } + + private static CommandMap? GetMap(MapMode mode) => mode switch + { + MapMode.Null => null, + MapMode.Default => CommandMap.Default, + MapMode.Disabled => CommandMap.Create(new HashSet { "echo", "custom" }, available: false), + MapMode.Renamed => CommandMap.Create(new Dictionary { { "echo", "echo2" }, { "custom", "custom2" } }), + _ => throw new ArgumentOutOfRangeException(nameof(mode)), + }; + + [Theory(Timeout = 1000)] + [InlineData(MapMode.Null, "", "*1\r\n$6\r\nCUSTOM\r\n")] + [InlineData(MapMode.Default, "", "*1\r\n$6\r\nCUSTOM\r\n")] + // [InlineData(MapMode.Disabled, "", "")] + // [InlineData(MapMode.Renamed, "", "*1\r\n$7\r\nCUSTOM2\r\n")] + [InlineData(MapMode.Null, "hello", "*2\r\n$6\r\nCUSTOM\r\n$5\r\nhello\r\n")] + [InlineData(MapMode.Default, "hello", "*2\r\n$6\r\nCUSTOM\r\n$5\r\nhello\r\n")] + // [InlineData(MapMode.Disabled, "hello", "")] + // [InlineData(MapMode.Renamed, "hello", "*2\r\n$7\r\nCUSTOM2\r\n$5\r\nhello\r\n")] + public async Task CustomRoundTripTest(MapMode mode, string payload, string requestResp) + { + var map = GetMap(mode); + + object[] args = string.IsNullOrEmpty(payload) ? [] : [payload]; + if (mode is MapMode.Disabled) + { + var ex = Assert.Throws(() => new RedisDatabase.ExecuteMessage(map, -1, CommandFlags.None, "custom", args)); + Assert.StartsWith(ex.Message, "This operation has been disabled in the command-map and cannot be used: custom"); + } + else + { + var msg = new RedisDatabase.ExecuteMessage(map, -1, CommandFlags.None, "custom", args); + Assert.Equal(RedisCommand.UNKNOWN, msg.Command); + + Assert.Equal("custom", msg.CommandAndKey); + Assert.Equal("custom", msg.CommandString); + var result = + await TestConnection.ExecuteAsync(msg, ResultProcessor.ScriptResult, requestResp, ":5\r\n", commandMap: map, log: log); + Assert.Equal(ResultType.Integer, result.Resp3Type); + Assert.Equal(5, result.AsInt32()); + } + } +} diff --git a/tests/StackExchange.Redis.Tests/RoundTripUnitTests/EchoRoundTrip.cs b/tests/StackExchange.Redis.Tests/RoundTripUnitTests/EchoRoundTrip.cs new file mode 100644 index 000000000..7ed8e70c8 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/RoundTripUnitTests/EchoRoundTrip.cs @@ -0,0 +1,17 @@ +using System.Threading.Tasks; +using Xunit; + +namespace StackExchange.Redis.Tests.RoundTripUnitTests; + +public class EchoRoundTrip +{ + [Theory(Timeout = 5000)] + [InlineData("hello", "*2\r\n$4\r\nECHO\r\n$5\r\nhello\r\n", "+hello\r\n")] + [InlineData("hello", "*2\r\n$4\r\nECHO\r\n$5\r\nhello\r\n", "$5\r\nhello\r\n")] + public async Task EchoRoundTripTest(string payload, string requestResp, string responseResp) + { + var msg = Message.Create(-1, CommandFlags.None, RedisCommand.ECHO, (RedisValue)payload); + var result = await TestConnection.ExecuteAsync(msg, ResultProcessor.String, requestResp, responseResp); + Assert.Equal(payload, result); + } +} diff --git a/tests/StackExchange.Redis.Tests/RoundTripUnitTests/TestConnection.cs b/tests/StackExchange.Redis.Tests/RoundTripUnitTests/TestConnection.cs new file mode 100644 index 000000000..ea7c90d29 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/RoundTripUnitTests/TestConnection.cs @@ -0,0 +1,142 @@ +using System; +using System.Buffers; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using RESPite.Tests; +using Xunit; + +namespace StackExchange.Redis.Tests.RoundTripUnitTests; + +public static class CancellationTokenExtensions +{ + public static CancellationTokenRegistration CancelWithTest(this TaskCompletionSource tcs) + => CancelWith(tcs, TestContext.Current.CancellationToken); + public static CancellationTokenRegistration CancelWith(this TaskCompletionSource tcs, CancellationToken token) + { + if (token.CanBeCanceled) + { + token.ThrowIfCancellationRequested(); + return token.Register(() => tcs.TrySetCanceled(token)); // note capture for token: deal with it + } + + return default; + } +} + +public class TestConnection : IDisposable +{ + internal static async Task ExecuteAsync( + Message message, + ResultProcessor processor, + string requestResp, + string responseResp, + ConnectionType connectionType = ConnectionType.Interactive, + RedisProtocol protocol = RedisProtocol.Resp2, + CommandMap? commandMap = null, + byte[]? channelPrefix = null, + ITestOutputHelper? log = null, + WriteMode writeMode = WriteMode.Default, + [CallerMemberName] string caller = "") + { + // Validate RESP samples are not null/empty to avoid test setup mistakes + Assert.False(string.IsNullOrEmpty(responseResp), "responseResp must not be null or empty"); + + using var conn = new TestConnection(false, writeMode, connectionType, protocol, log, caller); + + var box = TaskResultBox.Create(out var tcs, null); + using var timeout = tcs.CancelWithTest(); + + message.SetSource(box, processor); + conn.WriteOutbound(message, commandMap, channelPrefix); + Assert.Equal(TaskStatus.WaitingForActivation, tcs.Task.Status); // should be pending, since we haven't responded yet + await conn.CompleteOutputAsync(); + + // check the request + conn.AssertOutbound(requestResp); + + // since the request was good, we can start reading + conn.StartReading(); + await conn.AddInboundAsync(responseResp); + return await tcs.Task; + } + + private Task CompleteOutputAsync(Exception? exception = null) => _physical.CompleteOutputAsync(exception); + + public TestConnection( + bool startReading = true, + WriteMode writeMode = WriteMode.Default, + ConnectionType connectionType = ConnectionType.Interactive, + RedisProtocol protocol = RedisProtocol.Resp2, + ITestOutputHelper? log = null, + [CallerMemberName] string caller = "") + { + _physical = new PhysicalConnection(connectionType, protocol, _stream, (BufferedStreamWriter.WriteMode)writeMode, caller); + _log = log; + if (startReading) StartReading(); + } + private readonly TestDuplexStream _stream = new(); + private readonly PhysicalConnection _physical; + private readonly ITestOutputHelper? _log; + + public void StartReading() => _physical.StartReading(TestContext.Current.CancellationToken); + + public ReadOnlySpan GetOutboundData() => _stream.GetOutboundData(); + public void FlushOutboundData() => _stream.FlushOutboundData(); + public ValueTask AddInboundAsync(ReadOnlyMemory data, CancellationToken cancellationToken = default) + => _stream.AddInboundAsync(data, cancellationToken); + public ValueTask AddInboundAsync(ReadOnlySpan data, CancellationToken cancellationToken = default) + => _stream.AddInboundAsync(data, cancellationToken); + public ValueTask AddInboundAsync(string data, CancellationToken cancellationToken = default) + => _stream.AddInboundAsync(data, cancellationToken); + + public void Dispose() + { + _physical.Dispose(); + _stream.Dispose(); + } + + internal void WriteOutbound(Message message, CommandMap? commandMap = null, byte[]? channelPrefix = null) + { + _physical.EnqueueInsideWriteLock(message, enforceMuxer: false); + message.WriteTo(_physical, commandMap ?? CommandMap.Default, channelPrefix); + } + + public void AssertOutbound(string expected) + { + // Check max char count and lease a char buffer + var actual = GetOutboundData(); + var maxCharCount = Encoding.UTF8.GetMaxCharCount(actual.Length); + char[]? leased = null; + Span charBuffer = maxCharCount <= 256 + ? stackalloc char[maxCharCount] + : (leased = ArrayPool.Shared.Rent(maxCharCount)); + + try + { + // Decode into the buffer + var actualCharCount = Encoding.UTF8.GetChars(actual, charBuffer); + var actualChars = charBuffer.Slice(0, actualCharCount); + + // Use SequenceEqual to compare + if (actualChars.SequenceEqual(expected.AsSpan())) + { + return; // Success - no allocation needed + } + + // Only if comparison fails: allocate string for useful error message + var actualString = actualChars.ToString(); + _log?.WriteLine("Expected: {0}", expected); + _log?.WriteLine("Actual: {0}", actualString); + Assert.Equal(expected, actualString); + } + finally + { + if (leased != null) + { + ArrayPool.Shared.Return(leased); + } + } + } +} diff --git a/tests/StackExchange.Redis.Tests/SSLTests.cs b/tests/StackExchange.Redis.Tests/SSLTests.cs index f068e0aae..731701755 100644 --- a/tests/StackExchange.Redis.Tests/SSLTests.cs +++ b/tests/StackExchange.Redis.Tests/SSLTests.cs @@ -126,7 +126,7 @@ public async Task ConnectToSSLServer(bool useSsl, bool specifyHost) { conn.ExportConfiguration(file); } - RedisKey key = "SE.Redis"; + RedisKey key = Me(); const int AsyncLoop = 2000; // perf; async diff --git a/tests/StackExchange.Redis.Tests/ScriptingTests.cs b/tests/StackExchange.Redis.Tests/ScriptingTests.cs index 6416e32ad..6f6ad319b 100644 --- a/tests/StackExchange.Redis.Tests/ScriptingTests.cs +++ b/tests/StackExchange.Redis.Tests/ScriptingTests.cs @@ -1081,11 +1081,12 @@ public async Task TestEvalReadonly() var db = conn.GetDatabase(); string script = "return KEYS[1]"; - RedisKey[] keys = ["key1"]; + RedisKey key = Me(); + RedisKey[] keys = [key]; RedisValue[] values = ["first"]; var result = db.ScriptEvaluateReadOnly(script, keys, values); - Assert.Equal("key1", result.ToString()); + Assert.Equal(key.ToString(), result.ToString()); } [Fact] @@ -1095,11 +1096,12 @@ public async Task TestEvalReadonlyAsync() var db = conn.GetDatabase(); string script = "return KEYS[1]"; - RedisKey[] keys = ["key1"]; + RedisKey key = Me(); + RedisKey[] keys = [key]; RedisValue[] values = ["first"]; var result = await db.ScriptEvaluateReadOnlyAsync(script, keys, values); - Assert.Equal("key1", result.ToString()); + Assert.Equal(key.ToString(), result.ToString()); } [Fact] diff --git a/tests/StackExchange.Redis.Tests/SentinelTests.cs b/tests/StackExchange.Redis.Tests/SentinelTests.cs index e58f530fd..039df4335 100644 --- a/tests/StackExchange.Redis.Tests/SentinelTests.cs +++ b/tests/StackExchange.Redis.Tests/SentinelTests.cs @@ -469,7 +469,7 @@ public async Task ReadOnlyConnectionReplicasTest() await UntilConditionAsync(TimeSpan.FromSeconds(2), () => readonlyConn.IsConnected); Assert.True(readonlyConn.IsConnected); var db = readonlyConn.GetDatabase(); - var s = db.StringGet("test"); + var s = db.StringGet(Me()); Assert.True(s.IsNullOrEmpty); } } diff --git a/tests/StackExchange.Redis.Tests/SortedSetTests.cs b/tests/StackExchange.Redis.Tests/SortedSetTests.cs index 4dfa3be37..684ecf0bf 100644 --- a/tests/StackExchange.Redis.Tests/SortedSetTests.cs +++ b/tests/StackExchange.Redis.Tests/SortedSetTests.cs @@ -1123,7 +1123,8 @@ public async Task SortedSetMultiPopMultiKey() var db = conn.GetDatabase(); var key = Me(); - db.KeyDelete(key); + RedisKey[] keys = [key + ":missing1", key, key + ":missing2"]; + db.KeyDelete(keys); db.SortedSetAdd( key, @@ -1135,14 +1136,14 @@ public async Task SortedSetMultiPopMultiKey() new SortedSetEntry("orioles", 52), ]); - var highest = db.SortedSetPop(["not a real key", key, "yet another not a real key"], 1, order: Order.Descending); + var highest = db.SortedSetPop(keys, 1, order: Order.Descending); Assert.False(highest.IsNull); Assert.Equal(key, highest.Key); var entry = Assert.Single(highest.Entries); Assert.Equal("rays", entry.Element); Assert.Equal(100, entry.Score); - var bottom2 = db.SortedSetPop(["not a real key", key, "yet another not a real key"], 2); + var bottom2 = db.SortedSetPop(keys, 2); Assert.False(bottom2.IsNull); Assert.Equal(key, bottom2.Key); Assert.Equal(2, bottom2.Entries.Length); @@ -1159,7 +1160,8 @@ public async Task SortedSetMultiPopNoSet() var db = conn.GetDatabase(); var key = Me(); - db.KeyDelete(key); + RedisKey[] keys = [key + ":missing1", key, key + ":missing2"]; + db.KeyDelete(keys); var res = db.SortedSetPop([key], 1); Assert.True(res.IsNull); } @@ -1183,7 +1185,8 @@ public async Task SortedSetMultiPopAsync() var db = conn.GetDatabase(); var key = Me(); - db.KeyDelete(key); + RedisKey[] keys = [key + ":missing1", key, key + ":missing2"]; + db.KeyDelete(keys); db.SortedSetAdd( key, @@ -1196,14 +1199,14 @@ public async Task SortedSetMultiPopAsync() ]); var highest = await db.SortedSetPopAsync( - ["not a real key", key, "yet another not a real key"], 1, order: Order.Descending); + keys, 1, order: Order.Descending); Assert.False(highest.IsNull); Assert.Equal(key, highest.Key); var entry = Assert.Single(highest.Entries); Assert.Equal("rays", entry.Element); Assert.Equal(100, entry.Score); - var bottom2 = await db.SortedSetPopAsync(["not a real key", key, "yet another not a real key"], 2); + var bottom2 = await db.SortedSetPopAsync(keys, 2); Assert.False(bottom2.IsNull); Assert.Equal(key, bottom2.Key); Assert.Equal(2, bottom2.Entries.Length); diff --git a/tests/StackExchange.Redis.Tests/StackExchange.Redis.Tests.csproj b/tests/StackExchange.Redis.Tests/StackExchange.Redis.Tests.csproj index 1604d6905..c14c149d6 100644 --- a/tests/StackExchange.Redis.Tests/StackExchange.Redis.Tests.csproj +++ b/tests/StackExchange.Redis.Tests/StackExchange.Redis.Tests.csproj @@ -21,9 +21,12 @@ + + + + - @@ -31,11 +34,14 @@ + + + diff --git a/tests/StackExchange.Redis.Tests/SyncContextTests.cs b/tests/StackExchange.Redis.Tests/SyncContextTests.cs index 5feb37e3d..3c458ae47 100644 --- a/tests/StackExchange.Redis.Tests/SyncContextTests.cs +++ b/tests/StackExchange.Redis.Tests/SyncContextTests.cs @@ -1,11 +1,14 @@ using System; using System.IO; +using System.Linq; +using System.Text; using System.Threading; using System.Threading.Tasks; using Xunit; namespace StackExchange.Redis.Tests { + [RunPerProtocol] public class SyncContextTests(ITestOutputHelper testOutput) : TestBase(testOutput) { /* Note A (referenced below) @@ -72,6 +75,7 @@ public async Task SyncConfigure() using var ctx = new MySyncContext(Writer); await using var conn = Create(); Assert.Equal(0, ctx.OpCount); + // ReSharper disable once MethodHasAsyncOverload - very deliberate Assert.True(conn.Configure()); Assert.Equal(0, ctx.OpCount); } @@ -130,7 +134,7 @@ public MySyncContext(TextWriter log) public override void Post(SendOrPostCallback d, object? state) { - Log(_log, "sync-ctx: Post"); + Log(_log, $"sync-ctx: Post {Format(d, state)}"); Incr(); ThreadPool.QueueUserWorkItem( static state => @@ -143,14 +147,32 @@ public override void Post(SendOrPostCallback d, object? state) private void Invoke(SendOrPostCallback d, object? state) { - Log(_log, "sync-ctx: Invoke"); + Log(_log, $"sync-ctx: Invoke {Format(d, state)}"); if (!IsCurrent) SetSynchronizationContext(this); d(state); } + private static string Format(SendOrPostCallback? d, object? state) + { + if (d is null) return ""; + string name = d.IsSingle() ? d.Method.Name : GetNames(d); + return state is null ? name : $"{name}:{state}"; + + static string GetNames(SendOrPostCallback d) + { + var sb = new StringBuilder(); + foreach (var x in d.AsEnumerable()) + { + if (sb.Length != 0) sb.Append(","); + sb.Append(x.Method.Name); + } + return sb.ToString(); + } + } + public override void Send(SendOrPostCallback d, object? state) { - Log(_log, "sync-ctx: Send"); + Log(_log, $"sync-ctx: Send {Format(d, state)}"); Incr(); Invoke(d, state); } diff --git a/tests/StackExchange.Redis.Tests/TcpKeepAliveTests.cs b/tests/StackExchange.Redis.Tests/TcpKeepAliveTests.cs index 5e226546e..a9ebeba05 100644 --- a/tests/StackExchange.Redis.Tests/TcpKeepAliveTests.cs +++ b/tests/StackExchange.Redis.Tests/TcpKeepAliveTests.cs @@ -31,7 +31,9 @@ public async Task Roundtrip(bool ip, bool keepAlive) log.WriteLine($"Connecting to {Format.ToString(ep)}, {ep.AddressFamily}, keepAlive: {keepAlive}"); if (keepAlive) { +#pragma warning disable CS0618 Assert.SkipUnless(SocketManager.TryEnableTcpKeepAlive(client, ep), "keep-alive not supported"); +#pragma warning restore CS0618 } await client.ConnectAsync(ep); diff --git a/tests/StackExchange.Redis.Tests/TestBase.cs b/tests/StackExchange.Redis.Tests/TestBase.cs index 0f3fa9a31..4106fba98 100644 --- a/tests/StackExchange.Redis.Tests/TestBase.cs +++ b/tests/StackExchange.Redis.Tests/TestBase.cs @@ -274,6 +274,7 @@ internal virtual IInternalConnectionMultiplexer Create( BacklogPolicy? backlogPolicy = null, Version? require = null, RedisProtocol? protocol = null, + bool allowSimulateConnectionFailure = false, [CallerMemberName] string caller = "") { if (Output == null) @@ -281,6 +282,7 @@ internal virtual IInternalConnectionMultiplexer Create( Assert.Fail("Failure: Be sure to call the TestBase constructor like this: BasicOpsTests(ITestOutputHelper output) : base(output) { }"); } + if (allowSimulateConnectionFailure) shared = false; // Default to protocol context if not explicitly passed in protocol ??= TestContext.Current.GetProtocol(); @@ -329,6 +331,7 @@ internal virtual IInternalConnectionMultiplexer Create( protocol, highIntegrity, tunnel, + allowSimulateConnectionFailure, caller); TestBase.ThrowIfIncorrectProtocol(conn, protocol); @@ -419,6 +422,7 @@ public static ConnectionMultiplexer CreateDefault( RedisProtocol? protocol = null, bool highIntegrity = false, Tunnel? tunnel = null, + bool allowSimulateConnectionFailure = false, [CallerMemberName] string caller = "") { StringWriter? localLog = null; @@ -456,6 +460,12 @@ public static ConnectionMultiplexer CreateDefault( if (backlogPolicy is not null) config.BacklogPolicy = backlogPolicy; if (protocol is not null) config.Protocol = protocol; if (highIntegrity) config.HighIntegrity = highIntegrity; + if (allowSimulateConnectionFailure) config.AllowSimulateConnectionFailure = allowSimulateConnectionFailure; + if (checkConnect) + { + config.AbortOnConnectFail = false; + config.ConnectRetry = 0; + } var watch = Stopwatch.StartNew(); var task = ConnectionMultiplexer.ConnectAsync(config, log); if (!task.Wait(config.ConnectTimeout >= (int.MaxValue / 2) ? int.MaxValue : config.ConnectTimeout * 2)) @@ -478,11 +488,9 @@ public static ConnectionMultiplexer CreateDefault( Log(output, "Connect took: " + watch.ElapsedMilliseconds + "ms"); } var conn = task.Result; - if (checkConnect && !conn.IsConnected) + if (checkConnect) { - // If fail is true, we throw. - Assert.False(fail, failMessage + "Server is not available"); - Assert.Skip(failMessage + "Server is not available"); + Assert.SkipUnless(conn.IsConnected, (failMessage ?? "") + "Unable to connect to server"); } if (output != null) { @@ -583,15 +591,19 @@ void Callback() } private static readonly TimeSpan DefaultWaitPerLoop = TimeSpan.FromMilliseconds(50); - protected static async Task UntilConditionAsync(TimeSpan maxWaitTime, Func predicate, TimeSpan? waitPerLoop = null) + protected static async Task UntilConditionAsync(TimeSpan maxWaitTime, Func predicate, TimeSpan? waitPerLoop = null) { + var cancellationToken = TestContext.Current.CancellationToken; + cancellationToken.ThrowIfCancellationRequested(); + var watch = Stopwatch.StartNew(); TimeSpan spent = TimeSpan.Zero; while (spent < maxWaitTime && !predicate()) { var wait = waitPerLoop ?? DefaultWaitPerLoop; - await Task.Delay(wait).ForAwait(); + await Task.Delay(wait, cancellationToken).ForAwait(); spent += wait; } + return watch.Elapsed; } // simplified usage to get an interchangeable dedicated vs shared in-process server, useful for debugging @@ -617,6 +629,21 @@ protected void SkipIfWouldUseRealServer(string? reason = null) Assert.SkipUnless(_inProcServerFixture != null || UseDedicatedInProcessServer, reason ?? "Real server is in use."); } + protected async Task AssertDebugCommandEnabledAsync(IConnectionMultiplexer muxer) + { + foreach (var ep in muxer.GetEndPoints()) + { + var server = muxer.GetServer(ep); + var config = await server.ConfigGetAsync("enable-debug-command").ForAwait(); + + var value = config.Length == 0 ? "" : config[0].Value; + Log($"Server {ep} enable-debug-command config: {value}"); + Assert.SkipUnless( + string.Equals(value, "yes", StringComparison.OrdinalIgnoreCase), + $"Server {ep} enable-debug-command config is '{value}'; DEBUG OBJECT requires 'yes'."); + } + } + internal sealed class ClientFactory : IDisposable, IAsyncDisposable { private readonly TestBase _testBase; @@ -645,6 +672,7 @@ public IInternalConnectionMultiplexer CreateClient() { var config = _server.GetClientConfig(); config.AllowAdmin = _allowAdmin; + config.Protocol = TestContext.Current.GetProtocol(); if (_channelPrefix is not null) { config.ChannelPrefix = RedisChannel.Literal(_channelPrefix); diff --git a/tests/StackExchange.Redis.Tests/TestHarnessTests.cs b/tests/StackExchange.Redis.Tests/TestHarnessTests.cs new file mode 100644 index 000000000..ab70adc18 --- /dev/null +++ b/tests/StackExchange.Redis.Tests/TestHarnessTests.cs @@ -0,0 +1,90 @@ +using System; +using Xunit; +using Xunit.Sdk; + +namespace StackExchange.Redis.Tests; + +// who watches the watchers? +public class TestHarnessTests +{ + // this bit isn't required, but: by subclassing TestHarness we can expose the idiomatic test-framework faults. + private sealed class XUnitTestHarness(CommandMap? commandMap = null, RedisChannel channelPrefix = default, RedisKey keyPrefix = default) + : TestHarness(commandMap, channelPrefix, keyPrefix) + { + protected override void OnValidateFail(string expected, string actual) + => Assert.Equal(expected, actual); + + protected override void OnValidateFail(ReadOnlyMemory expected, ReadOnlyMemory actual) + => Assert.Equal(expected, actual); + + protected override void OnValidateFail(in RedisKey expected, in RedisKey actual) + => Assert.Equal(expected, actual); + } + + [Fact] + public void BasicWrite_Bytes() + { + var resp = new XUnitTestHarness(); + resp.ValidateRouting(RedisKey.Null, "hello world"); + resp.ValidateResp( + "*2\r\n$4\r\nECHO\r\n$11\r\nhello world\r\n"u8, + "echo", + "hello world"); + } + [Fact] + public void BasicWrite_String() + { + var resp = new XUnitTestHarness(); + resp.ValidateRouting(RedisKey.Null, "hello world"); + resp.ValidateResp( + "*2\r\n$4\r\nECHO\r\n$11\r\nhello world\r\n", + "echo", + "hello world"); + } + + [Fact] + public void WithKeyPrefix() + { + var map = CommandMap.Create(new() { ["sEt"] = "put" }); + RedisKey key = "mykey"; + var resp = new XUnitTestHarness(keyPrefix: "123/", commandMap: map); + object[] args = { key, 42 }; + resp.ValidateRouting(key, args); + resp.ValidateResp("*3\r\n$3\r\nPUT\r\n$9\r\n123/mykey\r\n$2\r\n42\r\n", "set", args); + } + + [Fact] + public void CommandMapDeltas() + { + Assert.Equal("", CommandMap.Default.ToString()); + Assert.Equal("", CommandMap.Create(new() { ["sEt"] = "set" }).ToString()); + Assert.Equal("$SET=PUT", CommandMap.Create(new() { ["sEt"] = "put" }).ToString()); + Assert.Equal("$ECHO=", CommandMap.Create(new() { "echo" }, available: false).ToString()); + } + + [Fact] + public void WithKeyPrefix_DetectIncorrectUsage() + { + string key = "mykey"; // incorrectly not a key + var resp = new XUnitTestHarness(keyPrefix: "123/"); + object[] args = { key, 42 }; + var ex = Assert.Throws(() => resp.ValidateRouting(key, args)); + Assert.Contains("Expected: 123/mykey", ex.Message); + Assert.Contains("Actual: (null)", ex.Message); + + ex = Assert.Throws(() => resp.ValidateResp("*3\r\n$3\r\nSET\r\n$9\r\n123/mykey\r\n$2\r\n42\r\n", "set", args)); + Assert.Contains(@"Expected: ""*3\r\n$3\r\nSET\r\n$9\r\n123/mykey\r\n$2\r\n42\r\n""", ex.Message); + Assert.Contains(@"Actual: ""*3\r\n$3\r\nSET\r\n$5\r\nmykey\r\n$2\r\n42\r\n""", ex.Message); + } + + [Fact] + public void ParseExample() + { + var resp = new XUnitTestHarness(); + var result = resp.Read("*3\r\n:42\r\n#t\r\n$3\r\nabc\r\n"u8); + Assert.Equal(3, result.Length); + Assert.Equal(42, (int)result[0]); + Assert.True((bool)result[1]); + Assert.Equal("abc", (string?)result[2]); + } +} diff --git a/tests/StackExchange.Redis.Tests/TransactionTests.cs b/tests/StackExchange.Redis.Tests/TransactionTests.cs index 3a0f1e40e..f72d7b653 100644 --- a/tests/StackExchange.Redis.Tests/TransactionTests.cs +++ b/tests/StackExchange.Redis.Tests/TransactionTests.cs @@ -1339,10 +1339,10 @@ public async Task TransactionWithAdHocCommandsAndSelectDisabled() Assert.False(db.KeyExists(key)); var tran = db.CreateTransaction("state"); - var a = tran.ExecuteAsync("SET", "foo", "bar"); + var a = tran.ExecuteAsync("SET", key, "bar"); Assert.True(await tran.ExecuteAsync()); await a; - var setting = db.StringGet("foo"); + var setting = db.StringGet(key); Assert.Equal("bar", setting); } @@ -1431,4 +1431,47 @@ public async Task ExecCompletes_Issue943() Assert.Equal(0, hashMiss); Assert.Equal(0, expireMiss); } + + [Fact] + public async Task TransactionWithFailingInnerOperation() + { + RedisKey keyA = Me() + ":A", keyB = Me() + ":B", keyC = Me() + ":C"; + await using var conn = Create(); + var db = conn.GetDatabase(); + db.StringSet(keyA, "42", flags: CommandFlags.FireAndForget); + db.StringSet(keyB, "abc", flags: CommandFlags.FireAndForget); + db.StringSet(keyC, 13, flags: CommandFlags.FireAndForget); + + var tran = db.CreateTransaction(); + var pendingA = tran.StringIncrementAsync(keyA); + var pendingB = tran.StringIncrementAsync(keyB); + var pendingC = tran.StringIncrementAsync(keyC); + Assert.True(await tran.ExecuteAsync()); + Assert.Equal(43, await pendingA); + var ex = await Assert.ThrowsAsync(() => pendingB); + Assert.Contains("ERR value is not an integer or out of range", ex.Message); + Assert.Equal(14, await pendingC); + } + + [Fact] + public async Task TransactionWithFailingCondition() + { + RedisKey keyA = Me() + ":A", keyB = Me() + ":B", keyC = Me() + ":C"; + await using var conn = Create(); + var db = conn.GetDatabase(); + db.StringSet(keyA, "42", flags: CommandFlags.FireAndForget); + db.StringSet(keyB, "abc", flags: CommandFlags.FireAndForget); + db.StringSet(keyC, 13, flags: CommandFlags.FireAndForget); + + var tran = db.CreateTransaction(); + var condition = tran.AddCondition(Condition.HashExists(keyA, "field")); + var pendingA = tran.StringIncrementAsync(keyA); + var pendingB = tran.StringIncrementAsync(keyB); + var pendingC = tran.StringIncrementAsync(keyC); + Assert.False(await tran.ExecuteAsync()); + Assert.False(condition.WasSatisfied); + Assert.Equal(TaskStatus.Canceled, pendingB.Status); + Assert.Equal(TaskStatus.Canceled, pendingB.Status); + Assert.Equal(TaskStatus.Canceled, pendingC.Status); + } } diff --git a/tests/StackExchange.Redis.Tests/WriteFailureTeardownTests.cs b/tests/StackExchange.Redis.Tests/WriteFailureTeardownTests.cs index 1710dab5d..80ff7309c 100644 --- a/tests/StackExchange.Redis.Tests/WriteFailureTeardownTests.cs +++ b/tests/StackExchange.Redis.Tests/WriteFailureTeardownTests.cs @@ -1,36 +1,34 @@ using System; +using System.IO; using System.Threading; using System.Threading.Tasks; +using StackExchange.Redis.Tests.RoundTripUnitTests; using Xunit; namespace StackExchange.Redis.Tests; public class WriteFailureTeardownTests(ITestOutputHelper output) : TestBase(output) { - private sealed class ThrowingMessage : Message + private sealed class ThrowingMessage(Exception toThrow, int db = -1, CommandFlags flags = CommandFlags.None, RedisCommand command = RedisCommand.PING) + : Message(db, flags, command) { - private readonly Exception _toThrow; - public ThrowingMessage(int db, CommandFlags flags, RedisCommand command, Exception toThrow) - : base(db, flags, command) - { - _toThrow = toThrow; - } - public override int ArgCount => 0; - protected override void WriteImpl(PhysicalConnection physical) => throw _toThrow; + protected override void WriteImpl(in MessageWriter writer) => throw toThrow; } [Fact] public void WriteTo_PropagatesWriteImplException() { var inner = new InvalidOperationException("simulated write failure"); - var msg = new ThrowingMessage(-1, CommandFlags.None, RedisCommand.PING, inner); + var msg = new ThrowingMessage(inner); // The new behavior: WriteTo must rethrow so the bridge's outer catch can record a connection // failure. Passing null for physical is safe because WriteTo null-conditionals every member // access on it. - var thrown = Assert.Throws(() => msg.WriteTo(null!)); + using var ms = new MemoryStream(); + using var connection = PhysicalConnection.Dummy(ms); + var thrown = Assert.Throws(() => msg.WriteTo(connection)); Assert.Same(inner, thrown); } @@ -40,9 +38,10 @@ public void WriteTo_DoesNotWrapRedisCommandException() // RedisCommandException is excluded from the catch filter (it carries its own meaning), // so it must surface unchanged from WriteImpl through WriteTo. var inner = new RedisCommandException("intentional"); - var msg = new ThrowingMessage(-1, CommandFlags.None, RedisCommand.PING, inner); - - var thrown = Assert.Throws(() => msg.WriteTo(null!)); + var msg = new ThrowingMessage(inner); + using var ms = new MemoryStream(); + using var connection = PhysicalConnection.Dummy(ms); + var thrown = Assert.Throws(() => msg.WriteTo(connection)); Assert.Same(inner, thrown); } @@ -56,11 +55,11 @@ public async Task WriteFailure_TearsDownPhysicalConnection() await using var conn = Create(shared: false, allowAdmin: true); int failedCount = 0; - ConnectionFailureType? observedFailure = null; + TaskCompletionSource observedFailure = new(); conn.ConnectionFailed += (_, e) => { Interlocked.Increment(ref failedCount); - observedFailure ??= e.FailureType; + observedFailure.TrySetResult(e.FailureType); }; await conn.GetDatabase().PingAsync(); @@ -69,7 +68,7 @@ public async Task WriteFailure_TearsDownPhysicalConnection() var server = muxer.GetServerSnapshot()[0]; var boom = new InvalidOperationException("simulated WriteImpl failure"); - var throwingMsg = new ThrowingMessage(-1, CommandFlags.None, RedisCommand.PING, boom); + var throwingMsg = new ThrowingMessage(boom); muxer.CheckMessage(throwingMsg); var sendTask = muxer.ExecuteAsyncImpl(throwingMsg, ResultProcessor.ResponseTimer, state: null, server); @@ -85,6 +84,7 @@ public async Task WriteFailure_TearsDownPhysicalConnection() // in-flight message. await UntilConditionAsync(TimeSpan.FromSeconds(3), () => Volatile.Read(ref failedCount) > 0); Assert.True(Volatile.Read(ref failedCount) > 0, "ConnectionFailed event did not fire after write failure"); - Assert.Equal(ConnectionFailureType.InternalFailure, observedFailure); + + Assert.Equal(ConnectionFailureType.InternalFailure, await observedFailure.Task.WithTimeout(5000)); } } diff --git a/tests/StackExchange.Redis.Tests/WriteMode.cs b/tests/StackExchange.Redis.Tests/WriteMode.cs new file mode 100644 index 000000000..cf66c345a --- /dev/null +++ b/tests/StackExchange.Redis.Tests/WriteMode.cs @@ -0,0 +1,9 @@ +namespace StackExchange.Redis.Tests; + +public enum WriteMode +{ + Default = (int)BufferedStreamWriter.WriteMode.Default, + Sync = (int)BufferedStreamWriter.WriteMode.Sync, + Async = (int)BufferedStreamWriter.WriteMode.Async, + Pipe = (int)BufferedStreamWriter.WriteMode.Pipe, +} diff --git a/toys/StackExchange.Redis.Server/GlobalUsings.cs b/toys/StackExchange.Redis.Server/GlobalUsings.cs deleted file mode 100644 index aa3ae0946..000000000 --- a/toys/StackExchange.Redis.Server/GlobalUsings.cs +++ /dev/null @@ -1,22 +0,0 @@ -extern alias seredis; -global using Format = seredis::StackExchange.Redis.Format; -global using PhysicalConnection = seredis::StackExchange.Redis.PhysicalConnection; -/* -During the v2/v3 transition, SE.Redis doesn't have RESPite, which -means it needs to merge in a few types like AsciiHash; this causes -conflicts; this file is a place to resolve them. Since the server -is now *mostly* RESPite, it turns out that the most efficient way -to do this is to shunt all of SE.Redis off into an alias, and bring -back just the types we need. -*/ -global using RedisChannel = seredis::StackExchange.Redis.RedisChannel; -global using RedisCommand = seredis::StackExchange.Redis.RedisCommand; -global using RedisCommandMetadata = seredis::StackExchange.Redis.RedisCommandMetadata; -global using RedisKey = seredis::StackExchange.Redis.RedisKey; -global using RedisProtocol = seredis::StackExchange.Redis.RedisProtocol; -global using RedisValue = seredis::StackExchange.Redis.RedisValue; -global using ResultType = seredis::StackExchange.Redis.ResultType; -global using ServerSelectionStrategy = seredis::StackExchange.Redis.ServerSelectionStrategy; -global using ServerType = seredis::StackExchange.Redis.ServerType; -global using SlotRange = seredis::StackExchange.Redis.SlotRange; -global using TaskSource = seredis::StackExchange.Redis.TaskSource; diff --git a/toys/StackExchange.Redis.Server/RedisClient.Output.cs b/toys/StackExchange.Redis.Server/RedisClient.Output.cs index 4e871b112..0e9396a5a 100644 --- a/toys/StackExchange.Redis.Server/RedisClient.Output.cs +++ b/toys/StackExchange.Redis.Server/RedisClient.Output.cs @@ -176,7 +176,7 @@ static void WritePrefix(IBufferWriter output, char prefix) switch (type) { case RespPrefix.Integer: - PhysicalConnection.WriteInteger(output, (long)value.AsRedisValue()); + MessageWriter.WriteInteger(output, (long)value.AsRedisValue()); break; case RespPrefix.Double: WriteDouble(output, (double)value.AsRedisValue()); @@ -190,11 +190,11 @@ static void WritePrefix(IBufferWriter output, char prefix) WritePrefix(output, prefix); var val = (string)value.AsRedisValue() ?? ""; var expectedLength = Encoding.UTF8.GetByteCount(val); - PhysicalConnection.WriteRaw(output, val, expectedLength); - PhysicalConnection.WriteCrlf(output); + MessageWriter.WriteRaw(output, val, expectedLength); + MessageWriter.WriteCrlf(output); break; case RespPrefix.BulkString: - PhysicalConnection.WriteBulkString(value.AsRedisValue(), output); + MessageWriter.WriteBulkString(value.AsRedisValue(), output); break; case RespPrefix.Null: case RespPrefix.Push when value.IsNullArray: @@ -204,7 +204,7 @@ static void WritePrefix(IBufferWriter output, char prefix) output.Write("_\r\n"u8); break; case RespPrefix.Array when value.IsNullArray: - PhysicalConnection.WriteMultiBulkHeader(output, -1); + MessageWriter.WriteMultiBulkHeader(output, -1); break; case RespPrefix.Push: case RespPrefix.Map: @@ -212,7 +212,7 @@ static void WritePrefix(IBufferWriter output, char prefix) case RespPrefix.Set: case RespPrefix.Attribute: var segment = value.Span; - PhysicalConnection.WriteMultiBulkHeader(output, segment.Length, ToResultType(type)); + MessageWriter.WriteMultiBulkHeader(output, segment.Length, type); foreach (var item in segment) { if (item.IsNil) throw new InvalidOperationException("Array element cannot be nil"); @@ -227,7 +227,6 @@ static void WritePrefix(IBufferWriter output, char prefix) Debug.WriteLine($"{type} not handled in RESP3; using {r2} instead"); goto RetryResp2; } - throw new InvalidOperationException( "Unexpected result type: " + value.Type); } @@ -244,30 +243,6 @@ static void WriteDouble(IBufferWriter output, double value) span[2 + len] = (byte)'\n'; output.Advance(3 + len); } - - static ResultType ToResultType(RespPrefix type) => - type switch - { - RespPrefix.None => ResultType.None, - RespPrefix.SimpleString => ResultType.SimpleString, - RespPrefix.SimpleError => ResultType.Error, - RespPrefix.Integer => ResultType.Integer, - RespPrefix.BulkString => ResultType.BulkString, - RespPrefix.Array => ResultType.Array, - RespPrefix.Null => ResultType.Null, - RespPrefix.Boolean => ResultType.Boolean, - RespPrefix.Double => ResultType.Double, - RespPrefix.BigInteger => ResultType.BigInteger, - RespPrefix.BulkError => ResultType.BlobError, - RespPrefix.VerbatimString => ResultType.VerbatimString, - RespPrefix.Map => ResultType.Map, - RespPrefix.Set => ResultType.Set, - RespPrefix.Push => ResultType.Push, - RespPrefix.Attribute => ResultType.Attribute, - // StreamContinuation and StreamTerminator don't have direct ResultType equivalents - // These are protocol-level markers, not result types - _ => throw new ArgumentOutOfRangeException(nameof(type), type, "Unexpected RespPrefix value"), - }; } public RespPrefix ApplyProtocol(RespPrefix type) => IsResp2 ? ToResp2(type) : type; diff --git a/toys/StackExchange.Redis.Server/RedisClient.cs b/toys/StackExchange.Redis.Server/RedisClient.cs index 3b56ebef0..d3e2c1475 100644 --- a/toys/StackExchange.Redis.Server/RedisClient.cs +++ b/toys/StackExchange.Redis.Server/RedisClient.cs @@ -11,11 +11,11 @@ namespace StackExchange.Redis.Server { public partial class RedisClient(RedisServer.Node node) : IDisposable #pragma warning disable SA1001 - #if NET +#if NET , ISpanFormattable #else , IFormattable - #endif +#endif #pragma warning restore SA1001 { private RespScanState _readState; diff --git a/toys/StackExchange.Redis.Server/RedisServer.cs b/toys/StackExchange.Redis.Server/RedisServer.cs index a3b52dec1..a46705c22 100644 --- a/toys/StackExchange.Redis.Server/RedisServer.cs +++ b/toys/StackExchange.Redis.Server/RedisServer.cs @@ -179,9 +179,9 @@ public override TypedRedisValue Execute(RedisClient client, in RedisRequest requ static bool IsAuthCommand(RedisCommand cmd) => cmd is RedisCommand.AUTH or RedisCommand.HELLO; static bool IsPubSubCommand(RedisCommand cmd) => cmd is RedisCommand.SUBSCRIBE or RedisCommand.UNSUBSCRIBE - or RedisCommand.SSUBSCRIBE or RedisCommand.SUNSUBSCRIBE - or RedisCommand.PSUBSCRIBE or RedisCommand.PUNSUBSCRIBE - or RedisCommand.PING or RedisCommand.QUIT; + or RedisCommand.SSUBSCRIBE or RedisCommand.SUNSUBSCRIBE + or RedisCommand.PSUBSCRIBE or RedisCommand.PUNSUBSCRIBE + or RedisCommand.PING or RedisCommand.QUIT; } [RedisCommand(2)] diff --git a/toys/StackExchange.Redis.Server/RespServer.cs b/toys/StackExchange.Redis.Server/RespServer.cs index 0b637b8c2..51996721e 100644 --- a/toys/StackExchange.Redis.Server/RespServer.cs +++ b/toys/StackExchange.Redis.Server/RespServer.cs @@ -6,12 +6,11 @@ using System.IO; using System.IO.Pipelines; using System.Linq; +using System.Net.Sockets; using System.Reflection; using System.Text; using System.Threading; using System.Threading.Tasks; -using Pipelines.Sockets.Unofficial; -using Pipelines.Sockets.Unofficial.Arenas; using RESPite; using RESPite.Buffers; using RESPite.Messages; @@ -295,8 +294,6 @@ protected virtual void Dispose(bool disposing) DoShutdown(ShutdownReason.ServerDisposed); } - private readonly Arena _arena = new(); - public virtual RedisServer.Node DefaultNode => null; public async Task RunClientAsync(IDuplexPipe pipe, RedisServer.Node node = null, object state = null) @@ -349,27 +346,25 @@ public async Task RunClientAsync(IDuplexPipe pipe, RedisServer.Node node = null, } client.Complete(); await output; + RemoveClient(client); client = null; // already completed } - catch (ConnectionResetException) { } - catch (ObjectDisposedException) { } + catch (SocketException) { } // expected + catch (OperationCanceledException) { } // expected + catch (ObjectDisposedException) { } // expected catch (Exception ex) { - if (ex.GetType().Name != nameof(ConnectionResetException)) - { - // aspnet core has one too; swallow it by pattern - fault = ex; - throw; - } + // unexpected: report as a failure exit + fault = ex; } finally { RedisRequest.ReleaseLease(ref commandLease); client?.Complete(fault); RemoveClient(client); - try { pipe.Input.Complete(fault); } catch { } - try { pipe.Output.Complete(fault); } catch { } + try { await pipe.Input.CompleteAsync(fault); } catch { } + try { await pipe.Output.CompleteAsync(fault); } catch { } if (fault != null && !_isShutdown) { diff --git a/toys/StackExchange.Redis.Server/RespSocketServer.cs b/toys/StackExchange.Redis.Server/RespSocketServer.cs index c5cc010ab..5e29fecb2 100644 --- a/toys/StackExchange.Redis.Server/RespSocketServer.cs +++ b/toys/StackExchange.Redis.Server/RespSocketServer.cs @@ -1,4 +1,4 @@ -using System; +/* left for ref only using System.Net; using System.Threading.Tasks; using Pipelines.Sockets.Unofficial; @@ -25,3 +25,4 @@ protected override void Dispose(bool disposing) } } } +*/ diff --git a/toys/StackExchange.Redis.Server/StackExchange.Redis.Server.csproj b/toys/StackExchange.Redis.Server/StackExchange.Redis.Server.csproj index 68d690497..3e800c817 100644 --- a/toys/StackExchange.Redis.Server/StackExchange.Redis.Server.csproj +++ b/toys/StackExchange.Redis.Server/StackExchange.Redis.Server.csproj @@ -12,7 +12,7 @@ $(NoWarn);CS1591 - + diff --git a/toys/TestConsoleBaseline/TestConsoleBaseline.csproj b/toys/TestConsoleBaseline/TestConsoleBaseline.csproj index 10d5ab321..27ebf8800 100644 --- a/toys/TestConsoleBaseline/TestConsoleBaseline.csproj +++ b/toys/TestConsoleBaseline/TestConsoleBaseline.csproj @@ -2,7 +2,7 @@ Exe - net8.0;net461;net462;net47;net472 + net8.0;net461;net472 @@ -15,5 +15,6 @@ + diff --git a/version.json b/version.json index 9500cbb6f..0db6f5860 100644 --- a/version.json +++ b/version.json @@ -1,9 +1,10 @@ { - "version": "2.13", + "version": "3.0-preview", "versionHeightOffset": 0, - "assemblyVersion": "2.0", + "assemblyVersion": "3.0", "publicReleaseRefSpec": [ "^refs/heads/main$", + "^refs/heads/v[0-9]+$", "^refs/tags/v\\d+\\.\\d+" ], "nugetPackageVersion": {