| public static AgainstNegativeAndZero ( [ argumentName, System.TimeSpan value ) : void | ||
| argumentName | [ | |
| value | System.TimeSpan | |
| return | void | |
/// <summary>
/// Maximum message size allowed for sending.
/// <remarks>Default is 256KB.</remarks>
/// </summary>
public AzureServiceBusMessageSenderSettings MaximuMessageSizeInKilobytes(int sizeInKilobytes)
{
Guard.AgainstNegativeAndZero(nameof(sizeInKilobytes), sizeInKilobytes);
settings.Set(WellKnownConfigurationKeys.Connectivity.MessageSenders.MaximumMessageSizeInKilobytes, sizeInKilobytes);
return(this);
}
/// <summary>
/// Sets the amount of time to add to the time to wait before checking for a new message
/// </summary>
public static TransportExtensions <AzureStorageQueueTransport> PeekInterval(this TransportExtensions <AzureStorageQueueTransport> config, TimeSpan value)
{
Guard.AgainstNull(nameof(config), config);
Guard.AgainstNegativeAndZero(nameof(value), value);
config.GetSettings().Set(WellKnownConfigurationKeys.ReceiverPeekInterval, value);
return(config);
}
/// <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. The time span cannot be negative or sero.</param>
public static void RunDeduplicationDataCleanupEvery(this OutboxSettings configuration, TimeSpan frequencyToRunDeduplicationDataCleanup)
{
Guard.AgainstNull(nameof(configuration), configuration);
Guard.AgainstNegativeAndZero(nameof(frequencyToRunDeduplicationDataCleanup), frequencyToRunDeduplicationDataCleanup);
configuration.GetSettings().Set(SqlOutboxFeature.FrequencyToRunDeduplicationDataCleanup, frequencyToRunDeduplicationDataCleanup);
}
/// <summary>
/// Allows to change the transaction isolation level and timeout for the `TransactionScope` used to receive messages.
/// </summary>
/// <remarks>
/// If not specified the default transaction timeout of the machine will be used and the isolation level will be set to
/// `ReadCommited`.
/// </remarks>
public static TransportExtensions <MsmqTransport> TransactionScopeOptions(this TransportExtensions <MsmqTransport> transportExtensions, TimeSpan?timeout = null, IsolationLevel?isolationLevel = null)
{
Guard.AgainstNull(nameof(transportExtensions), transportExtensions);
Guard.AgainstNegativeAndZero(nameof(timeout), timeout);
transportExtensions.Settings.Set <MsmqScopeOptions>(new MsmqScopeOptions(timeout, isolationLevel));
return(transportExtensions);
}
/// <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>
public static void SetTimeToKeepDeduplicationData(this OutboxSettings configuration, TimeSpan timeToKeepDeduplicationData)
{
Guard.AgainstNull(nameof(configuration), configuration);
Guard.AgainstNegativeAndZero(nameof(timeToKeepDeduplicationData), timeToKeepDeduplicationData);
configuration.GetSettings().Set(OutboxPersistenceFeature.TimeToKeepDeduplicationEntries, timeToKeepDeduplicationData);
}
public static void EnableSLAPerformanceCounter(this EndpointConfiguration config, TimeSpan sla)
{
Guard.AgainstNull(nameof(config), config);
Guard.AgainstNegativeAndZero(nameof(sla), sla);
config.Settings.Set(SLAMonitoring.EndpointSLAKey, sla);
EnableSLAPerformanceCounter(config);
}
/// <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="maxConcurrency">The max concurrency allowed.</param>
public static void LimitMessageProcessingConcurrencyTo(this EndpointConfiguration config, int maxConcurrency)
{
Guard.AgainstNull(nameof(config), config);
Guard.AgainstNegativeAndZero(nameof(maxConcurrency), maxConcurrency);
config.Settings.Get <ReceiveComponent.Settings>().PushRuntimeSettings = new PushRuntimeSettings(maxConcurrency);
}
/// <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. The time span cannot be negative or zero.</param>
public static void KeepDeduplicationDataFor(this OutboxSettings configuration, TimeSpan timeToKeepDeduplicationData)
{
Guard.AgainstNull(nameof(configuration), configuration);
Guard.AgainstNegativeAndZero(nameof(timeToKeepDeduplicationData), timeToKeepDeduplicationData);
configuration.GetSettings().Set(SqlOutboxFeature.TimeToKeepDeduplicationData, timeToKeepDeduplicationData);
}
public static TransportExtensions <RabbitMQTransport> SetNetworkRecoveryInterval(this TransportExtensions <RabbitMQTransport> transportExtensions, TimeSpan networkRecoveryInterval)
{
Guard.AgainstNull(nameof(transportExtensions), transportExtensions);
Guard.AgainstNegativeAndZero(nameof(networkRecoveryInterval), networkRecoveryInterval);
transportExtensions.Transport.NetworkRecoveryInterval = networkRecoveryInterval;
return(transportExtensions);
}
public static TransportExtensions <RabbitMQTransport> PrefetchMultiplier(this TransportExtensions <RabbitMQTransport> transportExtensions, int prefetchMultiplier)
{
Guard.AgainstNull(nameof(transportExtensions), transportExtensions);
Guard.AgainstNegativeAndZero(nameof(prefetchMultiplier), prefetchMultiplier);
transportExtensions.Transport.PrefetchCountCalculation = concurrency => prefetchMultiplier * concurrency;
return(transportExtensions);
}
/// <summary>
/// Overrides the default time to wait before triggering a circuit breaker that initiates the endpoint shutdown procedure when the message pump cannot successfully receieve a message.
/// </summary>
/// <param name="transportExtensions"></param>
/// <param name="timeToWait">The time to wait before triggering the circuit breaker.</param>
public static TransportExtensions <AzureServiceBusTransport> TimeToWaitBeforeTriggeringCircuitBreaker(this TransportExtensions <AzureServiceBusTransport> transportExtensions, TimeSpan timeToWait)
{
Guard.AgainstNegativeAndZero(nameof(timeToWait), timeToWait);
transportExtensions.GetSettings().Set(SettingsKeys.TimeToWaitBeforeTriggeringCircuitBreaker, timeToWait);
return(transportExtensions);
}
/// <summary>
/// Overrides the default maximum size used when creating queues and topics.
/// </summary>
/// <param name="transportExtensions"></param>
/// <param name="maximumSizeInGB">The maximum size to use, in gigabytes.</param>
public static TransportExtensions <AzureServiceBusTransport> EntityMaximumSize(this TransportExtensions <AzureServiceBusTransport> transportExtensions, int maximumSizeInGB)
{
Guard.AgainstNegativeAndZero(nameof(maximumSizeInGB), maximumSizeInGB);
transportExtensions.GetSettings().Set(SettingsKeys.MaximumSizeInGB, maximumSizeInGB);
return(transportExtensions);
}
public static TransportExtensions <RabbitMQTransport> TimeToWaitBeforeTriggeringCircuitBreaker(this TransportExtensions <RabbitMQTransport> transportExtensions, TimeSpan waitTime)
{
Guard.AgainstNull(nameof(transportExtensions), transportExtensions);
Guard.AgainstNegativeAndZero(nameof(waitTime), waitTime);
transportExtensions.Transport.TimeToWaitBeforeTriggeringCircuitBreaker = waitTime;
return(transportExtensions);
}
/// <summary>
/// Overrides the default prefetch count calculation with the specified value.
/// </summary>
/// <param name="transportExtensions"></param>
/// <param name="prefetchCount">The prefetch count to use.</param>
public static TransportExtensions <AzureServiceBusTransport> PrefetchCount(this TransportExtensions <AzureServiceBusTransport> transportExtensions, int prefetchCount)
{
Guard.AgainstNegativeAndZero(nameof(prefetchCount), prefetchCount);
transportExtensions.GetSettings().Set(SettingsKeys.PrefetchCount, prefetchCount);
return(transportExtensions);
}
public static TransportExtensions <RabbitMQTransport> SetHeartbeatInterval(this TransportExtensions <RabbitMQTransport> transportExtensions, TimeSpan heartbeatInterval)
{
Guard.AgainstNull(nameof(transportExtensions), transportExtensions);
Guard.AgainstNegativeAndZero(nameof(heartbeatInterval), heartbeatInterval);
transportExtensions.Transport.HeartbeatInterval = heartbeatInterval;
return(transportExtensions);
}
/// <summary>
/// Overrides the default time to wait before triggering a circuit breaker that initiates the endpoint shutdown procedure
/// in case there are numerous errors
/// while trying to receive messages.
/// </summary>
/// <param name="transportExtensions">The <see cref="TransportExtensions{T}" /> to extend.</param>
/// <param name="waitTime">Time to wait before triggering the circuit breaker.</param>
public static TransportExtensions <SqlServerTransport> TimeToWaitBeforeTriggeringCircuitBreaker(this TransportExtensions <SqlServerTransport> transportExtensions, TimeSpan waitTime)
{
Guard.AgainstNull(nameof(transportExtensions), transportExtensions);
Guard.AgainstNegativeAndZero(nameof(waitTime), waitTime);
transportExtensions.GetSettings().Set(SettingsKeys.TimeToWaitBeforeTriggering, waitTime);
return(transportExtensions);
}
/// <summary>
/// Specifies the multiplier to apply to the maximum concurrency value to calculate the prefetch count.
/// </summary>
/// <param name="transportExtensions">The transport configuration object</param>
/// <param name="prefetchMultiplier">The multiplier value to use in the prefetch calculation.</param>
public static TransportExtensions <RabbitMQTransport> PrefetchMultiplier(this TransportExtensions <RabbitMQTransport> transportExtensions, int prefetchMultiplier)
{
Guard.AgainstNull(nameof(transportExtensions), transportExtensions);
Guard.AgainstNegativeAndZero(nameof(prefetchMultiplier), prefetchMultiplier);
transportExtensions.GetSettings().Set(SettingsKeys.PrefetchMultiplier, prefetchMultiplier);
return(transportExtensions);
}
/// <summary>
/// Configures the amount of time to keep outbox deduplication data.
/// </summary>
public static PersistenceExtensions <MongoPersistence> TimeToKeepOutboxDeduplicationData(this PersistenceExtensions <MongoPersistence> persistenceExtensions, TimeSpan timeToKeepOutboxDeduplicationData)
{
Guard.AgainstNull(nameof(persistenceExtensions), persistenceExtensions);
Guard.AgainstNegativeAndZero(nameof(timeToKeepOutboxDeduplicationData), timeToKeepOutboxDeduplicationData);
var seconds = Math.Ceiling(timeToKeepOutboxDeduplicationData.TotalSeconds);
persistenceExtensions.GetSettings().Set(SettingsKeys.TimeToKeepOutboxDeduplicationData, TimeSpan.FromSeconds(seconds));
return(persistenceExtensions);
}
/// <summary>
/// Sets the time to be received.
/// </summary>
/// <param name="timeSpan">A timeSpan that can be interpreted by <see cref="TimeSpan.Parse(string)" />.</param>
public TimeToBeReceivedAttribute(string timeSpan)
{
Guard.AgainstNullAndEmpty(nameof(timeSpan), timeSpan);
if (!TimeSpan.TryParse(timeSpan, out var parsed))
{
var error = $"Could not parse '{timeSpan}' as a timespan.";
throw new ArgumentException(error);
}
Guard.AgainstNegativeAndZero(nameof(timeSpan), parsed);
TimeToBeReceived = parsed;
}
/// <summary>
/// Allows to change the transaction isolation level and timeout for the `TransactionScope` used to receive messages.
/// </summary>
/// <remarks>
/// If not specified the default transaction timeout of the machine will be used and the isolation level will be set to
/// <see cref="IsolationLevel.ReadCommitted"/>.
/// </remarks>
/// <param name="timeout">Transaction timeout duration.</param>
/// <param name="isolationLevel">Transaction isolation level.</param>
public void ConfigureTransactionScope(TimeSpan?timeout = null, IsolationLevel?isolationLevel = null)
{
Guard.AgainstNegativeAndZero(nameof(timeout), timeout);
if (isolationLevel == IsolationLevel.Snapshot)
{
throw new ArgumentException("Isolation level `Snapshot` is not supported by the transport. Consider not sharing the transaction between transport and persistence if persistence should use `IsolationLevel.Snapshot` by using `TransportTransactionMode.SendsAtomicWithReceive` or lower.", nameof(isolationLevel));
}
TransactionScopeOptions = new MsmqScopeOptions(timeout, isolationLevel);
}
/// <summary>
/// Schedules a task to be executed repeatedly in a given interval.
/// </summary>
/// <param name="session">The session which allows you to perform message operation.</param>
/// <param name="timeSpan">The interval to repeatedly execute the <paramref name="task" />.</param>
/// <param name="task">The async function to execute.</param>
/// <param name="name">The name to used for logging the task being executed.</param>
public static Task ScheduleEvery(this IMessageSession session, TimeSpan timeSpan, string name, Func <IPipelineContext, Task> task)
{
Guard.AgainstNull(nameof(task), task);
Guard.AgainstNullAndEmpty(nameof(name), name);
Guard.AgainstNegativeAndZero(nameof(timeSpan), timeSpan);
return(Schedule(session, new TaskDefinition
{
Every = timeSpan,
Name = name,
Task = task
}));
}
/// <summary>
/// Schedules a task to be executed repeatedly in a given interval.
/// </summary>
/// <param name="session">The session which allows you to perform message operation.</param>
/// <param name="timeSpan">The interval to repeatedly execute the <paramref name="task" />.</param>
/// <param name="task">The async function to execute.</param>
public static Task ScheduleEvery(this IMessageSession session, TimeSpan timeSpan, Func <IPipelineContext, Task> task)
{
Guard.AgainstNull(nameof(task), task);
Guard.AgainstNegativeAndZero(nameof(timeSpan), timeSpan);
var declaringType = task.Method.DeclaringType;
while (declaringType.DeclaringType != null &&
declaringType.CustomAttributes.Any(a => a.AttributeType.Name == "CompilerGeneratedAttribute"))
{
declaringType = declaringType.DeclaringType;
}
return(ScheduleEvery(session, timeSpan, declaringType.Name, task));
}
/// <summary>
/// Adds a receive channel that the gateway should listen to.
/// </summary>
/// <param name="address">The channel address.</param>
/// <param name="type">The channel type. Default is `http`.</param>
/// <param name="maxConcurrency">Maximum number of receive connections. Default is `1`.</param>
/// <param name="isDefault">True if this should be the default channel for send operations. Default is `false`.</param>
public void AddReceiveChannel(string address, string type = "http", int maxConcurrency = 1, bool isDefault = false)
{
Guard.AgainstNullAndEmpty(nameof(address), address);
Guard.AgainstNullAndEmpty(nameof(type), type);
Guard.AgainstNegativeAndZero(nameof(maxConcurrency), maxConcurrency);
var channels = settings.GetOrCreate <List <ReceiveChannel> >();
channels.Add(new ReceiveChannel
{
Address = address,
MaxConcurrency = maxConcurrency,
Type = type,
Default = isDefault
});
}
/// <summary>
/// Adds a receive channel that the gateway should listen to.
/// </summary>
/// <param name="address">The channel address.</param>
/// <param name="maxConcurrency">Maximum number of receive connections. Default is `1`.</param>
/// <param name="type">The channel type. Default is `http`.</param>
/// <param name="isDefault">True if this should be the default channel for send operations. Default is `false`.</param>
public void AddReceiveChannel(string address, string type = "http", int maxConcurrency = 1, bool isDefault = false)
{
Guard.AgainstNullAndEmpty(nameof(address), address);
Guard.AgainstNullAndEmpty(nameof(type), type);
Guard.AgainstNegativeAndZero(nameof(maxConcurrency), maxConcurrency);
var channel = new ReceiveChannel
{
Address = address,
MaxConcurrency = maxConcurrency,
Type = type,
Default = isDefault
};
if (settings.TryGet(out List <ReceiveChannel> channels))
{
channels.Add(channel);
}
settings.Set <List <ReceiveChannel> >(new List <ReceiveChannel>
{
channel
});
}
/// <summary>
/// Configures the transaction timeout to use when transmitting messages to remote sites. By default, the transaction timeout of the underlying transport is used.
/// </summary>
/// <param name="timeout">The new timeout value.</param>
public void TransactionTimeout(TimeSpan timeout)
{
Guard.AgainstNegativeAndZero(nameof(timeout), timeout);
settings.Set("Gateway.TransactionTimeout", timeout);
}
public static TransportExtensions <AzureServiceBusTransport> PrefetchMultiplier(this TransportExtensions <AzureServiceBusTransport> transportExtensions, int prefetchMultiplier)
{
Guard.AgainstNegativeAndZero(nameof(prefetchMultiplier), prefetchMultiplier);
transportExtensions.Transport.PrefetchMultiplier = prefetchMultiplier;
return(transportExtensions);
}
public static TransportExtensions <AzureServiceBusTransport> EntityMaximumSize(this TransportExtensions <AzureServiceBusTransport> transportExtensions, int maximumSizeInGB)
{
Guard.AgainstNegativeAndZero(nameof(maximumSizeInGB), maximumSizeInGB);
transportExtensions.Transport.EntityMaximumSize = maximumSizeInGB;
return(transportExtensions);
}
public static void GatewayDeduplicationCacheSize(this PersistenceExtensions <InMemoryPersistence> persistenceExtensions, int maxSize)
{
Guard.AgainstNull(nameof(persistenceExtensions), persistenceExtensions);
Guard.AgainstNegativeAndZero(nameof(maxSize), maxSize);
persistenceExtensions.Settings.Set(InMemoryGatewayPersistence.MaxSizeKey, maxSize);
}
/// <summary>
/// Overrides the TTRQ timespan. The default value if not set is Message.InfiniteTimeout
/// </summary>
/// <param name="config"></param>
/// <param name="timeToReachQueue">Timespan for the TTRQ</param>
public static void TimeToReachQueue(this TransportExtensions<MsmqTransport> config, TimeSpan timeToReachQueue)
{
Guard.AgainstNull(nameof(config), config);
Guard.AgainstNegativeAndZero(nameof(timeToReachQueue), timeToReachQueue);
config.GetSettings().Set("TimeToReachQueue", timeToReachQueue);
}
/// <summary>
/// Sets the time to live for outbox deduplication records
/// </summary>
public static void TimeToKeepOutboxDeduplicationData(this OutboxSettings outboxSettings, TimeSpan timeToKeepOutboxDeduplicationData)
{
Guard.AgainstNegativeAndZero(nameof(timeToKeepOutboxDeduplicationData), timeToKeepOutboxDeduplicationData);
outboxSettings.GetSettings().Set(SettingsKeys.OutboxTimeToLiveInSeconds, (int)timeToKeepOutboxDeduplicationData.TotalSeconds);
}
