From 263b45db8822d785951f5205cf06aaa5606a6e27 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 2 Apr 2026 17:37:00 +0100 Subject: [PATCH] ax(mining): rename cb receiver to circuitBreaker in CircuitBreaker methods MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit AX Principle 1: predictable names over short names. The receiver abbreviation `cb` required mapping overhead — replaced with the full `circuitBreaker` name across all eight methods in circuit_breaker.go. Co-Authored-By: Charon --- pkg/mining/circuit_breaker.go | 134 +++++++++++++++++----------------- 1 file changed, 67 insertions(+), 67 deletions(-) diff --git a/pkg/mining/circuit_breaker.go b/pkg/mining/circuit_breaker.go index a0f90af..df80d7c 100644 --- a/pkg/mining/circuit_breaker.go +++ b/pkg/mining/circuit_breaker.go @@ -77,29 +77,29 @@ func NewCircuitBreaker(name string, config CircuitBreakerConfig) *CircuitBreaker } } -// if cb.State() == CircuitOpen { return nil, ErrCircuitOpen } -func (cb *CircuitBreaker) State() CircuitState { - cb.mutex.RLock() - defer cb.mutex.RUnlock() - return cb.state +// if circuitBreaker.State() == CircuitOpen { return nil, ErrCircuitOpen } +func (circuitBreaker *CircuitBreaker) State() CircuitState { + circuitBreaker.mutex.RLock() + defer circuitBreaker.mutex.RUnlock() + return circuitBreaker.state } -// result, err := cb.Execute(func() (interface{}, error) { return fetchStats(ctx) }) -func (cb *CircuitBreaker) Execute(fn func() (interface{}, error)) (interface{}, error) { +// result, err := circuitBreaker.Execute(func() (interface{}, error) { return fetchStats(ctx) }) +func (circuitBreaker *CircuitBreaker) Execute(fn func() (interface{}, error)) (interface{}, error) { // Check if we should allow this request - if !cb.allowRequest() { + if !circuitBreaker.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() + circuitBreaker.mutex.RLock() + if circuitBreaker.cachedResult != nil && time.Since(circuitBreaker.lastCacheTime) < circuitBreaker.cacheDuration { + result := circuitBreaker.cachedResult + circuitBreaker.mutex.RUnlock() logging.Debug("circuit breaker returning cached result", logging.Fields{ - "name": cb.name, - "state": cb.state.String(), + "name": circuitBreaker.name, + "state": circuitBreaker.state.String(), }) return result, nil } - cb.mutex.RUnlock() + circuitBreaker.mutex.RUnlock() return nil, ErrCircuitOpen } @@ -108,30 +108,30 @@ func (cb *CircuitBreaker) Execute(fn func() (interface{}, error)) (interface{}, // Record the result if err != nil { - cb.recordFailure() + circuitBreaker.recordFailure() } else { - cb.recordSuccess(result) + circuitBreaker.recordSuccess(result) } return result, err } -// if cb.allowRequest() { /* execute the function */ } -func (cb *CircuitBreaker) allowRequest() bool { - cb.mutex.Lock() - defer cb.mutex.Unlock() +// if circuitBreaker.allowRequest() { /* execute the function */ } +func (circuitBreaker *CircuitBreaker) allowRequest() bool { + circuitBreaker.mutex.Lock() + defer circuitBreaker.mutex.Unlock() - switch cb.state { + switch circuitBreaker.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 + if time.Since(circuitBreaker.lastFailure) > circuitBreaker.config.ResetTimeout { + circuitBreaker.state = CircuitHalfOpen + circuitBreaker.successes = 0 logging.Info("circuit breaker transitioning to half-open", logging.Fields{ - "name": cb.name, + "name": circuitBreaker.name, }) return true } @@ -146,80 +146,80 @@ func (cb *CircuitBreaker) allowRequest() bool { } } -// cb.recordFailure() // increments failures; opens circuit after FailureThreshold is reached -func (cb *CircuitBreaker) recordFailure() { - cb.mutex.Lock() - defer cb.mutex.Unlock() +// circuitBreaker.recordFailure() // increments failures; opens circuit after FailureThreshold is reached +func (circuitBreaker *CircuitBreaker) recordFailure() { + circuitBreaker.mutex.Lock() + defer circuitBreaker.mutex.Unlock() - cb.failures++ - cb.lastFailure = time.Now() + circuitBreaker.failures++ + circuitBreaker.lastFailure = time.Now() - switch cb.state { + switch circuitBreaker.state { case CircuitClosed: - if cb.failures >= cb.config.FailureThreshold { - cb.state = CircuitOpen + if circuitBreaker.failures >= circuitBreaker.config.FailureThreshold { + circuitBreaker.state = CircuitOpen logging.Warn("circuit breaker opened", logging.Fields{ - "name": cb.name, - "failures": cb.failures, + "name": circuitBreaker.name, + "failures": circuitBreaker.failures, }) } case CircuitHalfOpen: // Probe failed, back to open - cb.state = CircuitOpen + circuitBreaker.state = CircuitOpen logging.Warn("circuit breaker probe failed, reopening", logging.Fields{ - "name": cb.name, + "name": circuitBreaker.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() +// circuitBreaker.recordSuccess(stats) // caches result, resets failures; in HalfOpen closes the circuit after SuccessThreshold +func (circuitBreaker *CircuitBreaker) recordSuccess(result interface{}) { + circuitBreaker.mutex.Lock() + defer circuitBreaker.mutex.Unlock() // Cache the successful result - cb.cachedResult = result - cb.lastCacheTime = time.Now() - cb.cachedErr = nil + circuitBreaker.cachedResult = result + circuitBreaker.lastCacheTime = time.Now() + circuitBreaker.cachedErr = nil - switch cb.state { + switch circuitBreaker.state { case CircuitClosed: // Reset failure count on success - cb.failures = 0 + circuitBreaker.failures = 0 case CircuitHalfOpen: - cb.successes++ - if cb.successes >= cb.config.SuccessThreshold { - cb.state = CircuitClosed - cb.failures = 0 + circuitBreaker.successes++ + if circuitBreaker.successes >= circuitBreaker.config.SuccessThreshold { + circuitBreaker.state = CircuitClosed + circuitBreaker.failures = 0 logging.Info("circuit breaker closed after successful probe", logging.Fields{ - "name": cb.name, + "name": circuitBreaker.name, }) } } } -// cb.Reset() // force closed state after maintenance window -func (cb *CircuitBreaker) Reset() { - cb.mutex.Lock() - defer cb.mutex.Unlock() +// circuitBreaker.Reset() // force closed state after maintenance window +func (circuitBreaker *CircuitBreaker) Reset() { + circuitBreaker.mutex.Lock() + defer circuitBreaker.mutex.Unlock() - cb.state = CircuitClosed - cb.failures = 0 - cb.successes = 0 + circuitBreaker.state = CircuitClosed + circuitBreaker.failures = 0 + circuitBreaker.successes = 0 logging.Debug("circuit breaker manually reset", logging.Fields{ - "name": cb.name, + "name": circuitBreaker.name, }) } -// if result, ok := cb.GetCached(); ok { return result, nil } -func (cb *CircuitBreaker) GetCached() (interface{}, bool) { - cb.mutex.RLock() - defer cb.mutex.RUnlock() +// if result, ok := circuitBreaker.GetCached(); ok { return result, nil } +func (circuitBreaker *CircuitBreaker) GetCached() (interface{}, bool) { + circuitBreaker.mutex.RLock() + defer circuitBreaker.mutex.RUnlock() - if cb.cachedResult != nil && time.Since(cb.lastCacheTime) < cb.cacheDuration { - return cb.cachedResult, true + if circuitBreaker.cachedResult != nil && time.Since(circuitBreaker.lastCacheTime) < circuitBreaker.cacheDuration { + return circuitBreaker.cachedResult, true } return nil, false }