3 import sys, os, string, glob, time, pickle
8 # -----------------------------------------------------------------------------
10 def add_path(directory, variable_name):
11 """Function helper to add environment variables"""
12 if not os.environ.has_key(variable_name):
13 os.environ[variable_name] = ""
15 if os.path.exists(directory):
17 for _dir in os.environ[variable_name].split(":"):
18 if os.path.exists(_dir):
19 if not os.path.samefile(_dir, directory):
22 if os.path.abspath(_dir) != os.path.abspath(directory):
26 newpath[:0] = [ directory ]
27 newpath = string.join(newpath,":")
28 os.environ[variable_name] = newpath
29 if variable_name == "PYTHONPATH":
30 sys.path[:0] = [directory]
32 # -----------------------------------------------------------------------------
36 Get list of modules, paths.
38 Read args from launch configure xml file and command line options.
39 Check variables <module>_ROOT_DIR and set list of used modules.
40 Return args, modules_list, modules_root_dir
43 # read args from launch configure xml file and command line options
45 import launchConfigureParser
46 args = launchConfigureParser.args
48 # Check variables <module>_ROOT_DIR
49 # and set list of used modules (without KERNEL)
52 if args.has_key("modules"):
53 modules_list += args["modules"]
54 # KERNEL must be last in the list to locate it at the first place in PATH
55 modules_list[:0] = ["KERNEL"]
56 modules_list.reverse()
61 for module in modules_list :
62 module_variable=module.upper()+"_ROOT_DIR"
63 if not os.environ.has_key(module_variable):
64 print "*******************************************************"
66 print "* Environment variable",module_variable,"must be set"
67 print "* Module", module, "will be not available"
69 print "********************************************************"
70 to_remove_list.append(module)
73 module_root_dir = os.environ[module_variable]
74 modules_root_dir[module]=module_root_dir
76 for to_remove in to_remove_list:
77 modules_list.remove(to_remove)
79 while "KERNEL" in modules_list:
80 modules_list.remove("KERNEL")
83 if "SUPERV" in modules_list and not 'superv' in args['standalone']:
84 args['standalone'].append("superv")
87 return args, modules_list, modules_root_dir
89 # -----------------------------------------------------------------------------
91 def set_env(args, modules_list, modules_root_dir):
92 """Add to the PATH-variables modules specific paths"""
94 python_version="python%d.%d" % sys.version_info[0:2]
95 modules_root_dir_list = []
96 modules_list = modules_list[:] + ["KERNEL"]
97 for module in modules_list :
98 module_root_dir = modules_root_dir[module]
99 modules_root_dir_list[:0] = [module_root_dir]
100 add_path(os.path.join(module_root_dir,"lib",args['appname']),
102 add_path(os.path.join(module_root_dir,"bin",args['appname']),
104 if os.path.exists(module_root_dir + "/examples") :
105 add_path(os.path.join(module_root_dir,"examples"),
107 add_path(os.path.join(module_root_dir,"bin",args['appname']),
109 add_path(os.path.join(module_root_dir,"lib",
110 python_version,"site-packages",args['appname']),
112 add_path(os.path.join(module_root_dir,"lib",args['appname']),
114 add_path(os.path.join(module_root_dir,"lib",
115 python_version,"site-packages",args['appname'],
119 os.environ["SALOMEPATH"]=":".join(modules_root_dir_list)
121 # special path for logger lib if needeed
123 os.environ["SALOME_trace"]="local"
125 os.environ["SALOME_trace"]=args['file'][0]
127 os.environ["SALOME_trace"]="with_logger"
128 locdir=os.environ['PWD']
129 libtracedir=os.path.join(locdir,"libSalomeTrace")
130 libtrace = os.path.join(modules_root_dir["KERNEL"],"lib",
132 "libSALOMELoggerClient.so.0.0.0")
133 libtraceln = os.path.join(libtracedir,"libSALOMELocalTrace.so")
134 aCommand = 'rm -rf ' + libtracedir + "; "
135 aCommand += 'mkdir ' + libtracedir + "; "
136 aCommand += 'ln -s ' + libtrace + " " + libtraceln + "; "
137 aCommand += 'ln -s ' + libtrace + " " + libtraceln + ".0; "
138 aCommand += 'ln -s ' + libtrace + " " + libtraceln + ".0.0.0; "
140 add_path(libtracedir, "LD_LIBRARY_PATH")
142 # set environment for SMESH plugins
144 if "SMESH" in modules_list:
145 os.environ["SMESH_MeshersList"]="StdMeshers"
146 if not os.environ.has_key("SALOME_StdMeshersResources"):
147 os.environ["SALOME_StdMeshersResources"] \
148 = modules_root_dir["SMESH"]+"/share/"+args["appname"]+"/resources"
150 if args.has_key("SMESH_plugins"):
151 for plugin in args["SMESH_plugins"]:
152 if os.environ.has_key(plugin.upper()+"_ROOT_DIR"):
153 os.environ["SMESH_MeshersList"] \
154 = os.environ["SMESH_MeshersList"]+":"+plugin
155 plugin_root = os.environ[plugin.upper()+"_ROOT_DIR"]
156 if not os.environ.has_key("SALOME_"+plugin+"Resources"):
157 os.environ["SALOME_"+plugin+"Resources"] \
158 = plugin_root+"/share/"+args["appname"]+"/resources"
159 add_path(os.path.join(plugin_root,"lib",python_version,
160 "site-packages",args['appname']),
162 add_path(os.path.join(plugin_root,"lib",args['appname']),
164 add_path(os.path.join(plugin_root,"lib",args['appname']),
166 add_path(os.path.join(plugin_root,"bin",args['appname']),
168 add_path(os.path.join(plugin_root,"bin",args['appname']),
173 # set environment for SUPERV module
174 os.environ["ENABLE_MACRO_NODE"]="1"
177 # -----------------------------------------------------------------------------
179 from killSalome import killAllPorts
183 kill servers from a previous SALOME exection, if needed,
184 on the CORBA port given in args of runSalome
187 from killSalomeWithPort import killMyPort
188 my_port=str(args['port'])
192 print "problem in killLocalPort()"
196 def givenPortKill(port):
198 kill servers from a previous SALOME exection, if needed,
199 on the same CORBA port
202 from killSalomeWithPort import killMyPort
207 print "problem in LocalPortKill(), killMyPort("<<port<<")"
211 def kill_salome(args):
213 Kill servers from previous SALOME executions, if needed;
214 depending on args 'killall' or 'portkill', kill all executions,
215 or only execution on the same CORBA port
220 elif args['portkill']:
221 givenPortKill(str(args['port']))
223 # -----------------------------------------------------------------------------
225 # Definition des classes d'objets pour le lancement des Server CORBA
229 """Generic class for CORBA server launch"""
234 if self.args['xterm']:
235 self.ARGS=['xterm', '-iconic', '-sb', '-sl', '500', '-hold']
237 def __init__(self,args):
245 if self.args['xterm']:
246 # (Debian) send LD_LIBRARY_PATH to children shells (xterm)
247 env_ld_library_path=['env', 'LD_LIBRARY_PATH='
248 + os.getenv("LD_LIBRARY_PATH")]
249 myargs = myargs +['-T']+self.CMD[:1]+['-e'] + env_ld_library_path
250 command = myargs + self.CMD
251 # print "command = ", command
252 pid = os.spawnvp(os.P_NOWAIT, command[0], command)
253 process_id[pid]=self.CMD
256 class InterpServer(Server):
257 def __init__(self,args):
259 env_ld_library_path=['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
260 self.CMD=['xterm', '-e']+ env_ld_library_path + ['python']
261 #self.CMD=['xterm', '-e', 'python']
266 print "command = ", command
267 pid = os.spawnvp(os.P_NOWAIT, command[0], command)
268 process_id[pid]=self.CMD
272 class CatalogServer(Server):
273 def __init__(self,args):
276 self.SCMD1=['SALOME_ModuleCatalog_Server','-common']
277 self.SCMD2=['-personal',
278 '${HOME}/Salome/resources/CatalogModulePersonnel.xml']
280 def setpath(self,modules_list,modules_root_dir):
282 list_modules = modules_list[:]
283 list_modules.reverse()
284 for module in ["KERNEL"] + list_modules:
285 module_root_dir=modules_root_dir[module]
286 module_cata=module+"Catalog.xml"
287 print " ", module_cata
289 glob.glob(os.path.join(module_root_dir,
290 "share",self.args['appname'],
291 "resources",module_cata)))
292 self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
296 class SalomeDSServer(Server):
297 def __init__(self,args):
300 self.CMD=['SALOMEDS_Server']
304 class RegistryServer(Server):
305 def __init__(self,args):
308 self.CMD=['SALOME_Registry_Server', '--salome_session','theSession']
312 class ContainerCPPServer(Server):
313 def __init__(self,args):
316 self.CMD=['SALOME_Container','FactoryServer']
320 class ContainerPYServer(Server):
321 def __init__(self,args):
324 self.CMD=['SALOME_ContainerPy.py','FactoryServerPy']
328 class ContainerSUPERVServer(Server):
329 def __init__(self,args):
332 self.CMD=['SALOME_Container','SuperVisionContainer']
336 class LoggerServer(Server):
337 def __init__(self,args):
340 self.CMD=['SALOME_Logger_Server', 'logger.log']
344 class SessionLoader(Server):
345 def __init__(self,args):
348 self.CMD=['SALOME_Session_Loader']
349 if "cppContainer" in self.args['standalone'] \
350 or "cppContainer" in self.args['embedded']:
351 self.CMD=self.CMD+['CPP']
352 if "pyContainer" in self.args['standalone'] \
353 or "pyContainer" in self.args['embedded']:
354 self.CMD=self.CMD+['PY']
355 if "supervContainer" in self.args['containers'] \
356 or "supervContainer" in self.args['standalone']:
357 self.CMD=self.CMD+['SUPERV']
359 self.CMD=self.CMD+['GUI']
364 class SessionServer(Server):
365 def __init__(self,args):
368 self.SCMD1=['SALOME_Session_Server']
370 if 'registry' in self.args['embedded']:
371 self.SCMD1+=['--with','Registry',
372 '(','--salome_session','theSession',')']
373 if 'moduleCatalog' in self.args['embedded']:
374 self.SCMD1+=['--with','ModuleCatalog','(','-common']
375 self.SCMD2+=['-personal',
376 '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
377 if 'study' in self.args['embedded']:
378 self.SCMD2+=['--with','SALOMEDS','(',')']
379 if 'cppContainer' in self.args['embedded']:
380 self.SCMD2+=['--with','Container','(','FactoryServer',')']
382 def setpath(self,modules_list,modules_root_dir):
384 list_modules = modules_list[:]
385 list_modules.reverse()
386 for module in ["KERNEL"] + list_modules:
387 module_root_dir=modules_root_dir[module]
388 module_cata=module+"Catalog.xml"
389 print " ", module_cata
391 glob.glob(os.path.join(module_root_dir,"share",
392 self.args['appname'],"resources",
394 if 'moduleCatalog' in self.args['embedded']:
395 self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
397 self.CMD=self.SCMD1 + self.SCMD2
399 ## # arguments SALOME_Session_Server pour ddd
401 ## for mot in self.CMD:
412 class ContainerManagerServer(Server):
413 def __init__(self,args):
416 self.SCMD1=['SALOME_ContainerManagerServer']
418 if 'registry' in self.args['embedded']:
419 self.SCMD1+=['--with','Registry',
420 '(','--salome_session','theSession',')']
421 if 'moduleCatalog' in self.args['embedded']:
422 self.SCMD1+=['--with','ModuleCatalog','(','-common']
423 self.SCMD2+=['-personal',
424 '${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
425 if 'study' in self.args['embedded']:
426 self.SCMD2+=['--with','SALOMEDS','(',')']
427 if 'cppContainer' in self.args['embedded']:
428 self.SCMD2+=['--with','Container','(','FactoryServer',')']
430 def setpath(self,modules_list,modules_root_dir):
432 list_modules = modules_list[:]
433 list_modules.reverse()
434 for module in ["KERNEL"] + list_modules:
435 module_root_dir=modules_root_dir[module]
436 module_cata=module+"Catalog.xml"
437 print " ", module_cata
439 glob.glob(os.path.join(module_root_dir,"share",
440 self.args['appname'],"resources",
442 if 'moduleCatalog' in self.args['embedded']:
443 self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
445 self.CMD=self.SCMD1 + self.SCMD2
447 class NotifyServer(Server):
448 def __init__(self,args,modules_root_dir):
451 self.modules_root_dir=modules_root_dir
452 myLogName = os.environ["LOGNAME"]
453 self.CMD=['notifd','-c',
454 self.modules_root_dir["KERNEL"] +'/share/salome/resources/channel.cfg',
455 '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior',
456 '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior',
457 '-DReportLogFile=/tmp/'+myLogName+'_notifd.report',
458 '-DDebugLogFile=/tmp/'+myLogName+'_notifd.debug',
462 # -----------------------------------------------------------------------------
465 """Salome Session Graphic User Interface activation"""
467 session=clt.waitNS("/Kernel/Session",SALOME.Session)
468 session.GetInterface()
470 # -----------------------------------------------------------------------------
472 def startSalome(args, modules_list, modules_root_dir):
473 """Launch all SALOME servers requested by args"""
474 init_time = os.times()
477 # Lancement Session Loader
480 print "startSalome ", args
483 myServer=SessionLoader(args)
487 # Initialisation ORB et Naming Service
490 clt=orbmodule.client()
492 # (non obligatoire) Lancement Logger Server
493 # et attente de sa disponibilite dans le naming service
497 myServer=LoggerServer(args)
499 clt.waitLogger("Logger")
501 # Notify Server launch
504 print "Notify Server to launch"
506 myServer=NotifyServer(args,modules_root_dir)
510 # Lancement Registry Server,
511 # attente de la disponibilite du Registry dans le Naming Service
514 if 'registry' not in args['embedded']:
515 myServer=RegistryServer(args)
517 clt.waitNS("/Registry")
520 # Lancement Catalog Server,
521 # attente de la disponibilite du Catalog Server dans le Naming Service
525 if 'moduleCatalog' not in args['embedded']:
526 cataServer=CatalogServer(args)
527 cataServer.setpath(modules_list,modules_root_dir)
529 import SALOME_ModuleCatalog
530 clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
533 # Lancement SalomeDS Server,
534 # attente de la disponibilite du SalomeDS dans le Naming Service
537 os.environ["CSF_PluginDefaults"] \
538 = os.path.join(modules_root_dir["KERNEL"],"share",
539 args['appname'],"resources")
540 os.environ["CSF_SALOMEDS_ResourcesDefaults"] \
541 = os.path.join(modules_root_dir["KERNEL"],"share",
542 args['appname'],"resources")
544 if "GEOM" in modules_list:
545 print "GEOM OCAF Resources"
546 os.environ["CSF_GEOMDS_ResourcesDefaults"] \
547 = os.path.join(modules_root_dir["GEOM"],"share",
548 args['appname'],"resources")
549 print "GEOM Shape Healing Resources"
550 os.environ["CSF_ShHealingDefaults"] \
551 = os.path.join(modules_root_dir["GEOM"],"share",
552 args['appname'],"resources")
554 if 'study' not in args['embedded']:
555 myServer=SalomeDSServer(args)
557 clt.waitNS("/myStudyManager")
560 # Lancement ContainerManagerServer
563 myCmServer = ContainerManagerServer(args)
564 myCmServer.setpath(modules_list,modules_root_dir)
568 # Lancement Session Server
571 mySessionServ = SessionServer(args)
572 mySessionServ.setpath(modules_list,modules_root_dir)
576 #pid = os.spawnvp(os.P_NOWAIT, macomm2[0], macomm2)
578 # Attente de la disponibilite du Session Server dans le Naming Service
582 session=clt.waitNS("/Kernel/Session",SALOME.Session)
584 from Utils_Identity import getShortHostName
586 if os.getenv("HOSTNAME") == None:
587 if os.getenv("HOST") == None:
588 os.environ["HOSTNAME"]=getShortHostName()
590 os.environ["HOSTNAME"]=os.getenv("HOST")
592 theComputer = getShortHostName()
595 # Lancement Container C++ local,
596 # attente de la disponibilite du Container C++ local dans le Naming Service
599 if 'cppContainer' in args['standalone']:
600 myServer=ContainerCPPServer(args)
602 clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
605 # Lancement Container Python local,
606 # attente de la disponibilite du Container Python local
607 # dans le Naming Service
610 if 'pyContainer' in args['standalone']:
611 myServer=ContainerPYServer(args)
613 clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
616 # Lancement Container Supervision local,
617 # attente de la disponibilite du Container Supervision local
618 # dans le Naming Service
621 if 'supervContainer' in args['standalone']:
622 myServer=ContainerSUPERVServer(args)
624 clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
626 end_time = os.times()
628 print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4]
632 # additionnal external python interpreters
639 nbaddi = int(args['interp'][0])
642 traceback.print_exc()
643 print "-------------------------------------------------------------"
644 print "-- to get an external python interpreter:runSalome --interp=1"
645 print "-------------------------------------------------------------"
647 print "additional external python interpreters: ", nbaddi
649 for i in range(nbaddi):
651 anInterp=InterpServer(args)
656 # -----------------------------------------------------------------------------
658 def useSalome(args, modules_list, modules_root_dir):
660 Launch all SALOME servers requested by args,
661 save list of process, give info to user,
662 show registered objects in Naming Service.
667 clt = startSalome(args, modules_list, modules_root_dir)
670 traceback.print_exc()
673 print "--- erreur au lancement Salome ---"
677 filedict = '/tmp/' + os.getenv('USER') + "_" + str(args['port']) \
678 + '_' + args['appname'].upper() + '_pidict'
682 fpid=open(filedict, 'r')
683 process_ids=pickle.load(fpid)
688 fpid=open(filedict, 'w')
689 process_ids.append(process_id)
690 pickle.dump(process_ids,fpid)
694 Saving of the dictionary of Salome processes in %s
695 To kill SALOME processes from a console (kill all sessions from all ports):
697 To kill SALOME from the present interpreter, if it is not closed :
698 killLocalPort() --> kill this session
699 (use CORBA port from args of runSalome)
700 givenPortKill(port) --> kill a specific session with given CORBA port
701 killAllPorts() --> kill all sessions
703 runSalome, with --killall option, starts with killing
704 the processes resulting from the previous execution.
708 # Impression arborescence Naming Service
713 print " --- registered objects tree in Naming Service ---"
718 # -----------------------------------------------------------------------------
720 def registerEnv(args, modules_list, modules_root_dir):
722 Register args, modules_list, modules_root_dir in a file
723 for further use, when SALOME is launched embedded in an other application.
725 fileEnv = '/tmp/' + os.getenv('USER') + "_" + str(args['port']) \
726 + '_' + args['appname'].upper() + '_env'
727 fenv=open(fileEnv,'w')
728 pickle.dump((args, modules_list, modules_root_dir),fenv)
730 os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
732 # -----------------------------------------------------------------------------
735 """Salome Launch, when embedded in other application"""
736 fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
737 fenv=open(fileEnv,'r')
738 args, modules_list, modules_root_dir = pickle.load(fenv)
741 clt = useSalome(args, modules_list, modules_root_dir)
744 # -----------------------------------------------------------------------------
747 """Salome launch as a main application"""
748 args, modules_list, modules_root_dir = get_config()
750 set_env(args, modules_list, modules_root_dir)
751 clt = useSalome(args, modules_list, modules_root_dir)
754 # -----------------------------------------------------------------------------
756 if __name__ == "__main__":