Changeset 4869 for branches/erijo-dev

Timestamp:

03/20/07 05:17:03 (21 months ago)

Author:

erijo

Message:

Add support for unloading unused libraries + misc cleanups.

Location:

branches/erijo-dev/licq/src/plugin

Files:

• CMakeLists.txt (modified) (1 diff)
• plugin.h (added)
• pluginfactory.h (moved) (moved from branches/erijo-dev/licq/src/plugin/pluginfactoryproxy.h) (4 diffs)
• pluginloader.cpp (modified) (8 diffs)
• pluginloader.h (modified) (3 diffs)
• pluginprototype.cpp (deleted)
• pluginprototype.h (deleted)
• pluginrepository.cpp (moved) (moved from branches/erijo-dev/licq/src/plugin/pluginmanager.cpp) (2 diffs)
• pluginrepository.h (moved) (moved from branches/erijo-dev/licq/src/plugin/pluginmanager.h) (1 diff)
• tests/CMakeLists.txt (modified) (1 diff)
• tests/pluginfactorytest.cpp (moved) (moved from branches/erijo-dev/licq/src/plugin/tests/pluginfactoryproxytest.cpp) (1 diff)

branches/erijo-dev/licq/src/plugin/CMakeLists.txt

@@ -1 +1 @@
 set(licqplugin_SRCS
   pluginloader.cpp
-  pluginmanager.cpp
-  pluginprototype.cpp
+  pluginrepository.cpp
 )
 

branches/erijo-dev/licq/src/plugin/pluginfactory.h

@@ -18 +18 @@
  */
 
-#ifndef LICQ_TPLUGINFACTORYPROXY_H
-#define LICQ_TPLUGINFACTORYPROXY_H
+#ifndef LICQ_TPLUGINFACTORY_H
+#define LICQ_TPLUGINFACTORY_H
 
 #include "licq/interface/pluginfactory.h"
 #include "utils/dynamiclibrary.h"
 
-#include <boost/noncopyable.hpp>
 #include <boost/shared_ptr.hpp>
+#include <cassert>
 
 namespace Licq
 {
 
-class TPluginFactoryProxy;
-typedef boost::shared_ptr<TPluginFactoryProxy> TPluginFactoryProxyPtr;
-
-class TPluginFactoryProxy : private boost::noncopyable
+class TPluginFactory : public IPluginFactory
 {
 private:
@@ -43 +40 @@
 
   /// Function to use when destroying the factory.
-  destroyPluginFactory_t FactoryDestructor;
+  FnDestroyPluginFactory FactoryDestructor;
 
 public:
-  /** \brief Create a new plugin factory proxy.
+  /** \brief Create a new plugin factory.
 
       \param[in] library The library the real factory was loaded from.
-      \param[in] factory The real factory.
-      \param[in] factoryDestructor The function that should be called to
-        destroy the real factory.
+      \param[in] constructor The function to call to create the real factory.
+      \param[in] destructor The function to call to destroy the real factory.
   */
-  TPluginFactoryProxy(TDynamicLibrary* library, IPluginFactory* factory,
-                      destroyPluginFactory_t factoryDestructor);
+  TPluginFactory(TDynamicLibrary* library,
+                 FnCreatePluginFactory constructor,
+                 FnDestroyPluginFactory destructor);
 
   /** \brief Destroy the factory.
@@ -60 +57 @@
       Destroys the real factory and unloads the dynamic library.
   */
-  ~TPluginFactoryProxy();
+  ~TPluginFactory();
 
-  /** \brief Get the real factory.
-      \return The real factory.
-  */
-  IPluginFactory* getFactory();
+  /// File the factory was loaded from.
+  std::string getLibraryFilename() const;
+
+  // From IPluginFactory
+  unsigned int getPluginCount() const;
+  TPluginInformation getPluginInformation(unsigned int index) const;
+  IPlugin* createPlugin(unsigned int index, TPluginId id, ILog* log);
 };
 
 } // namespace Licq
 
-inline
-Licq::TPluginFactoryProxy::TPluginFactoryProxy(TDynamicLibrary* library,
-                                               IPluginFactory* factory,
-                                               destroyPluginFactory_t factoryDestructor)
-  : Library(library), Factory(factory), FactoryDestructor(factoryDestructor)
+inline Licq::TPluginFactory::TPluginFactory(TDynamicLibrary* library,
+                                            FnCreatePluginFactory constructor,
+                                            FnDestroyPluginFactory destructor)
+  : Library(library),
+    Factory(constructor()),
+    FactoryDestructor(destructor)
 {
-  // Empty
+  assert(Factory != NULL);
 }
 
