public async Task PrepareToStart(IBuilder builder, RecoverabilityComponent recoverabilityComponent, MessageOperations messageOperations, PipelineComponent pipelineComponent, IPipelineCache pipelineCache) { if (configuration.IsSendOnlyEndpoint) { return; } var receivePipeline = pipelineComponent.CreatePipeline <ITransportReceiveContext>(builder); mainPipelineExecutor = new MainPipelineExecutor(builder, pipelineCache, messageOperations, configuration.PipelineCompletedSubscribers, receivePipeline); if (configuration.PurgeOnStartup) { Logger.Warn("All queues owned by the endpoint will be purged on startup."); } AddReceivers(builder, recoverabilityComponent.GetRecoverabilityExecutorFactory(builder), transportReceiveInfrastructure.MessagePumpFactory); foreach (var receiver in receivers) { try { await receiver.Init().ConfigureAwait(false); } catch (Exception ex) { Logger.Fatal($"Receiver {receiver.Id} failed to initialize.", ex); throw; } } }
public MainPipelineExecutor(IBuilder builder, IEventAggregator eventAggregator, IPipelineCache pipelineCache, IPipeline<ITransportReceiveContext> mainPipeline) { this.mainPipeline = mainPipeline; this.pipelineCache = pipelineCache; this.builder = builder; this.eventAggregator = eventAggregator; }
public RootContext(IBuilder builder, IPipelineCache pipelineCache, IEventAggregator eventAggregator, IMessageMapper messageMapper) : base(null) { Set(builder); Set(pipelineCache); Set(eventAggregator); Set(messageMapper); }
public MainPipelineExecutor(IServiceProvider rootBuilder, IPipelineCache pipelineCache, MessageOperations messageOperations, INotificationSubscriptions <ReceivePipelineCompleted> receivePipelineNotification, Pipeline <ITransportReceiveContext> receivePipeline) { this.rootBuilder = rootBuilder; this.pipelineCache = pipelineCache; this.messageOperations = messageOperations; this.receivePipelineNotification = receivePipelineNotification; this.receivePipeline = receivePipeline; }
public async Task Initialize(IServiceProvider builder, RecoverabilityComponent recoverabilityComponent, MessageOperations messageOperations, PipelineComponent pipelineComponent, IPipelineCache pipelineCache, TransportInfrastructure transportInfrastructure, CancellationToken cancellationToken = default) { if (configuration.IsSendOnlyEndpoint) { return; } var mainPump = transportInfrastructure.Receivers[MainReceiverId]; var receivePipeline = pipelineComponent.CreatePipeline <ITransportReceiveContext>(builder); var mainPipelineExecutor = new MainPipelineExecutor(builder, pipelineCache, messageOperations, configuration.PipelineCompletedSubscribers, receivePipeline); var recoverabilityExecutorFactory = recoverabilityComponent.GetRecoverabilityExecutorFactory(builder); var recoverability = recoverabilityExecutorFactory .CreateDefault(configuration.LocalAddress); await mainPump.Initialize(configuration.PushRuntimeSettings, mainPipelineExecutor.Invoke, recoverability.Invoke, cancellationToken).ConfigureAwait(false); receivers.Add(mainPump); if (transportInfrastructure.Receivers.TryGetValue(InstanceSpecificReceiverId, out var instanceSpecificPump)) { var instanceSpecificRecoverabilityExecutor = recoverabilityExecutorFactory.CreateDefault(configuration.InstanceSpecificQueue); await instanceSpecificPump.Initialize(configuration.PushRuntimeSettings, mainPipelineExecutor.Invoke, instanceSpecificRecoverabilityExecutor.Invoke, cancellationToken).ConfigureAwait(false); receivers.Add(instanceSpecificPump); } foreach (var satellite in configuration.SatelliteDefinitions) { try { var satellitePump = transportInfrastructure.Receivers[satellite.Name]; var satellitePipeline = new SatellitePipelineExecutor(builder, satellite); var satelliteRecoverabilityExecutor = recoverabilityExecutorFactory.Create(satellite.RecoverabilityPolicy, satellite.ReceiveAddress); await satellitePump.Initialize(satellite.RuntimeSettings, satellitePipeline.Invoke, satelliteRecoverabilityExecutor.Invoke, cancellationToken).ConfigureAwait(false); receivers.Add(satellitePump); } catch (Exception ex) when(!ex.IsCausedBy(cancellationToken)) { Logger.Fatal("Satellite failed to start.", ex); throw; } } }
public ReceiveComponent(ReceiveConfiguration configuration, TransportReceiveInfrastructure receiveInfrastructure, IPipelineCache pipelineCache, PipelineConfiguration pipelineConfiguration, IEventAggregator eventAggregator, IBuilder builder, CriticalError criticalError, string errorQueue) { this.configuration = configuration; this.receiveInfrastructure = receiveInfrastructure; this.pipelineCache = pipelineCache; this.pipelineConfiguration = pipelineConfiguration; this.eventAggregator = eventAggregator; this.builder = builder; this.criticalError = criticalError; this.errorQueue = errorQueue; }
ReceiveComponent CreateReceiveComponent(ReceiveConfiguration receiveConfiguration, TransportInfrastructure transportInfrastructure, QueueBindings queueBindings, IPipelineCache pipelineCache, EventAggregator eventAggregator, IMessageMapper messageMapper) { var errorQueue = settings.ErrorQueueAddress(); var receiveComponent = new ReceiveComponent(receiveConfiguration, receiveConfiguration != null ? transportInfrastructure.ConfigureReceiveInfrastructure() : null, //don't create the receive infrastructure for send-only endpoints pipelineCache, pipelineConfiguration, eventAggregator, builder, criticalError, errorQueue, messageMapper); receiveComponent.BindQueues(queueBindings); if (receiveConfiguration != null) { settings.AddStartupDiagnosticsSection("Receiving", new { receiveConfiguration.LocalAddress, receiveConfiguration.InstanceSpecificQueue, receiveConfiguration.LogicalAddress, receiveConfiguration.PurgeOnStartup, receiveConfiguration.QueueNameBase, TransactionMode = receiveConfiguration.TransactionMode.ToString("G"), receiveConfiguration.PushRuntimeSettings.MaxConcurrency, Satellites = receiveConfiguration.SatelliteDefinitions.Select(s => new { s.Name, s.ReceiveAddress, TransactionMode = s.RequiredTransportTransactionMode.ToString("G"), s.RuntimeSettings.MaxConcurrency }).ToArray() }); } return(receiveComponent); }
public MainPipelineExecutor(IBuilder builder, IEventAggregator eventAggregator, IPipelineCache pipelineCache, IPipeline <ITransportReceiveContext> mainPipeline) { this.mainPipeline = mainPipeline; this.pipelineCache = pipelineCache; this.builder = builder; this.eventAggregator = eventAggregator; }
public RootContext(IServiceProvider builder, MessageOperations messageOperations, IPipelineCache pipelineCache, CancellationToken cancellationToken) : base(null, cancellationToken) { Set(messageOperations); Set(builder); Set(pipelineCache); }
public RootContext(IBuilder builder, MessageOperations messageOperations, IPipelineCache pipelineCache) : base(null) { Set(messageOperations); Set(builder); Set(pipelineCache); }
internal void ReplaceCaches(IPipelineCache <IBuild> buildCache, IPipelineCache <IBranch> branchCache, IPipelineCache <IBuildDefinition> definitionCache) { _buildCache = buildCache; _branchCache = branchCache; _definitionCache = definitionCache; }
public RootContext(IBuilder builder, IPipelineCache pipelineCache, IEventAggregator eventAggregator) : base(null) { Set(builder); Set(pipelineCache); Set(eventAggregator); }