sjef.h

Go to the documentation of this file.

#ifndef SJEF_SJEF_H
#define SJEF_SJEF_H
#include <filesystem>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <thread>
#include <vector>
#include <ostream>
#include <iostream>
#include <atomic>
 
namespace pugi {
class xpath_node_set; 
}
namespace sjef {
class Backend;            
class Locker;             
struct remote_server;     
struct pugi_xml_document; 
static constexpr int recentMax = 128;
enum status : int { unknown = 0, running = 1, waiting = 2, completed = 3, unevaluated = 4, killed = 5 };
using mapstringstring_t = std::map<std::string, std::string>;
 
class Logger {
  std::ostream* m_stream;
  int m_level;
 
  class NullBuffer : public std::streambuf {
  public:
    int overflow(int c) override { return c; }
  };
  NullBuffer m_null_buffer;
  mutable std::ostream m_null{&m_null_buffer};
  std::vector<std::string> m_preambles;
 
public:
  enum class Levels : int { QUIET = -1, ERROR = 0, WARNING = 1, NOTIFICATION = 2, DETAIL = 3 };
  explicit Logger(std::ostream& stream, int level) : m_stream(&stream), m_level(level) {}
  explicit Logger(std::ostream& stream = std::cout, const Levels level = Levels::ERROR,
                  std::vector<std::string> preambles = {})
      : m_stream(&stream), m_level(static_cast<int>(level)), m_preambles(std::move(preambles)) {}
  explicit Logger(const Logger& source)
      : m_stream(source.m_stream), m_level(source.m_level), m_preambles(source.m_preambles) {}
  explicit Logger(Logger&& source) noexcept
      : m_stream(std::move(source.m_stream)), m_level(std::move(source.m_level)),
        m_preambles(std::move(source.m_preambles)) {}
  Logger& operator=(const Logger& source) {
    m_stream = source.m_stream;
    m_level = source.m_level;
    m_preambles = source.m_preambles;
    return *this;
  }
  Logger& operator=(Logger&& source) noexcept {
    m_stream = source.m_stream;
    m_level = source.m_level;
    m_preambles = std::move(source.m_preambles);
    return *this;
  }
  ~Logger() = default;
  std::ostream& stream() const { return *m_stream; }
  std::ostream& operator()(int level, const std::string& message = "") const {
    auto& stream = level > m_level ? m_null : *m_stream;
    if (level >= 0 && level < decltype(level)(m_preambles.size()))
      stream << m_preambles[level];
    if (!message.empty())
      stream << message << std::endl;
    return stream;
  }
  std::ostream& operator()(const Levels level, const std::string& message = "") const {
    return ((*this)(static_cast<int>(level), message));
  }
  std::ostream& detail(const std::string& message = "") const { return ((*this)(Levels::DETAIL, message)); }
  std::ostream& notify(const std::string& message = "") const { return ((*this)(Levels::NOTIFICATION, message)); }
  std::ostream& warn(const std::string& message = "") const { return ((*this)(Levels::WARNING, message)); }
  std::ostream& error(const std::string& message = "") const { return ((*this)(Levels::ERROR, message)); }
  int level() const { return m_level; }
  void set_level(int level) { Logger::m_level = level; }
  void set_level(Levels level) { Logger::m_level = static_cast<int>(level); }
  void set_stream(std::ostream& stream) { m_stream = &stream; }
};
 
template <typename Arg>
std::ostream& operator<<(const Logger& l, Arg arg) {
  l.stream() << arg;
  return l.stream();
}
 
class Project {
private:
  std::string m_project_suffix;
  std::filesystem::path m_filename; 
  std::vector<std::filesystem::path> m_reserved_files =
      std::vector<std::filesystem::path>{sjef::Project::s_propertyFile}; 
  std::unique_ptr<pugi_xml_document> m_properties;
  mapstringstring_t m_suffixes; 
  std::map<std::string, Backend> m_backends;
 
