CMSSW Reference Manual

StatusLoading
StatusUnloading
StatusEntries
StatusAttaching
StatusDetaching
StatusQuerying
ErrorLoadFailure
ErrorEntryFailure
ErrorBadModule
ErrorBadCacheFile
ErrorNoFactory
Other

Definition at line 48 of file IgPluginManager.h.

00049     {
00050         // Status feedback: no error object
00051         StatusLoading,          //< About to load a module library
00052         StatusUnloading,        //< About to unload a module library
00053         StatusEntries,          //< About to check for entry points
00054         StatusAttaching,        //< About to attach a module library
00055         StatusDetaching,        //< About to detach a module library
00056         StatusQuerying,         //< About to query a module library
00057 
00058         // Error feedback: see the passed error object
00059         ErrorLoadFailure,       //< Module library failed to load
00060         ErrorEntryFailure,      //< Missing entry points in the module
00061         ErrorBadModule,         //< Module is being marked bad
00062         ErrorBadCacheFile,      //< Bad or inaccessible cache file
00063         ErrorNoFactory,         //< Missing factory for a plug-in
00064 
00065         // Fallback
00066         Other                   //< Something else
00067     };

IgPluginManager::IgPluginManager ( const lat::SearchPath & path ) [private]

Construct a plug-in manager using the path as the list of module definition directories.

This constructor is private; use get() instead.

Definition at line 115 of file IgPluginManager.cc.

Referenced by get().

00117     : m_initialised (false),
00118       m_searchPath (path)

IgPluginManager::~IgPluginManager ( void ) [private]

Destroy the plug-in manager.

Frees all module caches.

Definition at line 121 of file IgPluginManager.cc.

