core::EventLoop Class Reference

#include <EventLoop.h>

Collaboration diagram for core::EventLoop:

Public Member Functions
	EventLoop (const EventLoop &eventLoop)=delete
EventLoop &	operator= (const EventLoop &eventLoop)=delete
EventMultiplexer &	getEventMultiplexer ()

Static Public Member Functions
static EventLoop &	instance ()
static unsigned long	getTickCounter ()
static core::State	getEventLoopState ()

Private Member Functions
	EventLoop ()
	~EventLoop ()=default
TickStatus	_tick (const utils::Timeval &timeOut)

Static Private Member Functions
static bool	init (int argc, char *argv[])
static TickStatus	tick (const utils::Timeval &timeOut)
static int	start (const utils::Timeval &timeOut)
static void	stop ()
static void	free ()
static void	stoponsig (int sig)

Private Attributes
core::EventMultiplexer &	eventMultiplexer

Static Private Attributes
static int	stopsig = 0
static unsigned long	tickCounter = 0
static core::State	eventLoopState = State::LOADED

Friends
class	SNodeC

Detailed Description

Definition at line 62 of file EventLoop.h.

Constructor & Destructor Documentation

EventLoop() [1/2]

core::EventLoop::EventLoop ( const EventLoop &  eventLoop )

delete

EventLoop() [2/2]

core::EventLoop::EventLoop ( )

private

Definition at line 75 of file EventLoop.cpp.

        : eventMultiplexer(::EventMultiplexer()) {
    }

References eventMultiplexer.

~EventLoop()

core::EventLoop::~EventLoop ( )

privatedefault

Member Function Documentation

_tick()

TickStatus core::EventLoop::_tick ( const utils::Timeval &  timeOut )

private

Definition at line 136 of file EventLoop.cpp.

                                                               {
        TickStatus tickStatus = TickStatus::SUCCESS;
 
        tickCounter++;
 
        sigset_t newSet{};
        sigaddset(&newSet, SIGINT);
        sigaddset(&newSet, SIGTERM);
        sigaddset(&newSet, SIGALRM);
        sigaddset(&newSet, SIGHUP);
 
        sigset_t oldSet{};
        sigprocmask(SIG_BLOCK, &newSet, &oldSet);
 
        if (eventLoopState == State::RUNNING || eventLoopState == State::STOPPING) {
            tickStatus = eventMultiplexer.tick(tickTimeOut, oldSet);
        }
 
        sigprocmask(SIG_SETMASK, &oldSet, nullptr);
 
        return tickStatus;
    }

References eventLoopState, eventMultiplexer, core::RUNNING, core::STOPPING, core::SUCCESS, core::EventMultiplexer::tick(), and tickCounter.

Referenced by free(), start(), and tick().

Here is the call graph for this function:

Here is the caller graph for this function:

free()

void core::EventLoop::free ( )

staticprivate

Definition at line 255 of file EventLoop.cpp.

                         {
        std::string signal = "SIG" + utils::system::sigabbrev_np(stopsig);
 
        if (signal == "SIGUNKNOWN") {
            signal = std::to_string(stopsig);
        }
 
        if (stopsig != 0) {
            LOG(TRACE) << "Core: Sending signal " << signal << " to all DescriptorEventReceivers";
 
            EventLoop::instance().eventMultiplexer.signal(stopsig);
        }
 
        eventLoopState = State::STOPPING;
 
        utils::Timeval timeout = 2;
 
        core::TickStatus tickStatus = TickStatus::SUCCESS;
        do {
            auto t1 = std::chrono::system_clock::now();
            const utils::Timeval timeoutOp = timeout;
 
            tickStatus = EventLoop::instance()._tick(timeoutOp);
 
            auto t2 = std::chrono::system_clock::now();
            const std::chrono::duration<double> seconds = t2 - t1;
 
            timeout -= seconds.count();
        } while (timeout > 0 && (tickStatus == TickStatus::SUCCESS));
 
        LOG(TRACE) << "Core: Terminate all stalled DescriptorEventReceivers";
 
        EventLoop::instance().eventMultiplexer.terminate();
 
        LOG(TRACE) << "Core: Close all libraries opened during runtime";
 
        DynamicLoader::execDlCloseAll();
 
        LOG(TRACE) << "Core:: Clean up the filesystem";
 
        utils::Config::terminate();
 
        LOG(TRACE) << "Core:: All resources released";
 
        LOG(TRACE) << "SNode.C: Ended ... BYE";
    }

References _tick(), eventLoopState, eventMultiplexer, core::DynamicLoader::execDlCloseAll(), instance(), utils::Timeval::operator-=(), utils::Timeval::operator>(), utils::system::sigabbrev_np(), core::EventMultiplexer::signal(), core::STOPPING, stopsig, core::SUCCESS, and core::EventMultiplexer::terminate().

Referenced by core::SNodeC::free(), start(), and tick().

Here is the call graph for this function:

Here is the caller graph for this function:

getEventLoopState()

