tksystem.cpp

/********************************************************************************
 *   Copyright (c) : Université de Lyon 1, CNRS/IN2P3, UMR5822,                 *
 *                   IP2I, F-69622 Villeurbanne Cedex, France                   *
 *                   Normandie Université, ENSICAEN, UNICAEN, CNRS/IN2P3,       *
 *                   LPC Caen, F-14000 Caen, France                             *
 *   Contibutor(s) :                                                            *
 *      Jérémie Dudouet jeremie.dudouet@cnrs.fr [2020]                          *
 *      Diego Gruyer    diego.gruyer@cnrs.fr    [2020]                          *
 *                                                                              *
 *   Licensed under the MIT License <http://opensource.org/licenses/MIT>.       *   
 *   SPDX-License-Identifier: MIT                                               *
 ********************************************************************************/
 
#include <dirent.h>
#include <cerrno>
#include <array>
#include <memory>
 
#include "tksystem.h"
#include "tklog.h"
 
namespace tkn {
}
 
using namespace tkn;
 
tksystem *tksystem::the_tksystem()
{
    // Function-local static initialisation is guaranteed to be thread-safe
    // since C++11.  Keep process-lifetime ownership, as for the historical
    // singleton, to avoid static destruction-order issues.
    static tksystem *instance = new tksystem();
    return instance;
}
 
int tksystem::getdir(tkstring _dir, std::vector<tkstring> &_files)
{
    glog.set_class("tksystem");
    glog.set_method(tkstring::form("getdir(%s, std::vector<tkstring> &_files)",_dir.data()));
 
    DIR *dp;
    struct dirent *dirp;
    if((dp  = opendir(_dir.c_str())) == nullptr) {
        glog << error_v << " error opening " << _dir << do_endl;
        glog.clear();
        return errno;
    }
 
    while ((dirp = readdir(dp)) != nullptr) {
        _files.emplace_back(tkstring(dirp->d_name));
    }
    closedir(dp);
 
    glog.clear();
    return 0;
}
 
bool tksystem::exists(tkstring _file_name)
{
    glog.set_class("tksystem");
    glog.set_method(tkstring::form("exists(%s)",_file_name.data()));
 
    tkstring path = _file_name.remove_last_occurence("/");
    tkstring name = _file_name.get_last_occurence("/");
 
    if(path==name) path = "./";
 
    DIR *dp;
    const struct dirent *dirp;
    if((dp  = opendir(path.c_str())) == nullptr) {
        // glog << error_v << " error opening " << path << do_endl;
        // glog.clear();
        return false;
    }
 
    bool found = false;
    while ((dirp = readdir(dp)) != nullptr) {
        if(!strcmp(dirp->d_name,name.data())) found = true;
    }
    closedir(dp);
 
    glog.clear();
    return found;
}
 
 
void tksystem::list_files(const tkstring &_dir, const tkstring &_pattern) {
    std::vector<tkstring> files;
    getdir(_dir,files);
    for(const auto &file: files) {
        if(file.match(_pattern)) std::cout << "             -- " << file << std::endl;
    }
}
 
std::vector<tkstring> tksystem::get_list_of_files(const tkstring &_dir, const tkstring &_pattern) {
    std::vector<tkstring> files;
    getdir(_dir,files);
    for(size_t ifile=0 ; ifile<files.size() ; ifile++) {
        if(!files.at(ifile).match(_pattern)) {
            files.erase(files.begin()+ifile);
            ifile--;
        }
    }
    return files;
}
 
int tksystem::remove_dir(const tkstring &_dirname, bool _force)
{
    if(_force) return system(tkstring::form("rm -rf %s",_dirname.data()));
    return system(tkstring::form("rm -r %s",_dirname.data()));
}
 
int tksystem::remove_file(const tkstring &_filename, bool _force)
{
    if(_force) return system(tkstring::form("rm -f %s",_filename.data()));
    return system(tkstring::form("rm %s",_filename.data()));
}
 
int tksystem::make_dir(const tkstring &_dirname, bool _recursive)
{
    if(_recursive) return system(tkstring::form("mkdir -p %s",_dirname.data()));
    return system(tkstring::form("mkdir %s",_dirname.data()));
}
 
int tksystem::move(const tkstring &_from,const tkstring &_to)
{
    return system(tkstring::form("mv %s %s",_from.data(),_to.data()));
}
 
int tksystem::unzip_file(const tkstring &_filename, tkstring _outputdir)
{
    if(_outputdir.is_empty()) return system(tkstring::form("unzip %s",_filename.data()));
    return system(tkstring::form("unzip %s -d %s/",_filename.data(),_outputdir.data()));
}
 
int tksystem::ls_dir(const tkstring &_dirname, tkstring _option)
{
    return system(tkstring::form("ls %s %s",_option.data(),_dirname.data()));
}
 
int tksystem::download_file(const tkstring &_filename, const tkstring &_outputdir, bool _replace_existing, bool _use_filename)
{
    tkstring command = "wget -q --timeout=30 --tries=2 ";
    if(!_replace_existing) command += "-N ";
    command += _filename;
    if(!_outputdir.is_empty()) {
        if(_use_filename) command += " -O ";
        else command += " -P ";
        command += _outputdir;
    }
 
    return system(command.data());
}
 
tkstring tksystem::get_system_command_output(tkstring command)
{
    std::array<char, 128> buffer{};
    tkstring result;
    std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(command.data(), "r"), pclose);
    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
        result += buffer.data();
    }
    return result;
}
 
#ifdef HAS_ROOT
ClassImp(tksystem);
#endif