-inline Licq::TPluginFactoryProxy::~TPluginFactoryProxy()
+inline Licq::TPluginFactory::~TPluginFactory()
 {
   FactoryDestructor(Factory);
@@ -85 +86 @@
 }
 
-inline Licq::IPluginFactory* Licq::TPluginFactoryProxy::getFactory()
+inline std::string Licq::TPluginFactory::getLibraryFilename() const
 {
-  return Factory;
+  assert(Library != NULL);
+  return Library->getFilename();
+}
+
+inline unsigned int Licq::TPluginFactory::getPluginCount() const
+{
+  return Factory->getPluginCount();
+}
+
+inline Licq::TPluginInformation
+Licq::TPluginFactory::getPluginInformation(unsigned int index) const
+{
+  return Factory->getPluginInformation(index);
+}
+
+inline Licq::IPlugin*
+Licq::TPluginFactory::createPlugin(unsigned int index, TPluginId id, ILog* log)
+{
+  return Factory->createPlugin(index, id, log);
 }
 

branches/erijo-dev/licq/src/plugin/pluginloader.cpp

@@ -18 +18 @@
  */
 
-#include "licq/interface/pluginfactory.h"
 #include "licq/version.h"
 
 #include "plugin/pluginloader.h"
-#include "plugin/pluginfactoryproxy.h"
 #include "utils/dynamiclibrary.h"
 
@@ -44 +42 @@
 }
 
-unsigned int
-Licq::TPluginLoader::loadPluginsFromDir(const bfs::path& dir, TPluginPrototypeList* pluginList)
+unsigned int Licq::
+TPluginLoader::loadPluginsFromDir(const bfs::path& dir,
+                                  TPluginFactories* factories)
 {
   assert(bfs::is_directory(dir) == true);
@@ -55 +54 @@
   {
     if (!bfs::is_directory(*file))
-      loadCount += loadPluginsFromFile(*file, pluginList);
+      loadCount += loadPluginsFromFile(*file, factories);
   }
 
@@ -61 +60 @@
 }
 
-unsigned int
-Licq::TPluginLoader::loadPluginsFromFile(const bfs::path& file, TPluginPrototypeList* pluginList)
+unsigned int Licq::
+TPluginLoader::loadPluginsFromFile(const bfs::path& file,
+                                   TPluginFactories* factories)
 {
   assert(bfs::is_directory(file) == false);
@@ -80 +80 @@
 
   // First check that the plugin and daemon uses the same API version
-  getPluginApiVersion_t apiVersion;
+  FnGetPluginApiVersion apiVersion;
   if (!lib->loadSymbol("licqGetPluginApiVersion", &apiVersion))
     return 0;
@@ -93 +93 @@
 
   // Load symbols for creating and destroying plugin factory
-  createPluginFactory_t createPluginFactory;
+  FnCreatePluginFactory createPluginFactory;
   if (!lib->loadSymbol("licqCreatePluginFactory", &createPluginFactory))
     return 0;
 
-  destroyPluginFactory_t destroyPluginFactory;
+  FnDestroyPluginFactory destroyPluginFactory;
   if (!lib->loadSymbol("licqDestroyPluginFactory", &destroyPluginFactory))
     return 0;
 
-  // Try and create the plugin factory
-  TPluginFactoryProxyPtr
-    factoryProxy(new TPluginFactoryProxy(libptr.release(),
-                                         createPluginFactory(),
-                                         destroyPluginFactory));
-  if (factoryProxy->getFactory() == NULL)
+  // Create the plugin factory
+  boost::shared_ptr<TPluginFactory>
+    factory(new TPluginFactory(libptr.release(),
+                               createPluginFactory,
+                               destroyPluginFactory));
+
+  if (factory->getPluginCount() == 0)
   {
-    Log->error("Failed to create plugin factory for %s", filename.c_str());
+    // No point in saving an empty factory.
+    Log->debug("IPluginFactory::getPluginCount() == 0 for %s", filename.c_str());
     return 0;
   }
 
-  // Create the "plugins"
-  const unsigned int count = factoryProxy->getFactory()->getPluginCount();
-  for (unsigned int i = 0; i < count; ++i)
-    pluginList->push_back(new TPluginPrototype(factoryProxy, i));
-
-  // If count = 0, the factory will be destroyed and the library unloaded
-  return count;
+  // Save it
+  factories->push_back(factory);
+  return 1;
 }
 
