public void Should_call_onreset_when_manually_resetting_circuit() { int onBreakCalled = 0; int onResetCalled = 0; Action <Exception, TimeSpan> onBreak = (_, __) => { onBreakCalled++; }; Action onReset = () => { onResetCalled++; }; var time = 1.January(2000); SystemClock.UtcNow = () => time; var durationOfBreak = TimeSpan.FromMinutes(1); CircuitBreakerPolicy breaker = Policy .Handle <DivideByZeroException>() .CircuitBreaker(2, durationOfBreak, onBreak, onReset); onBreakCalled.Should().Be(0); breaker.Isolate(); onBreakCalled.Should().Be(1); breaker.CircuitState.Should().Be(CircuitState.Isolated); breaker.Invoking(x => x.Execute(() => { })) .ShouldThrow <IsolatedCircuitException>(); onResetCalled.Should().Be(0); breaker.Reset(); onResetCalled.Should().Be(1); breaker.CircuitState.Should().Be(CircuitState.Closed); breaker.Invoking(x => x.Execute(() => { })).ShouldNotThrow(); }
public void Should_hold_circuit_open_despite_elapsed_time_if_manual_override_open() { var time = 1.January(2000); SystemClock.UtcNow = () => time; var durationOfBreak = TimeSpan.FromMinutes(1); CircuitBreakerPolicy breaker = Policy .Handle <DivideByZeroException>() .CircuitBreaker(2, durationOfBreak); breaker.CircuitState.Should().Be(CircuitState.Closed); breaker.Isolate(); breaker.CircuitState.Should().Be(CircuitState.Isolated); SystemClock.UtcNow = () => time.Add(durationOfBreak); breaker.CircuitState.Should().Be(CircuitState.Isolated); bool delegateExecutedWhenBroken = false; breaker.Invoking(x => x.Execute(() => { delegateExecutedWhenBroken = true; return(ResultPrimitive.Good); })) .ShouldThrow <IsolatedCircuitException>(); delegateExecutedWhenBroken.Should().BeFalse(); }
public void Should_open_circuit_and_block_calls_if_manual_override_open() { var time = 1.January(2000); SystemClock.UtcNow = () => time; var durationOfBreak = TimeSpan.FromMinutes(1); CircuitBreakerPolicy breaker = Policy .Handle <DivideByZeroException>() .CircuitBreaker(2, durationOfBreak); breaker.CircuitState.Should().Be(CircuitState.Closed); // manually break circuit breaker.Isolate(); breaker.CircuitState.Should().Be(CircuitState.Isolated); // circuit manually broken: execution should be blocked; even non-exception-throwing executions should not reset circuit bool delegateExecutedWhenBroken = false; breaker.Invoking(x => x.Execute(() => delegateExecutedWhenBroken = true)) .ShouldThrow <IsolatedCircuitException>(); breaker.CircuitState.Should().Be(CircuitState.Isolated); delegateExecutedWhenBroken.Should().BeFalse(); }
static async Task RunAsync() { Console.WriteLine("Select Polly test : "); Console.WriteLine("1. Test Retries"); Console.WriteLine("2. Test Timeout"); Console.WriteLine("3. Test Circuit Breaker"); Console.WriteLine("4. Isolate Circuit Breaker"); string userChoice = Console.ReadLine(); switch (userChoice) { case "1": await TestRetries(); break; case "2": await TestTimeout(); break; case "3": await TestCircuitBreaker(); break; case "4": _circuitBreakerPolicy.Isolate(); break; } }
public ActionResult <int> Get(int id) { // For demo purposes, a GET will trip circuit breaker CircuitBreakerPolicy breaker = registry.Get <CircuitBreakerPolicy>("DefaultBreaker"); breaker.Isolate(); // And trip another health check. Very buggy GET method :) return(healthCheck.Trip()); }
public void GetPolicyTPolicy_should_return_single_policy_of_type_TPolicy_matching_predicate() { CircuitBreakerPolicy policyA = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.Zero); Policy policyB = Policy.Handle <Exception>().Retry(); CircuitBreakerPolicy policyC = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.Zero); policyA.Isolate(); PolicyWrap wrap = policyA.Wrap(policyB.Wrap(policyC)); wrap.GetPolicy <CircuitBreakerPolicy>(p => p.CircuitState == CircuitState.Closed).Should().BeSameAs(policyC); }
public void GetPoliciesTPolicy_should_return_policies_of_type_TPolicy_matching_predicate() { CircuitBreakerPolicy policyA = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.Zero); Policy policyB = Policy.Handle <Exception>().Retry(); CircuitBreakerPolicy policyC = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.Zero); policyA.Isolate(); PolicyWrap wrap = policyA.Wrap(policyB.Wrap(policyC)); wrap.GetPolicies <CircuitBreakerPolicy>(p => p.CircuitState == CircuitState.Closed).ShouldBeEquivalentTo(new[] { policyC }, options => options.WithStrictOrdering()); }
static void CircuitBreaker() { Action <Exception, TimeSpan, Context> onBreak = (exception, timespan, context) => { Console.WriteLine("onBreak Running : " + exception.Message); }; Action <Context> onReset = context => { Console.WriteLine("Job Back to normal"); }; CircuitBreakerPolicy breaker = Policy .Handle <AggregateException>() .CircuitBreaker(3, TimeSpan.FromSeconds(10), onBreak, onReset); // Monitor the circuit state, for example for health reporting. CircuitState state = breaker.CircuitState; ISyncPolicy policy = Policy.Handle <ArgumentException>() .Retry(3, (ex, retryCount, context) => { Console.WriteLine($"Runing fallback,Exception :{ex.Message},RetryCount:{retryCount}"); }); while (true) { try { var policyWrap = Policy.Wrap(policy, breaker); // (wraps the policies around any executed delegate: fallback outermost ... bulkhead innermost) policyWrap.Execute(() => { Console.WriteLine("Job Start"); if (DateTime.Now.Second % 3 == 0) { throw new ArgumentException("Hello Polly!"); } }); } catch (Exception ex) { // 手动打开熔断器,阻止执行 breaker.Isolate(); } Thread.Sleep(1000); // 恢复操作,启动执行 breaker.Reset(); } }
public async Task Converting_a_nongeneric_IAsyncPolicy_to_generic_should_return_an_IAsyncPolicyTResult_version_of_the_supplied_nongeneric_policy_instance() { // Use a CircuitBreaker as a policy which we can easily manipulate to demonstrate that the executions are passing through the underlying non-generic policy. CircuitBreakerPolicy breaker = Policy.Handle <Exception>().CircuitBreakerAsync(1, TimeSpan.Zero); IAsyncPolicy nonGenericPolicy = breaker; var genericPolicy = nonGenericPolicy.AsAsyncPolicy <ResultPrimitive>(); Func <Task <ResultPrimitive> > deleg = () => TaskHelper.FromResult(ResultPrimitive.Good); (await genericPolicy.ExecuteAsync(deleg)).Should().Be(ResultPrimitive.Good); breaker.Isolate(); genericPolicy.Awaiting(p => p.ExecuteAsync(deleg)).ShouldThrow <BrokenCircuitException>(); }
public void Should_call_onbreak_when_breaking_circuit_manually() { bool onBreakCalled = false; Action <Exception, TimeSpan> onBreak = (_, __) => { onBreakCalled = true; }; Action onReset = () => { }; CircuitBreakerPolicy breaker = Policy .Handle <DivideByZeroException>() .CircuitBreaker(2, TimeSpan.FromMinutes(1), onBreak, onReset); onBreakCalled.Should().BeFalse(); breaker.Isolate(); onBreakCalled.Should().BeTrue(); }
public void Should_call_onbreak_when_breaking_circuit_manually() { bool onBreakCalled = false; Action <DelegateResult <ResultPrimitive>, TimeSpan> onBreak = (_, __) => { onBreakCalled = true; }; Action onReset = () => { }; CircuitBreakerPolicy <ResultPrimitive> breaker = Policy .HandleResult(ResultPrimitive.Fault) .CircuitBreaker(2, TimeSpan.FromMinutes(1), onBreak, onReset); onBreakCalled.Should().BeFalse(); breaker.Isolate(); onBreakCalled.Should().BeTrue(); }
public void Should_hold_circuit_open_despite_elapsed_time_if_manual_override_open() { var time = 1.January(2000); SystemClock.UtcNow = () => time; var durationOfBreak = TimeSpan.FromMinutes(1); CircuitBreakerPolicy breaker = Policy .Handle <DivideByZeroException>() .CircuitBreakerAsync(2, durationOfBreak); breaker.CircuitState.Should().Be(CircuitState.Closed); breaker.Isolate(); breaker.CircuitState.Should().Be(CircuitState.Isolated); SystemClock.UtcNow = () => time.Add(durationOfBreak); breaker.CircuitState.Should().Be(CircuitState.Isolated); breaker.Awaiting(x => x.ExecuteAsync(() => Task.FromResult(true))) .ShouldThrow <IsolatedCircuitException>(); }
public void Should_close_circuit_again_on_reset_after_manual_override() { var time = 1.January(2000); SystemClock.UtcNow = () => time; var durationOfBreak = TimeSpan.FromMinutes(1); CircuitBreakerPolicy breaker = Policy .Handle <DivideByZeroException>() .CircuitBreaker(2, durationOfBreak); breaker.CircuitState.Should().Be(CircuitState.Closed); breaker.Isolate(); breaker.CircuitState.Should().Be(CircuitState.Isolated); breaker.Invoking(x => x.Execute(() => { })) .ShouldThrow <IsolatedCircuitException>(); breaker.Reset(); breaker.CircuitState.Should().Be(CircuitState.Closed); breaker.Invoking(x => x.Execute(() => { })).ShouldNotThrow(); }
public void Should_open_circuit_with_timespan_maxvalue_if_manual_override_open() { TimeSpan?passedBreakTimespan = null; Action <Exception, TimeSpan, Context> onBreak = (_, timespan, __) => { passedBreakTimespan = timespan; }; Action <Context> onReset = _ => { }; var time = 1.January(2000); SystemClock.UtcNow = () => time; var durationOfBreak = TimeSpan.FromMinutes(1); CircuitBreakerPolicy breaker = Policy .Handle <DivideByZeroException>() .CircuitBreaker(2, durationOfBreak, onBreak, onReset); breaker.CircuitState.Should().Be(CircuitState.Closed); // manually break circuit breaker.Isolate(); breaker.CircuitState.Should().Be(CircuitState.Isolated); passedBreakTimespan.Should().Be(TimeSpan.MaxValue); }