ModuleManager.cc

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#include <framework/core/Module.h>
#include <framework/core/ModuleManager.h>
#include <framework/utilities/FileSystem.h>
#include <framework/logging/Logger.h>
 
#include <regex>
#include <fstream>
 
using namespace Belle2;
using namespace std;
 
#define MAP_FILE_EXTENSION ".b2modmap"
#define LIB_FILE_EXTENSION ".so"
 
 
ModuleManager& ModuleManager::Instance()
{
  static ModuleManager instance;
  return instance;
}
 
 
void ModuleManager::registerModuleProxy(ModuleProxyBase* moduleProxy)
{
  //Only register a module proxy if it was not yet registered.
  if (m_registeredProxyMap.count(moduleProxy->getModuleName()) == 0) {
    m_registeredProxyMap.insert(make_pair(moduleProxy->getModuleName(), moduleProxy));
  } else {
    B2ERROR("There seems to be more than one module called '" << moduleProxy->getModuleName() <<
            "'. Since module names are unique, you must rename one of them!");
  }
}
 
 
void ModuleManager::addModuleSearchPath(const string& path)
{
  if (FileSystem::isDir(path)) {
    m_moduleSearchPathList.push_back(path);
 
    //Search the path for map files and add the contained module names to the known module names
    auto fullPath = std::filesystem::absolute(std::filesystem::path(path));
    std::filesystem::directory_iterator endIter;
 
 
    map<string, string> moduleNameLibMap;
    for (std::filesystem::directory_iterator dirItr(fullPath); dirItr != endIter; ++dirItr) {
      //Only files in the given folder are taken, subfolders are not used.
      if (std::filesystem::is_regular_file(dirItr->status())) {
        if (std::filesystem::path(dirItr->path()).extension() == MAP_FILE_EXTENSION) {
          fillModuleNameLibMap(moduleNameLibMap, *dirItr);
        }
      }
    }
    //put modules into central map, if they haven't been  added yet
    m_moduleNameLibMap.insert(moduleNameLibMap.begin(), moduleNameLibMap.end());
  }
}
 
 
const list<string>& ModuleManager::getModuleSearchPaths() const
{
  return m_moduleSearchPathList;
}
 
 
const map<string, string>& ModuleManager::getAvailableModules() const
{
  return m_moduleNameLibMap;
}
 
 
ModulePtr ModuleManager::registerModule(const string& moduleName, std::string sharedLibPath) noexcept(false)
{
  auto moduleIter =  m_registeredProxyMap.find(moduleName);
 
  // Print an error message and then raise the exception ...
  auto error = [&moduleName](const std::string & text) -> void {
    auto exception = ModuleNotCreatedError() << moduleName << text;
    B2ERROR(exception.what());
    throw exception;
  };
 
  //If the proxy of the module was not already registered, load the corresponding shared library first
  if (moduleIter == m_registeredProxyMap.end()) {
    // no library specified, try to find it from map of known modules
    if (sharedLibPath.empty()) {
      auto libIter = m_moduleNameLibMap.find(moduleName);
      if (libIter != m_moduleNameLibMap.end()) {
        sharedLibPath = libIter->second;
      } else {
        error("The module is not known to the framework!");
      }
    }
    // Now we have a library name (provided or determined, try to load)
    if (!FileSystem::isFile(sharedLibPath)) {
      error("Could not load shared library " + sharedLibPath + ", file does not exist!");
    }
    if (!FileSystem::loadLibrary(sharedLibPath)) {
      error("Could not load shared library " + sharedLibPath + ".");
    }
    //Check if the loaded shared library file contained the module
    moduleIter =  m_registeredProxyMap.find(moduleName);
    if (moduleIter == m_registeredProxyMap.end()) {
      error("The shared library " + sharedLibPath + " does not contain the module!");
    }
  }
 
  //Create an instance of the module found or loaded in the previous steps and return it.
  //The iterator cannot point to the end of the map, we checked in all branches.
  ModulePtr currModulePtr = moduleIter->second->createModule();
  m_createdModulesList.push_back(currModulePtr);
  return currModulePtr;
}
 
 
const ModulePtrList& ModuleManager::getCreatedModules() const
{
  return m_createdModulesList;
}
 
 
ModulePtrList ModuleManager::getModulesByProperties(const ModulePtrList& modulePathList, unsigned int propertyFlags)
{
  ModulePtrList tmpModuleList;
 
  for (const ModulePtr& module : modulePathList)
    if (module->hasProperties(propertyFlags)) tmpModuleList.push_back(module);
 
  return tmpModuleList;
}
 
bool ModuleManager::allModulesHaveFlag(const ModulePtrList& list, unsigned int flag)
{
  for (const auto& m : list) {
    if (!m->hasProperties(flag))
      return false;
  }
  return true;
}
 
 
//============================================================================
//                              Private methods
//============================================================================
 
void ModuleManager::fillModuleNameLibMap(std::map<std::string, std::string>& moduleNameLibMap,
                                         const std::filesystem::directory_entry& mapPath)
{
  //Check if the associated shared library file exists
  string sharedLibPath = std::filesystem::path(mapPath).replace_extension(LIB_FILE_EXTENSION).string();
  if (!FileSystem::fileExists(sharedLibPath)) {
    B2WARNING("The shared library file: " << sharedLibPath << " doesn't exist, but is required by " << mapPath.path().string());
    return;
  }
 
  //Open the map file and parse the content line by line
  ifstream mapFile(mapPath.path().string().c_str());
  string currentLine;
 
  //Read each line of the map file and use boost regular expression to find the module name string in brackets.
  std::regex expression("^REG_MODULE\\((.+)\\)$");
  std::match_results<std::string::const_iterator> matchResult;
 
  int lineNr{0};
  while (getline(mapFile, currentLine)) {
    ++lineNr;
 
    if (!std::regex_match(currentLine, matchResult, expression)) {
      B2ERROR("Problem parsing map file " << mapPath << ": Invalid entry in line " << lineNr << ", skipping remaining file");
      return;
    }
 
    string moduleName(matchResult[1].first, matchResult[1].second);
    //Add result to map
    if (moduleNameLibMap.count(moduleName) == 0) {
      moduleNameLibMap.insert(make_pair(moduleName, sharedLibPath));
    } else {
      B2ERROR("There seems to be more than one module called '" << moduleName <<
              "'. Since module names are unique, you must rename one of them!");
    }
  }
 
  //Close the map file
  mapFile.close();
}
 
ModuleManager::ModuleManager() = default;
 
ModuleManager::~ModuleManager() = default;
 
void ModuleManager::reset()
{
  m_createdModulesList.clear();
}