cfg_expiration.h

Go to the documentation of this file.

// Copyright (C) 2015-2020 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 CFG_EXPIRATION_H
#define CFG_EXPIRATION_H

#include <asiolink/interval_timer.h>
#include <cc/cfg_to_element.h>
#include <dhcpsrv/timer_mgr.h>
#include <boost/shared_ptr.hpp>
#include <functional>
#include <stdint.h>
#include <string>

namespace isc {
namespace dhcp {

class CfgExpiration : public isc::data::CfgToElement {
public:


    static const uint16_t DEFAULT_RECLAIM_TIMER_WAIT_TIME;

    static const uint16_t DEFAULT_FLUSH_RECLAIMED_TIMER_WAIT_TIME;

    static const uint32_t DEFAULT_HOLD_RECLAIMED_TIME;

    static const uint32_t DEFAULT_MAX_RECLAIM_LEASES;

    static const uint16_t DEFAULT_MAX_RECLAIM_TIME;

    static const uint16_t DEFAULT_UNWARNED_RECLAIM_CYCLES;



    static const uint16_t LIMIT_RECLAIM_TIMER_WAIT_TIME;

    static const uint16_t LIMIT_FLUSH_RECLAIMED_TIMER_WAIT_TIME;

    static const uint32_t LIMIT_HOLD_RECLAIMED_TIME;

    static const uint32_t LIMIT_MAX_RECLAIM_LEASES;

    static const uint16_t LIMIT_MAX_RECLAIM_TIME;

    static const uint16_t LIMIT_UNWARNED_RECLAIM_CYCLES;




    static const std::string RECLAIM_EXPIRED_TIMER_NAME;

    static const std::string FLUSH_RECLAIMED_TIMER_NAME;


    CfgExpiration(const bool test_mode = false);

    uint16_t getReclaimTimerWaitTime() const {
        return (reclaim_timer_wait_time_);
    }

    void setReclaimTimerWaitTime(const int64_t reclaim_timer_wait_time);

    uint16_t getFlushReclaimedTimerWaitTime() const {
        return (flush_reclaimed_timer_wait_time_);
    }

    void setFlushReclaimedTimerWaitTime(const int64_t flush_reclaimed_wait_time);

    uint32_t getHoldReclaimedTime() const {
        return (hold_reclaimed_time_);
    }

    void setHoldReclaimedTime(const int64_t hold_reclaimed_time);

    uint32_t getMaxReclaimLeases() const {
        return (max_reclaim_leases_);
    }

    void setMaxReclaimLeases(const int64_t max_reclaim_leases);

    uint16_t getMaxReclaimTime() const {
        return (max_reclaim_time_);
    }

    void setMaxReclaimTime(const int64_t max_reclaim_time);

    uint16_t getUnwarnedReclaimCycles() const {
        return (unwarned_reclaim_cycles_);
    }

    void setUnwarnedReclaimCycles(const int64_t unwarned_reclaim_cycles);

    template<typename Instance>
    void setupTimers(void (Instance::*reclaim_fun)(const size_t, const uint16_t,
                                                   const bool, const uint16_t),
                     void (Instance::*delete_fun)(const uint32_t),
                     Instance* instance_ptr) const;

    virtual isc::data::ElementPtr toElement() const;

private:

    void rangeCheck(const int64_t value, const uint64_t max_value,
                    const std::string& config_parameter_name) const;

    uint16_t reclaim_timer_wait_time_;

    uint16_t flush_reclaimed_timer_wait_time_;

    uint32_t hold_reclaimed_time_;

    uint32_t max_reclaim_leases_;

    uint16_t max_reclaim_time_;

    uint16_t unwarned_reclaim_cycles_;

    TimerMgrPtr timer_mgr_;

    bool test_mode_;
};


typedef boost::shared_ptr<CfgExpiration> CfgExpirationPtr;

typedef boost::shared_ptr<const CfgExpiration> ConstCfgExpirationPtr;


template<typename Instance>
void
CfgExpiration::setupTimers(void (Instance::*reclaim_fun)(const size_t,
                                                         const uint16_t,
                                                         const bool,
                                                         const uint16_t),
                           void (Instance::*delete_fun)(const uint32_t),
                           Instance* instance_ptr) const {
    // One of the parameters passed to the leases' reclamation routine
    // is a boolean value which indicates if reclaimed leases should
    // be removed by the leases' reclamation routine. This is the case
    // when the timer for flushing reclaimed leases is set to 0
    // (disabled).
    const bool flush_timer_disabled = (getFlushReclaimedTimerWaitTime() == 0);

    // If the timer interval for the leases reclamation is non-zero
    // the timer will be scheduled.
    if (getReclaimTimerWaitTime() > 0) {
        // In the test mode the interval is expressed in milliseconds.
        // If this is not the test mode, the interval is in seconds.
        const long reclaim_interval = test_mode_ ? getReclaimTimerWaitTime() :
            1000 * getReclaimTimerWaitTime();
        // Register timer for leases' reclamation routine.
        timer_mgr_->registerTimer(RECLAIM_EXPIRED_TIMER_NAME,
                                  std::bind(reclaim_fun, instance_ptr,
                                            getMaxReclaimLeases(),
                                            getMaxReclaimTime(),
                                            flush_timer_disabled,
                                            getUnwarnedReclaimCycles()),
                                  reclaim_interval,
                                  asiolink::IntervalTimer::ONE_SHOT);
        timer_mgr_->setup(RECLAIM_EXPIRED_TIMER_NAME);
    }

    // If the interval for the timer flushing expired-reclaimed leases
    // is set we will schedule the timer.
    if (!flush_timer_disabled) {
        // The interval is specified in milliseconds if we're in the test mode.
        // It is specified in seconds otherwise.
        const long flush_interval = test_mode_ ?
            getFlushReclaimedTimerWaitTime() :
            1000 * getFlushReclaimedTimerWaitTime();
        // Register and setup the timer.
        timer_mgr_->registerTimer(FLUSH_RECLAIMED_TIMER_NAME,
                                  std::bind(delete_fun, instance_ptr,
                                            getHoldReclaimedTime()),
                                  flush_interval,
                                  asiolink::IntervalTimer::ONE_SHOT);
        timer_mgr_->setup(FLUSH_RECLAIMED_TIMER_NAME);
    }
}


} // end of isc::dhcp namespace
} // end of isc namespace

#endif // CFG_EXPIRATION_H