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