interval_timer.cc

Go to the documentation of this file.

// Copyright (C) 2011-2024 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/.
 
#include <config.h>
#include <asiolink/asio_wrapper.h>
#include <asiolink/interval_timer.h>
#include <asiolink/io_service.h>
 
#include <boost/enable_shared_from_this.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
 
#include <exceptions/exceptions.h>
 
#include <atomic>
#include <functional>
#include <mutex>
 
using namespace std;
namespace ph = std::placeholders;
 
namespace isc {
namespace asiolink {
 
class IntervalTimerImpl :
    public boost::enable_shared_from_this<IntervalTimerImpl>,
    public boost::noncopyable {
public:
 
    IntervalTimerImpl(const IOServicePtr& io_service);
 
    ~IntervalTimerImpl();
 
    void setup(const IntervalTimer::Callback& cbfunc, const long interval,
               const IntervalTimer::Mode& interval_mode = IntervalTimer::REPEATING);
 
    void callback(const boost::system::error_code& error);
 
    void cancel() {
        lock_guard<mutex> lk (mutex_);
        timer_.cancel();
        interval_ = 0;
        cbfunc_ = std::function<void()>();
    }
 
    long getInterval() const { return (interval_); }
 
private:
 
    void update();
 
    IntervalTimer::Callback cbfunc_;
 
    std::atomic<long> interval_;
 
    IOServicePtr io_service_;
 
    boost::asio::deadline_timer timer_;
 
    IntervalTimer::Mode mode_;
 
    std::mutex mutex_;
 
    static const long INVALIDATED_INTERVAL = -1;
};
 
IntervalTimerImpl::IntervalTimerImpl(const IOServicePtr& io_service) :
    interval_(0), io_service_(io_service), timer_(io_service_->getInternalIOService()),
    mode_(IntervalTimer::REPEATING) {
}
 
IntervalTimerImpl::~IntervalTimerImpl() {
    interval_ = INVALIDATED_INTERVAL;
}
 
void
IntervalTimerImpl::setup(const IntervalTimer::Callback& cbfunc,
                         const long interval,
                         const IntervalTimer::Mode& mode) {
    // Interval should not be less than 0.
    if (interval < 0) {
        isc_throw(isc::BadValue, "Interval should not be less than or "
                                 "equal to 0");
    }
    // Call back function should not be empty.
    if (!cbfunc) {
        isc_throw(isc::InvalidParameter, "Callback function is empty");
    }
 
    lock_guard<mutex> lk(mutex_);
    cbfunc_ = cbfunc;
    interval_ = interval;
    mode_ = mode;
 
    // Set initial expire time.
    // At this point the timer is not running yet and will not expire.
    // After calling IOService::run(), the timer will expire.
    update();
}
 
void
IntervalTimerImpl::update() {
    try {
        // Update expire time to (current time + interval_).
        timer_.expires_from_now(boost::posix_time::millisec(long(interval_)));
        // Reset timer.
        // Pass a function bound with a shared_ptr to this.
        timer_.async_wait(std::bind(&IntervalTimerImpl::callback,
                                    shared_from_this(),
                                    ph::_1)); //error
    } catch (const boost::system::system_error& e) {
        isc_throw(isc::Unexpected, "Failed to update timer: " << e.what());
    } catch (const boost::bad_weak_ptr&) {
        // Can't happen. It means a severe internal bug.
    }
}
 
void
IntervalTimerImpl::callback(const boost::system::error_code& ec) {
    if (interval_ == INVALIDATED_INTERVAL) {
        isc_throw(isc::BadValue, "Interval internal state");
    }
    if (interval_ == 0 || ec) {
        // timer has been canceled. Do nothing.
    } else {
        {
            lock_guard<mutex> lk(mutex_);
            // If we should repeat, set next expire time.
            if (mode_ == IntervalTimer::REPEATING) {
                update();
            }
        }
 
        // Invoke the call back function.
        cbfunc_();
    }
}
 
IntervalTimer::IntervalTimer(const IOServicePtr& io_service) :
    impl_(new IntervalTimerImpl(io_service)) {
}
 
IntervalTimer::~IntervalTimer() {
    // Cancel the timer to make sure cbfunc_() will not be called any more.
    cancel();
}
 
void
IntervalTimer::setup(const Callback& cbfunc, const long interval,
                     const IntervalTimer::Mode& mode) {
    return (impl_->setup(cbfunc, interval, mode));
}
 
void
IntervalTimer::cancel() {
    impl_->cancel();
}
 
long
IntervalTimer::getInterval() const {
    return (impl_->getInterval());
}
 
}  // namespace asiolink
}  // namespace isc