file.cpp

Go to the documentation of this file.

#define _OksBuildDll_
 
#include "oks/file.hpp"
#include "oks/kernel.hpp"
#include "oks/xml.hpp"
#include "oks/cstring.hpp"
 
#include "oks_utils.hpp"
 
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
 
#include <fstream>
#include <sstream>
#include <stdexcept>
 
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/date_time/posix_time/time_formatters.hpp>
#include <boost/date_time/posix_time/time_parsers.hpp>
#include <boost/interprocess/sync/file_lock.hpp>
 
#include "ers/ers.hpp"
#include "logging/Logging.hpp"
 
namespace dunedaq {
namespace oks {
  // Nasty hack to allow code generation on the fly without locking
  // file. Off by default
  bool OksFile::p_nolock_mode = false;
    //
    // Define XML formats used to store OKS schema and data files
    //
 
const char OksFile::xml_info_tag[]     = "info";
const char OksFile::xml_include_tag[]  = "include";
const char OksFile::xml_file_tag[]     = "file";
const char OksFile::xml_comments_tag[] = "comments";
const char OksFile::xml_comment_tag[]  = "comment";
 
const char OksFile::xml_file_header[]  = "<?xml version=\"1.0\" encoding=\"ASCII\"?>";
 
const char OksFile::xml_schema_file_dtd[] =
  "<!DOCTYPE oks-schema [\n"
 
  "  <!ELEMENT oks-schema (info, (include)?, (comments)?, (class)+)>\n"
 
  "  <!ELEMENT info EMPTY>\n"
  "  <!ATTLIST info\n"
  "      name CDATA #IMPLIED\n"
  "      type CDATA #IMPLIED\n"
  "      num-of-items CDATA #REQUIRED\n"
  "      oks-format CDATA #FIXED \"schema\"\n"
  "      oks-version CDATA #REQUIRED\n"
  "      created-by CDATA #IMPLIED\n"
  "      created-on CDATA #IMPLIED\n"
  "      creation-time CDATA #IMPLIED\n"
  "      last-modified-by CDATA #IMPLIED\n"
  "      last-modified-on CDATA #IMPLIED\n"
  "      last-modification-time CDATA #IMPLIED\n"
  "  >\n"
 
  "  <!ELEMENT include (file)+>\n"
  "  <!ELEMENT file EMPTY>\n"
  "  <!ATTLIST file\n"
  "      path CDATA #REQUIRED\n"
  "  >\n"
 
  "  <!ELEMENT comments (comment)+>\n"
  "  <!ELEMENT comment EMPTY>\n"
  "  <!ATTLIST comment\n"
  "      creation-time CDATA #REQUIRED\n"
  "      created-by CDATA #REQUIRED\n"
  "      created-on CDATA #REQUIRED\n"
  "      author CDATA #REQUIRED\n"
  "      text CDATA #REQUIRED\n"
  "  >\n"
 
  "  <!ELEMENT class (superclass | attribute | relationship | method)*>\n"
  "  <!ATTLIST class\n"
  "      name CDATA #REQUIRED\n"
  "      description CDATA \"\"\n"
  "      is-abstract (yes|no) \"no\"\n"
  "  >\n"
 
  "  <!ELEMENT superclass EMPTY>\n"
  "  <!ATTLIST superclass name CDATA #REQUIRED>\n"
 
  "  <!ELEMENT attribute EMPTY>\n"
  "  <!ATTLIST attribute\n"
  "      name CDATA #REQUIRED\n"
  "      description CDATA \"\"\n"
  "      type (bool|s8|u8|s16|u16|s32|u32|s64|u64|float|double|date|time|string|uid|enum|class) #REQUIRED\n"
  "      range CDATA \"\"\n"
  "      format (dec|hex|oct) \"dec\"\n"
  "      is-multi-value (yes|no) \"no\"\n"
  "      init-value CDATA \"\"\n"
  "      is-not-null (yes|no) \"no\"\n"
  "      ordered (yes|no) \"no\"\n"
  "  >\n"
 
  "  <!ELEMENT relationship EMPTY>\n"
  "  <!ATTLIST relationship\n"
  "      name CDATA #REQUIRED\n"
  "      description CDATA \"\"\n"
  "      class-type CDATA #REQUIRED\n"
  "      low-cc (zero|one) #REQUIRED\n"
  "      high-cc (one|many) #REQUIRED\n"
  "      is-composite (yes|no) #REQUIRED\n"
  "      is-exclusive (yes|no) #REQUIRED\n"
  "      is-dependent (yes|no) #REQUIRED\n"
  "      ordered (yes|no) \"no\"\n"
  "  >\n"
 
  "  <!ELEMENT method (method-implementation*)>\n"
  "  <!ATTLIST method\n"
  "      name CDATA #REQUIRED\n"
  "      description CDATA \"\"\n"
  "  >\n"
 
  "  <!ELEMENT method-implementation EMPTY>\n"
  "  <!ATTLIST method-implementation\n"
  "      language CDATA #REQUIRED\n"
  "      prototype CDATA #REQUIRED\n"
  "      body CDATA \"\"\n"
  "  >\n"
 
  "]>";
 
const char OksFile::xml_data_file_dtd[] =
  "<!DOCTYPE oks-data [\n"
 
  "  <!ELEMENT oks-data (info, (include)?, (comments)?, (obj)+)>\n"
 
  "  <!ELEMENT info EMPTY>\n"
  "  <!ATTLIST info\n"
  "      name CDATA #IMPLIED\n"
  "      type CDATA #IMPLIED\n"
  "      num-of-items CDATA #REQUIRED\n"
  "      oks-format CDATA #FIXED \"data\"\n"
  "      oks-version CDATA #REQUIRED\n"
  "      created-by CDATA #IMPLIED\n"
  "      created-on CDATA #IMPLIED\n"
  "      creation-time CDATA #IMPLIED\n"
  "      last-modified-by CDATA #IMPLIED\n"
  "      last-modified-on CDATA #IMPLIED\n"
  "      last-modification-time CDATA #IMPLIED\n"
  "  >\n"
 
