ConfigService.cpp

 */
std::vector<std::string> ConfigServiceImpl::getKeys(const std::string& keyName) const
{
  std::vector<std::string> rawKeys;
  std::vector<std::string> keyVector;
  keyVector.reserve(rawKeys.size());
  try
  {
    m_pConf->keys(keyName,rawKeys);
    // Work around a limitation of Poco < v1.4 which has no remove functionality so 
    // check those that have been marked with the correct flag
    const size_t nraw = rawKeys.size();
    for( size_t i = 0; i < nraw; ++i )
    {
      const std::string key = rawKeys[i];
      try
      {
        if( m_pConf->getString(key) == m_removedFlag ) continue;
      }
      catch (Poco::NotFoundException&)
      {
      }
      keyVector.push_back(key);
    }
  }
  catch (Poco::NotFoundException&)
  {
    g_log.debug() << "Unable to find " << keyName << " in the properties file" << std::endl;
    keyVector.clear();
  }
  return keyVector;
}

/** Removes a key from the memory stored properties file and inserts the key into the 
 *  changed key list so that when the program calls saveConfig the properties file will
 *  be the same and not contain the key no more
 *
 *  @param rootName :: The key that is to be deleted
 */
void ConfigServiceImpl::remove(const std::string& rootName) const
{
  try
  {
    // m_pConf->remove(rootName) will only work in Poco v >=1.4. Current Ubuntu and RHEL use 1.3.x
    // Simulate removal by marking with a flag value
    m_pConf->setString(rootName, m_removedFlag);
  }
  catch (Poco::NotFoundException&)
  {
    g_log.debug() << "Unable to find " << rootName << " in the properties file" << std::endl;
  }
  m_changed_keys.insert(rootName);
}

/** Checks to see whether the given key exists.
 *
 *  @param rootName :: The case sensitive key that you are looking to see if exists.
 *  @returns Boolean value denoting whether the exists or not.
 */
bool ConfigServiceImpl::hasProperty(const std::string& rootName) const
{
  // Work around a limitation of Poco < v1.4 which has no remove functionality
  return m_pConf->hasProperty(rootName) && m_pConf->getString(rootName) != m_removedFlag;
}

/** Checks to see whether the given file target is an executable one and it exists.
 * This method will expand environment variables found in the given file path.
 *
 *  @param target :: The path to the file you wish to see whether it's an executable.
 *  @returns Boolean value denoting whether the file is an executable or not.
 */
bool ConfigServiceImpl::isExecutable(const std::string& target) const
{    
  try
  {
    std::string expTarget = Poco::Path::expand(target);
    Poco::File tempFile = Poco::File(expTarget);

    if (tempFile.exists())
    {
      if(tempFile.canExecute())
        return true;
      else 
        return false;
    }
    else
      return false;
  }
  catch(Poco::Exception&)
  {
    return false;
  }
 
}

/** Runs a command line string to open a program. The function can take program arguments.
 *  i.e it can load in a file to the program on startup.
 *
 *  This method will expand environment variables found in the given file path.
 *
 *  @param programFilePath :: The directory where the program is located.
 *  @param programArguments :: The arguments that the program can take on startup. For example,
 *  the file to load up.
 */

void ConfigServiceImpl::launchProcess(const std::string& programFilePath, const std::vector<std::string>& programArguments) const
{
  try
  {
    std::string expTarget = Poco::Path::expand(programFilePath);
    Poco::Process::launch(expTarget, programArguments);
  }
  catch(Poco::SystemException &e)
  {
    throw std::runtime_error(e.what());
  }
}

/**
 * Set a configuration property. An existing key will have its value updated.
 * @param key :: The key to refer to this property
 * @param value :: The value of the property
 */
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;

  //Ensure we keep a correct full path
  std::map<std::string, bool>::const_iterator itr = m_ConfigPaths.find(key);
  if (itr != m_ConfigPaths.end())
  {
    m_AbsolutePaths[key] = makeAbsolute(value, key);
  }

  if (key == "datasearch.directories" )
  {
    cacheDataSearchPaths();
  }
  else if (key == "usersearch.directories")
  {
    cacheUserSearchPaths();
  }  
  else if (key == "instrumentDefinition.directory")
  {
    cacheInstrumentPaths();
  }
  else if (key == "defaultsave.directory")
  {
    appendDataSearchDir(value);
  }

  m_pConf->setString(key, value);

  m_notificationCenter.postNotification(new ValueChanged(key, value, old));
  m_changed_keys.insert(key);
}

