[3958] Allocation engine allows for overriding the # of allocation attempts.

diff --git a/src/bin/dhcp4/dhcp4_srv.cc b/src/bin/dhcp4/dhcp4_srv.cc
index e30811767d918fb71e8dfd0ccb4589793836cfb5..6ade319bd709f939eb2f85182cd0459469adf771 100644 (file)
--- a/src/bin/dhcp4/dhcp4_srv.cc
+++ b/src/bin/dhcp4/dhcp4_srv.cc
@@ -240,8 +240,10 @@ Dhcpv4Srv::Dhcpv4Srv(uint16_t port, const bool use_bcast,
             IfaceMgr::instance().setMatchingPacketFilter(direct_response_desired);
         }
 
-        // Instantiate allocation engine
-        alloc_engine_.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, 100,
+        // Instantiate allocation engine. The number of allocation attempts equal
+        // to zero indicates that the allocation engine will use the number of
+        // attempts depending on the pool size.
+        alloc_engine_.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, 0,
                                             false /* false = IPv4 */));
 
         // Register hook points

diff --git a/src/bin/dhcp6/dhcp6_srv.cc b/src/bin/dhcp6/dhcp6_srv.cc
index 3e3ac334d72f2311f21e40b31f9fcaa909054314..9ad61b05b9ec2fbcbb73bdb0ea3db0bb683fd140 100644 (file)
--- a/src/bin/dhcp6/dhcp6_srv.cc
+++ b/src/bin/dhcp6/dhcp6_srv.cc
@@ -212,8 +212,10 @@ Dhcpv6Srv::Dhcpv6Srv(uint16_t port)
             }
         }
 
-        // Instantiate allocation engine
-        alloc_engine_.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, 100));
+        // Instantiate allocation engine. The number of allocation attempts equal
+        // to zero indicates that the allocation engine will use the number of
+        // attempts depending on the pool size.
+        alloc_engine_.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, 0));
 
         /// @todo call loadLibraries() when handling configuration changes
 

diff --git a/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc b/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc
index 9106c388f92758fb8134222578635d7c9c237d09..0cf9df98f10483686997b6d8c9aed52f0e2a8acf 100644 (file)
--- a/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc
+++ b/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc
@@ -1610,6 +1610,51 @@ TEST_F(AllocEngine6Test, largePoolOver32bits) {
     ASSERT_EQ(1, leases.size());
 }
 
+// This test verifies that it is possible to override the number of allocation
+// attempts made by the allocation engine for a single lease.
+TEST_F(AllocEngine6Test, largeAllocationAttemptsOverride) {
+    // Remove the default NA pools.
+    subnet_->delPools(Lease::TYPE_NA);
+
+    // Add exactly one pool with many addresses.
+    Pool6Ptr pool(new Pool6(Lease::TYPE_NA, IOAddress("2001:db8:1::"), 56));
+    subnet_->addPool(pool);
+
+    // Allocate 5 addresses from the pool configured.
+    for (int i = 0; i < 5; ++i) {
+        DuidPtr duid = DuidPtr(new DUID(vector<uint8_t>(12,
+                                                        static_cast<uint8_t>(i))));
+        // Get the unique IAID.
+        const uint32_t iaid = 3568 + i;
+
+        // Construct the unique address from the pool.
+        std::ostringstream address;
+        address << "2001:db8:1::";
+        address << i;
+
+        // Allocate the leease.
+        Lease6Ptr lease(new Lease6(Lease::TYPE_NA, IOAddress(address.str()),
+                                   duid, iaid, 501, 502, 503, 504, subnet_->getID(),
+                                   HWAddrPtr(), 0));
+        ASSERT_TRUE(LeaseMgrFactory::instance().addLease(lease));
+    }
+
+    // Try to use the allocation engine to allocate the lease. The iterative
+    // allocator will pick the addresses already allocated until it finds the
+    // available address. Since, we have restricted the number of attempts the
+    // allocation should fail.
+    AllocEngine engine(AllocEngine::ALLOC_ITERATIVE, 3);
+    Lease6Collection leases = allocateTest(engine, pool_, IOAddress("::"),
+                                           false, true);
+    ASSERT_EQ(0, leases.size());
+
+    // This time, lets allow more attempts, and expect that the allocation will
+    // be successful.
+    AllocEngine engine2(AllocEngine::ALLOC_ITERATIVE, 6);
+    leases = allocateTest(engine2, pool_, IOAddress("::"), false, true);
+    ASSERT_EQ(1, leases.size());
+}
+
 }; // namespace test
 }; // namespace dhcp
 }; // namespace isc