X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FConfig%2FConfig_ModuleReader.cpp;h=9e8549cdb43bd7d7aea303add9f452ed95bf922c;hb=bdbfb368d71ed11cc0391354a7d86c880cd94949;hp=1a6d1c7ce989770fc0433bb75f44c041b1faa1df;hpb=e607e2c793a83dc30d483e1819f44c3497a08555;p=modules%2Fshaper.git diff --git a/src/Config/Config_ModuleReader.cpp b/src/Config/Config_ModuleReader.cpp index 1a6d1c7ce..9e8549cdb 100644 --- a/src/Config/Config_ModuleReader.cpp +++ b/src/Config/Config_ModuleReader.cpp @@ -1,3 +1,5 @@ +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D + /* * Config_ModuleReader.cpp * @@ -5,38 +7,55 @@ * Author: sbh */ +#include + +#include +#include #include #include +#include + +#include +#include -#include -#include +// Have to be included before std headers +#include -#ifdef _DEBUG +//Necessary for cerr #include +#include + +#ifdef WIN32 +#include +#pragma warning(disable : 4996) // for getenv +#else +#include #endif -//Hardcoded xml entities -// * Nodes -const static char* NODE_PLUGIN = "plugin"; -const static char* NODE_PLUGINS = "plugins"; +std::map Config_ModuleReader::myPluginTypes; +std::set Config_ModuleReader::myDependencyModules; -// * Properties -const static char* PLUGINS_MODULE = "module"; -const static char* PLUGIN_CONFIG = "configuration"; -const static char* PLUGIN_LIBRARY = "library"; +Config_ModuleReader::Config_ModuleReader(const char* theEventGenerated) + : Config_XMLReader(PLUGIN_FILE), + myEventGenerated(theEventGenerated) +{ +} +Config_ModuleReader::~Config_ModuleReader() +{ +} -Config_ModuleReader::Config_ModuleReader() - : Config_XMLReader("plugins.xml"), - m_isAutoImport(false) +const std::map& Config_ModuleReader::featuresInFiles() const { + return myFeaturesInFiles; } -Config_ModuleReader::~Config_ModuleReader() +const std::set& Config_ModuleReader::modulePluginFiles() const { + return myPluginFiles; } -/* +/*! * Get module name from plugins.xml * (property "module") */ @@ -46,16 +65,38 @@ std::string Config_ModuleReader::getModuleName() return getProperty(aRoot, PLUGINS_MODULE); } -/* - * - */ + +void Config_ModuleReader::addFeature(const std::string& theFeatureName, + const std::string& thePluginConfig) +{ + if (myFeaturesInFiles.count(theFeatureName)) { + std::string anErrorMsg = "Can not register feature '%1' in plugin '%2'." + " There is a feature with the same ID."; + Events_InfoMessage("Config_ModuleReader", anErrorMsg) + .arg(theFeatureName).arg(thePluginConfig).send(); + return; + } + + myFeaturesInFiles[theFeatureName] = thePluginConfig; +} + void Config_ModuleReader::processNode(xmlNodePtr theNode) { - if(isNode(theNode, NODE_PLUGIN, NULL)) { - std::string aPluginName = getProperty(theNode, PLUGIN_CONFIG); - if(m_isAutoImport) - importPlugin(aPluginName); - m_pluginsList.push_back(aPluginName); + if (isNode(theNode, NODE_PLUGIN, NULL)) { + if (!hasRequiredModules(theNode)) + return; + std::string aPluginConf = getProperty(theNode, PLUGIN_CONFIG); + if (!aPluginConf.empty()) + myPluginFiles.insert(aPluginConf); + std::string aPluginLibrary = getProperty(theNode, PLUGIN_LIBRARY); + std::string aPluginScript = getProperty(theNode, PLUGIN_SCRIPT); + std::string aPluginName = addPlugin(aPluginLibrary, aPluginScript, aPluginConf); + + std::list aFeatures = importPlugin(aPluginName, aPluginConf); + std::list::iterator it = aFeatures.begin(); + for (; it != aFeatures.end(); it++) { + addFeature(*it, aPluginConf); + } } } @@ -64,18 +105,138 @@ bool Config_ModuleReader::processChildren(xmlNodePtr theNode) return isNode(theNode, NODE_PLUGINS, NULL); } -void Config_ModuleReader::importPlugin(const std::string& thePluginName) +bool Config_ModuleReader::hasRequiredModules(xmlNodePtr theNode) const +{ + std::string aRequiredModule = normalize(getProperty(theNode, PLUGIN_DEPENDENCY)); + if(aRequiredModule.empty()) + return true; + std::set::iterator it = myDependencyModules.begin(); + for ( ; it != myDependencyModules.end(); it++ ) { + if (*it == aRequiredModule) return true; + } + return false; +} + +std::list Config_ModuleReader::importPlugin(const std::string& thePluginLibrary, + const std::string& thePluginXmlConf) { - Config_FeatureReader aReader(thePluginName); + if (thePluginXmlConf.empty()) { //probably a third party library + loadLibrary(thePluginLibrary); + return std::list(); + } + + Config_FeatureReader aReader = Config_FeatureReader(thePluginXmlConf, + thePluginLibrary, + myEventGenerated); aReader.readAll(); + return aReader.features(); } -void Config_ModuleReader::setAutoImport(bool enabled) +std::string Config_ModuleReader::addPlugin(const std::string& aPluginLibrary, + const std::string& aPluginScript, + const std::string& aPluginConf) { - m_isAutoImport = enabled; + PluginType aType = Config_ModuleReader::Binary; + std::string aPluginName; + if (!aPluginLibrary.empty()) { + aPluginName = aPluginLibrary; + if (aPluginConf.empty()) { + aType = Config_ModuleReader::Intrenal; + } + } else if (!aPluginScript.empty()) { + aPluginName = aPluginScript; + aType = Config_ModuleReader::Python; + } + if(!aPluginName.empty()) { + myPluginTypes[aPluginName] = aType; + } + addDependencyModule(aPluginName); + return aPluginName; } -const std::list& Config_ModuleReader::pluginsList() const +void Config_ModuleReader::loadPlugin(const std::string& thePluginName) { - return m_pluginsList; + PluginType aType = Config_ModuleReader::Binary; + if(myPluginTypes.find(thePluginName) != myPluginTypes.end()) { + aType = myPluginTypes.at(thePluginName); + } + switch (aType) { + case Config_ModuleReader::Python: + loadScript(thePluginName); + break; + case Config_ModuleReader::Binary: + case Config_ModuleReader::Intrenal: + default: + loadLibrary(thePluginName); + break; + } } + +void Config_ModuleReader::loadScript(const std::string& theFileName, bool theSendErr) +{ + /* acquire python thread */ + PyGILState_STATE gstate = PyGILState_Ensure(); + + PyObject* module = PyImport_ImportModule(theFileName.c_str()); + if (!module) { + std::string anErrorMsg = "An error occurred while importing " + theFileName; + //Get detailed error message: + if (PyErr_Occurred()) { + PyObject *pstr, *ptype, *pvalue, *ptraceback; + PyErr_Fetch(&ptype, &pvalue, &ptraceback); + PyErr_NormalizeException(&ptype, &pvalue, &ptraceback); + pstr = PyObject_Str(pvalue); + std::string aPyError = std::string(PyString_AsString(pstr)); + if (!aPyError.empty()) { + anErrorMsg += ":\n" + aPyError; + } + Py_XDECREF(pstr); + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + } + if (theSendErr) + Events_InfoMessage("Config_ModuleReader", anErrorMsg).send(); + } + + /* release python thread */ + PyGILState_Release(gstate); +} + +void Config_ModuleReader::loadLibrary(const std::string& theLibName) +{ + std::string aFileName = library(theLibName); + if (aFileName.empty()) + return; + + #ifdef WIN32 + HINSTANCE aModLib = ::LoadLibrary(aFileName.c_str()); + #else + void* aModLib = dlopen( aFileName.c_str(), RTLD_LAZY | RTLD_GLOBAL ); + #endif + if(!aModLib && theLibName != "DFBrowser") { // don't show error for internal debugging tool + std::string anErrorMsg = "Failed to load " + aFileName; + #ifdef WIN32 + DWORD dwLastError = ::GetLastError(); + LPSTR messageBuffer = NULL; + size_t size = ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + dwLastError, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (LPSTR)&messageBuffer, 0, NULL); + anErrorMsg += ": " + std::string(messageBuffer, size); + #else + anErrorMsg += ": " + std::string(dlerror()); + #endif + std::cerr << anErrorMsg << std::endl; + Events_InfoMessage("Config_ModuleReader", anErrorMsg).send(); + } +} + +void Config_ModuleReader::addDependencyModule(const std::string& theModuleName) +{ + myDependencyModules.insert(normalize(theModuleName)); +} +