file.hpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS oks source for the DUNE DAQ project.
// Fork baseline commit: oks-08-03-04 (2022-04-14).
// Renamed since fork: yes (from oks/file.h to include/oks/file.hpp).

 
#ifndef OKS_FILE_H
#define OKS_FILE_H
 
#include "oks/exceptions.hpp"
 
#include <list>
#include <map>
#include <memory>
#include <set>
#include <string>
 
#include <boost/date_time/posix_time/ptime.hpp>
 
#include <unordered_map>
#include <unordered_set>
 
namespace boost {
namespace interprocess {
class file_lock;
}
}
 
namespace dunedaq {
namespace oks {
 
class OksXmlOutputStream;
class OksXmlInputStream;
class OksKernel;
class OksFile;

 
class FileLockError : public exception
{
 
public:
 
  FileLockError(const OksFile& file, bool lock_action, const std::string& reason) noexcept
    : exception(fill(file, lock_action, reason), 0)
  {
  }
 
  virtual ~FileLockError() noexcept {}
 
private:
  static std::string fill(const OksFile& file, bool lock_action, const std::string& reason) noexcept;
};

 
class FileChangeError : public exception
{
 
public:
  FileChangeError(const OksFile& file, const std::string& action, const exception& reason) noexcept
    : exception(fill(file, action, reason.what()), reason.level() + 1)
  {
  }

  FileChangeError(const OksFile& file, const std::string& action, const std::string& reason) noexcept
    : exception(fill(file, action, reason), 0)
  {
  }
 
  virtual ~FileChangeError() noexcept {}
 
private:
  static std::string fill(const OksFile& file, const std::string& action, const std::string& reason) noexcept;
};

 
class FileCompareError : public exception
{
 
public:
  FileCompareError(const std::string& src, const std::string& dest, const std::string& reason) noexcept
    : exception(fill(src, dest, reason), 0)
  {
  }
 
  virtual ~FileCompareError() noexcept {}
 
private:
  static std::string fill(const std::string& src, const std::string& dest, const std::string& reason) noexcept;
};

 
class FailedAddInclude : public exception
{
 
public:
  FailedAddInclude(const OksFile& file, const std::string& include_name, const exception& reason) noexcept
    : exception(fill(file, include_name, reason.what()), reason.level() + 1)
  {
  }

  FailedAddInclude(const OksFile& file, const std::string& include_name, const std::string& reason) noexcept
    : exception(fill(file, include_name, reason), 0)
  {
  }
 
  virtual ~FailedAddInclude() noexcept {}
 
private:
  static std::string fill(const OksFile& file, const std::string& include_name, const std::string& reason) noexcept;
};

 
class FailedRemoveInclude : public exception
{
 
public:
  FailedRemoveInclude(const OksFile& file, const std::string& include_name, const exception& reason) noexcept
    : exception(fill(file, include_name, reason.what()), reason.level() + 1)
  {
  }

  FailedRemoveInclude(const OksFile& file, const std::string& include_name, const std::string& reason) noexcept
    : exception(fill(file, include_name, reason), 0)
  {
  }
 
  virtual ~FailedRemoveInclude() noexcept {}
 
private:
  static std::string fill(const OksFile& file, const std::string& include_name, const std::string& reason) noexcept;
};

 
class FailedRenameInclude : public exception
{
 
public:
  FailedRenameInclude(const OksFile& file,
                      const std::string& from,
                      const std::string& to,
                      const exception& reason) noexcept
    : exception(fill(file, from, to, reason.what()), reason.level() + 1)
  {
  }

  FailedRenameInclude(const OksFile& file,
                      const std::string& from,
                      const std::string& to,
                      const std::string& reason) noexcept
    : exception(fill(file, from, to, reason), 0)
  {
  }
 
  virtual ~FailedRenameInclude() noexcept {}
 
private:
  static std::string fill(const OksFile& file,
                          const std::string& from,
                          const std::string& to,
                          const std::string& reason) noexcept;
};

 
class FailedAddComment : public exception
{
 
public:
  FailedAddComment(const OksFile& file, const exception& reason) noexcept
    : exception(fill(file, reason.what()), reason.level() + 1)
  {
  }

  FailedAddComment(const OksFile& file, const std::string& reason) noexcept
    : exception(fill(file, reason), 0)
  {
  }
 
