X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2Fenvironment.py;h=20a5c1eb95dc0b4f6a58873ffa657305a57909d0;hb=cf8129d30d2a819ccee42e611c9f80d5e0aad5b8;hp=721fbeeabfeda1f49e937a42ff4f2f86f4a2aac6;hpb=cfa9edfb956345c69090469b519a94dcc55ba382;p=tools%2Fsat.git diff --git a/src/environment.py b/src/environment.py index 721fbee..20a5c1e 100644 --- a/src/environment.py +++ b/src/environment.py @@ -22,35 +22,37 @@ import string import sys import src +import src.debug as DBG +import pprint as PP + class Environ: - '''Class to manage the environment context - ''' + """\ + Class to manage the environment context + """ def __init__(self, environ=None): - '''Initialization. If the environ argument is passed, the environment + """Initialization. If the environ argument is passed, the environment will be add to it, else it is the external environment. :param environ dict: - ''' + """ if environ is not None: self.environ = environ else: self.environ = os.environ def __repr__(self): - """easy non exhaustive quick resume for debug print - """ - res={} - res["environ"]=self.environ - return self.__class__.__name__ + str(res)[0:-1] + " ...etc...}" + """easy non exhaustive quick resume for debug print""" + return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(self.environ)) def _expandvars(self, value): - '''replace some $VARIABLE into its actual value in the environment + """\ + replace some $VARIABLE into its actual value in the environment :param value str: the string to be replaced :return: the replaced variable :rtype: str - ''' + """ if "$" in value: # The string.Template class is a string class # for supporting $-substitutions @@ -63,12 +65,19 @@ class Environ: return value def append_value(self, key, value, sep=os.pathsep): - '''append value to key using sep - + """\ + append value to key using sep, + if value contains ":" or ";" then raise error + :param key str: the environment variable to append :param value str: the value to append to key :param sep str: the separator string - ''' + """ + # check that value so no contain the system separator + separator=os.pathsep + if separator in value: + raise Exception("Environ append key '%s' value '%s' contains forbidden character '%s'" % (key, value, separator)) + # check if the key is already in the environment if key in self.environ: value_list = self.environ[key].split(sep) @@ -82,12 +91,13 @@ class Environ: self.set(key, value) def append(self, key, value, sep=os.pathsep): - '''Same as append_value but the value argument can be a list + """\ + Same as append_value but the value argument can be a list :param key str: the environment variable to append :param value str or list: the value(s) to append to key :param sep str: the separator string - ''' + """ if isinstance(value, list): for v in value: self.append_value(key, v, sep) @@ -95,12 +105,20 @@ class Environ: self.append_value(key, value, sep) def prepend_value(self, key, value, sep=os.pathsep): - '''prepend value to key using sep + """\ + prepend value to key using sep, + if value contains ":" or ";" then raise error :param key str: the environment variable to prepend :param value str: the value to prepend to key :param sep str: the separator string - ''' + """ + # check that value so no contain the system separator + separator=os.pathsep + if separator in value: + raise Exception("Environ append key '%s' value '%s' contains forbidden character '%s'" % (key, value, separator)) + + # check if the key is already in the environment if key in self.environ: value_list = self.environ[key].split(sep) if not value in value_list: @@ -112,50 +130,64 @@ class Environ: self.set(key, value) def prepend(self, key, value, sep=os.pathsep): - '''Same as prepend_value but the value argument can be a list + """\ + Same as prepend_value but the value argument can be a list :param key str: the environment variable to prepend :param value str or list: the value(s) to prepend to key :param sep str: the separator string - ''' + """ if isinstance(value, list): - for v in value: + for v in reversed(value): # prepend list, first item at last to stay first self.prepend_value(key, v, sep) else: self.prepend_value(key, value, sep) def is_defined(self, key): - '''Check if the key exists in the environment + """\ + Check if the key exists in the environment :param key str: the environment variable to check - ''' + """ return key in self.environ.keys() def set(self, key, value): - '''Set the environment variable "key" to value "value" + """\ + Set the environment variable "key" to value "value" :param key str: the environment variable to set :param value str: the value - ''' + """ self.environ[key] = self._expandvars(value) def get(self, key): - '''Get the value of the environment variable "key" + """\ + Get the value of the environment variable "key" :param key str: the environment variable - ''' + """ if key in self.environ: return self.environ[key] else: return "" + def get_value(self, key): + """\ + Get the value of the environment variable "key" + This method is added for API compatibility with FileEnviron class + + :param key str: the environment variable + """ + return self.get(key) + def command_value(self, key, command): - '''Get the value given by the system command "command" - and put it in the environment variable key + """\ + Get the value given by the system command "command" + and put it in the environment variable key :param key str: the environment variable :param command str: the command to execute - ''' + """ value = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, @@ -164,68 +196,98 @@ class Environ: class SalomeEnviron: - """Class to manage the environment of SALOME. + """\ + Class to manage the environment of SALOME. """ - - def __init__(self, cfg, environ, forBuild=False): - '''Initialization. + def __init__(self, + cfg, + environ, + forBuild=False, + for_package=None, + enable_simple_env_script = True): + """\ + Initialization. :param cfg Config: the global config :param environ Environ: the Environ instance where to store the environment variables :param forBuild bool: If true, it is a launch environment, else a build one - ''' + :param for_package str: If not None, produce a relative environment + designed for a package. + """ self.environ = environ self.cfg = cfg self.forBuild = forBuild + self.for_package = for_package + self.enable_simple_env_script = enable_simple_env_script self.silent = False + self.has_python = False def __repr__(self): - """easy non exhaustive quick resume for debug print""" - res={} - res["environ"]=str(self.environ) - res["forBuild"]=self.forBuild - return self.__class__.__name__ + str(res)[0:-1] + " ...etc...}" + """easy almost exhaustive quick resume for debug print""" + res = { + "environ" : self.environ, + "forBuild" : self.forBuild, + "for_package" : self.for_package, + } + return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(res)) def append(self, key, value, sep=os.pathsep): - '''append value to key using sep + """\ + append value to key using sep :param key str: the environment variable to append :param value str: the value to append to key :param sep str: the separator string - ''' + """ return self.environ.append(key, value, sep) def prepend(self, key, value, sep=os.pathsep): - '''prepend value to key using sep + """\ + prepend value to key using sep :param key str: the environment variable to prepend :param value str: the value to prepend to key :param sep str: the separator string - ''' + """ return self.environ.prepend(key, value, sep) def is_defined(self, key): - '''Check if the key exists in the environment + """\ + Check if the key exists in the environment :param key str: the environment variable to check - ''' + """ return self.environ.is_defined(key) def get(self, key): - '''Get the value of the environment variable "key" + """\ + Get the value of the environment variable "key" :param key str: the environment variable - ''' + """ return self.environ.get(key) + def get_value(self, key): + """\ + Get the real value of the environment variable "key" + This method is added for API compatibility with FileEnviron class + + :param key str: the environment variable + """ + if key in self.environ: + return self.environ[key] + else: + return "" + def set(self, key, value): - '''Set the environment variable "key" to value "value" + """\ + Set the environment variable "key" to value "value" :param key str: the environment variable to set :param value str: the value - ''' + """ # check if value needs to be evaluated if value is not None and value.startswith("`") and value.endswith("`"): res = subprocess.Popen("echo %s" % value, @@ -236,7 +298,8 @@ class SalomeEnviron: return self.environ.set(key, value) def dump(self, out): - """Write the environment to out + """\ + Write the environment to out :param out file: the stream where to write the environment """ @@ -248,7 +311,8 @@ class SalomeEnviron: out.write("%s=%s\n" % (k, value)) def add_line(self, nb_line): - """Add empty lines to the out stream (in case of file generation) + """\ + Add empty lines to the out stream (in case of file generation) :param nb_line int: the number of empty lines to add """ @@ -256,7 +320,8 @@ class SalomeEnviron: self.environ.add_line(nb_line) def add_comment(self, comment): - """Add a commentary to the out stream (in case of file generation) + """\ + Add a commentary to the out stream (in case of file generation) :param comment str: the commentary to add """ @@ -264,7 +329,8 @@ class SalomeEnviron: self.environ.add_comment(comment) def add_warning(self, warning): - """Add a warning to the out stream (in case of file generation) + """\ + Add a warning to the out stream (in case of file generation) :param warning str: the warning to add """ @@ -272,18 +338,19 @@ class SalomeEnviron: self.environ.add_warning(warning) def finish(self, required): - """Add a final instruction in the out file (in case of file generation) + """\ + Add a final instruction in the out file (in case of file generation) :param required bool: Do nothing if required is False """ if 'finish' in dir(self.environ): self.environ.add_line(1) - self.environ.add_comment("clean all the path") + # what for ? + # self.environ.add_comment("clean all the path") self.environ.finish(required) def set_python_libdirs(self): - """Set some generic variables for python library paths - """ + """Set some generic variables for python library paths""" ver = self.get('PYTHON_VERSION') self.set('PYTHON_LIBDIR0', os.path.join('lib', 'python' + ver, @@ -294,18 +361,23 @@ class SalomeEnviron: self.python_lib0 = self.get('PYTHON_LIBDIR0') self.python_lib1 = self.get('PYTHON_LIBDIR1') + self.has_python = True def get_names(self, lProducts): - """Get the products name to add in SALOME_MODULES environment variable - It is the name of the product, except in the case where the is a - component name. And it has to be in SALOME_MODULES variable only - if has_gui = "yes" + """\ + Get the products name to add in SALOME_MODULES environment variable + It is the name of the product, except in the case where the is a + component name. And it has to be in SALOME_MODULES variable only + if the product has the property has_salome_hui = "yes" :param lProducts list: List of products to potentially add """ - lProdHasGui = [p for p in lProducts if 'type ' in - src.product.get_product_config(self.cfg, p) and - src.product.get_product_config(self.cfg, p).type=='salome'] + lProdHasGui = [p for p in lProducts if 'properties' in + src.product.get_product_config(self.cfg, p) and + 'has_salome_gui' in + src.product.get_product_config(self.cfg, p).properties and + src.product.get_product_config(self.cfg, + p).properties.has_salome_gui=='yes'] lProdName = [] for ProdName in lProdHasGui: pi = src.product.get_product_config(self.cfg, ProdName) @@ -316,55 +388,48 @@ class SalomeEnviron: return lProdName def set_application_env(self, logger): - """Sets the environment defined in the APPLICATION file. + """\ + Sets the environment defined in the APPLICATION file. :param logger Logger: The logger instance to display messages """ + if self.for_package: + self.set("PRODUCT_ROOT_DIR", "out_dir_Path") + else: + self.cfg.APPLICATION.environ.PRODUCT_ROOT_DIR = src.pyconf.Reference(self.cfg, src.pyconf.DOLLAR, "workdir") + + # these sensitive variables are reset to avoid bad environment interactions + self.add_line(1) + self.add_comment("reset these sensitive variables to avoid bad environment interactions") + self.add_comment("comment these to lines if you wish a different behaviour") + self.set("LD_LIBRARY_PATH", "") + self.set("PYTHONPATH", "") + self.add_line(1) + # Set the variables defined in the "environ" section if 'environ' in self.cfg.APPLICATION: - self.add_comment("APPLICATION environment") - for p in self.cfg.APPLICATION.environ: - self.set(p, self.cfg.APPLICATION.environ[p]) + # we write PRODUCT environment it in order to conform to + # parseConfigFile.py + self.add_comment("PRODUCT environment") + self.load_cfg_environment(self.cfg.APPLICATION.environ) + if self.forBuild and "build" in self.cfg.APPLICATION.environ: + self.load_cfg_environment(self.cfg.APPLICATION.environ.build) + if not self.forBuild and "launch" in self.cfg.APPLICATION.environ: + self.load_cfg_environment(self.cfg.APPLICATION.environ.launch) self.add_line(1) - # If there is an "environ_script" section, load the scripts - if 'environ_script' in self.cfg.APPLICATION: - for pscript in self.cfg.APPLICATION.environ_script: - self.add_comment("script %s" % pscript) - sname = pscript.replace(" ", "_") - self.run_env_script("APPLICATION_%s" % sname, - self.cfg.APPLICATION.environ_script[pscript], - logger) - self.add_line(1) - - # If there is profile (SALOME), then define additional variables - if 'profile' in self.cfg.APPLICATION: - profile_product = self.cfg.APPLICATION.profile.product - product_info_profile = src.product.get_product_config(self.cfg, - profile_product) - profile_share_salome = os.path.join(product_info_profile.install_dir, - "share", - "salome" ) - self.set( "SUITRoot", profile_share_salome ) - self.set( "SalomeAppConfig", - os.path.join(profile_share_salome, - "resources", - profile_product.lower() ) ) - - # The list of products to launch - lProductsName = self.get_names(self.cfg.APPLICATION.products.keys()) - - self.set( "SALOME_MODULES", ','.join(lProductsName)) def set_salome_minimal_product_env(self, product_info, logger): - """Sets the minimal environment for a SALOME product. - xxx_ROOT_DIR and xxx_SRC_DIR + """\ + Sets the minimal environment for a SALOME product. + xxx_ROOT_DIR and xxx_SRC_DIR :param product_info Config: The product description :param logger Logger: The logger instance to display messages """ # set root dir + DBG.write("set_salome_minimal_product_env", product_info) root_dir = product_info.name + "_ROOT_DIR" if not self.is_defined(root_dir): if 'install_dir' in product_info and product_info.install_dir: @@ -372,20 +437,27 @@ class SalomeEnviron: elif not self.silent: logger.write(" " + _("No install_dir for product %s\n") % product_info.name, 5) - - # set source dir, unless no source dir - if not src.product.product_is_fixed(product_info): - src_dir = product_info.name + "_SRC_DIR" - if not self.is_defined(src_dir): - self.set(src_dir, product_info.source_dir) - - def set_salome_generic_product_env(self, product): - """Sets the generic environment for a SALOME product. - :param product str: The product name + source_in_package = src.get_property_in_product_cfg(product_info, + "sources_in_package") + if not self.for_package or source_in_package == "yes": + # set source dir, unless no source dir + if not src.product.product_is_fixed(product_info): + src_dir = product_info.name + "_SRC_DIR" + if not self.is_defined(src_dir): + if not self.for_package: + self.set(src_dir, product_info.source_dir) + else: + self.set(src_dir, os.path.join("out_dir_Path", + "SOURCES", + product_info.name)) + + def set_salome_generic_product_env(self, pi): + """\ + Sets the generic environment for a SALOME product. + + :param pi Config: The product description """ - # get the product descritption - pi = src.product.get_product_config(self.cfg, product) # Construct XXX_ROOT_DIR env_root_dir = self.get(pi.name + "_ROOT_DIR") l_binpath_libpath = [] @@ -393,7 +465,7 @@ class SalomeEnviron: # create additional ROOT_DIR for CPP components if 'component_name' in pi: compo_name = pi.component_name - if compo_name + "CPP" == product: + if compo_name + "CPP" == pi.name: compo_root_dir = compo_name + "_ROOT_DIR" envcompo_root_dir = os.path.join( self.cfg.TOOLS.common.install_root, compo_name ) @@ -402,15 +474,24 @@ class SalomeEnviron: lib_path = os.path.join(envcompo_root_dir, 'lib', 'salome') l_binpath_libpath.append( (bin_path, lib_path) ) - appliname = 'salome' - if (src.get_cfg_param(pi, 'product_type', 'SALOME').upper() - not in [ "SALOME", "SMESH_PLUGIN", "SAMPLE" ]): - appliname = '' + + if src.get_property_in_product_cfg(pi, "fhs"): + lib_path = os.path.join(env_root_dir, 'lib') + bin_path = os.path.join(env_root_dir, 'bin') + if self.has_python: + # if the application doesn't include python, we don't need these two lines + pylib1_path = os.path.join(env_root_dir, self.python_lib0) + pylib2_path = os.path.join(env_root_dir, self.python_lib1) + else: + lib_path = os.path.join(env_root_dir, 'lib', 'salome') + bin_path = os.path.join(env_root_dir, 'bin', 'salome') + if self.has_python: + # if the application doesn't include python, we don't need these two lines + pylib1_path = os.path.join(env_root_dir, self.python_lib0, 'salome') + pylib2_path = os.path.join(env_root_dir, self.python_lib1, 'salome') # Construct the paths to prepend to PATH and LD_LIBRARY_PATH and # PYTHONPATH - bin_path = os.path.join(env_root_dir, 'bin', appliname) - lib_path = os.path.join(env_root_dir, 'lib', appliname) l_binpath_libpath.append( (bin_path, lib_path) ) for bin_path, lib_path in l_binpath_libpath: @@ -421,14 +502,46 @@ class SalomeEnviron: else : self.prepend('LD_LIBRARY_PATH', lib_path) - l = [ bin_path, lib_path, - os.path.join(env_root_dir, self.python_lib0, appliname), - os.path.join(env_root_dir, self.python_lib1, appliname) - ] + l = [ bin_path, lib_path ] + if not src.product.product_is_wheel(pi): + if self.has_python: + l.append(pylib1_path) + l.append(pylib2_path) + self.prepend('PYTHONPATH', l) + + def set_cpp_env(self, product_info): + """\ + Sets the generic environment for a SALOME cpp product. + + :param product_info Config: The product description + """ + # Construct XXX_ROOT_DIR + env_root_dir = self.get(product_info.name + "_ROOT_DIR") + l_binpath_libpath = [] + + # Construct the paths to prepend to PATH and LD_LIBRARY_PATH and + # PYTHONPATH + bin_path = os.path.join(env_root_dir, 'bin') + lib_path = os.path.join(env_root_dir, 'lib') + l_binpath_libpath.append( (bin_path, lib_path) ) + + for bin_path, lib_path in l_binpath_libpath: + if not self.forBuild: + self.prepend('PATH', bin_path) + if src.architecture.is_windows(): + self.prepend('PATH', lib_path) + else : + self.prepend('LD_LIBRARY_PATH', lib_path) + + l = [ bin_path, lib_path ] + if self.has_python: + l.append(os.path.join(env_root_dir, self.python_lib0)) + l.append(os.path.join(env_root_dir, self.python_lib1)) self.prepend('PYTHONPATH', l) def load_cfg_environment(self, cfg_env): - """Loads environment defined in cfg_env + """\ + Loads environment defined in cfg_env :param cfg_env Config: A config containing an environment """ @@ -469,7 +582,8 @@ class SalomeEnviron: self.set(env_def, val) def set_a_product(self, product, logger): - """Sets the environment of a product. + """\ + Sets the environment of a product. :param product str: The product name :param logger Logger: The logger instance to display messages @@ -478,22 +592,85 @@ class SalomeEnviron: # Get the informations corresponding to the product pi = src.product.get_product_config(self.cfg, product) - # Do not define environment if the product is native - if src.product.product_is_native(pi): - return - + # skip compile time products at run time + if not self.forBuild: + if src.product.product_is_compile_time(pi): + return + + # skip mesa products (if any) at run time, + # unless use_mesa property was activated + if not self.forBuild: + if not ("APPLICATION" in self.cfg and + "properties" in self.cfg.APPLICATION and + "use_mesa" in self.cfg.APPLICATION.properties and + self.cfg.APPLICATION.properties.use_mesa == "yes") : + if ("properties" in pi and + "is_mesa" in pi.properties and + pi.properties.is_mesa == "yes") : + logger.write(_("Skip mesa product %s\n") % pi.name, 4) + return + + + if self.for_package: + pi.install_dir = os.path.join("out_dir_Path", + self.for_package, + pi.name) + if not self.silent: logger.write(_("Setting environment for %s\n") % product, 4) self.add_line(1) self.add_comment('setting environ for ' + product) - + + # Do not define environment if the product is native + if src.product.product_is_native(pi): + if src.product.product_has_env_script(pi): + self.run_env_script(pi, native=True) + return + # Set an additional environment for SALOME products if src.product.product_is_salome(pi): # set environment using definition of the product self.set_salome_minimal_product_env(pi, logger) - self.set_salome_generic_product_env(product) + self.set_salome_generic_product_env(pi) + + # use variable LICENCE_FILE to communicate the licence file name to the environment script + licence_file_name = src.product.product_has_licence(pi, self.cfg.PATHS.LICENCEPATH) + if licence_file_name: + logger.write("licence file found for product %s : %s\n" % (pi.name, licence_file_name), 5) + self.set("LICENCE_FILE", licence_file_name) + if src.product.product_is_cpp(pi): + # set a specific environment for cpp modules + self.set_salome_minimal_product_env(pi, logger) + self.set_cpp_env(pi) + + if src.product.product_is_generated(pi): + if "component_name" in pi: + # hack the source and install directories in order to point + # on the generated product source install directories + install_dir_save = pi.install_dir + source_dir_save = pi.source_dir + name_save = pi.name + pi.install_dir = os.path.join(self.cfg.APPLICATION.workdir, + config.INTERNAL.config.install_dir, + pi.component_name) + if self.for_package: + pi.install_dir = os.path.join("out_dir_Path", + self.for_package, + pi.component_name) + pi.source_dir = os.path.join(self.cfg.APPLICATION.workdir, + "GENERATED", + pi.component_name) + pi.name = pi.component_name + self.set_salome_minimal_product_env(pi, logger) + self.set_salome_generic_product_env(pi) + + # Put original values + pi.install_dir = install_dir_save + pi.source_dir = source_dir_save + pi.name = name_save + # Put the environment define in the configuration of the product if "environ" in pi: self.load_cfg_environment(pi.environ) @@ -508,11 +685,13 @@ class SalomeEnviron: - def run_env_script(self, product_info, logger=None): - """Runs an environment script. + def run_env_script(self, product_info, logger=None, native=False): + """\ + Runs an environment script. :param product_info Config: The product description :param logger Logger: The logger instance to display messages + :param native Boolean: if True load set_native_env instead of set_env """ env_script = product_info.environ.env_script # Check that the script exists @@ -528,8 +707,25 @@ class SalomeEnviron: import imp pyproduct = imp.load_source(product_info.name + "_env_script", env_script) - pyproduct.set_env(self, product_info.install_dir, - product_info.version) + if not native: + if self.forBuild and "set_env_build" in dir(pyproduct): + pyproduct.set_env_build(self, + product_info.install_dir, + product_info.version) + elif (not self.forBuild) and "set_env_launch" in dir(pyproduct): + pyproduct.set_env_launch(self, + product_info.install_dir, + product_info.version) + else: + # at least this one is mandatory, + # if set_env_build and set_env_build are not defined + pyproduct.set_env(self, + product_info.install_dir, + product_info.version) + else: + # not mandatory, if set_nativ_env not defined, we do nothing + if "set_nativ_env" in dir(pyproduct): + pyproduct.set_nativ_env(self) except: __, exceptionValue, exceptionTraceback = sys.exc_info() print(exceptionValue) @@ -538,12 +734,15 @@ class SalomeEnviron: traceback.print_exc() def run_simple_env_script(self, script_path, logger=None): - """Runs an environment script. Same as run_env_script, but with a - script path as parameter. + """\ + Runs an environment script. Same as run_env_script, but with a + script path as parameter. :param script_path str: a path to an environment script :param logger Logger: The logger instance to display messages """ + if not self.enable_simple_env_script: + return # Check that the script exists if not os.path.exists(script_path): raise src.SatException(_("Environment script not found: %s") % @@ -570,7 +769,8 @@ class SalomeEnviron: traceback.print_exc() def set_products(self, logger, src_root=None): - """Sets the environment for all the products. + """\ + Sets the environment for all the products. :param logger Logger: The logger instance to display messages :param src_root src: the application working directory @@ -578,53 +778,56 @@ class SalomeEnviron: self.add_line(1) self.add_comment('setting environ for all products') - self.set_python_libdirs() - - # Set the application working directory - if src_root is None: - src_root = self.cfg.APPLICATION.workdir - self.set('SRC_ROOT', src_root) - - # SALOME variables - appli_name = "APPLI" - if "APPLI" in self.cfg and "application_name" in self.cfg.APPLI: - appli_name = self.cfg.APPLI.application_name - self.set("SALOME_APPLI_ROOT", - os.path.join(self.cfg.APPLICATION.workdir, appli_name)) + # Make sure that the python lib dirs are set after python + if "Python" in self.cfg.APPLICATION.products: + self.set_a_product("Python", logger) + self.set_python_libdirs() # The loop on the products for product in self.cfg.APPLICATION.products.keys(): + if product == "Python": + continue self.set_a_product(product, logger) self.finish(False) def set_full_environ(self, logger, env_info): - """Sets the full environment for products - specified in env_info dictionary. + """\ + Sets the full environment for products + specified in env_info dictionary. :param logger Logger: The logger instance to display messages :param env_info list: the list of products """ + DBG.write("set_full_environ for", env_info) + # DBG.write("set_full_environ config", self.cfg.APPLICATION.environ, True) + # set product environ self.set_application_env(logger) - self.set_python_libdirs() + if "Python" in env_info: + self.set_a_product("Python", logger) + self.set_python_libdirs() - # set products + # set products for product in env_info: + if product == "Python": + continue self.set_a_product(product, logger) class FileEnvWriter: - """Class to dump the environment to a file. + """\ + Class to dump the environment to a file. """ def __init__(self, config, logger, out_dir, src_root, env_info=None): - '''Initialization. + """\ + Initialization. :param cfg Config: the global config :param logger Logger: The logger instance to display messages :param out_dir str: The directory path where t put the output files :param src_root str: The application working directory :param env_info str: The list of products to add in the files. - ''' + """ self.config = config self.logger = logger self.out_dir = out_dir @@ -632,8 +835,9 @@ class FileEnvWriter: self.silent = True self.env_info = env_info - def write_env_file(self, filename, forBuild, shell): - """Create an environment file. + def write_env_file(self, filename, forBuild, shell, for_package = None): + """\ + Create an environment file. :param filename str: the file path :param forBuild bool: if true, the build environment @@ -650,7 +854,7 @@ class FileEnvWriter: tmp = src.fileEnviron.get_file_environ(env_file, shell, {}) - env = SalomeEnviron(self.config, tmp, forBuild) + env = SalomeEnviron(self.config, tmp, forBuild, for_package=for_package) env.silent = self.silent # Set the environment @@ -659,6 +863,11 @@ class FileEnvWriter: else: # set env from the APPLICATION env.set_application_env(self.logger) + + # The list of products to launch + lProductsName = env.get_names(self.config.APPLICATION.products.keys()) + env.set( "SALOME_MODULES", ','.join(lProductsName)) + # set the products env.set_products(self.logger, src_root=self.src_root) @@ -669,35 +878,53 @@ class FileEnvWriter: return env_file.name - def write_cfgForPy_file(self, filename, additional_env = {}): - """Append to current opened aFile a cfgForPy - environment (SALOME python launcher). + def write_cfgForPy_file(self, + filename, + additional_env = {}, + for_package = None, + with_commercial = True): + """\ + Append to current opened aFile a cfgForPy + environment (SALOME python launcher). :param filename str: the file path :param additional_env dict: a dictionary of additional variables to add to the environment + :param for_package str: If not None, produce a relative environment + designed for a package. """ if not self.silent: self.logger.write(_("Create configuration file %s\n") % - src.printcolors.printcLabel(aFile.name), 3) + src.printcolors.printcLabel(filename.name), 3) # create then env object - tmp = src.fileEnviron.get_file_environ(filename, - "cfgForPy", - {}) + tmp = src.fileEnviron.get_file_environ(filename, "cfgForPy", {}) + # DBG.write("fileEnviron.get_file_environ %s" % filename, tmp, True) + # environment for launch - env = SalomeEnviron(self.config, tmp, forBuild=False) + env = SalomeEnviron(self.config, + tmp, + forBuild=False, + for_package=for_package, + enable_simple_env_script = with_commercial) env.silent = self.silent + DBG.write("write_cfgForPy_file", self.config.APPLICATION.environ) + if self.env_info is not None: env.set_full_environ(self.logger, self.env_info) + DBG.write("set_full_environ", self.env_info) + else: # set env from PRODUCT env.set_application_env(self.logger) + # The list of products to launch + lProductsName = env.get_names(self.config.APPLICATION.products.keys()) + env.set("SALOME_MODULES", ','.join(lProductsName)) + # set the products - env.set_products(self.logger, - src_root=self.src_root) + env.set_products(self.logger, src_root=self.src_root) # Add the additional environment if it is not empty if len(additional_env) != 0: @@ -708,19 +935,22 @@ class FileEnvWriter: env.finish(True) class Shell: - """Definition of a Shell. + """\ + Definition of a Shell. """ def __init__(self, name, extension): - '''Initialization. + """\ + Initialization. :param name str: the shell name :param extension str: the shell extension - ''' + """ self.name = name self.extension = extension def load_environment(config, build, logger): - """Loads the environment (used to run the tests, for example). + """\ + Loads the environment (used to run the tests, for example). :param config Config: the global config :param build bool: build environement if True @@ -729,4 +959,4 @@ def load_environment(config, build, logger): environ = SalomeEnviron(config, Environ(os.environ), build) environ.set_application_env(logger) environ.set_products(logger) - environ.finish(True) \ No newline at end of file + environ.finish(True)