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