The presentation for the Swift Cloud Workshop 3 talk on Circuit Breakers with Swift.

1. Circuit Breakers with Swift ⚡
Swift Cloud Workshop 3
Manny Guerrero
(@SwiftyGuerrero)

2. Agenda
• History of Circuit Breakers 🧐
• How a Circuit Breaker Works 🔍
• Advantages/Disadvantages with Swift 😕
• Implementation in Swift 🛠
• Demo 🏎
• Q & A 🚀

3. History of Circuit Breakers
• Early beginnings in electrical engineering
• Was popularized in software by Michael T. Nygard

4. How a Circuit Breaker Works

5. Advantages/Disadvantages with Swift
Advantages:
• Reduces CPU resources
• Can protect parts of a system from failures in other
parts
• Easy monitoring of the state
Disadvantages:
• Managing the state can be difficult if OOP isn’t
being used.
• Need to use specific Timer APIs

6. Implementation in Swift
enum BreakerState {
case open
case halfOpened
case closed
}

7. Implementation in Swift
enum BreakerState {
case open
case halfOpened
case closed
}
class CircuitBreaker {
}

8. Implementation in Swift
enum BreakerState {
case open
case halfOpened
case closed
}
class CircuitBreaker {
var state: BreakerState {
return .closed
}
}

9. Implementation in Swift
enum BreakerState {
case open
case halfOpened
case closed
}
class CircuitBreaker {
var state: BreakerState {
return .closed
}
var workToPerform: ((CircuitBreaker) -> Void)?
var tripped: ((CircuitBreaker, Error?) -> Void)?
}

10. Implementation in Swift
enum BreakerState {
case open
case halfOpened
case closed
}
class CircuitBreaker {
var state: BreakerState {
return .closed
}
var workToPerform: ((CircuitBreaker) -> Void)?
var tripped: ((CircuitBreaker, Error?) -> Void)?
let maxFailures: Int
let timeout: TimeInterval
let retryDelay: TimeInterval
}

11. Implementation in Swift
enum BreakerState {
case open
case halfOpened
case closed
}
class CircuitBreaker {
var state: BreakerState {
return .closed
}
var workToPerform: ((CircuitBreaker) -> Void)?
var tripped: ((CircuitBreaker, Error?) -> Void)?
let maxFailures: Int
let timeout: TimeInterval
let retryDelay: TimeInterval
private var lastFailureTime: TimeInterval?
private var lastError: Error?
private var scheduler: Scheduler?
}

12. Implementation in Swift
enum BreakerState {
case open
case halfOpened
case closed
}
class CircuitBreaker {
var state: BreakerState {
if let lastFailureTime = self.lastFailureTime,
failureCount > maxFailures &&
(Date().timeIntervalSince1970 - lastFailureTime) > retryDelay {
return .halfOpened
}
if failureCount == maxFailures {
return .open
}
return .closed
}
var workToPerform: ((CircuitBreaker) -> Void)?
var tripped: ((CircuitBreaker, Error?) -> Void)?
let maxFailures: Int
let timeout: TimeInterval
let retryDelay: TimeInterval
private var lastFailureTime: TimeInterval?
private var lastError: Error?
private var scheduler: Scheduler?
}

13. Implementation in Swift
enum BreakerState {
case open
case halfOpened
case closed
}
class CircuitBreaker {
var state: BreakerState {
if let lastFailureTime = self.lastFailureTime,
failureCount > maxFailures &&
(Date().timeIntervalSince1970 - lastFailureTime) > retryDelay {
return .halfOpened
}
if failureCount == maxFailures {
return .open
}
return .closed
}
var workToPerform: ((CircuitBreaker) -> Void)?
var tripped: ((CircuitBreaker, Error?) -> Void)?
let maxFailures: Int
let timeout: TimeInterval
let retryDelay: TimeInterval
private var lastFailureTime: TimeInterval?
private var lastError: Error?
private var scheduler: Scheduler?
init(timeout: TimeInterval = 10, maxFailures: Int = 3, retryDelay: TimeInterval = 2) {
self.timeout = timeout
self.maxFailures = maxFailures
self.retryDelay = retryDelay
}
deinit {
scheduler?.suspend()
scheduler = nil
}
}

