stopRequest Class Reference

#include <ewmscp.h>

Collaboration diagram for stopRequest:

Public Types
enum	handlerIdType { handlerIdType::unhandled, handlerIdType::undefined, handlerIdType::requestProvider, handlerIdType::processLoop }

Static Public Member Functions
static void	instantiate (handlerIdType id)
static bool	Requested ()
static bool	Requested (handlerIdType id)
static void	RequestStop (const std::string &aReason)
static void	ThrowUpReasonably ()

Static Private Member Functions
static void	sigHandler (int)

Static Private Attributes
static handlerIdType	handlerId
static std::string	reason
static volatile std::atomic< bool >	stopRequested

Detailed Description

Definition at line 117 of file ewmscp.h.

Member Enumeration Documentation

handlerIdType

enum stopRequest::handlerIdType

strong

Enumerator
unhandled
undefined
requestProvider
processLoop

Definition at line 119 of file ewmscp.h.

                             {
        unhandled,
        undefined,
        requestProvider,
        processLoop
    };

Member Function Documentation

instantiate()

void stopRequest::instantiate ( stopRequest::handlerIdType  id )

static

Definition at line 143 of file ewmscp.cpp.

                                                         {
    if (handlerId != handlerIdType::unhandled) {
        throw std::logic_error("stop request handler cannot be instatiated twice");
    }
    if (id == handlerIdType::unhandled || id == handlerIdType::undefined) {
        throw std::logic_error("illegal handler id value");
    }
    std::signal(SIGTERM, sigHandler);
    handlerId = id;
}

References handlerId, sigHandler(), undefined, and unhandled.

Here is the call graph for this function:

Requested() [1/2]

bool stopRequest::Requested ( )

static

Definition at line 153 of file ewmscp.cpp.

                            {
    if (handlerId != handlerIdType::unhandled) {
        return stopRequested;
    }
    return false;
}

References handlerId, stopRequested, and unhandled.

Referenced by followInotifyWatchRequestProvider::followStream(), followJsonRequestProvider::followStream(), copyRequest::base::processQueue(), and followKafkaRequestProvider::processSources().

Here is the caller graph for this function:

Requested() [2/2]

bool stopRequest::Requested ( handlerIdType  id )

static

Definition at line 159 of file ewmscp.cpp.

                                            {
    return handlerId == id && stopRequested;
}

References handlerId, and stopRequested.

RequestStop()

void stopRequest::RequestStop ( const std::string &  aReason )

static

Definition at line 162 of file ewmscp.cpp.

                                                      {
    if (handlerId != handlerIdType::unhandled) {
        static std::mutex instanceProtector;
        std::unique_lock<decltype(instanceProtector)> lock(instanceProtector);
        stopRequested = true;
        reason = aReason;
    } else {
        errMsg::emit(errMsg::level::crit, errMsg::location(),
                     "stopRequest", "requestStop", "no stop request instance");
    }
}

References errMsg::crit, errMsg::emit(), handlerId, reason, stopRequested, and unhandled.

Referenced by printErrors(), printResults(), and copyRequest::base::processQueue().

Here is the call graph for this function:

Here is the caller graph for this function:

sigHandler()

void stopRequest::sigHandler ( int  )

staticprivate

Definition at line 139 of file ewmscp.cpp.

                                {
    stopRequested = true;
    //  static_assert(std::atomic_is_lock_free(&stopRequested), "atomic bool is not always lock free"); // assert that stopRequested is always lock-free
}

References stopRequested.

Referenced by instantiate().

Here is the caller graph for this function:

ThrowUpReasonably()

void stopRequest::ThrowUpReasonably ( )

static

Definition at line 173 of file ewmscp.cpp.

                                    {
    if (handlerId != handlerIdType::unhandled) {
        if (stopRequested) {
            if (! reason.empty()) {
                throw std::runtime_error(reason);
            } else {
                throw std::runtime_error("SIGTERM received");
            }
        }
    }
}

References handlerId, reason, stopRequested, and unhandled.

Member Data Documentation

handlerId

handlerIdType stopRequest::handlerId

staticprivate

Definition at line 126 of file ewmscp.h.

Referenced by instantiate(), Requested(), RequestStop(), and ThrowUpReasonably().

reason

std::string stopRequest::reason

staticprivate

Definition at line 127 of file ewmscp.h.

Referenced by RequestStop(), and ThrowUpReasonably().

stopRequested

volatile std::atomic<bool> stopRequest::stopRequested

staticprivate

Definition at line 129 of file ewmscp.h.

Referenced by Requested(), RequestStop(), sigHandler(), and ThrowUpReasonably().

---

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

• src/ewmscp.h (v0.19-24-g0617ca1 with changes)
• src/ewmscp.cpp (v0.19-24-g0617ca1 with changes)