  "  <!ELEMENT include (file)*>\n"
  "  <!ELEMENT file EMPTY>\n"
  "  <!ATTLIST file\n"
  "      path CDATA #REQUIRED\n"
  "  >\n"
 
  "  <!ELEMENT comments (comment)*>\n"
  "  <!ELEMENT comment EMPTY>\n"
  "  <!ATTLIST comment\n"
  "      creation-time CDATA #REQUIRED\n"
  "      created-by CDATA #REQUIRED\n"
  "      created-on CDATA #REQUIRED\n"
  "      author CDATA #REQUIRED\n"
  "      text CDATA #REQUIRED\n"
  "  >\n"
 
  "  <!ELEMENT obj (attr | rel)*>\n"
  "  <!ATTLIST obj\n"
  "      class CDATA #REQUIRED\n"
  "      id CDATA #REQUIRED\n"
  "  >\n"
  "  <!ELEMENT attr (data)*>\n"
  "  <!ATTLIST attr\n"
  "      name CDATA #REQUIRED\n"
  "      type (bool|s8|u8|s16|u16|s32|u32|s64|u64|float|double|date|time|string|uid|enum|class|-) \"-\"\n"
  "      val CDATA \"\"\n"
  "  >\n"
  "  <!ELEMENT data EMPTY>\n"
  "  <!ATTLIST data\n"
  "      val CDATA #REQUIRED\n"
  "  >\n"
  "  <!ELEMENT rel (ref)*>\n"
  "  <!ATTLIST rel\n"
  "      name CDATA #REQUIRED\n"
  "      class CDATA \"\"\n"
  "      id CDATA \"\"\n"
  "  >\n"
  "  <!ELEMENT ref EMPTY>\n"
  "  <!ATTLIST ref\n"
  "      class CDATA #REQUIRED\n"
  "      id CDATA #REQUIRED\n"
  "  >\n"
  "]>";
 
 
  std::string
  FailedAddInclude::fill(const OksFile& file, const std::string& include_name, const std::string& reason) noexcept
  {
    return ( std::string("Failed to add include \'") + include_name + "\' to file \'" + file.get_full_file_name() + "\' because:\n" + reason);
  }
 
  std::string
  FailedRemoveInclude::fill(const OksFile& file, const std::string& include_name, const std::string& reason) noexcept
  {
    return ( std::string("Failed to remove include \'") + include_name + "\' from file \'" + file.get_full_file_name() + "\' because:\n" + reason);
  }
 
  std::string
  FailedRenameInclude::fill(const OksFile& file, const std::string& from, const std::string& to, const std::string& reason) noexcept
  {
    return ( std::string("Failed to rename include of \'") + file.get_full_file_name() + "\' from \'" + from + "\' to \'" + to + "\' because:\n" + reason);
  }
 
  std::string
  FailedAddComment::fill(const OksFile& file, const std::string& reason) noexcept
  {
    return ( std::string("Failed to add new comment to file \'") + file.get_full_file_name() + "\' because:\n" + reason);
  }
 
  std::string
  FailedRemoveComment::fill(const OksFile& file, const std::string& creation_time, const std::string& reason) noexcept
  {
    return ( std::string("Failed to remove comment created at \'") + creation_time + "\' from file \'" + file.get_full_file_name() + "\' because:\n" + reason);
  }
 
  std::string
  FailedChangeComment::fill(const OksFile& file, const std::string& creation_time, const std::string& reason) noexcept
  {
    return ( std::string("Failed to change comment created at \'") + creation_time + "\' from file \'" + file.get_full_file_name() + "\' because:\n" + reason);
  }
 
  std::string
  FileLockError::fill(const OksFile& file, bool lock_action, const std::string& reason) noexcept
  {
    return ( std::string("Failed to ") + (lock_action ? "" : "un") + "lock file \'" + file.get_full_file_name() + "\' because:\n" + reason);
  }
 
  std::string
  FileChangeError::fill(const OksFile& file, const std::string& action, const std::string& reason) noexcept
  {
    return ( std::string("Failed to ") + action + " of file \'" + file.get_full_file_name() + "\' because:\n" + reason);
  }
 
