protected override void Setup(FeatureConfigurationContext context)
{
#region FeatureStartupTaskRegistration
context.RegisterStartupTask(new MyStartupTask());
// or
context.RegisterStartupTask(() => new MyStartupTask());
#endregion
}
protected override void Setup(FeatureConfigurationContext context)
{
var conventions = context.Settings.Get<Conventions>();
context.RegisterStartupTask(b =>
{
var handlerRegistry = b.Build<MessageHandlerRegistry>();
var messageTypesHandled = GetMessageTypesHandledByThisEndpoint(handlerRegistry, conventions);
return new HandledMessageInfoPublisher(b.Build<IDataBackplaneClient>(), messageTypesHandled, context.Settings, TimeSpan.FromSeconds(5));
});
context.RegisterStartupTask(b => new HandledMessageInfoSubscriber(b.Build<IDataBackplaneClient>(), context.Settings, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(20)));
}
/// <summary>
/// <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
if (context.Settings.GetOrDefault <bool>("Endpoint.SendOnly"))
{
throw new Exception("SLA Monitoring is not supported for send only endpoints, please remove .EnableSLAPerformanceCounter(mySLA) from your config.");
}
TimeSpan endpointSla;
if (!context.Settings.TryGet(EndpointSLAKey, out endpointSla))
{
throw new Exception("Endpoint SLA is required for the `SLA violation countdown` counter. Pass the SLA for this endpoint to .EnableSLAPerformanceCounter(mySLA).");
}
var counterInstanceName = context.Settings.EndpointName();
var slaBreachCounter = new EstimatedTimeToSLABreachCounter(endpointSla, counterInstanceName);
var notifications = context.Settings.Get <NotificationSubscriptions>();
notifications.Subscribe <ReceivePipelineCompleted>(e =>
{
string timeSentString;
if (!e.ProcessedMessage.Headers.TryGetValue(Headers.TimeSent, out timeSentString))
{
return(TaskEx.CompletedTask);
}
slaBreachCounter.Update(DateTimeExtensions.ToUtcDateTime(timeSentString), e.StartedAt, e.CompletedAt);
return(TaskEx.CompletedTask);
});
context.RegisterStartupTask(() => slaBreachCounter);
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var builder = new NHibernateConfigurationBuilder(context.Settings, "Timeout", "NHibernate.Timeouts.Configuration", "StorageConfiguration");
builder.AddMappings<TimeoutEntityMap>();
var config = builder.Build();
if (RunInstaller(context))
{
context.Settings.Get<Installer.SchemaUpdater>().Execute = identity =>
{
new OptimizedSchemaUpdate(config.Configuration).Execute(false, true);
return Task.FromResult(0);
};
}
var timeoutsCleanupExecutionInterval = context.Settings.GetOrDefault<TimeSpan?>("NHibernate.Timeouts.CleanupExecutionInterval") ?? TimeSpan.FromMinutes(2);
context.Container.ConfigureComponent(b =>
{
var sessionFactory = config.Configuration.BuildSessionFactory();
return new TimeoutPersister(
context.Settings.EndpointName().ToString(),
sessionFactory,
new NHibernateSynchronizedStorageAdapter(sessionFactory), new NHibernateSynchronizedStorage(sessionFactory),
timeoutsCleanupExecutionInterval);
}, DependencyLifecycle.SingleInstance);
context.RegisterStartupTask(new DetectIncorrectIndexesStartupTask(config.Configuration));
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var builder = new NHibernateConfigurationBuilder(context.Settings, "Subscription", "NHibernate.Subscriptions.Configuration", "StorageConfiguration");
builder.AddMappings <SubscriptionMap>();
var config = builder.Build();
if (RunInstaller(context))
{
context.Settings.Get <Installer.SchemaUpdater>().Execute = identity =>
{
new OptimizedSchemaUpdate(config.Configuration).Execute(false, true);
return(Task.FromResult(0));
};
}
var sessionFactory = config.Configuration.BuildSessionFactory();
var persister = context.Settings.HasSetting(CacheExpirationSettingsKey)
? new CachedSubscriptionPersister(sessionFactory, context.Settings.Get <TimeSpan>(CacheExpirationSettingsKey))
: new SubscriptionPersister(sessionFactory);
context.Container.ConfigureComponent(b => persister, DependencyLifecycle.SingleInstance);
context.RegisterStartupTask(new SubscriptionPersisterInitTask(persister));
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var builder = new NHibernateConfigurationBuilder(context.Settings, "Saga", "StorageConfiguration");
var config = builder.Build();
var sharedMappings = context.Settings.Get <SharedMappings>();
var outboxEnabled = context.Settings.IsFeatureActive(typeof(Outbox));
if (outboxEnabled)
{
sharedMappings.AddMapping(configuration => ApplyMappings(configuration, context));
config.Configuration.Properties[Environment.TransactionStrategy] = typeof(AdoNetTransactionFactory).FullName;
}
sharedMappings.ApplyTo(config.Configuration);
var sessionFactory = config.Configuration.BuildSessionFactory();
context.Container.ConfigureComponent(b => new NHibernateSynchronizedStorage(sessionFactory), DependencyLifecycle.SingleInstance);
context.Container.ConfigureComponent(b => new NHibernateSynchronizedStorageAdapter(sessionFactory), DependencyLifecycle.SingleInstance);
//Legacy
context.Container.ConfigureComponent(b => new NHibernateStorageContext(), DependencyLifecycle.InstancePerUnitOfWork);
if (outboxEnabled)
{
var factory = context.Settings.Get <IOutboxPersisterFactory>();
var persister = factory.Create(sessionFactory, context.Settings.EndpointName());
context.Container.ConfigureComponent(b => persister, DependencyLifecycle.SingleInstance);
context.RegisterStartupTask(b => new OutboxCleaner(persister, b.Build <CriticalError>()));
}
var runInstaller = context.Settings.Get <bool>("NHibernate.Common.AutoUpdateSchema");
if (runInstaller)
{
context.Settings.Get <Installer.SchemaUpdater>().Execute = identity =>
{
var schemaUpdate = new OptimizedSchemaUpdate(config.Configuration);
var sb = new StringBuilder();
schemaUpdate.Execute(s => sb.AppendLine(s), true);
if (schemaUpdate.Exceptions.Any())
{
var aggregate = new AggregateException(schemaUpdate.Exceptions);
var errorMessage = @"Schema update failed.
The following exception(s) were thrown:
{0}
TSql Script:
{1}";
throw new Exception(string.Format(errorMessage, aggregate.Flatten(), sb));
}
return(Task.FromResult(0));
};
}
}
/// <summary>
/// <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
if (context.Settings.GetOrDefault<bool>("Endpoint.SendOnly"))
{
throw new Exception("SLA Monitoring is not supported for send only endpoints, please remove .EnableSLAPerformanceCounter(mySLA) from your config.");
}
TimeSpan endpointSla;
if (!context.Settings.TryGet(EndpointSLAKey, out endpointSla))
{
throw new Exception("Endpoint SLA is required for the `SLA violation countdown` counter. Pass the SLA for this endpoint to .EnableSLAPerformanceCounter(mySLA).");
}
var counterInstanceName = context.Settings.EndpointName();
var slaBreachCounter = new EstimatedTimeToSLABreachCounter(endpointSla, counterInstanceName);
var notifications = context.Settings.Get<NotificationSubscriptions>();
notifications.Subscribe<ReceivePipelineCompleted>(e =>
{
string timeSentString;
if (!e.ProcessedMessage.Headers.TryGetValue(Headers.TimeSent, out timeSentString))
{
return TaskEx.CompletedTask;
}
slaBreachCounter.Update(DateTimeExtensions.ToUtcDateTime(timeSentString), e.StartedAt, e.CompletedAt);
return TaskEx.CompletedTask;
});
context.RegisterStartupTask(() => slaBreachCounter);
}
/// <summary>
/// See <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
var outboxStorage = new InMemoryOutboxStorage();
context.Container.RegisterSingleton<IOutboxStorage>(outboxStorage);
var timeSpan = context.Settings.Get<TimeSpan>(TimeToKeepDeduplicationEntries);
context.RegisterStartupTask(new OutboxCleaner(outboxStorage, timeSpan));
}
/// <summary>
/// See <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
var logicalAddress = context.Settings.LogicalAddress();
var performanceDiagnosticsBehavior = new ReceivePerformanceDiagnosticsBehavior(logicalAddress.EndpointInstance.Endpoint);
context.Pipeline.Register(performanceDiagnosticsBehavior, "Provides various performance counters for receive statistics");
context.RegisterStartupTask(new WarmupCooldownTask(performanceDiagnosticsBehavior));
}
/// <summary>Called when the features is activated.</summary>
protected override void Setup(FeatureConfigurationContext context)
{
if (!VersionChecker.CoreVersionIsAtLeast(4, 4))
{
context.Pipeline.Register("EnrichPreV44MessagesWithHostDetailsBehavior", new EnrichPreV44MessagesWithHostDetailsBehavior(context.Settings), "Enriches pre v4 messages with details about the host");
}
context.RegisterStartupTask(builder => new HeartbeatStartup(builder.Build<IDispatchMessages>(), context.Settings));
}
/// <summary>Called when the features is activated.</summary>
protected override void Setup(FeatureConfigurationContext context)
{
context.Settings.GetAvailableTypes()
.Where(t => typeof(ICustomCheck).IsAssignableFrom(t) && !(t.IsAbstract || t.IsInterface))
.ToList()
.ForEach(t => context.Container.ConfigureComponent(t, DependencyLifecycle.InstancePerCall));
context.RegisterStartupTask(b => new CustomChecksStartup(b.BuildAll<ICustomCheck>(), context.Settings, b.Build<CriticalError>(), b.Build<IDispatchMessages>()));
}
protected internal override void Setup(FeatureConfigurationContext context)
{
var transportDefinition = context.Settings.Get <TransportDefinition>();
var canReceive = !context.Settings.GetOrDefault <bool>("Endpoint.SendOnly");
var distributionPolicy = context.Routing.DistributionPolicy;
var publishers = context.Routing.Publishers;
var configuredPublishers = context.Settings.Get <ConfiguredPublishers>();
var conventions = context.Settings.Get <Conventions>();
var enforceBestPractices = context.Routing.EnforceBestPractices;
configuredPublishers.Apply(publishers, conventions, enforceBestPractices);
context.Pipeline.Register(b =>
{
var unicastPublishRouter = new UnicastPublishRouter(b.GetRequiredService <MessageMetadataRegistry>(), i =>
{
var queueAddress = new QueueAddress(i.Endpoint, i.Discriminator, i.Properties, null);
return(transportDefinition.ToTransportAddress(queueAddress));
}, b.GetRequiredService <ISubscriptionStorage>());
return(new MigrationModePublishConnector(distributionPolicy, unicastPublishRouter));
}, "Determines how the published messages should be routed");
if (canReceive)
{
var endpointInstances = context.Routing.EndpointInstances;
var subscriptionRouter = new SubscriptionRouter(publishers, endpointInstances, i =>
{
var queueAddress = new QueueAddress(i.Endpoint, i.Discriminator, i.Properties, null);
return(transportDefinition.ToTransportAddress(queueAddress));
});
var subscriberAddress = context.Receiving.LocalAddress;
context.Pipeline.Register(b =>
new MigrationSubscribeTerminator(b.GetRequiredService <ISubscriptionManager>(), b.GetRequiredService <MessageMetadataRegistry>(), subscriptionRouter, b.GetRequiredService <IMessageDispatcher>(), subscriberAddress, context.Settings.EndpointName()), "Requests the transport to subscribe to a given message type");
context.Pipeline.Register(b =>
new MigrationUnsubscribeTerminator(b.GetRequiredService <ISubscriptionManager>(), b.GetRequiredService <MessageMetadataRegistry>(), subscriptionRouter, b.GetRequiredService <IMessageDispatcher>(), subscriberAddress, context.Settings.EndpointName()), "Sends requests to unsubscribe when message driven subscriptions is in use");
var authorizer = context.Settings.GetSubscriptionAuthorizer();
if (authorizer == null)
{
authorizer = _ => true;
}
context.Container.AddSingleton(authorizer);
context.Pipeline.Register(typeof(SubscriptionReceiverBehavior), "Check for subscription messages and execute the requested behavior to subscribe or unsubscribe.");
}
else
{
context.Pipeline.Register(new SendOnlySubscribeTerminator(), "Throws an exception when trying to subscribe from a send-only endpoint");
context.Pipeline.Register(new SendOnlyUnsubscribeTerminator(), "Throws an exception when trying to unsubscribe from a send-only endpoint");
}
// implementations of IInitializableSubscriptionStorage are optional and can be provided by persisters.
context.RegisterStartupTask(b => new MessageDrivenSubscriptions.InitializableSubscriptionStorage(b.GetService <IInitializableSubscriptionStorage>()));
}
/// <summary>
/// See <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
var outboxStorage = new InMemoryOutboxStorage();
context.Container.RegisterSingleton <IOutboxStorage>(outboxStorage);
var timeSpan = context.Settings.Get <TimeSpan>(TimeToKeepDeduplicationEntries);
context.RegisterStartupTask(new OutboxCleaner(outboxStorage, timeSpan));
}
/// <summary>
/// See <see cref="Feature.Setup"/>.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
var transportDefinition = context.Settings.Get <TransportDefinition>();
SubscribeSettings settings;
if (!context.Settings.TryGet(out settings))
{
settings = new SubscribeSettings();
}
var conventions = context.Settings.Get <Conventions>();
if (transportDefinition.GetOutboundRoutingPolicy(context.Settings).Publishes == OutboundRoutingType.Multicast)
{
context.RegisterStartupTask(b =>
{
var handlerRegistry = b.Build <MessageHandlerRegistry>();
var messageTypesHandled = GetMessageTypesHandledByThisEndpoint(handlerRegistry, conventions, settings);
return(new ApplySubscriptions(messageTypesHandled));
});
}
else
{
context.RegisterStartupTask(b =>
{
var handlerRegistry = b.Build <MessageHandlerRegistry>();
var messageTypesToSubscribe = GetMessageTypesHandledByThisEndpoint(handlerRegistry, conventions, settings);
if (settings.RequireExplicitRouting)
{
var subscriptionRouter = b.Build <SubscriptionRouter>();
messageTypesToSubscribe = messageTypesToSubscribe.Where(t => subscriptionRouter.GetAddressesForEventType(t).Any())
.ToList();
}
return(new ApplySubscriptions(messageTypesToSubscribe));
});
}
}
protected override void Setup(FeatureConfigurationContext context)
{
var transportAddress = context.Settings.LocalAddress();
var connectionString = context.Settings.Get<string>("NServiceBus.DataBackplane.ConnectionString");
var definition = context.Settings.Get<BackplaneDefinition>();
var backplane = definition.CreateBackplane(transportAddress, connectionString);
var backplaneClient = new DataBackplaneClient(backplane, new DefaultQuerySchedule());
context.Container.ConfigureComponent(_ => backplaneClient, DependencyLifecycle.SingleInstance);
context.RegisterStartupTask(new DataBackplaneClientLifecycle(backplaneClient));
}
/// <summary>
/// See <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
if (!PersistenceStartup.HasSupportFor<StorageType.Outbox>(context.Settings))
{
throw new Exception("The selected persistence doesn't have support for outbox storage. Select another persistence or disable the outbox feature using endpointConfiguration.DisableFeature<Outbox>()");
}
//note: in the future we should change the persister api to give us a "outbox factory" so that we can register it in DI here instead of relying on the persister to do it
context.RegisterStartupTask(new DtcRunningWarning());
context.Pipeline.Register("ForceBatchDispatchToBeIsolated", new ForceBatchDispatchToBeIsolatedBehavior(), "Makes sure that we dispatch straight to the transport so that we can safely set the outbox record to dispatched one the dispatch pipeline returns.");
}
/// <summary>
/// See <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
if (!PersistenceStartup.HasSupportFor <StorageType.Outbox>(context.Settings))
{
throw new Exception("The selected persistence doesn't have support for outbox storage. Select another persistence or disable the outbox feature using endpointConfiguration.DisableFeature<Outbox>()");
}
//note: in the future we should change the persister api to give us a "outbox factory" so that we can register it in DI here instead of relying on the persister to do it
context.RegisterStartupTask(new DtcRunningWarning());
context.Pipeline.Register("ForceBatchDispatchToBeIsolated", new ForceBatchDispatchToBeIsolatedBehavior(), "Makes sure that we dispatch straight to the transport so that we can safely set the outbox record to dispatched one the dispatch pipeline returns.");
}
/// <summary>
/// Called when the features is activated.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
if (!context.Container.HasComponent<IDataBusSerializer>())
{
context.Container.ConfigureComponent<DefaultDataBusSerializer>(DependencyLifecycle.SingleInstance);
}
context.RegisterStartupTask(b => new IDataBusInitializer(b.GetRequiredService<IDataBus>()));
var conventions = context.Settings.Get<Conventions>();
context.Pipeline.Register(new DataBusReceiveBehavior.Registration(conventions));
context.Pipeline.Register(new DataBusSendBehavior.Registration(conventions));
}
protected override void Setup(FeatureConfigurationContext context)
{
var serviceControlQueue = context.Settings.Get <string>(SettingsKeys.SagaAuditQueue);
var customSagaEntitySerialization = context.Settings.GetOrDefault <Func <object, Dictionary <string, string> > >(SettingsKeys.CustomSerialization);
var backend = new ServiceControlBackend(serviceControlQueue, context.Settings.LocalAddress());
context.Pipeline.Register(new CaptureSagaStateBehavior.CaptureSagaStateRegistration(context.Settings.EndpointName(), backend, customSagaEntitySerialization));
context.Pipeline.Register("CaptureSagaResultingMessages", new CaptureSagaResultingMessagesBehavior(), "Reports the messages sent by sagas to ServiceControl");
context.Pipeline.Register("AuditInvokedSaga", new AuditInvokedSagaBehavior(), "Adds saga information to audit messages");
context.RegisterStartupTask(b => new SagaAuditStartupTask(backend, b.GetRequiredService <IMessageDispatcher>()));
}
protected internal override void Setup(FeatureConfigurationContext context)
{
var transportInfrastructure = context.Settings.Get <TransportInfrastructure>();
var canReceive = !context.Settings.GetOrDefault <bool>("Endpoint.SendOnly");
var distributionPolicy = context.Routing.DistributionPolicy;
var publishers = context.Routing.Publishers;
var configuredPublishers = context.Settings.Get <ConfiguredPublishers>();
var conventions = context.Settings.Get <Conventions>();
var enforceBestPractices = context.Routing.EnforceBestPractices;
configuredPublishers.Apply(publishers, conventions, enforceBestPractices);
context.Pipeline.Register(b =>
{
var unicastPublishRouter = new UnicastPublishRouter(b.Build <MessageMetadataRegistry>(), i => transportInfrastructure.ToTransportAddress(LogicalAddress.CreateRemoteAddress(i)), b.Build <ISubscriptionStorage>());
return(new MigrationModePublishConnector(distributionPolicy, unicastPublishRouter));
}, "Determines how the published messages should be routed");
if (canReceive)
{
var endpointInstances = context.Routing.EndpointInstances;
var transportSubscriptionInfrastructure = transportInfrastructure.ConfigureSubscriptionInfrastructure();
var subscriptionManager = transportSubscriptionInfrastructure.SubscriptionManagerFactory();
var subscriptionRouter = new SubscriptionRouter(publishers, endpointInstances, i => transportInfrastructure.ToTransportAddress(LogicalAddress.CreateRemoteAddress(i)));
var subscriberAddress = context.Receiving.LocalAddress;
context.Pipeline.Register(b =>
new MigrationSubscribeTerminator(subscriptionManager, subscriptionRouter, b.Build <IDispatchMessages>(), subscriberAddress, context.Settings.EndpointName()), "Requests the transport to subscribe to a given message type");
context.Pipeline.Register(b =>
new MigrationUnsubscribeTerminator(subscriptionManager, subscriptionRouter, b.Build <IDispatchMessages>(), subscriberAddress, context.Settings.EndpointName()), "Sends requests to unsubscribe when message driven subscriptions is in use");
var authorizer = context.Settings.GetSubscriptionAuthorizer();
if (authorizer == null)
{
authorizer = _ => true;
}
context.Container.RegisterSingleton(authorizer);
context.Pipeline.Register(typeof(SubscriptionReceiverBehavior), "Check for subscription messages and execute the requested behavior to subscribe or unsubscribe.");
}
else
{
context.Pipeline.Register(new SendOnlySubscribeTerminator(), "Throws an exception when trying to subscribe from a send-only endpoint");
context.Pipeline.Register(new SendOnlyUnsubscribeTerminator(), "Throws an exception when trying to unsubscribe from a send-only endpoint");
}
context.Container.ConfigureComponent <MessageDrivenSubscriptionsToBeRefactored.InitializableSubscriptionStorage>(DependencyLifecycle.SingleInstance);
context.RegisterStartupTask(b => b.Build <MessageDrivenSubscriptionsToBeRefactored.InitializableSubscriptionStorage>());
}
/// <summary>
/// Called when the features is activated.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
if (!context.Container.HasComponent<IDataBusSerializer>())
{
context.Container.ConfigureComponent<DefaultDataBusSerializer>(DependencyLifecycle.SingleInstance);
}
context.RegisterStartupTask(b => b.Build<IDataBusInitializer>());
context.Container.ConfigureComponent<IDataBusInitializer>(DependencyLifecycle.SingleInstance);
var conventions = context.Settings.Get<Conventions>();
context.Pipeline.Register(new DataBusReceiveBehavior.Registration(conventions));
context.Pipeline.Register(new DataBusSendBehavior.Registration(conventions));
}
protected override void Setup(FeatureConfigurationContext context)
{
var store = DocumentStoreManager.GetDocumentStore<StorageType.Timeouts>(context.Settings);
store.Listeners.RegisterListener(new TimeoutDataV1toV2Converter());
Helpers.SafelyCreateIndex(store, new TimeoutsIndex());
context.Container.ConfigureComponent(() => new TimeoutPersister(store), DependencyLifecycle.InstancePerCall);
context.Container.ConfigureComponent(() => new QueryTimeouts(store, context.Settings.EndpointName()), DependencyLifecycle.SingleInstance); // Needs to be SingleInstance because it contains cleanup state
context.Container.ConfigureComponent<QueryCanceller>(DependencyLifecycle.InstancePerCall);
context.RegisterStartupTask(b => b.Build<QueryCanceller>());
}
protected override void Setup(FeatureConfigurationContext context)
{
var store = DocumentStoreManager.GetDocumentStore<StorageType.Outbox>(context.Settings);
Helpers.SafelyCreateIndex(store, new OutboxRecordsIndex());
context.Container.ConfigureComponent(b => new OutboxPersister(store, context.Settings.EndpointName()), DependencyLifecycle.InstancePerCall);
context.Container.ConfigureComponent(b => new OutboxRecordsCleaner(store), DependencyLifecycle.InstancePerCall);
context.Container.ConfigureComponent<OutboxCleaner>(DependencyLifecycle.InstancePerCall);
context.RegisterStartupTask(builder => builder.Build<OutboxCleaner>());
}
protected override void Setup(FeatureConfigurationContext context)
{
var outboxStorage = new NonDurableOutboxStorage();
context.Services.AddSingleton(typeof(IOutboxStorage), outboxStorage);
var deduplicationPeriod = context.Settings.Get <TimeSpan>(TimeToKeepDeduplicationEntries);
if (!context.Settings.TryGet(IntervalToCheckForDuplicateEntries, out TimeSpan cleanupInterval))
{
cleanupInterval = TimeSpan.FromMinutes(1);
}
context.RegisterStartupTask(new OutboxCleaner(outboxStorage, deduplicationPeriod, cleanupInterval));
}
/// <summary>
/// Called when the features is activated
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var storageConfiguration = context.Settings.Get <GatewayDeduplicationConfiguration>();
storageConfiguration.Setup(context.Settings);
var transportDefinition = context.Settings.Get <TransportDefinition>();
ConfigureTransaction(context);
var channelManager = CreateChannelManager(context.Settings);
RegisterChannels(context, channelManager, out var channelSenderFactory, out var channelReceiverFactory);
var logicalAddress = new QueueAddress(context.Settings.EndpointQueueName(), null, null, "gateway");
var gatewayInputAddress = transportDefinition.ToTransportAddress(logicalAddress);
var retryPolicy = context.Settings.Get <Func <IncomingMessage, Exception, int, TimeSpan> >("Gateway.Retries.RetryPolicy");
var sender = new GatewayMessageSender(
gatewayInputAddress,
channelManager,
new MessageNotifier(),
context.Settings.LocalAddress(),
GetConfigurationBasedSiteRouter(context));
context.AddSatelliteReceiver("Gateway", gatewayInputAddress, PushRuntimeSettings.Default,
(config, errorContext) => GatewayRecoverabilityPolicy.Invoke(errorContext, retryPolicy, config),
(builder, messageContext, cancellationToken) => sender.SendToDestination(messageContext, builder.GetRequiredService <IMessageDispatcher>(), CreateForwarder(channelSenderFactory, builder.GetServices <IDataBus>()?.FirstOrDefault()), cancellationToken));
var configuredSitesKeys = GatewaySettings.GetConfiguredSites(context.Settings)
.Select(s => s.Key)
.ToList();
context.Pipeline.Register("RouteToGateway", new RouteToGatewayBehavior(gatewayInputAddress, configuredSitesKeys), "Reroutes gateway messages to the gateway");
context.Pipeline.Register("GatewayIncomingBehavior", new GatewayIncomingBehavior(), "Extracts gateway related information from the incoming message");
context.Pipeline.Register("GatewayOutgoingBehavior", new GatewayOutgoingBehavior(), "Puts gateway related information on the headers of outgoing messages");
context.RegisterStartupTask(b => new GatewayReceiverStartupTask(
channelManager,
channelReceiverFactory,
GetEndpointRouter(context),
b.GetRequiredService <IMessageDispatcher>(),
storageConfiguration.CreateStorage(b),
b.GetServices <IDataBus>()?.FirstOrDefault(),
gatewayInputAddress,
transportDefinition.TransportTransactionMode));
}
/// <summary>
/// See <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
if (!context.Settings.TryGet(out SubscribeSettings settings))
{
settings = new SubscribeSettings();
}
var conventions = context.Settings.Get <Conventions>();
context.RegisterStartupTask(b =>
{
var handlerRegistry = b.GetService <MessageHandlerRegistry>();
var messageTypesHandled = GetMessageTypesHandledByThisEndpoint(handlerRegistry, conventions, settings);
return(new ApplySubscriptions(messageTypesHandled, settings.ExcludedTypes));
});
}
protected internal override void Setup(FeatureConfigurationContext context)
{
var filePath = GetRootedPath(context.Settings.Get<string>(FilePathSettingsKey));
if (!File.Exists(filePath))
{
throw new Exception($"The specified instance mapping file '{filePath}' does not exist.");
}
var checkInterval = context.Settings.Get<TimeSpan>(CheckIntervalSettingsKey);
var endpointInstances = context.Settings.Get<EndpointInstances>();
var instanceMappingTable = new InstanceMappingFileMonitor(filePath, checkInterval, new AsyncTimer(), new InstanceMappingFileAccess(), endpointInstances);
instanceMappingTable.ReloadData();
context.RegisterStartupTask(instanceMappingTable);
}
static void SetupTimeoutPoller(FeatureConfigurationContext context, string dispatcherAddress)
{
context.Container.ConfigureComponent(b =>
{
var waitTime = context.Settings.Get <TimeSpan>("TimeToWaitBeforeTriggeringCriticalErrorForTimeoutPersisterReceiver");
var criticalError = b.GetRequiredService <CriticalError>();
var circuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker("TimeoutStorageConnectivity",
waitTime,
ex => criticalError.Raise("Repeated failures when fetching timeouts from storage, endpoint will be terminated.", ex));
return(new ExpiredTimeoutsPoller(b.GetRequiredService <IQueryTimeouts>(), b.GetRequiredService <IDispatchMessages>(), dispatcherAddress, circuitBreaker, () => DateTime.UtcNow));
}, DependencyLifecycle.SingleInstance);
context.RegisterStartupTask(b => new TimeoutPollerRunner(b.GetRequiredService <ExpiredTimeoutsPoller>()));
}
static void SetupTimeoutPoller(FeatureConfigurationContext context, string dispatcherAddress)
{
context.Container.ConfigureComponent(b =>
{
var waitTime = context.Settings.Get<TimeSpan>("TimeToWaitBeforeTriggeringCriticalErrorForTimeoutPersisterReceiver");
var criticalError = b.Build<CriticalError>();
var circuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker("TimeoutStorageConnectivity",
waitTime,
ex => criticalError.Raise("Repeated failures when fetching timeouts from storage, endpoint will be terminated.", ex));
return new ExpiredTimeoutsPoller(b.Build<IQueryTimeouts>(), b.Build<IDispatchMessages>(), dispatcherAddress, circuitBreaker, () => DateTime.UtcNow);
}, DependencyLifecycle.SingleInstance);
context.RegisterStartupTask(b => new TimeoutPollerRunner(b.Build<ExpiredTimeoutsPoller>()));
}
protected internal override void Setup(FeatureConfigurationContext context)
{
var filePath = GetRootedPath(context.Settings.Get <string>(FilePathSettingsKey));
if (!File.Exists(filePath))
{
throw new Exception($"The specified instance mapping file '{filePath}' does not exist.");
}
var checkInterval = context.Settings.Get <TimeSpan>(CheckIntervalSettingsKey);
var endpointInstances = context.Settings.Get <EndpointInstances>();
var instanceMappingTable = new InstanceMappingFileMonitor(filePath, checkInterval, new AsyncTimer(), new InstanceMappingFileAccess(), endpointInstances);
instanceMappingTable.ReloadData();
context.RegisterStartupTask(instanceMappingTable);
}
/// <summary>
/// See <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
if (!context.Settings.TryGet(out SubscribeSettings settings))
{
settings = new SubscribeSettings();
}
var conventions = context.Settings.Get <Conventions>();
var transportInfrastructure = context.Settings.Get <TransportInfrastructure>();
var requireExplicitRouting = transportInfrastructure.OutboundRoutingPolicy.Publishes == OutboundRoutingType.Unicast;
var publishers = context.Routing.Publishers;
context.RegisterStartupTask(b =>
{
var handlerRegistry = b.Build <MessageHandlerRegistry>();
var messageTypesHandled = GetMessageTypesHandledByThisEndpoint(handlerRegistry, conventions, settings);
var typesToSubscribe = messageTypesHandled.Where(eventType => !requireExplicitRouting || publishers.GetPublisherFor(eventType).Any()).ToList();
return(new ApplySubscriptions(typesToSubscribe));
});
}
/// <summary>
/// Called when the features is activated
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
if (context.Settings.TryGet("ResultingSupportedStorages", out List <Type> supportedStorages))
{
if (!supportedStorages.Contains(typeof(StorageType.GatewayDeduplication)))
{
throw new Exception("The selected persistence doesn't have support for gateway deduplication storage. Please configure one that supports gateway deduplication storage.");
}
}
else
{
throw new Exception("No persistence configured, please configure one that supports gateway deduplication storage.");
}
ConfigureTransaction(context);
var channelManager = CreateChannelManager(context.Settings);
RegisterChannels(context, channelManager, out var channelSenderFactory, out var channelReceiverFactory);
var gatewayInputAddress = context.Settings.GetTransportAddress(context.Settings.LogicalAddress().CreateQualifiedAddress("gateway"));
var retryPolicy = context.Settings.Get <Func <IncomingMessage, Exception, int, TimeSpan> >("Gateway.Retries.RetryPolicy");
var sender = new GatewayMessageSender(
gatewayInputAddress,
channelManager,
new MessageNotifier(),
context.Settings.LocalAddress(),
GetConfigurationBasedSiteRouter(context));
context.AddSatelliteReceiver("Gateway", gatewayInputAddress, PushRuntimeSettings.Default,
(config, errorContext) => GatewayRecoverabilityPolicy.Invoke(errorContext, retryPolicy, config),
(builder, messageContext) => sender.SendToDestination(messageContext, builder.Build <IDispatchMessages>(), CreateForwarder(channelSenderFactory, builder.BuildAll <IDataBus>()?.FirstOrDefault())));
context.Pipeline.Register("RouteToGateway", new RouteToGatewayBehavior(gatewayInputAddress), "Reroutes gateway messages to the gateway");
context.Pipeline.Register("GatewayIncomingBehavior", new GatewayIncomingBehavior(), "Extracts gateway related information from the incoming message");
context.Pipeline.Register("GatewayOutgoingBehavior", new GatewayOutgoingBehavior(), "Puts gateway related information on the headers of outgoing messages");
context.RegisterStartupTask(b => new GatewayReceiverStartupTask(channelManager, channelReceiverFactory, GetEndpointRouter(context), b.Build <IDispatchMessages>(), b.Build <IDeduplicateMessages>(), b.BuildAll <IDataBus>()?.FirstOrDefault(), gatewayInputAddress));
}
/// <summary>
/// See <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
SubscribeSettings settings;
if (!context.Settings.TryGet(out settings))
{
settings = new SubscribeSettings();
}
var conventions = context.Settings.Get<Conventions>();
var transportInfrastructure = context.Settings.Get<TransportInfrastructure>();
var requireExplicitRouting = transportInfrastructure.OutboundRoutingPolicy.Publishes == OutboundRoutingType.Unicast;
var publishers = context.Settings.Get<Publishers>();
context.RegisterStartupTask(b =>
{
var handlerRegistry = b.Build<MessageHandlerRegistry>();
var messageTypesHandled = GetMessageTypesHandledByThisEndpoint(handlerRegistry, conventions, settings);
var typesToSubscribe = messageTypesHandled.Where(eventType => !requireExplicitRouting || publishers.GetPublisherFor(eventType).Any());
return new ApplySubscriptions(typesToSubscribe);
});
}
/// <summary>
/// <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
var counterInstanceName = context.Settings.EndpointName();
var criticalTimeCounter = new CriticalTimeCounter(counterInstanceName);
var notifications = context.Settings.Get<NotificationSubscriptions>();
notifications.Subscribe<ReceivePipelineCompleted>(e =>
{
string timeSentString;
if (!e.ProcessedMessage.Headers.TryGetValue(Headers.TimeSent, out timeSentString))
{
return TaskEx.CompletedTask;
}
criticalTimeCounter.Update(DateTimeExtensions.ToUtcDateTime(timeSentString), e.StartedAt, e.CompletedAt);
return TaskEx.CompletedTask;
});
context.RegisterStartupTask(() => criticalTimeCounter);
}
/// <summary>
/// <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
var counterInstanceName = context.Settings.EndpointName();
var criticalTimeCounter = new CriticalTimeCounter(counterInstanceName);
var notifications = context.Settings.Get <NotificationSubscriptions>();
notifications.Subscribe <ReceivePipelineCompleted>(e =>
{
string timeSentString;
if (!e.ProcessedMessage.Headers.TryGetValue(Headers.TimeSent, out timeSentString))
{
return(TaskEx.CompletedTask);
}
criticalTimeCounter.Update(DateTimeExtensions.ToUtcDateTime(timeSentString), e.StartedAt, e.CompletedAt);
return(TaskEx.CompletedTask);
});
context.RegisterStartupTask(() => criticalTimeCounter);
}
/// <summary>
/// See <see cref="Feature.Setup" />.
/// </summary>
protected internal override void Setup(FeatureConfigurationContext context)
{
// The MessageDrivenSubscriptions feature needs to be activated when using the subscription migration mode as some persister packages check this feature before enabling the subscription storage.
if (SubscriptionMigrationMode.IsMigrationModeEnabled(context.Settings))
{
return;
}
var transportDefinition = context.Settings.Get <TransportDefinition>();
var conventions = context.Settings.Get <Conventions>();
var enforceBestPractices = context.Routing.EnforceBestPractices;
var distributionPolicy = context.Routing.DistributionPolicy;
var endpointInstances = context.Routing.EndpointInstances;
var publishers = context.Routing.Publishers;
var configuredPublishers = context.Settings.Get <ConfiguredPublishers>();
configuredPublishers.Apply(publishers, conventions, enforceBestPractices);
var publishingEnabled = context.Settings.Get <bool>(EnablePublishingSettingsKey);
if (publishingEnabled)
{
if (!PersistenceStartup.HasSupportFor <StorageType.Subscriptions>(context.Settings))
{
throw new Exception("The selected persistence doesn't have support for subscription storage. Select another persistence or disable the publish functionality using transportConfiguration.DisablePublishing()");
}
context.Pipeline.Register("UnicastPublishRouterConnector", b =>
{
var unicastPublishRouter = new UnicastPublishRouter(b.GetRequiredService <MessageMetadataRegistry>(), i => transportDefinition.ToTransportAddress(new QueueAddress(i.Endpoint, i.Discriminator, i.Properties, null)), b.GetRequiredService <ISubscriptionStorage>());
return(new UnicastPublishConnector(unicastPublishRouter, distributionPolicy));
}, "Determines how the published messages should be routed");
var authorizer = context.Settings.GetSubscriptionAuthorizer();
if (authorizer == null)
{
authorizer = _ => true;
}
context.Container.AddSingleton(authorizer);
context.Pipeline.Register(typeof(SubscriptionReceiverBehavior), "Check for subscription messages and execute the requested behavior to subscribe or unsubscribe.");
}
else
{
context.Pipeline.Register(typeof(DisabledPublishingTerminator), "Throws an exception when trying to publish with publishing disabled");
}
var canReceive = !context.Settings.GetOrDefault <bool>("Endpoint.SendOnly");
if (canReceive)
{
var subscriberAddress = context.Receiving.LocalAddress;
var subscriptionRouter = new SubscriptionRouter(publishers, endpointInstances, i => transportDefinition.ToTransportAddress(new QueueAddress(i.Endpoint, i.Discriminator, i.Properties, null)));
context.Pipeline.Register(b => new MessageDrivenSubscribeTerminator(subscriptionRouter, subscriberAddress, context.Settings.EndpointName(), b.GetRequiredService <IMessageDispatcher>()), "Sends subscription requests when message driven subscriptions is in use");
context.Pipeline.Register(b => new MessageDrivenUnsubscribeTerminator(subscriptionRouter, subscriberAddress, context.Settings.EndpointName(), b.GetRequiredService <IMessageDispatcher>()), "Sends requests to unsubscribe when message driven subscriptions is in use");
}
else
{
context.Pipeline.Register(new SendOnlySubscribeTerminator(), "Throws an exception when trying to subscribe from a send-only endpoint");
context.Pipeline.Register(new SendOnlyUnsubscribeTerminator(), "Throws an exception when trying to unsubscribe from a send-only endpoint");
}
// implementations of IInitializableSubscriptionStorage are optional and can be provided by persisters.
context.RegisterStartupTask(b => new InitializableSubscriptionStorage(b.GetService <IInitializableSubscriptionStorage>()));
}
protected internal override void Setup(FeatureConfigurationContext context)
{
context.RegisterStartupTask(() => new ValidatorTask(context.Settings));
}
protected override void Setup(FeatureConfigurationContext context)
{
Logger.WriteLine("Inside Feature.Setup");
context.RegisterStartupTask(new MyFeatureStartupTask());
}