/** Searches for a string within the currently loaded configuaration values and
 *  attempts to convert the values to the template type supplied.
 *
 *  @param keyName :: The case sensitive name of the property that you need the value of.
 *  @param out ::     The value if found
 *  @returns A success flag - 0 on failure, 1 on success
 */
template<typename T>
int ConfigServiceImpl::getValue(const std::string& keyName, T& out)
{
  std::string strValue = getString(keyName);
  int result = Mantid::Kernel::Strings::convert(strValue, out);
  return result;
}

/**
 * Return the full filename of the local properties file.
 * @returns A string containing the full path to the local file.
 */
std::string ConfigServiceImpl::getLocalFilename() const
{
#ifdef _WIN32
  return "Mantid.local.properties";
#else
  return "/etc/mantid.local.properties";
#endif
}

/**
 * Return the full filename of the user properties file
 * @returns A string containing the full path to the user file
 */
std::string ConfigServiceImpl::getUserFilename() const
{
  return getUserPropertiesDir() + m_user_properties_file_name;
}

/** Searches for the string within the environment variables and returns the
 *  value as a string.
 *
 *  @param keyName :: The name of the environment variable that you need the value of.
 *  @returns The string value of the property
 */
std::string ConfigServiceImpl::getEnvironment(const std::string& keyName)
{
  return m_pSysConfig->getString("system.env." + keyName);
}

/** Gets the name of the host operating system
 *
 *  @returns The name pf the OS version
 */
std::string ConfigServiceImpl::getOSName()
{
  return m_pSysConfig->getString("system.osName");
}

/** Gets the name of the computer running Mantid
 *
 *  @returns The  name of the computer
 */
std::string ConfigServiceImpl::getOSArchitecture()
{
  return m_pSysConfig->getString("system.osArchitecture");
}

/** Gets the name of the operating system Architecture
 *
 * @returns The operating system architecture
 */
std::string ConfigServiceImpl::getComputerName()
{
  return m_pSysConfig->getString("system.nodeName");
}

/** Gets the name of the operating system version
 *
 * @returns The operating system version
 */
std::string ConfigServiceImpl::getOSVersion()
{
  return m_pSysConfig->getString("system.osVersion");
}

/// @returns The name of the current user as reported by the environment.
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 (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 (Poco::NotFoundException &e) {
    UNUSED_ARG(e); // let it drop on the floor
  }

  // give up and return an empty string
  return std::string();
}

/** Gets the absolute path of the current directory containing the dll
 *
 * @returns The absolute path of the current directory containing the dll
 */
std::string ConfigServiceImpl::getCurrentDir()
{
  return m_pSysConfig->getString("system.currentDir");
}

/** Gets the absolute path of the current directory containing the dll. Const version.
 *
 * @returns The absolute path of the current directory containing the dll
 */
std::string ConfigServiceImpl::getCurrentDir() const
{
  return m_pSysConfig->getString("system.currentDir");
}

/** Gets the absolute path of the temp directory
 *
 * @returns The absolute path of the temp directory
 */
std::string ConfigServiceImpl::getTempDir()
{
  return m_pSysConfig->getString("system.tempDir");
}

/** Gets the absolute path of the appdata directory
*
* @returns The absolute path of the appdata directory
*/
std::string ConfigServiceImpl::getAppDataDir()
{
  const std::string applicationName = "mantid";
#if POCO_OS == POCO_OS_WINDOWS_NT
  const std::string vendorName = "mantidproject"; 
  std::string appdata = std::getenv("APPDATA");
  Poco::Path path(appdata);
  path.makeDirectory();
  path.pushDirectory(vendorName);
  path.pushDirectory(applicationName);
  return path.toString();
#else //linux and mac
  Poco::Path path(Poco::Path::home());
  path.pushDirectory("." + applicationName);
  return path.toString();
#endif
}

/**
 * Get the directory containing the program executable
 * @returns A string containing the path of the directory 
 * containing the executable, including a trailing slash
 */
std::string ConfigServiceImpl::getDirectoryOfExecutable() const
{
  return Poco::Path(getPathToExecutable()).parent().toString();
}

/**
  * Get the full path to the executing program (i.e. whatever Mantid is embedded in) 
  * @returns A string containing the full path the the executable
  */
