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); }