tracking_lease_mgr.h

Go to the documentation of this file.

// Copyright (C) 2023-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 TRACKING_LEASE_MGR_H
#define TRACKING_LEASE_MGR_H
 
#include <asiolink/io_address.h>
#include <dhcpsrv/lease_mgr.h>
 
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_set>
 
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/indexed_by.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/shared_ptr.hpp>
 
namespace isc {
namespace dhcp {

class TrackingLeaseMgr : public LeaseMgr {
public:

    friend class LeaseMgrFactory;

    enum CallbackType : uint16_t {
        TRACK_ADD_LEASE,
        TRACK_UPDATE_LEASE,
        TRACK_DELETE_LEASE
    };

    typedef std::function<void(LeasePtr)> CallbackFn;

    typedef struct {
        CallbackType type;

        std::string owner;

        SubnetID subnet_id;

        Lease::Type lease_type;

        CallbackFn fn;
    } Callback;
 
protected:

    typedef boost::multi_index_container<
        Callback,
        boost::multi_index::indexed_by<
            boost::multi_index::ordered_non_unique<
                boost::multi_index::composite_key<
                    Callback,
                    boost::multi_index::member<Callback, CallbackType, &Callback::type>,
                    boost::multi_index::member<Callback, SubnetID, &Callback::subnet_id>,
                    boost::multi_index::member<Callback, Lease::Type, &Callback::lease_type>
                >
            >,
            boost::multi_index::ordered_non_unique<
                boost::multi_index::composite_key<
                    Callback,
                    boost::multi_index::member<Callback, SubnetID, &Callback::subnet_id>,
                    boost::multi_index::member<Callback, Lease::Type, &Callback::lease_type>
                >
            >
        >
    > CallbackContainer;

    typedef boost::shared_ptr<CallbackContainer> CallbackContainerPtr;

    TrackingLeaseMgr();

    bool tryLock(const LeasePtr& lease);

    void unlock(const LeasePtr& lease);
 
public:

    bool isLocked(const LeasePtr& lease);
 
protected:

    void trackAddLease(const LeasePtr& lease);

    void trackUpdateLease(const LeasePtr& lease);

    void trackDeleteLease(const LeasePtr& lease);
 
public:

    void registerCallback(CallbackType type, std::string owner, SubnetID subnet_id,
                          Lease::Type lease_type, CallbackFn callback_fn);

    void registerCallback(CallbackType type, std::string owner, Lease::Type lease_type,
                          CallbackFn callback_fn);

    void unregisterCallbacks(SubnetID subnet_id, Lease::Type lease_type);

    void unregisterAllCallbacks();

    bool hasCallbacks() const;
 
protected:

    static std::string callbackTypeToString(CallbackType type);

    void runCallbacks(CallbackType type, const LeasePtr& lease);

    void runCallbacksForSubnetID(CallbackType type, SubnetID subnet_id,
                                 const LeasePtr& lease);

    CallbackContainerPtr callbacks_;

    std::unordered_set<asiolink::IOAddress, asiolink::IOAddress::Hash> locked_leases_;
};

typedef std::unique_ptr<TrackingLeaseMgr> TrackingLeaseMgrPtr;
 
} // end of namespace isc::dhcp
} // end of namespace isc
 
#endif // TRACKING_LEASE_MGR_H