Circuit Breaker

import java.util.function.Supplier;

class CircuitBreaker {
    enum State { CLOSED, OPEN, HALF_OPEN }

    private final int failureThreshold;
    private final double coolDownSeconds;
    private State state = State.CLOSED;
    private int failures = 0;
    private double openedAt = 0;

    CircuitBreaker(int failureThreshold, double coolDownSeconds) {
        this.failureThreshold = failureThreshold;
        this.coolDownSeconds = coolDownSeconds;
    }

    synchronized State state(double now) {
        if (state == State.OPEN && now - openedAt >= coolDownSeconds) {
            state = State.HALF_OPEN;
        }
        return state;
    }

    // call returns null on failure; fallback is used when the call fails or is blocked.
    synchronized String call(Supplier<String> call, String fallback, double now) {
        if (state(now) == State.OPEN) {
            return fallback;                  // fail fast, dependency untouched
        }
        String result = call.get();
        if (result != null) {
            failures = 0;
            state = State.CLOSED;
            return result;
        }
        failures++;
        if (state == State.HALF_OPEN || failures >= failureThreshold) {
            state = State.OPEN;
            openedAt = now;
        }
        return fallback;
    }
}

import threading

class CircuitBreaker:
    def __init__(self, failure_threshold, cool_down_seconds):
        self.threshold = failure_threshold
        self.cool_down = cool_down_seconds
        self._state = "closed"
        self.failures = 0
        self.opened_at = 0
        self.lock = threading.Lock()

    def state(self, now):
        if self._state == "open" and now - self.opened_at >= self.cool_down:
            self._state = "half-open"
        return self._state

    def call(self, fn, fallback, now):
        """fn returns None on failure; fallback is used when the call fails or is blocked."""
        with self.lock:
            if self.state(now) == "open":
                return fallback               # fail fast, dependency untouched
            result = fn()
            if result is not None:
                self.failures = 0
                self._state = "closed"
                return result
            self.failures += 1
            if self._state == "half-open" or self.failures >= self.threshold:
                self._state = "open"
                self.opened_at = now
            return fallback