#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 boost::filesystem::path &	loadableFor (const std::string &iCategory, const std::string &iPlugin)

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 boost::filesystem::path &)>	goingToLoad_

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

Private Member Functions
const boost::filesystem::path &	loadableFor_ (const std::string &iCategory, const std::string &iPlugin, bool &ioThrowIfFailElseSucceedStatus)

void	newFactory (const PluginFactoryBase *)

const PluginManager &	operator= (const PluginManager &)

std::recursive_mutex &	pluginLoadMutex ()

	PluginManager (const Config &)

	PluginManager (const PluginManager &)

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

static PluginManager *&	singleton ()

Private Attributes
CategoryToInfos	categoryToInfos_

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

std::recursive_mutex	pluginLoadMutex_

SearchPath	searchPath_

Friends
class	DummyFriend

Detailed Description

Definition at line 48 of file PluginManager.h.

Member Typedef Documentation

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

Definition at line 54 of file PluginManager.h.

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

Definition at line 53 of file PluginManager.h.

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

Definition at line 52 of file PluginManager.h.

Constructor & Destructor Documentation

PluginManager::~PluginManager ( )

Definition at line 128 of file PluginManager.cc.

129 {

130 }

PluginManager::PluginManager ( const Config & iConfig )

private

Definition at line 60 of file PluginManager.cc.

References edmplugin::PluginFactoryManager::begin(), edmplugin::standard::cachefileName(), categoryToInfos_, dir, alignCSCRings::e, edmplugin::PluginFactoryManager::end(), edm::hlt::Exception, edmplugin::PluginFactoryManager::get(), i, loadingLibraryNamed_(), newFactory(), edmplugin::PluginFactoryManager::newFactory_, cmsHarvester::path, edmplugin::standard::poisonedCachefileName(), edmplugin::readCacheFile(), and searchPath_.

Referenced by configure().

                                                                :
   searchPath_( iConfig.searchPath() )
 {
     using std::placeholders::_1;
     const boost::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 boost::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);
       boost::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";
         }
         boost::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.
         boost::filesystem::path poisonedCacheFile = dir/kPoisonedCacheFile;
         readCacheFile(poisonedCacheFile, dir/"poisoned", categoryToInfos_);
       }
     }
     if(not foundAtLeastOneCacheFile) {
       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>";
 }

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

private

Member Function Documentation

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.

References categoryToInfos_.

Referenced by PrintLoadingPlugins::askedToLoad(), FWEveViewManager::FWEveViewManager(), FWItemAccessorFactory::hasAccessor(), edm::service::LoadAllDictionaries::LoadAllDictionaries(), and main().

                                                      {
         return categoryToInfos_;
       }

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

static

Definition at line 335 of file PluginManager.cc.

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

Referenced by AutoLibraryLoader::enable(), StorageFactory::getMaker(), HcalO2OManager::HcalO2OManager(), main(), edm::ProblemTracker::ProblemTracker(), cond::Utilities::run(), and cond::topinit().

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

PluginManager * PluginManager::get ( void )

static

Definition at line 325 of file PluginManager.cc.

References edm::hlt::Exception, and singleton().

Referenced by Options.Options::__getitem__(), betterConfigParser.BetterConfigParser::__updateDict(), PrintLoadingPlugins::askedToLoad(), edmplugin::PluginFactoryBase::checkProperLoadable(), rrapi.RRApi::columns(), rrapi.RRApi::count(), rrapi.RRApi::data(), edmplugin::PluginFactoryBase::findPMaker(), FWEveViewManager::FWEveViewManager(), betterConfigParser.BetterConfigParser::getCompares(), betterConfigParser.BetterConfigParser::getGeneral(), betterConfigParser.BetterConfigParser::getResultingSection(), FWItemAccessorFactory::hasAccessor(), edmplugin::PluginCapabilities::load(), edm::service::LoadAllDictionaries::LoadAllDictionaries(), main(), PrintLoadingPlugins::PrintLoadingPlugins(), 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().

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

bool PluginManager::isAvailable ( )

static

Definition at line 374 of file PluginManager.cc.

References singleton().

