|| || || || || || || ||

---

RemoteRetriever.h

Go to the documentation of this file.

#ifndef REMOTERETRIEVER_H
#define REMOTERETRIEVER_H

// Todo: MD5 Hash of filename for cache?

#ifdef USE_CURL
#include "curl/curl.h"
#endif

#ifdef USE_BOOST_THREADPOOL
#define USE_BOOST_THREAD
#include "boost/thread/mutex.hpp"
#endif

#include <sys/stat.h>
#include <iostream>
#include <fstream>

#include "Core/Array/ReadImage.h"

namespace Impala { namespace Application { namespace MediaTable {

typedef Core::Array::Array2dVec3UInt8   Array2dVec3UInt8;

class RemoteRetriever {
public:
    static RemoteRetriever* GetInstance() {
        if (!sInstance)
        {
            ILOG_INFO("Instantiating RemoteRetriever.");
            sInstance = new RemoteRetriever();
        }
        return sInstance;
    }

        Array2dVec3UInt8* RetrieveImageData(std::string url, bool fromCache=true, bool toCache=true) {
                if(!mUseCache) fromCache = toCache = false;

                Array2dVec3UInt8* imageData = 0;

#ifndef WIN32
                if((toCache || fromCache) && !FileExists(mCachePrefix))
                {
                        ILOG_WARN("Cache folder does not exists, continuing without cache");
                        toCache = fromCache = false;
                }
#endif

                std::string filename = mCachePrefix + url.substr(url.find_last_of('/')+1);
        RemoteFileRetriever retriever = RemoteFileRetriever(url, fromCache, toCache, filename);
                retriever();

                if(retriever.target.size() < 512)
                {
                        ILOG_ERROR("Image is smaller than 512 bytes, skipping.");
                        return 0;
                }

                ILOG_DEBUG("Trying to ReadJpg from " << &retriever.target << " with size " << retriever.target.size());
#ifdef USE_BOOST_THREAD
                {
                        boost::mutex::scoped_lock lock(mutex_readjpg);
                        Core::Array::ReadJpgFromMemory(imageData, (char*) retriever.target.c_str(), retriever.target.size());
                }
#else
                Core::Array::ReadJpgFromMemory(imageData, (char*) retriever.target.c_str(), retriever.target.size());
#endif

                if(imageData != 0)
                        ILOG_DEBUG("Returning image data of " << imageData->CW() << "x" << imageData->CH() <<" pixels at " << imageData);
        return imageData;
    }

        std::string RetrieveFile(std::string url, bool fromCache=true, bool toCache=true, std::string filename = "") {
                if(filename == "" || !mUseCache) fromCache = toCache = false;
        RemoteFileRetriever retriever = RemoteFileRetriever(url, fromCache, toCache, filename);
        retriever();
        return filename;
    }

        class RemoteFileRetriever {
        public:
                RemoteFileRetriever(std::string url, bool fromCache, bool toCache, std::string filename = "") :
                        url(url), fromCache(fromCache), toCache(toCache), filename(filename) {
                        target = std::string();
                }
                RemoteFileRetriever(std::string url, std::string &target, bool fromCache, bool toCache, std::string filename = "") :
                        url(url), fromCache(fromCache), toCache(toCache), filename(filename), target(target) {
                }

                int operator()() {
                        ILOG_DEBUG("Getting file from: " << url << " to store in " << &target);

                        Core::Array::Array2dVec3UInt8* im = 0;
                        if(fromCache && FileExists(filename)) {
                                ILOG_DEBUG("Retrieving file from " << filename);
                                std::ifstream cachedFile(filename.c_str(), std::ios::binary | std::ios::in);
                                while (cachedFile.good())     // loop while extraction from file is possible
                                    target += (char) cachedFile.get();       // get character from file
                                cachedFile.close();
                                return 1;
                        }

#ifdef USE_CURL
                        CURL *h = curl_easy_init();
                        CURLcode result;

                        target = std::string();

                        curl_easy_setopt(h, CURLOPT_URL, url.c_str());
                        curl_easy_setopt(h, CURLOPT_WRITEFUNCTION, CurlCallback);
                        curl_easy_setopt(h, CURLOPT_WRITEDATA, &target);
#ifdef WIN32
                        curl_easy_setopt(h, CURLOPT_TIMEOUT, 5);
#endif

                        ILOG_DEBUG("Retrieving remote: " << url);
                        result = curl_easy_perform(h);

                        if (result == CURLE_OK) {
                                ILOG_DEBUG("retrieved " << target.size() << ", trying decode...");

                                if(toCache) {
#ifdef USE_BOOST_THREAD
                                        boost::mutex::scoped_lock lock(RemoteRetriever::GetInstance()->mutex_cache);
#endif
                                        std::ofstream cachedFile(filename.c_str(), std::ios::binary | std::ios::out);
                                        cachedFile << target;
                                        cachedFile.close();
                                } else {
                                }
                                curl_easy_cleanup(h);
                                return 1;
                        }
                        curl_easy_cleanup(h);
                        ILOG_ERROR("Could not retrieve URI: " << url);
                        return 0;
#else
                        ILOG_ERROR("Network retrieval of files not compiled in this version.");
                        return 0;
#endif
                }

                bool FileExists(std::string strFilename) {
                        struct stat stFileInfo;
                        int intStat = stat(strFilename.c_str(),&stFileInfo);
                        if(intStat == 0) return true;
                        return false;
                }

#ifdef USE_CURL
                static size_t CurlCallback(char *data, size_t size, size_t nmemb, std::string *buffer) {
                                if (buffer != 0) {
                                        buffer->append(data, size * nmemb);
                                } else return 0;
                                return size * nmemb;
                }
#endif

                std::string url, filename, target;
                bool toCache, fromCache;
        };

private:
        RemoteRetriever(std::string cachePrefix = "Cache/") // constructor: private
        {

#ifdef USE_CURL
                if (!sCurlInit) {
                        ILOG_DEBUG("Initializing CURL...");
                        // Only does something on Windows
                        curl_global_init(CURL_GLOBAL_WIN32);
                        sCurlInit = true;
                }
#endif

                mCachePrefix = cachePrefix;
                //if(FileExists(mCachePrefix))
                mUseCache = true;
                //else
                //      ILOG_WARN("Cache folder does not exists, continuing without cache");
        }

        RemoteRetriever(RemoteRetriever const&){};             // copy constructor: private
        RemoteRetriever& operator=(RemoteRetriever const&){};  // assignment operator: private

        bool                                                     mUseCache;
        std::string                                              mCachePrefix;

        static RemoteRetriever*          sInstance;

#ifdef USE_CURL
        static bool                                              sCurlInit;
#endif

#ifdef USE_BOOST_THREAD
        boost::mutex                    mutex_readjpg;
public:
        boost::mutex                    mutex_cache;
private:
#endif

    ILOG_VAR_DEC;
};

RemoteRetriever* RemoteRetriever::sInstance = 0;

#ifdef USE_CURL
bool RemoteRetriever::sCurlInit = false;
#endif

ILOG_VAR_INIT(RemoteRetriever, Application.MediaTable);

} } } // Namespace Impala::Application::MediaTable

#endif // REMOTERETRIEVER_H

---