Add system to an entity through Component Inspector

include/ignition/gazebo/SystemLoader.hh

@@ -17,6 +17,7 @@
 #ifndef IGNITION_GAZEBO_SYSTEMLOADER_HH_
 #define IGNITION_GAZEBO_SYSTEMLOADER_HH_
 
+#include <list>
 #include <memory>
 #include <optional>
 #include <string>
@@ -61,7 +62,8 @@ namespace ignition
 
       /// \brief Load and instantiate system plugin from name/filename.
       /// \param[in] _filename Shared library filename to load plugin from.
-      /// \param[in] _name Class name to be instantiated.
+      /// \param[in] _name Class name to be instantiated. If empty, the first
+      /// plugin in the shared library will be loaded.
       /// \param[in] _sdf SDF Element describing plugin instance to be loaded.
       /// \returns Shared pointer to system instance or nullptr.
       /// \note This will be deprecated in Gazebo 7 (Garden), please the use
@@ -81,6 +83,10 @@ namespace ignition
       /// \returns A pretty string
       public: std::string PrettyStr() const;
 
+      /// \brief Get the plugin search paths used for loading system plugins
+      /// \return Paths to search for plugins
+      public: std::list<std::string> PluginPaths() const;
+
       /// \brief Pointer to private data.
       private: std::unique_ptr<SystemLoaderPrivate> dataPtr;
     };

src/ServerConfig.cc

@@ -91,6 +91,7 @@ class ignition::gazebo::ServerConfig::PluginInfoPrivate
 
   /// \brief XML elements associated with this plugin
   public: sdf::ElementPtr sdf = nullptr;
+
 };
 
 //////////////////////////////////////////////////

src/SystemLoader.cc

@@ -41,8 +41,7 @@ class ignition::gazebo::SystemLoaderPrivate
   public: explicit SystemLoaderPrivate() = default;
 
   //////////////////////////////////////////////////
