configGenerator Class Reference

Collaboration diagram for configGenerator:

Public Member Functions
	configGenerator (const string &pkgName, const string &outputDirName)
int	genConfig (const Strings_t &modules, const string &userModule)
	main entry point of this class:
void	setConfigurableTypes (const std::set< conf_t > &types)
	customize configurable types to generate
void	setConfigurableModule (const std::string &moduleName)
	customize the Module name where configurable base classes are defined
void	setConfigurableDefaultName (const std::string &defaultName)
	customize the default name for configurable instances
void	setConfigurableAlgorithm (const std::string &cfgAlgorithm)
	customize the configurable base class for Algorithm component
void	setConfigurableAlgTool (const std::string &cfgAlgTool)
	customize the configurable base class for AlgTool component
void	setConfigurableAuditor (const std::string &cfgAuditor)
	customize the configurable base class for AlgTool component
void	setConfigurableService (const std::string &cfgService)
	customize the configurable base class for Service component

Private Member Functions
bool	genComponent (const std::string &libName, const std::string &componentName, component_t componentType, const vector< PropertyBase * > &properties, const Gaudi::PluginService::Details::Registry::FactoryInfo &info)
bool	genComponent2 (const std::string &componentName, component_t componentType, const vector< PropertyBase * > &properties, const std::vector< std::string > &interfaces, const Gaudi::PluginService::Details::Registry::FactoryInfo &info)
void	genImport (std::ostream &s, std::string_view frmt, std::string indent)
void	genHeader (std::ostream &pyOut, std::ostream &dbOut)
void	genBody (std::ostream &pyOut, std::ostream &dbOut)
void	genTrailer (std::ostream &pyOut, std::ostream &dbOut)
void	pythonizeValue (const PropertyBase *prop, string &pvalue, string &ptype)
	handle the "marshalling" of Properties

Private Attributes
string	m_pkgName
	name of the package we are processing
string	m_outputDirName
	absolute path to the directory where genconf will store auto-generated files (Configurables and ConfigurableDb)
stringstream	m_pyBuf
	buffer of auto-generated configurables
bool	m_importGaudiHandles = false
	switch to decide if the generated configurables need to import GaudiHandles (ie: if one of the components has a XyzHandle<T>)
bool	m_importDataHandles = false
std::set< conf_t >	m_confTypes
	Types of configurables to generate.
stringstream	m_dbBuf
	buffer of generated configurables informations for the "Db" file The "Db" file is holding informations about the generated configurables This file is later one used by the PropertyProxy.py to locate Configurables and know their default values, host module,...
stringstream	m_db2Buf
	buffer of generated GaudiConfig2 configurables
std::map< component_t, std::string >	m_configurable
	Configurable customization.

Detailed Description

Definition at line 159 of file genconf.cpp.

Constructor & Destructor Documentation

configGenerator()

configGenerator::configGenerator ( const string & pkgName, const string & outputDirName )

inline

Definition at line 195 of file genconf.cpp.

      : m_pkgName( pkgName ), m_outputDirName( outputDirName ) {}

Member Function Documentation

genBody()

void configGenerator::genBody ( std::ostream & pyOut, std::ostream & dbOut )

inlineprivate

Definition at line 243 of file genconf.cpp.

                                                       {
    pyOut << m_pyBuf.str() << flush;
    dbOut << m_dbBuf.str() << flush;
  }

genComponent()

bool configGenerator::genComponent ( const std::string & libName, const std::string & componentName, component_t componentType, const vector< PropertyBase * > & properties, const Gaudi::PluginService::Details::Registry::FactoryInfo & info )

private

Definition at line 689 of file genconf.cpp.

