ConfigService.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 "MantidKernel/ConfigService.h"
#include "MantidKernel/DateAndTime.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/FacilityInfo.h"
#include "MantidKernel/Glob.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/MantidVersion.h"
#include "MantidKernel/NetworkProxy.h"
#include "MantidKernel/StdoutChannel.h"
#include "MantidKernel/StringTokenizer.h"
#include "MantidKernel/Strings.h"
 
#include <Poco/AutoPtr.h>
#include <Poco/Channel.h>
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/Element.h>
#include <Poco/DOM/Node.h>
#include <Poco/DOM/NodeList.h>
#include <Poco/Environment.h>
#include <Poco/Exception.h>
#include <Poco/Instantiator.h>
#include <Poco/Logger.h>
#include <Poco/LoggingFactory.h>
#include <Poco/LoggingRegistry.h>
#include <Poco/Path.h>
#include <Poco/Pipe.h>
#include <Poco/PipeStream.h>
#include <Poco/Platform.h>
#include <Poco/Process.h>
#include <Poco/StreamCopier.h>
#include <Poco/String.h>
#include <Poco/URI.h>
#include <Poco/Util/LoggingConfigurator.h>
#include <Poco/Util/PropertyFileConfiguration.h>
#include <Poco/Util/SystemConfiguration.h>
#include <Poco/Version.h>
 
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <optional>
 
#include <algorithm>
#include <cctype>
#include <codecvt>
#include <cstdlib>
#include <cstring>
#include <exception>
#include <filesystem>
#include <fstream>
#include <functional>
#include <iostream>
#include <locale>
#include <stdexcept>
#include <utility>
 
#ifdef __APPLE__
#include <mach-o/dyld.h>
#include <sys/sysctl.h>
#endif
 
