memfile_lease_mgr.h

Go to the documentation of this file.

// Copyright (C) 2012-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 MEMFILE_LEASE_MGR_H
#define MEMFILE_LEASE_MGR_H
 
#include <asiolink/interval_timer.h>
#include <asiolink/process_spawn.h>
#include <database/database_connection.h>
#include <dhcp/hwaddr.h>
#include <dhcpsrv/csv_lease_file4.h>
#include <dhcpsrv/csv_lease_file6.h>
#include <dhcpsrv/lease_mgr_factory.h>
#include <dhcpsrv/memfile_lease_limits.h>
#include <dhcpsrv/memfile_lease_storage.h>
#include <dhcpsrv/tracking_lease_mgr.h>
 
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
 
#include <mutex>
 
namespace isc {
namespace dhcp {
 
class LFCSetup;
 
class Memfile_LeaseMgr : public TrackingLeaseMgr {
public:
 
    static const int MAJOR_VERSION_V4 = 3;
 
    static const int MINOR_VERSION_V4 = 0;
 
    static const int MAJOR_VERSION_V6 = 5;
 
    static const int MINOR_VERSION_V6 = 0;
 
    enum Universe {
        V4,
        V6
    };
 
 
 
    Memfile_LeaseMgr(const db::DatabaseConnection::ParameterMap& parameters);
 
    virtual ~Memfile_LeaseMgr();
 
    static std::string getDBVersion();
 
    static std::string getDBVersionInternal(Universe const& u);
 
    virtual bool addLease(const Lease4Ptr& lease) override;
 
    virtual bool addLease(const Lease6Ptr& lease) override;
 
    virtual Lease4Ptr getLease4(const isc::asiolink::IOAddress& addr) const override;
 
    virtual Lease4Collection getLease4(const isc::dhcp::HWAddr& hwaddr) const override;
 
    virtual Lease4Ptr getLease4(const HWAddr& hwaddr,
                                SubnetID subnet_id) const override;
 
    virtual Lease4Collection getLease4(const ClientId& client_id) const override;
 
    virtual Lease4Ptr getLease4(const ClientId& clientid,
                                SubnetID subnet_id) const override;
 
    virtual Lease4Collection getLeases4(SubnetID subnet_id) const override;
 
    virtual Lease4Collection getLeases4(const std::string& hostname) const override;
 
    virtual Lease4Collection getLeases4() const override;
 
    virtual Lease4Collection
    getLeases4(const asiolink::IOAddress& lower_bound_address,
               const LeasePageSize& page_size) const override;
 
    virtual Lease6Ptr getLease6(Lease::Type type,
                                const isc::asiolink::IOAddress& addr) const override;
 
    virtual Lease6Collection getLeases6(Lease::Type type,
                                        const DUID& duid,
                                        uint32_t iaid) const override;
 
    virtual Lease6Collection getLeases6(Lease::Type type,
                                        const DUID& duid,
                                        uint32_t iaid,
                                        SubnetID subnet_id) const override;
 
    virtual Lease6Collection getLeases6(SubnetID subnet_id) const override;
 
    virtual Lease6Collection getLeases6(const std::string& hostname) const override;
 
    virtual Lease6Collection getLeases6() const override;
 
    virtual Lease6Collection getLeases6(const DUID& duid) const override;
 
    virtual Lease6Collection
    getLeases6(const asiolink::IOAddress& lower_bound_address,
               const LeasePageSize& page_size) const override;
 
    virtual Lease6Collection
    getLeases6(SubnetID subnet_id,
               const asiolink::IOAddress& lower_bound_address,
               const LeasePageSize& page_size) const override;
 
    virtual void getExpiredLeases4(Lease4Collection& expired_leases,
                                   const size_t max_leases) const override;
 
    virtual void getExpiredLeases6(Lease6Collection& expired_leases,
                                   const size_t max_leases) const override;
 
    virtual void updateLease4(const Lease4Ptr& lease4) override;
 
    virtual void updateLease6(const Lease6Ptr& lease6) override;
 