{
  auto       cname    = pythonizeName( componentName );
  const auto decl_loc = info.getprop( "declaration_location" );
 
  std::vector<std::pair<std::string, std::string>> propDoc;
  propDoc.reserve( properties.size() );
 
  m_pyBuf << "\nclass " << cname << "( " << m_configurable[componentType] << " ) :\n";
  m_pyBuf << "  __slots__ = { \n";
  for ( const auto& prop : properties ) {
    const string& pname = prop->name();
    // Validate property name (it must be a valid Python identifier)
    if ( !boost::regex_match( pname, pythonIdentifier ) ) {
      LOG_ERROR << "invalid property name \"" << pname << "\" in component " << cname << " (invalid Python identifier)"
                << std::endl;
      // try to make the buffer at least more or less valid python code.
      m_pyBuf << " #ERROR-invalid identifier '" << pname << "'\n"
              << "  }\n";
      return false;
    }
 
    string pvalue, ptype;
    pythonizeValue( prop, pvalue, ptype );
    m_pyBuf << "    '" << pname << "' : " << pvalue << ",\n";
 
    if ( prop->documentation() != "none" ) {
      propDoc.emplace_back( pname, prop->documentation() + " [" + prop->ownerTypeName() + "]" );
    }
  }
  m_pyBuf << "  }\n";
  m_pyBuf << "  _propertyDocDct = { \n";
  for ( const auto& prop : propDoc ) {
    m_pyBuf << std::setw( 5 ) << "'" << prop.first << "' : "
            << "\"\"\" " << prop.second << " \"\"\",\n";
  }
  m_pyBuf << "  }\n";
 
  if ( !decl_loc.empty() ) { m_pyBuf << "  __declaration_location__ = '" << decl_loc << "'\n"; }
  m_pyBuf << "  def __init__(self, name = " << m_configurable[component_t::DefaultName] << ", **kwargs):\n"
          << "      super(" << cname << ", self).__init__(name)\n"
          << "      for n,v in kwargs.items():\n"
          << "         setattr(self, n, v)\n"
          << "  def getDlls( self ):\n"
          << "      return '" << libName << "'\n"
          << "  def getType( self ):\n"
          << "      return '" << componentName << "'\n"
          << "  pass # class " << cname << "\n"
          << flush;
 
  // name of the auto-generated module
  const string pyName  = ( fs::path( m_outputDirName ) / fs::path( libName + "Conf.py" ) ).string();
  const string modName = fs::path( pyName ).filename().stem().string();
 
  // now the db part
  m_dbBuf << m_pkgName << "." << modName << " " << libName << " " << cname << "\n" << flush;
 
  return true;
}

genComponent2()

bool configGenerator::genComponent2 ( const std::string & componentName, component_t componentType, const vector< PropertyBase * > & properties, const std::vector< std::string > & interfaces, const Gaudi::PluginService::Details::Registry::FactoryInfo & info )

private

Definition at line 753 of file genconf.cpp.

{
  m_db2Buf << "    '" << componentName << "': {\n";
  m_db2Buf << "        '__component_type__': '";
  switch ( componentType ) {
  case component_t::Algorithm:
    m_db2Buf << "Algorithm";
    break;
  case component_t::AlgTool:
    m_db2Buf << "AlgTool";
    break;
  case component_t::ApplicationMgr: // FALLTROUGH
  case component_t::Service:
    m_db2Buf << "Service";
    break;
  case component_t::Auditor:
    m_db2Buf << "Auditor";
    break;
  default:
    m_db2Buf << "Unknown";
  }
 
  const auto decl_loc = info.getprop( "declaration_location" );
  if ( !decl_loc.empty() ) { m_db2Buf << "',\n        '__declaration_location__': '" << decl_loc; }
 
  m_db2Buf << "',\n        '__interfaces__': (";
  for ( const auto& intf : std::set<std::string>{ begin( interfaces ), end( interfaces ) } ) {
    if ( ignored_interfaces.find( intf ) == end( ignored_interfaces ) ) { m_db2Buf << '\'' << intf << "', "; }
  }
  m_db2Buf << "),\n        'properties': {\n";
 
  bool success = true;
  for ( const auto& prop : properties ) {
    const string& pname = prop->name();
    // Validate property name (it must be a valid Python identifier)
    if ( !boost::regex_match( pname, pythonIdentifier ) ) {
      LOG_ERROR << "invalid property name \"" << pname << "\" in component " << componentName
                << " (invalid Python identifier)" << std::endl;
      m_db2Buf << " #ERROR-invalid identifier '" << pname << "'\n";
      success = false;
      break;
    }
 
    string pvalue, ptype;
    pythonizeValue( prop, pvalue, ptype );
 
    m_db2Buf << "            '" << pname << "': ('" << ptype << "', " << pvalue << ", '''" << prop->documentation()
             << " [" << prop->ownerTypeName() << "]'''";
    auto sem = prop->semantics();
    if ( !sem.empty() ) { m_db2Buf << ", '" << sem << '\''; }
    m_db2Buf << "),\n";
  }
 
  m_db2Buf << "        },\n    },\n";
 
  return success;
}