-  public: bool InstantiateSystemPlugin(const sdf::Plugin &_sdfPlugin,
-              ignition::plugin::PluginPtr &_gzPlugin)
+  public: std::list<std::string> PluginPaths() const
   {
     ignition::common::SystemPaths systemPaths;
     systemPaths.SetPluginPathEnv(pluginPathEnv);
@@ -52,9 +51,24 @@ class ignition::gazebo::SystemLoaderPrivate
 
     std::string homePath;
     ignition::common::env(IGN_HOMEDIR, homePath);
-    systemPaths.AddPluginPaths(homePath + "/.ignition/gazebo/plugins");
+    systemPaths.AddPluginPaths(common::joinPaths(
+        homePath, ".ignition", "gazebo", "plugins"));
     systemPaths.AddPluginPaths(IGN_GAZEBO_PLUGIN_INSTALL_DIR);
 
+    return systemPaths.PluginPaths();
+  }
+
+  //////////////////////////////////////////////////
+  public: bool InstantiateSystemPlugin(const sdf::Plugin &_sdfPlugin,
+              ignition::plugin::PluginPtr &_gzPlugin)
+  {
+    std::list<std::string> paths = this->PluginPaths();
+    common::SystemPaths systemPaths;
+    for (const auto &p : paths)
+    {
+      systemPaths.AddPluginPaths(p);
+    }
+
     auto pathToLib = systemPaths.FindSharedLibrary(_sdfPlugin.Filename());
     if (pathToLib.empty())
     {
@@ -85,7 +99,11 @@ class ignition::gazebo::SystemLoaderPrivate
       return false;
     }
 
-    _gzPlugin = this->loader.Instantiate(_sdfPlugin.Name());
+    // use the first plugin name in the library if not specified
+    std::string pluginToInstantiate = _sdfPlugin.Name().empty() ?
+        pluginName : _sdfPlugin.Name();
+
+    _gzPlugin = this->loader.Instantiate(pluginToInstantiate);
     if (!_gzPlugin)
     {
       ignerr << "Failed to load system plugin [" << _sdfPlugin.Name() <<
@@ -129,6 +147,12 @@ SystemLoader::SystemLoader()
 //////////////////////////////////////////////////
 SystemLoader::~SystemLoader() = default;
 
+//////////////////////////////////////////////////
+std::list<std::string> SystemLoader::PluginPaths() const
+{
+  return this->dataPtr->PluginPaths();
+}
+
 //////////////////////////////////////////////////
 void SystemLoader::AddSystemPluginPath(const std::string &_path)
 {
@@ -141,11 +165,10 @@ std::optional<SystemPluginPtr> SystemLoader::LoadPlugin(
   const std::string &_name,
   const sdf::ElementPtr &_sdf)
 {
-  if (_filename == "" || _name == "")
+  if (_filename == "")
   {
     ignerr << "Failed to instantiate system plugin: empty argument "
-              "[(filename): " << _filename << "] " <<
-              "[(name): " << _name << "]." << std::endl;
+              "[(filename): " << _filename << "] " << std::endl;
     return {};
   }
 
@@ -175,18 +198,16 @@ std::optional<SystemPluginPtr> SystemLoader::LoadPlugin(
 {
   ignition::plugin::PluginPtr plugin;
 
-  if (_plugin.Filename() == "" || _plugin.Name() == "")
+  if (_plugin.Filename() == "")
   {
     ignerr << "Failed to instantiate system plugin: empty argument "
-              "[(filename): " << _plugin.Filename() << "] " <<
-              "[(name): " << _plugin.Name() << "]." << std::endl;
+              "[(filename): " << _plugin.Filename() << "] " << std::endl;
     return {};
   }
 
   auto ret = this->dataPtr->InstantiateSystemPlugin(_plugin, plugin);
   if (ret && plugin)
     return plugin;
-
   return {};
 }
 

src/SystemLoader_TEST.cc

@@ -27,6 +27,7 @@
 #include "ignition/gazebo/test_config.hh"  // NOLINT(build/include)
 
 using namespace ignition;
+using namespace gazebo;
 
 /////////////////////////////////////////////////
 TEST(SystemLoader, Constructor)
@@ -67,3 +68,38 @@ TEST(SystemLoader, EmptyNames)
   auto system = sm.LoadPlugin(plugin);
   ASSERT_FALSE(system.has_value());
 }
+
+/////////////////////////////////////////////////
+TEST(SystemLoader, PluginPaths)
+{
+  SystemLoader sm;
+
+  // verify that there should exist some default paths
+  std::list<std::string> paths = sm.PluginPaths();
+  unsigned int pathCount = paths.size();
+  EXPECT_LT(0u, pathCount);
+
+  // Add test path and verify that the loader now contains this path
+  auto testBuildPath = common::joinPaths(
+      std::string(PROJECT_BINARY_PATH), "lib");
+  sm.AddSystemPluginPath(testBuildPath);
+  paths = sm.PluginPaths();
+
+  // Number of paths should increase by 1
+  EXPECT_EQ(pathCount + 1, paths.size());
+
+  // verify newly added paths exists
+  bool hasPath = false;
+  for (const auto &s : paths)
+  {
+    // the returned path string may not be exact match due to extra '/'
+    // appended at the end of the string. So use absPath to generate
+    // a path string that matches the format returned by joinPaths
+    if (common::absPath(s) == testBuildPath)
+    {
+      hasPath = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(hasPath);
+}

src/SystemManager.cc

@@ -15,6 +15,11 @@
  *
 */
 
+#include <list>
+#include <set>
+
+#include <ignition/common/StringUtils.hh>
+
 #include "ignition/gazebo/components/SystemPluginInfo.hh"
 #include "ignition/gazebo/Conversions.hh"
 #include "SystemManager.hh"
@@ -34,11 +39,15 @@ SystemManager::SystemManager(const SystemLoaderPtr &_systemLoader,
   transport::NodeOptions opts;
   opts.SetNameSpace(_namespace);
   this->node = std::make_unique<transport::Node>(opts);
-  std::string entitySystemService{"entity/system/add"};
-  this->node->Advertise(entitySystemService,
+  std::string entitySystemAddService{"entity/system/add"};
+  this->node->Advertise(entitySystemAddService,
       &SystemManager::EntitySystemAddService, this);
   ignmsg << "Serving entity system service on ["
-         << "/" << entitySystemService << "]" << std::endl;
+         << "/" << entitySystemAddService << "]" << std::endl;
+
+  std::string entitySystemInfoService{"system/info"};
+  this->node->Advertise(entitySystemInfoService,
+      &SystemManager::EntitySystemInfoService, this);
 }
 
 //////////////////////////////////////////////////
@@ -215,6 +224,51 @@ bool SystemManager::EntitySystemAddService(const msgs::EntityPlugin_V &_req,
   return true;
 }
 
+//////////////////////////////////////////////////
+bool SystemManager::EntitySystemInfoService(const msgs::Empty &,
+                                            msgs::EntityPlugin_V &_res)
+{
+  // loop through all files in paths and populate the list of
+  // plugin libraries.
+  std::list<std::string> paths = this->systemLoader->PluginPaths();
+  std::set<std::string> filenames;
+  for (const auto &p : paths)
+  {
+    if (common::exists(p))
+    {
+      for (common::DirIter file(p);
+          file != common::DirIter(); ++file)
+      {
+        std::string current(*file);
+        std::string filename = common::basename(current);
+        if (common::isFile(current) &&
+            (common::EndsWith(filename, ".so") ||
+             common::EndsWith(filename, ".dll") ||
+             common::EndsWith(filename, ".dylib")))
+        {
+          // remove extension and lib prefix
+          size_t extensionIndex = filename.rfind(".");
+          std::string nameWithoutExtension =
+              filename.substr(0, extensionIndex);
+          if (common::StartsWith(nameWithoutExtension, "lib"))
+          {
+            nameWithoutExtension = nameWithoutExtension.substr(3);
+          }
+          filenames.insert(nameWithoutExtension);
+        }
+      }
+    }
+  }
+
+  for (const auto &fn : filenames)
+  {
+    auto plugin = _res.add_plugins();
+    plugin->set_filename(fn);
+  }
+
+  return true;
+}
+
 //////////////////////////////////////////////////
 void SystemManager::ProcessPendingEntitySystems()
 {

src/SystemManager.hh

@@ -142,6 +142,14 @@ namespace ignition
       private: bool EntitySystemAddService(const msgs::EntityPlugin_V &_req,
                                            msgs::Boolean &_res);
 
+      /// \brief Callback for entity info system service.
+      /// \param[in] _req Empty request message
+      /// \param[out] _res Response containing a list of plugin names
+      /// and filenames
+      /// \return True if request received.
+      private: bool EntitySystemInfoService(const msgs::Empty &_req,
+                                            msgs::EntityPlugin_V &_res);
+
       /// \brief All the systems.
       private: std::vector<SystemInternal> systems;