3 # Copyright (C) 2010-2012 CEA/DEN
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.
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.
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
23 # Compatibility python 2/3 for input function
24 # input stays input for python 3 and input = raw_input for python 2
30 # Define all possible option for the compile command : sat compile <options>
31 parser = src.options.Options()
32 parser.add_option('p', 'products', 'list2', 'products',
33 _('products to configure. This option can be'
34 ' passed several time to configure several products.'))
35 parser.add_option('', 'with_fathers', 'boolean', 'fathers',
36 _("build all necessary products to the given product (KERNEL is build before"
37 " building GUI)."), False)
38 parser.add_option('', 'with_children', 'boolean', 'children',
39 _("build all products using the given product (all SMESH plugins are build "
40 "after SMESH)."), False)
41 parser.add_option('', 'clean_all', 'boolean', 'clean_all',
42 _("clean BUILD dir and INSTALL dir before building product."), False)
43 parser.add_option('', 'clean_install', 'boolean', 'clean_install',
44 _("clean INSTALL dir before building product."), False)
45 parser.add_option('', 'make_flags', 'string', 'makeflags',
46 _("add extra options to the 'make' command."))
47 parser.add_option('', 'show', 'boolean', 'no_compile',
48 _("DO NOT COMPILE just show if products are installed or not."), False)
49 parser.add_option('', 'stop_first_fail', 'boolean', 'stop_first_fail', _("Stop"
50 "s the command at first product compilation fail."), False)
52 def get_products_list(options, cfg, logger):
53 '''method that gives the product list with their informations from
54 configuration regarding the passed options.
56 :param options Options: The Options instance that stores the commands
58 :param cfg Config: The global configuration
59 :param logger Logger: The logger instance to use for the display and
61 :return: The list of (product name, product_informations).
64 # Get the products to be prepared, regarding the options
65 if options.products is None:
66 # No options, get all products sources
67 products = cfg.APPLICATION.products
69 # if option --products, check that all products of the command line
70 # are present in the application.
71 products = options.products
73 if p not in cfg.APPLICATION.products:
74 raise src.SatException(_("Product %(product)s "
75 "not defined in application %(application)s") %
76 { 'product': p, 'application': cfg.VARS.application} )
78 # Construct the list of tuple containing
79 # the products name and their definition
80 products_infos = src.product.get_products_infos(products, cfg)
82 products_infos = [pi for pi in products_infos if not(
83 src.product.product_is_native(pi[1]) or
84 src.product.product_is_fixed(pi[1]))]
88 def get_children(config, p_name_p_info):
90 p_name, __ = p_name_p_info
91 # Get all products of the application
92 products = config.APPLICATION.products
93 products_infos = src.product.get_products_infos(products, config)
94 for p_name_potential_child, p_info_potential_child in products_infos:
95 if ("depend" in p_info_potential_child and
96 p_name in p_info_potential_child.depend):
97 l_res.append(p_name_potential_child)
100 def get_recursive_children(config, p_name_p_info, without_native_fixed=False):
101 """ Get the recursive list of the product that depend on
102 the product defined by prod_info
104 :param config Config: The global configuration
105 :param prod_info Config: The specific config of the product
106 :param without_native_fixed boolean: If true, do not include the fixed
107 or native products in the result
108 :return: The list of product_informations.
111 p_name, __ = p_name_p_info
112 # Initialization of the resulting list
115 # Get the direct children (not recursive)
116 l_direct_children = get_children(config, p_name_p_info)
117 # Minimal case : no child
118 if l_direct_children == []:
120 # Add the children and call the function to get the children of the
122 for child_name in l_direct_children:
123 l_children_name = [pn_pi[0] for pn_pi in l_children]
124 if child_name not in l_children_name:
125 if child_name not in config.APPLICATION.products:
126 msg = _("The product %(child_name)s that is in %(product_nam"
127 "e)s children is not present in application "
128 "%(appli_name)s" % {"child_name" : child_name,
129 "product_name" : p_name.name,
130 "appli_name" : config.VARS.application})
131 raise src.SatException(msg)
132 prod_info_child = src.product.get_product_config(config,
134 pname_pinfo_child = (prod_info_child.name, prod_info_child)
135 # Do not append the child if it is native or fixed and
136 # the corresponding parameter is called
137 if without_native_fixed:
138 if not(src.product.product_is_native(prod_info_child) or
139 src.product.product_is_fixed(prod_info_child)):
140 l_children.append(pname_pinfo_child)
142 l_children.append(pname_pinfo_child)
143 # Get the children of the children
144 l_grand_children = get_recursive_children(config,
146 without_native_fixed = without_native_fixed)
147 l_children += l_grand_children
150 def get_recursive_fathers(config, p_name_p_info, without_native_fixed=False):
151 """ Get the recursive list of the dependencies of the product defined by
154 :param config Config: The global configuration
155 :param prod_info Config: The specific config of the product
156 :param without_native_fixed boolean: If true, do not include the fixed
157 or native products in the result
158 :return: The list of product_informations.
161 p_name, p_info = p_name_p_info
162 # Initialization of the resulting list
164 # Minimal case : no dependencies
165 if "depend" not in p_info or p_info.depend == []:
167 # Add the dependencies and call the function to get the dependencies of the
169 for father_name in p_info.depend:
170 l_fathers_name = [pn_pi[0] for pn_pi in l_fathers]
171 if father_name not in l_fathers_name:
172 if father_name not in config.APPLICATION.products:
173 msg = _("The product %(father_name)s that is in %(product_nam"
174 "e)s dependencies is not present in application "
175 "%(appli_name)s" % {"father_name" : father_name,
176 "product_name" : p_name,
177 "appli_name" : config.VARS.application})
178 raise src.SatException(msg)
179 prod_info_father = src.product.get_product_config(config,
181 pname_pinfo_father = (prod_info_father.name, prod_info_father)
182 # Do not append the father if it is native or fixed and
183 # the corresponding parameter is called
184 if without_native_fixed:
185 if not(src.product.product_is_native(prod_info_father) or
186 src.product.product_is_fixed(prod_info_father)):
187 l_fathers.append(pname_pinfo_father)
189 l_fathers.append(pname_pinfo_father)
190 # Get the dependencies of the dependency
191 l_grand_fathers = get_recursive_fathers(config,
193 without_native_fixed = without_native_fixed)
194 for item in l_grand_fathers:
195 if item not in l_fathers:
196 l_fathers.append(item)
199 def sort_products(config, p_infos):
200 """ Sort the p_infos regarding the dependencies between the products
202 :param config Config: The global configuration
203 :param p_infos list: List of (str, Config) => (product_name, product_info)
205 l_prod_sorted = deepcopy_list(p_infos)
207 l_fathers = get_recursive_fathers(config,
209 without_native_fixed=True)
210 l_fathers = [father for father in l_fathers if father in p_infos]
213 for p_sorted in l_prod_sorted:
214 if p_sorted in l_fathers:
215 l_fathers.remove(p_sorted)
217 l_prod_sorted.remove(prod)
218 l_prod_sorted.insert(l_prod_sorted.index(p_sorted)+1, prod)
223 def deepcopy_list(input_list):
224 """ Do a deep copy of a list
226 :param input_list List: The list to copy
227 :return: The copy of the list
231 for elem in input_list:
235 def extend_with_fathers(config, p_infos):
236 p_infos_res = deepcopy_list(p_infos)
237 for p_name_p_info in p_infos:
238 fathers = get_recursive_fathers(config,
240 without_native_fixed=True)
241 for p_name_p_info_father in fathers:
242 if p_name_p_info_father not in p_infos_res:
243 p_infos_res.append(p_name_p_info_father)
246 def extend_with_children(config, p_infos):
247 p_infos_res = deepcopy_list(p_infos)
248 for p_name_p_info in p_infos:
249 children = get_recursive_children(config,
251 without_native_fixed=True)
252 for p_name_p_info_child in children:
253 if p_name_p_info_child not in p_infos_res:
254 p_infos_res.append(p_name_p_info_child)
257 def check_dependencies(config, p_name_p_info):
258 l_depends_not_installed = []
259 fathers = get_recursive_fathers(config, p_name_p_info, without_native_fixed=True)
260 for p_name_father, p_info_father in fathers:
261 if not(src.product.check_installation(p_info_father)):
262 l_depends_not_installed.append(p_name_father)
263 return l_depends_not_installed
265 def log_step(logger, header, step):
266 logger.write("\r%s%s" % (header, " " * 30), 3)
267 logger.write("\r%s%s" % (header, step), 3)
268 logger.write("\n==== %s \n" % src.printcolors.printcInfo(step), 4)
271 def log_res_step(logger, res):
273 logger.write("%s \n" % src.printcolors.printcSuccess("OK"), 4)
276 logger.write("%s \n" % src.printcolors.printcError("KO"), 4)
279 def compile_all_products(sat, config, options, products_infos, logger):
280 '''Execute the proper configuration commands
281 in each product build directory.
283 :param config Config: The global configuration
284 :param products_info list: List of
285 (str, Config) => (product_name, product_info)
286 :param logger Logger: The logger instance to use for the display and logging
287 :return: the number of failing commands.
291 for p_name_info in products_infos:
293 p_name, p_info = p_name_info
297 logger.write("\n", 4, False)
298 logger.write("################ ", 4)
299 header = _("Compilation of %s") % src.printcolors.printcLabel(p_name)
300 header += " %s " % ("." * (len_end_line - len(p_name)))
301 logger.write(header, 3)
302 logger.write("\n", 4, False)
305 # Clean the build and the install directories
306 # if the corresponding options was called
307 if options.clean_all:
308 log_step(logger, header, "CLEAN BUILD AND INSTALL")
309 sat.clean(config.VARS.application +
310 " --products " + p_name +
311 " --build --install", batch=True, verbose=0)
313 # Clean the the install directory
314 # if the corresponding option was called
315 if options.clean_install and not options.clean_all:
316 log_step(logger, header, "CLEAN INSTALL")
317 sat.clean(config.VARS.application +
318 " --products " + p_name +
319 " --install", batch=True, verbose=0)
321 # Check if it was already successfully installed
322 if src.product.check_installation(p_info):
323 logger.write(_("Already installed\n"))
326 # If the show option was called, do not launch the compilation
327 if options.no_compile:
328 logger.write(_("Not installed\n"))
331 # Check if the dependencies are installed
332 l_depends_not_installed = check_dependencies(config, p_name_info)
333 if len(l_depends_not_installed) > 0:
334 logger.write(src.printcolors.printcError(
335 _("ERROR : the following product(s) is(are) mandatory: ")))
336 for prod_name in l_depends_not_installed:
337 logger.write(src.printcolors.printcError(prod_name + " "))
341 # Call the function to compile the product
342 res_prod, len_end_line, error_step = compile_product(sat,
351 # Clean the install directory if there is any
352 sat.clean(config.VARS.application +
353 " --products " + p_name +
354 " --install", batch=True, verbose=0)
359 logger.write("\r%s%s" % (header, " " * len_end_line), 3)
360 logger.write("\r" + header + src.printcolors.printcError("KO ") + error_step)
361 logger.write("\n==== %(KO)s in compile of %(name)s \n" %
362 { "name" : p_name , "KO" : src.printcolors.printcInfo("ERROR")}, 4)
365 logger.write("\r%s%s" % (header, " " * len_end_line), 3)
366 logger.write("\r" + header + src.printcolors.printcSuccess("OK"))
367 logger.write(_("\nINSTALL directory = %s" %
368 src.printcolors.printcInfo(p_info.install_dir)), 3)
369 logger.write("\n==== %s \n" % src.printcolors.printcInfo("OK"), 4)
370 logger.write("\n==== Compilation of %(name)s %(OK)s \n" %
371 { "name" : p_name , "OK" : src.printcolors.printcInfo("OK")}, 4)
373 logger.write("\n", 3, False)
376 if res_prod != 0 and options.stop_first_fail:
381 def compile_product(sat, p_name_info, config, options, logger, header, len_end):
382 '''Execute the proper configuration command(s)
383 in the product build directory.
385 :param p_name_info tuple: (str, Config) => (product_name, product_info)
386 :param config Config: The global configuration
387 :param logger Logger: The logger instance to use for the display
389 :return: 1 if it fails, else 0.
393 p_name, p_info = p_name_info
395 # Execute "sat configure", "sat make" and "sat install"
399 # Logging and sat command call for configure step
400 len_end_line = len_end
401 log_step(logger, header, "CONFIGURE")
402 res_c, __ = sat.configure(config.VARS.application + " --products " + p_name,
404 logger_add_link = logger)
405 log_res_step(logger, res_c)
409 error_step = "CONFIGURE"
411 # Logging and sat command call for make step
412 # Logging take account of the fact that the product has a compilation
414 if src.product.product_has_script(p_info):
415 # if the product has a compilation script,
416 # it is executed during make step
417 scrit_path_display = src.printcolors.printcLabel(
418 p_info.compil_script)
419 log_step(logger, header, "SCRIPT " + scrit_path_display)
420 len_end_line = len(scrit_path_display)
422 log_step(logger, header, "MAKE")
423 make_arguments = config.VARS.application + " --products " + p_name
424 # Get the make_flags option if there is any
425 if options.makeflags:
426 make_arguments += " --option -j" + options.makeflags
427 res_m, __ = sat.make(make_arguments,
429 logger_add_link = logger)
430 log_res_step(logger, res_m)
436 # Logging and sat command call for make install step
437 log_step(logger, header, "MAKE INSTALL")
438 res_mi, __ = sat.makeinstall(config.VARS.application +
442 logger_add_link = logger)
444 log_res_step(logger, res_mi)
448 error_step = "MAKE INSTALL"
450 return res, len_end_line, error_step
453 '''method that is called when salomeTools is called with --help option.
455 :return: The text to display for the compile command description.
458 return _("The compile command constructs the products of the application")
460 def run(args, runner, logger):
461 '''method that is called when salomeTools is called with compile parameter.
465 (options, args) = parser.parse_args(args)
467 # Warn the user if he invoked the clean_all option
468 # without --products option
469 if (options.clean_all and
470 options.products is None and
471 not runner.options.batch):
472 rep = input(_("You used --clean_all without specifying a product"
473 " are you sure you want to continue? [Yes/No] "))
474 if rep.upper() != _("YES").upper():
477 # check that the command has been called with an application
478 src.check_config_has_application( runner.cfg )
480 # Get the list of products to treat
481 products_infos = get_products_list(options, runner.cfg, logger)
484 # Extend the list with all recursive dependencies of the given products
485 products_infos = extend_with_fathers(runner.cfg, products_infos)
488 # Extend the list with all products that use the given products
489 products_infos = extend_with_children(runner.cfg, products_infos)
491 # Sort the list regarding the dependencies of the products
492 products_infos = sort_products(runner.cfg, products_infos)
494 # Print some informations
495 logger.write(_('Executing the compile commands in the build '
496 'directories of the products of '
497 'the application %s\n') %
498 src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
501 (_("SOURCE directory"),
502 os.path.join(runner.cfg.APPLICATION.workdir, 'SOURCES')),
503 (_("BUILD directory"),
504 os.path.join(runner.cfg.APPLICATION.workdir, 'BUILD'))
506 src.print_info(logger, info)
508 # Call the function that will loop over all the products and execute
509 # the right command(s)
510 res = compile_all_products(runner, runner.cfg, options, products_infos, logger)
512 # Print the final state
513 nb_products = len(products_infos)
519 logger.write(_("\nCompilation: %(status)s (%(valid_result)d/%(nb_products)d)\n") % \
520 { 'status': src.printcolors.printc(final_status),
521 'valid_result': nb_products - res,
522 'nb_products': nb_products }, 1)