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