@@ -127 +125 @@
 }
 
-unsigned int Licq::TPluginLoader::loadPlugins(const std::string& path, TPluginPrototypeList* pluginList)
+unsigned int Licq::
+TPluginLoader::loadPlugins(const std::string& path,
+                           TPluginFactories* factories)
 {
-  assert(pluginList != NULL);
+  assert(factories != NULL);
 
   if (path.empty())
@@ -144 +144 @@
 
     if (bfs::is_directory(absolute))
-      return loadPluginsFromDir(absolute, pluginList);
+      return loadPluginsFromDir(absolute, factories);
     else
-      return loadPluginsFromFile(absolute, pluginList);
+      return loadPluginsFromFile(absolute, factories);
   }
-  catch (const bfs::filesystem_error& e)
+  catch (const bfs::filesystem_error& ex)
   {
-    Log->error("Failed to load plugins from \"%s\": %s", path.c_str(), e.what());
+    Log->error("Failed to load plugins from \"%s\": %s", path.c_str(), ex.what());
   }
 

branches/erijo-dev/licq/src/plugin/pluginloader.h

@@ -22 +22 @@
 
 #include "licq/interface/log.h"
-#include "plugin/pluginprototype.h"
+#include "plugin/pluginfactory.h"
 
+#include <boost/shared_ptr.hpp>
+#include <list>
+
+// Forward declaration
 namespace boost
 {
 namespace filesystem
 {
-  class path;
+class path;
 }
 }
@@ -34 +38 @@
 namespace Licq
 {
+
+typedef std::list< boost::shared_ptr<TPluginFactory> > TPluginFactories;
 
 class TPluginLoader
@@ -41 +47 @@
 
   /** \brief Load plugins from all files in given directory.
-      \return The number of plugins loaded.
+      \return The number of plugin factories loaded.
   */
-  unsigned int loadPluginsFromDir(const boost::filesystem::path& dir, TPluginPrototypeList* pluginList);
+  unsigned int loadPluginsFromDir(const boost::filesystem::path& dir,
+                                  TPluginFactories* factories);
 
   /** \brief Load all plugins in given file.
-      \return The number of plugins loaded.
+      \return The number of plugin factories loaded. Since a single file
+      can only contain zero or one factory, this method always returns 0 or 1.
   */
-  unsigned int loadPluginsFromFile(const boost::filesystem::path& file, TPluginPrototypeList* pluginList);
+  unsigned int loadPluginsFromFile(const boost::filesystem::path& file,
+                                   TPluginFactories* factories);
 
 public:
   /// Creates a new plugin loader.
-  TPluginLoader(ILog* log);
+  explicit TPluginLoader(ILog* log);
 
   /** \brief Load all plugins from the given path.
 
       \param[in] path Path to seach for plugins.
-      \param[out] pluginList Loaded plugins will be added to the back of this list.
-        The ownership of all returned plugins is transfered to the caller.
+      \param[out] factories Loaded factories will be added to the back.
 
-      \return The number of plugins loaded.
+      \return The number of plugin factories loaded.
   */
-  unsigned int loadPlugins(const std::string& path, TPluginPrototypeList* pluginList);
+  unsigned int loadPlugins(const std::string& path,
+                           TPluginFactories* factories);
 };
 

branches/erijo-dev/licq/src/plugin/pluginrepository.cpp

@@ -18 +18 @@
  */
 
-#include "plugin/pluginmanager.h"
+#include "plugin/plugin.h"
+#include "plugin/pluginrepository.h"
 #include "utils/misc.h"
 
-Licq::TPluginManager::TPluginManager(ILog* log)
+Licq::TPluginRepository::TPluginRepository(ILog* log)
   : Log(log), PluginLoader(log), NextPluginId(1)
 {
@@ -27 +28 @@
 }
 
-Licq::TPluginManager::~TPluginManager()
+Licq::TPluginRepository::~TPluginRepository()
 {
-  std::for_each(PluginPrototypeList.begin(), PluginPrototypeList.end(), ObjectDeleter());
+  std::for_each(PluginCache.begin(), PluginCache.end(), ObjectDeleter());
 }
 
