/data/refman/pasoursint/CMSSW_5_3_1/src/EventFilter/ResourceBroker/interface/RBStateMachine.h

Go to the documentation of this file.

//
// RBStateMachine.h
// -------
//
// Finite state machine for the Resource Broker.
//
//  Created on: Dec 9, 2011
//                                                                              Andrei Spataru : aspataru@cern.ch

#ifndef RBBOOSTSTATEMACHINE_H_
#define RBBOOSTSTATEMACHINE_H_

#include "EventFilter/Utilities/interface/Exception.h"
#include "EventFilter/ResourceBroker/interface/FUTypes.h"

#include "xdaq2rc/RcmsStateNotifier.h"
#include "xdata/String.h"
#include "xdata/Bag.h"
#include "xdaq/Application.h"

#include <boost/statechart/event.hpp>
#include <boost/statechart/in_state_reaction.hpp>
#include <boost/statechart/state_machine.hpp>
#include <boost/statechart/state.hpp>
#include <boost/statechart/transition.hpp>
#include <boost/mpl/list.hpp>
#include <boost/shared_ptr.hpp>

#include "toolbox/task/Action.h"
#include "toolbox/task/WorkLoop.h"
#include "toolbox/task/WorkLoopFactory.h"

#include <iostream>
#include <string>
#include <vector>
#include <semaphore.h>

namespace bsc = boost::statechart;

namespace evf {

namespace rb_statemachine {

enum States {
        HALTED,
        CONFIGURING,
        READY,
        STOPPED,
        ENABLING,
        ENABLED,
        RUNNING,
        STOPPING,
        HALTING,
        NORMAL,
        FAILED
};

class SharedResources;
typedef boost::shared_ptr<SharedResources> SharedResourcesPtr_t;


// Outer states:
class Failed;
class Normal;

// Inner states of Normal:
class Halted;
class Halting;
class Configuring;
class Ready;

// Inner states of Ready:
class Stopped;
class Enabled;
class Enabling;
// state hidden from RCMS
class Stopping;

// Inner states of Enabled:
// state hidden from RCMS
class Running;


class Configure: public bsc::event<Configure> {
};
class ConfigureDone: public bsc::event<ConfigureDone> {
};
class Enable: public bsc::event<Enable> {
};
class EnableDone: public bsc::event<EnableDone> {
};
class Stop: public bsc::event<Stop> {
};
class StopDone: public bsc::event<StopDone> {
};
class Halt: public bsc::event<Halt> {
};
class HaltDone: public bsc::event<HaltDone> {
};
class Fail: public bsc::event<Fail> {
};

//______________________________________________________________________________
class BaseState {

public:

        BaseState();
        virtual ~BaseState() = 0;
        std::string stateName() const;
        void moveToFailedState(xcept::Exception& exception) const;

        /*
         * I2O message handling capability of states.
         * All states with special behavior must override these functions.
         */
        virtual bool take(toolbox::mem::Reference* bufRef) const {
                // output message handled in FUResourceBroker
                return false;
        }
        virtual bool evmLumisection(toolbox::mem::Reference* bufRef) const {
                // output message handled in FUResourceBroker
                return false;
        }
        virtual bool discardDataEvent(MemRef_t* bufRef) const {
                std::cout
                                << "RBStateMachine: current state does not support operation >>discardDataEvent<<"
                                << std::endl;
                // bool value doesn't matter... return value ignored by caller: FUResourceBroker
                return false;
        }

        virtual bool discardDqmEvent(MemRef_t* bufRef) const {
                std::cout
                                << "RBStateMachine: current state does not support operation >>discardDqmEvent<<"
                                << std::endl;
                // bool value doesn't matter... return value ignored by caller: FUResourceBroker
                return false;
        }

        /*
         * DEFAULT implementations of state-dependent actions.
         * All states with special behavior must override these functions.
         */

        virtual void do_stateNotify() = 0;

        virtual int stateID() const = 0;

        virtual void do_stateAction() const {
                // do nothing if state does not override this function
                /*
                 std::cout << "RBStateMachine: no >>STATE ACTION<< defined for state: "
                 << stateName() << std::endl;
                 */
        }

protected:

        virtual std::string do_stateName() const = 0;

