bin/runSalome.py

   1 #!/usr/bin/env python
   2 #  -*- coding: iso-8859-1 -*-
   3 # Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   4 #
   5 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   6 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   7 #
   8 # This library is free software; you can redistribute it and/or
   9 # modify it under the terms of the GNU Lesser General Public
  10 # License as published by the Free Software Foundation; either
  11 # version 2.1 of the License, or (at your option) any later version.
  12 #
  13 # This library is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 # Lesser General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU Lesser General Public
  19 # License along with this library; if not, write to the Free Software
  20 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21 #
  22 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  23 #
  24
  25 ## @package runSalome
  26 # \brief Module that provides services to launch SALOME
  27 #
  28
  29 import sys, os, string, glob, time, pickle, re
  30 import orbmodule
  31 import setenv
  32 from launchConfigureParser import verbose
  33 from server import process_id, Server
  34 import json
  35 import subprocess
  36
  37 # -----------------------------------------------------------------------------
  38
  39 from killSalome import killAllPorts
  40
  41 def killLocalPort():
  42     """
  43     kill servers from a previous SALOME exection, if needed,
  44     on the CORBA port given in args of runSalome
  45     """
  46
  47     from killSalomeWithPort import killMyPort
  48     my_port=str(args['port'])
  49     try:
  50         killMyPort(my_port)
  51     except:
  52         print "problem in killLocalPort()"
  53         pass
  54     pass
  55
  56 def givenPortKill(port):
  57     """
  58     kill servers from a previous SALOME exection, if needed,
  59     on the same CORBA port
  60     """
  61
  62     from killSalomeWithPort import killMyPort
  63     my_port=port
  64     try:
  65         killMyPort(my_port)
  66     except:
  67         print "problem in LocalPortKill(), killMyPort(%s)"%port
  68         pass
  69     pass
  70
  71 def kill_salome(args):
  72     """
  73     Kill servers from previous SALOME executions, if needed;
  74     depending on args 'killall' or 'portkill', kill all executions,
  75     or only execution on the same CORBA port
  76     """
  77
  78     if args['killall']:
  79         killAllPorts()
  80     elif args['portkill']:
  81         givenPortKill(str(args['port']))
  82
  83 # -----------------------------------------------------------------------------
  84 #
  85 # Class definitions to launch CORBA Servers
  86 #
  87
  88 class InterpServer(Server):
  89     def __init__(self,args):
  90         self.args=args
  91         if sys.platform != "win32":
  92           env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
  93           self.CMD=['xterm', '-e']+ env_ld_library_path + ['python']
  94         else:
  95           self.CMD=['cmd', '/c', 'start cmd.exe', '/K', 'python']
  96
  97     def run(self):
  98         global process_id
  99         command = self.CMD
 100         print "INTERPSERVER::command = ", command
 101         if sys.platform == "win32":
 102           import win32pm
 103           pid = win32pm.spawnpid( string.join(command, " "),'-nc' )
 104         else:
 105           pid = os.spawnvp(os.P_NOWAIT, command[0], command)
 106         process_id[pid]=self.CMD
 107         self.PID = pid
 108
 109 # ---
 110
 111 def get_cata_path(list_modules,modules_root_dir):
 112     """Build a list of catalog paths (cata_path) to initialize the ModuleCatalog server
 113     """
 114     modules_cata={}
 115     cata_path=[]
 116
 117     for module in list_modules:
 118         if modules_root_dir.has_key(module):
 119             module_root_dir=modules_root_dir[module]
 120             module_cata=module+"Catalog.xml"
 121             cata_file=os.path.join(module_root_dir, "share",setenv.salome_subdir, "resources",module.lower(), module_cata)
 122
 123             if os.path.exists(cata_file):
 124                 cata_path.append(cata_file)
 125                 modules_cata[module]=cata_file
 126             else:
 127                 cata_file=os.path.join(module_root_dir, "share",setenv.salome_subdir, "resources", module_cata)
 128                 if os.path.exists(cata_file):
 129                     cata_path.append(cata_file)
 130                     modules_cata[module]=cata_file
 131
 132     for path in os.getenv("SALOME_CATALOGS_PATH","").split(os.pathsep):
 133         if os.path.exists(path):
 134             for cata_file in glob.glob(os.path.join(path,"*Catalog.xml")):
 135                 module_name= os.path.basename(cata_file)[:-11]
 136                 if not modules_cata.has_key(module_name):
 137                     cata_path.append(cata_file)
 138                     modules_cata[module_name]=cata_file
 139
 140     return cata_path
 141
 142 _siman_name = None
 143 def simanStudyName(args):
 144     global _siman_name
 145     if _siman_name is None:
 146         # siman session paramenters and checkout processing
 147         _siman_name = ""
 148         if 'siman' in args:
 149             siman_data = []
 150             for param in [ 'study', 'scenario', 'user']:
 151                 siman_param = "siman_%s"%param
 152                 if siman_param in args:
 153                     siman_data.append(args[siman_param])
 154                 else:
 155                     print "SIMAN %s must be defined using parameter --siman-%s=XXX" % (siman_param, siman_param)
 156                     pass
 157                 pass
 158             if len(siman_data) == 3:
 159                 _siman_name = "_".join(siman_data)
 160                 pass
 161             pass
 162         pass
 163     return _siman_name
 164
 165 class CatalogServer(Server):
 166     def __init__(self,args):
 167         self.args=args
 168         self.initArgs()
 169         self.SCMD1=['SALOME_ModuleCatalog_Server','-common']
 170         self.SCMD2=[]
 171         home_dir=os.getenv('HOME')
 172         if home_dir is not None:
 173             self.SCMD2=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 174
 175     def setpath(self,modules_list,modules_root_dir):
 176         list_modules = modules_list[:]
 177         list_modules.reverse()
 178         if self.args["gui"] :
 179             list_modules = ["KERNEL", "GUI"] + list_modules
 180         else :
 181             list_modules = ["KERNEL"] + list_modules
 182
 183         cata_path=get_cata_path(list_modules,modules_root_dir)
 184
 185         self.CMD=self.SCMD1 + ['"' + string.join(cata_path,'"::"') + '"'] + self.SCMD2
 186
 187 # ---
 188
 189 class SalomeDSServer(Server):
 190     def __init__(self,args):
 191         self.args=args
 192         self.initArgs()
 193         self.CMD=['SALOMEDS_Server']
 194
 195 # ---
 196
 197 class ConnectionManagerServer(Server):
 198     def __init__(self,args):
 199         self.args=args
 200         self.initArgs()
 201         self.CMD=['SALOME_ConnectionManagerServer']
 202
 203 # ---
 204
 205 class RegistryServer(Server):
 206     def __init__(self,args):
 207         self.args=args
 208         self.initArgs()
 209         self.CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 210
 211 # ---
 212
 213 class ContainerCPPServer(Server):
 214     def __init__(self,args):
 215         self.args=args
 216         self.initArgs()
 217         self.CMD=['SALOME_Container','FactoryServer']
 218
 219 # ---
 220
 221 class LoggerServer(Server):
 222     def __init__(self,args):
 223         self.args=args
 224         self.initArgs()
 225         from salome_utils import generateFileName
 226         if sys.platform == "win32": dirpath = os.environ["HOME"]
 227         else:                       dirpath = "/tmp"
 228         logfile = generateFileName( dirpath,
 229                                     prefix="logger",
 230                                     extension="log",
 231                                     with_username=True,
 232                                     with_hostname=True,
 233                                     with_port=True)
 234         print "==========================================================="
 235         print "Logger server: put log to the file:"
 236         print logfile
 237         print "==========================================================="
 238         self.CMD=['SALOME_Logger_Server', logfile]
 239         pass
 240     pass # end of LoggerServer class
 241
 242 # ---
 243
 244 class SessionServer(Server):
 245     def __init__(self,args,modules_list,modules_root_dir):
 246         self.args = args.copy()
 247         # Bug 11512 (Problems with runSalome --xterm on Mandrake and Debian Sarge)
 248         #self.args['xterm']=0
 249         #
 250         self.initArgs()
 251         self.SCMD1=['SALOME_Session_Server']
 252         self.SCMD2=[]
 253         if 'registry' in self.args['embedded']:
 254             self.SCMD1+=['--with','Registry',
 255                          '(','--salome_session','theSession',')']
 256         if 'moduleCatalog' in self.args['embedded']:
 257             self.SCMD1+=['--with','ModuleCatalog','(','-common']
 258             home_dir=os.getenv('HOME')
 259             if home_dir is not None:
 260                 self.SCMD2+=['-personal',os.path.join(home_dir,'Salome/resources/CatalogModulePersonnel.xml')]
 261             self.SCMD2+=[')']
 262         if 'study' in self.args['embedded']:
 263             self.SCMD2+=['--with','SALOMEDS','(',')']
 264         if 'cppContainer' in self.args['embedded']:
 265             self.SCMD2+=['--with','Container','(','FactoryServer',')']
 266         if 'SalomeAppEngine' in self.args['embedded']:
 267             self.SCMD2+=['--with','SalomeAppEngine','(',')']
 268
 269         if 'cppContainer' in self.args['standalone'] or 'cppContainer' in self.args['embedded']:
 270             self.SCMD2+=['CPP']
 271         if 'pyContainer' in self.args['standalone'] or 'pyContainer' in self.args['embedded']:
 272             raise Exception('Python containers no longer supported')
 273         if self.args['gui']:
 274             session_gui = True
 275             if self.args.has_key('session_gui'):
 276                 session_gui = self.args['session_gui']
 277             if session_gui:
 278                 self.SCMD2+=['GUI']
 279                 if self.args['splash']:
 280                     self.SCMD2+=['SPLASH']
 281                     pass
 282                 if self.args['study_hdf'] is not None:
 283                     self.SCMD2+=['--study-hdf=%s'%self.args['study_hdf']]
 284                     pass
 285                 if simanStudyName(self.args):
 286                     self.SCMD2+=['--siman-study=%s'%simanStudyName(self.args)]
 287                     pass
 288                 pass
 289                 if self.args.has_key('pyscript') and len(self.args['pyscript']) > 0:
 290                     msg = json.dumps(self.args['pyscript'])
 291                     self.SCMD2+=['--pyscript=%s'%(msg)]
 292                     pass
 293                 pass
 294             pass
 295         if self.args['noexcepthandler']:
 296             self.SCMD2+=['noexcepthandler']
 297         if self.args.has_key('user_config'):
 298             self.SCMD2+=['--resources=%s'%self.args['user_config']]
 299         if self.args.has_key('modules'):
 300             list_modules = []
 301             #keep only modules with GUI
 302             for m in modules_list:
 303               if m not in modules_root_dir:
 304                 list_modules.insert(0,m)
 305               else:
 306                 fr1 = os.path.join(modules_root_dir[m],"share","salome","resources",m.lower(),"SalomeApp.xml")
 307                 fr2 = os.path.join(modules_root_dir[m],"share","salome","resources","SalomeApp.xml")
 308                 if os.path.exists(fr1) or os.path.exists(fr2):
 309                   list_modules.insert(0,m)
 310             list_modules.reverse()
 311             self.SCMD2+=['--modules (%s)' % ":".join(list_modules)]
 312             pass
 313         pass
 314
 315     def setpath(self,modules_list,modules_root_dir):
 316         list_modules = modules_list[:]
 317         list_modules.reverse()
 318         if self.args["gui"] :
 319             list_modules = ["KERNEL", "GUI"] + list_modules
 320         else :
 321             list_modules = ["KERNEL"] + list_modules
 322
 323         cata_path=get_cata_path(list_modules,modules_root_dir)
 324
 325         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 326             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 327             self.CMD=self.SCMD1 + ['"' + string.join(cata_path,'"::"') + '"'] + self.SCMD2
 328         else:
 329             self.CMD=self.SCMD1 + self.SCMD2
 330         if self.args.has_key('test'):
 331             self.CMD+=['-test'] + self.args['test']
 332         elif self.args.has_key('play'):
 333             self.CMD+=['-play'] + self.args['play']
 334
 335         if self.args["gdb_session"] or self.args["ddd_session"]:
 336             f = open(".gdbinit4salome", "w")
 337             f.write("set args ")
 338             args = " ".join(self.CMD[1:])
 339             args = args.replace("(", "\(")
 340             args = args.replace(")", "\)")
 341             f.write(args)
 342             f.write("\n")
 343             f.close()
 344             if self.args["ddd_session"]:
 345                 self.CMD = ["ddd", "--command=.gdbinit4salome", self.CMD[0]]
 346             elif self.args["gdb_session"]:
 347                 self.CMD = ["xterm", "-e", "gdb", "--command=.gdbinit4salome", self.CMD[0]]
 348                 pass
 349             pass
 350
 351         if self.args["valgrind_session"]:
 352             l = ["valgrind"]
 353             val = os.getenv("VALGRIND_OPTIONS")
 354             if val:
 355                 l += val.split()
 356                 pass
 357             self.CMD = l + self.CMD
 358             pass
 359
 360 # ---
 361
 362 class LauncherServer(Server):
 363     def __init__(self,args):
 364         self.args=args
 365         self.initArgs()
 366         self.SCMD1=['SALOME_LauncherServer']
 367         self.SCMD2=[]
 368         if args["gui"] :
 369             if 'registry' in self.args['embedded']:
 370                 self.SCMD1+=['--with','Registry',
 371                              '(','--salome_session','theSession',')']
 372             if 'moduleCatalog' in self.args['embedded']:
 373                 self.SCMD1+=['--with','ModuleCatalog','(','-common']
 374                 self.SCMD2+=['-personal',
 375                              '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 376             if 'study' in self.args['embedded']:
 377                 self.SCMD2+=['--with','SALOMEDS','(',')']
 378             if 'cppContainer' in self.args['embedded']:
 379                 self.SCMD2+=['--with','Container','(','FactoryServer',')']
 380
 381     def setpath(self,modules_list,modules_root_dir):
 382         list_modules = modules_list[:]
 383         list_modules.reverse()
 384         if self.args["gui"] :
 385             list_modules = ["KERNEL", "GUI"] + list_modules
 386         else :
 387             list_modules = ["KERNEL"] + list_modules
 388
 389         cata_path=get_cata_path(list_modules,modules_root_dir)
 390
 391         if (self.args["gui"]) & ('moduleCatalog' in self.args['embedded']):
 392             #Use '::' instead ":" because drive path with "D:\" is invalid on windows platform
 393             self.CMD=self.SCMD1 + ['"' + string.join(cata_path,'"::"') + '"'] + self.SCMD2
 394         else:
 395             self.CMD=self.SCMD1 + self.SCMD2
 396 #
 397 # -----------------------------------------------------------------------------
 398
 399 def startGUI(clt):
 400     """Salome Session Graphic User Interface activation"""
 401     import Engines
 402     import SALOME
 403     import SALOMEDS
 404     import SALOME_ModuleCatalog
 405     import SALOME_Session_idl
 406     session=clt.waitNS("/Kernel/Session",SALOME.Session)
 407     session.GetInterface()
 408
 409 # -----------------------------------------------------------------------------
 410
 411 def startSalome(args, modules_list, modules_root_dir):
 412     """Launch all SALOME servers requested by args"""
 413     init_time = os.times()
 414
 415     if verbose(): print "startSalome ", args
 416
 417     #
 418     # Set server launch command
 419     #
 420     if args.has_key('server_launch_mode'):
 421         Server.set_server_launch_mode(args['server_launch_mode'])
 422
 423     #
 424     # Wake up session option
 425     #
 426     if args['wake_up_session']:
 427         if "OMNIORB_CONFIG" not in os.environ:
 428             from salome_utils import generateFileName
 429             omniorbUserPath = os.getenv("OMNIORB_USER_PATH")
 430             kwargs={}
 431             if omniorbUserPath is not None:
 432                 kwargs["with_username"]=True
 433
 434             last_running_config = generateFileName(omniorbUserPath, prefix="omniORB",
 435                                                    suffix="last",
 436                                                    extension="cfg",
 437                                                    hidden=True,
 438                                                    **kwargs)
 439             os.environ['OMNIORB_CONFIG'] = last_running_config
 440             pass
 441         pass
 442
 443     #
 444     # Initialisation ORB and Naming Service
 445     #
 446
 447     clt=orbmodule.client(args)
 448
 449     #
 450     # Wake up session option
 451     #
 452     if args['wake_up_session']:
 453         import Engines
 454         import SALOME
 455         import SALOMEDS
 456         import SALOME_ModuleCatalog
 457         import SALOME_Session_idl
 458         session = clt.waitNS("/Kernel/Session",SALOME.Session)
 459         status = session.GetStatSession()
 460         if status.activeGUI:
 461             from salome_utils import getPortNumber
 462             port = getPortNumber()
 463             msg  = "Warning :"
 464             msg += "\n"
 465             msg += "Session GUI for port number %s is already active."%(port)
 466             msg += "\n"
 467             msg += "If you which to wake up another session,"
 468             msg += "\n"
 469             msg += "please use variable OMNIORB_CONFIG"
 470             msg += "\n"
 471             msg += "to get the correct session object in naming service."
 472             sys.stdout.write(msg+"\n")
 473             sys.stdout.flush()
 474             return clt
 475         session.GetInterface()
 476         args["session_object"] = session
 477         return clt
 478
 479     # Launch Logger Server (optional)
 480     # and wait until it is registered in naming service
 481     #
 482
 483     if args['logger']:
 484         myServer=LoggerServer(args)
 485         myServer.run()
 486         clt.waitLogger("Logger")
 487
 488     # set siman python path before the session server launching to import scripts inside python console
 489     if simanStudyName(args):
 490         # MPV: use os.environ here because session server is launched in separated process and sys.path is missed in this case
 491         os.environ["PYTHONPATH"] = "/tmp/SimanSalome/" + args['siman_study'] + "/" + \
 492                                    args['siman_scenario'] + "/" + args['siman_user'] + os.pathsep + os.environ["PYTHONPATH"];
 493
 494     # Launch  Session Server (to show splash ASAP)
 495     #
 496
 497     if args["gui"]:
 498         mySessionServ = SessionServer(args,args['modules'],modules_root_dir)
 499         mySessionServ.setpath(modules_list,modules_root_dir)
 500         mySessionServ.run()
 501
 502     #
 503     # Launch Registry Server,
 504     # and wait until it is registered in naming service
 505     #
 506
 507     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
 508         myServer=RegistryServer(args)
 509         myServer.run()
 510         if sys.platform == "win32":
 511           clt.waitNS("/Registry")
 512         else:
 513           clt.waitNSPID("/Registry",myServer.PID)
 514
 515     #
 516     # Launch Catalog Server,
 517     # and wait until it is registered in naming service
 518     #
 519
 520     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
 521         cataServer=CatalogServer(args)
 522         cataServer.setpath(modules_list,modules_root_dir)
 523         cataServer.run()
 524         import SALOME_ModuleCatalog
 525         if sys.platform == "win32":
 526           clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 527         else:
 528           clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
 529
 530     #
 531     # Launch SalomeDS Server,
 532     # and wait until it is registered in naming service
 533     #
 534
 535     #print "ARGS = ",args
 536     if ('study' not in args['embedded']) | (args["gui"] == 0):
 537         print "RunStudy"
 538         myServer=SalomeDSServer(args)
 539         myServer.run()
 540         if sys.platform == "win32":
 541           clt.waitNS("/myStudyManager")
 542         else:
 543           clt.waitNSPID("/myStudyManager",myServer.PID)
 544
 545     #
 546     # Launch LauncherServer
 547     #
 548
 549     myCmServer = LauncherServer(args)
 550     myCmServer.setpath(modules_list,modules_root_dir)
 551     myCmServer.run()
 552
 553     #
 554     # Launch ConnectionManagerServer
 555     #
 556
 557     myConnectionServer = ConnectionManagerServer(args)
 558     myConnectionServer.run()
 559
 560
 561     from Utils_Identity import getShortHostName
 562
 563     if os.getenv("HOSTNAME") == None:
 564         if os.getenv("HOST") == None:
 565             os.environ["HOSTNAME"]=getShortHostName()
 566         else:
 567             os.environ["HOSTNAME"]=os.getenv("HOST")
 568
 569     theComputer = getShortHostName()
 570
 571     #
 572     # Launch local C++ Container (FactoryServer),
 573     # and wait until it is registered in naming service
 574     #
 575
 576     if ('cppContainer' in args['standalone']) | (args["gui"] == 0) :
 577         myServer=ContainerCPPServer(args)
 578         myServer.run()
 579         if sys.platform == "win32":
 580           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 581         else:
 582           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
 583
 584     if 'pyContainer' in args['standalone']:
 585         raise Exception('Python containers no longer supported')
 586
 587     #
 588     # Wait until Session Server is registered in naming service
 589     #
 590
 591     if args["gui"]:
 592 ##----------------
 593         import Engines
 594         import SALOME
 595         import SALOMEDS
 596         import SALOME_ModuleCatalog
 597         import SALOME_Session_idl
 598         if sys.platform == "win32":
 599           session=clt.waitNS("/Kernel/Session",SALOME.Session)
 600         else:
 601           session=clt.waitNSPID("/Kernel/Session",mySessionServ.PID,SALOME.Session)
 602         args["session_object"] = session
 603     end_time = os.times()
 604     if verbose(): print
 605     print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
 606                                                          - init_time[4])
 607
 608     # ASV start GUI without Loader
 609     #if args['gui']:
 610     #    session.GetInterface()
 611
 612     #
 613     # additionnal external python interpreters
 614     #
 615     nbaddi=0
 616
 617     try:
 618         if 'interp' in args:
 619             nbaddi = args['interp']
 620     except:
 621         import traceback
 622         traceback.print_exc()
 623         print "-------------------------------------------------------------"
 624         print "-- to get an external python interpreter:runSalome --interp=1"
 625         print "-------------------------------------------------------------"
 626
 627     if verbose(): print "additional external python interpreters: ", nbaddi
 628     if nbaddi:
 629         for i in range(nbaddi):
 630             print "i=",i
 631             anInterp=InterpServer(args)
 632             anInterp.run()
 633
 634     # set PYTHONINSPECT variable (python interpreter in interactive mode)
 635     if args['pinter']:
 636         os.environ["PYTHONINSPECT"]="1"
 637         try:
 638             import readline
 639         except ImportError:
 640             pass
 641
 642     # siman session paramenters and checkout processing
 643     if simanStudyName(args):
 644         print '**********************************************'
 645         print "Siman study name= '" + simanStudyName(args) + "'"
 646         import SALOMEDS
 647         obj = clt.Resolve('myStudyManager')
 648         myStudyManager = obj._narrow(SALOMEDS.StudyManager)
 649         aNewStudy = myStudyManager.NewStudy(simanStudyName(args))
 650         aSimS = myStudyManager.GetSimanStudy()
 651         aSimS._set_StudyId(args['siman_study'])
 652         aSimS._set_ScenarioId(args['siman_scenario'])
 653         aSimS._set_UserId(args['siman_user'])
 654         aSimS.CheckOut(aNewStudy)
 655         # if session server is enabled, activate the created study
 656         if args["gui"]:
 657             print "Activate the SIMAN study in the SALOME GUI"
 658             obj = clt.Resolve('/Kernel/Session')
 659             mySession = obj._narrow(SALOME.Session)
 660             mySession.emitMessage("simanCheckoutDone " + simanStudyName(args))
 661         print '**********************************************'
 662
 663     return clt
 664
 665 # -----------------------------------------------------------------------------
 666
 667 def useSalome(args, modules_list, modules_root_dir):
 668     """
 669     Launch all SALOME servers requested by args,
 670     save list of process, give info to user,
 671     show registered objects in Naming Service.
 672     """
 673     global process_id
 674
 675     clt=None
 676     try:
 677         clt = startSalome(args, modules_list, modules_root_dir)
 678     except:
 679         import traceback
 680         traceback.print_exc()
 681         print
 682         print
 683         print "--- Error during Salome launch ---"
 684
 685     #print process_id
 686
 687     from addToKillList import addToKillList
 688     from killSalomeWithPort import getPiDict
 689
 690     filedict = getPiDict(args['port'])
 691     for pid, cmd in process_id.items():
 692         addToKillList(pid, cmd, args['port'])
 693         pass
 694
 695     if verbose(): print """
 696     Saving of the dictionary of Salome processes in %s
 697     To kill SALOME processes from a console (kill all sessions from all ports):
 698       python killSalome.py
 699     To kill SALOME from the present interpreter, if it is not closed :
 700       killLocalPort()      --> kill this session
 701                                (use CORBA port from args of runSalome)
 702       givenPortKill(port)  --> kill a specific session with given CORBA port
 703       killAllPorts()       --> kill all sessions
 704
 705     runSalome, with --killall option, starts with killing
 706     the processes resulting from the previous execution.
 707     """%filedict
 708
 709     #
 710     #  Print Naming Service directory list
 711     #
 712
 713     if clt != None:
 714         if verbose():
 715             print
 716             print " --- registered objects tree in Naming Service ---"
 717             clt.showNS()
 718             pass
 719
 720         if not args['gui'] or not args['session_gui']:
 721             if args['shutdown_servers']:
 722                 class __utils__(object):
 723                     def __init__(self, port):
 724                         self.port = port
 725                         import killSalomeWithPort
 726                         self.killSalomeWithPort = killSalomeWithPort
 727                         return
 728                     def __del__(self):
 729                         self.killSalomeWithPort.killMyPort(self.port)
 730                         return
 731                     pass
 732                 def func(s):
 733                     del s
 734                 import atexit
 735                 atexit.register(func, __utils__(args['port']))
 736                 pass
 737             pass
 738
 739         # run python scripts, passed as command line arguments
 740         toimport = []
 741         if args.has_key('pyscript'):
 742             if args.has_key('gui') and args.has_key('session_gui'):
 743                 if not args['gui'] or not args['session_gui']:
 744                     toimport = args['pyscript']
 745
 746         from salomeContextUtils import formatScriptsAndArgs
 747         command = formatScriptsAndArgs(toimport)
 748         if command:
 749             proc = subprocess.Popen(command, shell=True)
 750             addToKillList(proc.pid, command, args['port'])
 751             res = proc.wait()
 752             if res: sys.exit(1) # if there's an error when executing script, we should explicitly exit
 753
 754     return clt
 755
 756 def execScript(script_path):
 757     print 'executing', script_path
 758     sys.path.insert(0, os.path.dirname(script_path))
 759     execfile(script_path,globals())
 760     del sys.path[0]
 761
 762 # -----------------------------------------------------------------------------
 763
 764 def registerEnv(args, modules_list, modules_root_dir):
 765     """
 766     Register args, modules_list, modules_root_dir in a file
 767     for further use, when SALOME is launched embedded in an other application.
 768     """
 769     if sys.platform == "win32":
 770       fileEnv = os.getenv('TEMP')
 771     else:
 772       fileEnv = '/tmp/'
 773
 774     fileEnv += os.getenv('USER') + "_" + str(args['port']) \
 775             + '_' + args['appname'].upper() + '_env'
 776     fenv=open(fileEnv,'w')
 777     pickle.dump((args, modules_list, modules_root_dir),fenv)
 778     fenv.close()
 779     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
 780
 781 # -----------------------------------------------------------------------------
 782
 783 def no_main():
 784     """Salome Launch, when embedded in other application"""
 785     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
 786     fenv=open(fileEnv,'r')
 787     args, modules_list, modules_root_dir = pickle.load(fenv)
 788     fenv.close()
 789     kill_salome(args)
 790     from searchFreePort import searchFreePort
 791     searchFreePort(args, 0)
 792     clt = useSalome(args, modules_list, modules_root_dir)
 793     return clt
 794
 795 # -----------------------------------------------------------------------------
 796
 797 def main():
 798     """Salome launch as a main application"""
 799
 800     # define folder to store omniorb config (initially in virtual application folder)
 801     try:
 802         from salomeContextUtils import setOmniOrbUserPath
 803         setOmniOrbUserPath()
 804     except Exception, e:
 805         print e
 806         sys.exit(1)
 807
 808     from salome_utils import getHostName
 809     args, modules_list, modules_root_dir = setenv.get_config()
 810     print "runSalome running on %s" % getHostName()
 811
 812     kill_salome(args)
 813     save_config = True
 814     if args.has_key('save_config'):
 815         save_config = args['save_config']
 816     # --
 817     test = True
 818     if args['wake_up_session']:
 819         test = False
 820         pass
 821     if test:
 822         from searchFreePort import searchFreePort
 823         searchFreePort(args, save_config, args.get('useport'))
 824         pass
 825     # --
 826     #setenv.main()
 827     setenv.set_env(args, modules_list, modules_root_dir)
 828     clt = useSalome(args, modules_list, modules_root_dir)
 829     return clt,args
 830
 831 # -----------------------------------------------------------------------------
 832
 833 def foreGround(clt, args):
 834     # --
 835     if "session_object" not in args:
 836         return
 837     session = args["session_object"]
 838     # --
 839     # Wait until gui is arrived
 840     # tmax = nbtot * dt
 841     # --
 842     gui_detected = False
 843     dt = 0.1
 844     nbtot = 100
 845     nb = 0
 846     while 1:
 847         try:
 848             status = session.GetStatSession()
 849             gui_detected = status.activeGUI
 850         except:
 851             pass
 852         if gui_detected:
 853             break
 854         from time import sleep
 855         sleep(dt)
 856         nb += 1
 857         if nb == nbtot:
 858             break
 859         pass
 860     # --
 861     if not gui_detected:
 862         return
 863     # --
 864     from salome_utils import getPortNumber
 865     port = getPortNumber()
 866     # --
 867     server = Server({})
 868     if sys.platform == "win32":
 869       server.CMD = [os.getenv("PYTHONBIN"), "-m", "killSalomeWithPort", "--spy", "%s"%(os.getpid()), "%s"%(port)]
 870     else:
 871       server.CMD = ["killSalomeWithPort.py", "--spy", "%s"%(os.getpid()), "%s"%(port)]
 872     server.run()
 873     # os.system("killSalomeWithPort.py --spy %s %s &"%(os.getpid(), port))
 874     # --
 875     dt = 1.0
 876     try:
 877         while 1:
 878             try:
 879                 status = session.GetStatSession()
 880                 assert status.activeGUI
 881             except:
 882                 break
 883             from time import sleep
 884             sleep(dt)
 885             pass
 886         pass
 887     except KeyboardInterrupt:
 888         from killSalomeWithPort import killMyPort
 889         killMyPort(port)
 890         pass
 891     return
 892 #
 893
 894 def runSalome():
 895     print sys.argv
 896     import user
 897     clt,args = main()
 898     # --
 899     test = args['gui'] and args['session_gui']
 900     test = test or args['wake_up_session']
 901     # --
 902     # The next test covers the --pinter option or var PYTHONINSPECT setted
 903     # --
 904     test = test and not os.environ.get('PYTHONINSPECT')
 905     # --
 906     # The next test covers the python -i $KERNEL_ROOT_DIR/bin/salome/runSalome.py case
 907     # --
 908     try:
 909         from ctypes import POINTER, c_int, cast, pythonapi
 910         iflag_ptr = cast(pythonapi.Py_InteractiveFlag, POINTER(c_int))
 911         test = test and not iflag_ptr.contents.value
 912     except:
 913         pass
 914     # --
 915     test = test and os.getenv("SALOME_TEST_MODE", "0") != "1"
 916     test = test and args['foreground']
 917     # --
 918     if test:
 919         foreGround(clt, args)
 920         pass
 921     pass
 922 #
 923
 924 # -----------------------------------------------------------------------------
 925
 926 if __name__ == "__main__":
 927     runSalome()
 928 #