ModbusTCPServer.h

// -------------------------------------------------------------------------
#ifndef ModbusTCPServer_H_
#define ModbusTCPServer_H_
// -------------------------------------------------------------------------
#include <string>
#include <queue>
#include <ev++.h>
#include <sigc++/sigc++.h>
#include "Mutex.h"
#include "Debug.h"
#include "Configuration.h"
#include "PassiveTimer.h"
#include "ModbusTypes.h"
#include "ModbusServer.h"
#include "ModbusTCPSession.h"
#include "UTCPSocket.h"
#include "EventLoopServer.h"
// -------------------------------------------------------------------------
namespace uniset
{
    // -------------------------------------------------------------------------
    class ModbusTCPServer:
        public EventLoopServer,
        public ModbusServer
    {
        public:
            ModbusTCPServer( const std::string& addr, int port = 502 );
            virtual ~ModbusTCPServer();
 
            bool run( const std::unordered_set<ModbusRTU::ModbusAddr>& vmbaddr );
 
            bool async_run( const std::unordered_set<ModbusRTU::ModbusAddr>& vmbaddr );
 
            virtual void terminate() override;
 
            virtual bool isActive() const override;
 
            void setMaxSessions( size_t num );
            size_t getMaxSessions() const noexcept;
 
            void setSessionTimeout( timeout_t msec );
            timeout_t getSessionTimeout() const noexcept;
 
            size_t getCountSessions() const noexcept;
 
            // Сбор статистики по соединениям...
            struct SessionInfo
            {
                SessionInfo( const std::string& a, size_t ask ): iaddr(a), askCount(ask) {}
 
                std::string iaddr;
                size_t askCount;
            };
 
            typedef std::list<SessionInfo> Sessions;
 
            void getSessions( Sessions& lst );
 
            std::string getInetAddress() const noexcept;
            int getInetPort() const noexcept;
 
            // статистика
            size_t getConnectionCount() const noexcept;
 
            // -------------------------------------------------
            // Таймер.
            // Т.к. eventLoop() "бесконечный", то сделана возможность
            // подключиться к сигналу "таймера", например для обновления статистики по сессиям
            // \warning Следует иметь ввиду, что обработчик сигнала, должен быть максимально коротким
            // т.к. на это время останавливается работа основного потока (eventLoop)
            // -------------------------------------------------
            typedef sigc::signal<void> TimerSignal;
            TimerSignal signal_timer();
 
            void setTimer( timeout_t msec );
            timeout_t getTimer() const noexcept;
 
            // Таймаут для переоткрытия сокета.
            // Если в течение msec миллисекунд нет действующих соединений
            // сокет переоткрывается
            void setSocketTimeout( timeout_t msec );
            timeout_t getSocketTimeout() const noexcept;
 
        protected:
 
            // ожидание (при этом время отдаётся eventloop-у)
            virtual void iowait( timeout_t msec ) override;
 
            // функция receive пока не поддерживается...
            virtual ModbusRTU::mbErrCode realReceive( const std::unordered_set<ModbusRTU::ModbusAddr>& vaddr, timeout_t msecTimeout ) override;
 
            virtual void evprepare() override;
            virtual void evfinish() override;
 
            virtual void ioAccept(ev::io& watcher, int revents);
            void onTimer( ev::timer& t, int revents );
            void onSocketTimeout( ev::timer& t, int revents );
            void onSocketResetTimeout( ev::async& watcher, int revents ) noexcept;
 
            void sessionFinished( const ModbusTCPSession* s );
 
            virtual size_t getNextData( unsigned char* buf, int len ) override
            {
                return 0;
            }
 
            virtual ModbusRTU::mbErrCode sendData( unsigned char* buf, int len ) override
            {
                return  ModbusRTU::erHardwareError;
            }
 
            virtual void setChannelTimeout( timeout_t msec ) override {};
 
            int port = { 0 };
            std::string iaddr;
            std::string myname;
            std::queue<unsigned char> qrecv;
            ModbusRTU::MBAPHeader curQueryHeader;
 
            std::mutex sMutex;
            typedef std::list<std::shared_ptr<ModbusTCPSession>> SessionList;
            SessionList slist;
 
            bool ignoreAddr = { false };
 
            size_t maxSessions = { 100 };
            size_t sessCount = { 0 };
 
            // Статистика
            size_t connCount = { 0 }; // количество обработанных соединений
 
            timeout_t sessTimeout = { 10000 }; // msec
 
            ev::io io;
            ev::timer ioTimer;
            std::shared_ptr<UTCPSocket> sock;
 
            ev::timer sockTimeout;
            timeout_t socketTimeout_msec = { UniSetTimer::WaitUpTime };
            double tmSockTimeout = { 0.0 };
            ev::async asyncResetSockTimeout;
 
            std::unordered_set<ModbusRTU::ModbusAddr> vmbaddr;
            TimerSignal m_timer_signal;
 
            timeout_t tmTime_msec = { UniSetTimer::WaitUpTime }; // время по умолчанию для таймера (TimerSignal)
            double tmTime = { 0.0 };
 
            PassiveTimer ptWait;
 
        private:
            void createSocket();
 
            // транслирование сигналов от Sessions..
            void postReceiveEvent( ModbusRTU::mbErrCode res );
            ModbusRTU::mbErrCode preReceiveEvent( const std::unordered_set<ModbusRTU::ModbusAddr> vaddr, timeout_t tout );
    };
    // -------------------------------------------------------------------------
} // end of namespace uniset
// -------------------------------------------------------------------------
#endif // ModbusTCPServer_H_
// -------------------------------------------------------------------------