package_registry.cpp

Go to the documentation of this file.

// Provides cached ros::package::getPath() lookups
// Author: Max Schwarz <max.schwarz@uni-bonn.de>

#include "package_registry.h"

#include <ros/package.h>
#include <ros/time.h>

#include <rospack/rospack.h>

#include <boost/filesystem.hpp>
#include <boost/tokenizer.hpp>

#include <sys/types.h>
#include <sys/wait.h>

namespace rosmon
{

static std::map<std::string, std::string> g_cache;
static rospack::Rospack g_pack;
static std::vector<std::string> g_catkin_workspaces;
static std::map<std::pair<std::string, std::string>, std::string> g_executableCache;
static bool g_initialized = false;

namespace fs = boost::filesystem;

static void init()
{
        if(g_initialized)
                return;

        std::vector<std::string> sp;
        g_pack.getSearchPathFromEnv(sp);
        g_pack.crawl(sp, false);

        // Determine stack of catkin workspaces
        char* env_cmake = getenv("CMAKE_PREFIX_PATH");
        if(env_cmake)
        {
                std::string cmakePath = env_cmake;
                boost::char_separator<char> sep(":");
                boost::tokenizer<boost::char_separator<char>> tok(cmakePath, sep);

                for(auto token : tok)
                {
                        fs::path path(token);
                        if(!fs::exists(path / ".catkin"))
                                continue;

//                      printf("Found catkin workspace: '%s'\n", path.string().c_str());
                        g_catkin_workspaces.push_back(path.string());
                }
        }
}

std::string PackageRegistry::getPath(const std::string& package)
{
        if(!g_initialized)
                init();

        auto it = g_cache.find(package);
        if(it == g_cache.end())
        {
                std::string path;
                if(!g_pack.find(package, path))
                        path.clear();

                g_cache[package] = path;
                return path;
        }

        return it->second;
}

static std::string getExecutableInPath(const fs::path& path, const std::string& name)
{
        if(!fs::exists(path))
                return std::string();

        for(fs::recursive_directory_iterator it(path); it != fs::recursive_directory_iterator(); ++it)
        {
                if(it->path().filename() == name
                        && fs::is_regular_file(it->path())
                        && access(it->path().c_str(), X_OK) == 0)
                {
                        return it->path().string();
                }
        }

        return std::string();
}

static std::string _getExecutable(const std::string& package, const std::string& name)
{
        if(!g_initialized)
                init();

        // Try catkin libexec & catkin share first
        for(const auto& workspace : g_catkin_workspaces)
        {
                fs::path workspacePath(workspace);

                fs::path execPath = workspacePath / "lib" / package / name;
                if(fs::exists(execPath) && access(execPath.c_str(), X_OK) == 0)
                        return execPath.string();

                std::string sharePath = getExecutableInPath(workspacePath / "share" / package, name);
                if(!sharePath.empty())
                        return sharePath;
        }

        // Crawl package directory for an appropriate executable
        std::string packageDir = PackageRegistry::getPath(package);
        if(!packageDir.empty())
                return getExecutableInPath(packageDir, name);

        // Nothing found :-(
        return std::string();
}

std::string PackageRegistry::getExecutable(const std::string& package, const std::string& name)
{
        std::pair<std::string, std::string> key(package, name);

        auto it = g_executableCache.find(key);
        if(it != g_executableCache.end())
                return it->second;

        std::string result = _getExecutable(package, name);
        g_executableCache[key] = result;

        return result;
}

std::string PackageRegistry::findPathToFile(const std::string& package, const std::string& name)
{
        if(!g_initialized)
                init();

        // Try catkin libexec & catkin share first
        for(const auto& workspace : g_catkin_workspaces)
        {
                fs::path workspacePath(workspace);

                fs::path execPath = workspacePath / "lib" / package;
                fs::path filePath = execPath / name;
                if(fs::exists(filePath) && access(filePath.c_str(), X_OK) == 0)
                        return execPath.string();

                fs::path sharePath = workspacePath / "share" / package;
                filePath = sharePath / name;
                if(fs::exists(filePath) && access(filePath.c_str(), X_OK) == 0)
                        return sharePath.string();
        }

        // Try package directory (src)
        fs::path packageDir = PackageRegistry::getPath(package);
        fs::path filePath = packageDir / name;
        if(fs::exists(filePath) && access(filePath.c_str(), X_OK) == 0)
                return packageDir.string();

        // Nothing found :-(
        return std::string();
}

}