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