freedakgmail
146 lines
3.1 KiB
Go
146 lines
3.1 KiB
Go
package scheduler
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// CircuitBreaker implements a sliding-window circuit breaker for adapter health.
|
|
type CircuitBreaker struct {
|
|
mu sync.Mutex
|
|
errorRateThreshold float64
|
|
minRequests int
|
|
windowSeconds int
|
|
openDuration time.Duration
|
|
halfOpenMax int
|
|
|
|
// sliding window state
|
|
requests []time.Time
|
|
errors []time.Time
|
|
|
|
// breaker state
|
|
state breakerState
|
|
openedAt time.Time
|
|
halfOpenCount int
|
|
}
|
|
|
|
type breakerState int
|
|
|
|
const (
|
|
breakerClosed breakerState = iota
|
|
breakerOpen
|
|
breakerHalfOpen
|
|
)
|
|
|
|
// NewCircuitBreaker creates a new circuit breaker from config.
|
|
func NewCircuitBreaker(errorRate float64, minRequests, windowSec, openSec, halfOpenMax int) *CircuitBreaker {
|
|
return &CircuitBreaker{
|
|
errorRateThreshold: errorRate,
|
|
minRequests: minRequests,
|
|
windowSeconds: windowSec,
|
|
openDuration: time.Duration(openSec) * time.Second,
|
|
halfOpenMax: halfOpenMax,
|
|
state: breakerClosed,
|
|
}
|
|
}
|
|
|
|
// AllowRequest checks if a request should be allowed through.
|
|
func (cb *CircuitBreaker) AllowRequest() bool {
|
|
cb.mu.Lock()
|
|
defer cb.mu.Unlock()
|
|
|
|
now := time.Now()
|
|
cb.prune(now)
|
|
|
|
switch cb.state {
|
|
case breakerClosed:
|
|
return true
|
|
case breakerOpen:
|
|
if now.Sub(cb.openedAt) >= cb.openDuration {
|
|
cb.state = breakerHalfOpen
|
|
cb.halfOpenCount = 0
|
|
return true
|
|
}
|
|
return false
|
|
case breakerHalfOpen:
|
|
if cb.halfOpenCount < cb.halfOpenMax {
|
|
cb.halfOpenCount++
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
// RecordSuccess records a successful request.
|
|
func (cb *CircuitBreaker) RecordSuccess() {
|
|
cb.mu.Lock()
|
|
defer cb.mu.Unlock()
|
|
|
|
now := time.Now()
|
|
cb.requests = append(cb.requests, now)
|
|
|
|
if cb.state == breakerHalfOpen {
|
|
cb.state = breakerClosed
|
|
cb.requests = nil
|
|
cb.errors = nil
|
|
}
|
|
}
|
|
|
|
// RecordError records a failed request and may trip the breaker.
|
|
func (cb *CircuitBreaker) RecordError() {
|
|
cb.mu.Lock()
|
|
defer cb.mu.Unlock()
|
|
|
|
now := time.Now()
|
|
cb.requests = append(cb.requests, now)
|
|
cb.errors = append(cb.errors, now)
|
|
|
|
if cb.state == breakerHalfOpen {
|
|
cb.state = breakerOpen
|
|
cb.openedAt = now
|
|
return
|
|
}
|
|
|
|
if cb.state == breakerClosed && len(cb.requests) >= cb.minRequests {
|
|
errorRate := float64(len(cb.errors)) / float64(len(cb.requests))
|
|
if errorRate >= cb.errorRateThreshold {
|
|
cb.state = breakerOpen
|
|
cb.openedAt = now
|
|
}
|
|
}
|
|
}
|
|
|
|
// State returns the current breaker state name.
|
|
func (cb *CircuitBreaker) State() string {
|
|
cb.mu.Lock()
|
|
defer cb.mu.Unlock()
|
|
switch cb.state {
|
|
case breakerClosed:
|
|
return "closed"
|
|
case breakerOpen:
|
|
return "open"
|
|
case breakerHalfOpen:
|
|
return "half_open"
|
|
}
|
|
return "unknown"
|
|
}
|
|
|
|
// prune removes entries outside the sliding window.
|
|
func (cb *CircuitBreaker) prune(now time.Time) {
|
|
cutoff := now.Add(-time.Duration(cb.windowSeconds) * time.Second)
|
|
cb.requests = pruneBefore(cb.requests, cutoff)
|
|
cb.errors = pruneBefore(cb.errors, cutoff)
|
|
}
|
|
|
|
func pruneBefore(times []time.Time, cutoff time.Time) []time.Time {
|
|
idx := 0
|
|
for idx < len(times) && times[idx].Before(cutoff) {
|
|
idx++
|
|
}
|
|
if idx > 0 {
|
|
times = times[idx:]
|
|
}
|
|
return times
|
|
}
|