State core::EventLoop::getEventLoopState ( )

static

Definition at line 93 of file EventLoop.cpp.

                                       {
        return eventLoopState;
    }

References eventLoopState.

Referenced by core::eventLoopState(), and core::SNodeC::state().

Here is the caller graph for this function:

getEventMultiplexer()

EventMultiplexer & core::EventLoop::getEventMultiplexer

(

)

Definition at line 89 of file EventLoop.cpp.

                                                     {
        return eventMultiplexer;
    }

References eventMultiplexer.

Referenced by core::eventreceiver::AcceptEventReceiver::AcceptEventReceiver(), core::eventreceiver::ConnectEventReceiver::ConnectEventReceiver(), core::Event::Event(), core::eventreceiver::ExceptionalConditionEventReceiver::ExceptionalConditionEventReceiver(), core::eventreceiver::ReadEventReceiver::ReadEventReceiver(), core::TimerEventReceiver::TimerEventReceiver(), and core::eventreceiver::WriteEventReceiver::WriteEventReceiver().

Here is the caller graph for this function:

getTickCounter()

unsigned long core::EventLoop::getTickCounter ( )

static

Definition at line 85 of file EventLoop.cpp.

                                            {
        return tickCounter;
    }

References tickCounter.

Referenced by express::Controller::Controller(), core::getTickCounterAsString(), and express::Controller::next().

Here is the caller graph for this function:

init()

bool core::EventLoop::init ( int  argc, char *  argv[]  )

staticprivate

Definition at line 98 of file EventLoop.cpp.

                                               {
        struct sigaction sact{};
        sigemptyset(&sact.sa_mask);
        sact.sa_flags = 0;
        sact.sa_handler = SIG_IGN;
 
        struct sigaction oldPipeAct{};
        sigaction(SIGPIPE, &sact, &oldPipeAct);
 
        struct sigaction oldIntAct{};
        sigaction(SIGINT, &sact, &oldIntAct);
 
        struct sigaction oldTermAct{};
        sigaction(SIGTERM, &sact, &oldTermAct);
 
        struct sigaction oldAlarmAct{};
        sigaction(SIGALRM, &sact, &oldAlarmAct);
 
        struct sigaction oldHupAct{};
        sigaction(SIGHUP, &sact, &oldHupAct);
 
        logger::Logger::setCustomFormatSpec("%tick", core::getTickCounterAsString);
 
        if (utils::Config::init(argc, argv)) {
            eventLoopState = State::INITIALIZED;
 
            LOG(TRACE) << "SNode.C: Starting ... HELLO";
        }
 
        sigaction(SIGPIPE, &oldPipeAct, nullptr);
        sigaction(SIGINT, &oldIntAct, nullptr);
        sigaction(SIGTERM, &oldTermAct, nullptr);
        sigaction(SIGALRM, &oldAlarmAct, nullptr);
        sigaction(SIGHUP, &oldHupAct, nullptr);
 
        return eventLoopState == State::INITIALIZED;
    }

References eventLoopState, core::getTickCounterAsString(), and core::INITIALIZED.

Referenced by core::SNodeC::init().

Here is the call graph for this function:

Here is the caller graph for this function:

instance()

EventLoop & core::EventLoop::instance ( )

static

Definition at line 79 of file EventLoop.cpp.

                                   {
        static EventLoop eventLoop;
 
        return eventLoop;
    }

Referenced by core::eventreceiver::AcceptEventReceiver::AcceptEventReceiver(), core::eventreceiver::ConnectEventReceiver::ConnectEventReceiver(), core::Event::Event(), core::eventreceiver::ExceptionalConditionEventReceiver::ExceptionalConditionEventReceiver(), free(), core::eventreceiver::ReadEventReceiver::ReadEventReceiver(), start(), tick(), core::TimerEventReceiver::TimerEventReceiver(), and core::eventreceiver::WriteEventReceiver::WriteEventReceiver().

Here is the caller graph for this function:

operator=()

EventLoop & core::EventLoop::operator= ( const EventLoop &  eventLoop )

delete

start()

int core::EventLoop::start ( const utils::Timeval &  timeOut )

staticprivate