    virtual bool deleteLease(const Lease4Ptr& lease) override;
 
    virtual bool deleteLease(const Lease6Ptr& lease) override;
 
    virtual uint64_t deleteExpiredReclaimedLeases4(const uint32_t secs) override;
 
    virtual uint64_t deleteExpiredReclaimedLeases6(const uint32_t secs) override;
 
    virtual size_t wipeLeases4(const SubnetID& subnet_id) override;
 
    virtual size_t wipeLeases6(const SubnetID& subnet_id) override;
 
    virtual std::string
    checkLimits4(isc::data::ConstElementPtr const& user_context) const override;
 
    virtual std::string
    checkLimits6(isc::data::ConstElementPtr const& user_context) const override;
 
    virtual bool isJsonSupported() const override;
 
private:
 
 
    bool addLeaseInternal(const Lease4Ptr& lease);
 
    bool addLeaseInternal(const Lease6Ptr& lease);
 
    Lease4Ptr getLease4Internal(const isc::asiolink::IOAddress& addr) const;
 
    void getLease4Internal(const isc::dhcp::HWAddr& hwaddr,
                           Lease4Collection& collection) const;
 
    Lease4Ptr getLease4Internal(const HWAddr& hwaddr,
                                SubnetID subnet_id) const;
 
    void getLease4Internal(const ClientId& client_id,
                           Lease4Collection& collection) const;
 
    Lease4Ptr getLease4Internal(const ClientId& clientid,
                                const HWAddr& hwaddr,
                                SubnetID subnet_id) const;
 
    Lease4Ptr getLease4Internal(const ClientId& clientid,
                                SubnetID subnet_id) const;
 
    void getLeases4Internal(SubnetID subnet_id,
                            Lease4Collection& collection) const;
 
    void getLeases4Internal(const std::string& hostname,
                            Lease4Collection& collection) const;
 
    void getLeases4Internal(Lease4Collection& collection) const;
 
    void getLeases4Internal(const asiolink::IOAddress& lower_bound_address,
                            const LeasePageSize& page_size,
                            Lease4Collection& collection) const;
 
    Lease6Ptr getLease6Internal(Lease::Type type,
                                const isc::asiolink::IOAddress& addr) const;
 
    Lease6Ptr getAnyLease6Internal(const isc::asiolink::IOAddress& addr) const;
 
    void getLeases6Internal(Lease::Type type,
                            const DUID& duid,
                            uint32_t iaid,
                            Lease6Collection& collection) const;
 
    void getLeases6Internal(Lease::Type type,
                            const DUID& duid,
                            uint32_t iaid,
                            SubnetID subnet_id,
                            Lease6Collection& collection) const;
 
    void getLeases6Internal(SubnetID subnet_id,
                            Lease6Collection& collection) const;
 
    void getLeases6Internal(const std::string& hostname,
                            Lease6Collection& collection) const;
 
    void getLeases6Internal(Lease6Collection& collection) const;
 
    void getLeases6Internal(const DUID& duid,
                            Lease6Collection& collection) const;
 
    void getLeases6Internal(const asiolink::IOAddress& lower_bound_address,
                            const LeasePageSize& page_size,
                            Lease6Collection& collection) const;
 
    virtual Lease6Collection
    getLeases6Internal(SubnetID subnet_id,
                       const asiolink::IOAddress& lower_bound_address,
                       const LeasePageSize& page_size) const;
 
    void getExpiredLeases4Internal(Lease4Collection& expired_leases,
                                   const size_t max_leases) const;
 
    void getExpiredLeases6Internal(Lease6Collection& expired_leases,
                                   const size_t max_leases) const;
 
    void updateLease4Internal(const Lease4Ptr& lease4);
 
    void updateLease6Internal(const Lease6Ptr& lease6);
 
    bool deleteLeaseInternal(const Lease4Ptr& addr);
 
    bool deleteLeaseInternal(const Lease6Ptr& addr);
 
    size_t wipeLeases4Internal(const SubnetID& subnet_id);
 
