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();
 
    static constexpr unsigned char ConscienceFastMessagePrefix[] =
        {'z', 'z', '_', 'C', 's', 'c', 'F', 'a', 's', 't', '_', 'z', 'z'};
 
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