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);
}
public void TestBoolean(bool value, string expected)
{
RespValue resp = value;
int len = checked ((int)resp.GetByteCount());
using var lease = Lifetime.RentMemory <byte>(len);
Assert.Equal(len, resp.CopyTo(lease.Value.Span));
var result = Encoding.UTF8.GetString(lease.Value.Span);
Assert.Equal(expected, result);
}
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);
}
}
}
public void TestBytes()
{
const int MAX_LENGTH = 800;
var sourceData = ArrayPool <byte> .Shared.Rent(MAX_LENGTH);
var target = ArrayPool <byte> .Shared.Rent(MAX_LENGTH + 2);
try
{
var rand = new Random(12345);
rand.NextBytes(sourceData);
for (int i = 0; i < MAX_LENGTH; i++)
{
int offset = MAX_LENGTH - i;
var seq = new ReadOnlySequence <byte>(sourceData, offset, i);
RespValue resp = RespValue.Create(RespType.BlobString, seq);
Assert.Equal(i, resp.GetByteCount());
var dest = new Span <byte>(target, 1, i);
Array.Clear(target, 0, i + 2);
Assert.Equal(i, resp.CopyTo(dest));
Assert.Equal(0, target[0]);
Assert.Equal(0, target[i + 1]);
for (int j = 0; j < i; j++)
{
Assert.Equal(sourceData[j + offset], target[j + 1]);
}
}
}
finally
{
ArrayPool <byte> .Shared.Return(sourceData);
ArrayPool <byte> .Shared.Return(target);
}
}
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);
}
public void SimpleExamples(string payload, RespType expectedType, string expectedText) => Verify(payload, RespValue.Create(expectedType, expectedText), null);
