private IHttpClient CreateHttpClientWapper(CircuitBreakerConfig circuitBreakerConfig)
{
IHttpClientBuilder httpClientBuilder = new HttpClientBuilder(circuitBreakerConfig);
var httpClientWrapper = httpClientBuilder.Create(useCookies: true, allowAutoRedirect: true);
return(httpClientWrapper);
}
public static CircuitBreakerConfig ToBreakerConfig(this CircuitBreakerConfigSection circuitBreakerConfigSection)
{
var circuitBreakerConfig = new CircuitBreakerConfig
{
BreakerId = string.Format("{0}-{1}", circuitBreakerConfigSection.BreakerId, Environment.MachineName),
UseTimeout = circuitBreakerConfigSection.UseTimeout,
OpenEventTolerance = circuitBreakerConfigSection.OpenEventTolerance,
Timeout = GetTimeout(circuitBreakerConfigSection),
ExpectedExceptionList = GetExpectedExceptionList(circuitBreakerConfigSection),
UseImmediateFailureRetry = circuitBreakerConfigSection.UseImmediateFailureRetry
};
if (!string.IsNullOrEmpty(circuitBreakerConfigSection.BreakerOpenPeriods))
{
circuitBreakerConfig.BreakerOpenPeriods = GetBreakerOpenPeriods(circuitBreakerConfigSection);
}
if (circuitBreakerConfigSection.Exceptions.Count > 0)
{
circuitBreakerConfig.ExpectedExceptionListType = GetExceptionListType(circuitBreakerConfigSection);
}
if (circuitBreakerConfigSection.PermittedExceptionBehaviourConfig != PermittedExceptionBehaviourConfig.None)
{
circuitBreakerConfig.PermittedExceptionPassThrough =
GetPermittedExceptionBehaviour(circuitBreakerConfigSection);
}
if (!string.IsNullOrEmpty(circuitBreakerConfigSection.OpenEventToleranceResetPeriod))
{
circuitBreakerConfig.OpenEventToleranceResetPeriod =
GetOpenEventToleranceResetPeriod(circuitBreakerConfigSection);
}
return circuitBreakerConfig;
}
public void Deserialization_ValidData_CreatesValidInstance()
{
CircuitBreakerConfig config = JsonConvert.DeserializeObject <CircuitBreakerConfig>(
"{ duration : 12.5, tolerance : 15 }");
Assert.IsNotNull(config);
Assert.AreEqual(12.5d, config.BreakDuration, 0.0001d);
Assert.AreEqual(15, config.FaultTolerance);
}
public void AsPolicy_LoggerNull_Throws()
{
var config = new CircuitBreakerConfig
{
BreakDuration = 1.0d,
FaultTolerance = 25
};
Assert.ThrowsException <ArgumentNullException>(
() => config.AsTypeModel(null));
}
public void AsPolicy_InvalidFaultTolerance_Throws()
{
var logger = new Mock <ILogger>(MockBehavior.Loose);
var config = new CircuitBreakerConfig
{
BreakDuration = 15.0d,
FaultTolerance = 0
};
Assert.ThrowsException <InvalidOperationException>(
() => config.AsTypeModel(logger.Object));
}
public IHttpClient Get(string caheKey, CircuitBreakerConfig circuitBreakerConfig)
{
IHttpClient httpClient;
if (_httpClientDictionary.TryGetValue(caheKey, out var httpClientQueue))
{
httpClientQueue.TryDequeue(out httpClient);
return(httpClient ?? CreateHttpClientWapper(circuitBreakerConfig));
}
httpClient = CreateHttpClientWapper(circuitBreakerConfig);
return(httpClient);
}
public void AsPolicy_AllValuesInitialized_ReturnsPolicy()
{
var logger = new Mock <ILogger>(MockBehavior.Loose);
var config = new CircuitBreakerConfig
{
BreakDuration = 15.0d,
FaultTolerance = 25
};
IAsyncPolicy <HttpResponseMessage> policy = config.AsTypeModel(logger.Object);
Assert.IsNotNull(policy);
Assert.IsInstanceOfType(policy, typeof(AsyncCircuitBreakerPolicy <HttpResponseMessage>));
}
public HttpClientBuilder(CircuitBreakerConfig circuitBreakerConfig)
{
_circuitBreakerConfig = circuitBreakerConfig;
}
public HttpClientRequestHandler(IHttpClientCache httpClientCache, CircuitBreakerConfig circuitBreakerConfig)
{
_httpClientCache = httpClientCache;
_circuitBreakerConfig = circuitBreakerConfig;
}
