From: rahuel Date: Thu, 26 Feb 2004 16:12:32 +0000 (+0000) Subject: New server : ResourcesManager (Computers) X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=2de6d8fa0c7cfe5c9e491335e0200d2cdc3ff8f9;p=modules%2Fkernel.git New server : ResourcesManager (Computers) --- diff --git a/src/ResourcesManager/Makefile.in b/src/ResourcesManager/Makefile.in new file mode 100755 index 000000000..b9b63f905 --- /dev/null +++ b/src/ResourcesManager/Makefile.in @@ -0,0 +1,54 @@ +# SALOME ResourcesManager +# +# Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +# +# +# +# File : Makefile.in +# Author : Jean Rahuel +# Module : SALOME +# $Header: + +top_srcdir=@top_srcdir@ +top_builddir=../.. +srcdir=@srcdir@ +VPATH=.:@srcdir@:@top_srcdir@/idl + + +@COMMENCE@ + +# Libraries targets +LIB = libResourcesManager.la +LIB_SRC = ResourcesManager_Handler.cxx \ + ResourcesComputer_Impl.cxx \ + ResourcesManager_Impl.cxx + +# Executables targets +BIN = ResourcesManager_Server +BIN_SRC = +BIN_SERVER_IDL = ContainersManager.idl SALOME_Component.idl ResourcesManager.idl + +CPPFLAGS+= $(QT_MT_INCLUDES) +CXXFLAGS+= +LDFLAGS+= $(QT_MT_LIBS) $(OGL_LIBS) -lSalomeNS -lOpUtil -lSALOMELocalTrace + +@CONCLUDE@ + + diff --git a/src/ResourcesManager/ResourcesComputer_Impl.cxx b/src/ResourcesManager/ResourcesComputer_Impl.cxx new file mode 100755 index 000000000..5cde09439 --- /dev/null +++ b/src/ResourcesManager/ResourcesComputer_Impl.cxx @@ -0,0 +1,145 @@ +// ResourcesComputer_Impl +// +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : ResourcesComputer_Impl.cxx +// Author : Jean Rahuel +// Module : SALOME + +using namespace std; +#include "ResourcesComputer_Impl.hxx" +#include + +Computer_Impl::Computer_Impl() { +} + +Computer_Impl::Computer_Impl( CORBA::ORB_ptr orb , + PortableServer::POA_ptr poa , + Resources::ComputerParameters * aComputerParameters , + Resources::ComputerEnvironment * aComputerEnvironment ) { + _Orb = CORBA::ORB::_duplicate( orb ) ; + _Poa = PortableServer::POA::_duplicate( poa ) ; + _Id = _Poa->activate_object( this ) ; + _ComputerParameters = new Resources::ComputerParameters() ; + _ComputerParameters->FullName = CORBA::string_dup( aComputerParameters->FullName ) ; + _ComputerParameters->Alias = CORBA::string_dup( aComputerParameters->Alias ) ; + _ComputerParameters->SshAccess = aComputerParameters->SshAccess ; + _ComputerParameters->Interactive = aComputerParameters->Interactive ; + _ComputerParameters->Batch = aComputerParameters->Batch ; + _ComputerParameters->UserName = CORBA::string_dup( aComputerParameters->UserName ) ; + _ComputerParameters->Os = aComputerParameters->Os ; + _ComputerParameters->Memory = aComputerParameters->Memory ; + _ComputerParameters->Swap = aComputerParameters->Swap ; + _ComputerParameters->CpuClock = aComputerParameters->CpuClock ; + _ComputerParameters->NbProc = aComputerParameters->NbProc ; + _ComputerParameters->NbNode = aComputerParameters->NbNode ; + _ComputerEnvironment = new Resources::ComputerEnvironment() ; + _ComputerEnvironment->Path = CORBA::string_dup( aComputerEnvironment->Path ) ; + _ComputerEnvironment->Ld_Library_Path = CORBA::string_dup( aComputerEnvironment->Ld_Library_Path ) ; + _ComputerEnvironment->PythonPath = CORBA::string_dup( aComputerEnvironment->PythonPath ) ; + _ComputerEnvironment->CasRoot = CORBA::string_dup( aComputerEnvironment->CasRoot ) ; + int size = aComputerEnvironment->Module_Root_Dir_Names.length() ; + _ComputerEnvironment->Module_Root_Dir_Names.length( size ) ; + _ComputerEnvironment->Module_Root_Dir_Values.length( size ) ; + int i ; + for ( i = 0 ; i < size ; i++ ) { + _ComputerEnvironment->Module_Root_Dir_Names[ i ] = CORBA::string_dup( aComputerEnvironment->Module_Root_Dir_Names[ i ] ) ; + _ComputerEnvironment->Module_Root_Dir_Values[ i ] = CORBA::string_dup( aComputerEnvironment->Module_Root_Dir_Values[ i ] ) ; + } + cout << "Computer_Impl::Computer_Impl FullName " << _ComputerParameters->FullName << endl ; + cout << "Computer_Impl::Computer_Impl Alias " << _ComputerParameters->Alias << endl ; + cout << "Computer_Impl::Computer_Impl SshAccess " << _ComputerParameters->SshAccess << endl ; + cout << "Computer_Impl::Computer_Impl Interactive " << _ComputerParameters->Interactive << endl ; + cout << "Computer_Impl::Computer_Impl Batch " << _ComputerParameters->Batch << endl ; + cout << "Computer_Impl::Computer_Impl UserName " << _ComputerParameters->UserName << endl ; + cout << "Computer_Impl::Computer_Impl Os " << _ComputerParameters->Os << endl ; + cout << "Computer_Impl::Computer_Impl Memory " << _ComputerParameters->Memory << endl ; + cout << "Computer_Impl::Computer_Impl Swap " << _ComputerParameters->Swap << endl ; + cout << "Computer_Impl::Computer_Impl CpuClock " << _ComputerParameters->CpuClock << endl ; + cout << "Computer_Impl::Computer_Impl NbProc " << _ComputerParameters->NbProc << endl ; + cout << "Computer_Impl::Computer_Impl NbNode " << _ComputerParameters->NbNode << endl ; + for ( i = 0 ; i < size ; i++ ) { + cout << "Computer_Impl::Computer_Impl Module_Root_Dir_Names[" << i << " ] " << _ComputerEnvironment->Module_Root_Dir_Names[ i ] << endl ; + cout << "Computer_Impl::Computer_Impl Module_Root_Dir_Values[" << i << " ] " << _ComputerEnvironment->Module_Root_Dir_Values[ i ] << endl ; + } + cout << "Computer_Impl::Computer_Impl Path " << _ComputerEnvironment->Path << endl ; + cout << "Computer_Impl::Computer_Impl Ld_Library_Path " << _ComputerEnvironment->Ld_Library_Path << endl ; + cout << "Computer_Impl::Computer_Impl PythonPath " << _ComputerEnvironment->PythonPath << endl ; + cout << "Computer_Impl::Computer_Impl CasRoot " << _ComputerEnvironment->CasRoot << endl ; +} + +Computer_Impl::~Computer_Impl() { +} + +PortableServer::ObjectId * Computer_Impl::getId() { + return _Id ; +} + +long Computer_Impl::ping() { + MESSAGE("Computer_Impl::ping()") ; + return 1 ; +} + +char * Computer_Impl::FullName() { + MESSAGE("Computer_Impl::FullName()") ; + return CORBA::string_dup( _ComputerParameters->FullName ) ; +} + +char * Computer_Impl::Alias() { + MESSAGE("Computer_Impl::Alias()") ; + return CORBA::string_dup( _ComputerParameters->Alias ) ; +} + +Resources::ComputerParameters * Computer_Impl::Parameters() { + Resources::ComputerParameters_var aComputerParameters = new Resources::ComputerParameters() ; + aComputerParameters->FullName = CORBA::string_dup( _ComputerParameters->FullName ) ; + aComputerParameters->Alias = CORBA::string_dup( _ComputerParameters->Alias ) ; + aComputerParameters->SshAccess = _ComputerParameters->SshAccess ; + aComputerParameters->Interactive = _ComputerParameters->Interactive ; + aComputerParameters->Batch = _ComputerParameters->Batch ; + aComputerParameters->UserName = CORBA::string_dup( _ComputerParameters->UserName ) ; + aComputerParameters->Os = _ComputerParameters->Os ; + aComputerParameters->Memory = _ComputerParameters->Memory ; + aComputerParameters->Swap = _ComputerParameters->Swap ; + aComputerParameters->CpuClock = _ComputerParameters->CpuClock ; + aComputerParameters->NbProc = _ComputerParameters->NbProc ; + aComputerParameters->NbNode = _ComputerParameters->NbNode ; + return aComputerParameters._retn() ; +} + +Resources::ComputerEnvironment * Computer_Impl::Environment() { + Resources::ComputerEnvironment_var aComputerEnvironment = new Resources::ComputerEnvironment() ; + aComputerEnvironment->Path = CORBA::string_dup( _ComputerEnvironment->Path ) ; + aComputerEnvironment->Ld_Library_Path = CORBA::string_dup( _ComputerEnvironment->Ld_Library_Path ) ; + aComputerEnvironment->PythonPath = CORBA::string_dup( _ComputerEnvironment->PythonPath ) ; + aComputerEnvironment->CasRoot = CORBA::string_dup( _ComputerEnvironment->CasRoot ) ; + int size = _ComputerEnvironment->Module_Root_Dir_Names.length() ; + aComputerEnvironment->Module_Root_Dir_Names.length( size ) ; + aComputerEnvironment->Module_Root_Dir_Values.length( size ) ; + int i ; + for ( i = 0 ; i < size ; i++ ) { + aComputerEnvironment->Module_Root_Dir_Names[ i ] = CORBA::string_dup( _ComputerEnvironment->Module_Root_Dir_Names[ i ] ) ; + aComputerEnvironment->Module_Root_Dir_Values[ i ] = CORBA::string_dup( _ComputerEnvironment->Module_Root_Dir_Values[ i ] ) ; + } + return aComputerEnvironment._retn() ; +} + diff --git a/src/ResourcesManager/ResourcesComputer_Impl.hxx b/src/ResourcesManager/ResourcesComputer_Impl.hxx new file mode 100755 index 000000000..e1fa3e806 --- /dev/null +++ b/src/ResourcesManager/ResourcesComputer_Impl.hxx @@ -0,0 +1,72 @@ +// SALOME ResourcesComputer_Impl +// +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : ResourcesComputer_Impl.hxx +// Author : Jean Rahuel +// Module : SALOME +// $Header: + +#ifndef RESOURCESCOMPUTER_IMPL_HXX +#define RESOURCESCOMPUTER_IMPL_HXX + +#include "utilities.h" +#include +#include CORBA_SERVER_HEADER( ResourcesManager ) + +class Computer_Impl : public POA_Resources::Computer , + public PortableServer::RefCountServantBase { + private: + + CORBA::ORB_ptr _Orb ; + PortableServer::POA_ptr _Poa ; + PortableServer::ObjectId * _Id ; + + Resources::ComputerParameters * _ComputerParameters ; + Resources::ComputerEnvironment * _ComputerEnvironment ; + + public: + + Computer_Impl() ; + + Computer_Impl( CORBA::ORB_ptr orb , + PortableServer::POA_ptr poa , + Resources::ComputerParameters * aComputerParameters , + Resources::ComputerEnvironment * aComputerEnvironment ) ; + + ~Computer_Impl() ; + + PortableServer::ObjectId * Computer_Impl::getId() ; + + virtual long ping() ; + + virtual char * FullName() ; + + virtual char * Alias() ; + + virtual Resources::ComputerParameters * Parameters() ; + + virtual Resources::ComputerEnvironment * Environment() ; + +} ; + +#endif diff --git a/src/ResourcesManager/ResourcesManager_Handler.cxx b/src/ResourcesManager/ResourcesManager_Handler.cxx new file mode 100755 index 000000000..c2e3d5a4d --- /dev/null +++ b/src/ResourcesManager/ResourcesManager_Handler.cxx @@ -0,0 +1,252 @@ +// SALOME ResourcesManager_Handler +// +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : ResourcesManager_Handler.cxx +// Author : Jean Rahuel +// Module : SALOME +//$Header: + +#define TRACE 1 + +using namespace std; + +#include "ResourcesManager_Handler.hxx" + +ResourcesManager_Handler::ResourcesManager_Handler( CORBA::ORB_ptr orb , + PortableServer::POA_ptr poa ) { + MESSAGE("ResourcesManager_Handler creation") ; + _Orb = CORBA::ORB::_duplicate( orb ) ; + _Poa = PortableServer::POA::_duplicate( poa ) ; + ResetParameters() ; +} + +ResourcesManager_Handler::~ResourcesManager_Handler() { + MESSAGE("~ResourcesManager_Handler"); +} + +//Resources::ListOfComputers * ResourcesManager_Handler::ListOfComputers() { +// MESSAGE("ResourcesManager_Handler::ListOfComputers() " << _ComputersList->length() << " computers" ) ; +// return _ComputersList._retn() ; +//} + +vector< Computer_Impl * > ResourcesManager_Handler::ComputersVector() { + MESSAGE("ResourcesManager_Handler::ComputersVector() " << _ComputersVector.size() << " computers" ) ; + return _ComputersVector; +} + +void ResourcesManager_Handler::ResetParameters() { + _ComputerParameters.FullName = CORBA::string_dup( "" ) ; + _ComputerParameters.Alias = CORBA::string_dup( "" ) ; + _ComputerParameters.SshAccess = 0 ; + _ComputerParameters.Interactive = 0 ; + _ComputerParameters.Batch = 0 ; + _ComputerParameters.UserName = CORBA::string_dup( "" ) ; + _ComputerParameters.Os = Containers::Unknown ; + _ComputerParameters.Memory = 0 ; + _ComputerParameters.Swap = 0 ; + _ComputerParameters.CpuClock = 0 ; + _ComputerParameters.NbProc = 0 ; + _ComputerParameters.NbNode = 0 ; + _ComputerEnvironment.Path = CORBA::string_dup( "" ) ; + _ComputerEnvironment.Ld_Library_Path = CORBA::string_dup( "" ) ; + _ComputerEnvironment.PythonPath = CORBA::string_dup( "" ) ; + _ComputerEnvironment.CasRoot = CORBA::string_dup( "" ) ; + _ComputerEnvironment.Module_Root_Dir_Names.length( 0 ) ; + _ComputerEnvironment.Module_Root_Dir_Values.length( 0 ) ; +} + +Containers::System ResourcesManager_Handler::OsEnumValue( const string anOsName ) { + if ( anOsName == "Linux" ) { + return Containers::Linux ; + } + return Containers::Unknown ; +} + +bool ResourcesManager_Handler::startDocument() { + MESSAGE("Begin parse document"); + return true; +} + +bool ResourcesManager_Handler::startElement( const QString&, + const QString&, + const QString& qName, + const QXmlAttributes& atts) { + return true; +} + +bool ResourcesManager_Handler::endElement( const QString& , const QString& , + const QString& qName ) { + if ( qName.compare( QString( "fullname" ) ) == 0 ) { +#if TRACE + cout << "fullname " << content.c_str() << endl ; +#endif + _ComputerParameters.FullName = CORBA::string_dup( content.c_str() ) ; + } + else if ( qName.compare(QString( "alias" ) ) == 0 ) { +#if TRACE + cout << "alias " << content.c_str() << endl ; +#endif + _ComputerParameters.Alias = CORBA::string_dup( content.c_str() ) ; + } + else if ( qName.compare(QString( "sshaccess" ) ) == 0 ) { +#if TRACE + cout << "sshaccess " << content.c_str() << endl ; +#endif + _ComputerParameters.SshAccess = atol( content.c_str() ) ; + } + else if ( qName.compare(QString( "interactive" ) ) == 0 ) { +#if TRACE + cout << "interactive " << content.c_str() << endl ; +#endif + _ComputerParameters.Interactive = atol( content.c_str() ) ; + } + else if ( qName.compare(QString( "batch" ) ) == 0 ) { +#if TRACE + cout << "batch " << content.c_str() << endl ; +#endif + _ComputerParameters.Batch = atol( content.c_str() ) ; + } + else if ( qName.compare(QString( "username" ) ) == 0 ) { +#if TRACE + cout << "username " << content.c_str() << " length " << content.length() << endl ; +#endif + if ( content[0] != '\n' ) { + _ComputerParameters.UserName = CORBA::string_dup( content.c_str() ) ; + } + } + else if ( qName.compare(QString( "os" ) ) == 0 ) { +#if TRACE + cout << "os " << content.c_str() << endl ; +#endif + _ComputerParameters.Os = OsEnumValue( content ) ; + } + else if ( qName.compare(QString( "memory" ) ) == 0 ) { +#if TRACE + cout << "memory " << content.c_str() << endl ; +#endif + _ComputerParameters.Memory = atol( content.c_str() ) ; + } + else if ( qName.compare(QString( "swap" ) ) == 0 ) { +#if TRACE + cout << "swap " << content.c_str() << endl ; +#endif + _ComputerParameters.Swap = atol( content.c_str() ) ; + } + else if ( qName.compare(QString( "cpuclock" ) ) == 0 ) { +#if TRACE + cout << "cpuclock " << content.c_str() << endl ; +#endif + _ComputerParameters.CpuClock = atol( content.c_str() ) ; + } + else if ( qName.compare(QString( "nbproc" ) ) == 0 ) { +#if TRACE + cout << "nbproc " << content.c_str() << endl ; +#endif + _ComputerParameters.NbProc = atol( content.c_str() ) ; + } + else if ( qName.compare(QString( "nbnode" ) ) == 0 ) { +#if TRACE + cout << "nbnode " << content.c_str() << endl ; +#endif + _ComputerParameters.NbNode = atol( content.c_str() ) ; + } + + else if ( qName.compare(QString("path") ) == 0 ) { +#if TRACE + cout << "path " << content.c_str() << endl ; +#endif + _ComputerEnvironment.Path = CORBA::string_dup( content.c_str() ) ; + } + else if ( qName.compare(QString("ld_library_path") ) == 0 ) { +#if TRACE + cout << "ld_library_path " << content.c_str() << endl ; +#endif + _ComputerEnvironment.Ld_Library_Path = CORBA::string_dup( content.c_str() ) ; + } + else if ( qName.compare(QString("pythonpath") ) == 0 ) { +#if TRACE + cout << "pythonpath " << content.c_str() << endl ; +#endif + _ComputerEnvironment.PythonPath = CORBA::string_dup( content.c_str() ) ; + } + else if ( qName.compare(QString("casroot") ) == 0 ) { +#if TRACE + cout << "casroot " << content.c_str() << endl ; +#endif + _ComputerEnvironment.CasRoot = CORBA::string_dup( content.c_str() ) ; + } + else if ( qName.compare(QString("modules_root_dir") ) == 0 ) { +#if TRACE + cout << "modules_root_dir " << content.c_str() << endl ; +#endif + int size = _ComputerEnvironment.Module_Root_Dir_Names.length() ; + _ComputerEnvironment.Module_Root_Dir_Names.length( size + 1 ) ; + _ComputerEnvironment.Module_Root_Dir_Names[ size ] = CORBA::string_dup( content.c_str() ) ; + } + else if ( qName.compare(QString("modules_root_path") ) == 0 ) { +#if TRACE + cout << "modules_root_path " << content.c_str() << endl ; +#endif + int size = _ComputerEnvironment.Module_Root_Dir_Values.length() ; + _ComputerEnvironment.Module_Root_Dir_Values.length( size + 1 ) ; + _ComputerEnvironment.Module_Root_Dir_Values[ size ] = CORBA::string_dup( content.c_str() ) ; + } + + else if ( qName.compare(QString("computer") ) == 0 ) { + Computer_Impl * aComputer = new Computer_Impl( _Orb , _Poa , + &_ComputerParameters , &_ComputerEnvironment ) ; + int size = _ComputersVector.size() ; + _ComputersVector.resize( size + 1 ) ; + _ComputersVector[ size ] = aComputer ; + ResetParameters() ; +#if TRACE + cout << size+1 << " computers" << endl ; +#endif + } + + return true; +} + +bool ResourcesManager_Handler::characters(const QString& chars) { + content = (const char *)chars ; + return true; +} + +bool ResourcesManager_Handler::endDocument() { + MESSAGE("End parse document"); + return true; +} + +QString ResourcesManager_Handler::errorProtocol() { + return errorProt; +} + +bool ResourcesManager_Handler::fatalError(const QXmlParseException& exception) { + errorProt += QString( "fatal parsing error: %1 in line %2, column %3\n" ) + .arg( exception.message() ) + .arg( exception.lineNumber() ) + .arg( exception.columnNumber() ); + + return QXmlDefaultHandler::fatalError( exception ); +} + diff --git a/src/ResourcesManager/ResourcesManager_Handler.hxx b/src/ResourcesManager/ResourcesManager_Handler.hxx new file mode 100755 index 000000000..e411775cc --- /dev/null +++ b/src/ResourcesManager/ResourcesManager_Handler.hxx @@ -0,0 +1,91 @@ +// SALOME ResourcesManager_Handler +// +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : ResourcesManager_Handler.hxx +// Author : Jean Rahuel +// Module : SALOME +//$Header: + +#ifndef RESSOURCESMANAGER_HANDLER_HXX +#define RESSOURCESMANAGER_HANDLER_HXX + +#include +#include CORBA_SERVER_HEADER( ResourcesManager ) +#include CORBA_SERVER_HEADER( ContainersManager ) + +#include "utilities.h" +#include "ResourcesManager_Parser.hxx" +#include "ResourcesComputer_Impl.hxx" +#include +#include +#include + +class ResourcesManager_Handler : public QXmlDefaultHandler { + + private : + + CORBA::ORB_ptr _Orb ; + PortableServer::POA_ptr _Poa ; + +// Resources::ListOfComputers_var _ComputersList ; + vector< Computer_Impl * > _ComputersVector ; + Resources::ComputerParameters _ComputerParameters ; + Resources::ComputerEnvironment _ComputerEnvironment ; + + QString errorProt ; + + string content ; + + void ResourcesManager_Handler::ResetParameters() ; + + Containers::System OsEnumValue( const string anOsName ) ; + + public : + + ResourcesManager_Handler( CORBA::ORB_ptr orb , + PortableServer::POA_ptr poa ) ; + + virtual ~ResourcesManager_Handler() ; + +// virtual Resources::ListOfComputers * ListOfComputers() ; + vector< Computer_Impl * > ComputersVector() ; + + virtual bool startDocument() ; + + virtual bool startElement( const QString& , const QString& , + const QString& qName , const QXmlAttributes& atts ) ; + + virtual bool endElement( const QString& , const QString& , + const QString& qName) ; + + virtual bool characters( const QString & chars) ; + + virtual bool endDocument() ; + + virtual QString errorProtocol() ; + + virtual bool fatalError( const QXmlParseException& exception ) ; + +} ; + +#endif diff --git a/src/ResourcesManager/ResourcesManager_Impl.cxx b/src/ResourcesManager/ResourcesManager_Impl.cxx new file mode 100755 index 000000000..a2b8111ed --- /dev/null +++ b/src/ResourcesManager/ResourcesManager_Impl.cxx @@ -0,0 +1,239 @@ +// ResourcesManager_Impl +// +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : ResourcesManager_Impl.cxx +// Author : Jean Rahuel +// Module : SALOME + +using namespace std; + +#include + +#include "ResourcesManager_Impl.hxx" + +Manager_Impl::Manager_Impl( CORBA::ORB_ptr orb , + PortableServer::POA_ptr poa , + SALOME_NamingService * NamingService , + int argc , + char ** argv ) { + + _Orb = CORBA::ORB::_duplicate( orb ) ; + _Poa = PortableServer::POA::_duplicate( poa ) ; + _Id = _Poa->activate_object( this ) ; + _NamingService = NamingService ; + + _ComputersList = new Resources::ListOfComputers() ; + + if ( !ParseArguments( argc , argv , &_CatalogPath ) ) { + MESSAGE( "Error while argument parsing" ) ; + } + else if ( _CatalogPath == NULL ) { + MESSAGE( "Error the resources catalog should be indicated" ) ; + } + else { + MESSAGE("Parse resources catalog"); + ParseXmlFile( _CatalogPath ) ; + } + int i ; + MESSAGE(_ComputersVector.size() << " computers") ; + int size = _ComputersVector.size() ; + _ComputersList->length( size ) ; + for ( i = 0 ; i < size ; i++ ) { + Computer_Impl * aComputer = _ComputersVector[ i ] ; + PortableServer::ObjectId * id = aComputer->getId() ; + CORBA::Object_var obj = _Poa->id_to_reference( *id ) ; + Resources::Computer_var iobject = Resources::Computer::_narrow( obj ) ; + _ComputersList[ i ] = Resources::Computer::_duplicate( iobject ) ; + Resources::ComputerParameters * aComputerParameters = aComputer->Parameters() ; + const char * anAlias = aComputerParameters->Alias ; + if ( _MapOfComputers[ anAlias ] > 0 ) { + MESSAGE("Duplicate computer " << aComputerParameters->FullName << " " << anAlias ) ; + } + else { + MESSAGE("Computer " << aComputerParameters->FullName << " " << anAlias ) ; + _MapOfComputers[ anAlias ] = i + 1 ; + } + } + MESSAGE(_ComputersList->length() << " computers") ; +} + +Manager_Impl::~Manager_Impl() { + MESSAGE("~Manager_Impl()") ; +} + +long Manager_Impl::ping() { + MESSAGE("Manager_Impl::ping()") ; + return 1 ; +} + +Resources::Computer_ptr Manager_Impl::TestComputer() { +#if 1 + Resources::ComputerParameters * aComputerParameters = new Resources::ComputerParameters() ; + aComputerParameters->FullName = CORBA::string_dup( "FullName" ) ; + aComputerParameters->Alias = CORBA::string_dup( "Alias" ) ; + aComputerParameters->SshAccess = 1 ; + aComputerParameters->Interactive = 1 ; + aComputerParameters->Batch = 1 ; + aComputerParameters->UserName = CORBA::string_dup( "UserName" ) ; + aComputerParameters->Os = Containers::Linux ; + aComputerParameters->Memory = 100 ; + aComputerParameters->Swap = 200 ; + aComputerParameters->CpuClock = 300 ; + aComputerParameters->NbProc = 1 ; + aComputerParameters->NbNode = 1 ; + Resources::ComputerEnvironment * aComputerEnvironment = new Resources::ComputerEnvironment() ; + aComputerEnvironment->Path = CORBA::string_dup( "Path" ) ; + aComputerEnvironment->Ld_Library_Path = CORBA::string_dup( "Ld_Library_Path" ) ; + aComputerEnvironment->PythonPath = CORBA::string_dup( "PythonPath" ) ; + aComputerEnvironment->CasRoot = CORBA::string_dup( "CasRoot" ) ; + Computer_Impl * aComputer = new Computer_Impl( _Orb , _Poa , + aComputerParameters , aComputerEnvironment ) ; + PortableServer::ObjectId * id = aComputer->getId() ; + CORBA::Object_var obj = _Poa->id_to_reference( *id ) ; + Resources::Computer_var iobject = Resources::Computer::_narrow( obj ) ; + return Resources::Computer::_duplicate( iobject ) ; +#endif +} + +long Manager_Impl::SshAccess( const char * aComputerName ) { + if ( !CORBA::is_nil( SearchComputer( aComputerName ) ) ) { + return SearchComputer( aComputerName )->Parameters()->SshAccess ; + } + return 0 ; +} + +Resources::ListOfComputers * Manager_Impl::AllComputers() { + MESSAGE("Manager_Impl::AllComputers()") ; + Resources::ListOfComputers_var aListOfComputers = new Resources::ListOfComputers() ; + aListOfComputers->length( _ComputersList->length() ) ; + int i ; + for ( i = 0 ; i < _ComputersList->length() ; i++ ) { + Resources::Computer_var aComputer = _ComputersList[ i ] ; + aListOfComputers[ i ] = Resources::Computer::_duplicate( aComputer ) ; + } + return aListOfComputers._retn() ; +} + +Resources::ListOfComputers * Manager_Impl::GetComputers( const Containers::MachineParameters & aMachineParameters ) { + MESSAGE("Manager_Impl::GetComputers()") ; + Resources::ListOfComputers_var aListOfComputers = new Resources::ListOfComputers() ; + int i ; + if ( strlen( (char * ) ((CORBA::String_member ) aMachineParameters.HostName) ) ) { + for ( i = 0 ; i < _ComputersList->length() ; i++ ) { + Resources::Computer_var aComputer = _ComputersList[ i ] ; + if ( aComputer->Parameters()->FullName == aMachineParameters.HostName || + aComputer->Parameters()->Alias == aMachineParameters.HostName ) { + aListOfComputers->length( 1 ) ; + aListOfComputers[ 0 ] = Resources::Computer::_duplicate( aComputer ) ; + MESSAGE("Manager_Impl::GetComputers() " << aComputer->FullName() << " selected" ) ; + break ; + } + } + } + else { + for ( i = 0 ; i < _ComputersList->length() ; i++ ) { + Resources::Computer_var aComputer = _ComputersList[ i ] ; + if ( ( aMachineParameters.Os == Containers::Unknown || + ( aComputer->Parameters()->Os == aMachineParameters.Os ) ) && + aComputer->Parameters()->Memory >= aMachineParameters.Memory && + aComputer->Parameters()->CpuClock >= aMachineParameters.CpuClock && + aComputer->Parameters()->NbProc >= aMachineParameters.NbProc && + aComputer->Parameters()->NbNode >= aMachineParameters.NbNode ) { + int size = aListOfComputers->length() ; + aListOfComputers->length( size + 1 ) ; + aListOfComputers[ size ] = Resources::Computer::_duplicate( aComputer ) ; + MESSAGE("Manager_Impl::GetComputers() " << aComputer->FullName() << " selected" ) ; + } + } + } + MESSAGE("Manager_Impl::GetComputers() " << aListOfComputers->length() << " found" ) ; + return aListOfComputers._retn() ; +} + +Resources::Computer_ptr Manager_Impl::SelectComputer( const Containers::MachineParameters & aMachineParameters ) { + MESSAGE("Manager_Impl::SelectComputer()") ; + Resources::ListOfComputers_var aListOfComputers = GetComputers( aMachineParameters ) ; + MESSAGE("Manager_Impl::SelectComputer()") ; + return GetComputer( aListOfComputers ) ; +} + +Resources::Computer_ptr Manager_Impl::GetComputer( const Resources::ListOfComputers & aListOfComputers ) { + MESSAGE("Manager_Impl::GetComputer()") ; + Resources::Computer_var aComputer = Resources::Computer::_nil() ; + if ( aListOfComputers.length() ) { + aComputer = aListOfComputers[ 0 ] ; + } + MESSAGE("Manager_Impl::GetComputer()") ; + return Resources::Computer::_duplicate( aComputer ) ; +} + +Resources::Computer_ptr Manager_Impl::SearchComputer( const char * aComputerName ) { + MESSAGE("Manager_Impl::SearchComputer()") ; + Resources::Computer_var aComputer = Resources::Computer::_nil() ; + int i = _MapOfComputers[ aComputerName ] ; + if ( i ) { + aComputer = _ComputersList[ i - 1 ] ; + } + MESSAGE("Manager_Impl::SearchComputer()") ; + return Resources::Computer::_duplicate( aComputer ) ; +} + +//Resources::ListOfComputers_var Manager_Impl::ParseXmlFile( const char * xmlfile ) { +void Manager_Impl::ParseXmlFile( const char * xmlfile ) { + ResourcesManager_Handler * MyHandler = new ResourcesManager_Handler( _Orb , _Poa ); + QFile xmlFile( xmlfile ) ; + QXmlInputSource source( xmlFile ) ; + QXmlSimpleReader reader ; + reader.setContentHandler( MyHandler ) ; + reader.setErrorHandler( MyHandler ) ; + reader.parse( source ) ; +// Resources::ListOfComputers_var aListOfComputers = MyHandler->ListOfComputers() ; + _ComputersVector = MyHandler->ComputersVector() ; + xmlFile.close() ; + MESSAGE("Manager_Impl::ParseXmlFile()" << _ComputersVector.size() << " computers" ) ; +// return aListOfComputers ; +} + +bool Manager_Impl::ParseArguments( int argc , char ** argv , char ** path) { + bool RetVal = true; + *path = NULL; + for ( int ind = 0 ; ind < argc ; ind++ ) { + if ( strcmp( argv[ind] , "-help" ) == 0 ) { + INFOS( "Usage: " << argv[0] << " -common 'path to ressources catalog' -ORBInitRef NameService=corbaname::localhost"); + RetVal = false ; + } + if ( strcmp( argv[ind] ,"-common" ) == 0 ) { + if ( ind + 1 <= argc ) { + *path = argv[ind + 1] ; + ifstream path_file(*path); + if ( !path_file ) { + MESSAGE( "Sorry the file " << *path << " can't be open" ) + *path = NULL ; + RetVal = false; + } + } + } + } + return RetVal ; +} + diff --git a/src/ResourcesManager/ResourcesManager_Impl.hxx b/src/ResourcesManager/ResourcesManager_Impl.hxx new file mode 100755 index 000000000..d31476422 --- /dev/null +++ b/src/ResourcesManager/ResourcesManager_Impl.hxx @@ -0,0 +1,95 @@ +// SALOME ResourcesManager_Impl +// +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : ResourcesManager_Impl.hxx +// Author : Jean Rahuel +// Module : SALOME +// $Header: + +#ifndef RESOURCESMANAGER_IMPL_HXX +#define RESOURCESMANAGER_IMPL_HXX + +#include +#include + +#include + +#include "SALOME_NamingService.hxx" + +#include "utilities.h" +#include "ResourcesManager_Handler.hxx" + +#include +#include CORBA_SERVER_HEADER( ResourcesManager ) +#include CORBA_SERVER_HEADER( ContainersManager ) + +class Manager_Impl : public POA_Resources::Manager , + public PortableServer::RefCountServantBase { + + private: + + CORBA::ORB_ptr _Orb ; + PortableServer::POA_ptr _Poa ; + SALOME_NamingService * _NamingService ; + PortableServer::ObjectId * _Id ; + + char * _CatalogPath ; + + vector< Computer_Impl * > _ComputersVector ; + Resources::ListOfComputers_var _ComputersList ; + map< string , int > _MapOfComputers ; + +// virtual Resources::ListOfComputers_var ParseXmlFile( const char * xmlfile ) ; + virtual void ParseXmlFile( const char * xmlfile ) ; + + virtual bool ParseArguments( int argc , char ** argv , char ** path ) ; + + public: + + Manager_Impl( CORBA::ORB_ptr orb , + PortableServer::POA_ptr poa , + SALOME_NamingService * NamingService , + int argc , + char** argv ) ; + + virtual ~Manager_Impl(); + + virtual long ping() ; + + virtual Resources::Computer_ptr TestComputer() ; + + virtual long SshAccess( const char * aComputerName ) ; + + virtual Resources::ListOfComputers * AllComputers() ; + + virtual Resources::ListOfComputers * GetComputers( const Containers::MachineParameters & aMachineParameters ) ; + + virtual Resources::Computer_ptr SelectComputer( const Containers::MachineParameters & aMachineParameters ) ; + + virtual Resources::Computer_ptr GetComputer( const Resources::ListOfComputers & aListOfComputers ) ; + + virtual Resources::Computer_ptr SearchComputer( const char * aComputerName ) ; + +} ; + +#endif diff --git a/src/ResourcesManager/ResourcesManager_Parser.hxx b/src/ResourcesManager/ResourcesManager_Parser.hxx new file mode 100755 index 000000000..4530187ce --- /dev/null +++ b/src/ResourcesManager/ResourcesManager_Parser.hxx @@ -0,0 +1,63 @@ +// SALOME ResourcesManager_Parser +// +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : ResourcesManager_Parser.hxx +// Author : Jean Rahuel +// Module : SALOME +//$Header: + +#ifndef RESOURCESMANAGER_PARSER +#define RESOURCESMANAGER_PARSER + +#include +#include + +struct ParserProc{ + long Parsernumber; + string Parsermodel_name; + float Parsercpu_mhz; + float Parsercache_size; +}; + +typedef vector ListOfParserProc; + +enum Parsercontainertype {Cpp, python, NP}; +typedef vector ListOfParserContainerType; + +struct Parserressources{ + string Parsername; + string ParserOS; + string ParserOS_version; + ListOfParserProc Parserprocs; + ListOfParserContainerType Parsercontainertype; +}; + +typedef vector ListOfParserressources; + +#ifdef WRITE_RESSOURCES_TYPE +ListOfParserressources _ressources_list; +#else +extern ListOfParserressources _ressources_list; +#endif + +#endif diff --git a/src/ResourcesManager/ResourcesManager_Server.cxx b/src/ResourcesManager/ResourcesManager_Server.cxx new file mode 100755 index 000000000..8c3b5bd0f --- /dev/null +++ b/src/ResourcesManager/ResourcesManager_Server.cxx @@ -0,0 +1,181 @@ +// SALOME ResourcesManager_Server +// +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : ResourcesManager_Server.cxx +// Author : Jean Rahuel +// Module : SALOME +// $Header: + +#include +#include "SALOME_NamingService.hxx" +#include "Utils_SINGLETON.hxx" + +#include "ResourcesManager_Impl.hxx" + +using namespace std; + +int main(int argc,char **argv) { + try { + +// initialize the ORB + CORBA::ORB_ptr orb = CORBA::ORB_init ( argc , argv ) ; + + long TIMESleep = 250000000 ; + int NumberOfTries = 40 ; + int a ; + int i ; + int j ; + timespec ts_req ; + ts_req.tv_nsec=TIMESleep ; + ts_req.tv_sec=0 ; + timespec ts_rem ; + ts_rem.tv_nsec=0 ; + ts_rem.tv_sec=0 ; + +// initialize POA + CosNaming::NamingContext_var inc ; + PortableServer::POA_var poa ; + CORBA::Object_var theObj = CORBA::Object::_nil() ; + CORBA::Object_var obj = CORBA::Object::_nil() ; + CORBA::Object_var object = CORBA::Object::_nil() ; + SALOME_NamingService &naming = *SINGLETON_::Instance() ; + int CONTAINERS_MANAGER = 0 ; + const char * Env = getenv("USE_LOGGER") ; + int EnvL =0; + if ( ( Env != NULL ) && ( strlen(Env ) ) ) { + EnvL=1 ; + } + CosNaming::Name name ; + name.length( 1 ) ; + name[0].id = CORBA::string_dup("Logger") ; + PortableServer::POAManager_var mgr ; + for ( i = 1 ; i <= NumberOfTries ; i++ ) { + if ( i != 1 ) { + a=nanosleep( &ts_req , &ts_rem ) ; + } + try { + obj = orb->resolve_initial_references( "RootPOA" ) ; + if ( !CORBA::is_nil( obj ) ) { + poa = PortableServer::POA::_narrow( obj ) ; + } + if ( !CORBA::is_nil( poa ) ) { + mgr = poa->the_POAManager() ; + } + if ( !CORBA::is_nil( orb ) ) { + theObj = orb->resolve_initial_references( "NameService" ) ; + } + if ( !CORBA::is_nil( theObj ) ) { + inc = CosNaming::NamingContext::_narrow(theObj) ; + } + } + catch ( CORBA::COMM_FAILURE& ) { + MESSAGE( "ContainersManager : CORBA::COMM_FAILURE: Unable to contact the Naming Service" ) ; + } + if ( !CORBA::is_nil( inc ) ) { + MESSAGE( "ContainersManager : Naming Service was found" ) ; + if ( EnvL == 1 ) { + for ( j = 1 ; j <= NumberOfTries ; j++ ) { + if ( j !=1 ) { + a=nanosleep( &ts_req , &ts_rem ) ; + } + try { + object = inc->resolve( name ) ; + } + catch ( CosNaming::NamingContext::NotFound ) { + MESSAGE( "ContainersManager : Logger Server wasn't found" ) ; + } + catch (...) { + MESSAGE( "ContainersManager : Unknown exception" ) ; + } + if ( !CORBA::is_nil( object ) ) { + MESSAGE( "ContainersManager : Loger Server was found" ) ; + CONTAINERS_MANAGER = 1 ; + break; + } + } + } + } + if ( ( CONTAINERS_MANAGER == 1 ) || ( (EnvL ==0 ) && ( !CORBA::is_nil( inc ) ) ) ) { + break; + } + } + +#if 0 + // define policy objects + PortableServer::ImplicitActivationPolicy_var implicitActivation = + poa->create_implicit_activation_policy(PortableServer::NO_IMPLICIT_ACTIVATION) ; + + // default = NO_IMPLICIT_ACTIVATION + PortableServer::ThreadPolicy_var threadPolicy = + poa->create_thread_policy(PortableServer::ORB_CTRL_MODEL) ; + // default = ORB_CTRL_MODEL, other choice SINGLE_THREAD_MODEL + + // create policy list + CORBA::PolicyList policyList; + policyList.length(2); + policyList[0] = PortableServer::ImplicitActivationPolicy::_duplicate(implicitActivation) ; + policyList[1] = PortableServer::ThreadPolicy::_duplicate(threadPolicy) ; + + // create the child POA + PortableServer::POAManager_var nil_mgr = PortableServer::POAManager::_nil() ; + PortableServer::POA_var factory_poa = + poa->create_POA("factory_poa", mgr, policyList) ; + //with nil_mgr instead of mgr, a new POA manager is created with the new POA + + // destroy policy objects + implicitActivation->destroy() ; + threadPolicy->destroy() ; + +#endif + +// initialise Naming Service + SALOME_NamingService *_NS ; + _NS = new SALOME_NamingService( orb ) ; + +// Active ResourcesManager + Manager_Impl * MyResourcesManager = new Manager_Impl( orb , poa , _NS , argc , argv ) ; +// Manager_Impl * MyResourcesManager = new Manager_Impl( orb , factory_poa , _NS , argc , argv ) ; +// poa->activate_object ( MyResourcesManager ) ; + mgr->activate() ; + CORBA::Object_ptr TheResourcesManager = MyResourcesManager->_this() ; + + +// register ResourcesManager in Naming Service + _NS->Register( TheResourcesManager , "/Kernel/ResourcesManager" ) ; + + MESSAGE("Running ResourcesManager Server.") ; + + orb->run(); + + poa->destroy( 1 , 1 ) ; + + } + catch ( CORBA::SystemException& ) { + INFOS("Caught CORBA::SystemException.") ; + } + catch ( CORBA::Exception& ) { + INFOS("Caught CORBA::Exception.") ; + } + + return 0 ; +}