XrdCl::PlugInManager Class Reference

Manage client-side plug-ins and match them agains URLs. More...

#include <XrdClPlugInManager.hh>

Collaboration diagram for XrdCl::PlugInManager:

Public Member Functions
	PlugInManager ()
	Constructor.
	~PlugInManager ()
	Destructor.
PlugInFactory *	GetFactory (const std::string url)
void	ProcessEnvironmentSettings ()
bool	RegisterDefaultFactory (PlugInFactory *factory)
	Register a plug-in factory applying to all URLs.
bool	RegisterFactory (const std::string &url, PlugInFactory *factory)

Friends
class	::PlugInManagerFixture

Detailed Description

Manage client-side plug-ins and match them agains URLs.

Definition at line 45 of file XrdClPlugInManager.hh.

Constructor & Destructor Documentation

PlugInManager()

XrdCl::PlugInManager::PlugInManager

(

)

Constructor.

Definition at line 52 of file XrdClPlugInManager.cc.

                              :
    pDefaultFactory(0)
  {
  }

Referenced by ::PlugInManagerFixture.

Here is the caller graph for this function:

~PlugInManager()

XrdCl::PlugInManager::~PlugInManager

(

)

Destructor.

Definition at line 60 of file XrdClPlugInManager.cc.

  {
    std::map<std::string, FactoryHelper*>::iterator it;
    for( it = pFactoryMap.begin(); it != pFactoryMap.end(); ++it )
    {
      it->second->counter--;
      if( it->second->counter == 0 )
        delete it->second;
    }
 
    delete pDefaultFactory;
  }

Member Function Documentation

GetFactory()

PlugInFactory * XrdCl::PlugInManager::GetFactory

(

const std::string

url

)

Retrieve the plug-in factory for the given URL

Returns

you do not own the returned memory

Definition at line 146 of file XrdClPlugInManager.cc.

  {
    XrdSysMutexHelper scopedLock( pMutex );
 
    if( pDefaultFactory && pDefaultFactory->isEnv )
      return pDefaultFactory->factory;
 
    std::string normUrl = NormalizeURL( url );
    if( normUrl.empty() )
    {
      if( pDefaultFactory )
        return pDefaultFactory->factory;
      return 0;
    }
 
    std::map<std::string, FactoryHelper*>::iterator it;
    it = pFactoryMap.find( normUrl );
    if( it != pFactoryMap.end() && it->second->isEnv )
      return it->second->factory;
 
    std::string protocol = URL( url ).GetProtocol();
    std::map<std::string, FactoryHelper*>::iterator itProt;
    itProt = pFactoryMap.find( protocol );
    if( itProt != pFactoryMap.end() && itProt->second->isEnv )
      return itProt->second->factory;
 
    if( pDefaultFactory )
      return pDefaultFactory->factory;
 
    if( it != pFactoryMap.end() )
      return it->second->factory;
 
    if( itProt != pFactoryMap.end() )
      return itProt->second->factory;
 
    return 0;
  }

References XrdCl::URL::URL().

Referenced by XrdCl::FileSystem::FileSystem(), ::PlugInManagerFixture, and XrdCl::ThirdPartyCopy().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessEnvironmentSettings()

void XrdCl::PlugInManager::ProcessEnvironmentSettings

(

)

Process user environment to load plug-in settings.

This will try to load a default plug-in from a library pointed to by the XRD_PLUGIN envvar. If this fails it will scan the configuration files located in:

1) directory pointed to by XRD_PLUGINCONFDIR envvar 2) user directory: ~/.xrootd/client.plugins.d/ 3) system directory: /etc/xrootd/client.plugins.d/

In that order.

The configuration files contain lines with key-value pairs in the form of 'key=value'.

Mandatory keys are: url - a semicolon separated list of URLs the plug-in applies to lib - plugin library to be loaded enable - determines whether the plug-in should be enabled or not

You may use any other keys for your own purposes.

The first directory with a setting for a URL decides it, and the directories after it cannot change it. This applies to disabled plug-ins as well. Within one directory, the config files are processed in alphabetic order, and a setting for a URL found later supersedes the previous one. However, only the first enabled plug-in for all URLs ('url = *') is loaded. Any setting applied via environment or config files supersedes any setting done programmatically.

The plug-in library must implement the following C function:

extern "C"
{
  void *XrdClGetPlugIn( const void *arg )
  {
    return __your_plug_in_factory__;
  }
}

where arg is a const pointer to std::map<std::string, std::string> containing the plug-in configuration.

