TRestDataBase.cxx

#include "TRestDataBase.h"
 
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
#include <chrono>
#include <thread>
 
#include "TClass.h"
#include "TRestStringHelper.h"
#include "TRestStringOutput.h"
#include "TRestTools.h"
#include "TSystem.h"
#include "TUrl.h"
 
using namespace std;
 
 
DBEntry::DBEntry(vector<string> items) {
    this->runNr = atoi(items[0].c_str());
    this->type = items[1];
    this->tag = items[2];
    this->description = items[3];
    this->version = items[4];
}
 
void TRestDataBase::Initialize() {
    fDataEntries.clear();
    string metaFilename = REST_PATH + "/data/dataURL";
    if (!TRestTools::fileExists(metaFilename)) {
        return;
    } else {
        vector<int> result;
        ifstream infile(metaFilename);
        string s;
        while (TRestTools::GetLine(infile, s)) {
            DBEntry info;
            vector<string> items = Split(s, "\t", true);
            if (items.size() <= 2) continue;
            for (auto item : items) {
                vector<string> pair = Split(item, "=", true);
                if (pair.size() == 2) {
                    if (pair[0] == "run")
                        info.runNr = atoi(pair[1].c_str());
                    else if (pair[0] == "type")
                        info.type = pair[1];
                    else if (pair[0] == "tag")
                        info.tag = pair[1];
                    else if (pair[0] == "description")
                        info.description = pair[1];
                    else if (pair[0] == "version")
                        info.version = pair[1];
                    else if (pair[0] == "value")
                        info.value = pair[1];
                }
            }
 
            fDataEntries.push_back(info);
        }
    }
}
 
DBFile DBFile::ParseFile(string _filename) {
    DBFile file;
    file.filename = _filename;
    auto _fullname = TRestTools::ToAbsoluteName(_filename);
 
    struct stat buf;
    int result = stat(_fullname.c_str(), &buf);
 
    if (result != 0) {
        RESTError << "DBFile::ParseFile: Failed to load file \"" << _fullname << "\"!" << RESTendl;
    } else {
        file.fileSize = buf.st_size;
        file.evtRate = 0;
        file.quality = true;
        file.start = buf.st_ctime;
        file.stop = buf.st_mtime;
        string sha1result = TRestTools::Execute("sha1sum " + _fullname);
        string sha1 = Split(sha1result, " ")[0];
        if (sha1.size() == 40) {
            for (int i = 0; i < 40; i++) {
                file.sha1sum[i] = sha1[i];
            }
            file.sha1sum[40] = 0;
        }
    }
    return file;
}
 
void DBFile::Print() {
    cout << "----DBFile struct----" << endl;
    cout << "size: " << fileSize << endl;
    cout << "event rate: " << evtRate << endl;
    cout << "sha1sum: " << sha1sum << endl;
    cout << "quality: " << quality << endl;
    cout << "start time: " << ToDateTimeString(start) << endl;
    cout << "stop time: " << ToDateTimeString(stop) << endl;
}
 
TRestDataBase::TRestDataBase() {
    auto url = getenv("REST_DBURL");
    if (url != nullptr) {
        fConnectionString = url;
    }
    Initialize();
}
 
int TRestDataBase::get_lastrun() {
    int runNr = 1;
    string runFilename = REST_USER_PATH + "/runNumber";
    bool fileExist = TRestTools::fileExists(runFilename);
    int fd = open(runFilename.c_str(), O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        RESTError << "Error opening file " << runFilename << strerror(errno) << RESTendl;
        return -1;
    }
    flock(fd, LOCK_EX);
    if (!fileExist) {
        string newRun = to_string(runNr) + "\n";
        if (write(fd, newRun.c_str(), newRun.size()) == -1)
            RESTError << "Error writing file " << runFilename << strerror(errno) << RESTendl;
        fsync(fd);
    } else {
        lseek(fd, 0, SEEK_SET);
        char buffer[64] = {0};
        ssize_t bytesReaded = read(fd, buffer, sizeof(buffer) - 1);
        if (bytesReaded > 0) runNr = std::atoi(buffer);
    }
    flock(fd, LOCK_UN);
    close(fd);
    // the number recorded in "runNumber" file is for the next run, we subtract 1 to get the latest run.
    return runNr - 1;
}
 
int TRestDataBase::set_run(DBEntry info, bool overwrite) {
    int newRunNr = -1;
    if (info.runNr == 0) {
        newRunNr = get_lastrun() + 1;
    } else if (info.runNr > 0) {
        newRunNr = info.runNr;
    } else {
        return -1;
    }
 
    string runFilename = REST_USER_PATH + "/runNumber";
    if (TRestTools::isPathWritable(REST_USER_PATH)) {
        int fd = open(runFilename.c_str(), O_RDWR | O_CREAT, 0666);
        if (fd == -1) {
            RESTError << "Error opening file " << runFilename << strerror(errno) << RESTendl;
            return -1;
        }
        flock(fd, LOCK_EX);
        string newRun = to_string(newRunNr + 1) + "\n";
        if (write(fd, newRun.c_str(), newRun.size()) == -1)
            RESTError << "Error writing file " << runFilename << strerror(errno) << RESTendl;
        fsync(fd);
        flock(fd, LOCK_UN);
        close(fd);
 
    } else {
        RESTWarning << "runNumber file not writable. auto run number "
                       "increment is disabled"
                    << RESTendl;
    }
    return newRunNr;
}
 
DBEntry TRestDataBase::query_data(DBEntry _info) {
    vector<DBEntry> match;
    if (_info.runNr <= 0 && _info.type == "" && _info.tag == "" && _info.description == "" &&
        _info.version == "")
        return DBEntry();
 
    for (unsigned int i = 0; i < fDataEntries.size(); i++) {
        DBEntry info = fDataEntries[i];
 
        bool runmatch = (_info.runNr == 0 || info.runNr == 0 || info.runNr == _info.type);
        bool typematch = (_info.type == "" || info.type == _info.type);
        bool tagmatch = (_info.tag == "" || info.tag == _info.tag);
        bool descriptionmatch = (_info.description == "" || info.description == _info.description);
        bool versionmatch = (_info.version == "" || info.version == _info.version);
        bool valuematch = (_info.value == "" || info.value == _info.value);
 
        if (runmatch && typematch && tagmatch && descriptionmatch && versionmatch && valuematch) {
            match.push_back(info);
        }
    }
 
    if (match.size() == 1) {
        return match[0];
    } else if (match.size() > 1) {
        RESTWarning << "multiple metadata found! returning the first!" << RESTendl;
        return match[0];
    } else {
        return DBEntry();
    }
    return DBEntry();
}
 
// int TRestDataBase::add_metadata(DBEntry info, string url, bool overwrite) {
//    if (TRestTools::isPathWritable(REST_USER_PATH)) {
//        cout << "error! path not writable" << endl;
//        return -1;
//    }
//
//    string metaFilename = REST_USER_PATH + "/dataURL";
//
//    if (info.runNr == 0) {
//        info.runNr = get_lastmetadata();
//    }
//    fDataEntries.push_back({info, url});
//
//    std::ofstream file(metaFilename, std::ios::app);
//    file << "\"" << info.runNr << "\" ";
//    file << "\"" << info.type << "\" ";
//    file << "\"" << info.tag << "\" ";
//    file << "\"" << info.description << "\" ";
//    file << "\"" << info.version << "\" ";
//    file << "\"" << url << "\" ";
//    file << endl;
//    file.close();
//
//    return info.runNr;
//}
//