bin/salomeContext.py

   1 # Copyright (C) 2013-2015  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
  35 def usage():
  36   #exeName = os.path.splitext(os.path.basename(__file__))[0]
  37
  38   msg = '''\
  39 Usage: salome [command] [options] [--config=<file,folder,...>]
  40
  41 Commands:
  42 =========
  43     start         Starts a SALOME session (through virtual application)
  44     shell         Initializes SALOME environment, and executes scripts passed
  45                   as command arguments
  46     connect       Connects a Python console to the active SALOME session
  47     killall       Kill all SALOME running sessions for current user
  48     info          Display some information about SALOME
  49     help          Show this message
  50     coffee        Yes! SALOME can also make coffee!!
  51
  52 If no command is given, default to start.
  53
  54 Command options:
  55 ================
  56     Use salome <command> --help to show help on command ; available for start
  57     and shell commands.
  58
  59 --config=<file,folder,...>
  60 ==========================
  61     Initialize SALOME environment from a list of context files and/or a list
  62     of folders containing context files. The list is comma-separated, whithout
  63     any blank characters.
  64 '''
  65
  66   print msg
  67 #
  68
  69 """
  70 The SalomeContext class in an API to configure SALOME environment then
  71 start SALOME using a single python command.
  72
  73 """
  74 class SalomeContext:
  75   """
  76   Initialize environment from a list of configuration files
  77   identified by their names.
  78   These files should be in appropriate (new .cfg) format.
  79   However you can give old .sh environment files; in this case,
  80   the SalomeContext class will try to automatically convert them
  81   to .cfg format before setting the environment.
  82   """
  83   def __init__(self, configFileNames=0):
  84     #it could be None explicitely (if user use multiples setVariable...for standalone)
  85     if configFileNames is None:
  86        return
  87     configFileNames = configFileNames or []
  88     if len(configFileNames) == 0:
  89       raise SalomeContextException("No configuration files given")
  90
  91     reserved=['PATH', 'DYLD_LIBRARY_PATH', 'LD_LIBRARY_PATH', 'PYTHONPATH', 'MANPATH', 'PV_PLUGIN_PATH']
  92     for filename in configFileNames:
  93       basename, extension = os.path.splitext(filename)
  94       if extension == ".cfg":
  95         self.__setEnvironmentFromConfigFile(filename, reserved)
  96       elif extension == ".sh":
  97         #new convert procedures, temporary could be use not to be automatically deleted
  98         #temp = tempfile.NamedTemporaryFile(suffix='.cfg', delete=False)
  99         temp = tempfile.NamedTemporaryFile(suffix='.cfg')
 100         try:
 101           convertEnvFileToConfigFile(filename, temp.name, reserved)
 102           self.__setEnvironmentFromConfigFile(temp.name, reserved)
 103           temp.close()
 104         except (ConfigParser.ParsingError, ValueError) as e:
 105           self.getLogger().error("Invalid token found when parsing file: %s\n"%(filename))
 106           temp.close()
 107           sys.exit(1)
 108       else:
 109         self.getLogger().warning("Unrecognized extension for configuration file: %s", filename)
 110   #
 111
 112   def runSalome(self, args):
 113     # Run this module as a script, in order to use appropriate Python interpreter
 114     # according to current path (initialized from environment files).
 115 #    kill = False
 116 #    for e in args:
 117 #      if "--shutdown-server" in e:
 118 #        kill = True
 119 #        args.remove(e)
 120
 121     import os
 122     absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH','')
 123     env_copy = os.environ.copy()
 124     proc = subprocess.Popen(['python', os.path.join(absoluteAppliPath,"bin","salome","salomeContext.py"), pickle.dumps(self), pickle.dumps(args)], shell=False, close_fds=True, env=env_copy)
 125     msg = proc.communicate()
 126  #   if kill:
 127  #     self._killAll(args)
 128     return msg, proc.returncode
 129   #
 130
 131   """Append value to PATH environment variable"""
 132   def addToPath(self, value):
 133     self.addToVariable('PATH', value)
 134   #
 135
 136   """Append value to LD_LIBRARY_PATH environment variable"""
 137   def addToLdLibraryPath(self, value):
 138     self.addToVariable('LD_LIBRARY_PATH', value)
 139   #
 140
 141   """Append value to DYLD_LIBRARY_PATH environment variable"""
 142   def addToDyldLibraryPath(self, value):
 143     self.addToVariable('DYLD_LIBRARY_PATH', value)
 144   #
 145
 146   """Append value to PYTHONPATH environment variable"""
 147   def addToPythonPath(self, value):
 148     self.addToVariable('PYTHONPATH', value)
 149   #
 150
 151   """Set environment variable to value"""
 152   def setVariable(self, name, value, overwrite=False):
 153     env = os.getenv(name, '')
 154     if env and not overwrite:
 155       self.getLogger().warning("Environment variable already existing (and not overwritten): %s=%s", name, value)
 156       return
 157
 158     if env:
 159       self.getLogger().warning("Overwriting environment variable: %s=%s", name, value)
 160
 161     value = os.path.expandvars(value) # expand environment variables
 162     self.getLogger().debug("Set environment variable: %s=%s", name, value)
 163     os.environ[name] = value
 164   #
 165
 166   """Unset environment variable"""
 167   def unsetVariable(self, name):
 168     if os.environ.has_key(name):
 169       del os.environ[name]
 170   #
 171
 172   """Append value to environment variable"""
 173   def addToVariable(self, name, value, separator=os.pathsep):
 174     if value == '':
 175       return
 176
 177     value = os.path.expandvars(value) # expand environment variables
 178     self.getLogger().debug("Add to %s: %s", name, value)
 179     env = os.getenv(name, None)
 180     if env is None:
 181       os.environ[name] = value
 182     else:
 183       os.environ[name] = value + separator + env
 184   #
 185
 186   ###################################
 187   # This begins the private section #
 188   ###################################
 189
 190   def __parseArguments(self, args):
 191     if len(args) == 0 or args[0].startswith("-"):
 192       return None, args
 193
 194     command = args[0]
 195     options = args[1:]
 196
 197     availableCommands = {
 198       'start' :   '_runAppli',
 199       'shell' :   '_runSession',
 200       'connect' : '_runConsole',
 201       'killall':  '_killAll',
 202       'info':     '_showInfo',
 203       'help':     '_usage',
 204       'coffee' :  '_makeCoffee'
 205       }
 206
 207     if not command in availableCommands.keys():
 208       command = "start"
 209       options = args
 210
 211     return availableCommands[command], options
 212   #
 213
 214   """
 215   Run SALOME!
 216   Args consist in a mandatory command followed by optionnal parameters.
 217   See usage for details on commands.
 218   """
 219   def _startSalome(self, args):
 220     try:
 221       import os
 222       absoluteAppliPath = os.getenv('ABSOLUTE_APPLI_PATH')
 223       import sys
 224       path = os.path.realpath(os.path.join(absoluteAppliPath, "bin", "salome"))
 225       if not path in sys.path:
 226         sys.path[:0] = [path]
 227     except:
 228       pass
 229
 230     command, options = self.__parseArguments(args)
 231     sys.argv = options
 232
 233     if command is None:
 234       if args and args[0] in ["-h","--help","help"]:
 235         usage()
 236         sys.exit(0)
 237       # try to default to "start" command
 238       command = "_runAppli"
 239
 240     try:
 241       res = getattr(self, command)(options) # run appropriate method
 242       return res or (None, None)
 243     except SystemExit, returncode:
 244       if returncode != 0:
 245         self.getLogger().warning("SystemExit %s in method %s.", returncode, command)
 246       sys.exit(returncode)
 247     except StandardError:
 248       self.getLogger().error("Unexpected error:")
 249       import traceback
 250       traceback.print_exc()
 251       sys.exit(1)
 252     except SalomeContextException, e:
 253       self.getLogger().error(e)
 254       sys.exit(1)
 255   #
 256
 257   def __setEnvironmentFromConfigFile(self, filename, reserved=None):
 258     if reserved is None:
 259       reserved = []
 260     try:
 261       unsetVars, configVars, reservedDict = parseConfigFile(filename, reserved)
 262     except SalomeContextException, e:
 263       msg = "%s"%e
 264       file_dir = os.path.dirname(filename)
 265       file_base = os.path.basename(filename)
 266       base_no_ext, ext = os.path.splitext(file_base)
 267       sh_file = os.path.join(file_dir, base_no_ext+'.sh')
 268       if ext == ".cfg" and os.path.isfile(sh_file):
 269         msg += "Found similar %s file; trying to parse this one instead..."%(base_no_ext+'.sh')
 270         temp = tempfile.NamedTemporaryFile(suffix='.cfg')
 271         try:
 272           convertEnvFileToConfigFile(sh_file, temp.name, reserved)
 273           self.__setEnvironmentFromConfigFile(temp.name, reserved)
 274           msg += "OK\n"
 275           self.getLogger().warning(msg)
 276           temp.close()
 277           return
 278         except (ConfigParser.ParsingError, ValueError) as e:
 279           msg += "Invalid token found when parsing file: %s\n"%(sh_file)
 280           self.getLogger().error(msg)
 281           temp.close()
 282           sys.exit(1)
 283       else:
 284         self.getLogger().error(msg)
 285         sys.exit(1)
 286
 287     # unset variables
 288     for var in unsetVars:
 289       self.unsetVariable(var)
 290
 291     # set environment
 292     for reserved in reservedDict:
 293       a = filter(None, reservedDict[reserved]) # remove empty elements
 294       a = [ os.path.realpath(x) for x in a ]
 295       reformattedVals = os.pathsep.join(a)
 296       self.addToVariable(reserved, reformattedVals)
 297       pass
 298
 299     for key,val in configVars:
 300       self.setVariable(key, val, overwrite=True)
 301       pass
 302
 303     pythonpath = os.getenv('PYTHONPATH','').split(os.pathsep)
 304     pythonpath = [ os.path.realpath(x) for x in pythonpath ]
 305     sys.path[:0] = pythonpath
 306   #
 307
 308   def _runAppli(self, args=None):
 309     if args is None:
 310       args = []
 311     # Initialize SALOME environment
 312     sys.argv = ['runSalome'] + args
 313     import setenv
 314     setenv.main(True)
 315
 316     import runSalome
 317     runSalome.runSalome()
 318   #
 319
 320   def _runSession(self, args=None):
 321     if args is None:
 322       args = []
 323     sys.argv = ['runSession'] + args
 324     import runSession
 325     params, args = runSession.configureSession(args, exe="salome shell")
 326
 327     sys.argv = ['runSession'] + args
 328     import setenv
 329     setenv.main(True)
 330
 331     return runSession.runSession(params, args)
 332   #
 333
 334   def _runConsole(self, args=None):
 335     if args is None:
 336       args = []
 337     # Initialize SALOME environment
 338     sys.argv = ['runConsole'] + args
 339     import setenv
 340     setenv.main(True)
 341
 342     cmd = ["python", "-c", "import runConsole\nrunConsole.connect()" ]
 343     proc = subprocess.Popen(cmd, shell=False, close_fds=True)
 344     return proc.communicate()
 345   #
 346
 347   def _killAll(self, args=None):
 348     if args is None:
 349       args = []
 350     try:
 351       import PortManager # mandatory
 352       from multiprocessing import Process
 353       from killSalomeWithPort import killMyPort
 354       ports = PortManager.getBusyPorts()
 355
 356       if ports:
 357         import tempfile
 358         for port in ports:
 359           with tempfile.NamedTemporaryFile():
 360             p = Process(target = killMyPort, args=(port,))
 361             p.start()
 362             p.join()
 363     except ImportError:
 364       from killSalome import killAllPorts
 365       killAllPorts()
 366       pass
 367
 368   #
 369
 370   def _showInfo(self, args=None):
 371     print "Running with python", platform.python_version()
 372     self._runAppli(["--version"])
 373   #
 374
 375   def _usage(self, unused=None):
 376     usage()
 377   #
 378
 379   def _makeCoffee(self, args=None):
 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     print "       \'._     \"\"\"----.....______.....----\"\"\"     _.\'"
 400     print "          `\"\"--..,,_____            _____,,..--\"\"`"
 401     print "                        `\"\"\"----\"\"\"`"
 402     sys.exit(0)
 403   #
 404
 405   # Add the following two methods since logger is not pickable
 406   # Ref: http://stackoverflow.com/questions/2999638/how-to-stop-attributes-from-being-pickled-in-python
 407   def __getstate__(self):
 408     d = dict(self.__dict__)
 409     if hasattr(self, '_logger'):
 410       del d['_logger']
 411     return d
 412   #
 413   def __setstate__(self, d):
 414     self.__dict__.update(d) # I *think* this is a safe way to do it
 415   #
 416   # Excluding self._logger from pickle operation imply using the following method to access logger
 417   def getLogger(self):
 418     if not hasattr(self, '_logger'):
 419       self._logger = logging.getLogger(__name__)
 420       #self._logger.setLevel(logging.DEBUG)
 421       #self._logger.setLevel(logging.WARNING)
 422       self._logger.setLevel(logging.ERROR)
 423     return self._logger
 424   #
 425
 426 if __name__ == "__main__":
 427   if len(sys.argv) == 3:
 428     context = pickle.loads(sys.argv[1])
 429     args = pickle.loads(sys.argv[2])
 430
 431     (out, err) = context._startSalome(args)
 432     if out:
 433       sys.stdout.write(out)
 434     if err:
 435       sys.stderr.write(err)
 436   else:
 437     usage()
 438 #