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 <assert.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <fstream>
#include <iostream>
#include <libgen.h>
#include <pwd.h>
#include <sstream>
#include <stdio.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
#include "ers/ers.hpp"
 
#include "okssystem/Executable.hpp"
#include "okssystem/File.hpp"
#include "okssystem/User.hpp"
#include "okssystem/exceptions.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 !=