bin/runSalome.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (C) 2005  OPEN CASCADE, CEA, EDF R&D, LEG
   4 #           PRINCIPIA R&D, EADS CCR, Lip6, BV, CEDRAT
   5 # This library is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU Lesser General Public
   7 # License as published by the Free Software Foundation; either
   8 # version 2.1 of the License.
   9 #
  10 # This library is distributed in the hope that it will be useful
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 # Lesser General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU Lesser General Public
  16 # License along with this library; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 #
  19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 #
  21
  22 import sys, os, string, glob, time, pickle
  23 import orbmodule
  24
  25 process_id = {}
  26
  27 # salome_subdir variable is used for composing paths like $KERNEL_ROOT_DIR/share/salome/resources/kernel, etc.
  28 # before moving to SUIT-based gui, instead of salome_subdir there was args['appname'] used.
  29 # but after - 'appname'  = "SalomeApp", so using it in making the subdirectory is an error.
  30 salome_subdir = "salome"
  31
  32 # -----------------------------------------------------------------------------
  33
  34 def add_path(directory, variable_name):
  35     """Function helper to add environment variables"""
  36     if not os.environ.has_key(variable_name):
  37         os.environ[variable_name] = ""
  38         pass
  39     if os.path.exists(directory):
  40         newpath=[]
  41         for _dir in os.environ[variable_name].split(":"):
  42             if os.path.exists(_dir):
  43                 if not os.path.samefile(_dir, directory):
  44                   newpath.append(_dir)
  45             else:
  46                 if os.path.abspath(_dir) != os.path.abspath(directory):
  47                   newpath.append(_dir)
  48             pass
  49         import string
  50         newpath[:0] = [ directory ]
  51         newpath = string.join(newpath,":")
  52         os.environ[variable_name] = newpath
  53         if variable_name == "PYTHONPATH":
  54             sys.path[:0] = [directory]
  55
  56 # -----------------------------------------------------------------------------
  57
  58 def get_lib_dir():
  59     if os.path.exists("/usr/lib64/libc.so"):
  60         return "lib64"
  61     return "lib"
  62
  63 # -----------------------------------------------------------------------------
  64
  65 def get_config():
  66     """
  67     Get list of modules, paths.
  68
  69     Read args from launch configure xml file and command line options.
  70     Check variables <module>_ROOT_DIR and set list of used modules.
  71     Return args, modules_list, modules_root_dir
  72     """
  73
  74     # read args from launch configure xml file and command line options
  75
  76     import launchConfigureParser
  77     args = launchConfigureParser.args
  78
  79     # Check variables <module>_ROOT_DIR
  80     # and set list of used modules (without KERNEL)
  81
  82     modules_list = []
  83     if args.has_key("modules"):
  84         modules_list += args["modules"]
  85     # KERNEL must be last in the list to locate it at the first place in PATH
  86     if args["gui"] :
  87         modules_list[:0] = ["GUI"]
  88     modules_list[:0] = ["KERNEL"]
  89     modules_list.reverse()
  90
  91     modules_root_dir = {}
  92
  93     to_remove_list=[]
  94     for module in modules_list :
  95         module_variable=module+"_ROOT_DIR"
  96         if not os.environ.has_key(module_variable):
  97             print "*******************************************************"
  98             print "*"
  99             print "* Environment variable",module_variable,"must be set"
 100             print "* Module", module, "will be not available"
 101             print "*"
 102             print "********************************************************"
 103             to_remove_list.append(module)
 104             continue
 105             pass
 106         module_root_dir = os.environ[module_variable]
 107         modules_root_dir[module]=module_root_dir
 108
 109     for to_remove in to_remove_list:
 110         modules_list.remove(to_remove)
 111
 112     while "KERNEL" in modules_list:
 113         modules_list.remove("KERNEL")
 114         pass
 115
 116     while "GUI" in modules_list:
 117         modules_list.remove("GUI")
 118         pass
 119
 120     if "SUPERV" in modules_list and not 'superv' in args['standalone']:
 121         args['standalone'].append("superv")
 122         pass
 123
 124     return args, modules_list, modules_root_dir
 125
 126 # -----------------------------------------------------------------------------
 127
 128 def set_env(args, modules_list, modules_root_dir):
 129     """Add to the PATH-variables modules specific paths"""
 130
 131     python_version="python%d.%d" % sys.version_info[0:2]
 132     modules_root_dir_list = []
 133     if args["gui"] :
 134         modules_list = modules_list[:] + ["GUI"]
 135     modules_list = modules_list[:] + ["KERNEL"]
 136     for module in modules_list :
 137         if modules_root_dir.has_key(module):
 138             module_root_dir = modules_root_dir[module]
 139             modules_root_dir_list[:0] = [module_root_dir]
 140             add_path(os.path.join(module_root_dir,get_lib_dir(),salome_subdir),
 141                      "LD_LIBRARY_PATH")
 142             add_path(os.path.join(module_root_dir,"bin",salome_subdir),
 143                      "PATH")
 144             if os.path.exists(module_root_dir + "/examples") :
 145                 add_path(os.path.join(module_root_dir,"examples"),
 146                          "PYTHONPATH")
 147                 pass
 148             add_path(os.path.join(module_root_dir,"bin",salome_subdir),
 149                      "PYTHONPATH")
 150             add_path(os.path.join(module_root_dir,get_lib_dir(),
 151                                   python_version,"site-packages",
 152                                   salome_subdir),
 153                      "PYTHONPATH")
 154             add_path(os.path.join(module_root_dir,get_lib_dir(),salome_subdir),
 155                      "PYTHONPATH")
 156             add_path(os.path.join(module_root_dir,get_lib_dir(),
 157                                   python_version,"site-packages",
 158                                   salome_subdir,
 159                                   "shared_modules"),
 160                      "PYTHONPATH")
 161             pass
 162         pass
 163
 164
 165     os.environ["SALOMEPATH"]=":".join(modules_root_dir_list)
 166
 167     # set trace environment variable
 168
 169     if not os.environ.has_key("SALOME_trace"):
 170         os.environ["SALOME_trace"]="local"
 171     if args['file']:
 172         os.environ["SALOME_trace"]="file:"+args['file'][0]
 173     if args['logger']:
 174         os.environ["SALOME_trace"]="with_logger"
 175
 176     # set environment for SMESH plugins
 177
 178     if "SMESH" in modules_list:
 179         os.environ["SMESH_MeshersList"]="StdMeshers"
 180         if not os.environ.has_key("SALOME_StdMeshersResources"):
 181             os.environ["SALOME_StdMeshersResources"] \
 182             = modules_root_dir["SMESH"]+"/share/"+args["appname"]+"/resources/smesh"
 183             pass
 184         if args.has_key("SMESH_plugins"):
 185             for plugin in args["SMESH_plugins"]:
 186                 plugin_root = ""
 187                 if os.environ.has_key(plugin+"_ROOT_DIR"):
 188                     plugin_root = os.environ[plugin+"_ROOT_DIR"]
 189                 else:
 190                     # workaround to avoid modifications of existing environment
 191                     if os.environ.has_key(plugin.upper()+"_ROOT_DIR"):
 192                         plugin_root = os.environ[plugin.upper()+"_ROOT_DIR"]
 193                         pass
 194                     pass
 195                 if plugin_root != "":
 196                     os.environ["SMESH_MeshersList"] \
 197                     = os.environ["SMESH_MeshersList"]+":"+plugin
 198                     if not os.environ.has_key("SALOME_"+plugin+"Resources"):
 199                         os.environ["SALOME_"+plugin+"Resources"] \
 200                         = plugin_root+"/share/"+args["appname"]+"/resources/"+plugin.lower()
 201                     add_path(os.path.join(plugin_root,get_lib_dir(),python_version,
 202                                           "site-packages",salome_subdir),
 203                              "PYTHONPATH")
 204                     add_path(os.path.join(plugin_root,get_lib_dir(),salome_subdir),
 205                              "PYTHONPATH")
 206                     add_path(os.path.join(plugin_root,get_lib_dir(),salome_subdir),
 207                              "LD_LIBRARY_PATH")
 208                     add_path(os.path.join(plugin_root,"bin",salome_subdir),
 209                              "PYTHONPATH")
 210                     add_path(os.path.join(plugin_root,"bin",salome_subdir),
 211                              "PATH")
 212             pass
 213         pass
 214
 215     # set environment for SUPERV module
 216     os.environ["ENABLE_MACRO_NODE"]="1"
 217     # set resources variables if not yet set
 218     # Done now by launchConfigureParser.py
 219     #if os.getenv("GUI_ROOT_DIR"):
 220         #if not os.getenv("SalomeAppConfig"): os.environ["SalomeAppConfig"] =  os.getenv("GUI_ROOT_DIR") + "/share/salome/resources/gui"
 221
 222     # set CSF_PluginDefaults variable only if it is not customized
 223     # by the user
 224     if not os.getenv("CSF_PluginDefaults"):
 225         os.environ["CSF_PluginDefaults"] \
 226         = os.path.join(modules_root_dir["KERNEL"],"share",
 227                        salome_subdir,"resources","kernel")
 228     os.environ["CSF_SALOMEDS_ResourcesDefaults"] \
 229     = os.path.join(modules_root_dir["KERNEL"],"share",
 230                    salome_subdir,"resources","kernel")
 231
 232     if "GEOM" in modules_list:
 233         print "GEOM OCAF Resources"
 234         os.environ["CSF_GEOMDS_ResourcesDefaults"] \
 235         = os.path.join(modules_root_dir["GEOM"],"share",
 236                        salome_subdir,"resources","geom")
 237         print "GEOM Shape Healing Resources"
 238         os.environ["CSF_ShHealingDefaults"] \
 239         = os.path.join(modules_root_dir["GEOM"],"share",
 240                        salome_subdir,"resources","geom")
 241
 242 # -----------------------------------------------------------------------------
 243
 244 from killSalome import killAllPorts
 245
 246 def killLocalPort():
 247     """
 248     kill servers from a previous SALOME exection, if needed,
 249     on the CORBA port given in args of runSalome
 250     """
 251
 252     from killSalomeWithPort import killMyPort
 253     my_port=str(args['port'])
 254     try:
 255         killMyPort(my_port)
 256     except:
 257         print "problem in killLocalPort()"
 258         pass
 259     pass
 260
 261 def givenPortKill(port):
 262     """
 263     kill servers from a previous SALOME exection, if needed,
 264     on the same CORBA port
 265     """
 266
 267     from killSalomeWithPort import killMyPort
 268     my_port=port
 269     try:
 270         killMyPort(my_port)
 271     except:
 272         print "problem in LocalPortKill(), killMyPort("<<port<<")"
 273         pass
 274     pass
 275
 276 def kill_salome(args):
 277     """
 278     Kill servers from previous SALOME executions, if needed;
 279     depending on args 'killall' or 'portkill', kill all executions,
 280     or only execution on the same CORBA port
 281     """
 282
 283     if args['killall']:
 284         killAllPorts()
 285     elif args['portkill']:
 286         givenPortKill(str(args['port']))
 287
 288 # -----------------------------------------------------------------------------
 289 #
 290 # Definition des classes d'objets pour le lancement des Server CORBA
 291 #
 292
 293 class Server:
 294     """Generic class for CORBA server launch"""
 295
 296     def initArgs(self):
 297         self.PID=None
 298         self.CMD=[]
 299         self.ARGS=[]
 300         if self.args['xterm']:
 301             self.ARGS=['xterm', '-iconic', '-sb', '-sl', '500', '-hold']
 302
 303     def __init__(self,args):
 304         self.args=args
 305         self.initArgs()
 306
 307
 308     def run(self):
 309         global process_id
 310         myargs=self.ARGS
 311         if self.args['xterm']:
 312             # (Debian) send LD_LIBRARY_PATH to children shells (xterm)
 313             env_ld_library_path=['env', 'LD_LIBRARY_PATH='
 314                                  + os.getenv("LD_LIBRARY_PATH")]
 315             myargs = myargs +['-T']+self.CMD[:1]+['-e'] + env_ld_library_path
 316         command = myargs + self.CMD
 317         print "command = ", command
 318         pid = os.spawnvp(os.P_NOWAIT, command[0], command)
 319         process_id[pid]=self.CMD
 320         self.PID = pid
 321
 322
 323 class InterpServer(Server):
 324     def __init__(self,args):
 325         self.args=args
 326         env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
 327         self.CMD=['xterm', '-e']+ env_ld_library_path + ['python']
 328         #self.CMD=['xterm', '-e', 'python']
 329
 330     def run(self):
 331         global process_id
 332         command = self.CMD
 333         #print "command = ", command
 334         pid = os.spawnvp(os.P_NOWAIT, command[0], command)
 335         process_id[pid]=self.CMD
 336         self.PID = pid
 337
 338 # ---
 339
 340 class CatalogServer(Server):
 341     def __init__(self,args):
 342         self.args=args
 343         self.initArgs()
 344         self.SCMD1=['SALOME_ModuleCatalog_Server','-common']
 345         self.SCMD2=[]
 346         home_dir=os.getenv('HOME')
 347         if home_dir is not None:
 348             self.SCMD2=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 349
 350     def setpath(self,modules_list,modules_root_dir):
 351         cata_path=[]
 352         list_modules = modules_list[:]
 353         list_modules.reverse()
 354         if self.args["gui"] :
 355             list_modules = ["KERNEL", "GUI"] + list_modules
 356         else :
 357             list_modules = ["KERNEL"] + list_modules
 358         for module in list_modules:
 359             if modules_root_dir.has_key(module):
 360                 module_root_dir=modules_root_dir[module]
 361                 module_cata=module+"Catalog.xml"
 362                 #print "   ", module_cata
 363                 if os.path.exists(os.path.join(module_root_dir,
 364                                                "share",salome_subdir,
 365                                                "resources",module.lower(),
 366                                                module_cata)):
 367                     cata_path.extend(
 368                         glob.glob(os.path.join(module_root_dir,
 369                                                "share",salome_subdir,
 370                                                "resources",module.lower(),
 371                                                module_cata)))
 372                 else:
 373                     cata_path.extend(
 374                         glob.glob(os.path.join(module_root_dir,
 375                                                "share",salome_subdir,
 376                                                "resources",
 377                                                module_cata)))
 378                 pass
 379             pass
 380         self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 381
 382 # ---
 383
 384 class SalomeDSServer(Server):
 385     def __init__(self,args):
 386         self.args=args
 387         self.initArgs()
 388         self.CMD=['SALOMEDS_Server']
 389
 390 # ---
 391
 392 class RegistryServer(Server):
 393     def __init__(self,args):
 394         self.args=args
 395         self.initArgs()
 396         self.CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 397
 398 # ---
 399
 400 class ContainerCPPServer(Server):
 401     def __init__(self,args):
 402         self.args=args
 403         self.initArgs()
 404         self.CMD=['SALOME_Container','FactoryServer']
 405
 406 # ---
 407
 408 class ContainerPYServer(Server):
 409     def __init__(self,args):
 410         self.args=args
 411         self.initArgs()
 412         self.CMD=['SALOME_ContainerPy.py','FactoryServerPy']
 413
 414 # ---
 415
 416 class ContainerSUPERVServer(Server):
 417     def __init__(self,args):
 418         self.args=args
 419         self.initArgs()
 420         self.CMD=['SALOME_Container','SuperVisionContainer']
 421
 422 # ---
 423
 424 class LoggerServer(Server):
 425     def __init__(self,args):
 426         self.args=args
 427         self.initArgs()
 428         self.CMD=['SALOME_Logger_Server', 'logger.log']
 429
 430 # ---
 431
 432 class SessionServer(Server):
 433     def __init__(self,args):
 434         self.args = args.copy()
 435         # Bug 11512 (Problems with runSalome --xterm on Mandrake and Debian Sarge)
 436         self.args['xterm']=0
 437         #
 438         self.initArgs()
 439         self.SCMD1=['SALOME_Session_Server']
 440         self.SCMD2=[]
 441         if 'registry' in self.args['embedded']:
 442             self.SCMD1+=['--with','Registry',
 443                          '(','--salome_session','theSession',')']
 444         if 'moduleCatalog' in self.args['embedded']:
 445             self.SCMD1+=['--with','ModuleCatalog','(','-common']
 446             home_dir=os.getenv('HOME')
 447             if home_dir is not None:
 448                 self.SCMD2+=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 449             self.SCMD2+=[')']
 450         if 'study' in self.args['embedded']:
 451             self.SCMD2+=['--with','SALOMEDS','(',')']
 452         if 'cppContainer' in self.args['embedded']:
 453             self.SCMD2+=['--with','Container','(','FactoryServer',')']
 454         if 'SalomeAppEngine' in self.args['embedded']:
 455             self.SCMD2+=['--with','SalomeAppEngine','(',')']
 456
 457         if 'cppContainer' in self.args['standalone'] or 'cppContainer' in self.args['embedded']:
 458             self.SCMD2+=['CPP']
 459         if 'pyContainer' in self.args['standalone'] or 'pyContainer' in self.args['embedded']:
 460             self.SCMD2+=['PY']
 461         if 'supervContainer' in self.args['containers'] or 'supervContainer' in self.args['standalone']:
 462             self.SCMD2+=['SUPERV']
 463         if self.args['gui']:
 464             self.SCMD2+=['GUI']
 465         if self.args['splash'] and self.args['gui']:
 466             self.SCMD2+=['SPLASH']
 467         if self.args['noexcepthandler']:
 468             self.SCMD2+=['noexcepthandler']
 469         if self.args.has_key('modules'):
 470             self.SCMD2+=['--modules (']
 471             for mod in self.args['modules']:
 472                 self.SCMD2+=[mod + ':']
 473             self.SCMD2+=[')']
 474
 475     def setpath(self,modules_list,modules_root_dir):
 476         cata_path=[]
 477         list_modules = modules_list[:]
 478         list_modules.reverse()
 479         if self.args["gui"] :
 480             list_modules = ["KERNEL", "GUI"] + list_modules
 481         else :
 482             list_modules = ["KERNEL"] + list_modules
 483         for module in list_modules:
 484             module_root_dir=modules_root_dir[module]
 485             module_cata=module+"Catalog.xml"
 486             #print "   ", module_cata
 487             if os.path.exists(os.path.join(module_root_dir,
 488                                            "share",salome_subdir,
 489                                            "resources",module.lower(),
 490                                            module_cata)):
 491                 cata_path.extend(
 492                     glob.glob(os.path.join(module_root_dir,"share",
 493                                            salome_subdir,"resources",
 494                                            module.lower(),module_cata)))
 495             else:
 496                 cata_path.extend(
 497                     glob.glob(os.path.join(module_root_dir,"share",
 498                                            salome_subdir,"resources",
 499                                            module_cata)))
 500             pass
 501         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 502             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 503         else:
 504             self.CMD=self.SCMD1 + self.SCMD2
 505
 506 # ---
 507
 508 class ContainerManagerServer(Server):
 509     def __init__(self,args):
 510         self.args=args
 511         self.initArgs()
 512         self.SCMD1=['SALOME_ContainerManagerServer']
 513         self.SCMD2=[]
 514         if args["gui"] :
 515             if 'registry' in self.args['embedded']:
 516                 self.SCMD1+=['--with','Registry',
 517                              '(','--salome_session','theSession',')']
 518             if 'moduleCatalog' in self.args['embedded']:
 519                 self.SCMD1+=['--with','ModuleCatalog','(','-common']
 520                 self.SCMD2+=['-personal',
 521                              '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 522             if 'study' in self.args['embedded']:
 523                 self.SCMD2+=['--with','SALOMEDS','(',')']
 524             if 'cppContainer' in self.args['embedded']:
 525                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 526
 527     def setpath(self,modules_list,modules_root_dir):
 528         cata_path=[]
 529         list_modules = modules_list[:]
 530         list_modules.reverse()
 531         if self.args["gui"] :
 532             list_modules = ["GUI"] + list_modules
 533         for module in ["KERNEL"] + list_modules:
 534             if modules_root_dir.has_key(module):
 535                 module_root_dir=modules_root_dir[module]
 536                 module_cata=module+"Catalog.xml"
 537                 #print "   ", module_cata
 538                 if os.path.exists(os.path.join(module_root_dir,
 539                                                "share",salome_subdir,
 540                                                "resources",module.lower(),
 541                                                module_cata)):
 542                     cata_path.extend(
 543                         glob.glob(os.path.join(module_root_dir,"share",
 544                                                self.args['appname'],"resources",
 545                                                module.lower(),module_cata)))
 546                 else:
 547                     cata_path.extend(
 548                         glob.glob(os.path.join(module_root_dir,"share",
 549                                                self.args['appname'],"resources",
 550                                                module_cata)))
 551                 pass
 552             pass
 553         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 554             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 555         else:
 556             self.CMD=self.SCMD1 + self.SCMD2
 557
 558 class NotifyServer(Server):
 559     def __init__(self,args,modules_root_dir):
 560         self.args=args
 561         self.initArgs()
 562         self.modules_root_dir=modules_root_dir
 563         myLogName = os.environ["LOGNAME"]
 564         self.CMD=['notifd','-c',
 565                   self.modules_root_dir["KERNEL"] +'/share/salome/resources/kernel/channel.cfg',
 566                   '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior',
 567                   '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior',
 568                   '-DReportLogFile=/tmp/'+myLogName+'_notifd.report',
 569                   '-DDebugLogFile=/tmp/'+myLogName+'_notifd.debug',
 570                   ]
 571
 572 #
 573 # -----------------------------------------------------------------------------
 574
 575 def startGUI():
 576     """Salome Session Graphic User Interface activation"""
 577     import Engines
 578     import SALOME
 579     import SALOMEDS
 580     import SALOME_ModuleCatalog
 581     reload(Engines)
 582     reload(SALOME)
 583     reload(SALOMEDS)
 584     import SALOME_Session_idl
 585     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 586     session.GetInterface()
 587
 588 # -----------------------------------------------------------------------------
 589
 590 def startSalome(args, modules_list, modules_root_dir):
 591     """Launch all SALOME servers requested by args"""
 592     init_time = os.times()
 593
 594     print "startSalome ", args
 595
 596     #
 597     # Initialisation ORB et Naming Service
 598     #
 599
 600     clt=orbmodule.client()
 601
 602     # (non obligatoire) Lancement Logger Server
 603     # et attente de sa disponibilite dans le naming service
 604     #
 605
 606     if args['logger']:
 607         myServer=LoggerServer(args)
 608         myServer.run()
 609         clt.waitLogger("Logger")
 610
 611     # Notify Server launch
 612     #
 613
 614     print "Notify Server to launch"
 615
 616     myServer=NotifyServer(args,modules_root_dir)
 617     myServer.run()
 618
 619     # Lancement Session Server (to show splash ASAP)
 620     #
 621
 622     if args["gui"]:
 623         mySessionServ = SessionServer(args)
 624         mySessionServ.setpath(modules_list,modules_root_dir)
 625         mySessionServ.run()
 626
 627     #
 628     # Lancement Registry Server,
 629     # attente de la disponibilite du Registry dans le Naming Service
 630     #
 631
 632     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
 633         myServer=RegistryServer(args)
 634         myServer.run()
 635         clt.waitNSPID("/Registry",myServer.PID)
 636
 637     #
 638     # Lancement Catalog Server,
 639     # attente de la disponibilite du Catalog Server dans le Naming Service
 640     #
 641
 642
 643     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 644         cataServer=CatalogServer(args)
 645         cataServer.setpath(modules_list,modules_root_dir)
 646         cataServer.run()
 647         import SALOME_ModuleCatalog
 648         clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 649
 650     #
 651     # Lancement SalomeDS Server,
 652     # attente de la disponibilite du SalomeDS dans le Naming Service
 653     #
 654
 655     #print "ARGS = ",args
 656     if ('study' not in args['embedded']) | (args["gui"] == 0):
 657         print "RunStudy"
 658         myServer=SalomeDSServer(args)
 659         myServer.run()
 660         clt.waitNSPID("/myStudyManager",myServer.PID)
 661
 662     #
 663     # Lancement ContainerManagerServer
 664     #
 665
 666     myCmServer = ContainerManagerServer(args)
 667     myCmServer.setpath(modules_list,modules_root_dir)
 668     myCmServer.run()
 669
 670
 671     from Utils_Identity import getShortHostName
 672
 673     if os.getenv("HOSTNAME") == None:
 674         if os.getenv("HOST") == None:
 675             os.environ["HOSTNAME"]=getShortHostName()
 676         else:
 677             os.environ["HOSTNAME"]=os.getenv("HOST")
 678
 679     theComputer = getShortHostName()
 680
 681     #
 682     # Lancement Container C++ local,
 683     # attente de la disponibilite du Container C++ local dans le Naming Service
 684     #
 685
 686     if 'cppContainer' in args['standalone']:
 687         myServer=ContainerCPPServer(args)
 688         myServer.run()
 689         clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 690
 691     #
 692     # Lancement Container Python local,
 693     # attente de la disponibilite du Container Python local
 694     # dans le Naming Service
 695     #
 696
 697     if 'pyContainer' in args['standalone']:
 698         myServer=ContainerPYServer(args)
 699         myServer.run()
 700         clt.waitNSPID("/Containers/" + theComputer + "/FactoryServerPy",myServer.PID)
 701
 702     #
 703     # Lancement Container Supervision local,
 704     # attente de la disponibilite du Container Supervision local
 705     # dans le Naming Service
 706     #
 707
 708     if 'supervContainer' in args['standalone']:
 709         myServer=ContainerSUPERVServer(args)
 710         myServer.run()
 711         clt.waitNSPID("/Containers/" + theComputer + "/SuperVisionContainer",myServer.PID)
 712
 713     #
 714     # Attente de la disponibilite du Session Server dans le Naming Service
 715     #
 716
 717     if args["gui"]:
 718 ##----------------
 719         import Engines
 720         import SALOME
 721         import SALOMEDS
 722         import SALOME_ModuleCatalog
 723         reload(Engines)
 724         reload(SALOME)
 725         reload(SALOMEDS)
 726         import SALOME_Session_idl
 727         session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
 728
 729     end_time = os.times()
 730     print
 731     print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 732                                                          - init_time[4])
 733
 734     # ASV start GUI without Loader
 735     #if args['gui']:
 736     #    session.GetInterface()
 737
 738     #
 739     # additionnal external python interpreters
 740     #
 741     nbaddi=0
 742
 743     try:
 744         if 'interp' in args:
 745             if args['interp']:
 746                 nbaddi = int(args['interp'][0])
 747     except:
 748         import traceback
 749         traceback.print_exc()
 750         print "-------------------------------------------------------------"
 751         print "-- to get an external python interpreter:runSalome --interp=1"
 752         print "-------------------------------------------------------------"
 753
 754     print "additional external python interpreters: ", nbaddi
 755     if nbaddi:
 756         for i in range(nbaddi):
 757             print "i=",i
 758             anInterp=InterpServer(args)
 759             anInterp.run()
 760
 761     return clt
 762
 763 # -----------------------------------------------------------------------------
 764
 765 def useSalome(args, modules_list, modules_root_dir):
 766     """
 767     Launch all SALOME servers requested by args,
 768     save list of process, give info to user,
 769     show registered objects in Naming Service.
 770     """
 771
 772     clt=None
 773     try:
 774         clt = startSalome(args, modules_list, modules_root_dir)
 775     except:
 776         import traceback
 777         traceback.print_exc()
 778         print
 779         print
 780         print "--- erreur au lancement Salome ---"
 781
 782     #print process_id
 783
 784     from killSalomeWithPort import getPiDict
 785     filedict = getPiDict(args['port'])
 786
 787     process_ids = []
 788     try:
 789         fpid=open(filedict, 'r')
 790         process_ids=pickle.load(fpid)
 791         fpid.close()
 792     except:
 793         pass
 794
 795     fpid=open(filedict, 'w')
 796     process_ids.append(process_id)
 797     pickle.dump(process_ids,fpid)
 798     fpid.close()
 799
 800     print """
 801     Saving of the dictionary of Salome processes in %s
 802     To kill SALOME processes from a console (kill all sessions from all ports):
 803       python killSalome.py
 804     To kill SALOME from the present interpreter, if it is not closed :
 805       killLocalPort()      --> kill this session
 806                                (use CORBA port from args of runSalome)
 807       givenPortKill(port)  --> kill a specific session with given CORBA port
 808       killAllPorts()       --> kill all sessions
 809
 810     runSalome, with --killall option, starts with killing
 811     the processes resulting from the previous execution.
 812     """%filedict
 813
 814     #
 815     #  Impression arborescence Naming Service
 816     #
 817
 818     if clt != None:
 819         print
 820         print " --- registered objects tree in Naming Service ---"
 821         clt.showNS()
 822
 823     return clt
 824
 825 # -----------------------------------------------------------------------------
 826
 827 def registerEnv(args, modules_list, modules_root_dir):
 828     """
 829     Register args, modules_list, modules_root_dir in a file
 830     for further use, when SALOME is launched embedded in an other application.
 831     """
 832     fileEnv = '/tmp/' + os.getenv('USER') + "_" + str(args['port']) \
 833             + '_' + args['appname'].upper() + '_env'
 834     fenv=open(fileEnv,'w')
 835     pickle.dump((args, modules_list, modules_root_dir),fenv)
 836     fenv.close()
 837     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 838
 839 # -----------------------------------------------------------------------------
 840
 841 def no_main():
 842     """Salome Launch, when embedded in other application"""
 843     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 844     fenv=open(fileEnv,'r')
 845     args, modules_list, modules_root_dir = pickle.load(fenv)
 846     fenv.close()
 847     kill_salome(args)
 848     clt = useSalome(args, modules_list, modules_root_dir)
 849     return clt
 850
 851 # -----------------------------------------------------------------------------
 852
 853 def main():
 854     """Salome launch as a main application"""
 855     args, modules_list, modules_root_dir = get_config()
 856     kill_salome(args)
 857     set_env(args, modules_list, modules_root_dir)
 858     clt = useSalome(args, modules_list, modules_root_dir)
 859     return clt,args
 860
 861 # -----------------------------------------------------------------------------
 862
 863 if __name__ == "__main__":
 864    import user
 865    clt,args = main()