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 NCRestorer;
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class IONotifyController:
    public IOController,
    public POA_IONotifyController_i
{
    public:

        IONotifyController(const std::string& name, const std::string& section, std::shared_ptr<NCRestorer> dumper = nullptr );
        IONotifyController(const uniset::ObjectId id, std::shared_ptr<NCRestorer> dumper = 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;
        Poco::JSON::Object::Ptr httpRequest( const string& req, const Poco::URI::QueryParameters& p );
#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;
            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;

        struct ThresholdInfoExt:
            public IONotifyController_i::ThresholdInfo
        {
            ThresholdInfoExt( uniset::ThresholdId tid, CORBA::Long low, CORBA::Long hi, bool inv,
                              uniset::ObjectId _sid = uniset::DefaultObjectId ):
                sid(_sid),
                invert(inv)
            {
                id       = tid;
                hilimit  = hi;
                lowlimit = low;
                state    = IONotifyController_i::NormalThreshold;
            }

            ConsumerListInfo clst; 
            uniset::ObjectId sid;

            IOController::IOStateList::iterator sit;

            bool invert;

            inline bool operator== ( const ThresholdInfo& r ) const
            {
                return ((id == r.id) &&
                        (hilimit == r.hilimit) &&
                        (lowlimit == r.lowlimit) &&
                        (invert == r.invert) );
            }

            operator IONotifyController_i::ThresholdInfo()
            {
                IONotifyController_i::ThresholdInfo r;
                r.id = id;
                r.hilimit = hilimit;
                r.lowlimit = lowlimit;
                r.invert = invert;
                r.tv_sec = tv_sec;
                r.tv_nsec = tv_nsec;
                r.state = state;
                return r;
            }

            ThresholdInfoExt( const ThresholdInfoExt& ) = delete;
            ThresholdInfoExt& operator=( const ThresholdInfoExt& ) = delete;
            ThresholdInfoExt( ThresholdInfoExt&& ) = default;
            ThresholdInfoExt& operator=(ThresholdInfoExt&& ) = default;
        };

        typedef std::list<ThresholdInfoExt> ThresholdExtList;

        struct ThresholdsListInfo
        {
            ThresholdsListInfo() {}
            ThresholdsListInfo( const IOController_i::SensorInfo& si, ThresholdExtList&& list,
                                UniversalIO::IOType t = UniversalIO::AI ):
                si(si), type(t), list( std::move(list) ) {}

            uniset::uniset_rwmutex mut;

            IOController_i::SensorInfo si = { uniset::DefaultObjectId, uniset::DefaultObjectId };
            std::shared_ptr<USensorInfo> usi;
            UniversalIO::IOType type = { UniversalIO::AI };
            ThresholdExtList list;   
        };

        typedef std::unordered_map<uniset::ObjectId, ThresholdsListInfo> AskThresholdMap;

    protected:
        IONotifyController();
        virtual bool activateObject() override;
        virtual void initItem(std::shared_ptr<USensorInfo>& usi, IOController* ic );

        virtual void send( ConsumerListInfo& lst, const uniset::SensorMessage& sm );

        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 );

        ThresholdExtList::iterator findThreshold( const uniset::ObjectId sid, const uniset::ThresholdId tid );

        virtual void dumpOrdersList( const uniset::ObjectId sid, const IONotifyController::ConsumerListInfo& lst );

        virtual void dumpThresholdList( const uniset::ObjectId sid, const IONotifyController::ThresholdExtList& lst );

        virtual void readDump();

        std::shared_ptr<NCRestorer> 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;

        // идентификаторы данные в userdata (см. USensorInfo::userdata)
        enum UserDataID
        {
            udataConsumerList = 0,
            udataThresholdList = 1
        };

#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 string& req, const Poco::URI::QueryParameters& p );
        Poco::JSON::Object::Ptr getConsumers(uniset::ObjectId sid, ConsumerListInfo& clist, bool ifNotEmpty = true );
#endif
                
    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);

        bool addThreshold(ThresholdExtList& lst, ThresholdInfoExt&& ti, const uniset::ConsumerInfo& ci);
        bool removeThreshold(ThresholdExtList& lst, ThresholdInfoExt& 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
// --------------------------------------------------------------------------