        virtual void do_moveToFailedState(xcept::Exception& exception) const = 0;
        void fail();

        void safeEntryAction();
        virtual void do_entryActionWork() = 0;

        void safeExitAction();
        virtual void do_exitActionWork() = 0;

};

//______________________________________________________________________________
class RBStateMachine: public bsc::state_machine<RBStateMachine, Normal> {

public:

        RBStateMachine(xdaq::Application* app, SharedResourcesPtr_t sr);
        ~RBStateMachine();

        BaseState const& getCurrentState() const throw (std::bad_cast);

        inline SharedResourcesPtr_t getSharedResources() const {
                return sharedResources_;
        }
        inline std::string getExternallyVisibleState() {
                return visibleStateName_.value_;
        }
        inline xdata::String* getExternallyVisibleStatePtr() {
                return &visibleStateName_;
        }
        inline std::string getInternalStateName() {
                return internalStateName_;
        }
        inline xdaq::Application* getApp() const {
                return app_;
        }
        void setExternallyVisibleState(const std::string& s);
        void setInternalStateName(const std::string& s);
        inline bool firstTimeInHalted() const {
                return firstTimeInHalted_;
        }
        inline void setFirstTimeInHaltedFalse() {
                firstTimeInHalted_ = false;
        }

        xdata::Bag<xdaq2rc::ClassnameAndInstance>* rcmsStateListener();
        xdata::Boolean* foundRcmsStateListener();
        void findRcmsStateListener(xdaq::Application* app);
        void rcmsStateChangeNotify();

        // state-transition safety
        void transitionWriteLock() {
                pthread_rwlock_wrlock(&transitionLock_);
        }
        void transitionReadLock() {
                pthread_rwlock_rdlock(&transitionLock_);
        }
        void transitionUnlock() {
                pthread_rwlock_unlock(&transitionLock_);
        }

private:
        void updateWebGUIExternalState(std::string newStateName) const;
        void updateWebGUIInternalState(std::string newStateName) const;

private:

        xdaq::Application* app_;
        SharedResourcesPtr_t sharedResources_;
        xdaq2rc::RcmsStateNotifier rcmsStateNotifier_;
        xdata::String visibleStateName_;
        std::string internalStateName_;
        bool firstTimeInHalted_;

        pthread_rwlock_t transitionLock_;
};


//______________________________________________________________________________
class Failed: public bsc::state<Failed, RBStateMachine>, public BaseState {

public:

        Failed( my_context);
        virtual ~Failed();

        // state-dependent actions
        virtual void do_stateNotify();

        virtual int stateID() const {
                return rb_statemachine::FAILED;
        }

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;

};

//______________________________________________________________________________
class Normal: public bsc::state<Normal, RBStateMachine, Halted>,
                public BaseState {

public:

        typedef bsc::transition<Fail, Failed> FT;
        typedef boost::mpl::list<FT> reactions;

        // state-dependent actions
        virtual void do_stateNotify();

        virtual int stateID() const {
                return rb_statemachine::NORMAL;
        }

        Normal( my_context);
        virtual ~Normal();

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;
};

//______________________________________________________________________________
class Halted: public bsc::state<Halted, Normal>, public BaseState {

public:

        typedef bsc::transition<Configure, Configuring> RT;
        typedef boost::mpl::list<RT> reactions;

        // state-dependent actions
        virtual void do_stateNotify();

        virtual int stateID() const {
                return rb_statemachine::HALTED;
        }

        Halted( my_context);
        virtual ~Halted();

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;

};

//______________________________________________________________________________
class Configuring: public bsc::state<Configuring, Normal>, public BaseState {

public:

        typedef bsc::transition<ConfigureDone, Ready> CR;
        typedef boost::mpl::list<CR> reactions;

        Configuring( my_context);
        virtual ~Configuring();

        // state-dependent actions
        virtual void do_stateNotify();
        virtual int stateID() const {
                return rb_statemachine::CONFIGURING;
        }
        virtual void do_stateAction() const;

private:

        void connectToBUandSM() const throw (evf::Exception);

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;

};

//______________________________________________________________________________
class Ready: public bsc::state<Ready, Normal, Stopped>, public BaseState {

public:

