public DistributedBulkheadPolicyTests()
        {
            _backplane          = Mock.Of <IDistributedBulkheadBackplane>();
            _keyPrefix          = "test";
            _maxParallelization = 3;
            _onBulkheadRejected = Mock.Of <Func <Context, Task> >();

            _policy = new DistributedBulkheadPolicy(_backplane, _keyPrefix, _maxParallelization, _onBulkheadRejected);
        }
        public TestController(ILogger <TestController> logger, IDistributedBulkheadBackplane bulkheadBackplane)
        {
            _logger            = logger ?? throw new ArgumentNullException(nameof(logger));
            _bulkheadBackplane = bulkheadBackplane ?? throw new ArgumentNullException(nameof(bulkheadBackplane));


            _distributedBulkhead = Policy
                                   .Handle <Exception>()
                                   .DistributedBulkhead(_bulkheadBackplane, "test", 3, OnBulkheadRejected);
        }
        public DistributedBulkheadPolicy(IDistributedBulkheadBackplane backplane, string keyPrefix, int maxParallelization, Func <Context, Task> onBulkheadRejectedAsync, PolicyBuilder policyBuilder = null)
            : base(policyBuilder)
        {
            if (string.IsNullOrWhiteSpace(keyPrefix))
            {
                throw new ArgumentException(nameof(keyPrefix));
            }
            if (maxParallelization <= 0)
            {
                throw new ArgumentException("Max parallelization should be at least one", nameof(maxParallelization));
            }

            _backplane = backplane ?? throw new ArgumentNullException(nameof(backplane));
            _keyPrefix = keyPrefix;
            _onBulkheadRejectedAsync = onBulkheadRejectedAsync;
            _maxParallelization      = maxParallelization;
        }
        public static DistributedBulkheadPolicy DistributedBulkhead(this PolicyBuilder builder, IDistributedBulkheadBackplane backplane, string keyPrefix, int maxParallelization)
        {
            Task DoNothingAsync(Context _) => TaskHelper.EmptyTask;

            return(builder.DistributedBulkhead(backplane, keyPrefix, maxParallelization, DoNothingAsync));
        }
 public static DistributedBulkheadPolicy DistributedBulkhead(this PolicyBuilder builder, IDistributedBulkheadBackplane backplane, string keyPrefix, int maxParallelization, Func <Context, Task> onBulkheadRejected)
 {
     return(new DistributedBulkheadPolicy(backplane, keyPrefix, maxParallelization, onBulkheadRejected));
 }
        public RedisDistributedBulkheadBackplaneTests()
        {
            _multiplexer = Mock.Of <IConnectionMultiplexer>();

            _backplane = new RedisDistributedBulkheadBackplane(_multiplexer);
        }