timer_mgr.cc

Go to the documentation of this file.

// Copyright (C) 2016-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/interval_timer.h>
#include <asiolink/io_service.h>
#include <dhcpsrv/dhcpsrv_log.h>
#include <dhcpsrv/timer_mgr.h>
#include <exceptions/exceptions.h>
#include <util/multi_threading_mgr.h>
 
#include <boost/scoped_ptr.hpp>
 
#include <exception>
#include <functional>
#include <map>
#include <mutex>
#include <ostream>
#include <string>
#include <utility>
 
#include <stddef.h>
 
using namespace isc;
using namespace isc::asiolink;
using namespace isc::util;
 
namespace {
 
struct TimerInfo {
    asiolink::IntervalTimer interval_timer_;
 
    asiolink::IntervalTimer::Callback user_callback_;
 
    long interval_;
 
    asiolink::IntervalTimer::Mode scheduling_mode_;
 
    TimerInfo(const asiolink::IOServicePtr& io_service,
              const asiolink::IntervalTimer::Callback& user_callback,
              const long interval,
              const asiolink::IntervalTimer::Mode& mode)
        : interval_timer_(io_service),
          user_callback_(user_callback),
          interval_(interval),
          scheduling_mode_(mode) { };
};
 
}
 
namespace isc {
namespace dhcp {
 
typedef boost::shared_ptr<TimerInfo> TimerInfoPtr;
 
typedef std::map<std::string, TimerInfoPtr> TimerInfoMap;
 
class TimerMgrImpl {
public:
 
    TimerMgrImpl();
 
    void setIOService(const IOServicePtr& io_service);
 
    void registerTimer(const std::string& timer_name,
                       const asiolink::IntervalTimer::Callback& callback,
                       const long interval,
                       const asiolink::IntervalTimer::Mode& scheduling_mode);
 
    void unregisterTimer(const std::string& timer_name);
 
    void unregisterTimers();
 
    bool isTimerRegistered(const std::string& timer_name);
 
    size_t timersCount() const;
 
    void setup(const std::string& timer_name);
 
    void cancel(const std::string& timer_name);
 
private:
 
 
    void registerTimerInternal(const std::string& timer_name,
                               const asiolink::IntervalTimer::Callback& callback,
                               const long interval,
                               const asiolink::IntervalTimer::Mode& scheduling_mode);
 
    void unregisterTimerInternal(const std::string& timer_name);
 
    void unregisterTimersInternal();
 
    void setupInternal(const std::string& timer_name);
 
    void cancelInternal(const std::string& timer_name);
 
    void timerCallback(const std::string& timer_name);
 
    asiolink::IOServicePtr io_service_;
 
    TimerInfoMap registered_timers_;
 
