kcenon::monitoring::transaction_manager Class Reference

Transaction manager for coordinating transactions. More...

#include <data_consistency.h>

Collaboration diagram for kcenon::monitoring::transaction_manager:

Public Member Functions
	transaction_manager (const std::string &name, const transaction_config &config)
std::string	get_name () const
common::Result< std::shared_ptr< transaction > >	begin_transaction (const std::string &id)
bool	commit_transaction (const std::string &id)
bool	abort_transaction (const std::string &id)
size_t	active_transaction_count () const
size_t	completed_transaction_count () const
common::Result< std::vector< std::string > >	detect_deadlocks ()
void	cleanup_completed_transactions (std::chrono::milliseconds)
transaction_metrics &	get_metrics ()
const transaction_metrics &	get_metrics () const

Private Attributes
std::string	name_
transaction_config	config_
std::shared_mutex	mutex_
std::unordered_map< std::string, std::shared_ptr< transaction > >	active_transactions_
std::unordered_map< std::string, std::shared_ptr< transaction > >	completed_transactions_
transaction_metrics	metrics_

Detailed Description

Transaction manager for coordinating transactions.

Definition at line 241 of file data_consistency.h.

Constructor & Destructor Documentation

transaction_manager()

kcenon::monitoring::transaction_manager::transaction_manager ( const std::string & name, const transaction_config & config )

inline

Definition at line 243 of file data_consistency.h.

        : name_(name)
        , config_(config) {}

Member Function Documentation

abort_transaction()

bool kcenon::monitoring::transaction_manager::abort_transaction ( const std::string & id )

inline

Definition at line 286 of file data_consistency.h.

                                                {
        std::unique_lock<std::shared_mutex> lock(mutex_);
 
        auto it = active_transactions_.find(id);
        if (it == active_transactions_.end()) {
            return false;
        }
 
        auto tx = it->second;
        active_transactions_.erase(it);
 
        tx->abort();
        metrics_.aborted_transactions++;
        return true;
    }

References kcenon::monitoring::transaction_metrics::aborted_transactions, active_transactions_, metrics_, and mutex_.

Referenced by TEST_F().

Here is the caller graph for this function:

active_transaction_count()

size_t kcenon::monitoring::transaction_manager::active_transaction_count ( ) const

inline

Definition at line 302 of file data_consistency.h.

                                            {
        std::shared_lock<std::shared_mutex> lock(mutex_);
        return active_transactions_.size();
    }

References active_transactions_, and mutex_.

Referenced by TEST_F().

Here is the caller graph for this function:

begin_transaction()

common::Result< std::shared_ptr< transaction > > kcenon::monitoring::transaction_manager::begin_transaction ( const std::string & id )

inline

Definition at line 249 of file data_consistency.h.

                                                                                    {
        std::unique_lock<std::shared_mutex> lock(mutex_);
 
        // Check for duplicate transaction
        if (active_transactions_.find(id) != active_transactions_.end()) {
            return common::make_error<std::shared_ptr<transaction>>(
                static_cast<int>(monitoring_error_code::already_exists),
                "Transaction with ID '" + id + "' already exists");
        }
 
        auto tx = std::make_shared<transaction>(id, config_);
        active_transactions_[id] = tx;
        metrics_.total_transactions++;
        return common::ok(tx);
    }

References active_transactions_, kcenon::monitoring::already_exists, config_, metrics_, mutex_, and kcenon::monitoring::transaction_metrics::total_transactions.

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

cleanup_completed_transactions()

void kcenon::monitoring::transaction_manager::cleanup_completed_transactions ( std::chrono::milliseconds )

inline

Definition at line 330 of file data_consistency.h.

                                                                 {
        std::unique_lock<std::shared_mutex> lock(mutex_);
        completed_transactions_.clear();
    }

References completed_transactions_, and mutex_.

Referenced by TEST_F().

Here is the caller graph for this function:

commit_transaction()

bool kcenon::monitoring::transaction_manager::commit_transaction ( const std::string & id )

inline

