kcenon::thread::circuit_breaker_policy Class Reference

Pool policy that implements circuit breaker pattern for failure protection. More...

#include <circuit_breaker_policy.h>

Inheritance diagram for kcenon::thread::circuit_breaker_policy:

Collaboration diagram for kcenon::thread::circuit_breaker_policy:

Public Member Functions
	circuit_breaker_policy (const circuit_breaker_config &config={})
	Constructs a circuit breaker policy with the given configuration.
	circuit_breaker_policy (std::shared_ptr< circuit_breaker > cb)
	Constructs a circuit breaker policy with an existing circuit breaker.
	~circuit_breaker_policy () override=default
	Destructor.
	circuit_breaker_policy (const circuit_breaker_policy &)=delete
circuit_breaker_policy &	operator= (const circuit_breaker_policy &)=delete
	circuit_breaker_policy (circuit_breaker_policy &&)=delete
circuit_breaker_policy &	operator= (circuit_breaker_policy &&)=delete
auto	on_enqueue (job &j) -> common::VoidResult override
	Checks circuit state before allowing job enqueue.
void	on_job_start (job &j) override
	Called when job starts executing.
void	on_job_complete (job &j, bool success, const std::exception *error=nullptr) override
	Records job completion in the circuit breaker.
auto	get_name () const -> std::string override
	Gets the policy name.
auto	is_enabled () const -> bool override
	Checks if the policy is enabled.
void	set_enabled (bool enabled) override
	Enables or disables the policy.
auto	is_accepting_work () const -> bool
	Checks if the circuit is accepting work.
auto	get_state () const -> circuit_state
	Gets the current circuit state.
auto	get_circuit_breaker () const -> std::shared_ptr< circuit_breaker >
	Gets the underlying circuit breaker.
Public Member Functions inherited from kcenon::thread::pool_policy
virtual	~pool_policy ()=default
	Virtual destructor for proper cleanup.

Private Attributes
std::shared_ptr< circuit_breaker >	circuit_breaker_
std::atomic< bool >	enabled_ {true}

Detailed Description

Pool policy that implements circuit breaker pattern for failure protection.

This policy wraps the circuit breaker functionality as a composable pool policy, enabling circuit breaker protection without modifying the thread_pool class.

Circuit Breaker Pattern

The circuit breaker monitors job failures and automatically opens when a threshold is exceeded, preventing cascading failures:

• CLOSED: Normal operation, all jobs allowed
• OPEN: Failure threshold exceeded, jobs rejected immediately
• HALF_OPEN: Testing recovery, limited jobs allowed

Thread Safety

All methods are thread-safe and can be called from any thread.

Usage Example

circuit_breaker_config config;
config.failure_threshold = 5;
config.open_duration = std::chrono::seconds{30};
 
auto cb_policy = std::make_unique<circuit_breaker_policy>(config);
pool->add_policy(std::move(cb_policy));
 
// Now all jobs are protected by the circuit breaker
// Jobs will be rejected when circuit is open

See also

pool_policy

circuit_breaker

circuit_breaker_config

Definition at line 66 of file circuit_breaker_policy.h.

Constructor & Destructor Documentation

circuit_breaker_policy() [1/4]

kcenon::thread::circuit_breaker_policy::circuit_breaker_policy ( const circuit_breaker_config & config = {} )

explicit

Constructs a circuit breaker policy with the given configuration.

Parameters

config

Circuit breaker configuration.

Definition at line 12 of file circuit_breaker_policy.cpp.

    : circuit_breaker_(std::make_shared<circuit_breaker>(config))
{
}

circuit_breaker_policy() [2/4]

kcenon::thread::circuit_breaker_policy::circuit_breaker_policy ( std::shared_ptr< circuit_breaker > cb )

explicit

Constructs a circuit breaker policy with an existing circuit breaker.

Parameters

cb	Shared pointer to an existing circuit breaker.

This allows sharing a circuit breaker across multiple pools or components.

Definition at line 17 of file circuit_breaker_policy.cpp.

    : circuit_breaker_(std::move(cb))
{
    if (!circuit_breaker_) {
        // Create default circuit breaker if nullptr passed
        circuit_breaker_ = std::make_shared<circuit_breaker>();
    }
}

References circuit_breaker_.

~circuit_breaker_policy()

kcenon::thread::circuit_breaker_policy::~circuit_breaker_policy ( )

overridedefault

Destructor.

circuit_breaker_policy() [3/4]

kcenon::thread::circuit_breaker_policy::circuit_breaker_policy ( const circuit_breaker_policy & )

delete

circuit_breaker_policy() [4/4]

kcenon::thread::circuit_breaker_policy::circuit_breaker_policy ( circuit_breaker_policy && )

delete

Member Function Documentation

get_circuit_breaker()

auto kcenon::thread::circuit_breaker_policy::get_circuit_breaker ( ) const -> std::shared_ptr<circuit_breaker>

nodiscard

Gets the underlying circuit breaker.

Returns

Shared pointer to the circuit breaker.

Useful for sharing the circuit breaker with other components or for advanced circuit breaker operations.

Definition at line 100 of file circuit_breaker_policy.cpp.

{
    return circuit_breaker_;
}

References circuit_breaker_.

get_name()

auto kcenon::thread::circuit_breaker_policy::get_name ( ) const -> std::string

nodiscardoverridevirtual

Gets the policy name.

Returns

"circuit_breaker_policy"