  std::string
  FileCompareError::fill(const std::string& src, const std::string& dest, const std::string& reason) noexcept
  {
    return ( std::string("Failed to compare file \'") + src + "\' with \'" + dest + "\' because:\n" + reason);
  }
 
 
OksFile::OksFile(const std::string& s, const std::string& ln, const std::string& ft, const std::string& ff, OksKernel * k) :
 p_short_name               (s),
 p_full_name                (s),
 p_logical_name             (ln),
 p_type                     (ft),
 p_oks_format               (ff),
 p_number_of_items          (0),
 p_size                     (0),
 p_created_by               (OksKernel::get_user_name()),
 p_creation_time            (boost::posix_time::second_clock::universal_time()),
 p_created_on               (OksKernel::get_host_name()),
 p_last_modification_time   (p_creation_time),
 p_lock                     (),
 p_is_updated               (false),
 p_is_read_only             (true),
 p_last_modified            (0),
 p_repository_last_modified (0),
 p_is_on_disk               (false),
 p_included_by              (0),
 p_kernel                   (k)
{
  p_last_modified_on = p_created_on;
  p_last_modified_by = p_created_by;
  create_lock_name();
  check_repository();
}
 
void
OksFile::clear_comments() noexcept
{
  for(std::map<std::string, oks::Comment *>::iterator i = p_comments.begin(); i != p_comments.end(); ++i) {
    delete i->second;
  }
 
  p_comments.clear();
}
 
 
OksFile::~OksFile() noexcept
{
  clear_comments();
}
 
OksFile&
OksFile::operator=(const OksFile & f)
{
  if (&f != this)
    {
      p_list_of_include_files.clear();
      clear_comments();
 
      p_short_name = f.p_short_name;
      p_full_name = f.p_full_name;
//      p_repository = f.p_repository;
      p_repository_name = f.p_repository_name;
      p_logical_name = f.p_logical_name;
      p_type = f.p_type;
      p_oks_format = f.p_oks_format;
      p_number_of_items = f.p_number_of_items;
      p_size = f.p_size;
      p_created_by = f.p_created_by;
      p_creation_time = f.p_creation_time;
      p_created_on = f.p_created_on;
      p_last_modified_by = f.p_last_modified_by;
      p_last_modification_time = f.p_last_modification_time;
      p_last_modified_on = f.p_last_modified_on;
      p_open_mode = f.p_open_mode;
      p_is_updated = f.p_is_updated;
      p_lock = f.p_lock;
      p_is_read_only = f.p_is_read_only;
      p_lock_file_name = f.p_lock_file_name;
      p_list_of_include_files = f.p_list_of_include_files;
      p_last_modified = f.p_last_modified;
      p_repository_last_modified = f.p_repository_last_modified;
      p_is_on_disk = f.p_is_on_disk;
      p_included_by = f.p_included_by;
      p_kernel = f.p_kernel;
 
      for (const auto& i : f.p_comments)
        {
          p_comments[i.first] = new oks::Comment(*i.second);
        }
    }
 
  return *this;
}
 
 
  // read xml-file header from file
 
const char _empty_str[] = "empty";
 
OksFile::OksFile(std::shared_ptr<OksXmlInputStream> xmls, const std::string& sp, const std::string& fp, OksKernel * k) :
 p_short_name               (sp),
 p_full_name                (fp),
 p_oks_format               (_empty_str, sizeof(_empty_str)-1),
 p_creation_time            (boost::posix_time::not_a_date_time),
 p_last_modification_time   (boost::posix_time::not_a_date_time),
 p_lock                     (),
 p_is_updated               (false),
 p_is_read_only             (true),
 p_last_modified            (0),
 p_repository_last_modified (0),
 p_is_on_disk               (true),
 p_included_by              (0),
 p_kernel                   (k)
{
  const char * fname = "OksFile::OksFile()";
 
//  create_lock_name();
  check_repository();
 
 
    // check file header
 
  try {
 
      // skip an xml file header
 
    {
      const char * tag_start = xmls->get_tag_start();
 
      if(!oks::cmp_str4(tag_start, "?xml")) {
        xmls->throw_unexpected_tag(tag_start, "?xml");
      }
    }
 
      // skip possible tag attributes
 
    while(true) {
      OksXmlAttribute attr(*xmls);
 
        // check for close of tag
 
      if(
        oks::cmp_str1(attr.name(), ">") ||
        oks::cmp_str1(attr.name(), "/") ||
    oks::cmp_str1(attr.name(), "?")
      ) { break; }
 
        // check for start of info tag
 
      if(!oks::cmp_str7(attr.name(), "version") && !oks::cmp_str8(attr.name(), "encoding")) {
        if(!p_kernel->get_silence_mode()) {
          Oks::warning_msg(fname) << "  Unexpected attribute \'" << attr.name() << "\' in the xml file header. Either \'version\' or \'encoding\' is expected.\n";
        }
      }
    }
 
  }
  catch (oks::exception & e) {
    throw oks::FailedRead("an xml file header", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("an xml file header", e.what());
  }
 
 
    // skip document type declaration and comments
 
  {
    while(true) {
      try {
        const char * dtd = xmls->get_tag();
        const char dtd_start[] = "<!DOCTYPE ";
        if(!strncmp(dtd_start, dtd, sizeof(dtd_start) - 1)) {
          break;
        }
      }
      catch (oks::exception & e) {
        throw oks::FailedRead("DTD section", e);
      }
      catch (std::exception & e) {
        throw oks::FailedRead("DTD section", e.what());
      }
    }
  }
 
 
    // skip
 
  try {
    xmls->store_position();
 
    const char * a_tag = xmls->get_tag();
 
    const char xml_stylesheet_start[] = "<?xml-stylesheet";
    if(strncmp(xml_stylesheet_start, a_tag, sizeof(xml_stylesheet_start) - 1)) {
      xmls->restore_position();
    }
  }
  catch (oks::exception & e) {
    throw oks::FailedRead("an xml-stylesheet tag or an oks tag", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("an xml-stylesheet tag or an oks tag", e.what());
  }
 
    // read start-of-tag
 
  try {
    xmls->get_tag_start();
  }
  catch (oks::exception & e) {
    throw oks::FailedRead("tag", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("tag", e.what());
  }
 
 
    // read info tag
 
  try {
    const char * tag_start = xmls->get_tag_start();
 
    if(!oks::cmp_str4(tag_start, xml_info_tag)) {
      xmls->throw_unexpected_tag(tag_start, xml_info_tag);
    }
  }
  catch (oks::exception & e) {
    throw oks::FailedRead("<info> tag", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("<info> tag", e.what());
  }
 
 
  std::string oks_version;
 
 
    // read class attributes
 
  try {
    while(true) {
      OksXmlAttribute attr(*xmls);
 
        // check for close of tag
 
      if(oks::cmp_str1(attr.name(), ">") || oks::cmp_str1(attr.name(), "/")) { break; }
 
        // check for known info' attributes
 
      else if(oks::cmp_str4 (attr.name(), "name"))             p_logical_name.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str4 (attr.name(), "type"))             p_type.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str10(attr.name(), "oks-format"))       p_oks_format.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str10(attr.name(), "created-by"))       p_created_by.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str10(attr.name(), "created-on"))       p_created_on.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str11(attr.name(), "oks-version"))      oks_version.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str12(attr.name(), "num-of-items"))     p_number_of_items = atol(attr.value());
      else if(oks::cmp_str13(attr.name(), "creation-time"))    p_creation_time = oks::str2time(attr.value(), attr.value_len(), p_full_name.c_str());
      else if(oks::cmp_str15(attr.name(), "num-of-includes"))  continue; // ignore this value
      else if(oks::cmp_str16(attr.name(), "last-modified-by")) p_last_modified_by.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str16(attr.name(), "last-modified-on")) p_last_modified_on.assign(attr.value(), attr.value_len());
      else if(!strcmp(attr.name(), "last-modification-time"))  p_last_modification_time = oks::str2time(attr.value(), attr.value_len(), p_full_name.c_str());
      else {
    p_oks_format.clear();
    xmls->throw_unexpected_tag(attr.name(), "info\'s tags");
      }
    }
  }
  catch(oks::exception & e) {
    throw oks::FailedRead("<info> tag attribute", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("<info> tag attribute", e.what());
  }
 
    // read include and comments sections
  while(true) {
    xmls->store_position();
 
    bool read_include = false;
 
    try {
      const char * tag_start = xmls->get_tag_start();
      if(oks::cmp_str7(tag_start, xml_include_tag)) { read_include = true; }
      else if(oks::cmp_str8(tag_start, xml_comments_tag)) { read_include = false; }
      else { xmls->restore_position(); return; }
    }
    catch (oks::exception & e) {
      throw oks::FailedRead("a tag", e);
    }
    catch (std::exception & e) {
      throw oks::FailedRead("a tag", e.what());
    }
 
    if(read_include) {
      while(true) {
        try {
    
          {
        const char * tag_start = xmls->get_tag_start();
            if(!oks::cmp_str4(tag_start, xml_file_tag)) {
          if(!oks::cmp_str8(tag_start, "/include")) { xmls->throw_unexpected_tag(tag_start + 1, xml_file_tag); }
          break;
            }
          }
 
          while(true) {
            OksXmlAttribute attr(*xmls);
 
              // check for close of tag
            if(oks::cmp_str1(attr.name(), ">") || oks::cmp_str1(attr.name(), "/")) { break; }
 
              // check for known info' attributes
            else if(oks::cmp_str4(attr.name(), "path")) p_list_of_include_files.push_back(std::string(attr.value(),attr.value_len()));
            else {
              p_oks_format.clear();
          xmls->throw_unexpected_tag(attr.name(), "path");
            }
          }
 
        }
        catch (oks::exception & e) {
          throw oks::FailedRead("<file> tag", e);
        }
        catch (std::exception & e) {
          throw oks::FailedRead("<file> tag", e.what());
        }
      }
    }
    else {
      while(true) {
        try {
 
          {
        const char * tag_start = xmls->get_tag_start();
            if(!oks::cmp_str7(tag_start, xml_comment_tag)) {
          if(!oks::cmp_str9(tag_start, "/comments")) { xmls->throw_unexpected_tag(tag_start, xml_comment_tag); }
          return;
            }
          }
 
      std::unique_ptr<oks::Comment> comment( new oks::Comment() );
      std::string creation_time;
 
          while(true) {
            OksXmlAttribute attr(*xmls);
 
              // check for close of tag
            if(oks::cmp_str1(attr.name(), ">") || oks::cmp_str1(attr.name(), "/")) { break; }
 
              // check for known info' attributes
            else if(oks::cmp_str4 (attr.name(), "text"))          comment->p_text.assign(attr.value(), attr.value_len());
            else if(oks::cmp_str6 (attr.name(), "author"))        comment->p_author.assign(attr.value(), attr.value_len());
            else if(oks::cmp_str10(attr.name(), "created-by"))    comment->p_created_by.assign(attr.value(), attr.value_len());
            else if(oks::cmp_str10(attr.name(), "created-on"))    comment->p_created_on.assign(attr.value(), attr.value_len());
            else if(oks::cmp_str13(attr.name(), "creation-time")) creation_time.assign(attr.value(), attr.value_len());
            else {
              p_oks_format.clear();
          xmls->throw_unexpected_tag(attr.name(), "comment\'s tags");
            }
          }
 
          comment->validate(creation_time);
 
          if(p_comments.find(creation_time) != p_comments.end()) {
            std::ostringstream text;
            text << "The comment created at \'" << creation_time << "\' was already defined in this file";
            throw std::runtime_error(text.str().c_str());
          }
 
      p_comments[creation_time] = comment.release();
 
        }
        catch (oks::exception & e) {
          throw oks::FailedRead("<comment>", e);
        }
        catch (std::exception & e) {
          throw oks::FailedRead("<comment>", e.what());
        }
      }
    }
  }
}
 
 
void
oks::Comment::validate(const std::string& creation_time)
{
    // YYYYMMDDThhmmss
  if( creation_time.size() != 15 || creation_time[8] != 'T' ) {
    std::ostringstream msg;
    msg << "the creation time \'" << creation_time << "\' is not an ISO-8601 date-time";
    throw std::runtime_error(msg.str().c_str());
  }
 
  validate();
}
 