Definition at line 265 of file data_consistency.h.

                                                 {
        std::unique_lock<std::shared_mutex> lock(mutex_);
 
        auto it = active_transactions_.find(id);
        if (it == active_transactions_.end()) {
            return false;
        }
 
        auto tx = it->second;
        active_transactions_.erase(it);
 
        bool success = tx->commit();
        if (success) {
            metrics_.committed_transactions++;
            completed_transactions_[id] = tx;
        } else {
            metrics_.aborted_transactions++;
        }
        return success;
    }

References kcenon::monitoring::transaction_metrics::aborted_transactions, active_transactions_, kcenon::monitoring::transaction_metrics::committed_transactions, completed_transactions_, metrics_, mutex_, and kcenon::monitoring::success.

Referenced by TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

completed_transaction_count()

size_t kcenon::monitoring::transaction_manager::completed_transaction_count ( ) const

inline

Definition at line 307 of file data_consistency.h.

                                               {
        std::shared_lock<std::shared_mutex> lock(mutex_);
        return completed_transactions_.size();
    }

References completed_transactions_, and mutex_.

Referenced by TEST_F(), and TEST_F().

Here is the caller graph for this function:

detect_deadlocks()

common::Result< std::vector< std::string > > kcenon::monitoring::transaction_manager::detect_deadlocks ( )

inline

Definition at line 312 of file data_consistency.h.

                                                          {
        std::shared_lock<std::shared_mutex> lock(mutex_);
 
        std::vector<std::string> deadlocked;
        auto now = std::chrono::steady_clock::now();
 
        for (const auto& [id, tx] : active_transactions_) {
            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
                now - tx->creation_time());
            if (elapsed > config_.timeout) {
                deadlocked.push_back(id);
                metrics_.deadlocks_detected++;
            }
        }
 
        return common::ok(deadlocked);
    }

References active_transactions_, config_, kcenon::monitoring::transaction_metrics::deadlocks_detected, metrics_, mutex_, and kcenon::monitoring::transaction_config::timeout.

Referenced by TEST_F().

Here is the caller graph for this function:

get_metrics() [1/2]

transaction_metrics & kcenon::monitoring::transaction_manager::get_metrics ( )

inline

Definition at line 335 of file data_consistency.h.

{ return metrics_; }

References metrics_.

Referenced by TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

get_metrics() [2/2]

const transaction_metrics & kcenon::monitoring::transaction_manager::get_metrics ( ) const

inline

Definition at line 336 of file data_consistency.h.

{ return metrics_; }

References metrics_.

get_name()

std::string kcenon::monitoring::transaction_manager::get_name ( ) const

inline

Definition at line 247 of file data_consistency.h.

{ return name_; }

References name_.

Member Data Documentation

active_transactions_

std::unordered_map<std::string, std::shared_ptr<transaction> > kcenon::monitoring::transaction_manager::active_transactions_

private

Definition at line 342 of file data_consistency.h.

Referenced by abort_transaction(), active_transaction_count(), begin_transaction(), commit_transaction(), and detect_deadlocks().

completed_transactions_

std::unordered_map<std::string, std::shared_ptr<transaction> > kcenon::monitoring::transaction_manager::completed_transactions_

private

Definition at line 343 of file data_consistency.h.

Referenced by cleanup_completed_transactions(), commit_transaction(), and completed_transaction_count().

config_

transaction_config kcenon::monitoring::transaction_manager::config_

private

Definition at line 340 of file data_consistency.h.

Referenced by begin_transaction(), and detect_deadlocks().

metrics_

transaction_metrics kcenon::monitoring::transaction_manager::metrics_

private

Definition at line 344 of file data_consistency.h.

Referenced by abort_transaction(), begin_transaction(), commit_transaction(), detect_deadlocks(), get_metrics(), and get_metrics().

mutex_

std::shared_mutex kcenon::monitoring::transaction_manager::mutex_

mutableprivate

Definition at line 341 of file data_consistency.h.

Referenced by abort_transaction(), active_transaction_count(), begin_transaction(), cleanup_completed_transactions(), commit_transaction(), completed_transaction_count(), and detect_deadlocks().

name_

std::string kcenon::monitoring::transaction_manager::name_

private

Definition at line 339 of file data_consistency.h.

Referenced by get_name().

---

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

• include/kcenon/monitoring/reliability/data_consistency.h