edmplugin::PluginManager Class Reference

#include <PluginManager.h>

Classes
class	Config

Public Types
typedef std::map< std::string, Infos >	CategoryToInfos
typedef std::vector< PluginInfo >	Infos
typedef std::vector< std::string >	SearchPath

Public Member Functions
const CategoryToInfos &	categoryToInfos () const
const SharedLibrary &	load (const std::string &iCategory, const std::string &iPlugin)
const std::filesystem::path &	loadableFor (const std::string &iCategory, const std::string &iPlugin)
const PluginManager &	operator= (const PluginManager &)=delete
	PluginManager (const PluginManager &)=delete
const SharedLibrary *	tryToLoad (const std::string &iCategory, const std::string &iPlugin)
	~PluginManager ()

Static Public Member Functions
static PluginManager &	configure (const Config &)
static PluginManager *	get ()
static bool	isAvailable ()
static const std::string &	loadingFile ()
	file name of the shared object being loaded More...
static const std::string &	staticallyLinkedLoadingFileName ()
	if the value returned from loadingFile matches this string then the file is statically linked More...

Public Attributes
edm::signalslot::Signal< void(const std::string &, const std::string &)>	askedToLoadCategoryWithPlugin_
edm::signalslot::Signal< void(const std::filesystem::path &)>	goingToLoad_
edm::signalslot::Signal< void(const SharedLibrary &)>	justLoaded_

Private Member Functions
const std::filesystem::path &	loadableFor_ (const std::string &iCategory, const std::string &iPlugin, bool &ioThrowIfFailElseSucceedStatus)
void	newFactory (const PluginFactoryBase *)
std::recursive_mutex &	pluginLoadMutex ()
	PluginManager (const Config &)

Static Private Member Functions
static std::string &	loadingLibraryNamed_ ()
static PluginManager *&	singleton ()

Private Attributes
CategoryToInfos	categoryToInfos_
tbb::concurrent_unordered_map< std::filesystem::path, std::shared_ptr< SharedLibrary >, PluginManagerPathHasher >	loadables_
std::recursive_mutex	pluginLoadMutex_
SearchPath	searchPath_

Friends
class	DummyFriend

Detailed Description

Definition at line 45 of file PluginManager.h.

Member Typedef Documentation

CategoryToInfos

typedef std::map<std::string, Infos> edmplugin::PluginManager::CategoryToInfos

Definition at line 51 of file PluginManager.h.

Infos

typedef std::vector<PluginInfo> edmplugin::PluginManager::Infos

Definition at line 50 of file PluginManager.h.

SearchPath

typedef std::vector<std::string> edmplugin::PluginManager::SearchPath

Definition at line 49 of file PluginManager.h.

Constructor & Destructor Documentation

PluginManager() [1/2]

edmplugin::PluginManager::PluginManager ( const PluginManager &  )

delete

Referenced by configure().

~PluginManager()

PluginManager::~PluginManager

(

)

Definition at line 123 of file PluginManager.cc.

{}

PluginManager() [2/2]

PluginManager::PluginManager ( const Config &  iConfig )

private

