URL.h

Go to the documentation of this file.

#ifndef URL_H_9DAEGSMV
#define URL_H_9DAEGSMV

#include "uscxml/Common.h"
#include "uscxml/messages/Event.h"

#define DOWNLOAD_IF_NECESSARY if (!_isDownloaded) { download(true); }

#include <string>
#include <sstream>
#include <map>
#include <set>
#include <list>
#include <thread>
#include <condition_variable>
#include <curl/curl.h>
#include <uriparser/Uri.h>

#define USCXML_URI_STRING(obj, field) std::string(obj.field.first, obj.field.afterLast - obj.field.first)

namespace uscxml {

class URL;

class USCXML_API URLMonitor {
public:
    virtual void downloadStarted(const URL& url) {};
    virtual void downloadCompleted(const URL& url) {};
    virtual void downloadFailed(const URL& url, int errorCode) {};
    virtual void headerChunkReceived(const URL& url, const std::string& headerChunk) {};
    virtual void contentChunkReceived(const URL& url, const std::string& contentChunk) {};
};

enum URLRequestType {
    POST,
    GET
};

class USCXML_API URLImpl : public std::enable_shared_from_this<URLImpl> {
public:
    URLImpl(const std::string& url);
    ~URLImpl();

    bool isAbsolute() const {
        // see https://sourceforge.net/p/uriparser/bugs/3/
        return _uri.absolutePath || ((_uri.hostText.first != nullptr) && (_uri.pathHead != nullptr));
    }

    std::string scheme() const {
        return USCXML_URI_STRING(_uri, scheme);
    }

    std::string userInfo() const {
        return USCXML_URI_STRING(_uri, userInfo);
    }

    std::string host() const {
        return USCXML_URI_STRING(_uri, hostText);
    }

    std::string port() const {
        return USCXML_URI_STRING(_uri, portText);
    }

    std::string fragment() const {
        return USCXML_URI_STRING(_uri, fragment);
    }

    std::map<std::string, std::string> query() const;
    std::string path() const;
    std::list<std::string> pathComponents() const;

    void normalize();

    static URL resolve(URLImpl* relativeURL, URLImpl* absoluteURL);
    static URL resolveWithCWD(URLImpl* relativeURL);
    static URL refer(URLImpl* absoluteSource, URLImpl* absoluteBase);

    void addMonitor(URLMonitor* monitor)    {
        _monitors.insert(monitor);
    }
    void removeMonitor(URLMonitor* monitor) {
        _monitors.erase(monitor);
    }

    // downloading / uploading
    void addOutHeader(const std::string& key, const std::string& value) {
        _outHeader[key] = value;
    }
    void setOutContent(const std::string& content) {
        _outContent = content;
        _requestType = URLRequestType::POST;
    }
    void setRequestType(URLRequestType requestType) {
        _requestType = requestType;

    }

    const std::map<std::string, std::string> getInHeaderFields() {
        DOWNLOAD_IF_NECESSARY
        return _inHeaders;
    }

    const std::string getInHeaderField(const std::string& key) {
        DOWNLOAD_IF_NECESSARY
        if (_inHeaders.find(key) != _inHeaders.end()) {
            return _inHeaders[key];
        }
        return "";
    }

    const std::string getStatusCode() const {
//        DOWNLOAD_IF_NECESSARY
        return _statusCode;
    }

    const std::string getStatusMessage() const {
//        DOWNLOAD_IF_NECESSARY
        return _statusMsg;
    }

    const std::string getInContent(bool forceReload = false) {
        if (forceReload)
            _isDownloaded = false;
        DOWNLOAD_IF_NECESSARY
        return _rawInContent.str();
    }

    const void download(bool blocking = false);

    operator Data() const;
    operator std::string() const;

protected:
    URLImpl();
    UriUriA _uri;
    std::string _orig;

    CURL* getCurlHandle();
    static size_t writeHandler(void *ptr, size_t size, size_t nmemb, void *userdata);
    static size_t headerHandler(void *ptr, size_t size, size_t nmemb, void *userdata);

