File.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS system source for the DUNE DAQ project.
// Fork baseline commit: system-00-00-20 (2020-09-25).
// Renamed since fork: yes (from src/File.cxx to src/File.cpp).
 
/*
 *  File.cxx
 *  ers
 *
 *  Created by Matthias Wiesmann on 04.01.05.
 *  Copyright 2005 CERN. All rights reserved.
 *
 */
 
#include <unistd.h>
#include <stdio.h>
#include <libgen.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <assert.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <iostream>
#include <sstream>
#include <fstream>
#include <pwd.h>
 
#include "ers/ers.hpp"
 
#include "okssystem/File.hpp"
#include "okssystem/exceptions.hpp"
#include "okssystem/Executable.hpp"
#include "okssystem/User.hpp"
 
#define SPACE_CHAR ' ' 
 
const char * const OksSystem::File::HUMAN_SIZE_STR[] = { "B", "KB", "MB", "GB" };
const char * const OksSystem::File::HUMAN_OPEN_STR[] = { "READ", "WRITE", "NOBLOCK", "APPEND", "CREATE", "TRUNCATE","EXCLUSIVE"  };
const char * const OksSystem::File::FILE_COMMAND_PATH = "/usr/bin/file";
const char * const OksSystem::File::FILE_FLAG_STR = "-rwxS";
const char * const OksSystem::File::FILE_PROTOCOL = "file";
 
 
#define READ_CHAR_CODE (OksSystem::File::FILE_FLAG_STR[1])
#define WRITE_CHAR_CODE (OksSystem::File::FILE_FLAG_STR[2])
#define EXECUTE_CHAR_CODE (OksSystem::File::FILE_FLAG_STR[3])
#define NOTHING_CHAR_CODE (OksSystem::File::FILE_FLAG_STR[0])
#define SETUID_CHAR_CODE (OksSystem::File::FILE_FLAG_STR[4])
 
#define SLASH_CHAR '/' 
#define COLON_CHAR ':'
#define DOT_CHAR '.' 
 
const int OksSystem::File::KILOBYTE = 1024;
 
 
// --------------------------------------
// Static Methods
// --------------------------------------
 

 
std::string OksSystem::File::protocol(const std::string &url) throw() {
    std::string::size_type colon = url.find(COLON_CHAR);
    if (colon==std::string::npos) return std::string();
    return url.substr(0,colon);
} // protocol

 
std::string OksSystem::File::extension(const std::string &url) throw() {
    std::string::size_type dot = url.rfind(DOT_CHAR);
    if (dot==std::string::npos) return std::string();
    return url.substr(dot+1);
} // extension

 
std::string OksSystem::File::short_name(const std::string &url) throw() {
    std::string::size_type slash = url.rfind(SLASH_CHAR);
    if (slash==std::string::npos) return url;
    return url.substr(slash+1);
} // extension

 
std::string OksSystem::File::uri(const std::string &url) throw() {
    std::string::size_type colon = url.find(COLON_CHAR);
    if (colon==std::string::npos) return url;
    return url.substr(colon+1);
} // uri
 

 
int OksSystem::File::depth(const std::string &path) throw() {
    if (path[0] == SLASH_CHAR) {
    int count = 0;
    std::string rest = path.substr(1); 
    while(! rest.empty()) {
        std::string::size_type slash = rest.find(SLASH_CHAR);
        if (slash==std::string::npos) return count;
        count++;
        rest = rest.substr(slash+1);
    } // while
    return count;   
    } // path with slash 
    if (protocol(path) == FILE_PROTOCOL) {
    return depth(uri(path));
    } //
    return -1;
} // depth

 
std::string OksSystem::File::first_line(const std::string &text) {
    std::string::size_type nl = text.find('\n');
    if (nl>0) return text.substr(0,nl); 
    return text;
} // first_line
 

 
OksSystem::File OksSystem::File::from_url(const std::string &url) {
    std::string prot = protocol(url);
    ERS_PRECONDITION(prot==FILE_PROTOCOL); 
    const std::string path = uri(url); 
    return File(path);
} // from_url

 
std::string OksSystem::File::working_directory() {
    char *wd_buffer = getcwd(0,MAXPATHLEN);  
    if (wd_buffer) {
        std::string directory = std::string(wd_buffer);
        free(wd_buffer); 
    return directory;
    }
    std::string message("getting the current working directory");
    throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "getcwd", message.c_str() );
} // working_directory 
 
