Back to index

salome-kernel  6.5.0
Classes | Functions | Variables
runSalome Namespace Reference

Module that provides services to launch SALOME. More...

Classes

class  InterpServer
class  CatalogServer
class  SalomeDSServer
class  ConnectionManagerServer
class  RegistryServer
class  ContainerCPPServer
class  ContainerPYServer
class  LoggerServer
class  SessionServer
class  LauncherServer
class  NotifyServer

Functions

def killLocalPort
def givenPortKill
def kill_salome
def get_cata_path
def startGUI
def startSalome
def useSalome
def execScript
def registerEnv
def searchFreePort
def no_main
def main
def foreGround

Variables

string SEP = ";"
tuple session = clt.waitNS("/Kernel/Session",SALOME.Session)
tuple end_time = os.times()
int nbaddi = 0
tuple anInterp = InterpServer(args)
list test = args['gui']
tuple iflag_ptr = cast(pythonapi.Py_InteractiveFlag, POINTER(c_int))
 port
 killSalomeWithPort

Detailed Description

Module that provides services to launch SALOME.


Function Documentation

def runSalome.execScript (   script_path)

Definition at line 785 of file runSalome.py.

00785 
00786 def execScript(script_path):
00787     print 'executing', script_path
00788     sys.path.insert(0, os.path.dirname(script_path))
00789     execfile(script_path,globals())
00790     del sys.path[0]
00791 
00792 # -----------------------------------------------------------------------------

def runSalome.foreGround (   clt,
  args 
)

Definition at line 956 of file runSalome.py.

00956 
00957 def foreGround(clt, args):
00958     # --
00959     if "session_object" not in args:
00960         return
00961     session = args["session_object"]
00962     # --
00963     # Wait until gui is arrived
00964     # tmax = nbtot * dt
00965     # --
00966     gui_detected = False
00967     dt = 0.1
00968     nbtot = 100
00969     nb = 0
00970     while 1:
00971         try:
00972             status = session.GetStatSession()
00973             gui_detected = status.activeGUI
00974         except:
00975             pass
00976         if gui_detected:
00977             break
00978         from time import sleep
00979         sleep(dt)
00980         nb += 1
00981         if nb == nbtot:
00982             break
00983         pass
00984     # --
00985     if not gui_detected:
00986         return
00987     # --
00988     from salome_utils import getPortNumber
00989     port = getPortNumber()
00990     # --
00991     server = Server({})
00992     if sys.platform == "win32":
00993       server.CMD = [os.getenv("PYTHONBIN"), "-m", "killSalomeWithPort", "--spy", "%s"%(os.getpid()), "%s"%(port)]
00994     else:
00995       server.CMD = ["killSalomeWithPort.py", "--spy", "%s"%(os.getpid()), "%s"%(port)]
00996     server.run()   
00997     # os.system("killSalomeWithPort.py --spy %s %s &"%(os.getpid(), port))
00998     # --
00999     dt = 1.0
01000     try:
01001         while 1:
01002             try:
01003                 status = session.GetStatSession()
01004                 assert status.activeGUI
01005             except:
01006                 break
01007             from time import sleep
01008             sleep(dt)
01009             pass
01010         pass
01011     except KeyboardInterrupt:
01012         from killSalomeWithPort import killMyPort
01013         killMyPort(port)
01014         pass
01015     return
01016 
01017 # -----------------------------------------------------------------------------

Here is the call graph for this function:

def runSalome.get_cata_path (   list_modules,
  modules_root_dir 
)
Build a list of catalog paths (cata_path) to initialize the ModuleCatalog server

Definition at line 114 of file runSalome.py.

00114 
00115 def get_cata_path(list_modules,modules_root_dir):
00116     """Build a list of catalog paths (cata_path) to initialize the ModuleCatalog server
00117     """
00118     modules_cata={}
00119     cata_path=[]
00120 
00121     for module in list_modules:
00122         if modules_root_dir.has_key(module):
00123             module_root_dir=modules_root_dir[module]
00124             module_cata=module+"Catalog.xml"
00125             cata_file=os.path.join(module_root_dir, "share",setenv.salome_subdir, "resources",module.lower(), module_cata)
00126 
00127             if os.path.exists(cata_file):
00128                 cata_path.append(cata_file)
00129                 modules_cata[module]=cata_file
00130             else:
00131                 cata_file=os.path.join(module_root_dir, "share",setenv.salome_subdir, "resources", module_cata)
00132                 if os.path.exists(cata_file):
00133                     cata_path.append(cata_file)
00134                     modules_cata[module]=cata_file
00135 
00136     for path in os.getenv("SALOME_CATALOGS_PATH","").split(SEP):
00137         if os.path.exists(path):
00138             for cata_file in glob.glob(os.path.join(path,"*Catalog.xml")):
00139                 module_name= os.path.basename(cata_file)[:-11]
00140                 if not modules_cata.has_key(module_name):
00141                     cata_path.append(cata_file)
00142                     modules_cata[module_name]=cata_file
00143 
00144     return cata_path
00145 
00146 

