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