libkea_dhcp___la_SOURCES += packet_queue_mgr.h
libkea_dhcp___la_SOURCES += packet_queue_mgr4.cc packet_queue_mgr4.h
libkea_dhcp___la_SOURCES += packet_queue_mgr6.cc packet_queue_mgr6.h
+libkea_dhcp___la_SOURCES += packet_queue_ring.h
libkea_dhcp___la_SOURCES += pkt.cc pkt.h
libkea_dhcp___la_SOURCES += pkt4.cc pkt4.h
libkea_dhcp___la_SOURCES += pkt4o6.cc pkt4o6.h
packet_queue_mgr.h \
packet_queue_mgr4.h \
packet_queue_mgr6.h \
+ packet_queue_ring.h \
pkt.h \
pkt4.h \
pkt4o6.h \
/// implementations which may be used by @c IfaceMgr to store
/// inbound packets until they are a dequeued for processing.
/// @note Derivations of this class MUST BE thread-safe.
-/// @endnote
///
template<typename PacketTypePtr>
class PacketQueue {
/// @brief Adds a packet to the queue
///
- /// Calls @c shouldDropPacket to determine if the packet should be queued
- /// or dropped. If it should be queued it is added to the end of the
- /// queue specified by the "to" parameter.
+ /// Adds the packet to the queue. Derivations determine
+ /// which packets to queue and how to queue them.
///
/// @param packet packet to enqueue
/// @param source socket the packet came from
- /// @param to end of the queue from which to remove packet(s).
- /// Defaults to BACK.
- ///
- void enqueuePacket(PacketTypePtr packet, const SocketInfo& source,
- const QueueEnd& to=QueueEnd::BACK) {
- if (!shouldDropPacket(packet, source)) {
- pushPacket(packet, to);
- }
- }
+ virtual void enqueuePacket(PacketTypePtr packet, const SocketInfo& source) = 0;
/// @brief Dequeues the next packet from the queue
///
- /// Calls @eatPackets to discard packets as needed, and then
- /// dequeues the next packet (if any) and returns it. Packets
- /// are dequeued from the end of the queue specified by the "from"
- /// parameter.
- ///
- /// @param from end of the queue from which to remove packet(s).
- /// Defaults to FRONT.
- ///
- /// @return A pointer to dequeued packet, or an empty pointer
- /// if the queue is empty.
- PacketTypePtr dequeuePacket(const QueueEnd& from=QueueEnd::FRONT) {
- eatPackets(from);
- return(popPacket(from));
- }
-
- /// @brief Determines if a packet should be discarded.
- ///
- /// This function is called at the beginning of @c enqueuePacket and
- /// provides an opportunity to examine the packet and its source
- /// and decide whether it should be dropped or added to the queue.
- /// Derivations are expected to provide implementations based on
- /// their own requirements. Bear in mind that the packet has NOT
- /// been unpacked at this point. The default implementation simply
- /// returns false.
- ///
- /// @param packet the packet under consideration
- /// @param source the socket the packet came from
- ///
- /// @return true if the packet should be dropped, false if it should be
- /// kept.
- virtual bool shouldDropPacket(PacketTypePtr /* packet */,
- const SocketInfo& /* source */) {
- return (false);
- }
-
- /// @brief Discards packets from one end of the queue.
- ///
- /// This function is called at the beginning of @c dequeuePacket and
- /// provides an opportunity to examine and discard packets from
- /// the queue prior to dequeuing the next packet to be
- /// processed. Derivations are expected to provide implementations
- /// based on their own requirements. The default implemenation is to
- /// to simply return without skipping any packets.
- ///
- /// @param from end of the queue from which packets should discarded
- /// This is passed in from @c dequeuePackets.
- ///
- /// @param from specifies the end of the queue from which packets
- /// should be discarded.
- ///
- /// @return The number of packets discarded.
- virtual int eatPackets(const QueueEnd& /* from */) {
- return (0);
- }
-
- /// @brief Pushes a packet onto the queue
- ///
- /// Adds a packet onto the end of queue specified.
- ///
- /// @param packet packet to add to the queue
- /// @param to specifies the end of the queue to which the packet
- /// should be added.
- virtual void pushPacket(PacketTypePtr& packet, const QueueEnd& to=QueueEnd::BACK) = 0;
-
- /// @brief Pops a packet from the queue
- ///
- /// Removes a packet from the end of the queue specified and returns it.
- ///
- /// @param from specifies the end of the queue from which the packet
- /// should be taken.
+ /// Dequeues the next packet (if any) and returns it. Derivations determine
+ /// how packets are dequeued.
///
/// @return A pointer to dequeued packet, or an empty pointer
/// if the queue is empty.
- virtual PacketTypePtr popPacket(const QueueEnd& from=QueueEnd::FRONT) = 0;
-
- /// @brief Gets the packet currently at one end of the queue
- ///
- /// Returns a pointer the packet at the specified end of the
- /// queue without dequeuing it.
- ///
- /// @param from specifies which end of the queue to examine.
- ///
- /// @return A pointer to packet, or an empty pointer if the
- /// queue is empty.
- virtual const PacketTypePtr peek(const QueueEnd& from=QueueEnd::FRONT) const = 0;
+ virtual PacketTypePtr dequeuePacket() = 0;
/// @brief return True if the queue is empty.
virtual bool empty() const = 0;
- /// @todo size may not apply either... what if there are two internal buffers?
/// @brief Returns the current number of packets in the buffer.
virtual size_t getSize() const = 0;
/// DHCPv6 packet queue factories.
typedef boost::shared_ptr<PacketQueue<Pkt6Ptr>> PacketQueue6Ptr;
-
-/// @brief Provides an abstract ring-buffer implementation of the PacketQueue interface.
-template<typename PacketTypePtr>
-class PacketQueueRing : public PacketQueue<PacketTypePtr> {
-public:
- /// @brief Minimum queue capacity permitted. Below five is pretty much
- /// nonsensical.
- static const size_t MIN_RING_CAPACITY = 5;
-
- /// @brief Constructor
- ///
- /// @param queue_type logical name of the queue implementation
- /// @param capacity maximum number of packets the queue can hold
- PacketQueueRing(const std::string& queue_type, size_t capacity)
- : PacketQueue<PacketTypePtr>(queue_type) {
- queue_.set_capacity(capacity);
- }
-
- /// @brief virtual Destructor
- virtual ~PacketQueueRing(){};
-
- /// @brief Pushes a packet onto the queue
- ///
- /// Adds a packet onto the end of queue specified. Note that this
- /// function is protected by a Mutex.
- ///
- /// @param packet packet to add to the queue
- /// @param to specifies the end of the queue to which the packet
- /// should be added.
- 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);
- }
- }
-
- /// @brief Pops a packet from the queue
- ///
- /// Removes a packet from the end of the queue specified and returns it. Note
- /// that this function is protected by a Mutex.
- ///
- /// @param from specifies the end of the queue from which the packet
- /// should be taken.
- ///
- /// @return A pointer to dequeued packet, or an empty pointer
- /// if the queue is empty.
- 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);
- }
-
-
- /// @brief Gets the packet currently at one end of the queue
- ///
- /// Returns a pointer the packet at the specified end of the
- /// queue without dequeuing it.
- ///
- /// @param from specifies which end of the queue to examine.
- ///
- /// @return A pointer to packet, or an empty pointer if the
- /// queue is empty.
- 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);
- }
-
- /// @brief Returns True if the queue is empty.
- virtual bool empty() const {
- return(queue_.empty());
- }
-
- /// @brief Returns the maximum number of packets allowed in the buffer.
- virtual size_t getCapacity() const {
- return (queue_.capacity());
- }
-
- /// @brief Sets the maximum number of packets allowed in the buffer.
- ///
- /// @todo - do we want to change size on the fly? This might need
- /// to be private, called only by constructor
- ///
- /// @throw BadValue if capacity is too low.
- 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);
- }
-
- /// @todo should probably throw if it's zero
- queue_.set_capacity(capacity);
- }
-
- /// @brief Returns the current number of packets in the buffer.
- virtual size_t getSize() const {
- return (queue_.size());
- }
-
- /// @brief Discards all packets currently in the buffer.
- virtual void clear() {
- queue_.clear();
- }
-
- /// @brief Fetches pertinent information
- 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:
-
- /// @brief Packet queue
- boost::circular_buffer<PacketTypePtr> queue_;
-
- /// @brief Mutex for protecting queue accesses.
- isc::util::thread::Mutex mutex_;
-};
-
-
-/// @brief DHCPv4 packet queue buffer implementation
-///
-/// This implementation does not (currently) add any drop
-/// or packet skip logic, it operates as a verbatim ring
-/// queue for DHCPv4 packets.
-///
-class PacketQueueRing4 : public PacketQueueRing<Pkt4Ptr> {
-public:
- /// @brief Constructor
- ///
- /// @param queue_type logical name of the queue implementation
- /// @param capacity maximum number of packets the queue can hold
- PacketQueueRing4(const std::string& queue_type, size_t capacity)
- : PacketQueueRing(queue_type, capacity) {
- };
-
- /// @brief virtual Destructor
- virtual ~PacketQueueRing4(){}
-};
-
-/// @brief DHCPv6 packet queue buffer implementation
-///
-/// This implementation does not (currently) add any drop
-/// or packet skip logic, it operates as a verbatim ring
-/// queue for DHCPv6 packets.
-///
-class PacketQueueRing6 : public PacketQueueRing<Pkt6Ptr> {
-public:
- /// @brief Constructor
- ///
- /// @param queue_type logical name of the queue implementation
- /// @param capacity maximum number of packets the queue can hold
- PacketQueueRing6(const std::string& queue_type, size_t capacity)
- : PacketQueueRing(queue_type, capacity) {
- };
-
- /// @brief virtual Destructor
- virtual ~PacketQueueRing6(){}
-};
-
-
}; // namespace isc::dhcp
}; // namespace isc
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include <config.h>
+#include <dhcp/packet_queue_ring.h>
#include <dhcp/packet_queue_mgr4.h>
#include <boost/scoped_ptr.hpp>
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include <config.h>
+#include <dhcp/packet_queue_ring.h>
#include <dhcp/packet_queue_mgr6.h>
#include <boost/scoped_ptr.hpp>
--- /dev/null
+// 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 {
+
+/// @brief Provides an abstract ring-buffer implementation of the PacketQueue interface.
+template<typename PacketTypePtr>
+class PacketQueueRing : public PacketQueue<PacketTypePtr> {
+public:
+ /// @brief Minimum queue capacity permitted. Below five is pretty much
+ /// nonsensical.
+ static const size_t MIN_RING_CAPACITY = 5;
+
+ /// @brief Constructor
+ ///
+ /// @param queue_type logical name of the queue implementation
+ /// @param capacity maximum number of packets the queue can hold
+ PacketQueueRing(const std::string& queue_type, size_t capacity)
+ : PacketQueue<PacketTypePtr>(queue_type) {
+ queue_.set_capacity(capacity);
+ }
+
+ /// @brief virtual Destructor
+ virtual ~PacketQueueRing(){};
+
+ /// @brief Adds a packet to the queue
+ ///
+ /// Calls @c shouldDropPacket to determine if the packet should be queued
+ /// or dropped. If it should be queued it is added to the end of the
+ /// queue specified by the "to" parameter.
+ ///
+ /// @param packet packet to enqueue
+ /// @param source socket the packet came from
+ virtual void enqueuePacket(PacketTypePtr packet, const SocketInfo& source) {
+ if (!shouldDropPacket(packet, source)) {
+ pushPacket(packet);
+ }
+ }
+
+ /// @brief Dequeues the next packet from the queue
+ ///
+ /// Dequeues the next packet (if any) and returns it.
+ ///
+ /// @return A pointer to dequeued packet, or an empty pointer
+ /// if the queue is empty.
+ virtual PacketTypePtr dequeuePacket() {
+ eatPackets(QueueEnd::FRONT);
+ return(popPacket());
+ }
+
+ /// @brief Determines if a packet should be discarded.
+ ///
+ /// This function is called in @c enqueuePackets for each packet
+ /// in its packet list. It provides an opportunity to examine the
+ /// packet and its source and decide whether it should be dropped
+ /// or added to the queue. Derivations are expected to provide
+ /// implementations based on their own requirements. Bear in mind
+ /// that the packet has NOT been unpacked at this point. The default
+ /// implementation simply returns false (i.e. keep the packet).
+ ///
+ /// @param packet the packet under consideration
+ /// @param source the socket the packet came from
+ ///
+ /// @return true if the packet should be dropped, false if it should be
+ /// kept.
+ virtual bool shouldDropPacket(PacketTypePtr /* packet */,
+ const SocketInfo& /* source */) {
+ return (false);
+ }
+
+ /// @brief Discards packets from one end of the queue.
+ ///
+ /// This function is called at the beginning of @c dequeuePacket and
+ /// provides an opportunity to examine and discard packets from
+ /// the queue prior to dequeuing the next packet to be
+ /// processed. Derivations are expected to provide implementations
+ /// based on their own requirements. The default implemenation is to
+ /// to simply return without skipping any packets.
+ ///
+ /// @param from end of the queue from which packets should discarded
+ /// This is passed in from @c dequeuePackets.
+ ///
+ /// @param from specifies the end of the queue from which packets
+ /// should be discarded.
+ ///
+ /// @return The number of packets discarded.
+ virtual int eatPackets(const QueueEnd& /* from */) {
+ return (0);
+ }
+
+ /// @brief Pushes a packet onto the queue
+ ///
+ /// Adds a packet onto the end of queue specified.
+ ///
+ /// @param packet packet to add to the queue
+ /// @param to specifies the end of the queue to which the packet
+ /// should be added.
+ virtual void pushPacket(PacketTypePtr& packet, const QueueEnd& to=QueueEnd::BACK) {
+ if (to == QueueEnd::BACK) {
+ queue_.push_back(packet);
+ } else {
+ queue_.push_front(packet);
+ }
+ }
+
+ /// @brief Pops a packet from the queue
+ ///
+ /// Removes a packet from the end of the queue specified and returns it.
+ ///
+ /// @param from specifies the end of the queue from which the packet
+ /// should be taken. It locks the queue's Mutex upon entry.
+ ///
+ /// @return A pointer to dequeued packet, or an empty pointer
+ /// if the queue is empty.
+ 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);
+ }
+
+
+ /// @brief Gets the packet currently at one end of the queue
+ ///
+ /// Returns a pointer the packet at the specified end of the
+ /// queue without dequeuing it.
+ ///
+ /// @param from specifies which end of the queue to examine.
+ ///
+ /// @return A pointer to packet, or an empty pointer if the
+ /// queue is empty.
+ 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);
+ }
+
+ /// @brief Returns True if the queue is empty.
+ virtual bool empty() const {
+ return(queue_.empty());
+ }
+
+ /// @brief Returns the maximum number of packets allowed in the buffer.
+ virtual size_t getCapacity() const {
+ return (queue_.capacity());
+ }
+
+ /// @brief Sets the maximum number of packets allowed in the buffer.
+ ///
+ /// @todo - do we want to change size on the fly? This might need
+ /// to be private, called only by constructor
+ ///
+ /// @throw BadValue if capacity is too low.
+ 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);
+ }
+
+ /// @todo should probably throw if it's zero
+ queue_.set_capacity(capacity);
+ }
+
+ /// @brief Returns the current number of packets in the buffer.
+ virtual size_t getSize() const {
+ return (queue_.size());
+ }
+
+ /// @brief Discards all packets currently in the buffer.
+ virtual void clear() {
+ queue_.clear();
+ }
+
+ /// @brief Fetches pertinent information
+ 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:
+
+ /// @brief Packet queue
+ boost::circular_buffer<PacketTypePtr> queue_;
+
+ /// @brief Mutex for protecting queue accesses.
+ isc::util::thread::Mutex mutex_;
+};
+
+
+/// @brief DHCPv4 packet queue buffer implementation
+///
+/// This implementation does not (currently) add any drop
+/// or packet skip logic, it operates as a verbatim ring
+/// queue for DHCPv4 packets.
+///
+class PacketQueueRing4 : public PacketQueueRing<Pkt4Ptr> {
+public:
+ /// @brief Constructor
+ ///
+ /// @param queue_type logical name of the queue implementation
+ /// @param capacity maximum number of packets the queue can hold
+ PacketQueueRing4(const std::string& queue_type, size_t capacity)
+ : PacketQueueRing(queue_type, capacity) {
+ };
+
+ /// @brief virtual Destructor
+ virtual ~PacketQueueRing4(){}
+};
+
+/// @brief DHCPv6 packet queue buffer implementation
+///
+/// This implementation does not (currently) add any drop
+/// or packet skip logic, it operates as a verbatim ring
+/// queue for DHCPv6 packets.
+///
+class PacketQueueRing6 : public PacketQueueRing<Pkt6Ptr> {
+public:
+ /// @brief Constructor
+ ///
+ /// @param queue_type logical name of the queue implementation
+ /// @param capacity maximum number of packets the queue can hold
+ PacketQueueRing6(const std::string& queue_type, size_t capacity)
+ : PacketQueueRing(queue_type, capacity) {
+ };
+
+ /// @brief virtual Destructor
+ virtual ~PacketQueueRing6(){}
+};
+
+}; // namespace isc::dhcp
+}; // namespace isc
+
+#endif // PACKET_QUEUE_RING_H
#include <config.h>
-#include <dhcp/packet_queue.h>
+#include <dhcp/packet_queue_ring.h>
#include <dhcp/tests/packet_queue_testutils.h>
#include <boost/shared_ptr.hpp>
// Verifies use of the generic PacketQueue interface to
// construct a queue implementation.
-TEST(TestQueue4, interfaceBasics) {
+TEST(PacketQueueRing4, interfaceBasics) {
// Verify we can create a queue
- PacketQueue4Ptr q4(new TestQueue4(100));
- ASSERT_TRUE(q4);
+ PacketQueue4Ptr q(new PacketQueueRing4("kea-ring4",100));
+ ASSERT_TRUE(q);
// It should be empty.
- EXPECT_TRUE(q4->empty());
+ EXPECT_TRUE(q->empty());
// Type should match.
- EXPECT_EQ("kea-ring4", q4->getQueueType());
+ EXPECT_EQ("kea-ring4", q->getQueueType());
// Fetch the queue info and verify it has all the expected values.
- checkInfo(q4, "{ \"capacity\": 100, \"queue-type\": \"kea-ring4\", \"size\": 0 }");
+ checkInfo(q, "{ \"capacity\": 100, \"queue-type\": \"kea-ring4\", \"size\": 0 }");
}
-// Verifies the basic mechanics of the adding and
-// removing packets to and from the ring buffer.
-TEST(TestQueue4, ringTest) {
- PacketQueue4Ptr q4(new TestQueue4(3));
+// Verifies the higher level functions of queueing and dequeueing
+// from the ring buffer.
+TEST(PacketQueueRing4, enqueueDequeueTest) {
+ PacketQueue4Ptr q(new PacketQueueRing4("kea-ring4", 3));
// Fetch the queue info and verify it has all the expected values.
- checkInfo(q4, "{ \"capacity\": 3, \"queue-type\": \"kea-ring4\", \"size\": 0 }");
+ checkInfo(q, "{ \"capacity\": 3, \"queue-type\": \"kea-ring4\", \"size\": 0 }");
// Enqueue five packets. The first two should be pushed off.
SocketInfo sock1(isc::asiolink::IOAddress("127.0.0.1"), 777, 10);
+
for (int i = 1; i < 6; ++i) {
Pkt4Ptr pkt(new Pkt4(DHCPDISCOVER, 1000+i));
- ASSERT_NO_THROW(q4->enqueuePacket(pkt, sock1));
- checkIntStat(q4, "size", (i > 3 ? 3 : i));
+ ASSERT_NO_THROW(q->enqueuePacket(pkt, sock1));
}
+
// Fetch the queue info and verify it has all the expected values.
- checkInfo(q4, "{ \"capacity\": 3, \"queue-type\": \"kea-ring4\", \"size\": 3 }");
+ checkInfo(q, "{ \"capacity\": 3, \"queue-type\": \"kea-ring4\", \"size\": 3 }");
+
+ // We should have transids 1003,1004,1005
+ Pkt4Ptr pkt;
+ for (int i = 3; i < 6; ++i) {
+ ASSERT_NO_THROW(pkt = q->dequeuePacket());
+ ASSERT_TRUE(pkt);
+ EXPECT_EQ(1000 + i, pkt->getTransid());
+ }
+
+ // Queue should be empty.
+ ASSERT_TRUE(q->empty());
+
+ // Dequeuing should fail safely, with an empty return.
+ ASSERT_NO_THROW(pkt = q->dequeuePacket());
+ ASSERT_FALSE(pkt);
+
+ // Enqueue three more packets.
+ for (int i = 0; i < 3; ++i) {
+ Pkt4Ptr pkt(new Pkt4(DHCPDISCOVER, 1000+i));
+ ASSERT_NO_THROW(q->enqueuePacket(pkt, sock1));
+ }
+
+ checkIntStat(q, "size", 3);
+
+ // Let's flush the buffer and then verify it is empty.
+ q->clear();
+ EXPECT_TRUE(q->empty());
+ checkIntStat(q, "size", 0);
+}
+
+// Verifies peeking, pushing, and popping which
+// are unique to PacketQueueRing<> derivations.
+TEST(PacketQueueRing4, peekPushPopTest) {
+ PacketQueueRing4 q("kea-ring4", 3);
+
+ // Push five packets onto the end. The first two should get pushed off.
+ for (int i = 1; i < 6; ++i) {
+ Pkt4Ptr pkt(new Pkt4(DHCPDISCOVER, 1000+i));
+ ASSERT_NO_THROW(q.pushPacket(pkt));
+ }
+
+ // We should have three.
+ ASSERT_EQ(3, q.getSize());
// We should have transids 1005,1004,1003 (back to front)
// Peek front should be transid 1003.
Pkt4Ptr pkt;
- ASSERT_NO_THROW(pkt = q4->peek(QueueEnd::FRONT));
+ ASSERT_NO_THROW(pkt = q.peek(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
EXPECT_EQ(1003, pkt->getTransid());
// Peek back should be transid 1005.
- ASSERT_NO_THROW(pkt = q4->peek(QueueEnd::BACK));
+ ASSERT_NO_THROW(pkt = q.peek(QueueEnd::BACK));
ASSERT_TRUE(pkt);
EXPECT_EQ(1005, pkt->getTransid());
// Pop front should return transid 1003.
- ASSERT_NO_THROW(pkt = q4->popPacket(QueueEnd::FRONT));
+ ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
EXPECT_EQ(1003, pkt->getTransid());
// Pop back should return transid 1005.
- ASSERT_NO_THROW(pkt = q4->popPacket(QueueEnd::BACK));
+ ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::BACK));
ASSERT_TRUE(pkt);
EXPECT_EQ(1005, pkt->getTransid());
// Peek front should be transid 1004.
- ASSERT_NO_THROW(pkt = q4->peek(QueueEnd::FRONT));
+ ASSERT_NO_THROW(pkt = q.peek(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
EXPECT_EQ(1004, pkt->getTransid());
// Peek back should be transid 1004.
- ASSERT_NO_THROW(pkt = q4->peek(QueueEnd::BACK));
+ ASSERT_NO_THROW(pkt = q.peek(QueueEnd::BACK));
ASSERT_TRUE(pkt);
EXPECT_EQ(1004, pkt->getTransid());
// Pop front should return transid 1004.
- ASSERT_NO_THROW(pkt = q4->popPacket(QueueEnd::FRONT));
+ ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
EXPECT_EQ(1004, pkt->getTransid());
// Pop front should return an empty pointer.
- ASSERT_NO_THROW(pkt = q4->popPacket(QueueEnd::BACK));
- ASSERT_FALSE(pkt);
-
- // Enqueue three packets.
- for (int i = 1; i < 3; ++i) {
- Pkt4Ptr pkt(new Pkt4(DHCPDISCOVER, 1000+i));
- ASSERT_NO_THROW(q4->enqueuePacket(pkt, sock1));
- checkIntStat(q4, "size", i);
- }
-
- // Let's flush the buffer and then verify it is empty.
- q4->clear();
- EXPECT_TRUE(q4->empty());
- checkIntStat(q4, "size", 0);
-}
-
-// Verifies the higher level functions of queueing and
-// dequeueing with drop and skip logic disabled.
-TEST(TestQueue4, enqueueDequeueTest) {
- PacketQueue4Ptr q4(new TestQueue4(100));
- EXPECT_TRUE(q4->empty());
-
- SocketInfo sock1(isc::asiolink::IOAddress("127.0.0.1"), 777, 10);
-
- // Enqueue the first packet.
- Pkt4Ptr pkt(new Pkt4(DHCPDISCOVER, 1002));
- ASSERT_NO_THROW(q4->enqueuePacket(pkt, sock1));
- checkIntStat(q4, "size", 1);
-
- // Enqueue a packet onto the front.
- pkt.reset(new Pkt4(DHCPDISCOVER, 1003));
- ASSERT_NO_THROW(q4->enqueuePacket(pkt, sock1, QueueEnd::FRONT));
- checkIntStat(q4, "size", 2);
-
- // Enqueue a packet onto the back.
- pkt.reset(new Pkt4(DHCPDISCOVER, 1001));
- ASSERT_NO_THROW(q4->enqueuePacket(pkt, sock1, QueueEnd::BACK));
- checkIntStat(q4, "size", 3);
-
- // By default we dequeue from the front. We should get transid 1003.
- ASSERT_NO_THROW(pkt = q4->dequeuePacket());
- ASSERT_TRUE(pkt);
- EXPECT_EQ(1003, pkt->getTransid());
-
- // Dequeue from the back, we should get transid 1001.
- ASSERT_NO_THROW(pkt = q4->dequeuePacket(QueueEnd::BACK));
- ASSERT_TRUE(pkt);
- EXPECT_EQ(1001, pkt->getTransid());
-
- // Dequeue from the front, we should get transid 1002.
- ASSERT_NO_THROW(pkt = q4->dequeuePacket(QueueEnd::FRONT));
- ASSERT_TRUE(pkt);
- EXPECT_EQ(1002, pkt->getTransid());
-
- // Queue should be empty.
- ASSERT_NO_THROW(pkt = q4->dequeuePacket());
+ ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::BACK));
ASSERT_FALSE(pkt);
}
// This accesses it's queue instance as a TestQueue4, rather than
// a PacketQueue4Ptr, to provide access to TestQueue4 specifics.
TEST(TestQueue4, shouldDropPacketTest) {
- TestQueue4 q4(100);
- EXPECT_TRUE(q4.empty());
- ASSERT_FALSE(q4.drop_enabled_);
- ASSERT_EQ(0, q4.eat_count_);
+ TestQueue4 q(100);
+ EXPECT_TRUE(q.empty());
+ ASSERT_FALSE(q.drop_enabled_);
+ ASSERT_EQ(0, q.eat_count_);
- SocketInfo sockEven(isc::asiolink::IOAddress("127.0.0.1"), 888, 10);
- SocketInfo sockOdd(isc::asiolink::IOAddress("127.0.0.1"), 777, 11);
+ SocketInfo sock_even(isc::asiolink::IOAddress("127.0.0.1"), 888, 10);
+ SocketInfo sock_odd(isc::asiolink::IOAddress("127.0.0.1"), 777, 11);
// Drop is not enabled.
// We should be able to enqueue a packet with even numbered values.
Pkt4Ptr pkt(new Pkt4(DHCPDISCOVER, 1002));
- ASSERT_NO_THROW(q4.enqueuePacket(pkt, sockEven));
- EXPECT_EQ(1, q4.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_even));
+ ASSERT_EQ(1, q.getSize());
// We should be able to enqueue a packet with odd numbered values.
pkt.reset(new Pkt4(DHCPDISCOVER, 1003));
- ASSERT_NO_THROW(q4.enqueuePacket(pkt, sockOdd));
- EXPECT_EQ(2, q4.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
+ ASSERT_EQ(2, q.getSize());
// Enable drop logic.
- q4.drop_enabled_ = true;
+ q.drop_enabled_ = true;
// We should not be able to add one with an even-numbered transid.
pkt.reset(new Pkt4(DHCPDISCOVER, 1004));
- ASSERT_NO_THROW(q4.enqueuePacket(pkt, sockOdd));
- EXPECT_EQ(2, q4.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
+ ASSERT_EQ(2, q.getSize());
// We should not be able to add one with from even-numbered port.
pkt.reset(new Pkt4(DHCPDISCOVER, 1005));
- ASSERT_NO_THROW(q4.enqueuePacket(pkt, sockEven));
- EXPECT_EQ(2, q4.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_even));
+ EXPECT_EQ(2, q.getSize());
// We should be able to add one with an odd-numbered values.
pkt.reset(new Pkt4(DHCPDISCOVER, 1007));
- ASSERT_NO_THROW(q4.enqueuePacket(pkt, sockOdd));
- EXPECT_EQ(3, q4.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
+ EXPECT_EQ(3, q.getSize());
// Dequeue them and make sure they are as expected: 1002,1003, and 1007.
- ASSERT_NO_THROW(pkt = q4.dequeuePacket());
+ ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
EXPECT_EQ(1002, pkt->getTransid());
- ASSERT_NO_THROW(pkt = q4.dequeuePacket());
+ ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
EXPECT_EQ(1003, pkt->getTransid());
- ASSERT_NO_THROW(pkt = q4.dequeuePacket());
+ ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
EXPECT_EQ(1007, pkt->getTransid());
// Queue should be empty.
- ASSERT_NO_THROW(pkt = q4.dequeuePacket());
+ ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_FALSE(pkt);
}
// This accesses it's queue instance as a TestQueue4, rather than
// a PacketQueue4Ptr, to provide access to TestQueue4 specifics.
TEST(TestQueue4, eatPacketsTest) {
- TestQueue4 q4(100);
- EXPECT_TRUE(q4.empty());
- ASSERT_FALSE(q4.drop_enabled_);
- ASSERT_EQ(0, q4.eat_count_);
+ TestQueue4 q(100);
+ EXPECT_TRUE(q.empty());
+ ASSERT_FALSE(q.drop_enabled_);
+ ASSERT_EQ(0, q.eat_count_);
SocketInfo sock(isc::asiolink::IOAddress("127.0.0.1"), 888, 10);
// Let's add five packets.
for (int i = 1; i < 6; ++i) {
pkt.reset(new Pkt4(DHCPDISCOVER, 1000 + i));
- ASSERT_NO_THROW(q4.enqueuePacket(pkt, sock));
- EXPECT_EQ(i, q4.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock));
+ ASSERT_EQ(i, q.getSize());
}
- // Setting eat count to two and dequeuing (from the front, by default),
- // should discard 1001 and 1002, resulting in a dequeue of 1003.
- q4.eat_count_ = 2;
- ASSERT_NO_THROW(pkt = q4.dequeuePacket());
+ // Setting eat count to two and dequeuing should discard 1001
+ // and 1002, resulting in a dequeue of 1003.
+ q.eat_count_ = 2;
+ ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
EXPECT_EQ(1003, pkt->getTransid());
- EXPECT_EQ(2, q4.getSize());
-
- // Setting eat count to one and dequeing from the back, should discard
- // 1005 and dequeue 104.
- q4.eat_count_ = 1;
- ASSERT_NO_THROW(pkt = q4.dequeuePacket(QueueEnd::BACK));
- ASSERT_TRUE(pkt);
- EXPECT_EQ(1004, pkt->getTransid());
- EXPECT_EQ(0, q4.getSize());
+ EXPECT_EQ(2, q.getSize());
}
} // end of anonymous namespace
#include <config.h>
#include <dhcp/dhcp6.h>
-#include <dhcp/packet_queue.h>
+#include <dhcp/packet_queue_ring.h>
#include <dhcp/tests/packet_queue_testutils.h>
#include <boost/shared_ptr.hpp>
// Verifies use of the generic PacketQueue interface to
// construct a queue implementation.
-TEST(TestQueue6, interfaceBasics) {
+TEST(PacketQueueRing6, interfaceBasics) {
// Verify we can create a queue
- PacketQueue6Ptr q6(new TestQueue6(100));
- ASSERT_TRUE(q6);
+ PacketQueue6Ptr q(new PacketQueueRing6("kea-ring6",100));
+ ASSERT_TRUE(q);
// It should be empty.
- EXPECT_TRUE(q6->empty());
+ EXPECT_TRUE(q->empty());
// Type should match.
- EXPECT_EQ("kea-ring6", q6->getQueueType());
+ EXPECT_EQ("kea-ring6", q->getQueueType());
// Fetch the queue info and verify it has all the expected values.
- checkInfo(q6, "{ \"capacity\": 100, \"queue-type\": \"kea-ring6\", \"size\": 0 }");
+ checkInfo(q, "{ \"capacity\": 100, \"queue-type\": \"kea-ring6\", \"size\": 0 }");
}
-// Verifies the basic mechanics of the adding and
-// removing packets to and from the ring buffer.
-TEST(TestQueue6, ringTest) {
- PacketQueue6Ptr q6(new TestQueue6(3));
+// Verifies the higher level functions of queueing and dequeueing
+// from the ring buffer.
+TEST(PacketQueueRing6, enqueueDequeueTest) {
+ PacketQueue6Ptr q(new PacketQueueRing6("kea-ring6", 3));
// Fetch the queue info and verify it has all the expected values.
- checkInfo(q6, "{ \"capacity\": 3, \"queue-type\": \"kea-ring6\", \"size\": 0 }");
+ checkInfo(q, "{ \"capacity\": 3, \"queue-type\": \"kea-ring6\", \"size\": 0 }");
// Enqueue five packets. The first two should be pushed off.
SocketInfo sock1(isc::asiolink::IOAddress("127.0.0.1"), 777, 10);
+
for (int i = 1; i < 6; ++i) {
Pkt6Ptr pkt(new Pkt6(DHCPV6_SOLICIT, 1000+i));
- ASSERT_NO_THROW(q6->enqueuePacket(pkt, sock1));
- checkIntStat(q6, "size", (i > 3 ? 3 : i));
+ ASSERT_NO_THROW(q->enqueuePacket(pkt, sock1));
}
+
// Fetch the queue info and verify it has all the expected values.
- checkInfo(q6, "{ \"capacity\": 3, \"queue-type\": \"kea-ring6\", \"size\": 3 }");
+ checkInfo(q, "{ \"capacity\": 3, \"queue-type\": \"kea-ring6\", \"size\": 3 }");
+
+ // We should have transids 1003,1004,1005
+ Pkt6Ptr pkt;
+ for (int i = 3; i < 6; ++i) {
+ ASSERT_NO_THROW(pkt = q->dequeuePacket());
+ ASSERT_TRUE(pkt);
+ EXPECT_EQ(1000 + i, pkt->getTransid());
+ }
+
+ // Queue should be empty.
+ ASSERT_TRUE(q->empty());
+
+ // Dequeuing should fail safely, with an empty return.
+ ASSERT_NO_THROW(pkt = q->dequeuePacket());
+ ASSERT_FALSE(pkt);
+
+ // Enqueue three more packets.
+ for (int i = 0; i < 3; ++i) {
+ Pkt6Ptr pkt(new Pkt6(DHCPV6_SOLICIT, 1000+i));
+ ASSERT_NO_THROW(q->enqueuePacket(pkt, sock1));
+ }
+
+ checkIntStat(q, "size", 3);
+
+ // Let's flush the buffer and then verify it is empty.
+ q->clear();
+ EXPECT_TRUE(q->empty());
+ checkIntStat(q, "size", 0);
+}
+
+// Verifies peeking, pushing, and popping which
+// are unique to PacketQueueRing<> derivations.
+TEST(PacketQueueRing6, peekPushPopTest) {
+ PacketQueueRing6 q("kea-ring6", 3);
+
+ // Push five packets onto the end. The first two should get pushed off.
+ for (int i = 1; i < 6; ++i) {
+ Pkt6Ptr pkt(new Pkt6(DHCPV6_SOLICIT, 1000+i));
+ ASSERT_NO_THROW(q.pushPacket(pkt));
+ }
+
+ // We should have three.
+ ASSERT_EQ(3, q.getSize());
// We should have transids 1005,1004,1003 (back to front)
// Peek front should be transid 1003.
Pkt6Ptr pkt;
- ASSERT_NO_THROW(pkt = q6->peek(QueueEnd::FRONT));
+ ASSERT_NO_THROW(pkt = q.peek(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
EXPECT_EQ(1003, pkt->getTransid());
// Peek back should be transid 1005.
- ASSERT_NO_THROW(pkt = q6->peek(QueueEnd::BACK));
+ ASSERT_NO_THROW(pkt = q.peek(QueueEnd::BACK));
ASSERT_TRUE(pkt);
EXPECT_EQ(1005, pkt->getTransid());
// Pop front should return transid 1003.
- ASSERT_NO_THROW(pkt = q6->popPacket(QueueEnd::FRONT));
+ ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
EXPECT_EQ(1003, pkt->getTransid());
// Pop back should return transid 1005.
- ASSERT_NO_THROW(pkt = q6->popPacket(QueueEnd::BACK));
+ ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::BACK));
ASSERT_TRUE(pkt);
EXPECT_EQ(1005, pkt->getTransid());
// Peek front should be transid 1004.
- ASSERT_NO_THROW(pkt = q6->peek(QueueEnd::FRONT));
+ ASSERT_NO_THROW(pkt = q.peek(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
EXPECT_EQ(1004, pkt->getTransid());
// Peek back should be transid 1004.
- ASSERT_NO_THROW(pkt = q6->peek(QueueEnd::BACK));
+ ASSERT_NO_THROW(pkt = q.peek(QueueEnd::BACK));
ASSERT_TRUE(pkt);
EXPECT_EQ(1004, pkt->getTransid());
// Pop front should return transid 1004.
- ASSERT_NO_THROW(pkt = q6->popPacket(QueueEnd::FRONT));
+ ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
EXPECT_EQ(1004, pkt->getTransid());
// Pop front should return an empty pointer.
- ASSERT_NO_THROW(pkt = q6->popPacket(QueueEnd::BACK));
- ASSERT_FALSE(pkt);
-
- // Enqueue three packets.
- for (int i = 1; i < 3; ++i) {
- Pkt6Ptr pkt(new Pkt6(DHCPV6_SOLICIT, 1000+i));
- ASSERT_NO_THROW(q6->enqueuePacket(pkt, sock1));
- checkIntStat(q6, "size", i);
- }
-
- // Let's flush the buffer and then verify it is empty.
- q6->clear();
- EXPECT_TRUE(q6->empty());
- checkIntStat(q6, "size", 0);
-}
-
-// Verifies the higher level functions of queueing and
-// dequeueing with drop and skip logic disabled.
-TEST(TestQueue6, enqueueDequeueTest) {
- PacketQueue6Ptr q6(new TestQueue6(100));
- EXPECT_TRUE(q6->empty());
-
- SocketInfo sock1(isc::asiolink::IOAddress("127.0.0.1"), 777, 10);
-
- // Enqueue the first packet.
- Pkt6Ptr pkt(new Pkt6(DHCPV6_SOLICIT, 1002));
- ASSERT_NO_THROW(q6->enqueuePacket(pkt, sock1));
- checkIntStat(q6, "size", 1);
-
- // Enqueue a packet onto the front.
- pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1003));
- ASSERT_NO_THROW(q6->enqueuePacket(pkt, sock1, QueueEnd::FRONT));
- checkIntStat(q6, "size", 2);
-
- // Enqueue a packet onto the back.
- pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1001));
- ASSERT_NO_THROW(q6->enqueuePacket(pkt, sock1, QueueEnd::BACK));
- checkIntStat(q6, "size", 3);
-
- // By default we dequeue from the front. We should get transid 1003.
- ASSERT_NO_THROW(pkt = q6->dequeuePacket());
- ASSERT_TRUE(pkt);
- EXPECT_EQ(1003, pkt->getTransid());
-
- // Dequeue from the back, we should get transid 1001.
- ASSERT_NO_THROW(pkt = q6->dequeuePacket(QueueEnd::BACK));
- ASSERT_TRUE(pkt);
- EXPECT_EQ(1001, pkt->getTransid());
-
- // Dequeue from the front, we should get transid 1002.
- ASSERT_NO_THROW(pkt = q6->dequeuePacket(QueueEnd::FRONT));
- ASSERT_TRUE(pkt);
- EXPECT_EQ(1002, pkt->getTransid());
-
- // Queue should be empty.
- ASSERT_NO_THROW(pkt = q6->dequeuePacket());
+ ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::BACK));
ASSERT_FALSE(pkt);
}
// This accesses it's queue instance as a TestQueue6, rather than
// a PacketQueue6Ptr, to provide access to TestQueue6 specifics.
TEST(TestQueue6, shouldDropPacketTest) {
- TestQueue6 q6(100);
- EXPECT_TRUE(q6.empty());
- ASSERT_FALSE(q6.drop_enabled_);
- ASSERT_EQ(0, q6.eat_count_);
+ TestQueue6 q(100);
+ EXPECT_TRUE(q.empty());
+ ASSERT_FALSE(q.drop_enabled_);
+ ASSERT_EQ(0, q.eat_count_);
- SocketInfo sockEven(isc::asiolink::IOAddress("127.0.0.1"), 888, 10);
- SocketInfo sockOdd(isc::asiolink::IOAddress("127.0.0.1"), 777, 11);
+ SocketInfo sock_even(isc::asiolink::IOAddress("127.0.0.1"), 888, 10);
+ SocketInfo sock_odd(isc::asiolink::IOAddress("127.0.0.1"), 777, 11);
// Drop is not enabled.
// We should be able to enqueue a packet with even numbered values.
Pkt6Ptr pkt(new Pkt6(DHCPV6_SOLICIT, 1002));
- ASSERT_NO_THROW(q6.enqueuePacket(pkt, sockEven));
- EXPECT_EQ(1, q6.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_even));
+ ASSERT_EQ(1, q.getSize());
// We should be able to enqueue a packet with odd numbered values.
pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1003));
- ASSERT_NO_THROW(q6.enqueuePacket(pkt, sockOdd));
- EXPECT_EQ(2, q6.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
+ ASSERT_EQ(2, q.getSize());
// Enable drop logic.
- q6.drop_enabled_ = true;
+ q.drop_enabled_ = true;
// We should not be able to add one with an even-numbered transid.
pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1004));
- ASSERT_NO_THROW(q6.enqueuePacket(pkt, sockOdd));
- EXPECT_EQ(2, q6.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
+ ASSERT_EQ(2, q.getSize());
// We should not be able to add one with from even-numbered port.
pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1005));
- ASSERT_NO_THROW(q6.enqueuePacket(pkt, sockEven));
- EXPECT_EQ(2, q6.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_even));
+ EXPECT_EQ(2, q.getSize());
// We should be able to add one with an odd-numbered values.
pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1007));
- ASSERT_NO_THROW(q6.enqueuePacket(pkt, sockOdd));
- EXPECT_EQ(3, q6.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
+ EXPECT_EQ(3, q.getSize());
// Dequeue them and make sure they are as expected: 1002,1003, and 1007.
- ASSERT_NO_THROW(pkt = q6.dequeuePacket());
+ ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
EXPECT_EQ(1002, pkt->getTransid());
- ASSERT_NO_THROW(pkt = q6.dequeuePacket());
+ ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
EXPECT_EQ(1003, pkt->getTransid());
- ASSERT_NO_THROW(pkt = q6.dequeuePacket());
+ ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
EXPECT_EQ(1007, pkt->getTransid());
// Queue should be empty.
- ASSERT_NO_THROW(pkt = q6.dequeuePacket());
+ ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_FALSE(pkt);
}
// This accesses it's queue instance as a TestQueue6, rather than
// a PacketQueue6Ptr, to provide access to TestQueue6 specifics.
TEST(TestQueue6, eatPacketsTest) {
- TestQueue6 q6(100);
- EXPECT_TRUE(q6.empty());
- ASSERT_FALSE(q6.drop_enabled_);
- ASSERT_EQ(0, q6.eat_count_);
+ TestQueue6 q(100);
+ EXPECT_TRUE(q.empty());
+ ASSERT_FALSE(q.drop_enabled_);
+ ASSERT_EQ(0, q.eat_count_);
SocketInfo sock(isc::asiolink::IOAddress("127.0.0.1"), 888, 10);
// Let's add five packets.
for (int i = 1; i < 6; ++i) {
pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1000 + i));
- ASSERT_NO_THROW(q6.enqueuePacket(pkt, sock));
- EXPECT_EQ(i, q6.getSize());
+ ASSERT_NO_THROW(q.enqueuePacket(pkt, sock));
+ ASSERT_EQ(i, q.getSize());
}
- // Setting eat count to two and dequeuing (from the front, by default),
- // should discard 1001 and 1002, resulting in a dequeue of 1003.
- q6.eat_count_ = 2;
- ASSERT_NO_THROW(pkt = q6.dequeuePacket());
+ // Setting eat count to two and dequeuing should discard 1001
+ // and 1002, resulting in a dequeue of 1003.
+ q.eat_count_ = 2;
+ ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
EXPECT_EQ(1003, pkt->getTransid());
- EXPECT_EQ(2, q6.getSize());
-
- // Setting eat count to one and dequeing from the back, should discard
- // 1005 and dequeue 104.
- q6.eat_count_ = 1;
- ASSERT_NO_THROW(pkt = q6.dequeuePacket(QueueEnd::BACK));
- ASSERT_TRUE(pkt);
- EXPECT_EQ(1004, pkt->getTransid());
- EXPECT_EQ(0, q6.getSize());
+ EXPECT_EQ(2, q.getSize());
}
} // end of anonymous namespace
#include <config.h>
+#include <dhcp/packet_queue_ring.h>
#include <dhcp/packet_queue_mgr4.h>
#include <dhcp/tests/packet_queue_testutils.h>
#include <config.h>
+#include <dhcp/packet_queue_ring.h>
#include <dhcp/packet_queue_mgr6.h>
#include <dhcp/tests/packet_queue_testutils.h>
projects / thirdparty / kea.git / commitdiff