std::string ConfigServiceImpl::getPathToExecutable() const
{
  std::string execpath("");
  const size_t LEN(1024);
  // cppcheck-suppress variableScope
  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;
}

/**
 * Check if the path is on a network drive
 * @param path :: The path to be checked
 * @return True if the path is on a network drive.
 */
bool ConfigServiceImpl::isNetworkDrive(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
    UNUSED_ARG(path);
  // Not yet implemented for the mac
  return false;
#endif
}

/**
 * Set the environment variable for the PV_PLUGIN_PATH based on where Mantid is.
 */
void ConfigServiceImpl::setParaViewPluginPath() const
{
  std::string mantid_loc = this->getDirectoryOfExecutable();
  Poco::Path pv_plugin_path(mantid_loc + "/pvplugins/pvplugins"); // Developer build paths
  pv_plugin_path = pv_plugin_path.absolute();
  g_log.debug() << "Trying " << pv_plugin_path.toString() << " as PV_PLUGIN_PATH\n";
  Poco::File pv_plugin(pv_plugin_path.toString());
  if (!pv_plugin.exists() || !pv_plugin.isDirectory())
  {
    // Installation paths
    g_log.debug("ParaView plugin directory \"" + pv_plugin.path() + "\" does not exist. Trying properties file location.");
    std::string user_loc = this->getString("pvplugins.directory");
    if(user_loc.empty())
    {
      g_log.debug("No ParaView plugin directory specified in the properties file.");
      return; // it didn't work
    }
    pv_plugin_path = Poco::Path(user_loc, "pvplugins");
    pv_plugin_path = pv_plugin_path.absolute();
    pv_plugin = Poco::File(pv_plugin_path.toString());
    if (!pv_plugin.exists() || !pv_plugin.isDirectory())
    {
      g_log.debug("ParaView plugin directory \"" + pv_plugin.path() + "\" does not exist");
      return; // it didn't work
    }
  }

  // one of the two choices worked so set to that directory
  g_log.debug("Setting PV_PLUGIN_PATH = \"" + pv_plugin.path() + "\"");
  Poco::Environment::set("PV_PLUGIN_PATH", pv_plugin.path());
}

/**
 * Gets the directory that we consider to be the directory containing the Mantid.properties file. 
 * Basically, this is the either the directory pointed to by MANTIDPATH or the directory of the current
 * executable if this is not set.
 * @returns The directory to consider as the base directory, including a trailing slash
 */
std::string ConfigServiceImpl::getPropertiesDir() const
{
  return m_strBaseDir;
}

/**
 * Return the directory that Mantid should use for writing any files it needs so that
 * this is kept separated to user saved files. A trailing slash is appended
 * so that filenames can more easily be concatenated with this
 * @return the directory that Mantid should use for writing files
 */
std::string ConfigServiceImpl::getUserPropertiesDir() const
{
#ifdef _WIN32
  return m_strBaseDir;
#else
  Poco::Path datadir(m_pSysConfig->getString("system.homeDir"));
  datadir.append(".mantid");
  // Create the directory if it doesn't already exist
  Poco::File(datadir).createDirectory();
  return datadir.toString() + "/";
#endif
}

/**
 * Return the list of search paths
 * @returns A vector of strings containing the defined search directories
 */
const std::vector<std::string>& ConfigServiceImpl::getDataSearchDirs() const
{
  return m_DataSearchDirs;
}

/**
 * Set a list of search paths via a vector
 * @param searchDirs :: A list of search directories
 */
void ConfigServiceImpl::setDataSearchDirs(const std::vector<std::string> &searchDirs)
{
  std::string searchPaths = boost::join(searchDirs, ";");
  setDataSearchDirs(searchPaths);
}

/**
 * Set a list of search paths via a string
 * @param searchDirs :: A string containing a list of search directories separated by a semi colon (;).
 */
void ConfigServiceImpl::setDataSearchDirs(const std::string &searchDirs)
{
  setString("datasearch.directories", searchDirs);
}

/**
 *  Adds the passed path to the end of the list of data search paths
 *  the path name must be absolute
 *  @param path :: the absolute path to add
 */