void OksSystem::File::working_directory(const File &dir) {
    const char * path = dir.c_full_name(); 
    const int status = ::chdir(path); 
    if (status<0) {
      std::string message = "on directory " + dir.full_name(); 
      throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "chdir", message.c_str() );
    }
} // working_directory
 

 
 
std::string OksSystem::File::expand_home(const std::string path) {
    ERS_PRECONDITION(! path.empty());
    ERS_PRECONDITION(path[0] == '~'); 
    std::string::size_type slash = path.find('/');
    const std::string user_name = path.substr(1,slash-1); 
    const std::string rest_path = path.substr(slash);  
    OksSystem::User user;
    if (! user_name.empty()) {
    user = OksSystem::User(user_name);
    } 
    return user.home() + rest_path;
} // home_directory
 

 
std::string OksSystem::File::pretty_permissions(mode_t permissions) {
    char buffer[11];
    buffer[0] = (permissions & S_ISUID) ? SETUID_CHAR_CODE : NOTHING_CHAR_CODE;
    buffer[1] = (permissions & S_IRUSR) ? READ_CHAR_CODE : NOTHING_CHAR_CODE;
    buffer[2] = (permissions & S_IWUSR) ? WRITE_CHAR_CODE : NOTHING_CHAR_CODE;
    buffer[3] = (permissions & S_IXUSR) ? EXECUTE_CHAR_CODE : NOTHING_CHAR_CODE;
    buffer[4] = (permissions & S_IRGRP) ? READ_CHAR_CODE : NOTHING_CHAR_CODE;
    buffer[5] = (permissions & S_IWGRP) ? WRITE_CHAR_CODE : NOTHING_CHAR_CODE;
    buffer[6] = (permissions & S_IXGRP) ? EXECUTE_CHAR_CODE : NOTHING_CHAR_CODE;
    buffer[7] = (permissions & S_IROTH) ? READ_CHAR_CODE : NOTHING_CHAR_CODE;
    buffer[8] = (permissions & S_IWOTH) ? WRITE_CHAR_CODE : NOTHING_CHAR_CODE;
    buffer[9] = (permissions & S_IXOTH) ? EXECUTE_CHAR_CODE : NOTHING_CHAR_CODE;
    buffer[10] = '\0';
    return std::string(buffer); 
} // pretty_permissions

 
std::string OksSystem::File::pretty_open_flag(int flags) {
    std::ostringstream flag_str;
    if (flags & O_WRONLY) {
        flag_str << HUMAN_OPEN_STR[1];
    } else if (flags & O_RDWR) {
        flag_str << HUMAN_OPEN_STR[0] << "-" << HUMAN_OPEN_STR[1];
    } else {
        flag_str << HUMAN_OPEN_STR[0];
    }
    if (flags & O_NONBLOCK) {
        flag_str << "/" << HUMAN_OPEN_STR[2];
    } 
    if (flags & O_APPEND) {
        flag_str << "/" << HUMAN_OPEN_STR[3];
    }
    if (flags & O_CREAT) {
        flag_str << "/" << HUMAN_OPEN_STR[4];
    }
    if (flags & O_TRUNC) {
        flag_str << "/" << HUMAN_OPEN_STR[5];
    } 
    if (flags & O_EXCL) {
        flag_str << "/" << HUMAN_OPEN_STR[6];
    }
    flag_str << "(" << flags << ")";
    return flag_str.str();
} // pretty_open_permission
 
 
int  OksSystem::File::unit(int u) {
    ERS_PRECONDITION(u >= 0);
    if (u==0) return 1;
    return KILOBYTE * unit(u-1);
} // unit

 
std::string OksSystem::File::pretty_size(size_t size, bool cut_small) {
    if (0==size) return "0";
    std::ostringstream size_str;
    bool writen_something = false;
    for(int i=3;i>=0;i--) {
    const unsigned int size_unit = unit(i);
    if (size > size_unit && ! (cut_small && writen_something)) {
        const int amount = size / size_unit;
        size = size % size_unit;
        size_str << amount << SPACE_CHAR << HUMAN_SIZE_STR[i];
        writen_something = true;
    } // if unit is present
    } // loop
    return size_str.str(); 
} // pretty_size
 