        typedef bsc::transition<Halt, Halting> HT;
        typedef boost::mpl::list<HT> reactions;

        // state-dependent actions
        virtual void do_stateNotify();

        virtual int stateID() const {
                return rb_statemachine::READY;
        }

        Ready( my_context);
        virtual ~Ready();

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;

};

//______________________________________________________________________________
class Stopped: public bsc::state<Stopped, Ready>, public BaseState {

public:

        typedef bsc::transition<Enable, Enabling> ET;
        typedef boost::mpl::list<ET> reactions;

        // state-dependent actions
        virtual void do_stateNotify();

        virtual int stateID() const {
                return rb_statemachine::STOPPED;
        }

        Stopped( my_context);
        virtual ~Stopped();

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;

};

//______________________________________________________________________________
class Enabling: public bsc::state<Enabling, Ready>,
                public BaseState,
                public toolbox::lang::Class {

public:

        typedef bsc::transition<EnableDone, Enabled> ED;
        typedef boost::mpl::list<ED> reactions;

        Enabling( my_context);
        virtual ~Enabling();

        // state-dependent actions
        virtual void do_stateNotify();
        virtual int stateID() const {
                return rb_statemachine::ENABLING;
        }
        virtual void do_stateAction() const;

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;

};

//______________________________________________________________________________
class Enabled: public bsc::state<Enabled, Ready, Running>, public BaseState {

public:

        typedef bsc::transition<Stop, Stopping> ST;
        typedef boost::mpl::list<ST> reactions;

        // state-dependent actions
        virtual void do_stateNotify();

        virtual int stateID() const {
                return rb_statemachine::ENABLED;
        }

        Enabled( my_context);
        virtual ~Enabled();

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;

};

//______________________________________________________________________________
class Running: public bsc::state<Running, Enabled>,
                public BaseState,
                public toolbox::lang::Class {

public:

        Running( my_context);
        virtual ~Running();

        // I2O message handling capability of state
        virtual bool take(toolbox::mem::Reference* bufRef) const;
        virtual bool evmLumisection(toolbox::mem::Reference* bufRef) const;
        virtual bool discardDataEvent(MemRef_t* bufRef) const;
        virtual bool discardDqmEvent(MemRef_t* bufRef) const;

        // state-dependent actions
        virtual void do_stateNotify();
        virtual int stateID() const {
                return rb_statemachine::RUNNING;
        }

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;
};

//______________________________________________________________________________
class Stopping: public bsc::state<Stopping, Ready>, public BaseState {

public:

        typedef bsc::transition<StopDone, Stopped> SD;
        typedef boost::mpl::list<SD> reactions;

        Stopping( my_context);
        virtual ~Stopping();

        //I2O capability
        virtual bool discardDataEvent(MemRef_t* bufRef) const;
        virtual bool discardDqmEvent(MemRef_t* bufRef) const;

        // state-dependent actions
        virtual void do_stateNotify();
        virtual int stateID() const {
                return rb_statemachine::STOPPING;
        }
        virtual void do_stateAction() const;

private:

        void emergencyStop() const;

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;

        bool destructionIsDone() const;
};

//______________________________________________________________________________
class Halting: public bsc::state<Halting, Normal>, public BaseState {

public:

        typedef bsc::transition<HaltDone, Halted> HD;
        typedef boost::mpl::list<HD> reactions;

        Halting( my_context);
        virtual ~Halting();

        //I2O capability
        virtual bool discardDataEvent(MemRef_t* bufRef) const;
        virtual bool discardDqmEvent(MemRef_t* bufRef) const;

        // state-dependent actions
        virtual void do_stateNotify();
        virtual int stateID() const {
                return rb_statemachine::HALTING;
        }
        virtual void do_stateAction() const;

private:

        virtual std::string do_stateName() const;
        virtual void do_entryActionWork();
        virtual void do_exitActionWork();
        virtual void do_moveToFailedState(xcept::Exception& exception) const;

        bool destructionIsDone() const;

        void doAsync() const;

};

typedef boost::shared_ptr<RBStateMachine> RBStateMachinePtr;

} // end namespace rb_statemachine

} // end namespace evf

#endif /* RBBOOSTSTATEMACHINE_H_ */