Definition at line 184 of file EventLoop.cpp.

                                                    {
        struct sigaction sact{};
        sigemptyset(&sact.sa_mask);
        sact.sa_flags = 0;
        sact.sa_handler = SIG_IGN;
 
        struct sigaction oldPipeAct{};
        sigaction(SIGPIPE, &sact, &oldPipeAct);
 
        sact.sa_handler = EventLoop::stoponsig;
 
        struct sigaction oldIntAct{};
        sigaction(SIGINT, &sact, &oldIntAct);
 
        struct sigaction oldTermAct{};
        sigaction(SIGTERM, &sact, &oldTermAct);
 
        struct sigaction oldAlarmAct{};
        sigaction(SIGALRM, &sact, &oldAlarmAct);
 
        struct sigaction oldHupAct{};
        sigaction(SIGHUP, &sact, &oldHupAct);
 
        if (eventLoopState == State::INITIALIZED) {
            if (utils::Config::bootstrap()) {
                eventLoopState = State::RUNNING;
                core::TickStatus tickStatus = TickStatus::SUCCESS;
 
                LOG(TRACE) << "Core::EventLoop: started";
 
                do {
                    tickStatus = EventLoop::instance()._tick(timeOut);
                } while ((tickStatus == TickStatus::SUCCESS || tickStatus == TickStatus::INTERRUPTED) && eventLoopState == State::RUNNING);
 
                switch (tickStatus) {
                    case TickStatus::SUCCESS:
                        LOG(TRACE) << "Core::EventLoop: Stopped";
                        break;
                    case TickStatus::NOOBSERVER:
                        LOG(TRACE) << "Core::EventLoop: No Observer";
                        break;
                    case TickStatus::INTERRUPTED:
                        LOG(TRACE) << "Core::EventLoop: Interrupted";
                        break;
                    case TickStatus::TRACE:
                        PLOG(FATAL) << "Core::EventLoop: _tick()";
                        break;
                }
            } else {
                stopsig = -2;
            }
        } else {
            stopsig = -1;
        }
 
        sigaction(SIGPIPE, &oldPipeAct, nullptr);
        sigaction(SIGTERM, &oldTermAct, nullptr);
        sigaction(SIGALRM, &oldAlarmAct, nullptr);
        sigaction(SIGHUP, &oldHupAct, nullptr);
 
        free();
 
        sigaction(SIGINT, &oldIntAct, nullptr);
 
        return -stopsig;
    }

References _tick(), eventLoopState, free(), core::INITIALIZED, instance(), core::INTERRUPTED, core::NOOBSERVER, core::RUNNING, stoponsig(), stopsig, core::SUCCESS, and core::TRACE.

Referenced by core::SNodeC::start().

Here is the call graph for this function:

Here is the caller graph for this function:

stop()

void core::EventLoop::stop ( )

staticprivate

Definition at line 251 of file EventLoop.cpp.

                         {
        eventLoopState = State::STOPPING;
    }

References eventLoopState, and core::STOPPING.

Referenced by core::SNodeC::stop(), and stoponsig().

Here is the caller graph for this function:

stoponsig()

void core::EventLoop::stoponsig ( int  sig )

staticprivate

Definition at line 302 of file EventLoop.cpp.

                                     {
        LOG(TRACE) << "Core: Received signal '" << strsignal(sig) << "' (SIG" << utils::system::sigabbrev_np(sig) << " = " << sig << ")";
        stopsig = sig;
        stop();
    }

References utils::system::sigabbrev_np(), stop(), and stopsig.

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

tick()

TickStatus core::EventLoop::tick ( const utils::Timeval &  timeOut )

staticprivate

Definition at line 159 of file EventLoop.cpp.

                                                          {
        TickStatus tickStatus = TickStatus::TRACE;
 
        if (eventLoopState == State::INITIALIZED) {
            struct sigaction sact{};
            sigemptyset(&sact.sa_mask);
            sact.sa_flags = 0;
            sact.sa_handler = SIG_IGN;
 
            struct sigaction oldPipeAct{};
            sigaction(SIGPIPE, &sact, &oldPipeAct);
 
            tickStatus = EventLoop::instance()._tick(timeOut);
 
            sigaction(SIGPIPE, &oldPipeAct, nullptr);
        } else {
            EventLoop::instance().eventMultiplexer.clearEventQueue();
            free();
 
            PLOG(FATAL) << "Core: not initialized: No events will be processed\nCall SNodeC::init(argc, argv) before SNodeC::tick().";
        }
 
        return tickStatus;
    }

References _tick(), core::EventMultiplexer::clearEventQueue(), eventLoopState, eventMultiplexer, free(), core::INITIALIZED, instance(), and core::TRACE.

Referenced by core::SNodeC::tick().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

SNodeC

friend class SNodeC

friend

Definition at line 99 of file EventLoop.h.

Member Data Documentation

eventLoopState

core::State core::EventLoop::eventLoopState = State::LOADED

staticprivate

Definition at line 97 of file EventLoop.h.

Referenced by _tick(), free(), getEventLoopState(), init(), start(), stop(), and tick().

eventMultiplexer

core::EventMultiplexer& core::EventLoop::eventMultiplexer

private

Definition at line 91 of file EventLoop.h.

Referenced by _tick(), EventLoop(), free(), getEventMultiplexer(), and tick().

stopsig

int core::EventLoop::stopsig = 0

staticprivate

Definition at line 93 of file EventLoop.h.

Referenced by free(), start(), and stoponsig().

tickCounter

unsigned long core::EventLoop::tickCounter = 0

staticprivate

Definition at line 95 of file EventLoop.h.

Referenced by _tick(), and getTickCounter().

---

The documentation for this class was generated from the following files:

• core/EventLoop.h
• core/EventLoop.cpp