/// <summary>
/// Creates the worker factory
/// </summary>
public ThreadPoolWorkerFactory(ITransport transport, IRebusLoggerFactory rebusLoggerFactory,
IPipelineInvoker pipelineInvoker, Options options, Func <RebusBus> busGetter,
BusLifetimeEvents busLifetimeEvents, IBackoffStrategy backoffStrategy, CancellationToken busDisposalCancellationToken)
{
if (busLifetimeEvents == null)
{
throw new ArgumentNullException(nameof(busLifetimeEvents));
}
_transport = transport ?? throw new ArgumentNullException(nameof(transport));
_rebusLoggerFactory = rebusLoggerFactory ?? throw new ArgumentNullException(nameof(rebusLoggerFactory));
_pipelineInvoker = pipelineInvoker ?? throw new ArgumentNullException(nameof(pipelineInvoker));
_options = options ?? throw new ArgumentNullException(nameof(options));
_busGetter = busGetter ?? throw new ArgumentNullException(nameof(busGetter));
_backoffStrategy = backoffStrategy ?? throw new ArgumentNullException(nameof(backoffStrategy));
_busDisposalCancellationToken = busDisposalCancellationToken;
_parallelOperationsManager = new ParallelOperationsManager(options.MaxParallelism);
_log = _rebusLoggerFactory.GetLogger <ThreadPoolWorkerFactory>();
if (_options.MaxParallelism < 1)
{
throw new ArgumentException($"Max parallelism is {_options.MaxParallelism} which is an invalid value");
}
if (options.WorkerShutdownTimeout < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException($"Cannot use '{options.WorkerShutdownTimeout}' as worker shutdown timeout as it");
}
busLifetimeEvents.WorkersStopped += WaitForContinuationsToFinish;
}
public RabbitMQMessageSource(IOptions <RabbitMQMessageSourceOptions> options, IBackoffStrategy backoffStrategy, ILogger <RabbitMQMessageSource> logger)
{
this.options = options.Value;
this.bus = RabbitHutch.CreateBus(this.options.ConnectionString, x => x.Register <IScheduler, DelayedExchangeScheduler>());
this.backoffStrategy = backoffStrategy;
this.logger = logger;
}
public DefaultRequestExecutor(
IHttpClient httpClient,
IClientApiKey apiKey,
AuthenticationScheme authenticationScheme,
ILogger logger,
IBackoffStrategy defaultBackoffStrategy,
IBackoffStrategy throttlingBackoffStrategy)
{
if (!apiKey.IsValid())
{
throw new ApplicationException("API Key is invalid.");
}
this.httpClient = httpClient;
this.syncHttpClient = httpClient as ISynchronousHttpClient;
this.asyncHttpClient = httpClient as IAsynchronousHttpClient;
this.apiKey = apiKey;
this.authenticationScheme = authenticationScheme;
IRequestAuthenticatorFactory requestAuthenticatorFactory = new DefaultRequestAuthenticatorFactory();
this.requestAuthenticator = requestAuthenticatorFactory.Create(authenticationScheme);
this.logger = logger;
this.defaultBackoffStrategy = defaultBackoffStrategy;
this.throttlingBackoffStrategy = throttlingBackoffStrategy;
}
/// <summary>
/// Constructs the worker factory
/// </summary>
public ThreadWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, int maxParallelism, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory)
{
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (pipeline == null)
{
throw new ArgumentNullException(nameof(pipeline));
}
if (pipelineInvoker == null)
{
throw new ArgumentNullException(nameof(pipelineInvoker));
}
if (backoffStrategy == null)
{
throw new ArgumentNullException(nameof(backoffStrategy));
}
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (maxParallelism <= 0)
{
throw new ArgumentOutOfRangeException($"Cannot use value '{maxParallelism}' as max parallelism!");
}
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_backoffStrategy = backoffStrategy;
_rebusLoggerFactory = rebusLoggerFactory;
_parallelOperationsManager = new ParallelOperationsManager(maxParallelism);
}
public DefaultRequestExecutor(
IHttpClient httpClient,
IClientApiKey apiKey,
AuthenticationScheme authenticationScheme,
ILogger logger,
IBackoffStrategy defaultBackoffStrategy,
IBackoffStrategy throttlingBackoffStrategy)
{
if (!apiKey.IsValid())
{
throw new ApplicationException("API Key is invalid.");
}
this.httpClient = httpClient;
this.syncHttpClient = httpClient as ISynchronousHttpClient;
this.asyncHttpClient = httpClient as IAsynchronousHttpClient;
this.apiKey = apiKey;
this.authenticationScheme = authenticationScheme;
IRequestAuthenticatorFactory requestAuthenticatorFactory = new DefaultRequestAuthenticatorFactory();
this.requestAuthenticator = requestAuthenticatorFactory.Create(authenticationScheme);
this.logger = logger;
this.defaultBackoffStrategy = defaultBackoffStrategy;
this.throttlingBackoffStrategy = throttlingBackoffStrategy;
}
public ExternalTaskTopicManager(string workerId, ExternalTaskService externalTaskService,
ExternalTaskTopicManagerInfo taskManagerInfo, IBackoffStrategy backoffStrategy, IPolicyManager policyManager)
{
this.workerId = workerId;
this.externalTaskService = externalTaskService;
this.topicManagerInfo = taskManagerInfo;
this.backoffStrategy = backoffStrategy;
this.policyManager = policyManager;
}
public OutboxMessagesProcessor(int topMessagesToRetrieve, ITransport transport, IOutboxStorage outboxStorage, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory, CancellationToken busDisposalCancellationToken)
{
_topMessagesToRetrieve = topMessagesToRetrieve;
_transport = transport;
_outboxStorage = outboxStorage;
_backoffStrategy = backoffStrategy;
_busDisposalCancellationToken = busDisposalCancellationToken;
_log = rebusLoggerFactory.GetLogger <OutboxMessagesProcessor>();
}
public OutboxMessageProcessorTests()
{
_transport = Substitute.For <ITransport>();
_outboxStorage = Substitute.For <IOutboxStorage>();
_backoffStrategy = Substitute.For <IBackoffStrategy>();
_busDisposalCancellationTokenSource = new CancellationTokenSource();
_processor = new OutboxMessagesProcessor(TopMessagesToRetrieve, _transport, _outboxStorage,
_backoffStrategy, new NullLoggerFactory(), _busDisposalCancellationTokenSource.Token);
}
public JitterStrategyTests()
{
_constantStrategy = new ConstantBackoffStrategy(_waitTime);
_minRandomNumberGenerator = new MinConstantRandomNumberGenerator();
_maxRandomNumberGenerator = new MaxConstantRandomNumberGenerator();
rangeOfError = 1 - (1 - _maxRandomNumberGenerator.NextDouble()) * 10; // Let's be generous with our buffer.
}
public CappedBackoffStrategy(IBackoffStrategy strategy, TimeSpan maxWaitTime)
{
if (maxWaitTime < TimeSpan.Zero)
{
throw new ArgumentException("The maximum wait time cannot be less than zero.", nameof(maxWaitTime));
}
_strategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
_maxWaitTime = maxWaitTime;
}
public void NullStrategyThrowsExceptionForAConstantAdjustment()
{
IBackoffStrategy decoratedStrategy = null;
IRandomNumberGenerator randomNumberGenerator = new DefaultRandomNumberGenerator();
Assert.Throws <ArgumentNullException>(() =>
{
new ConstantAdjustedBackoffStrategy(decoratedStrategy, TimeSpan.Zero);
});
}
public void NullStrategyThrowsExceptionForAPercentageAdjustment()
{
IBackoffStrategy decoratedStrategy = null;
IRandomNumberGenerator randomNumberGenerator = new DefaultRandomNumberGenerator();
Assert.Throws <ArgumentNullException>(() =>
{
new PercentageAdjustedBackoffStrategy(decoratedStrategy, 1);
});
}
public void NullStrategyThrowsException()
{
IBackoffStrategy decoratedStrategy = null;
IRandomNumberGenerator randomNumberGenerator = new DefaultRandomNumberGenerator();
Assert.Throws <ArgumentNullException>(() =>
{
new MultiplicativeJitterBackoffStrategy(decoratedStrategy, 0, 1);
});
}
public NsqTcpConnection(DnsEndPoint endPoint, ConsumerOptions options, IBackoffStrategy backoffStrategy)
{
_endPoint = endPoint;
_options = options;
_backoffStrategy = backoffStrategy;
_connectionClosedSource = new CancellationTokenSource();
_workerThread = new Thread(WorkerLoop);
_workerThread.Name = "Turbocharged.NSQ Worker";
}
public NsqTcpConnection(DnsEndPoint endPoint, ConsumerOptions options, IBackoffStrategy backoffStrategy)
{
EndPoint = endPoint;
_options = options;
_backoffStrategy = backoffStrategy;
_connectionClosedSource = new CancellationTokenSource();
_workerThread = new Thread(WorkerLoop);
_workerThread.Name = "NSQCore Worker";
}
public ConstantAdjustedBackoffStrategy(IBackoffStrategy strategy, TimeSpan adjustment)
{
_strategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
if (adjustment + strategy.InitialWaitTime < TimeSpan.Zero)
{
throw new ArgumentException("A negative adjustment cannot result in a wait time less than zero.", nameof(adjustment));
}
_adjustment = adjustment;
}
public MessageReaderFactory(IRebusLoggerFactory rebusLoggerFactory,
RebusBus owningBus,
ITransport transport,
IPipelineInvoker pipelineInvoker,
IBackoffStrategy backoffStrategy)
{
this._log = rebusLoggerFactory.GetLogger <RebusMessageReader>();
_transport = transport;
_pipelineInvoker = pipelineInvoker;
_owningBus = owningBus;
_backoffStrategy = backoffStrategy;
}
private static IRequestExecutor GetRequestExecutor(IHttpClient client, IBackoffStrategy defaultStrategy = null, IBackoffStrategy throttlingStrategy = null)
{
var defaultBackoffStrategy = defaultStrategy ?? GetFakeBackoffStrategy();
var throttlingBackoffStrategy = throttlingStrategy ?? GetFakeBackoffStrategy();
return(new DefaultRequestExecutor(
client,
FakeApiKey.Create(valid: true),
AuthenticationScheme.Basic,
Substitute.For <ILogger>(),
defaultBackoffStrategy,
throttlingBackoffStrategy));
}
public PercentageAdjustedBackoffStrategy(IBackoffStrategy strategy, double percentageAdjustment)
{
_strategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
// Prevent violations of causality. Current systems executing this code don't have this problem,
// but who knows what system this will run on in the future.
if (percentageAdjustment < 0)
{
throw new ArgumentException("A negative percentage will result in a negative wait time and is not allowed.", nameof(percentageAdjustment));
}
_percentageAdjustment = percentageAdjustment;
}
public RebusOutboxProcessor(
int topMessagesToRetrieve,
ITransport transport,
IBackoffStrategy backoffStrategy,
IRebusLoggerFactory rebusLoggerFactory,
IOutboxContextFactory outboxContextFactory)
{
_topMessagesToRetrieve = topMessagesToRetrieve;
_transport = transport;
_backoffStrategy = backoffStrategy;
_outboxContextFactory = outboxContextFactory;
_log = rebusLoggerFactory.GetLogger <RebusOutboxProcessor>();
}
private static IRequestExecutor GetRequestExecutor(IHttpClient client, IBackoffStrategy defaultStrategy = null, IBackoffStrategy throttlingStrategy = null)
{
var defaultBackoffStrategy = defaultStrategy ?? GetFakeBackoffStrategy();
var throttlingBackoffStrategy = throttlingStrategy ?? GetFakeBackoffStrategy();
return new DefaultRequestExecutor(
client,
FakeApiKey.Create(valid: true),
AuthenticationScheme.Basic,
Substitute.For<ILogger>(),
defaultBackoffStrategy,
throttlingBackoffStrategy);
}
/// <summary>
/// Constructs the TPL worker factory
/// </summary>
public TplWorkerFactory(ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker, Options options, Func <RebusBus> busGetter, BusLifetimeEvents busLifetimeEvents, IBackoffStrategy backoffStrategy, CancellationToken busDisposalCancellationToken)
{
_transport = transport;
_rebusLoggerFactory = rebusLoggerFactory;
_pipelineInvoker = pipelineInvoker;
_options = options;
_busGetter = busGetter;
_backoffStrategy = backoffStrategy;
_busDisposalCancellationToken = busDisposalCancellationToken;
_parallelOperationsManager = new ParallelOperationsManager(options.MaxParallelism);
_log = _rebusLoggerFactory.GetLogger <TplWorkerFactory>();
busLifetimeEvents.WorkersStopped += WaitForContinuationsToFinish;
}
/// <summary>
/// Constructs the worker factory
/// </summary>
public ThreadWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, int maxParallelism, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory)
{
if (transport == null) throw new ArgumentNullException("transport");
if (pipeline == null) throw new ArgumentNullException("pipeline");
if (pipelineInvoker == null) throw new ArgumentNullException("pipelineInvoker");
if (backoffStrategy == null) throw new ArgumentNullException("backoffStrategy");
if (rebusLoggerFactory == null) throw new ArgumentNullException("rebusLoggerFactory");
if (maxParallelism <= 0) throw new ArgumentOutOfRangeException(string.Format("Cannot use value '{0}' as max parallelism!", maxParallelism));
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_backoffStrategy = backoffStrategy;
_rebusLoggerFactory = rebusLoggerFactory;
_parallelOperationsManager = new ParallelOperationsManager(maxParallelism);
}
public RebusMessageReader(long taskId,
ITaskCoordinatorAdvanced tasksCoordinator,
ILog log,
ITransport transport,
IBackoffStrategy backoffStrategy,
IPipelineInvoker pipelineInvoker,
RebusBus owningBus
) :
base(taskId, tasksCoordinator, log)
{
_transport = transport;
_pipelineInvoker = pipelineInvoker;
_owningBus = owningBus;
_backoffStrategy = backoffStrategy;
}
public TplWorker(string workerName, RebusBus owningBus, ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker, ParallelOperationsManager parallelOperationsManager, Options options, IBackoffStrategy backoffStrategy)
{
_owningBus = owningBus;
_transport = transport;
_pipelineInvoker = pipelineInvoker;
_parallelOperationsManager = parallelOperationsManager;
_options = options;
_backoffStrategy = backoffStrategy;
Name = workerName;
_cancellationToken = _cancellationTokenSource.Token;
_log = rebusLoggerFactory.GetLogger <TplWorker>();
Task.Run(Run);
}
/// <summary>
/// Creates the worker factory
/// </summary>
public WorkersCoordinatorFactory(ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker, Options options, Func <RebusBus> busGetter, BusLifetimeEvents busLifetimeEvents, IBackoffStrategy backoffStrategy)
{
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (pipelineInvoker == null)
{
throw new ArgumentNullException(nameof(pipelineInvoker));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (busGetter == null)
{
throw new ArgumentNullException(nameof(busGetter));
}
if (busLifetimeEvents == null)
{
throw new ArgumentNullException(nameof(busLifetimeEvents));
}
if (backoffStrategy == null)
{
throw new ArgumentNullException(nameof(backoffStrategy));
}
_transport = transport;
_rebusLoggerFactory = rebusLoggerFactory;
_pipelineInvoker = pipelineInvoker;
_options = options;
_busGetter = busGetter;
_backoffStrategy = backoffStrategy;
_log = _rebusLoggerFactory.GetLogger <WorkersCoordinatorFactory>();
if (_options.MaxReadParallelism < 1)
{
throw new ArgumentException($"Max read parallelism is {_options.MaxReadParallelism} which is an invalid value");
}
if (options.WorkerShutdownTimeout < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException($"Cannot use '{options.WorkerShutdownTimeout}' as worker shutdown timeout as it");
}
}
internal ThreadWorker(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, string workerName, ThreadWorkerSynchronizationContext threadWorkerSynchronizationContext, ParallelOperationsManager parallelOperationsManager, IBackoffStrategy backoffStrategy)
{
Name = workerName;
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_threadWorkerSynchronizationContext = threadWorkerSynchronizationContext;
_parallelOperationsManager = parallelOperationsManager;
_backoffStrategy = backoffStrategy;
_workerThread = new Thread(ThreadStart)
{
Name = workerName,
IsBackground = true
};
_workerThread.Start();
}
internal ThreadPoolWorker(string name, ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker, ParallelOperationsManager parallelOperationsManager, RebusBus owningBus, Options options, IBackoffStrategy backoffStrategy)
{
Name = name;
_log = rebusLoggerFactory.GetLogger <ThreadPoolWorker>();
_transport = transport;
_pipelineInvoker = pipelineInvoker;
_parallelOperationsManager = parallelOperationsManager;
_owningBus = owningBus;
_options = options;
_backoffStrategy = backoffStrategy;
_workerThread = new Thread(Run)
{
Name = name,
IsBackground = true
};
_workerThread.Start();
}
/// <summary>
/// Constructs the worker factory
/// </summary>
public ThreadWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory, Options options, Func <RebusBus> busGetter)
{
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (pipeline == null)
{
throw new ArgumentNullException(nameof(pipeline));
}
if (pipelineInvoker == null)
{
throw new ArgumentNullException(nameof(pipelineInvoker));
}
if (backoffStrategy == null)
{
throw new ArgumentNullException(nameof(backoffStrategy));
}
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
var maxParallelism = options.MaxParallelism;
if (maxParallelism <= 0)
{
throw new ArgumentOutOfRangeException($"Cannot use value '{maxParallelism}' as setting for max parallelism as it must be a positive number");
}
var workerShutdownTimeout = options.WorkerShutdownTimeout;
if (workerShutdownTimeout < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException($"Cannot use '{workerShutdownTimeout}' as worker shutdown timeout as it");
}
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_backoffStrategy = backoffStrategy;
_rebusLoggerFactory = rebusLoggerFactory;
_busGetter = busGetter;
_parallelOperationsManager = new ParallelOperationsManager(maxParallelism);
_workerShutdownTimeout = workerShutdownTimeout;
}
public MultiplicativeJitterBackoffStrategy(IBackoffStrategy strategy, double minMultiplier, double maxMultiplier)
{
_strategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
MinMultiplier = minMultiplier;
MaxMultiplier = maxMultiplier;
if (minMultiplier < 0)
{
throw new ArgumentOutOfRangeException(nameof(minMultiplier), "Must be greater than or equal to 0");
}
if (maxMultiplier <= 0)
{
throw new ArgumentOutOfRangeException(nameof(maxMultiplier), "Must be greater than 0");
}
if (minMultiplier > maxMultiplier)
{
throw new ArgumentOutOfRangeException(nameof(maxMultiplier), $"Max multiplier should be greater than {nameof(minMultiplier)}");
}
}
/// <summary>
/// Constructs the worker factory
/// </summary>
public ThreadWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, int maxParallelism, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory, TimeSpan workerShutdownTimeout)
{
if (transport == null) throw new ArgumentNullException(nameof(transport));
if (pipeline == null) throw new ArgumentNullException(nameof(pipeline));
if (pipelineInvoker == null) throw new ArgumentNullException(nameof(pipelineInvoker));
if (backoffStrategy == null) throw new ArgumentNullException(nameof(backoffStrategy));
if (rebusLoggerFactory == null) throw new ArgumentNullException(nameof(rebusLoggerFactory));
if (maxParallelism <= 0) throw new ArgumentOutOfRangeException($"Cannot use value '{maxParallelism}' as max parallelism!");
if (workerShutdownTimeout == null) throw new ArgumentNullException(nameof(workerShutdownTimeout));
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_backoffStrategy = backoffStrategy;
_rebusLoggerFactory = rebusLoggerFactory;
_parallelOperationsManager = new ParallelOperationsManager(maxParallelism);
_workerShutdownTimeout = workerShutdownTimeout;
}
internal ThreadWorker(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, string workerName, ThreadWorkerSynchronizationContext threadWorkerSynchronizationContext, ParallelOperationsManager parallelOperationsManager, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory)
{
Name = workerName;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_threadWorkerSynchronizationContext = threadWorkerSynchronizationContext;
_parallelOperationsManager = parallelOperationsManager;
_backoffStrategy = backoffStrategy;
_workerThread = new Thread(ThreadStart)
{
Name = workerName,
IsBackground = true,
};
_workerThread.Start();
}
private void TestBackoffMaxLevel(IBackoffStrategy backoffStrategy)
{
for (var maxBackoff = 0; maxBackoff <= 16; maxBackoff++)
{
for (var multiplier = 1; multiplier <= 16; multiplier++)
{
var config = new NsqConfig
{
MaxBackoffDuration = TimeSpan.FromMilliseconds(maxBackoff),
BackoffMultiplier = TimeSpan.FromMilliseconds(multiplier)
};
config.Validate();
var expectedMaxLevel = 1;
if (maxBackoff != 0 && multiplier != 0)
{
var x = config.MaxBackoffDuration.TotalSeconds / config.BackoffMultiplier.TotalSeconds;
expectedMaxLevel = (int)Math.Ceiling(Math.Log(x, 2)) + 1;
if (expectedMaxLevel <= 0)
{
expectedMaxLevel = 1;
}
}
bool increaseBackoffLevel;
if (expectedMaxLevel > 1)
{
increaseBackoffLevel = backoffStrategy.Calculate(config, expectedMaxLevel - 1).IncreaseBackoffLevel;
Assert.IsTrue(increaseBackoffLevel,
string.Format("increaseBackoff max={0} multiplier={1} level={2} expectedMaxLevel={3}",
config.MaxBackoffDuration, config.BackoffMultiplier, expectedMaxLevel - 1,
expectedMaxLevel));
}
increaseBackoffLevel = backoffStrategy.Calculate(config, expectedMaxLevel).IncreaseBackoffLevel;
Assert.IsFalse(increaseBackoffLevel,
string.Format("increaseBackoff max={0} multiplier={1} level={2} expectedMaxLevel={3}",
config.MaxBackoffDuration, config.BackoffMultiplier, expectedMaxLevel, expectedMaxLevel));
}
}
}
internal ThreadWorker(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, string workerName, ThreadWorkerSynchronizationContext threadWorkerSynchronizationContext, ParallelOperationsManager parallelOperationsManager, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory, TimeSpan workerShutdownTimeout)
{
Name = workerName;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_threadWorkerSynchronizationContext = threadWorkerSynchronizationContext;
_parallelOperationsManager = parallelOperationsManager;
_backoffStrategy = backoffStrategy;
_workerShutdownTimeout = workerShutdownTimeout;
_workerThread = new Thread(ThreadStart)
{
Name = workerName,
IsBackground = true,
};
_workerThread.Start();
}
/// <summary>
/// Sets the backoff strategy of the retry policy. If not called, the default
/// <see cref="ExponentBackoffStrategy"/> would be used.
/// </summary>
/// <param name="backoffStrategy">The backoff strategy.</param>
/// <returns>The builder instance.</returns>
public RetryPolicyBuilder WithBackoffStrategy(IBackoffStrategy backoffStrategy)
{
this.backoffStrategy = backoffStrategy;
return(this);
}
internal RetryPolicyBuilder()
{
this.maxRetries = DefaultMaxRetries;
this.backoffStrategy = DefaultBackoffStrategy;
}
public DefaultPolicyManager(IBackoffStrategy backoffStrategy, string topicName)
{
this.backoffStrategy = backoffStrategy;
this.topicName = topicName;
}
