AlarmSourceImpl.h

Go to the documentation of this file.

#ifndef ACS_ALARMSOURCEIMPL_H
#define ACS_ALARMSOURCEIMPL_H
/*
 *    ALMA - Atacama Large Millimiter Array
 *    (c) European Southern Observatory, 2011
 *    Copyright by ESO (in the framework of the ALMA collaboration),
 *    All rights reserved
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 2.1 of the License, or (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *    MA 02111-1307  USA
 */

#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif

#include <map>
#include <set>
#include <memory>

#include "AlarmSource.h"
#include "ACSAlarmSystemInterfaceFactory.h"
#include "AlarmToQueue.h"
#include "AlarmsMap.h"
#include "AlarmSourceThread.h"

#include <maciS.h>
#include <acscommonC.h>

#include "ace/Task.h"

namespace acsalarm
{

        class AlarmSourceImpl: public AlarmSource {
        private:
                // true if the sending of alarms has been disabled
                bool m_disabled;

                // Signal if the object is locally queuing alarms instead of
                // sending them immediately to the alarm server
                bool m_queuing;

                // Synchronize access to shared vars
                ACE_Recursive_Thread_Mutex m_mutex;

                std::map<std::string, AlarmToQueue*> m_queue;

                std::set<std::string> m_activatedAlarms;

                AlarmsMap m_alarms;

                auto_ptr<acsalarm::AlarmSystemInterface> m_alarmSource_ap;

                const AlarmSourceThread* m_updaterThread_p;

                bool m_locallyInstantiatedThread;

                ACS::Time m_nextMapUpdateTime;

                ACS::Time m_nextFlushTime;


        public:

                AlarmSourceImpl(const AlarmSourceThread* updaterThread);

                AlarmSourceImpl();

                virtual ~AlarmSourceImpl();

                void raiseAlarm(
                                std::string faultFamily,
                                std::string faultMember,
                                int faultCode);

                void raiseAlarm(
                                std::string faultFamily,
                                std::string faultMember,
                                int faultCode,
                                Properties properties);

                void clearAlarm(
                                std::string faultFamily,
                                std::string faultMember,
                                int faultCode);

                void setAlarm(
                                std::string faultFamily,
                                std::string faultMember,
                                int faultCode,
                                Properties alarmProps,
                                bool active);

                void setAlarm(
                                std::string faultFamily,
                                std::string faultMember,
                                int faultCode,
                                bool active);

                void terminateAllAlarms();

                void queueAlarms(ACS::TimeInterval time);

                void queueAlarms();

                void flushAlarms();

                void disableAlarms();

                void enableAlarms();

                virtual void update(ACS::Time now);

                void start();

                void tearDown();
        private:
                std::string buildAlarmID(std::string faultFamily, std::string faultMember, int faultCode);

                void internalAlarmSender(
                                std::string faultFamily,
                                std::string faultMember,
                                int faultCode,
                                Properties alarmProps,
                                bool active);
        };

}

#endif // ACS_ALARMSOURCEIMPL_H