zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/PluginManagerI.cpp

@@ -1,72 +1,27 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <IceUtil/Options.h>
-#include <Ice/PluginManagerI.h>
-#include <Ice/DynamicLibrary.h>
-#include <Ice/Communicator.h>
-#include <Ice/Properties.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/Instance.h>
-#include <Ice/LocalException.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "PluginManagerI.h"
+#include "DynamicLibrary.h"
+#include "Ice/Communicator.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/Properties.h"
+#include "Instance.h"
+#include "Options.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-const char * const Ice::PluginManagerI::_kindOfObject = "plugin";
-
-namespace
-{
-
-map<string, PluginFactory>* factories = 0;
-vector<string>* loadOnInitialization = 0;
+const char* const Ice::PluginManagerI::_kindOfObject = "plugin";
 
-class PluginFactoryDestroy
-{
-public:
-
-    ~PluginFactoryDestroy()
-    {
-        delete factories;
-        factories = 0;
-
-        delete loadOnInitialization;
-        loadOnInitialization = 0;
-    }
-};
-PluginFactoryDestroy destroy;
-
-}
-
-void
-Ice::PluginManagerI::registerPluginFactory(const std::string& name, PluginFactory factory, bool loadOnInit)
-{
-    if(factories == 0)
-    {
-        factories = new map<string, PluginFactory>();
-    }
-
-    map<string, PluginFactory>::const_iterator p = factories->find(name);
-    if(p == factories->end())
-    {
-        factories->insert(make_pair(name, factory));
-        if(loadOnInit)
-        {
-            if(loadOnInitialization == 0)
-            {
-                loadOnInitialization = new vector<string>();
-            }
-            loadOnInitialization->push_back(name);
-        }
-    }
-}
+Ice::Plugin::~Plugin() = default;               // avoid weak vtable
+Ice::PluginManager::~PluginManager() = default; // avoid weak vtable
 
 void
 Ice::PluginManagerI::initializePlugins()
 {
-    if(_initialized)
+    if (_initialized)
     {
         throw InitializationException(__FILE__, __LINE__, "plug-ins already initialized");
     }
@@ -77,44 +32,44 @@ Ice::PluginManagerI::initializePlugins()
     vector<PluginPtr> initializedPlugins;
     try
     {
-        for(PluginInfoList::iterator p = _plugins.begin(); p != _plugins.end(); ++p)
+        for (const auto& plugin : _plugins)
         {
             try
             {
-                p->plugin->initialize();
+                plugin.plugin->initialize();
             }
-            catch(const Ice::PluginInitializationException&)
+            catch (const Ice::PluginInitializationException&)
             {
                 throw;
             }
-            catch(const std::exception& ex)
+            catch (const std::exception& ex)
             {
                 ostringstream os;
-                os << "plugin `" << p->name << "' initialization failed:\n" << ex.what();
+                os << "plugin '" << plugin.name << "' initialization failed:\n" << ex.what();
                 throw PluginInitializationException(__FILE__, __LINE__, os.str());
             }
-            catch(...)
+            catch (...)
             {
                 ostringstream os;
-                os << "plugin `" << p->name << "' initialization failed:\nunknown exception";
+                os << "plugin '" << plugin.name << "' initialization failed:\nunknown exception";
                 throw PluginInitializationException(__FILE__, __LINE__, os.str());
             }
-            initializedPlugins.push_back(p->plugin);
+            initializedPlugins.push_back(plugin.plugin);
         }
     }
-    catch(...)
+    catch (...)
     {
         //
         // Destroy the plug-ins that have been successfully initialized, in the
         // reverse order.
         //
-        for(vector<PluginPtr>::reverse_iterator p = initializedPlugins.rbegin(); p != initializedPlugins.rend(); ++p)
+        for (auto p = initializedPlugins.rbegin(); p != initializedPlugins.rend(); ++p)
         {
             try
             {
                 (*p)->destroy();
             }
-            catch(...)
+            catch (...)
             {
                 // Ignore.
             }
@@ -126,157 +81,123 @@ Ice::PluginManagerI::initializePlugins()
 }
 
 StringSeq
-Ice::PluginManagerI::getPlugins() ICE_NOEXCEPT
+Ice::PluginManagerI::getPlugins()
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     StringSeq names;
-    for(PluginInfoList::iterator p = _plugins.begin(); p != _plugins.end(); ++p)
+    for (const auto& plugin : _plugins)
     {
-        names.push_back(p->name);
+        names.push_back(plugin.name);
     }
     return names;
 }
 
 PluginPtr
-Ice::PluginManagerI::getPlugin(const string& name)
+Ice::PluginManagerI::getPlugin(string_view name)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(!_communicator)
+    if (!_communicator)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
 
     PluginPtr p = findPlugin(name);
-    if(p)
+    if (p)
     {
         return p;
     }
 
-    throw NotRegisteredException(__FILE__, __LINE__, _kindOfObject, name);
+    throw NotRegisteredException(__FILE__, __LINE__, _kindOfObject, string{name});
 }
 
 void