genConfig()

int configGenerator::genConfig	(	const Strings_t &	modules,
		const string &	userModule )

main entry point of this class:

• iterate over all the modules (ie: library names)
• for each module extract component informations
• eventually generate the header/body/trailer python file and "Db" file

write-out files for this library

Definition at line 450 of file genconf.cpp.

{
  const auto endLib = libs.end();
 
  static const std::string gaudiSvc = "GaudiCoreSvc";
  const bool               isGaudiSvc =
      std::find_if( libs.begin(), endLib, []( const auto& s ) {
        return s.find( gaudiSvc ) != std::string::npos; // libs can be <name> or path/to/lib<name>.so
      } ) != endLib;
 
  //--- Instantiate ApplicationMgr --------------------------------------------
  if ( !isGaudiSvc && createAppMgr() ) {
    cout << "ERROR: ApplicationMgr can not be created. Check environment" << endl;
    return EXIT_FAILURE;
  }
 
  //--- Iterate over component factories --------------------------------------
  using Gaudi::PluginService::Details::Registry;
  const Registry& registry = Registry::instance();
 
  auto bkgNames = registry.loadedFactoryNames();
 
  ISvcLocator* svcLoc   = Gaudi::svcLocator();
  IInterface*  dummySvc = new Service( "DummySvc", svcLoc );
  dummySvc->addRef();
 
  bool allGood = true;
 
  // iterate over all the requested libraries
  for ( const auto& iLib : libs ) {
    std::string lib = fs::path( iLib ).stem().string();
    if ( lib.compare( 0, 3, "lib" ) == 0 ) {
      lib = lib.substr( 3 ); // For *NIX remove "lib"
    }
    LOG_INFO << ":::: processing library: " << iLib << "...";
 
    // reset state
    m_importGaudiHandles = false;
    m_importDataHandles  = false;
    m_pyBuf.str( "" );
    m_dbBuf.str( "" );
    m_db2Buf.str( "" );
 
    //--- Load component library ----------------------------------------------
    System::ImageHandle handle;
    unsigned long       err = System::loadDynamicLib( iLib, &handle );
    if ( err != 1 ) {
      LOG_ERROR << System::getLastErrorString();
      allGood = false;
      continue;
    }
 
    const auto& factories = registry.factories();
    for ( const auto& factoryName : registry.loadedFactoryNames() ) {
      if ( bkgNames.find( factoryName ) != bkgNames.end() ) {
        if ( Gaudi::PluginService::Details::logger().level() <= 1 ) {
          LOG_INFO << "\t==> skipping [" << factoryName << "]...";
        }
        continue;
      }
      auto entry = factories.find( factoryName );
      if ( entry == end( factories ) ) {
        LOG_ERROR << "inconsistency in component factories list: I cannot find anymore " << factoryName;
        continue;
      }
      const auto& info = entry->second;
      if ( !info.is_set() ) continue;
 
      // do not generate configurables for the Reflex-compatible aliases
      if ( !info.getprop( "ReflexName" ).empty() ) continue;
 
      // Atlas contributed code (patch #1247)
      // Skip the generation of configurables if the component does not come
      // from the same library we are processing (i.e. we found a symbol that
      // is coming from a library loaded by the linker).
      if ( libNativeName( lib ) != info.library ) {
        LOG_WARNING << "library [" << lib << "] exposes factory [" << factoryName << "] which is declared in ["
                    << info.library << "] !!";
        continue;
      }
 
      component_t type = component_t::Unknown;
      {
        const auto ft = allowedFactories.find( info.factory.type().name() );
        if ( ft != allowedFactories.end() ) {
          type = ft->second;
        } else if ( factoryName == "ApplicationMgr" ) {
          type = component_t::ApplicationMgr;
        } else
          continue;
      }
 
      // handle possible problems with templated components
      std::string name = boost::trim_copy( factoryName );
 
      const auto className = info.getprop( "ClassName" );
      LOG_INFO << " - component: " << className << " (" << ( className != name ? ( name + ": " ) : std::string() )
               << type << ")";
 
      string             cname = "DefaultName";
      SmartIF<IProperty> prop;
      try {
        switch ( type ) {
        case component_t::Algorithm:
          prop = SmartIF<IAlgorithm>( Gaudi::Algorithm::Factory::create( factoryName, cname, svcLoc ).release() );
          break;
        case component_t::Service:
          prop = SmartIF<IService>( Service::Factory::create( factoryName, cname, svcLoc ).release() );
          break;
        case component_t::AlgTool:
          prop =
              SmartIF<IAlgTool>( AlgTool::Factory::create( factoryName, cname, toString( type ), dummySvc ).release() );
          // FIXME: AlgTool base class increase artificially by 1 the refcount.
          prop->release();
          break;
        case component_t::Auditor:
          prop = SmartIF<Gaudi::IAuditor>( Gaudi::Auditor::Factory::create( factoryName, cname, svcLoc ).release() );
          break;
        case component_t::ApplicationMgr:
          prop = SmartIF<ISvcLocator>( svcLoc );
          break;
        default:
          continue; // unknown
        }
      } catch ( exception& e ) {
        LOG_ERROR << "Error instantiating " << name << " from " << iLib;
        LOG_ERROR << "Got exception: " << e.what();
        allGood = false;
        continue;
      } catch ( ... ) {
        LOG_ERROR << "Error instantiating " << name << " from " << iLib;
        allGood = false;
        continue;
      }
      if ( prop ) {
        if ( m_confTypes.contains( conf_t::CONF ) && !genComponent( lib, name, type, prop->getProperties(), info ) ) {
          allGood = false;
        }
        if ( m_confTypes.contains( conf_t::CONF2 ) &&
             !genComponent2( name, type, prop->getProperties(), prop->getInterfaceNames(), info ) ) {
          allGood = false;
        }
        prop.reset();
      } else {
        LOG_ERROR << "could not cast IInterface* object to an IProperty* !";
        LOG_ERROR << "NO Configurable will be generated for [" << name << "] !";
        allGood = false;
      }
    } //> end loop over factories

    if ( m_confTypes.contains( conf_t::CONF ) ) {
      const std::string pyName = ( fs::path( m_outputDirName ) / fs::path( lib + "Conf.py" ) ).string();
      const std::string dbName = ( fs::path( m_outputDirName ) / fs::path( lib + ".confdb" ) ).string();
 
      std::fstream py( pyName, std::ios_base::out | std::ios_base::trunc );
      std::fstream db( dbName, std::ios_base::out | std::ios_base::trunc );
 
      genHeader( py, db );
      if ( !userModule.empty() ) py << "from " << userModule << " import *" << endl;
      genBody( py, db );
      genTrailer( py, db );
    }
    if ( m_confTypes.contains( conf_t::CONF2 ) ) {
      const std::string db2Name = ( fs::path( m_outputDirName ) / fs::path( lib + ".confdb2_part" ) ).string();
      std::fstream      db2( db2Name, std::ios_base::out | std::ios_base::trunc );
      db2 << "{\n" << m_db2Buf.str() << "}\n";
    }
 
  } //> end loop over libraries
 
  dummySvc->release();
  dummySvc = 0;
 
  return allGood ? EXIT_SUCCESS : EXIT_FAILURE;
}

