Mining/pkg/mining/circuit_breaker.go

package mining

import (
	"sync"
	"time"

	"forge.lthn.ai/Snider/Mining/pkg/logging"
)

// if cb.State() == CircuitClosed { /* requests are flowing normally */ }
// if cb.State() == CircuitOpen { /* circuit tripped; requests are rejected */ }
// if cb.State() == CircuitHalfOpen { /* probe request allowed; awaiting SuccessThreshold */ }
type CircuitState int

const (
	CircuitClosed   CircuitState = iota
	CircuitOpen
	CircuitHalfOpen
)

func (s CircuitState) String() string {
	switch s {
	case CircuitClosed:
		return "closed"
	case CircuitOpen:
		return "open"
	case CircuitHalfOpen:
		return "half-open"
	default:
		return "unknown"
	}
}

// CircuitBreakerConfig{FailureThreshold: 3, ResetTimeout: 30 * time.Second, SuccessThreshold: 1}
type CircuitBreakerConfig struct {
	FailureThreshold int
	ResetTimeout     time.Duration
	SuccessThreshold int
}

// configuration := DefaultCircuitBreakerConfig()
// cb := NewCircuitBreaker("github-api", configuration)
func DefaultCircuitBreakerConfig() CircuitBreakerConfig {
	return CircuitBreakerConfig{
		FailureThreshold: 3,
		ResetTimeout:     30 * time.Second,
		SuccessThreshold: 1,
	}
}

// cb := NewCircuitBreaker("github-api", DefaultCircuitBreakerConfig())
// result, err := cb.Execute(func() (interface{}, error) { return fetchStats(ctx) })
type CircuitBreaker struct {
	name           string
	config         CircuitBreakerConfig
	state          CircuitState
	failures       int
	successes      int
	lastFailure    time.Time
	mutex          sync.RWMutex
	cachedResult   interface{}
	cachedErr      error
	lastCacheTime  time.Time
	cacheDuration  time.Duration
}

// ErrCircuitOpen is returned when the circuit is open
// if err == ErrCircuitOpen { /* fallback to cached result */ }
var ErrCircuitOpen = NewMiningError(ErrCodeServiceUnavailable, "circuit breaker is open")

// cb := NewCircuitBreaker("github-api", DefaultCircuitBreakerConfig())
func NewCircuitBreaker(name string, config CircuitBreakerConfig) *CircuitBreaker {
	return &CircuitBreaker{
		name:          name,
		config:        config,
		state:         CircuitClosed,
		cacheDuration: 5 * time.Minute, // Cache successful results for 5 minutes
	}
}

// if cb.State() == CircuitOpen { return nil, ErrCircuitOpen }
func (cb *CircuitBreaker) State() CircuitState {
	cb.mutex.RLock()
	defer cb.mutex.RUnlock()
	return cb.state
}

// result, err := cb.Execute(func() (interface{}, error) { return fetchStats(ctx) })
func (cb *CircuitBreaker) Execute(fn func() (interface{}, error)) (interface{}, error) {
	// Check if we should allow this request
	if !cb.allowRequest() {
		// Return cached result if available
		cb.mutex.RLock()
		if cb.cachedResult != nil && time.Since(cb.lastCacheTime) < cb.cacheDuration {
			result := cb.cachedResult
			cb.mutex.RUnlock()
			logging.Debug("circuit breaker returning cached result", logging.Fields{
				"name":  cb.name,
				"state": cb.state.String(),
			})
			return result, nil
		}
		cb.mutex.RUnlock()
		return nil, ErrCircuitOpen
	}

	// Execute the function
	result, err := fn()

	// Record the result
	if err != nil {
		cb.recordFailure()
	} else {
		cb.recordSuccess(result)
	}

	return result, err
}

// if cb.allowRequest() { /* execute the function */ }
func (cb *CircuitBreaker) allowRequest() bool {
	cb.mutex.Lock()
	defer cb.mutex.Unlock()

	switch cb.state {
	case CircuitClosed:
		return true

	case CircuitOpen:
		// Check if we should transition to half-open
		if time.Since(cb.lastFailure) > cb.config.ResetTimeout {
			cb.state = CircuitHalfOpen
			cb.successes = 0
			logging.Info("circuit breaker transitioning to half-open", logging.Fields{
				"name": cb.name,
			})
			return true
		}
		return false

	case CircuitHalfOpen:
		// Allow probe requests through
		return true

	default:
		return false
	}
}

// cb.recordFailure() // increments failures; opens circuit after FailureThreshold is reached
func (cb *CircuitBreaker) recordFailure() {
	cb.mutex.Lock()
	defer cb.mutex.Unlock()

	cb.failures++
	cb.lastFailure = time.Now()

	switch cb.state {
	case CircuitClosed:
		if cb.failures >= cb.config.FailureThreshold {
			cb.state = CircuitOpen
			logging.Warn("circuit breaker opened", logging.Fields{
				"name":     cb.name,
				"failures": cb.failures,
			})
		}

	case CircuitHalfOpen:
		// Probe failed, back to open
		cb.state = CircuitOpen
		logging.Warn("circuit breaker probe failed, reopening", logging.Fields{
			"name": cb.name,
		})
	}
}

// cb.recordSuccess(stats) // caches result, resets failures; in HalfOpen closes the circuit after SuccessThreshold
func (cb *CircuitBreaker) recordSuccess(result interface{}) {
	cb.mutex.Lock()
	defer cb.mutex.Unlock()

	// Cache the successful result
	cb.cachedResult = result
	cb.lastCacheTime = time.Now()
	cb.cachedErr = nil

	switch cb.state {
	case CircuitClosed:
		// Reset failure count on success
		cb.failures = 0

	case CircuitHalfOpen:
		cb.successes++
		if cb.successes >= cb.config.SuccessThreshold {
			cb.state = CircuitClosed
			cb.failures = 0
			logging.Info("circuit breaker closed after successful probe", logging.Fields{
				"name": cb.name,
			})
		}
	}
}

// cb.Reset() // force closed state after maintenance window
func (cb *CircuitBreaker) Reset() {
	cb.mutex.Lock()
	defer cb.mutex.Unlock()

	cb.state = CircuitClosed
	cb.failures = 0
	cb.successes = 0
	logging.Debug("circuit breaker manually reset", logging.Fields{
		"name": cb.name,
	})
}

// if result, ok := cb.GetCached(); ok { return result, nil }
func (cb *CircuitBreaker) GetCached() (interface{}, bool) {
	cb.mutex.RLock()
	defer cb.mutex.RUnlock()

	if cb.cachedResult != nil && time.Since(cb.lastCacheTime) < cb.cacheDuration {
		return cb.cachedResult, true
	}
	return nil, false
}

// Global circuit breaker for GitHub API
var (
	githubCircuitBreaker     *CircuitBreaker
	githubCircuitBreakerOnce sync.Once
)

// cb := getGitHubCircuitBreaker()
// result, err := cb.Execute(func() (interface{}, error) { return fetchLatestVersion(ctx) })
func getGitHubCircuitBreaker() *CircuitBreaker {
	githubCircuitBreakerOnce.Do(func() {
		githubCircuitBreaker = NewCircuitBreaker("github-api", CircuitBreakerConfig{
			FailureThreshold: 3,
			ResetTimeout:     60 * time.Second, // Wait 1 minute before retrying
			SuccessThreshold: 1,
		})
	})
	return githubCircuitBreaker
}