CoreSupervisorBase.h

#ifndef _ots_CoreSupervisorBase_h_
#define _ots_CoreSupervisorBase_h_
 
#include "otsdaq/FiniteStateMachine/RunControlStateMachine.h"
#include "otsdaq/SOAPUtilities/SOAPMessenger.h"
#include "otsdaq/WorkLoopManager/WorkLoopManager.h"
 
#include "otsdaq/CoreSupervisors/CorePropertySupervisorBase.h"
 
#include "otsdaq/CgiDataUtilities/CgiDataUtilities.h"
#include "otsdaq/SOAPUtilities/SOAPUtilities.h"
#include "otsdaq/XmlUtilities/HttpXmlDocument.h"
 
#include "otsdaq/FiniteStateMachine/VStateMachine.h"
#include "otsdaq/WebUsersUtilities/RemoteWebUsers.h"
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include <xdaq/Application.h>
#pragma GCC diagnostic pop
#include "otsdaq/Macros/XDAQApplicationMacros.h"
#include "xgi/Method.h"
 
#include <toolbox/fsm/FailedEvent.h>
 
#include <xdaq/NamespaceURI.h>
#include <xoap/Method.h>
 
#include <time.h>
#include <map>
#include <memory>
#include <set>
#include <string> /*string and to_string*/
#include <vector>
 
namespace ots
{
// clang-format off
 
class CoreSupervisorBase : public xdaq::Application,
                           public SOAPMessenger,
                           public CorePropertySupervisorBase,
                           public RunControlStateMachine
{
    friend class MacroMakerSupervisor;  
 
  public:
    CoreSupervisorBase(xdaq::ApplicationStub* stub);
    virtual ~CoreSupervisorBase(void);
 
    void destroy(void);
 
    unsigned int                    getSupervisorLID                (void) const { return getApplicationDescriptor()->getLocalId(); }
 
 
    virtual void                    defaultPage                     (xgi::Input* in, xgi::Output* out);
    virtual void                    request                         (const std::string&               requestType,
                                                                    cgicc::Cgicc&                    cgiIn,
                                                                    HttpXmlDocument&                 xmlOut,
                                                                    const WebUsers::RequestUserInfo& userInfo);
    virtual void                    nonXmlRequest                   (const std::string&               requestType,
                                                                    cgicc::Cgicc&                    cgiIn,
                                                                    std::ostream&                    out,
                                                                    const WebUsers::RequestUserInfo& userInfo);
    virtual std::string             getStatusProgressDetail         (void);
    virtual std::vector<
        SupervisorInfo::SubappInfo> getSubappInfo                   (void) { return std::vector<SupervisorInfo::SubappInfo>(); }
 
  private:
    xoap::MessageReference          workLoopStatusRequestWrapper    (xoap::MessageReference message);
    void                            defaultPageWrapper              (xgi::Input* in, xgi::Output* out);
    void                            requestWrapper                  (xgi::Input* in, xgi::Output* out);
    xoap::MessageReference          TRACESupervisorRequest          (xoap::MessageReference message);
 
  public:
    void                            stateMachineXgiHandler          (xgi::Input* in, xgi::Output* out);
    xoap::MessageReference          stateMachineXoapHandler         (xoap::MessageReference message);
 
    xoap::MessageReference          stateMachineStateRequest        (xoap::MessageReference message);
    xoap::MessageReference          stateMachineErrorMessageRequest (xoap::MessageReference message);
 
    void                            sendAsyncExceptionToGateway     (const std::string& errMsg, bool isPauseException, bool isStopException);
 
    virtual xoap::MessageReference  workLoopStatusRequest           (xoap::MessageReference message);
    virtual xoap::MessageReference  applicationStatusRequest        (xoap::MessageReference message);
    xoap::MessageReference          minReadyForEventGenerationStartIterationRequest(xoap::MessageReference message);
 
    bool                            stateMachineThread              (toolbox::task::WorkLoop* workLoop);
 
    virtual void                    stateInitial                    (toolbox::fsm::FiniteStateMachine& fsm);
    virtual void                    statePaused                     (toolbox::fsm::FiniteStateMachine& fsm);
    virtual void                    stateRunning                    (toolbox::fsm::FiniteStateMachine& fsm);
    virtual void                    stateHalted                     (toolbox::fsm::FiniteStateMachine& fsm);
    virtual void                    stateConfigured                 (toolbox::fsm::FiniteStateMachine& fsm);
    virtual void                    inError                         (toolbox::fsm::FiniteStateMachine& fsm);
 
    virtual void                    transitionConfiguring           (toolbox::Event::Reference event);
  protected:
    void                            configureInit                   (bool attemptSkipIfGroupUnchanged = false);
    void                            transitionConfiguringFSMs       (void);
  public:
    virtual void                    transitionHalting               (toolbox::Event::Reference event);
    virtual void                    transitionInitializing          (toolbox::Event::Reference event);
    virtual void                    transitionPausing               (toolbox::Event::Reference event);
    virtual void                    transitionResuming              (toolbox::Event::Reference event);
    virtual void                    transitionStarting              (toolbox::Event::Reference event);
    virtual void                    transitionStopping              (toolbox::Event::Reference event);
    virtual void                    enteringError                   (toolbox::Event::Reference event);
 
    static const std::string WORK_LOOP_DONE, WORK_LOOP_WORKING;
 
  protected:
    WorkLoopManager             stateMachineWorkLoopManager_;
    toolbox::BSem               stateMachineSemaphore_;
    std::vector<VStateMachine*> theStateMachineImplementation_;
 
    bool lastActivationHadMergeOrOverride_ = false;
 
    std::vector<bool>       stateMachinesIterationDone_;
    std::set<unsigned int>  stateMachinesWaitingSubsystemIteration_;  
    unsigned int            lastSubsystemIterationIndexSeen_ = 0;
    unsigned int            stateMachinesIterationWorkCount_;
    unsigned int            subIterationWorkStateMachineIndex_;
    void              preStateMachineExecution(unsigned int i);
    void              postStateMachineExecution(unsigned int i);
    void              preStateMachineExecutionLoop(void);
    void              postStateMachineExecutionLoop(void);
 
    RemoteWebUsers              theRemoteWebUsers_;
 
};
// clang-format on
}  // namespace ots
 
#endif