genHeader()

void configGenerator::genHeader ( std::ostream & pyOut, std::ostream & dbOut )

private

Definition at line 661 of file genconf.cpp.

{
  // python file part
  std::string now = Gaudi::Time::current().format( true );
  py << "#" << now //<< "\n"
     << "\"\"\"Automatically generated. DO NOT EDIT please\"\"\"\n";
 
  if ( m_importGaudiHandles ) { py << "from GaudiKernel.GaudiHandles import *\n"; }
 
  if ( m_importDataHandles ) { py << "from GaudiKernel.DataHandle import DataHandle\n"; }
 
  genImport( py, "from {}.Configurable import *" );
 
  // db file part
  db << "##  -*- ascii -*-  \n"
     << "# db file automatically generated by genconf on: " << now << "\n"
     << flush;
}

genImport()

void configGenerator::genImport ( std::ostream & s, std::string_view frmt, std::string indent = "" )

private

Definition at line 630 of file genconf.cpp.

                                                                                           {
 
  std::string::size_type pos = 0, nxtpos = 0;
  std::string            mod;
 
  while ( std::string::npos != pos ) {
    // find end of module name
    nxtpos = m_configurable[component_t::Module].find_first_of( ',', pos );
 
    // Prepare import string
    mod = m_configurable[component_t::Module].substr( pos, nxtpos - pos );
    std::ostringstream import;
    import << fmt::format( fmt::runtime( frmt ), mod );
 
    // append a normal import or a try/except enclosed one depending
    // on availability of a fall-back module (next in the list)
    if ( std::string::npos == nxtpos ) {
      // last possible module
      s << indent << import.str() << "\n" << flush;
      pos = std::string::npos;
    } else {
      // we have a fallback for this
      s << indent << "try:\n" << indent << py_tab << import.str() << "\n" << indent << "except ImportError:\n" << flush;
      pos = nxtpos + 1;
    }
    // increase indentation level for next iteration
    indent += py_tab;
  }
}

