private async Task DispatchMessage(IMessage messageIn)
{
var messageHandler = actorHandlerMap.Get(messageIn);
if (messageHandler != null)
{
try
{
var response = (await messageHandler(messageIn)).Messages;
foreach (var messageOut in response)
{
messageRouter.Route(SetOutMessageProperties(messageOut));
}
}
catch (Exception err)
{
var payload = err.BuildExceptionMessage();
var messageOut = Message.Create(payload, MessageIdentifiers.Exception);
messageRouter.Route(SetOutMessageProperties(messageOut));
}
}
else
{
throw new MessageHandlerNotFoundException(messageIn);
}
IMessage SetOutMessageProperties(IMessage messageOut)
{
messageOut.Domain = securityProvider.GetDomain(messageOut.Identity);
return(messageOut.CopyMessageProperties(messageIn));
}
}
private async Task applyRoutingRules(Envelope envelope)
{
var routes = await _router.Route(envelope.Message.GetType());
if (!routes.Any())
{
Logger.NoRoutesFor(envelope);
if (_settings.NoMessageRouteBehavior == NoRouteBehavior.ThrowOnNoRoutes)
{
throw new NoRoutesException(envelope);
}
}
if (envelope.RequiresLocalReply)
{
var missing = routes.Where(x => x.Channel.LocalReplyUri == null).ToArray();
// TODO -- should you try to use either an HTTP or TCP listener if one exists?
if (missing.Any())
{
throw new InvalidOperationException(
$"There is no known local reply Uri for outgoing destinations {missing.Select(x => x.ToString()).Join(", ")}");
}
}
foreach (var route in routes)
{
await sendEnvelope(envelope, route);
}
}
public void Execute(MessageContext messagecontext, Action <MessageContext, MiddlewareContext> next, MiddlewareContext middlewarecontext)
{
var data = Activator.CreateInstance(messagecontext.Saga.DataType);
var storage = _factory.Create <ISagaStorage>(Configuration.SagaStorageType);
var serializer = _factory.Create <IMessageSerializer>(Configuration.MessageSerializerType);
messagecontext.SagaContext.Status = DefaultStatus;
var sagaentity = CreateSagaEntity(messagecontext);
sagaentity.Data = serializer.Serialize(data);
messagecontext.SagaContext.Id = storage.CreateSaga(messagecontext, sagaentity);
messagecontext.AddTrack(messagecontext.Identity, messagecontext.Origin, messagecontext.Route, messagecontext.Saga, messagecontext.SagaContext);
_router.Route(messagecontext, data);
sagaentity.Updated = messagecontext.DateTimeUtc;
SaveSaga(messagecontext, storage, sagaentity, serializer, data);
SaveMessage(messagecontext, storage, sagaentity);
}
public static async Task Main(string[] args)
{
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddCommandLine(args)
.AddJsonFile(path: "appsettings.json", optional: false, reloadOnChange: true)
.AddJsonFile(path: $"appsettings.{Environment.GetEnvironmentVariable("ENVIRONMENT") ?? "Development"}.json", optional: true)
.AddEnvironmentVariables()
.Build();
var rabbitMQUri = configuration.GetSection("RabbitMq")["uri"];
var serviceProvider =
new ServiceCollection()
.AddLogging(lb => lb.AddConsole().SetMinimumLevel(LogLevel.Trace))
.AddMessaging(mc =>
{
mc.UseInMemory();
//mc.UseRabbitMQ(cf => cf.Uri = new Uri(rabbitMQUri));
mc.UseJsonPacker(jso => jso.PropertyNamingPolicy = JsonNamingPolicy.CamelCase);
},
sc => sc
.AddSingleton <IMessageHandler <TestMessage>, TestMessageHandler>()
.AddSingleton <IMessageHandler <TestMessageWithEventId>, TestMessageHandler>()
)
.BuildServiceProvider();
Logger = serviceProvider.GetRequiredService <ILoggerFactory>().CreateLogger("Program");
MessageRouter = serviceProvider.GetRequiredService <IMessageRouter>();
using var cancellationTokenSource = new CancellationTokenSource();
var publisher = serviceProvider.GetRequiredService <IMessagePublisher>();
var routerTask = MessageRouter.Route(cancellationToken: cancellationTokenSource.Token);
var renderTask = Render(cancellationToken: cancellationTokenSource.Token);
while (!cancellationTokenSource.IsCancellationRequested)
{
switch (Console.ReadKey(true).Key)
{
case ConsoleKey.Escape:
cancellationTokenSource.Cancel();
await Task.Delay(TimeSpan.FromSeconds(1));
break;
case ConsoleKey.Enter:
var message = new TestMessage {
Ping = "AAA"
};
publisher.Publish(message, cancellationToken: cancellationTokenSource.Token);
break;
default:
break;
}
}
}
public Flow Route(IMessageRouter router)
{
this.steps.Add(message =>
{
var branchname = router.Route(message);
return(this.SendToBranch(branchname, message));
});
return(this);
}
public void Execute(MessageContext context, Action next, MiddlewareParameter parameter)
{
var storage = _factory.Create <IStorage>(_configuration.StorageType);
var serializer = _factory.Create <IMessageSerializer>(_configuration.MessageSerializerType);
var sagaentity = storage.GetSaga(context.SagaContext.Id);
context.SagaContext.Status = DefaultStatus;
if (sagaentity != null)
{
var data = serializer.Deserialize(sagaentity.Data, parameter.Saga.DataType);
context.AddTrack(context.Id, context.Origin.Key, context.Origin.From, parameter.Route.Name, context.SagaContext.Id, parameter.Saga.Name);
if (data != null)
{
_router.Route(context, parameter.Route, data, parameter.Saga.DataType);
sagaentity.Data = serializer.Serialize(data);
sagaentity.Ended = context.DateTimeUtc;
sagaentity.Status = context.SagaContext.Status;
sagaentity.Duration = (sagaentity.Ended.Value - sagaentity.Created).TotalMilliseconds;
storage.UpdateSaga(context, context.SagaContext.Id, sagaentity);
var message = CreateMessageEntity(context, parameter, sagaentity);
try
{
storage.CreateMessage(context, context.SagaContext.Id, sagaentity, message);
}
catch (Exception)
{
if (!_configuration.Storage.IgnoreExceptionOnSaveMessage)
{
throw;
}
}
}
else
{
throw new ApplicationException($"Empty/Invalid data {parameter.Saga.DataType.FullName} for {parameter.Route.ContentType.FullName}, saga {parameter.Saga.Name}");
}
}
else
{
throw new ApplicationException($"No data {parameter.Saga.DataType.FullName} for {parameter.Route.ContentType.FullName}, saga {parameter.Saga.Name}");
}
}
public void Execute(MessageContext context, Action next, MiddlewareParameter parameter)
{
var data = Activator.CreateInstance(parameter.Saga.DataType);
var storage = _factory.Create <IStorage>(_configuration.StorageType);
var serializer = _factory.Create <IMessageSerializer>(_configuration.MessageSerializerType);
context.SagaContext.Status = DefaultStatus;
var sagaentity = CreateSagaEntity(context, parameter);
sagaentity.Data = serializer.Serialize(data);
var id = storage.CreateSaga(context, sagaentity);
context.SagaContext.Id = id;
context.AddTrack(context.Id, context.Origin.Key, context.Origin.From, parameter.Route.Name, context.SagaContext.Id, parameter.Saga.Name);
_router.Route(context, parameter.Route, data, parameter.Saga.DataType);
sagaentity = storage.GetSaga(id);
if (sagaentity != null)
{
sagaentity.Data = serializer.Serialize(data);
sagaentity.Updated = context.DateTimeUtc;
sagaentity.Status = context.SagaContext.Status;
storage.UpdateSaga(context, id, sagaentity);
var messageentity = CreateMessageEntity(context, parameter, sagaentity);
try
{
storage.CreateMessage(context, id, sagaentity, messageentity);
}
catch (Exception)
{
if (!_configuration.Storage.IgnoreExceptionOnSaveMessage)
{
throw;
}
}
}
else
{
throw new ApplicationException($"No data {parameter.Saga.DataType.FullName} for {parameter.Route.ContentType.FullName}, saga {parameter.Saga.Name}");
}
}
public async Task Publish(Envelope envelope)
{
if (envelope.Message == null)
{
throw new ArgumentNullException(nameof(envelope.Message));
}
if (envelope.RequiresLocalReply)
{
throw new ArgumentOutOfRangeException(nameof(envelope), "Cannot 'Publish' and envelope that requires a local reply");
}
var outgoing = await _router.Route(envelope);
if (!outgoing.Any())
{
_logger.NoRoutesFor(envelope);
return;
}
await persistOrSend(outgoing);
}
public override void ChannelRead(IChannelHandlerContext context, object msg)
{
Contract.Requires(context != null);
var channel = context.Channel;
var session = _appSessionContainer.Get(channel.Id.ToString());
if (session != null)
{
session.LastAccessTime = DateTime.Now;
}
bool release = true;
try
{
if (msg is IPacket packet)
{
_logger.LogInformation($"The msg {msg} from {channel} has been read.");
var requestContext = new RequestContext()
{
AppSession = session, Request = packet
};
_messageRouter.Route(requestContext);
}
else
{
_logger.LogInformation($"The msg {msg} is not type of IMessage.");
release = false;
context.FireChannelRead(msg);
}
}
catch (Exception ex)
{
_logger.LogError($"ChannelRead error", ex);
}
finally
{
if (_autoRelease && release)
{
ReferenceCountUtil.Release(msg);
}
}
}
public void Execute(MessageContext context, Action next, MiddlewareParameter parameter)
{
var storage = _factory.Create <IStorage>(_configuration.StorageType);
context.AddTrack(context.Id, context.Origin.Key, context.Origin.From, parameter.Route.Name);
if (_configuration.Storage.SaveMessage)
{
var message = new MessageEntity()
{
Content = context.ContentAsString,
ContentType = context.Route.ContentType.FullName,
Id = context.Id,
Version = context.Version,
RetryCount = context.RetryCount,
LastRetry = context.LastRetry,
Origin = context.Origin,
Headers = context.Headers,
DateTimeUtc = context.DateTimeUtc,
Name = context.Route.Name,
Tracks = context.Tracks
};
try
{
storage.CreateMessage(context, message);
}
catch (Exception)
{
if (!_configuration.Storage.IgnoreExceptionOnSaveMessage)
{
throw;
}
}
}
_router.Route(context, parameter.Route);
next();
}
public void Execute(MessageContext messagecontext, Action <MessageContext, MiddlewareContext> next, MiddlewareContext middlewarecontext)
{
messagecontext.AddTrack(messagecontext.Identity, messagecontext.Origin, messagecontext.Route);
if (_configuration.Storage.SaveMessage)
{
var storage = _factory.Create <ISagaStorage>(_configuration.SagaStorageType);
var messageentity = new MessageEntity()
{
Content = messagecontext.Content,
ContentType = messagecontext.Route.ContentType.FullName,
Identity = messagecontext.Identity,
Version = messagecontext.Version,
RetryCount = messagecontext.RetryCount,
LastRetry = messagecontext.LastRetry,
Origin = messagecontext.Origin,
Headers = messagecontext.Headers,
DateTimeUtc = messagecontext.DateTimeUtc,
Name = messagecontext.Route.Name,
Tracks = messagecontext.Tracks,
ContentId = messagecontext.ContentId,
Data = string.Empty
};
try
{
storage.CreateMessage(messagecontext, messageentity);
}
catch (Exception)
{
if (!_configuration.Storage.IgnoreExceptionOnSaveMessage)
{
throw;
}
}
}
_router.Route(messagecontext);
}
public void Execute(MessageContext messagecontext, Action <MessageContext, MiddlewareContext> next, MiddlewareContext middlewarecontext)
{
var storage = _factory.Create <ISagaStorage>(Configuration.SagaStorageType);
var serializer = _factory.Create <IMessageSerializer>(Configuration.MessageSerializerType);
var sagaentity = storage.GetSaga(messagecontext.SagaContext.Id);
messagecontext.SagaContext.Status = DefaultStatus;
if (sagaentity != null)
{
messagecontext.AddTrack(messagecontext.Identity, messagecontext.Origin, messagecontext.Route, messagecontext.Saga, messagecontext.SagaContext);
var data = serializer.Deserialize(sagaentity.Data, messagecontext.Saga.DataType);
if (data != null)
{
_router.Route(messagecontext, data);
sagaentity.Ended = messagecontext.DateTimeUtc;
sagaentity.Duration = (sagaentity.Ended.Value - sagaentity.Created).TotalMilliseconds;
SaveSaga(messagecontext, storage, sagaentity, serializer, data);
SaveMessage(messagecontext, storage, sagaentity);
}
else
{
throw new ApplicationException($"Empty/Invalid data {messagecontext.Saga.DataType.FullName} for {messagecontext.Route.ContentType.FullName}, saga {messagecontext.Saga.Name} route {messagecontext.Route.Name}");
}
}
else
{
throw new ApplicationException($"No data {messagecontext.Saga.DataType.FullName} for {messagecontext.Route.ContentType.FullName}, saga {messagecontext.Saga.Name} route {messagecontext.Route.Name}");
}
}
public async Task <string> Send(Envelope envelope, IMessageCallback callback)
{
if (envelope.Message == null)
{
throw new ArgumentNullException(nameof(envelope.Message));
}
envelope.Source = _settings.NodeId;
if (envelope.Destination == null)
{
var routes = await _router.Route(envelope.Message.GetType());
if (!routes.Any())
{
Logger.NoRoutesFor(envelope);
if (_settings.NoMessageRouteBehavior == NoRouteBehavior.ThrowOnNoRoutes)
{
throw new NoRoutesException(envelope);
}
}
foreach (var route in routes)
{
await sendEnvelope(envelope, route, callback);
}
}
else
{
var route = await _router.RouteForDestination(envelope);
await sendEnvelope(envelope, route, callback);
}
return(envelope.CorrelationId);
}
public void SendOneWay(IMessage message)
{
message.Domain = securityProvider.GetDomain(message.Identity);
messageRouter.Route(message);
}
