Plugin.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
#ifndef _GZ_PLUGIN_HH_
#define _GZ_PLUGIN_HH_
 
#ifndef _WIN32
  #include <unistd.h>
#endif
 
#include <sys/types.h>
#include <sys/stat.h>
 
#include <gazebo/gazebo_config.h>
#include <dlfcn.h>
 
#include <list>
#include <string>
 
#include <sdf/sdf.hh>
#include <boost/filesystem.hpp>
 
#include "gazebo/common/CommonTypes.hh"
#include "gazebo/common/SystemPaths.hh"
#include "gazebo/common/Console.hh"
#include "gazebo/common/Exception.hh"
 
#include "gazebo/physics/PhysicsTypes.hh"
#include "gazebo/sensors/SensorTypes.hh"
#include "gazebo/rendering/RenderTypes.hh"
#include "gazebo/util/system.hh"
 
namespace gazebo
{
  class Event;
 
 
  enum PluginType
  {
    WORLD_PLUGIN,
    MODEL_PLUGIN,
    SENSOR_PLUGIN,
    SYSTEM_PLUGIN,
    VISUAL_PLUGIN,
    GUI_PLUGIN
  };
 
 
  template<class T>
  class PluginT
  {
    public: typedef boost::shared_ptr<T> TPtr;
 
    public: PluginT()
            {
              this->dlHandle = nullptr;
            }
 
    public: virtual ~PluginT()
            {
              // dlclose has been disabled due to segfaults in the test suite
              // This workaround is detailed in #1026 and #1066. After the test
              // or gazebo execution the plugin is not loaded in memory anymore
              // \todo Figure out the right thing to do.
 
              // dlclose(this->dlHandle);
            }
 
    public: std::string GetFilename() const
            {
              return this->filename;
            }
 
    public: std::string GetHandle() const
            {
              return this->handleName;
            }
 
    public: static TPtr Create(const std::string &_filename,
                const std::string &_name)
            {
              TPtr result;
              // PluginPtr result;
              std::string filename(_filename);
              std::list<std::string> pluginPaths =
                common::SystemPaths::Instance()->GetPluginPaths();
              std::ostringstream errorStream;
 
              // helper function to find and dlopen a plugin file
              // returns void * dlHandle
              auto findAndDlopenPluginFile = [](
                  const std::string &_pluginFilename,
                  const std::list<std::string> &_pluginPaths,
                  std::ostringstream &_errorStream) -> void *
              {
                struct stat st;
                bool found = false;
                std::string fullname;
                std::list<std::string>::const_iterator iter;
 
                for (iter = _pluginPaths.begin();
                     iter!= _pluginPaths.end(); ++iter)
                {
                  fullname = (*iter)+std::string("/")+_pluginFilename;
                  fullname = boost::filesystem::path(fullname)
                      .make_preferred().string();
                  if (stat(fullname.c_str(), &st) == 0)
                  {
                    found = true;
                    break;
                  }
                }
 
                if (!found)
                  fullname = _pluginFilename;
 
                void *dlHandle = dlopen(fullname.c_str(), RTLD_LAZY|RTLD_GLOBAL);
                if (!dlHandle)
                {
                  _errorStream << "Failed to load plugin " << fullname << ": "
                    << dlerror() << "\n";
                }
                return dlHandle;
              };
 
              // This logic is to support different extensions on each OS
              // see issue #800
              //
              // Linux: lib*.so
              // macOS: lib*.so, lib*.dylib
              // Windows: *.dll
              //
              // Assuming that most plugin names are specified as lib*.so,
              // replace prefix and suffix depending on the OS.
              // On macOS, first try the lib*.so name, then try lib*.dylib
#ifdef _WIN32
              {
                // replace .so with .dll
                size_t soSuffix = filename.rfind(".so");
                if (soSuffix != std::string::npos)
                {
                  const std::string winSuffix(".dll");
                  filename.replace(soSuffix, winSuffix.length(), winSuffix);
                }
                size_t libPrefix = filename.find("lib");
                if (libPrefix == 0)
                {
                  // remove the lib prefix
                  filename.erase(0, 3);
                }
              }
#endif  // ifdef _WIN32
 
              // Try to find and dlopen plugin with the following pattern:
              // Linux: lib*.so
              // macOS: lib*.so
              // Windows: *.dll
              void *dlHandle = findAndDlopenPluginFile(filename, pluginPaths,
                                                       errorStream);
#ifdef __APPLE__
              if (!dlHandle)
              {
                // lib*.so file could not be found or opened, try lib*.dylib
                size_t soSuffix = filename.rfind(".so");
                if (soSuffix != std::string::npos)
                {
                  const std::string macSuffix(".dylib");
                  filename.replace(soSuffix, macSuffix.length(), macSuffix);
                }
              }
              // macOS: lib*.dylib
              dlHandle = findAndDlopenPluginFile(filename, pluginPaths, errorStream);
#endif  // ifdef __APPLE__
 
              if (!dlHandle)
              {
                gzerr << errorStream.str();
                return result;
              }
 
              fptr_union_t registerFunc;
              const char *registerName = "RegisterPlugin";
 
              registerFunc.ptr = dlsym(dlHandle, registerName);
 
              if (!registerFunc.ptr)
              {
                gzerr << "Failed to resolve " << registerName
                      << ": " << dlerror();
                return result;
              }
 
              // Register the new controller.
              result.reset(registerFunc.func());
              result->dlHandle = dlHandle;
 
              result->handleName = _name;
              result->filename = filename;
 
              return result;
            }
 
