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.get_env()
  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 (%s)'%":".join(self.args['modules'])]
 477         if self.args.has_key('test') and len(args['test']) > 0:
 478             self.SCMD2+=['--test=%s'%(",".join(args['test']))]
 479
 480     def setpath(self,modules_list,modules_root_dir):
 481         cata_path=[]
 482         list_modules = modules_list[:]
 483         list_modules.reverse()
 484         if self.args["gui"] :
 485             list_modules = ["KERNEL", "GUI"] + list_modules
 486         else :
 487             list_modules = ["KERNEL"] + list_modules
 488         for module in list_modules:
 489             module_root_dir=modules_root_dir[module]
 490             module_cata=module+"Catalog.xml"
 491             #print "   ", module_cata
 492             if os.path.exists(os.path.join(module_root_dir,
 493                                            "share",salome_subdir,
 494                                            "resources",module.lower(),
 495                                            module_cata)):
 496                 cata_path.extend(
 497                     glob.glob(os.path.join(module_root_dir,"share",
 498                                            salome_subdir,"resources",
 499                                            module.lower(),module_cata)))
 500             else:
 501                 cata_path.extend(
 502                     glob.glob(os.path.join(module_root_dir,"share",
 503                                            salome_subdir,"resources",
 504                                            module_cata)))
 505             pass
 506         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 507             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 508         else:
 509             self.CMD=self.SCMD1 + self.SCMD2
 510
 511 # ---
 512
 513 class ContainerManagerServer(Server):
 514     def __init__(self,args):
 515         self.args=args
 516         self.initArgs()
 517         self.SCMD1=['SALOME_ContainerManagerServer']
 518         self.SCMD2=[]
 519         if args["gui"] :
 520             if 'registry' in self.args['embedded']:
 521                 self.SCMD1+=['--with','Registry',
 522                              '(','--salome_session','theSession',')']
 523             if 'moduleCatalog' in self.args['embedded']:
 524                 self.SCMD1+=['--with','ModuleCatalog','(','-common']
 525                 self.SCMD2+=['-personal',
 526                              '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 527             if 'study' in self.args['embedded']:
 528                 self.SCMD2+=['--with','SALOMEDS','(',')']
 529             if 'cppContainer' in self.args['embedded']:
 530                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 531
 532     def setpath(self,modules_list,modules_root_dir):
 533         cata_path=[]
 534         list_modules = modules_list[:]
 535         list_modules.reverse()
 536         if self.args["gui"] :
 537             list_modules = ["GUI"] + list_modules
 538         for module in ["KERNEL"] + list_modules:
 539             if modules_root_dir.has_key(module):
 540                 module_root_dir=modules_root_dir[module]
 541                 module_cata=module+"Catalog.xml"
 542                 #print "   ", module_cata
 543                 if os.path.exists(os.path.join(module_root_dir,
 544                                                "share",salome_subdir,
 545                                                "resources",module.lower(),
 546                                                module_cata)):
 547                     cata_path.extend(
 548                         glob.glob(os.path.join(module_root_dir,"share",
 549                                                self.args['appname'],"resources",
 550                                                module.lower(),module_cata)))
 551                 else:
 552                     cata_path.extend(
 553                         glob.glob(os.path.join(module_root_dir,"share",
 554                                                self.args['appname'],"resources",
 555                                                module_cata)))
 556                 pass
 557             pass
 558         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 559             self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 560         else:
 561             self.CMD=self.SCMD1 + self.SCMD2
 562
 563 class NotifyServer(Server):
 564     def __init__(self,args,modules_root_dir):
 565         self.args=args
 566         self.initArgs()
 567         self.modules_root_dir=modules_root_dir
 568         myLogName = os.environ["LOGNAME"]
 569         self.CMD=['notifd','-c',
 570                   self.modules_root_dir["KERNEL"] +'/share/salome/resources/kernel/channel.cfg',
 571                   '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior',
 572                   '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior',
 573                   '-DReportLogFile=/tmp/'+myLogName+'_notifd.report',
 574                   '-DDebugLogFile=/tmp/'+myLogName+'_notifd.debug',
 575                   ]
 576
 577 #
 578 # -----------------------------------------------------------------------------
 579
 580 def startGUI():
 581     """Salome Session Graphic User Interface activation"""
 582     import Engines
 583     import SALOME
 584     import SALOMEDS
 585     import SALOME_ModuleCatalog
 586     reload(Engines)
 587     reload(SALOME)
 588     reload(SALOMEDS)
 589     import SALOME_Session_idl
 590     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 591     session.GetInterface()
 592
 593 # -----------------------------------------------------------------------------
 594
 595 def startSalome(args, modules_list, modules_root_dir):
 596     """Launch all SALOME servers requested by args"""
 597     init_time = os.times()
 598
 599     print "startSalome ", args
 600
 601     #
 602     # Initialisation ORB et Naming Service
 603     #
 604
 605     clt=orbmodule.client()
 606
 607     # (non obligatoire) Lancement Logger Server
 608     # et attente de sa disponibilite dans le naming service
 609     #
 610
 611     if args['logger']:
 612         myServer=LoggerServer(args)
 613         myServer.run()
 614         clt.waitLogger("Logger")
 615
 616     # Notify Server launch
 617     #
 618
 619     print "Notify Server to launch"
 620
 621     myServer=NotifyServer(args,modules_root_dir)
 622     myServer.run()
 623
 624     # Lancement Session Server (to show splash ASAP)
 625     #
 626
 627     if args["gui"]:
 628         mySessionServ = SessionServer(args)
 629         mySessionServ.setpath(modules_list,modules_root_dir)
 630         mySessionServ.run()
 631
 632     #
 633     # Lancement Registry Server,
 634     # attente de la disponibilite du Registry dans le Naming Service
 635     #
 636
 637     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
 638         myServer=RegistryServer(args)
 639         myServer.run()
 640         clt.waitNSPID("/Registry",myServer.PID)
 641
 642     #
 643     # Lancement Catalog Server,
 644     # attente de la disponibilite du Catalog Server dans le Naming Service
 645     #
 646
 647
 648     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 649         cataServer=CatalogServer(args)
 650         cataServer.setpath(modules_list,modules_root_dir)
 651         cataServer.run()
 652         import SALOME_ModuleCatalog
 653         clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 654
 655     #
 656     # Lancement SalomeDS Server,
 657     # attente de la disponibilite du SalomeDS dans le Naming Service
 658     #
 659
 660     #print "ARGS = ",args
 661     if ('study' not in args['embedded']) | (args["gui"] == 0):
 662         print "RunStudy"
 663         myServer=SalomeDSServer(args)
 664         myServer.run()
 665         clt.waitNSPID("/myStudyManager",myServer.PID)
 666
 667     #
 668     # Lancement ContainerManagerServer
 669     #
 670
 671     myCmServer = ContainerManagerServer(args)
 672     myCmServer.setpath(modules_list,modules_root_dir)
 673     myCmServer.run()
 674
 675
 676     from Utils_Identity import getShortHostName
 677
 678     if os.getenv("HOSTNAME") == None:
 679         if os.getenv("HOST") == None:
 680             os.environ["HOSTNAME"]=getShortHostName()
 681         else:
 682             os.environ["HOSTNAME"]=os.getenv("HOST")
 683
 684     theComputer = getShortHostName()
 685
 686     #
 687     # Lancement Container C++ local,
 688     # attente de la disponibilite du Container C++ local dans le Naming Service
 689     #
 690
 691     if 'cppContainer' in args['standalone']:
 692         myServer=ContainerCPPServer(args)
 693         myServer.run()
 694         clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 695
 696     #
 697     # Lancement Container Python local,
 698     # attente de la disponibilite du Container Python local
 699     # dans le Naming Service
 700     #
 701
 702     if 'pyContainer' in args['standalone']:
 703         myServer=ContainerPYServer(args)
 704         myServer.run()
 705         clt.waitNSPID("/Containers/" + theComputer + "/FactoryServerPy",myServer.PID)
 706
 707     #
 708     # Lancement Container Supervision local,
 709     # attente de la disponibilite du Container Supervision local
 710     # dans le Naming Service
 711     #
 712
 713     if 'supervContainer' in args['standalone']:
 714         myServer=ContainerSUPERVServer(args)
 715         myServer.run()
 716         clt.waitNSPID("/Containers/" + theComputer + "/SuperVisionContainer",myServer.PID)
 717
 718     #
 719     # Attente de la disponibilite du Session Server dans le Naming Service
 720     #
 721
 722     if args["gui"]:
 723 ##----------------
 724         import Engines
 725         import SALOME
 726         import SALOMEDS
 727         import SALOME_ModuleCatalog
 728         reload(Engines)
 729         reload(SALOME)
 730         reload(SALOMEDS)
 731         import SALOME_Session_idl
 732         session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
 733
 734     end_time = os.times()
 735     print
 736     print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 737                                                          - init_time[4])
 738
 739     # ASV start GUI without Loader
 740     #if args['gui']:
 741     #    session.GetInterface()
 742
 743     #
 744     # additionnal external python interpreters
 745     #
 746     nbaddi=0
 747
 748     try:
 749         if 'interp' in args:
 750             if args['interp']:
 751                 nbaddi = int(args['interp'][0])
 752     except:
 753         import traceback
 754         traceback.print_exc()
 755         print "-------------------------------------------------------------"
 756         print "-- to get an external python interpreter:runSalome --interp=1"
 757         print "-------------------------------------------------------------"
 758
 759     print "additional external python interpreters: ", nbaddi
 760     if nbaddi:
 761         for i in range(nbaddi):
 762             print "i=",i
 763             anInterp=InterpServer(args)
 764             anInterp.run()
 765
 766     return clt
 767
 768 # -----------------------------------------------------------------------------
 769
 770 def useSalome(args, modules_list, modules_root_dir):
 771     """
 772     Launch all SALOME servers requested by args,
 773     save list of process, give info to user,
 774     show registered objects in Naming Service.
 775     """
 776
 777     clt=None
 778     try:
 779         clt = startSalome(args, modules_list, modules_root_dir)
 780     except:
 781         import traceback
 782         traceback.print_exc()
 783         print
 784         print
 785         print "--- erreur au lancement Salome ---"
 786
 787     #print process_id
 788
 789     from killSalomeWithPort import getPiDict
 790     filedict = getPiDict(args['port'])
 791
 792     process_ids = []
 793     try:
 794         fpid=open(filedict, 'r')
 795         process_ids=pickle.load(fpid)
 796         fpid.close()
 797     except:
 798         pass
 799
 800     fpid=open(filedict, 'w')
 801     process_ids.append(process_id)
 802     pickle.dump(process_ids,fpid)
 803     fpid.close()
 804
 805     print """
 806     Saving of the dictionary of Salome processes in %s
 807     To kill SALOME processes from a console (kill all sessions from all ports):
 808       python killSalome.py
 809     To kill SALOME from the present interpreter, if it is not closed :
 810       killLocalPort()      --> kill this session
 811                                (use CORBA port from args of runSalome)
 812       givenPortKill(port)  --> kill a specific session with given CORBA port
 813       killAllPorts()       --> kill all sessions
 814
 815     runSalome, with --killall option, starts with killing
 816     the processes resulting from the previous execution.
 817     """%filedict
 818
 819     #
 820     #  Impression arborescence Naming Service
 821     #
 822
 823     if clt != None:
 824         print
 825         print " --- registered objects tree in Naming Service ---"
 826         clt.showNS()
 827
 828         # run python scripts, passed via -t option
 829         toimport = args['pyscript']
 830         i = 0
 831         while i < len( toimport ) :
 832             if toimport[ i ] == 'killall':
 833                 print "killall : option disabled"
 834                 #killAllPorts()
 835             else:
 836                 print 'importing',toimport[ i ]
 837                 doimport = 'import ' + toimport[ i ]
 838                 exec doimport
 839                 i = i + 1
 840
 841     return clt
 842
 843 # -----------------------------------------------------------------------------
 844
 845 def registerEnv(args, modules_list, modules_root_dir):
 846     """
 847     Register args, modules_list, modules_root_dir in a file
 848     for further use, when SALOME is launched embedded in an other application.
 849     """
 850     fileEnv = '/tmp/' + os.getenv('USER') + "_" + str(args['port']) \
 851             + '_' + args['appname'].upper() + '_env'
 852     fenv=open(fileEnv,'w')
 853     pickle.dump((args, modules_list, modules_root_dir),fenv)
 854     fenv.close()
 855     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 856
 857 # -----------------------------------------------------------------------------
 858
 859 def no_main():
 860     """Salome Launch, when embedded in other application"""
 861     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 862     fenv=open(fileEnv,'r')
 863     args, modules_list, modules_root_dir = pickle.load(fenv)
 864     fenv.close()
 865     kill_salome(args)
 866     clt = useSalome(args, modules_list, modules_root_dir)
 867     return clt
 868
 869 # -----------------------------------------------------------------------------
 870
 871 def main():
 872     """Salome launch as a main application"""
 873     args, modules_list, modules_root_dir = get_config()
 874     kill_salome(args)
 875     set_env(args, modules_list, modules_root_dir)
 876     clt = useSalome(args, modules_list, modules_root_dir)
 877     return clt,args
 878
 879 # -----------------------------------------------------------------------------
 880
 881 if __name__ == "__main__":
 882    import user
 883    clt,args = main()