private async Task <int> SharedStringsTest_Common()
{
int length = 0;
await this.EchoTest(async client =>
{
var requestStream = SChannel.CreateUnbounded <StringMessage>();
byte[] random = new byte[1024];
new Random().NextBytes(random);
string randomB64 = Convert.ToBase64String(random);
for (int i = 0; i < 100; ++i)
{
await requestStream.Writer.WriteAsync(new StringMessage {
Value = randomB64
});
}
requestStream.Writer.Complete();
MultiStringMessage response = await((IEchoService)client).EchoClientStreaming(requestStream, default);
// Test that the string is only written once. This confirms that our update to the serializer worked as intended.
Assert.IsAssignableFrom <IFlatBufferDeserializedObject>(response);
IFlatBufferDeserializedObject obj = (IFlatBufferDeserializedObject)response;
length = obj.InputBuffer.Length;
});
return(length);
}
public Task EchoDuplexStreaming_Interface_Canceled_BeforeCompletion()
{
return(this.EchoTest_Interface(async client =>
{
CancellationTokenSource cts = new();
var sourceChannel = SChannel.CreateUnbounded <StringMessage>();
var destChannel = SChannel.CreateUnbounded <StringMessage>();
var duplexCall = client.EchoDuplexStreaming(sourceChannel.Reader, destChannel.Writer, cts.Token);
for (int i = 0; i < 100; ++i)
{
string str = Guid.NewGuid().ToString();
await sourceChannel.Writer.WriteAsync(new StringMessage {
Value = str
});
var item = await destChannel.Reader.ReadAsync();
Assert.Equal(str, item.Value);
}
cts.Cancel();
await Task.Delay(50);
sourceChannel.Writer.Complete();
await this.AssertCanceled(() => duplexCall);
Assert.True(destChannel.Reader.Completion.IsCompleted);
Assert.False(destChannel.Reader.Completion.IsCompletedSuccessfully);
}));
}
public Task EchoDuplexStreaming_Interface()
{
return(this.EchoTest_Interface(async client =>
{
var sourceChannel = SChannel.CreateUnbounded <StringMessage>();
var destChannel = SChannel.CreateUnbounded <StringMessage>();
var duplexCall = client.EchoDuplexStreaming(sourceChannel.Reader, destChannel.Writer, CancellationToken.None);
for (int i = 0; i < 100; ++i)
{
string str = Guid.NewGuid().ToString();
await sourceChannel.Writer.WriteAsync(new StringMessage {
Value = str
});
var item = await destChannel.Reader.ReadAsync();
Assert.Equal(str, item.Value);
}
sourceChannel.Writer.Complete();
await duplexCall;
Assert.True(destChannel.Reader.Completion.IsCompletedSuccessfully);
}));
}
public Task EchoServerStreaming_Interface()
{
return(this.EchoTest_Interface(async client =>
{
MultiStringMessage message = new MultiStringMessage
{
Value = Enumerable.Range(0, 100).Select(x => Guid.NewGuid().ToString()).ToList()
};
var channel = SChannel.CreateUnbounded <StringMessage>();
var task = client.EchoServerStreaming(message, channel, CancellationToken.None);
int i = 0;
while (await channel.Reader.WaitToReadAsync())
{
Assert.True(channel.Reader.TryRead(out var item));
Assert.Equal(message.Value[i++], item.Value);
}
Assert.Equal(100, i);
await task;
Assert.True(channel.Reader.Completion.IsCompleted);
Assert.True(channel.Reader.Completion.IsCompletedSuccessfully);
}));
}
public Task EchoClientStreaming_Interface()
{
return(this.EchoTest_Interface(async client =>
{
var requestChannel = SChannel.CreateUnbounded <StringMessage>();
List <string> messages = new();
for (int i = 0; i < 100; ++i)
{
string msg = Guid.NewGuid().ToString();
await requestChannel.Writer.WriteAsync(new StringMessage {
Value = msg
});
messages.Add(msg);
}
requestChannel.Writer.Complete();
MultiStringMessage response = await client.EchoClientStreaming(requestChannel, CancellationToken.None);
Assert.Equal(100, response.Value.Count);
for (int i = 0; i < 100; ++i)
{
Assert.Equal(messages[i], response.Value[i]);
}
}));
}
public Task EchoDuplexStreaming_Interface_Canceled_OnWrite()
{
return(this.EchoTest_Interface(async client =>
{
CancellationTokenSource cts = new();
var sourceChannel = SChannel.CreateUnbounded <StringMessage>();
var destChannel = SChannel.CreateUnbounded <StringMessage>();
var duplexCall = client.EchoDuplexStreaming(sourceChannel.Reader, destChannel.Writer, cts.Token);
for (int i = 0; i < 100; ++i)
{
string str = Guid.NewGuid().ToString();
await sourceChannel.Writer.WriteAsync(new StringMessage {
Value = str
});
if (i == 50)
{
cts.Cancel();
await Task.Delay(50);
try
{
await destChannel.Reader.ReadAsync();
Assert.False(true, "Exception not thrown");
}
catch (System.Threading.Channels.ChannelClosedException)
{
}
catch (TaskCanceledException)
{
}
break;
}
else
{
var item = await destChannel.Reader.ReadAsync();
Assert.Equal(str, item.Value);
}
}
await this.AssertCanceled(() => duplexCall);
Assert.True(destChannel.Reader.Completion.IsCompleted);
Assert.False(destChannel.Reader.Completion.IsCompletedSuccessfully);
}));
}
public Task EchoClientStreaming_Interface_Canceled()
{
return(this.EchoTest_Interface(async client =>
{
CancellationTokenSource cts = new();
var channel = SChannel.CreateUnbounded <StringMessage>();
await channel.Writer.WriteAsync(new StringMessage {
Value = "foo"
});
await channel.Writer.WriteAsync(new StringMessage {
Value = "bar"
});
var responseTask = client.EchoClientStreaming(channel, cts.Token);
cts.Cancel();
await this.AssertCanceled(() => responseTask);
}));
}
public SuperSocketSocketClient(ILogger <SuperSocketSocketClient> logger, IFluentSocketApplication app, ISocketSessionBuilder socketSessionBuilder, ClientSetting setting)
{
_logger = logger;
_app = app;
_socketSessionBuilder = socketSessionBuilder;
_setting = setting;
if (!_setting.ExtraSettings.Any())
{
_setting.ExtraSettings.Add(new SuperSocketClientSetting());
}
_extraSetting = (SuperSocketClientSetting)_setting.ExtraSettings.FirstOrDefault();
_cts = new CancellationTokenSource();
_semaphoreSlim = new SemaphoreSlim(1);
_manualResetEventSlim = new ManualResetEventSlim(true);
_reqPushChannel = SystemChannel.CreateBounded <PushReqPacket>(_setting.PushReqCapacity);
_pushMessageHandlerDict = new ConcurrentDictionary <short, IPushMessageHandler>();
_responseFutureDict = new ConcurrentDictionary <int, ResponseFuture>();
}
public Task EchoServerStreaming_Interface_Canceled()
{
return(this.EchoTest_Interface(async client =>
{
MultiStringMessage message = new MultiStringMessage
{
Value = Enumerable.Range(0, 100).Select(x => Guid.NewGuid().ToString()).ToList()
};
var channel = SChannel.CreateUnbounded <StringMessage>();
CancellationTokenSource cts = new();
var task = client.EchoServerStreaming(message, channel, cts.Token);
int i = 0;
while (await channel.Reader.WaitToReadAsync(cts.Token))
{
Assert.True(channel.Reader.TryRead(out var item));
Assert.Equal(message.Value[i++], item.Value);
if (i == 50)
{
cts.Cancel();
await this.AssertCanceled(
async() => await channel.Reader.WaitToReadAsync(cts.Token));
break;
}
}
await this.AssertCanceled(() => task);
Assert.True(channel.Reader.Completion.IsCompleted);
Assert.False(channel.Reader.Completion.IsCompletedSuccessfully);
}));
}