Referenced by edmplugin::PluginFactoryBase::checkProperLoadable(), StorageFactory::getMaker(), edm::ProblemTracker::ProblemTracker(), and cond::topinit().

 {
   return 0 != singleton();
 }

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

Definition at line 248 of file PluginManager.cc.

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

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

 {
   askedToLoadCategoryWithPlugin_(iCategory,iPlugin);
   const boost::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());
       //boost::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);
     ptr.reset( new SharedLibrary(p) );
       }
       loadables_[p]=ptr;
       justLoaded_(*ptr);
       return *ptr;
     }
   }
   return *(itLoaded->second);
 }

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

Definition at line 164 of file PluginManager.cc.

References loadableFor_().

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

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

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

private

Definition at line 172 of file PluginManager.cc.

References categoryToInfos_, edm::hlt::Exception, i, edmplugin::PluginInfo::name_, and cmsHarvester::path.

Referenced by loadableFor(), and tryToLoad().

 {
   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 boost::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 boost::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_.branch_path() == (range.first+1)->loadable_.branch_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_.leaf()<<"'\n '"
       <<(range.first+1)->loadable_.leaf()<<"'\n"
       "in directory '"<<range.first->loadable_.branch_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_;
 }

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

inlinestatic

file name of the shared object being loaded

Definition at line 92 of file PluginManager.h.

References loadingLibraryNamed_().

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

92 {

93 return loadingLibraryNamed_();}

edmplugin::PluginManager::loadingLibraryNamed_

static std::string & loadingLibraryNamed_()

Definition: PluginManager.cc:359

std::string & PluginManager::loadingLibraryNamed_ ( )

staticprivate

Definition at line 359 of file PluginManager.cc.

References staticallyLinkedLoadingFileName(), and AlCaHLTBitMon_QueryRunRegistry::string.

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

 {
   //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;
 }

void PluginManager::newFactory ( const PluginFactoryBase * )

private

Definition at line 148 of file PluginManager.cc.

Referenced by PluginManager().

149 {

150 }

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

private

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

inlineprivate

Definition at line 118 of file PluginManager.h.

References pluginLoadMutex_.

Referenced by load(), and tryToLoad().

118 {return pluginLoadMutex_;}

edmplugin::PluginManager::pluginLoadMutex_

std::recursive_mutex pluginLoadMutex_

Definition: PluginManager.h:128

PluginManager *& PluginManager::singleton ( )

staticprivate

Definition at line 367 of file PluginManager.cc.

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

 {
   [[cms::thread_safe]] static PluginManager* s_singleton=0;
   return s_singleton;
 }

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

static

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

Definition at line 352 of file PluginManager.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

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

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

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

Definition at line 282 of file PluginManager.cc.

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

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

 {
   askedToLoadCategoryWithPlugin_(iCategory,iPlugin);
   bool ioThrowIfFailElseSucceedStatus = false;
   const boost::filesystem::path& p = loadableFor_(iCategory,iPlugin, ioThrowIfFailElseSucceedStatus);
   
   if( not ioThrowIfFailElseSucceedStatus ) {
     return 0;
   }
   
 
   //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());
       //boost::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);
     ptr.reset( new SharedLibrary(p) );
       }
       loadables_[p]=ptr;
       justLoaded_(*ptr);
       return ptr.get();
     }
   }
   return (itLoaded->second).get();
 }

Friends And Related Function Documentation

friend class DummyFriend

friend

Definition at line 50 of file PluginManager.h.

Member Data Documentation

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

Definition at line 107 of file PluginManager.h.

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

CategoryToInfos edmplugin::PluginManager::categoryToInfos_

private

Definition at line 127 of file PluginManager.h.

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

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

Definition at line 105 of file PluginManager.h.

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

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

Definition at line 106 of file PluginManager.h.

Referenced by load(), and tryToLoad().

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

private

Definition at line 125 of file PluginManager.h.

Referenced by load(), and tryToLoad().

std::recursive_mutex edmplugin::PluginManager::pluginLoadMutex_

private

Definition at line 128 of file PluginManager.h.

Referenced by pluginLoadMutex().

SearchPath edmplugin::PluginManager::searchPath_

private

Definition at line 124 of file PluginManager.h.

Referenced by PluginManager().

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation