void ConfigureMessageRegistry(List <Type> knownMessages)
{
var messageRegistry = new MessageMetadataRegistry
{
DefaultToNonPersistentMessages = !SettingsHolder.Get <bool>("Endpoint.DurableMessages")
};
knownMessages.ForEach(messageRegistry.RegisterMessageType);
Configure.Instance.Configurer.RegisterSingleton <MessageMetadataRegistry>(messageRegistry);
Configure.Instance.Configurer.ConfigureComponent <LogicalMessageFactory>(DependencyLifecycle.SingleInstance);
if (!Logger.IsInfoEnabled)
{
return;
}
var messageDefinitions = messageRegistry.GetAllMessages().ToList();
Logger.InfoFormat("Number of messages found: {0}", messageDefinitions.Count());
if (!Logger.IsDebugEnabled)
{
return;
}
Logger.DebugFormat("Message definitions: \n {0}",
string.Concat(messageDefinitions.Select(md => md.ToString() + "\n")));
}
public void Should_throw_an_exception_for_a_unmapped_type()
{
var defaultMessageRegistry = new MessageMetadataRegistry();
var exception = Assert.Throws <Exception>(() => defaultMessageRegistry.GetMessageDefinition(typeof(int)));
Assert.AreEqual("Could not find Metadata for 'System.Int32'. Messages need to implement either 'IMessage', 'IEvent' or 'ICommand'. Alternatively, if you don't want to implement an interface, you can configure 'Unobtrusive Mode Messages' and use convention to configure how messages are mapped.", exception.Message);
}
void ConfigureMessageRegistry(FeatureConfigurationContext context, IEnumerable <Type> knownMessages)
{
var messageRegistry = new MessageMetadataRegistry(!DurableMessagesConfig.GetDurableMessagesEnabled(context.Settings), context.Settings.Get <Conventions>());
foreach (var msg in knownMessages)
{
messageRegistry.RegisterMessageType(msg);
}
context.Container.RegisterSingleton(messageRegistry);
context.Container.ConfigureComponent <LogicalMessageFactory>(DependencyLifecycle.SingleInstance);
if (!Logger.IsInfoEnabled)
{
return;
}
var messageDefinitions = messageRegistry.GetAllMessages().ToList();
Logger.InfoFormat("Number of messages found: {0}", messageDefinitions.Count());
if (!Logger.IsDebugEnabled)
{
return;
}
Logger.DebugFormat("Message definitions: \n {0}",
string.Concat(messageDefinitions.Select(md => md.ToString() + "\n")));
}
void ConfigureMessageRegistry(List<Type> knownMessages)
{
var messageRegistry = new MessageMetadataRegistry
{
DefaultToNonPersistentMessages = !SettingsHolder.Get<bool>("Endpoint.DurableMessages")
};
knownMessages.ForEach(messageRegistry.RegisterMessageType);
Configure.Instance.Configurer.RegisterSingleton<MessageMetadataRegistry>(messageRegistry);
Configure.Instance.Configurer.ConfigureComponent<LogicalMessageFactory>(DependencyLifecycle.SingleInstance);
if (!Logger.IsInfoEnabled)
{
return;
}
var messageDefinitions = messageRegistry.GetAllMessages().ToList();
Logger.InfoFormat("Number of messages found: {0}", messageDefinitions.Count());
if (!Logger.IsDebugEnabled)
{
return;
}
Logger.DebugFormat("Message definitions: \n {0}",
string.Concat(messageDefinitions.Select(md => md.ToString() + "\n")));
}
/// <summary>
/// Creates the configuration object.
/// </summary>
internal InitializableEndpoint Build()
{
if (scannedTypes == null)
{
var directoryToScan = AppDomain.CurrentDomain.BaseDirectory;
if (HttpRuntime.AppDomainAppId != null)
{
directoryToScan = HttpRuntime.BinDirectory;
}
scannedTypes = GetAllowedTypes(directoryToScan);
}
else
{
scannedTypes = scannedTypes.Union(GetAllowedCoreTypes()).ToList();
}
Settings.SetDefault("TypesToScan", scannedTypes);
ActivateAndInvoke <INeedInitialization>(scannedTypes, t => t.Customize(this));
UseTransportExtensions.EnsureTransportConfigured(this);
var container = customBuilder ?? new AutofacObjectBuilder();
var conventions = conventionsBuilder.Conventions;
Settings.SetDefault <Conventions>(conventions);
var messageMetadataRegistry = new MessageMetadataRegistry(conventions);
messageMetadataRegistry.RegisterMessageTypesFoundIn(Settings.GetAvailableTypes());
Settings.SetDefault <MessageMetadataRegistry>(messageMetadataRegistry);
return(new InitializableEndpoint(Settings, container, registrations, Pipeline, pipelineCollection));
}
public void Should_return_metadata_for_a_mapped_type()
{
var defaultMessageRegistry = new MessageMetadataRegistry();
defaultMessageRegistry.RegisterMessageType(typeof(int));
var messageMetadata = defaultMessageRegistry.GetMessageDefinition(typeof (int));
Assert.AreEqual(typeof(int),messageMetadata.MessageType);
}
public SerializeConnector(
SerializationMapper serializationMapper,
MessageMetadataRegistry messageMetadataRegistry)
{
this.serializationMapper = serializationMapper;
this.messageMetadataRegistry = messageMetadataRegistry;
}
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);
}
}
public void Should_return_metadata_for_a_mapped_type()
{
var defaultMessageRegistry = new MessageMetadataRegistry(false, new Conventions());
defaultMessageRegistry.RegisterMessageType(typeof(int));
var messageMetadata = defaultMessageRegistry.GetMessageMetadata(typeof(int));
Assert.AreEqual(typeof(int), messageMetadata.MessageType);
Assert.AreEqual(1, messageMetadata.MessageHierarchy.Count());
}
public TopicCache(IAmazonSimpleNotificationService snsClient, MessageMetadataRegistry messageMetadataRegistry, TransportConfiguration configuration)
{
this.configuration = configuration;
this.messageMetadataRegistry = messageMetadataRegistry;
this.snsClient = snsClient;
CustomEventToTopicsMappings = configuration.CustomEventToTopicsMappings ?? new EventToTopicsMappings();
CustomEventToEventsMappings = configuration.CustomEventToEventsMappings ?? new EventToEventsMappings();
}
public void Should_return_metadata_for_a_mapped_type()
{
var defaultMessageRegistry = new MessageMetadataRegistry();
defaultMessageRegistry.RegisterMessageType(typeof(int));
var messageMetadata = defaultMessageRegistry.GetMessageDefinition(typeof(int));
Assert.AreEqual(typeof(int), messageMetadata.MessageType);
}
public void Setup()
{
metadataRegistry = new MessageMetadataRegistry(new Conventions());
endpointInstances = new EndpointInstances();
subscriptionStorage = new FakeSubscriptionStorage();
router = new UnicastPublishRouter(
metadataRegistry,
subscriptionStorage);
}
public DeserializeConnector(
SerializationMapper serializationMapper,
MessageMetadataRegistry messageMetadataRegistry,
LogicalMessageFactory logicalMessageFactory)
{
this.serializationMapper = serializationMapper;
this.messageMetadataRegistry = messageMetadataRegistry;
this.logicalMessageFactory = logicalMessageFactory;
}
public void Should_return_metadata_for_a_mapped_type()
{
var defaultMessageRegistry = new MessageMetadataRegistry(false, new Conventions());
defaultMessageRegistry.RegisterMessageType(typeof(int));
var messageMetadata = defaultMessageRegistry.GetMessageMetadata(typeof(int));
Assert.AreEqual(typeof(int), messageMetadata.MessageType);
Assert.AreEqual(1, messageMetadata.MessageHierarchy.Count());
}
public void Setup()
{
metadataRegistry = new MessageMetadataRegistry(_ => true);
endpointInstances = new EndpointInstances();
subscriptionStorage = new FakeSubscriptionStorage();
router = new UnicastPublishRouter(
metadataRegistry,
i => string.Empty,
subscriptionStorage);
}
public MigrationSubscribeTerminator(ISubscriptionManager subscriptionManager,
MessageMetadataRegistry messageMetadataRegistry, SubscriptionRouter subscriptionRouter,
IMessageDispatcher dispatcher, string subscriberAddress, string subscriberEndpoint)
{
this.subscriptionManager = subscriptionManager;
this.messageMetadataRegistry = messageMetadataRegistry;
this.subscriptionRouter = subscriptionRouter;
this.dispatcher = dispatcher;
this.subscriberAddress = subscriberAddress;
this.subscriberEndpoint = subscriberEndpoint;
}
public void Should_match_types_from_a_different_assembly(string typeName)
{
var defaultMessageRegistry = new MessageMetadataRegistry(new Conventions().IsMessageType);
defaultMessageRegistry.RegisterMessageTypesFoundIn(new List <Type> {
typeof(MyEvent)
});
var messageMetadata = defaultMessageRegistry.GetMessageMetadata(typeName);
Assert.AreEqual(typeof(MyEvent), messageMetadata.MessageHierarchy.ToList()[0]);
}
static SendConnector InitializeBehavior(FakeRouter router = null)
{
var metadataRegistry = new MessageMetadataRegistry(new Conventions().IsMessageType);
metadataRegistry.RegisterMessageTypesFoundIn(new List <Type>
{
typeof(MyMessage),
typeof(MessageWithoutRouting)
});
return(new SendConnector(router ?? new FakeRouter()));
}
public void Should_return_metadata_for_a_mapped_type()
{
var conventions = new Conventions();
conventions.IsMessageTypeAction = type => type == typeof(int);
var defaultMessageRegistry = new MessageMetadataRegistry(conventions);
defaultMessageRegistry.RegisterMessageTypesFoundIn(new List<Type> { typeof(int) });
var messageMetadata = defaultMessageRegistry.GetMessageMetadata(typeof(int));
Assert.AreEqual(typeof(int), messageMetadata.MessageType);
Assert.AreEqual(1, messageMetadata.MessageHierarchy.Count());
}
static UnicastSendRouterConnector InitializeBehavior(
string sharedQueue = null,
string instanceSpecificQueue = null,
FakeSendRouter router = null)
{
var metadataRegistry = new MessageMetadataRegistry(new Conventions());
metadataRegistry.RegisterMessageTypesFoundIn(new List <Type> {
typeof(MyMessage), typeof(MessageWithoutRouting)
});
return(new UnicastSendRouterConnector(sharedQueue, instanceSpecificQueue, router ?? new FakeSendRouter(), new DistributionPolicy(), e => e.ToString()));
}
public void Should_return_metadata_for_a_mapped_type()
{
var defaultMessageRegistry = new MessageMetadataRegistry(type => type == typeof(int));
defaultMessageRegistry.RegisterMessageTypesFoundIn(new List <Type> {
typeof(int)
});
var messageMetadata = defaultMessageRegistry.GetMessageMetadata(typeof(int));
Assert.AreEqual(typeof(int), messageMetadata.MessageType);
Assert.AreEqual(1, messageMetadata.MessageHierarchy.Count());
}
static string SerializeEnclosedMessageTypes(MessageMetadataRegistry messageMeta, Type messageType)
{
var metadata = messageMeta.GetMessageMetadata(messageType);
var assemblyQualifiedNames = new HashSet <string>();
foreach (var type in metadata.MessageHierarchy)
{
assemblyQualifiedNames.Add(type.AssemblyQualifiedName);
}
return(string.Join(";", assemblyQualifiedNames));
}
public EventSubscriber(MessageHandlerRegistry registry, IMessageMapper mapper,
MessageMetadataRegistry messageMeta, IEventStoreConnection[] connections, int concurrency)
{
_registry = registry;
_clients = connections;
_messageMeta = messageMeta;
_concurrency = concurrency;
_settings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto,
SerializationBinder = new EventSerializationBinder(mapper),
ContractResolver = new EventContractResolver(mapper)
};
}
object[] Extract(TransportMessage m)
{
if (m.Body == null || m.Body.Length == 0)
{
return(new object[0]);
}
var messageMetadata = MessageMetadataRegistry.GetMessageTypes(m);
using (var stream = new MemoryStream(m.Body))
{
return(MessageSerializer.Deserialize(stream, messageMetadata.Select(metadata => metadata.MessageType).ToList()));
}
}
public void Should_return_the_correct_parent_hierarchy()
{
var defaultMessageRegistry = new MessageMetadataRegistry();
defaultMessageRegistry.RegisterMessageType(typeof(MyEvent));
var messageMetadata = defaultMessageRegistry.GetMessageDefinition(typeof(MyEvent));
Assert.AreEqual(5, messageMetadata.MessageHierarchy.Count());
Assert.AreEqual(typeof(MyEvent), messageMetadata.MessageHierarchy.ToList()[0]);
Assert.AreEqual(typeof(InterfaceParent1), messageMetadata.MessageHierarchy.ToList()[1]);
Assert.AreEqual(typeof(ConcreteParent1), messageMetadata.MessageHierarchy.ToList()[2]);
Assert.AreEqual(typeof(InterfaceParent1Base), messageMetadata.MessageHierarchy.ToList()[3]);
Assert.AreEqual(typeof(ConcreteParentBase), messageMetadata.MessageHierarchy.ToList()[4]);
}
public void SetUp()
{
consumer = new Consumer();
registry = new MessageMetadataRegistry();
headers = new Dictionary <string, string> [120];
for (var i = 0; i < 120; i++)
{
headers[i] = new Dictionary <string, string>
{
{
Headers.EnclosedMessageTypes,
$"Shipping.OrderAccepted{i}, Shared{i}, Version=1.0.0.0, Culture=neutral, PublicKeyToken=XYZ;Shipping.IOrderAccepted{i}, Shared{i}, Version=1.0.0.0, Culture=neutral, PublicKeyToken=XYZ;Shipping.IOrderStatusChanged{i}, Shared{i}, Version=1.0.0.0, Culture=neutral, PublicKeyToken=XYZ"
}
};
}
}
Type[] BuildTypesPublishedWithInheritance(Type[] messageTypesPublished, MessageMetadataRegistry registry)
{
if (!messageTypesPublished.Any())
{
return(messageTypesPublished);
}
var publishedMessageTypes = new HashSet <Type>(messageTypesPublished);
foreach (var t in messageTypesPublished)
{
publishedMessageTypes.UnionWith(registry.GetMessageMetadata(t).MessageHierarchy);
}
return(publishedMessageTypes.ToArray());
}
public void Should_return_the_correct_parent_hierarchy()
{
var defaultMessageRegistry = new MessageMetadataRegistry(new Conventions());
defaultMessageRegistry.RegisterMessageTypesFoundIn(new List<Type> { typeof(MyEvent) });
var messageMetadata = defaultMessageRegistry.GetMessageMetadata(typeof(MyEvent));
Assert.AreEqual(5, messageMetadata.MessageHierarchy.Count());
Assert.AreEqual(typeof(MyEvent), messageMetadata.MessageHierarchy.ToList()[0]);
Assert.AreEqual(typeof(InterfaceParent1), messageMetadata.MessageHierarchy.ToList()[1]);
Assert.AreEqual(typeof(ConcreteParent1), messageMetadata.MessageHierarchy.ToList()[2]);
Assert.AreEqual(typeof(InterfaceParent1Base), messageMetadata.MessageHierarchy.ToList()[3]);
Assert.AreEqual(typeof(ConcreteParentBase), messageMetadata.MessageHierarchy.ToList()[4]);
}
static void ConfigureMessageTypes(Conventions conventions, SettingsHolder settings)
{
var messageMetadataRegistry = new MessageMetadataRegistry(conventions.IsMessageType);
messageMetadataRegistry.RegisterMessageTypesFoundIn(settings.GetAvailableTypes());
settings.Set(messageMetadataRegistry);
var foundMessages = messageMetadataRegistry.GetAllMessages().ToList();
settings.AddStartupDiagnosticsSection("Messages", new
{
CustomConventionUsed = conventions.CustomMessageTypeConventionUsed,
NumberOfMessagesFoundAtStartup = foundMessages.Count,
Messages = foundMessages.Select(m => m.MessageType.FullName)
});
}
public void Invoke(OutgoingContext context, Action next)
{
var deliveryOptions = context.DeliveryOptions;
var toSend = new TransportMessage {
MessageIntent = MessageIntentEnum.Publish
};
var sendOptions = deliveryOptions as SendOptions;
if (sendOptions != null)
{
toSend.MessageIntent = sendOptions is ReplyOptions ? MessageIntentEnum.Reply : MessageIntentEnum.Send;
if (sendOptions.CorrelationId != null)
{
toSend.CorrelationId = sendOptions.CorrelationId;
}
}
//apply static headers
foreach (var kvp in UnicastBus.OutgoingHeaders)
{
toSend.Headers[kvp.Key] = kvp.Value;
}
//apply individual headers
foreach (var kvp in context.OutgoingLogicalMessage.Headers)
{
toSend.Headers[kvp.Key] = kvp.Value;
}
if (context.OutgoingLogicalMessage.MessageType != null)
{
var messageDefinitions = MessageMetadataRegistry.GetMessageMetadata(context.OutgoingLogicalMessage.MessageType);
toSend.TimeToBeReceived = messageDefinitions.TimeToBeReceived;
toSend.Recoverable = messageDefinitions.Recoverable;
}
context.Set(toSend);
next();
}
public async Task Should_set_content_type_header()
{
var registry = new MessageMetadataRegistry(new Conventions());
registry.RegisterMessageTypesFoundIn(new List<Type>
{
typeof(MyMessage)
});
var context = new TestableOutgoingLogicalMessageContext();
context.Message = new OutgoingLogicalMessage(typeof(MyMessage), new MyMessage());
var behavior = new SerializeMessageConnector(new FakeSerializer("myContentType"), registry);
await behavior.Invoke(context, c => TaskEx.CompletedTask);
Assert.AreEqual("myContentType", context.Headers[Headers.ContentType]);
}
public async Task Should_set_content_type_header()
{
var registry = new MessageMetadataRegistry(new Conventions().IsMessageType);
registry.RegisterMessageTypesFoundIn(new List <Type>
{
typeof(MyMessage)
});
var context = new TestableOutgoingLogicalMessageContext();
context.Message = new OutgoingLogicalMessage(typeof(MyMessage), new MyMessage());
var behavior = new SerializeMessageConnector(new FakeSerializer("myContentType"), registry);
await behavior.Invoke(context, c => Task.CompletedTask);
Assert.AreEqual("myContentType", context.Headers[Headers.ContentType]);
}
public EventSubscriber(MessageHandlerRegistry registry,
IEventStoreConnection connection, IMessageMapper mapper, MessageMetadataRegistry messageMeta)
{
_registry = registry;
_connection = connection;
_messageMeta = messageMeta;
_settings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto,
Binder = new EventSerializationBinder(mapper),
ContractResolver = new EventContractResolver(mapper)
};
_toBeAcknowledged = new ConcurrentBag <ResolvedEvent>();
_acknowledger = new Timer(_ =>
{
if (_toBeAcknowledged.IsEmpty)
{
return;
}
var willAcknowledge = _toBeAcknowledged.ToList();
var newBag = new ConcurrentBag <ResolvedEvent>();
Interlocked.Exchange <ConcurrentBag <ResolvedEvent> >(ref _toBeAcknowledged, newBag);
if (!ProcessingLive)
{
return;
}
Acknowledging.Update(willAcknowledge.Count);
Logger.Write(LogLevel.Info, () => $"Acknowledging {willAcknowledge.Count} events");
var page = 0;
while (page < willAcknowledge.Count)
{
var working = willAcknowledge.Skip(page).Take(1000);
_subscription.Acknowledge(working);
page += 1000;
}
}, null, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(5));
}
public void Invoke(SendLogicalMessagesContext context, Action next)
{
var sendOptions = context.SendOptions;
var toSend = new TransportMessage
{
MessageIntent = sendOptions.Intent,
ReplyToAddress = sendOptions.ReplyToAddress
};
if (sendOptions.CorrelationId != null)
{
toSend.CorrelationId = sendOptions.CorrelationId;
}
//apply static headers
foreach (var kvp in UnicastBus.OutgoingHeaders)
{
toSend.Headers[kvp.Key] = kvp.Value;
}
//apply individual headers
foreach (var kvp in context.LogicalMessages.SelectMany(m => m.Headers))
{
toSend.Headers[kvp.Key] = kvp.Value;
}
var messageDefinitions = context.LogicalMessages.Select(m => MessageMetadataRegistry.GetMessageDefinition(m.MessageType)).ToList();
toSend.TimeToBeReceived = messageDefinitions.Min(md => md.TimeToBeReceived);
toSend.Recoverable = messageDefinitions.Any(md => md.Recoverable);
context.Set(toSend);
PipelineExecutor.InvokeSendPipeline(sendOptions, toSend);
next();
}
// Moved event to error queue
private static async Task PoisonEvent(MessageMetadataRegistry messageMeta, JsonSerializerSettings settings, RecordedEvent e)
{
var transportTransaction = new TransportTransaction();
var descriptor = e.Metadata.Deserialize(settings);
var messageId = Guid.NewGuid().ToString();
var headers = new Dictionary <string, string>(descriptor.Headers)
{
[Headers.MessageIntent] = MessageIntentEnum.Send.ToString(),
[Headers.EnclosedMessageTypes] = SerializeEnclosedMessageTypes(messageMeta, Type.GetType(e.EventType)),
[Headers.MessageId] = messageId,
["EventId"] = e.EventId.ToString(),
["EventStreamId"] = e.EventStreamId,
["EventNumber"] = e.EventNumber.ToString()
};
var ex = new InvalidOperationException("Poisoned Event");
var errorContext = new ErrorContext(ex, headers,
messageId,
e.Data ?? new byte[0], transportTransaction,
int.MaxValue);
await Bus.OnError(errorContext).ConfigureAwait(false);
}
/// <summary>
/// Wraps the provided messages in an NServiceBus envelope, does not include destination.
/// Invokes message mutators.
/// </summary>
/// <param name="rawMessages">The messages to wrap.</param>
/// <param name="result">The envelope in which the messages are placed.</param>
/// <returns>The envelope containing the messages.</returns>
void MapTransportMessageFor(IList <object> rawMessages, TransportMessage result)
{
if (!Configure.SendOnlyMode)
{
result.ReplyToAddress = Address.Local;
if (PropagateReturnAddressOnSend && _messageBeingHandled != null && _messageBeingHandled.ReplyToAddress != null)
{
result.ReplyToAddress = _messageBeingHandled.ReplyToAddress;
}
}
var messages = ApplyOutgoingMessageMutatorsTo(rawMessages).ToArray();
var messageDefinitions = rawMessages.Select(m => MessageMetadataRegistry.GetMessageDefinition(GetMessageType(m))).ToList();
result.TimeToBeReceived = messageDefinitions.Min(md => md.TimeToBeReceived);
result.Recoverable = messageDefinitions.Any(md => md.Recoverable);
SerializeMessages(result, messages);
InvokeOutgoingTransportMessagesMutators(messages, result);
}
public void Should_throw_an_exception_for_a_unmapped_type()
{
var defaultMessageRegistry = new MessageMetadataRegistry();
var exception = Assert.Throws<Exception>(() => defaultMessageRegistry.GetMessageDefinition(typeof (int)));
Assert.AreEqual("Could not find Metadata for 'System.Int32'. Messages need to implement either 'IMessage', 'IEvent' or 'ICommand'. Alternatively, if you don't want to implement an interface, you can configure 'Unobtrusive Mode Messages' and use convention to configure how messages are mapped.", exception.Message);
}
/// <summary>
/// Initializes a new instance of <see cref="LogicalMessageFactory" />.
/// </summary>
public LogicalMessageFactory(MessageMetadataRegistry messageMetadataRegistry, IMessageMapper messageMapper)
{
this.messageMetadataRegistry = messageMetadataRegistry;
this.messageMapper = messageMapper;
}
void ConfigureMessageRegistry(FeatureConfigurationContext context, IEnumerable<Type> knownMessages)
{
var messageRegistry = new MessageMetadataRegistry(!DurableMessagesConfig.GetDurableMessagesEnabled(context.Settings), context.Settings.Get<Conventions>());
foreach (var msg in knownMessages)
{
messageRegistry.RegisterMessageType(msg);
}
context.Container.RegisterSingleton(messageRegistry);
context.Container.ConfigureComponent<LogicalMessageFactory>(DependencyLifecycle.SingleInstance);
if (!Logger.IsInfoEnabled)
{
return;
}
var messageDefinitions = messageRegistry.GetAllMessages().ToList();
Logger.InfoFormat("Number of messages found: {0}", messageDefinitions.Count());
if (!Logger.IsDebugEnabled)
{
return;
}
Logger.DebugFormat("Message definitions: \n {0}",
string.Concat(messageDefinitions.Select(md => md.ToString() + "\n")));
}
public void Should_throw_an_exception_for_a_unmapped_type()
{
var defaultMessageRegistry = new MessageMetadataRegistry(new Conventions());
Assert.Throws<Exception>(() => defaultMessageRegistry.GetMessageMetadata(typeof(int)));
}
public void Setup()
{
metadataRegistry = new MessageMetadataRegistry(new Conventions());
endpointInstances = new EndpointInstances();
subscriptionStorage = new FakeSubscriptionStorage();
router = new UnicastPublishRouter(
metadataRegistry,
subscriptionStorage);
}
static UnicastSendRouterConnector InitializeBehavior(
string sharedQueue = null,
string instanceSpecificQueue = null,
FakeSendRouter router = null)
{
var metadataRegistry = new MessageMetadataRegistry(new Conventions());
metadataRegistry.RegisterMessageTypesFoundIn(new List<Type> { typeof(MyMessage), typeof(MessageWithoutRouting) });
return new UnicastSendRouterConnector(sharedQueue, instanceSpecificQueue, null, router ?? new FakeSendRouter(), new DistributionPolicy(), e => e.ToString());
}
public UnicastPublishRouter(MessageMetadataRegistry messageMetadataRegistry, ISubscriptionStorage subscriptionStorage)
{
this.messageMetadataRegistry = messageMetadataRegistry;
this.subscriptionStorage = subscriptionStorage;
}
