/// <summary> /// <see cref="ISendOnlyBus.Publish{T}(T)"/> /// </summary> public virtual void Publish <T>(T message) { var logicalMessage = LogicalMessageFactory.Create(message); var options = new PublishOptions(logicalMessage.MessageType); InvokeSendPipeline(options, logicalMessage); }
public MultiDeserializer(Configure config, Conventions conventions, IMessageSerializer defaultSerializer, IMessageMapper mapper, LogicalMessageFactory logicalMessageFactory, MessageMetadataRegistry metadataRegistry) { _defaultSerializer = defaultSerializer; _logicalMessageFactory = logicalMessageFactory; _metadataRegistry = metadataRegistry; var json = new JsonMessageSerializer(mapper); serializers.Add(json.ContentType, json); var bson = new BsonMessageSerializer(mapper); serializers.Add(bson.ContentType, bson); var binary = new BinaryMessageSerializer(); serializers.Add(binary.ContentType, binary); var xml = new XmlMessageSerializer(mapper, conventions); List <Type> messageTypes = config.TypesToScan.Where(conventions.IsMessageType).ToList(); xml.Initialize(messageTypes); serializers.Add(xml.ContentType, xml); if (!serializers.ContainsKey(_defaultSerializer.ContentType)) { serializers.Add(_defaultSerializer.ContentType, _defaultSerializer); } }
protected internal sealed override void Setup(FeatureConfigurationContext context) { var mapper = new MessageMapper(); var settings = context.Settings; var messageMetadataRegistry = settings.Get<MessageMetadataRegistry>(); mapper.Initialize(messageMetadataRegistry.GetAllMessages().Select(m => m.MessageType)); var defaultSerializerAndDefinition = settings.GetMainSerializer(); var defaultSerializer = CreateMessageSerializer(defaultSerializerAndDefinition, mapper, settings); var additionalDeserializers = new List<IMessageSerializer>(); foreach (var definitionAndSettings in context.Settings.GetAdditionalSerializers()) { additionalDeserializers.Add(CreateMessageSerializer(definitionAndSettings, mapper, settings)); } var resolver = new MessageDeserializerResolver(defaultSerializer, additionalDeserializers); var logicalMessageFactory = new LogicalMessageFactory(messageMetadataRegistry, mapper); context.Pipeline.Register(new DeserializeLogicalMessagesConnector(resolver, logicalMessageFactory, messageMetadataRegistry), "Deserializes the physical message body into logical messages"); context.Pipeline.Register(new SerializeMessageConnector(defaultSerializer, messageMetadataRegistry), "Converts a logical message into a physical message"); context.Container.ConfigureComponent(_ => mapper, DependencyLifecycle.SingleInstance); context.Container.ConfigureComponent(_ => messageMetadataRegistry, DependencyLifecycle.SingleInstance); context.Container.ConfigureComponent(_ => logicalMessageFactory, DependencyLifecycle.SingleInstance); LogFoundMessages(messageMetadataRegistry.GetAllMessages().ToList()); }
/// <summary> /// <see cref="IBus.Reply{T}(Action{T})"/> /// </summary> public void Reply <T>(Action <T> messageConstructor) { var instance = messageMapper.CreateInstance(messageConstructor); var options = new ReplyOptions(MessageBeingProcessed.ReplyToAddress, GetCorrelationId()); SendMessage(options, LogicalMessageFactory.Create(instance)); }
/// <summary> /// <see cref="ISendOnlyBus.Send{T}(Action{T})"/> /// </summary> public ICallback Send <T>(Action <T> messageConstructor) { object message = messageMapper.CreateInstance(messageConstructor); var destination = GetDestinationForSend(message); return(SendMessage(new SendOptions(destination), LogicalMessageFactory.Create(message))); }
/// <summary> /// <see cref="IBus.Return{T}"/> /// </summary> public void Return <T>(T errorCode) { var tType = errorCode.GetType(); if (!(tType.IsEnum || tType == typeof(Int32) || tType == typeof(Int16) || tType == typeof(Int64))) { throw new ArgumentException("The errorCode can only be an enum or an integer.", "errorCode"); } var returnCode = errorCode.ToString(); if (tType.IsEnum) { returnCode = Enum.Format(tType, errorCode, "D"); } var returnMessage = LogicalMessageFactory.CreateControl(new Dictionary <string, string> { { Headers.ReturnMessageErrorCodeHeader, returnCode } }); var options = new ReplyOptions(MessageBeingProcessed.ReplyToAddress, GetCorrelationId()); InvokeSendPipeline(options, returnMessage); }
protected internal sealed override void Setup(FeatureConfigurationContext context) { var mapper = new MessageMapper(); var settings = context.Settings; var messageMetadataRegistry = settings.Get <MessageMetadataRegistry>(); mapper.Initialize(messageMetadataRegistry.GetAllMessages().Select(m => m.MessageType)); var defaultSerializerAndDefinition = settings.GetMainSerializer(); var defaultSerializer = CreateMessageSerializer(defaultSerializerAndDefinition, mapper, settings); var additionalDeserializers = new List <IMessageSerializer>(); foreach (var definitionAndSettings in context.Settings.GetAdditionalSerializers()) { additionalDeserializers.Add(CreateMessageSerializer(definitionAndSettings, mapper, settings)); } var resolver = new MessageDeserializerResolver(defaultSerializer, additionalDeserializers); var logicalMessageFactory = new LogicalMessageFactory(messageMetadataRegistry, mapper); context.Pipeline.Register(new DeserializeLogicalMessagesConnector(resolver, logicalMessageFactory, messageMetadataRegistry), "Deserializes the physical message body into logical messages"); context.Pipeline.Register(new SerializeMessageConnector(defaultSerializer, messageMetadataRegistry), "Converts a logical message into a physical message"); context.Container.ConfigureComponent(_ => mapper, DependencyLifecycle.SingleInstance); context.Container.ConfigureComponent(_ => messageMetadataRegistry, DependencyLifecycle.SingleInstance); context.Container.ConfigureComponent(_ => logicalMessageFactory, DependencyLifecycle.SingleInstance); LogFoundMessages(messageMetadataRegistry.GetAllMessages().ToList()); }
public ICallback Send(params object[] messages) { var destinations = GetAddressForMessages(messages) .Distinct() .ToList(); if (destinations.Count > 1) { throw new InvalidOperationException("Sends can only target one address."); } if (destinations.Count == 0) { var messageType = "none"; if (messages != null && messages.Length >= 1) { messageType = messages[0].GetType().ToString(); } var error = string.Format("No destination could be found for message type {0}. Check the <MessageEndpointMappings> section of the configuration of this endpoint for an entry either for this specific message type or for its assembly.", messageType); throw new InvalidOperationException(error); } var destination = destinations[0]; return(SendMessages(new SendOptions(destination), LogicalMessageFactory.CreateMultiple(messages))); }
public void Reply(params object[] messages) { var options = SendOptions.ReplyTo(MessageBeingProcessed.ReplyToAddress); options.CorrelationId = !string.IsNullOrEmpty(MessageBeingProcessed.CorrelationId) ? MessageBeingProcessed.CorrelationId : MessageBeingProcessed.Id; SendMessages(options, LogicalMessageFactory.CreateMultiple(messages)); }
public ICallback Send(Address address, string correlationId, params object[] messages) { var options = new SendOptions(address) { CorrelationId = correlationId }; return(SendMessages(options, LogicalMessageFactory.CreateMultiple(messages))); }
public ICallback Send <T>(string destination, string correlationId, Action <T> messageConstructor) { var options = new SendOptions(destination) { CorrelationId = correlationId }; return(SendMessages(options, LogicalMessageFactory.Create(CreateInstance(messageConstructor)))); }
/// <summary> /// <see cref="ISendOnlyBus.Send(Address,string,object)"/> /// </summary> public ICallback Send(Address address, string correlationId, object message) { var options = new SendOptions(address) { CorrelationId = correlationId }; return(SendMessage(options, LogicalMessageFactory.Create(message))); }
public ICallback SendLocal(params object[] messages) { //if we're a worker, send to the distributor data bus if (Configure.Instance.WorkerRunsOnThisEndpoint()) { return(SendMessages(new SendOptions(MasterNodeAddress), LogicalMessageFactory.CreateMultiple(messages))); } return(SendMessages(new SendOptions(Address.Local), LogicalMessageFactory.CreateMultiple(messages))); }
/// <summary> /// <see cref="ISendOnlyBus.Send{T}(Address,string,Action{T})"/> /// </summary> public ICallback Send <T>(Address address, string correlationId, Action <T> messageConstructor) { var options = new SendOptions(address) { CorrelationId = correlationId }; return(SendMessage(options, LogicalMessageFactory.Create(messageMapper.CreateInstance(messageConstructor)))); }
public ICallback Send(string destination, string correlationId, object message) { var options = new SendOptions(destination) { CorrelationId = correlationId }; return(SendMessages(options, LogicalMessageFactory.Create(message))); }
/// <summary> /// <see cref="ISendOnlyBus.Send(object)"/> /// </summary> public ICallback SendLocal(object message) { //if we're a worker, send to the distributor data bus if (Settings.GetOrDefault <bool>("Worker.Enabled")) { return(SendMessage(new SendOptions(Settings.Get <Address>("MasterNode.Address")), LogicalMessageFactory.Create(message))); } return(SendMessage(new SendOptions(Configure.LocalAddress), LogicalMessageFactory.Create(message))); }
public DeserializeConnector( SerializationMapper serializationMapper, MessageMetadataRegistry messageMetadataRegistry, LogicalMessageFactory logicalMessageFactory) { this.serializationMapper = serializationMapper; this.messageMetadataRegistry = messageMetadataRegistry; this.logicalMessageFactory = logicalMessageFactory; }
protected internal sealed override void Setup(FeatureConfigurationContext context) { var mapper = new MessageMapper(); var settings = context.Settings; var messageMetadataRegistry = settings.Get <MessageMetadataRegistry>(); mapper.Initialize(messageMetadataRegistry.GetAllMessages().Select(m => m.MessageType)); var defaultSerializerAndDefinition = settings.GetMainSerializer(); var defaultSerializer = CreateMessageSerializer(defaultSerializerAndDefinition, mapper, settings); var additionalDeserializerDefinitions = context.Settings.GetAdditionalSerializers(); var additionalDeserializers = new List <IMessageSerializer>(); var additionalDeserializerDiagnostics = new List <object>(); foreach (var definitionAndSettings in additionalDeserializerDefinitions) { var deserializer = CreateMessageSerializer(definitionAndSettings, mapper, settings); additionalDeserializers.Add(deserializer); var deserializerType = definitionAndSettings.Item1.GetType(); additionalDeserializerDiagnostics.Add(new { Type = deserializerType.FullName, Version = FileVersionRetriever.GetFileVersion(deserializerType), deserializer.ContentType }); } var resolver = new MessageDeserializerResolver(defaultSerializer, additionalDeserializers); var logicalMessageFactory = new LogicalMessageFactory(messageMetadataRegistry, mapper); context.Pipeline.Register(new DeserializeLogicalMessagesConnector(resolver, logicalMessageFactory, messageMetadataRegistry, mapper), "Deserializes the physical message body into logical messages"); context.Pipeline.Register(new SerializeMessageConnector(defaultSerializer, messageMetadataRegistry), "Converts a logical message into a physical message"); context.Container.ConfigureComponent(_ => mapper, DependencyLifecycle.SingleInstance); context.Container.ConfigureComponent(_ => messageMetadataRegistry, DependencyLifecycle.SingleInstance); context.Container.ConfigureComponent(_ => logicalMessageFactory, DependencyLifecycle.SingleInstance); LogFoundMessages(messageMetadataRegistry.GetAllMessages().ToList()); context.Settings.AddStartupDiagnosticsSection("Serialization", new { DefaultSerializer = new { Type = defaultSerializerAndDefinition.Item1.GetType().FullName, Version = FileVersionRetriever.GetFileVersion(defaultSerializerAndDefinition.Item1.GetType()), defaultSerializer.ContentType }, AdditionalDeserializers = additionalDeserializerDiagnostics }); }
public ICallback Defer(DateTime processAt, params object[] messages) { var options = new SendOptions(Address.Local) { DeliverAt = processAt, EnforceMessagingBestPractices = false }; return(SendMessages(options, LogicalMessageFactory.CreateMultiple(messages))); }
public ICallback Defer(TimeSpan delay, params object[] messages) { var options = new SendOptions(Address.Local) { DelayDeliveryWith = delay, EnforceMessagingBestPractices = false }; return(SendMessages(options, LogicalMessageFactory.CreateMultiple(messages))); }
private void ExtractNative(IncomingContext context, TransportMessage transportMessage) { //assuming all inbound native messages are of the same type var serializer = new System.Xml.Serialization.XmlSerializer(typeof(TestCommand)); var memStream = new MemoryStream(transportMessage.Body); var resultingMessage = serializer.Deserialize(memStream); var logicalMessage = LogicalMessageFactory.Create(typeof(TestCommand), resultingMessage, transportMessage.Headers); context.LogicalMessages = new List <LogicalMessage> { logicalMessage }; }
public Bus( EndpointConfiguration configuration, IDequeueStrategy strategy, IOutgoingPipelineFactory outgoingPipelineFactory, IIncomingPipelineFactory incomingPipelineFactory) { this.incomingPipelineFactory = incomingPipelineFactory; this.outgoingPipelineFactory = outgoingPipelineFactory; factory = new LogicalMessageFactory(); this.configuration = configuration; this.strategy = strategy; }
public Bus( EndpointConfiguration configuration, IDequeueStrategy strategy, IOutgoingPipelineFactory outgoingPipelineFactory, IIncomingPipelineFactory incomingPipelineFactory) { this.incomingPipelineFactory = incomingPipelineFactory; this.outgoingPipelineFactory = outgoingPipelineFactory; this.factory = new LogicalMessageFactory(); this.configuration = configuration; this.strategy = strategy; }
List <LogicalMessage> Extract(TransportMessage physicalMessage) { if (physicalMessage.Body == null || physicalMessage.Body.Length == 0) { return(new List <LogicalMessage>()); } string messageTypeIdentifier; var messageMetadata = new List <MessageMetadata>(); if (physicalMessage.Headers.TryGetValue(Headers.EnclosedMessageTypes, out messageTypeIdentifier)) { foreach (var messageTypeString in messageTypeIdentifier.Split(';')) { var typeString = messageTypeString; if (DoesTypeHaveImplAddedByVersion3(typeString)) { continue; } if (IsV4OrBelowScheduledTask(typeString)) { typeString = typeof(ScheduledTask).AssemblyQualifiedName; } var metadata = MessageMetadataRegistry.GetMessageMetadata(typeString); if (metadata == null) { continue; } messageMetadata.Add(metadata); } if (messageMetadata.Count == 0 && physicalMessage.MessageIntent != MessageIntentEnum.Publish) { log.WarnFormat("Could not determine message type from message header '{0}'. MessageId: {1}", messageTypeIdentifier, physicalMessage.Id); } } using (var stream = new MemoryStream(physicalMessage.Body)) { var messageTypesToDeserialize = messageMetadata.Select(metadata => metadata.MessageType).ToList(); return(MessageSerializer.Deserialize(stream, messageTypesToDeserialize) .Select(x => LogicalMessageFactory.Create(x.GetType(), x, physicalMessage.Headers)) .ToList()); } }
public ICallback Send(params object[] messages) { var destinations = GetAddressForMessages(messages) .Distinct() .ToList(); if (destinations.Count > 1) { throw new InvalidOperationException("Sends can only target one address."); } var destination = destinations.SingleOrDefault(); return(SendMessages(new SendOptions(destination), LogicalMessageFactory.CreateMultiple(messages))); }
public ICallback Defer(DateTime processAt, params object[] messages) { SendOptions options; if (Configure.Instance.WorkerRunsOnThisEndpoint()) { options = new SendOptions(MasterNodeAddress); } else { options = new SendOptions(Address.Local); } options.DeliverAt = processAt; options.EnforceMessagingBestPractices = false; return(SendMessages(options, LogicalMessageFactory.CreateMultiple(messages))); }
/// <summary> /// <see cref="IBus.Defer(DateTime,object)"/> /// </summary> public ICallback Defer(DateTime processAt, object message) { SendOptions options; if (Settings.GetOrDefault <bool>("Worker.Enabled")) { options = new SendOptions(Settings.Get <Address>("MasterNode.Address")); } else { options = new SendOptions(Configure.LocalAddress); } options.DeliverAt = processAt; options.EnforceMessagingBestPractices = false; return(SendMessage(options, LogicalMessageFactory.Create(message))); }
public void Raise <T>(T @event) { var messageType = typeof(T); EnsureMessageIsRegistered(messageType); var logicalMessage = LogicalMessageFactory.Create(messageType, @event); if (PipelineFactory.CurrentContext is RootContext) { using (var childBuilder = Builder.CreateChildBuilder()) { PipelineFactory.CurrentContext.Set(childBuilder); PipelineFactory.InvokeLogicalMessagePipeline(logicalMessage); } } else { PipelineFactory.InvokeLogicalMessagePipeline(logicalMessage); } }
/// <summary> /// Publishes the messages to all subscribers of the first message's type. /// </summary> public virtual void Publish <T>(params T[] messages) { if (messages == null || messages.Length == 0) { return; } var messagesToPublish = messages.Cast <object>().ToList(); var sendOptions = new SendOptions { Intent = MessageIntentEnum.Publish }; var context = InvokeSendPipeline(sendOptions, LogicalMessageFactory.CreateMultiple(messagesToPublish)); if (!context.Get <bool>("SubscribersFound") && NoSubscribersForMessage != null) { NoSubscribersForMessage(this, new MessageEventArgs(messagesToPublish.First())); } }
public DeserializeLogicalMessagesConnector(MessageDeserializerResolver deserializerResolver, LogicalMessageFactory logicalMessageFactory, MessageMetadataRegistry messageMetadataRegistry, MessageMapper mapper) { this.deserializerResolver = deserializerResolver; this.logicalMessageFactory = logicalMessageFactory; this.messageMetadataRegistry = messageMetadataRegistry; this.mapper = mapper; }
public DeserializeTransportMessageStep(IMessageSerializer serializer) { this.factory = new LogicalMessageFactory(); this.serializer = serializer; }
/// <summary> /// <see cref="ISendOnlyBus.Send(Address,object)"/> /// </summary> public ICallback Send(Address address, object message) { return(SendMessage(new SendOptions(address), LogicalMessageFactory.Create(message))); }
/// <summary> /// <see cref="ISendOnlyBus.Send(string,object)"/> /// </summary> public ICallback Send(string destination, object message) { return(SendMessage(new SendOptions(destination), LogicalMessageFactory.Create(message))); }