  virtual ~FailedAddComment() noexcept {}
 
private:
  static std::string fill(const OksFile& file, const std::string& reason) noexcept;
};

 
class FailedRemoveComment : public exception
{
 
public:
  FailedRemoveComment(const OksFile& file, const std::string& creation_time, const exception& reason) noexcept
    : exception(fill(file, creation_time, reason.what()), reason.level() + 1)
  {
  }

  FailedRemoveComment(const OksFile& file, const std::string& creation_time, const std::string& reason) noexcept
    : exception(fill(file, creation_time, reason), 0)
  {
  }
 
  virtual ~FailedRemoveComment() noexcept {}
 
private:
  static std::string fill(const OksFile& file, const std::string& creation_time, const std::string& reason) noexcept;
};

 
class FailedChangeComment : public exception
{
 
public:
  FailedChangeComment(const OksFile& file, const std::string& creation_time, const exception& reason) noexcept
    : exception(fill(file, creation_time, reason.what()), reason.level() + 1)
  {
  }

  FailedChangeComment(const OksFile& file, const std::string& creation_time, const std::string& reason) noexcept
    : exception(fill(file, creation_time, reason), 0)
  {
  }
 
  virtual ~FailedChangeComment() noexcept {}
 
private:
  static std::string fill(const OksFile& file, const std::string& creation_time, const std::string& reason) noexcept;
};

 
class Comment
{
 
  friend class OksFile;
 
private:
  Comment() noexcept { ; }

  Comment(const std::string& text, const std::string& author);

  Comment(const oks::Comment& src) noexcept;
 
public:
  const std::string& get_created_by() const { return p_created_by; }

  const std::string& get_author() const { return p_author; }

  const std::string& get_created_on() const { return p_created_on; }

  const std::string& get_text() const { return p_text; }

  void validate(const std::string& creation_time);

  void validate();
 
private:
  std::string p_created_by;
  std::string p_author;
  std::string p_created_on;
  std::string p_text;
};
 
struct hash_file_ptr
{
  inline size_t operator()(const OksFile* x) const { return reinterpret_cast<size_t>(x); }
};
 
struct equal_file_ptr
{
  inline bool operator()(const OksFile* __x, const OksFile* __y) const { return (__x == __y); }
};

 
class OksFile
{
 
  friend class OksKernel;
  friend class OksClass;
  friend class OksObject;
  friend struct OksLoadObjectsJob;
 
public:
  enum Mode
  {
    ReadOnly,
    ReadWrite
  };
 
  enum FileStatus
  {
    FileNotModified,
    FileModified,
    FileWasNotSaved,
    FileRemoved
  };
 
  struct SortByName
  {
    bool operator()(const std::string* s1, const std::string* s2) const { return *s1 < *s2; }
  };
 
  typedef std::map<const std::string*, OksFile*, SortByName> Map;
 
  typedef std::unordered_set<OksFile*, oks::hash_file_ptr, oks::equal_file_ptr> Set;
  typedef std::unordered_map<OksFile*, Set, oks::hash_file_ptr, oks::equal_file_ptr> IMap;

 
  void lock();
 
  // Nasty hack to allow code generation on the fly without locking
  // file. Off by default
  static void set_nolock_mode(bool nl) { p_nolock_mode = nl; }

 
  void unlock();

 
  void add_include_file(const std::string& name);

 
  void remove_include_file(const std::string& name);

 
  void rename_include_file(const std::string& from, const std::string& to);

 
  void add_comment(const std::string& text, const std::string& author);

 
  void modify_comment(const std::string& creation_time, const std::string& text, const std::string& author);

 
  void remove_comment(const std::string& creation_time);

 
  const std::map<std::string, oks::Comment*>& get_comments() const { return p_comments; }

 
  void set_logical_name(const std::string& name);

 
  void set_type(const std::string& type);
 
  const std::string& get_short_file_name() const { return p_short_name; }

 
  const std::string& get_full_file_name() const { return p_full_name; }

 
  bool is_repository_file() const;

 
  const std::string& get_repository_name() const { return p_repository_name; }

 
  const std::string& get_well_formed_name() const
  {
    return (!p_repository_name.empty() ? p_repository_name : p_full_name);
  }
 
