tracking_lease_mgr.h

Go to the documentation of this file.

// Copyright (C) 2023 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 <boost/multi_index_container.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/indexed_by.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/shared_ptr.hpp>
#include <functional>
#include <string>
#include <unordered_set>
 
namespace isc {
namespace dhcp {
 
class TrackingLeaseMgr : public LeaseMgr {
public:
 
    friend class LeaseMgrFactory;
 
    typedef enum {
        TRACK_ADD_LEASE,
        TRACK_UPDATE_LEASE,
        TRACK_DELETE_LEASE
    } CallbackType;
 
    typedef std::function<void(LeasePtr, bool)> 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, bool mt_safe);
 
    void trackUpdateLease(const LeasePtr& lease, bool mt_safe);
 
    void trackDeleteLease(const LeasePtr& lease, bool mt_safe);
 
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, bool mt_safe);
 
    void runCallbacksForSubnetID(CallbackType type, SubnetID subnet_id,
                                 const LeasePtr& lease, bool mt_safe);
 
    CallbackContainerPtr callbacks_;
 
    std::unordered_set<asiolink::IOAddress, asiolink::IOAddress::Hash> locked_leases_;
};
 
} // end of namespace isc::dhcp
} // end of namespace isc
 
#endif // TRACKING_LEASE_MGR_H