-Ice::PluginManagerI::addPlugin(const string& name, const PluginPtr& plugin)
+Ice::PluginManagerI::addPlugin(string name, PluginPtr plugin)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(!_communicator)
+    if (!_communicator)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
 
-    if(findPlugin(name))
+    if (findPlugin(name))
     {
         throw AlreadyRegisteredException(__FILE__, __LINE__, _kindOfObject, name);
     }
 
     PluginInfo info;
-    info.name = name;
-    info.plugin = plugin;
-    _plugins.push_back(info);
+    info.name = std::move(name);
+    info.plugin = std::move(plugin);
+    _plugins.push_back(std::move(info));
 }
 
 void
-Ice::PluginManagerI::destroy() ICE_NOEXCEPT
+Ice::PluginManagerI::destroy() noexcept
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_communicator)
+    if (_communicator)
     {
-        if(_initialized)
+        if (_initialized)
         {
-
             //
             // Destroy the plug-ins that have been successfully initialized, in the
             // reverse order.
             //
-            for(PluginInfoList::reverse_iterator p = _plugins.rbegin(); p != _plugins.rend(); ++p)
+            for (auto p = _plugins.rbegin(); p != _plugins.rend(); ++p)
             {
                 try
                 {
                     p->plugin->destroy();
                 }
-                catch(const std::exception& ex)
+                catch (const std::exception& ex)
                 {
                     Warning out(getProcessLogger());
-                    out << "unexpected exception raised by plug-in `" << p->name << "' destruction:\n" << ex.what();
+                    out << "unexpected exception raised by plug-in '" << p->name << "' destruction:\n" << ex.what();
                 }
-                catch(const std::string& str)
+                catch (...)
                 {
                     Warning out(getProcessLogger());
-                    out << "unexpected exception raised by plug-in `" << p->name << "' destruction:\n" << str;
-                }
-                catch(const char* msg)
-                {
-                    Warning out(getProcessLogger());
-                    out << "unexpected exception raised by plug-in `" << p->name << "' destruction:\n" << msg;
-                }
-                catch(...)
-                {
-                    Warning out(getProcessLogger());
-                    out << "unexpected exception raised by plug-in `" << p->name << "' destruction";
+                    out << "unexpected exception raised by plug-in '" << p->name << "' destruction";
                 }
             }
         }
 
-        _communicator = 0;
+        _communicator = nullptr;
     }
 
     _plugins.clear();
-    _libraries = 0;
 }
 
-Ice::PluginManagerI::PluginManagerI(const CommunicatorPtr& communicator, const DynamicLibraryListPtr& libraries) :
-    _communicator(communicator),
-    _libraries(libraries),
-    _initialized(false)
-{
-}
+Ice::PluginManagerI::PluginManagerI(CommunicatorPtr communicator) : _communicator(std::move(communicator)) {}
 
