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