Implements kcenon::thread::pool_policy.

Definition at line 70 of file circuit_breaker_policy.cpp.

{
    return "circuit_breaker_policy";
}

get_state()

auto kcenon::thread::circuit_breaker_policy::get_state ( ) const -> circuit_state

nodiscard

Gets the current circuit state.

Returns

Current circuit_state.

Definition at line 95 of file circuit_breaker_policy.cpp.

{
    return circuit_breaker_->get_state();
}

References circuit_breaker_.

is_accepting_work()

auto kcenon::thread::circuit_breaker_policy::is_accepting_work ( ) const -> bool

nodiscard

Checks if the circuit is accepting work.

Returns

True if circuit is closed or half-open with capacity.

Definition at line 85 of file circuit_breaker_policy.cpp.

{
    if (!enabled_.load(std::memory_order_acquire)) {
        return true;  // If disabled, always accept
    }
 
    auto state = circuit_breaker_->get_state();
    return state != circuit_state::OPEN;
}

References circuit_breaker_, and enabled_.

is_enabled()

auto kcenon::thread::circuit_breaker_policy::is_enabled ( ) const -> bool

nodiscardoverridevirtual

Checks if the policy is enabled.

Returns

True if enabled.

Reimplemented from kcenon::thread::pool_policy.

Definition at line 75 of file circuit_breaker_policy.cpp.

{
    return enabled_.load(std::memory_order_acquire);
}

References enabled_.

on_enqueue()

auto kcenon::thread::circuit_breaker_policy::on_enqueue ( job & j ) -> common::VoidResult

overridevirtual

Checks circuit state before allowing job enqueue.

Parameters

j	Reference to the job being enqueued.

Returns

common::ok() if allowed, error if circuit is open.

When the circuit is open, jobs are rejected immediately with an error indicating the circuit breaker state.

Implements kcenon::thread::pool_policy.

Definition at line 26 of file circuit_breaker_policy.cpp.

{
    (void)j;  // Job not used, policy applies to all jobs equally
 
    if (!enabled_.load(std::memory_order_acquire)) {
        return common::ok();
    }
 
    // Check if circuit breaker allows the request
    if (!circuit_breaker_->allow_request()) {
        auto state = circuit_breaker_->get_state();
        if (state == circuit_state::OPEN) {
            return make_error_result(error_code::circuit_open,
                                     "Circuit breaker is open, job rejected");
        }
        // half_open state but at capacity
        return make_error_result(error_code::circuit_half_open,
                                 "Circuit breaker is half-open and at capacity");
    }
 
    return common::ok();
}

References kcenon::thread::circuit_half_open, kcenon::thread::circuit_open, and kcenon::thread::make_error_result().

Here is the call graph for this function:

on_job_complete()

void kcenon::thread::circuit_breaker_policy::on_job_complete ( job & j, bool success, const std::exception * error = nullptr )

overridevirtual

Records job completion in the circuit breaker.

Parameters

j	Reference to the completed job.
success	True if job succeeded.
error	Exception pointer if job failed.

This updates the circuit breaker state based on success/failure.

Implements kcenon::thread::pool_policy.

Definition at line 55 of file circuit_breaker_policy.cpp.

{
    (void)j;  // Job not used, policy applies to all jobs equally
 
    if (!enabled_.load(std::memory_order_acquire)) {
        return;
    }
 
    if (success) {
        circuit_breaker_->record_success();
    } else {
        circuit_breaker_->record_failure(error);
    }
}

References circuit_breaker_, enabled_, and kcenon::thread::success.

on_job_start()

void kcenon::thread::circuit_breaker_policy::on_job_start ( job & j )

overridevirtual

Called when job starts executing.

Parameters

j	Reference to the job.

Records the start time for latency tracking.

Implements kcenon::thread::pool_policy.

Definition at line 49 of file circuit_breaker_policy.cpp.

{
    (void)j;  // Currently no action needed on job start
    // Could be extended to track timing in the future
}

operator=() [1/2]

circuit_breaker_policy & kcenon::thread::circuit_breaker_policy::operator= ( circuit_breaker_policy && )

delete

operator=() [2/2]

circuit_breaker_policy & kcenon::thread::circuit_breaker_policy::operator= ( const circuit_breaker_policy & )

delete

set_enabled()

void kcenon::thread::circuit_breaker_policy::set_enabled ( bool enabled )

overridevirtual

Enables or disables the policy.

Parameters

enabled

Whether to enable.

Reimplemented from kcenon::thread::pool_policy.

Definition at line 80 of file circuit_breaker_policy.cpp.

{
    enabled_.store(enabled, std::memory_order_release);
}

References enabled_.

Member Data Documentation

circuit_breaker_

std::shared_ptr<circuit_breaker> kcenon::thread::circuit_breaker_policy::circuit_breaker_

private

Definition at line 172 of file circuit_breaker_policy.h.

Referenced by circuit_breaker_policy(), get_circuit_breaker(), get_state(), is_accepting_work(), and on_job_complete().

enabled_

std::atomic<bool> kcenon::thread::circuit_breaker_policy::enabled_ {true}

private

Definition at line 173 of file circuit_breaker_policy.h.

{true};

Referenced by is_accepting_work(), is_enabled(), on_job_complete(), and set_enabled().

---

The documentation for this class was generated from the following files:

• include/kcenon/thread/pool_policies/circuit_breaker_policy.h
• src/pool_policies/circuit_breaker_policy.cpp