    size_t wipeLeases6Internal(const SubnetID& subnet_id);
 
    template<typename IndexType, typename LeaseType, typename StorageType,
             typename LeaseFileType>
    uint64_t deleteExpiredReclaimedLeases(const uint32_t secs,
                                          const Universe& universe,
                                          StorageType& storage,
                                          LeaseFileType& lease_file);
 
    int64_t getSubnetStat(const SubnetID& subnet_id, const std::string& stat_label) const;
 
    bool getLeaseLimit(data::ConstElementPtr parent, Lease::Type ltype, size_t& limit) const;
 
public:
 
    virtual std::string getType() const override {
        return (std::string("memfile"));
    }
 
    virtual std::string getName() const override {
        return ("memory");
    }
 
    virtual std::string getDescription() const override;
 
    virtual std::pair<uint32_t, uint32_t> getVersion(const std::string& timer_name = std::string()) const override;
 
    virtual void commit() override;
 
    virtual void rollback() override;
 
 
 
 
    enum LFCFileType {
        FILE_CURRENT,  
        FILE_INPUT,    
        FILE_PREVIOUS, 
        FILE_OUTPUT,   
        FILE_FINISH,   
        FILE_PID       
    };
 
    static std::string appendSuffix(const std::string& file_name,
                                    const LFCFileType& file_type);
 
 
 
    std::string getDefaultLeaseFilePath(Universe u) const;
 
    std::string getLeaseFilePath(Universe u) const;
 
    bool persistLeases(Universe u) const;
 
 
private:
 
    std::string initLeaseFilePath(Universe u);
 
    template<typename LeaseObjectType, typename LeaseFileType,
             typename StorageType>
    bool loadLeasesFromFiles(const std::string& filename,
                             boost::shared_ptr<LeaseFileType>& lease_file,
                             StorageType& storage);
 
    Lease4Storage storage4_;
 
    Lease6Storage storage6_;
 
protected:
 
    Lease6ExtendedInfoRelayIdTable relay_id6_;
 
    Lease6ExtendedInfoRemoteIdTable remote_id6_;
 
    boost::shared_ptr<CSVLeaseFile4> lease_file4_;
 
    boost::shared_ptr<CSVLeaseFile6> lease_file6_;
 
public:
 
 
 
    bool isLFCRunning() const;
 
    int getLFCExitStatus() const;
 
    virtual LeaseStatsQueryPtr startLeaseStatsQuery4() override;
 
    virtual LeaseStatsQueryPtr startPoolLeaseStatsQuery4() override;
 
    virtual LeaseStatsQueryPtr startSubnetLeaseStatsQuery4(const SubnetID& subnet_id) override;
 
    virtual LeaseStatsQueryPtr startSubnetRangeLeaseStatsQuery4(const SubnetID& first_subnet_id,
                                                                const SubnetID& last_subnet_id) override;
 
    virtual LeaseStatsQueryPtr startLeaseStatsQuery6() override;
 
    virtual LeaseStatsQueryPtr startPoolLeaseStatsQuery6() override;
 
    virtual LeaseStatsQueryPtr startSubnetLeaseStatsQuery6(const SubnetID& subnet_id) override;
 
    virtual LeaseStatsQueryPtr startSubnetRangeLeaseStatsQuery6(const SubnetID& first_subnet_id,
                                                                const SubnetID& last_subnet_id) override;
 
 
 
protected:
 
    virtual void lfcCallback();
 
 
 
private:
 
    void lfcSetup(bool conversion_needed = false);
 
    template<typename LeaseFileType>
    void lfcExecute(boost::shared_ptr<LeaseFileType>& lease_file);
 
    boost::scoped_ptr<LFCSetup> lfc_setup_;
 
    db::DatabaseConnection conn_;
 
 
    boost::scoped_ptr<std::mutex> mutex_;
 
    ClassLeaseCounter class_lease_counter_;
 
public:
    virtual size_t getClassLeaseCount(const ClientClass& client_class,
                                      const Lease::Type& ltype = Lease::TYPE_V4) const override;
 