Here is the caller graph for this function:

def runSalome.givenPortKill (   port)
kill servers from a previous SALOME exection, if needed,
on the same CORBA port

Definition at line 59 of file runSalome.py.

00059 
00060 def givenPortKill(port):
00061     """
00062     kill servers from a previous SALOME exection, if needed,
00063     on the same CORBA port
00064     """
00065     
00066     from killSalomeWithPort import killMyPort
00067     my_port=port
00068     try:
00069         killMyPort(my_port)
00070     except:
00071         print "problem in LocalPortKill(), killMyPort("<<port<<")"
00072         pass
00073     pass

Here is the call graph for this function:

Here is the caller graph for this function:

def runSalome.kill_salome (   args)
Kill servers from previous SALOME executions, if needed;
depending on args 'killall' or 'portkill', kill all executions,
or only execution on the same CORBA port

Definition at line 74 of file runSalome.py.

00074 
00075 def kill_salome(args):
00076     """
00077     Kill servers from previous SALOME executions, if needed;
00078     depending on args 'killall' or 'portkill', kill all executions,
00079     or only execution on the same CORBA port
00080     """
00081 
00082     if args['killall']:
00083         killAllPorts()
00084     elif args['portkill']:
00085         givenPortKill(str(args['port']))
00086 
00087 # -----------------------------------------------------------------------------
00088 #
00089 # Class definitions to launch CORBA Servers
00090 #

Here is the call graph for this function:

Here is the caller graph for this function:

kill servers from a previous SALOME exection, if needed,
on the CORBA port given in args of runSalome

Definition at line 44 of file runSalome.py.

00044 
00045 def killLocalPort():
00046     """
00047     kill servers from a previous SALOME exection, if needed,
00048     on the CORBA port given in args of runSalome
00049     """
00050     
00051     from killSalomeWithPort import killMyPort
00052     my_port=str(args['port'])
00053     try:
00054         killMyPort(my_port)
00055     except:
00056         print "problem in killLocalPort()"
00057         pass
00058     pass
    

Here is the call graph for this function:

Here is the caller graph for this function:

def runSalome.main ( )
Salome launch as a main application

Definition at line 931 of file runSalome.py.

00931 
00932 def main():
00933     """Salome launch as a main application"""
00934     from salome_utils import getHostName
00935     print "runSalome running on %s" % getHostName()
00936     args, modules_list, modules_root_dir = setenv.get_config()
00937     kill_salome(args)
00938     save_config = True
00939     if args.has_key('save_config'):
00940         save_config = args['save_config']
00941     # --
00942     test = True
00943     if args['wake_up_session']:
00944         test = False
00945         pass
00946     if test:
00947         searchFreePort(args, save_config)
00948         pass
00949     # --
00950     #setenv.main()
00951     setenv.set_env(args, modules_list, modules_root_dir)
00952     clt = useSalome(args, modules_list, modules_root_dir)
00953     return clt,args
00954 
00955 # -----------------------------------------------------------------------------

Here is the call graph for this function:

Here is the caller graph for this function:

Salome Launch, when embedded in other application

Definition at line 918 of file runSalome.py.

00918 
00919 def no_main():
00920     """Salome Launch, when embedded in other application"""
00921     fileEnv = os.environ["SALOME_LAUNCH_CONFIG"]
00922     fenv=open(fileEnv,'r')
00923     args, modules_list, modules_root_dir = pickle.load(fenv)
00924     fenv.close()
00925     kill_salome(args)
00926     searchFreePort(args, 0)
00927     clt = useSalome(args, modules_list, modules_root_dir)
00928     return clt
00929 
00930 # -----------------------------------------------------------------------------

Here is the call graph for this function:

def runSalome.registerEnv (   args,
  modules_list,
  modules_root_dir 
)
Register args, modules_list, modules_root_dir in a file
for further use, when SALOME is launched embedded in an other application.