// --------------------------------------
// Constructors
// --------------------------------------
 

 
OksSystem::File::File(const std::string &name) {
    set_name(name); 
} // File

 
OksSystem::File::File(const char* c_name) {
    ERS_PRECONDITION(c_name); 
    std::string name = std::string(c_name);
    set_name(name); 
} // File

 
OksSystem::File::File(const File& other) {
    set_name(other.m_full_name);
} // File
 
// --------------------------------------
// Operators
// --------------------------------------
 
 
 
OksSystem::File::operator std::string() const throw() {
    return m_full_name;
} // operator std::string
 
OksSystem::File::operator const char*() const throw() {
    return m_full_name.c_str();
} // operator const char*

 
OksSystem::File::operator bool() const throw() {
    return exists(); 
} // operator bool

 
bool OksSystem::File::equals(const File &other) const throw() {
    return (m_full_name == other.m_full_name);
} // operator==

 
OksSystem::File::operator size_t() const {
    return size();
} // operator size_t
 
 
 
 
// --------------------------------------
// Methods
// --------------------------------------
 

 
void OksSystem::File::set_name(const std::string &name) {
    ERS_PRECONDITION(! name.empty()); 
    const char c = name[0];
    std::string long_path;
    switch (c) {
    case '/' :
        long_path = name;
        break;
    case '~' : 
        long_path = expand_home(name); 
        break;
    default:
        long_path = working_directory() + "/" + name;
        break;
    } // switch     
    char buffer[PATH_MAX];
    const char* result = realpath(long_path.c_str(),buffer); 
    if (result==0) { // could not resolve path 
    m_full_name = long_path;
    } else { // we could canonicalize the path 
    m_full_name = buffer;
    } // 
} // set_name

 
const std::string & OksSystem::File::full_name() const throw() {
    return m_full_name;
} // full_name

 
const char* OksSystem::File::c_full_name() const throw() {
    return m_full_name.c_str(); 
} // c_full_name
 

 
std::string OksSystem::File::short_name() const throw() {
    return short_name(m_full_name);
} // short_name

 
std::string OksSystem::File::parent_name() const throw() {
  std::string::size_type size = m_full_name.size();
  std::string::size_type slash = m_full_name.rfind(SLASH_CHAR,size-1);
  if (slash==std::string::npos || slash==0) return ("/"); 
  return m_full_name.substr(0,slash); 
} // directory

 
std::string OksSystem::File::extension() const throw() {
    return extension(m_full_name);
} // extension
 
int OksSystem::File::depth() const throw() {
    return depth(m_full_name);
} // depth

 
OksSystem::File OksSystem::File::parent() const {
    return File(parent_name());
} // parent
 
OksSystem::File OksSystem::File::child(const std::string &name) const {
    std::string child_name = m_full_name + "/" + name;
    return OksSystem::File(child_name);
} // child
 
