blq_service.h

Go to the documentation of this file.

// Copyright (C) 2022-2026 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 BLQ_SERVICE_H
#define BLQ_SERVICE_H
 
#include <asiolink/asio_wrapper.h>
#include <cc/data.h>
#include <cc/simple_parser.h>
#include <exceptions/exceptions.h>
#include <lease_query/lease_query_impl.h>
#include <lease_query/mt_lease_query_mgr.h>
 
#include <boost/noncopyable.hpp>
 
namespace isc {
namespace lease_query {

class BulkLeaseQueryService;

typedef boost::shared_ptr<BulkLeaseQueryService> BulkLeaseQueryServicePtr;
 
// @brief Multi-threaded Lease Query listener manager singleton class.
class BulkLeaseQueryService  : boost::noncopyable {
public:

    class AdvancedConfig {
        public:
        AdvancedConfig(uint16_t family)
            : family_(family),
              bulk_query_enabled_(false),
              active_query_enabled_(false),
              extended_info_tables_enabled_(false),
              lease_query_ip_(asiolink::IOAddress(family == AF_INET ?
                                                  "127.0.0.1" : "::1")),
              lease_query_tcp_port_(family == AF_INET ? 67 : 547),
              max_bulk_query_threads_(0),
              max_requester_connections_(10),
              max_concurrent_queries_(0),
              max_requester_idle_time_(300),
              max_leases_per_fetch_(100),
              trust_anchor_(),
              cert_file_(),
              key_file_(),
              cert_required_(true) {
        }

        void parse(isc::data::ConstElementPtr advanced);

        static const isc::data::SimpleKeywords CONFIG_KEYWORDS;

        uint16_t family_;

        bool bulk_query_enabled_;

        bool active_query_enabled_;

        bool extended_info_tables_enabled_;

        isc::asiolink::IOAddress lease_query_ip_;

        uint16_t lease_query_tcp_port_;

        size_t max_bulk_query_threads_;

        size_t max_requester_connections_;

        size_t max_concurrent_queries_;

        long max_requester_idle_time_;

        size_t max_leases_per_fetch_;

        std::string trust_anchor_;

        std::string cert_file_;

        std::string key_file_;

        bool cert_required_;
    };

    virtual ~BulkLeaseQueryService();

    static void reset();

    static void create(LeaseQueryImpl* impl,
                       isc::data::ConstElementPtr advanced);

    static BulkLeaseQueryServicePtr instance();

    static void doStartListener();


    uint16_t getFamily() const {
        return (config_.family_);
    }

    bool getBulkQueryEnabled() const {
        return (config_.bulk_query_enabled_);
    }

    bool getActiveQueryEnabled() const {
        return (config_.active_query_enabled_);
    }

    bool getExtendedInfoTablesEnabled() const {
        return (config_.extended_info_tables_enabled_);
    }

    const isc::asiolink::IOAddress& getLeaseQueryIp() const {
        return (config_.lease_query_ip_);
    }

    uint16_t getLeaseQueryTcpPort() const {
        return (config_.lease_query_tcp_port_);
    }

    size_t getMaxBulkQueryThreads() const {
        return (config_.max_bulk_query_threads_);
    }

    void setMaxBulkQueryThreads(size_t max_bulk_query_threads) {
        config_.max_bulk_query_threads_ = max_bulk_query_threads;
    }

    size_t getMaxRequesterConnections() const {
        return (config_.max_requester_connections_);
    }

    void setMaxRequesterConnections(size_t max_requester_connections);

    size_t getMaxConcurrentQueries() const {
        return (config_.max_concurrent_queries_);
    }

    void setMaxConcurrentQueries(size_t max_concurrent_queries) {
        config_.max_concurrent_queries_ = max_concurrent_queries;
    }

    long getMaxRequesterIdleTime() const {
        return (config_.max_requester_idle_time_);
    }

    size_t getMaxLeasePerFetch() const {
        return (config_.max_leases_per_fetch_);
    }

    void setMaxLeasePerFetch(size_t max_leases_per_fetch);

    void checkListenerPausePermission();

    void startListener();

    void pauseListener();

    void resumeListener();

    void stopListener();

    static bool acceptFilter(const boost::asio::ip::tcp::endpoint& endpoint);
 
private:
    BulkLeaseQueryService(LeaseQueryImpl* impl,
                          const AdvancedConfig& config);

    static BulkLeaseQueryServicePtr& getBulkLeaseQueryServicePtr();

    LeaseQueryImpl* impl_;

    AdvancedConfig config_;

    MtLeaseQueryListenerMgrPtr mt_listener_mgr_;
};
 
} // namespace isc::lease_query
} // namespace isc
 
#endif // BLQ_SERVICE_H