public PartiallyClosedCircuitBreakerState(CircuitBreaker breaker, Exception exception,
IEnumerator<int> timeoutEnumerator)
: base(breaker)
{
_exception = exception;
_timeoutEnumerator = timeoutEnumerator;
}
public void ShouldProcessOnMultipleThreads()
{
// Arrange
var breaker = new CircuitBreaker();
var source = Enumerable.Range(0, 100).ToArray();
// Act
var usedThreadIds = new List<int>();
Reliable.ParallelForEach(
breaker,
source,
elements => usedThreadIds.Add(Thread.CurrentThread.ManagedThreadId),
new RetryOptions
{
AllowedRetries = 5,
RetryInterval = TimeSpan.Zero
},
new ParallelOptions
{
MaxDegreeOfParallelism = 100
});
// Assert
if (usedThreadIds.Distinct().Count() == 1)
Assert.Inconclusive("This test relies on multiple threads, however only one was ever spawned.");
}
public void CanChangeTimeout()
{
var expected = 66;
var cb = new CircuitBreaker(100, 5);
cb.Timeout = expected;
Assert.AreEqual(expected, cb.Timeout);
}
public OpenCircuitBreakerState(CircuitBreaker breaker, Exception exception, IEnumerator<int> timeoutEnumerator)
: base(breaker)
{
_exception = exception;
_timeoutEnumerator = timeoutEnumerator;
_timer = GetTimer(timeoutEnumerator);
}
public void Constructor_Overload()
{
var cb = new CircuitBreaker(1500, 2);
Assert.AreEqual(1500, cb.Timeout);
Assert.AreEqual(2, cb.Threshold);
Assert.AreEqual(CircuitBreakerState.Closed, cb.State);
}
public void Execute_CanExecuteOperation()
{
var cb = new CircuitBreaker(1000, 3);
var result = cb.Execute(new Func<int>(() => { return 1 + 2; }));
Assert.AreEqual(3, result);
Assert.AreEqual(CircuitBreakerState.Closed, cb.State);
}
public void Constructor_Empty()
{
var cb = new CircuitBreaker();
Assert.AreEqual(1000, cb.Timeout);
Assert.AreEqual(5, cb.Threshold);
Assert.AreEqual(CircuitBreakerState.Closed, cb.State);
}
public void CanChangeThreshold()
{
var expected = 66;
var cb = new CircuitBreaker(100, 5);
cb.Threshold = expected;
Assert.AreEqual(expected, cb.Threshold);
}
public void ExecuteWithResultShouldReturnResult()
{
var circuitBreaker = new CircuitBreaker();
var expectedResult = new object();
var result = circuitBreaker.Execute(() => expectedResult);
Assert.AreEqual(expectedResult, result);
}
public void ExecuteShouldExecuteActionOnce()
{
var circuitBreaker = new CircuitBreaker();
var actionCallCount = 0;
circuitBreaker.Execute(() => { actionCallCount++; });
Assert.AreEqual(1, actionCallCount);
}
public void TestThresholdReach()
{
var breaker = new CircuitBreaker(new CircuitBreakerConfig { ConsecutiveErrorsToBreak = 2, BreakDelayInSeconds = 5 });
Assert.IsFalse(breaker.IsCircuitOpen());
breaker.AddError();
Assert.IsFalse(breaker.IsCircuitOpen());
breaker.AddError();
Assert.IsTrue(breaker.IsCircuitOpen());
}
protected override void Given()
{
base.Given();
_timeout = TimeSpan.FromMilliseconds(1000);
_config = new CircuitBreakerConfig
{
UseTimeout = true,
Timeout = _timeout
};
_circuitBreaker = new CircuitBreaker(_config);
}
public void SetUp()
{
this.cb = new CircuitBreaker(5, 1000);
this.cb.StateChanged += new EventHandler(cb_StateChanged);
this.executeCount = 0;
this.serviceFailureCount = 0;
this.halfOpenStateChangeCount = 0;
this.closedStateChangeCount = 0;
this.openStateChangeCount = 0;
this.openCircuitCount = 0;
}
protected override void Given()
{
base.Given();
_caughtExceptions = new List<Exception>();
_config = new CircuitBreakerConfig
{
UseImmediateFailureRetry = true
};
_circuitBreaker = new CircuitBreaker(_config);
_circuitBreaker.OpenedCircuitBreaker += (sender, args) => _openedEventFired = true;
}
static CircuitBreakerHttpModule()
{
FilesWatched = ConfigurationManager.AppSettings["IISCircuitBreaker.FilesWatched"].Split(new[] {','}).ToList();
StatusCodes = ConfigurationManager.AppSettings["IISCircuitBreaker.StatusCodes"].Split(new[] { ',' }).ToList();
StatusCodeWhileBroken = Convert.ToInt32(ConfigurationManager.AppSettings["IISCircuitBreaker.StatusCodeWhileBroken"]);
Breaker = new CircuitBreaker(new CircuitBreakerConfig
{
BreakDelayInSeconds = Convert.ToInt32(ConfigurationManager.AppSettings["IISCircuitBreaker.BreakDelayInSeconds"]),
ConsecutiveErrorsToBreak = Convert.ToInt32(ConfigurationManager.AppSettings["IISCircuitBreaker.ConsecutiveErrorsToBreak"])
});
}
static void Main(string[] args)
{
var breaker = new CircuitBreaker(3, TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(500));
breaker.OnClose(() => { Console.WriteLine("Close"); })
.OnHalfOpen(() => { Console.WriteLine("HalfOpen"); })
.OnOpen(() => { Console.WriteLine("Open"); });
while(true)
{
TestCaseAsync(breaker);
Thread.Sleep(10);
}
}
public void TestCorrectSetup()
{
var breaker = new CircuitBreaker(new CircuitBreakerConfig {ConsecutiveErrorsToBreak = 100, BreakDelayInSeconds = 5});
Assert.IsNotNull(breaker.Config);
Assert.AreEqual(100, breaker.Config.ConsecutiveErrorsToBreak);
Assert.AreEqual(5, breaker.Config.BreakDelayInSeconds);
Assert.AreEqual(0, breaker.CurrentNumberOfErrors);
Assert.IsTrue(DateTime.Now.CompareTo(breaker.OpenUntil) >= 0);
Assert.IsFalse(breaker.IsCircuitOpen());
}
protected override void Given()
{
base.Given();
_caughtExceptions = new List<Exception>();
_thrownException = new ArgumentNullException();
_config = new CircuitBreakerConfig
{
OpenEventTolerance = 2,
OpenEventToleranceResetPeriod = new TimeSpan(0, 0, 3)
};
_circuitBreaker = new CircuitBreaker(_config);
_circuitBreaker.ToleratedOpenCircuitBreaker += (sender, args) => _toleratedOpenEventCount++;
_circuitBreaker.OpenedCircuitBreaker += (sender, args) => _openedEventFired = true;
}
public void TestThresholdNotReachedWhenErrorsAreCleared()
{
var breaker = new CircuitBreaker(new CircuitBreakerConfig { ConsecutiveErrorsToBreak = 2, BreakDelayInSeconds = 5 });
Assert.IsFalse(breaker.IsCircuitOpen());
breaker.AddError();
Assert.IsFalse(breaker.IsCircuitOpen());
breaker.ClearErrors();
Assert.IsFalse(breaker.IsCircuitOpen());
breaker.AddError();
Assert.IsFalse(breaker.IsCircuitOpen());
}
public static void Main()
{
var externalService = new ExternalService();
var circuitBreaker = new CircuitBreaker(
TaskScheduler.Default,
maxFailures: 2,
invocationTimeout: TimeSpan.FromMilliseconds(10),
circuitResetTimeout: TimeSpan.FromMilliseconds(1000));
TryExecute(circuitBreaker, externalService.Get);
TryExecute(circuitBreaker, () => Thread.Sleep(100));
TryExecute(circuitBreaker, externalService.Get);
}
public void ShouldThrowOpenCircuitExceptionWhenCircuitBreakerIsOpenTheEntireTime()
{
var circuitBreaker = new CircuitBreaker(100, TimeSpan.FromHours(1));
circuitBreaker.Trip();
try
{
circuitBreaker.ExecuteWithRetries(
() => 1,
new RetryOptions { AllowedRetries = 5, RetryInterval = TimeSpan.Zero });
Assert.Fail("No exception was thrown");
}
catch (Exception ex)
{
Assert.IsInstanceOf<OpenCircuitException>(ex);
}
}
public void ShouldNotCallFuncWhenCircuitBreakerIsOpen()
{
var circuitBreaker = new CircuitBreaker(100, TimeSpan.FromHours(1));
circuitBreaker.Trip();
var result = 0;
try
{
result = circuitBreaker.ExecuteWithRetries(
() => 999,
new RetryOptions { AllowedRetries = 5, RetryInterval = TimeSpan.Zero });
}
catch (OpenCircuitException)
{
}
Assert.AreNotEqual(result, 999);
}
public void Retry_WithZeroAttempts_Failure()
{
AggregateException exceptions = new AggregateException();
try
{
var func = new Func<int>(() => { throw new Exception(); });
var cb = new CircuitBreaker(500, 1);
cb.Retry<int>(func, 0);
}
catch (AggregateException ex)
{
exceptions = ex;
}
Assert.AreEqual("The operation terminated after 0 retries.", exceptions.Message);
Assert.AreEqual(0, exceptions.InnerExceptions.Count);
}
public void TestWaitForOneSecondUntilCircuitCloses()
{
var breaker = new CircuitBreaker(new CircuitBreakerConfig { ConsecutiveErrorsToBreak = 2, BreakDelayInSeconds = 1 });
Assert.IsFalse(breaker.IsCircuitOpen());
breaker.AddError();
Assert.IsFalse(breaker.IsCircuitOpen());
breaker.AddError();
Assert.IsTrue(breaker.IsCircuitOpen());
Thread.Sleep(250);
Assert.IsTrue(breaker.IsCircuitOpen());
Thread.Sleep(250);
Assert.IsTrue(breaker.IsCircuitOpen());
Thread.Sleep(500);
Assert.IsFalse(breaker.IsCircuitOpen());
}
public void ShouldThrowAggregateExceptionWhenMultipleRetriesFailWithExceptions()
{
var circuitBreaker = new CircuitBreaker(100, TimeSpan.FromSeconds(1));
try
{
circuitBreaker.ExecuteWithRetries<int>(
() => {throw new Exception("foo"); },
new RetryOptions { AllowedRetries = 5, RetryInterval = TimeSpan.Zero });
Assert.Fail("No exception was thrown");
}
catch (AggregateException ex)
{
Assert.AreEqual(5, ex.InnerExceptions.Count);
Assert.IsTrue(ex.InnerExceptions.All(e => e.Message == "foo"));
}
catch (Exception ex)
{
Assert.IsInstanceOf<AggregateException>(ex);
}
}
public void ShouldProcessAllElementsInOrder()
{
// Arrange
var breaker = new CircuitBreaker();
var source = Enumerable.Range(0, 10).ToArray();
// Act
var processedElements = new List<int>();
Reliable.ForEach(
breaker,
source,
processedElements.Add,
new RetryOptions
{
AllowedRetries = 5,
RetryInterval = TimeSpan.Zero
});
// Assert
CollectionAssert.AreEqual(source, processedElements);
}
private static async void TestCaseAsync(CircuitBreaker breaker)
{
try
{
await Task.Delay(100);
string result;
if (random.Next(10) == 0)
{
result = await breaker.WithCircuitBreaker<string>(() => { throw new Exception("Business Exception"); Task.FromResult("Test"); });
}
else
{
result = await breaker.WithCircuitBreaker<string>(() => Task.FromResult("Test"));
}
Console.WriteLine(result);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private static void TestCase(CircuitBreaker breaker)
{
try
{
string result;
if (random.Next(2) == 0)
{
result = breaker.WithSyncCircuitBreaker(() => { throw new Exception("Test"); return "Test"; });
}
else
{
result = breaker.WithSyncCircuitBreaker(() => { Task.Delay(100); return "Test"; });
}
Console.WriteLine(result);
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
}
Thread.Sleep(1000);
}
public void Execute_ChangesStateToOpenWhenOperationFails()
{
var failureCount = 0;
var threshold = 1;
Func<int> failFunc = new Func<int>(() => { throw new Exception(); });
var cb = new CircuitBreaker(1000, threshold);
while (failureCount < threshold + 1)
{
try
{
var result = cb.Execute(failFunc);
}
catch (Exception)
{
}
failureCount++;
}
Assert.AreEqual(CircuitBreakerState.Open, cb.State);
}
public double ServiceLevel(string callPattern)
{
var circuitBreaker = new CircuitBreaker();
foreach (var call in callPattern.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
{
switch (call)
{
case "good":
circuitBreaker.Execute(() => { });
break;
case "bad":
try { circuitBreaker.Execute(() => { throw new Exception(); }); }
catch (OperationFailedException) { }
break;
default:
Assert.Fail("Unknown call sequence");
break;
}
}
return circuitBreaker.ServiceLevel;
}
public BinaryDiagnosticPushStream(IPushStream diagnosticOutputStream, CircuitBreaker loggingBreaker)
{
this.diagnosticOutputStream = diagnosticOutputStream;
this.loggingBreaker = loggingBreaker;
this.writer = new BinaryPushStreamWriter(diagnosticOutputStream);
}
public FileConsole(LogConfiguration logConfig, CircuitBreaker loggingBreaker)
{
this.logConfig = logConfig;
this.loggingBreaker = loggingBreaker;
}
public WebApiFilterCircuitBreaker()
{
this.circuitBreaker = new CircuitBreaker(new CircuitBreakerSettings());
}
public void SetUp()
{
cb = new CircuitBreaker();
}
public CState(CircuitBreaker b)
{
_breaker = b;
}
public Half_OpenState(CircuitBreaker c) : base(c)
{
Entry();
}
public CircuitBreakerTests()
{
_sut = new CircuitBreaker(TaskScheduler.Default, MaxFailures, Timeout, ResetTimeout);
}
public ActorEmail(IServiceScopeFactory scopeFactory, CircuitBreaker breaker)
: base(scopeFactory, breaker)
{
}
private static void DeleteCircuitBreaker(CircuitBreaker circuitBreaker)
{
circuitBreaker.ParentSubstation.CircuitBreakers.Remove(circuitBreaker);
}
//================================================================================================//
/// <summary>
/// Initialization when simulation starts with moving train
/// <\summary>
public override void InitializeMoving()
{
base.InitializeMoving();
CircuitBreaker.InitializeMoving();
}
public void GivenIHaveACircuitBreakerWithSettings(Table table)
{
CircuitBreakerSettings settings = table.CreateInstance <CircuitBreakerSettings>();
this.circuitBreaker = new CircuitBreaker(settings);
}
private void ExecuteSucessAction(CircuitBreaker cb)
{
cb.Execute(() => { });
}
public CircuitBreakerStateHalfOpen(CircuitBreaker circuitBreaker)
{
_circuitBreaker = circuitBreaker;
}