    boost::scoped_ptr<std::mutex> mutex_;
};
 
TimerMgrImpl::TimerMgrImpl() : io_service_(new IOService()),
    registered_timers_(), mutex_(new std::mutex) {
}
 
void
TimerMgrImpl::setIOService(const IOServicePtr& io_service) {
    if (!io_service) {
        isc_throw(BadValue, "IO service object must not be null for TimerMgr");
    }
 
    io_service_ = io_service;
}
 
void
TimerMgrImpl::registerTimer(const std::string& timer_name,
                            const IntervalTimer::Callback& callback,
                            const long interval,
                            const IntervalTimer::Mode& scheduling_mode) {
    if (MultiThreadingMgr::instance().getMode()) {
        std::lock_guard<std::mutex> lock(*mutex_);
        registerTimerInternal(timer_name, callback, interval, scheduling_mode);
    } else {
        registerTimerInternal(timer_name, callback, interval, scheduling_mode);
    }
}
 
void
TimerMgrImpl::registerTimerInternal(const std::string& timer_name,
                                    const IntervalTimer::Callback& callback,
                                    const long interval,
                                    const IntervalTimer::Mode& scheduling_mode) {
    // Timer name must not be empty.
    if (timer_name.empty()) {
        isc_throw(BadValue, "registered timer name must not be empty");
    }
 
    // Must not register two timers under the same name.
    if (registered_timers_.find(timer_name) != registered_timers_.end()) {
        isc_throw(BadValue, "trying to register duplicate timer '"
                  << timer_name << "'");
    }
 
    // Create a structure holding the configuration for the timer. It will
    // create the instance if the IntervalTimer. It will also hold the
    // callback, interval and scheduling mode parameters.
    TimerInfoPtr timer_info(new TimerInfo(io_service_, callback,
                                          interval, scheduling_mode));
 
    // Actually register the timer.
    registered_timers_.insert(std::pair<std::string, TimerInfoPtr>(timer_name,
                                                                   timer_info));
}
 
void
TimerMgrImpl::unregisterTimer(const std::string& timer_name) {
    if (MultiThreadingMgr::instance().getMode()) {
        std::lock_guard<std::mutex> lock(*mutex_);
        unregisterTimerInternal(timer_name);
    } else {
        unregisterTimerInternal(timer_name);
    }
}
 
void
TimerMgrImpl::unregisterTimerInternal(const std::string& timer_name) {
    // Find the timer with specified name.
    TimerInfoMap::iterator timer_info_it = registered_timers_.find(timer_name);
 
    // Check if the timer has been registered.
    if (timer_info_it == registered_timers_.end()) {
        isc_throw(BadValue, "unable to unregister non existing timer '"
                  << timer_name << "'");
    }
 
    // Cancel any pending asynchronous operation and stop the timer.
    cancelInternal(timer_name);
 
    // Remove the timer.
    registered_timers_.erase(timer_info_it);
}
 
void
TimerMgrImpl::unregisterTimers() {
    if (MultiThreadingMgr::instance().getMode()) {
        std::lock_guard<std::mutex> lock(*mutex_);
        unregisterTimersInternal();
    } else {
        unregisterTimersInternal();
    }
}
 
void
TimerMgrImpl::unregisterTimersInternal() {
    // Copy the map holding timers configuration. This is required so as
    // we don't cut the branch which we're sitting on when we will be
    // erasing the timers. We're going to iterate over the register timers
    // and remove them with the call to unregisterTimer function. But this
    // function will remove them from the register_timers_ map. If we
    // didn't work on the copy here, our iterator would invalidate. The
    // TimerInfo structure is copyable and since it is using the shared
    // pointers the copy is not expensive. Also this function is called when
    // the process terminates so it is not critical for performance.
    TimerInfoMap registered_timers_copy(registered_timers_);
 
    // Iterate over the existing timers and unregister them.
    for (auto const& timer_info_it : registered_timers_copy) {
        unregisterTimerInternal(timer_info_it.first);
    }
}
 
bool
TimerMgrImpl::isTimerRegistered(const std::string& timer_name) {
    if (MultiThreadingMgr::instance().getMode()) {
        std::lock_guard<std::mutex> lock(*mutex_);
        return (registered_timers_.find(timer_name) != registered_timers_.end());
    } else {
        return (registered_timers_.find(timer_name) != registered_timers_.end());
    }
}
 
size_t
TimerMgrImpl::timersCount() const {
    if (MultiThreadingMgr::instance().getMode()) {
        std::lock_guard<std::mutex> lock(*mutex_);
        return (registered_timers_.size());
    } else {
        return (registered_timers_.size());
    }
}
 
void
TimerMgrImpl::setup(const std::string& timer_name) {
    if (MultiThreadingMgr::instance().getMode()) {
        std::lock_guard<std::mutex> lock(*mutex_);
        setupInternal(timer_name);
    } else {
        setupInternal(timer_name);
    }
}
 
void
TimerMgrImpl::setupInternal(const std::string& timer_name) {
   // Check if the specified timer exists.
   TimerInfoMap::const_iterator timer_info_it = registered_timers_.find(timer_name);
   if (timer_info_it == registered_timers_.end()) {
       isc_throw(BadValue, "unable to setup timer '" << timer_name << "': "
                 "no such timer registered");
   }
 
   // Schedule the execution of the timer using the parameters supplied
   // during the registration.
   const TimerInfoPtr& timer_info = timer_info_it->second;
   IntervalTimer::Callback cb = std::bind(&TimerMgrImpl::timerCallback, this,
                                          timer_name);
   timer_info->interval_timer_.setup(cb, timer_info->interval_,
                                     timer_info->scheduling_mode_);
}
 
void
TimerMgrImpl::cancel(const std::string& timer_name) {
    if (MultiThreadingMgr::instance().getMode()) {
        std::lock_guard<std::mutex> lock(*mutex_);
        cancelInternal(timer_name);
    } else {
        cancelInternal(timer_name);
    }
}
 
void
TimerMgrImpl::cancelInternal(const std::string& timer_name) {
    // Find the timer of our interest.
    TimerInfoMap::const_iterator timer_info_it = registered_timers_.find(timer_name);
    if (timer_info_it == registered_timers_.end()) {
        isc_throw(BadValue, "unable to cancel timer '" << timer_name << "': "
                  "no such timer registered");
    }
    // Cancel the timer.
    timer_info_it->second->interval_timer_.cancel();
}
 
void
TimerMgrImpl::timerCallback(const std::string& timer_name) {
    // Find the specified timer setup.
    TimerInfoMap::iterator timer_info_it = registered_timers_.find(timer_name);
    if (timer_info_it != registered_timers_.end()) {
 
        // Running user-defined operation for the timer. Logging it
        // on the slightly lower debug level as there may be many
        // such traces.
        LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL,
                  DHCPSRV_TIMERMGR_RUN_TIMER_OPERATION)
            .arg(timer_info_it->first);
 
        std::string error_string;
        try {
            timer_info_it->second->user_callback_();
 
        } catch (const std::exception& ex){
            error_string = ex.what();
 
        } catch (...) {
            error_string = "unknown reason";
        }
 
        // Exception was thrown. Log an error.
        if (!error_string.empty()) {
            LOG_ERROR(dhcpsrv_logger, DHCPSRV_TIMERMGR_CALLBACK_FAILED)
                .arg(timer_info_it->first)
                .arg(error_string);
        }
    }
}
 
const TimerMgrPtr&
TimerMgr::instance() {
    static TimerMgrPtr timer_mgr(new TimerMgr());
    return (timer_mgr);
}
 
TimerMgr::TimerMgr()
    : impl_(new TimerMgrImpl()) {
}
 
TimerMgr::~TimerMgr() {
    impl_->unregisterTimers();
}
 
void
TimerMgr::registerTimer(const std::string& timer_name,
                        const IntervalTimer::Callback& callback,
                        const long interval,
                        const IntervalTimer::Mode& scheduling_mode) {
 
    LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE,
              DHCPSRV_TIMERMGR_REGISTER_TIMER)
        .arg(timer_name)
        .arg(interval);
 