void
oks::Comment::validate()
{
  if(p_text.empty()) {
    throw std::runtime_error("text is empty");
  }
}
 
oks::Comment::Comment(const std::string& text, const std::string& author) :
  p_created_by  (OksKernel::get_user_name()),
  p_author      (author),
  p_created_on  (OksKernel::get_host_name()),
  p_text        (text)
{
  validate();
}
 
oks::Comment::Comment(const oks::Comment& src) noexcept :
  p_created_by  (src.p_created_by),
  p_author      (src.p_author),
  p_created_on  (src.p_created_on),
  p_text        (src.p_text)
{
}
 
void
OksFile::add_comment(const std::string& text, const std::string& author)
{
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FailedAddComment(*this, ex);
  }
 
  boost::posix_time::ptime now = boost::posix_time::second_clock::universal_time();
  std::string creation_time = boost::posix_time::to_iso_string(now);
 
  try {
    std::unique_ptr<oks::Comment> comment( new oks::Comment(text, author) );
    comment->validate();
 
    oks::Comment *& x(p_comments[creation_time]);
 
    if(x == 0)
      {
        x = comment.release();
      }
    else
      {
        x->p_text += "\n-----\n";
        x->p_text.append(text);
      }
  }
  catch(std::exception & ex) {
    throw oks::FailedAddComment(*this, ex.what());
  }
 
  p_is_updated = true;
}
 
oks::Comment *
OksFile::get_comment(const std::string& creation_time) noexcept
{
  std::map<std::string, oks::Comment *>::const_iterator i = p_comments.find(creation_time);
  return (i == p_comments.end()) ? 0: i->second;
}
 
