public Policy GetPolicyAsync(PolicyBuilder policyBuilder)
{
return(policyBuilder.CircuitBreakerAsync(_exceptionsAllowedBeforeBreaking, TimeSpan.FromMilliseconds(_durationOfBreakInMilliseconds),
onBreak: (x, y) => _logger.LogException(new Exception("Breaker logging: Breaking the circuit for " + y.TotalMilliseconds + " ms!", x)),
onReset: () => _logger.LogMessage("Breaker logging: Call ok! Closed the circuit again!"),
onHalfOpen: () => _logger.LogMessage("Breaker logging: Half-open: Next call is a trial!")));
}
protected virtual AsyncCircuitBreakerPolicy GetCircuitBreakerPolicy()
{
PolicyBuilder builder = Policy.Handle <Exception>(ShouldHandleException);
int exceptionsAllowedBeforeBreaking = Settings.CircuitBreakerExceptionsAllowedBeforeBreaking;
TimeSpan durationOfBreak = TimeSpan.FromMinutes(Settings.CircuitBreakerDurationOfBreakInMinutes);
return(builder.CircuitBreakerAsync(exceptionsAllowedBeforeBreaking, durationOfBreak, OnCircuitBreakerBreak, OnCircuitBreakerReset));
}
public static AsyncPolicy <T> AlteredRetryPolicy <T>(this PolicyBuilder <T> p, string name) where T : IAlteredResponse
=> Policy.WrapAsync(
p.WaitAndRetryAsync(
DecorrelatedJitter(MaxRetries, MinDelay, MaxDelay),
(response, timeSpan, numRetries, context) =>
{
AlteredLog.Warning(new
{
Name = name,
response.Result.RequestId,
Response = new
{
StatusCode = (int)RetryStatusCode,
response.Result.RequestDuration,
RetryAfter = timeSpan.TotalMilliseconds,
NumRetries = numRetries,
Context = context.ToDictionary()
// response.Exception? already logged
}
});
}),
p.CircuitBreakerAsync(MaxCircuitFails, CircuitBreakDuration,
(response, state, timeSpan, context) =>
{
AlteredLog.Error(new
{
Name = name,
response.Result.RequestId,
Response = new
{
StatusCode = (int)CircuitBreakStatusCode,
response.Result.RequestDuration,
RetryAfter = timeSpan.TotalMilliseconds,
CircuitState = state,
Context = context.ToDictionary()
}
});
},
(context) =>
{
AlteredLog.Error(new
{
Name = name,
Response = new
{
StatusCode = (int)CircuitResetStatusCode,
Context = context.ToDictionary()
}
});
},
() =>
{
// half-open
}));
public Policy Build()
{
_circuitBreakerPolicyAsync = _policyBuilder.CircuitBreakerAsync(_exceptionsAllowedBeforeBreaking,
_durationOfBreak,
(ex, breakDelay) =>
{
_log.Error("发生异常：", ex);
},
() =>
{
_log.Debug("正在重新启动任务");
});
_circuitBreakerPolicy = _policyBuilder.CircuitBreaker(_exceptionsAllowedBeforeBreaking,
_durationOfBreak,
(ex, breakDelay) =>
{
_log.Error("发生异常：", ex);
},
() =>
{
_log.Debug("正在重新启动任务");
});
return(_circuitBreakerPolicyAsync);
}
public PolicyProvider()
{
IdPSearchServiceRetryPolicy = _idPSearchServicePolicyBuilder.RetryAsync(3);
IdPSearchServiceErrorPolicy = _idPSearchServicePolicyBuilder.CircuitBreakerAsync(3, TimeSpan.FromMinutes(5));
IdPSearchServicePolicy = IdPSearchServiceRetryPolicy.WrapAsync(IdPSearchServiceErrorPolicy);
}
private static Polly.CircuitBreaker.AsyncCircuitBreakerPolicy <HttpResponseMessage> CircuitBreakerPolicy(
PolicyBuilder <HttpResponseMessage> builder, int handledEventsAllowedBeforeBreaking, TimeSpan durationOfBreak)
=> builder.CircuitBreakerAsync(handledEventsAllowedBeforeBreaking, durationOfBreak);
public AsyncPolicy CreatePolicyAsync(PolicyBuilder policyBuilder) => policyBuilder.CircuitBreakerAsync(_exceptionsAllowedBeforeBreaking, _durationOfBreak);