Definition at line 793 of file runSalome.py.

00793 
00794 def registerEnv(args, modules_list, modules_root_dir):
00795     """
00796     Register args, modules_list, modules_root_dir in a file
00797     for further use, when SALOME is launched embedded in an other application.
00798     """
00799     if sys.platform == "win32":
00800       fileEnv = os.getenv('TEMP')
00801     else:
00802       fileEnv = '/tmp/'
00803 
00804     fileEnv += os.getenv('USER') + "_" + str(args['port']) \
00805             + '_' + args['appname'].upper() + '_env'
00806     fenv=open(fileEnv,'w')
00807     pickle.dump((args, modules_list, modules_root_dir),fenv)
00808     fenv.close()
00809     os.environ["SALOME_LAUNCH_CONFIG"] = fileEnv
00810 
00811 # -----------------------------------------------------------------------------

def runSalome.searchFreePort (   args,
  save_config = 1 
)

Definition at line 812 of file runSalome.py.

00812 
00813 def searchFreePort(args, save_config=1):
00814     print "Searching for a free port for naming service:",
00815     #
00816     if sys.platform == "win32":
00817         tmp_file = os.getenv('TEMP');
00818     else:
00819         tmp_file = '/tmp'
00820     tmp_file = os.path.join(tmp_file, '.netstat_%s'%os.getpid())
00821     #
00822     ###status = os.system("netstat -ltn | grep -E :%s > /dev/null 2>&1"%(NSPORT))
00823     os.system( "netstat -a -n > %s" % tmp_file );
00824     f = open( tmp_file, 'r' );
00825     ports = f.readlines();
00826     f.close();
00827     os.remove( tmp_file );
00828     #
00829     def portIsUsed(port, data):
00830         regObj = re.compile( ".*tcp.*:([0-9]+).*:.*listen", re.IGNORECASE );
00831         for item in data:
00832             try:
00833                 p = int(regObj.match(item).group(1))
00834                 if p == port: return True
00835                 pass
00836             except:
00837                 pass
00838             pass
00839         return False
00840     #
00841     NSPORT=2810
00842     limit=NSPORT+100
00843     #
00844     while 1:
00845         if not portIsUsed(NSPORT, ports):
00846             print "%s - OK"%(NSPORT)
00847             #
00848             from salome_utils import generateFileName, getHostName
00849             hostname = getHostName()
00850             #
00851             home  = os.getenv("HOME")
00852             appli = os.getenv("APPLI")
00853             kwargs={}
00854             if appli is not None: 
00855               home = os.path.join(home, appli,"USERS")
00856               kwargs["with_username"]=True
00857             #
00858             omniorb_config = generateFileName(home, prefix="omniORB",
00859                                               extension="cfg",
00860                                               hidden=True,
00861                                               with_hostname=True,
00862                                               with_port=NSPORT,
00863                                               **kwargs)
00864             orbdata = []
00865             initref = "NameService=corbaname::%s:%s"%(hostname, NSPORT)
00866             from omniORB import CORBA
00867             if CORBA.ORB_ID == "omniORB4":
00868                 orbdata.append("InitRef = %s"%(initref))
00869                 orbdata.append("giopMaxMsgSize = 2097152000  # 2 GBytes")
00870                 orbdata.append("traceLevel = 0 # critical errors only")
00871             else:
00872                 orbdata.append("ORBInitRef %s"%(initref))
00873                 orbdata.append("ORBgiopMaxMsgSize = 2097152000  # 2 GBytes")
00874                 orbdata.append("ORBtraceLevel = 0 # critical errors only")
00875                 pass
00876             orbdata.append("")
00877             f = open(omniorb_config, "w")
00878             f.write("\n".join(orbdata))
00879             f.close()
00880             #
00881             os.environ['OMNIORB_CONFIG'] = omniorb_config
00882             os.environ['NSPORT'] = "%s"%(NSPORT)
00883             os.environ['NSHOST'] = "%s"%(hostname)
00884             args['port'] = os.environ['NSPORT']
00885             #
00886             if save_config:
00887                 last_running_config = generateFileName(home, prefix="omniORB",
00888                                                        suffix="last",
00889                                                        extension="cfg",
00890                                                        hidden=True,
00891                                                        **kwargs)
00892                 try:
00893                     if sys.platform == "win32":
00894                         import shutil       
00895                         shutil.copyfile(omniorb_config, last_running_config)
00896                     else:
00897                         try:
00898                             os.remove(last_running_config)
00899                         except OSError:
00900                             pass
00901                         os.symlink(omniorb_config, last_running_config)
00902                         pass
00903                     pass
00904                 except:
00905                     pass
00906             break
00907         print "%s"%(NSPORT),
00908         if NSPORT == limit:
00909             msg  = "\n"
00910             msg += "Can't find a free port to launch omniNames\n"
00911             msg += "Try to kill the running servers and then launch SALOME again.\n"
00912             raise RuntimeError, msg
00913         NSPORT=NSPORT+1
00914         pass
00915     return
00916     
00917 # -----------------------------------------------------------------------------

