CscMessagingManager.h

Go to the documentation of this file.

#ifndef CscMessagingManager_H_
#define CscMessagingManager_H_
 
#include "CscCommon.h"
 
#include "Communication/CscMessageReader.h"
#include "Communication/CscMessageSender.h"
#include "Communication/CscMessageHandler.h"
#include "Communication/CscMessageEncryption.h"
#include "Communication/CscMessageLowLevelHandler.h"
 
#include "TcpServer.h"
#include "UdpServer.h"
#include "TcpClient.h"
#include <algorithm>
#include <mutex>
 
#define MAXLINE 4096
#define CONSCIENCE_ERROR_MESSAGE "__CSC_COM_ERROR"
 
using namespace conscience_utils::logging;
 
using std::remove, std::mutex, std::recursive_mutex, std::thread;
 
namespace conscience_core::communication {
 
    class CscMessagingManager {
    public:
        CscMessagingManager(CscMessagingPort tcpPort, CscMessagingPort udpPort, const CscMessageEncryption *messageEncryption, CscMessageHandler *messageHandler);
        
        ~CscMessagingManager();
        
        optional<string> sendTcp(const string &message, const string &ip, CscMessagingPort port);
        void sendUdp(const string &message, const string &ip, CscMessagingPort port);
        void sendMessage(const string &message, ptr<CscMessagingRequestContext> context, CscMessageSender *sender = nullptr);
        void sendMessageAndDownloadResponseBytes(const string &message, ptr<CscMessagingRequestContext> context, fs::path outPath, optional<function<void(float progress)>> onDownloadProgress = {}, CscMessageSender *sender = nullptr);
 
        ptr<CscMessagingRequestContext> sendMessage(const string &message, const string &ip, CscMessagingPort port, CscMessagingProtocol protocol, CscMessageSender *sender = nullptr);
 
        const string &getUid() const;
        optional<CscMessagingPort> getUdpServerPort();
 
        CscMessageSender *getSender();
    private:
        const string uid;
        
        const CscMessageLowLevelHandler *lowLevelHandler = nullptr;
        CscMessageSender *unencryptedSender = nullptr;
 
        const CscMessageEncryption *messageEncryption = nullptr;
        CscMessageReader *messageReader = nullptr;
        CscMessageSender *messageSender = nullptr;
        void initForEncryption(const CscMessageEncryption *messageEncryption);
 
        CscMessageHandler *messageHandler = nullptr;
        
        TcpServer *tcpServer = nullptr;
        UdpServer *udpServer = nullptr;
        CscMessagingPort udpPort;
        
        bool started = true;
        ptr<bool> destroyed = newptr<bool>(false);
        
        void startUdpServer(CscMessagingPort udpPort);
        void startTcpServer(CscMessagingPort tcpPort);
 
        bool onMessageDataReceived(vector<unsigned char> *messageData, ptr<CscMessagingRequestContext> context);
        void onMessageFullyReceived(const string &receivedMessage, ptr<CscMessagingRequestContext> context);
 
        void processIncomingMessage(const string message, ptr<CscMessagingRequestContext> context);
        
        ptr<CscMessagingRequestContext> sendMessageBytes(vector<unsigned char> *data, const string &ip, CscMessagingPort port, CscMessagingProtocol protocol, optional<fs::path> downloadResponseToPath = {}, optional<function<void(float progress)>> onDownloadProgress = {}, CscMessageSender *sender = nullptr);
        void sendMessageBytes(vector<unsigned char> *data, ptr<CscMessagingRequestContext> context, optional<fs::path> downloadResponseToPath = {}, optional<function<void(float progress)>> onDownloadProgress = {}, CscMessageSender *sender = nullptr);
        void sendBack(CscMessageHandlerResult response, ptr<CscMessagingRequestContext> context);
 
 
        unique_ptr<CscLogger> logger;
    };
}
 
#endif