ca_cfg_mgr.h

Go to the documentation of this file.

// Copyright (C) 2016-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef CTRL_AGENT_CFG_MGR_H
#define CTRL_AGENT_CFG_MGR_H
 
#include <cc/data.h>
#include <hooks/hooks_config.h>
#include <http/auth_config.h>
#include <process/d_cfg_mgr.h>
#include <boost/pointer_cast.hpp>
#include <map>
#include <string>
 
namespace isc {
namespace agent {
 
class CtrlAgentCfgContext;
typedef boost::shared_ptr<CtrlAgentCfgContext> CtrlAgentCfgContextPtr;
 
class CtrlAgentCfgContext : public process::ConfigBase {
public:
 
    CtrlAgentCfgContext();
 
    virtual process::ConfigPtr clone() {
        return (process::ConfigPtr(new CtrlAgentCfgContext(*this)));
    }
 
    isc::data::ConstElementPtr
    getControlSocketInfo(const std::string& service) const;
 
    void setControlSocketInfo(const isc::data::ConstElementPtr& control_socket,
                              const std::string& service);
 
    std::string getControlSocketInfoSummary() const;
 
    void setHttpHost(const std::string& host) {
        http_host_ = host;
    }
 
    std::string getHttpHost() const {
        return (http_host_);
    }
 
    void setHttpPort(const uint16_t port) {
        http_port_ = port;
    }
 
    uint16_t getHttpPort() const {
        return (http_port_);
    }
 
    void setAuthConfig(const isc::http::HttpAuthConfigPtr& auth_config) {
        auth_config_ = auth_config;
    }
 
    const isc::http::HttpAuthConfigPtr& getAuthConfig() const {
        return (auth_config_);
    }
 
    void setTrustAnchor(const std::string& ca) {
        trust_anchor_ = ca;
    }
 
    std::string getTrustAnchor() const {
        return (trust_anchor_);
    }
 
    void setCertFile(const std::string& cert) {
        cert_file_ = cert;
    }
 
    std::string getCertFile() const {
        return (cert_file_);
    }
 
    void setKeyFile(const std::string& key) {
        key_file_ = key;
    }
 
    std::string getKeyFile() const {
        return (key_file_);
    }
 
    void setCertRequired(bool required) {
        cert_required_ = required;
    }
 
    bool getCertRequired() const {
        return (cert_required_);
    }
 
    isc::hooks::HooksConfig& getHooksConfig() {
        return (hooks_config_);
    }
 
    const isc::hooks::HooksConfig& getHooksConfig() const {
        return (hooks_config_);
    }
 
    virtual isc::data::ElementPtr toElement() const;
 
private:
 
    CtrlAgentCfgContext(const CtrlAgentCfgContext& orig);
 
    CtrlAgentCfgContext& operator=(const CtrlAgentCfgContext& rhs);
 
    std::map<std::string, isc::data::ConstElementPtr> ctrl_sockets_;
 
    std::string http_host_;
 
    uint16_t http_port_;
 
    std::string trust_anchor_;
 
    std::string cert_file_;
 
    std::string key_file_;
 
    bool cert_required_;
 
    isc::hooks::HooksConfig hooks_config_;
 
    isc::http::HttpAuthConfigPtr auth_config_;
};
 
class CtrlAgentCfgMgr : public process::DCfgMgrBase {
public:
 
    CtrlAgentCfgMgr();
 
    virtual ~CtrlAgentCfgMgr();
 
    CtrlAgentCfgContextPtr getCtrlAgentCfgContext() {
        return (boost::dynamic_pointer_cast<CtrlAgentCfgContext>(getContext()));
    }
 
    virtual std::string getConfigSummary(const uint32_t selection) override;
 
protected:
 
    virtual isc::data::ConstElementPtr
    parse(isc::data::ConstElementPtr config, bool check_only) override;
 
    virtual process::ConfigPtr createNewContext() override;
 
    std::list<std::list<std::string>> jsonPathsToRedact() const final override;
};
 
typedef boost::shared_ptr<CtrlAgentCfgMgr> CtrlAgentCfgMgrPtr;
 
} // namespace isc::agent
} // namespace isc
 
#endif // CTRL_AGENT_CFG_MGR_H