  std::unique_ptr<pugi_xml_document> m_backend_doc;
  mutable std::shared_ptr<remote_server> m_remote_server;
  mutable std::chrono::milliseconds m_status_lifetime = std::chrono::milliseconds(0);
  mutable std::chrono::time_point<std::chrono::steady_clock> m_status_last = std::chrono::steady_clock::now();
  mutable std::thread m_backend_watcher;
  // put the flag into a container to deal conveniently with std:atomic_flag's
  // lack of move constructor
  struct backend_watcher_flag_container {
    std::atomic_flag shutdown_flag;
    std::mutex m_property_set_mutex;
  };
  mutable backend_watcher_flag_container m_unmovables;
  std::unique_ptr<Project> m_backend_watcher_instance;
  const Project* m_master_instance;
  bool m_master_of_slave;
  bool m_monitor;
  bool m_sync;
  mutable std::mutex m_status_mutex;
  mutable std::mutex m_remote_server_mutex;
  mutable std::mutex m_synchronize_mutex;
  mutable std::string m_backend; 
  mutable std::string m_xml_cached;
  std::string remote_server_run(const std::string& command, int verbosity = 0, bool wait = true) const;
  static const std::string s_propertyFile;
  std::shared_ptr<Locker> m_locker;
  Logger m_warn{std::cerr, Logger::Levels::WARNING, {"sjef:: Error: ", "sjef:: Warning: ", "sjef:: Note:"}};
  Logger m_trace{std::cout, Logger::Levels::QUIET};
 
public:
  explicit Project(const std::filesystem::path& filename, bool construct = true, const std::string& default_suffix = "",
                   const mapstringstring_t& suffixes = {{"inp", "inp"}, {"out", "out"}, {"xml", "xml"}},
                    bool monitor = true, bool sync = true, const Project* masterProject = nullptr);
  //  explicit Project(const std::string& filename, bool construct = true, const std::string& default_suffix = "",
//                   const mapstringstring_t& suffixes = {{"inp", "inp"}, {"out", "out"}, {"xml", "xml"}}) : Project(std::filesystem::path(filename),construct,default_suffix,suffixes) {}
  Project(const Project& source) = delete;
  Project(const Project&& source) = delete;
  virtual ~Project();
  bool copy(const std::filesystem::path& destination_filename, bool force = false, bool keep_hash = false, bool slave = false, int keep_run_directories=std::numeric_limits<int>::max());
  bool move(const std::filesystem::path& destination_filename, bool force = false);
  static void erase(const std::filesystem::path& filename, const std::string& default_suffix = "");
  bool import_file(const std::filesystem::path& file, bool overwrite = false);
  bool import_file(const std::vector<std::string>& files, bool overwrite = false) {
    bool result = true;
    for (const auto& file : files)
      result &= import_file(file, overwrite);
    return result;
  }
  bool export_file(const std::filesystem::path& file, bool overwrite = false);
  bool export_file(const std::vector<std::string>& files, bool overwrite = false) {
    bool result = true;
    for (const auto& file : files)
      result &= export_file(file, overwrite);
    return result;
  }
  bool synchronize(int verbosity = 0, bool nostatus = false, bool force = false) const;
  void set_warnings(const Logger::Levels level = Logger::Levels::WARNING, std::ostream& stream = std::cerr,
                std::vector<std::string> preambles = {"sjef:: Error: ", "sjef:: Warning: ", "sjef:: Note:"}) {
    m_warn = Logger{stream, level, std::move(preambles)};
  }
  void set_verbosity(int verbosity, std::ostream& stream = std::cout) { m_trace = Logger(stream, verbosity); }
 
  bool run(int verbosity = 0, bool force = false, bool wait = false);
  bool run(const std::string& name, int verbosity = 0, bool force = false, bool wait = false) {
    change_backend(name);
    return run(verbosity, force, wait);
  }
 
  sjef::status status(int verbosity = 0, bool cached = true) const;
  std::string status_message(int verbosity = 0) const;
  void wait(unsigned int maximum_microseconds = 10000) const;
  void kill();
  bool run_needed(int verbosity = 0) const;
  std::string input_from_output(bool sync = true) const;
  void rewrite_input_file(const std::string& input_file_name, const std::string& old_name);
  void custom_initialisation();
  void custom_run_preface();
  std::string xml(int run = 0, bool sync = true) const;
  std::string file_contents(const std::string& suffix = "", const std::string& name = "", int run = 0,
                            bool sync = true) const;
 
  void clean(bool oldOutput = true, bool output = false, bool unused = false, int keep_run_directories=0);
  void property_set(const std::string& property, const std::string& value);
  void property_set(const mapstringstring_t& properties);
  std::string property_get(const std::string& property) const;
  mapstringstring_t property_get(const std::vector<std::string>& properties) const;
  void property_delete(const std::string& property);
  void property_delete(const std::vector<std::string>& properties);
  std::vector<std::string> property_names() const;
  std::filesystem::path filename(std::string suffix = "", const std::string& name = "", int run = -1) const;
  std::filesystem::path run_directory(int run = 0) const;
  int run_verify(int run) const;
  using run_list_t = std::set<int, std::greater<int>>;
  run_list_t run_list() const;
  int run_directory_new();
  void run_delete(int run);
  int run_directory_next() const;
  std::string name() const;
  static int recent_find(const std::string& suffix, const std::filesystem::path& filename);
  int recent_find(const std::filesystem::path& filename) const;
  static std::string recent(const std::string& suffix, int number = 1);
  std::string recent(int number = 1) const;
  void ensure_remote_server() const;
  void change_backend(std::string backend = std::string{""}, bool force = false);
 