void
OksFile::modify_comment(const std::string& creation_time, const std::string& text, const std::string& author)
{
  if(oks::Comment * comment = get_comment(creation_time)) {
    try {
      lock();
    }
    catch(oks::exception& ex) {
      throw oks::FailedChangeComment(*this, creation_time, ex);
    }
 
    std::string saved_author(comment->p_author);
    std::string saved_text(comment->p_text);
 
    comment->p_author = author;
    comment->p_text = text;
 
    try {
      comment->validate();
    }
    catch(std::exception& ex) {
      comment->p_author = saved_author;
      comment->p_text = saved_text;
      throw oks::FailedChangeComment(*this, creation_time, ex.what());
    }
 
    p_is_updated = true;
  }
  else {
    throw oks::FailedChangeComment(*this, creation_time, "cannot find comment");
  }
}
 
 
void
OksFile::remove_comment(const std::string& creation_time)
{
  if(oks::Comment * comment = get_comment(creation_time)) {
    try {
      lock();
    }
    catch(oks::exception& ex) {
      throw oks::FailedRemoveComment(*this, creation_time, ex);
    }
 
    delete comment;
    p_comments.erase(creation_time);
    p_is_updated = true;
  }
  else {
    throw oks::FailedRemoveComment(*this, creation_time, "cannot find comment");
  }
}
 
 
void
OksFile::write(OksXmlOutputStream& xmls)
{
  const static std::string __data("data");
  const static std::string __schema("schema");
 
  try
    {
      const char __oks_data[] = "oks-data";
      const char __oks_schema[] = "oks-schema";
 
      const char * id(__oks_data);
      long id_len(sizeof(__oks_data) - 1);
      const char * dtd(xml_data_file_dtd);
      long dtd_len(sizeof(xml_data_file_dtd) - 1);
 
      if (p_oks_format != __data)
        {
          if (p_oks_format == __schema)
            {
              id = __oks_schema;
              id_len = sizeof(__oks_schema) - 1;
              dtd = xml_schema_file_dtd;
              dtd_len = sizeof(xml_schema_file_dtd) - 1;
            }
          else
            {
              throw std::runtime_error("bad oks format");
            }
        }
 
        {
          const char __hdr_start[] = "\n\n<!-- ";
          const char __hdr_end[] = " version 2.2 -->\n\n\n";
 
          std::string header(xml_file_header, sizeof(xml_file_header) - 1);
          header.append(__hdr_start, sizeof(__hdr_start) - 1);
          header.append(id, id_len);
          header.append(__hdr_end, sizeof(__hdr_end) - 1);
          header.append(dtd, dtd_len);
 
          xmls.put_raw(header.c_str(), header.size());
          xmls.put_raw('\n');
          xmls.put_raw('\n');
        }
 
      xmls.put_start_tag(id, id_len);
 
      xmls.put_raw('>');
      xmls.put_raw('\n');
      xmls.put_raw('\n');
 
      // "creation-time" may not be filled
 
      std::string created_c_str;
      if (!p_creation_time.is_not_a_date_time())
        {
          created_c_str = boost::posix_time::to_iso_string(p_creation_time);
        }
 
      // get last-modified information
 
      if (p_repository_name.empty())
        {
          p_last_modification_time = boost::posix_time::second_clock::universal_time();
          p_last_modified_by = OksKernel::get_user_name();
          p_last_modified_on = OksKernel::get_host_name();
        }
 
      std::string last_modified_c_str = boost::posix_time::to_iso_string(p_last_modification_time);
 
      xmls.put_start_tag(xml_info_tag, sizeof(xml_info_tag) - 1);
      xmls.put_attribute("name", sizeof("name") - 1, p_logical_name.c_str());
      xmls.put_attribute("type", sizeof("type") - 1, p_type.c_str());
      xmls.put_attribute("num-of-items", sizeof("num-of-items") - 1, p_number_of_items);
      xmls.put_attribute("oks-format", sizeof("oks-format") - 1, p_oks_format.c_str());
      xmls.put_attribute("oks-version", sizeof("oks-version") - 1, OksKernel::GetVersion());
      xmls.put_attribute("created-by", sizeof("created-by") - 1, p_created_by.c_str());
      xmls.put_attribute("created-on", sizeof("created-on") - 1, p_created_on.c_str());
      if (!created_c_str.empty())
        xmls.put_attribute("creation-time", sizeof("creation-time") - 1, created_c_str.c_str());
      if (p_repository_name.empty())
        {
          xmls.put_attribute("last-modified-by", sizeof("last-modified-by") - 1, p_last_modified_by.c_str());
          xmls.put_attribute("last-modified-on", sizeof("last-modified-on") - 1, p_last_modified_on.c_str());
          xmls.put_attribute("last-modification-time", sizeof("last-modification-time") - 1, last_modified_c_str.c_str());
        }
      xmls.put_end_tag();
 
      if (!p_list_of_include_files.empty())
        {
          xmls.put_raw('\n');
          xmls.put_start_tag(xml_include_tag, sizeof(xml_include_tag) - 1);
 
          xmls.put_raw('>');
          xmls.put_raw('\n');
 
          for (const auto& i : p_list_of_include_files)
            {
              xmls.put_raw(' ');
              xmls.put_start_tag(xml_file_tag, sizeof(xml_file_tag) - 1);
              xmls.put_attribute("path", sizeof("path") - 1, i.c_str());
              xmls.put_end_tag();
            }
 
          xmls.put_last_tag(xml_include_tag, sizeof(xml_include_tag) - 1);
          xmls.put_raw('\n');
        }
 
      if (!p_comments.empty())
        {
          xmls.put_start_tag(xml_comments_tag, sizeof(xml_comments_tag) - 1);
 
          xmls.put_raw('>');
          xmls.put_raw('\n');
 
          for (const auto& i : p_comments)
            {
              xmls.put_raw(' ');
              xmls.put_start_tag(xml_comment_tag, sizeof(xml_comment_tag) - 1);
              xmls.put_attribute("creation-time", sizeof("creation-time") - 1, i.first.c_str());
              xmls.put_attribute("created-by", sizeof("created-by") - 1, i.second->p_created_by.c_str());
              xmls.put_attribute("created-on", sizeof("created-on") - 1, i.second->p_created_on.c_str());
              xmls.put_attribute("author", sizeof("author") - 1, i.second->p_author.c_str());
              xmls.put_attribute("text", sizeof("text") - 1, i.second->p_text.c_str());
              xmls.put_end_tag();
            }
 
          xmls.put_last_tag(xml_comments_tag, sizeof(xml_comments_tag) - 1);
          xmls.put_raw('\n');
        }
 
      xmls.put_raw('\n');
    }
  catch (std::exception& ex)
    {
      throw oks::FailedSave("oks-file", p_full_name, ex.what());
    }
 
  p_is_on_disk = true;
}
 