OksSystem::File OksSystem::File::temporary(const std::string &prefix) const {
    char *tmp_name = tempnam(m_full_name.c_str(),prefix.c_str());
    if ( !tmp_name ) {
      std::string message = "while creating a valid filename in directory " + m_full_name;
      throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "tempnam", message.c_str() );
    }
    OksSystem::File tmp_file(tmp_name);
    free(tmp_name);
    return tmp_file;
} // temporary
 

 
bool OksSystem::File::exists() const throw() {
    struct stat file_status;
    const int result = stat(m_full_name.c_str(),&file_status);
    if (0==result) return true;
    return false;
} // exists

 
mode_t OksSystem::File::get_mode() const {
    struct stat file_status;
    const int result = stat(m_full_name.c_str(),&file_status);
    if (0==result) {
    return file_status.st_mode;
    } // if
    std::string message = "on file/directory " + m_full_name;
    throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "stat", message.c_str() );
} // mode
 

 
mode_t OksSystem::File::permissions() const {
    mode_t mode = get_mode();
    return (mode & 07777);
} // permissions

 
std::string OksSystem::File::pretty_permissions() const {
    return pretty_permissions(permissions()); 
} // pretty_permissions

 
std::string OksSystem::File::to_string(mode_t permissions) throw() {
    std::ostringstream stream;
    stream.setf(std::ios::oct,std::ios::basefield);
    stream << permissions;
    return stream.str();
} // to_string
 

 
size_t OksSystem::File::size() const {
    struct stat file_status;
    const int result = stat(m_full_name.c_str(),&file_status);
    if (0==result) return file_status.st_size;
    std::string message = "on file/directory " + m_full_name;
    throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "stat", message.c_str() );
} // size 

 
uid_t OksSystem::File::owner_id() const {
    struct stat file_status;
    const int result = stat(m_full_name.c_str(),&file_status);
    if (0==result) return file_status.st_uid;
    std::string message = "on file/directory " + m_full_name;
    throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "stat", message.c_str() );
} // owner_id
 
OksSystem::User OksSystem::File::owner() const {
    return User(owner_id());
} // owner
 

 
gid_t OksSystem::File::group() const {
    struct stat file_status;
    const int result = stat(m_full_name.c_str(),&file_status);
    if (0==result) return file_status.st_gid;
    std::string message = "on file/directory " + m_full_name;
    throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "stat", message.c_str() );
} // owner
 

 
bool OksSystem::File::is_regular() const {
    const mode_t mode = get_mode();
    return (mode & S_IFREG);
} // is_regular
 

 
bool OksSystem::File::is_directory() const {
    const mode_t mode = get_mode();
    return (mode & S_IFDIR);
} // is_regular

 
bool OksSystem::File::is_fifo() const {
    const mode_t mode = get_mode();
    return (mode & S_IFIFO);
} // is_pipe
 
 
std::string OksSystem::File::file_type() const {
    OksSystem::Executable file_command(FILE_COMMAND_PATH); 
    OksSystem::Executable::param_collection params;
    params.push_back("-b"); 
    params.push_back(full_name()); 
    return first_line(file_command.pipe_in(params)); 
} // file_type
    
 
OksSystem::File::file_list_t OksSystem::File::directory() const {
    file_list_t file_vector;
    DIR* directory_ptr = opendir(m_full_name.c_str());
    if (! directory_ptr) {
      std::string message = "on directory " + m_full_name;
      throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "opendir", message.c_str() );
    }
    while(true) {
    struct dirent* directory_entry = readdir(directory_ptr); 
    if (directory_entry) {
        const std::string name = directory_entry->d_name;
        if ((name!=".") && (name!="..")) {
        std::string path = m_full_name + "/" + name;
        OksSystem::File file(path); 
        file_vector.push_back(file);
        } // if
    } else {
        break;
    } // if / else
    } // while
    int status = closedir(directory_ptr);
    if (status<0) {
      std::string message = "on directory " + m_full_name;
      throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "closedir", message.c_str() );
    }
    return file_vector;
} // directory

 
void OksSystem::File::unlink() const {
    const int result = ::unlink(m_full_name.c_str());
    if (0==result) return;
    throw OksSystem::RemoveFileIssue( ERS_HERE, errno, m_full_name.c_str() ); 
} //unlink
 
