internal void Call(RespConnection connection, Lifetime <Memory <RespValue> > args, Action <RespValue>?inspector = null) { using (args) { Interlocked.Increment(ref _opCount); connection.Send(RespValue.CreateAggregate(RespType.Array, args.Value)); } using var response = connection.Receive(); response.Value.ThrowIfError(); inspector?.Invoke(response.Value); }
internal T Call <T>(RespConnection connection, Lifetime <Memory <RespValue> > args, Func <RespValue, T> selector) { using (args) { Interlocked.Increment(ref _opCount); connection.Send(RespValue.CreateAggregate(RespType.Array, args.Value)); } using var response = connection.Receive(); response.Value.ThrowIfError(); return(selector(response.Value)); }
protected override async Task <T> CallAsync <T>(Lifetime <Memory <RespValue> > args, Func <RespValue, T> selector) { using (args) { Multiplexer.IncrementOpCount(); await _lease.Value.SendAsync(RespValue.CreateAggregate(RespType.Array, args.Value), _cancellationToken).ConfigureAwait(false); } using var response = await _lease.Value.ReceiveAsync(_cancellationToken).ConfigureAwait(false); response.Value.ThrowIfError(); return(selector(response.Value)); }
protected override async Task CallAsync(Lifetime <Memory <RespValue> > args, Action <RespValue>?inspector = null) { using (args) { Multiplexer.IncrementOpCount(); await _lease.Value.SendAsync(RespValue.CreateAggregate(RespType.Array, args.Value), _cancellationToken).ConfigureAwait(false); } using var response = await _lease.Value.ReceiveAsync(_cancellationToken).ConfigureAwait(false); response.Value.ThrowIfError(); inspector?.Invoke(response.Value); }
internal async Task <T> CallAsync <T>(Lifetime <Memory <RespValue> > args, Func <RespValue, T> selector, CancellationToken cancellationToken) { using (args) { Interlocked.Increment(ref _opCount); await using var lease = await _pool.RentAsync(cancellationToken).ConfigureAwait(false); await lease.Value.SendAsync(RespValue.CreateAggregate(RespType.Array, args.Value), cancellationToken).ConfigureAwait(false); using var response = await lease.Value.ReceiveAsync(cancellationToken).ConfigureAwait(false); response.Value.ThrowIfError(); return(selector(response.Value)); } }
internal async Task CallAsync(Lifetime <Memory <RespValue> > args, CancellationToken cancellationToken, Action <RespValue>?inspector = null) { using (args) { Interlocked.Increment(ref _opCount); await using var lease = await _pool.RentAsync(cancellationToken).ConfigureAwait(false); await lease.Value.SendAsync(RespValue.CreateAggregate(RespType.Array, args.Value), cancellationToken).ConfigureAwait(false); using var response = await lease.Value.ReceiveAsync(cancellationToken).ConfigureAwait(false); response.Value.ThrowIfError(); inspector?.Invoke(response.Value); } }
#pragma warning disable IDE0051 // Remove unused private members static async ValueTask BasicTest() #pragma warning restore IDE0051 // Remove unused private members { var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); SocketConnection.SetRecommendedClientOptions(socket); socket.Connect(ServerEndpoint); await using var client = RespConnection.Create(socket); var payload = new string('a', 2048); var frame = RespValue.CreateAggregate(RespType.Array, "ping", payload); var timer = Stopwatch.StartNew(); for (int i = 0; i < 1000; i++) { client.Send(frame); using var reply = client.Receive(); reply.Value.ThrowIfError(); // client.Ping(); } timer.Stop(); Log("sync", timer.Elapsed, 1000, payload); }
static async Task RunClientAsync(RespConnection client, int pingsPerClient, int pipelineDepth, string payload) { var frame = string.IsNullOrEmpty(payload) ? s_ping : RespValue.CreateAggregate(RespType.Array, "PING", payload); var expected = string.IsNullOrEmpty(payload) ? s_pong : RespValue.Create(RespType.BlobString, payload); if (pipelineDepth == 1) { for (int i = 0; i < pingsPerClient; i++) { await client.SendAsync(frame).ConfigureAwait(false); using var result = await client.ReceiveAsync().ConfigureAwait(false); result.Value.ThrowIfError(); if (!result.Value.Equals(expected)) { Throw(); } // await client.PingAsync(); } } else { using var frames = Replicate(frame, pipelineDepth); for (int i = 0; i < pingsPerClient; i++) { using var batch = await client.BatchAsync(frames.Value).ConfigureAwait(false); CheckBatchForErrors(batch.Value, expected); } } }
private static async PooledValueTask SendAsync(PooledMultiplexer @this, RespConnection connection, IBatchedOperation op, CancellationToken cancellationToken, bool flush) { Interlocked.Increment(ref @this._opCount); using var args = op.ConsumeArgs(); await connection.SendAsync(RespValue.CreateAggregate(RespType.Array, args.Value), cancellationToken, flush).ConfigureAwait(false); }
static void Send(PooledMultiplexer @this, RespConnection connection, IBatchedOperation op, bool flush) { Interlocked.Increment(ref @this._opCount); using var args = op.ConsumeArgs(); connection.Send(RespValue.CreateAggregate(RespType.Array, args.Value), flush); }