EventCatalogue.cxx

Go to the documentation of this file.

#include "EventCatalogue.h"
 
#include "event_db_settings.h"
#include "nlohmann/json.hpp"
 
#include <fstream>
#include <iostream>
#include <map>
#include <sstream>
 
using json = nlohmann::ordered_json;
 
map<int, string> const Errors{{401, "Unauthorized Access (check user login and password)"},
                              {403, "Token invalid or expired"},
                              {404, "Requested Data not found"},
                              {409, "Incorrect Database Request (e.g. violating constraints)"},
                              {422, "Incorrect Input Request"},
                              {500, "Internal Server Error"},
                              {503, "Service Unavaialble"},
                              {504, "Server Timeout"}};
 
string const GetErrorString(int error_id)
{
    auto it = Errors.find(error_id);
    return it != Errors.end() ? it->second : "";
}
 
EventCondition::EventCondition(searchAttributes attribute, matchCriteria condition)
    : EventAttribute(attribute)
    , EventMatchCriteria(condition)
    , iValueType(0)
{}
 
EventCondition::EventCondition(searchAttributes attribute, matchCriteria condition, int value)
    : EventAttribute(attribute)
    , EventMatchCriteria(condition)
    , iValueType(1)
    , iValue(value)
{}
 
EventCondition::EventCondition(searchAttributes attribute, matchCriteria condition, unsigned int value)
    : EventAttribute(attribute)
    , EventMatchCriteria(condition)
    , iValueType(2)
    , uiValue(value)
{}
 
EventCondition::EventCondition(searchAttributes attribute, matchCriteria condition, double value)
    : EventAttribute(attribute)
    , EventMatchCriteria(condition)
    , iValueType(3)
    , dValue(value)
{}
 
EventCondition::EventCondition(searchAttributes attribute, matchCriteria condition, string value)
    : EventAttribute(attribute)
    , EventMatchCriteria(condition)
    , iValueType(4)
    , strValue(value)
{}
 
// private default constructor
EventCondition::EventCondition()
    : EventAttribute(kError)
    , EventMatchCriteria(kEqual)
    , iValueType(0)
{}
 
// Event Catalogue Constructor
EventCatalogue::EventCatalogue()
{
    curl_global_init(CURL_GLOBAL_DEFAULT);
    curlInstance = curl_easy_init();
    if (!curlInstance) {
        // cout<<"ERROR: CURL initialisation failed"<<endl;
        throw runtime_error("CURL initialisation failed");
        return;
    }
 
    ServiceUrl =
        EVENT_API_HOST + string("/") + EVENT_API_NAME + string("/v") + to_string(EventInfo::Version) + string("/");
    ServiceAccount = EVENT_API_USERNAME + string(":") + EVENT_API_PASSWORD;
    if (VerboseLevel > 2)
        cout << "DEBUG: ServiceUrl = " << ServiceUrl << ", ServiceAccount = " << ServiceAccount << endl;
}
 
// Event Catalogue Destructor
EventCatalogue::~EventCatalogue()
{
    curl_easy_cleanup(curlInstance);
    curl_global_cleanup();
}
 
vector<unique_ptr<EventInfo>> EventCatalogue::GetEventList(vector<unique_ptr<EventCondition>> event_conditions)
{
    vector<unique_ptr<EventInfo>> event_array;
    cout << "ERROR: EventCatalogue::GetEventList is not implemented yet" << endl;
 
    return event_array;
}
 
unique_ptr<EventInfo> EventCatalogue::GetEventInfo(string storage_name, string file_path, int event_number)
{
    unique_ptr<EventInfo> event_info;
    cout << "ERROR: EventCatalogue::GetEventInfo is not implemented yet" << endl;
 
    return event_info;
}
 
int EventCatalogue::AddEventInfo(string storage_name, string file_path, int event_number, EventInfo event_metadata)
{
    cout << "ERROR: EventCatalogue::AddEventInfo is not implemented yet" << endl;
 
    return 0;
}
 
size_t response_callback(void* contents, size_t size, size_t nmemb, string* data)
{
    size_t realsize = size * nmemb;
    try {
        data->append((char*)contents, realsize);
    } catch (std::bad_alloc& e) {
        // handle memory problem
        return 0;
    }
 
    return realsize;
}
 
static size_t header_callback(char* buffer, size_t size, size_t nitems, void* userdata)
{
    string* headers = (string*)userdata;
    try {
        headers->append(buffer, nitems * size);
    } catch (std::bad_alloc& e) {
        // handle memory problem
        return 0;
    }
 
    return nitems * size;
}
 
int EventCatalogue::AddEventInfo(string json_file_path)
{
    ifstream json_file(json_file_path);
    ostringstream sstr;
    sstr << json_file.rdbuf();
    string json_string = sstr.str();
    if (VerboseLevel > 2)
        cout << "DEBUG: json_string = " << json_string << endl;
 
    string success_message =
        "Event metadata have been written from JSON file '" + json_file_path + "' to the Event Catalogue";
    int return_code = PostRequest(ServiceUrl + "event", json_string, success_message);
 
    return return_code;
}
 
int EventCatalogue::UpdateEventInfo(string storage_name, string file_path, int event_number, EventInfo event_metadata)
{
    cout << "ERROR: EventCatalogue::UpdateEventInfo is not implemented yet" << endl;
 
    return 0;
}
 
int EventCatalogue::DeleteEventInfo(string storage_name, string file_path, int event_number)
{
    cout << "ERROR: EventCatalogue::DeleteEventInfo is not implemented yet" << endl;
 
    return 0;
}
 
