source: geovis/trunk/IData.cpp @ 6666

/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 * Copyright (C) 2015 HUBzero Foundation, LLC
 *
 * Author: Leif Delgass <ldelgass@purdue.edu>
 */
#include <string>
#include <iostream>
#include <sstream>
#include <cstring>
#include <cstdlib>
#include <cstddef>

#include <curl/curl.h>
#include <osgEarth/JsonUtils>

#include "IData.h"
#include "Trace.h"

static const char *commandNames[] = {
    "list",
    "get",
    "contents",
    "setglobalmeta",
    "delete",
    "upload",
    "finishupload",
    "checksum"
};
#if 0
static const char *sharingValues[] = {
    "no",
    "read-only",
    "read-write"
};
#endif

static const char *defaultHubURL = "https://mygeohub.org";
static const std::string servicePath = "/api/idata/collection/";
static std::string serviceURL;
static std::string iDataUsername;

using namespace IData;
using namespace osgEarth;

void IData::iDataInit(const char *username, const char *hubURL)
{
    TRACE("user: %s hub: %s", username, hubURL);
    static bool first = true;
    std::ostringstream oss;
    std::string hubHost;
    if (hubURL != NULL) {
        hubHost = hubURL;
    } else {
        hubHost = defaultHubURL;
    }
    oss << hubHost << servicePath;
    serviceURL = oss.str();
    iDataUsername = username;
    if (first) {
        curl_global_init(CURL_GLOBAL_DEFAULT);
        first = false;
    }
}

void IData::iDataCleanup()
{
    curl_global_cleanup();
}

static std::string urlEncode(const std::string& str)
{
    std::string retStr;
    CURL *curl = curl_easy_init();
    if (curl) {
        char *encoded = curl_easy_escape(curl, str.c_str(), str.length());
        retStr = encoded;
        curl_free(encoded);
        curl_easy_cleanup(curl);
    }
    return retStr;
}

static std::string formatQuery(Command cmd, std::vector<std::string> &params)
{
    std::ostringstream oss;
    oss << serviceURL << commandNames[cmd] << "?username=" << iDataUsername;
    for (std::vector<std::string>::iterator itr = params.begin();
         itr != params.end(); ++itr) {
        oss << "&" << *itr << "=";
        itr++;
        oss << urlEncode(*itr);
    }

    return oss.str();
}

static size_t writeData(void *buffer, size_t size, size_t nmemb, void *userp)
{
    size_t numBytes = size * nmemb;
    Buffer *out = static_cast<Buffer *>(userp); 
    out->data = realloc(out->data, out->size + numBytes);
    memcpy((char *)out->data + out->size, buffer, numBytes);
    out->size += numBytes;
    return numBytes;
}

void IData::getCollectionList(std::vector<Collection>& list)
{
    std::vector<std::string> params;
    std::string query = formatQuery(COMMAND_LIST, params);
    CURL *curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, query.c_str()); 
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeData);
        Buffer buff;
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buff);
        CURLcode ret = curl_easy_perform(curl);
        if (ret == CURLE_OK) {
            //std::cout.write((char *)buff.data, buff.size);
            Json::Reader reader;
            Json::Value result;
            const char *begin = (const char *)buff.data;
            const char *end = begin + buff.size;
            reader.parse(begin, end, result, false);
            for (size_t i = 0; i < result["collections"].size(); i++) {
                Collection collection;
                Json::Value& val = result["collections"][i];
                collection.name = val["name"].asString();
                collection.shared = val["shared"].asString();
                collection.id = atoi(val["id"].asCString());
                list.push_back(collection);
            }
        }
        curl_easy_cleanup(curl);
    }
}

void IData::getContents(int collectionID, const char *path,
                        std::vector<DirectoryItem>& contents)
{
    std::vector<std::string> params;
    {
        std::ostringstream oss;
        oss << collectionID;
        params.push_back("id");
        params.push_back(oss.str());
    }
    if (path) {
        params.push_back("path");
        params.push_back(path);
    }
    std::string query = formatQuery(COMMAND_CONTENTS, params);
    CURL *curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, query.c_str()); 
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeData);
        Buffer buff;
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buff);
        CURLcode ret = curl_easy_perform(curl);
        if (ret == CURLE_OK) {
            std::cout.write((char *)buff.data, buff.size);
            Json::Reader reader;
            Json::Value result;
            const char *begin = (const char *)buff.data;
            const char *end = begin + buff.size;
            reader.parse(begin, end, result, false);
            for (size_t i = 0; i < result["contents"].size(); i++) {
                DirectoryItem dir;
                Json::Value& val = result["contents"][i];
                dir.name = val["name"].asString();
                dir.isDir = (val["dir-or-file"].asInt() == TYPE_DIRECTORY);
                if (!dir.isDir) {
                    dir.type = val["type"].asString();
                    dir.size = atol(val["size"].asCString());
                    dir.ctime = val["ctime"].asString();
                    dir.doi = val["doi"].asString();
                }
                contents.push_back(dir);
            }
        }
        curl_easy_cleanup(curl);
    }
}

void IData::getFile(int collectionID, const char *doi, Buffer *buff)
{
    std::vector<std::string> params;
    {
        std::ostringstream oss;
        oss << collectionID;
        params.push_back("id");
        params.push_back(oss.str());
    }
    if (doi) {
        params.push_back("doi");
        params.push_back(doi);
    }
    std::string query = formatQuery(COMMAND_GET, params);
    CURL *curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, query.c_str()); 
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeData);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, buff);
        CURLcode ret = curl_easy_perform(curl);
        if (ret == CURLE_OK) {
            //std::cout.write((char *)buff->data, buff->size);
        }
        curl_easy_cleanup(curl);
    }
}

void setFileMetadata(int collectionID, const char *doi, const char *name, const char *value)
{
    std::vector<std::string> params;
    {
        std::ostringstream oss;
        oss << collectionID;
        params.push_back("id");
        params.push_back(oss.str());
    }
    if (doi) {
        params.push_back("doi");
        params.push_back(doi);
    }
    if (name) {
        params.push_back(name);
        params.push_back(value);
    }
    std::string query = formatQuery(COMMAND_SETGLOBALMETA, params);
    CURL *curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, query.c_str()); 
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeData);
        Buffer buff;
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buff);
        CURLcode ret = curl_easy_perform(curl);
        if (ret == CURLE_OK) {
            //std::cout.write((char *)buff->data, buff->size);
        }
        curl_easy_cleanup(curl);
    }
}

void deleteFile(int collectionID, const char *path, const char *filename)
{
    std::vector<std::string> params;
    {
        std::ostringstream oss;
        oss << collectionID;
        params.push_back("id");
        params.push_back(oss.str());
    }
    if (path) {
        params.push_back("path");
        params.push_back(path);
    }
    if (filename) {
        params.push_back("filename");
        params.push_back(filename);
    }
    std::string query = formatQuery(COMMAND_DELETE, params);
    CURL *curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, query.c_str()); 
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeData);
        Buffer buff;
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buff);
        CURLcode ret = curl_easy_perform(curl);
        if (ret == CURLE_OK) {
            //std::cout.write((char *)buff->data, buff->size);
        }
        curl_easy_cleanup(curl);
    }
}