/// <summary>
/// Subscribes to receive published messages of the specified type if
/// they meet the provided condition.
/// </summary>
/// <param name="messageType">The type of message to subscribe to.</param>
/// <param name="condition">The condition under which to receive the message.</param>
public virtual void Subscribe(Type messageType, Predicate <object> condition)
{
MessagingBestPractices.AssertIsValidForPubSub(messageType);
if (Configure.SendOnlyMode)
{
throw new InvalidOperationException("It's not allowed for a send only endpoint to be a subscriber");
}
AssertHasLocalAddress();
var destination = GetAddressForMessageType(messageType);
if (Address.Self == destination)
{
throw new InvalidOperationException(string.Format("Message {0} is owned by the same endpoint that you're trying to subscribe", messageType));
}
if (SubscriptionManager == null)
{
throw new InvalidOperationException("No subscription manager is available");
}
SubscriptionManager.Subscribe(messageType, destination);
if (SubscriptionPredicatesEvaluator != null)
{
SubscriptionPredicatesEvaluator.AddConditionForSubscriptionToMessageType(messageType, condition);
}
}
/// <summary>
/// Subscribes to receive published messages of the specified type if
/// they meet the provided condition.
/// </summary>
/// <param name="messageType">The type of message to subscribe to.</param>
/// <param name="condition">The condition under which to receive the message.</param>
public virtual void Subscribe(Type messageType, Predicate <object> condition)
{
MessagingBestPractices.AssertIsValidForPubSub(messageType);
if (Configure.SendOnlyMode)
{
throw new InvalidOperationException("It's not allowed for a send only endpoint to be a subscriber");
}
AssertHasLocalAddress();
if (SubscriptionManager == null)
{
throw new InvalidOperationException("No subscription manager is available");
}
if (TransportDefinition.HasSupportForCentralizedPubSub && !IsAzureTransport())
{
// We are dealing with a brokered transport wired for auto pub/sub.
SubscriptionManager.Subscribe(messageType, null);
return;
}
var addresses = GetAddressForMessageType(messageType);
if (addresses.Count == 0)
{
throw new InvalidOperationException(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));
}
foreach (var destination in addresses)
{
if (Address.Self == destination)
{
throw new InvalidOperationException(string.Format("Message {0} is owned by the same endpoint that you're trying to subscribe", messageType));
}
SubscriptionManager.Subscribe(messageType, destination);
if (SubscriptionPredicatesEvaluator != null)
{
SubscriptionPredicatesEvaluator.AddConditionForSubscriptionToMessageType(messageType, condition);
}
}
}
public void SetUp()
{
HandlerInvocationCache.Clear();
SettingsHolder.Reset();
SettingsHolder.SetDefault("Endpoint.SendOnly", false);
Transport = new FakeTransport();
FuncBuilder = new FuncBuilder();
Configure.GetEndpointNameAction = () => "TestEndpoint";
const string localAddress = "endpointA";
MasterNodeAddress = new Address(localAddress, "MasterNode");
subscriptionPredicatesEvaluator = new SubscriptionPredicatesEvaluator();
router = new StaticMessageRouter(KnownMessageTypes());
handlerRegistry = new MessageHandlerRegistry();
MessageMetadataRegistry = new MessageMetadataRegistry
{
DefaultToNonPersistentMessages = false
};
try
{
Address.InitializeLocalAddress(localAddress);
}
catch // intentional
{
}
MessageSerializer = new XmlMessageSerializer(MessageMapper);
ExtensionMethods.GetStaticOutgoingHeadersAction = () => MessageHeaderManager.staticHeaders;
gatewayAddress = MasterNodeAddress.SubScope("gateway");
messageSender = MockRepository.GenerateStub <ISendMessages>();
subscriptionStorage = new FakeSubscriptionStorage();
subscriptionManager = new MessageDrivenSubscriptionManager
{
Builder = FuncBuilder,
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => headerManager);
FuncBuilder.Register <IMutateIncomingMessages>(() => new FilteringMutator
{
SubscriptionPredicatesEvaluator = subscriptionPredicatesEvaluator
});
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new SentTimeMutator());
FuncBuilder.Register <IMutateIncomingTransportMessages>(() => subscriptionManager);
FuncBuilder.Register <DefaultDispatcherFactory>(() => new DefaultDispatcherFactory());
FuncBuilder.Register <EstimatedTimeToSLABreachCalculator>(() => SLABreachCalculator);
FuncBuilder.Register <ExtractIncomingPrincipal>(() => new WindowsImpersonator());
unicastBus = new UnicastBus
{
MasterNodeAddress = MasterNodeAddress,
MessageSerializer = MessageSerializer,
Builder = FuncBuilder,
MessageSender = messageSender,
Transport = Transport,
MessageMapper = MessageMapper,
MessagePublisher = new StorageDrivenPublisher
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
},
MessageDeferrer = new TimeoutManagerDeferrer
{
MessageSender = messageSender,
TimeoutManagerAddress = MasterNodeAddress.SubScope("Timeouts")
},
SubscriptionManager = subscriptionManager,
MessageMetadataRegistry = MessageMetadataRegistry,
SubscriptionPredicatesEvaluator = subscriptionPredicatesEvaluator,
HandlerRegistry = handlerRegistry,
MessageRouter = router
};
bus = unicastBus;
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new CausationMutator {
Bus = bus
});
FuncBuilder.Register <IBus>(() => bus);
ExtensionMethods.SetHeaderAction = headerManager.SetHeader;
}
public void SetUp()
{
transportDefinition = new Msmq();
HandlerInvocationCache.Clear();
SettingsHolder.Reset();
SettingsHolder.SetDefault("Endpoint.SendOnly", false);
Transport = new FakeTransport();
FuncBuilder = new FuncBuilder();
Configure.GetEndpointNameAction = () => "TestEndpoint";
subscriptionPredicatesEvaluator = new SubscriptionPredicatesEvaluator();
router = new StaticMessageRouter(KnownMessageTypes());
handlerRegistry = new MessageHandlerRegistry();
MessageMetadataRegistry = new MessageMetadataRegistry
{
DefaultToNonPersistentMessages = false
};
MessageSerializer = new XmlMessageSerializer(MessageMapper);
//ExtensionMethods.GetStaticOutgoingHeadersAction = () => MessageHeaderManager.staticHeaders;
gatewayAddress = MasterNodeAddress.SubScope("gateway");
messageSender = MockRepository.GenerateStub <ISendMessages>();
subscriptionStorage = new FakeSubscriptionStorage();
subscriptionManager = new MessageDrivenSubscriptionManager
{
Builder = FuncBuilder,
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
var pipelineBuilder = new PipelineBuilder(FuncBuilder);
pipelineFactory = new PipelineExecutor(FuncBuilder, pipelineBuilder);
FuncBuilder.Register <IMessageSerializer>(() => MessageSerializer);
FuncBuilder.Register <ISendMessages>(() => messageSender);
FuncBuilder.Register <MessageAuditer>(() => new MessageAuditer());
FuncBuilder.Register <LogicalMessageFactory>(() => new LogicalMessageFactory());
FuncBuilder.Register <IMutateIncomingMessages>(() => new FilteringMutator
{
SubscriptionPredicatesEvaluator = subscriptionPredicatesEvaluator
});
FuncBuilder.Register <IMutateIncomingTransportMessages>(() => subscriptionManager);
FuncBuilder.Register <EstimatedTimeToSLABreachCalculator>(() => SLABreachCalculator);
FuncBuilder.Register <MessageMetadataRegistry>(() => MessageMetadataRegistry);
FuncBuilder.Register <IMessageHandlerRegistry>(() => handlerRegistry);
FuncBuilder.Register <ExtractIncomingPrincipal>(() => new WindowsImpersonator());
FuncBuilder.Register <IMessageMapper>(() => MessageMapper);
FuncBuilder.Register <ExtractLogicalMessagesBehavior>(() => new ExtractLogicalMessagesBehavior
{
MessageSerializer = MessageSerializer,
MessageMetadataRegistry = MessageMetadataRegistry,
});
FuncBuilder.Register <ImpersonateSenderBehavior>(() => new ImpersonateSenderBehavior
{
ExtractIncomingPrincipal = MockRepository.GenerateStub <ExtractIncomingPrincipal>()
});
FuncBuilder.Register <CreatePhysicalMessageBehavior>(() => new CreatePhysicalMessageBehavior());
FuncBuilder.Register <PipelineBuilder>(() => pipelineBuilder);
FuncBuilder.Register <PipelineExecutor>(() => pipelineFactory);
FuncBuilder.Register <TransportDefinition>(() => transportDefinition);
var messagePublisher = new StorageDrivenPublisher
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
var deferrer = new TimeoutManagerDeferrer
{
MessageSender = messageSender,
TimeoutManagerAddress = MasterNodeAddress.SubScope("Timeouts")
};
FuncBuilder.Register <IDeferMessages>(() => deferrer);
FuncBuilder.Register <IPublishMessages>(() => messagePublisher);
unicastBus = new UnicastBus
{
MasterNodeAddress = MasterNodeAddress,
Builder = FuncBuilder,
MessageSender = messageSender,
Transport = Transport,
MessageMapper = MessageMapper,
SubscriptionManager = subscriptionManager,
SubscriptionPredicatesEvaluator = subscriptionPredicatesEvaluator,
MessageRouter = router
};
bus = unicastBus;
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new CausationMutator {
Bus = bus
});
FuncBuilder.Register <IBus>(() => bus);
FuncBuilder.Register <UnicastBus>(() => unicastBus);
new HeaderBootstrapper
{
Builder = FuncBuilder
}.SetupHeaderActions();
}
