filesystem.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_FS_FILESYSTEM_HPP_
#define FOEDUS_FS_FILESYSTEM_HPP_
#include <iosfwd>
#include <string>

#include "foedus/cxx11.hpp"
#include "foedus/error_code.hpp"
#include "foedus/fwd.hpp"
#include "foedus/initializable.hpp"
#include "foedus/assorted/fixed_string.hpp"
#include "foedus/fs/path.hpp"

namespace foedus {
namespace fs {

enum FileType {
  kStatusError = 0,
  kFileNotFound,
  kRegularFile,
  kDirectoryFile,
  kTypeUnknown,
};

enum FilePermission {
  kNoPerms = 0,       // kFileNotFound is kNoPerms rather than kPermsNotKnown

  // POSIX equivalent macros given in comments.
  // Values are from POSIX and are given in octal per the POSIX standard.

  // permission bits

  kOwnerRead = 0400,      // S_IRUSR, Read permission, owner
  kOwnerWrite = 0200,     // S_IWUSR, Write permission, owner
  kOwnerExe = 0100,       // S_IXUSR, Execute/search permission, owner
  kOwnerAll = 0700,       // S_IRWXU, Read, write, execute/search by owner

  kGroupRead = 040,       // S_IRGRP, Read permission, group
  kGroupWrite = 020,      // S_IWGRP, Write permission, group
  kGroupExe = 010,        // S_IXGRP, Execute/search permission, group
  kGroupAll = 070,        // S_IRWXG, Read, write, execute/search by group

  kOthersRead = 04,       // S_IROTH, Read permission, others
  kOthersWrite = 02,      // S_IWOTH, Write permission, others
  kOthersExe = 01,        // S_IXOTH, Execute/search permission, others
  kOthersAll = 07,        // S_IRWXO, Read, write, execute/search by others

  kAllAll = kOwnerAll|kGroupAll|kOthersAll,  // 0777

  kPermsNotKnown = 0xFFFF,   // present when directory_entry cache not loaded
};

typedef assorted::FixedString<508> FixedPath;

struct FileStatus {
  FileStatus()            : type_(kStatusError), permissions_(kPermsNotKnown) {}
  explicit FileStatus(FileType type, FilePermission permissions = kPermsNotKnown)
                    : type_(type), permissions_(permissions) {}

  bool type_present() const       { return type_ != kStatusError; }
  bool permissions_present() const    { return permissions_ != kPermsNotKnown;}
  bool status_known() const       { return type_present() && permissions_present(); }
  bool exists() const             { return type_ != kStatusError && type_ != kFileNotFound; }
  bool is_regular_file() const    { return type_ == kRegularFile; }
  bool is_directory() const       { return type_ == kDirectoryFile; }

  FileType        type_;
  FilePermission  permissions_;
};

struct SpaceInfo  {
  uint64_t capacity_;
  uint64_t free_;
  uint64_t available_;
  friend std::ostream& operator<<(std::ostream& o, const SpaceInfo& v);
};

FileStatus status(const Path& p);
inline bool exists(const Path& p) {return status(p).exists(); }
inline bool is_directory(const Path& p) {return status(p).is_directory(); }
inline bool is_regular_file(const Path& p) {return status(p).is_regular_file(); }

Path        current_path();
Path        home_path();
Path        absolute(const std::string& p);

// so far not needed
// ErrorCode copy(const Path& from, const Path& to);
// ErrorCode copy_directory(const Path& from, const Path& to);
// ErrorCode copy_file(const Path& from, const Path& to);

bool        create_directories(const Path& p, bool sync = false);
bool        create_directory(const Path& p, bool sync = false);
uint64_t    file_size(const Path& p);
bool        remove(const Path& p);
uint64_t    remove_all(const Path& p);
SpaceInfo   space(const Path& p);
std::string unique_name(uint64_t differentiator = 0);
std::string unique_name(const std::string& model, uint64_t differentiator = 0);

bool        fsync(const Path& path, bool sync_parent_directory = false);

bool        atomic_rename(const Path& old_path, const Path& new_path);

bool        durable_atomic_rename(const Path& old_path, const Path& new_path);

inline bool rename(const Path& old_path, const Path& new_path) {
  return atomic_rename(old_path, new_path);
}

}  // namespace fs
}  // namespace foedus
#endif  // FOEDUS_FS_FILESYSTEM_HPP_