GWServerConnector.h

#pragma once

#include <Poco/AtomicCounter.h>
#include <Poco/AutoPtr.h>
#include <Poco/Event.h>
#include <Poco/Mutex.h>
#include <Poco/Net/WebSocket.h>
#include <Poco/SharedPtr.h>
#include <Poco/Thread.h>
#include <Poco/Timespan.h>
#include <Poco/Timestamp.h>
#include <Poco/Util/Timer.h>

#include "commands/NewDeviceCommand.h"
#include "commands/ServerDeviceListCommand.h"
#include "commands/ServerLastValueCommand.h"
#include "core/CommandHandler.h"
#include "core/CommandSender.h"
#include "core/Exporter.h"
#include "core/GatewayInfo.h"
#include "gwmessage/GWAck.h"
#include "gwmessage/GWDeviceAcceptRequest.h"
#include "gwmessage/GWListenRequest.h"
#include "gwmessage/GWMessage.h"
#include "gwmessage/GWMessage.h"
#include "gwmessage/GWRequest.h"
#include "gwmessage/GWResponse.h"
#include "gwmessage/GWSensorDataConfirm.h"
#include "gwmessage/GWSetValueRequest.h"
#include "gwmessage/GWUnpairRequest.h"
#include "loop/StoppableLoop.h"
#include "server/GWMessageContext.h"
#include "server/GWSOutputQueue.h"
#include "server/GWContextPoll.h"
#include "ssl/SSLClient.h"
#include "util/Loggable.h"

namespace BeeeOn {

class GWServerConnector :
        public StoppableLoop,
        public CommandSender,
        public CommandHandler,
        public Exporter,
        protected Loggable {
public:
        typedef Poco::SharedPtr<GWServerConnector> Ptr;

        GWServerConnector();

        void start() override;
        void stop() override;

        void setHost(const std::string &host);
        void setPort(int port);
        void setPollTimeout(const Poco::Timespan &timeout);
        void setReceiveTimeout(const Poco::Timespan &timeout);
        void setSendTimeout(const Poco::Timespan &timeout);
        void setRetryConnectTimeout(const Poco::Timespan &timeout);
        void setBusySleep(const Poco::Timespan &timeout);
        void setResendTimeout(const Poco::Timespan &timeout);
        void setMaxMessageSize(int size);
        void setGatewayInfo(Poco::SharedPtr<GatewayInfo> info);
        void setSSLConfig(Poco::SharedPtr<SSLClient> config);
        void setInactiveMultiplier(int multiplier);

        bool accept(const Command::Ptr cmd) override;
        void handle(Command::Ptr cmd, Answer::Ptr answer) override;

        bool ship(const SensorData &data) override;

private:
        void startReceiver();

        void runReceiver();

        void startSender();

        void runSender();

        bool connectUnlocked();

        bool registerUnlocked();

        void connectAndRegisterUnlocked();

        void disconnectUnlocked();

        void reconnect();

        void markDisconnected();

        void sendPing();

        void forwardContext(GWMessageContext::Ptr context);

        void forwardOutputQueue();
        void sendMessage(const GWMessage::Ptr message);
        void sendMessageUnlocked(const GWMessage::Ptr message);

        void doNewDeviceCommand(NewDeviceCommand::Ptr cmd, Answer::Ptr answer);
        void doDeviceListCommand(ServerDeviceListCommand::Ptr cmd, Answer::Ptr answer);
        void doLastValueCommand(ServerLastValueCommand::Ptr cmd, Answer::Ptr answer);

        void dispatchServerCommand(Command::Ptr cmd, const GlobalID &id, GWResponse::Ptr response);

        void handleRequest(GWRequest::Ptr request);

        void handleDeviceAcceptRequest(GWDeviceAcceptRequest::Ptr request);
        void handleListenRequest(GWListenRequest::Ptr request);
        void handleSetValueRequest(GWSetValueRequest::Ptr request);
        void handleUnpairRequest(GWUnpairRequest::Ptr request);

        void handleResponse(GWResponse::Ptr response);

        void handleAck(GWAck::Ptr ack);

        void handleSensorDataConfirm(GWSensorDataConfirm::Ptr confirm);

        void handleMessage(GWMessage::Ptr msg);

        void enqueueFinishedAnswers();

        bool connectionSeemsBroken();
        void updateLastReceived();

        GWMessage::Ptr receiveMessageUnlocked();

        Poco::Event &readyToSendEvent();

private:
        std::string m_host;
        int m_port;
        Poco::Timespan m_pollTimeout;
        Poco::Timespan m_receiveTimeout;
        Poco::Timespan m_sendTimeout;
        Poco::Timespan m_retryConnectTimeout;
        Poco::Timespan m_busySleep;
        Poco::Timespan m_resendTimeout;
        size_t m_maxMessageSize;
        Poco::SharedPtr<GatewayInfo> m_gatewayInfo;
        Poco::SharedPtr<SSLClient> m_sslConfig;
        Poco::Timestamp m_lastReceived;
        Poco::FastMutex m_lastReceivedMutex;
        int m_inactiveMultiplier;

        Poco::FastMutex m_dispatchLock;

        Poco::Buffer<char> m_receiveBuffer;
        Poco::SharedPtr<Poco::Net::WebSocket> m_socket;
        Poco::FastMutex m_receiveMutex;
        Poco::FastMutex m_sendMutex;
        Poco::Thread m_senderThread;
        Poco::Thread m_receiverThread;

        Poco::AtomicCounter m_isConnected;
        Poco::Event m_connectedEvent;

        Poco::AtomicCounter m_stop;
        Poco::Event m_stopEvent;

        GWContextPoll m_contextPoll;
        GWSOutputQueue m_outputQueue;
        Poco::Util::Timer m_timer;
};

}