PluginServiceV2.cpp

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 2013-2026 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/

 
#define GAUDI_PLUGIN_SERVICE_V2
#include <Gaudi/PluginService.h>
 
#include <dirent.h>
#include <dlfcn.h>
 
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <memory>
#include <regex>
#include <string_view>
 
#include <cxxabi.h>
#include <sys/stat.h>
 
#ifdef _GNU_SOURCE
#  include <cstring>
#  include <dlfcn.h>
#endif
 
#ifdef USE_BOOST_FILESYSTEM
#  include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#else
#  include <filesystem>
namespace fs = std::filesystem;
#endif // USE_BOOST_FILESYSTEM
 
namespace {
  std::mutex registrySingletonMutex;
}
 
#include <algorithm>
#include <array>
 
namespace {
  struct OldStyleCnv {
    std::string name;
    void        operator()( const char c ) {
      switch ( c ) {
      case '<':
      case '>':
      case ',':
      case '(':
      case ')':
      case ':':
      case '.':
        name.push_back( '_' );
        break;
      case '&':
        name.push_back( 'r' );
        break;
      case '*':
        name.push_back( 'p' );
        break;
      case ' ':
        break;
      default:
        name.push_back( c );
        break;
      }
    }
  };
  std::string old_style_name( const std::string& name ) {
    return std::for_each( name.begin(), name.end(), OldStyleCnv() ).name;
  }
 
  // helper to locate the current DSO
  int _dso_marker() { return 0; }
} // namespace
 
