bin/salomeRunner.py

   1 # Copyright (C) 2013-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 #
   3 # This library is free software; you can redistribute it and/or
   4 # modify it under the terms of the GNU Lesser General Public
   5 # License as published by the Free Software Foundation; either
   6 # version 2.1 of the License, or (at your option) any later version.
   7 #
   8 # This library is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 # Lesser General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU Lesser General Public
  14 # License along with this library; if not, write to the Free Software
  15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 #
  17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 #
  19
  20 import os
  21 import sys
  22 import logging
  23 import ConfigParser
  24
  25 from parseConfigFile import parseConfigFile
  26 from parseConfigFile import convertEnvFileToConfigFile
  27
  28 import tempfile
  29 import pickle
  30 import subprocess
  31 import platform
  32
  33 from salomeLauncherUtils import SalomeRunnerException
  34 from salomeLauncherUtils import getScriptsAndArgs, formatScriptsAndArgs
  35
  36 def usage():
  37   #exeName = os.path.splitext(os.path.basename(__file__))[0]
  38
  39   msg = '''\
  40 Usage: salome [command] [options] [--config=file1,...,filen]
  41
  42 Commands:
  43     start         Launches SALOME virtual application [DEFAULT]
  44     shell         Executes a script under SALOME application environment
  45     connect       Connects a Python console to the active SALOME session
  46     killall       Kill all SALOME running sessions
  47     info          Display some information about SALOME
  48     help          Show this message
  49     coffee        Yes! SALOME can also make coffee!!"
  50
  51 Use salome start --help or salome shell --help
  52 to show help on start and shell commands.
  53 '''
  54
  55   print msg
  56 #
  57
  58 """
  59 The SalomeRunner class in an API to configure SALOME environment then
  60 start SALOME using a single python command.
  61
  62 """
  63 class SalomeRunner:
  64   """
  65   Initialize environment from a list of configuration files
  66   identified by their names.
  67   These files should be in appropriate (new .cfg) format.
  68   However you can give old .sh environment files; in this case,
  69   the SalomeRunner class will try to automatically convert them
  70   to .cfg format before setting the environment.
  71   """
  72   def __init__(self, configFileNames=[]):
  73     #it could be None explicitely (if user use multiples setEnviron...for standalone)
  74     if configFileNames==None:
  75        return
  76
  77     if len(configFileNames) == 0:
  78       raise SalomeRunnerException("No configuration files given")
  79
  80     reserved=['PATH', 'LD_LIBRARY_PATH', 'PYTHONPATH', 'MANPATH', 'PV_PLUGIN_PATH']
  81     for filename in configFileNames:
  82       basename, extension = os.path.splitext(filename)
  83       if extension == ".cfg":
  84         self.__setEnvironmentFromConfigFile(filename, reserved)
  85       elif extension == ".sh":
  86         #new convert procedures, temporary could be use not to be automatically deleted
  87         #temp = tempfile.NamedTemporaryFile(suffix='.cfg', delete=False)
  88         temp = tempfile.NamedTemporaryFile(suffix='.cfg')
  89         try:
  90           convertEnvFileToConfigFile(filename, temp.name, reserved)
  91           self.__setEnvironmentFromConfigFile(temp.name, reserved)
  92         except ConfigParser.ParsingError, e:
  93           self.getLogger().warning("Invalid token found when parsing file: %s\n"%(filename))
  94           print e
  95           print '\n'
  96         finally:
  97           # Automatically cleans up the file
  98           temp.close()
  99       else:
 100         self.getLogger().warning("Unrecognized extension for configuration file: %s", filename)
 101   #
 102
 103   def go(self, args):
 104     # Run this module as a script, in order to use appropriate Python interpreter
 105     # according to current path (initialized from environment files).
 106     kill = False
 107     for e in args:
 108       if "--shutdown-server" in e:
 109         kill = True
 110         args.remove(e)
 111
 112     absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH','')
 113     proc = subprocess.Popen(['python', os.path.join(absoluteAppliPath,"bin","salome","salomeRunner.py"), pickle.dumps(self),  pickle.dumps(args)], shell=False, close_fds=True)
 114     proc.communicate()
 115     if kill:
 116       self._killAll(args)
 117   #
 118
 119   """Append value to PATH environment variable"""
 120   def addToPath(self, value):
 121     self.addToEnviron('PATH', value)
 122   #
 123
 124   """Append value to LD_LIBRARY_PATH environment variable"""
 125   def addToLdLibraryPath(self, value):
 126     self.addToEnviron('LD_LIBRARY_PATH', value)
 127   #
 128
 129   """Append value to PYTHONPATH environment variable"""
 130   def addToPythonPath(self, value):
 131     self.addToEnviron('PYTHONPATH', value)
 132   #
 133
 134   """Set environment variable to value"""
 135   def setEnviron(self, name, value, overwrite=False):
 136     env = os.getenv(name, '')
 137     if env and not overwrite:
 138       self.getLogger().warning("Environment variable already existing (and not overwritten): %s=%s", name, value)
 139       return
 140
 141     if env:
 142       self.getLogger().warning("Overwriting environment variable: %s=%s", name, value)
 143
 144     value = os.path.expandvars(value) # expand environment variables
 145     self.getLogger().debug("Set environment variable: %s=%s", name, value)
 146     os.environ[name] = value
 147   #
 148
 149   """Unset environment variable"""
 150   def unsetEnviron(self, name):
 151     if os.environ.has_key(name):
 152       del os.environ[name]
 153   #
 154
 155   """Append value to environment variable"""
 156   def addToEnviron(self, name, value, separator=os.pathsep):
 157     if value == '':
 158       return
 159
 160     value = os.path.expandvars(value) # expand environment variables
 161     self.getLogger().debug("Add to %s: %s", name, value)
 162     env = os.getenv(name, None)
 163     if env is None:
 164       os.environ[name] = value
 165     else:
 166       os.environ[name] = value + separator + env
 167   #
 168
 169   ###################################
 170   # This begins the private section #
 171   ###################################
 172
 173   def __parseArguments(self, args):
 174     if len(args) == 0 or args[0].startswith("-"):
 175       return None, args
 176
 177     command = args[0]
 178     options = args[1:]
 179
 180     availableCommands = {
 181       'start' :   '_runAppli',
 182       'shell' :   '_runSession',
 183       'connect' : '_runConsole',
 184       'killall':  '_killAll',
 185       'info':     '_showInfo',
 186       'help':     '_usage',
 187       'coffee' :  '_makeCoffee'
 188       }
 189
 190     if not command in availableCommands.keys():
 191       command = "start"
 192       options = args
 193
 194     return availableCommands[command], options
 195   #
 196
 197   """
 198   Run SALOME!
 199   Args consist in a mandatory command followed by optionnal parameters.
 200   See usage for details on commands.
 201   """
 202   def _getStarted(self, args):
 203     command, options = self.__parseArguments(args)
 204     sys.argv = options
 205
 206     if command is None:
 207       if args and args[0] in ["-h","--help","help"]:
 208         usage()
 209         sys.exit(0)
 210       # try to default to "start" command
 211       command = "_runAppli"
 212
 213     try:
 214       res = getattr(self, command)(options) # run appropriate method
 215       return res or (None, None)
 216     except SystemExit, exc:
 217       if exc==0:
 218         sys.exit(0) #catch sys.exit(0) happy end no warning
 219       if exc==1:
 220         self.getLogger().warning("SystemExit 1 in method %s.", command)
 221       sys.exit(1)
 222     except StandardError:
 223       self.getLogger().error("Unexpected error:")
 224       import traceback
 225       traceback.print_exc()
 226       sys.exit(1)
 227     except SalomeRunnerException, e:
 228       self.getLogger().error(e)
 229       sys.exit(1)
 230   #
 231
 232   def __setEnvironmentFromConfigFile(self, filename, reserved=[]):
 233     unsetVars, configVars, reservedDict = parseConfigFile(filename, reserved)
 234
 235     # unset variables
 236     for var in unsetVars:
 237       self.unsetEnviron(var)
 238
 239     # set environment
 240     for reserved in reservedDict:
 241       a = filter(None, reservedDict[reserved]) # remove empty elements
 242       reformattedVals = ':'.join(a)
 243       self.addToEnviron(reserved, reformattedVals)
 244       pass
 245
 246     for key,val in configVars:
 247       self.setEnviron(key, val, overwrite=True)
 248       pass
 249
 250     sys.path[:0] = os.getenv('PYTHONPATH','').split(':')
 251   #
 252
 253   def _runAppli(self, args=[]):
 254     # Initialize SALOME environment
 255     sys.argv = ['runSalome'] + args
 256     import setenv
 257     setenv.main(True)
 258
 259     import runSalome
 260     runSalome.runSalome()
 261   #
 262
 263   def _runSession(self, args=[]):
 264     sys.argv = ['runSession'] + args
 265     import runSession
 266     runSession.configureSession(args)
 267
 268     import setenv
 269     setenv.main(True)
 270
 271     scriptArgs = getScriptsAndArgs(args)
 272     command = formatScriptsAndArgs(scriptArgs)
 273     if command:
 274       sep = ";"
 275       if sys.platform == "win32":
 276         sep= "&"
 277       command = command.split(sep)
 278       outmsg = []
 279       errmsg = []
 280       for cmd in command:
 281         cmd = cmd.strip().split(' ')
 282         proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 283         (stdoutdata, stderrdata) = proc.communicate()
 284         if stdoutdata or stderrdata:
 285           outmsg.append(stdoutdata)
 286           errmsg.append(stderrdata)
 287
 288       return ("".join(outmsg), "".join(errmsg))
 289     else:
 290       absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH','')
 291       cmd = ["/bin/bash",  "--rcfile", absoluteAppliPath + "/.bashrc" ]
 292       proc = subprocess.Popen(cmd, shell=False, close_fds=True)
 293       proc.wait()
 294   #
 295
 296   def _runConsole(self, args=[]):
 297     # Initialize SALOME environment
 298     sys.argv = ['runConsole'] + args
 299     import setenv
 300     setenv.main(True)
 301
 302     import runConsole
 303     runConsole.connect()
 304   #
 305
 306   def _killAll(self, args=[]):
 307     absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH','')
 308     try:
 309       import PortManager # mandatory
 310       from multiprocessing import Process
 311       from killSalomeWithPort import killMyPort
 312       ports = PortManager.getBusyPorts()
 313
 314       if ports:
 315         import tempfile
 316         for port in ports:
 317           with tempfile.NamedTemporaryFile():
 318             p = Process(target = killMyPort, args=(port,))
 319             p.start()
 320             p.join()
 321
 322       p = Process(target = killMyPort, args=(2809,))
 323       p.start()
 324       p.join()
 325     except ImportError:
 326       from killSalome import killAllPorts
 327       killAllPorts()
 328       pass
 329
 330   #
 331
 332   def _showInfo(self, args=[]):
 333     print "Running with python", platform.python_version()
 334     self._runAppli(["--version"])
 335   #
 336
 337   def _usage(self, unused=[]):
 338     usage()
 339   #
 340
 341   def _makeCoffee(self, args=[]):
 342     print "                        ("
 343     print "                          )     ("
 344     print "                   ___...(-------)-....___"
 345     print "               .-\"\"       )    (          \"\"-."
 346     print "         .-\'``\'|-._             )         _.-|"
 347     print "        /  .--.|   `\"\"---...........---\"\"`   |"
 348     print "       /  /    |                             |"
 349     print "       |  |    |                             |"
 350     print "        \\  \\   |                             |"
 351     print "         `\\ `\\ |                             |"
 352     print "           `\\ `|                             |"
 353     print "           _/ /\\                             /"
 354     print "          (__/  \\                           /"
 355     print "       _..---\"\"` \\                         /`\"\"---.._"
 356     print "    .-\'           \\                       /          \'-."
 357     print "   :               `-.__             __.-\'              :"
 358     print "   :                  ) \"\"---...---\"\" (                 :"
 359     print "    \'._               `\"--...___...--\"`              _.\'"
 360     print "      \\\"\"--..__                              __..--\"\"/"
 361     print "       \'._     \"\"\"----.....______.....----\"\"\"     _.\'"
 362     print "          `\"\"--..,,_____            _____,,..--\"\"`"
 363     print "                        `\"\"\"----\"\"\"`"
 364     sys.exit(0)
 365   #
 366
 367   # Add the following two methods since logger is not pickable
 368   # Ref: http://stackoverflow.com/questions/2999638/how-to-stop-attributes-from-being-pickled-in-python
 369   def __getstate__(self):
 370     d = dict(self.__dict__)
 371     if hasattr(self, '_logger'):
 372       del d['_logger']
 373     return d
 374   #
 375   def __setstate__(self, d):
 376     self.__dict__.update(d) # I *think* this is a safe way to do it
 377   #
 378   # Excluding self._logger from pickle operation imply using the following method to access logger
 379   def getLogger(self):
 380     if not hasattr(self, '_logger'):
 381       self._logger = logging.getLogger(__name__)
 382       #self._logger.setLevel(logging.DEBUG)
 383       self._logger.setLevel(logging.ERROR)
 384     return self._logger
 385   #
 386
 387 ###
 388 import pickle
 389 if __name__ == "__main__":
 390   if len(sys.argv) == 3:
 391     runner = pickle.loads(sys.argv[1])
 392     args = pickle.loads(sys.argv[2])
 393     (out, err) = runner._getStarted(args)
 394     if out:
 395       sys.stdout.write(out)
 396     if err:
 397       sys.stderr.write(err)
 398   else:
 399     usage()
 400 #