Definition at line 58 of file PluginManager.cc.

                                                                 : searchPath_(iConfig.searchPath()) {
    using std::placeholders::_1;
    const std::filesystem::path& kCacheFile(standard::cachefileName());
    // This is the filename of a file which contains plugins which exist in the
    // base release and which should exists in the local area, otherwise they
    // were removed and we want to catch their usage.
    const std::filesystem::path& kPoisonedCacheFile(standard::poisonedCachefileName());
    //NOTE: This may not be needed :/
    PluginFactoryManager* pfm = PluginFactoryManager::get();
    pfm->newFactory_.connect(std::bind(std::mem_fn(&PluginManager::newFactory), this, _1));
 
    // When building a single big executable the plugins are already registered in the
    // PluginFactoryManager, we therefore only need to populate the categoryToInfos_ map
    // with the relevant information.
    for (PluginFactoryManager::const_iterator i = pfm->begin(), e = pfm->end(); i != e; ++i) {
      categoryToInfos_[(*i)->category()] = (*i)->available();
    }
 
    //read in the files
    //Since we are looping in the 'precidence' order then the lists in categoryToInfos_ will also be
    // in that order
    bool foundAtLeastOneCacheFile = false;
    std::set<std::string> alreadySeen;
    for (SearchPath::const_iterator itPath = searchPath_.begin(), itEnd = searchPath_.end(); itPath != itEnd;
         ++itPath) {
      //take care of the case where the same path is passed in multiple times
      if (alreadySeen.find(*itPath) != alreadySeen.end()) {
        continue;
      }
      alreadySeen.insert(*itPath);
      std::filesystem::path dir(*itPath);
      if (exists(dir)) {
        if (not is_directory(dir)) {
          throw cms::Exception("PluginManagerBadPath")
              << "The path '" << dir.string() << "' for the PluginManager is not a directory";
        }
        std::filesystem::path cacheFile = dir / kCacheFile;
 
        if (readCacheFile(cacheFile, dir, categoryToInfos_)) {
          foundAtLeastOneCacheFile = true;
        }
 
        // We do not check for return code since we do not want to consider a
        // poison cache file as a valid cache file having been found.
        std::filesystem::path poisonedCacheFile = dir / kPoisonedCacheFile;
        readCacheFile(poisonedCacheFile, dir / "poisoned", categoryToInfos_);
      }
    }
    if (not foundAtLeastOneCacheFile and iConfig.mustHaveCache()) {
      auto ex = cms::Exception("PluginManagerNoCacheFile")
                << "No cache files named '" << standard::cachefileName() << "' were found in the directories \n";
      for (auto const& seen : alreadySeen) {
        ex << " '" << seen << "'\n";
      }
      throw ex;
    }
    //Since this should not be called until after 'main' has started, we can set the value
    loadingLibraryNamed_() = "<loaded by another plugin system>";
  }

References edmplugin::PluginFactoryManager::begin(), edmplugin::standard::cachefileName(), categoryToInfos_, DeadROC_duringRun::dir, MillePedeFileConverter_cfg::e, edmplugin::PluginFactoryManager::end(), Exception, edmplugin::PluginFactoryManager::get(), mps_fire::i, loadingLibraryNamed_(), edmplugin::PluginManager::Config::mustHaveCache(), newFactory(), edmplugin::PluginFactoryManager::newFactory_, castor_dqm_sourceclient_file_cfg::path, edmplugin::standard::poisonedCachefileName(), edmplugin::readCacheFile(), searchPath_, and postprocess-scan-build::seen.

Member Function Documentation

categoryToInfos()

const CategoryToInfos& edmplugin::PluginManager::categoryToInfos ( ) const

inline

The container is ordered by category, then plugin name and then by precidence order of the plugin files. Therefore the first match on category and plugin name will be the proper file to load

Definition at line 82 of file PluginManager.h.

{ return categoryToInfos_; }

References categoryToInfos_.

Referenced by PrintLoadingPlugins::askedToLoad(), FWDetailViewManager::findViewersFor(), FWEveViewManager::FWEveViewManager(), FWItemAccessorFactory::hasAccessor(), main(), and edm::PluginDescription< T >::printNestedContent_().

configure()

PluginManager & PluginManager::configure ( const Config &  iConfig )

static

Definition at line 315 of file PluginManager.cc.

                                                               {
    PluginManager*& s = singleton();
    if (nullptr != s) {
      throw cms::Exception("PluginManagerReconfigured");
    }
 
    const Config& realConfig = iConfig;
    if (realConfig.searchPath().empty()) {
      throw cms::Exception("PluginManagerEmptySearchPath");
    }
    s = new PluginManager(realConfig);
    return *s;
  }

References Exception, PluginManager(), alignCSCRings::s, edmplugin::PluginManager::Config::searchPath(), and singleton().

Referenced by FWLiteEnabler::enable(), StorageFactory::getMaker(), main(), edm::ProblemTracker::ProblemTracker(), cond::Utilities::run(), and edm::PluginDescription< T >::writeCfi_().

get()

PluginManager * PluginManager::get ( )

static

Definition at line 306 of file PluginManager.cc.

                                    {
    PluginManager* manager = singleton();
    if (nullptr == manager) {
      throw cms::Exception("PluginManagerNotConfigured")
          << "PluginManager::get() was called before PluginManager::configure.";
    }
    return manager;
  }

References Exception, and singleton().