-void Licq::TPluginManager::addPluginSearchPath(const std::string& path)
+void Licq::TPluginRepository::addSearchPath(const std::string& path)
 {
-  unsigned int count = PluginLoader.loadPlugins(path, &PluginPrototypeList);
-  Log->debug("Loaded %d plugin%s from '%s'", count, (count == 1 ? "" : "s"), path.c_str());
+  PluginPaths.push_back(path);
+}
 
-  // TODO Remove duplicate plugins (same name, remove older IntVersion)
+void Licq::TPluginRepository::rebuildCache()
+{
+  // Remove all old factories
+  PluginFactories.clear();
 
-  TPluginPrototypeList::iterator it = PluginPrototypeList.begin();
-  for (; it != PluginPrototypeList.end(); ++it)
+  for (TStringList::const_iterator path = PluginPaths.begin();
+       path != PluginPaths.end(); ++path)
   {
-    Log->info("Plugin %s version %s.",
-              (*it)->getPluginInformation().Name.c_str(),
-              (*it)->getPluginInformation().Version.c_str());
-    Log->info("       %s", (*it)->getPluginInformation().Description.c_str());
+    const unsigned int count = PluginLoader.loadPlugins(*path, &PluginFactories);
+    Log->debug("Loaded %u plugin%s from %s",
+               count, (count == 1 ? "" : "s"), path->c_str());
+  }
+
+  // Clear the cache
+  std::for_each(PluginCache.begin(), PluginCache.end(), ObjectDeleter());
+
+  for (TPluginFactories::const_iterator factory = PluginFactories.begin();
+       factory != PluginFactories.end(); ++factory)
+  {
+    const unsigned int count = (*factory)->getPluginCount();
+    for (unsigned int index = 0; index < count; ++index)
+    {
+      TCacheEntry* entry = new TCacheEntry;
+      entry->LibraryFilename = (*factory)->getLibraryFilename();
+      entry->Factory = *factory;
+      entry->Index = index;
+      entry->Information = (*factory)->getPluginInformation(index);
+
+      // Check for duplicate plugins
+      TPluginCache::iterator cache = PluginCache.find(entry->Information.Name);
+      if (cache != PluginCache.end())
+      {
+        // Keep the one with the highest IntVersion, or if equal, the first loaded.
+        if (entry->Information.IntVersion <= cache->second->Information.IntVersion)
+        {
+          delete entry;
+          continue;
+        }
+        else
+        {
+          delete cache->second;
+          PluginCache.erase(cache);
+        }
+      }
+
+      PluginCache[entry->Information.Name] = entry;
+    }
   }
 }
+
+void Licq::TPluginRepository::unloadUnusedPlugins()
+{
+  PluginFactories.clear();
+}
+
+void Licq::TPluginRepository::
+getAvailablePlugins(std::list<TPluginInformation>* pluginInformation)
+{
+  for (TPluginCache::const_iterator cache = PluginCache.begin();
+       cache != PluginCache.end(); ++cache)
+  {
+    pluginInformation->push_back(cache->second->Information);
+  }
+}
+
+Licq::IPlugin* Licq::TPluginRepository::createPlugin(const std::string& name)
+{
+  TPluginCache::const_iterator cache = PluginCache.find(name);
+  if (cache == PluginCache.end())
+  {
+    Log->error("No such plugin %s", name.c_str());
+    return NULL;
+  }
+
+  boost::shared_ptr<IPluginFactory> factory = cache->second->Factory.lock();
+  if (!factory)
+  {
+    // Need to reload the library
+    TPluginFactories factories;
+    if (PluginLoader.loadPlugins(cache->second->LibraryFilename, &factories) == 0)
+    {
+      Log->error("Failed to reopen plugin library %s",
+                 cache->second->LibraryFilename.c_str());
+      return NULL;
+    }
+
+    assert(factories.size() == 1);
+    factory = factories.front();
+  }
+  
+  assert(factory);
+  IPlugin* plugin = factory->createPlugin(cache->second->Index, NextPluginId, Log);
+
+  if (plugin != NULL)
+  {
+    NextPluginId += 1;
+    return new TPlugin(plugin, factory);
+  }
+
+  return NULL;
+}

branches/erijo-dev/licq/src/plugin/pluginrepository.h

@@ -18 +18 @@
  */
 
