bin/salomeContext.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 salomeContextUtils import SalomeContextException
  34 from salomeContextUtils 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 SalomeContext class in an API to configure SALOME environment then
  60 start SALOME using a single python command.
  61
  62 """
  63 class SalomeContext:
  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 SalomeContext 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 setVariable...for standalone)
  74     if configFileNames==None:
  75        return
  76
  77     if len(configFileNames) == 0:
  78       raise SalomeContextException("No configuration files given")
  79
  80     reserved=['PATH', 'DYLD_LIBRARY_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           temp.close()
  93         except (ConfigParser.ParsingError, ValueError) as e:
  94           self.getLogger().error("Invalid token found when parsing file: %s\n"%(filename))
  95           temp.close()
  96           sys.exit(1)
  97       else:
  98         self.getLogger().warning("Unrecognized extension for configuration file: %s", filename)
  99   #
 100
 101   def runSalome(self, args):
 102     # Run this module as a script, in order to use appropriate Python interpreter
 103     # according to current path (initialized from environment files).
 104     kill = False
 105     for e in args:
 106       if "--shutdown-server" in e:
 107         kill = True
 108         args.remove(e)
 109
 110     absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH','')
 111     proc = subprocess.Popen(['python', os.path.join(absoluteAppliPath,"bin","salome","salomeContext.py"), pickle.dumps(self), pickle.dumps(args)], shell=False, close_fds=True)
 112     msg = proc.communicate()
 113     if kill:
 114       self._killAll(args)
 115     return msg, proc.returncode
 116   #
 117
 118   """Append value to PATH environment variable"""
 119   def addToPath(self, value):
 120     self.addToVariable('PATH', value)
 121   #
 122
 123   """Append value to LD_LIBRARY_PATH environment variable"""
 124   def addToLdLibraryPath(self, value):
 125     self.addToVariable('LD_LIBRARY_PATH', value)
 126   #
 127
 128   """Append value to DYLD_LIBRARY_PATH environment variable"""
 129   def addToDyldLibraryPath(self, value):
 130     self.addToVariable('DYLD_LIBRARY_PATH', value)
 131   #
 132
 133   """Append value to PYTHONPATH environment variable"""
 134   def addToPythonPath(self, value):
 135     self.addToVariable('PYTHONPATH', value)
 136   #
 137
 138   """Set environment variable to value"""
 139   def setVariable(self, name, value, overwrite=False):
 140     env = os.getenv(name, '')
 141     if env and not overwrite:
 142       self.getLogger().warning("Environment variable already existing (and not overwritten): %s=%s", name, value)
 143       return
 144
 145     if env:
 146       self.getLogger().warning("Overwriting environment variable: %s=%s", name, value)
 147
 148     value = os.path.expandvars(value) # expand environment variables
 149     self.getLogger().debug("Set environment variable: %s=%s", name, value)
 150     os.environ[name] = value
 151   #
 152
 153   """Unset environment variable"""
 154   def unsetVariable(self, name):
 155     if os.environ.has_key(name):
 156       del os.environ[name]
 157   #
 158
 159   """Append value to environment variable"""
 160   def addToVariable(self, name, value, separator=os.pathsep):
 161     if value == '':
 162       return
 163
 164     value = os.path.expandvars(value) # expand environment variables
 165     self.getLogger().debug("Add to %s: %s", name, value)
 166     env = os.getenv(name, None)
 167     if env is None:
 168       os.environ[name] = value
 169     else:
 170       os.environ[name] = value + separator + env
 171   #
 172
 173   ###################################
 174   # This begins the private section #
 175   ###################################
 176
 177   def __parseArguments(self, args):
 178     if len(args) == 0 or args[0].startswith("-"):
 179       return None, args
 180
 181     command = args[0]
 182     options = args[1:]
 183
 184     availableCommands = {
 185       'start' :   '_runAppli',
 186       'shell' :   '_runSession',
 187       'connect' : '_runConsole',
 188       'killall':  '_killAll',
 189       'info':     '_showInfo',
 190       'help':     '_usage',
 191       'coffee' :  '_makeCoffee'
 192       }
 193
 194     if not command in availableCommands.keys():
 195       command = "start"
 196       options = args
 197
 198     return availableCommands[command], options
 199   #
 200
 201   """
 202   Run SALOME!
 203   Args consist in a mandatory command followed by optionnal parameters.
 204   See usage for details on commands.
 205   """
 206   def _startSalome(self, args):
 207     command, options = self.__parseArguments(args)
 208     sys.argv = options
 209
 210     if command is None:
 211       if args and args[0] in ["-h","--help","help"]:
 212         usage()
 213         sys.exit(0)
 214       # try to default to "start" command
 215       command = "_runAppli"
 216
 217     try:
 218       res = getattr(self, command)(options) # run appropriate method
 219       return res or (None, None)
 220     except SystemExit, returncode:
 221       if returncode != 0:
 222         self.getLogger().warning("SystemExit %s in method %s.", returncode, command)
 223       sys.exit(returncode)
 224     except StandardError:
 225       self.getLogger().error("Unexpected error:")
 226       import traceback
 227       traceback.print_exc()
 228       sys.exit(1)
 229     except SalomeContextException, e:
 230       self.getLogger().error(e)
 231       sys.exit(1)
 232   #
 233
 234   def __setEnvironmentFromConfigFile(self, filename, reserved=[]):
 235     try:
 236       unsetVars, configVars, reservedDict = parseConfigFile(filename, reserved)
 237     except SalomeContextException, e:
 238       msg = "%s"%e
 239       file_dir = os.path.dirname(filename)
 240       file_base = os.path.basename(filename)
 241       base_no_ext, ext = os.path.splitext(file_base)
 242       sh_file = os.path.join(file_dir, base_no_ext+'.sh')
 243       if ext == ".cfg" and os.path.isfile(sh_file):
 244         msg += "Found similar %s file; trying to parse this one instead..."%(base_no_ext+'.sh')
 245         temp = tempfile.NamedTemporaryFile(suffix='.cfg')
 246         try:
 247           convertEnvFileToConfigFile(sh_file, temp.name, reserved)
 248           self.__setEnvironmentFromConfigFile(temp.name, reserved)
 249           msg += "OK\n"
 250           self.getLogger().warning(msg)
 251           temp.close()
 252           return
 253         except (ConfigParser.ParsingError, ValueError) as e:
 254           msg += "Invalid token found when parsing file: %s\n"%(sh_file)
 255           self.getLogger().error(msg)
 256           temp.close()
 257           sys.exit(1)
 258       else:
 259         self.getLogger().error(msg)
 260         sys.exit(1)
 261
 262     # unset variables
 263     for var in unsetVars:
 264       self.unsetVariable(var)
 265
 266     # set environment
 267     for reserved in reservedDict:
 268       a = filter(None, reservedDict[reserved]) # remove empty elements
 269       reformattedVals = ':'.join(a)
 270       self.addToVariable(reserved, reformattedVals)
 271       pass
 272
 273     for key,val in configVars:
 274       self.setVariable(key, val, overwrite=True)
 275       pass
 276
 277     sys.path[:0] = os.getenv('PYTHONPATH','').split(':')
 278   #
 279
 280   def _runAppli(self, args=[]):
 281     # Initialize SALOME environment
 282     sys.argv = ['runSalome'] + args
 283     import setenv
 284     setenv.main(True)
 285
 286     import runSalome
 287     runSalome.runSalome()
 288   #
 289
 290   def _runSession(self, args=[]):
 291     sys.argv = ['runSession'] + args
 292     import runSession
 293     runSession.configureSession(args)
 294
 295     import setenv
 296     setenv.main(True)
 297
 298     scriptArgs = getScriptsAndArgs(args)
 299     command = formatScriptsAndArgs(scriptArgs)
 300     if command:
 301       sep = ";"
 302       if sys.platform == "win32":
 303         sep= "&"
 304       command = command.split(sep)
 305       outmsg = []
 306       errmsg = []
 307       for cmd in command:
 308         save_cmd = cmd
 309         cmd = cmd.strip().split(' ')
 310         #proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 311         proc = subprocess.Popen(cmd)
 312         (stdoutdata, stderrdata) = proc.communicate()
 313         if stdoutdata:
 314           outmsg.append(stdoutdata)
 315         if stderrdata:
 316           errmsg.append(stderrdata)
 317
 318         if proc.returncode != 0:
 319           errmsg.append("Error raised when executing command: %s\n"%save_cmd)
 320           if outmsg:
 321             sys.stdout.write("".join(outmsg))
 322           if errmsg:
 323             sys.stderr.write("".join(errmsg))
 324           sys.exit(proc.returncode)
 325
 326       return ("".join(outmsg), "".join(errmsg))
 327     else:
 328       absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH','')
 329       cmd = ["/bin/bash",  "--rcfile", absoluteAppliPath + "/.bashrc" ]
 330       proc = subprocess.Popen(cmd, shell=False, close_fds=True)
 331       return proc.communicate()
 332   #
 333
 334   def _runConsole(self, args=[]):
 335     # Initialize SALOME environment
 336     sys.argv = ['runConsole'] + args
 337     import setenv
 338     setenv.main(True)
 339
 340     cmd = ["python", "-c", "import runConsole\nrunConsole.connect()" ]
 341     proc = subprocess.Popen(cmd, shell=False, close_fds=True)
 342     return proc.communicate()
 343   #
 344
 345   def _killAll(self, args=[]):
 346     absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH','')
 347     try:
 348       import PortManager # mandatory
 349       from multiprocessing import Process
 350       from killSalomeWithPort import killMyPort
 351       ports = PortManager.getBusyPorts()
 352
 353       if ports:
 354         import tempfile
 355         for port in ports:
 356           with tempfile.NamedTemporaryFile():
 357             p = Process(target = killMyPort, args=(port,))
 358             p.start()
 359             p.join()
 360     except ImportError:
 361       from killSalome import killAllPorts
 362       killAllPorts()
 363       pass
 364
 365   #
 366
 367   def _showInfo(self, args=[]):
 368     print "Running with python", platform.python_version()
 369     self._runAppli(["--version"])
 370   #
 371
 372   def _usage(self, unused=[]):
 373     usage()
 374   #
 375
 376   def _makeCoffee(self, args=[]):
 377     print "                        ("
 378     print "                          )     ("
 379     print "                   ___...(-------)-....___"
 380     print "               .-\"\"       )    (          \"\"-."
 381     print "         .-\'``\'|-._             )         _.-|"
 382     print "        /  .--.|   `\"\"---...........---\"\"`   |"
 383     print "       /  /    |                             |"
 384     print "       |  |    |                             |"
 385     print "        \\  \\   |                             |"
 386     print "         `\\ `\\ |                             |"
 387     print "           `\\ `|                             |"
 388     print "           _/ /\\                             /"
 389     print "          (__/  \\                           /"
 390     print "       _..---\"\"` \\                         /`\"\"---.._"
 391     print "    .-\'           \\                       /          \'-."
 392     print "   :               `-.__             __.-\'              :"
 393     print "   :                  ) \"\"---...---\"\" (                 :"
 394     print "    \'._               `\"--...___...--\"`              _.\'"
 395     print "      \\\"\"--..__                              __..--\"\"/"
 396     print "       \'._     \"\"\"----.....______.....----\"\"\"     _.\'"
 397     print "          `\"\"--..,,_____            _____,,..--\"\"`"
 398     print "                        `\"\"\"----\"\"\"`"
 399     sys.exit(0)
 400   #
 401
 402   # Add the following two methods since logger is not pickable
 403   # Ref: http://stackoverflow.com/questions/2999638/how-to-stop-attributes-from-being-pickled-in-python
 404   def __getstate__(self):
 405     d = dict(self.__dict__)
 406     if hasattr(self, '_logger'):
 407       del d['_logger']
 408     return d
 409   #
 410   def __setstate__(self, d):
 411     self.__dict__.update(d) # I *think* this is a safe way to do it
 412   #
 413   # Excluding self._logger from pickle operation imply using the following method to access logger
 414   def getLogger(self):
 415     if not hasattr(self, '_logger'):
 416       self._logger = logging.getLogger(__name__)
 417       #self._logger.setLevel(logging.DEBUG)
 418       self._logger.setLevel(logging.WARNING)
 419     return self._logger
 420   #
 421
 422 import pickle
 423 if __name__ == "__main__":
 424   if len(sys.argv) == 3:
 425     context = pickle.loads(sys.argv[1])
 426     args = pickle.loads(sys.argv[2])
 427
 428     (out, err) = context._startSalome(args)
 429     if out:
 430       sys.stdout.write(out)
 431     if err:
 432       sys.stderr.write(err)
 433   else:
 434     usage()
 435 #