resource_handler.h

Go to the documentation of this file.

// Copyright (C) 2020-2021 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 RESOURCE_HANDLER_H
#define RESOURCE_HANDLER_H
 
#include <asiolink/io_address.h>
#include <dhcpsrv/lease.h>
 
#include <boost/noncopyable.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/shared_ptr.hpp>
 
#include <mutex>
 
namespace isc {
namespace dhcp {
 
class ResourceBusy : public Exception {
public:
    ResourceBusy(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class ResourceHandler : public boost::noncopyable {
public:
 
    ResourceHandler();
 
    virtual ~ResourceHandler();
 
    bool tryLock(Lease::Type type, const asiolink::IOAddress& addr);
 
    bool isLocked(Lease::Type type, const asiolink::IOAddress& addr);
 
    void unLock(Lease::Type type, const asiolink::IOAddress& addr);
 
private:
 
 
 
    struct Resource {
 
        Resource(Lease::Type type, const asiolink::IOAddress& addr)
            : type_(type), addr_(addr) {
        }
 
        Lease::Type type_;
 
        asiolink::IOAddress addr_;
 
        std::vector<uint8_t> toBytes() const {
            return (addr_.toBytes());
        }
    };
 
    typedef boost::shared_ptr<Resource> ResourcePtr;
 
    typedef boost::multi_index_container<
 
        // This container stores pointers to resource objects.
        ResourcePtr,
 
        // Start specification of indexes here.
        boost::multi_index::indexed_by<
 
            // First index is used to search by type and address.
            boost::multi_index::hashed_unique<
                boost::multi_index::composite_key<
                    Resource,
                    // Lease type.
                    boost::multi_index::member<
                        Resource, Lease::Type, &Resource::type_
                    >,
                    // Address bytes.
                    boost::multi_index::const_mem_fun<
                        Resource, std::vector<uint8_t>, &Resource::toBytes
                    >
                >
            >
        >
    > ResourceContainer;
 
 
 
 
    static ResourceContainer resources_;
 
    static std::mutex mutex_;
 
    static ResourcePtr
    lookup(Lease::Type type, const asiolink::IOAddress& addr);
 
 
 
 
    void lock(Lease::Type type, const asiolink::IOAddress& addr);
 
    void unLockInternal(Lease::Type type, const asiolink::IOAddress& addr);
 
    ResourceContainer owned_;
 
};
 
class ResourceHandler4 : public ResourceHandler {
public:
 
    virtual ~ResourceHandler4() { }
 
    bool tryLock4(const asiolink::IOAddress& addr) {
        return (tryLock(Lease::TYPE_V4, addr));
    }
 
    bool isLocked4(const asiolink::IOAddress& addr) {
        return (isLocked(Lease::TYPE_V4, addr));
    }
 
    void unLock4(const asiolink::IOAddress& addr) {
        unLock(Lease::TYPE_V4, addr);
    }
};
 
} // namespace isc
} // namespace dhcp
 
#endif // RESOURCE_HANDLER_H