RequestGateway.h

#if !defined(_REQUESTGATEWAY_H_)
#define _REQUESTGATEWAY_H_

#pragma once

#include "Stats.h"
#include "NetworkManager.h"
#include "RequestExecutor.h"
#include "RequestClient.h"


namespace   cmlabs{

// RequestGateway

class RequestGateway : public Runnable, public NetworkReceiver {
public:
    static bool UnitTest();

    friend THREAD_RET THREAD_FUNCTION_CALL RequestGatewayExecRun(THREAD_ARG arg);
    friend THREAD_RET THREAD_FUNCTION_CALL RequestGatewayClientRun(THREAD_ARG arg);

    RequestGateway(uint32 id, const char* version = NULL);
    virtual ~RequestGateway();

    bool init(const char* sslCertPath = NULL, const char* sslKeyPath = NULL);

    bool setWebServerInfo(const char* name, const char* rootdir, const char* indexfile);
    bool setExternalAPILabel(const char* label);
    bool setInternalAPILabel(const char* label);
    bool setCacheFiles(bool cache);
    bool setResponseType(const char* type);
    bool setLongRequestLimit(uint32 limit);
    bool setExecutorHeartbeatTimeout(uint32 timeout);
    bool setQueuingParameters(uint32 maxRequestQueueSize, uint32 maxRequestProcessingSize, uint32 priorityThreshold);

    bool addPort(uint16 port, uint8 encryption, bool enableHTTP = false, uint32 timeout = 3000);
    bool addGateway(uint32 id, std::string addr, uint16 port);
    bool addAuthUser(const char* user, const char* password);

    bool receiveNetworkEvent(NetworkEvent* evt, NetworkChannel* channel, uint64 conid);
    bool receiveMessage(DataMessage* msg, NetworkChannel* channel, uint64 conid);
    bool receiveHTTPRequest(HTTPRequest* req, NetworkChannel* channel, uint64 conid);

protected:
    bool runExec();
    bool runClient();

    bool callInternalAPI(const char* apiName, HTTPRequest* req, NetworkChannel* channel, uint64 conid);
    bool callExternalAPI(const char* apiName, HTTPRequest* req, NetworkChannel* channel, uint64 conid);

    bool sendRestartToExecutor(uint64 id);
    bool distributeDeadExecutorRequests(std::list<RequestReply*>& shortQueue, std::list<RequestReply*>& longQueue);

    uint64 getBestExecutorID(std::string requestString, uint32 reqSize, bool& isLongReq);
    //std::list<RequestConnection> getTopExecutors(std::string requestString, uint32 reqSize, bool& isLongReq);
    //bool sendToExecutor(RequestReply* reply);
    bool replyToClient(DataMessage* msg);
    bool addToRequestQueue(DataMessage* msg, uint64 origin, uint64 conID, uint64 clientRef);
    bool addRequestReplyToRequestQueue(RequestReply* reply);

    NetworkManager* manager;
    NetworkChannel* channel;
    std::map<uint64,RequestConnection> executors;
    std::map<uint64,RequestConnection> clients;
    std::map<uint64,RequestConnection> webClients;
    utils::WaitQueue<RequestReply*> execQ;
    utils::WaitQueuePointer<DataMessage*> replyQ;
    std::map<uint64,RequestReply*> requestMap;
    std::vector<std::string> longReqNames;
    std::map<std::string, uint64> httpAuth;

    utils::Mutex mutex;
    //uint32 threadID;
    uint64 systemStartTime;
    uint32 threadIDClient;
    uint64 lastRefID;
    uint64 clientSentCount;
    uint64 clientReceivedCount;
    uint64 execSentCount;
    uint64 execReceivedCount;

    uint32 id;
    uint16 port;
    uint32 longReqLimit;
    uint32 executorHeartbeatTimeout;
    uint32 maxRequestQueueSize;
    uint32 maxRequestProcessingSize;
    uint32 priorityThreshold;
    bool sslSupport;
    bool cacheFiles;
    bool replyXML;

    std::string webServerName;
    std::string rootdir;
    std::string indexFilename;
    std::string versionString;

    std::string internalAPITitle;
    std::string externalAPITitle;

    MovingAverage shortAvgStats;
    MovingAverage longAvgStats;
    //std::map<uint64, MovingAverage> shortAvgStatsExec;
    //std::map<uint64, MovingAverage> shortAvgStatsClients;
    //std::map<uint64, MovingAverage> shortAvgStatsWeb;
    //std::map<uint64, MovingAverage> longAvgStatsExec;
    //std::map<uint64, MovingAverage> longAvgStatsClients;
    //std::map<uint64, MovingAverage> longAvgStatsWeb;
};

THREAD_RET THREAD_FUNCTION_CALL RequestGatewayExecRun(THREAD_ARG arg);
THREAD_RET THREAD_FUNCTION_CALL RequestGatewayClientRun(THREAD_ARG arg);

}

#endif // _REQUESTGATEWAY_H_