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_

#ifdef _WIN32
  // Ensure that Winsock2.h is included before Windows.h, which can get
  // pulled in by anybody (e.g., Boost).
  // This was put here because all the plugins are going to use it
  // This doesn't guarantee something else won't cause it,
  // but this saves putting this in every plugin
#include <Winsock2.h>
#endif

#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 "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;
              struct stat st;
              bool found = false;
              std::string fullname, filename(_filename);
              std::list<std::string>::iterator iter;
              std::list<std::string> pluginPaths =
                common::SystemPaths::Instance()->GetPluginPaths();

#ifdef __APPLE__
              // This is a hack to work around issue #800,
              // error loading plugin libraries with different extensions
              {
                size_t soSuffix = filename.rfind(".so");
                if (soSuffix != std::string::npos)
                {
                  const std::string macSuffix(".dylib");
                  filename.replace(soSuffix, macSuffix.length(), macSuffix);
                }
              }
#elif _WIN32
              // Corresponding windows hack
              {
                // 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);
                }
                // remove the lib prefix
                filename.erase(0, 3);
              }
#endif  // ifdef __APPLE__

              for (iter = pluginPaths.begin();
                   iter!= pluginPaths.end(); ++iter)
              {
                fullname = (*iter)+std::string("/")+filename;
                if (stat(fullname.c_str(), &st) == 0)
                {
                  found = true;
                  break;
                }
              }

              if (!found)
                fullname = filename;

              fptr_union_t registerFunc;
              std::string registerName = "RegisterPlugin";

              void *dlHandle = dlopen(fullname.c_str(), RTLD_LAZY|RTLD_GLOBAL);
              if (!dlHandle)
              {
                gzerr << "Failed to load plugin " << fullname << ": "
                  << dlerror() << "\n";
                return result;
              }

              registerFunc.ptr = dlsym(dlHandle, registerName.c_str());

              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