static async Task Main(string[] args)
{
var rabbitBus = RabbitHutch.CreateBus(RabbitConfig, _ => { });
var logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
var bus = new BusModel(rabbitBus.Advanced);
var rpc = new RpcModel(rabbitBus.Advanced);
var logic = new BusinessLogic(bus, rpc, logger);
await rpc.RegisterHandlerAsync("toxon.micro.router.register", async (requestMessage, _) =>
{
var request = JsonMessage.Read <RegisterRouteRequest>(requestMessage);
var response = await logic.RegisterRoute(request);
return(JsonMessage.Write(new RegisterRouteResponse {
Done = response
}));
});
await bus.RegisterHandlerAsync("toxon.micro.router.route", (message, _) => logic.RouteBusMessage(message));
await rpc.RegisterHandlerAsync("toxon.micro.router.route", (message, _) => logic.RouteRpcMessage(message));
logic.Start();
Console.WriteLine("Running Router... press enter to exit!");
Console.ReadLine();
}
private async Task <bool> CheckHealth(string serviceKey, string healthEndpoint)
{
var nonce = Interlocked.Increment(ref _nonce);
var request = new HealthCheck {
Health = "ping", Nonce = nonce
};
var requestMessage = JsonMessage.Write(request);
var cts = new CancellationTokenSource();
cts.CancelAfter(_healthCheckTimeout);
try
{
var responseMessage = await _rpc.SendAsync(healthEndpoint, requestMessage, cts.Token);
var response = JsonMessage.Read <HealthCheck>(responseMessage);
return(response.Health == "pong" && response.Nonce == nonce);
}
catch (TaskCanceledException)
{
return(false);
}
}
public IReadOnlyCollection <Entry> Match(Message message)
{
var fields = JsonMessage.Read <Dictionary <string, object> >(message);
fields = new Dictionary <string, object>(fields, StringComparer.InvariantCultureIgnoreCase);
return(_routeSelectionStrategy.Select(_routes.Values.ToList(), fields));
}
protected async Task <Message> JsonRpcHandler <TRequest, TResponse>(Message requestMessage, Func <TRequest, Task <TResponse> > handler)
{
var request = JsonMessage.Read <TRequest>(requestMessage);
var response = await handler(request);
var responseMessage = JsonMessage.Write(response);
return(responseMessage);
}
public async Task SendAsync(Message message, CancellationToken cancellationToken = default)
{
var routes = _busRouter.Match(message);
if (!routes.Any())
{
var fields = JsonMessage.Read <Dictionary <string, object> >(message);
_logger.Information("Failed to match any routes for bus message: {fields}", fields);
}
foreach (var route in routes)
{
await route.Data.Handler(message, cancellationToken);
}
}
private static Task <Message> HandleHealthCheckAsync(Message requestMessage, CancellationToken cancellationToken)
{
var request = JsonMessage.Read <HealthCheck>(requestMessage);
var response = "unknown";
if (request.Health == "ping")
{
response = "pong";
}
return(Task.FromResult(JsonMessage.Write(new HealthCheck
{
Health = response,
Nonce = request.Nonce,
})));
}
public Task <Message> CallAsync(Message message, CancellationToken cancellationToken = default)
{
var routes = _rpcRouter.Match(message);
if (!routes.Any())
{
var fields = JsonMessage.Read <Dictionary <string, object> >(message);
_logger.Error("Failed to match any routes for RPC message: {fields}", fields);
var fieldsString = string.Join(", ", fields.Select(x => $"{x.Key}:{x.Value}"));
throw new Exception($"Failed to match any routes for RPC message: {fieldsString}");
}
var route = routes.Single();
return(route.Data.Handler(message, cancellationToken));
}
protected async Task JsonBusHandler <TRequest>(Message requestMessage, Func <TRequest, Task> handler)
{
var request = JsonMessage.Read <TRequest>(requestMessage);
await handler(request);
}
