ISISJournal.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2020 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
// Includes
#include "MantidDataHandling/ISISJournal.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/Exception.h"
 
#include "Poco/SAX/SAXException.h"
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/NodeFilter.h>
#include <Poco/DOM/TreeWalker.h>
#include <Poco/Net/HTTPResponse.h>
 
#include <boost/algorithm/string.hpp>
#include <boost/regex.hpp>
#include <sstream>
 
namespace Mantid::DataHandling {
 
using Kernel::InternetHelper;
using Poco::XML::Document;
using Poco::XML::DOMParser;
using Poco::XML::Element;
using Poco::XML::Node;
using Poco::XML::NodeFilter;
using Poco::XML::TreeWalker;
 
namespace {
static constexpr const char *INDEX_FILE_NAME = "main";
static constexpr const char *JOURNAL_PREFIX = "/journal_";
static constexpr const char *JOURNAL_EXT = ".xml";
static constexpr const char *NXROOT_TAG = "NXroot";
static constexpr const char *NXENTRY_TAG = "NXentry";
static constexpr const char *JOURNAL_TAG = "journal";
static constexpr const char *FILE_TAG = "file";
 
std::string constructURL(std::string instrument, std::string const &name) {
  boost::algorithm::to_lower(instrument);
  std::ostringstream url;
  url << Mantid::Kernel::ConfigService::Instance().getString("isisjournal.url_prefix") << instrument << JOURNAL_PREFIX
      << name << JOURNAL_EXT;
  return url.str();
}
 
Poco::AutoPtr<Document> parse(std::string const &xmlString) {
  DOMParser domParser;
  Poco::AutoPtr<Document> xmldoc;
  try {
    xmldoc = domParser.parseString(xmlString);
  } catch (Poco::XML::SAXParseException const &ex) {
    std::ostringstream msg;
    msg << "ISISJournal: Error parsing file: " << ex.what();
    throw std::runtime_error(msg.str());
  }
  return xmldoc;
}
 
void throwIfNotValid(Element *element, const char *expectedName) {
  if (!element) {
    std::ostringstream msg;
    msg << "ISISJournal::throwIfNotValid() - invalid element for '" << expectedName << "'\n";
    throw std::invalid_argument(msg.str());
  }
 
  if (element->nodeName() != expectedName) {
    std::ostringstream msg;
    msg << "ISISJournal::throwIfNotValid() - Element name does not match '" << expectedName << "'. Found "
        << element->nodeName() << "\n";
    throw std::invalid_argument(msg.str());
  }
}
 
std::string getTextValue(Node *node) {
  if (!node)
    return std::string();
 
  auto child = node->firstChild();
  if (child && child->nodeName() == "#text") {
    auto value = child->nodeValue();
    boost::algorithm::trim(value);
    return value;
  }
 
  return std::string();
}
 
bool matchesAllFilters(Element *element, ISISJournal::RunData const &filters) {
  for (auto const &filterKvp : filters) {
    auto const childElement = element->getChildElement(filterKvp.first);
    if (getTextValue(childElement) != filterKvp.second)
      return false;
  }
  return true;
}
 
ISISJournal::RunData createRunDataForElement(Element *element) {
  return ISISJournal::RunData{{"name", element->getAttribute("name")}};
}
 
void addValuesForElement(Element *element, std::vector<std::string> const &valuesToLookup,
                         ISISJournal::RunData &result) {
  for (auto &name : valuesToLookup)
    result[name] = getTextValue(element->getChildElement(name));
}
 
std::vector<ISISJournal::RunData> getValuesForAllElements(Element *parentElement,
                                                          std::vector<std::string> const &valuesToLookup,
                                                          ISISJournal::RunData const &filters) {
  auto results = std::vector<ISISJournal::RunData>{};
 
  auto nodeIter = TreeWalker(parentElement, NodeFilter::SHOW_ELEMENT);
  for (auto node = nodeIter.nextNode(); node; node = nodeIter.nextSibling()) {
    auto element = dynamic_cast<Element *>(node);
    throwIfNotValid(element, NXENTRY_TAG);
 
    if (matchesAllFilters(element, filters)) {
      auto result = createRunDataForElement(element);
      addValuesForElement(element, valuesToLookup, result);
      results.emplace_back(std::move(result));
    }
  }
 
  return results;
}
 
std::vector<std::string> getAttributeForAllChildElements(Element *parentElement, const char *childElementName,
                                                         const char *attributeName) {
  auto results = std::vector<std::string>{};
 
  auto nodeIter = TreeWalker(parentElement, NodeFilter::SHOW_ELEMENT);
  for (auto node = nodeIter.nextNode(); node; node = nodeIter.nextSibling()) {
    auto element = dynamic_cast<Element *>(node);
    throwIfNotValid(element, childElementName);
    results.emplace_back(element->getAttribute(attributeName));
  }
 
  return results;
}
 
std::string convertFilenameToCycleName(std::string const &filename) {
  boost::regex pattern("[0-9]+_[0-9]+");
  boost::smatch matches;
  boost::regex_search(filename, matches, pattern);
 
  if (matches.size() == 1)
    return matches[0];
 
  return std::string();
}
 
std::vector<std::string> convertFilenamesToCycleNames(std::vector<std::string> const &filenames) {
  auto cycles = std::vector<std::string>();
  cycles.reserve(filenames.size());
  for (const auto &filename : filenames) {
    auto cycle = convertFilenameToCycleName(filename);
    if (!cycle.empty())
      cycles.emplace_back(std::move(cycle));
  }
  return cycles;
}
} // namespace
 
ISISJournal::ISISJournal(std::string const &instrument, std::string const &cycle,
                         std::unique_ptr<InternetHelper> internetHelper)
    : m_internetHelper(std::move(internetHelper)), m_runsFileURL(constructURL(instrument, cycle)),
      m_indexFileURL(constructURL(instrument, INDEX_FILE_NAME)) {}
 
ISISJournal::ISISJournal(ISISJournal &&rhs) = default;
 
ISISJournal &ISISJournal::operator=(ISISJournal &&rhs) = default;
 
std::vector<std::string> ISISJournal::getCycleNames() {
  if (!m_indexDocument) {
    auto xmlString = getURLContents(m_indexFileURL);
    m_indexDocument = parse(xmlString);
  }
  auto rootElement = m_indexDocument->documentElement();
  throwIfNotValid(rootElement, JOURNAL_TAG);
  auto filenames = getAttributeForAllChildElements(rootElement, FILE_TAG, "name");
  return convertFilenamesToCycleNames(filenames);
}
 
std::vector<ISISJournal::RunData> ISISJournal::getRuns(std::vector<std::string> const &valuesToLookup,
                                                       ISISJournal::RunData const &filters) {
  if (!m_runsDocument) {
    auto xmlString = getURLContents(m_runsFileURL);
    m_runsDocument = parse(xmlString);
  }
  auto rootElement = m_runsDocument->documentElement();
  throwIfNotValid(rootElement, NXROOT_TAG);
  return getValuesForAllElements(rootElement, valuesToLookup, filters);
}
 
std::string ISISJournal::getURLContents(std::string const &url) {
  std::ostringstream serverReply;
  InternetHelper::HTTPStatus statusCode{InternetHelper::HTTPStatus::BAD_REQUEST};
  try {
    statusCode = m_internetHelper->sendRequest(url, serverReply);
  } catch (Kernel::Exception::InternetError const &) {
    std::ostringstream msg;
    msg << "Failed to access file " << url << "\nCheck that the cycle name is valid.";
    throw Kernel::Exception::InternetError(msg.str());
  }
 
  if (statusCode != InternetHelper::HTTPStatus::OK) {
    std::ostringstream msg;
    msg << "Failed to access file " << url << "\nHTTP Code: " << static_cast<int>(statusCode)
        << "\nCheck that the cycle name is valid.";
    throw Kernel::Exception::InternetError(msg.str());
  }
  return serverReply.str();
}
} // namespace Mantid::DataHandling