Changeset 6016 for branches/newapi

Timestamp:

01/11/08 05:30:23 (11 months ago)

Author:

erijo

Message:

Added methods to PluginManager? for handling starting and stopping of plugins.

Location:

branches/newapi/licq/src/plugin

Files:

• pluginmanager.h (modified) (2 diffs)
• pluginmanagerimpl.cpp (modified) (4 diffs)
• pluginmanagerimpl.h (modified) (3 diffs)

branches/newapi/licq/src/plugin/pluginmanager.h

@@ -24 +24 @@
 
 #include <boost/noncopyable.hpp>
-#include <boost/shared_ptr.hpp>
 #include <vector>
 
@@ -39 +38 @@
 {
 public:
-  virtual void getPluginInformation(
-    std::vector< boost::shared_ptr<const Licq::Plugin::Information> >* info) = 0;
+  virtual void getPluginInformation(Licq::Plugin::InformationVector* info) = 0;
+  virtual bool isValidPluginId(Licq::Plugin::Id id) const = 0;
 
-  virtual Licq::Plugin::Id
-  loadPlugin(const std::string& filename, int argc, char** argv) = 0;
+  virtual Licq::Plugin::Id startPlugin(const std::string& filename,
+                                       int argc, char** argv) = 0;
+
+  virtual void stopAllPlugins() = 0;
+
+  virtual void stopPlugin(Licq::Plugin::Id id) = 0;
+  virtual void cleanupPlugin(Licq::Plugin::Id id) = 0;
 
   virtual PluginCache* getPluginCache() const = 0;

branches/newapi/licq/src/plugin/pluginmanagerimpl.cpp

@@ -18 +18 @@
  */
 
+#include "event/eventmanager.h"
+#include "event/eventqueuename.h"
 #include "licq/event/eventqueue.h"
+#include "licq/exception/invalidargumentexception.h"
 #include "plugin/plugincache.h"
 #include "plugin/plugininstanceimpl.h"
 #include "plugin/pluginmanagerimpl.h"
+#include "util/tr.h"
 
-LicqDaemon::PluginManagerImpl::PluginManagerImpl(PluginCache& cache,
+LicqDaemon::PluginManagerImpl::PluginManagerImpl(EventManager& eventManager,
+                                                 PluginCache& cache,
                                                  Licq::LogSink& sink)
-  : myCache(cache),
+  : myEventManager(eventManager),
+    myCache(cache),
     myPluginLogSink(sink)
 {
@@ -33 +39 @@
 LicqDaemon::PluginManagerImpl::~PluginManagerImpl()
 {
-  // Empty
+  // Cleanup plugins that didn't exit on their own
+  while (!myPlugins.empty())
+    cleanupPlugin(myPlugins.begin(), true);
 }
 
-void LicqDaemon::PluginManagerImpl::getPluginInformation(
-  std::vector< boost::shared_ptr<const Licq::Plugin::Information> >* info)
+void LicqDaemon::PluginManagerImpl::
+getPluginInformation(Licq::Plugin::InformationVector* info)
 {
   assert(info != NULL);
@@ -47 +55 @@
 }
 
+bool LicqDaemon::PluginManagerImpl::isValidPluginId(Licq::Plugin::Id id) const
+{
+  return (myPlugins.find(id) != myPlugins.end());
+}
+
 Licq::Plugin::Id LicqDaemon::PluginManagerImpl::
-loadPlugin(const std::string& filename, int argc, char** argv)
+startPlugin(const std::string& filename, int argc, char** argv)
 {
   const size_t index = myCache.getIndex(filename);
 
-  boost::shared_ptr<const Licq::Plugin::Information>
-      info = myCache.getInformation(index);
-
+  Licq::Plugin::Information::Ptr info = myCache.getInformation(index);
   boost::shared_ptr<PluginLibrary> lib = myCache.getLibrary(index);
 
-  boost::shared_ptr<PluginInstance>
-      instance(new PluginInstanceImpl(info, lib, myPluginLogSink));
+  // Create the plugin instance
+  PluginInstancePtr instance(new PluginInstanceImpl(info, lib, myPluginLogSink));
 
   Licq::Plugin::Id id = instance->load(argc, argv);
@@ -64 +75 @@
 
   // Start the plugin
-  instance->getThread()->start();
+  instance->start();
 
-  // Send started event
-  boost::shared_ptr<Licq::Event> started = Licq::Event::create("started");
-  instance->getEventQueue()->push(started);
+  // Add to default queues
+  myEventManager.registerQueue(EventQueueName::allPlugins,
+                               instance->getEventQueue(), 0);
+  myEventManager.registerQueue(EventQueueName::getPluginPrivate(id),
+                               instance->getEventQueue(), 0);
+
+  // Notify all plugins that a new plugin has started
+  Licq::Event::Ptr started = Licq::Event::create("plugin.started");
+  started->setProperty("id", id);
+  started->setProperty("information", info);
+  myEventManager.sendEvent(EventQueueName::allPlugins, started);
 
   return id;
 }
+
+void LicqDaemon::PluginManagerImpl::stopAllPlugins()
+{
+  for (Plugins::iterator plugin = myPlugins.begin();
+       plugin != myPlugins.end(); ++plugin)
+  {
+    stopPlugin(plugin);
+  }
+}
+
+void LicqDaemon::PluginManagerImpl::stopPlugin(Licq::Plugin::Id id)
+{
+  stopPlugin(getPlugin(id));
+}
+
+void LicqDaemon::PluginManagerImpl::cleanupPlugin(Licq::Plugin::Id id)
+{
+  cleanupPlugin(getPlugin(id), false);
+}
+
+LicqDaemon::PluginManagerImpl::Plugins::iterator
+LicqDaemon::PluginManagerImpl::getPlugin(Licq::Plugin::Id id)
+{
+  Plugins::iterator plugin = myPlugins.find(id);
+  if (plugin == myPlugins.end())
+    throw Licq::InvalidArgumentException("PluginManager::getPlugin",
+                                         tr("No plugin instance with id %1%") % id);
+  return plugin;
+}
+
+void LicqDaemon::PluginManagerImpl::stopPlugin(Plugins::iterator plugin)
+{
+  const Licq::Plugin::Id id = plugin->first;
+  PluginInstancePtr& instance = plugin->second;
+
+  // Remove from default queues
+  myEventManager.unregisterQueue(EventQueueName::allPlugins,
+                                 instance->getEventQueue());
+  myEventManager.unregisterQueue(EventQueueName::getPluginPrivate(id),
+                                 instance->getEventQueue());
+
+  // Send event telling plugin to stop
+  Licq::Event::Ptr stop = Licq::Event::create("plugin.stop");
+  stop->setProperty("id", id);
+  instance->initiateStop(stop);
+}
+
+void LicqDaemon::PluginManagerImpl::cleanupPlugin(Plugins::iterator plugin,
+                                                  bool force)
+{
+  const Licq::Plugin::Id id = plugin->first;
+  PluginInstancePtr& instance = plugin->second;
+
+  // Stop plugin
+  instance->completeStop(force);
+
+  // Remove from all queues
+  myEventManager.unregisterQueue(instance->getEventQueue());
+
+  // Notify all plugins that a plugin has stopped
+  Licq::Event::Ptr stopped = Licq::Event::create("plugin.stopped");
+  stopped->setProperty("id", id);
+  stopped->setProperty("information", instance->getInformation());
+  myEventManager.sendEvent(EventQueueName::allPlugins, stopped);
+
+  myPlugins.erase(plugin);
+}

branches/newapi/licq/src/plugin/pluginmanagerimpl.h

@@ -33 +33 @@
 {
 
+class EventManager;
 class PluginInstance;
 
@@ -39 +40 @@
 public:
   /**
+   * @param eventManager The event manager to use.
    * @param cache PluginCache to use.
    * @param sink LogSink that plugins should use.
    */
-  PluginManagerImpl(PluginCache& cache, Licq::LogSink& sink);
+  PluginManagerImpl(EventManager& eventManger,
+                    PluginCache& cache,
+                    Licq::LogSink& sink);
 
   ~PluginManagerImpl();
 
-  void getPluginInformation(
-    std::vector< boost::shared_ptr<const Licq::Plugin::Information> >* info);
+  void getPluginInformation(Licq::Plugin::InformationVector* info);
+  bool isValidPluginId(Licq::Plugin::Id id) const;
 
-  Licq::Plugin::Id
-    loadPlugin(const std::string& filename, int argc, char** argv);
+  Licq::Plugin::Id startPlugin(const std::string& filename,
+                               int argc, char** argv);
+
+  void stopAllPlugins();
+
+  void stopPlugin(Licq::Plugin::Id id);
+  void cleanupPlugin(Licq::Plugin::Id id);
 
   /**
@@ -58 +67 @@
 
 private:
+  EventManager& myEventManager;
   PluginCache& myCache;
   Licq::LogSink& myPluginLogSink;
   
-  typedef std::map<Licq::Plugin::Id,
-                   boost::shared_ptr<PluginInstance> > Plugins;
+  typedef boost::shared_ptr<PluginInstance> PluginInstancePtr;
+  typedef std::map<Licq::Plugin::Id, PluginInstancePtr> Plugins;
   Plugins myPlugins;
+
+  Plugins::iterator getPlugin(Licq::Plugin::Id id);
+  void stopPlugin(Plugins::iterator plugin);
+  void cleanupPlugin(Plugins::iterator plugin, bool force);
 };