void OksSystem::File::rmdir() const {
    const int result = ::rmdir(m_full_name.c_str());
    if (0==result) return;
    std::string message = "on directory " + m_full_name;
    throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "rmdir", message.c_str() ); 
} // rmdir
 

 
void OksSystem::File::remove() const {
    if (is_directory()) {
    file_list_t childs = directory(); 
    for (file_list_t::const_iterator p=childs.begin();p!=childs.end();p++) {
        const File f = *p;
        if(f.exists()) {
          f.remove(); 
        }
    } // for
    rmdir();
    } else {
    unlink(); 
    } 
} // remove
 

 
void OksSystem::File::rename(const File &other) const {
    const char *source = c_full_name() ;
    const char *dest = other.c_full_name();
    const int result = ::rename(source,dest); 
    if (0==result) return;
    throw OksSystem::RenameFileIssue( ERS_HERE, errno, source, dest );
} // rename

 
void OksSystem::File::permissions(mode_t perm) const {
  if(perm !=  permissions()) {
    const int result = ::chmod(m_full_name.c_str(),perm); 
    if (0==result) {
      return;
    }
    std::string message = "on file/directory " + m_full_name;
    throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "chmod", message.c_str());
  }
} // permissions
 
 
void OksSystem::File::make_dir(mode_t perm) const {
 
    errno = 0;
    const int result = ::mkdir(m_full_name.c_str(),perm);
    int mkdir_error = errno;
 
    if (0==result) {
      try {
    permissions(perm);
      }
      catch (OksSystem::OksSystemCallIssue &e){
    std::string message = "on directory " + m_full_name;
    throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "mkdir -> chmod", message.c_str() ); 
      }
      return;
    } else {
      if (exists()) {
        if (is_directory()) { // already exists we attempt a chmod
      try {
        permissions(perm);
      }
      catch (OksSystem::OksSystemCallIssue &e){
        // ignore this case...
      }
      return;
    } // is directory
      } else { // exists
    std::string message = "on directory " + m_full_name;
    throw OksSystem::OksSystemCallIssue(ERS_HERE, mkdir_error, "mkdir", message.c_str()); 
      }
    }
    
} // makedir

 
void OksSystem::File::make_path(mode_t perm) const { 
    const File father = parent(); 
    if (! father.exists()) {
    mode_t father_permission = perm | S_IRWXU;// we need rights to write sons
    father.make_path(father_permission); 
    } // if
    make_dir(perm); 
} // makepath

 
void  OksSystem::File::ensure_path(mode_t perm) const {
    const File father = parent();
    father.make_path(perm); 
} // ensure_path
 

 
void OksSystem::File::make_fifo(mode_t perm) const {
    if (exists()) {
    if (is_fifo()) {
      if(perm != permissions()) {
        permissions(perm); 
        return;
      } else {
        return;
      }
    } // is_fifo
    } // exists
    const int status = ::mkfifo(m_full_name.c_str(),perm); 
    if (status==0) {
      permissions(perm);
      return;
    } 
    std::string message = "while creating FIFO " + m_full_name;
    throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "mkfifo", message.c_str() ); 
} // makefifo
    
 
 

 
std::istream* OksSystem::File::input() const {
    try {
    std::ifstream *stream = new std::ifstream(m_full_name.c_str());
    stream->exceptions(std::ios::failbit | std::ios::badbit); 
    return stream;
    } catch (std::ios_base::failure &ex) {
    throw OksSystem::OpenFileIssue( ERS_HERE, errno, m_full_name.c_str(), ex ); 
    } // catch
} // std::istream*

    
std::ostream* OksSystem::File::output(bool append) const {
    try {
    std::ios::openmode mode = std::ios::out;
    if (append) {
        mode |= std::ios::app;
    }
    std::ofstream *stream = new std::ofstream(m_full_name.c_str(),mode);
    stream->exceptions(std::ios::failbit | std::ios::badbit); 
    return stream;
    } catch (std::ios_base::failure &ex) {
    throw OksSystem::OpenFileIssue( ERS_HERE, errno, m_full_name.c_str(), ex ); 
    } // catch
} // std::ostream*

 
std::ostream& operator<<(std::ostream& stream, const OksSystem::File& file) {
    stream << OksSystem::File::FILE_PROTOCOL << ":/" << file.full_name();
    return stream;
} // operator<<
 
bool operator ==(const OksSystem::File &a, const OksSystem::File &b)  throw() {
    return a.equals(b); 
} // operator ==
 
bool operator !=(const OksSystem::File &a, const OksSystem::File &b)  throw() {
    return ! a.equals(b); 
} // operator !=