    virtual void recountClassLeases4() override;
 
    virtual void recountClassLeases6() override;
 
    virtual void clearClassLeaseCounts() override;
 
 
    virtual Lease4Collection
    getLeases4ByRelayId(const OptionBuffer& relay_id,
                        const asiolink::IOAddress& lower_bound_address,
                        const LeasePageSize& page_size,
                        const time_t& qry_start_time = 0,
                        const time_t& qry_end_time = 0) override;
 
    virtual Lease4Collection
    getLeases4ByRemoteId(const OptionBuffer& remote_id,
                         const asiolink::IOAddress& lower_bound_address,
                         const LeasePageSize& page_size,
                         const time_t& qry_start_time = 0,
                         const time_t& qry_end_time = 0) override;
 
    virtual Lease6Collection
    getLeases6ByRelayId(const DUID& relay_id,
                        const asiolink::IOAddress& lower_bound_address,
                        const LeasePageSize& page_size) override;
 
    virtual Lease6Collection
    getLeases6ByRemoteId(const OptionBuffer& remote_id,
                         const asiolink::IOAddress& lower_bound_address,
                         const LeasePageSize& page_size) override;
 
    size_t extractExtendedInfo4(bool update, bool current);
 
    virtual size_t upgradeExtendedInfo6(const LeasePageSize& page_size) override;
 
    virtual void wipeExtendedInfoTables6() override;
 
    virtual size_t byRelayId6size() const override;
 
    virtual size_t byRemoteId6size() const override;
 
private:
 
    Lease4Collection
    getLeases4ByRelayIdInternal(const OptionBuffer& relay_id,
                                const asiolink::IOAddress& lower_bound_address,
                                const LeasePageSize& page_size,
                                const time_t& qry_start_time,
                                const time_t& qry_end_time);
 
    Lease4Collection
    getLeases4ByRemoteIdInternal(const OptionBuffer& remote_id,
                                 const asiolink::IOAddress& lower_bound_address,
                                 const LeasePageSize& page_size,
                                 const time_t& qry_start_time,
                                 const time_t& qry_end_time);
 
    Lease6Collection
    getLeases6ByRelayIdInternal(const DUID& relay_id,
                                const asiolink::IOAddress& lower_bound_address,
                                const LeasePageSize& page_size);
 
    Lease6Collection
    getLeases6ByRemoteIdInternal(const OptionBuffer& remote_id,
                                 const asiolink::IOAddress& lower_bound_address,
                                 const LeasePageSize& page_size);
 
public:
 
    virtual void writeLeases4(const std::string& filename) override;
 
    virtual void writeLeases6(const std::string& filename) override;
 
    virtual size_t upgradeExtendedInfo4(const LeasePageSize& page_size) override;
 
protected:
 
 
    void buildExtendedInfoTables6();
 
    virtual void deleteExtendedInfo6(const isc::asiolink::IOAddress& addr) override;
 
    virtual void addRelayId6(const isc::asiolink::IOAddress& lease_addr,
                             const std::vector<uint8_t>& relay_id) override;
 
    virtual void addRemoteId6(const isc::asiolink::IOAddress& lease_addr,
                              const std::vector<uint8_t>& remote_id) override;
 
private:
    virtual void writeLeases4Internal(const std::string& filename);
 
    virtual void writeLeases6Internal(const std::string& filename);
 
public:
    static TrackingLeaseMgrPtr
    factory(const isc::db::DatabaseConnection::ParameterMap& parameters);
};
 
struct MemfileLeaseMgrInit {
    // Constructor registers
    MemfileLeaseMgrInit() {
        LeaseMgrFactory::registerFactory("memfile",
                                         Memfile_LeaseMgr::factory,
                                         true,
                                         Memfile_LeaseMgr::getDBVersion);
    }
 
    // Destructor deregisters
    ~MemfileLeaseMgrInit() {
        LeaseMgrFactory::deregisterFactory("memfile", true);
    }
};
 
}  // namespace dhcp
}  // namespace isc
 
#endif // MEMFILE_LEASE_MGR_H