WorkLoop.cc

#include "otsdaq/WorkLoopManager/WorkLoop.h"
#include "otsdaq/Macros/CoutMacros.h"
#include "otsdaq/MessageFacility/MessageFacility.h"

#include <toolbox/task/WorkLoopFactory.h>

#include <unistd.h>
#include <iostream>

using namespace ots;

#undef __MF_SUBJECT__
#define __MF_SUBJECT__ "Workloop"
#undef __COUT_HDR__
#define __COUT_HDR__ (std::string("Workloop-") + WorkLoop::workLoopName_ + "\t<>")

//==============================================================================
WorkLoop::WorkLoop(const std::string& name)
    : continueWorkLoop_(false)
    , workLoopName_(name)
    , workLoopType_("waiting")
    , workLoop_(0)
    , job_(toolbox::task::bind(this, &WorkLoop::workLoopThread, workLoopName_))
{
    __COUT__ << "Constructed." << __E__;
}

//==============================================================================
WorkLoop::~WorkLoop(void)
{
    __COUT__ << "Destructor." << __E__;
    if(stopWorkLoop())
        toolbox::task::getWorkLoopFactory()->removeWorkLoop(workLoopName_, workLoopType_);
    __COUT__ << "Destructed." << __E__;
}

//==============================================================================
void WorkLoop::startWorkLoop(void)
{
    __COUT__ << "Starting WorkLoop: " << workLoopName_ << __E__;
    continueWorkLoop_ = true;
    try
    {
        workLoop_ = toolbox::task::getWorkLoopFactory()->getWorkLoop(workLoopName_, workLoopType_);
    }
    catch(xcept::Exception& e)
    {
        __COUT__ << "ERROR: Can't create WorkLoop job for " << workLoopName_ << __E__;
        stopWorkLoop();
    }

    if(workLoop_->isActive())
        return;  // This might be a consumer producer running at the same time so it has
                 // been activated already

    try
    {
        workLoop_->submit(job_);
    }
    catch(xcept::Exception& e)
    {
        __COUT__ << "ERROR: Can't submit WorkLoop job for " << workLoopName_ << __E__;
        stopWorkLoop();
    }

    try
    {
        workLoop_->activate();
    }
    catch(xcept::Exception& e)
    {
        __COUT__ << "ERROR: Can't activate WorkLoop job for " << workLoopName_ << " Very likely because the name " << workLoopName_ << " is not unique!"
                 << __E__;
        stopWorkLoop();
    }
}  // end startWorkLoop()

//==============================================================================
bool WorkLoop::stopWorkLoop()
{
    __COUT__ << "Stopping WorkLoop: " << workLoopName_ << __E__;

    continueWorkLoop_ = false;
    if(workLoop_ == 0)
    {
        __COUT__ << "MEASSAGE: WorkLoop " << workLoopName_ << " was not created at all! This message will be commented in the future" << __E__;
        return false;
    }

    __COUT__ << "initially workLoop_->isActive() " << (workLoop_->isActive() ? "yes" : "no") << __E__;

    try
    {
        // THis method waits until the workloop job returns! Super cool!
        workLoop_->cancel();
    }
    catch(xcept::Exception& e)
    {
        __COUT__ << "WARNING: Can't cancel WorkLoop job for " << workLoopName_ << " because probably it has never been activated!" << __E__;

        __COUT__ << "workLoop_->isActive() " << (workLoop_->isActive() ? "yes" : "no") << __E__;
        return true;
    }

    try
    {
        workLoop_->remove(job_);
    }
    catch(xcept::Exception& e)
    {
        // ATTENTION!
        // If the workloop job thread returns false, then the workloop job is
        // automatically removed and it can't be removed again Leaving this try catch
        // allows me to be general in the job threads so I can return true (repeat loop)
        // or false ( loop only once) without crashing
        __COUT__ << "WARNING: Can't remove request WorkLoop: " << workLoopName_ << __E__;
        __COUT__ << "workLoop_->isActive() " << (workLoop_->isActive() ? "yes" : "no") << __E__;
    }

    __COUT__ << "Stopped WorkLoop: " << workLoopName_ << __E__;
    __COUT__ << "workLoop_->isActive() " << (workLoop_->isActive() ? "yes" : "no") << __E__;
    return true;
}  // end stopWorkLoop()

//==============================================================================
bool WorkLoop::isActive(void) const { return workLoop_->isActive() && continueWorkLoop_; }  // end isActive