Here is the call graph for this function:

Here is the caller graph for this function:

def runSalome.startGUI (   clt)
Salome Session Graphic User Interface activation

Definition at line 400 of file runSalome.py.

00400 
00401 def startGUI(clt):
00402     """Salome Session Graphic User Interface activation"""
00403     import Engines
00404     import SALOME
00405     import SALOMEDS
00406     import SALOME_ModuleCatalog
00407     import SALOME_Session_idl
00408     session=clt.waitNS("/Kernel/Session",SALOME.Session)
00409     session.GetInterface()
00410   
00411 # -----------------------------------------------------------------------------

def runSalome.startSalome (   args,
  modules_list,
  modules_root_dir 
)
Launch all SALOME servers requested by args

Definition at line 412 of file runSalome.py.

00412 
00413 def startSalome(args, modules_list, modules_root_dir):
00414     """Launch all SALOME servers requested by args"""
00415     init_time = os.times()
00416 
00417     if verbose(): print "startSalome ", args
00418     
00419     #
00420     # Set server launch command
00421     #
00422     if args.has_key('server_launch_mode'):
00423         Server.set_server_launch_mode(args['server_launch_mode'])
00424     
00425     #
00426     # Wake up session option
00427     #
00428     if args['wake_up_session']:
00429         if "OMNIORB_CONFIG" not in os.environ:
00430             from salome_utils import generateFileName
00431             home  = os.getenv("HOME")
00432             appli = os.getenv("APPLI")
00433             kwargs={}
00434             if appli is not None: 
00435                 home = os.path.join(home, appli,"USERS")
00436                 kwargs["with_username"] = True
00437                 pass
00438             last_running_config = generateFileName(home, prefix="omniORB",
00439                                                    suffix="last",
00440                                                    extension="cfg",
00441                                                    hidden=True,
00442                                                    **kwargs)
00443             os.environ['OMNIORB_CONFIG'] = last_running_config
00444             pass
00445         pass
00446     
00447     #
00448     # Initialisation ORB and Naming Service
00449     #
00450    
00451     clt=orbmodule.client(args)
00452 
00453     #
00454     # Wake up session option
00455     #
00456     if args['wake_up_session']:
00457         import Engines
00458         import SALOME
00459         import SALOMEDS
00460         import SALOME_ModuleCatalog
00461         import SALOME_Session_idl
00462         session = clt.waitNS("/Kernel/Session",SALOME.Session)
00463         status = session.GetStatSession()
00464         if status.activeGUI:
00465             from salome_utils import getPortNumber
00466             port = getPortNumber()
00467             msg  = "Warning :"
00468             msg += "\n"
00469             msg += "Session GUI for port number %s is already active."%(port)
00470             msg += "\n"
00471             msg += "If you which to wake up another session,"
00472             msg += "\n"
00473             msg += "please use variable OMNIORB_CONFIG"
00474             msg += "\n"
00475             msg += "to get the correct session object in naming service."
00476             sys.stdout.write(msg+"\n")
00477             sys.stdout.flush()
00478             return clt
00479         session.GetInterface()
00480         args["session_object"] = session
00481         return clt
00482     
00483     # Save Naming service port name into
00484     # the file args["ns_port_log_file"]
00485     if args.has_key('ns_port_log_file'):
00486       home = os.environ['HOME']
00487       appli= os.environ.get("APPLI")
00488       if appli is not None:
00489         home = os.path.join(home, appli, "USERS")
00490       file_name = os.path.join(home, args["ns_port_log_file"])
00491       f = open(file_name, "w")
00492       f.write(os.environ['NSPORT'])
00493       f.close()
00494 
00495     # Launch Logger Server (optional)
00496     # and wait until it is registered in naming service
00497     #
00498 
00499     if args['logger']:
00500         myServer=LoggerServer(args)
00501         myServer.run()
00502         clt.waitLogger("Logger")
00503 
00504     # Notify Server launch
00505     #
00506 
00507     if sys.platform != "win32":
00508       if verbose(): print "Notify Server to launch"
00509     
00510       myServer=NotifyServer(args,modules_root_dir)
00511       myServer.run()
00512 
00513     # Launch  Session Server (to show splash ASAP)
00514     #
00515 
00516     if args["gui"]:
00517         mySessionServ = SessionServer(args,args['modules'],modules_root_dir)
00518         mySessionServ.setpath(modules_list,modules_root_dir)
00519         mySessionServ.run()
00520 
00521     #
00522     # Launch Registry Server,
00523     # and wait until it is registered in naming service
00524     #
00525 
00526     if ('registry' not in args['embedded']) | (args["gui"] == 0) :
00527         myServer=RegistryServer(args)
00528         myServer.run()
00529         if sys.platform == "win32":
00530           clt.waitNS("/Registry")
00531         else:
00532           clt.waitNSPID("/Registry",myServer.PID)
00533 
00534     #
00535     # Launch Catalog Server,
00536     # and wait until it is registered in naming service
00537     #
00538 
00539     if ('moduleCatalog' not in args['embedded']) | (args["gui"] == 0):
00540         cataServer=CatalogServer(args)
00541         cataServer.setpath(modules_list,modules_root_dir)
00542         cataServer.run()
00543         import SALOME_ModuleCatalog
00544         if sys.platform == "win32":
00545           clt.waitNS("/Kernel/ModulCatalog",SALOME_ModuleCatalog.ModuleCatalog)
00546         else:
00547           clt.waitNSPID("/Kernel/ModulCatalog",cataServer.PID,SALOME_ModuleCatalog.ModuleCatalog)
00548 
00549     #
00550     # Launch SalomeDS Server,
00551     # and wait until it is registered in naming service
00552     #
00553 
00554     #print "ARGS = ",args
00555     if ('study' not in args['embedded']) | (args["gui"] == 0):
00556         print "RunStudy"
00557         myServer=SalomeDSServer(args)
00558         myServer.run()
00559         if sys.platform == "win32":
00560           clt.waitNS("/myStudyManager")
00561         else:
00562           clt.waitNSPID("/myStudyManager",myServer.PID)
00563 
00564     #
00565     # Launch LauncherServer
00566     #
00567     
00568     myCmServer = LauncherServer(args)
00569     myCmServer.setpath(modules_list,modules_root_dir)
00570     myCmServer.run()
00571 
00572     #
00573     # Launch ConnectionManagerServer
00574     #
00575 
00576     myConnectionServer = ConnectionManagerServer(args)
00577     myConnectionServer.run()
00578 
00579 
00580     from Utils_Identity import getShortHostName
00581     
00582     if os.getenv("HOSTNAME") == None:
00583         if os.getenv("HOST") == None:
00584             os.environ["HOSTNAME"]=getShortHostName()
00585         else:
00586             os.environ["HOSTNAME"]=os.getenv("HOST")
00587 
00588     theComputer = getShortHostName()
00589     
00590     #
00591     # Launch local C++ Container (FactoryServer),
00592     # and wait until it is registered in naming service
00593     #
00594 
00595     if ('cppContainer' in args['standalone']) | (args["gui"] == 0) : 
00596         myServer=ContainerCPPServer(args)
00597         myServer.run()
00598         if sys.platform == "win32":
00599           clt.waitNS("/Containers/" + theComputer + "/FactoryServer")
00600         else:
00601           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServer",myServer.PID)
00602 
00603     #
00604     # Launch local Python Container (FactoryServerPy),
00605     # and wait until it is registered in naming service
00606     #
00607 
00608     if 'pyContainer' in args['standalone']:
00609         myServer=ContainerPYServer(args)
00610         myServer.run()
00611         if sys.platform == "win32":
00612           clt.waitNS("/Containers/" + theComputer + "/FactoryServerPy")
00613         else:
00614           clt.waitNSPID("/Containers/" + theComputer + "/FactoryServerPy",myServer.PID)
00615 
00616     #
00617     # Wait until Session Server is registered in naming service
00618     #
00619     
    if args["gui"]:

