packet_queue_mgr.h

Go to the documentation of this file.

// Copyright (C) 2018-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 PACKET_QUEUE_MGR_H
#define PACKET_QUEUE_MGR_H
 
#include <cc/data.h>
#include <cc/simple_parser.h>
#include <dhcp/packet_queue.h>
#include <exceptions/exceptions.h>
#include <boost/shared_ptr.hpp>
#include <functional>
#include <map>
#include <string>
 
namespace isc {
namespace dhcp {
 
class InvalidQueueType : public Exception {
public:
    InvalidQueueType(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
template<typename PacketQueueTypePtr>
class PacketQueueMgr {
public:
    typedef std::function<PacketQueueTypePtr(data::ConstElementPtr)> Factory;
 
    PacketQueueMgr()
        : factories_(), packet_queue_() {
    }
 
    bool registerPacketQueueFactory(const std::string& queue_type,
                                    Factory factory) {
        // Check if this backend has been already registered.
        if (factories_.count(queue_type)) {
            return (false);
        }
 
        // Register the new backend.
        factories_.insert(std::make_pair(queue_type, factory));
        return (true);
    }
 
    bool unregisterPacketQueueFactory(const std::string& queue_type) {
        // Look for it.
        auto index = factories_.find(queue_type);
 
        // Not there so nothing to do.
        if (index == factories_.end()) {
            return (false);
        }
 
        // If the queue is of the type being unregistered, then remove it. We don't
        // a queue instance outliving its library.
        if ((packet_queue_) && (packet_queue_->getQueueType() == queue_type)) {
            packet_queue_.reset();
        }
 
        // Remove the factory.
        factories_.erase(index);
 
        return (true);
    }
 
    void createPacketQueue(data::ConstElementPtr parameters) {
        if (!parameters) {
            isc_throw(Unexpected, "createPacketQueue - queue parameters is null");
        }
 
        // Get the database type to locate a factory function.
        std::string queue_type ;
        try {
            queue_type = data::SimpleParser::getString(parameters, "queue-type");
        } catch (const std::exception& ex) {
            isc_throw(InvalidQueueParameter, "queue-type missing or invalid: " << ex.what());
        }
 
        // Look up the factory.
        auto index = factories_.find(queue_type);
 
        // Punt if there is no matching factory.
        if (index == factories_.end()) {
            isc_throw(InvalidQueueType, "The type of the packet queue: '" <<
                      queue_type << "' is not supported"); }
 
        // Call the factory to create the new queue.
        // Factories should throw InvalidQueueParameter if given
        // bad values in the control.
        auto new_queue = index->second(parameters);
        if (!new_queue) {
            isc_throw(Unexpected, "Packet queue " << queue_type <<
                      " factory returned NULL");
        }
 
        // Replace the existing queue with the new one.
        packet_queue_ = new_queue;
    }
 
    PacketQueueTypePtr getPacketQueue() const {
        return (packet_queue_);
    }
 
    void destroyPacketQueue() {
        packet_queue_.reset();
    }
 
protected:
    std::map<std::string, Factory> factories_;
 
    PacketQueueTypePtr packet_queue_;
};
 
} // end of namespace isc::dhcp
} // end of namespace isc
 
#endif // PACKET_QUEUE_MGR_H