commands/check.py

   1 #!/usr/bin/env python
   2 #-*- coding:utf-8 -*-
   3 #  Copyright (C) 2010-2012  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
  21 import src
  22
  23 # Define all possible option for the check command :  sat check <options>
  24 parser = src.options.Options()
  25 parser.add_option('p', 'products', 'list2', 'products',
  26     _('Optional: products to check. This option accepts a comma separated list.'))
  27
  28 CHECK_PROPERTY = "has_unit_tests"
  29
  30
  31 def log_step(logger, header, step):
  32     logger.write("\r%s%s" % (header, " " * 20), 3)
  33     logger.write("\r%s%s" % (header, step), 3)
  34     logger.write("\n==== %s \n" % src.printcolors.printcInfo(step), 4)
  35     logger.flush()
  36
  37 def log_res_step(logger, res):
  38     if res == 0:
  39         logger.write("%s \n" % src.printcolors.printcSuccess("OK"), 4)
  40         logger.flush()
  41     else:
  42         logger.write("%s \n" % src.printcolors.printcError("KO"), 4)
  43         logger.flush()
  44
  45 def check_all_products(config, products_infos, logger):
  46     '''Execute the proper configuration commands
  47        in each product build directory.
  48
  49     :param config Config: The global configuration
  50     :param products_info list: List of
  51                                  (str, Config) => (product_name, product_info)
  52     :param logger Logger: The logger instance to use for the display and logging
  53     :return: the number of failing commands.
  54     :rtype: int
  55     '''
  56     res = 0
  57     for p_name_info in products_infos:
  58         res_prod = check_product(p_name_info, config, logger)
  59         if res_prod != 0:
  60             res += 1
  61     return res
  62
  63 def check_product(p_name_info, config, logger):
  64     '''Execute the proper configuration command(s)
  65        in the product build directory.
  66
  67     :param p_name_info tuple: (str, Config) => (product_name, product_info)
  68     :param config Config: The global configuration
  69     :param logger Logger: The logger instance to use for the display
  70                           and logging
  71     :return: 1 if it fails, else 0.
  72     :rtype: int
  73     '''
  74
  75     p_name, p_info = p_name_info
  76
  77     # Logging
  78     logger.write("\n", 4, False)
  79     logger.write("################ ", 4)
  80     header = _("Check of %s") % src.printcolors.printcLabel(p_name)
  81     header += " %s " % ("." * (20 - len(p_name)))
  82     logger.write(header, 3)
  83     logger.write("\n", 4, False)
  84     logger.flush()
  85
  86     # Verify if the command has to be launched or not
  87     ignored = False
  88     if not src.get_property_in_product_cfg(p_info, CHECK_PROPERTY):
  89         msg = _("The product %s is defined as not having tests. "
  90                 "product ignored." % p_name)
  91         logger.write("%s\n" % msg, 4)
  92         ignored = True
  93     if "build_dir" not in p_info:
  94         msg = _("No build_dir key defined in "
  95                 "the config file of %s: product ignored." % p_name)
  96         logger.write("%s\n" % msg, 4)
  97         ignored = True
  98     if not src.product.product_compiles(p_info):
  99         msg = _("The product %s is defined as not compiling. "
 100                 "product ignored." % p_name)
 101         logger.write("%s\n" % msg, 4)
 102         ignored = True
 103
 104     # Get the command to execute for script products
 105     cmd_found = True
 106     command = ""
 107     if src.product.product_has_script(p_info) and not ignored:
 108         command = src.get_cfg_param(p_info, "test_build", "Not found")
 109         if command == "Not found":
 110             cmd_found = False
 111             msg = _('WARNING: The product %s is defined as having tests. But it'
 112                     ' is compiled using a script and the key "test_build" is '
 113                     'not defined in the definition of %s' % (p_name, p_name))
 114             logger.write("%s\n" % msg, 4)
 115
 116     if ignored or not cmd_found:
 117         log_step(logger, header, "ignored")
 118         logger.write("==== %(name)s %(IGNORED)s\n" %
 119             { "name" : p_name ,
 120              "IGNORED" : src.printcolors.printcInfo("IGNORED")},
 121             4)
 122         logger.write("\n", 3, False)
 123         logger.flush()
 124         if not cmd_found:
 125             return 1
 126         return 0
 127
 128     # Instantiate the class that manages all the construction commands
 129     # like cmake, check, make install, make test, environment management, etc...
 130     builder = src.compilation.Builder(config, logger, p_info)
 131
 132     # Prepare the environment
 133     log_step(logger, header, "PREPARE ENV")
 134     res_prepare = builder.prepare()
 135     log_res_step(logger, res_prepare)
 136
 137     len_end_line = 20
 138
 139     # Launch the check
 140     log_step(logger, header, "CHECK")
 141     res = builder.check(command=command)
 142     log_res_step(logger, res)
 143
 144     # Log the result
 145     if res > 0:
 146         logger.write("\r%s%s" % (header, " " * len_end_line), 3)
 147         logger.write("\r" + header + src.printcolors.printcError("KO"))
 148         logger.write("==== %(KO)s in check of %(name)s \n" %
 149             { "name" : p_name , "KO" : src.printcolors.printcInfo("ERROR")}, 4)
 150         logger.flush()
 151     else:
 152         logger.write("\r%s%s" % (header, " " * len_end_line), 3)
 153         logger.write("\r" + header + src.printcolors.printcSuccess("OK"))
 154         logger.write("==== %s \n" % src.printcolors.printcInfo("OK"), 4)
 155         logger.write("==== Check of %(name)s %(OK)s \n" %
 156             { "name" : p_name , "OK" : src.printcolors.printcInfo("OK")}, 4)
 157         logger.flush()
 158     logger.write("\n", 3, False)
 159
 160     return res
 161
 162 def description():
 163     '''method that is called when salomeTools is called with --help option.
 164
 165     :return: The text to display for the check command description.
 166     :rtype: str
 167     '''
 168     return _("The check command executes the \"check\" command in"
 169              " the build directory of all the products of the application."
 170              "\nIt is possible to reduce the list of products to check by using"
 171              " the --products option\n\nexample\nsat check SALOME-master "
 172              "--products KERNEL,GUI,GEOM")
 173
 174 def run(args, runner, logger):
 175     '''method that is called when salomeTools is called with check parameter.
 176     '''
 177
 178     # Parse the options
 179     (options, args) = parser.parse_args(args)
 180
 181     # check that the command has been called with an application
 182     src.check_config_has_application( runner.cfg )
 183
 184     # Get the list of products to treat
 185     products_infos = src.product.get_products_list(options, runner.cfg, logger)
 186
 187     # Print some informations
 188     logger.write(_('Executing the check command in the build '
 189                                 'directories of the application %s\n') %
 190                 src.printcolors.printcLabel(runner.cfg.VARS.application), 1)
 191
 192     info = [(_("BUILD directory"),
 193              os.path.join(runner.cfg.APPLICATION.workdir, 'BUILD'))]
 194     src.print_info(logger, info)
 195
 196     # Call the function that will loop over all the products and execute
 197     # the right command(s)
 198     res = check_all_products(runner.cfg, products_infos, logger)
 199
 200     # Print the final state
 201     nb_products = len(products_infos)
 202     if res == 0:
 203         final_status = "OK"
 204     else:
 205         final_status = "KO"
 206
 207     logger.write(_("\nCheck: %(status)s (%(valid_result)d/%(nb_products)d)\n") % \
 208         { 'status': src.printcolors.printc(final_status),
 209           'valid_result': nb_products - res,
 210           'nb_products': nb_products }, 1)
 211
 212     return res