ORNLDataArchive.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 <sstream>
 
#include "MantidAPI/ArchiveSearchFactory.h"
#include "MantidDataHandling/ORNLDataArchive.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/FacilityInfo.h"
#include "MantidKernel/InternetHelper.h"
#include "MantidKernel/Logger.h"
 
#include <boost/regex.hpp>
 
using Mantid::Catalog::Exception::CatalogError;
using Mantid::Catalog::ONCat::ONCat;
using Mantid::Catalog::ONCat::ONCat_uptr;
using Mantid::Catalog::ONCat::ONCatEntity;
using Mantid::Catalog::ONCat::QueryParameter;
using Mantid::Catalog::ONCat::QueryParameters;
 
namespace {
 
std::string toUpperCase(const std::string &s) {
  std::string result(s);
  std::transform(s.begin(), s.end(), result.begin(), toupper);
  return result;
}
 
const static boost::regex FILE_REGEX("^(.*?)_(\\d+).*$");
const static std::string NOT_FOUND("");
 
Mantid::Kernel::Logger g_log("ORNLDataArchive");
} // namespace
 
namespace Mantid::DataHandling {
 
DECLARE_ARCHIVESEARCH(ORNLDataArchive, ORNLDataSearch)
DECLARE_ARCHIVESEARCH(ORNLDataArchive, SNSDataSearch)
 
 
const API::Result<std::string> ORNLDataArchive::getArchivePath(const std::set<std::string> &basenames,
                                                               const std::vector<std::string> &suffixes) const {
  if (basenames.size() == 0) {
    return API::Result<std::string>(NOT_FOUND, "Not found.");
  }
 
  // Mimic previous functionality by only using the first basename.
  const auto basename = *basenames.cbegin();
 
  // Validate and parse the basename.
  boost::smatch result;
  if (!boost::regex_match(basename, result, FILE_REGEX)) {
    g_log.debug() << "Unexpected input passed to getArchivePath():" << std::endl << basename << std::endl;
    return API::Result<std::string>(NOT_FOUND, "Not found.");
    ;
  }
 
  assert(result.size() == 3);
  const std::string instrument = toUpperCase(result[1]);
  const std::string run = result[2];
 
  const auto &config = Mantid::Kernel::ConfigService::Instance();
  std::string facility;
  try {
    facility = config.getInstrument(instrument).facility().name();
 
    if (facility != "HFIR" && facility != "SNS") {
      return API::Result<std::string>(NOT_FOUND, "Not found.");
    }
  } catch (Mantid::Kernel::Exception::NotFoundError &) {
    g_log.debug() << "\"" << instrument << "\" is not an instrument known to Mantid." << std::endl;
    return API::Result<std::string>(NOT_FOUND, "Not found.");
  }
 
  // Note that we will only be asking for raw files with the given instrument
  // and run number, and *not* filtering by suffix at this point.  (ONCat has
  // a strict definition of what a file "extension" is, and has no way of
  // filtering by, for example, "_event.nxs".)
  const QueryParameters params{{"facility", facility},
                               {"instrument", instrument},
                               {"projection", "location"},
                               {"tags", "type/raw"},
                               {"sort_by", "ingested"},
                               {"sort_direction", "DESCENDING"},
                               {"ranges_q", "indexed.run_number:" + run}};
 
  // If we've not manually set up an ONCat instance (presumably for testing
  // purposes) then we must instead create one using the settings in the
  // currently-running instance of Mantid, making sure to run it in an
  // "unauthenticated" mode.  If we were to authenticate we'd be able to see
  // more information, but that would require users logging in and publically
  // available information is more than enough for our purposes here, anyway.
  auto defaultOncat = ONCat::fromMantidSettings();
  auto *oncat = m_oncat ? m_oncat.get() : defaultOncat.get();
 
  const auto datafiles = [&]() {
    try {
      return oncat->list("api", "datafiles", params);
    } catch (CatalogError &ce) {
      g_log.debug() << "Error while calling ONCat:" << std::endl << ce.what() << std::endl;
      return std::vector<ONCatEntity>();
    }
  }();
 
  if (datafiles.size() == 0) {
    g_log.debug() << "ONCat does not know the location of run \"" << run << "\" for \"" << instrument << "\"."
                  << std::endl;
    return API::Result<std::string>(NOT_FOUND, "Not found.");
  }
 
  g_log.debug() << "All datafiles returned from ONCat:" << std::endl;
  for (const auto &datafile : datafiles) {
    g_log.debug() << datafile.toString() << std::endl;
  }
 
  // It's technically possible to have been given multiple locations for a
  // single run, since runs are occasionally written out to the wrong IPTS and
  // therefore need to be "re-translated", leaving us with duplicates in the
  // catalog.  Duplicates require manual intervention to be removed, and so in
  // the meantime, since we have asked for locations to be returned to us in
  // descending order of the time at which they were ingested, we can take the
  // first one and be (quite) sure we end up with the correct run location.
  const auto location = *datafiles.cbegin()->get<std::string>("location");
 
  // Mimic the previous ICAT-calling functionality by taking "full"
  // suffixes into account.
  for (const auto &suffix : suffixes) {
    const std::string fullSuffix = basename + suffix;
    if (toUpperCase(location).ends_with(toUpperCase(fullSuffix))) {
      return API::Result<std::string>(location);
    }
  }
 
  if (toUpperCase(location).ends_with(toUpperCase(basename))) {
    return API::Result<std::string>(location);
  }
 
  return API::Result<std::string>(NOT_FOUND, "Not found.");
}
 
void ORNLDataArchive::setONCat(ONCat_uptr oncat) { m_oncat = std::move(oncat); }
 
} // namespace Mantid::DataHandling