eventloop.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-
// vim:set sts=4 ts=8:

// Copyright (c) 2001-2011 XORP, Inc and Others
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License, Version
// 2.1, June 1999 as published by the Free Software Foundation.
// Redistribution and/or modification of this program under the terms of
// any other version of the GNU Lesser General Public License is not
// permitted.
// 
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For more details,
// see the GNU Lesser General Public License, Version 2.1, a copy of
// which can be found in the XORP LICENSE.lgpl file.
// 
// XORP, Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net


#ifndef __LIBXORP_EVENTLOOP_HH__
#define __LIBXORP_EVENTLOOP_HH__

#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

#include "xorpfd.hh"
#include "clock.hh"
#include "timer.hh"
#include "task.hh"
#include "callback.hh"
#include "ioevents.hh"

#ifdef USE_WIN_DISPATCHER
#include "win_dispatcher.hh"
#else
#include "selector.hh"
#endif


// The default signal handler logic will catch:
// SIGTERM, SIGINT, SIGXFSZ, SIGXCPU
// and set xorp_do_run to 0.  Control loops can use this
// to bail out and gracefully exit.
extern int xorp_do_run;
extern char xorp_sig_msg_buffer[64];

void setup_dflt_sighandlers();
void dflt_sig_handler(int signo);


extern EnvTrace eloop_trace;


class EventLoop :
    public NONCOPYABLE
{
public:
    EventLoop();

    virtual ~EventLoop();

    void run();

    void set_debug(bool v) {
    _is_debug = v;
#ifndef HOST_OS_WINDOWS
    _selector_list.set_debug(v);
#endif
    }

    bool is_debug() const { return (_is_debug); }

    TimerList&    timer_list()      { return _timer_list; }

#ifndef HOST_OS_WINDOWS

    SelectorList& selector_list()   { return _selector_list; }
#endif

    XorpTimer new_oneoff_at(const TimeVal& when,
                const OneoffTimerCallback& ocb,
                int priority = XorpTask::PRIORITY_DEFAULT);

    XorpTimer new_oneoff_after(const TimeVal& wait,
                   const OneoffTimerCallback& ocb,
                   int priority = XorpTask::PRIORITY_DEFAULT);

    XorpTimer new_oneoff_after_ms(int ms, const OneoffTimerCallback& ocb,
                  int priority = XorpTask::PRIORITY_DEFAULT);

    void remove_timer(XorpTimer& t);

    XorpTimer new_periodic(const TimeVal& wait,
               const PeriodicTimerCallback& pcb,
               int priority = XorpTask::PRIORITY_DEFAULT);

    XorpTimer new_periodic_ms(int ms, const PeriodicTimerCallback& pcb,
                  int priority = XorpTask::PRIORITY_DEFAULT);

    XorpTimer set_flag_at(const TimeVal&    when,
              bool*         flag_ptr,
              bool          to_value = true);

    XorpTimer set_flag_after(const TimeVal&     wait,
                 bool*      flag_ptr,
                 bool       to_value = true);

    XorpTimer set_flag_after_ms(int ms, bool* flag_ptr, bool to_value = true);

    XorpTimer new_timer(const BasicTimerCallback& cb);

    XorpTask new_oneoff_task(const OneoffTaskCallback& cb,
                 int priority = XorpTask::PRIORITY_DEFAULT,
                 int weight = XorpTask::WEIGHT_DEFAULT);

    XorpTask new_task(const RepeatedTaskCallback& cb,
              int priority = XorpTask::PRIORITY_DEFAULT,
              int weight = XorpTask::WEIGHT_DEFAULT);

    bool add_ioevent_cb(XorpFd fd, IoEventType type, const IoEventCb& cb,
            int priority = XorpTask::PRIORITY_DEFAULT);

    bool remove_ioevent_cb(XorpFd fd, IoEventType type = IOT_ANY);

    bool timers_pending() const;

    bool events_pending() const;

    size_t timer_list_length() const;

    void current_time(TimeVal& now) const;

    size_t descriptor_count() const;

    void set_aggressiveness(int num);

private:
    void do_work();

private:
    ClockBase*      _clock;
    TimerList       _timer_list;
    TaskList        _task_list;
    int         _aggressiveness;
    time_t      _last_ev_run;   // 0 - Means run not called yet.
    time_t      _last_warned;
    bool        _is_debug;  // If true, debug enabled
    // Was the last event at this priority a selector or a task.
    bool        _last_ev_type[XorpTask::PRIORITY_INFINITY]; 
#if USE_WIN_DISPATCHER
    WinDispatcher   _win_dispatcher;
#else
    SelectorList    _selector_list;
#endif
};

// ----------------------------------------------------------------------------
// Deferred definitions

inline XorpTimer
EventLoop::new_timer(const BasicTimerCallback& cb)
{
    return _timer_list.new_timer(cb);
}

inline XorpTimer
EventLoop::new_oneoff_at(const TimeVal& tv, const OneoffTimerCallback& ocb,
             int priority)
{
    return _timer_list.new_oneoff_at(tv, ocb, priority);
}

inline XorpTimer
EventLoop::new_oneoff_after(const TimeVal& wait,
                const OneoffTimerCallback& ocb,
                int priority)
{
    return _timer_list.new_oneoff_after(wait, ocb, priority);
}

inline XorpTimer
EventLoop::new_oneoff_after_ms(int ms, const OneoffTimerCallback& ocb,
                   int priority)
{
    TimeVal wait(ms / 1000, (ms % 1000) * 1000);
    return _timer_list.new_oneoff_after(wait, ocb, priority);
}

inline XorpTimer
EventLoop::new_periodic(const TimeVal& wait, const PeriodicTimerCallback& pcb,
            int priority)
{
    return _timer_list.new_periodic(wait, pcb, priority);
}

inline XorpTimer
EventLoop::new_periodic_ms(int ms, const PeriodicTimerCallback& pcb,
               int priority)
{
    TimeVal wait(ms / 1000, (ms % 1000) * 1000);
    return _timer_list.new_periodic(wait, pcb, priority);
}

inline XorpTimer
EventLoop::set_flag_at(const TimeVal& tv, bool *flag_ptr, bool to_value)
{
    return _timer_list.set_flag_at(tv, flag_ptr, to_value);
}

inline XorpTimer
EventLoop::set_flag_after(const TimeVal& wait, bool *flag_ptr, bool to_value)
{
    return _timer_list.set_flag_after(wait, flag_ptr, to_value);
}

inline XorpTimer
EventLoop::set_flag_after_ms(int ms, bool *flag_ptr, bool to_value)
{
    TimeVal wait(ms / 1000, (ms % 1000) * 1000);
    return _timer_list.set_flag_after(wait, flag_ptr, to_value);
}

inline bool
EventLoop::timers_pending() const
{
    return !_timer_list.empty();
}

inline bool
EventLoop::events_pending() const
{
    return ((!_timer_list.empty()) || (!_task_list.empty()));
}

inline size_t
EventLoop::timer_list_length() const
{
    return _timer_list.size();
}

inline void
EventLoop::current_time(TimeVal& t) const
{
    _timer_list.current_time(t);
}

#endif // __LIBXORP_EVENTLOOP_HH__