/// <summary>
/// Configures a custom path where host diagnostics is written.
/// </summary>
/// <param name="config">Configuration object to extend.</param>
/// <param name="path">The custom path to use.</param>
public static void SetDiagnosticsPath(this EndpointConfiguration config, string path)
{
Guard.AgainstNull(nameof(config), config);
Guard.AgainstNullAndEmpty(nameof(path), path);
PathChecker.ThrowForBadPath(path, "Diagnostics root path");
config.GetSettings().Get <HostingComponent.Settings>().DiagnosticsPath = path;
}
/// <summary>
/// Sets the frequency to run the deduplication data cleanup task.
/// </summary>
/// <param name="configuration">The configuration being extended</param>
/// <param name="frequencyToRunDeduplicationDataCleanup">The frequency to run the deduplication data cleanup task. By specifying <code>System.Threading.Timeout.InfiniteTimeSpan</code> (-1 milliseconds) the cleanup task will never run.</param>
/// <returns>The configuration</returns>
public static EndpointConfiguration SetFrequencyToRunDeduplicationDataCleanup(this EndpointConfiguration configuration, TimeSpan frequencyToRunDeduplicationDataCleanup)
{
if (frequencyToRunDeduplicationDataCleanup <= TimeSpan.Zero && frequencyToRunDeduplicationDataCleanup != System.Threading.Timeout.InfiniteTimeSpan)
{
throw new ArgumentOutOfRangeException(nameof(frequencyToRunDeduplicationDataCleanup), "Provide a non-negative TimeSpan to specify cleanup task execution frequency or specify System.Threading.Timeout.InfiniteTimeSpan to disable cleanup.");
}
configuration.GetSettings().Set("Outbox.FrequencyToRunDeduplicationDataCleanup", frequencyToRunDeduplicationDataCleanup);
return(configuration);
}
public FunctionsAwareEndpointNoTransport(string endpointName)
{
endpointConfiguration = new EndpointConfiguration(endpointName);
endpointConfiguration.GetSettings().Set("hack-do-not-use-the-pump", true);
transport = endpointConfiguration.UseTransport <NoopTransport>();
transport.ConnectionString("no-op");
Routing = transport.Routing();
}
/// <summary>
/// Use 256 bit AES encryption based on the Aes cipher.
/// </summary>
/// <param name="config">The <see cref="EndpointConfiguration" /> instance to apply the settings to.</param>
public static void AesEncryptionService(this EndpointConfiguration config)
{
Guard.AgainstNull(nameof(config), config);
RegisterEncryptionService(config, () =>
{
var section = config.GetSettings().GetConfigSection <EncryptionServiceConfig>();
return(ConvertConfigToAesService(section));
});
}
/// <summary>
/// Allows the user to control how the gateway behaves.
/// </summary>
/// <param name="config">The <see cref="EndpointConfiguration"/> instance to apply the settings to.</param>
/// <param name="storageConfiguration">the storage configuration for the gateway's deduplication mechanism</param>
public static GatewaySettings Gateway(this EndpointConfiguration config, GatewayDeduplicationConfiguration storageConfiguration)
{
Guard.AgainstNull(nameof(config), config);
Guard.AgainstNull(nameof(storageConfiguration), storageConfiguration);
config.EnableFeature <Features.Gateway>();
config.GetSettings().Set(storageConfiguration);
return(new GatewaySettings(config));
}
void SetSlaFromAttribute(EndpointConfiguration configuration, IConfigureThisEndpoint configureThisEndpoint)
{
var endpointConfigurationType = configureThisEndpoint
.GetType();
TimeSpan sla;
if (TryGetSlaFromEndpointConfigType(endpointConfigurationType, out sla))
{
configuration.GetSettings().Set("EndpointSLA", sla);
}
}
public FunctionsAwareServiceBusEndpoint(string endpointName)
{
endpointConfiguration = new EndpointConfiguration(endpointName);
endpointConfiguration.GetSettings().Set("hack-do-not-use-the-pump", true);
transport = endpointConfiguration.UseTransport <AzureServiceBusTransport>();
Routing = transport.Routing();
WarnAgainstMultipleHandlersForSameMessageType();
}
public static void OnEndpointStarted(this EndpointConfiguration configuration, Func <IMessageSession, Task> onEndpointStarted)
{
if (onEndpointStarted == null)
{
throw new ArgumentNullException(nameof(onEndpointStarted));
}
var settings = configuration.GetSettings();
settings.Set(NServiceBusExtensionsEndpointStartedSetting, onEndpointStarted);
configuration.EnableFeature <EndpointStartupCallback>();
}
/// <summary>
/// Sets the time to keep the deduplication data to the specified time span.
/// </summary>
/// <param name="configuration">The configuration being extended</param>
/// <param name="timeToKeepDeduplicationData">The time to keep the deduplication data.
/// The cleanup process removes entries older than the specified time to keep deduplication data, therefore the time span cannot be negative</param>
/// <returns>The configuration</returns>
public static EndpointConfiguration SetTimeToKeepDeduplicationData(this EndpointConfiguration configuration, TimeSpan timeToKeepDeduplicationData)
{
var now = DateTime.UtcNow;
if (now - timeToKeepDeduplicationData >= now)
{
throw new ArgumentOutOfRangeException(nameof(timeToKeepDeduplicationData), "Specify a non-negative TimeSpan. The cleanup process removes entries older than the specified time to keep deduplication data, therefore the time span cannot be negative.");
}
configuration.GetSettings().Set("Outbox.TimeToKeepDeduplicationData", timeToKeepDeduplicationData);
return(configuration);
}
/// <summary>
/// Configures additional deserializers to be considered when processing messages. Can be called multiple times.
/// </summary>
/// <typeparam name="T">The serializer definition eg <see cref="XmlSerializer" />.</typeparam>
/// <param name="config">The <see cref="EndpointConfiguration" /> instance to apply the settings to.</param>
/// <param name="serializationDefinition">An instance of serialization definition.</param>
public static SerializationExtensions <T> AddDeserializer <T>(this EndpointConfiguration config, T serializationDefinition) where T : SerializationDefinition
{
Guard.AgainstNull(nameof(config), config);
Guard.AgainstNull(nameof(serializationDefinition), serializationDefinition);
var additionalSerializers = config.GetSettings().GetAdditionalSerializers();
var settings = new SettingsHolder();
additionalSerializers.Add(Tuple.Create <SerializationDefinition, SettingsHolder>(serializationDefinition, settings));
return(CreateSerializationExtension <T>(settings));
}
/// <summary>
/// Enable Serilog Tracing for this endpoint.
/// </summary>
public static SerilogTracingSettings EnableSerilogTracing(this EndpointConfiguration configuration, ILogger logger)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(logger, nameof(logger));
configuration.Recoverability().AddUnrecoverableException <ConfigurationException>();
configuration.EnableFeature <TracingFeature>();
var settings = configuration.GetSettings();
var attachments = new SerilogTracingSettings(logger, configuration);
settings.Set(attachments);
return(attachments);
}
/// <summary>
/// Enable SQL attachments for this endpoint.
/// </summary>
public static AttachmentSettings EnableAttachments(
this EndpointConfiguration configuration,
Func <Task <SqlConnection> > connectionFactory,
GetTimeToKeep timeToKeep)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(timeToKeep, nameof(timeToKeep));
Guard.AgainstNull(connectionFactory, nameof(connectionFactory));
var settings = configuration.GetSettings();
var attachments = new AttachmentSettings(connectionFactory, timeToKeep);
return(SetAttachments(configuration, settings, attachments));
}
/// <summary>
/// Enable SQL attachments for this endpoint.
/// </summary>
public static AttachmentSettings EnableAttachments(
this EndpointConfiguration configuration,
string connection,
GetTimeToKeep timeToKeep)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(timeToKeep, nameof(timeToKeep));
Guard.AgainstNullOrEmpty(connection, nameof(connection));
var settings = configuration.GetSettings();
var attachments = new AttachmentSettings(() => OpenConnection(connection), timeToKeep);
return(SetAttachments(configuration, settings, attachments));
}
/// <summary>
/// Enables the Metrics feature.
/// </summary>
/// <param name="endpointConfiguration">The endpoint configuration to enable the metrics feature on.</param>
/// <returns>An object containing configuration options for the Metrics feature.</returns>
public static MetricsOptions EnableMetrics(this EndpointConfiguration endpointConfiguration)
{
Guard.AgainstNull(nameof(endpointConfiguration), endpointConfiguration);
var settings = endpointConfiguration.GetSettings();
var options = settings.GetOrCreate <MetricsOptions>();
settings.Set(typeof(MetricsFeature).FullName, FeatureState.Enabled);
endpointConfiguration.Recoverability().Immediate(c => c.OnMessageBeingRetried((m, ct) => options.Immediate(m, ct)));
endpointConfiguration.Recoverability().Delayed(c => c.OnMessageBeingRetried((m, ct) => options.Delayed(m, ct)));
return(options);
}
/// <summary>
/// Register a specific instance of an IWantToRunWhenEndpointStartsAndStops implementation
/// </summary>
public static void RunWhenEndpointStartsAndStops(this EndpointConfiguration configuration, IWantToRunWhenEndpointStartsAndStops startableAndStoppable)
{
var settings = configuration.GetSettings();
List <IWantToRunWhenEndpointStartsAndStops> instanceList;
if (!settings.TryGet(out instanceList))
{
instanceList = new List <IWantToRunWhenEndpointStartsAndStops>();
settings.Set <List <IWantToRunWhenEndpointStartsAndStops> >(instanceList);
}
instanceList.Add(startableAndStoppable);
}
/// <summary>
/// Enable SQL attachments for this endpoint.
/// </summary>
public static AttachmentSettings EnableAttachments(
this EndpointConfiguration configuration,
Func <Task <SqlConnection> > connectionFactory,
GetTimeToKeep timeToKeep)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(timeToKeep, nameof(timeToKeep));
Guard.AgainstNull(connectionFactory, nameof(connectionFactory));
var settings = configuration.GetSettings();
var attachments = new AttachmentSettings(connectionFactory, timeToKeep);
settings.Set <AttachmentSettings>(attachments);
configuration.EnableFeature <AttachmentFeature>();
configuration.DisableFeature <AttachmentsUsedWhenNotEnabledFeature>();
return(attachments);
}
/// <summary>
/// Instructs the transport to limits the allowed concurrency when processing messages.
/// </summary>
/// <param name="config">The <see cref="EndpointConfiguration" /> instance to apply the settings to.</param>
/// <param name="noActivityDuration"></param>
public static void RaiseCriticalWhenNoActivity(this EndpointConfiguration config, TimeSpan noActivityDuration)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (noActivityDuration == null)
{
throw new ArgumentNullException(nameof(noActivityDuration));
}
if (noActivityDuration.Ticks < 0)
{
throw new ArgumentOutOfRangeException(nameof(noActivityDuration), noActivityDuration, "Must be positive");
}
config.GetSettings().Set("NoActivityDuration", noActivityDuration);
}
public static EndpointConfiguration AddMessageTypeTransformation(this EndpointConfiguration config,
Type typeToTransform, Func <object, object> transform)
{
var settings = config.GetSettings();
if (!settings.HasExplicitValue(TransformMessageTypes.TransformMessageTypesSettingsKeys))
{
settings.Set(TransformMessageTypes.TransformMessageTypesSettingsKeys, new Dictionary <Type, Func <object, object> >());
}
var transforms = settings.Get(TransformMessageTypes.TransformMessageTypesSettingsKeys) as Dictionary <Type, Func <object, object> >;
transforms.Add(typeToTransform, transform);
return(config);
}
/// <summary>
/// Enable SQL attachments for this endpoint.
/// </summary>
public static AttachmentSettings EnableAttachments(
this EndpointConfiguration configuration,
string fileShare,
GetTimeToKeep timeToKeep)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(timeToKeep, nameof(timeToKeep));
Guard.AgainstNullOrEmpty(fileShare, nameof(fileShare));
var settings = configuration.GetSettings();
var attachments = new AttachmentSettings(fileShare, timeToKeep);
settings.Set(attachments);
configuration.EnableFeature <AttachmentFeature>();
configuration.DisableFeature <AttachmentsUsedWhenNotEnabledFeature>();
return(attachments);
}
/// <summary>
/// If you want full control over the limit and the duration then this overload allows to set any rates.
///
/// Max rate: 5 calls every second:
///
/// endpointConfiguration.ApplyRateLimiting(5);
///
/// </summary>
public static void ApplyRateLimiting(this EndpointConfiguration instance, int limitPerSecond)
{
if (limitPerSecond < 1)
{
throw new ArgumentOutOfRangeException(nameof(limitPerSecond), limitPerSecond, "Must be larger than 0");
}
var properties = new global::Properties
{
Duration = TimeSpan.FromSeconds(1),
Limit = limitPerSecond,
};
var settings = instance.GetSettings();
settings.Set <global::Properties>(properties);
instance.EnableFeature <RateLimiterFeature>();
}
/// <summary>
/// Enable SQL attachments for this endpoint.
/// </summary>
public static DedupeSettings EnableDedupe(
this EndpointConfiguration configuration,
Func <CancellationToken, Task <DbConnection> > connectionBuilder)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(connectionBuilder, nameof(connectionBuilder));
var recoverability = configuration.Recoverability();
recoverability.AddUnrecoverableException <NotSupportedException>();
var settings = configuration.GetSettings();
var dedupeSettings = new DedupeSettings(connectionBuilder);
settings.Set(dedupeSettings);
configuration.EnableFeature <DeduplicationFeature>();
return(dedupeSettings);
}
public static void TweakConfigurationBuilder(IConfigureThisEndpoint specifier, EndpointConfiguration config)
{
// ReSharper disable once SuspiciousTypeConversion.Global
if (specifier is AsA_Client)
{
config.PurgeOnStartup(true);
config.GetSettings().Set <TransportTransactionMode>(TransportTransactionMode.None);
config.Recoverability().Delayed(delayed => delayed.NumberOfRetries(0));
config.DisableFeature <TimeoutManager>();
}
Type transportDefinitionType;
if (TryGetTransportDefinitionType(specifier, out transportDefinitionType))
{
config.UseTransport(transportDefinitionType);
}
}
/// <summary>
/// If you want full control over the limit and the duration then this overload allows to set any rates.
///
/// Minute max rates: 100 calls every minute:
///
/// endpointConfiguration.ApplyRateLimiting(100, TimeSpan.FromMinutes(1));
///
/// </summary>
public static void ApplyRateLimiting(this EndpointConfiguration instance, int limit, TimeSpan duration)
{
if (limit < 1)
{
throw new ArgumentOutOfRangeException(nameof(limit), limit, "Must be larger than 0");
}
if (duration < MinimumDuration)
{
throw new ArgumentOutOfRangeException(nameof(duration), duration, $"Must be larger than {MinimumDuration.TotalMilliseconds}ms.");
}
var properties = new global::Properties
{
Duration = duration,
Limit = limit,
};
var settings = instance.GetSettings();
settings.Set <global::Properties>(properties);
instance.EnableFeature <RateLimiterFeature>();
}
/// <summary>
/// Limits the processing rate per second based on <param name="limitPerSecond"/>. It will calculate the smallest interval based on the specified concurrency.
///
/// If you do not want to use the smallest interval but want to allow for burst then set concurrency to the max burst size.
///
/// Smallest interval based on concurrency:
/// If you allow for 100 messages per second, with a concurrency of 4 then the logic will limit processing of 4 messages every 400 milliseconds.
///
/// endpointConfiguration.ApplyRateLimiting(limitPerSecond:10, concurrency:4);
///
/// Bursts:
/// If you allow for burst of 250 items as a rate of 10 messages per second then the logic will limit processing of 250 messages every 25 seconds.
///
/// endpointConfiguration.ApplyRateLimiting(limitPerSecond:10, concurrency:250);
/// </summary>
public static void ApplyRateLimiting(this EndpointConfiguration instance, int limitPerSecond, int burstSize)
{
if (limitPerSecond < 1)
{
throw new ArgumentOutOfRangeException(nameof(limitPerSecond), limitPerSecond, "Must be larger than 0");
}
var properties = new global::Properties
{
Duration = TimeSpan.FromSeconds(1.0 / limitPerSecond * burstSize),
Limit = burstSize,
};
var minimumBurstSize = limitPerSecond / 10D;
if (burstSize < minimumBurstSize)
{
throw new ArgumentOutOfRangeException(nameof(burstSize), burstSize, $"Must be larger than {Math.Ceiling(minimumBurstSize):N0} when {nameof(limitPerSecond)}={limitPerSecond}.");
}
var settings = instance.GetSettings();
settings.Set <global::Properties>(properties);
instance.EnableFeature <RateLimiterFeature>();
}
/// <summary>
/// Enable compression of message bodies
/// </summary>
public static void CompressMessageBody(
this EndpointConfiguration config,
CompressionLevel compressionLevel,
int thresholdSize
)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (thresholdSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(thresholdSize), thresholdSize, "Threshold size must be greater than 0.");
}
var properties = new Options
{
CompressionLevel = compressionLevel,
ThresholdSize = thresholdSize
};
var settings = config.GetSettings();
settings.Set <Options>(properties);
}
public static void RegisterPartitionsForThisEndpoint(this EndpointConfiguration endpointConfiguration,
string localPartitionKey, string[] allPartitionKeys)
{
endpointConfiguration.MakeInstanceUniquelyAddressable(localPartitionKey);
var settings = endpointConfiguration.GetSettings();
var endpointName = settings.EndpointName();
var distributionStrategy = new PartitionAwareDistributionStrategy(endpointName, _ => localPartitionKey,
DistributionStrategyScope.Send);
var distributionPolicy = settings.GetOrCreate <DistributionPolicy>();
distributionPolicy.SetDistributionStrategy(distributionStrategy);
var destinationEndpointInstances =
allPartitionKeys.Select(key => new EndpointInstance(endpointName, key)).ToList();
var endpointInstances = settings.GetOrCreate <EndpointInstances>();
endpointInstances.AddOrReplaceInstances(endpointName, destinationEndpointInstances);
endpointConfiguration.EnableFeature <HardcodeReplyToAddressToLogicalAddressFeature>();
}
internal GatewaySettings(EndpointConfiguration config)
{
settings = config.GetSettings();
}
/// <summary>
/// Defines the endpoint name in code thus overriding the previously assigned endpoint name.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="endpointName">The endpoint name to be used.</param>
public static void DefineEndpointName(this EndpointConfiguration configuration, string endpointName)
{
configuration.GetSettings().Set("NServiceBus.Routing.EndpointName", endpointName);
}
/// <summary>
/// Configuration settings for recoverability.
/// </summary>
/// <param name="configuration">The endpoint configuration.</param>
public static RecoverabilitySettings Recoverability(this EndpointConfiguration configuration)
{
Guard.AgainstNull(nameof(configuration), configuration);
return new RecoverabilitySettings(configuration.GetSettings());
}
/// <summary>
/// Configuration settings for recoverability.
/// </summary>
/// <param name="configuration">The endpoint configuration.</param>
public static RecoverabilitySettings Recoverability(this EndpointConfiguration configuration)
{
return(new RecoverabilitySettings(configuration.GetSettings()));
}
