bin/runSession.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
   3 #
   4 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   5 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   6 #
   7 # This library is free software; you can redistribute it and/or
   8 # modify it under the terms of the GNU Lesser General Public
   9 # License as published by the Free Software Foundation; either
  10 # version 2.1 of the License, or (at your option) any later version.
  11 #
  12 # This library is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 # Lesser General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Lesser General Public
  18 # License along with this library; if not, write to the Free Software
  19 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 #
  21 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  22 #
  23
  24 import os
  25 import sys
  26 from optparse import OptionParser
  27 from NSparam import getNSparams
  28 import socket
  29 import subprocess
  30 import re
  31 from salomeContextUtils import getScriptsAndArgs, formatScriptsAndArgs, getShortAndExtraArgs
  32 from salome_utils import getUserName
  33
  34 # Use to display newlines (\n) in epilog
  35 class MyParser(OptionParser):
  36     def format_epilog(self, formatter):
  37         return self.epilog
  38 #
  39
  40 class SessionParameters:
  41   def __init__(self, mode, port, machine, user, directory):
  42     self.mode = mode
  43     self.port = port
  44     self.machine = machine
  45     self.user = user
  46     self.directory = directory
  47   #
  48   def __repr__(self):
  49     msg = "\n# Session Parameters:\n"
  50     msg += "     * mode: %s\n"%self.mode
  51     msg += "     * port: %s\n"%self.port
  52     msg += "     * machine: %s\n"%self.machine
  53     msg += "     * user: %s\n"%self.user
  54     msg += "     * directory: %s\n"%self.directory
  55     return msg
  56   #
  57 #
  58
  59 def configureSession(args=None, exe=None):
  60   if args is None:
  61     args = []
  62   if exe:
  63       usage = "Usage: %s [options] [command] [-- <extra>]"%exe
  64   else:
  65       usage = "Usage: %prog [options] [command] [-- <extra>]"
  66   epilog  = """\n
  67 If command is not given a shell is opened; else execute the given command.\n
  68 * Command may be an executable script or program, either identified by its
  69   full path or located in a directory pointed by a system variable (e.g.
  70   PATH).\n
  71 * Command may also be a series of Python scripts with arguments:
  72   [PYTHON_FILE [args] [PYTHON_FILE [args]...]]
  73 Python file arguments, if any, must be comma-separated (without blank
  74   characters) and prefixed by "args:" keyword (without quotes).
  75 For example:
  76        salome shell hello.py add.py args:1,2 hello.py args:you
  77 will successively say hello, add 1+2, and say hello to you.\n
  78 The double dash (--) syntax indicates an extra command to be run "as is". It
  79   allows calling a extern program or system command with options and
  80   arguments, using the syntax: -- <program> [options] [arguments].
  81 For example:
  82        salome shell -- ls -l *.py
  83        salome shell -- python -tt hello.py
  84 \n
  85 If PORT and MACHINE are not given, try to connect to the last active session
  86   on the local machine.
  87 If PORT and MACHINE are given, try to connect to the remote session associated
  88   with PORT on MACHINE.
  89 If MACHINE is not given, try to connect to the session associated to PORT on
  90   the local machine.
  91 If PORT is not given, try to connect to the remote session associated to port
  92   2810 on MACHINE.\n
  93 If MACHINE is remote, the following options MUST be provided:
  94      * DIRECTORY: The full path to the salome command on remote machine.
  95      * USER: The user on the computer to connect to.\n
  96 In case of remote call, syntax "out:res1,res2,..." can be used to get results
  97   from remote machine.
  98 For example:
  99        salome shell -m remotemachine -p 2810 -u myself -d /full/path/to/salome
 100   concatenate.py args:file1.txt,file2.txt out:result.txt
 101 User "myself" connects to remotemachine to run the script concatenate.py in
 102   a SALOME session on port 2810; the script takes two input parameters and
 103   produces one result file.\n
 104 """
 105   parser = MyParser(usage=usage, epilog=epilog)
 106   parser.add_option("-p", "--port", metavar="<port>", default=0,
 107                     action="store", type="string", dest="port",
 108                     help="The port to connect to."
 109                     )
 110   parser.add_option("-m", "--machine", metavar="<machine>", default=0,
 111                     action="store", type="string", dest="host",
 112                     help="The machine to connect to."
 113                     )
 114   parser.add_option('-d', '--directory', dest="directory", default=None,
 115                     help="[Remote mode] The full path to the salome command on remote machine."
 116                     )
 117   parser.add_option('-u', '--user', dest="user", default=None,
 118                     help="[Remote mode] The user on the computer to connect to."
 119                     )
 120
 121   short_args, extra_args = getShortAndExtraArgs(args)
 122   try:
 123     (options, args) = parser.parse_args(short_args)
 124   except Exception, e:
 125     print e
 126     return
 127
 128   port = options.port
 129   host = options.host
 130
 131   # :GLITCH: this code defines specific environment variables (OMNIORB_CONFIG, NSPORT,
 132   # NSHOST) which are later used by other modules. Working, but not really "safe"...
 133   if not port:
 134     if not host:
 135       # neither MACHINE nor PORT are given
 136       # --- set omniORB configuration to current session if any
 137       omniorbUserPath = os.environ['OMNIORB_USER_PATH']
 138       fileOmniConfig = omniorbUserPath + '/.omniORB_' + getUserName() + '_last.cfg'
 139       if os.path.isfile(fileOmniConfig):
 140         os.environ['OMNIORB_CONFIG'] = fileOmniConfig
 141         # --- set environment variables for port and hostname of NamingService
 142         host, port = getNSparams()
 143       else:
 144         # No running session
 145         host = "no_host"
 146         port = "no_port"
 147     else:
 148       # only MACHINE is given
 149       port = '2810'
 150       _writeConfigFile(port, host)
 151     #
 152   else:
 153     if not host:
 154       # only PORT is given
 155       host = socket.gethostname()
 156     # both MACHINE and PORT are given
 157     _writeConfigFile(port, host)
 158   #
 159   os.environ['NSPORT'] = port
 160   os.environ['NSHOST'] = host
 161
 162   # determine running mode, taht is either 'local' or 'remote'
 163   here = socket.gethostname()
 164   mode = "local"
 165   if host != here and host != "localhost" and host != "no_host":
 166     mode="remote"
 167     pass
 168   params = SessionParameters(mode, port, host, options.user, options.directory)
 169   return params, args+extra_args
 170 #
 171
 172 # --- set the OMNIORB_CONFIG file and environment relative to this run of SALOME
 173 def _writeConfigFile(port, host):
 174   path = os.environ['OMNIORB_USER_PATH']
 175   kwargs = {'with_username' : getUserName()}
 176
 177   from ORBConfigFile import writeORBConfigFile
 178   [ filename, msgSize ] = writeORBConfigFile(path, host, port, kwargs)
 179
 180   os.environ['OMNIORB_CONFIG'] = filename
 181 #
 182
 183 # command looks like a Bash command-line:
 184 # script1.py [args] ; script2.py [args] ; ...
 185 def __runLocalSession(command):
 186   if command:
 187     sep = ";"
 188     if sys.platform == "win32":
 189       sep= "&"
 190     command = command.split(sep)
 191     outmsg = []
 192     errmsg = []
 193     for cmd in command:
 194       single_cmd = cmd.strip().split(' ')
 195       any_error = False
 196       try:
 197         proc = subprocess.Popen(single_cmd)
 198         (stdoutdata, stderrdata) = proc.communicate() # Wait for process to terminate
 199         if stdoutdata:
 200           outmsg.append(stdoutdata)
 201         if stderrdata:
 202           errmsg.append(stderrdata)
 203
 204         if proc.returncode != 0:
 205           any_error = True
 206       except:
 207           any_error = True
 208           pass
 209
 210       if any_error:
 211         errmsg.append("Error raised when executing command: %s\n"%cmd)
 212         if outmsg:
 213           sys.stdout.write("".join(outmsg))
 214         if errmsg:
 215           sys.stderr.write("".join(errmsg))
 216         sys.exit(1)
 217
 218     return ("".join(outmsg), "".join(errmsg))
 219   else:
 220     absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH','')
 221     cmd = ["/bin/bash",  "--rcfile", absoluteAppliPath + "/.bashrc" ]
 222     proc = subprocess.Popen(cmd, shell=False, close_fds=True)
 223     return proc.communicate()
 224 #
 225
 226 def __copyFiles(user, machine, script, infiles, outfiles):
 227   """Modify script, copy files to remote computer and return lists of copied files."""
 228
 229   namescript = os.path.basename(script)
 230   import getpass
 231   logname = getpass.getuser()
 232   tmp_script = "/tmp/%s_%s_%s" % (logname, os.getpid(), namescript)
 233   with open(script, 'r') as fscript:
 234     script_text = fscript.read()
 235
 236   list_infiles = []
 237   list_outfiles = []
 238   n = 0
 239   for infile in infiles:
 240     # generate a temporary file name
 241     namefile = os.path.basename(infile)
 242     tmp_file = "/tmp/%s_%s_i%s_%s" % (logname, os.getpid(), n, namefile)
 243
 244     # modify the salome script
 245     script_text = re.sub(infile, tmp_file, script_text)
 246
 247     # copy the infile to the remote server
 248     cmd = "scp %s %s@%s:%s" % (infile, user, machine, tmp_file)
 249     print "[  SCP  ]", cmd
 250     os.system(cmd)
 251
 252     list_infiles.append(tmp_file)
 253     n = n + 1
 254   #
 255   n = 0
 256   for outfile in outfiles:
 257     # generate a temporary file name
 258     namefile = os.path.basename(outfile)
 259     tmp_file = "/tmp/%s_%s_o%s_%s" % (logname, os.getpid(), n, namefile)
 260
 261     # modify the salome script
 262     script_text = re.sub(outfile, tmp_file, script_text)
 263
 264     list_outfiles.append(tmp_file)
 265     n = n + 1
 266   #
 267
 268   with open(tmp_script,'w') as fscript:
 269     fscript.write(script_text)
 270
 271   # copy the salome script on the remote server
 272   cmd = "scp %s %s@%s:%s" % (tmp_script, user, machine, tmp_script)
 273   print "[  SCP  ]", cmd
 274   os.system(cmd)
 275
 276   return list_infiles, list_outfiles, tmp_script
 277 #
 278
 279 # sa_obj is a ScriptAndArgs object (from salomeContextUtils)
 280 def __runRemoteSession(sa_obj, params):
 281   if not params.user:
 282     print "ERROR: The user login on remote machine MUST be given."
 283     return
 284   if not params.directory:
 285     print "ERROR: The remote directory MUST be given."
 286     return
 287
 288   # sa_obj.script may be 'python script.py' --> only process .py file
 289   header = " ".join(sa_obj.script.split()[:-1])
 290   script = sa_obj.script.split()[-1]
 291
 292   tmp_in, tmp_out, tmp_script = __copyFiles(params.user, params.machine, script, sa_obj.args or [], sa_obj.out or [])
 293
 294   # execute command on the remote SALOME application
 295   command = "ssh %s@%s %s/salome shell " % (params.user, params.machine, params.directory)
 296   if params.port:
 297     command = command + "-p %s "%params.port
 298   command = command + " %s %s args:%s"%(header, tmp_script, ",".join(tmp_in))
 299   print '[  SSH   ] ' + command
 300   os.system(command)
 301
 302   # Get remote files and clean
 303   temp_files = tmp_in + tmp_out + [tmp_script]
 304
 305   # get the outfiles
 306   for outfile in (sa_obj.out or []):
 307     remote_outfile = tmp_out.pop(0)
 308     command = "scp %s@%s:%s %s" %(params.user, params.machine, remote_outfile, outfile)
 309     print "[  SCP  ] " + command
 310     os.system(command)
 311
 312   # clean temporary files
 313   command = "ssh %s@%s \\rm -f %s" % (params.user, params.machine, " ".join(temp_files))
 314   print '[  SSH   ] ' + command
 315   os.system(command)
 316   os.remove(tmp_script)
 317
 318 #
 319
 320 def runSession(params, args):
 321   scriptArgs = getScriptsAndArgs(args)
 322
 323   if params.mode == "local":
 324     command = formatScriptsAndArgs(scriptArgs)
 325     return __runLocalSession(command)
 326
 327   elif params.mode == "remote":
 328     for sa_obj in scriptArgs:
 329       __runRemoteSession(sa_obj, params)
 330 #