  std::map<std::string, Backend>& backends() { return m_backends; }
 
private:
  Backend default_backend();
  sjef::status cached_status() const;
  void cached_status(sjef::status status) const;
  void throw_if_backend_invalid(std::string backend = "") const;
  std::string get_project_suffix(const std::filesystem::path& filename, const std::string& default_suffix) const;
  static void recent_edit(const std::filesystem::path& add, const std::filesystem::path& remove = "");
  mutable std::filesystem::file_time_type m_property_file_modification_time;
  mutable std::map<std::string, std::filesystem::file_time_type, std::less<>> m_input_file_modification_time;
  std::set<std::string, std::less<>> m_run_directory_ignore;
  void property_delete_locked(const std::string& property);
  void check_property_file_locked() const;
  void check_property_file() const;
  void save_property_file_locked() const;
  void save_property_file() const;
  void load_property_file_locked() const;
  bool properties_last_written_by_me(bool removeFile = false) const;
 
public:
  std::filesystem::path propertyFile() const;
  const std::string backend_cache() const;
 
private:
  std::string cache(const Backend& backend) const;
  void force_file_names(const std::string& oldname);
  static void backend_watcher(sjef::Project& project_, int min_wait_milliseconds, int max_wait_milliseconds = 0,
                              int poll_milliseconds = 1);
  void shutdown_backend_watcher();
  std::string referenced_file_contents(const std::string& line) const;
 
public:
  static const std::vector<std::string> suffix_keys;
  /*
   */
  size_t project_hash();
  size_t input_hash() const;
 
  std::string backend_get(const std::string& backend, const std::string& key) const;
 
  std::string backend_parameter_expand(const std::string& backend, std::string templ = "") const;
 
  mapstringstring_t backend_parameters(const std::string& backend, bool doc = false) const;
 
  void backend_parameter_set(const std::string& backend, const std::string& name, const std::string& value) {
    property_set("Backend/" + backend + "/" + name, value);
  }
 
  void backend_parameter_delete(const std::string& backend, const std::string& name) {
    property_delete("Backend/" + backend + "/" + name);
  }
 
  std::string backend_parameter_get(const std::string& backend, const std::string& name) const {
    auto p = property_get("Backend/" + backend + "/" + name);
    if (p.find("!") == std::string::npos)
      return p;
    return p.substr(0, p.find("!"));
  }
 
  std::string backend_parameter_documentation(const std::string& backend, const std::string& name) const {
    auto ps = backend_parameters(backend, true);
    if (ps.count(name) == 0)
      return "";
    return ps.at(name);
  }
 
  std::string backend_parameter_default(const std::string& backend, const std::string& name) const {
    auto ps = backend_parameters(backend, false);
    if (ps.count(name) == 0)
      return "";
    return ps.at(name);
  }
 
  std::vector<std::string> backend_names() const;
 
  void add_backend(const std::string& name, const mapstringstring_t& fields);
 
  void delete_backend(const std::string& name);
 
  bool check_backend(const std::string& name) const;
 
  bool check_all_backends() const;
 
  void take_run_files(int run = 0, const std::string& fromname = "", const std::string& toname = "") const;
 
  void set_current_run(unsigned int run = 0);
 
  unsigned int current_run() const;
 
  pugi::xpath_node_set select_nodes(const std::string& xpath_query, int run = 0) const;
  std::vector<std::string> xpath_search(const std::string& xpath_query, const std::string& attribute = "",
                                        int run = 0) const;
};
 
bool check_backends(const std::string& suffix);
 
std::filesystem::path expand_path(const std::filesystem::path& path, const std::string& suffix = "");
 
std::string xmlRepair(const std::string& source, const mapstringstring_t& injections = {});
 
std::string version() noexcept;
 
class runtime_error : public std::runtime_error {
  using std::runtime_error::runtime_error;
};
 
} // namespace sjef
 
#endif // SJEF_SJEF_H