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);
}