-void
-Ice::PluginManagerI::loadPlugins(int& argc, const char* argv[])
+bool
+Ice::PluginManagerI::loadPlugins()
 {
     assert(_communicator);
-
-    StringSeq cmdArgs = argsToStringSeq(argc, argv);
+    bool libraryLoaded = false;
 
     const string prefix = "Ice.Plugin.";
     PropertiesPtr properties = _communicator->getProperties();
     PropertyDict plugins = properties->getPropertiesForPrefix(prefix);
 
-    //
-    // First, load static plugin factories which were setup to load on
-    // communicator initialization. If a matching plugin property is
-    // set, we load the plugin with the plugin specification. The
-    // entryPoint will be ignored but the rest of the plugin
-    // specification might be used.
-    //
-    if(loadOnInitialization)
+    // First, create plug-ins using the plug-in factories from initData, in order.
+    for (const auto& pluginFactory : getInstance(_communicator)->initializationData().pluginFactories)
     {
-        for(vector<string>::const_iterator p = loadOnInitialization->begin(); p != loadOnInitialization->end(); ++p)
-        {
-            string property = prefix + *p;
-            PropertyDict::iterator r = plugins.find(property + ".cpp");
-            if(r == plugins.end())
-            {
-                r = plugins.find(property);
-            }
-            else
-            {
-                plugins.erase(property);
-            }
+        string name = pluginFactory.pluginName;
 
-            if(r != plugins.end())
-            {
-                loadPlugin(*p, r->second, cmdArgs);
-                plugins.erase(r);
-            }
-            else
-            {
-                loadPlugin(*p, "", cmdArgs);
-            }
+        string key = prefix + name;
+        auto r = plugins.find(key);
+        if (r != plugins.end())
+        {
+            loadPlugin(pluginFactory.factoryFunc, name, r->second);
+            plugins.erase(r);
+        }
+        else
+        {
+            loadPlugin(pluginFactory.factoryFunc, name, "");
         }
     }
 
@@ -285,41 +206,30 @@ Ice::PluginManagerI::loadPlugins(int& argc, const char* argv[])
     // set with the prefix "Ice.Plugin.". These properties should have
     // the following format:
     //
-    // Ice.Plugin.name[.<language>]=entry_point [args]
+    // Ice.Plugin.<name>=entry_point [args]
     //
     // If the Ice.PluginLoadOrder property is defined, load the
     // specified plug-ins in the specified order, then load any
     // remaining plug-ins.
     //
-    StringSeq loadOrder = properties->getPropertyAsList("Ice.PluginLoadOrder");
-    for(StringSeq::const_iterator p = loadOrder.begin(); p != loadOrder.end(); ++p)
+    StringSeq loadOrder = properties->getIcePropertyAsList("Ice.PluginLoadOrder");
+    for (const auto& name : loadOrder)
     {
-        string name = *p;
-
-        if(findPlugin(name))
+        if (findPlugin(name))
         {
-            throw PluginInitializationException(__FILE__, __LINE__, "plug-in `" + name + "' already loaded");
+            throw PluginInitializationException(__FILE__, __LINE__, "plug-in '" + name + "' already loaded");
         }
 
         string property = prefix + name;
-        PropertyDict::iterator r = plugins.find(property + ".cpp");
-        if(r == plugins.end())
-        {
-            r = plugins.find(property);
-        }
-        else
+        auto r = plugins.find(property);
+        if (r != plugins.end())
         {
-            plugins.erase(property);
-        }
-
-        if(r != plugins.end())
-        {
-            loadPlugin(name, r->second, cmdArgs);
+            libraryLoaded |= loadPlugin(nullptr, name, r->second);
             plugins.erase(r);
         }
         else
         {
-            throw PluginInitializationException(__FILE__, __LINE__, "plug-in `" + name + "' not defined");
+            throw PluginInitializationException(__FILE__, __LINE__, "plug-in '" + name + "' not defined");
         }
     }
 
@@ -327,68 +237,31 @@ Ice::PluginManagerI::loadPlugins(int& argc, const char* argv[])
     // Load any remaining plug-ins that weren't specified in PluginLoadOrder.
     //
 
-    while(!plugins.empty())
+    for (const auto& [key, value] : plugins)
     {
-        PropertyDict::iterator p = plugins.begin();
-
-        string name = p->first.substr(prefix.size());
-
-        size_t dotPos = name.find_last_of('.');
-        if(dotPos != string::npos)
-        {
-            string suffix = name.substr(dotPos + 1);
-            if(suffix == "java" || suffix == "clr")
-            {
-                //
-                // Ignored
-                //
-                plugins.erase(p);
-            }
-            else if(suffix == "cpp")
-            {
-                name = name.substr(0, dotPos);
-                loadPlugin(name, p->second, cmdArgs);
-                plugins.erase(p);
-
-                plugins.erase(prefix + name);
-            }
-            else
-            {
-                //
-                // Name is just a regular name that happens to contain a dot
-                //
-                dotPos = string::npos;
-            }
-        }
-
-        if(dotPos == string::npos)
-        {
-            //
-            // Is there a .cpp entry?
-            //
-            PropertyDict::iterator q = plugins.find(prefix + name + ".cpp");
-            if(q != plugins.end())
-            {
-                plugins.erase(p);
-                p = q;
-            }
-
-            loadPlugin(name, p->second, cmdArgs);
-            plugins.erase(p);
-        }
+        libraryLoaded |= loadPlugin(nullptr, key.substr(prefix.size()), value);
     }
 
-    stringSeqToArgs(cmdArgs, argc, argv);
+    return libraryLoaded;
 }
 
-void
-Ice::PluginManagerI::loadPlugin(const string& name, const string& pluginSpec, StringSeq& cmdArgs)
+bool
+Ice::PluginManagerI::loadPlugin(PluginFactoryFunc factoryFunc, const string& name, const string& pluginSpec)
 {
     assert(_communicator);
 
+    if (findPlugin(name))
+    {
+        // We check and throw this exception before creating the plug-in. For example, the plug-in constructor can
+        // register endpoint types, and we don't want such duplication to ever occur.
+        throw AlreadyRegisteredException{__FILE__, __LINE__, _kindOfObject, name};
+    }
+
+    bool libraryLoaded = false;
+
     string entryPoint;
     StringSeq args;
-    if(!pluginSpec.empty())
+    if (!pluginSpec.empty())
     {
         //
         // Split the entire property value into arguments. An entry point containing spaces
@@ -396,12 +269,14 @@ Ice::PluginManagerI::loadPlugin(const string& name, const string& pluginSpec, St
         //
         try
         {
-            args = IceUtilInternal::Options::split(pluginSpec);
+            args = IceInternal::Options::split(pluginSpec);
         }
-        catch(const IceUtilInternal::BadOptException& ex)
+        catch (const IceInternal::BadOptException& ex)
         {
-            throw PluginInitializationException(__FILE__, __LINE__, "invalid arguments for plug-in `" + name + "':\n" +
-                                                ex.reason);
+            throw PluginInitializationException(
+                __FILE__,
+                __LINE__,
+                "invalid arguments for plug-in '" + name + "':\n" + string{ex.what()});
         }
 
         assert(!args.empty());
@@ -412,92 +287,58 @@ Ice::PluginManagerI::loadPlugin(const string& name, const string& pluginSpec, St
         entryPoint = args[0];
         args.erase(args.begin());
 
-        //
-        // Convert command-line options into properties. First we
-        // convert the options from the plug-in configuration, then
-        // we convert the options from the application command-line.
-        //
+        // Convert command-line options into properties.
         PropertiesPtr properties = _communicator->getProperties();
         args = properties->parseCommandLineOptions(name, args);
-        cmdArgs = properties->parseCommandLineOptions(name, cmdArgs);
     }
 
-    PluginFactory factory = 0;
-    DynamicLibraryPtr library;
-
-    //
-    // Always check the static plugin factory table first, it takes
-    // precedence over the entryPoint specified in the plugin
-    // property value.
-    //
-    if(factories)
-    {
-        map<string, PluginFactory>::const_iterator p = factories->find(name);
-        if(p != factories->end())
-        {
-            factory = p->second;
-        }
-    }
-
-    //
-    // If we didn't find the factory, get the factory using the entry
-    // point symbol.
-    //
-    if(!factory)
+    if (!factoryFunc)
     {
         assert(!entryPoint.empty());
-        library = new DynamicLibrary();
-        DynamicLibrary::symbol_type sym = library->loadEntryPoint(entryPoint);
-        if(sym == 0)
+        DynamicLibrary library;
+        DynamicLibrary::symbol_type sym = library.loadEntryPoint(entryPoint);
+        if (sym == nullptr)
         {
             ostringstream os;
-            string msg = library->getErrorMessage();
-            os << "unable to load entry point `" << entryPoint << "'";
-            if(!msg.empty())
+            os << "unable to load entry point '" << entryPoint << "'";
+            const string& msg = library.getErrorMessage();
+            if (!msg.empty())
             {
                 os << ": " + msg;
             }
             throw PluginInitializationException(__FILE__, __LINE__, os.str());
         }
+        libraryLoaded = true;
 
-#ifdef __IBMCPP__
-    // xlC warns when casting a void* to function pointer
-#   pragma report(disable, "1540-0216")
-#endif
-
-        factory = reinterpret_cast<PluginFactory>(sym);
+        factoryFunc = reinterpret_cast<PluginFactoryFunc>(sym);
     }
 
     //
     // Invoke the factory function. No exceptions can be raised
     // by the factory function because it's declared extern "C".
     //
-    PluginPtr plugin(factory(_communicator, name, args));
-    if(!plugin)
+    PluginPtr plugin{factoryFunc(_communicator, name, args)};
+    if (!plugin)
     {
-        throw PluginInitializationException(__FILE__, __LINE__, "failure in entry point `" + entryPoint + "'");
+        throw PluginInitializationException(__FILE__, __LINE__, "failure in entry point '" + entryPoint + "'");
     }
 
     PluginInfo info;
     info.name = name;
     info.plugin = plugin;
-    _plugins.push_back(info);
-
-    if(library)
-    {
-        _libraries->add(library);
-    }
+    _plugins.push_back(std::move(info));
+    return libraryLoaded;
 }
 
 Ice::PluginPtr
-Ice::PluginManagerI::findPlugin(const string& name) const
+Ice::PluginManagerI::findPlugin(string_view name) const
 {
-    for(PluginInfoList::const_iterator p = _plugins.begin(); p != _plugins.end(); ++p)
+    for (const auto& p : _plugins)
     {
-        if(name == p->name)
+        if (name == p.name)
         {
-            return p->plugin;
+            return p.plugin;
         }
     }
-    return 0;
+    return nullptr;
 }