NPLNetClient.h

#pragma once
#include "IParaWebService.h"
#include <string>
#include <map>
#include <set>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/scoped_ptr.hpp>

/* curl specific */
#include <curl/curl.h>


namespace ParaEngine
{
#ifdef HAS_JABBER_CLIENT
    class CNPLJabberClient;
#endif
    struct AssetEntity;

    using namespace std;

    class CAssetRequestData
    {
    public:
        CAssetRequestData():m_nAssetType(-1), m_bLazyLoading(false){};
        CAssetRequestData(AssetEntity& asset);
    public:
        int m_nAssetType;
        string m_sAssetKey;
        bool m_bLazyLoading;
    };

    class CURLRequestTask;
    typedef DWORD (*URL_REQUEST_TASK_CALLBACK)(int nResult, CURLRequestTask* pRequest, LPVOID lpUserData);

    class CURLRequestTask
    {
    public:
        enum URLREQUEST_TYPE
        {
            URL_REQUEST_HTTP_AUTO,
            URL_REQUEST_HTTP_GET,
            URL_REQUEST_HTTP_POST,
            URL_REQUEST_HTTP_GETFILE,
        };

        enum URLREQUEST_STATUS
        {
            // not yet started
            URL_REQUEST_UNSTARTED,
            URL_REQUEST_INCOMPLETE,
            URL_REQUEST_COMPLETED,
        };
        // default time out in milliseconds
        static const DWORD DEFAULT_TIME_OUT = 15000;

        CURLRequestTask():m_pFormPost(0), m_nTimeOutTime(DEFAULT_TIME_OUT), m_nStartTime(0),m_responseCode(0), m_pFormLast(0), m_pUserData(0), m_returnCode(CURLE_OK), m_type(URL_REQUEST_HTTP_AUTO), m_nPriority(0), m_nStatus(URL_REQUEST_UNSTARTED), m_pfuncCallBack(0), m_nBytesReceived(0), m_nTotalBytes(0), m_nUserDataType(0) {};
        ~CURLRequestTask();

    public:
        CURLFORMcode AppendFormParam(const char* name, const char* value);

        CURLFORMcode AppendFormParam(const char* name, const char* type, const char* file, const char* data, int datalen);

        void SetCurlEasyOpt(CURL* handle);

        void CompleteTask();

        static size_t CUrl_write_data_callback(void *buffer, size_t size, size_t nmemb, void *stream);
        static size_t CUrl_write_header_callback(void *buffer, size_t size, size_t nmemb, void *stream);

        void SetTimeOut(int nMilliSeconds);
        int GetTimeOut();

        void SetAssetRequestOpt(CAssetRequestData* pRequestData, URL_REQUEST_TASK_CALLBACK pFuncCallback=NULL);

        static DWORD Asset_HTTP_request_callback(int nResult, CURLRequestTask* pRequest, LPVOID lpUserData);

        void SafeDeleteUserData();

        bool IsTimedOut(DWORD nCurrentTime);

        DWORD UpdateTime();

    public:
        string m_url;
        struct curl_httppost* m_pFormPost;
        struct curl_httppost* m_pFormLast;

        int m_nPriority;
        string m_sNPLCallback;

        URL_REQUEST_TASK_CALLBACK m_pfuncCallBack;
        string m_sSaveToFileName;

        int m_nUserDataType;
        union {
            LPVOID m_pUserData;
            CAssetRequestData* m_pAssetData;
        };


        URLREQUEST_TYPE m_type;
        URLREQUEST_STATUS m_nStatus;

        DWORD m_nStartTime;
        DWORD m_nTimeOutTime;

        int m_nBytesReceived;
        int m_nTotalBytes;
        vector<char> m_data;
        vector<char> m_header;
        string m_sResponseData;
        string m_sResponseHeader;
        // curl return code
        CURLcode m_returnCode;   
        // the last received HTTP or FTP code. We will expect 200 for successful HTTP response
        long m_responseCode;   

    };

    class CRequestTaskPool 
    {
    public:
        class CUrlWorkerState
        {
        public:
            CUrlWorkerState(): m_easy_handle(NULL), m_pCurrentTask(NULL), m_returnCode(CURLE_OK), m_bIsCompleted(true) {};
            CURL* m_easy_handle;
            /* return code for last transfer */
            CURLcode m_returnCode;   
            bool m_bIsCompleted;   
            CURLRequestTask* m_pCurrentTask;
        };

        CRequestTaskPool():m_nRunningTaskCount(0), m_nMaxWorkerThreads(1), m_nMaxQueuedTask(65535), m_multi_handle(NULL){}
        ~CRequestTaskPool();
    public:
        bool AppendURLRequest(CURLRequestTask* pUrlTask);

        int DoProcess();

        void SetMaxTaskSlotsCount(int nCount);
    protected:
        CUrlWorkerState* GetFreeWorkerSlot();

        int CURL_MultiPerform();

    private:

        std::list <CURLRequestTask*> m_task_pool;

        int m_nMaxWorkerThreads;
        std::list <CUrlWorkerState> m_easy_handles;

        int m_nMaxQueuedTask;
        CURLM * m_multi_handle;
        int m_nRunningTaskCount;
    };


    class CNPLNetClient : public INPLWebServiceClient
    {
    public:
        CNPLNetClient();
        virtual ~CNPLNetClient();

        static CNPLNetClient* GetInstance();
        static void ReleaseInstance();
    public:

        virtual INPLWebService* GetWebService(const char* sURL);
        virtual INPLWebService* OpenWebService(const char* sURL, const char* sUserName, const char* sPassword, const char* sDomain);

        virtual bool CloseWebService(const char* sURL);

        virtual INPLJabberClient* GetJabberClient(const char* sJID);
        virtual INPLJabberClient* CreateJabberClient(const char* sJID);

        virtual bool CloseJabberClient(const char* sJID);

        virtual void AsyncDownload(const char* url, const char* destFolder, const char* callbackScript, const char* DownloaderName);


        virtual void CancelDownload(const char* DownloaderName);

        virtual int Download(const char* url, const char* destFolder, const char* callbackScript, const char* DownloaderName);

        virtual int ProcessResults();

        virtual int ProcessDownloaderResults();

        virtual void DeleteThis();

        //
        // Do url request 
        //

        virtual bool AppendURLRequest(CURLRequestTask* pUrlTask, const char* sPoolName = NULL);

        virtual bool ChangeRequestPoolSize(const char* sPoolName, int nCount);

        virtual int ProcessUrlRequests();

        void AddPendingRequest(const char* sURL);

        bool HasPendingRequest(const char* sURL);

        void RemovePendingRequest(const char* sURL);

        void ClearAllPendingRequests();

        string GetCachePath(const char* sFileUrl);

        void Cleanup();
    protected:

        CRequestTaskPool* CreateGetRequestTaskPool(const char* sPoolName = NULL);

    private:
#ifdef HAS_JABBER_CLIENT
        std::map <std::string, CNPLJabberClient*> m_jabberClients;
#endif
        std::map <std::string, CRequestTaskPool*> m_request_pools;

        std::set <std::string> m_pending_requests;

        boost::asio::io_service m_dispatcher_io_service;

        boost::scoped_ptr<boost::thread> m_dispatcherThread;

        boost::scoped_ptr<boost::asio::io_service::work> m_work_lifetime;
    };
}