namespace Gaudi {
  namespace PluginService {
    GAUDI_PLUGIN_SERVICE_V2_INLINE namespace v2 {
      namespace Details {
        std::string demangle( const std::string& id ) {
          int  status;
          auto realname = std::unique_ptr<char, decltype( free )*>(
              abi::__cxa_demangle( id.c_str(), nullptr, nullptr, &status ), free );
          if ( !realname ) return id;
          std::string result = realname.get();
          // Normalize libstdc++ (Linux) std::string representation
          result = std::regex_replace(
              result,
              std::regex{ "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >( (?=>))?" },
              "std::string" );
          // Normalize libc++ (macOS) inline namespace - remove std::__1:: prefix
          result = std::regex_replace( result, std::regex{ "std::__1::" }, "std::" );
          // Normalize libc++ basic_string (after removing __1::)
          result = std::regex_replace(
              result, std::regex{ "std::basic_string<char, std::char_traits<char>, std::allocator<char>>( (?=>))?" },
              "std::string" );
          // Normalize closing angle brackets: >> to > > (match libstdc++ C++03 style)
          result = std::regex_replace( result, std::regex{ ">>" }, "> >" );
          result = std::regex_replace( result, std::regex{ ">>" }, "> >" ); // twice for >>>
          return result;
        }
        std::string demangle( const std::type_info& id ) { return demangle( id.name() ); }
 
        Registry& Registry::instance() {
          auto            _guard = std::scoped_lock{ ::registrySingletonMutex };
          static Registry r;
          return r;
        }
 
        void reportBadAnyCast( const std::type_info& factory_type, const std::string& id ) {
          if ( logger().level() <= Logger::Debug ) {
            std::stringstream msg;
            const auto&       info = Registry::instance().getInfo( id );
            msg << "bad any_cast: requested factory " << id << " of type " << demangle( factory_type ) << ", got ";
            if ( info.is_set() )
              msg << demangle( info.factory.type() ) << " from " << info.library;
            else
              msg << "nothing";
            logger().debug( msg.str() );
          }
        }
 
        Registry::Properties::mapped_type Registry::FactoryInfo::getprop( const Properties::key_type& name ) const {
          auto p = properties.find( name );
          return ( p != end( properties ) ) ? p->second : Properties::mapped_type{};
        }
 
        Registry::Registry() {}
 
        void Registry::initialize() {
          auto _guard = std::scoped_lock{ m_mutex };
 
          std::regex  line_format{ "^(?:[[:space:]]*(?:(v[0-9]+)::)?([^:]+):(.*[^[:space:]]))?[[:space:]]*(?:#.*)?$" };
          std::smatch m;
          for ( const auto& dir : getPluginSearchPath() ) {
            // correctly handle begin of string or path separator
            logger().debug( " looking into " + dir );
            // look for files called "*.components" in the directory
            if ( !fs::is_directory( dir ) ) { continue; }
            for ( const auto& p : fs::directory_iterator( dir ) ) {
              if ( p.path().extension() != ".components" || !is_regular_file( p.path() ) ) { continue; }
              // read the file
              const auto& fullPath = p.path().string();
              logger().debug( "  reading " + p.path().filename().string() );
              std::ifstream factories{ fullPath };
              std::string   line;
              int           factoriesCount = 0;
              int           lineCount      = 0;
              while ( !factories.eof() ) {
                ++lineCount;
                std::getline( factories, line );
                if ( regex_match( line, m, line_format ) ) {
                  if ( m[1] != "v2" ) { continue; } // ignore non "v2" and "empty" lines
                  const std::string lib{ m[2] };
                  const std::string fact{ m[3] };
                  m_factories.emplace( fact, FactoryInfo{ lib, {}, { { "ClassName", fact } } } );
#ifdef GAUDI_REFLEX_COMPONENT_ALIASES
                  // add an alias for the factory using the Reflex convention
                  std::string old_name = old_style_name( fact );
                  if ( fact != old_name ) {
                    m_factories.emplace( old_name,
                                         FactoryInfo{ lib, {}, { { "ReflexName", "true" }, { "ClassName", fact } } } );
                  }
#endif
                  ++factoriesCount;
                } else {
                  logger().warning( "failed to parse line " + fullPath + ':' + std::to_string( lineCount ) );
                }
              }
              if ( logger().level() <= Logger::Debug ) {
                logger().debug( "  found " + std::to_string( factoriesCount ) + " factories" );
              }
            }
          }
        }
 
        const Registry::FactoryMap& Registry::factories() const {
          std::call_once( m_initialized, &Registry::initialize, const_cast<Registry*>( this ) );
          return m_factories;
        }
 
        Registry::FactoryMap& Registry::factories() {
          std::call_once( m_initialized, &Registry::initialize, this );
          return m_factories;
        }
 
        Registry::FactoryInfo& Registry::add( const KeyType& id, FactoryInfo info ) {
          auto        _guard = std::scoped_lock{ m_mutex };
          FactoryMap& facts  = factories();
 
#ifdef GAUDI_REFLEX_COMPONENT_ALIASES
          // add an alias for the factory using the Reflex convention
          const auto old_name = old_style_name( id );
          if ( id != old_name ) {
            auto new_info = info;
 
            new_info.properties["ReflexName"] = "true";
 
            add( old_name, new_info );
          }
#endif
 
          auto entry = facts.find( id );
          if ( entry == facts.end() ) {
            // this factory was not known yet
            entry = facts.emplace( id, std::move( info ) ).first;
          } else {
            // do not replace an existing factory with a new one
            if ( !entry->second.is_set() ) entry->second = std::move( info );
          }
          return entry->second;
        }
 
        Registry::FactoryMap::size_type Registry::erase( const KeyType& id ) {
          auto        _guard = std::scoped_lock{ m_mutex };
          FactoryMap& facts  = factories();
          return facts.erase( id );
        }
 
        const Registry::FactoryInfo& Registry::getInfo( const KeyType& id, const bool load ) const {
          auto                     _guard  = std::scoped_lock{ m_mutex };
          static const FactoryInfo unknown = { "unknown" };
          const FactoryMap&        facts   = factories();
          auto                     f       = facts.find( id );
 
          if ( f == facts.end() ) { return unknown; }
          if ( !load || f->second.is_set() ) { return f->second; }
 
          if ( !loadPluginLibrary( f->second.library ) ) { return unknown; }
 
          f = facts.find( id ); // ensure that the iterator is valid
          return f->second;
        }
 
        Registry& Registry::addProperty( const KeyType& id, const KeyType& k, const std::string& v ) {
          auto        _guard = std::scoped_lock{ m_mutex };
          FactoryMap& facts  = factories();
          auto        f      = facts.find( id );
 
          if ( f != facts.end() ) f->second.properties[k] = v;
          return *this;
        }
 
        void Registry::setError( const KeyType& warning ) { m_werror.insert( warning ); }
 
        void Registry::unsetError( const KeyType& warning ) { m_werror.erase( warning ); }
 
        std::set<Registry::KeyType> Registry::loadedFactoryNames() const {
          auto              _guard = std::scoped_lock{ m_mutex };
          std::set<KeyType> l;
          for ( const auto& f : factories() ) {
            if ( f.second.is_set() ) l.insert( f.first );
          }
          return l;
        }
 
        bool Registry::loadPluginLibrary( std::string_view library ) const {
          for ( const auto& dir : getPluginSearchPath() ) {
            if ( !fs::exists( dir ) ) { continue; }
            const auto path = dir / fs::path( library );
            if ( is_regular_file( path ) ) {
              if ( dlopen( path.c_str(), RTLD_LAZY | RTLD_GLOBAL ) ) {
                return true;
              } else {
                logger().warning( "cannot load " + path.string() );
                if ( char* dlmsg = dlerror() ) { logger().warning( dlmsg ); }
              }
            }
          }
          // not found yet, let's see if dlopen can find it via LD_LIBRARY_PATH
          if ( dlopen( std::string{ library }.c_str(), RTLD_LAZY | RTLD_GLOBAL ) ) { return true; }
          // still no luck
          logger().warning( "cannot load " + std::string{ library } );
          if ( char* dlmsg = dlerror() ) { logger().warning( dlmsg ); }
          return false;
        }
 
        void Logger::report( Level lvl, const std::string& msg ) {
          static const char* levels[] = { "DEBUG  : ", "INFO   : ", "WARNING: ", "ERROR  : " };
          if ( lvl >= level() ) { std::cerr << levels[lvl] << msg << std::endl; }
        }
 
        static auto s_logger = std::make_unique<Logger>();
        Logger&     logger() { return *s_logger; }
        void        setLogger( Logger* logger ) { s_logger.reset( logger ); }
 
        // This chunk of code was taken from GaudiKernel (genconf) DsoUtils.h
        std::string getDSONameFor( void* fptr ) {
#if defined _GNU_SOURCE || defined __APPLE__
          Dl_info info;
          if ( dladdr( fptr, &info ) == 0 ) return "";
 
          auto pos = std::strrchr( info.dli_fname, '/' );
          if ( pos )
            ++pos;
          else
            return info.dli_fname;
          return pos;
#else
          return "";
#endif
        }
 
        std::string implicitPluginDir() {
#ifdef PLUGIN_PATH_RELATIVE
#  define stringify( x ) stringify_( x )
#  define stringify_( x ) #x
          std::string relative_path = stringify( PLUGIN_PATH_RELATIVE );
#else
          std::string relative_path = ".";
#endif
          Dl_info info;
          if ( dladdr( (void*)_dso_marker, &info ) != 0 ) {
            auto plugin_path = fs::path( info.dli_fname ).parent_path() / relative_path;
            return plugin_path.string();
          } else {
            return relative_path;
          }
        }
 
        const std::vector<std::string>& getPluginSearchPath() {
          // we search for plugin libraries in the following order:
          // 1. GAUDI_PLUGIN_PATH environment variable
          // 2. LD_LIBRARY_PATH environment variable (backward compatibility)
          // 3. implicit plugin path (relative to the library)
 
          constexpr char const* envVars[] =
#if defined( __APPLE__ )
              { "GAUDI_PLUGIN_PATH", "DYLD_LIBRARY_PATH" };
#else
              { "GAUDI_PLUGIN_PATH", "LD_LIBRARY_PATH" };
#endif
 
          // We cache the result to avoid recomputing it on every call
          static std::vector<std::string> search_path;
          static std::once_flag           initialized;
          std::call_once( initialized, [&]() {
            for ( const auto& envVar : envVars ) {
              if ( auto ptr = std::getenv( envVar ) ) {
                std::string_view path{ ptr };
                while ( !path.empty() ) {
                  auto        sep     = path.find( ':' );
                  std::string dirname = std::string{ path.substr( 0, sep ) };
                  // ignore duplicates
                  if ( find( search_path.begin(), search_path.end(), dirname ) == search_path.end() ) {
                    search_path.emplace_back( std::move( dirname ) );
                  }
                  // handle correctly missing separator
                  if ( sep != std::string_view::npos ) {
                    path = path.substr( sep + 1 );
                  } else {
                    path = {};
                  }
                }
              }
            }
            search_path.push_back( implicitPluginDir() );
          } );
          return search_path;
        }
      } // namespace Details
 
      void SetDebug( int debugLevel ) {
        using namespace Details;
        Logger& l = logger();
        if ( debugLevel > 1 )
          l.setLevel( Logger::Debug );
        else if ( debugLevel > 0 )
          l.setLevel( Logger::Info );
        else
          l.setLevel( Logger::Warning );
      }
 
      int Debug() {
        using namespace Details;
        switch ( logger().level() ) {
        case Logger::Debug:
          return 2;
        case Logger::Info:
          return 1;
        default:
          return 0;
        }
      }
    }
  } // namespace PluginService
} // namespace Gaudi