leaderKeyStorage.h

Go to the documentation of this file.

#ifndef LEADER_KEY_STORAGE_H
#define LEADER_KEY_STORAGE_H
 
#include <mutex>
#include <array>
#include <atomic>
#include <chrono>
#include <cstdint>
#include <cstdio>
#include "api/network/ethernet.h"
#include "api/util/debug.h"
#include "api/traits.h"
 
// Define MAC key type
using MacKeyType = std::array<uint8_t, 16>;
 
class LeaderKeyStorage {
public:
    static LeaderKeyStorage& getInstance();
    void setLeaderId(const Ethernet::Address& leader_id);
    Ethernet::Address getLeaderId() const;
    void setGroupMacKey(const MacKeyType& key);
    MacKeyType getGroupMacKey() const;
    std::chrono::steady_clock::time_point getLastUpdateTime() const;
 
private:
    LeaderKeyStorage();
    ~LeaderKeyStorage() = default;
    LeaderKeyStorage(const LeaderKeyStorage&) = delete;
    LeaderKeyStorage& operator=(const LeaderKeyStorage&) = delete;
 
    mutable std::mutex _mutex;
    Ethernet::Address _current_leader_id;
    MacKeyType _current_group_mac_key;
    std::atomic<std::chrono::steady_clock::time_point> _last_update_time;
};
 
// Implementation
 
inline LeaderKeyStorage& LeaderKeyStorage::getInstance() {
    static LeaderKeyStorage instance;
    return instance;
}
 
inline void LeaderKeyStorage::setLeaderId(const Ethernet::Address& leader_id) {
    std::lock_guard<std::mutex> lock(_mutex);
    if (_current_leader_id != leader_id) {
        db<LeaderKeyStorage>(INF) << "LeaderKeyStorage: Leader changed from " 
            << Ethernet::mac_to_string(_current_leader_id) << " to " 
            << Ethernet::mac_to_string(leader_id) << "\n";
        _current_leader_id = leader_id;
        _last_update_time.store(std::chrono::steady_clock::now(), std::memory_order_release);
    }
}
 
inline Ethernet::Address LeaderKeyStorage::getLeaderId() const {
    std::lock_guard<std::mutex> lock(_mutex);
    return _current_leader_id;
}
 
inline void LeaderKeyStorage::setGroupMacKey(const MacKeyType& key) {
    std::lock_guard<std::mutex> lock(_mutex);
    if (_current_group_mac_key != key) {
        // Debug logging: Show old and new keys
        std::string old_key_hex = "";
        for (size_t i = 0; i < 16; ++i) {
            char hex_byte[4];
            snprintf(hex_byte, sizeof(hex_byte), "%02X ", _current_group_mac_key[i]);
            old_key_hex += hex_byte;
        }
        std::string new_key_hex = "";
        for (size_t i = 0; i < 16; ++i) {
            char hex_byte[4];
            snprintf(hex_byte, sizeof(hex_byte), "%02X ", key[i]);
            new_key_hex += hex_byte;
        }
        
        db<LeaderKeyStorage>(INF) << "LeaderKeyStorage: Group MAC key updated\n";
        db<LeaderKeyStorage>(INF) << "LeaderKeyStorage: Old key: " << old_key_hex << "\n";
        db<LeaderKeyStorage>(INF) << "LeaderKeyStorage: New key: " << new_key_hex << "\n";
        _current_group_mac_key = key;
        _last_update_time.store(std::chrono::steady_clock::now(), std::memory_order_release);
    }
}
 
inline MacKeyType LeaderKeyStorage::getGroupMacKey() const {
    std::lock_guard<std::mutex> lock(_mutex);
    
    // Debug logging: Show the key being retrieved
    std::string key_hex = "";
    for (size_t i = 0; i < 16; ++i) {
        char hex_byte[4];
        snprintf(hex_byte, sizeof(hex_byte), "%02X ", _current_group_mac_key[i]);
        key_hex += hex_byte;
    }
    db<LeaderKeyStorage>(TRC) << "LeaderKeyStorage: Retrieved key: " << key_hex << "\n";
    
    return _current_group_mac_key;
}
 
inline std::chrono::steady_clock::time_point LeaderKeyStorage::getLastUpdateTime() const {
    return _last_update_time.load(std::memory_order_acquire);
}
 
inline LeaderKeyStorage::LeaderKeyStorage() : 
    _current_leader_id(Ethernet::NULL_ADDRESS),
    _last_update_time(std::chrono::steady_clock::now()) { 
    _current_group_mac_key.fill(0);
    db<LeaderKeyStorage>(INF) << "LeaderKeyStorage: Initialized\n";
}
 
#endif // LEADER_KEY_STORAGE_H