    public: PluginType GetType() const
            {
              return this->type;
            }
 
    protected: template <typename V> void LoadParam(const sdf::ElementPtr &_sdf,
                const std::string &_name, V &_target,
                V _defaultValue = V()) const
            {
              auto result = _sdf->Get<V>(_name, _defaultValue);
 
              if (!result.second)
              {
                gzmsg << this->handleName.c_str() << " Plugin missing <"
                      << _name.c_str() << ">, defaults to "
                      << result.first << std::endl;
              }
              else
              {
                gzmsg << this->handleName.c_str() << " Plugin <"
                      << _name.c_str() << "> set to "
                      << result.first << std::endl;
              }
              _target = result.first;
            }
 
    protected: void LoadParam(sdf::ElementPtr &_sdf,
                const std::string &_name, std::string &_target,
                const char* _defaultValue) const
            {
              this->LoadParam<std::string>(_sdf, _name, _target, _defaultValue);
            }
 
    protected: PluginType type;
 
    protected: std::string filename;
 
    protected: std::string handleName;
 
    private: typedef union
             {
               T *(*func)();
               void *ptr;
             } fptr_union_t;
 
    private: void *dlHandle;
  };
 
  class WorldPlugin : public PluginT<WorldPlugin>
  {
    public: WorldPlugin()
             {this->type = WORLD_PLUGIN;}
 
    public: virtual ~WorldPlugin() {}
 
    public: virtual void Load(physics::WorldPtr _world,
                              sdf::ElementPtr _sdf) = 0;
 
    public: virtual void Init() {}
    public: virtual void Reset() {}
  };
 
  class ModelPlugin : public PluginT<ModelPlugin>
  {
    public: ModelPlugin()
             {this->type = MODEL_PLUGIN;}
 
    public: virtual ~ModelPlugin() {}
 
    public: virtual void Load(physics::ModelPtr _model,
                              sdf::ElementPtr _sdf) = 0;
 
    public: virtual void Init() {}
 
    public: virtual void Reset() {}
  };
 
  class SensorPlugin : public PluginT<SensorPlugin>
  {
    public: SensorPlugin()
             {this->type = SENSOR_PLUGIN;}
 
    public: virtual ~SensorPlugin() {}
 
    public: virtual void Load(sensors::SensorPtr _sensor,
                              sdf::ElementPtr _sdf) = 0;
 
    public: virtual void Init() {}
 
    public: virtual void Reset() {}
  };
 
  class SystemPlugin : public PluginT<SystemPlugin>
  {
    public: SystemPlugin()
             {this->type = SYSTEM_PLUGIN;}
 
    public: virtual ~SystemPlugin() {}
 
    public: virtual void Load(int _argc = 0, char **_argv = nullptr) = 0;
 
    public: virtual void Init() {}
 
    public: virtual void Reset() {}
  };
 
  class VisualPlugin : public PluginT<VisualPlugin>
  {
    public: VisualPlugin()
             {this->type = VISUAL_PLUGIN;}
 
    public: virtual void Load(rendering::VisualPtr _visual,
                              sdf::ElementPtr _sdf) = 0;
 
    public: virtual void Init() {}
 
    public: virtual void Reset() {}
  };
 
 
 
#define GZ_REGISTER_MODEL_PLUGIN(classname) \
  extern "C" GZ_PLUGIN_VISIBLE gazebo::ModelPlugin *RegisterPlugin(); \
  gazebo::ModelPlugin *RegisterPlugin() \
  {\
    return new classname();\
  }
 
#define GZ_REGISTER_WORLD_PLUGIN(classname) \
  extern "C" GZ_PLUGIN_VISIBLE gazebo::WorldPlugin *RegisterPlugin(); \
  gazebo::WorldPlugin *RegisterPlugin() \
  {\
    return new classname();\
  }
 
#define GZ_REGISTER_SENSOR_PLUGIN(classname) \
  extern "C" GZ_PLUGIN_VISIBLE gazebo::SensorPlugin *RegisterPlugin(); \
  gazebo::SensorPlugin *RegisterPlugin() \
  {\
    return new classname();\
  }
 
#define GZ_REGISTER_SYSTEM_PLUGIN(classname) \
  extern "C" GZ_PLUGIN_VISIBLE gazebo::SystemPlugin *RegisterPlugin(); \
  gazebo::SystemPlugin *RegisterPlugin() \
  {\
    return new classname();\
  }
 
#define GZ_REGISTER_VISUAL_PLUGIN(classname) \
  extern "C" GZ_PLUGIN_VISIBLE gazebo::VisualPlugin *RegisterPlugin(); \
  gazebo::VisualPlugin *RegisterPlugin() \
  {\
    return new classname();\
  }
}
 
#endif