Here is the call graph for this function:

Here is the caller graph for this function:

def runSalome.useSalome (   args,
  modules_list,
  modules_root_dir 
)
Launch all SALOME servers requested by args,
save list of process, give info to user,
show registered objects in Naming Service.

Definition at line 674 of file runSalome.py.

00674 
00675 def useSalome(args, modules_list, modules_root_dir):
00676     """
00677     Launch all SALOME servers requested by args,
00678     save list of process, give info to user,
00679     show registered objects in Naming Service.
00680     """
00681     global process_id
00682     
00683     clt=None
00684     try:
00685         clt = startSalome(args, modules_list, modules_root_dir)
00686     except:
00687         import traceback
00688         traceback.print_exc()
00689         print
00690         print
00691         print "--- Error during Salome launch ---"
00692         
00693     #print process_id
00694 
00695     from addToKillList import addToKillList
00696     from killSalomeWithPort import getPiDict
00697 
00698     filedict = getPiDict(args['port'])
00699     for pid, cmd in process_id.items():
00700         addToKillList(pid, cmd, args['port'])
00701         pass
00702 
00703     if verbose(): print """
00704     Saving of the dictionary of Salome processes in %s
00705     To kill SALOME processes from a console (kill all sessions from all ports):
00706       python killSalome.py 
00707     To kill SALOME from the present interpreter, if it is not closed :
00708       killLocalPort()      --> kill this session
00709                                (use CORBA port from args of runSalome)
00710       givenPortKill(port)  --> kill a specific session with given CORBA port 
00711       killAllPorts()       --> kill all sessions
00712     
00713     runSalome, with --killall option, starts with killing
00714     the processes resulting from the previous execution.
00715     """%filedict
00716     
00717     #
00718     #  Print Naming Service directory list
00719     #
00720     
00721     if clt != None:
00722         if verbose():
00723             print
00724             print " --- registered objects tree in Naming Service ---"
00725             clt.showNS()
00726             pass
00727         
00728         if not args['gui'] or not args['session_gui']:
00729             if args['shutdown_servers']:
00730                 class __utils__(object):
00731                     def __init__(self, port):
00732                         self.port = port
00733                         import killSalomeWithPort
00734                         self.killSalomeWithPort = killSalomeWithPort
00735                         return
00736                     def __del__(self):
00737                         self.killSalomeWithPort.killMyPort(self.port)
00738                         return
00739                     pass
00740                 args['shutdown_servers'] = __utils__(args['port'])
00741                 pass
00742             pass
00743         
00744         # run python scripts, passed via --execute option
00745         toimport = []
00746         if args.has_key('pyscript'):
00747             if args.has_key('gui') and args.has_key('session_gui'):
00748                 if not args['gui'] or not args['session_gui']:
00749                     toimport = args['pyscript']
00750 
00751         for srcname in toimport :
00752             if srcname == 'killall':
00753                 clt.showNS()
00754                 killAllPorts()
00755                 sys.exit(0)
00756             else:
00757                 if os.path.isabs(srcname):
00758                     if os.path.exists(srcname):
00759                         execScript(srcname)
00760                     elif os.path.exists(srcname+".py"):
00761                         execScript(srcname+".py")
00762                     else:
00763                         print "Can't execute file %s" % srcname
00764                     pass
00765                 else:
00766                     found = False
00767                     for path in [os.getcwd()] + sys.path:
00768                         if os.path.exists(os.path.join(path,srcname)):
00769                             execScript(os.path.join(path,srcname))
00770                             found = True
00771                             break
00772                         elif os.path.exists(os.path.join(path,srcname+".py")):
00773                             execScript(os.path.join(path,srcname+".py"))
00774                             found = True
00775                             break
00776                         pass
00777                     if not found:
00778                         print "Can't execute file %s" % srcname
00779                         pass
00780                     pass
00781                 pass
00782             pass
00783         pass
00784     return clt
    

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 659 of file runSalome.py.

tuple runSalome.end_time = os.times()

Definition at line 631 of file runSalome.py.

tuple runSalome.iflag_ptr = cast(pythonapi.Py_InteractiveFlag, POINTER(c_int))

Definition at line 1033 of file runSalome.py.

Definition at line 733 of file runSalome.py.

list runSalome.nbaddi = 0

Definition at line 643 of file runSalome.py.

Definition at line 731 of file runSalome.py.

string runSalome.SEP = ";"

Definition at line 36 of file runSalome.py.

tuple runSalome.session = clt.waitNS("/Kernel/Session",SALOME.Session)

Definition at line 627 of file runSalome.py.

list runSalome.test = args['gui']

Definition at line 1022 of file runSalome.py.