bin/runSalome.py

   1 #!/usr/bin/env python
   2
   3 import sys, os, string, glob, time, pickle
   4
   5 ### read launch configure xml file and command line options
   6 import launchConfigureParser
   7 args = launchConfigureParser.args
   8
   9 ### kill servers if it is need
  10
  11 from killSalome import killAllPorts
  12
  13 def killLocalPort():
  14     from killSalomeWithPort import killMyPort
  15     my_port=str(args['port'])
  16     try:
  17         killMyPort(my_port)
  18     except:
  19         print "problem in killLocalPort()"
  20         pass
  21     pass
  22
  23 if args['killall']:
  24     killAllPorts()
  25 elif args['portkill']:
  26     killLocalPort()
  27
  28 # -----------------------------------------------------------------------------
  29 #
  30 # Fonctions helper pour ajouter des variables d'environnement
  31 #
  32
  33 def add_path(directory, variable_name):
  34     if not os.environ.has_key(variable_name):
  35         os.environ[variable_name] = ""
  36         pass
  37     if os.path.exists(directory):
  38         for _dir in os.environ[variable_name].split(":"):
  39             if os.path.exists(_dir):
  40                 if os.path.samefile(_dir, directory):
  41                     return
  42             else:
  43                 if os.path.abspath(_dir) == os.path.abspath(directory):
  44                     return
  45             pass
  46         if os.environ[variable_name] == "":
  47             os.environ[variable_name] = directory
  48         else:
  49             os.environ[variable_name] = directory + ":" + os.environ[variable_name]
  50         if variable_name == "PYTHONPATH":
  51             sys.path[:0] = [directory]
  52
  53
  54 init_time = os.times()
  55 # -----------------------------------------------------------------------------
  56 #
  57 # Check variables <module>_ROOT_DIR and set list of used modules (without KERNEL)
  58 # Add to the PATH-variables modules' specific paths
  59 #
  60 modules_list = []
  61 if args.has_key("modules"):
  62     modules_list += args["modules"]
  63 modules_list[:0] = ["KERNEL"] # KERNEL must be last in the list to locate it at the first place in PATH variables
  64 modules_list.reverse()
  65
  66 modules_root_dir = {}
  67 modules_root_dir_list = []
  68 python_version="python%d.%d" % sys.version_info[0:2]
  69
  70 to_remove_list=[]
  71 for module in modules_list :
  72     module_variable=module.upper()+"_ROOT_DIR"
  73     if not os.environ.has_key(module_variable):
  74         print "*******************************************************************************"
  75         print "*"
  76         print "* Environment variable",module_variable,"must be set"
  77         print "* Module", module, "will be not available"
  78         print "*"
  79         print "*******************************************************************************"
  80         to_remove_list.append(module)
  81         continue
  82         pass
  83     module_root_dir = os.environ[module_variable]
  84     modules_root_dir[module]=module_root_dir
  85     modules_root_dir_list[:0] = [module_root_dir]
  86     add_path(os.path.join(module_root_dir,"lib",args['appname']), "LD_LIBRARY_PATH")
  87     add_path(os.path.join(module_root_dir,"bin",args['appname']), "PATH")
  88     if os.path.exists(module_root_dir + "/examples") :
  89         add_path(os.path.join(module_root_dir,"examples"), "PYTHONPATH")
  90
  91 for to_remove in to_remove_list:
  92     modules_list.remove(to_remove)
  93
  94 while "KERNEL" in modules_list:
  95     modules_list.remove("KERNEL")
  96     pass
  97
  98 # KERNEL must be last in the list to locate it at the first place in PYTHONPATH variable
  99 list_modules = modules_list[:] + ["KERNEL"]
 100 for module in list_modules:
 101     module_root_dir = modules_root_dir[module]
 102     add_path(os.path.join(module_root_dir,"bin",args['appname']), "PYTHONPATH")
 103     add_path(os.path.join(module_root_dir,"lib",python_version,"site-packages",args['appname']), "PYTHONPATH")
 104     add_path(os.path.join(module_root_dir,"lib",args['appname']), "PYTHONPATH")
 105     add_path(os.path.join(module_root_dir,"lib",python_version,"site-packages",args['appname'],"shared_modules"), "PYTHONPATH")
 106
 107 #os.environ["SALOMEPATH"]=":".join(modules_root_dir.values())
 108 os.environ["SALOMEPATH"]=":".join(modules_root_dir_list)
 109 if "SUPERV" in modules_list and not 'superv' in args['standalone']:
 110     args['standalone'].append("superv")
 111     pass
 112
 113
 114 # -----------------------------------------------------------------------------
 115 #
 116 # Définition des classes d'objets pour le lancement des Server CORBA
 117 #
 118
 119 class Server:
 120    CMD=[]
 121    if args['xterm']:
 122         ARGS=['xterm', '-iconic', '-sb', '-sl', '500', '-hold']
 123    else:
 124         ARGS=[]
 125
 126    def run(self):
 127        global process_id
 128        myargs=self.ARGS
 129        if args['xterm']:
 130            # (Debian) Transfert variable LD_LIBRARY_PATH aux shells fils (xterm)
 131            env_ld_library_path=['env', 'LD_LIBRARY_PATH='+ os.getenv("LD_LIBRARY_PATH")]
 132            myargs = myargs +['-T']+self.CMD[:1]+['-e'] + env_ld_library_path
 133        command = myargs + self.CMD
 134        #print "command = ", command
 135        pid = os.spawnvp(os.P_NOWAIT, command[0], command)
 136        process_id[pid]=self.CMD
 137
 138 class CatalogServer(Server):
 139    SCMD1=['SALOME_ModuleCatalog_Server','-common']
 140    SCMD2=['-personal','${HOME}/Salome/resources/CatalogModulePersonnel.xml']
 141
 142    def setpath(self,modules_list):
 143       cata_path=[]
 144       list_modules = modules_list[:]
 145       list_modules.reverse()
 146       for module in ["KERNEL"] + list_modules:
 147           module_root_dir=modules_root_dir[module]
 148           module_cata=module+"Catalog.xml"
 149           print "   ", module_cata
 150           cata_path.extend(glob.glob(os.path.join(module_root_dir,"share",args['appname'],"resources",module_cata)))
 151       self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 152
 153 class SalomeDSServer(Server):
 154    CMD=['SALOMEDS_Server']
 155
 156 class RegistryServer(Server):
 157    CMD=['SALOME_Registry_Server', '--salome_session','theSession']
 158
 159 class ContainerCPPServer(Server):
 160    #CMD=['SALOME_Container','FactoryServer','-ORBInitRef','NameService=corbaname::localhost']
 161    CMD=['SALOME_Container','FactoryServer']
 162
 163 class ContainerPYServer(Server):
 164    #CMD=['SALOME_ContainerPy.py','FactoryServerPy','-ORBInitRef','NameService=corbaname::localhost']
 165    CMD=['SALOME_ContainerPy.py','FactoryServerPy']
 166
 167 class ContainerSUPERVServer(Server):
 168    #CMD=['SALOME_Container','SuperVisionContainer','-ORBInitRef','NameService=corbaname::localhost']
 169    CMD=['SALOME_Container','SuperVisionContainer']
 170
 171 class LoggerServer(Server):
 172    CMD=['SALOME_Logger_Server', 'logger.log']
 173
 174 class SessionLoader(Server):
 175    CMD=['SALOME_Session_Loader']
 176    if "cpp" in args['containers']:
 177        CMD=CMD+['CPP']
 178    if "python" in args['containers']:
 179        CMD=CMD+['PY']
 180    if "superv" in args['containers']:
 181        CMD=CMD+['SUPERV']
 182    if args['gui']:
 183        CMD=CMD+['GUI']
 184
 185 class SessionServer(Server):
 186    SCMD1=['SALOME_Session_Server']
 187    SCMD2=[]
 188    if 'registry' in args['embedded']:
 189        SCMD1+=['--with','Registry','(','--salome_session','theSession',')']
 190    if 'moduleCatalog' in args['embedded']:
 191        SCMD1+=['--with','ModuleCatalog','(','-common']
 192        SCMD2+=['-personal','${HOME}/Salome/resources/CatalogModulePersonnel.xml',')']
 193    if 'study' in args['embedded']:
 194        SCMD2+=['--with','SALOMEDS','(',')']
 195    if 'cppContainer' in args['embedded']:
 196        SCMD2+=['--with','Container','(','FactoryServer',')']
 197
 198    def setpath(self,modules_list):
 199       cata_path=[]
 200       list_modules = modules_list[:]
 201       list_modules.reverse()
 202       for module in ["KERNEL"] + list_modules:
 203           module_root_dir=modules_root_dir[module]
 204           module_cata=module+"Catalog.xml"
 205           print "   ", module_cata
 206           cata_path.extend(glob.glob(os.path.join(module_root_dir,"share",args['appname'],"resources",module_cata)))
 207       if 'moduleCatalog' in args['embedded']:
 208           self.CMD=self.SCMD1 + [string.join(cata_path,':')] + self.SCMD2
 209       else:
 210           self.CMD=self.SCMD1 + self.SCMD2
 211
 212 class NotifyServer(Server):
 213     myLogName = os.environ["LOGNAME"]
 214     CMD=['notifd','-c',modules_root_dir["KERNEL"]+'/share/salome/resources/channel.cfg', '-DFactoryIORFileName=/tmp/'+myLogName+'_rdifact.ior', '-DChannelIORFileName=/tmp/'+myLogName+'_rdichan.ior']
 215
 216 # -----------------------------------------------------------------------------
 217 #
 218 # initialisation des variables d'environnement
 219 #
 220
 221 os.environ["SALOME_trace"]="local"
 222 if args['logger']:
 223    os.environ["SALOME_trace"]="with_logger"
 224    locdir=os.environ['PWD']
 225    libtracedir=os.path.join(locdir,"libSalomeTrace")
 226    libtrace = os.path.join(modules_root_dir["KERNEL"],"lib",args['appname'],"libSALOMELoggerClient.so.0.0.0")
 227    libtraceln = os.path.join(libtracedir,"libSALOMELocalTrace.so")
 228    aCommand = 'rm -rf ' + libtracedir + "; "
 229    aCommand += 'mkdir ' + libtracedir + "; "
 230    aCommand += 'ln -s ' + libtrace + " " + libtraceln + "; "
 231    aCommand += 'ln -s ' + libtrace + " " + libtraceln + ".0; "
 232    aCommand += 'ln -s ' + libtrace + " " + libtraceln + ".0.0.0; "
 233    os.system(aCommand)
 234    add_path(libtracedir, "LD_LIBRARY_PATH")
 235
 236 # set environment for SMESH plugins
 237
 238 if "SMESH" in modules_list:
 239     os.environ["SMESH_MeshersList"]="StdMeshers"
 240     if not os.environ.has_key("SALOME_StdMeshersResources"):
 241         os.environ["SALOME_StdMeshersResources"] = modules_root_dir["SMESH"]+"/share/"+args["appname"]+"/resources"
 242         pass
 243     if args.has_key("SMESH_plugins"):
 244         for plugin in args["SMESH_plugins"]:
 245             if os.environ.has_key(plugin.upper()+"_ROOT_DIR"):
 246                 os.environ["SMESH_MeshersList"]=os.environ["SMESH_MeshersList"]+":"+plugin
 247                 plugin_root = os.environ[plugin.upper()+"_ROOT_DIR"]
 248                 if not os.environ.has_key("SALOME_"+plugin+"Resources"):
 249                     os.environ["SALOME_"+plugin+"Resources"] = plugin_root+"/share/"+args["appname"]+"/resources"
 250                 add_path(os.path.join(plugin_root,"lib",python_version,"site-packages",args['appname']), "PYTHONPATH")
 251                 add_path(os.path.join(plugin_root,"lib",args['appname']), "PYTHONPATH")
 252                 add_path(os.path.join(plugin_root,"lib",args['appname']), "LD_LIBRARY_PATH")
 253                 add_path(os.path.join(plugin_root,"bin",args['appname']), "PYTHONPATH")
 254                 add_path(os.path.join(plugin_root,"bin",args['appname']), "PATH")
 255         pass
 256     pass
 257
 258 import orbmodule
 259
 260 #
 261 # -----------------------------------------------------------------------------
 262 #
 263
 264 def startGUI():
 265   import SALOME
 266   session=clt.waitNS("/Kernel/Session",SALOME.Session)
 267
 268   #
 269   # Activation du GUI de Session Server
 270   #
 271
 272   session.GetInterface()
 273
 274 #
 275 # -----------------------------------------------------------------------------
 276 #
 277
 278 def startSalome():
 279
 280   #
 281   # Lancement Session Loader
 282   #
 283
 284   if args['gui']:
 285      SessionLoader().run()
 286
 287   #
 288   # Initialisation ORB et Naming Service
 289   #
 290
 291   clt=orbmodule.client()
 292
 293   # (non obligatoire) Lancement Logger Server et attente de sa disponibilite dans le naming service
 294   #
 295
 296   if args['logger']:
 297         LoggerServer().run()
 298         clt.waitLogger("Logger")
 299
 300   # Notify Server launch
 301   #
 302   NotifyServer().run()
 303
 304   #
 305   # Lancement Registry Server, attente de la disponibilité du Registry dans le Naming Service
 306   #
 307   if 'registry' not in args['embedded']:
 308       RegistryServer().run()
 309       clt.waitNS("/Registry")
 310
 311   #
 312   # Lancement Catalog Server, attente de la disponibilité du Catalog Server dans le Naming Service
 313   #
 314
 315   if 'moduleCatalog' not in args['embedded']:
 316       cataServer=CatalogServer()
 317       cataServer.setpath(modules_list)
 318       cataServer.run()
 319       import SALOME_ModuleCatalog
 320       clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
 321
 322   #
 323   # Lancement SalomeDS Server, attente de la disponibilité du SalomeDS dans le Naming Service
 324   #
 325
 326   os.environ["CSF_PluginDefaults"]=os.path.join(modules_root_dir["KERNEL"],"share",args['appname'],"resources")
 327   os.environ["CSF_SALOMEDS_ResourcesDefaults"]=os.path.join(modules_root_dir["KERNEL"],"share",args['appname'],"resources")
 328
 329   if "GEOM" in modules_list:
 330         print "GEOM OCAF Resources"
 331         os.environ["CSF_GEOMDS_ResourcesDefaults"]=os.path.join(modules_root_dir["GEOM"],"share",args['appname'],"resources")
 332
 333   if 'study' not in args['embedded']:
 334       SalomeDSServer().run()
 335       clt.waitNS("/myStudyManager")
 336
 337   #
 338   # Lancement Session Server
 339   #
 340
 341   mySessionServ=SessionServer()
 342   mySessionServ.setpath(modules_list)
 343   mySessionServ.run()
 344
 345   #
 346   # Attente de la disponibilité du Session Server dans le Naming Service
 347   #
 348
 349   #import SALOME
 350   #session=clt.waitNS("/Kernel/Session",SALOME.Session)
 351
 352   if os.getenv("HOSTNAME") == None:
 353      if os.getenv("HOST") == None:
 354         os.environ["HOSTNAME"]="localhost"
 355      else:
 356         os.environ["HOSTNAME"]=os.getenv("HOST")
 357
 358   theComputer = os.getenv("HOSTNAME")
 359   computerSplitName = theComputer.split('.')
 360   theComputer = computerSplitName[0]
 361
 362   #
 363   # Lancement Container C++ local, attente de la disponibilité du Container C++ local dans le Naming Service
 364   #
 365
 366   if 'cppContainer' in args['standalone']:
 367           ContainerCPPServer().run()
 368           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
 369
 370   #
 371   # Lancement Container Python local, attente de la disponibilité du Container Python local dans le Naming Service
 372   #
 373
 374   if 'pyContainer' in args['standalone']:
 375           ContainerPYServer().run()
 376           clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
 377
 378   #
 379   # Lancement Container Supervision local, attente de la disponibilité du Container Supervision local dans le Naming Service
 380   #
 381
 382   if 'supervContainer' in args['standalone']:
 383       ContainerSUPERVServer().run()
 384       clt.waitNS("/Containers/" + theComputer + "/SuperVisionContainer")
 385
 386   end_time = os.times()
 387   print
 388   print "Start SALOME, elapsed time : %5.1f seconds"% (end_time[4] - init_time[4])
 389
 390   return clt
 391
 392 #
 393 # -----------------------------------------------------------------------------
 394 #
 395
 396 process_id = {}
 397 if __name__ == "__main__":
 398     clt=None
 399     try:
 400         clt = startSalome()
 401     except:
 402         print
 403         print
 404         print "--- erreur au lancement Salome ---"
 405
 406     #print process_id
 407
 408     filedict='/tmp/'+os.getenv('USER')+"_"+str(args['port'])+'_'+args['appname'].upper()+'_pidict'
 409     #filedict='/tmp/'+os.getlogin()+'_SALOME_pidict'
 410
 411
 412     process_ids = []
 413     try:
 414         fpid=open(filedict, 'r')
 415         process_ids=pickle.load(fpid)
 416         fpid.close()
 417     except:
 418         pass
 419
 420     fpid=open(filedict, 'w')
 421     process_ids.append(process_id)
 422     pickle.dump(process_ids,fpid)
 423     fpid.close()
 424
 425     print """
 426     Saving of the dictionary of Salome processes in %s
 427     To kill SALOME processes from a console (kill all sessions from all ports):
 428       python killSalome.py
 429     To kill SALOME from the present interpreter, if it is not closed :
 430       killLocalPort()  --> kill this session
 431       killAllPorts()   --> kill all sessions
 432
 433     runSalome, with --killall option, starts with killing the processes resulting from the previous execution.
 434     """%filedict
 435
 436     #
 437     #  Impression arborescence Naming Service
 438     #
 439
 440     if clt != None:
 441         print
 442         print " --- registered objects tree in Naming Service ---"
 443         clt.showNS()