14. Implementation in Swift
extension CircuitBreaker {
func start() {
switch state {
case .open:
tripCircuit()
case .halfOpened, .closed:
beginWork()
}
}
}

15. Implementation in Swift
extension CircuitBreaker {
func start() {
switch state {
case .open:
tripCircuit()
case .halfOpened, .closed:
beginWork()
}
}
}
private extension CircuitBreaker {
func tripCircuit() {
tripped?(self, lastError)
reset()
}
func beginWork() {
scheduler?.suspend()
startTimeoutTimer()
workToPerform?(self)
}
}

16. Implementation in Swift
extension CircuitBreaker {
func start() {
switch state {
case .open:
tripCircuit()
case .halfOpened, .closed:
beginWork()
}
}
func reset() {
scheduler?.suspend()
failureCount = 0
lastFailureTime = nil
lastError = nil
}
}
private extension CircuitBreaker {
func tripCircuit() {
tripped?(self, lastError)
reset()
}
func beginWork() {
scheduler?.suspend()
startTimeoutTimer()
workToPerform?(self)
}
}
private extension CircuitBreaker {
func startTimeoutTimer() {
scheduler?.suspend()
scheduler = Scheduler(startTime: timeout)
scheduler?.task = { [weak self] in
self?.failure()
}
scheduler?.resume()
}
}

17. Implementation in Swift
extension CircuitBreaker {
func failure(error: Error? = nil) {
scheduler?.suspend()
lastError = error
failureCount += 1
lastFailureTime = Date().timeIntervalSince1970
switch state {
case .open:
tripCircuit()
break
case .halfOpened, .closed:
startRetryDelayTimer()
break
}
}
}

18. Implementation in Swift
private extension CircuitBreaker {
func startTimeoutTimer() {
scheduler?.suspend()
scheduler = Scheduler(startTime: timeout)
scheduler?.task = { [weak self] in
self?.failure()
}
scheduler?.resume()
}
func startRetryDelayTimer() {
scheduler?.suspend()
scheduler = Scheduler(startTime: retryDelay)
scheduler?.task = { [weak self] in
self?.beginWork()
}
scheduler?.resume()
}
}

19. Implementation in Swift
extension CircuitBreaker {
func success() {
reset()
}
func failure(error: Error? = nil) {
scheduler?.suspend()
lastError = error
failureCount += 1
lastFailureTime = Date().timeIntervalSince1970
switch state {
case .open:
tripCircuit()
break
case .halfOpened, .closed:
startRetryDelayTimer()
break
}
}
}

20. Implementation in Swift
final class Scheduler {
var task: (() -> Void)?
private enum TimerState {
case suspended
case resumed
}
private var timerState: TimerState = .suspended
private let startTime: TimeInterval
private lazy var timer: DispatchSourceTimer = {
let dispatchTimer = DispatchSource.makeTimerSource()
let time: DispatchTime = .now() + startTime
dispatchTimer.schedule(deadline: time)
dispatchTimer.setEventHandler { [weak self] in
self?.task?()
}
return dispatchTimer
}()
init(startTime: TimeInterval) {
self.startTime = startTime
}
deinit {
timer.setEventHandler {}
timer.cancel()
timer.resume()
task = nil
}
}
extension Scheduler {
func resume() {
if timerState == .resumed { return }
timerState = .resumed
timer.resume()
}
func suspend() {
if timerState == .suspended { return }
timerState = .suspended
timer.suspend()
}
}

21. Lets Demo Our Implementation 🏎

22. IBM-Swift’s Circuit Breaker
• Provides a heavy duty implementation
• Provides advanced configuration
• Provides a snapshot of the circuit
breaker state
• Can plug in with SwiftMetrics

23. Lets Demo IBM-Swift’s CircuitBreaker 🏎

24. Resources
• SGCircuitBreaker: https://github.com/eman6576/SGCircuitBreaker
• Demos: https://github.com/eman6576/CircuitBreakerTime
• IBM-Swift CircuitBreaker: https://github.com/IBM-Swift/CircuitBreaker

25. Q & A 🚀

26. Thanks 🎉