Referenced by Options.Options::__getitem__(), betterConfigParser.BetterConfigParser::__updateDict(), submitPVValidationJobs.BetterConfigParser::__updateDict(), PrintLoadingPlugins::askedToLoad(), edmplugin::PluginFactoryBase::checkProperLoadable(), rrapi.RRApi::columns(), rrapi.RRApi::count(), rrapi.RRApi::data(), edmplugin::PluginFactoryBase::findPMaker(), FWDetailViewManager::findViewersFor(), FWEveViewManager::FWEveViewManager(), betterConfigParser.BetterConfigParser::getCompares(), betterConfigParser.BetterConfigParser::getGeneral(), betterConfigParser.BetterConfigParser::getResultingSection(), submitPVValidationJobs.BetterConfigParser::getResultingSection(), FWItemAccessorFactory::hasAccessor(), edmplugin::PluginCapabilities::load(), edm::service::LoadAllDictionaries::LoadAllDictionaries(), main(), PrintLoadingPlugins::PrintLoadingPlugins(), edm::PluginDescription< T >::printNestedContent_(), rrapi.RRApi::report(), rrapi.RRApi::reports(), rrapi.RRApi::tables(), rrapi.RRApi::tags(), rrapi.RRApi::templates(), edmplugin::PluginFactoryBase::tryToFindPMaker(), edmplugin::PluginCapabilities::tryToLoad(), and rrapi.RRApi::workspaces().

isAvailable()

bool PluginManager::isAvailable ( )

static

Definition at line 346 of file PluginManager.cc.

{ return nullptr != singleton(); }

References singleton().

Referenced by edmplugin::PluginFactoryBase::checkProperLoadable(), StorageFactory::getMaker(), edm::ProblemTracker::ProblemTracker(), and edm::PluginDescription< T >::writeCfi_().

load()

const SharedLibrary & PluginManager::load	(	const std::string &	iCategory,
		const std::string &	iPlugin
	)

Definition at line 226 of file PluginManager.cc.

                                                                                               {
    askedToLoadCategoryWithPlugin_(iCategory, iPlugin);
    const std::filesystem::path& p = loadableFor(iCategory, iPlugin);
 
    //have we already loaded this?
    auto itLoaded = loadables_.find(p);
    if (itLoaded == loadables_.end()) {
      //Need to make sure we only have on SharedLibrary loading at a time
      std::lock_guard<std::recursive_mutex> guard(pluginLoadMutex());
      //Another thread may have gotten this while we were waiting on the mutex
      itLoaded = loadables_.find(p);
      if (itLoaded == loadables_.end()) {
        //try to make one
        goingToLoad_(p);
        Sentry s(loadingLibraryNamed_(), p.string());
        //std::filesystem::path native(p.string());
        std::shared_ptr<SharedLibrary> ptr;
        {
          //TEMPORARY: to avoid possible deadlocks from ROOT, we must
          // take the lock ourselves
          R__LOCKGUARD2(gInterpreterMutex);
          try {
            ptr = std::make_shared<SharedLibrary>(p);
          } catch (cms::Exception& e) {
            e.addContext("While attempting to load plugin " + iPlugin);
            throw;
          }
        }
        loadables_[p] = ptr;
        justLoaded_(*ptr);
        return *ptr;
      }
    }
    return *(itLoaded->second);
  }

References askedToLoadCategoryWithPlugin_, MillePedeFileConverter_cfg::e, goingToLoad_, justLoaded_, loadableFor(), loadables_, loadingLibraryNamed_(), AlCaHLTBitMon_ParallelJobs::p, castor_dqm_sourceclient_file_cfg::path, pluginLoadMutex(), and alignCSCRings::s.

Referenced by edmplugin::PluginFactoryBase::findPMaker(), and edmplugin::PluginCapabilities::load().

loadableFor()

const std::filesystem::path & PluginManager::loadableFor	(	const std::string &	iCategory,
		const std::string &	iPlugin
	)

Definition at line 150 of file PluginManager.cc.

                                                                                                          {
    bool throwIfFail = true;
    return loadableFor_(iCategory, iPlugin, throwIfFail);
  }

References loadableFor_().

Referenced by edmplugin::PluginFactoryBase::checkProperLoadable(), and load().

loadableFor_()

const std::filesystem::path & PluginManager::loadableFor_ ( const std::string &  iCategory, const std::string &  iPlugin, bool &  ioThrowIfFailElseSucceedStatus  )

private