Definition at line 187 of file XrdClPlugInManager.cc.

  {
    XrdSysMutexHelper scopedLock( pMutex );
    Log *log = DefaultEnv::GetLog();
    Env *env = DefaultEnv::GetEnv();
 
    log->Debug( PlugInMgrMsg, "Initializing plug-in manager..." );
 
    //--------------------------------------------------------------------------
    // Check if a default plug-in has been specified in the environment
    //--------------------------------------------------------------------------
    bool loadConfigs = true;
    std::string defaultPlugIn = DefaultPlugIn;
    env->GetString( "PlugIn", defaultPlugIn );
    if( !defaultPlugIn.empty() )
    {
      loadConfigs = false;
      log->Debug( PlugInMgrMsg, "Loading default plug-in from %s...",
                  defaultPlugIn.c_str());
 
      std::pair<XrdOucPinLoader*, PlugInFactory *> pg = LoadFactory(
        defaultPlugIn, std::map<std::string, std::string>() );
 
      if( !pg.first )
      {
        log->Debug( PlugInMgrMsg, "Failed to load default plug-in from %s",
                    defaultPlugIn.c_str());
        loadConfigs = false;
      }
 
      pDefaultFactory = new FactoryHelper();
      pDefaultFactory->factory = pg.second;
      pDefaultFactory->plugin  = pg.first;
      pDefaultFactory->isEnv = true;
    }
 
    //--------------------------------------------------------------------------
    // If there is no default plug-in or it is invalid then load plug-in config
    // files
    //--------------------------------------------------------------------------
    if( loadConfigs )
    {
      log->Debug( PlugInMgrMsg,
                  "No default plug-in, loading plug-in configs..." );
 
      std::vector<std::string> dirs;
 
      std::string customPlugIns = DefaultPlugInConfDir;
      env->GetString( "PlugInConfDir", customPlugIns );
      if( !customPlugIns.empty() )
        dirs.push_back( customPlugIns );
 
      XrdSysPwd pwdHandler;
      passwd *pwd = pwdHandler.Get( getuid() );
      if( pwd )
        dirs.push_back( std::string( pwd->pw_dir ) + "/.xrootd/client.plugins.d" );
 
      dirs.push_back( "/etc/xrootd/client.plugins.d" );
 
      ProcessConfigDirs( dirs );
    }
  }

References XrdCl::Log::Debug(), XrdCl::DefaultPlugIn, XrdCl::DefaultPlugInConfDir, XrdSysPwd::Get(), XrdCl::DefaultEnv::GetEnv(), XrdCl::DefaultEnv::GetLog(), XrdCl::Env::GetString(), and XrdCl::PlugInMgrMsg.

Referenced by ::PlugInManagerFixture.

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterDefaultFactory()

bool XrdCl::PlugInManager::RegisterDefaultFactory

(

PlugInFactory *

factory

)

Register a plug-in factory applying to all URLs.

Register a plug-in factory applying to all URLs, registering a 0 pointer removes the factory

Definition at line 120 of file XrdClPlugInManager.cc.

  {
    Log *log = DefaultEnv::GetLog();
    XrdSysMutexHelper scopedLock( pMutex );
 
    if( pDefaultFactory && pDefaultFactory->isEnv )
      return false;
 
    delete pDefaultFactory;
    pDefaultFactory = 0;
 
    if( factory )
    {
      log->Debug( PlugInMgrMsg, "Registering a default factory" );
      pDefaultFactory = new FactoryHelper;
      pDefaultFactory->factory = factory;
    }
    else
      log->Debug( PlugInMgrMsg, "Removing the default factory" );
 
    return true;
  }

References XrdCl::Log::Debug(), XrdCl::DefaultEnv::GetLog(), and XrdCl::PlugInMgrMsg.

Referenced by ::PlugInManagerFixture.

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterFactory()

bool XrdCl::PlugInManager::RegisterFactory	(	const std::string &	url,
		PlugInFactory *	factory )

Register a plug-in factory for the given url, registering a 0 pointer removes the factory for the url

Definition at line 76 of file XrdClPlugInManager.cc.

  {
    Log *log = DefaultEnv::GetLog();
    XrdSysMutexHelper scopedLock( pMutex );
 
    std::string normUrl = NormalizeURL( url );
    if( normUrl == "" )
      return false;
 
    std::map<std::string, FactoryHelper*>::iterator it;
    it = pFactoryMap.find( normUrl );
    if( it != pFactoryMap.end() )
    {
      if( it->second->isEnv )
        return false;
 
      // we don't need to check the counter because it's valid only
      // for environment plugins which cannot be replaced via
      // this method
      delete it->second;
    }
 
    if( !factory )
    {
      log->Debug( PlugInMgrMsg, "Removing the factory for %s",
                  normUrl.c_str() );
      pFactoryMap.erase( it );
      return true;
    }
 
    log->Debug( PlugInMgrMsg, "Registering a factory for %s",
                normUrl.c_str() );
 
    FactoryHelper *h = new FactoryHelper();
    h->factory = factory;
    h->counter = 1;
    pFactoryMap[normUrl] = h;
    return true;
  }

References XrdCl::Log::Debug(), XrdCl::DefaultEnv::GetLog(), and XrdCl::PlugInMgrMsg.

Referenced by ::PlugInManagerFixture.

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

::PlugInManagerFixture

friend class ::PlugInManagerFixture

friend

Definition at line 47 of file XrdClPlugInManager.hh.

References PlugInManager(), GetFactory(), ProcessEnvironmentSettings(), RegisterDefaultFactory(), and RegisterFactory().

---

The documentation for this class was generated from the following files:

• XrdClPlugInManager.hh
• XrdClPlugInManager.cc