int EventCatalogue::CheckEventInfo(string storage_name, string file_path, int event_number)
{
    cout << "ERROR: EventCatalogue::CheckEventInfo is not implemented yet" << endl;
 
    return 0;
}
 
int EventCatalogue::PrintEventInfo(string storage_name, string file_path, int event_number)
{
    cout << "ERROR: EventCatalogue::PrintEventInfo is not implemented yet" << endl;
 
    return 0;
}
 
int EventCatalogue::AddStorageInfo(string storage_name)
{
    // write storage metadata to JSON element
    // json storage_element;
    // storage_element["storage_id"] = -1;
    // storage_element["storage_name"] = storage_name;
    string json_string = "{\"storage_id\": -1, \"storage_name\": \"" + storage_name + "\"}";
    if (VerboseLevel > 2)
        cout << "DEBUG: json_string = " << json_string << endl;
 
    string success_message = "Storage information has been added for '" + storage_name + "' to the Event Catalogue";
    int return_code = PostRequest(ServiceUrl + "storage", json_string, success_message);
 
    return return_code;
}
 
int EventCatalogue::AddSoftwareInfo(string software_version)
{
    // write software version to JSON element
    // json storage_element;
    // storage_element["software_id"] = -1;
    // storage_element["software_version"] = software_version;
    string json_string = "{\"software_id\": -1, \"software_version\": \"" + software_version + "\"}";
    if (VerboseLevel > 2)
        cout << "ERROR: json_string = " << json_string << endl;
 
    string success_message =
        "Software version has been added for '" + software_version + "' version to the Event Catalogue";
    int return_code = PostRequest(ServiceUrl + "software", json_string, success_message);
 
    return return_code;
}
 
vector<unique_ptr<EventInfo>> EventCatalogue::EventCatalogueRequest(string rest_api_request)
{
    vector<unique_ptr<EventInfo>> event_array;
    cout << "ERROR: EventCatalogue::EventCatalogueRequest is not implemented yet" << endl;
 
    return event_array;
}
 
int EventCatalogue::EventCatalogueChecks(int& file_not_found, vector<unique_ptr<EventInfo>>& event_list)
{
    cout << "ERROR: EventCatalogue::EventCatalogueChecks is not implemented yet" << endl;
 
    return 0;
}
 
int EventCatalogue::EventCatalogueStats(int& record_count)
{
    cout << "ERROR: EventCatalogue::EventCatalogueStats is not implemented yet" << endl;
 
    return 0;
}
 
int EventCatalogue::PostRequest(string RequestUrl, string json_string, string success_message)
{
    struct curl_slist* http_header = nullptr;
    http_header = curl_slist_append(http_header, "Accept: */*");
    http_header = curl_slist_append(http_header, "Content-Type: application/json");
    http_header = curl_slist_append(http_header, "charset: utf-8");
    curl_easy_setopt(curlInstance, CURLOPT_HTTPHEADER, http_header);
    curl_easy_setopt(curlInstance, CURLOPT_URL, RequestUrl.c_str());
    curl_easy_setopt(curlInstance, CURLOPT_USERPWD, ServiceAccount.c_str());
 
    // curl_easy_setopt(curlInstance, CURLOPT_TCP_KEEPALIVE, 1);
    // curl_easy_setopt(curlInstance, CURLOPT_TCP_KEEPIDLE, 30);
    // curl_easy_setopt(curlInstance, CURLOPT_TCP_KEEPINTVL, 30);
    // curl_easy_setopt(curlInstance, CURLOPT_TCP_KEEPCNT, 720);
 
    curl_easy_setopt(curlInstance, CURLOPT_POST, 1);
    curl_easy_setopt(curlInstance, CURLOPT_POSTFIELDS, json_string.c_str());
 
    string response_string, header_string;
    curl_easy_setopt(curlInstance, CURLOPT_WRITEFUNCTION, response_callback);
    curl_easy_setopt(curlInstance, CURLOPT_WRITEDATA, &response_string);
    curl_easy_setopt(curlInstance, CURLOPT_HEADERFUNCTION, header_callback);
    curl_easy_setopt(curlInstance, CURLOPT_HEADERDATA, &header_string);
 
    // write new event metadata to the Event Catalogue
    int res = curl_easy_perform(curlInstance);
    if (res) {
        cout << "ERROR: sending command to '" << RequestUrl << "' failed with code = " << res << endl;
        curl_slist_free_all(http_header);
        return -1;
    }
    curl_slist_free_all(http_header);
 
    long response_code;
    curl_easy_getinfo(curlInstance, CURLINFO_RESPONSE_CODE, &response_code);
    if (VerboseLevel > 2) {
        double elapsed;
        curl_easy_getinfo(curlInstance, CURLINFO_TOTAL_TIME, &elapsed);
        char* url;
        curl_easy_getinfo(curlInstance, CURLINFO_EFFECTIVE_URL, &url);
        cout << "DEBUG: CURLINFO_TOTAL_TIME = " << elapsed << ", CURLINFO_EFFECTIVE_URL = " << string(url) << endl;
    }
    // check the result of the request
    if ((response_code >= 200) && (response_code < 205)) {
        if (VerboseLevel > 0)
            cout << success_message << endl;
        if (VerboseLevel > 1)
            cout << "Request has been completed with the following response: " << response_string << endl;
    } else {
        string error_message = GetErrorString(response_code);
        cout << "ERROR: Sending request to '" << RequestUrl << "' has been failed";
        if (error_message != "")
            cout << ": " << error_message << endl;
        else
            cout << " with code = " << response_code << endl;
        if (VerboseLevel > 1)
            cout << "Error Message:" << endl
                 << response_string << endl
                 << "Error Output Header:" << endl
                 << header_string << endl;
        return -1 * response_code;
    }
 
    return 0;
}