fix breaks

Author: mgravell

src/RESPite.StackExchange.Redis/RespContextDatabase.Connection.cs

@@ -10,20 +10,21 @@ internal partial class RespContextDatabase
     public bool IsConnected(RedisKey key, CommandFlags flags = CommandFlags.None) =>
         throw new NotImplementedException();
 
-    private static readonly byte[] PingRaw = "*1\r\n$4\r\nping\r\n"u8.ToArray();
+    internal static readonly byte[] PingRaw = "*1\r\n$4\r\nping\r\n"u8.ToArray();
 
     public Task<TimeSpan> PingAsync(CommandFlags flags = CommandFlags.None) =>
         Context(flags).Send("ping"u8, DateTime.UtcNow, PingParser.Default, PingRaw).AsTask();
 
     public TimeSpan Ping(CommandFlags flags = CommandFlags.None) =>
         Context(flags).Send("ping"u8, DateTime.UtcNow, PingParser.Default, PingRaw).Wait(SyncTimeout);
 
-    private sealed class PingParser : IRespParser<DateTime, TimeSpan>
+    internal sealed class PingParser : IRespParser<DateTime, TimeSpan>
     {
         public static readonly PingParser Default = new();
         private PingParser() { }
         public TimeSpan Parse(in DateTime state, ref RespReader reader) => DateTime.UtcNow - state;
     }
+
     public Task<EndPoint?> IdentifyEndpointAsync(RedisKey key = default, CommandFlags flags = CommandFlags.None) =>
         throw new NotImplementedException();
 

src/RESPite.StackExchange.Redis/RespContextDatabase.cs

@@ -31,20 +31,7 @@ public RespContextDatabase(IConnectionMultiplexer muxer, IRespContextSource sour
     protected void SetSource(IRespContextSource source)
         => this._source = source;
 
-    // Question: cache this, or rebuild each time? the latter handles shutdown better.
-    // internal readonly RespContext Context = proxy.Context.WithDatabase(db);
-    private RespContext Context(CommandFlags flags)
-    {
-        // the flags intentionally align between CommandFlags and RespContextFlags
-        const RespContext.RespContextFlags flagMask = RespContext.RespContextFlags.DemandPrimary
-                                                      | RespContext.RespContextFlags.DemandReplica
-                                                      | RespContext.RespContextFlags.PreferReplica
-                                                      | RespContext.RespContextFlags.NoRedirect
-                                                      | RespContext.RespContextFlags.FireAndForget
-                                                      | RespContext.RespContextFlags.NoScriptCache;
-
-        return _source.Context.With(_db, (RespContext.RespContextFlags)flags, flagMask);
-    }
+    private RespContext Context(CommandFlags flags) => _source.Context.With(_db, flags);
 
     private TimeSpan SyncTimeout => _source.Context.SyncTimeout;
     public int Database => _db;

src/RESPite.StackExchange.Redis/RespContextExtensions.cs

@@ -0,0 +1,20 @@
+using StackExchange.Redis;
+
+namespace RESPite.StackExchange.Redis;
+
+internal static class RespContextExtensions
+{
+    // Question: cache this, or rebuild each time? the latter handles shutdown better.
+    // internal readonly RespContext Context = proxy.Context.WithDatabase(db);
+    internal static RespContext With(this in RespContext context, int db, CommandFlags flags)
+    {
+        // the flags intentionally align between CommandFlags and RespContextFlags
+        const RespContext.RespContextFlags FlagMask = RespContext.RespContextFlags.DemandPrimary
+                                                      | RespContext.RespContextFlags.DemandReplica
+                                                      | RespContext.RespContextFlags.PreferReplica
+                                                      | RespContext.RespContextFlags.NoRedirect
+                                                      | RespContext.RespContextFlags.FireAndForget
+                                                      | RespContext.RespContextFlags.NoScriptCache;
+        return context.With(db, (RespContext.RespContextFlags)flags, FlagMask);
+    }
+}

src/RESPite.StackExchange.Redis/RespContextServer.cs

@@ -12,10 +12,14 @@ namespace RESPite.StackExchange.Redis;
 internal sealed class RespContextServer(RespMultiplexer muxer, Node node) : IServer
 {
     // deliberately not caching this - if the connection changes, we want to know about it
-    internal ref readonly RespContext Context => ref node.Context;
+    internal RespContext Context(CommandFlags flags) => node.Context.With(-1, flags);
+
+    private TimeSpan SyncTimeout => node.Context.SyncTimeout;
 
     public IConnectionMultiplexer Multiplexer => muxer;
-    public Task<TimeSpan> PingAsync(CommandFlags flags = CommandFlags.None) => throw new NotImplementedException();
+
+    public Task<TimeSpan> PingAsync(CommandFlags flags = CommandFlags.None)
+        => Context(flags).Send("ping"u8, DateTime.UtcNow, RespContextDatabase.PingParser.Default, RespContextDatabase.PingRaw).AsTask();
 
     public bool TryWait(Task task) => task.Wait(Multiplexer.TimeoutMilliseconds);
 
@@ -25,7 +29,8 @@ internal sealed class RespContextServer(RespMultiplexer muxer, Node node) : ISer
 
     public void WaitAll(params Task[] tasks) => Multiplexer.WaitAll(tasks);
 
-    public TimeSpan Ping(CommandFlags flags = CommandFlags.None) => throw new NotImplementedException();
+    public TimeSpan Ping(CommandFlags flags = CommandFlags.None)
+        => Context(flags).Send("ping"u8, DateTime.UtcNow, RespContextDatabase.PingParser.Default, RespContextDatabase.PingRaw).Wait(SyncTimeout);
 
     public ClusterConfiguration? ClusterConfiguration => throw new NotImplementedException();
     public EndPoint EndPoint => node.Manager.ConnectionFactory.GetEndPoint(node.EndPoint, node.Port);

src/StackExchange.Redis/ConnectionMultiplexer.cs

@@ -1229,7 +1229,7 @@ public IServer GetServer(EndPoint? endpoint, object? asyncState = null)
                 throw new NotSupportedException($"The server API is not available via {RawConfig.Proxy}");
             }
             var server = servers[endpoint] as ServerEndPoint ?? throw new ArgumentException("The specified endpoint is not defined", nameof(endpoint));
-            return new RedisServer(server, asyncState);
+            return server.GetRedisServer(asyncState);
         }
 
         /// <inheritdoc cref="IConnectionMultiplexer.GetServer(RedisKey, object, CommandFlags)"/>