identity_manager.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/config/identity.h>
#include <entropic/types/error.h>
 
#include <atomic>
#include <shared_mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace entropic {
 
struct IdentityManagerConfig {
    size_t max_identities = 64;  
    bool allow_dynamic = true;   
};
 
struct GrammarValidationInterface {
    bool (*has_grammar)(const std::string& key,
                        void* user_data) = nullptr;
    void* user_data = nullptr; 
};
 
struct MCPKeyInterface {
    void (*register_identity)(const std::string& name,
                              void* user_data) = nullptr;
    void (*grant)(const std::string& name, const std::string& pattern,
                  int level, void* user_data) = nullptr;
    bool (*is_enforced)(const std::string& name,
                        void* user_data) = nullptr;
    void (*unregister_identity)(const std::string& name,
                                void* user_data) = nullptr;
    void* user_data = nullptr; 
};
 
class IdentityManager {
public:
    explicit IdentityManager(const IdentityManagerConfig& config);
 
    void set_grammar_interface(const GrammarValidationInterface& iface);
 
    void set_mcp_interface(const MCPKeyInterface& iface);
 
    size_t load_static(const std::vector<IdentityConfig>& identities);
 
    entropic_error_t create(const IdentityConfig& config);
 
    entropic_error_t update(const std::string& name,
                            const IdentityConfig& config);
 
    entropic_error_t destroy(const std::string& name);
 
    const IdentityConfig* get(const std::string& name) const;
 
    bool has(const std::string& name) const;
 
    std::vector<std::string> list() const;
 
    std::vector<const IdentityConfig*> list_routable() const;
 
    size_t count() const;
 
    size_t count_dynamic() const;
 
    bool is_router_dirty() const;
 
    void clear_router_dirty();
 
    void set_in_use_checker(bool (*checker)(const std::string& name,
                                            void* user_data),
                            void* user_data);
 
    void set_cache_invalidator(void (*cb)(void* user_data),
                               void* user_data);
 
private:
    void fire_cache_invalidator();
 
    void (*cache_invalidator_)(void*) = nullptr;
    void* cache_invalidator_data_ = nullptr;
 
    // ── pre-existing private section continues ─────────────
 
 
    std::string validate(const IdentityConfig& config,
                         bool is_update) const;
 
    static std::string validate_name(const std::string& name);
 
    void register_mcp_keys(const IdentityConfig& config);
 
    void unregister_mcp_keys(const std::string& name);
 
    IdentityManagerConfig config_;                              
    GrammarValidationInterface grammar_iface_;                 
    MCPKeyInterface mcp_iface_;                                
 
    std::unordered_map<std::string, IdentityConfig> identities_; 
    mutable std::shared_mutex identities_mutex_;               
 
    std::atomic<bool> router_dirty_{false};                    
 
    bool (*in_use_checker_)(const std::string&, void*) = nullptr; 
    void* in_use_user_data_ = nullptr;                            
};
 
} // namespace entropic