namespace Mantid {
std::string welcomeMessage() {
  return "Welcome to Mantid " + std::string(Mantid::Kernel::MantidVersion::version()) +
         "\nPlease cite: " + Mantid::Kernel::MantidVersion::paperCitation() +
         " and this release: " + Mantid::Kernel::MantidVersion::doi();
}
 
namespace Kernel {
 
namespace { // anonymous namespace for some utility functions
 
Logger g_log("ConfigService");
 
const std::string PATH_DELIMITERS = ";,";
 
std::vector<std::string> splitPath(const std::string &path) {
  std::vector<std::string> splitted;
 
  if (path.find_first_of(PATH_DELIMITERS) == std::string::npos) { // don't bother tokenizing
    splitted.emplace_back(path);
  } else {
    int options = Mantid::Kernel::StringTokenizer::TOK_TRIM + Mantid::Kernel::StringTokenizer::TOK_IGNORE_EMPTY;
    Mantid::Kernel::StringTokenizer tokenizer(path, PATH_DELIMITERS, options);
    auto iend = tokenizer.end();
    for (auto itr = tokenizer.begin(); itr != iend; ++itr) {
      if (!itr->empty()) {
        splitted.emplace_back(*itr);
      }
    }
  }
  return splitted;
}
 
const std::string LOG_LEVEL_KEY("logging.loggers.root.level");
 
} // end of anonymous namespace
 
//-------------------------------
// Private member functions
//-------------------------------
 
ConfigServiceImpl::ConfigServiceImpl()
    : m_pConf(nullptr), m_pSysConfig(new Poco::Util::SystemConfiguration()), m_changed_keys(), m_strBaseDir(""),
      m_propertyString(""), m_properties_file_name("Mantid.properties"),
      m_user_properties_file_name("Mantid.user.properties"), m_dataSearchDirs(), m_instrumentDirs(), m_proxyInfo() {
  // Register StdChannel with Poco
  Poco::LoggingFactory::defaultFactory().registerChannelClass(
      "StdoutChannel", new Poco::Instantiator<Poco::StdoutChannel, Poco::Channel>);
 
  setBaseDirectory();
 
  m_configPaths.insert("framework.plugins.directory");
  m_configPaths.insert("mantidqt.plugins.directory");
  m_configPaths.insert("instrumentDefinition.directory");
  m_configPaths.insert("instrumentDefinition.vtpDirectory");
  m_configPaths.insert("groupingFiles.directory");
  m_configPaths.insert("maskFiles.directory");
  m_configPaths.insert("colormaps.directory");
  m_configPaths.insert("requiredpythonscript.directories");
  m_configPaths.insert("pythonscripts.directory");
  m_configPaths.insert("pythonscripts.directories");
  m_configPaths.insert("python.plugins.directories");
  m_configPaths.insert("user.python.plugins.directories");
  m_configPaths.insert("icatDownload.directory");
  m_configPaths.insert("datasearch.directories");
  m_configPaths.insert("python.plugins.manifest");
  m_configPaths.insert("python.templates.directory");
 
  // attempt to load the default properties file that resides in the directory
  // of the executable
  std::string propertiesFilesList;
  updateConfig(getPropertiesDir() + m_properties_file_name, false, false);
  propertiesFilesList = getPropertiesDir() + m_properties_file_name;
 
  // Load the local (machine) properties file, if it exists
  if (std::filesystem::exists(getLocalFilename())) {
    updateConfig(getLocalFilename(), true, false);
    propertiesFilesList += ", " + getLocalFilename();
  }
 
  if (Poco::Environment::has("MANTIDPROPERTIES")) {
    // and then append the user properties
    updateConfig(getUserFilename(), true, false);
    propertiesFilesList += ", " + getUserFilename();
    // and the extra one from the environment
    updateConfig(Poco::Environment::get("MANTIDPROPERTIES"), true, true);
    propertiesFilesList += ", " + Poco::Environment::get("MANTIDPROPERTIES");
  } else {
    // Just do the user properties
    updateConfig(getUserFilename(), true, true);
    propertiesFilesList += ", " + getUserFilename();
  }
 
  g_log.debug() << "ConfigService created.\n";
  g_log.debug() << "Configured Mantid.properties directory of application as " << getPropertiesDir() << '\n';
  g_log.information() << "This is Mantid version " << MantidVersion::version() << " revision "
                      << MantidVersion::revision() << '\n';
  g_log.information() << "running on " << getComputerName() << " starting "
                      << Types::Core::DateAndTime::getCurrentTime().toFormattedString("%Y-%m-%dT%H:%MZ") << "\n";
  g_log.information() << "Properties file(s) loaded: " << propertiesFilesList << '\n';
 
  // Assert that the appdata and the instrument subdirectory exists
  std::string appDataDir = getAppDataDir();
  std::filesystem::path path = std::filesystem::path(appDataDir) / "instrument";
  // create_directories will fail gracefully if it is already present - but will
  // throw an error if it cannot create the directory
  try {
    std::filesystem::create_directories(path);
  } catch (const std::filesystem::filesystem_error &fe) {
    g_log.error() << "Cannot create the local instrument cache directory [" << path.string()
                  << "]. Mantid will not be able to update instrument definitions.\n"
                  << fe.what() << '\n';
  }
  std::filesystem::path vtpDir(getVTPFileDirectory());
  try {
    std::filesystem::create_directories(vtpDir);
  } catch (const std::filesystem::filesystem_error &fe) {
    g_log.error() << "Cannot create the local instrument geometry cache directory [" << vtpDir.string()
                  << "]. Mantid will be slower at viewing complex instruments.\n"
                  << fe.what() << '\n';
  }
  // must update the cache of instrument paths
  cacheInstrumentPaths();
 
  // update the facilities AFTER we have ensured that all of the directories are
  // created and the paths updated
  // if we don't do that first the function below will silently fail without
  // initialising the facilities vector
  // and Mantid will crash when it tries to access them, for example when
  // creating the first time startup screen
  updateFacilities();
}
 
ConfigServiceImpl::~ConfigServiceImpl() {
  Kernel::Logger::shutdown();
  clearFacilities();
}
 
void ConfigServiceImpl::setBaseDirectory() {
  // Define the directory to search for the Mantid.properties file.
  std::filesystem::path filepath;
 
  // First directory: the current working
  m_strBaseDir = std::filesystem::current_path().string() + "/";
  filepath = std::filesystem::path(m_strBaseDir) / m_properties_file_name;
  if (std::filesystem::exists(filepath))
    return;
 
  // Check the executable directory to see if it includes a mantid.properties
  // file
  m_strBaseDir = getDirectoryOfExecutable();
  filepath = std::filesystem::path(m_strBaseDir) / m_properties_file_name;
  if (std::filesystem::exists(filepath))
    return;
 
  // Check the MANTIDPATH environment var
  if (Poco::Environment::has("MANTIDPATH")) {
    // Here we have to follow the convention of the rest of this code and
    // add a trailing slash.
    // Note: adding it to the MANTIDPATH itself will make other parts of the
    // code crash.
#ifdef _WIN32
    // In case the path contains backslashes, we cannot
    // mix forward and back slashes in the path.
    m_strBaseDir = Poco::Environment::get("MANTIDPATH") + "\\";
#else
    m_strBaseDir = Poco::Environment::get("MANTIDPATH") + "/";
#endif
    filepath = std::filesystem::path(m_strBaseDir) / m_properties_file_name;
    if (std::filesystem::exists(filepath))
      return;
  }
 
#ifdef __APPLE__
  // Finally, on OSX check if we're in the package directory and the .properties
  // file just happens to be two directories up
  std::filesystem::path execPath(getDirectoryOfExecutable());
  m_strBaseDir = execPath.parent_path().parent_path().parent_path().string() + "/";
#endif
}
 
namespace {
// look for specific keys and throw an exception if one is found
std::string checkForBadConfigOptions(const std::string &filename, const std::string &propertiesString) {
  std::stringstream stream(propertiesString);
  std::stringstream resultPropertiesString;
  std::string line;
  int line_num = 0;
  while (std::getline(stream, line)) {
    line_num += 1; // increment early
    bool is_ok = true;
 
    // Check for common errors. Empty lines are ok, things that are a key
    // without a value are a critical failure. Forbidden keys are just commented
    // out.
    if (line.empty() || (Kernel::Strings::strip(line)[0] == '#')) {
      // do nothing
    } else if (line.find("FilterChannel") != std::string::npos) {
      is_ok = false;
    }
 
    // Print warning to error channel and comment out offending line
    if (!is_ok) {
      const auto end = line.find("=");
      g_log.warning() << "Encontered invalid key \"";
      if (end != std::string::npos) {
        g_log.warning() << Kernel::Strings::strip(line.substr(0, end));
      } else {
        g_log.warning() << Kernel::Strings::strip(line);
      }
      g_log.warning() << "\" in " << filename << " on line " << line_num << std::endl;
 
      // comment out the property
      resultPropertiesString << '#';
    }
    // copy over the line
    resultPropertiesString << line << '\n';
  }
  return resultPropertiesString.str();
}
} // end of anonymous namespace
 
void ConfigServiceImpl::loadConfig(const std::string &filename, const bool append) {
 
  if (!append) {
    // remove the previous property string
    m_propertyString = "";
    m_changed_keys.clear();
  }
 
  try {
    // slurp in entire file
    std::string temp;
    bool good = readFile(filename, temp);
 
    // check if we have failed to open the file
    if ((!good) || (temp.empty())) {
      if (filename == getUserPropertiesDir() + m_user_properties_file_name) {
        // write out a fresh file
        createUserPropertiesFile();
      } else {
        throw Exception::FileError("Cannot open file", filename);
      }
    }
 
    // verify the contents and comment out offending lines
    temp = checkForBadConfigOptions(filename, temp);
 
    // store the property string
    if ((append) && (!m_propertyString.empty())) {
      m_propertyString = m_propertyString + "\n" + temp;
    } else {
      m_propertyString = temp;
    }
  } catch (std::exception &e) {
    // there was a problem loading the file - it probably is not there
    g_log.error() << "Problem loading the configuration file " << filename << " " << e.what() << '\n';
    g_log.error() << "Mantid is unable to start.\n" << std::endl;
    throw;
  }
 
  // use the cached property string to initialise the POCO property file
  std::istringstream istr(m_propertyString);
  m_pConf = new Poco::Util::PropertyFileConfiguration(istr);
}
 
bool ConfigServiceImpl::readFile(const std::string &filename, std::string &contents) const {
  std::ifstream propFile(filename.c_str(), std::ios::in);
  bool good = propFile.good();
  if (!good) {
    contents = "";
    propFile.close();
    return good;
  }
 
  // slurp in entire file - extremely unlikely delimiter used as an alternate to
  // \n
  contents.clear();
  getline(propFile, contents, '`');
  propFile.close();
  return good;
}
 
void ConfigServiceImpl::configureLogging() {
  try {
    // Configure the logging framework
    Poco::Util::LoggingConfigurator configurator;
#if POCO_VERSION > 0x01090400
    configurator.configure(m_pConf);
#else
    configurator.configure(m_pConf.get());
#endif
  } catch (std::exception &e) {
    std::cerr << "Trouble configuring the logging framework " << e.what() << '\n';
  }
}
 
std::string ConfigServiceImpl::makeAbsolute(const std::string &dir, const std::string &key) const {
  if (dir.empty()) {
    // Don't do anything for an empty value
    return dir;
  }
  std::string converted;
  // If we have a list, chop it up and convert each one
  if (dir.find_first_of(PATH_DELIMITERS) != std::string::npos) {
    auto splitted = splitPath(dir);
    auto iend = splitted.cend();
    for (auto itr = splitted.begin(); itr != iend;) {
      std::string absolute = makeAbsolute(*itr, key);
      if (absolute.empty()) {
        ++itr;
      } else {
        converted += absolute;
        if (++itr != iend) {
          converted += ";";
        }
      }
    }
    return converted;
  }
 
  // MG 05/10/09: When the Poco::FilePropertyConfiguration object reads its
  // key/value pairs it
  // treats a backslash as the start of an escape sequence. If the next
  // character does not
  // form a valid sequence then the backslash is removed from the stream. This
  // has the effect
  // of giving malformed paths when using Windows-style directories. E.g
  // C:\Mantid ->C:Mantid
  // std::filesystem::path can handle this better
  bool is_relative(false);
  try {
    std::filesystem::path testPath(dir);
    is_relative = testPath.is_relative();
 
#ifdef _WIN32
    // On Windows, std::filesystem treats paths starting with / or \ as relative
    // (because they lack a drive letter), but we want to treat them as absolute
    // to match the original Poco::Path behavior and Unix conventions
    if (is_relative && !dir.empty() && (dir[0] == '/' || dir[0] == '\\')) {
      is_relative = false;
    }
#endif
  } catch (const std::exception &) {
    g_log.warning() << "Malformed path detected in the \"" << key << "\" variable, skipping \"" << dir << "\"\n";
    return "";
  }
  if (is_relative) {
    const std::string propFileDir(getPropertiesDir());
    std::filesystem::path basePath(propFileDir);
    std::filesystem::path fullPath = basePath / dir;
    converted = fullPath.string();
  } else {
    converted = dir;
  }
  std::filesystem::path convertedPath(converted);
  if (!convertedPath.extension().empty()) {
    converted = convertedPath.string();
  } else {
    // Ensure directory has trailing slash
    converted = convertedPath.string();
    if (converted.back() != '/' && converted.back() != '\\') {
      converted += "/";
    }
  }
  // Backward slashes cannot be allowed to go into our properties file
  // Note this is a temporary fix for ticket #2445.
  // Ticket #2460 prompts a review of our path handling in the config service.
  boost::replace_all(converted, "\\", "/");
  return converted;
}
 
void ConfigServiceImpl::cacheDataSearchPaths() {
  std::string paths = getString("datasearch.directories", true);
  if (paths.empty()) {
    m_dataSearchDirs.clear();
  } else {
    m_dataSearchDirs = splitPath(paths);
  }
}
 
bool ConfigServiceImpl::isInDataSearchList(const std::string &path) const {
  // the path produced by poco will have \ on windows, but the searchdirs will
  // always have /
  std::string correctedPath = path;
  replace(correctedPath.begin(), correctedPath.end(), '\\', '/');
 
  using std::placeholders::_1;
  auto it = std::find_if(m_dataSearchDirs.cbegin(), m_dataSearchDirs.cend(),
                         std::bind(std::equal_to<std::string>(), _1, correctedPath));
  return (it != m_dataSearchDirs.end());
}
 
void ConfigServiceImpl::createUserPropertiesFile() const {
  try {
    std::fstream filestr((getUserPropertiesDir() + m_user_properties_file_name).c_str(), std::fstream::out);
 
    filestr << "# This file can be used to override any properties for this "
               "installation.\n";
    filestr << "# Any properties found in this file will override any that are "
               "found in the Mantid.Properties file\n";
    filestr << "# As this file will not be replaced with further installations "
               "of Mantid it is a safe place to put \n";
    filestr << "# properties that suit your particular installation.\n";
    filestr << "#\n";
    filestr << "# See here for a list of possible options:\n";
    filestr << "# "
               "http://docs.mantidproject.org/nightly/concepts/PropertiesFile.html"
               "\n\n";
    filestr << "##\n";
    filestr << "## GENERAL\n";
    filestr << "##\n\n";
    filestr << "## Set the maximum number of cores used to run algorithms over\n";
    filestr << "#MultiThreaded.MaxCores=4\n\n";
    filestr << "##\n";
    filestr << "## FACILITY AND INSTRUMENT\n";
    filestr << "##\n\n";
    filestr << "## Sets the default facility\n";
    filestr << "## e.g.: ISIS, SNS, ILL\n";
    filestr << "default.facility=\n\n";
    filestr << "## Sets the default instrument\n";
    filestr << "## e.g. IRIS, HET, NIMROD\n";
    filestr << "default.instrument=\n\n";
    filestr << '\n';
    filestr << "## Sets the Q.convention\n";
    filestr << "## Set to Crystallography for kf-ki instead of default "
               "Inelastic which is ki-kf\n";
    filestr << "#Q.convention=Crystallography\n";
    filestr << "##\n";
    filestr << "## DIRECTORIES\n";
    filestr << "##\n\n";
    filestr << "## Sets a list of directories (separated by semi colons) to "
               "search for data\n";
    filestr << "#datasearch.directories=../data;../isis/data\n\n";
    filestr << "## Set a list (separated by semi colons) of directories to "
               "look for additional Python scripts\n";
    filestr << "#pythonscripts.directories=../scripts;../docs/MyScripts\n\n";
    filestr << "## Uncomment to enable archive search - ICat and Orbiter\n";
    filestr << "#datasearch.searcharchive=On\n\n";
    filestr << "## Sets default save directory\n";
    filestr << "#defaultsave.directory=../data\n\n";
    filestr << "##\n";
    filestr << "## LOGGING\n";
    filestr << "##\n\n";
    filestr << "## Uncomment to change logging level\n";
    filestr << "## Default is information\n";
    filestr << "## Valid values are: error, warning, notice, information, debug\n";
    filestr << "#logging.loggers.root.level=information\n\n";
    filestr << "##\n";
    filestr << "## MantidWorkbench\n";
    filestr << "##\n\n";
    filestr << "## Hides categories from the algorithm list in MantidWorkbench\n";
    filestr << "#algorithms.catagories.hidden=Muons,Inelastic\n\n";
    filestr << "## Show invisible workspaces\n";
    filestr << "#MantidOptions.InvisibleWorkspaces=0\n";
    filestr << "## Re-use plot instances for different plot types\n";
    filestr << "#MantidOptions.ReusePlotInstances=Off\n\n";
    filestr << "## Uncomment to disable use of OpenGL to render unwrapped "
               "instrument views\n";
    filestr << "#MantidOptions.InstrumentView.UseOpenGL=Off\n\n";
    filestr << "## Muon GUI settings\n";
    filestr << "#muon.GUI = \n\n";
    filestr << "## SANS ISIS Command Interface\n";
    filestr << "## Uncomment below line to allow usage of deprecated ISIS Command Interface\n";
    filestr << "#sans.deprecated_command_interface=On\n\n";
 
    filestr.close();
  } catch (std::runtime_error &ex) {
    g_log.warning() << "Unable to write out user.properties file to " << getUserPropertiesDir()
                    << m_user_properties_file_name << " error: " << ex.what() << '\n';
  }
}
 
//-------------------------------
// Public member functions
//-------------------------------
 
void ConfigServiceImpl::reset() {
  // Remove the current user properties file and write a fresh one
  try {
    std::filesystem::remove(getUserFilename());
  } catch (const std::exception &) {
  }
  createUserPropertiesFile();
 
  // Now load the original
  const bool append = false;
  const bool updateCaches = true;
  updateConfig(getPropertiesDir() + m_properties_file_name, append, updateCaches);
}
 
void ConfigServiceImpl::updateConfig(const std::string &filename, const bool append, const bool update_caches) {
  loadConfig(filename, append);
 
  if (update_caches) {
    // Only configure logging once
    configureLogging();
    // Configure search paths into a specially saved store as they will be used
    // frequently
    cacheDataSearchPaths();
    appendDataSearchDir(getString("defaultsave.directory"));
    cacheInstrumentPaths();
  }
}
 
void ConfigServiceImpl::saveConfig(const std::string &filename) const {
  // Open and read the user properties file
  std::string updated_file;
 
  std::ifstream reader(filename.c_str(), std::ios::in);
  if (reader.bad()) {
    throw std::runtime_error("Error opening user properties file. Cannot save "
                             "updated configuration.");
  }
 
  std::string file_line, output;
  bool line_continuing(false);
  while (std::getline(reader, file_line)) {
    if (!file_line.empty()) {
      char last = *(file_line.end() - 1);
      if (last == '\\') {
        // If we are not in line continuation mode then need
        // a fresh start line
        if (!line_continuing)
          output = "";
        line_continuing = true;
        output += file_line + "\n";
        continue;
      } else if (line_continuing) {
        output += file_line;
        line_continuing = false;
      } else {
        output = file_line;
      }
    } else {
      output = "";
      updated_file += "\n";
      continue;
    } // end if-else
 
    // Output is the current line in the file
 
    // Extract the key from the current line
    std::string key;
    std::string::size_type pos = output.find('=');
    if (pos == std::string::npos) {
      key = output; // If no equals then the entire thing is the key
    } else {
      key = output.substr(0, pos); // Strip the equals to get only the key
    }
    // Now deal with trimming (removes spaces)
    Poco::trimInPlace(key);
 
    // Find the comments
    std::string::size_type comment = key.find('#');
 
    // Check if it exists in the service using hasProperty and make sure it
    // isn't a comment
    if (comment == 0) {
      updated_file += output;
    } else if (!hasProperty(key)) {
      // Remove the key from the changed key list
      m_changed_keys.erase(key);
      continue;
    } else {
      // If it does exist make sure the value is current
      std::string value = getString(key, false);
      Poco::replaceInPlace(value, "\\", "\\\\"); // replace single \ with double
      updated_file.append(key).append("=").append(value);
      // Remove the key from the changed key list
      m_changed_keys.erase(key);
    }
    updated_file += "\n";
  } // End while-loop
 
  // Any remaining keys within the changed key store weren't present in the
  // current user properties so append them IF they exist
  if (!m_changed_keys.empty()) {
    updated_file += "\n";
    auto key_end = m_changed_keys.end();
    for (auto key_itr = m_changed_keys.begin(); key_itr != key_end;) {
      // if the key does not have a property, skip it
      if (!hasProperty(*key_itr)) {
        ++key_itr;
        continue;
      }
      updated_file += *key_itr + "=";
      std::string value = getString(*key_itr, false);
      Poco::replaceInPlace(value, "\\", "\\\\"); // replace single \ with double
      updated_file += value;
      if (++key_itr != key_end) {
        updated_file += "\n";
      }
    }
    m_changed_keys.clear();
  }
 
  // Write out the new file
  std::ofstream writer(filename.c_str(), std::ios_base::trunc);
  if (writer.bad()) {
    writer.close();
    g_log.error() << "Error writing new user properties file. Cannot save "
                     "current configuration.\n";
    throw std::runtime_error("Error writing new user properties file. Cannot "
                             "save current configuration.");
  }
 
  writer.write(updated_file.c_str(), updated_file.size());
  writer.close();
}
 
std::string ConfigServiceImpl::getString(const std::string &keyName, bool pathAbsolute) const {
  if (m_pConf->hasProperty(keyName)) {
    std::string value = m_pConf->getString(keyName);
    const auto key = m_configPaths.find(keyName);
    if (pathAbsolute && key != m_configPaths.end()) {
      value = makeAbsolute(value, keyName);
    }
    return value;
  }
 
  g_log.debug() << "Unable to find " << keyName << " in the properties file" << '\n';
  return {};
}
 
std::vector<std::string> ConfigServiceImpl::getKeys(const std::string &keyName) const {
  std::vector<std::string> rawKeys;
  m_pConf->keys(keyName, rawKeys);
  return rawKeys;
}
 
void ConfigServiceImpl::getKeysRecursive(const std::string &root, std::vector<std::string> &allKeys) const {
  std::vector<std::string> rootKeys = getKeys(root);
 
  if (rootKeys.empty())
    allKeys.emplace_back(root);
 
  for (auto &rootKey : rootKeys) {
    std::string searchString;
    if (root.empty()) {
      searchString.append(rootKey);
    } else {
      searchString.append(root).append(".").append(rootKey);
    }
 
    getKeysRecursive(searchString, allKeys);
  }
}
 
std::vector<std::string> ConfigServiceImpl::keys() const {
  std::vector<std::string> allKeys;
  getKeysRecursive("", allKeys);
  return allKeys;
}
 
void ConfigServiceImpl::remove(const std::string &rootName) {
  m_pConf->remove(rootName);
  m_changed_keys.insert(rootName);
}
 
bool ConfigServiceImpl::hasProperty(const std::string &rootName) const { return m_pConf->hasProperty(rootName); }
 
namespace {
std::string expandEnvironmentInFilepath(const std::string &target) {
  std::string result = target;
  size_t pos = 0;
 
#ifdef _WIN32
  // Windows style: %VAR%
  while ((pos = result.find('%', pos)) != std::string::npos) {
    size_t end = result.find('%', pos + 1);
    if (end == std::string::npos)
      break;
 
    std::string varName = result.substr(pos + 1, end - pos - 1);
    const char *envValue = std::getenv(varName.c_str());
 
    if (envValue) {
      result.replace(pos, end - pos + 1, envValue);
      pos += std::strlen(envValue);
    } else {
      pos = end + 1;
    }
  }
#else
  // Unix style: $VAR or ${VAR}
  pos = 0;
  while ((pos = result.find('$', pos)) != std::string::npos) {
    size_t start = pos;
    size_t end;
    std::string varName;
 
    if (pos + 1 < result.length() && result[pos + 1] == '{') {
      // ${VAR} format
      end = result.find('}', pos + 2);
      if (end == std::string::npos) {
        pos++;
        continue;
      }
      varName = result.substr(pos + 2, end - pos - 2);
      end++; // include the closing brace
    } else {
      // $VAR format - find end of variable name
      end = pos + 1;
      while (end < result.length() && (std::isalnum(result[end]) || result[end] == '_')) {
        end++;
      }
      varName = result.substr(pos + 1, end - pos - 1);
    }
 
    if (!varName.empty()) {
      const char *envValue = std::getenv(varName.c_str());
      if (envValue) {
        result.replace(start, end - start, envValue);
        pos = start + std::strlen(envValue);
      } else {
        pos = end;
      }
    } else {
      pos++;
    }
  }
#endif
 
  return result;
}
} // namespace
 
bool ConfigServiceImpl::isExecutable(const std::string &target) const {
  try {
    std::filesystem::path filepath(expandEnvironmentInFilepath(target));
 
    if (std::filesystem::exists(filepath) && std::filesystem::is_regular_file(filepath)) {
      // On Unix-like systems, check execute permission
      // std::filesystem doesn't have a direct equivalent to canExecute
      // so we use std::filesystem::status
#ifdef _WIN32
      // On Windows, check if it's a regular file with .exe, .bat, .cmd extension
      std::string ext = filepath.extension().string();
      std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
      return (ext == ".exe" || ext == ".bat" || ext == ".cmd" || ext == ".com");
#else
      // On Unix-like systems, check execute permissions
      auto perms = std::filesystem::status(filepath).permissions();
      return (perms & std::filesystem::perms::owner_exec) != std::filesystem::perms::none ||
             (perms & std::filesystem::perms::group_exec) != std::filesystem::perms::none ||
             (perms & std::filesystem::perms::others_exec) != std::filesystem::perms::none;
#endif
    } else
      return false;
  } catch (const std::exception &) {
    return false;
  }
}
 
void ConfigServiceImpl::launchProcess(const std::string &programFilePath,
                                      const std::vector<std::string> &programArguments) const {
  try {
    std::string expTarget = expandEnvironmentInFilepath(programFilePath);
    Poco::Process::launch(expTarget, programArguments);
  } catch (Poco::SystemException &e) {
    throw std::runtime_error(e.what());
  }
}
 
void ConfigServiceImpl::setString(const std::string &key, const std::string &value) {
  // If the value is unchanged (after any path conversions), there's nothing to
  // do.
  const std::string old = getString(key);
  if (value == old)
    return;
 
  // Update the internal value
  m_pConf->setString(key, value);
 
  // Cache things that are accessed frequently
  if (key == "datasearch.directories") {
    cacheDataSearchPaths();
  } else if (key == "instrumentDefinition.directory") {
    cacheInstrumentPaths();
  } else if (key == "defaultsave.directory") {
    appendDataSearchDir(value);
  } else if (key == "logging.channels.consoleChannel.class") {
    // this key requires reloading logging for it to take effect
    configureLogging();
  } else if (key == LOG_LEVEL_KEY) {
    this->setLogLevel(value);
  }
 
  m_notificationCenter.postNotification(new ValueChanged(key, value, old));
  m_changed_keys.insert(key);
}
 
template <typename T> std::optional<T> ConfigServiceImpl::getValue(const std::string &keyName) {
  std::string strValue = getString(keyName);
  T output;
  int result = Mantid::Kernel::Strings::convert(strValue, output);
 
  if (result != 1) {
    return std::nullopt;
  }
 
  return std::optional<T>(output);
}
 
template <> std::optional<bool> ConfigServiceImpl::getValue(const std::string &keyName) {
  auto returnedValue = getValue<std::string>(keyName);
  if (!returnedValue.has_value()) {
    return std::nullopt;
  }
 
  auto &configVal = returnedValue.value();
 
  std::transform(configVal.begin(), configVal.end(), configVal.begin(), ::tolower);
 
  boost::trim(configVal);
 
  bool trueString = configVal == "true";
  bool valueOne = configVal == "1";
  bool onOffString = configVal == "on";
 
  // A string of 1 or true both count
  return trueString || valueOne || onOffString;
}
 
std::string ConfigServiceImpl::getLocalFilename() const {
#ifdef _WIN32
  return "Mantid.local.properties";
#else
  return "/etc/mantid.local.properties";
#endif
}
 
std::string ConfigServiceImpl::getUserFilename() const { return getUserPropertiesDir() + m_user_properties_file_name; }
 
std::string ConfigServiceImpl::getEnvironment(const std::string &keyName) {
  return m_pSysConfig->getString("system.env." + keyName);
}
 
std::string ConfigServiceImpl::getOSName() { return m_pSysConfig->getString("system.osName"); }
 
std::string ConfigServiceImpl::getOSArchitecture() {
  auto osArch = m_pSysConfig->getString("system.osArchitecture");
#ifdef __APPLE__
  if (osArch == "x86_64") {
    // This could be running under Rosetta on an Arm Mac
    // https://developer.apple.com/documentation/apple-silicon/about-the-rosetta-translation-environment
    int ret = 0;
    size_t size = sizeof(ret);
    if (sysctlbyname("sysctl.proc_translated", &ret, &size, nullptr, 0) != -1 && ret == 1) {
      osArch = "arm64_(x86_64)";
      g_log.warning("You are running an Intel build of Mantid on Apple silicon, which will be significantly slower and "
                    "use more power. For best performance, install the Arm version of Mantid. This version is "
                    "available here: https://downloads.mantidproject.org");
    } else {
      // TODO this can be removed after the v6.14 code freeze because the feature will be dropped
      g_log.warning("Mantid v6.14 is the last version that will support Intel macOS.");
    }
  }
#endif
  return osArch;
}
 
std::string ConfigServiceImpl::getComputerName() { return m_pSysConfig->getString("system.nodeName"); }
 
std::string ConfigServiceImpl::getOSVersion() { return m_pSysConfig->getString("system.osVersion"); }
 
bool canRead(const std::string &filename) {
  // check for existence of the file
  if (!std::filesystem::exists(filename)) {
    return false;
  }
 
  // Try to open the file to check if it's readable
  std::ifstream file(filename);
  return file.good();
}
 
std::string getValueFromStdOut(const std::string &orig, const std::string &key) {
  size_t start = orig.find(key);
  if (start == std::string::npos) {
    return std::string();
  }
  start += key.size();
 
  size_t stop = orig.find('\n', start);
  if (stop == std::string::npos) {
    return std::string();
  }
 
  return Mantid::Kernel::Strings::strip(orig.substr(start, stop - start));
}
 
std::string ConfigServiceImpl::getOSVersionReadable() {
  std::string description;
 
  // read os-release
  static const std::string OS_RELEASE("/etc/os-release");
  if (canRead(OS_RELEASE)) {
    static const std::string PRETTY_NAME("PRETTY_NAME=");
 
    // open it to see if it has the magic line
    std::ifstream handle(OS_RELEASE.c_str(), std::ios::in);
 
    // go through the file
    std::string line;
    while (std::getline(handle, line)) {
      if (line.find(PRETTY_NAME) != std::string::npos) {
        if (line.length() > PRETTY_NAME.length() + 1) {
          size_t length = line.length() - PRETTY_NAME.length() - 2;
          description = line.substr(PRETTY_NAME.length() + 1, length);
        }
        break;
      }
    }
 
    // cleanup
    handle.close();
    if (!description.empty()) {
      return description;
    }
  }
 
  // read redhat-release
  static const std::string REDHAT_RELEASE("/etc/redhat-release");
  if (canRead(REDHAT_RELEASE)) {
    // open it to see if it has the magic line
    std::ifstream handle(REDHAT_RELEASE.c_str(), std::ios::in);
 
    // go through the file
    std::string line;
    while (std::getline(handle, line)) {
      if (!line.empty()) {
        description = std::move(line);
        break;
      }
    }
 
    // cleanup
    handle.close();
    if (!description.empty()) {
      return description;
    }
  }
 
  // try system calls
  std::string cmd;
  std::vector<std::string> args;
#ifdef __APPLE__
  cmd = "sw_vers"; // mac
#elif _WIN32
  cmd = "wmic";                 // windows
  args.emplace_back("os");      // windows
  args.emplace_back("get");     // windows
  args.emplace_back("Caption"); // windows
  args.emplace_back("/value");  // windows
#endif
 
#if defined __APPLE__ || defined _WIN32
  try {
    Poco::Pipe outPipe, errorPipe;
    Poco::ProcessHandle ph = Poco::Process::launch(cmd, args, nullptr, &outPipe, &errorPipe);
    const int rc = ph.wait();
    // Only if the command returned successfully.
    if (rc == 0) {
      Poco::PipeInputStream pipeStream(outPipe);
      std::stringstream stringStream;
      Poco::StreamCopier::copyStream(pipeStream, stringStream);
      const std::string result = stringStream.str();
#ifdef __APPLE__
      const std::string product_name = getValueFromStdOut(result, "ProductName:");
      const std::string product_vers = getValueFromStdOut(result, "ProductVersion:");
 
      description = product_name + " " + product_vers;
#elif _WIN32
      description = getValueFromStdOut(result, "Caption=");
#else
      UNUSED_ARG(result); // only used on mac and windows
#endif
    } else {
      std::stringstream messageStream;
      messageStream << "command \"" << cmd << "\" failed with code: " << rc;
      g_log.debug(messageStream.str());
    }
  } catch (Poco::SystemException &e) {
    g_log.debug("command \"" + cmd + "\" failed");
    g_log.debug(e.what());
  }
#endif
  return description;
}
 
std::string ConfigServiceImpl::getUsername() {
  std::string username;
 
  // mac and favorite way to get username on linux
  try {
    username = m_pSysConfig->getString("system.env.USER");
    if (!username.empty()) {
      return username;
    }
  } catch (const Poco::NotFoundException &e) {
    UNUSED_ARG(e); // let it drop on the floor
  }
 
  // windoze and alternate linux username variable
  try {
    username = m_pSysConfig->getString("system.env.USERNAME");
    if (!username.empty()) {
      return username;
    }
  } catch (const Poco::NotFoundException &e) {
    UNUSED_ARG(e); // let it drop on the floor
  }
 
  // give up and return an empty string
  return std::string();
}
 
std::string ConfigServiceImpl::getCurrentDir() { return m_pSysConfig->getString("system.currentDir"); }
 
std::string ConfigServiceImpl::getCurrentDir() const { return m_pSysConfig->getString("system.currentDir"); }
 
std::string ConfigServiceImpl::getTempDir() { return m_pSysConfig->getString("system.tempDir"); }
 
std::string ConfigServiceImpl::getAppDataDir() {
  const std::string applicationName = "mantid";
#if POCO_OS == POCO_OS_WINDOWS_NT
  const std::string vendorName = "mantidproject";
  wchar_t *w_appdata = _wgetenv(L"APPDATA");
  std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
  std::string appdata = converter.to_bytes(w_appdata);
  std::filesystem::path path(appdata);
  path /= vendorName;
  path /= applicationName;
  return path.string();
#else // linux and mac
  const char *home = std::getenv("HOME");
  if (!home) {
    throw std::runtime_error("HOME environment variable not set - seen in ConfigService.getAppDataDir()");
  }
  std::filesystem::path path(home);
  path /= ("." + applicationName);
  return path.string();
#endif
}
 
std::string ConfigServiceImpl::getDirectoryOfExecutable() const {
  std::filesystem::path execPath(getPathToExecutable());
  return execPath.parent_path().string() + "/";
}
 
std::string ConfigServiceImpl::getPathToExecutable() const {
  std::string execpath;
  const size_t LEN(1024);
  char pBuf[LEN];
 
#ifdef _WIN32
  unsigned int bytes = GetModuleFileName(NULL, pBuf, LEN);
#elif defined __linux__
  char szTmp[32];
  sprintf(szTmp, "/proc/%d/exe", getpid());
  ssize_t bytes = readlink(szTmp, pBuf, LEN);
#elif defined __APPLE__
  // Two calls to _NSGetExecutablePath required - first to get size of buffer
  uint32_t bytes(0);
  _NSGetExecutablePath(pBuf, &bytes);
  const int success = _NSGetExecutablePath(pBuf, &bytes);
  if (success < 0)
    bytes = 1025;
#endif
 
  if (bytes > 0 && bytes < 1024) {
    pBuf[bytes] = '\0';
    execpath = std::string(pBuf);
  }
  return execpath;
}
 
bool ConfigServiceImpl::isNetworkDrive([[maybe_unused]] const std::string &path) {
#ifdef _WIN32
  // if path is relative get the full one
  char buff[MAX_PATH];
  GetFullPathName(path.c_str(), MAX_PATH, buff, NULL);
  std::string fullName(buff);
  size_t i = fullName.find(':');
 
  // if the full path doesn't contain a drive letter assume it's on the network
  if (i == std::string::npos)
    return true;
 
  fullName.erase(i + 1);
  fullName += '\\'; // make sure the name has the trailing backslash
  UINT type = GetDriveType(fullName.c_str());
  return DRIVE_REMOTE == type;
#elif defined __linux__
  // This information is only present in the /proc/mounts file on linux. There
  // are no drives on
  // linux only mount locations therefore the test will have to check the path
  // against
  // entries in /proc/mounts to see if the filesystem type is NFS or SMB (any
  // others ????)
  // Each line corresponds to a particular mounted location
  // 1st column - device name
  // 2nd column - mounted location
  // 3rd column - filesystem type commonly ext2, ext3 for hard drives and NFS or
  // SMB for
  //              network locations
 
  std::ifstream mntfile("/proc/mounts");
  std::string txtread("");
  while (getline(mntfile, txtread)) {
    std::istringstream strm(txtread);
    std::string devname(""), mntpoint(""), fstype("");
    strm >> devname >> mntpoint >> fstype;
    if (!strm)
      continue;
    // I can't be sure that the file system type is always lower case
    std::transform(fstype.begin(), fstype.end(), fstype.begin(), toupper);
    // Skip the current line if the file system isn't a network one
    if (fstype != "NFS" && fstype != "SMB")
      continue;
    // Now we have a line containing a network filesystem and just need to check
    // if the path
    // supplied contains the mount location. There is a small complication in
    // that the mount
    // points within the file have certain characters transformed into their
    // octal
    // representations, for example spaces->040.
    std::string::size_type idx = mntpoint.find("\\0");
    if (idx != std::string::npos) {
      std::string oct = mntpoint.substr(idx + 1, 3);
      strm.str(oct);
      int printch(-1);
      strm.setf(std::ios::oct, std::ios::basefield);
      strm >> printch;
      if (printch != -1) {
        mntpoint = mntpoint.substr(0, idx) + static_cast<char>(printch) + mntpoint.substr(idx + 4);
      }
      // Search for this at the start of the path
      if (path.find(mntpoint) == 0)
        return true;
    }
  }
  return false;
#else
  // Not yet implemented for the mac
  return false;
#endif
}
 
std::string ConfigServiceImpl::getPropertiesDir() const { return m_strBaseDir; }
 
std::string ConfigServiceImpl::getUserPropertiesDir() const {
#ifdef _WIN32
  return m_strBaseDir;
#else
  std::filesystem::path datadir(m_pSysConfig->getString("system.homeDir"));
  datadir /= ".mantid";
  // Create the directory if it doesn't already exist
  std::filesystem::create_directory(datadir);
  return datadir.string() + "/";
#endif
}
 
const std::vector<std::string> &ConfigServiceImpl::getDataSearchDirs() const { return m_dataSearchDirs; }
 
void ConfigServiceImpl::setDataSearchDirs(const std::vector<std::string> &searchDirs) {
  std::string searchPaths = boost::join(searchDirs, ";");
  setDataSearchDirs(searchPaths);
}
 
void ConfigServiceImpl::setDataSearchDirs(const std::string &searchDirs) {
  setString("datasearch.directories", searchDirs);
}
 
void ConfigServiceImpl::appendDataSearchSubDir(const std::string &subdir) {
  if (subdir.empty())
    return;
 
  std::filesystem::path subDirPath;
  try {
    subDirPath = std::filesystem::path(subdir);
  } catch (const std::exception &) {
    return;
  }
 
  // Check if path has trailing slash (indicates directory) and is relative
  if (!subDirPath.is_relative()) {
    return;
  }
 
  auto newDataDirs = m_dataSearchDirs;
  for (const auto &path : m_dataSearchDirs) {
    std::filesystem::path newDirPath;
    try {
      newDirPath = std::filesystem::path(path) / subDirPath;
      // only add new path if it isn't already there
      if (std::find(newDataDirs.begin(), newDataDirs.end(), newDirPath.string()) == newDataDirs.end())
        newDataDirs.emplace_back(newDirPath.string());
    } catch (const std::exception &) {
      continue;
    }
  }
 
  setDataSearchDirs(newDataDirs);
}
 
void ConfigServiceImpl::appendDataSearchDir(const std::string &path) {
  if (path.empty())
    return;
 
  std::filesystem::path dirPath;
  try {
    dirPath = std::filesystem::path(path);
    // Ensure it has a trailing slash for consistency
    std::string pathStr = dirPath.string();
    if (pathStr.back() != '/' && pathStr.back() != '\\') {
      pathStr += "/";
    }
    if (!isInDataSearchList(pathStr)) {
      auto newSearchString = Strings::join(std::begin(m_dataSearchDirs), std::end(m_dataSearchDirs), ";");
      newSearchString.append(";" + path);
      setString("datasearch.directories", newSearchString);
    }
  } catch (const std::exception &) {
    return;
  }
}
 
void ConfigServiceImpl::setInstrumentDirectories(const std::vector<std::string> &directories) {
  m_instrumentDirs = directories;
}
 
const std::vector<std::string> &ConfigServiceImpl::getInstrumentDirectories() const { return m_instrumentDirs; }
 
const std::string ConfigServiceImpl::getInstrumentDirectory() const { return m_instrumentDirs.back(); }
const std::string ConfigServiceImpl::getVTPFileDirectory() {
  // Determine the search directory for XML instrument definition files (IDFs)
  std::string directoryName = getString("instrumentDefinition.vtp.directory");
 
  if (directoryName.empty()) {
    std::filesystem::path path(getAppDataDir());
    path /= "instrument";
    path /= "geometryCache";
    directoryName = path.string();
  }
  return directoryName;
}
void ConfigServiceImpl::cacheInstrumentPaths() {
  m_instrumentDirs.clear();
 
  std::filesystem::path path(getAppDataDir());
  path /= "instrument";
  const std::string appdatadir = path.string();
  addDirectoryifExists(appdatadir, m_instrumentDirs);
 
#ifndef _WIN32
  addDirectoryifExists("/etc/mantid/instrument", m_instrumentDirs);
#endif
 
  // Determine the search directory for XML instrument definition files (IDFs)
  std::string directoryName = getString("instrumentDefinition.directory", true);
  if (directoryName.empty()) {
    // This is the assumed deployment directory for IDFs, where we need to be
    // relative to the
    // directory of the executable, not the current working directory.
    std::filesystem::path basePath(getPropertiesDir());
    directoryName = (basePath / ".." / "instrument").lexically_normal().string();
  }
  addDirectoryifExists(directoryName, m_instrumentDirs);
}
 
bool ConfigServiceImpl::addDirectoryifExists(const std::string &directoryName,
                                             std::vector<std::string> &directoryList) {
  try {
    if (std::filesystem::is_directory(directoryName)) {
      directoryList.emplace_back(directoryName);
      return true;
    } else {
      g_log.information("Unable to locate directory at: " + directoryName);
      return false;
    }
  } catch (const std::filesystem::filesystem_error &) {
    g_log.information("Unable to locate directory at: " + directoryName);
    return false;
  } catch (const std::exception &) {
    g_log.information("Unable to locate directory at: " + directoryName);
    return false;
  }
}
 
const std::vector<std::string> ConfigServiceImpl::getFacilityFilenames(const std::string &fName) {
  std::vector<std::string> returnPaths;
 
  // first try the supplied file
  if (!fName.empty()) {
    if (std::filesystem::exists(fName)) {
      returnPaths.emplace_back(fName);
      return returnPaths;
    }
  }
 
  // search all of the instrument directories
  const auto &directoryNames = getInstrumentDirectories();
 
  // only use downloaded instruments if configured to download
  const std::string updateInstrStr = this->getString("UpdateInstrumentDefinitions.OnStartup");
 
  auto instrDir = directoryNames.begin();
 
  // If we are not updating the instrument definitions
  // update the iterator, this means we will skip the folder in HOME and
  // look in the instrument folder in mantid install directory or mantid source
  // code directory
  if (!(updateInstrStr == "1" || updateInstrStr == "on" || updateInstrStr == "On") && directoryNames.size() > 1) {
    instrDir++;
  }
 
  // look through all the possible files
  for (; instrDir != directoryNames.end(); ++instrDir) {
    std::filesystem::path p(*instrDir);
    p /= "Facilities.xml";
    std::string filename = p.string();
 
    if (std::filesystem::exists(filename))
      returnPaths.emplace_back(filename);
  }
 
  if (returnPaths.size() > 0) {
    return returnPaths;
  }
 
  // getting this far means the file was not found
  std::string directoryNamesList = boost::algorithm::join(directoryNames, ", ");
  throw std::runtime_error("Failed to find \"Facilities.xml\". Searched in " + directoryNamesList);
}
 
void ConfigServiceImpl::updateFacilities(const std::string &fName) {
  clearFacilities();
 
  // Try to find the file. If it does not exist we will crash, and cannot read
  // the Facilities file
  const auto fileNames = getFacilityFilenames(fName);
  size_t attemptIndex = 0;
  bool success = false;
  while ((!success) && (attemptIndex < fileNames.size())) {
    const auto &fileName = fileNames[attemptIndex];
    try {
      // Set up the DOM parser and parse xml file
      Poco::AutoPtr<Poco::XML::Document> pDoc;
      try {
        Poco::XML::DOMParser pParser;
        pDoc = pParser.parse(fileName);
      } catch (...) {
        throw Kernel::Exception::FileError("Unable to parse file:", fileName);
      }
 
      // Get pointer to root element
      Poco::XML::Element *pRootElem = pDoc->documentElement();
      if (!pRootElem->hasChildNodes()) {
        throw std::runtime_error("No root element in Facilities.xml file");
      }
 
      const Poco::AutoPtr<Poco::XML::NodeList> pNL_facility = pRootElem->getElementsByTagName("facility");
      const size_t n = pNL_facility->length();
 
      for (unsigned long i = 0; i < n; ++i) {
        const auto *elem = dynamic_cast<Poco::XML::Element *>(pNL_facility->item(i));
        if (elem) {
          m_facilities.emplace_back(new FacilityInfo(elem));
        }
      }
 
      if (m_facilities.empty()) {
        throw std::runtime_error("The facility definition file " + fileName + " defines no facilities");
      }
 
      // if we got here we have suceeded and can exit the loop
      success = true;
    } catch (std::runtime_error &ex) {
      // log this failure to load a file
      g_log.error() << "Failed to load the facilities.xml file at " << fileName << "\nIt might be corrupt.  "
                    << ex.what() << "\nWill try to load another version.\n";
      attemptIndex++;
      // move on to the next file index if available
      if (attemptIndex == fileNames.size()) {
        const std::string errorMessage = "No more Facilities.xml files can be found, Mantid will not be "
                                         "able to start, Sorry.  Try reinstalling Mantid.";
        // This is one of the few times that both logging a messge and throwing
        // might make sense
        // as the error reporter tends to swallow the thrown message.
        g_log.error() << errorMessage << "\n";
        // Throw an exception as we have run out of files to try
        throw std::runtime_error(errorMessage);
      }
    }
  }
}
 
void ConfigServiceImpl::clearFacilities() {
  for (const auto &facility : m_facilities) {
    delete facility;
  }
  m_facilities.clear();
  m_instrumentPrefixesCache.clear();
  m_isInstrumentPrefixesCached = false;
}
 
const InstrumentInfo &ConfigServiceImpl::getInstrument(const std::string &instrumentName) const {
 
  // Let's first search for the instrument in our default facility
  std::string defaultFacility = getFacility().name();
 
  if (!defaultFacility.empty()) {
    try {
      g_log.debug() << "Looking for " << instrumentName << " at " << defaultFacility << ".\n";
      return getFacility(defaultFacility).instrument(instrumentName);
    } catch (Exception::NotFoundError &) {
      // Well the instName doesn't exist for this facility
      // Move along, there's nothing to see here...
    }
  }
 
  // Now let's look through the other facilities
  for (auto facility : m_facilities) {
    try {
      g_log.debug() << "Looking for " << instrumentName << " at " << (*facility).name() << ".\n";
      return (*facility).instrument(instrumentName);
    } catch (Exception::NotFoundError &) {
      // Well the instName doesn't exist for this facility...
      // Move along, there's nothing to see here...
    }
  }
 
  const std::string errMsg = "Failed to find an instrument with this name in any facility: '" + instrumentName + "' -";
  g_log.debug("Instrument " + instrumentName + " not found");
  throw Exception::NotFoundError(errMsg, instrumentName);
}
 
const std::string ConfigServiceImpl::findLongestInstrumentPrefix(const std::string &hint) const {
  if (!m_isInstrumentPrefixesCached) {
    std::vector<std::string> names;
 
    for (const auto &facility : m_facilities) {
      const auto &insts = facility->instruments();
      for (const auto &inst : insts) {
        names.emplace_back(inst.shortName());
        names.emplace_back(inst.name());
      }
    }
 
    std::sort(names.begin(), names.end());
    const auto last = std::unique(names.begin(), names.end());
    names.erase(last, names.end());
    m_instrumentPrefixesCache = std::move(names);
    m_isInstrumentPrefixesCached = true;
  }
 
  std::string longestPrefix;
  // Binary search for the hint in the list of instrument prefixes. Since this is a sorted list the longest prefix will
  // be found by searching backwards from the insertion point.
  const auto match = std::upper_bound(m_instrumentPrefixesCache.cbegin(), m_instrumentPrefixesCache.cend(), hint);
  if (match != m_instrumentPrefixesCache.cbegin()) {
    auto it = std::prev(match);
    while (true) {
      if (hint.starts_with(*it)) {
        longestPrefix = *it;
        break;
      }
      if ((*it)[0] != hint[0]) {
        break;
      }
      if (it == m_instrumentPrefixesCache.cbegin()) {
        break;
      }
      it = std::prev(it);
    }
  }
 
  return longestPrefix;
}
 
const std::vector<FacilityInfo *> ConfigServiceImpl::getFacilities() const { return m_facilities; }
 
const std::vector<std::string> ConfigServiceImpl::getFacilityNames() const {
  auto names = std::vector<std::string>(m_facilities.size());
  std::transform(m_facilities.cbegin(), m_facilities.cend(), names.begin(),
                 [](const FacilityInfo *facility) { return facility->name(); });
 
  return names;
}
 
const FacilityInfo &ConfigServiceImpl::getFacility() const {
  std::string defFacility = getString("default.facility");
  if (defFacility.empty()) {
    defFacility = " ";
  }
  return this->getFacility(defFacility);
}
 
const FacilityInfo &ConfigServiceImpl::getFacility(const std::string &facilityName) const {
  if (facilityName.empty())
    return this->getFacility();
 
  auto facility = std::find_if(m_facilities.cbegin(), m_facilities.cend(),
                               [&facilityName](const auto f) { return f->name() == facilityName; });
 
  if (facility != m_facilities.cend()) {
    return **facility;
  }
 
  throw Exception::NotFoundError("Facilities", facilityName);
}
 
void ConfigServiceImpl::setFacility(const std::string &facilityName) {
  const FacilityInfo *foundFacility = nullptr;
 
  try {
    // Get facility looks up by string - so re-use that to check if the facility
    // is known
    foundFacility = &getFacility(facilityName);
  } catch (const Exception::NotFoundError &) {
    g_log.error("Failed to set default facility to be " + facilityName + ". Facility not found");
    throw;
  }
  assert(foundFacility);
  setString("default.facility", facilityName);
 
  const auto &associatedInsts = foundFacility->instruments();
  if (associatedInsts.empty()) {
    throw std::invalid_argument("The selected facility has no instruments associated with it");
  }
 
  // Update the default instrument to be one from this facility
  setString("default.instrument", associatedInsts[0].name());
}
 
void ConfigServiceImpl::addObserver(const Poco::AbstractObserver &observer) const {
  m_notificationCenter.addObserver(observer);
}
 
void ConfigServiceImpl::removeObserver(const Poco::AbstractObserver &observer) const {
  m_notificationCenter.removeObserver(observer);
}
 
/*
Gets the system proxy information
@url A url to match the proxy to
@return the proxy information.
*/
Kernel::ProxyInfo &ConfigServiceImpl::getProxy(const std::string &url) {
  if (!m_isProxySet) {
    // set the proxy
    // first check if the proxy is defined in the properties file
    auto proxyHost = getValue<std::string>("proxy.host");
    auto proxyPort = getValue<int>("proxy.port");
 
    if (proxyHost.has_value() && proxyPort.has_value()) {
      // set it from the config values
      m_proxyInfo = ProxyInfo(proxyHost.value(), proxyPort.value(), true);
    } else {
      // get the system proxy
      Poco::URI uri(url);
      Mantid::Kernel::NetworkProxy proxyHelper;
      m_proxyInfo = proxyHelper.getHttpProxy(uri.toString());
    }
    m_isProxySet = true;
  }
  return m_proxyInfo;
}
 
std::string ConfigServiceImpl::getFullPath(const std::string &filename, const bool ignoreDirs,
                                           const int options) const {
  std::string fName = Kernel::Strings::strip(filename);
  g_log.debug() << "getFullPath(" << fName << ")\n";
  // If this is already a full path, nothing to do
  std::filesystem::path filepath(fName);
  if (filepath.is_absolute())
    return fName;
  // First try the path relative to the current directory. Can throw in some
  // circumstances with extensions that have wild cards
  try {
    std::filesystem::path fullPath = std::filesystem::current_path() / fName;
    if (std::filesystem::exists(fullPath) && (!ignoreDirs || !std::filesystem::is_directory(fullPath)))
      return fullPath.string();
  } catch (const std::exception &) {
  }
 
  auto directoryNames = getDataSearchDirs();
  const auto &instrDirectories = getInstrumentDirectories();
  directoryNames.insert(directoryNames.end(), instrDirectories.begin(), instrDirectories.end());
  for (const auto &searchPath : directoryNames) {
    g_log.debug() << "Searching for " << fName << " in " << searchPath << "\n";
// On windows globbing is not working properly with network drives
// for example a network drive containing a $
// For this reason, and since windows is case insensitive anyway
// a special case is made for windows
#ifdef _WIN32
    if (fName.find("*") != std::string::npos) {
#endif
      std::filesystem::path path = std::filesystem::path(searchPath) / fName;
      std::set<std::string> files;
      Kernel::Glob::glob(path.string(), files, options);
      if (!files.empty()) {
        std::filesystem::path matchPath(*files.begin());
        if (ignoreDirs && std::filesystem::is_directory(matchPath)) {
          continue;
        }
        return *files.begin();
      }
#ifdef _WIN32
    } else {
      std::filesystem::path path = std::filesystem::path(searchPath) / fName;
      if (std::filesystem::exists(path) && !(ignoreDirs && std::filesystem::is_directory(path))) {
        return path.string();
      }
    }
#endif
  }
  return "";
}
 
void ConfigServiceImpl::setLogLevel(int logLevel, bool quiet) {
  Mantid::Kernel::Logger::setLevelForAll(logLevel);
  // update the internal value to keep strings in sync
  m_pConf->setString(LOG_LEVEL_KEY, g_log.getLevelName());
 
  if (!quiet) {
    g_log.log("logging set to " + Logger::PriorityNames[std::size_t(logLevel)] + " priority",
              static_cast<Logger::Priority>(logLevel));
  }
}
 
void ConfigServiceImpl::setLogLevel(std::string const &logLevel, bool quiet) {
  Mantid::Kernel::Logger::setLevelForAll(logLevel);
  // update the internal value to keep strings in sync
  m_pConf->setString(LOG_LEVEL_KEY, g_log.getLevelName());
 
  if (!quiet) {
    g_log.log("logging set to " + logLevel + " priority", static_cast<Logger::Priority>(g_log.getLevel()));
  }
}
 
std::string ConfigServiceImpl::getLogLevel() { return g_log.getLevelName(); }
 
template DLLExport std::optional<double> ConfigServiceImpl::getValue(const std::string &);
template DLLExport std::optional<std::string> ConfigServiceImpl::getValue(const std::string &);
template DLLExport std::optional<int> ConfigServiceImpl::getValue(const std::string &);
template DLLExport std::optional<size_t> ConfigServiceImpl::getValue(const std::string &);
#ifdef _MSC_VER
template DLLExport std::optional<bool> ConfigServiceImpl::getValue(const std::string &);
#endif
 
 
} // namespace Kernel
} // namespace Mantid