    void downloadStarted();
    void downloadCompleted();
    void downloadFailed(CURLcode errorCode);

    static void prepareException(ErrorEvent& exception, int errorCode, const std::string& origUri, UriParserStateA* parser);

    CURL* _handle;
    std::stringstream _rawInContent;
    std::stringstream _rawInHeader;
    std::map<std::string, std::string> _inHeaders;

    std::string _outContent;
    std::map<std::string, std::string> _outHeader;
    URLRequestType _requestType;

    std::string _statusCode;
    std::string _statusMsg;
    bool _isDownloaded;
    bool _hasFailed;
    std::string _error;

    std::condition_variable_any _condVar;
    std::recursive_mutex _mutex;

    std::set<URLMonitor*> _monitors;

    friend class URLFetcher;
};

class USCXML_API URL {
public:
    PIMPL_OPERATORS(URL);
    
    URL(const std::string url) : _impl(new URLImpl(url)) {}

    bool isAbsolute() {
        return _impl->isAbsolute();
    }

    std::string scheme() {
        return _impl->scheme();
    }

    std::string userInfo() {
        return _impl->userInfo();
    }

    std::string host() {
        return _impl->host();
    }

    std::string port() {
        return _impl->port();
    }

    std::string fragment() {
        return _impl->fragment();
    }

    std::map<std::string, std::string> query() {
        return _impl->query();
    }

    std::string path() {
        return _impl->path();
    }

    std::list<std::string> pathComponents() {
        return _impl->pathComponents();
    }

    void normalize() {
        return _impl->normalize();
    }

    static URL resolve(URL relativeURL, URL absoluteURL) {
        return URLImpl::resolve(relativeURL._impl.get(), absoluteURL._impl.get());
    }

    static URL resolveWithCWD(URL relativeURL) {
        return URLImpl::resolveWithCWD(relativeURL._impl.get());
    }

    static URL refer(URL absoluteSource, URL absoluteBase) {
        return URLImpl::refer(absoluteSource._impl.get(), absoluteBase._impl.get());
    }

    void addOutHeader(const std::string& key, const std::string& value) {
        return _impl->addOutHeader(key, value);
    }

    void setOutContent(const std::string& content) {
        return _impl->setOutContent(content);
    }
    void setRequestType(URLRequestType requestType) {
        return _impl->setRequestType(requestType);
    }

    const std::map<std::string, std::string> getInHeaderFields() {
        return _impl->getInHeaderFields();
    }

    const std::string getInHeaderField(const std::string& key) {
        return _impl->getInHeaderField(key);
    }

    const std::string getStatusCode() const {
        return _impl->getStatusCode();
    }

    const std::string getStatusMessage() const {
        return _impl->getStatusMessage();
    }

    const std::string getInContent(bool forceReload = false) {
        return _impl->getInContent(forceReload);
    }

    const void download(bool blocking = false) const {
        return _impl->download(blocking);
    }

    void addMonitor(URLMonitor* monitor)    {
        return _impl->addMonitor(monitor);
    }
    void removeMonitor(URLMonitor* monitor) {
        return _impl->removeMonitor(monitor);
    }

    operator Data() const {
        return _impl->operator Data();
    }

    operator std::string() {
        return (*_impl.get());
    }

protected:
    std::shared_ptr<URLImpl> _impl;
    friend class URLFetcher;
};

class USCXML_API URLFetcher {
public:
    static void fetchURL(URL& url);
    static void breakURL(URL& url);

    void start();
    void stop();

protected:
    URLFetcher();
    ~URLFetcher();

    static URLFetcher* _instance;
    static URLFetcher* getInstance();

    static void run(void* instance);
    void perform();

    std::thread* _thread;
    std::condition_variable_any _condVar;
    std::recursive_mutex _mutex;
    bool _isStarted;

    std::map<CURL*, URL> _handlesToURLs;
    CURLM* _multiHandle;
    char* _envProxy;
};

}

#endif /* end of include guard: URL_H_9DAEGSMV */