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