-#ifndef LICQ_TPLUGINMANAGER_H
-#define LICQ_TPLUGINMANAGER_H
+#ifndef LICQ_TPLUGINREPOSITORY_H
+#define LICQ_TPLUGINREPOSITORY_H
 
 #include "licq/interface/log.h"
+#include "licq/interface/plugin.h"
+#include "licq/interface/plugininformation.h"
+
+#include "plugin/pluginfactory.h"
 #include "plugin/pluginloader.h"
-#include "plugin/pluginprototype.h"
 
-#include <boost/noncopyable.hpp>
+#include <boost/weak_ptr.hpp>
+#include <map>
+#include <string>
 
 namespace Licq
 {
 
-class TPluginManager : boost::noncopyable
+class TPluginRepository
 {
 private:
   ILog* Log;
 
+  /// A list of paths to search for plugins.
+  TStringList PluginPaths;
+
   TPluginLoader PluginLoader;
-  TPluginPrototypeList PluginPrototypeList;
+
+  /// By keeping factories in this list, their dynamic library is keept in memory.
+  TPluginFactories PluginFactories;
+
+  struct TCacheEntry
+  {
+    std::string LibraryFilename;
+    boost::weak_ptr<IPluginFactory> Factory;
+    unsigned int Index;
+    TPluginInformation Information;
+  };
+
+  typedef std::map<std::string, TCacheEntry*> TPluginCache;
+  TPluginCache PluginCache;
 
   TPluginId NextPluginId;
 
 public:
-  TPluginManager(ILog* log);
-  ~TPluginManager();
+  explicit TPluginRepository(ILog* log);
+  ~TPluginRepository();
 
-  void addPluginSearchPath(const std::string& path);
+  void addSearchPath(const std::string& path);
+  void rebuildCache();
+
+  void unloadUnusedPlugins();
+
+  void getAvailablePlugins(std::list<TPluginInformation>* pluginInformation);
+
+  IPlugin* createPlugin(const std::string& name);
 };
 

branches/erijo-dev/licq/src/plugin/tests/CMakeLists.txt

@@ -1 +1 @@
 set(licqplugintest_SRCS
   main.cpp
-  pluginfactoryproxytest.cpp
+  pluginfactorytest.cpp
 )
 

branches/erijo-dev/licq/src/plugin/tests/pluginfactorytest.cpp

@@ -21 +21 @@
 
 #include "licq/interface/pluginfactory.h"
-#include "plugin/pluginfactoryproxy.h"
+#include "plugin/pluginfactory.h"
+
+class TPluginFactory : public Licq::IPluginFactory
+{
+public:
+  virtual unsigned int getPluginCount() const { return 0; }
+  virtual Licq::TPluginInformation getPluginInformation(unsigned int) const
+  {
+    return Licq::TPluginInformation();
+  }
+
+  virtual Licq::IPlugin* createPlugin(unsigned int, Licq::TPluginId, Licq::ILog*)
+  {
+    return NULL;
+  }
+};
 
 static unsigned int DestructorCount = 0;
+static TPluginFactory PluginFactory;
+static Licq::IPluginFactory* DestroyedPluginFactory = NULL;
 
-void licqDestroyPluginFactory(Licq::IPluginFactory*)
+Licq::IPluginFactory* licqCreatePluginFactory()
 {
+  return &PluginFactory;
+}
+
+void licqDestroyPluginFactory(Licq::IPluginFactory* factory)
+{
+  DestroyedPluginFactory = factory;
   DestructorCount += 1;
 }
 
-BOOST_AUTO_UNIT_TEST( tc_pluginfactoryproxy )
+BOOST_AUTO_UNIT_TEST( tc_pluginfactory )
 {
+  BOOST_CHECK_EQUAL(DestroyedPluginFactory, (Licq::IPluginFactory*)NULL);
   BOOST_CHECK_EQUAL(DestructorCount, 0u);
   {
-    Licq::TPluginFactoryProxy proxy(NULL, NULL, &licqDestroyPluginFactory);
-    BOOST_CHECK_EQUAL(proxy.getFactory(), (Licq::IPluginFactory*)NULL);
+    Licq::TPluginFactory factory(NULL, 
+                                 &licqCreatePluginFactory, 
+                                 &licqDestroyPluginFactory);
   }
   BOOST_CHECK_EQUAL(DestructorCount, 1u);
+  BOOST_CHECK_EQUAL(&PluginFactory, DestroyedPluginFactory);
 }