    impl_->registerTimer(timer_name, callback, interval, scheduling_mode);
}
 
void
TimerMgr::unregisterTimer(const std::string& timer_name) {
 
    LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE,
              DHCPSRV_TIMERMGR_UNREGISTER_TIMER)
        .arg(timer_name);
 
    impl_->unregisterTimer(timer_name);
}
 
void
TimerMgr::unregisterTimers() {
 
    LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE,
              DHCPSRV_TIMERMGR_UNREGISTER_ALL_TIMERS);
 
    impl_->unregisterTimers();
}
 
bool
TimerMgr::isTimerRegistered(const std::string& timer_name) {
    return (impl_->isTimerRegistered(timer_name));
}
 
size_t
TimerMgr::timersCount() const {
    return (impl_->timersCount());
}
 
void
TimerMgr::setup(const std::string& timer_name) {
 
    LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE,
              DHCPSRV_TIMERMGR_START_TIMER)
        .arg(timer_name);
 
    impl_->setup(timer_name);
}
 
void
TimerMgr::cancel(const std::string& timer_name) {
 
    LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE,
              DHCPSRV_TIMERMGR_STOP_TIMER)
        .arg(timer_name);
 
    impl_->cancel(timer_name);
}
 
void
TimerMgr::setIOService(const IOServicePtr& io_service) {
    impl_->setIOService(io_service);
}
 
} // end of namespace isc::dhcp
} // end of namespace isc