public async Task TimeoutsAfterMultipleRetries()
{
var address = NetworkAddress.Parse("127.0.0.1:11001");
using var _ = HConsole.Capture(consoleOptions => consoleOptions
.ClearAll()
.Configure().SetMaxLevel()
.Configure(this).SetPrefix("TEST")
.Configure <AsyncContext>().SetMinLevel()
.Configure <SocketConnectionBase>().SetIndent(1).SetLevel(0).SetPrefix("SOCKET"));
HConsole.WriteLine(this, "Begin");
HConsole.WriteLine(this, "Start server");
await using var server = new Server(address, async(xsvr, xconn, xmsg)
=> await HandleAsync(xsvr, xconn, xmsg, async(svr, conn, msg) =>
{
HConsole.WriteLine(svr, "Handle request (wait...)");
await Task.Delay(500).CfAwait();
HConsole.WriteLine(svr, "Respond with error.");
var response = ErrorsServerCodec.EncodeResponse(new[]
{
// make sure the error is retryable
new ErrorHolder(RemoteError.RetryableHazelcast, "classname", "message", Enumerable.Empty <StackTraceElement>())
});
//HConsole.WriteLine(svr, "Respond with success.");
//var response = ClientPingServerCodec.EncodeResponse();
response.CorrelationId = msg.CorrelationId;
await conn.SendAsync(response).CfAwait();
}), LoggerFactory);
await server.StartAsync().CfAwait();
HConsole.WriteLine(this, "Start client");
var options = HazelcastOptions.Build(configure: (configuration, options) =>
{
options.Networking.Addresses.Add("127.0.0.1:11001");
options.Messaging.RetryTimeoutSeconds = 3; // default value is 120s
});
await using var client = (HazelcastClient) await HazelcastClientFactory.StartNewClientAsync(options);
HConsole.WriteLine(this, "Send message");
var message = ClientPingServerCodec.EncodeRequest();
// note: the error only happens *after* the server has responded
// we could wait for the response for ever
await AssertEx.ThrowsAsync <TaskTimeoutException>(async() =>
{
// server will respond w/ error every 500ms and client will retry
// until the 3s retry timeout (options above) is reached
await client.Cluster.Messaging.SendAsync(message).CfAwait();
});
await server.StopAsync().CfAwait();
}
public async Task CanRetryAndSucceed()
{
var address = NetworkAddress.Parse("127.0.0.1:11001");
HConsole.Configure(x => x.Configure(this).SetIndent(0).SetPrefix("TEST"));
HConsole.WriteLine(this, "Begin");
HConsole.WriteLine(this, "Start server");
var count = 0;
await using var server = new Server(address, async(xsvr, xconn, xmsg)
=> await HandleAsync(xsvr, xconn, xmsg, async(svr, conn, msg) =>
{
HConsole.WriteLine(svr, "Handle request.");
ClientMessage response;
if (++count > 3)
{
HConsole.WriteLine(svr, "Respond with success.");
response = ClientPingServerCodec.EncodeResponse();
}
else
{
HConsole.WriteLine(svr, "Respond with error.");
response = CreateErrorMessage(RemoteError.RetryableHazelcast);
response.Flags |= ClientMessageFlags.BeginFragment | ClientMessageFlags.EndFragment;
}
response.CorrelationId = msg.CorrelationId;
await conn.SendAsync(response).CfAwait();
}), LoggerFactory);
await server.StartAsync().CfAwait();
HConsole.WriteLine(this, "Start client");
var options = HazelcastOptions.Build(configure: (configuration, options) =>
{
options.Networking.Addresses.Add("127.0.0.1:11001");
});
await using var client = (HazelcastClient) await HazelcastClientFactory.StartNewClientAsync(options);
HConsole.WriteLine(this, "Send message");
var message = ClientPingServerCodec.EncodeRequest();
var token = new CancellationTokenSource(3_000).Token;
await client.Cluster.Messaging.SendAsync(message, token); // default is 120s
Assert.AreEqual(4, count);
await server.StopAsync().CfAwait();
}
public async Task TimeoutsIfServerIsTooSlow()
{
var address = NetworkAddress.Parse("127.0.0.1:11001");
HConsole.Configure(this, config => config.SetIndent(0).SetPrefix("TEST"));
HConsole.WriteLine(this, "Begin");
HConsole.WriteLine(this, "Start server");
await using var server = new Server(address, async(svr, conn, msg) =>
{
HConsole.WriteLine(svr, "Handle request (slowww...)");
await Task.Delay(10_000).CAF();
HConsole.WriteLine(svr, "Respond with success.");
var response = ClientPingServerCodec.EncodeResponse();
response.CorrelationId = msg.CorrelationId;
await conn.SendAsync(response).CAF();
}, LoggerFactory);
await server.StartAsync().CAF();
HConsole.WriteLine(this, "Start client");
var options = HazelcastOptions.Build(configure: (configuration, options) =>
{
options.Networking.Addresses.Add("127.0.0.1:11001");
});
await using var client = (HazelcastClient)HazelcastClientFactory.CreateClient(options);
await client.StartAsync().CAF();
HConsole.WriteLine(this, "Send message");
var message = ClientPingServerCodec.EncodeRequest();
Assert.ThrowsAsync <TaskCanceledException>(async() =>
{
var token = new CancellationTokenSource(3_000).Token;
await client.Cluster.Messaging.SendAsync(message, token); // default is 120s
});
// TODO dispose the client, the server
await server.StopAsync().CAF();
}
public async Task CanRetryAndTimeout()
{
var address = NetworkAddress.Parse("127.0.0.1:11001");
HConsole.Configure(x => x.Configure(this).SetIndent(0).SetPrefix("TEST"));
HConsole.WriteLine(this, "Begin");
HConsole.WriteLine(this, "Start server");
await using var server = new Server(address, async(xsvr, xconn, xmsg)
=> await HandleAsync(xsvr, xconn, xmsg, async(svr, conn, msg) =>
{
async Task ResponseAsync(ClientMessage response)
{
response.CorrelationId = msg.CorrelationId;
response.Flags |= ClientMessageFlags.BeginFragment | ClientMessageFlags.EndFragment;
await conn.SendAsync(response).CfAwait();
}
async Task EventAsync(ClientMessage eventMessage)
{
eventMessage.CorrelationId = msg.CorrelationId;
eventMessage.Flags |= ClientMessageFlags.BeginFragment | ClientMessageFlags.EndFragment;
await conn.SendAsync(eventMessage).CfAwait();
}
switch (msg.MessageType)
{
// must handle auth
case ClientAuthenticationServerCodec.RequestMessageType:
var authRequest = ClientAuthenticationServerCodec.DecodeRequest(msg);
var authResponse = ClientAuthenticationServerCodec.EncodeResponse(
0, address, Guid.NewGuid(), SerializationService.SerializerVersion,
"4.0", 1, Guid.NewGuid(), false);
await ResponseAsync(authResponse).CfAwait();
break;
// must handle events
case ClientAddClusterViewListenerServerCodec.RequestMessageType:
var addRequest = ClientAddClusterViewListenerServerCodec.DecodeRequest(msg);
var addResponse = ClientAddClusterViewListenerServerCodec.EncodeResponse();
await ResponseAsync(addResponse).CfAwait();
_ = Task.Run(async() =>
{
await Task.Delay(500).CfAwait();
var eventMessage = ClientAddClusterViewListenerServerCodec.EncodeMembersViewEvent(1, new[]
{
new MemberInfo(Guid.NewGuid(), address, new MemberVersion(4, 0, 0), false, new Dictionary <string, string>()),
});
await EventAsync(eventMessage).CfAwait();
});
break;
default:
HConsole.WriteLine(svr, "Respond with error.");
var response = CreateErrorMessage(RemoteError.RetryableHazelcast);
await ResponseAsync(response).CfAwait();
break;
}
}), LoggerFactory);
await server.StartAsync().CfAwait();
HConsole.WriteLine(this, "Start client");
var options = HazelcastOptions.Build(configure: (configuration, options) =>
{
options.Networking.Addresses.Add("127.0.0.1:11001");
});
await using var client = (HazelcastClient) await HazelcastClientFactory.StartNewClientAsync(options);
HConsole.WriteLine(this, "Send message");
var message = ClientPingServerCodec.EncodeRequest();
var token = new CancellationTokenSource(3_000).Token;
await AssertEx.ThrowsAsync <TaskCanceledException>(async() => await client.Cluster.Messaging.SendAsync(message, token).CfAwait());
// TODO dispose the client, the server
await server.StopAsync().CfAwait();
}