void ConfigServiceImpl::appendDataSearchDir(const std::string & path)
{
  if ( path.empty() ) return;

  Poco::Path dirPath;
  try
  {
    dirPath = Poco::Path(path);
    dirPath.makeDirectory();
  }
  catch(Poco::PathSyntaxException &)
  {
    return;
  }
  if (!isInDataSearchList(dirPath.toString()))
  {
    std::string newSearchString;
    std::vector<std::string>::const_iterator it = m_DataSearchDirs.begin();
    for (; it != m_DataSearchDirs.end(); ++it)
    {
      newSearchString.append(*it);
      newSearchString.append(";");
    }
    newSearchString.append(path);
    setString("datasearch.directories", newSearchString);
  }
}

/**
 * Return the list of user search paths
 * @returns A vector of strings containing the defined search directories
 */
const std::vector<std::string>& ConfigServiceImpl::getUserSearchDirs() const
{
  return m_UserSearchDirs;
}

/**
 * Return the search directories for XML instrument definition files (IDFs)
 * @returns An ordered list of paths for instrument searching
 */
const std::vector<std::string>& ConfigServiceImpl::getInstrumentDirectories() const
{
  return m_InstrumentDirs;
}

/**
 * Return the base search directories for XML instrument definition files (IDFs)
 * @returns a last entry of getInstrumentDirectories
 */
const std::string ConfigServiceImpl::getInstrumentDirectory() const
{
  return m_InstrumentDirs[m_InstrumentDirs.size()-1];
}

/**
 * Fills the internal cache of instrument definition directories
 */
void ConfigServiceImpl::cacheInstrumentPaths()
{
    m_InstrumentDirs.clear();
    Poco::Path path(getAppDataDir());
    path.makeDirectory();
    path.pushDirectory("instrument");
    std::string appdatadir =  path.toString();
    addDirectoryifExists(appdatadir,m_InstrumentDirs);

#ifndef _WIN32
    std::string etcdatadir =  "/etc/mantid/instrument";
    addDirectoryifExists(etcdatadir,m_InstrumentDirs);
#endif

    // Determine the search directory for XML instrument definition files (IDFs)
    std::string directoryName = getString("instrumentDefinition.directory");
    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.
      directoryName = Poco::Path(getPropertiesDir()).resolve("../instrument").toString();
    }
    addDirectoryifExists(directoryName,m_InstrumentDirs);
}



/**
 * Verifies the directory exists and add it to the back of the directory list if valid
 * @param directoryName the directory name to add
 * @param directoryList the list to add the directory to
 * @returns true if the directory was valid and added to the list
 */
bool ConfigServiceImpl::addDirectoryifExists(const std::string& directoryName, std::vector<std::string>& directoryList)
{
  try
  {
    if (Poco::File(directoryName).isDirectory())
    {
      directoryList.push_back(directoryName);
      return true;
    }
    else
    {
      g_log.information("Unable to locate directory at: " + directoryName);
      return false;
    }
  }
  catch (Poco::PathNotFoundException&)
  {
    g_log.information("Unable to locate directory at: " + directoryName);
    return false;
  }   
  catch (Poco::FileNotFoundException&)
  {
    g_log.information("Unable to locate directory at: " + directoryName);
    return false;
  } 
}

/**
 * Load facility information from instrumentDir/Facilities.xml file if fName parameter
 * is not set
 * @param fName :: An alternative file name for loading facilities information.
 */
void ConfigServiceImpl::updateFacilities(const std::string& fName)
{
  clearFacilities();

  std::string instrDir = getString("instrumentDefinition.directory");
  std::string fileName = fName.empty() ? instrDir + "Facilities.xml" : fName;

  // Set up the DOM parser and parse xml file
  Poco::XML::DOMParser pParser;
  Poco::AutoPtr<Poco::XML::Document> pDoc;

  try
  {
    try
    {
      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");
    }

    Poco::AutoPtr<Poco::XML::NodeList> pNL_facility = pRootElem->getElementsByTagName("facility");
    unsigned long n = pNL_facility->length();

    for (unsigned long i = 0; i < n; ++i)
    {
      Poco::XML::Element* elem = dynamic_cast<Poco::XML::Element*> (pNL_facility->item(i));
      if (elem)
      {
        m_facilities.push_back(new FacilityInfo(elem));
      }
    }

    if (m_facilities.empty())
    {
      throw std::runtime_error("The facility definition file " + fileName + " defines no facilities");
    }

  } catch (std::exception& e)
  {
    g_log.error(e.what());
  }

}

