[#1418] Changed remaining_ for reusable_

diff --git a/src/bin/dhcp4/dhcp4_srv.cc b/src/bin/dhcp4/dhcp4_srv.cc
index 4739e88446be329111415e172c9d847cadb00f07..1e7ec87f7bbfbd6cfdae1010f4684d05b050d081 100644 (file)
--- a/src/bin/dhcp4/dhcp4_srv.cc
+++ b/src/bin/dhcp4/dhcp4_srv.cc
@@ -1354,7 +1354,7 @@ Dhcpv4Srv::processDhcp4Query(Pkt4Ptr& query, Pkt4Ptr& rsp,
         callout_handle->setArgument("query4", query);
 
         Lease4CollectionPtr new_leases(new Lease4Collection());
-        if (ctx->new_lease_ && (ctx->new_lease_->remaining_valid_lft_ == 0)) {
+        if (ctx->new_lease_ && (ctx->new_lease_->reuseable_valid_lft_ == 0)) {
             new_leases->push_back(ctx->new_lease_);
         }
         callout_handle->setArgument("leases4", new_leases);
@@ -2509,8 +2509,8 @@ Dhcpv4Srv::assignLease(Dhcpv4Exchange& ex) {
         postAllocateNameUpdate(ctx, lease, query, resp, client_name_changed);
 
         // Reuse the lease if possible.
-        if (lease->remaining_valid_lft_ > 0) {
-            lease->valid_lft_ = lease->remaining_valid_lft_;
+        if (lease->reuseable_valid_lft_ > 0) {
+            lease->valid_lft_ = lease->reuseable_valid_lft_;
             LOG_INFO(lease4_logger, DHCP4_LEASE_REUSE)
                 .arg(query->getLabel())
                 .arg(lease->addr_.toText())
@@ -2602,7 +2602,7 @@ Dhcpv4Srv::postAllocateNameUpdate(const AllocEngine::ClientContext4Ptr& ctx, con
         try {
             if (!ctx->fake_allocation_) {
                 // The lease can't be reused.
-                lease->remaining_valid_lft_ = 0;
+                lease->reuseable_valid_lft_ = 0;
 
                 // The lease update should be safe, because the lease should
                 // be already in the database. In most cases the exception

diff --git a/src/bin/dhcp6/dhcp6_srv.cc b/src/bin/dhcp6/dhcp6_srv.cc
index 13d4040f60b502784dd815e38571c60a851fafd0..b75c434401095642c8f1133aa1354bf6a9eb1d70 100644 (file)
--- a/src/bin/dhcp6/dhcp6_srv.cc
+++ b/src/bin/dhcp6/dhcp6_srv.cc
@@ -1005,7 +1005,7 @@ Dhcpv6Srv::processDhcp6Query(Pkt6Ptr& query, Pkt6Ptr& rsp) {
         Lease6CollectionPtr new_leases(new Lease6Collection());
         if (!ctx.new_leases_.empty()) {
             for (auto new_lease : ctx.new_leases_) {
-                if (new_lease->remaining_valid_lft_ == 0) {
+                if (new_lease->reuseable_valid_lft_ == 0) {
                     new_leases->push_back(new_lease);
                 }
             }
@@ -2065,15 +2065,15 @@ Dhcpv6Srv::assignIA_NA(const Pkt6Ptr& query, const Pkt6Ptr& answer,
                 .arg(query->getLabel())
                 .arg(lease->addr_.toText())
                 .arg(ia->getIAID());
-        } else if (lease->remaining_valid_lft_ == 0) {
+        } else if (lease->reuseable_valid_lft_ == 0) {
             LOG_INFO(lease6_logger, DHCP6_LEASE_ALLOC)
                 .arg(query->getLabel())
                 .arg(lease->addr_.toText())
                 .arg(ia->getIAID())
                 .arg(Lease::lifetimeToText(lease->valid_lft_));
         } else {
-            lease->valid_lft_ = lease->remaining_valid_lft_;
-            lease->preferred_lft_ = lease->remaining_preferred_lft_;
+            lease->valid_lft_ = lease->reuseable_valid_lft_;
+            lease->preferred_lft_ = lease->reuseable_preferred_lft_;
             LOG_INFO(lease6_logger, DHCP6_LEASE_REUSE)
                 .arg(query->getLabel())
                 .arg(lease->addr_.toText())
@@ -2189,7 +2189,7 @@ Dhcpv6Srv::assignIA_PD(const Pkt6Ptr& query, const Pkt6Ptr& /*answer*/,
                     .arg((*l)->addr_.toText())
                     .arg(static_cast<int>((*l)->prefixlen_))
                     .arg(ia->getIAID());
-            } else if ((*l)->remaining_valid_lft_ == 0) {
+            } else if ((*l)->reuseable_valid_lft_ == 0) {
                 LOG_INFO(lease6_logger, DHCP6_PD_LEASE_ALLOC)
                     .arg(query->getLabel())
                     .arg((*l)->addr_.toText())
@@ -2197,8 +2197,8 @@ Dhcpv6Srv::assignIA_PD(const Pkt6Ptr& query, const Pkt6Ptr& /*answer*/,
                     .arg(ia->getIAID())
                     .arg(Lease::lifetimeToText((*l)->valid_lft_));
             } else {
-                (*l)->valid_lft_ = (*l)->remaining_valid_lft_;
-                (*l)->preferred_lft_ = (*l)->remaining_preferred_lft_;
+                (*l)->valid_lft_ = (*l)->reuseable_valid_lft_;
+                (*l)->preferred_lft_ = (*l)->reuseable_preferred_lft_;
                 LOG_INFO(lease6_logger, DHCP6_PD_LEASE_REUSE)
                     .arg(query->getLabel())
                     .arg((*l)->addr_.toText())
@@ -2345,14 +2345,14 @@ Dhcpv6Srv::extendIA_NA(const Pkt6Ptr& query, const Pkt6Ptr& answer,
 
     // For all leases we have now, add the IAADDR with non-zero lifetimes.
     for (Lease6Collection::iterator l = leases.begin(); l != leases.end(); ++l) {
-        if ((*l)->remaining_valid_lft_ == 0) {
+        if ((*l)->reuseable_valid_lft_ == 0) {
             LOG_INFO(lease6_logger, DHCP6_LEASE_RENEW)
                 .arg(query->getLabel())
                 .arg((*l)->addr_.toText())
                 .arg(ia->getIAID());
         } else {
-            (*l)->valid_lft_ = (*l)->remaining_valid_lft_;
-            (*l)->preferred_lft_ = (*l)->remaining_preferred_lft_;
+            (*l)->valid_lft_ = (*l)->reuseable_valid_lft_;
+            (*l)->preferred_lft_ = (*l)->reuseable_preferred_lft_;
             LOG_INFO(lease6_logger, DHCP6_LEASE_REUSE)
                 .arg(query->getLabel())
                 .arg((*l)->addr_.toText())
@@ -2533,15 +2533,15 @@ Dhcpv6Srv::extendIA_PD(const Pkt6Ptr& query,
     uint32_t min_preferred_lft = std::numeric_limits<uint32_t>::max();
 
     for (Lease6Collection::iterator l = leases.begin(); l != leases.end(); ++l) {
-        if ((*l)->remaining_valid_lft_ == 0) {
+        if ((*l)->reuseable_valid_lft_ == 0) {
             LOG_INFO(lease6_logger, DHCP6_PD_LEASE_RENEW)
                 .arg(query->getLabel())
                 .arg((*l)->addr_.toText())
                 .arg(static_cast<int>((*l)->prefixlen_))
                 .arg(ia->getIAID());
         } else {
-            (*l)->valid_lft_ = (*l)->remaining_valid_lft_;
-            (*l)->preferred_lft_ = (*l)->remaining_preferred_lft_;
+            (*l)->valid_lft_ = (*l)->reuseable_valid_lft_;
+            (*l)->preferred_lft_ = (*l)->reuseable_preferred_lft_;
             LOG_INFO(lease6_logger, DHCP6_PD_LEASE_REUSE)
                 .arg(query->getLabel())
                 .arg((*l)->addr_.toText())
@@ -4013,7 +4013,7 @@ Dhcpv6Srv::generateFqdn(const Pkt6Ptr& answer,
             }
             if (lease) {
                 lease->hostname_ = generated_name;
-                lease->remaining_valid_lft_ = 0;
+                lease->reuseable_valid_lft_ = 0;
                 LeaseMgrFactory::instance().updateLease6(lease);
 
             } else {
@@ -4336,7 +4336,7 @@ Dhcpv6Srv::checkDynamicSubnetChange(const Pkt6Ptr& question, Pkt6Ptr& answer,
             (*l)->hostname_ = ctx.hostname_;
             (*l)->fqdn_fwd_ = ctx.fwd_dns_update_;
             (*l)->fqdn_rev_ = ctx.rev_dns_update_;
-            (*l)->remaining_valid_lft_ = 0;
+            (*l)->reuseable_valid_lft_ = 0;
             LeaseMgrFactory::instance().updateLease6(*l);
         }
     }

diff --git a/src/lib/dhcpsrv/alloc_engine.cc b/src/lib/dhcpsrv/alloc_engine.cc
index 01cd7547392b760c7f60560e44ddf28db5e4fbd3..11997b1cfc49d0d0f911cc7a74eb8652a941673a 100644 (file)
--- a/src/lib/dhcpsrv/alloc_engine.cc
+++ b/src/lib/dhcpsrv/alloc_engine.cc
@@ -1750,7 +1750,7 @@ AllocEngine::reuseExpiredLease(Lease6Ptr& expired, ClientContext6& ctx,
     }
     // Use subnet's valid triplet to conditionally determine
     // valid lifetime based on hint
-    expired->remaining_valid_lft_ = 0;
+    expired->reuseable_valid_lft_ = 0;
     if (!ctx.currentIA().hints_.empty() &&
         ctx.currentIA().hints_[0].getValid()) {
         uint32_t valid = ctx.currentIA().hints_[0].getValid();
@@ -2150,7 +2150,7 @@ AllocEngine::extendLease6(ClientContext6& ctx, Lease6Ptr lease) {
     if (lease->preferred_lft_ < current_preferred_lft) {
         changed = true;
     }
-    lease->remaining_valid_lft_ = 0;
+    lease->reuseable_valid_lft_ = 0;
     if (!ctx.currentIA().hints_.empty() &&
         ctx.currentIA().hints_[0].getValid()) {
         uint32_t valid = ctx.currentIA().hints_[0].getValid();
@@ -2254,13 +2254,13 @@ AllocEngine::extendLease6(ClientContext6& ctx, Lease6Ptr lease) {
 
         // Try to reuse the lease.
         if (!changed) {
-            setLeaseRemainingLife(lease, current_preferred_lft, ctx);
+            setLeaseReusable(lease, current_preferred_lft, ctx);
         }
 
 
         // Now that the lease has been reclaimed, we can go ahead and update it
         // in the lease database.
-        if (lease->remaining_valid_lft_ == 0) {
+        if (lease->reuseable_valid_lft_ == 0) {
             LeaseMgrFactory::instance().updateLease6(lease);
         }
 
@@ -2307,7 +2307,7 @@ AllocEngine::updateLeaseData(ClientContext6& ctx, const Lease6Collection& leases
             continue;
         }
 
-        lease->remaining_valid_lft_ = 0;
+        lease->reuseable_valid_lft_ = 0;
         lease->fqdn_fwd_ = ctx.fwd_dns_update_;
         lease->fqdn_rev_ = ctx.rev_dns_update_;
         lease->hostname_ = ctx.hostname_;
@@ -2332,9 +2332,9 @@ AllocEngine::updateLeaseData(ClientContext6& ctx, const Lease6Collection& leases
             lease->cltt_ = time(NULL);
             if (!fqdn_changed) {
                 uint32_t current_preferred_lft = lease->preferred_lft_;
-                setLeaseRemainingLife(lease, current_preferred_lft, ctx);
+                setLeaseReusable(lease, current_preferred_lft, ctx);
             }
-            if (lease->remaining_valid_lft_ == 0) {
+            if (lease->reuseable_valid_lft_ == 0) {
                 ctx.currentIA().changed_leases_.push_back(*lease_it);
                 LeaseMgrFactory::instance().updateLease6(lease);
             }
@@ -2987,7 +2987,7 @@ void AllocEngine::reclaimLeaseInDatabase(const LeasePtrType& lease,
     } else if (lease_update_fun) {
         // Clear FQDN information as we have already sent the
         // name change request to remove the DNS record.
-        lease->remaining_valid_lft_ = 0;
+        lease->reuseable_valid_lft_ = 0;
         lease->hostname_.clear();
         lease->fqdn_fwd_ = false;
         lease->fqdn_rev_ = false;
@@ -3935,9 +3935,9 @@ AllocEngine::renewLease4(const Lease4Ptr& lease,
 
     // Update the lease with the information from the context.
     // If there was no significant changes, try reuse.
-    lease->remaining_valid_lft_ = 0;
+    lease->reuseable_valid_lft_ = 0;
     if (!updateLease4Information(lease, ctx)) {
-        setLeaseRemainingLife(lease, ctx);
+        setLeaseReusable(lease, ctx);
     }
 
     if (!ctx.fake_allocation_) {
@@ -4000,7 +4000,7 @@ AllocEngine::renewLease4(const Lease4Ptr& lease,
         /// DROP status does not make sense here.
     }
 
-    if (!ctx.fake_allocation_ && !skip && (lease->remaining_valid_lft_ == 0)) {
+    if (!ctx.fake_allocation_ && !skip && (lease->reuseable_valid_lft_ == 0)) {
         // for REQUEST we do update the lease
         LeaseMgrFactory::instance().updateLease4(lease);
 
@@ -4047,7 +4047,7 @@ AllocEngine::reuseExpiredLease4(Lease4Ptr& expired,
         expired->state_ = Lease::STATE_DEFAULT;
     }
 
-    expired->remaining_valid_lft_ = 0;
+    expired->reuseable_valid_lft_ = 0;
     static_cast<void>(updateLease4Information(expired, ctx));
 
     LOG_DEBUG(alloc_engine_logger, ALLOC_ENGINE_DBG_TRACE_DETAIL_DATA,
@@ -4477,10 +4477,10 @@ AllocEngine::updateLease6ExtendedInfo(const Lease6Ptr& lease,
 }
 
 void
-AllocEngine::setLeaseRemainingLife(const Lease4Ptr& lease,
-                                   const ClientContext4& ctx) const {
+AllocEngine::setLeaseReusable(const Lease4Ptr& lease,
+                              const ClientContext4& ctx) const {
     // Sanity.
-    lease->remaining_valid_lft_ = 0;
+    lease->reuseable_valid_lft_ = 0;
     const Subnet4Ptr& subnet = ctx.subnet_;
     if (!subnet) {
         return;
@@ -4491,7 +4491,7 @@ AllocEngine::setLeaseRemainingLife(const Lease4Ptr& lease,
 
     // Always reuse infinite lifetime leases.
     if (lease->valid_lft_ == Lease::INFINITY_LFT) {
-        lease->remaining_valid_lft_ = Lease::INFINITY_LFT;
+        lease->reuseable_valid_lft_ = Lease::INFINITY_LFT;
         return;
     }
 
@@ -4533,16 +4533,16 @@ AllocEngine::setLeaseRemainingLife(const Lease4Ptr& lease,
     }
 
     // Seems to be reusable.
-    lease->remaining_valid_lft_ = lease->current_valid_lft_ - age;
+    lease->reuseable_valid_lft_ = lease->current_valid_lft_ - age;
 }
 
 void
-AllocEngine::setLeaseRemainingLife(const Lease6Ptr& lease,
-                                   uint32_t current_preferred_lft,
-                                   const ClientContext6& ctx) const {
+AllocEngine::setLeaseReusable(const Lease6Ptr& lease,
+                              uint32_t current_preferred_lft,
+                              const ClientContext6& ctx) const {
     // Sanity.
-    lease->remaining_valid_lft_ = 0;
-    lease->remaining_preferred_lft_ = 0;
+    lease->reuseable_valid_lft_ = 0;
+    lease->reuseable_preferred_lft_ = 0;
     const Subnet6Ptr& subnet = ctx.subnet_;
     if (!subnet) {
         return;
@@ -4592,17 +4592,17 @@ AllocEngine::setLeaseRemainingLife(const Lease6Ptr& lease,
     if ((current_preferred_lft == Lease::INFINITY_LFT) ||
         (current_preferred_lft == 0)) {
         // Keep these values.
-        lease->remaining_preferred_lft_ = current_preferred_lft;
+        lease->reuseable_preferred_lft_ = current_preferred_lft;
     } else if (current_preferred_lft > age) {
-        lease->remaining_preferred_lft_ = current_preferred_lft - age;
+        lease->reuseable_preferred_lft_ = current_preferred_lft - age;
     } else {
         // Can be a misconfiguration so stay safe...
         return;
     }
     if (lease->current_valid_lft_ == Lease::INFINITY_LFT) {
-        lease->remaining_valid_lft_ = Lease::INFINITY_LFT;
+        lease->reuseable_valid_lft_ = Lease::INFINITY_LFT;
     } else {
-        lease->remaining_valid_lft_ = lease->current_valid_lft_ - age;
+        lease->reuseable_valid_lft_ = lease->current_valid_lft_ - age;
     }
 }
 

diff --git a/src/lib/dhcpsrv/alloc_engine.h b/src/lib/dhcpsrv/alloc_engine.h
index f64eac151c23fc9b99b30a64bafb884f06763b74..670066664cff4a1ccaa5fb7b2f1299aeff8b74dc 100644 (file)
--- a/src/lib/dhcpsrv/alloc_engine.h
+++ b/src/lib/dhcpsrv/alloc_engine.h
@@ -1874,27 +1874,27 @@ private:
 
     /// @brief Try to reuse an already allocated lease.
     ///
-    /// This function computes and sets when acceptable the remaining
+    /// This function computes and sets when acceptable the reusable
     /// valid lifetime of an already allocated lease.
     /// This uses the cache-threshold and cache-max-age parameters.
     ///
-    /// A not zero value for the remaining valid lifetime means the
+    /// A not zero value for the reusable valid lifetime means the
     /// lease can reuse i.e.:
     ///  - the lease is not updated in the lease database.
     ///  - the previous value of the lease can be returned to the client.
     ///
     /// @param [in,out] lease A pointer to the lease to be updated.
     /// @param subnet A pointer to the lease subnet.
-    void setLeaseRemainingLife(const Lease4Ptr& lease,
-                               const ClientContext4& ctx) const;
+    void setLeaseReusable(const Lease4Ptr& lease,
+                          const ClientContext4& ctx) const;
 
     /// @brief Try to reuse an already allocated lease.
     ///
-    /// This function computes and sets when acceptable the remaining
+    /// This function computes and sets when acceptable the reusable
     /// valid lifetime of an already allocated lease.
     /// This uses the cache-threshold and cache-max-age parameters.
     ///
-    /// A not zero value for the remaining valid lifetime means the
+    /// A not zero value for the reusable valid lifetime means the
     /// lease can reuse i.e.:
     ///  - the lease is not updated in the lease database.
     ///  - the previous value of the lease can be returned to the client.
@@ -1902,9 +1902,9 @@ private:
     /// @param [in,out] lease A pointer to the lease to be updated.
     /// @param current_preferred_lft Current preferred lease lifetime.
     /// @param subnet A pointer to the lease subnet.
-    void setLeaseRemainingLife(const Lease6Ptr& lease,
-                               uint32_t current_preferred_lft,
-                               const ClientContext6& ctx) const;
+    void setLeaseReusable(const Lease6Ptr& lease,
+                          uint32_t current_preferred_lft,
+                          const ClientContext6& ctx) const;
 
 private:
 

diff --git a/src/lib/dhcpsrv/lease.cc b/src/lib/dhcpsrv/lease.cc
index a05b78ee482d15b735160dc64a176355df64f0fa..df29c37ab90096001ab2eb6fe49139e4382494ab 100644 (file)
--- a/src/lib/dhcpsrv/lease.cc
+++ b/src/lib/dhcpsrv/lease.cc
@@ -41,7 +41,7 @@ Lease::Lease(const isc::asiolink::IOAddress& addr,
              const bool fqdn_fwd, const bool fqdn_rev,
              const std::string& hostname, const HWAddrPtr& hwaddr)
     : addr_(addr), valid_lft_(valid_lft), current_valid_lft_(valid_lft),
-      remaining_valid_lft_(0),
+      reuseable_valid_lft_(0),
       cltt_(cltt), current_cltt_(cltt), subnet_id_(subnet_id),
       hostname_(boost::algorithm::to_lower_copy(hostname)), fqdn_fwd_(fqdn_fwd),
       fqdn_rev_(fqdn_rev), hwaddr_(hwaddr), state_(STATE_DEFAULT) {
@@ -392,7 +392,7 @@ Lease4::operator=(const Lease4& other) {
         addr_ = other.addr_;
         valid_lft_ = other.valid_lft_;
         current_valid_lft_ = other.current_valid_lft_;
-        remaining_valid_lft_ = other.remaining_valid_lft_;
+        reuseable_valid_lft_ = other.reuseable_valid_lft_;
         cltt_ = other.cltt_;
         current_cltt_ = other.current_cltt_;
         subnet_id_ = other.subnet_id_;
@@ -489,7 +489,7 @@ Lease6::Lease6(Lease::Type type, const isc::asiolink::IOAddress& addr,
                SubnetID subnet_id, const HWAddrPtr& hwaddr, uint8_t prefixlen)
     : Lease(addr, valid, subnet_id, 0/*cltt*/, false, false, "", hwaddr),
       type_(type), prefixlen_(prefixlen), iaid_(iaid), duid_(duid),
-      preferred_lft_(preferred), remaining_preferred_lft_(0) {
+      preferred_lft_(preferred), reuseable_preferred_lft_(0) {
     if (!duid) {
         isc_throw(InvalidOperation, "DUID is mandatory for an IPv6 lease");
     }
@@ -506,7 +506,7 @@ Lease6::Lease6(Lease::Type type, const isc::asiolink::IOAddress& addr,
     : Lease(addr, valid, subnet_id, 0/*cltt*/,
             fqdn_fwd, fqdn_rev, hostname, hwaddr),
       type_(type), prefixlen_(prefixlen), iaid_(iaid), duid_(duid),
-      preferred_lft_(preferred), remaining_preferred_lft_(0) {
+      preferred_lft_(preferred), reuseable_preferred_lft_(0) {
     if (!duid) {
         isc_throw(InvalidOperation, "DUID is mandatory for an IPv6 lease");
     }
@@ -518,7 +518,7 @@ Lease6::Lease6(Lease::Type type, const isc::asiolink::IOAddress& addr,
 Lease6::Lease6()
     : Lease(isc::asiolink::IOAddress("::"), 0, 0, 0, false, false, "",
             HWAddrPtr()), type_(TYPE_NA), prefixlen_(0), iaid_(0),
-            duid_(DuidPtr()), preferred_lft_(0), remaining_preferred_lft_(0) {
+            duid_(DuidPtr()), preferred_lft_(0), reuseable_preferred_lft_(0) {
 }
 
 std::string
@@ -602,7 +602,7 @@ Lease4::operator==(const Lease4& other) const {
             subnet_id_ == other.subnet_id_ &&
             valid_lft_ == other.valid_lft_ &&
             current_valid_lft_ == other.current_valid_lft_ &&
-            remaining_valid_lft_ == other.remaining_valid_lft_ &&
+            reuseable_valid_lft_ == other.reuseable_valid_lft_ &&
             cltt_ == other.cltt_ &&
             current_cltt_ == other.current_cltt_ &&
             hostname_ == other.hostname_ &&
@@ -621,10 +621,10 @@ Lease6::operator==(const Lease6& other) const {
             prefixlen_ == other.prefixlen_ &&
             iaid_ == other.iaid_ &&
             preferred_lft_ == other.preferred_lft_ &&
-            remaining_preferred_lft_ == other.remaining_preferred_lft_ &&
+            reuseable_preferred_lft_ == other.reuseable_preferred_lft_ &&
             valid_lft_ == other.valid_lft_ &&
             current_valid_lft_ == other.current_valid_lft_ &&
-            remaining_valid_lft_ == other.remaining_valid_lft_ &&
+            reuseable_valid_lft_ == other.reuseable_valid_lft_ &&
             cltt_ == other.cltt_ &&
             current_cltt_ == other.current_cltt_ &&
             subnet_id_ == other.subnet_id_ &&

diff --git a/src/lib/dhcpsrv/lease.h b/src/lib/dhcpsrv/lease.h
index 25ca007ff633195646e8e9050b07bfd41f5f42bf..ab7ab66c4494d79fb3ac71476aeb266915b3f3ee 100644 (file)
--- a/src/lib/dhcpsrv/lease.h
+++ b/src/lib/dhcpsrv/lease.h
@@ -133,7 +133,7 @@ struct Lease : public isc::data::UserContext, public isc::data::CfgToElement {
     /// Expressed as number of seconds since current time, also
     /// valid lifetime - age where age is old cltt - new cltt.
     /// The value 0 is used for the "cannot be reused" condition.
-    uint32_t remaining_valid_lft_;
+    uint32_t reuseable_valid_lft_;
 
     /// @brief Client last transmission time
     ///
@@ -532,9 +532,9 @@ struct Lease6 : public Lease {
     ///
     /// Expressed as number of seconds since current time, also
     /// preferred lifetime - age where age is old cltt - new cltt.
-    /// This parameter is used only when remaining_valid_lft_ is not zero,
+    /// This parameter is used only when reuseable_valid_lft_ is not zero,
     /// i.e. when the lease can be reused.
-    uint32_t remaining_preferred_lft_;
+    uint32_t reuseable_preferred_lft_;
 
     /// @todo: Add DHCPv6 failover related fields here
 

diff --git a/src/lib/dhcpsrv/libdhcpsrv.dox b/src/lib/dhcpsrv/libdhcpsrv.dox
index b5453614c24e84f287217f346622b9319d85c344..96f39884dae78de5ede0ffe5dc1b6a106065e044 100644 (file)
--- a/src/lib/dhcpsrv/libdhcpsrv.dox
+++ b/src/lib/dhcpsrv/libdhcpsrv.dox
@@ -278,7 +278,7 @@ The allocation engine provides a cache-like feature: when a suitable
 lease already exists for a client if its age is small enough compared
 to the valid lifetime (threshold parameter) and below a configured maximum
 (max age parameter) the lease can be reused. A reusable lease is marked
-by a not zero remaining_valid_lft_ value.
+by a not zero reuseable_valid_lft_ value.
 
 @section timerManager Timer Manager
 

diff --git a/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc b/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc
index 9f3ce773d6a52a1c8310563f22d74de66263c1d5..cf5579243360b363c5a0f7b94057637e9da9f1b6 100644 (file)
--- a/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc
+++ b/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc
@@ -3871,7 +3871,7 @@ TEST_F(AllocEngine4Test, discoverCacheThreshold4) {
     time_t age = lease->cltt_ - now;
     EXPECT_GE(age, 100);
     EXPECT_LE(age, 110);
-    EXPECT_EQ(500 - age, lease->remaining_valid_lft_);
+    EXPECT_EQ(500 - age, lease->reuseable_valid_lft_);
 
     // Check other lease parameters.
     EXPECT_EQ(lease->subnet_id_, subnet_->getID());
@@ -3918,7 +3918,7 @@ TEST_F(AllocEngine4Test, requestCacheThreshold4) {
     time_t age = lease->cltt_ - now;
     EXPECT_GE(age, 100);
     EXPECT_LE(age, 110);
-    EXPECT_EQ(500 - age, lease->remaining_valid_lft_);
+    EXPECT_EQ(500 - age, lease->reuseable_valid_lft_);
 
     // Check other lease parameters.
     EXPECT_EQ(lease->subnet_id_, subnet_->getID());
@@ -3972,7 +3972,7 @@ TEST_F(AllocEngine4Test, discoverCacheMaxAge4) {
     time_t age = lease->cltt_ - now;
     EXPECT_GE(age, 100);
     EXPECT_LE(age, 110);
-    EXPECT_EQ(500 - age, lease->remaining_valid_lft_);
+    EXPECT_EQ(500 - age, lease->reuseable_valid_lft_);
 
     // Check other lease parameters.
     EXPECT_EQ(lease->subnet_id_, subnet_->getID());
@@ -4022,7 +4022,7 @@ TEST_F(AllocEngine4Test, requestCacheBoth4) {
     time_t age = lease->cltt_ - now;
     EXPECT_GE(age, 100);
     EXPECT_LE(age, 110);
-    EXPECT_EQ(500 - age, lease->remaining_valid_lft_);
+    EXPECT_EQ(500 - age, lease->reuseable_valid_lft_);
 
     // Check other lease parameters.
     EXPECT_EQ(lease->subnet_id_, subnet_->getID());
@@ -4070,7 +4070,7 @@ TEST_F(AllocEngine4Test, discoverCacheBadThreshold4) {
     EXPECT_EQ(addr, lease->addr_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 }
 
 // This test checks if a lease can't be reused in DHCPREQUEST (real allocation)
@@ -4107,7 +4107,7 @@ TEST_F(AllocEngine4Test, requestCacheBadMaxAge4) {
     EXPECT_EQ(addr, lease->addr_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease4Ptr from_mgr = LeaseMgrFactory::instance().getLease4(addr);
@@ -4148,7 +4148,7 @@ TEST_F(AllocEngine4Test, discoverCacheReducedValid4) {
     EXPECT_EQ(addr, lease->addr_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 }
 
 // This test checks if a lease can't be reused in DHCPREQUEST (real allocation)
@@ -4182,7 +4182,7 @@ TEST_F(AllocEngine4Test, requestCacheFwdDDNS4) {
     EXPECT_EQ(addr, lease->addr_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease4Ptr from_mgr = LeaseMgrFactory::instance().getLease4(addr);
@@ -4226,7 +4226,7 @@ TEST_F(AllocEngine4Test, discoverCacheRevDDNS4) {
     EXPECT_EQ(addr, lease->addr_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 }
 
 // This test checks if a lease can't be reused in DHCPREQUEST (real allocation)
@@ -4261,7 +4261,7 @@ TEST_F(AllocEngine4Test, requestCacheHostname4) {
     EXPECT_EQ(addr, lease->addr_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
     EXPECT_EQ("bar", lease->hostname_);
 
     // Check the lease was updated in the database.

diff --git a/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc b/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc
index ece87a1dc05c6a656299857cf6e8268fcf369be8..4ae41d9dc8cdefec730986a90cfb9d5efc4869b4 100644 (file)
--- a/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc
+++ b/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc
@@ -4425,7 +4425,7 @@ TEST_F(AllocEngine6Test, solicitNoCache) {
     EXPECT_EQ(128, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was not updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -4469,8 +4469,8 @@ TEST_F(AllocEngine6Test, requestCacheThreshold6) {
     time_t age = lease->cltt_ - now;
     EXPECT_GE(age, 100);
     EXPECT_LE(age, 110);
-    EXPECT_EQ(400 - age, lease->remaining_valid_lft_);
-    EXPECT_EQ(300 - age, lease->remaining_preferred_lft_);
+    EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
+    EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
 
     // Check other lease parameters.
     EXPECT_TRUE(*lease->duid_ == *duid_);
@@ -4521,8 +4521,8 @@ TEST_F(AllocEngine6Test, renewCacheThreshold6) {
     time_t age = lease->cltt_ - now;
     EXPECT_GE(age, 100);
     EXPECT_LE(age, 110);
-    EXPECT_EQ(400 - age, lease->remaining_valid_lft_);
-    EXPECT_EQ(300 - age, lease->remaining_preferred_lft_);
+    EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
+    EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
 
     // Check other lease parameters.
     EXPECT_TRUE(*lease->duid_ == *duid_);
@@ -4570,8 +4570,8 @@ TEST_F(AllocEngine6Test, requestCacheMaxAge6) {
     time_t age = lease->cltt_ - now;
     EXPECT_GE(age, 100);
     EXPECT_LE(age, 110);
-    EXPECT_EQ(400 - age, lease->remaining_valid_lft_);
-    EXPECT_EQ(300 - age, lease->remaining_preferred_lft_);
+    EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
+    EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
 
     // Check other lease parameters.
     EXPECT_TRUE(*lease->duid_ == *duid_);
@@ -4622,8 +4622,8 @@ TEST_F(AllocEngine6Test, renewCacheMaxAge6) {
     time_t age = lease->cltt_ - now;
     EXPECT_GE(age, 100);
     EXPECT_LE(age, 110);
-    EXPECT_EQ(400 - age, lease->remaining_valid_lft_);
-    EXPECT_EQ(300 - age, lease->remaining_preferred_lft_);
+    EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
+    EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
 
     // Check other lease parameters.
     EXPECT_TRUE(*lease->duid_ == *duid_);
@@ -4675,8 +4675,8 @@ TEST_F(AllocEngine6Test, requestCacheBoth6) {
     time_t age = lease->cltt_ - now;
     EXPECT_GE(age, 100);
     EXPECT_LE(age, 110);
-    EXPECT_EQ(400 - age, lease->remaining_valid_lft_);
-    EXPECT_EQ(300 - age, lease->remaining_preferred_lft_);
+    EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
+    EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
 
     // Check other lease parameters.
     EXPECT_TRUE(*lease->duid_ == *duid_);
@@ -4731,8 +4731,8 @@ TEST_F(AllocEngine6Test, renewCacheBoth6) {
     time_t age = lease->cltt_ - now;
     EXPECT_GE(age, 100);
     EXPECT_LE(age, 110);
-    EXPECT_EQ(400 - age, lease->remaining_valid_lft_);
-    EXPECT_EQ(300 - age, lease->remaining_preferred_lft_);
+    EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
+    EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
 
     // Check other lease parameters.
     EXPECT_TRUE(*lease->duid_ == *duid_);
@@ -4779,7 +4779,7 @@ TEST_F(AllocEngine6Test, requestCacheBadThreshold6) {
     EXPECT_EQ(128, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -4825,7 +4825,7 @@ TEST_F(AllocEngine6Test, renewCacheBadThreshold6) {
     EXPECT_EQ(prefixlen, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -4868,7 +4868,7 @@ TEST_F(AllocEngine6Test, requestCacheBadMaxAge6) {
     EXPECT_EQ(128, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -4914,7 +4914,7 @@ TEST_F(AllocEngine6Test, renewCacheBadMaxAge6) {
     EXPECT_EQ(prefixlen, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -4958,7 +4958,7 @@ TEST_F(AllocEngine6Test, renewCacheReducedValid6) {
     EXPECT_EQ(128, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -5005,7 +5005,7 @@ TEST_F(AllocEngine6Test, renewCacheReducedPreferred6) {
     EXPECT_EQ(prefixlen, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -5044,7 +5044,7 @@ TEST_F(AllocEngine6Test, requestCacheFwdDDNS6) {
     EXPECT_EQ(128, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -5086,7 +5086,7 @@ TEST_F(AllocEngine6Test, renewCacheFwdDDNS6) {
     EXPECT_EQ(prefixlen, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -5125,7 +5125,7 @@ TEST_F(AllocEngine6Test, requestCacheRevDDNS6) {
     EXPECT_EQ(128, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -5167,7 +5167,7 @@ TEST_F(AllocEngine6Test, renewCacheRevDDNS6) {
     EXPECT_EQ(prefixlen, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
 
     // Check the lease was updated in the database.
     Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
@@ -5207,7 +5207,7 @@ TEST_F(AllocEngine6Test, requestCacheHostname6) {
     EXPECT_EQ(128, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
     EXPECT_EQ("bar", lease->hostname_);
 
     // Check the lease was updated in the database.
@@ -5251,7 +5251,7 @@ TEST_F(AllocEngine6Test, renewCacheHostname6) {
     EXPECT_EQ(prefixlen, lease->prefixlen_);
 
     // The lease was not reused.
-    EXPECT_EQ(0, lease->remaining_valid_lft_);
+    EXPECT_EQ(0, lease->reuseable_valid_lft_);
     EXPECT_EQ("bar", lease->hostname_);
 
     // Check the lease was updated in the database.

diff --git a/src/lib/dhcpsrv/tests/alloc_engine_utils.h b/src/lib/dhcpsrv/tests/alloc_engine_utils.h
index 6c812734fc319b6d28f4b8d9f32c50c873da8767..5e140a33f647a64c97ffbec46ceb36a6ee4482ae 100644 (file)
--- a/src/lib/dhcpsrv/tests/alloc_engine_utils.h
+++ b/src/lib/dhcpsrv/tests/alloc_engine_utils.h
@@ -242,7 +242,7 @@ public:
         EXPECT_EQ(fqdn_rev_, lease->fqdn_rev_);
         EXPECT_EQ(hostname_, lease->hostname_);
         EXPECT_TRUE(*lease->duid_ == *duid);
-        EXPECT_EQ(0, lease->remaining_valid_lft_);
+        EXPECT_EQ(0, lease->reuseable_valid_lft_);
         /// @todo: check cltt
     }
 
@@ -562,7 +562,7 @@ public:
             EXPECT_TRUE(*lease->client_id_ == *clientid_);
         }
         EXPECT_TRUE(*lease->hwaddr_ == *hwaddr_);
-        EXPECT_EQ(0, lease->remaining_valid_lft_);
+        EXPECT_EQ(0, lease->reuseable_valid_lft_);
         /// @todo: check cltt
     }