  const std::string& get_lock_file() const
  {
    init_lock_name();
    return p_lock_file_name;
  }
  const std::string& get_logical_name() const { return p_logical_name; }
  const std::string& get_type() const { return p_type; }
  const std::string& get_oks_format() const { return p_oks_format; }

 
  long get_number_of_items() const { return p_number_of_items; }

 
  long get_size() const { return p_size; }

 
  const std::string& get_created_by() const { return p_created_by; }

 
  const boost::posix_time::ptime get_creation_time() const { return p_creation_time; }

 
  const std::string& get_created_on() const { return p_created_on; }

 
  const std::string& get_last_modified_by() const { return p_last_modified_by; }

 
  const boost::posix_time::ptime get_last_modification_time() const { return p_last_modification_time; }

 
  const std::string& get_last_modified_on() const { return p_last_modified_on; }

 
  bool is_locked() const { return (p_lock != nullptr); }

 
  bool is_updated() const { return p_is_updated; }

 
  bool is_read_only() const { return p_is_read_only; }

 
  const std::list<std::string>& get_include_files() const { return p_list_of_include_files; }

 
  void get_all_include_files(const OksKernel* kernel, std::set<OksFile*>& out);

 
  FileStatus get_status_of_file() const;

 
  void update_status_of_file(bool update_local = true, bool update_repository = true);

 
  bool get_lock_string(std::string& info) const;

 
  static bool compare(const char* file1_name, const char* file2_name);

 
  bool compare(const char* name) const { return compare(p_full_name.c_str(), name); }

 
  const OksFile* get_parent() const { return p_included_by; }

 
  OksFile* check_parent(const OksFile* parent_h);
 
public:
  ~OksFile() noexcept;
 
private:
  static bool p_nolock_mode; // Nasty hack mode
 
  std::string p_short_name;      // short path to file
  std::string p_full_name;       // path which is used to open file
  std::string p_repository_name; // the name of file inside repository
  std::string p_logical_name;    // name of file, e.g. "Control Workstations"
  std::string p_type;            // type of file, e.g. "DCS"
  std::string p_oks_format;      // format of file: "data" or "schema"
  long p_number_of_items;        // number of objects or classes
  long p_size;                   // size of file in bytes
  std::string p_created_by;
  boost::posix_time::ptime p_creation_time;
  std::string p_created_on;
  std::string p_last_modified_by;
  boost::posix_time::ptime p_last_modification_time;
  std::string p_last_modified_on;
  Mode p_open_mode;
  std::shared_ptr<boost::interprocess::file_lock> p_lock;
  std::string p_lock_file_name; // lock file
  bool p_is_updated;
  bool p_is_read_only;
  std::list<std::string> p_list_of_include_files;
  time_t p_last_modified;
  time_t p_repository_last_modified;
  std::map<std::string, oks::Comment*> p_comments;
  bool p_is_on_disk;
  const OksFile* p_included_by;
  OksKernel* p_kernel;
 
  static const char xml_file_header[];
  static const char xml_schema_file_dtd[];
  static const char xml_data_file_dtd[];
  static const char xml_info_tag[];
  static const char xml_include_tag[];
  static const char xml_file_tag[];
  static const char xml_comments_tag[];
  static const char xml_comment_tag[];
 
  // only to be used by the friends
 
  OksFile(const std::string&, // file full path
          const std::string&, // file logical name
          const std::string&, // file type
          const std::string&, // file oks-format
          OksKernel*);
 
  OksFile& operator=(const OksFile&);
 
  OksFile(const OksFile& f) { *this = f; }
 
  OksFile(std::shared_ptr<OksXmlInputStream>, const std::string&, const std::string&, OksKernel*);
  void write(OksXmlOutputStream&);
 
  void set_updated() { p_is_updated = true; } // in-memory
 
  void rename(const std::string& short_name, const std::string& full_name);
  void rename(const std::string& full_name); // repository rename
  void create_lock_name();
  void init_lock_name() const
  {
    if (p_lock_file_name.empty())
      const_cast<OksFile*>(this)->create_lock_name();
  }
  void check_repository();
 
  std::string make_repository_name() const;
 
  oks::Comment* get_comment(const std::string& creation_time) noexcept;
 
  void clear_comments() noexcept;
 
  std::list<std::string>::iterator find_include_file(const std::string&);
};
 
std::ostream&
operator<<(std::ostream&, const OksFile&);
std::ostream&
operator<<(std::ostream&, const oks::Comment&);
 
} // namespace oks
} // namespace dunedaq
#endif