00123 {
00124     // Zap all the module cache directories
00125     DirectoryIterator dir = beginDirectories ();
00126     for ( ; dir != endDirectories (); ++dir)
00127         delete *dir;
00128 
00129     // Zap any factories that still remain.  The ones we still have must
00130     // be dynamically allocated and thus delete is safe -- otherwise the
00131     // global destructors would have already destructed them, causing
00132     // them to unregistered themselves from me.  (This assumes correct
00133     // library dependency linkage.)
00134     while (! m_factories.empty ())
00135         delete *m_factories.begin ();

IgPluginManager::IgPluginManager ( const IgPluginManager & ) [private]

void IgPluginManager::addFactory ( IgPluginFactoryBase * factory )

Add the factory to the plugin manager.

This makes the factory participate in the internal cache management scheme to allow data about modules and plug-ins to to be cached and restored. This method is called by the IgPluginFactoryBase constructor.

Definition at line 284 of file IgPluginManager.cc.

References m_factories.

Referenced by IgPluginFactoryBase::IgPluginFactoryBase().

00286 {
00287     // FIXME: allow factories to be registered to the database, then
00288     // notify them on each refresh (and when they are added).  The
00289     // factories should be accessed via XyzDB::get () which gets the
00290     // global database and registers an instance of the factory into it.
00291     m_factories.push_back (factory);

void IgPluginManager::addFeedback ( FeedbackCB callback )

Add a feedback target.

Definition at line 437 of file IgPluginManager.cc.

References m_feedbacks.

Referenced by IgApplication::initDatabase().

00439 { m_feedbacks.push_back (callback); }

void IgPluginManager::addInfo ( IgPluginInfo * info )

Route a new plug-in info object to the appropriate factory.

Definition at line 192 of file IgPluginManager.cc.

References IgPluginFactoryBase::addInfo(), ASSERT, IgPluginInfo::category(), and findFactory().

Referenced by IgModule::addInfo().

00194 {
00195     // This method is called by #IgModule when it receives a new info
00196     // object.  We find the factory that matches the info object's
00197     // category, and then route the call to the factory so it can
00198     // add the info object to its list of available plug-ins.
00199     //
00200     // #IgModule is notified in turn by #IgPluginInfo constructors, or
00201     // more specifically, the finish() method that is called by the
00202     // IgPluginInfo subclass at the end of its constructor.  The
00203     // module just routes the call to us.
00204     //
00205     // The #IgPluginInfo can come into existence in one of two ways:
00206     // created by the module query, or reincarnated from a cache by
00207     // request of the factory when it is being constructed.
00208     //
00209     // The factory matching the info object must already exist, there
00210     // is no way to get here without that being the case.  However it
00211     // may still be under construction, which is one reason why the
00212     // call is propagated through base classes and not directly to the
00213     // factory from the IgPluginInfo derived class; another reason is
00214     // to keep knowledge about factories in the plug-in manager and
00215     // out of #IgModule.
00216     IgPluginFactoryBase *factory = findFactory (info->category ());
00217     ASSERT (factory);
00218     factory->addInfo (info);

IgPluginManager::DirectoryIterator IgPluginManager::beginDirectories ( void ) const

Get an iterator over all the module definition directories.

Definition at line 375 of file IgPluginManager.cc.

References m_directories.

Referenced by IgApplication::dumpDatabase(), locateDirectory(), rebuild(), IgPluginFactoryBase::rebuild(), refresh(), and IgQtAppDebugPluginsInfo::update().

00377 { return m_directories.begin (); }

FactoryIterator IgPluginManager::beginFactories ( void ) [private]

IgPluginManager::ModuleIterator IgPluginManager::beginModules ( void ) const

Return an iterator over all the modules currently known about.

Note that several module directories can define a module with the same name; only the first is visible in the plug-in manager.

Definition at line 406 of file IgPluginManager.cc.

References m_modules.

00408 { return ModuleIterator (m_modules.begin ()); }

void IgPluginManager::destroyOnExit ( bool destroy ) [static]

Configure the destruction of the plug-in manager.

By default the manager is destructed. This function allows the application to set the destruction policy, either to force the destruction or to prevent it. In general, it would be a good idea to destroy the manager, but you will want to ensure your compiler and language run-times are implementing correct destruction mechanism before enabling the functionality.

Note that this method only sets the destruction policy if a IgPluginManager is constructed. The method itself neither creates nor destroys the manager.

Definition at line 109 of file IgPluginManager.cc.

References IgPluginManagerDestructor::policy().

00111 { s_destructor.policy (destroy); }

IgModuleCache * IgPluginManager::directory ( const lat::Filename & name ) const

Locate a module definition directory name.

Returns the pointer to the matching IgModuleCache if one is found, null otherwise.

Definition at line 395 of file IgPluginManager.cc.

References endDirectories(), and locateDirectory().

00397 {
00398     DirectoryIterator pos = locateDirectory (name);
00399     return pos != endDirectories () ? *pos : 0;

IgPluginManager::DirectoryIterator IgPluginManager::endDirectories ( void ) const

Get an iterator over all the module definition directories.

Definition at line 380 of file IgPluginManager.cc.

References m_directories.

Referenced by directory(), IgApplication::dumpDatabase(), locateDirectory(), rebuild(), IgPluginFactoryBase::rebuild(), refresh(), and IgQtAppDebugPluginsInfo::update().

00382 { return m_directories.end (); }

FactoryIterator IgPluginManager::endFactories ( void ) [private]

IgPluginManager::ModuleIterator IgPluginManager::endModules ( void ) const

Return an iterator over all the modules currently known about.

Note that several module directories can define a module with the same name; only the first is visible in the plug-in manager.

Definition at line 413 of file IgPluginManager.cc.

References m_modules.

Referenced by module().

00415 { return ModuleIterator (m_modules.end ()); }

void IgPluginManager::feedback	(	FeedbackCode	code,
		const std::string &	scope,
		lat::Error *	error = `0`
	)

Send a feedback notification to all registered targets.

Definition at line 463 of file IgPluginManager.cc.

References feedback().

00467 { feedback (FeedbackData (code, scope, error)); }

void IgPluginManager::feedback	(	FeedbackCode	code,
		const lat::Filename &	scope,
		lat::Error *	error = `0`
	)

Send a feedback notification to all registered targets.

Definition at line 456 of file IgPluginManager.cc.

References feedback().

00460 { feedback (FeedbackData (code, (std::string) scope, error)); }

void IgPluginManager::feedback ( FeedbackData data )

Send a feedback notification to all registered targets.

Definition at line 447 of file IgPluginManager.cc.

References i, and m_feedbacks.

Referenced by IgModule::attach(), IgModule::checkEntryPoints(), IgModule::detach(), feedback(), IgModule::library(), IgModuleCache::makeBad(), IgPluginInfo::noFactory(), IgModuleCache::parse(), IgModule::query(), IgModuleCache::scanModules(), and IgModule::unload().

00449 {
00450    FeedbackIterator i;
00451    for (i = m_feedbacks.begin (); i != m_feedbacks.end (); ++i)
00452         (*i) (data);

IgPluginFactoryBase * IgPluginManager::findFactory ( const std::string & name ) [private]

Find a factory that matches category label name.

Internal method used to match info item categories to factories. Returns pointer to the matching factory, or null if none is found.

Definition at line 309 of file IgPluginManager.cc.

References m_factories.

Referenced by addInfo(), removeInfo(), and restore().

00311 {
00312     FactoryIterator pos = m_factories.begin ();
00313     while (pos != m_factories.end () && (*pos)->category () != name)
00314         ++pos;
00315 
00316     return pos != m_factories.end () ? *pos : 0;

IgPluginManager * IgPluginManager::get ( void ) [static]

Get the plug-in manager.

This retrieves a pointer to a global plug-in manager object. The manager is automatically created on first call to this function, and initialised to use IGUANA_PLUGINS environment variable as the search path. The manager is not fully initialised until someone calls initialise() method. That is, it is functional but will not scan for plug-ins until initialise() is called. Otherwise the manager is fully functional. Once the init has been done, the manager also knows about the plug-ins.

Definition at line 77 of file IgPluginManager.cc.

References IgPluginManager(), LFplugin_manager, LOG, IgPluginManagerDestructor::object(), p, lat::SharedLibrary::path(), path(), and GsfMatrixTools::trace().

Referenced by IgModule::builtin(), IgApplication::dumpDatabase(), IgPluginFactoryBase::IgPluginFactoryBase(), IgApplication::initDatabase(), IgModuleCache::makeBad(), IgPluginFactoryBase::rebuild(), IgQtAppDebugPluginsInfo::update(), and IgPluginFactoryBase::~IgPluginFactoryBase().

00079 {
00080     // FIXME: Thread safety
00081     static IgPluginManager *s_db = 0;
00082     if (! s_db)
00083     {
00084         std::string path;
00085         if (const char *p = getenv ("IGUANA_PLUGINS"))
00086             path = p;
00087         else
00088             path = lat::SharedLibrary::path ();
00089 
00090         LOG (0, trace, LFplugin_manager,
00091              "initialising plugin manager with path <" << path << ">");
00092         s_db = new IgPluginManager (lat::SearchPath (path));
00093         s_destructor.object (s_db);
00094     }
00095     return s_db;

void IgPluginManager::initialise ( void )

Initialise the plug-in manager.

This causes all the plug-in directories determined by get() (from $IGUANA_PLUGINS environment variable) to be scanned, and new plug-ins potentially be queried. It is safe to call this method several times, only the first time counts. The first call should happen at a time when it is safe to load and unload libraries: when the program is in sufficiently stable state. If you don't like spending hours of debugging odd bugs or don't want to be vulnerable to strange and fragile error conditions, translate that to "never call this method from a global constructor, directly or indirectly".

Causes a IgModuleCache to be created for every directory mentioned in the search path. Directories that don't exist or for which caching fails for some other reason are ignored (see logging output for details).

Definition at line 153 of file IgPluginManager.cc.

References lat::SearchPath::begin(), lat::SearchPath::end(), error, lat::Error::explain(), LFplugin_manager, LOG, m_directories, m_initialised, m_searchPath, name, rebuild(), lat::undent(), and warning.

Referenced by IgApplication::initDatabase().

00155 {
00156     if (m_initialised) return;
00157     m_initialised = true;
00158 
00159     lat::SearchPath::const_iterator dir = m_searchPath.begin ();
00160     for ( ; dir != m_searchPath.end (); ++dir)
00161     {
00162         // Ignore directories that do not exist.  Also ignore
00163         // empty directory components ("foo::bar") as they are
00164         // unlikely to be intended.  This is unlike normal unix
00165         // behaviour where "::" really means ":.:", but avoids
00166         // a common problem from appending to IGUANA_PLUGINS as
00167         // $IGUANA_PLUGINS:foo when SEAL_PLUGINS is not set.  If
00168         // user really wants to have "." in the path -- and that
00169         // is exceedingly unlikely -- they can always do so
00170         // explicitly.
00171         if (! dir->empty ())
00172         {
00173             try {
00174                 m_directories.push_back (new IgModuleCache (this, *dir));
00175             } catch (lat::Error &error) {
00176                 LOG (0, warning, LFplugin_manager, lat::undent << lat::undent
00177                      << "directory " << *dir << " ignored: "
00178                      << typeid(error).name () << " ("
00179                      << error.explain ().c_str () << ")\n");
00180                 continue;
00181             }
00182         }
00183     }
00184 
00185     rebuild ();

IgPluginManager::DirectoryIterator IgPluginManager::locateDirectory ( const lat::Filename & name ) const

Get an iterator to a module definition directory name.

Definition at line 385 of file IgPluginManager.cc.

References beginDirectories(), and endDirectories().

Referenced by directory().

00387 {
00388     return std::find_if (beginDirectories (), endDirectories (),
00389                          IgDirectoryByName (name));

IgPluginManager::ModuleIterator IgPluginManager::locateModule ( const lat::Filename & libraryName ) const

Return an iterator to a module with shared library libraryName.

Note that several module directories can define a module with the same name; only the first is visible in the plug-in manager.

Definition at line 420 of file IgPluginManager.cc.

References m_modules.

Referenced by module().

00422 { return ModuleIterator (m_modules.find (libraryName)); }

IgModule * IgPluginManager::module ( const lat::Filename & libraryName ) const

Locate a module with shared library libraryName.

Returns the pointer to the matching IgModule if one is found, null otherwise. Note that several module directories can define a module with the same name; only the first is visible in the plug-in manager.

Definition at line 428 of file IgPluginManager.cc.

References endModules(), and locateModule().

00430 {
00431     ModuleIterator pos = locateModule (libraryName);
00432     return pos != endModules () ? *pos : 0;

IgPluginManager& IgPluginManager::operator= ( const IgPluginManager & ) [private]

void IgPluginManager::rebuild ( void ) [private]

Internal method to rebuild the module table.

Collects all modules currently in all the caches into a map that can be iterated over by the clients. The modules are added in the order seen in the search path: a module earlier in the path will hide identically named module later in the path. This allows for instance a module in a developer area to override one in a base release area.

Definition at line 328 of file IgPluginManager.cc.

References beginDirectories(), endDirectories(), m_modules, and server-conf-online::modules.

Referenced by initialise(), and refresh().

00330 {
00331     ModuleMap                   modules;
00332     IgModuleCache::Iterator     module;
00333     DirectoryIterator           dir;
00334 
00335     // Collect modules into a map
00336     for (dir = beginDirectories (); dir != endDirectories (); ++dir)
00337         for (module = (*dir)->begin (); module != (*dir)->end (); ++module)
00338             if (! modules.count ((*module)->libraryName ()))
00339                 modules [(*module)->libraryName ()] = *module;
00340 
00341     // Put the information back
00342     m_modules.swap (modules);
00343 
00344     // There's no need to update custom factories.  Refreshing the modules
00345     // caused them to be re-queried, which caused each module to blast
00346     // away their caches and existing infos, which caused all factories to
00347     // remove their database of those infos, plus the re-query caused
00348     // all necessary new infos to be created.

void IgPluginManager::refresh ( void )

Refresh the plug-in database.

Rescans all module directories, re-querying all new or updated modules. This method can take a substantial amount of time to run as it may load and unload a large number of modules. Do not call this method in a program that is already running and has loaded some modules in memory -- they may get unloaded or worse, reloaded with a new, incompatible version of the module (if the modules are updated on disk). In general plug-in factories may change their contents considerably, and will certainly change somewhat, so beware of invalidating outstanding object references.

Definition at line 361 of file IgPluginManager.cc.

References beginDirectories(), endDirectories(), and rebuild().

00363 {
00364     DirectoryIterator dir = beginDirectories ();
00365     for ( ; dir != endDirectories (); ++dir)
00366         (*dir)->refresh ();
00367 
00368     rebuild ();

void IgPluginManager::removeFactory ( IgPluginFactoryBase * factory )

Remove a factory from the plug-in manager.

This method is be called from the IgPluginFactoryBase destructor so that the manager will not try to notify factories that have already been unloaded from the program.

Definition at line 298 of file IgPluginManager.cc.

References ASSERT, find(), and m_factories.

Referenced by IgPluginFactoryBase::~IgPluginFactoryBase().

00300 {
00301     FactoryIterator pos = std::find (m_factories.begin (), m_factories.end (), factory);
00302     ASSERT (pos != m_factories.end ());
00303     m_factories.erase (pos);

void IgPluginManager::removeFeedback ( FeedbackCB callback )

Remove a feedback target.

Definition at line 442 of file IgPluginManager.cc.

References m_feedbacks.

00444 { m_feedbacks.remove (callback); }

void IgPluginManager::removeInfo ( IgPluginInfo * info )

Definition at line 222 of file IgPluginManager.cc.

References ASSERT, IgPluginInfo::category(), findFactory(), and IgPluginFactoryBase::removeInfo().

Referenced by IgModule::detachInfo().

00224 {
00225     // This method is called by #IgModule when a #IgPluginInfo object is
00226     // being destructed, with some processing in #IgModule first.  We
00227     // find the factory matching the info object category, and route
00228     // the call to the factory so it can remove the info from it's
00229     // list.  Knowledge about the info object remains in raw cached
00230     // form in #IgModule unless the purpose is to purge the cache.
00231     //
00232     // #IgPluginInfo objects die in one of two ways: either because the
00233     // factory is going out of scope -- for instance because it itself
00234     // was in a dynamically loaded module that is getting unloaded --
00235     // or because the #IgModule object deletes it.  The latter can
00236     // happen for a variety reasons, for example when re-querying a
00237     // module, when module is marked bad, or when the module object
00238     // is deleted as a part of a cache refresh.
00239     //
00240     // By definition the factory already exists, info objects can be
00241     // created only with the factory present, and the factory deletes
00242     // its info objects before dying itself.  The call is routed here
00243     // in order to keep knowledge about factories here, as well as
00244     // for symmetry with the other info-related registration methods.
00245     IgPluginFactoryBase *factory = findFactory (info->category ());
00246     ASSERT (factory);
00247     factory->removeInfo (info);

void IgPluginManager::restore	(	IgModule *	module,
		IgModuleDescriptor *	from
	)

Definition at line 253 of file IgPluginManager.cc.

References ASSERT, findFactory(), IgModuleDescriptor::token(), and IgModuleDescriptor::tokens().

Referenced by IgModule::restore().

00255 {
00256     // This method is called by #IgModule when reading back a cache
00257     // to inform a factory to create a #IgPluginInfo from cached form.
00258     // We look for a factory matching the info object category; the
00259     // convention is that the first token of the cached info object
00260     // data must be the category of the info object and the name of
00261     // the factory.  If such a factory is registered, we pass it the
00262     // cache data; it will instantiate an appropriate info object
00263     // from it, which will then end up calling #addInfo().
00264     //
00265     // If no factory is currently registered, the call is ignored.
00266     // In that case, #IgModule will retain the raw cached data, and
00267     // when the factory is instantiated, it will rebuild the info
00268     // objects from that (see #IgPluginFactoryBase::rebuild()).  In
00269     // that case the calls will not go through this method; only
00270     // #addInfo() is used as the info objects are instantiated.
00271     ASSERT (from);
00272     ASSERT (from->tokens () >= 2);
00273     if (IgPluginFactoryBase *factory = findFactory (from->token (0)))
00274         factory->restore (module, from);

friend class IgPluginManagerDestructor [friend]

Definition at line 126 of file IgPluginManager.h.

DirectoryMap IgPluginManager::m_directories [private]

Definition at line 137 of file IgPluginManager.h.

Referenced by beginDirectories(), endDirectories(), and initialise().

FactoryList IgPluginManager::m_factories [private]

Definition at line 139 of file IgPluginManager.h.

Referenced by addFactory(), findFactory(), and removeFactory().

FeedbackList IgPluginManager::m_feedbacks [private]

Definition at line 140 of file IgPluginManager.h.

Referenced by addFeedback(), feedback(), and removeFeedback().

bool IgPluginManager::m_initialised [private]

Definition at line 135 of file IgPluginManager.h.

Referenced by initialise().

ModuleMap IgPluginManager::m_modules [private]

Definition at line 138 of file IgPluginManager.h.

Referenced by beginModules(), endModules(), locateModule(), and rebuild().

lat::SearchPath IgPluginManager::m_searchPath [private]

Definition at line 136 of file IgPluginManager.h.

Referenced by initialise().

IgPluginManager Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Classes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation


Public Types
typedef DirectoryMap::const_iterator	DirectoryIterator
typedef std::list < IgModuleCache * >	DirectoryMap
typedef lat::Callback1 < FeedbackData >	FeedbackCB
	Feedback callback type.
enum	FeedbackCode { StatusLoading, StatusUnloading, StatusEntries, StatusAttaching, StatusDetaching, StatusQuerying, ErrorLoadFailure, ErrorEntryFailure, ErrorBadModule, ErrorBadCacheFile, ErrorNoFactory, Other }
	Types of information passed as feedback. More...
typedef lat::MapValueIterator < ModuleMap >	ModuleIterator
typedef std::map < lat::Filename, IgModule * >	ModuleMap
Public Member Functions
void	addFactory (IgPluginFactoryBase *factory)
	Add the factory to the plugin manager.
void	addFeedback (FeedbackCB callback)
	Add a feedback target.
void	addInfo (IgPluginInfo *info)
	Route a new plug-in info object to the appropriate factory.
DirectoryIterator	beginDirectories (void) const
	Get an iterator over all the module definition directories.
ModuleIterator	beginModules (void) const
	Return an iterator over all the modules currently known about.
IgModuleCache *	directory (const lat::Filename &name) const
	Locate a module definition directory name.
DirectoryIterator	endDirectories (void) const
	Get an iterator over all the module definition directories.
ModuleIterator	endModules (void) const
	Return an iterator over all the modules currently known about.
void	feedback (FeedbackCode code, const std::string &scope, lat::Error *error=0)
	Send a feedback notification to all registered targets.
void	feedback (FeedbackCode code, const lat::Filename &scope, lat::Error *error=0)
	Send a feedback notification to all registered targets.
void	feedback (FeedbackData data)
	Send a feedback notification to all registered targets.
void	initialise (void)
	Initialise the plug-in manager.
DirectoryIterator	locateDirectory (const lat::Filename &name) const
	Get an iterator to a module definition directory name.
ModuleIterator	locateModule (const lat::Filename &libraryName) const
	Return an iterator to a module with shared library libraryName.
IgModule *	module (const lat::Filename &libraryName) const
	Locate a module with shared library libraryName.
void	refresh (void)
	Refresh the plug-in database.
void	removeFactory (IgPluginFactoryBase *factory)
	Remove a factory from the plug-in manager.
void	removeFeedback (FeedbackCB callback)
	Remove a feedback target.
void	removeInfo (IgPluginInfo *info)
void	restore (IgModule module, IgModuleDescriptor from)
Static Public Member Functions
static void	destroyOnExit (bool destroy)
	Configure the destruction of the plug-in manager.
static IgPluginManager *	get (void)
	Get the plug-in manager.
Private Types
typedef FactoryList::iterator	FactoryIterator
typedef std::list < IgPluginFactoryBase * >	FactoryList
typedef FeedbackList::iterator	FeedbackIterator
typedef std::list< FeedbackCB >	FeedbackList
Private Member Functions
FactoryIterator	beginFactories (void)
FactoryIterator	endFactories (void)
IgPluginFactoryBase *	findFactory (const std::string &name)
	Find a factory that matches category label name.
	IgPluginManager (const IgPluginManager &)
	IgPluginManager (const lat::SearchPath &path)
	Construct a plug-in manager using the path as the list of module definition directories.
IgPluginManager &	operator= (const IgPluginManager &)
void	rebuild (void)
	Internal method to rebuild the module table.
	~IgPluginManager (void)
	Destroy the plug-in manager.
Private Attributes
DirectoryMap	m_directories
FactoryList	m_factories
FeedbackList	m_feedbacks
bool	m_initialised
ModuleMap	m_modules
lat::SearchPath	m_searchPath
Friends
class	IgPluginManagerDestructor
Classes
struct	FeedbackData
	Simple tuple of data passed to feedback clients. More...