genTrailer()

void configGenerator::genTrailer ( std::ostream & pyOut, std::ostream & dbOut )

private

Definition at line 681 of file genconf.cpp.

{
  // db file part
  db << "## " << m_pkgName << "\n" << std::flush;
}

pythonizeValue()

void configGenerator::pythonizeValue ( const PropertyBase * prop, string & pvalue, string & ptype )

private

handle the "marshalling" of Properties

Definition at line 815 of file genconf.cpp.

{
  const std::string     cvalue = p->toString();
  const std::type_index ti     = std::type_index( *p->type_info() );
  ptype                        = System::typeinfoName( *p->type_info() );
 
  if ( ti == typeIndex<bool>() ) {
    pvalue = ( cvalue == "0" || cvalue == "False" || cvalue == "false" ) ? "False" : "True";
  } else if ( ti == typeIndex<char>() || ti == typeIndex<signed char>() || ti == typeIndex<unsigned char>() ||
              ti == typeIndex<short>() || ti == typeIndex<unsigned short>() || ti == typeIndex<int>() ||
              ti == typeIndex<unsigned int>() || ti == typeIndex<long>() || ti == typeIndex<unsigned long>() ||
              ti == typeIndex<long long>() || ti == typeIndex<unsigned long long>() ) {
    pvalue = cvalue;
  } else if ( ti == typeIndex<float>() || ti == typeIndex<double>() ) {
    // forces python to handle this as a float: put a dot in there...
    pvalue = boost::to_lower_copy( cvalue );
    if ( std::string::npos != pvalue.find( "nan" ) ) {
      pvalue = "float('nan')";
    } else if ( std::string::npos == pvalue.find( "." ) && std::string::npos == pvalue.find( "e" ) ) {
      pvalue = cvalue + ".0";
    }
  } else if ( ti == typeIndex<string>() ) {
    pvalue = quote( cvalue );
  } else if ( ti == typeIndex<GaudiHandleBase>() ) {
    const GaudiHandleProperty& hdl  = dynamic_cast<const GaudiHandleProperty&>( *p );
    const GaudiHandleBase&     base = hdl.value();
 
    pvalue               = base.pythonRepr();
    ptype                = base.pythonPropertyClassName();
    m_importGaudiHandles = true;
  } else if ( ti == typeIndex<GaudiHandleArrayBase>() ) {
    const GaudiHandleArrayProperty& hdl  = dynamic_cast<const GaudiHandleArrayProperty&>( *p );
    const GaudiHandleArrayBase&     base = hdl.value();
 
    pvalue               = base.pythonRepr();
    ptype                = base.pythonPropertyClassName();
    m_importGaudiHandles = true;
  } else if ( auto hdl = dynamic_cast<const DataHandleProperty*>( p ); hdl ) {
    // dynamic_cast to support also classes derived from DataHandleProperty
    const Gaudi::DataHandle& base = hdl->value();
 
    pvalue              = base.pythonRepr();
    m_importDataHandles = true;
  } else {
    std::ostringstream v_str;
    v_str.setf( std::ios::showpoint ); // to correctly display floats
    p->toStream( v_str );
    pvalue = v_str.str();
  }
}

