plugin.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2009, Willow Garage, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Willow Garage, Inc. nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "rve_pluginloader/plugin.h"
#include "rve_pluginloader/type_registry.h"

#include <iostream>
#include <fstream>
#include <yaml-cpp/yaml.h>

#include <ros/assert.h>
#include <ros/package.h>
#include <ros/debug.h>

#include <boost/filesystem.hpp>

namespace fs = boost::filesystem;

namespace rve_pluginloader
{

Plugin::Plugin()
: loaded_(false)
, doc_(0)
{

}

Plugin::~Plugin()
{
  unload(false);

  delete doc_;
}

void Plugin::loadDescription(const std::string& description_path)
{
  description_path_ = description_path;

  std::ifstream fin(description_path.c_str());

  try
  {
    YAML::Parser parser(fin);
    doc_ = new YAML::Node;
    YAML::Node& doc = *doc_;
    parser.GetNextDocument(doc);

    std::string library;
    doc["library"] >> library;

    fs::path p(description_path);
    fs::path parent = p.parent_path();
    // figure out the package this plugin is part of
    while (true)
    {
      if (fs::exists(parent / "manifest.xml"))
      {
        std::string package = parent.filename();
        std::string package_path = ros::package::getPath(package);
        if (description_path.find(package_path) == 0)
        {
          package_name_ = package;
          package_path_ = package_path;
          break;
        }
      }

      parent = parent.parent_path();

      if (parent.string().empty())
      {
        ROS_ERROR("Could not find package name for plugin [%s]", description_path.c_str());
        break;
      }
    }

    std::string library_dir = (fs::path(package_path_) / (fs::path(library).parent_path())).string();
    std::string library_name = fs::path(library).filename();
    library_path_ = (fs::path(library_dir) / fs::path(rve_dynlib::prefix() + library_name + rve_dynlib::suffix())).string();

    doc["name"] >> name_;
  }
  catch (YAML::ParserException& e)
  {
    throw PluginParseException(description_path, e.msg);
  }
  catch (YAML::RepresentationException& e)
  {
    throw PluginParseException(description_path, e.msg);
  }
}

void Plugin::load()
{
  if (loaded_)
  {
    return;
  }

  loading_signal_(PluginStatus(this));

  if (!fs::exists(library_path_))
  {
    throw LibraryDoesNotExistException(library_path_);
  }

  try
  {
    library_ = rve_dynlib::load(library_path_);
  }
  catch (rve_dynlib::LibraryLoadException& e)
  {
    throw LibraryLoadException(library_path_, e.what());
  }

  if (!rve_dynlib::hasSymbol(library_, "rvePluginRegister"))
  {
    throw NoPluginRegisterFunctionException(library_path_);
  }

  typedef void (*RegisterFunc)(TypeRegistry*);
  RegisterFunc init = reinterpret_cast<RegisterFunc>(rve_dynlib::getSymbol(library_, "rvePluginRegister"));

  TypeRegistry reg(package_name_);
  (*init)(&reg);

  class_entries_ = reg.getClassEntries();

  loaded_ = true;
  loaded_signal_(PluginStatus(this));
}

const V_ClassEntry* Plugin::getClassEntries(const std::string& base_class) const
{
  M_ClassEntry::const_iterator it = class_entries_.find(base_class);
  if (it == class_entries_.end())
  {
    return 0;
  }

  return &it->second;
}

void Plugin::unload()
{
  unload(true);
}

void Plugin::unload(bool allow_throw)
{
  if (!loaded_)
  {
    return;
  }

  unloading_signal_(PluginStatus(this));

  // Check for outstanding allocations.  At this point no class created from this plugin should still exist.
  // Otherwise a crash is very likely when the library gets unloaded
  if (!allocations_.empty())
  {
    std::stringstream ss;
    ss << "Plugin loaded from [" << description_path_ << "] still has outstanding allocations:\n";

    M_AllocationInfo::iterator it = allocations_.begin();
    M_AllocationInfo::iterator end = allocations_.end();
    for (; it != end; ++it)
    {
      AllocationInfo& info = it->second;
      ss << "====================================================\n";
      ss << "Base Class: " << info.base_class << "\n";
      ss << "Derived Class: " << info.derived_class << "\n";
      ss << "Pointer Address: " << info.pointer << "\n";

      std::string backtrace  = ros::debug::backtraceToString(info.backtrace);
      ss << "Allocated from:\n";
      ss << backtrace;
    }

    if (allow_throw)
    {
      throw OutstandingAllocationException(ss.str());
    }
    else
    {
      ROS_ERROR_STREAM(ss.str());
    }
  }

  class_entries_.clear();

  rve_dynlib::unload(library_);
  loaded_ = false;

  unloaded_signal_(PluginStatus(this));
}

bool Plugin::isLoaded()
{
  return loaded_;
}

bool Plugin::hasClass(const std::string& base_class, const std::string& derived_class) const
{
  try
  {
    getClassEntry(base_class, derived_class);
  }
  catch (PluginDoesNotContainClassException&)
  {
    return false;
  }

  return true;
}

const ClassEntryPtr& Plugin::getClassEntry(const std::string& base_class, const std::string& derived_class) const
{
  M_ClassEntry::const_iterator it = class_entries_.find(base_class);
  if (it == class_entries_.end())
  {
    throw PluginDoesNotContainClassException(package_name_, derived_class);
  }

  V_ClassEntry::const_iterator lit = it->second.begin();
  V_ClassEntry::const_iterator lend = it->second.end();
  for (; lit != lend; ++lit)
  {
    const ClassEntryPtr& entry = *lit;
    if (entry->class_name == derived_class)
    {
      return entry;
    }
  }

  throw PluginDoesNotContainClassException(package_name_, derived_class);
}

void* Plugin::create(const std::string& base_class, const std::string& derived_class)
{
  const ClassEntryPtr& ent = getClassEntry(base_class, derived_class);
  void* mem = ent->creator->create();
  AllocationInfo info;
  info.base_class = base_class;
  info.derived_class = derived_class;
  info.pointer = mem;
  ros::debug::getBacktrace(info.backtrace);
  allocations_.insert(std::make_pair(mem, info));
  return mem;
}

struct ClassDeleter
{
  ClassDeleter(Plugin* plugin)
  : plugin_(plugin)
  {}

  void operator()(void* mem)
  {
    plugin_->destroy(mem);
  }

  Plugin* plugin_;
};

boost::shared_ptr<void> Plugin::createShared(const std::string& base_class, const std::string& derived_class)
{
  return boost::shared_ptr<void>(create(base_class, derived_class), ClassDeleter(this));
}

void Plugin::destroy(void* mem)
{
  M_AllocationInfo::iterator it = allocations_.find(mem);
  ROS_ASSERT(it != allocations_.end());
  allocations_.erase(it);
}

bool Plugin::ownsAllocation(void* mem)
{
  M_AllocationInfo::iterator it = allocations_.find(mem);
  return it != allocations_.end();
}

}