UniSetObject.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 UniSetObject_H_
#define UniSetObject_H_
//--------------------------------------------------------------------------
#include <condition_variable>
#include <thread>
#include <mutex>
#include <atomic>
#include <ostream>
#include <memory>
#include <string>
#include <list>
 
#include "UniSetTypes.h"
#include "MessageType.h"
#include "PassiveTimer.h"
#include "Exceptions.h"
#include "UInterface.h"
#include "UniSetObject_i.hh"
#include "ThreadCreator.h"
#include "LT_Object.h"
#include "MQMutex.h"
#include "UHttpRequestHandler.h"
 
//---------------------------------------------------------------------------
namespace uniset
{
    //---------------------------------------------------------------------------
    class UniSetActivator;
    class UniSetManager;
 
    //---------------------------------------------------------------------------
    class UniSetObject;
    typedef std::list< std::shared_ptr<UniSetObject> > ObjectsList;     
    //---------------------------------------------------------------------------
    class UniSetObject:
        public std::enable_shared_from_this<UniSetObject>,
        public POA_UniSetObject_i,
        public LT_Object
#ifndef DISABLE_REST_API
        , public uniset::UHttp::IHttpRequest
#endif
    {
        public:
            UniSetObject( const std::string& name, const std::string& section );
            UniSetObject( uniset::ObjectId id );
            UniSetObject();
            virtual ~UniSetObject();
 
            // Функции объявленые в IDL
            virtual CORBA::Boolean exist() override;
 
            virtual uniset::ObjectId getId() override;
 
            const uniset::ObjectId getId() const;
            std::string getName() const;
 
            virtual uniset::ObjectType getType() override
            {
                return uniset::ObjectType("UniSetObject");
            }
 
            const std::string getStrType();
 
            virtual uniset::SimpleInfo* getInfo( const char* userparam = "" ) override;
 
            // обёртка для вызова HTTP API через RPC
            virtual uniset::SimpleInfo* apiRequest( const char* query ) override;

            virtual void push( const uniset::TransportMessage& msg ) override;

            virtual void pushMessage( const char* msg,
                                      ::CORBA::Long mtype,
                                      const ::uniset::Timespec& tm,
                                      const ::uniset::ProducerInfo& pi,
                                      ::CORBA::Long priority,
                                      ::CORBA::Long consumer ) override;
 
#ifndef DISABLE_REST_API
            // HTTP API (IHttpRequest)
            virtual Poco::JSON::Object::Ptr httpRequest( const UHttp::HttpRequestContext& ctx ) override;
            virtual Poco::JSON::Object::Ptr httpHelp( const Poco::URI::QueryParameters& p ) override;
#endif
            // -------------- вспомогательные --------------
            uniset::ObjectPtr getRef() const;
            std::shared_ptr<UniSetObject> get_ptr();

            virtual timeout_t askTimer( uniset::TimerId timerid, timeout_t timeMS, clock_t ticks = -1,
                                        uniset::Message::Priority p = uniset::Message::High ) override;
 
            friend std::ostream& operator<<(std::ostream& os, UniSetObject& obj );
 
        protected:
 
            std::shared_ptr<UInterface> ui; 
            std::string myname;
            std::weak_ptr<UniSetManager> mymngr;

            virtual void processingMessage( const uniset::VoidMessage* msg );
 
            // конкретные виды сообщений
            virtual void sysCommand( const uniset::SystemMessage* sm ) {}
            virtual void sensorInfo( const uniset::SensorMessage* sm ) {}
            virtual void timerInfo( const uniset::TimerMessage* tm ) {}
            virtual void onTextMessage( const uniset::TextMessage* tm ) {}

            VoidMessagePtr receiveMessage();

            VoidMessagePtr waitMessage( timeout_t msec = UniSetTimer::WaitUpTime );

            void termWaiting();

            size_t countMessages();

            size_t getCountOfLostMessages() const;

            virtual bool activateObject();

            virtual bool deactivateObject();
 
            // прерывание работы всей программы (с вызовом shutdown)
            void uterminate();
 
            // управление созданием потока обработки сообщений -------

            void thread( bool create );

            void offThread();

            void onThread();

            virtual void callback();
 
            // ----- конфигурирование объекта -------
            void setID(uniset::ObjectId id);

            void setThreadPriority( Poco::Thread::Priority p );

            void setMaxSizeOfMessageQueue( size_t s );

            size_t getMaxSizeOfMessageQueue() const;

            bool isActive() const;

            void setActive( bool set );
 
#ifndef DISABLE_REST_API
            // вспомогательные функции
            virtual Poco::JSON::Object::Ptr httpGetMyInfo( Poco::JSON::Object::Ptr root );
            Poco::JSON::Object::Ptr request_configure( const std::string& req, const Poco::URI::QueryParameters& p );
            Poco::JSON::Object::Ptr request_configure_get( const std::string& req, const Poco::URI::QueryParameters& p );
            Poco::JSON::Object::Ptr request_configure_by_name( const std::string& name, const std::string& props );
            Poco::JSON::Object::Ptr request_params( const std::string& req, const Poco::URI::QueryParameters& p );
            virtual Poco::JSON::Object::Ptr request_params_get( const std::string& req, const Poco::URI::QueryParameters& p );
            virtual Poco::JSON::Object::Ptr request_params_set( const std::string& req, const Poco::URI::QueryParameters& p );
#endif
 
        private:
 
            friend class UniSetManager;
            friend class UniSetActivator;

            void work();
            bool init( const std::weak_ptr<UniSetManager>& om );
            bool deactivate();
            bool activate();
            /* регистрация в репозитории объектов */
            void registration();
            /* удаление ссылки из репозитория объектов     */
            void unregistration();
 
            void waitFinish();
 
            void initObject();
 
            pid_t msgpid = { 0 }; // pid потока обработки сообщений
            bool regOK = { false };
            std::atomic_bool active;
 
            bool threadcreate;
            std::unique_ptr<UniSetTimer> tmr;
            uniset::ObjectId myid;
            CORBA::Object_var oref;

            mutable uniset::uniset_rwmutex refmutex;
 
            std::unique_ptr< ThreadCreator<UniSetObject> > thr;

            MQMutex mqueueLow;
            MQMutex mqueueMedium;
            MQMutex mqueueHi;
 
            bool a_working;
            std::mutex    m_working;
            std::condition_variable cv_working;
    };
    // -------------------------------------------------------------------------
} // end of uniset namespace
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------