packet_queue_ring.h

Go to the documentation of this file.

// Copyright (C) 2018 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_RING_H
#define PACKET_QUEUE_RING_H

#include <dhcp/packet_queue.h>
#include <util/threads/sync.h>

#include <boost/function.hpp>
#include <boost/circular_buffer.hpp>
#include <sstream>

namespace isc {

namespace dhcp {

template<typename PacketTypePtr>
class PacketQueueRing : public PacketQueue<PacketTypePtr> {
public:
    static const size_t MIN_RING_CAPACITY = 5;

    PacketQueueRing(const std::string& queue_type, size_t capacity)
        : PacketQueue<PacketTypePtr>(queue_type) {
        queue_.set_capacity(capacity);
    }

    virtual ~PacketQueueRing(){};

    virtual void enqueuePacket(PacketTypePtr packet, const SocketInfo& source) {
        if (!shouldDropPacket(packet, source)) {
            pushPacket(packet);
        }
    }

    virtual PacketTypePtr dequeuePacket() {
        eatPackets(QueueEnd::FRONT);
        return(popPacket());
    }

    virtual bool shouldDropPacket(PacketTypePtr /* packet */,
                            const SocketInfo& /* source */) {
        return (false);
    }

    virtual int eatPackets(const QueueEnd& /* from */) {
        return (0);
    }

    virtual void pushPacket(PacketTypePtr& packet, const QueueEnd& to=QueueEnd::BACK) {
        isc::util::thread::Mutex::Locker lock(mutex_);
        if (to == QueueEnd::BACK) {
            queue_.push_back(packet);
        } else {
            queue_.push_front(packet);
        }
    }

    virtual PacketTypePtr popPacket(const QueueEnd& from = QueueEnd::FRONT) {
        isc::util::thread::Mutex::Locker lock(mutex_);
        PacketTypePtr packet;
        if (queue_.empty()) {
            return (packet);
        }

        if (from == QueueEnd::FRONT) {
            packet = queue_.front();
            queue_.pop_front();
        } else {
            packet = queue_.back();
            queue_.pop_back();
        }

        return (packet);
    }


    virtual const PacketTypePtr peek(const QueueEnd& from=QueueEnd::FRONT) const {
        PacketTypePtr packet;
        if (!queue_.empty()) {
            packet = (from == QueueEnd::FRONT ? queue_.front() : queue_.back());
        }

        return (packet);
    }

    virtual bool empty() const {
        return(queue_.empty());
    }

    virtual size_t getCapacity() const {
        return (queue_.capacity());
    }

    virtual void setCapacity(size_t capacity) {
        if (capacity < MIN_RING_CAPACITY) {
            isc_throw(BadValue, "Queue capacity of " << capacity
                      << " is invalid.  It must be at least "
                      << MIN_RING_CAPACITY);
        }

        queue_.set_capacity(capacity);
    }

    virtual size_t getSize() const {
        return (queue_.size());
    }

    virtual void clear()  {
        queue_.clear();
    }

    virtual data::ElementPtr getInfo() const {
       data::ElementPtr info = PacketQueue<PacketTypePtr>::getInfo();
       info->set("capacity", data::Element::create(static_cast<int64_t>(getCapacity())));
       info->set("size", data::Element::create(static_cast<int64_t>(getSize())));
       return(info);
    }

private:

    boost::circular_buffer<PacketTypePtr> queue_;

    isc::util::thread::Mutex mutex_;
};


class PacketQueueRing4 : public PacketQueueRing<Pkt4Ptr> {
public:
    PacketQueueRing4(const std::string& queue_type, size_t capacity)
        : PacketQueueRing(queue_type, capacity) {
    };

    virtual ~PacketQueueRing4(){}
};

class PacketQueueRing6 : public PacketQueueRing<Pkt6Ptr> {
public:
    PacketQueueRing6(const std::string& queue_type, size_t capacity)
        : PacketQueueRing(queue_type, capacity) {
    };

    virtual ~PacketQueueRing6(){}
};

}; // namespace isc::dhcp
}; // namespace isc

#endif // PACKET_QUEUE_RING_H