Definition at line 155 of file PluginManager.cc.

                                                                                                 {
    const bool throwIfFail = ioThrowIfFailElseSucceedStatus;
    ioThrowIfFailElseSucceedStatus = true;
    CategoryToInfos::iterator itFound = categoryToInfos_.find(iCategory);
    if (itFound == categoryToInfos_.end()) {
      if (throwIfFail) {
        throw cms::Exception("PluginNotFound") << "Unable to find plugin '" << iPlugin << "' because the category '"
                                               << iCategory << "' has no known plugins";
      } else {
        ioThrowIfFailElseSucceedStatus = false;
        static const std::filesystem::path s_path;
        return s_path;
      }
    }
 
    PluginInfo i;
    i.name_ = iPlugin;
    typedef std::vector<PluginInfo>::iterator PIItr;
    std::pair<PIItr, PIItr> range = std::equal_range(itFound->second.begin(), itFound->second.end(), i, PICompare());
 
    if (range.first == range.second) {
      if (throwIfFail) {
        throw cms::Exception("PluginNotFound") << "Unable to find plugin '" << iPlugin << "' in category '" << iCategory
                                               << "'. Please check spelling of name.";
      } else {
        ioThrowIfFailElseSucceedStatus = false;
        static const std::filesystem::path s_path;
        return s_path;
      }
    }
 
    if (range.second - range.first > 1) {
      //see if the come from the same directory
      if (range.first->loadable_.parent_path() == (range.first + 1)->loadable_.parent_path()) {
        //std::cout<<range.first->name_ <<" " <<(range.first+1)->name_<<std::endl;
        throw cms::Exception("MultiplePlugins")
            << "The plugin '" << iPlugin
            << "' is found in multiple files \n"
               " '"
            << range.first->loadable_.filename() << "'\n '" << (range.first + 1)->loadable_.filename()
            << "'\n"
               "in directory '"
            << range.first->loadable_.parent_path().string()
            << "'.\n"
               "The code must be changed so the plugin only appears in one plugin file. "
               "You will need to remove the macro which registers the plugin so it only appears in"
               " one of these files.\n"
               "  If none of these files register such a plugin, "
               "then the problem originates in a library to which all these files link.\n"
               "The plugin registration must be removed from that library since plugins are not allowed in regular "
               "libraries.";
      }
    }
 
    return range.first->loadable_;
  }

References categoryToInfos_, Exception, mps_fire::i, castor_dqm_sourceclient_file_cfg::path, and FastTimerService_cff::range.

Referenced by loadableFor(), and tryToLoad().

loadingFile()

static const std::string& edmplugin::PluginManager::loadingFile ( )

inlinestatic

file name of the shared object being loaded

Definition at line 89 of file PluginManager.h.

{ return loadingLibraryNamed_(); }

References loadingLibraryNamed_().

Referenced by edmplugin::PluginFactoryBase::newPlugin(), and edmplugin::PluginFactoryBase::registerPMaker().

loadingLibraryNamed_()

std::string & PluginManager::loadingLibraryNamed_ ( )

staticprivate

Definition at line 334 of file PluginManager.cc.

                                                 {
    //NOTE: pluginLoadMutex() indirectly guards this since this value
    // is only accessible via the Sentry call which us guarded by the mutex
    CMS_THREAD_SAFE static std::string s_name(staticallyLinkedLoadingFileName());
    return s_name;
  }

