ReceiveConfiguration BuildReceiveConfiguration(TransportComponent.Configuration transportConfiguration)
{
var receiveConfiguration = ReceiveConfigurationBuilder.Build(settings, transportConfiguration);
if (receiveConfiguration == null)
{
return(null);
}
//note: remove once settings.LogicalAddress() , .LocalAddress() and .InstanceSpecificQueue() has been obsoleted
settings.Set(receiveConfiguration);
return(receiveConfiguration);
}
public static ReceiveConfiguration Build(ReadOnlySettings settings, TransportComponent.Configuration transportConfiguration)
{
var isSendOnlyEndpoint = settings.Get <bool>("Endpoint.SendOnly");
if (isSendOnlyEndpoint)
{
if (settings.HasExplicitValue(ReceiveSettingsExtensions.CustomLocalAddressKey))
{
throw new Exception($"Specifying a base name for the input queue using `{nameof(ReceiveSettingsExtensions.OverrideLocalAddress)}(baseInputQueueName)` is not supported for send-only endpoints.");
}
return(null);
}
var endpointName = settings.EndpointName();
var discriminator = settings.GetOrDefault <string>("EndpointInstanceDiscriminator");
var queueNameBase = settings.GetOrDefault <string>(ReceiveSettingsExtensions.CustomLocalAddressKey) ?? endpointName;
var purgeOnStartup = settings.GetOrDefault <bool>("Transport.PurgeOnStartup");
//note: This is an old hack, we are passing the endpoint name to bind but we only care about the properties
var mainInstanceProperties = transportConfiguration.BindToLocalEndpoint(new EndpointInstance(endpointName)).Properties;
var logicalAddress = LogicalAddress.CreateLocalAddress(queueNameBase, mainInstanceProperties);
var localAddress = transportConfiguration.ToTransportAddress(logicalAddress);
string instanceSpecificQueue = null;
if (discriminator != null)
{
instanceSpecificQueue = transportConfiguration.ToTransportAddress(logicalAddress.CreateIndividualizedAddress(discriminator));
}
var transactionMode = GetRequiredTransactionMode(settings);
var pushRuntimeSettings = GetDequeueLimitations(settings);
return(new ReceiveConfiguration(
logicalAddress,
queueNameBase,
localAddress,
instanceSpecificQueue,
transactionMode,
pushRuntimeSettings,
purgeOnStartup,
settings.GetOrDefault <Notification <ReceivePipelineCompleted> >() ?? new Notification <ReceivePipelineCompleted>()));
}
public static RoutingComponent Initialize(Configuration configuration,
TransportComponent.Configuration transportConfiguration,
ReceiveConfiguration receiveConfiguration,
Conventions conventions,
PipelineSettings pipelineSettings)
{
var distributionPolicy = configuration.DistributionPolicy;
var unicastRoutingTable = configuration.UnicastRoutingTable;
var endpointInstances = configuration.EndpointInstances;
foreach (var distributionStrategy in configuration.DistributionStrategies)
{
distributionPolicy.SetDistributionStrategy(distributionStrategy);
}
configuration.ConfiguredUnicastRoutes?.Apply(unicastRoutingTable, conventions);
var isSendOnlyEndpoint = receiveConfiguration == null;
if (isSendOnlyEndpoint == false)
{
pipelineSettings.Register(new ApplyReplyToAddressBehavior(
receiveConfiguration.LocalAddress,
receiveConfiguration.InstanceSpecificQueue,
configuration.PublicReturnAddress),
"Applies the public reply to address to outgoing messages");
}
var sendRouter = new UnicastSendRouter(
isSendOnlyEndpoint,
receiveConfiguration?.QueueNameBase,
receiveConfiguration?.InstanceSpecificQueue,
distributionPolicy,
unicastRoutingTable,
endpointInstances,
i => transportConfiguration.ToTransportAddress(LogicalAddress.CreateRemoteAddress(i)));
return(new RoutingComponent(
unicastRoutingTable,
distributionPolicy,
endpointInstances,
configuration.Publishers,
sendRouter,
configuration.EnforceBestPractices,
new Validations(conventions)));
}
public static ReceiveComponent Initialize(Configuration configuration,
ReceiveConfiguration transportReceiveConfiguration,
TransportComponent.Configuration transportConfiguration,
PipelineComponent pipelineComponent,
string errorQueue,
HostingComponent.Configuration hostingConfiguration,
PipelineSettings pipelineSettings)
{
var receiveComponent = new ReceiveComponent(transportReceiveConfiguration,
pipelineComponent,
hostingConfiguration.CriticalError,
errorQueue);
receiveComponent.BindQueues(transportConfiguration.QueueBindings);
pipelineSettings.Register("TransportReceiveToPhysicalMessageProcessingConnector", b =>
{
var storage = hostingConfiguration.Container.HasComponent <IOutboxStorage>() ? b.Build <IOutboxStorage>() : new NoOpOutboxStorage();
return(new TransportReceiveToPhysicalMessageConnector(storage));
}, "Allows to abort processing the message");
pipelineSettings.Register("LoadHandlersConnector", b =>
{
var adapter = hostingConfiguration.Container.HasComponent <ISynchronizedStorageAdapter>() ? b.Build <ISynchronizedStorageAdapter>() : new NoOpSynchronizedStorageAdapter();
var syncStorage = hostingConfiguration.Container.HasComponent <ISynchronizedStorage>() ? b.Build <ISynchronizedStorage>() : new NoOpSynchronizedStorage();
return(new LoadHandlersConnector(b.Build <MessageHandlerRegistry>(), syncStorage, adapter));
}, "Gets all the handlers to invoke from the MessageHandler registry based on the message type.");
pipelineSettings.Register("ExecuteUnitOfWork", new UnitOfWorkBehavior(), "Executes the UoW");
pipelineSettings.Register("InvokeHandlers", new InvokeHandlerTerminator(), "Calls the IHandleMessages<T>.Handle(T)");
if (!hostingConfiguration.Container.HasComponent <MessageHandlerRegistry>())
{
var orderedHandlers = configuration.ExecuteTheseHandlersFirst;
LoadMessageHandlers(configuration, orderedHandlers, hostingConfiguration.Container, hostingConfiguration.AvailableTypes);
}
if (transportReceiveConfiguration != null)
{
hostingConfiguration.AddStartupDiagnosticsSection("Receiving", new
{
transportReceiveConfiguration.LocalAddress,
transportReceiveConfiguration.InstanceSpecificQueue,
transportReceiveConfiguration.LogicalAddress,
transportReceiveConfiguration.PurgeOnStartup,
transportReceiveConfiguration.QueueNameBase,
TransactionMode = transportReceiveConfiguration.TransactionMode.ToString("G"),
transportReceiveConfiguration.PushRuntimeSettings.MaxConcurrency,
Satellites = transportReceiveConfiguration.SatelliteDefinitions.Select(s => new
{
s.Name,
s.ReceiveAddress,
TransactionMode = s.RequiredTransportTransactionMode.ToString("G"),
s.RuntimeSettings.MaxConcurrency
}).ToArray()
});
}
return(receiveComponent);
}