bool
OksFile::is_repository_file() const
{
  return (!p_kernel->get_user_repository_root().empty());
}
 
void
OksFile::check_repository()
{
//  if(size_t len = OksKernel::get_repository_root().size()) {
//    if(p_full_name.size() > len && p_full_name.substr(0, len) == OksKernel::get_repository_root()) {
//      p_repository = GlobalRepository;
//      p_repository_name = p_full_name.substr(len + 1);
//      TLOG_DEBUG( 3 ) << "file \'" << p_full_name << "\' comes from user repository [\'" << p_repository_name << "\']";
//      return;
//    }
//  }
 
  const std::string& s(p_kernel->get_user_repository_root());
  if(size_t len = s.size()) {
    if(p_full_name.size() > len && p_full_name.substr(0, len) == s) {
//      p_repository = UserRepository;
      p_repository_name = p_full_name.substr(len + 1);
 
      TLOG_DEBUG( 3 ) << "file \'" << p_full_name << "\' comes from user repository [\'" << p_repository_name << "\']" ;
      return;
 
//      std::string repository_file = OksKernel::get_repository_root() + '/' + p_repository_name;
//
//      struct stat buf;
//      if(stat(repository_file.c_str(), &buf) == 0) {
//        TLOG_DEBUG( 3 ) << "file \'" << p_full_name << "\' comes from user repository [\'" << p_repository_name << "\']" ;
//        return;
//      }
//      else {
//        TLOG_DEBUG( 3 ) << "file \'" << p_full_name << "\' is found in user repository [\'" << p_repository_name << "\'] but does not exist in global one [\'" << OksKernel::get_repository_root() << "\']" ;
//      }
    }
  }
 
  TLOG_DEBUG( 3 ) << "file \'" << p_full_name << "\' is not in a repository" ;
//  p_repository = NoneRepository;
  p_repository_name.clear();
}
 
void
OksFile::create_lock_name()
{
  p_lock_file_name = p_full_name;
 
  std::string::size_type idx = p_lock_file_name.find_last_of('/');
  if(idx == std::string::npos) p_lock_file_name = "./";
  else p_lock_file_name.erase(idx+1);
 
  const char _prefix_str[] = ".oks-lock-";
  p_lock_file_name.append(_prefix_str, sizeof(_prefix_str)-1);
 
  idx = p_full_name.find_last_of('/');
  std::string::size_type len(p_full_name.size());
  if(idx == std::string::npos) {
    idx = 0;
  }
  else {
    idx++;
    len -= idx;
  }
 
  p_lock_file_name.append(p_full_name, idx, len);
  p_lock_file_name.append(".txt");
}
 
 
  // return true if lock exists and false if does not exist
  // the string is non-empty, if the lock file was read
 
bool
OksFile::get_lock_string(std::string& lock_file_contents) const
{
  init_lock_name();
 
  lock_file_contents.clear();
 
  const char * lock_name = p_lock_file_name.c_str();
  struct stat buf;
 
  if(stat(lock_name, &buf) == 0) {
    std::ifstream f(lock_name);
 
    if(f.good()) {
      std::getline(f, lock_file_contents);
      return true;
    }
    else {
      lock_file_contents = "unknown [cannot read lock file \'";
      lock_file_contents += p_lock_file_name;
      lock_file_contents += "\']";
      return true;
    }
  }
 
  return false;
}
 
void
OksFile::lock()
{
  if (p_nolock_mode) {
    // Nasty hack to allow code generation on the fly without locking
    // file. Just return without locking!
    return;
  }
 
  init_lock_name();
 
  if (p_lock != nullptr)
    {
      return;
    }
 
 
    // check that the file is not read-only
 
    {
      struct stat buf;
 
      if (stat(p_full_name.c_str(), &buf) == 0)
        {
          if (OksKernel::check_read_only(this) == true)
            {
              throw oks::FileLockError(*this, true, "file is read-only");
            }
        }
    }
 
 
    // check lock and report problem if it exists and cannot be reset
 
    {
      std::string lock_file_contents;
 
      if (get_lock_string(lock_file_contents))
        {
          try
            {
              boost::interprocess::file_lock lock(p_lock_file_name.c_str());
 
              if (lock.try_lock() == false)
                {
                  std::ostringstream text;
                  text << "file is already locked by \"" << lock_file_contents << '\"';
                  throw oks::FileLockError(*this, true, text.str());
                }
              else
                {
                  try
                    {
                      lock.unlock();
                    }
                  catch (const boost::interprocess::interprocess_exception& ex)
                    {
                      std::ostringstream text;
                      text << "boost::interprocess::unlock() failed: \"" << ex.what() << '\"';
                      throw oks::FileLockError(*this, false, text.str());
                    }
 
                  if (!p_kernel->get_silence_mode())
                    {
                      Oks::warning_msg("OksFile::lock()") << "Remove obsolete lock of file \'" << p_full_name << "\' created by \n\"" << lock_file_contents << "\"\n";
                    }
 
                  if (unlink(p_lock_file_name.c_str()) != 0)
                    {
                      std::ostringstream text;
                      text << "failed to remove lock file \'" << p_lock_file_name << "\':\n" << oks::strerror(errno);
                      throw oks::FileLockError(*this, false, text.str());
                    }
                }
            }
          catch (const boost::interprocess::interprocess_exception& ex)
            {
              std::ostringstream text;
              text << "boost::interprocess::try_lock() failed: \"" << ex.what() << '\"';
              throw oks::FileLockError(*this, false, text.str());
            }
        }
    }
 
 
    // write lock file
 
    {
      std::ofstream f(p_lock_file_name.c_str());
 
      if (!f.good())
        {
          std::ostringstream text;
          text << "failed to create lock file \'" << p_lock_file_name << '\'';
          throw oks::FileLockError(*this, true, text.str());
        }
 
      try
        {
          boost::posix_time::ptime now(boost::posix_time::second_clock::universal_time());
          f << "process " << getpid() << " on " << OksKernel::get_host_name() << " started by " << OksKernel::get_user_name() << " at " << boost::posix_time::to_simple_string(now) << " (UTC)" << std::endl;
          f.flush();
          f.close();
        }
      catch (std::exception& ex)
        {
          std::ostringstream text;
          text << "failed to write lock file \'" << p_lock_file_name << "\': " << ex.what();
          throw oks::FileLockError(*this, true, text.str());
        }
    }
 
 
  try
    {
      p_lock.reset(new boost::interprocess::file_lock(p_lock_file_name.c_str()));
 
      if (p_lock->try_lock() == false)
        {
          throw std::runtime_error("file is locked by another process");
        }
    }
  catch (const std::exception& ex)
    {
      std::ostringstream text;
      text << "boost::interprocess::try_lock() failed: \"" << ex.what() << '\"';
      p_lock.reset();
      throw oks::FileLockError(*this, false, text.str());
    }
}
 
