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