public RootContext(IServiceProvider builder, MessageOperations messageOperations, IPipelineCache pipelineCache, CancellationToken cancellationToken)
: base(null, cancellationToken)
{
Set(messageOperations);
Set(builder);
Set(pipelineCache);
}
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 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 Task Unsubscribe(Type eventType, UnsubscribeOptions options)
{
return(MessageOperations.Unsubscribe(context, eventType, options));
}
public Task Publish <T>(Action <T> messageConstructor, PublishOptions publishOptions)
{
return(MessageOperations.Publish(context, messageConstructor, publishOptions));
}
public Task Publish(object message, PublishOptions options)
{
return(MessageOperations.Publish(context, message, options));
}
public Task Send <T>(Action <T> messageConstructor, SendOptions options)
{
return(MessageOperations.Send(context, messageConstructor, options));
}
public Task Send(object message, SendOptions options)
{
return(MessageOperations.Send(context, message, options));
}
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 Task Subscribe(Type eventType, SubscribeOptions options)
{
return(MessageOperations.Subscribe(this, eventType, options));
}
public Task Reply <T>(Action <T> messageConstructor, ReplyOptions options)
{
return(MessageOperations.Reply(this, messageConstructor, options));
}
public Task Reply(object message, ReplyOptions options)
{
return(MessageOperations.Reply(this, message, options));
}
public RootContext(IBuilder builder, MessageOperations messageOperations, IPipelineCache pipelineCache) : base(null)
{
Set(messageOperations);
Set(builder);
Set(pipelineCache);
}
