src/Container/Container_i.cxx

   1 //  SALOME Container : implementation of container and engine for Kernel
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //
  23 //
  24 //  File   : Container_i.cxx
  25 //  Author : Paul RASCLE, EDF - MARC TAJCHMAN, CEA
  26 //  Module : SALOME
  27 //  $Header$
  28
  29 //#define private public
  30 #include <string.h>
  31 #include <stdio.h>
  32 #include <time.h>
  33 #ifndef WNT
  34 #include <sys/time.h>
  35 #include <dlfcn.h>
  36 #include <unistd.h>
  37 #else
  38 #include <signal.h>
  39 #include <process.h>
  40 int SIGUSR1 = 1000;
  41 #endif
  42
  43 #include "utilities.h"
  44 #include <SALOMEconfig.h>
  45 //#ifndef WNT
  46 #include CORBA_SERVER_HEADER(SALOME_Component)
  47 #include CORBA_SERVER_HEADER(SALOME_Exception)
  48 //#else
  49 //#include <SALOME_Component.hh>
  50 //#endif
  51 #include <pthread.h>  // must be before Python.h !
  52 #include "SALOME_Container_i.hxx"
  53 #include "SALOME_Component_i.hxx"
  54 #include "SALOME_FileRef_i.hxx"
  55 #include "SALOME_FileTransfer_i.hxx"
  56 #include "Salome_file_i.hxx"
  57 #include "SALOME_NamingService.hxx"
  58 #include "OpUtil.hxx"
  59
  60 #include <Python.h>
  61 #include "Container_init_python.hxx"
  62
  63 using namespace std;
  64
  65 bool _Sleeping = false ;
  66
  67 // // Needed by multi-threaded Python --- Supervision
  68 int _ArgC ;
  69 char ** _ArgV ;
  70
  71
  72 // Containers with name FactoryServer are started via rsh in LifeCycleCORBA
  73 // Other Containers are started via start_impl of FactoryServer
  74
  75 extern "C" {void ActSigIntHandler() ; }
  76 #ifndef WNT
  77   extern "C" {void SigIntHandler(int, siginfo_t *, void *) ; }
  78 #else
  79   extern "C" {void SigIntHandler( int ) ; }
  80 #endif
  81
  82
  83 map<std::string, int> Engines_Container_i::_cntInstances_map;
  84 map<std::string, void *> Engines_Container_i::_library_map;
  85 map<std::string, void *> Engines_Container_i::_toRemove_map;
  86 omni_mutex Engines_Container_i::_numInstanceMutex ;
  87
  88 //=============================================================================
  89 /*!
  90  *  Default constructor, not for use
  91  */
  92 //=============================================================================
  93
  94 Engines_Container_i::Engines_Container_i () :
  95   _numInstance(0)
  96 {
  97 }
  98
  99 //=============================================================================
 100 /*!
 101  *  Construtor to use
 102  */
 103 //=============================================================================
 104
 105 Engines_Container_i::Engines_Container_i (CORBA::ORB_ptr orb,
 106                                           PortableServer::POA_ptr poa,
 107                                           char *containerName ,
 108                                           int argc , char* argv[],
 109                                           bool activAndRegist,
 110                                           bool isServantAloneInProcess
 111                                           ) :
 112   _numInstance(0),_isServantAloneInProcess(isServantAloneInProcess)
 113 {
 114   _pid = (long)getpid();
 115
 116   if(activAndRegist)
 117     ActSigIntHandler() ;
 118
 119   _argc = argc ;
 120   _argv = argv ;
 121
 122   string hostname = GetHostname();
 123 #ifndef WNT
 124   MESSAGE(hostname << " " << getpid() <<
 125          " Engines_Container_i starting argc " <<
 126    _argc << " Thread " << pthread_self() ) ;
 127 #else
 128   MESSAGE(hostname << " " << _getpid() <<
 129          " Engines_Container_i starting argc " << _argc<< " Thread " << pthread_self().p ) ;
 130 #endif
 131
 132   int i = 0 ;
 133   while ( _argv[ i ] )
 134     {
 135       MESSAGE("           argv" << i << " " << _argv[ i ]) ;
 136       i++ ;
 137     }
 138
 139   if ( argc < 2 )
 140     {
 141       INFOS("SALOME_Container usage : SALOME_Container ServerName");
 142       ASSERT(0) ;
 143     }
 144   SCRUTE(argv[1]);
 145   _isSupervContainer = false;
 146   if (strcmp(argv[1],"SuperVisionContainer") == 0) _isSupervContainer = true;
 147
 148   if (_isSupervContainer)
 149     {
 150       _ArgC = argc ;
 151       _ArgV = argv ;
 152     }
 153
 154   _orb = CORBA::ORB::_duplicate(orb) ;
 155   _poa = PortableServer::POA::_duplicate(poa) ;
 156
 157   // Pour les containers paralleles: il ne faut pas enregistrer et activer
 158   // le container generique, mais le container specialise
 159
 160   if(activAndRegist)
 161     {
 162       _id = _poa->activate_object(this);
 163       _NS = new SALOME_NamingService();
 164       _NS->init_orb( _orb ) ;
 165       CORBA::Object_var obj=_poa->id_to_reference(*_id);
 166       Engines::Container_var pCont
 167         = Engines::Container::_narrow(obj);
 168       _remove_ref();
 169
 170       _containerName = _NS->BuildContainerNameForNS(containerName,
 171                                                     hostname.c_str());
 172       SCRUTE(_containerName);
 173       _NS->Register(pCont, _containerName.c_str());
 174       MESSAGE("Engines_Container_i::Engines_Container_i : Container name "
 175               << _containerName);
 176
 177       // Python:
 178       // import SALOME_Container
 179       // pycont = SALOME_Container.SALOME_Container_i(containerIORStr)
 180
 181       CORBA::String_var sior =  _orb->object_to_string(pCont);
 182       string myCommand="pyCont = SALOME_Container.SALOME_Container_i('";
 183       myCommand += _containerName + "','";
 184       myCommand += sior;
 185       myCommand += "')\n";
 186       SCRUTE(myCommand);
 187
 188       if (!_isSupervContainer)
 189         {
 190 #ifdef WNT
 191
 192           PyEval_AcquireLock();
 193           PyThreadState *myTstate = PyThreadState_New(KERNEL_PYTHON::_interp);
 194           PyThreadState *myoldTstate = PyThreadState_Swap(myTstate);
 195 #else
 196           Py_ACQUIRE_NEW_THREAD;
 197 #endif
 198
 199 #ifdef WNT
 200           // mpv: this is temporary solution: there is a unregular crash if not
 201           //Sleep(2000);
 202           //
 203     // first element is the path to Registry.dll, but it's wrong
 204           PyRun_SimpleString("import sys\n");
 205           PyRun_SimpleString("sys.path = sys.path[1:]\n");
 206 #endif
 207           PyRun_SimpleString("import SALOME_Container\n");
 208           PyRun_SimpleString((char*)myCommand.c_str());
 209           Py_RELEASE_NEW_THREAD;
 210         }
 211
 212       fileTransfer_i* aFileTransfer = new fileTransfer_i();
 213       CORBA::Object_var obref=aFileTransfer->_this();
 214       _fileTransfer = Engines::fileTransfer::_narrow(obref);
 215       aFileTransfer->_remove_ref();
 216     }
 217 }
 218
 219 //=============================================================================
 220 /*!
 221  *  Destructor
 222  */
 223 //=============================================================================
 224
 225 Engines_Container_i::~Engines_Container_i()
 226 {
 227   MESSAGE("Container_i::~Container_i()");
 228   delete _id;
 229   if(_NS)
 230     delete _NS;
 231 }
 232
 233 //=============================================================================
 234 /*!
 235  *  CORBA attribute: Container name (see constructor)
 236  */
 237 //=============================================================================
 238
 239 char* Engines_Container_i::name()
 240 {
 241    return CORBA::string_dup(_containerName.c_str()) ;
 242 }
 243
 244 //=============================================================================
 245 /*!
 246  *  CORBA attribute: Container working directory
 247  */
 248 //=============================================================================
 249
 250 char* Engines_Container_i::workingdir()
 251 {
 252   char wd[256];
 253   getcwd (wd,256);
 254   return CORBA::string_dup(wd) ;
 255 }
 256
 257 //=============================================================================
 258 /*!
 259  *  CORBA attribute: Container log file name
 260  */
 261 //=============================================================================
 262
 263 char* Engines_Container_i::logfilename()
 264 {
 265   return CORBA::string_dup(_logfilename.c_str()) ;
 266 }
 267
 268 void Engines_Container_i::logfilename(const char* name)
 269 {
 270   _logfilename=name;
 271 }
 272
 273 //=============================================================================
 274 /*!
 275  *  CORBA method: Get the hostName of the Container (without domain extensions)
 276  */
 277 //=============================================================================
 278
 279 char* Engines_Container_i::getHostName()
 280 {
 281   string s = GetHostname();
 282   //  MESSAGE("Engines_Container_i::getHostName " << s);
 283   return CORBA::string_dup(s.c_str()) ;
 284 }
 285
 286 //=============================================================================
 287 /*!
 288  *  CORBA method: Get the PID (process identification) of the Container
 289  */
 290 //=============================================================================
 291
 292 CORBA::Long Engines_Container_i::getPID()
 293 {
 294   return (CORBA::Long)getpid();
 295 }
 296
 297 //=============================================================================
 298 /*!
 299  *  CORBA method: check if servant is still alive
 300  */
 301 //=============================================================================
 302
 303 void Engines_Container_i::ping()
 304 {
 305   MESSAGE("Engines_Container_i::ping() pid "<< getpid());
 306 }
 307
 308 //=============================================================================
 309 /*!
 310  *  CORBA method, oneway: Server shutdown.
 311  *  - Container name removed from naming service,
 312  *  - servant deactivation,
 313  *  - orb shutdown if no other servants in the process
 314  */
 315 //=============================================================================
 316
 317 void Engines_Container_i::Shutdown()
 318 {
 319   MESSAGE("Engines_Container_i::Shutdown()");
 320
 321   /* For each component contained in this container
 322    * tell it to self-destroy
 323    */
 324   std::map<std::string, Engines::Component_var>::iterator itm;
 325   for (itm = _listInstances_map.begin(); itm != _listInstances_map.end(); itm++)
 326     itm->second->destroy();
 327
 328   _NS->Destroy_FullDirectory(_containerName.c_str());
 329   _NS->Destroy_Name(_containerName.c_str());
 330   //_remove_ref();
 331   //_poa->deactivate_object(*_id);
 332   if(_isServantAloneInProcess)
 333     {
 334       MESSAGE("Effective Shutdown of container Begins...");
 335       if(!CORBA::is_nil(_orb))
 336         _orb->shutdown(0);
 337     }
 338 }
 339
 340
 341 //=============================================================================
 342 /*!
 343  *  CORBA method: load a new component class (Python or C++ implementation)
 344  *  \param componentName like COMPONENT
 345  *                          try to make a Python import of COMPONENT,
 346  *                          then a lib open of libCOMPONENTEngine.so
 347  *  \return true if dlopen successfull or already done, false otherwise
 348  */
 349 //=============================================================================
 350
 351 bool
 352 Engines_Container_i::load_component_Library(const char* componentName)
 353 {
 354
 355   string aCompName = componentName;
 356
 357   // --- try dlopen C++ component
 358
 359 #ifndef WNT
 360   string impl_name = string ("lib") + aCompName + string("Engine.so");
 361 #else
 362   string impl_name = aCompName + string("Engine.dll");
 363 #endif
 364   SCRUTE(impl_name);
 365
 366   _numInstanceMutex.lock(); // lock to be alone
 367   // (see decInstanceCnt, finalize_removal))
 368   if (_toRemove_map.count(impl_name) != 0) _toRemove_map.erase(impl_name);
 369   if (_library_map.count(impl_name) != 0)
 370     {
 371       MESSAGE("Library " << impl_name << " already loaded");
 372       _numInstanceMutex.unlock();
 373       return true;
 374     }
 375
 376 #ifndef WNT
 377   void* handle;
 378   handle = dlopen( impl_name.c_str() , RTLD_LAZY ) ;
 379 #else
 380   HINSTANCE handle;
 381   handle = LoadLibrary( impl_name.c_str() );
 382 #endif
 383
 384   if ( handle )
 385   {
 386       _library_map[impl_name] = handle;
 387       _numInstanceMutex.unlock();
 388       return true;
 389   }
 390   _numInstanceMutex.unlock();
 391
 392   // --- try import Python component
 393
 394   INFOS("try import Python component "<<componentName);
 395   if (_isSupervContainer)
 396     {
 397       INFOS("Supervision Container does not support Python Component Engines");
 398       return false;
 399     }
 400   if (_library_map.count(aCompName) != 0)
 401     {
 402       return true; // Python Component, already imported
 403     }
 404   else
 405     {
 406       Py_ACQUIRE_NEW_THREAD;
 407       PyObject *mainmod = PyImport_AddModule("__main__");
 408       PyObject *globals = PyModule_GetDict(mainmod);
 409       PyObject *pyCont = PyDict_GetItemString(globals, "pyCont");
 410       PyObject *result = PyObject_CallMethod(pyCont,
 411                                              "import_component",
 412                                              "s",componentName);
 413       int ret= PyInt_AsLong(result);
 414       Py_XDECREF(result);
 415       SCRUTE(ret);
 416       Py_RELEASE_NEW_THREAD;
 417
 418       if (ret) // import possible: Python component
 419         {
 420           _numInstanceMutex.lock() ; // lock to be alone (stl container write)
 421           _library_map[aCompName] = (void *)pyCont; // any non O value OK
 422           _numInstanceMutex.unlock() ;
 423           MESSAGE("import Python: "<<aCompName<<" OK");
 424           return true;
 425         }
 426     }
 427   INFOS( "Impossible to load component: " << componentName );
 428   INFOS( "Can't load shared library: " << impl_name );
 429   INFOS( "Can't import Python module: " << componentName );
 430   return false;
 431 }
 432
 433 //=============================================================================
 434 /*!
 435  *  CORBA method: Creates a new servant instance of a component.
 436  *  The servant registers itself to naming service and Registry.
 437  *  \param genericRegisterName  Name of the component instance to register
 438  *                         in Registry & Name Service (without _inst_n suffix)
 439  *  \param studyId         0 for multiStudy instance,
 440  *                         study Id (>0) otherwise
 441  *  \return a loaded component
 442  */
 443 //=============================================================================
 444
 445 Engines::Component_ptr
 446 Engines_Container_i::create_component_instance(const char*genericRegisterName,
 447                                                CORBA::Long studyId)
 448 {
 449   if (studyId < 0)
 450     {
 451       INFOS("studyId must be > 0 for mono study instance, =0 for multiStudy");
 452       return Engines::Component::_nil() ;
 453     }
 454
 455   Engines::Component_var iobject = Engines::Component::_nil() ;
 456
 457   string aCompName = genericRegisterName;
 458   if (_library_map.count(aCompName) != 0) // Python component
 459     {
 460       if (_isSupervContainer)
 461         {
 462           INFOS("Supervision Container does not support Python Component Engines");
 463           return Engines::Component::_nil();
 464         }
 465       _numInstanceMutex.lock() ; // lock on the instance number
 466       _numInstance++ ;
 467       int numInstance = _numInstance ;
 468       _numInstanceMutex.unlock() ;
 469
 470       char aNumI[12];
 471       sprintf( aNumI , "%d" , numInstance ) ;
 472       string instanceName = aCompName + "_inst_" + aNumI ;
 473       string component_registerName =
 474         _containerName + "/" + instanceName;
 475
 476       Py_ACQUIRE_NEW_THREAD;
 477       PyObject *mainmod = PyImport_AddModule("__main__");
 478       PyObject *globals = PyModule_GetDict(mainmod);
 479       PyObject *pyCont = PyDict_GetItemString(globals, "pyCont");
 480       PyObject *result = PyObject_CallMethod(pyCont,
 481                                              "create_component_instance",
 482                                              "ssl",
 483                                              aCompName.c_str(),
 484                                              instanceName.c_str(),
 485                                              studyId);
 486       string iors = PyString_AsString(result);
 487       Py_DECREF(result);
 488       SCRUTE(iors);
 489       Py_RELEASE_NEW_THREAD;
 490
 491       if( iors!="" )
 492       {
 493         CORBA::Object_var obj = _orb->string_to_object(iors.c_str());
 494         iobject = Engines::Component::_narrow( obj ) ;
 495         _listInstances_map[instanceName] = iobject;
 496       }
 497       return iobject._retn();
 498     }
 499
 500   //--- try C++
 501
 502 #ifndef WNT
 503   string impl_name = string ("lib") + genericRegisterName +string("Engine.so");
 504 #else
 505   string impl_name = genericRegisterName +string("Engine.dll");
 506 #endif
 507   if (_library_map.count(impl_name) == 0)
 508     {
 509       INFOS("shared library " << impl_name <<" must be loaded before creating instance");
 510       return Engines::Component::_nil() ;
 511     }
 512   else
 513     {
 514       void* handle = _library_map[impl_name];
 515       iobject = createInstance(genericRegisterName,
 516                                handle,
 517                                studyId);
 518       return iobject._retn();
 519     }
 520 }
 521
 522 //=============================================================================
 523 /*!
 524  *  CORBA method: Finds a servant instance of a component
 525  *  \param registeredName  Name of the component in Registry or Name Service,
 526  *                         without instance suffix number
 527  *  \param studyId         0 if instance is not associated to a study,
 528  *                         >0 otherwise (== study id)
 529  *  \return the first instance found with same studyId
 530  */
 531 //=============================================================================
 532
 533 Engines::Component_ptr
 534 Engines_Container_i::find_component_instance( const char* registeredName,
 535                                               CORBA::Long studyId)
 536 {
 537   Engines::Component_var anEngine = Engines::Component::_nil();
 538   map<string,Engines::Component_var>::iterator itm =_listInstances_map.begin();
 539   while (itm != _listInstances_map.end())
 540     {
 541       string instance = (*itm).first;
 542       SCRUTE(instance);
 543       if (instance.find(registeredName) == 0)
 544         {
 545           anEngine = (*itm).second;
 546           if (studyId == anEngine->getStudyId())
 547             {
 548               return anEngine._retn();
 549             }
 550         }
 551       itm++;
 552     }
 553   return anEngine._retn();
 554 }
 555
 556 //=============================================================================
 557 /*!
 558  *  CORBA method: find or create an instance of the component (servant),
 559  *  load a new component class (dynamic library) if required,
 560  *  ---- FOR COMPATIBILITY WITH 2.2 ----
 561  *  ---- USE ONLY FOR MULTISTUDY INSTANCES ! --------
 562  *  The servant registers itself to naming service and Registry.
 563  *  \param genericRegisterName  Name of the component to register
 564  *                              in Registry & Name Service
 565  *  \param componentName       Name of the constructed library of the component
 566  *  \return a loaded component
 567  */
 568 //=============================================================================
 569
 570 Engines::Component_ptr
 571 Engines_Container_i::load_impl( const char* genericRegisterName,
 572                                 const char* componentName )
 573 {
 574   string impl_name = string ("lib") + genericRegisterName +string("Engine.so");
 575   Engines::Component_var iobject = Engines::Component::_nil() ;
 576   if (load_component_Library(genericRegisterName))
 577     iobject = find_or_create_instance(genericRegisterName, impl_name);
 578   return iobject._retn();
 579 }
 580
 581
 582 //=============================================================================
 583 /*!
 584  *  CORBA method: Stops the component servant, and deletes all related objects
 585  *  \param component_i     Component to be removed
 586  */
 587 //=============================================================================
 588
 589 void Engines_Container_i::remove_impl(Engines::Component_ptr component_i)
 590 {
 591   ASSERT(! CORBA::is_nil(component_i));
 592   string instanceName = component_i->instanceName() ;
 593   MESSAGE("unload component " << instanceName);
 594   _numInstanceMutex.lock() ; // lock to be alone (stl container write)
 595   _listInstances_map.erase(instanceName);
 596   _numInstanceMutex.unlock() ;
 597   component_i->destroy() ;
 598   _NS->Destroy_Name(instanceName.c_str());
 599 }
 600
 601 //=============================================================================
 602 /*!
 603  *  CORBA method: Discharges unused libraries from the container.
 604  */
 605 //=============================================================================
 606
 607 void Engines_Container_i::finalize_removal()
 608 {
 609   MESSAGE("finalize unload : dlclose");
 610   _numInstanceMutex.lock(); // lock to be alone
 611                             // (see decInstanceCnt, load_component_Library)
 612   map<string, void *>::iterator ith;
 613   for (ith = _toRemove_map.begin(); ith != _toRemove_map.end(); ith++)
 614     {
 615       void *handle = (*ith).second;
 616       string impl_name= (*ith).first;
 617       if (handle)
 618         {
 619           SCRUTE(handle);
 620           SCRUTE(impl_name);
 621 //        dlclose(handle);                // SALOME unstable after ...
 622 //        _library_map.erase(impl_name);
 623         }
 624     }
 625   _toRemove_map.clear();
 626   _numInstanceMutex.unlock();
 627 }
 628
 629 //=============================================================================
 630 /*!
 631  *  CORBA method: Kill the container process with exit(0).
 632  *  To remove :  never returns !
 633  */
 634 //=============================================================================
 635
 636 bool Engines_Container_i::Kill_impl()
 637 {
 638   MESSAGE("Engines_Container_i::Kill() pid "<< getpid() << " containerName "
 639           << _containerName.c_str() << " machineName "
 640           << GetHostname().c_str());
 641   INFOS("===============================================================");
 642   INFOS("= REMOVE calls to Kill_impl in C++ container                  =");
 643   INFOS("===============================================================");
 644   //exit( 0 ) ;
 645   ASSERT(0);
 646   return false;
 647 }
 648
 649 //=============================================================================
 650 /*!
 651  *  CORBA method: get or create a fileRef object associated to a local file
 652  *  (a file on the computer on which runs the container server), which stores
 653  *  a list of (machine, localFileName) corresponding to copies already done.
 654  *
 655  *  \param  origFileName absolute path for a local file to copy on other
 656  *          computers
 657  *  \return a fileRef object associated to the file.
 658  */
 659 //=============================================================================
 660
 661 Engines::fileRef_ptr
 662 Engines_Container_i::createFileRef(const char* origFileName)
 663 {
 664   string origName(origFileName);
 665   Engines::fileRef_var theFileRef = Engines::fileRef::_nil();
 666
 667   if (origName[0] != '/')
 668     {
 669       INFOS("path of file to copy must be an absolute path begining with '/'");
 670       return Engines::fileRef::_nil();
 671     }
 672
 673   if (CORBA::is_nil(_fileRef_map[origName]))
 674     {
 675       CORBA::Object_var obj=_poa->id_to_reference(*_id);
 676       Engines::Container_var pCont = Engines::Container::_narrow(obj);
 677       fileRef_i* aFileRef = new fileRef_i(pCont, origFileName);
 678       theFileRef = Engines::fileRef::_narrow(aFileRef->_this());
 679       _numInstanceMutex.lock() ; // lock to be alone (stl container write)
 680       _fileRef_map[origName] = theFileRef;
 681       _numInstanceMutex.unlock() ;
 682     }
 683
 684   theFileRef =  Engines::fileRef::_duplicate(_fileRef_map[origName]);
 685   ASSERT(! CORBA::is_nil(theFileRef));
 686   return theFileRef._retn();
 687 }
 688
 689 //=============================================================================
 690 /*!
 691  *  CORBA method:
 692  *  \return a reference to the fileTransfer object
 693  */
 694 //=============================================================================
 695
 696 Engines::fileTransfer_ptr
 697 Engines_Container_i::getFileTransfer()
 698 {
 699   Engines::fileTransfer_var aFileTransfer
 700     = Engines::fileTransfer::_duplicate(_fileTransfer);
 701   return aFileTransfer._retn();
 702 }
 703
 704
 705 Engines::Salome_file_ptr
 706 Engines_Container_i::createSalome_file(const char* origFileName)
 707 {
 708   string origName(origFileName);
 709   if (CORBA::is_nil(_Salome_file_map[origName]))
 710     {
 711       Salome_file_i* aSalome_file = new Salome_file_i();
 712       aSalome_file->setContainer(Engines::Container::_duplicate(this->_this()));
 713       try
 714       {
 715         aSalome_file->setLocalFile(origFileName);
 716         aSalome_file->recvFiles();
 717       }
 718       catch (const SALOME::SALOME_Exception& e)
 719       {
 720         return Engines::Salome_file::_nil();
 721       }
 722
 723       Engines::Salome_file_var theSalome_file = Engines::Salome_file::_nil();
 724       theSalome_file = Engines::Salome_file::_narrow(aSalome_file->_this());
 725       _numInstanceMutex.lock() ; // lock to be alone (stl container write)
 726       _Salome_file_map[origName] = theSalome_file;
 727       _numInstanceMutex.unlock() ;
 728     }
 729
 730   Engines::Salome_file_ptr theSalome_file =
 731     Engines::Salome_file::_duplicate(_Salome_file_map[origName]);
 732   ASSERT(!CORBA::is_nil(theSalome_file));
 733   return theSalome_file;
 734 }
 735 //=============================================================================
 736 /*!
 737  *  C++ method: Finds an already existing servant instance of a component, or
 738  *              create an instance.
 739  *  ---- USE ONLY FOR MULTISTUDY INSTANCES ! --------
 740  *  \param genericRegisterName    Name of the component instance to register
 741  *                                in Registry & Name Service,
 742  *                                (without _inst_n suffix, like "COMPONENT")
 743  *  \param componentLibraryName   like "libCOMPONENTEngine.so"
 744  *  \return a loaded component
 745  *
 746  *  example with names:
 747  *  aGenRegisterName = COMPONENT (= first argument)
 748  *  impl_name = libCOMPONENTEngine.so (= second argument)
 749  *  _containerName = /Containers/cli76ce/FactoryServer
 750  *  factoryName = COMPONENTEngine_factory
 751  *  component_registerBase = /Containers/cli76ce/FactoryServer/COMPONENT
 752  *
 753  *  instanceName = COMPONENT_inst_1
 754  *  component_registerName = /Containers/cli76ce/FactoryServer/COMPONENT_inst_1
 755  */
 756 //=============================================================================
 757
 758 Engines::Component_ptr
 759 Engines_Container_i::find_or_create_instance(string genericRegisterName,
 760                                              string componentLibraryName)
 761 {
 762   string aGenRegisterName = genericRegisterName;
 763   string impl_name = componentLibraryName;
 764   if (_library_map.count(impl_name) == 0)
 765     {
 766       INFOS("shared library " << impl_name <<" must be loaded before creating instance");
 767       return Engines::Component::_nil() ;
 768     }
 769   else
 770     {
 771       // --- find a registered instance in naming service, or create
 772
 773       void* handle = _library_map[impl_name];
 774       string component_registerBase =
 775         _containerName + "/" + aGenRegisterName;
 776       Engines::Component_var iobject = Engines::Component::_nil() ;
 777       try
 778         {
 779           CORBA::Object_var obj =
 780             _NS->ResolveFirst( component_registerBase.c_str());
 781           if ( CORBA::is_nil( obj ) )
 782             {
 783               iobject = createInstance(genericRegisterName,
 784                                        handle,
 785                                        0); // force multiStudy instance here !
 786             }
 787           else
 788             {
 789               iobject = Engines::Component::_narrow( obj ) ;
 790               Engines_Component_i *servant =
 791                 dynamic_cast<Engines_Component_i*>
 792                 (_poa->reference_to_servant(iobject));
 793               ASSERT(servant)
 794               int studyId = servant->getStudyId();
 795               ASSERT (studyId >= 0);
 796               if (studyId == 0) // multiStudy instance, OK
 797                 {
 798                   // No ReBind !
 799                   MESSAGE(component_registerBase.c_str()<<" already bound");
 800                 }
 801               else // monoStudy instance: NOK
 802                 {
 803                   iobject = Engines::Component::_nil();
 804                   INFOS("load_impl & find_component_instance methods "
 805                         << "NOT SUITABLE for mono study components");
 806                 }
 807             }
 808         }
 809       catch (...)
 810         {
 811           INFOS( "Container_i::load_impl catched" ) ;
 812         }
 813       return iobject._retn();
 814     }
 815 }
 816
 817 //=============================================================================
 818 /*!
 819  *  C++ method: create a servant instance of a component.
 820  *  \param genericRegisterName    Name of the component instance to register
 821  *                                in Registry & Name Service,
 822  *                                (without _inst_n suffix, like "COMPONENT")
 823  *  \param handle                 loaded library handle
 824  *  \param studyId                0 for multiStudy instance,
 825  *                                study Id (>0) otherwise
 826  *  \return a loaded component
 827  *
 828  *  example with names:
 829  *  aGenRegisterName = COMPONENT (= first argument)
 830  *  _containerName = /Containers/cli76ce/FactoryServer
 831  *  factoryName = COMPONENTEngine_factory
 832  *  component_registerBase = /Containers/cli76ce/FactoryServer/COMPONENT
 833  *  instanceName = COMPONENT_inst_1
 834  *  component_registerName = /Containers/cli76ce/FactoryServer/COMPONENT_inst_1
 835  */
 836 //=============================================================================
 837
 838 Engines::Component_ptr
 839 Engines_Container_i::createInstance(string genericRegisterName,
 840                                     void *handle,
 841                                     int studyId)
 842 {
 843   // --- find the factory
 844
 845   string aGenRegisterName = genericRegisterName;
 846   string factory_name = aGenRegisterName + string("Engine_factory");
 847   SCRUTE(factory_name) ;
 848
 849   typedef  PortableServer::ObjectId * (*FACTORY_FUNCTION)
 850     (CORBA::ORB_ptr,
 851      PortableServer::POA_ptr,
 852      PortableServer::ObjectId *,
 853      const char *,
 854      const char *) ;
 855
 856 #ifndef WNT
 857   FACTORY_FUNCTION Component_factory = (FACTORY_FUNCTION)dlsym( handle, factory_name.c_str() );
 858 #else
 859   FACTORY_FUNCTION Component_factory = (FACTORY_FUNCTION)GetProcAddress( (HINSTANCE)handle, factory_name.c_str() );
 860 #endif
 861
 862   if ( !Component_factory )
 863   {
 864       INFOS( "Can't resolve symbol: " + factory_name );
 865 #ifndef WNT
 866       SCRUTE( dlerror() );
 867 #endif
 868       return Engines::Component::_nil() ;
 869   }
 870
 871   // --- create instance
 872
 873   Engines::Component_var iobject = Engines::Component::_nil() ;
 874
 875   try
 876     {
 877       _numInstanceMutex.lock() ; // lock on the instance number
 878       _numInstance++ ;
 879       int numInstance = _numInstance ;
 880       _numInstanceMutex.unlock() ;
 881
 882       char aNumI[12];
 883       sprintf( aNumI , "%d" , numInstance ) ;
 884       string instanceName = aGenRegisterName + "_inst_" + aNumI ;
 885       string component_registerName =
 886         _containerName + "/" + instanceName;
 887
 888       // --- Instanciate required CORBA object
 889
 890       PortableServer::ObjectId *id ; //not owner, do not delete (nore use var)
 891       id = (Component_factory) ( _orb, _poa, _id, instanceName.c_str(),
 892                                  aGenRegisterName.c_str() ) ;
 893       if (id == NULL)
 894         return iobject._retn();
 895
 896       // --- get reference & servant from id
 897
 898       CORBA::Object_var obj = _poa->id_to_reference(*id);
 899       iobject = Engines::Component::_narrow( obj ) ;
 900
 901       Engines_Component_i *servant =
 902         dynamic_cast<Engines_Component_i*>(_poa->reference_to_servant(iobject));
 903       ASSERT(servant);
 904       //SCRUTE(servant->pd_refCount);
 905       servant->_remove_ref(); // compensate previous id_to_reference
 906       //SCRUTE(servant->pd_refCount);
 907       _numInstanceMutex.lock() ; // lock to be alone (stl container write)
 908       _listInstances_map[instanceName] = iobject;
 909       _cntInstances_map[aGenRegisterName] += 1;
 910       _numInstanceMutex.unlock() ;
 911       SCRUTE(aGenRegisterName);
 912       SCRUTE(_cntInstances_map[aGenRegisterName]);
 913       //SCRUTE(servant->pd_refCount);
 914       bool ret_studyId = servant->setStudyId(studyId);
 915       ASSERT(ret_studyId);
 916
 917       // --- register the engine under the name
 918       //     containerName(.dir)/instanceName(.object)
 919
 920       _NS->Register( iobject , component_registerName.c_str() ) ;
 921       MESSAGE( component_registerName.c_str() << " bound" ) ;
 922     }
 923   catch (...)
 924     {
 925       INFOS( "Container_i::createInstance exception catched" ) ;
 926     }
 927   return iobject._retn();
 928 }
 929
 930 //=============================================================================
 931 /*!
 932  *
 933  */
 934 //=============================================================================
 935
 936 void Engines_Container_i::decInstanceCnt(string genericRegisterName)
 937 {
 938   if(_cntInstances_map.count(genericRegisterName)==0)
 939     return;
 940   string aGenRegisterName =genericRegisterName;
 941   MESSAGE("Engines_Container_i::decInstanceCnt " << aGenRegisterName);
 942   ASSERT(_cntInstances_map[aGenRegisterName] > 0);
 943   _numInstanceMutex.lock(); // lock to be alone
 944                             // (see finalize_removal, load_component_Library)
 945   _cntInstances_map[aGenRegisterName] -= 1;
 946   SCRUTE(_cntInstances_map[aGenRegisterName]);
 947   if (_cntInstances_map[aGenRegisterName] == 0)
 948     {
 949       string impl_name =
 950         Engines_Component_i::GetDynLibraryName(aGenRegisterName.c_str());
 951       SCRUTE(impl_name);
 952       void* handle = _library_map[impl_name];
 953       ASSERT(handle);
 954       _toRemove_map[impl_name] = handle;
 955     }
 956   _numInstanceMutex.unlock();
 957 }
 958
 959 //=============================================================================
 960 /*!
 961  *  Retrieves only with container naming convention if it is a python container
 962  */
 963 //=============================================================================
 964
 965 bool Engines_Container_i::isPythonContainer(const char* ContainerName)
 966 {
 967   bool ret=false;
 968   int len=strlen(ContainerName);
 969   if(len>=2)
 970     if(strcmp(ContainerName+len-2,"Py")==0)
 971       ret=true;
 972   return ret;
 973 }
 974
 975 //=============================================================================
 976 /*!
 977  *
 978  */
 979 //=============================================================================
 980
 981 void ActSigIntHandler()
 982 {
 983 #ifndef WNT
 984   struct sigaction SigIntAct ;
 985   SigIntAct.sa_sigaction = &SigIntHandler ;
 986   SigIntAct.sa_flags = SA_SIGINFO ;
 987 #endif
 988
 989 // DEBUG 03.02.2005 : the first parameter of sigaction is not a mask of signals
 990 // (SIGINT | SIGUSR1) :
 991 // it must be only one signal ===> one call for SIGINT
 992 // and an other one for SIGUSR1
 993
 994 #ifndef WNT
 995   if ( sigaction( SIGINT , &SigIntAct, NULL ) )
 996     {
 997       perror("SALOME_Container main ") ;
 998       exit(0) ;
 999     }
1000   if ( sigaction( SIGUSR1 , &SigIntAct, NULL ) )
1001     {
1002       perror("SALOME_Container main ") ;
1003       exit(0) ;
1004     }
1005   if ( sigaction( SIGUSR2 , &SigIntAct, NULL ) )
1006     {
1007       perror("SALOME_Container main ") ;
1008       exit(0) ;
1009     }
1010
1011   //PAL9042 JR : during the execution of a Signal Handler (and of methods called through Signal Handlers)
1012   //             use of streams (and so on) should never be used because :
1013   //             streams of C++ are naturally thread-safe and use pthread_mutex_lock ===>
1014   //             A stream operation may be interrupted by a signal and if the Handler use stream we
1015   //             may have a "Dead-Lock" ===HangUp
1016   //==INFOS is commented
1017   //  INFOS(pthread_self() << "SigIntHandler activated") ;
1018
1019 #else
1020   signal( SIGINT, SigIntHandler );
1021   signal( SIGUSR1, SigIntHandler );
1022 #endif
1023
1024 }
1025
1026 void SetCpuUsed() ;
1027 void CallCancelThread() ;
1028
1029 #ifndef WNT
1030 void SigIntHandler(int what ,
1031                    siginfo_t * siginfo ,
1032                    void * toto )
1033 {
1034   //PAL9042 JR : during the execution of a Signal Handler (and of methods called through Signal Handlers)
1035   //             use of streams (and so on) should never be used because :
1036   //             streams of C++ are naturally thread-safe and use pthread_mutex_lock ===>
1037   //             A stream operation may be interrupted by a signal and if the Handler use stream we
1038   //             may have a "Dead-Lock" ===HangUp
1039   //==MESSAGE is commented
1040   //  MESSAGE(pthread_self() << "SigIntHandler what     " << what << endl
1041   //          << "              si_signo " << siginfo->si_signo << endl
1042   //          << "              si_code  " << siginfo->si_code << endl
1043   //          << "              si_pid   " << siginfo->si_pid) ;
1044
1045   if ( _Sleeping )
1046     {
1047       _Sleeping = false ;
1048       //     MESSAGE("SigIntHandler END sleeping.") ;
1049       return ;
1050     }
1051   else
1052     {
1053       ActSigIntHandler() ;
1054       if ( siginfo->si_signo == SIGUSR1 )
1055         {
1056           SetCpuUsed() ;
1057         }
1058       else if ( siginfo->si_signo == SIGUSR2 )
1059         {
1060           CallCancelThread() ;
1061         }
1062       else
1063         {
1064           _Sleeping = true ;
1065           //      MESSAGE("SigIntHandler BEGIN sleeping.") ;
1066           int count = 0 ;
1067           while( _Sleeping )
1068             {
1069               sleep( 1 ) ;
1070               count += 1 ;
1071             }
1072           //      MESSAGE("SigIntHandler LEAVE sleeping after " << count << " s.") ;
1073         }
1074       return ;
1075     }
1076 }
1077 #else // Case WNT
1078 void SigIntHandler( int what )
1079 {
1080 #ifndef WNT
1081   MESSAGE( pthread_self() << "SigIntHandler what     " << what << endl );
1082 #else
1083   MESSAGE( "SigIntHandler what     " << what << endl );
1084 #endif
1085   if ( _Sleeping )
1086     {
1087       _Sleeping = false ;
1088       MESSAGE("SigIntHandler END sleeping.") ;
1089       return ;
1090     }
1091   else
1092     {
1093       ActSigIntHandler() ;
1094       if ( what == SIGUSR1 )
1095         {
1096           SetCpuUsed() ;
1097         }
1098       else
1099         {
1100           _Sleeping = true ;
1101           MESSAGE("SigIntHandler BEGIN sleeping.") ;
1102           int count = 0 ;
1103           while( _Sleeping )
1104             {
1105               Sleep( 1000 ) ;
1106               count += 1 ;
1107             }
1108           MESSAGE("SigIntHandler LEAVE sleeping after " << count << " s.") ;
1109         }
1110       return ;
1111     }
1112 }
1113 #endif