IONotifyController.h

/*
 * Copyright (c) 2015 Pavel Vainerman.
 *
 * This program 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, version 2.1.
 *
 * This program 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 Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
#ifndef IONotifyController_H_
#define IONotifyController_H_
//---------------------------------------------------------------------------
#include <memory>
#include <unordered_map>
#include <list>
#include <string>
 
#include "UniSetTypes.h"
#include "IOController_i.hh"
#include "IOController.h"
 
//---------------------------------------------------------------------------
namespace uniset
{
    class IOConfig;
    //---------------------------------------------------------------------------
    //---------------------------------------------------------------------------
    class IONotifyController:
        public IOController,
        public POA_IONotifyController_i
    {
        public:
 
            IONotifyController(const std::string& name, const std::string& section, std::shared_ptr<IOConfig> ioconf = nullptr );
            IONotifyController(const uniset::ObjectId id, std::shared_ptr<IOConfig> ioconf = nullptr );
 
            virtual ~IONotifyController();
 
            virtual uniset::ObjectType getType() override
            {
                return uniset::ObjectType("IONotifyController");
            }
 
            virtual uniset::SimpleInfo* getInfo( const char* userparam = 0 ) override;
 
            virtual void askSensor(const uniset::ObjectId sid, const uniset::ConsumerInfo& ci, UniversalIO::UIOCommand cmd) override;
 
            virtual void askThreshold(const uniset::ObjectId sid, const uniset::ConsumerInfo& ci,
                                      uniset::ThresholdId tid,
                                      CORBA::Long lowLimit, CORBA::Long hiLimit, CORBA::Boolean invert,
                                      UniversalIO::UIOCommand cmd ) override;
 
            virtual IONotifyController_i::ThresholdInfo getThresholdInfo( const uniset::ObjectId sid, uniset::ThresholdId tid ) override;
            virtual IONotifyController_i::ThresholdList* getThresholds(const uniset::ObjectId sid ) override;
            virtual IONotifyController_i::ThresholdsListSeq* getThresholdsList() override;
 
            virtual uniset::IDSeq* askSensorsSeq(const uniset::IDSeq& lst,
                                                 const uniset::ConsumerInfo& ci, UniversalIO::UIOCommand cmd) override;
 
            // --------------------------------------------
 
#ifndef DISABLE_REST_API
            // http API
            virtual Poco::JSON::Object::Ptr httpHelp( const Poco::URI::QueryParameters& p ) override;
            virtual Poco::JSON::Object::Ptr httpRequest( const std::string& req, const Poco::URI::QueryParameters& p ) override;
#endif
 
            // --------------------------------------------
            struct ConsumerInfoExt:
                public uniset::ConsumerInfo
            {
                ConsumerInfoExt( const uniset::ConsumerInfo& ci,
                                 UniSetObject_i_ptr ref = 0, size_t maxAttemtps = 10 ):
                    uniset::ConsumerInfo(ci),
                    ref(ref), attempt(maxAttemtps) {}
 
                UniSetObject_i_var ref;
                size_t attempt = { 10 };
                size_t lostEvents = { 0 }; // количество потерянных сообщений (не смогли послать)
                size_t smCount = { 0 }; // количество посланных SensorMessage
 
                ConsumerInfoExt( const ConsumerInfoExt& ) = default;
                ConsumerInfoExt& operator=( const ConsumerInfoExt& ) = default;
                ConsumerInfoExt( ConsumerInfoExt&& ) = default;
                ConsumerInfoExt& operator=(ConsumerInfoExt&& ) = default;
            };
 
            typedef std::list<ConsumerInfoExt> ConsumerList;
 
            struct ConsumerListInfo
            {
                ConsumerListInfo(): mut("ConsumerInfoMutex") {}
                ConsumerList clst;
                uniset::uniset_rwmutex mut;
 
                ConsumerListInfo( const ConsumerListInfo& ) = delete;
                ConsumerListInfo& operator=( const ConsumerListInfo& ) = delete;
                ConsumerListInfo( ConsumerListInfo&& ) = default;
                ConsumerListInfo& operator=(ConsumerListInfo&& ) = default;
            };
 
            typedef std::unordered_map<uniset::ObjectId, ConsumerListInfo> AskMap;
 
            // связь: id датчика --> id порога --> список заказчиков
            // т.к. каждый порог имеет уникальный указатель, используем его в качестве ключа
            typedef std::unordered_map<UThresholdInfo*, ConsumerListInfo> AskThresholdMap;
 
        protected:
            IONotifyController();
            virtual bool activateObject() override;
            virtual void sensorsRegistration() override;
            virtual void initItem( std::shared_ptr<USensorInfo>& usi, IOController* ic );
 
            virtual void send( ConsumerListInfo& lst, const uniset::SensorMessage& sm, const uniset::ConsumerInfo* ci = nullptr );
 
            virtual void checkThreshold( std::shared_ptr<USensorInfo>& usi, bool send = true );
            virtual void checkThreshold( IOController::IOStateList::iterator& li, const uniset::ObjectId sid, bool send_msg = true );
 
            std::shared_ptr<UThresholdInfo> findThreshold( const uniset::ObjectId sid, const uniset::ThresholdId tid );
 
            virtual void readConf();
 
            std::shared_ptr<IOConfig> restorer;
 
            void onChangeUndefinedState( std::shared_ptr<USensorInfo>& usi, IOController* ic );
 
            // функция для работы напрямую с указателем (оптимизация)
            virtual long localSetValue( std::shared_ptr<USensorInfo>& usi,
                                        CORBA::Long value, uniset::ObjectId sup_id ) override;
 
#ifndef DISABLE_REST_API
            // http api
            Poco::JSON::Object::Ptr request_consumers( const std::string& req, const Poco::URI::QueryParameters& p );
            Poco::JSON::Object::Ptr request_lost( const std::string& req, const Poco::URI::QueryParameters& p );
            Poco::JSON::Object::Ptr getConsumers(uniset::ObjectId sid, ConsumerListInfo& clist, bool ifNotEmpty = true );
#endif
 
            // статистика
            void showStatisticsForConsumer( std::ostringstream& inf, const std::string& consumer );
            void showStatisticsForLostConsumers( std::ostringstream& inf );
            void showStatisticsForConsusmers( std::ostringstream& inf );
            void showStatisticsForConsumersWithLostEvent( std::ostringstream& inf );
            void showStatisticsForSensor( std::ostringstream& inf, const std::string& name );
 
            // идентификаторы данных в userdata (см. USensorInfo::userdata)
            enum UserDataID
            {
                udataConsumerList = 0
            };
 
        private:
 
            friend class NCRestorer;
 
            //----------------------
            bool addConsumer( ConsumerListInfo& lst, const uniset::ConsumerInfo& cons );     
            bool removeConsumer( ConsumerListInfo& lst, const uniset::ConsumerInfo& cons );  
 
            void ask(AskMap& askLst, const uniset::ObjectId sid,
                     const uniset::ConsumerInfo& ci, UniversalIO::UIOCommand cmd);
 
            std::shared_ptr<UThresholdInfo> addThresholdIfNotExist( std::shared_ptr<USensorInfo>& usi, std::shared_ptr<UThresholdInfo>& ti );
            bool addThresholdConsumer( std::shared_ptr<UThresholdInfo>& ti, const uniset::ConsumerInfo& ci );
 
            bool removeThresholdConsumer( std::shared_ptr<USensorInfo>& usi,
                                          std::shared_ptr<UThresholdInfo>& ti,
                                          const uniset::ConsumerInfo& ci);
 
            AskMap askIOList; 
            AskThresholdMap askTMap; 
            uniset::uniset_rwmutex askIOMutex;
            uniset::uniset_rwmutex trshMutex;
 
            sigc::connection conInit;
            sigc::connection conUndef;
 
            int maxAttemtps; 
            int sendAttemtps; 
            std::mutex lostConsumersMutex;
 
            struct LostConsumerInfo
            {
                size_t count = { 0 }; // количество "пропаданий"
                bool lost = { false }; // флаг означающий что "заказчик пропал"
                // lost нужен чтобы в count не увеличивать, на send() по каждому датчику, если заказчик заказывал больше одного датчика)
                // флаг сбрасывается при перезаказе датчика..
            };
 
            std::unordered_map<uniset::ObjectId, LostConsumerInfo> lostConsumers;
    };
    // -------------------------------------------------------------------------
} // end of uniset namespace
// --------------------------------------------------------------------------
#endif
// --------------------------------------------------------------------------