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); }