/// Empty the list of facilities, deleting the FacilityInfo objects in the process
void ConfigServiceImpl::clearFacilities()
{
  for (auto it = m_facilities.begin(); it != m_facilities.end(); ++it)
  {
    delete *it;
  }
  m_facilities.clear();
}

/**
 * Returns instruments with given name
 * @param  instrumentName Instrument name
 * @return the instrument information object
 * @throw NotFoundError if iName was not found
 */
const InstrumentInfo & ConfigServiceImpl::getInstrument(const std::string& instrumentName) const
{

  // Let's first search for the instrument in our default facility
  std::string defaultFacility = ConfigService::Instance().getFacility().name();

  if (!defaultFacility.empty())
  {
    try
    {
      g_log.debug() << "Looking for " << instrumentName << " at " << defaultFacility << "." << std::endl;
      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
  std::vector<FacilityInfo*>::const_iterator it = m_facilities.begin();
  for (; it != m_facilities.end(); ++it)
  {
    try
    {
      g_log.debug() << "Looking for " << instrumentName << " at " << (**it).name() << "." << std::endl;
      return (**it).instrument(instrumentName);
    }
    catch (Exception::NotFoundError &)
    {
      // Well the instName doesn't exist for this facility...
      // Move along, there's nothing to see here...
    }
  }
  g_log.debug("Instrument " + instrumentName + " not found");
  throw Exception::NotFoundError("Instrument", instrumentName);
}

/** Gets a vector of the facility Information objects
 * @return A vector of FacilityInfo objects
 */
const std::vector<FacilityInfo*> ConfigServiceImpl::getFacilities() const
{
  return m_facilities;
}

/** Gets a vector of the facility names
 * @return A vector of the facility Names
 */
const std::vector<std::string> ConfigServiceImpl::getFacilityNames()const
{
  auto names = std::vector<std::string>(m_facilities.size());
  auto itFacilities = m_facilities.begin();
  auto itNames = names.begin();
  for (; itFacilities != m_facilities.end(); ++itFacilities,++itNames)
  {
    *itNames = (**itFacilities).name();
  }
  return names;
}

/** Get the default facility
 * @return the facility information object
 */
const FacilityInfo& ConfigServiceImpl::getFacility() const
{
  std::string defFacility = getString("default.facility");
  if (defFacility.empty())
  {
    defFacility = "ISIS";
  }
  return this->getFacility(defFacility);
}

/**
 * Get a facility
 * @param facilityName :: Facility name
 * @return the facility information object
 * @throw NotFoundException if the facility is not found
 */
const FacilityInfo& ConfigServiceImpl::getFacility(const std::string& facilityName) const
{
  if (facilityName.empty())
    return this->getFacility();

  std::vector<FacilityInfo*>::const_iterator it = m_facilities.begin();
  for (; it != m_facilities.end(); ++it)
  {
    if ((**it).name() == facilityName)
    {
      return **it;
    }
  }

  throw Exception::NotFoundError("Facilities", facilityName);
}

/**
 * Set the default facility
 * @param facilityName the facility name
 * @throw NotFoundException if the facility is not found
 */
void ConfigServiceImpl::setFacility(const std::string &facilityName)
{
  bool found = false;
  // Look through the facilities for a matching one.
  std::vector<FacilityInfo*>::const_iterator it = m_facilities.begin();
  for (; it != m_facilities.end(); ++it)
  {
    if ((**it).name() == facilityName)
    {
      // Found the facility
      found = true;
      // So it's safe to set it as our default
      setString("default.facility", facilityName);
    }
  }
  if (found == false)
  {
    g_log.error("Failed to set default facility to be " + facilityName + ". Facility not found");
    throw Exception::NotFoundError("Facilities", facilityName);
  }

}

/**  Add an observer to a notification
 @param observer :: Reference to the observer to add
 */
void ConfigServiceImpl::addObserver(const Poco::AbstractObserver& observer) const
{
  m_notificationCenter.addObserver(observer);
}

/**  Remove an observer
 @param observer :: Reference to the observer to remove
 */
void ConfigServiceImpl::removeObserver(const Poco::AbstractObserver& observer) const
{
  m_notificationCenter.removeObserver(observer);
}

/*
Ammend paths to point to include the paraview core libraries.
@param path : path to add
*/
void ConfigServiceImpl::setParaviewLibraryPath(const std::string& path)
{
#ifdef _WIN32
  const std::string platformPathName = "PATH";
  Poco::Path existingPath;
  char separator = existingPath.pathSeparator();
  std::string strSeparator;
  strSeparator.push_back(separator);

  if(Poco::Environment::has(platformPathName))
  {
    existingPath = Poco::Environment::get(platformPathName);
    existingPath.append(strSeparator + path);
  }
  else
  {
    existingPath = path;
  }
  const std::string newPath = existingPath.toString();
  Poco::Environment::set(platformPathName, newPath);
#elif defined __linux__
  UNUSED_ARG(path)
  throw std::runtime_error("Cannot dynamically set the library path on Linux");
#elif defined __APPLE__
  throw std::runtime_error("Cannot dynamically set the library path on Mac");
#else
  throw std::runtime_error("ConfigServiceImpl::setParaviewLibraryPath cannot determine the running platform and therefore cannot set the path to the Paraview libraries.");
#endif 
}

/*
Extracts the string from a poco pipe and returns the numerical part.
@param pipe : input pipe.
@return the numerical part of the version string contained inside the pipe.
*/
const std::string extractVersionNumberFromPipe(const Poco::Pipe& pipe)
{
  std::string versionString = "undetermined";
  Poco::PipeInputStream pipeStream(pipe);
  std::stringstream stringStream;
  Poco::StreamCopier::copyStream(pipeStream, stringStream);
  const std::string givenVersion = stringStream.str();
  boost::smatch  match;
  boost::regex expression("(\\d+)\\.(\\d+)\\.?(\\d*)$"); // Gets the version number part.
  if(boost::regex_search(givenVersion, match, expression))
  {
    versionString = match[0];
  }
  return versionString;
}

/*
Checks to see whether paraview usage is explicitly ignored in the property file then, 
quick check to determine if paraview is installed. We make the assumption 
that if the executable paraview binary is on the path that the paraview libraries 
will also be available on the library path, or equivalent.
@return True if paraview is available or not disabled.
*/
bool ConfigServiceImpl::quickParaViewCheck() const
{
  const std::string paraviewIgnoreProperty = "paraview.ignore";
  const bool ignoreParaview = hasProperty(paraviewIgnoreProperty) && atoi(getString(paraviewIgnoreProperty).c_str());
  if(ignoreParaview)
  {
    g_log.debug("Ignoring ParaView");
    return false;
  }
  
  g_log.debug("Checking for ParaView");
  bool isAvailable = false;

  try
  {
    //Try to run "paraview -V", which will succeed if ParaView is installed.
    std::string paraviewDir = getString("paraview.path");
    std::string cmd = "paraview";
    if(!paraviewDir.empty())
    {
      Poco::Path paraviewExe = Poco::Path(paraviewDir, "paraview");
      cmd = paraviewExe.toString();
    }
    std::vector<std::string> args;
    args.push_back("-V");
    Poco::Pipe outPipe, errorPipe;
    Poco::ProcessHandle ph = Poco::Process::launch(cmd, args, 0, &outPipe, &errorPipe);
    const int rc = ph.wait();
    // Only if the paraview query returned successfully.
    if(rc == 1)
    {
      // Check the actual version numbers against what we expect they should be.
      const std::string givenVersionNumber = extractVersionNumberFromPipe(errorPipe);
      const std::string targetVersionNumber = ParaViewVersion::targetVersion();
      if (givenVersionNumber == targetVersionNumber)
      {
        isAvailable = true;
        g_log.information("ParaView is available");
        // Now set the plugin path.
        this->setParaViewPluginPath();
      }
      else
      {
        std::stringstream messageStream;
        messageStream << "The compatible version of ParaView is " << targetVersionNumber << " but the installed version is " << givenVersionNumber;
        g_log.debug(messageStream.str());
        g_log.information("ParaView is not available");
      }
    }
    else
    {
      std::stringstream messageStream;
      messageStream << "ParaView version query failed with code: " << rc;
      g_log.debug(messageStream.str());
      g_log.information("ParaView is not available");
    }
  }
  catch(Poco::SystemException &e)
  {
    g_log.debug(e.what());
    g_log.information("ParaView is not available");
  }
  return isAvailable; 
}

/*
Quick check to determine if VATES is installed.
@return TRUE if available.
*/
bool ConfigServiceImpl::quickVatesCheck() const
{
  std::string path = this->getDirectoryOfExecutable();