src/environment.py

   1 #!/usr/bin/env python
   2 #-*- coding:utf-8 -*-
   3 #  Copyright (C) 2010-2013  CEA/DEN
   4 #
   5 #  This library is free software; you can redistribute it and/or
   6 #  modify it under the terms of the GNU Lesser General Public
   7 #  License as published by the Free Software Foundation; either
   8 #  version 2.1 of the License.
   9 #
  10 #  This library is distributed in the hope that it will be useful,
  11 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 #  Lesser General Public License for more details.
  14 #
  15 #  You should have received a copy of the GNU Lesser General Public
  16 #  License along with this library; if not, write to the Free Software
  17 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18
  19 import os
  20 import subprocess
  21 import string
  22 import sys
  23
  24 import src
  25 import src.debug as DBG
  26 import pprint as PP
  27
  28 class Environ:
  29     """\
  30     Class to manage the environment context
  31     """
  32     def __init__(self, environ=None):
  33         """Initialization. If the environ argument is passed, the environment
  34            will be add to it, else it is the external environment.
  35
  36         :param environ dict:
  37         """
  38         if environ is not None:
  39             self.environ = environ
  40         else:
  41             self.environ = os.environ
  42
  43     def __repr__(self):
  44         """easy non exhaustive quick resume for debug print"""
  45         return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(self.environ))
  46
  47     def _expandvars(self, value):
  48         """\
  49         replace some $VARIABLE into its actual value in the environment
  50
  51         :param value str: the string to be replaced
  52         :return: the replaced variable
  53         :rtype: str
  54         """
  55         if "$" in value:
  56             # The string.Template class is a string class
  57             # for supporting $-substitutions
  58             zt = string.Template(value)
  59             try:
  60                 value = zt.substitute(self.environ)
  61             except KeyError as exc:
  62                 raise src.SatException(_("Missing definition "
  63                                          "in environment: %s") % str(exc))
  64         return value
  65
  66     def append_value(self, key, value, sep=os.pathsep):
  67         """\
  68         append value to key using sep
  69
  70         :param key str: the environment variable to append
  71         :param value str: the value to append to key
  72         :param sep str: the separator string
  73         """
  74         # check if the key is already in the environment
  75         if key in self.environ:
  76             value_list = self.environ[key].split(sep)
  77             # Check if the value is already in the key value or not
  78             if not value in value_list:
  79                 value_list.append(value)
  80             else:
  81                 value_list.append(value_list.pop(value_list.index(value)))
  82             self.set(key, sep.join(value_list))
  83         else:
  84             self.set(key, value)
  85
  86     def append(self, key, value, sep=os.pathsep):
  87         """\
  88         Same as append_value but the value argument can be a list
  89
  90         :param key str: the environment variable to append
  91         :param value str or list: the value(s) to append to key
  92         :param sep str: the separator string
  93         """
  94         if isinstance(value, list):
  95             for v in value:
  96                 self.append_value(key, v, sep)
  97         else:
  98             self.append_value(key, value, sep)
  99
 100     def prepend_value(self, key, value, sep=os.pathsep):
 101         """\
 102         prepend value to key using sep
 103
 104         :param key str: the environment variable to prepend
 105         :param value str: the value to prepend to key
 106         :param sep str: the separator string
 107         """
 108         if key in self.environ:
 109             value_list = self.environ[key].split(sep)
 110             if not value in value_list:
 111                 value_list.insert(0, value)
 112             else:
 113                 value_list.insert(0, value_list.pop(value_list.index(value)))
 114             self.set(key, sep.join(value_list))
 115         else:
 116             self.set(key, value)
 117
 118     def prepend(self, key, value, sep=os.pathsep):
 119         """\
 120         Same as prepend_value but the value argument can be a list
 121
 122         :param key str: the environment variable to prepend
 123         :param value str or list: the value(s) to prepend to key
 124         :param sep str: the separator string
 125         """
 126         if isinstance(value, list):
 127             for v in value:
 128                 self.prepend_value(key, v, sep)
 129         else:
 130             self.prepend_value(key, value, sep)
 131
 132     def is_defined(self, key):
 133         """\
 134         Check if the key exists in the environment
 135
 136         :param key str: the environment variable to check
 137         """
 138         return key in self.environ.keys()
 139
 140     def set(self, key, value):
 141         """\
 142         Set the environment variable "key" to value "value"
 143
 144         :param key str: the environment variable to set
 145         :param value str: the value
 146         """
 147         self.environ[key] = self._expandvars(value)
 148
 149     def get(self, key):
 150         """\
 151         Get the value of the environment variable "key"
 152
 153         :param key str: the environment variable
 154         """
 155         if key in self.environ:
 156             return self.environ[key]
 157         else:
 158             return ""
 159
 160     def command_value(self, key, command):
 161         """\
 162         Get the value given by the system command "command"
 163         and put it in the environment variable key
 164
 165         :param key str: the environment variable
 166         :param command str: the command to execute
 167         """
 168         value = subprocess.Popen(command,
 169                                  shell=True,
 170                                  stdout=subprocess.PIPE,
 171                                  env=self.environ).communicate()[0]
 172         self.environ[key] = value
 173
 174
 175 class SalomeEnviron:
 176     """\
 177     Class to manage the environment of SALOME.
 178     """
 179     def __init__(self,
 180                  cfg,
 181                  environ,
 182                  forBuild=False,
 183                  for_package=None,
 184                  enable_simple_env_script = True):
 185         """\
 186         Initialization.
 187
 188         :param cfg Config: the global config
 189         :param environ Environ: the Environ instance where
 190                                 to store the environment variables
 191         :param forBuild bool: If true, it is a launch environment,
 192                               else a build one
 193         :param for_package str: If not None, produce a relative environment
 194                                 designed for a package.
 195         """
 196         self.environ = environ
 197         self.cfg = cfg
 198         self.forBuild = forBuild
 199         self.for_package = for_package
 200         self.enable_simple_env_script = enable_simple_env_script
 201         self.silent = False
 202
 203     def __repr__(self):
 204         """easy almost exhaustive quick resume for debug print"""
 205         res = {
 206           "environ" : self.environ,
 207           "forBuild" : self.forBuild,
 208           "for_package" : self.for_package,
 209         }
 210         return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(res))
 211
 212     def append(self, key, value, sep=os.pathsep):
 213         """\
 214         append value to key using sep
 215
 216         :param key str: the environment variable to append
 217         :param value str: the value to append to key
 218         :param sep str: the separator string
 219         """
 220         return self.environ.append(key, value, sep)
 221
 222     def prepend(self, key, value, sep=os.pathsep):
 223         """\
 224         prepend value to key using sep
 225
 226         :param key str: the environment variable to prepend
 227         :param value str: the value to prepend to key
 228         :param sep str: the separator string
 229         """
 230         return self.environ.prepend(key, value, sep)
 231
 232     def is_defined(self, key):
 233         """\
 234         Check if the key exists in the environment
 235
 236         :param key str: the environment variable to check
 237         """
 238         return self.environ.is_defined(key)
 239
 240     def get(self, key):
 241         """\
 242         Get the value of the environment variable "key"
 243
 244         :param key str: the environment variable
 245         """
 246         return self.environ.get(key)
 247
 248     def set(self, key, value):
 249         """\
 250         Set the environment variable "key" to value "value"
 251
 252         :param key str: the environment variable to set
 253         :param value str: the value
 254         """
 255         # check if value needs to be evaluated
 256         if value is not None and value.startswith("`") and value.endswith("`"):
 257             res = subprocess.Popen("echo %s" % value,
 258                                    shell=True,
 259                                    stdout=subprocess.PIPE).communicate()
 260             value = res[0].strip()
 261
 262         return self.environ.set(key, value)
 263
 264     def dump(self, out):
 265         """\
 266         Write the environment to out
 267
 268         :param out file: the stream where to write the environment
 269         """
 270         for k in self.environ.environ.keys():
 271             try:
 272                 value = self.get(k)
 273             except:
 274                 value = "?"
 275             out.write("%s=%s\n" % (k, value))
 276
 277     def add_line(self, nb_line):
 278         """\
 279         Add empty lines to the out stream (in case of file generation)
 280
 281         :param nb_line int: the number of empty lines to add
 282         """
 283         if 'add_line' in dir(self.environ):
 284             self.environ.add_line(nb_line)
 285
 286     def add_comment(self, comment):
 287         """\
 288         Add a commentary to the out stream (in case of file generation)
 289
 290         :param comment str: the commentary to add
 291         """
 292         if 'add_comment' in dir(self.environ):
 293             self.environ.add_comment(comment)
 294
 295     def add_warning(self, warning):
 296         """\
 297         Add a warning to the out stream (in case of file generation)
 298
 299         :param warning str: the warning to add
 300         """
 301         if 'add_warning' in dir(self.environ):
 302             self.environ.add_warning(warning)
 303
 304     def finish(self, required):
 305         """\
 306         Add a final instruction in the out file (in case of file generation)
 307
 308         :param required bool: Do nothing if required is False
 309         """
 310         if 'finish' in dir(self.environ):
 311             self.environ.add_line(1)
 312             self.environ.add_comment("clean all the path")
 313             self.environ.finish(required)
 314
 315     def set_python_libdirs(self):
 316         """Set some generic variables for python library paths"""
 317         ver = self.get('PYTHON_VERSION')
 318         self.set('PYTHON_LIBDIR0', os.path.join('lib',
 319                                                 'python' + ver,
 320                                                 'site-packages'))
 321         self.set('PYTHON_LIBDIR1', os.path.join('lib64',
 322                                                 'python' + ver,
 323                                                 'site-packages'))
 324
 325         self.python_lib0 = self.get('PYTHON_LIBDIR0')
 326         self.python_lib1 = self.get('PYTHON_LIBDIR1')
 327
 328     def get_names(self, lProducts):
 329         """\
 330         Get the products name to add in SALOME_MODULES environment variable
 331         It is the name of the product, except in the case where the is a
 332         component name. And it has to be in SALOME_MODULES variable only
 333         if the product has the property has_salome_hui = "yes"
 334
 335         :param lProducts list: List of products to potentially add
 336         """
 337         lProdHasGui = [p for p in lProducts if 'properties' in
 338             src.product.get_product_config(self.cfg, p) and
 339             'has_salome_gui' in
 340             src.product.get_product_config(self.cfg, p).properties and
 341             src.product.get_product_config(self.cfg,
 342                                            p).properties.has_salome_gui=='yes']
 343         lProdName = []
 344         for ProdName in lProdHasGui:
 345             pi = src.product.get_product_config(self.cfg, ProdName)
 346             if 'component_name' in pi:
 347                 lProdName.append(pi.component_name)
 348             else:
 349                 lProdName.append(ProdName)
 350         return lProdName
 351
 352     def set_application_env(self, logger):
 353         """\
 354         Sets the environment defined in the APPLICATION file.
 355
 356         :param logger Logger: The logger instance to display messages
 357         """
 358
 359         # add variable PRODUCT_ROOT_DIR as $workdir in APPLICATION.environ section if not present
 360         try:
 361           tmp = self.cfg.APPLICATION.environ.PRODUCT_ROOT_DIR
 362         except:
 363           self.cfg.APPLICATION.environ.PRODUCT_ROOT_DIR = src.pyconf.Reference(self.cfg, src.pyconf.DOLLAR, "workdir")
 364           DBG.write("set_application_env add default Config.APPLICATION.environ.PRODUCT_ROOT_DIR", self.cfg.APPLICATION.environ)
 365
 366         # Set the variables defined in the "environ" section
 367         if 'environ' in self.cfg.APPLICATION:
 368             # we write PRODUCT environment it in order to conform to
 369             # parseConfigFile.py
 370             self.add_comment("PRODUCT environment")
 371             self.load_cfg_environment(self.cfg.APPLICATION.environ)
 372             if self.forBuild and "build" in self.cfg.APPLICATION.environ:
 373                 self.load_cfg_environment(self.cfg.APPLICATION.environ.build)
 374             if not self.forBuild and "launch" in self.cfg.APPLICATION.environ:
 375                 self.load_cfg_environment(self.cfg.APPLICATION.environ.launch)
 376             self.add_line(1)
 377
 378         # If there is an "environ_script" section, load the scripts
 379         if 'environ_script' in self.cfg.APPLICATION:
 380             for pscript in self.cfg.APPLICATION.environ_script:
 381                 self.add_comment("script %s" % pscript)
 382                 sname = pscript.replace(" ", "_")
 383                 self.run_env_script("APPLICATION_%s" % sname,
 384                                 self.cfg.APPLICATION.environ_script[pscript],
 385                                 logger)
 386                 self.add_line(1)
 387
 388     def set_salome_minimal_product_env(self, product_info, logger):
 389         """\
 390         Sets the minimal environment for a SALOME product.
 391         xxx_ROOT_DIR and xxx_SRC_DIR
 392
 393         :param product_info Config: The product description
 394         :param logger Logger: The logger instance to display messages
 395         """
 396         # set root dir
 397         DBG.write("set_salome_minimal_product_env", product_info)
 398         root_dir = product_info.name + "_ROOT_DIR"
 399         if not self.is_defined(root_dir):
 400             if 'install_dir' in product_info and product_info.install_dir:
 401                 self.set(root_dir, product_info.install_dir)
 402             elif not self.silent:
 403                 logger.write("  " + _("No install_dir for product %s\n") %
 404                               product_info.name, 5)
 405
 406         source_in_package = src.get_property_in_product_cfg(product_info,
 407                                                            "sources_in_package")
 408         if not self.for_package or source_in_package == "yes":
 409             # set source dir, unless no source dir
 410             if not src.product.product_is_fixed(product_info):
 411                 src_dir = product_info.name + "_SRC_DIR"
 412                 if not self.is_defined(src_dir):
 413                     if not self.for_package:
 414                         self.set(src_dir, product_info.source_dir)
 415                     else:
 416                         self.set(src_dir, os.path.join("out_dir_Path",
 417                                                        "SOURCES",
 418                                                        product_info.name))
 419
 420     def set_salome_generic_product_env(self, pi):
 421         """\
 422         Sets the generic environment for a SALOME product.
 423
 424         :param pi Config: The product description
 425         """
 426         # Construct XXX_ROOT_DIR
 427         env_root_dir = self.get(pi.name + "_ROOT_DIR")
 428         l_binpath_libpath = []
 429
 430         # create additional ROOT_DIR for CPP components
 431         if 'component_name' in pi:
 432             compo_name = pi.component_name
 433             if compo_name + "CPP" == pi.name:
 434                 compo_root_dir = compo_name + "_ROOT_DIR"
 435                 envcompo_root_dir = os.path.join(
 436                             self.cfg.TOOLS.common.install_root, compo_name )
 437                 self.set(compo_root_dir ,  envcompo_root_dir)
 438                 bin_path = os.path.join(envcompo_root_dir, 'bin', 'salome')
 439                 lib_path = os.path.join(envcompo_root_dir, 'lib', 'salome')
 440                 l_binpath_libpath.append( (bin_path, lib_path) )
 441
 442         if src.get_property_in_product_cfg(pi, "fhs"):
 443             lib_path = os.path.join(env_root_dir, 'lib')
 444             pylib1_path = os.path.join(env_root_dir, self.python_lib0)
 445             pylib2_path = os.path.join(env_root_dir, self.python_lib1)
 446             bin_path = os.path.join(env_root_dir, 'bin')
 447         else:
 448             lib_path = os.path.join(env_root_dir, 'lib', 'salome')
 449             pylib1_path = os.path.join(env_root_dir, self.python_lib0, 'salome')
 450             pylib2_path = os.path.join(env_root_dir, self.python_lib1, 'salome')
 451             bin_path = os.path.join(env_root_dir, 'bin', 'salome')
 452
 453         # Construct the paths to prepend to PATH and LD_LIBRARY_PATH and
 454         # PYTHONPATH
 455         l_binpath_libpath.append( (bin_path, lib_path) )
 456
 457         for bin_path, lib_path in l_binpath_libpath:
 458             if not self.forBuild:
 459                 self.prepend('PATH', bin_path)
 460                 if src.architecture.is_windows():
 461                     self.prepend('PATH', lib_path)
 462                 else :
 463                     self.prepend('LD_LIBRARY_PATH', lib_path)
 464
 465             l = [ bin_path, lib_path, pylib1_path, pylib2_path ]
 466             self.prepend('PYTHONPATH', l)
 467
 468     def set_cpp_env(self, product_info):
 469         """\
 470         Sets the generic environment for a SALOME cpp product.
 471
 472         :param product_info Config: The product description
 473         """
 474         # Construct XXX_ROOT_DIR
 475         env_root_dir = self.get(product_info.name + "_ROOT_DIR")
 476         l_binpath_libpath = []
 477
 478         # Construct the paths to prepend to PATH and LD_LIBRARY_PATH and
 479         # PYTHONPATH
 480         bin_path = os.path.join(env_root_dir, 'bin')
 481         lib_path = os.path.join(env_root_dir, 'lib')
 482         l_binpath_libpath.append( (bin_path, lib_path) )
 483
 484         for bin_path, lib_path in l_binpath_libpath:
 485             if not self.forBuild:
 486                 self.prepend('PATH', bin_path)
 487                 if src.architecture.is_windows():
 488                     self.prepend('PATH', lib_path)
 489                 else :
 490                     self.prepend('LD_LIBRARY_PATH', lib_path)
 491
 492             l = [ bin_path, lib_path,
 493                   os.path.join(env_root_dir, self.python_lib0),
 494                   os.path.join(env_root_dir, self.python_lib1)
 495                 ]
 496             self.prepend('PYTHONPATH', l)
 497
 498     def load_cfg_environment(self, cfg_env):
 499         """\
 500         Loads environment defined in cfg_env
 501
 502         :param cfg_env Config: A config containing an environment
 503         """
 504         # Loop on cfg_env values
 505         for env_def in cfg_env:
 506             val = cfg_env[env_def]
 507
 508             # if it is env_script, do not do anything (reserved keyword)
 509             if env_def == "env_script":
 510                 continue
 511
 512             # if it is a dict, do not do anything
 513             if isinstance(val, src.pyconf.Mapping):
 514                 continue
 515
 516             # if it is a list, loop on its values
 517             if isinstance(val, src.pyconf.Sequence):
 518                 # transform into list of strings
 519                 l_val = []
 520                 for item in val:
 521                     l_val.append(item)
 522                 val = l_val
 523
 524             # "_" means that the value must be prepended
 525             if env_def.startswith("_"):
 526                 # separator exception for PV_PLUGIN_PATH
 527                 if env_def[1:] == 'PV_PLUGIN_PATH':
 528                     self.prepend(env_def[1:], val, ';')
 529                 else:
 530                     self.prepend(env_def[1:], val)
 531             elif env_def.endswith("_"):
 532                 # separator exception for PV_PLUGIN_PATH
 533                 if env_def[:-1] == 'PV_PLUGIN_PATH':
 534                     self.append(env_def[:-1], val, ';')
 535                 else:
 536                     self.append(env_def[:-1], val)
 537             else:
 538                 self.set(env_def, val)
 539
 540     def set_a_product(self, product, logger):
 541         """\
 542         Sets the environment of a product.
 543
 544         :param product str: The product name
 545         :param logger Logger: The logger instance to display messages
 546         """
 547
 548         # Get the informations corresponding to the product
 549         pi = src.product.get_product_config(self.cfg, product)
 550
 551         if self.for_package:
 552             pi.install_dir = os.path.join("out_dir_Path",
 553                                           self.for_package,
 554                                           pi.name)
 555
 556         if not self.silent:
 557             logger.write(_("Setting environment for %s\n") % product, 4)
 558
 559         self.add_line(1)
 560         self.add_comment('setting environ for ' + product)
 561
 562         # Do not define environment if the product is native
 563         if src.product.product_is_native(pi):
 564             if src.product.product_has_env_script(pi):
 565                 self.run_env_script(pi, native=True)
 566             return
 567
 568         # Set an additional environment for SALOME products
 569         if src.product.product_is_salome(pi):
 570             # set environment using definition of the product
 571             self.set_salome_minimal_product_env(pi, logger)
 572             self.set_salome_generic_product_env(pi)
 573
 574         if src.product.product_is_cpp(pi):
 575             # set a specific environment for cpp modules
 576             self.set_salome_minimal_product_env(pi, logger)
 577             self.set_cpp_env(pi)
 578
 579             if src.product.product_is_generated(pi):
 580                 if "component_name" in pi:
 581                     # hack the source and install directories in order to point
 582                     # on the generated product source install directories
 583                     install_dir_save = pi.install_dir
 584                     source_dir_save = pi.source_dir
 585                     name_save = pi.name
 586                     pi.install_dir = os.path.join(self.cfg.APPLICATION.workdir,
 587                                                   "INSTALL",
 588                                                   pi.component_name)
 589                     if self.for_package:
 590                         pi.install_dir = os.path.join("out_dir_Path",
 591                                                       self.for_package,
 592                                                       pi.component_name)
 593                     pi.source_dir = os.path.join(self.cfg.APPLICATION.workdir,
 594                                                   "GENERATED",
 595                                                   pi.component_name)
 596                     pi.name = pi.component_name
 597                     self.set_salome_minimal_product_env(pi, logger)
 598                     self.set_salome_generic_product_env(pi)
 599
 600                     # Put original values
 601                     pi.install_dir = install_dir_save
 602                     pi.source_dir = source_dir_save
 603                     pi.name = name_save
 604
 605         # Put the environment define in the configuration of the product
 606         if "environ" in pi:
 607             self.load_cfg_environment(pi.environ)
 608             if self.forBuild and "build" in pi.environ:
 609                 self.load_cfg_environment(pi.environ.build)
 610             if not self.forBuild and "launch" in pi.environ:
 611                 self.load_cfg_environment(pi.environ.launch)
 612             # if product_info defines a env_scripts, load it
 613             if 'env_script' in pi.environ:
 614                 self.run_env_script(pi, logger)
 615
 616
 617
 618
 619     def run_env_script(self, product_info, logger=None, native=False):
 620         """\
 621         Runs an environment script.
 622
 623         :param product_info Config: The product description
 624         :param logger Logger: The logger instance to display messages
 625         :param native Boolean: if True load set_native_env instead of set_env
 626         """
 627         env_script = product_info.environ.env_script
 628         # Check that the script exists
 629         if not os.path.exists(env_script):
 630             raise src.SatException(_("Environment script not found: %s") %
 631                                    env_script)
 632
 633         if not self.silent and logger is not None:
 634             logger.write("  ** load %s\n" % env_script, 4)
 635
 636         # import the script and run the set_env function
 637         try:
 638             import imp
 639             pyproduct = imp.load_source(product_info.name + "_env_script",
 640                                         env_script)
 641             if not native:
 642                 pyproduct.set_env(self,
 643                                   product_info.install_dir,
 644                                   product_info.version)
 645             else:
 646                 if "set_nativ_env" in dir(pyproduct):
 647                     pyproduct.set_nativ_env(self)
 648         except:
 649             __, exceptionValue, exceptionTraceback = sys.exc_info()
 650             print(exceptionValue)
 651             import traceback
 652             traceback.print_tb(exceptionTraceback)
 653             traceback.print_exc()
 654
 655     def run_simple_env_script(self, script_path, logger=None):
 656         """\
 657         Runs an environment script. Same as run_env_script, but with a
 658         script path as parameter.
 659
 660         :param script_path str: a path to an environment script
 661         :param logger Logger: The logger instance to display messages
 662         """
 663         if not self.enable_simple_env_script:
 664             return
 665         # Check that the script exists
 666         if not os.path.exists(script_path):
 667             raise src.SatException(_("Environment script not found: %s") %
 668                                    script_path)
 669
 670         if not self.silent and logger is not None:
 671             logger.write("  ** load %s\n" % script_path, 4)
 672
 673         script_basename = os.path.basename(script_path)
 674         if script_basename.endswith(".py"):
 675             script_basename = script_basename[:-len(".py")]
 676
 677         # import the script and run the set_env function
 678         try:
 679             import imp
 680             pyproduct = imp.load_source(script_basename + "_env_script",
 681                                         script_path)
 682             pyproduct.load_env(self)
 683         except:
 684             __, exceptionValue, exceptionTraceback = sys.exc_info()
 685             print(exceptionValue)
 686             import traceback
 687             traceback.print_tb(exceptionTraceback)
 688             traceback.print_exc()
 689
 690     def set_products(self, logger, src_root=None):
 691         """\
 692         Sets the environment for all the products.
 693
 694         :param logger Logger: The logger instance to display messages
 695         :param src_root src: the application working directory
 696         """
 697         self.add_line(1)
 698         self.add_comment('setting environ for all products')
 699
 700         # Make sure that the python lib dirs are set after python
 701         if "Python" in self.cfg.APPLICATION.products:
 702             self.set_a_product("Python", logger)
 703             self.set_python_libdirs()
 704
 705         # The loop on the products
 706         for product in self.cfg.APPLICATION.products.keys():
 707             if product == "Python":
 708                 continue
 709             self.set_a_product(product, logger)
 710             self.finish(False)
 711
 712     def set_full_environ(self, logger, env_info):
 713         """\
 714         Sets the full environment for products
 715         specified in env_info dictionary.
 716
 717         :param logger Logger: The logger instance to display messages
 718         :param env_info list: the list of products
 719         """
 720         DBG.write("set_full_environ for", env_info)
 721         # DBG.write("set_full_environ config", self.cfg.APPLICATION.environ, True)
 722         # set product environ
 723         self.set_application_env(logger)
 724
 725         self.set_python_libdirs()
 726
 727         # set products
 728         for product in env_info:
 729             self.set_a_product(product, logger)
 730
 731 class FileEnvWriter:
 732     """\
 733     Class to dump the environment to a file.
 734     """
 735     def __init__(self, config, logger, out_dir, src_root, env_info=None):
 736         """\
 737         Initialization.
 738
 739         :param cfg Config: the global config
 740         :param logger Logger: The logger instance to display messages
 741         :param out_dir str: The directory path where t put the output files
 742         :param src_root str: The application working directory
 743         :param env_info str: The list of products to add in the files.
 744         """
 745         self.config = config
 746         self.logger = logger
 747         self.out_dir = out_dir
 748         self.src_root= src_root
 749         self.silent = True
 750         self.env_info = env_info
 751
 752     def write_env_file(self, filename, forBuild, shell, for_package = None):
 753         """\
 754         Create an environment file.
 755
 756         :param filename str: the file path
 757         :param forBuild bool: if true, the build environment
 758         :param shell str: the type of file wanted (.sh, .bat)
 759         :return: The path to the generated file
 760         :rtype: str
 761         """
 762         if not self.silent:
 763             self.logger.write(_("Create environment file %s\n") %
 764                               src.printcolors.printcLabel(filename), 3)
 765
 766         # create then env object
 767         env_file = open(os.path.join(self.out_dir, filename), "w")
 768         tmp = src.fileEnviron.get_file_environ(env_file,
 769                                                shell,
 770                                                {})
 771         env = SalomeEnviron(self.config, tmp, forBuild, for_package=for_package)
 772         env.silent = self.silent
 773
 774         # Set the environment
 775         if self.env_info is not None:
 776             env.set_full_environ(self.logger, self.env_info)
 777         else:
 778             # set env from the APPLICATION
 779             env.set_application_env(self.logger)
 780
 781             # The list of products to launch
 782             lProductsName = env.get_names(self.config.APPLICATION.products.keys())
 783             env.set( "SALOME_MODULES",    ','.join(lProductsName))
 784
 785             # set the products
 786             env.set_products(self.logger,
 787                             src_root=self.src_root)
 788
 789         # add cleanup and close
 790         env.finish(True)
 791         env_file.close()
 792
 793         return env_file.name
 794
 795     def write_cfgForPy_file(self,
 796                             filename,
 797                             additional_env = {},
 798                             for_package = None,
 799                             with_commercial = True):
 800         """\
 801         Append to current opened aFile a cfgForPy
 802         environment (SALOME python launcher).
 803
 804         :param filename str: the file path
 805         :param additional_env dict: a dictionary of additional variables
 806                                     to add to the environment
 807         :param for_package str: If not None, produce a relative environment
 808                                 designed for a package.
 809         """
 810         if not self.silent:
 811             self.logger.write(_("Create configuration file %s\n") %
 812                               src.printcolors.printcLabel(filename.name), 3)
 813
 814         # create then env object
 815         tmp = src.fileEnviron.get_file_environ(filename,
 816                                                "cfgForPy",
 817                                                {})
 818         # environment for launch
 819         env = SalomeEnviron(self.config,
 820                             tmp,
 821                             forBuild=False,
 822                             for_package=for_package,
 823                             enable_simple_env_script = with_commercial)
 824         env.silent = self.silent
 825
 826         if self.env_info is not None:
 827             env.set_full_environ(self.logger, self.env_info)
 828         else:
 829             # set env from PRODUCT
 830             env.set_application_env(self.logger)
 831
 832             # The list of products to launch
 833             lProductsName = env.get_names(self.config.APPLICATION.products.keys())
 834             env.set( "SALOME_MODULES",    ','.join(lProductsName))
 835
 836             # set the products
 837             env.set_products(self.logger,
 838                             src_root=self.src_root)
 839
 840         # Add the additional environment if it is not empty
 841         if len(additional_env) != 0:
 842             for variable in additional_env:
 843                 env.set(variable, additional_env[variable])
 844
 845         # add cleanup and close
 846         env.finish(True)
 847
 848 class Shell:
 849     """\
 850     Definition of a Shell.
 851     """
 852     def __init__(self, name, extension):
 853         """\
 854         Initialization.
 855
 856         :param name str: the shell name
 857         :param extension str: the shell extension
 858         """
 859         self.name = name
 860         self.extension = extension
 861
 862 def load_environment(config, build, logger):
 863     """\
 864     Loads the environment (used to run the tests, for example).
 865
 866     :param config Config: the global config
 867     :param build bool: build environement if True
 868     :param logger Logger: The logger instance to display messages
 869     """
 870     environ = SalomeEnviron(config, Environ(os.environ), build)
 871     environ.set_application_env(logger)
 872     environ.set_products(logger)
 873     environ.finish(True)