X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2Fenvironment.py;h=e6540b050c841f4c83dc9ff3319726d61125d1a5;hb=75c094e1cbcad9685d572ef30a34631a63ac1aba;hp=81741d26e6c0ac00e159d3d35f711a22cdacee27;hpb=5e7b4c7caa792bdd59ebe12d50c8e75236055301;p=tools%2Fsat.git diff --git a/src/environment.py b/src/environment.py index 81741d2..e6540b0 100644 --- a/src/environment.py +++ b/src/environment.py @@ -54,15 +54,21 @@ class Environ: :return: the replaced variable :rtype: str """ - if "$" in value: + if src.architecture.is_windows(): + delim = "%" + else: + delim = "$" + if delim in value: # The string.Template class is a string class # for supporting $-substitutions zt = string.Template(value) + zt.delimiter = delim try: value = zt.substitute(self.environ) except KeyError as exc: - raise src.SatException(_("Missing definition " - "in environment: %s") % str(exc)) + pass + #raise src.SatException(_("Missing definition " + # "in environment: %s") % str(exc)) return value def append_value(self, key, value, sep=os.pathsep): @@ -211,6 +217,7 @@ class SalomeEnviron: self.enable_simple_env_script = enable_simple_env_script self.silent = False self.has_python = False + self.__set_sorted_products_list() def __repr__(self): """easy almost exhaustive quick resume for debug print""" @@ -221,6 +228,25 @@ class SalomeEnviron: } return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(res)) + def __set_sorted_products_list(self): + from compile import get_dependencies_graph, depth_first_topo_graph + all_products_infos = src.product.get_products_infos( + self.cfg.APPLICATION.products, + self.cfg) + + all_products_graph=get_dependencies_graph(all_products_infos) + visited_nodes=[] + sorted_nodes=[] + for n in all_products_graph: + if n not in visited_nodes: + visited_nodes,sorted_nodes=depth_first_topo_graph( + all_products_graph, + n, + visited_nodes, + sorted_nodes) + self.sorted_product_list=sorted_nodes + + def append(self, key, value, sep=os.pathsep): """\ append value to key using sep @@ -346,30 +372,6 @@ class SalomeEnviron: self.python_lib = self.get('PYTHON_LIBDIR') 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 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 '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) - if 'component_name' in pi: - lProdName.append(pi.component_name) - else: - lProdName.append(ProdName) - return lProdName - def set_application_env(self, logger): """\ Sets the environment defined in the APPLICATION file. @@ -378,7 +380,11 @@ class SalomeEnviron: """ if self.for_package: - self.set("PRODUCT_ROOT_DIR", "out_dir_Path") + if src.architecture.is_windows(): + self.set("PRODUCT_ROOT_DIR", "%out_dir_Path%") + else: + 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") @@ -386,7 +392,8 @@ class SalomeEnviron: 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", "") + if not src.architecture.is_windows(): + self.set("LD_LIBRARY_PATH", "") self.set("PYTHONPATH", "") self.add_line(1) @@ -414,27 +421,33 @@ class SalomeEnviron: # 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: - self.set(root_dir, product_info.install_dir) - elif not self.silent: - logger.write(" " + _("No install_dir for product %s\n") % - product_info.name, 5) - + if 'install_dir' in product_info and product_info.install_dir: + self.set(root_dir, product_info.install_dir) + elif not self.silent: + logger.write(" " + _("No install_dir for product %s\n") % + product_info.name, 5) + 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", - os.path.basename(product_info.source_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", + os.path.basename(product_info.source_dir))) + def expand_salome_modules(self, pi): + if 'component_name' in pi: + compo_name = pi.component_name + else: + compo_name = pi.name + self.append('SALOME_MODULES', compo_name, ',') + + def set_salome_generic_product_env(self, pi): """\ Sets the generic environment for a SALOME product. @@ -444,7 +457,6 @@ class SalomeEnviron: # Construct XXX_ROOT_DIR env_root_dir = self.get(pi.name + "_ROOT_DIR") l_binpath_libpath = [] - # create additional ROOT_DIR for CPP components if 'component_name' in pi: compo_name = pi.component_name @@ -570,7 +582,6 @@ class SalomeEnviron: # Get the informations corresponding to the product pi = src.product.get_product_config(self.cfg, product) - # skip compile time products at run time if not self.forBuild: if src.product.product_is_compile_time(pi): @@ -619,7 +630,12 @@ class SalomeEnviron: # set environment using definition of the product self.set_salome_minimal_product_env(pi, logger) self.set_salome_generic_product_env(pi) + + # Expand SALOME_MODULES variable for products which have a salome gui + if src.product.product_has_salome_gui(pi): + self.expand_salome_modules(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: @@ -719,7 +735,6 @@ class SalomeEnviron: traceback.print_tb(exceptionTraceback) traceback.print_exc() - def set_products(self, logger, src_root=None): """\ Sets the environment for all the products. @@ -731,12 +746,12 @@ class SalomeEnviron: self.add_comment('setting environ for all products') # Make sure that the python lib dirs are set after python - if "Python" in self.cfg.APPLICATION.products: + if "Python" in self.sorted_product_list: self.set_a_product("Python", logger) self.set_python_libdirs() # The loop on the products - for product in self.cfg.APPLICATION.products.keys(): + for product in self.sorted_product_list: if product == "Python": continue self.set_a_product(product, logger) @@ -751,16 +766,22 @@ class SalomeEnviron: """ 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) - if "Python" in env_info: + # use the sorted list of all products to sort the list of products + # we have to set + sorted_product_list=[] + for n in self.sorted_product_list: + if n in env_info: + sorted_product_list.append(n) + + if "Python" in sorted_product_list: self.set_a_product("Python", logger) self.set_python_libdirs() # set products - for product in env_info: + for product in sorted_product_list: if product == "Python": continue self.set_a_product(product, logger) @@ -786,6 +807,91 @@ class FileEnvWriter: self.silent = True self.env_info = env_info + def write_tcl_files(self, + forBuild, + shell, + for_package = None, + no_path_init=False, + additional_env = {}): + """\ + Create tcl environment files for environment module. + + :param forBuild bool: if true, the build environment + :param shell str: the type of file wanted (.sh, .bat) + :param for_package bool: if true do specific stuff for required for packages + :param no_path_init bool: if true generate a environ file that do not reinitialise paths + :param additional_env dict: contains sat_ prefixed variables to help the génération, + and also variables to add in the environment. + :return: The path to the generated file + :rtype: str + """ + + # get the products informations + all_products=self.config.APPLICATION.products + products_infos = src.product.get_products_infos(all_products, self.config) + + # set a global environment (we need it to resolve variable references + # between dependent products + global_environ = src.environment.SalomeEnviron(self.config, + src.environment.Environ(additional_env), + False) + global_environ.set_products(self.logger) + + # The loop on the products + for product in all_products: + # create one file per product + pi = src.product.get_product_config(self.config, product) + if "base" not in pi: # we write tcl files only for products in base + continue + + # get the global environment, and complete it with sat_ prefixed + # prefixed variables which are used to transfer info to + # TclFileEnviron class + product_env = copy.deepcopy(global_environ.environ) + product_env.environ["sat_product_name"] = pi.name + product_env.environ["sat_product_version"] = pi.version + product_env.environ["sat_product_base_path"] = src.get_base_path(self.config) + product_env.environ["sat_product_base_name"] = pi.base + + # store infos in sat_product_load_depend to set dependencies in tcl file + sat_product_load_depend="" + for p_name,p_info in products_infos: + if p_name in pi.depend: + sat_product_load_depend+="module load %s/%s/%s;" % (pi.base, + p_info.name, + p_info.version) + if len(sat_product_load_depend)>0: + # if there are dependencies, store the module to load (get rid of trailing ;) + product_env.environ["sat_product_load_depend"]=sat_product_load_depend[0:-1] + + + env_file_name = os.path.join(product_env.environ["sat_product_base_path"], + "modulefiles", + product_env.environ["sat_product_base_name"], + product_env.environ["sat_product_name"], + product_env.environ["sat_product_version"]) + prod_dir_name=os.path.dirname(env_file_name) + if not os.path.isdir(prod_dir_name): + os.makedirs(prod_dir_name) + + env_file = open(env_file_name, "w") + file_environ = src.fileEnviron.get_file_environ(env_file, + "tcl", product_env) + env = SalomeEnviron(self.config, + file_environ, + False, + for_package=for_package) + if "Python" in pi.depend: + # short cut, env.python_lib is required by set_a_product for salome modules + env.has_python="True" + env.python_lib=global_environ.get("PYTHON_LIBDIR") + env.set_a_product(product, self.logger) + env_file.close() + if not self.silent: + self.logger.write(_(" Create tcl module environment file %s\n") % + src.printcolors.printcLabel(env_file_name), 3) + + def write_env_file(self, filename, forBuild, @@ -809,7 +915,6 @@ class FileEnvWriter: if not self.silent: self.logger.write(_("Create environment file %s\n") % src.printcolors.printcLabel(filename), 3) - # create then env object env_file = open(os.path.join(self.out_dir, filename), "w") @@ -837,15 +942,9 @@ 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) - # Add the additional environment if it is not empty if len(additional_env) != 0: env.add_line(1)