void
OksFile::unlock()
{
  if (p_lock == nullptr)
    return;
 
  try
    {
      p_lock->unlock();
    }
  catch (const boost::interprocess::interprocess_exception& ex)
    {
      std::ostringstream text;
      text << "boost::interprocess::unlock() failed: \"" << ex.what() << '\"';
      p_lock.reset();
      throw oks::FileLockError(*this, false, text.str());
    }
 
  p_lock.reset();
 
  if (unlink(p_lock_file_name.c_str()) != 0 && errno != ENOENT)
    {
      std::ostringstream text;
      text << "failed to remove lock file \'" << p_lock_file_name << "\':\n" << oks::strerror(errno);
      throw oks::FileLockError(*this, false, text.str());
    }
}
 
 
std::list<std::string>::iterator
OksFile::find_include_file(const std::string& s)
{
  std::list<std::string>::iterator i = p_list_of_include_files.begin();
 
  for(;i != p_list_of_include_files.end(); ++i) {if(*i == s) break;}
 
  return i;
}
 
 
OksFile *
OksFile::check_parent(const OksFile * parent_h)
{
  if(p_included_by == 0 && parent_h != 0) {
    p_included_by = parent_h;
  }
 
  return this;
}
 
 
void
OksFile::add_include_file(const std::string& s)
{
    // check if the file was already included
  if(find_include_file(s) != p_list_of_include_files.end()) { return; }
 
    // lock file
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FailedAddInclude(*this, s, ex);
  }
 
    // try to find path to include and load it
  try {
    std::string path = p_kernel->get_file_path(s, this);
    p_kernel->k_load_file(path, true, this, 0);
  }
  catch(std::exception& ex) {
    throw oks::FailedAddInclude(*this, s, ex.what());
  }
 
    // add include and mark file as updated
  p_list_of_include_files.push_back(s);
  p_is_updated = true;
}
 
 
void
OksFile::remove_include_file(const std::string& s)
{
    // search included file
  std::list<std::string>::iterator i = find_include_file(s);
 
    // check if the file was included
  if(i == p_list_of_include_files.end()) {
    throw oks::FailedRemoveInclude(*this, s, "there is no such include file");
  }
 
    // lock file
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FailedRemoveInclude(*this, s, ex);
  }
 
    // remove include and mark file as updated
  p_list_of_include_files.erase(i);
  p_is_updated = true;
 
    // close file, if it is not referenced by others
  p_kernel->k_close_dangling_includes();
}
 
 
void
OksFile::rename_include_file(const std::string& old_s, const std::string& new_s)
{
  if(old_s == new_s) return;
 
  std::list<std::string>::iterator i1 = find_include_file(old_s);
  std::list<std::string>::iterator i2 = find_include_file(new_s);
 
  if(i1 == p_list_of_include_files.end()) {
    throw oks::FailedRenameInclude(*this, old_s, new_s, "there is no such include file");
  }
 
  if(i2 != p_list_of_include_files.end()) {
    throw oks::FailedRenameInclude(*this, old_s, new_s, "file with new name is already included");
  }
 
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FailedRenameInclude(*this, old_s, new_s, ex);
  }
 
  (*i1) = new_s;
  p_is_updated = true;
}
 
 
void
OksFile::set_logical_name(const std::string& s)
{
  if(s == p_logical_name) return;
 
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FileChangeError(*this, "set logical name", ex);
  }
 
  p_logical_name = s;
  p_is_updated = true;
}
 
 
void
OksFile::set_type(const std::string& s)
{
  if(s == p_type) return;
 
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FileChangeError(*this, "set type", ex);
  }
 
  p_type = s;
  p_is_updated = true;
}
 
