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 40 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 53 of file EventLoop.cpp.

        : eventMultiplexer(::EventMultiplexer()) {
    }

~EventLoop()

core::EventLoop::~EventLoop ( )

privatedefault

Member Function Documentation

_tick()

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

private

Definition at line 114 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;
    }

free()

void core::EventLoop::free ( )

staticprivate

Definition at line 227 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";
    }

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

Here is the caller graph for this function:

getEventLoopState()

State core::EventLoop::getEventLoopState ( )

static

Definition at line 71 of file EventLoop.cpp.

                                       {
        return 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 67 of file EventLoop.cpp.

                                                     {
        return eventMultiplexer;
    }

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

Here is the caller graph for this function:

getTickCounter()

unsigned long core::EventLoop::getTickCounter ( )

static

Definition at line 63 of file EventLoop.cpp.

                                            {
        return tickCounter;
    }

init()

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

staticprivate

Definition at line 76 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;
    }

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

Here is the caller graph for this function:

instance()

EventLoop & core::EventLoop::instance ( )

static

Definition at line 57 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(), core::eventreceiver::ReadEventReceiver::ReadEventReceiver(), 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 162 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 && 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;
            }
        }
 
        sigaction(SIGPIPE, &oldPipeAct, nullptr);
        sigaction(SIGTERM, &oldTermAct, nullptr);
        sigaction(SIGALRM, &oldAlarmAct, nullptr);
        sigaction(SIGHUP, &oldHupAct, nullptr);
 
        free();
 
        sigaction(SIGINT, &oldIntAct, nullptr);
 
        return stopsig;
    }

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

Here is the caller graph for this function:

stop()

void core::EventLoop::stop ( )

staticprivate

Definition at line 223 of file EventLoop.cpp.

                         {
        eventLoopState = State::STOPPING;
    }

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

Here is the caller graph for this function:

stoponsig()

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

staticprivate

Definition at line 274 of file EventLoop.cpp.

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

tick()

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

staticprivate

Definition at line 137 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;
    }

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

Here is the caller graph for this function:

Friends And Related Symbol Documentation

SNodeC

friend class SNodeC

friend

Definition at line 77 of file EventLoop.h.

Member Data Documentation

eventLoopState

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

staticprivate

Definition at line 75 of file EventLoop.h.

eventMultiplexer

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

private

Definition at line 69 of file EventLoop.h.

stopsig

int core::EventLoop::stopsig = 0

staticprivate

Definition at line 71 of file EventLoop.h.

tickCounter

unsigned long core::EventLoop::tickCounter = 0

staticprivate

Definition at line 73 of file EventLoop.h.

---

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

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