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]                          *
 *                                                                              *
 *    This software is governed by the CeCILL-B license under French law and    *
 *    abiding by the  rules of distribution of free  software.  You can use,    *
 *    modify  and/ or  redistribute  the  software under  the  terms of  the    *
 *    CeCILL-B license as circulated by CEA, CNRS and INRIA at the following    *
 *    URL \"http://www.cecill.info\".                                           *
 *                                                                              *
 *    As a counterpart to the access  to the source code and rights to copy,    *
 *    modify  and redistribute granted  by the  license, users  are provided    *
 *    only with a limited warranty  and the software's author, the holder of    *
 *    the economic  rights, and the  successive licensors have  only limited    *
 *    liability.                                                                *
 *                                                                              *
 *    In this respect, the user's attention is drawn to the risks associated    *
 *    with loading,  using, modifying  and/or developing or  reproducing the    *
 *    software by the user in light of its specific status of free software,    *
 *    that  may mean that  it is  complicated to  manipulate, and  that also    *
 *    therefore  means that it  is reserved  for developers  and experienced    *
 *    professionals having in-depth  computer knowledge. Users are therefore    *
 *    encouraged  to load  and test  the software's  suitability  as regards    *
 *    their  requirements  in  conditions  enabling the  security  of  their    *
 *    systems  and/or data to  be ensured  and, more  generally, to  use and    *
 *    operate it in the same conditions as regards security.                    *
 *                                                                              *
 *    The fact that  you are presently reading this means  that you have had    *
 *    knowledge of the CeCILL-B license and that you accept its terms.          *
 ********************************************************************************/
 
#include <dirent.h>
#include <cerrno>
#include <array>
 
#include "tksystem.h"
#include "tklog.h"
 
namespace tkn {
}
 
using namespace tkn;
 
tksystem *tksystem::g_tksystem = nullptr;
 
tksystem *tksystem::the_tksystem()
{
    if ( g_tksystem == nullptr ) {
        g_tksystem = new tksystem();
    }
 
    return g_tksystem;
}
 
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;
    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 ";
    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