std::ostream& operator<<(std::ostream& s, const oks::Comment& c)
{
  s << "user \"" << c.get_created_by() << "\" (" << c.get_author() << ")"
    << " on \"" << c.get_created_on() << "\" wrote: \"" << c.get_text() << "\"";
 
  return s;
}
 
 
std::ostream&
operator<<(std::ostream& s, const OksFile& f)
{
  s << "OKS file\n"
       " short file name:        \'" << f.get_short_file_name() << "\'\n"
       " full file name:         \'" << f.get_full_file_name() << "\'\n"
       " lock file name:         \'" << f.get_lock_file() << "\'\n"
       " logical name:           \'" << f.get_logical_name() << "\'\n"
       " type:                   \'" << f.get_type() << "\'\n"
       " oks format:             \'" << f.get_oks_format() << "\'\n"
       " number of items:        " << f.get_number_of_items() << "\n"
       " created by:             " << f.get_created_by() << "\n"
       " creation time:          " << boost::posix_time::to_simple_string(f.get_creation_time()) << "\n"
       " created on:             " << f.get_created_on() << "\n"
       " last modified by:       \'" << f.get_last_modified_by() << "\'\n"
       " last modification time: " << boost::posix_time::to_simple_string(f.get_last_modification_time()) << "\'\n"
       " last modified on:       " << f.get_last_modified_on() << "\'\n"
       " is " << (f.is_read_only() ? "read-only" : "read-write") << "\n"
       " is " << (f.is_locked() ? "" : "not ") << "locked\n"
       " is " << (f.is_updated() ? "" : "not ") << "updated\n";
 
    {
      size_t num_of_includes = f.get_include_files().size();
 
      if (num_of_includes)
        {
          s << " contains " << num_of_includes << " include file(s)";
          for (const auto& i : f.get_include_files())
            s << "  - \'" << i << "\'\n";
        }
      else
        {
          s << " contains no include files\n";
        }
    }
 
    {
      size_t num_of_comments = f.get_comments().size();
 
      if (num_of_comments)
        {
          s << " contains " << num_of_comments << " comment(s)";
          for (const auto& i : f.get_comments())
            s << "  - " << boost::posix_time::to_simple_string(boost::posix_time::from_iso_string(i.first)) << ": \'" << *i.second << "\'\n";
        }
      else
        {
          s << " contains no comments\n";
        }
    }
 
  s << "END of oks file\n";
 
  return s;
}
 
 
std::string
OksFile::make_repository_name() const
{
  std::string name;
 
  if(!OksKernel::get_repository_root().empty()) {
    name = OksKernel::get_repository_root() + '/' + get_repository_name();
  }
 
  return name;
}
 
 
void
OksFile::update_status_of_file(bool update_local, bool update_repository)
{
  struct stat buf;
 
  if(update_local == true && p_is_on_disk == true) {
 
    if(stat(p_full_name.c_str(), &buf) == 0) {
      p_last_modified = buf.st_mtime;
    }
  }
 
  if(update_repository == true /*&& get_repository() == UserRepository*/) {
    std::string full_repository_name = make_repository_name();
 
    if(!full_repository_name.empty() && stat(full_repository_name.c_str(), &buf) == 0) {
      p_repository_last_modified = buf.st_mtime;
    }
  }
}
 
 
OksFile::FileStatus
OksFile::get_status_of_file() const
{
  if(p_is_on_disk == false) {
    return FileWasNotSaved;
  }
  else {
    struct stat buf;
 
    if(stat(p_full_name.c_str(), &buf) != 0) {
      return FileRemoved;
    }
 
    if(buf.st_mtime != p_last_modified) {
      return FileModified;
    }
 
//    if(get_repository() == UserRepository) {
//      std::string full_repository_name = make_repository_name();
//
//      if(!full_repository_name.empty()) {
//        if(stat(full_repository_name.c_str(), &buf) != 0) {
//          return FileRepositoryRemoved;
//        }
//
//        if(buf.st_mtime != p_repository_last_modified) {
//          return FileRepositoryModified;
//        }
//      }
//    }
  }
 
  return FileNotModified;
}
 
 
void
OksFile::rename(const std::string& short_name, const std::string& full_name)
{
  p_short_name = short_name;
  p_full_name = full_name;
  create_lock_name();
  check_repository();
}
 
void
OksFile::rename(const std::string& full_name)
{
  p_full_name = full_name;
  create_lock_name();
  update_status_of_file();
}
 
void
OksFile::get_all_include_files(const OksKernel * kernel, std::set<OksFile *>& out)
{
  const OksFile::Map & schema_files = kernel->schema_files();
  const OksFile::Map & data_files = kernel->data_files();
 
  for(std::list<std::string>::iterator i = p_list_of_include_files.begin(); i != p_list_of_include_files.end(); ++i) {
    std::string s = kernel->get_file_path(*i, this);
    if(s.size()) {
      OksFile::Map::const_iterator j = data_files.find(&s);
      if(j != data_files.end()) {
        if(out.find(j->second) != out.end()) { continue; }
        out.insert(j->second);
      }
      else {
        j = schema_files.find(&s);
        if(j != schema_files.end()) {
          if(out.find(j->second) != out.end()) { continue; }
          out.insert(j->second);
        }
        else {
          continue;
        }
      }
 
      j->second->get_all_include_files(kernel, out);
    }
  }
}
 
// return true if the string is not info line:
// <info ... last-modification-time="nnnnnnnnTnnnnnn"/>
 
static bool
is_not_info(const std::string& line)
{
  static const char start_tag[] = "<info ";
  static const char last_tag[] = "last-modification-time=\"yyyymmddThhmmss\"/>"; // 24 - is a position of first double quote
 
  const std::string::size_type len = line.length();
 
  return(
    ( len < (sizeof(start_tag) + sizeof(last_tag)) ) ||
    ( line.compare(0, sizeof(start_tag)-1, start_tag, sizeof(start_tag)-1) != 0 ) ||
    ( line.compare(len - sizeof(last_tag) + 1, 24, last_tag, 24) != 0 )
  );
}
 
bool
OksFile::compare(const char * file1_name, const char * file2_name)
{
  std::ifstream f1(file1_name);
  std::ifstream f2(file2_name);
 
  if (!f1)
    {
      throw oks::FileCompareError(file1_name, file2_name, "cannot open file");
    }
 
  if (!f2)
    {
      throw oks::FileCompareError(file2_name, file1_name, "cannot open file");
    }
 
  std::string line1;
  std::string line2;
 
  while (true)
    {
      if (f1.eof() && f2.eof())
        {
          return true;
        }
 
      std::getline(f1, line1);
      std::getline(f2, line2);
 
      if ((line1 != line2) && (is_not_info(line1) || is_not_info(line2)))
        {
          return false;
        }
    }
 
  return true;
}
 
} // namespace oks
} // namespace dunedaq