public bool ExecuteException(CircuitBreakerParameters model)
{
try
{
if (model.Exception.IsNotNull())
{
var processExists = this._user.GetCircuitBreaker().Where(_ => _.Process == model.Process).SingleOrDefault();
if (processExists.IsNull())
{
var CircuitBreaker = new CurrentUser.CircuitBreakerMananger();
CircuitBreaker.SetProcess(model.Process);
CircuitBreaker.AddErrorCount();
CircuitBreaker.SetSecurityDateStop(DateTime.Now.ToTimeZone());
this._user.AddCircuitBreaker(CircuitBreaker);
}
else
{
processExists.AddErrorCount();
processExists.SetSecurityDateStop(DateTime.Now.ToTimeZone());
}
}
}
catch (Exception ex)
{
this._logger.LogError(ex.ToString());
}
return(true);
}
private IEasyCachingProvider CreateCachingProviderWithUnavailableRedisAndFallback()
{
var serviceProvider = CreateServiceProvider(options =>
{
options.DBConfig.Configuration = "127.0.0.1:9999,allowAdmin=false,defaultdatabase=9,connectTimeout=1";
var initCircuitBreakerParameters =
new CircuitBreakerParameters(
exceptionsAllowedBeforeBreaking: 1,
durationOfBreak: TimeSpan.FromMinutes(1));
var executeCircuitBreakerParameters =
new AdvancedCircuitBreakerParameters(
failureThreshold: 0.1,
samplingDuration: TimeSpan.FromSeconds(15),
minimumThroughput: 10,
durationOfBreak: TimeSpan.FromSeconds(60));
options
.DecorateWithCircuitBreaker(
initCircuitBreakerParameters,
executeCircuitBreakerParameters,
exceptionFilter: RedisOptionsExtensions.RedisExceptionFilter)
.DecorateWithFallback(
(name, _) => new NullCachingProvider(name, options),
exceptionFilter: RedisOptionsExtensions.RedisExceptionFilter);
});
return(serviceProvider.GetService <IEasyCachingProvider>());
}
protected IEasyCachingProvider CreateDecoratedProvider() =>
ServiceBuilders.CreateFakeProvider(options =>
{
options.ProviderFactory = CreateProvider;
var circuitBreakerParameters = new CircuitBreakerParameters(
exceptionsAllowedBeforeBreaking: 1,
durationOfBreak: TimeSpan.FromMinutes(1));
options.DecorateWithCircuitBreaker(
initParameters: circuitBreakerParameters,
executeParameters: circuitBreakerParameters,
exception => exception is InvalidOperationException);
});
protected IEasyCachingBus CreateDecoratedProvider() =>
ServiceBuilders.CreateFakeBus(options =>
{
options.BusFactory = CreateBus;
var circuitBreakerParameters = new CircuitBreakerParameters(
exceptionsAllowedBeforeBreaking: 1,
durationOfBreak: TimeSpan.FromMinutes(1));
options.DecorateWithCircuitBreaker(
initParameters: circuitBreakerParameters,
executeParameters: circuitBreakerParameters,
subscribeRetryInterval: TimeSpan.FromMilliseconds(1),
exceptionFilter: exception => exception is InvalidOperationException);
});
public static IEasyCachingProvider CreateDecoratedProvider(
Func <IEasyCachingProvider> providerFactory, IEasyCachingProvider fallbackProvider) =>
ServiceBuilders.CreateFakeProvider(options =>
{
options.ProviderFactory = providerFactory;
var circuitBreakerParameters = new CircuitBreakerParameters(
exceptionsAllowedBeforeBreaking: 1,
durationOfBreak: TimeSpan.FromMinutes(1));
options
.DecorateWithCircuitBreaker(
initParameters: circuitBreakerParameters,
executeParameters: circuitBreakerParameters,
exception => exception is InvalidOperationException)
.DecorateWithFallback(
(_, __) => fallbackProvider,
exception => exception is InvalidOperationException);
});
public void Subscribe_With_Circuit_Breaker_Subscribe_Exception_Should_Not_Break()
{
var circuitBreakerParameters = new CircuitBreakerParameters(
exceptionsAllowedBeforeBreaking: 1,
durationOfBreak: TimeSpan.FromMinutes(1));
var(hybridProvider, _, _, _) = CreateCachingProviderWithFakes(
decorateFakeBus: options => options.DecorateWithCircuitBreaker(
initParameters: circuitBreakerParameters,
executeParameters: circuitBreakerParameters,
subscribeRetryInterval: TimeSpan.FromMinutes(1),
exceptionFilter: exception => exception is InvalidOperationException),
setupFakeBus: bus =>
A.CallTo(() => bus.Subscribe("test_topic", A <Action <EasyCachingMessage> > ._)).Throws(new InvalidOperationException())
);
hybridProvider.RemoveAsync("fake-remove");
Assert.True(true);
}
private IHybridCachingProvider CreateCachingProviderWithCircuitBreakerAndFallback(string connectionString) =>
CreateService <IHybridCachingProvider>(services =>
{
services.AddEasyCaching(x =>
{
x.UseInMemory(LocalCacheProviderName);
var circuitBreakerParameters = new CircuitBreakerParameters(
exceptionsAllowedBeforeBreaking: 1,
durationOfBreak: TimeSpan.FromMinutes(1));
x.UseRedis(options =>
{
options.DBConfig.Configuration = connectionString;
options.DecorateWithCircuitBreaker(
initParameters: circuitBreakerParameters,
executeParameters: circuitBreakerParameters,
exceptionFilter: RedisOptionsExtensions.RedisExceptionFilter);
},
DistributedCacheProviderName);
x.WithRedisBus(options =>
{
options.Configuration = connectionString;
options
.DecorateWithCircuitBreaker(
initParameters: circuitBreakerParameters,
executeParameters: circuitBreakerParameters,
subscribeRetryInterval: TimeSpan.FromMinutes(1),
exceptionFilter: RedisOptionsExtensions.RedisExceptionFilter)
.DecorateWithRetry(1, RedisOptionsExtensions.RedisExceptionFilter)
.DecorateWithPublishFallback(RedisOptionsExtensions.RedisExceptionFilter);
});
UseHybrid(x);
});
});
CreateCachingProviderWithFakes(
Action <FakeBusOptions> decorateFakeBus = null,
Action <IEasyCachingProvider> setupFakeDistributedProvider = null,
Action <IEasyCachingBus> setupFakeBus = null)
{
var fakeBus = A.Fake <IEasyCachingBus>();
setupFakeBus?.Invoke(fakeBus);
var fakeDistributedProvider = A.Fake <IEasyCachingProvider>();
A.CallTo(() => fakeDistributedProvider.Name).Returns(DistributedCacheProviderName);
setupFakeDistributedProvider?.Invoke(fakeDistributedProvider);
var services = new ServiceCollection();
services.AddEasyCaching(x =>
{
x.UseInMemory(LocalCacheProviderName);
x.UseFakeProvider(
options =>
{
options.ProviderFactory = () => fakeDistributedProvider;
var circuitBreakerParameters = new CircuitBreakerParameters(
exceptionsAllowedBeforeBreaking: 2,
durationOfBreak: TimeSpan.FromMinutes(1));
options.DecorateWithCircuitBreaker(
initParameters: circuitBreakerParameters,
executeParameters: circuitBreakerParameters,
exception => exception is InvalidOperationException);
},
DistributedCacheProviderName);
x.WithFakeBus(options =>
{
options.BusFactory = () => fakeBus;
if (decorateFakeBus != null)
{
decorateFakeBus(options);
}
else
{
options
.DecorateWithRetry(retryCount: 1, exceptionFilter: null)
.DecorateWithPublishFallback(exceptionFilter: null);
};
});
UseHybrid(x);
});
var serviceProvider = services.BuildServiceProvider();
return(
serviceProvider.GetService <IHybridCachingProvider>(),
serviceProvider.GetService <IEasyCachingProviderFactory>().GetCachingProvider(LocalCacheProviderName),
fakeDistributedProvider,
fakeBus);
}
