bin/runSession.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2016  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 as 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     if sys.platform == "win32":
 222       cmd = ["cmd", "/K", "set PROMPT=[SALOME] $P$G"]
 223     else:
 224       cmd = ["/bin/bash",  "--rcfile", absoluteAppliPath + "/.bashrc" ]
 225     proc = subprocess.Popen(cmd, shell=False, close_fds=True)
 226     return proc.communicate()
 227 #
 228
 229 def __copyFiles(user, machine, script, infiles, outfiles):
 230   """Modify script, copy files to remote computer and return lists of copied files."""
 231
 232   namescript = os.path.basename(script)
 233   import getpass
 234   logname = getpass.getuser()
 235   tmp_script = "/tmp/%s_%s_%s" % (logname, os.getpid(), namescript)
 236   with open(script, 'r') as fscript:
 237     script_text = fscript.read()
 238
 239   list_infiles = []
 240   list_outfiles = []
 241   n = 0
 242   for infile in infiles:
 243     # generate a temporary file name
 244     namefile = os.path.basename(infile)
 245     tmp_file = "/tmp/%s_%s_i%s_%s" % (logname, os.getpid(), n, namefile)
 246
 247     # modify the salome script
 248     script_text = re.sub(infile, tmp_file, script_text)
 249
 250     # copy the infile to the remote server
 251     cmd = "scp %s %s@%s:%s" % (infile, user, machine, tmp_file)
 252     print("[  SCP  ]", cmd)
 253     os.system(cmd)
 254
 255     list_infiles.append(tmp_file)
 256     n = n + 1
 257   #
 258   n = 0
 259   for outfile in outfiles:
 260     # generate a temporary file name
 261     namefile = os.path.basename(outfile)
 262     tmp_file = "/tmp/%s_%s_o%s_%s" % (logname, os.getpid(), n, namefile)
 263
 264     # modify the salome script
 265     script_text = re.sub(outfile, tmp_file, script_text)
 266
 267     list_outfiles.append(tmp_file)
 268     n = n + 1
 269   #
 270
 271   with open(tmp_script,'w') as fscript:
 272     fscript.write(script_text)
 273
 274   # copy the salome script on the remote server
 275   cmd = "scp %s %s@%s:%s" % (tmp_script, user, machine, tmp_script)
 276   print("[  SCP  ]", cmd)
 277   os.system(cmd)
 278
 279   return list_infiles, list_outfiles, tmp_script
 280 #
 281
 282 # sa_obj is a ScriptAndArgs object (from salomeContextUtils)
 283 def __runRemoteSession(sa_obj, params):
 284   if not params.user:
 285     print("ERROR: The user login on remote machine MUST be given.")
 286     return
 287   if not params.directory:
 288     print("ERROR: The remote directory MUST be given.")
 289     return
 290
 291   # sa_obj.script may be 'python script.py' --> only process .py file
 292   header = " ".join(sa_obj.script.split()[:-1])
 293   script = sa_obj.script.split()[-1]
 294
 295   tmp_in, tmp_out, tmp_script = __copyFiles(params.user, params.machine, script, sa_obj.args or [], sa_obj.out or [])
 296
 297   # execute command on the remote SALOME application
 298   command = "ssh %s@%s %s/salome shell " % (params.user, params.machine, params.directory)
 299   if params.port:
 300     command = command + "-p %s "%params.port
 301   command = command + " %s %s args:%s"%(header, tmp_script, ",".join(tmp_in))
 302   print('[  SSH   ] ' + command)
 303   os.system(command)
 304
 305   # Get remote files and clean
 306   temp_files = tmp_in + tmp_out + [tmp_script]
 307
 308   # get the outfiles
 309   for outfile in (sa_obj.out or []):
 310     remote_outfile = tmp_out.pop(0)
 311     command = "scp %s@%s:%s %s" %(params.user, params.machine, remote_outfile, outfile)
 312     print("[  SCP  ] " + command)
 313     os.system(command)
 314
 315   # clean temporary files
 316   command = "ssh %s@%s \\rm -f %s" % (params.user, params.machine, " ".join(temp_files))
 317   print('[  SSH   ] ' + command)
 318   os.system(command)
 319   os.remove(tmp_script)
 320
 321 #
 322
 323 def runSession(params, args):
 324   scriptArgs = getScriptsAndArgs(args)
 325
 326   if params.mode == "local":
 327     command = formatScriptsAndArgs(scriptArgs)
 328     return __runLocalSession(command)
 329
 330   elif params.mode == "remote":
 331     for sa_obj in scriptArgs:
 332       __runRemoteSession(sa_obj, params)
 333 #