SharedMemory/SharedMemory.h

// -----------------------------------------------------------------------------
#ifndef SharedMemory_H_
#define SharedMemory_H_
// -----------------------------------------------------------------------------
#include <string>
#include <deque>
#include "IONotifyController_LT.h"
#include "Mutex.h"
#include "PassiveTimer.h"
#include "NCRestorer.h"
#include "WDTInterface.h"
// -----------------------------------------------------------------------------

class SharedMemory:
    public IONotifyController_LT
{
    public:
        SharedMemory( UniSetTypes::ObjectId id, const std::string& datafile, const std::string& confname="" );
        virtual ~SharedMemory();

        static SharedMemory* init_smemory( int argc, const char* const* argv );
        static void help_print( int argc, const char* const* argv );

        // функция определяет "готовность" SM к работе.
        // должна использоваться другими процессами, для того,
        // чтобы понять, когда можно получать от SM данные.
        virtual CORBA::Boolean exist();

        void addReadItem( Restorer_XML::ReaderSlot sl );


        // ------------  HISTORY  --------------------
        typedef std::deque<long> HBuffer;

        struct HistoryItem
        {
            HistoryItem():id(UniSetTypes::DefaultObjectId){}

            inline void init( unsigned int size, long val )
            {
                if( size > 0 )
                   buf.assign(size,val);
            }

            UniSetTypes::ObjectId id;
            HBuffer buf;

            IOStateList::iterator ioit;

            void add( long val, size_t size )
            {
                // т.е. буфер у нас уже заданного размера
                // то просто удаляем очередную точку в начале
                // и добавляем в конце
                buf.pop_front();
                buf.push_back(val);
            }
        };

        typedef std::list<HistoryItem> HistoryList;

        struct HistoryInfo
        {
            HistoryInfo():
                id(0),
                size(0),filter(""),
                fuse_id(UniSetTypes::DefaultObjectId),
                fuse_invert(false),fuse_use_val(false),fuse_val(0),
                fuse_sec(0),fuse_usec(0)
                {
                      struct timeval tv;
                      struct timezone tz;
                      gettimeofday(&tv,&tz);
                      fuse_sec = tv.tv_sec;
                      fuse_usec = tv.tv_usec;
                }

            long id;                        // ID
            HistoryList hlst;               // history list
            int size;
            std::string filter;             // filter field
            UniSetTypes::ObjectId fuse_id;  // fuse sesnsor
            bool fuse_invert;
            bool fuse_use_val;
            long fuse_val;
            // timestamp
            long fuse_sec;
            long fuse_usec;
        };

        friend std::ostream& operator<<( std::ostream& os, const HistoryInfo& h );

        typedef std::list<HistoryInfo> History;

        // т.к. могуть быть одинаковые "детонаторы" для разных "историй" то,
        // вводим не просто map, а "map списка историй".
        // точнее итераторов-историй.
        typedef std::list<History::iterator> HistoryItList;
        typedef std::map<UniSetTypes::ObjectId,HistoryItList> HistoryFuseMap;

        typedef sigc::signal<void,HistoryInfo*> HistorySlot;
        HistorySlot signal_history(); 
        inline int getHistoryStep(){ return histSaveTime; } 
    protected:
        typedef std::list<Restorer_XML::ReaderSlot> ReadSlotList;
        ReadSlotList lstRSlot;

        virtual void sysCommand( const UniSetTypes::SystemMessage *sm ) override;
        virtual void timerInfo( const UniSetTypes::TimerMessage *tm ) override;
        virtual void askSensors( UniversalIO::UIOCommand cmd );
        void sendEvent( UniSetTypes::SystemMessage& sm );

        // действия при завершении работы
        virtual void sigterm( int signo ) override;
        virtual bool activateObject() override;
//        virtual void logging(UniSetTypes::SensorMessage& sm){}
//        virtual void dumpToDB(){}
        bool readItem( const std::shared_ptr<UniXML>& xml, UniXML::iterator& it, xmlNode* sec );

        void buildEventList( xmlNode* cnode );
        void readEventList( const std::string& oname );

        UniSetTypes::uniset_rwmutex mutex_start;

        struct HeartBeatInfo
        {
            HeartBeatInfo():
                a_sid(UniSetTypes::DefaultObjectId),
                d_sid(UniSetTypes::DefaultObjectId),
                reboot_msec(UniSetTimer::WaitUpTime),
                timer_running(false),
                ptReboot(UniSetTimer::WaitUpTime)
            {}

            UniSetTypes::ObjectId a_sid; // аналоговый счётчик
            UniSetTypes::ObjectId d_sid; // дискретный датчик состояния процесса
            IOStateList::iterator ioit;

            int reboot_msec; 
            bool timer_running;
            PassiveTimer ptReboot;
        };

        enum Timers
        {
            tmHeartBeatCheck,
            tmEvent,
            tmHistory,
            tmPulsar
        };

        int heartbeatCheckTime;
        std::string heartbeat_node;
        int histSaveTime;

        void checkHeartBeat();

        typedef std::list<HeartBeatInfo> HeartBeatList;
        HeartBeatList hlist; // список датчиков "сердцебиения"
        WDTInterface* wdt;
        std::atomic_bool activated;
        std::atomic_bool workready;

        typedef std::list<UniSetTypes::ObjectId> EventList;
        EventList elst;
        std::string e_filter;
        int evntPause;
        int activateTimeout;

        virtual void loggingInfo( UniSetTypes::SensorMessage& sm ) override;
        virtual void dumpOrdersList( const UniSetTypes::ObjectId sid, const IONotifyController::ConsumerListInfo& lst ) override {};
        virtual void dumpThresholdList( const UniSetTypes::ObjectId sid, const IONotifyController::ThresholdExtList& lst ) override {}

        bool dblogging;

        History hist;
        HistoryFuseMap histmap;  
        virtual void updateHistory( IOStateList::iterator& it, IOController* );
        virtual void saveHistory();

        void buildHistoryList( xmlNode* cnode );
        void checkHistoryFilter( UniXML::iterator& it );

        IOStateList::iterator itPulsar;
        UniSetTypes::ObjectId sidPulsar;
        int msecPulsar;

    private:
        HistorySlot m_historySignal;
};
// -----------------------------------------------------------------------------
#endif // SharedMemory_H_
// -----------------------------------------------------------------------------