setConfigurableAlgorithm()

void configGenerator::setConfigurableAlgorithm ( const std::string & cfgAlgorithm )

inline

customize the configurable base class for Algorithm component

Definition at line 216 of file genconf.cpp.

                                                                 {
    m_configurable[component_t::Algorithm] = cfgAlgorithm;
  }

setConfigurableAlgTool()

void configGenerator::setConfigurableAlgTool ( const std::string & cfgAlgTool )

inline

customize the configurable base class for AlgTool component

Definition at line 221 of file genconf.cpp.

{ m_configurable[component_t::AlgTool] = cfgAlgTool; }

setConfigurableAuditor()

void configGenerator::setConfigurableAuditor ( const std::string & cfgAuditor )

inline

customize the configurable base class for AlgTool component

Definition at line 224 of file genconf.cpp.

{ m_configurable[component_t::Auditor] = cfgAuditor; }

setConfigurableDefaultName()

void configGenerator::setConfigurableDefaultName ( const std::string & defaultName )

inline

customize the default name for configurable instances

Definition at line 211 of file genconf.cpp.

                                                                  {
    m_configurable[component_t::DefaultName] = defaultName;
  }

setConfigurableModule()

void configGenerator::setConfigurableModule ( const std::string & moduleName )

inline

customize the Module name where configurable base classes are defined

Definition at line 208 of file genconf.cpp.

{ m_configurable[component_t::Module] = moduleName; }

setConfigurableService()

void configGenerator::setConfigurableService ( const std::string & cfgService )

inline

customize the configurable base class for Service component

Definition at line 227 of file genconf.cpp.

                                                             {
    m_configurable[component_t::Service]        = cfgService;
    m_configurable[component_t::ApplicationMgr] = cfgService;
  }

setConfigurableTypes()

void configGenerator::setConfigurableTypes ( const std::set< conf_t > & types )

inline

customize configurable types to generate

Definition at line 205 of file genconf.cpp.

{ m_confTypes = types; }

Member Data Documentation

m_configurable

std::map<component_t, std::string> configGenerator::m_configurable

private

Configurable customization.

Contains customization for:

• Name of the module where configurable base classes are defined
• Name of the configurable base class for the Algorithm component
• Name of the configurable base class for the AlgTool component
• Name of the configurable base class for the Service component

Definition at line 192 of file genconf.cpp.

m_confTypes

std::set<conf_t> configGenerator::m_confTypes

private

Types of configurables to generate.

Definition at line 176 of file genconf.cpp.

m_db2Buf

stringstream configGenerator::m_db2Buf

private

buffer of generated GaudiConfig2 configurables

Definition at line 185 of file genconf.cpp.

m_dbBuf

stringstream configGenerator::m_dbBuf

private

buffer of generated configurables informations for the "Db" file The "Db" file is holding informations about the generated configurables This file is later one used by the PropertyProxy.py to locate Configurables and know their default values, host module,...

Definition at line 182 of file genconf.cpp.

m_importDataHandles

bool configGenerator::m_importDataHandles = false

private

Definition at line 173 of file genconf.cpp.

m_importGaudiHandles

bool configGenerator::m_importGaudiHandles = false

private

switch to decide if the generated configurables need to import GaudiHandles (ie: if one of the components has a XyzHandle<T>)

Definition at line 172 of file genconf.cpp.

m_outputDirName

string configGenerator::m_outputDirName

private

absolute path to the directory where genconf will store auto-generated files (Configurables and ConfigurableDb)

Definition at line 165 of file genconf.cpp.

m_pkgName

string configGenerator::m_pkgName

private

name of the package we are processing

Definition at line 161 of file genconf.cpp.

m_pyBuf

stringstream configGenerator::m_pyBuf

private

buffer of auto-generated configurables

Definition at line 168 of file genconf.cpp.

---

The documentation for this class was generated from the following file:

• GaudiKernel/src/Util/genconf.cpp