References CMS_THREAD_SAFE, staticallyLinkedLoadingFileName(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by load(), loadingFile(), PluginManager(), and tryToLoad().

newFactory()

void PluginManager::newFactory ( const PluginFactoryBase *  )

private

Definition at line 140 of file PluginManager.cc.

{}

Referenced by PluginManager().

operator=()

const PluginManager& edmplugin::PluginManager::operator= ( const PluginManager &  )

delete

pluginLoadMutex()

std::recursive_mutex& edmplugin::PluginManager::pluginLoadMutex ( )

inlineprivate

Definition at line 111 of file PluginManager.h.

{ return pluginLoadMutex_; }

References pluginLoadMutex_.

Referenced by load(), and tryToLoad().

singleton()

PluginManager *& PluginManager::singleton ( )

staticprivate

Definition at line 341 of file PluginManager.cc.

                                           {
    CMS_THREAD_SAFE static PluginManager* s_singleton = nullptr;
    return s_singleton;
  }

References CMS_THREAD_SAFE.

Referenced by configure(), get(), and isAvailable().

staticallyLinkedLoadingFileName()

const std::string & PluginManager::staticallyLinkedLoadingFileName ( )

static

if the value returned from loadingFile matches this string then the file is statically linked

Definition at line 329 of file PluginManager.cc.

                                                                  {
    static const std::string s_name("static");
    return s_name;
  }

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edmplugin::PluginFactoryBase::checkProperLoadable(), and loadingLibraryNamed_().

tryToLoad()

const SharedLibrary * PluginManager::tryToLoad	(	const std::string &	iCategory,
		const std::string &	iPlugin
	)

Definition at line 262 of file PluginManager.cc.

                                                                                                    {
    askedToLoadCategoryWithPlugin_(iCategory, iPlugin);
    bool ioThrowIfFailElseSucceedStatus = false;
    const std::filesystem::path& p = loadableFor_(iCategory, iPlugin, ioThrowIfFailElseSucceedStatus);
 
    if (not ioThrowIfFailElseSucceedStatus) {
      return nullptr;
    }
 
    //have we already loaded this?
    auto itLoaded = loadables_.find(p);
    if (itLoaded == loadables_.end()) {
      //Need to make sure we only have on SharedLibrary loading at a time
      std::lock_guard<std::recursive_mutex> guard(pluginLoadMutex());
      //Another thread may have gotten this while we were waiting on the mutex
      itLoaded = loadables_.find(p);
      if (itLoaded == loadables_.end()) {
        //try to make one
        goingToLoad_(p);
        Sentry s(loadingLibraryNamed_(), p.string());
        //std::filesystem::path native(p.string());
        std::shared_ptr<SharedLibrary> ptr;
        {
          //TEMPORARY: to avoid possible deadlocks from ROOT, we must
          // take the lock ourselves
          R__LOCKGUARD(gInterpreterMutex);
          try {
            ptr = std::make_shared<SharedLibrary>(p);
          } catch (cms::Exception& e) {
            e.addContext("While attempting to load plugin " + iPlugin);
            throw;
          }
        }
        loadables_[p] = ptr;
        justLoaded_(*ptr);
        return ptr.get();
      }
    }
    return (itLoaded->second).get();
  }

References askedToLoadCategoryWithPlugin_, MillePedeFileConverter_cfg::e, goingToLoad_, justLoaded_, loadableFor_(), loadables_, loadingLibraryNamed_(), AlCaHLTBitMon_ParallelJobs::p, castor_dqm_sourceclient_file_cfg::path, pluginLoadMutex(), and alignCSCRings::s.

Referenced by edmplugin::PluginFactoryBase::tryToFindPMaker(), and edmplugin::PluginCapabilities::tryToLoad().

Friends And Related Function Documentation

DummyFriend

friend class DummyFriend

friend

Definition at line 46 of file PluginManager.h.

Member Data Documentation

askedToLoadCategoryWithPlugin_

edm::signalslot::Signal<void(const std::string&, const std::string&)> edmplugin::PluginManager::askedToLoadCategoryWithPlugin_

Definition at line 102 of file PluginManager.h.

Referenced by load(), PrintLoadingPlugins::PrintLoadingPlugins(), and tryToLoad().

categoryToInfos_

CategoryToInfos edmplugin::PluginManager::categoryToInfos_

private

Definition at line 121 of file PluginManager.h.

Referenced by categoryToInfos(), loadableFor_(), and PluginManager().

goingToLoad_

edm::signalslot::Signal<void(const std::filesystem::path&)> edmplugin::PluginManager::goingToLoad_

Definition at line 100 of file PluginManager.h.

Referenced by load(), PrintLoadingPlugins::PrintLoadingPlugins(), and tryToLoad().

justLoaded_

edm::signalslot::Signal<void(const SharedLibrary&)> edmplugin::PluginManager::justLoaded_

Definition at line 101 of file PluginManager.h.

Referenced by load(), and tryToLoad().

loadables_

tbb::concurrent_unordered_map<std::filesystem::path, std::shared_ptr<SharedLibrary>, PluginManagerPathHasher> edmplugin::PluginManager::loadables_

private

Definition at line 119 of file PluginManager.h.

Referenced by load(), and tryToLoad().

pluginLoadMutex_

std::recursive_mutex edmplugin::PluginManager::pluginLoadMutex_

private

Definition at line 122 of file PluginManager.h.

Referenced by pluginLoadMutex().

searchPath_

SearchPath edmplugin::PluginManager::searchPath_

private

Definition at line 117 of file PluginManager.h.

Referenced by PluginManager().