src/product.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 '''In this file are implemented the methods
  19    relative to the product notion of salomeTools
  20 '''
  21
  22 import os
  23 import re
  24
  25 import src
  26
  27 AVAILABLE_VCS = ['git', 'svn', 'cvs']
  28 config_expression = "^config-\d+$"
  29 VERSION_DELIMITER = "_to_"
  30
  31 def get_product_config(config, product_name, with_install_dir=True):
  32     '''Get the specific configuration of a product from the global configuration
  33
  34     :param config Config: The global configuration
  35     :param product_name str: The name of the product
  36     :param with_install_dir boolean: If false, do not provide an install
  37                                      directory (at false only for internal use
  38                                      of the function check_config_exists)
  39     :return: the specific configuration of the product
  40     :rtype: Config
  41     '''
  42
  43     # Get the version of the product from the application definition
  44     version = config.APPLICATION.products[product_name]
  45     # if no version, then take the default one defined in the application
  46     if isinstance(version, bool):
  47         version = config.APPLICATION.tag
  48
  49     # Define debug and dev modes
  50     # Get the tag if a dictionary is given in APPLICATION.products for the
  51     # current product
  52     debug = 'no'
  53     dev = 'no'
  54     base = 'maybe'
  55     section = None
  56     if isinstance(version, src.pyconf.Mapping):
  57         dic_version = version
  58         # Get the version/tag
  59         if not 'tag' in dic_version:
  60             version = config.APPLICATION.tag
  61         else:
  62             version = dic_version.tag
  63
  64         # Get the debug if any
  65         if 'debug' in dic_version:
  66             debug = dic_version.debug
  67
  68         # Get the dev if any
  69         if 'dev' in dic_version:
  70             dev = dic_version.dev
  71
  72         # Get the base if any
  73         if 'base' in dic_version:
  74             base = dic_version.base
  75
  76         # Get the section if any
  77         if 'section' in dic_version:
  78             section = dic_version.section
  79
  80     vv = version
  81     # substitute some character with _ in order to get the correct definition
  82     # in config.PRODUCTS. This is done because the pyconf tool does not handle
  83     # the . and - characters
  84     for c in ".-": vv = vv.replace(c, "_")
  85
  86     prod_info = None
  87     if product_name in config.PRODUCTS:
  88         # Search for the product description in the configuration
  89         prod_info = get_product_section(config, product_name, vv, section)
  90
  91         # merge opt_depend in depend
  92         if prod_info is not None and 'opt_depend' in prod_info:
  93             for depend in prod_info.opt_depend:
  94                 if depend in config.APPLICATION.products:
  95                     prod_info.depend.append(depend,'')
  96
  97         # In case of a product get with a vcs,
  98         # put the tag (equal to the version)
  99         if prod_info is not None and prod_info.get_source in AVAILABLE_VCS:
 100
 101             if prod_info.get_source == 'git':
 102                 prod_info.git_info.tag = version
 103
 104             if prod_info.get_source == 'svn':
 105                 prod_info.svn_info.tag = version
 106
 107             if prod_info.get_source == 'cvs':
 108                 prod_info.cvs_info.tag = version
 109
 110         # In case of a fixed product,
 111         # define the install_dir (equal to the version)
 112         if prod_info is not None and os.path.isdir(version):
 113             prod_info.install_dir = version
 114             prod_info.get_source = "fixed"
 115
 116         # Check if the product is defined as native in the application
 117         if prod_info is not None:
 118             if version == "native":
 119                 prod_info.get_source = "native"
 120             elif prod_info.get_source == "native":
 121                 msg = _("The product %(prod)s has version %(ver)s but is "
 122                         "declared as native in its definition" %
 123                         { 'prod': prod_info.name, 'ver': version})
 124                 raise src.SatException(msg)
 125
 126     # If there is no definition but the product is declared as native,
 127     # construct a new definition containing only the get_source key
 128     if prod_info is None and version == "native":
 129         prod_info = src.pyconf.Config()
 130         prod_info.name = product_name
 131         prod_info.get_source = "native"
 132
 133     # If there is no definition but the product is fixed,
 134     # construct a new definition containing only the product name
 135     if prod_info is None and os.path.isdir(version):
 136         prod_info = src.pyconf.Config()
 137         prod_info.name = product_name
 138         prod_info.get_source = "fixed"
 139         prod_info.addMapping("environ", src.pyconf.Mapping(prod_info), "")
 140
 141
 142     # If prod_info is still None, it means that there is no product definition
 143     # in the config. The user has to provide it.
 144     if prod_info is None:
 145         prod_pyconf_path = src.find_file_in_lpath(product_name + ".pyconf",
 146                                                   config.PATHS.PRODUCTPATH)
 147         if not prod_pyconf_path:
 148             msg = _("No definition found for the product %s\n"
 149                "Please create a %s.pyconf file." % (product_name, product_name))
 150         else:
 151             msg = _("No definition corresponding to the version %(version)s was"
 152                     " found in the file %(prod_file_path)s.\nPlease add a "
 153                     "section in it." % {"version" : vv,
 154                                         "prod_file_path" : prod_pyconf_path} )
 155         raise src.SatException(msg)
 156
 157     # Set the debug, dev and version keys
 158     prod_info.debug = debug
 159     prod_info.dev = dev
 160     prod_info.version = version
 161
 162     # Set the archive_info if the product is get in archive mode
 163     if prod_info.get_source == "archive":
 164         if not "archive_info" in prod_info:
 165             prod_info.addMapping("archive_info",
 166                                  src.pyconf.Mapping(prod_info),
 167                                  "")
 168         if "archive_name" not in prod_info.archive_info:
 169             arch_name = product_name + "-" + version + ".tar.gz"
 170             arch_path = src.find_file_in_lpath(arch_name,
 171                                                config.PATHS.ARCHIVEPATH)
 172             if not arch_path:
 173                 msg = _("Archive %(arch_name)s for %(prod_name)s not found:"
 174                             "\n" % {"arch_name" : arch_name,
 175                                      "prod_name" : prod_info.name})
 176                 raise src.SatException(msg)
 177             prod_info.archive_info.archive_name = arch_path
 178         else:
 179             if (os.path.basename(prod_info.archive_info.archive_name) ==
 180                                         prod_info.archive_info.archive_name):
 181                 arch_name = prod_info.archive_info.archive_name
 182                 arch_path = src.find_file_in_lpath(
 183                                             arch_name,
 184                                             config.PATHS.ARCHIVEPATH)
 185                 if not arch_path:
 186                     msg = _("Archive %(arch_name)s for %(prod_name)s not found:"
 187                                 "\n" % {"arch_name" : arch_name,
 188                                          "prod_name" : prod_info.name})
 189                     raise src.SatException(msg)
 190                 prod_info.archive_info.archive_name = arch_path
 191
 192     # If the product compiles with a script, check the script existence
 193     # and if it is executable
 194     if product_has_script(prod_info):
 195         # Check the compil_script key existence
 196         if "compil_script" not in prod_info:
 197             msg = _("No compilation script found for the product %s\n"
 198                 "Please provide a \"compil_script\" key in its definition."
 199                 % (product_name))
 200             raise src.SatException(msg)
 201
 202         # Get the path of the script
 203         script = prod_info.compil_script
 204         script_name = os.path.basename(script)
 205         if script == script_name:
 206             # Only a name is given. Search in the default directory
 207             script_path = src.find_file_in_lpath(script_name,
 208                                                  config.PATHS.PRODUCTPATH,
 209                                                  "compil_scripts")
 210             if not script_path:
 211                 raise src.SatException(_("Compilation script not found: %s") %
 212                                    script_name)
 213             prod_info.compil_script = script_path
 214             if src.architecture.is_windows():
 215                 prod_info.compil_script = prod_info.compil_script[:-len(".sh")] + ".bat"
 216
 217         # Check that the script is executable
 218         if not os.access(prod_info.compil_script, os.X_OK):
 219             raise src.SatException(
 220                     _("Compilation script cannot be executed: %s") %
 221                     prod_info.compil_script)
 222
 223     # Get the full paths of all the patches
 224     if product_has_patches(prod_info):
 225         patches = []
 226         for patch in prod_info.patches:
 227             patch_path = patch
 228             # If only a filename, then search for the patch in the PRODUCTPATH
 229             if os.path.basename(patch_path) == patch_path:
 230                 # Search in the PRODUCTPATH/patches
 231                 patch_path = src.find_file_in_lpath(patch,
 232                                                     config.PATHS.PRODUCTPATH,
 233                                                     "patches")
 234                 if not patch_path:
 235                     msg = _("Patch %(patch_name)s for %(prod_name)s not found:"
 236                             "\n" % {"patch_name" : patch,
 237                                      "prod_name" : prod_info.name})
 238                     raise src.SatException(msg)
 239             patches.append(patch_path)
 240         prod_info.patches = patches
 241
 242     # Get the full paths of the environment scripts
 243     if product_has_env_script(prod_info):
 244         env_script_path = prod_info.environ.env_script
 245         # If only a filename, then search for the environment script
 246         # in the PRODUCTPATH/env_scripts
 247         if os.path.basename(env_script_path) == env_script_path:
 248             # Search in the PRODUCTPATH/env_scripts
 249             env_script_path = src.find_file_in_lpath(
 250                                             prod_info.environ.env_script,
 251                                             config.PATHS.PRODUCTPATH,
 252                                             "env_scripts")
 253             if not env_script_path:
 254                 msg = _("Environment script %(env_name)s for %(prod_name)s not "
 255                         "found.\n" % {"env_name" : env_script_path,
 256                                        "prod_name" : prod_info.name})
 257                 raise src.SatException(msg)
 258
 259         prod_info.environ.env_script = env_script_path
 260
 261     if with_install_dir:
 262         # The variable with_install_dir is at false only for internal use
 263         # of the function get_install_dir
 264
 265         # Set the install_dir key
 266         prod_info.install_dir = get_install_dir(config, base, version, prod_info)
 267
 268     return prod_info
 269
 270 def get_product_section(config, product_name, version, section=None):
 271     '''Get the product description from the configuration
 272
 273     :param config Config: The global configuration
 274     :param product_name str: The product name
 275     :param version str: The version of the product
 276     :param section str: The searched section (if not None, the section is
 277                         explicitly given
 278     :return: The product description
 279     :rtype: Config
 280     '''
 281
 282     # if section is not None, try to get the corresponding section
 283     if section:
 284         if section not in config.PRODUCTS[product_name]:
 285             return None
 286         # returns specific information for the given version
 287         prod_info = config.PRODUCTS[product_name][section]
 288         prod_info.section = section
 289         return prod_info
 290
 291     # If it exists, get the information of the product_version
 292     if "version_" + version in config.PRODUCTS[product_name]:
 293         # returns specific information for the given version
 294         prod_info = config.PRODUCTS[product_name]["version_" + version]
 295         prod_info.section = "version_" + version
 296         return prod_info
 297
 298     # Else, check if there is a description for multiple versions
 299     l_section_name = config.PRODUCTS[product_name].keys()
 300     l_section_ranges = [section_name for section_name in l_section_name
 301                         if VERSION_DELIMITER in section_name]
 302     for section_range in l_section_ranges:
 303         minimum, maximum = section_range.split(VERSION_DELIMITER)
 304         if (src.only_numbers(version) >= src.only_numbers(minimum)
 305                     and src.only_numbers(version) <= src.only_numbers(maximum)):
 306             # returns specific information for the versions
 307             prod_info = config.PRODUCTS[product_name][section_range]
 308             prod_info.section = section_range
 309             return prod_info
 310
 311     # Else, get the standard informations
 312     if "default" in config.PRODUCTS[product_name]:
 313         # returns the generic information (given version not found)
 314         prod_info = config.PRODUCTS[product_name].default
 315         prod_info.section = "default"
 316         return prod_info
 317
 318     # if noting was found, return None
 319     return None
 320
 321 def get_install_dir(config, base, version, prod_info):
 322     '''Compute the installation directory of a given product
 323
 324     :param config Config: The global configuration
 325     :param base str: This corresponds to the value given by user in its
 326                      application.pyconf for the specific product. If "yes", the
 327                     user wants the product to be in base. If "no", he wants the
 328                     product to be in the application workdir
 329     :param version str: The version of the product
 330     :param product_info Config: The configuration specific to
 331                                the product
 332
 333     :return: The path of the product installation
 334     :rtype: str
 335     '''
 336     install_dir = ""
 337     in_base = False
 338     if (("install_dir" in prod_info and prod_info.install_dir == "base")
 339                                                             or base == "yes"):
 340         in_base = True
 341     if (base == "no" or ("no_base" in config.APPLICATION
 342                          and config.APPLICATION.no_base == "yes")):
 343         in_base = False
 344
 345     if in_base:
 346         install_dir = get_base_install_dir(config, prod_info, version)
 347     else:
 348         if "install_dir" not in prod_info or prod_info.install_dir == "base":
 349             # Set it to the default value (in application directory)
 350             install_dir = os.path.join(config.APPLICATION.workdir,
 351                                                 "INSTALL",
 352                                                 prod_info.name)
 353         else:
 354             install_dir = prod_info.install_dir
 355
 356     return install_dir
 357
 358 def get_base_install_dir(config, prod_info, version):
 359     '''Compute the installation directory of a product in base
 360
 361     :param config Config: The global configuration
 362     :param product_info Config: The configuration specific to
 363                                the product
 364     :param version str: The version of the product
 365     :return: The path of the product installation
 366     :rtype: str
 367     '''
 368     base_path = src.get_base_path(config)
 369     prod_dir = os.path.join(base_path, prod_info.name + "-" + version)
 370     if not os.path.exists(prod_dir):
 371         return os.path.join(prod_dir, "config-1")
 372
 373     exists, install_dir = check_config_exists(config, prod_dir, prod_info)
 374     if exists:
 375         return install_dir
 376
 377     # Find the first config-<i> directory that is available in the product
 378     # directory
 379     found = False
 380     label = 1
 381     while not found:
 382         install_dir = os.path.join(prod_dir, "config-%i" % label)
 383         if os.path.exists(install_dir):
 384             label+=1
 385         else:
 386             found = True
 387
 388     return install_dir
 389
 390 def check_config_exists(config, prod_dir, prod_info):
 391     '''Verify that the installation directory of a product in a base exists
 392        Check all the config-<i> directory and verify the sat-config.pyconf file
 393        that is in it
 394
 395     :param config Config: The global configuration
 396     :param prod_dir str: The product installation directory path
 397                          (without config-<i>)
 398     :param product_info Config: The configuration specific to
 399                                the product
 400     :return: True or false is the installation is found or not
 401              and if it is found, the path of the found installation
 402     :rtype: (boolean, str)
 403     '''
 404     # check if the directories or files of the directory corresponds to the
 405     # directory installation of the product
 406     l_dir_and_files = os.listdir(prod_dir)
 407     for dir_or_file in l_dir_and_files:
 408         oExpr = re.compile(config_expression)
 409         if not(oExpr.search(dir_or_file)):
 410             # not config-<i>, not interesting
 411             continue
 412         # check if there is the file sat-config.pyconf file in the installation
 413         # directory
 414         config_file = os.path.join(prod_dir, dir_or_file, src.CONFIG_FILENAME)
 415         if not os.path.exists(config_file):
 416             continue
 417
 418         # If there is no dependency, it is the right path
 419         if len(prod_info.depend)==0:
 420             compile_cfg = src.pyconf.Config(config_file)
 421             if len(compile_cfg) == 0:
 422                 return True, os.path.join(prod_dir, dir_or_file)
 423             continue
 424
 425         # check if there is the config described in the file corresponds the
 426         # dependencies of the product
 427         config_corresponds = True
 428         compile_cfg = src.pyconf.Config(config_file)
 429         for prod_dep in prod_info.depend:
 430             # if the dependency is not in the config,
 431             # the config does not correspond
 432             if prod_dep not in compile_cfg:
 433                 config_corresponds = False
 434                 break
 435             else:
 436                 prod_dep_info = get_product_config(config, prod_dep, False)
 437                 # If the version of the dependency does not correspond,
 438                 # the config does not correspond
 439                 if prod_dep_info.version != compile_cfg[prod_dep]:
 440                     config_corresponds = False
 441                     break
 442
 443         for prod_name in compile_cfg:
 444             if prod_name not in prod_info.depend:
 445                 config_corresponds = False
 446                 break
 447
 448         if config_corresponds:
 449             return True, os.path.join(prod_dir, dir_or_file)
 450
 451     return False, None
 452
 453
 454
 455 def get_products_infos(lproducts, config):
 456     '''Get the specific configuration of a list of products
 457
 458     :param lproducts List: The list of product names
 459     :param config Config: The global configuration
 460     :return: the list of tuples
 461              (product name, specific configuration of the product)
 462     :rtype: [(str, Config)]
 463     '''
 464     products_infos = []
 465     # Loop on product names
 466     for prod in lproducts:
 467         # Get the specific configuration of the product
 468         prod_info = get_product_config(config, prod)
 469         if prod_info is not None:
 470             products_infos.append((prod, prod_info))
 471         else:
 472             msg = _("The %s product has no definition "
 473                     "in the configuration.") % prod
 474             raise src.SatException(msg)
 475     return products_infos
 476
 477 def get_product_dependencies(config, product_info):
 478     '''Get recursively the list of products that are
 479        in the product_info dependencies
 480
 481     :param config Config: The global configuration
 482     :param product_info Config: The configuration specific to
 483                                the product
 484     :return: the list of products in dependence
 485     :rtype: list
 486     '''
 487     if "depend" not in product_info or product_info.depend == []:
 488         return []
 489     res = []
 490     for prod in product_info.depend:
 491         if prod == product_info.name:
 492             continue
 493         if prod not in res:
 494             res.append(prod)
 495         prod_info = get_product_config(config, prod)
 496         dep_prod = get_product_dependencies(config, prod_info)
 497         for prod_in_dep in dep_prod:
 498             if prod_in_dep not in res:
 499                 res.append(prod_in_dep)
 500     return res
 501
 502 def check_installation(product_info):
 503     '''Verify if a product is well installed. Checks install directory presence
 504        and some additional files if it is defined in the config
 505
 506     :param product_info Config: The configuration specific to
 507                                the product
 508     :return: True if it is well installed
 509     :rtype: boolean
 510     '''
 511     if not product_compiles(product_info):
 512         return True
 513     install_dir = product_info.install_dir
 514     if not os.path.exists(install_dir):
 515         return False
 516     if ("present_files" in product_info and
 517         "install" in product_info.present_files):
 518         for file_relative_path in product_info.present_files.install:
 519             file_path = os.path.join(install_dir, file_relative_path)
 520             if not os.path.exists(file_path):
 521                 return False
 522     return True
 523
 524 def product_is_sample(product_info):
 525     '''Know if a product has the sample type
 526
 527     :param product_info Config: The configuration specific to
 528                                the product
 529     :return: True if the product has the sample type, else False
 530     :rtype: boolean
 531     '''
 532     if 'type' in product_info:
 533         ptype = product_info.type
 534         return ptype.lower() == 'sample'
 535     else:
 536         return False
 537
 538 def product_is_salome(product_info):
 539     '''Know if a product is of type salome
 540
 541     :param product_info Config: The configuration specific to
 542                                the product
 543     :return: True if the product is salome, else False
 544     :rtype: boolean
 545     '''
 546     if 'type' in product_info:
 547         ptype = product_info.type
 548         return ptype.lower() == 'salome'
 549     else:
 550         return False
 551
 552 def product_is_fixed(product_info):
 553     '''Know if a product is fixed
 554
 555     :param product_info Config: The configuration specific to
 556                                the product
 557     :return: True if the product is fixed, else False
 558     :rtype: boolean
 559     '''
 560     get_src = product_info.get_source
 561     return get_src.lower() == 'fixed'
 562
 563 def product_is_native(product_info):
 564     '''Know if a product is native
 565
 566     :param product_info Config: The configuration specific to
 567                                the product
 568     :return: True if the product is native, else False
 569     :rtype: boolean
 570     '''
 571     get_src = product_info.get_source
 572     return get_src.lower() == 'native'
 573
 574 def product_is_dev(product_info):
 575     '''Know if a product is in dev mode
 576
 577     :param product_info Config: The configuration specific to
 578                                the product
 579     :return: True if the product is in dev mode, else False
 580     :rtype: boolean
 581     '''
 582     dev = product_info.dev
 583     return dev.lower() == 'yes'
 584
 585 def product_is_debug(product_info):
 586     '''Know if a product is in debug mode
 587
 588     :param product_info Config: The configuration specific to
 589                                the product
 590     :return: True if the product is in debug mode, else False
 591     :rtype: boolean
 592     '''
 593     debug = product_info.debug
 594     return debug.lower() == 'yes'
 595
 596 def product_is_autotools(product_info):
 597     '''Know if a product is compiled using the autotools
 598
 599     :param product_info Config: The configuration specific to
 600                                the product
 601     :return: True if the product is autotools, else False
 602     :rtype: boolean
 603     '''
 604     build_src = product_info.build_source
 605     return build_src.lower() == 'autotools'
 606
 607 def product_is_cmake(product_info):
 608     '''Know if a product is compiled using the cmake
 609
 610     :param product_info Config: The configuration specific to
 611                                the product
 612     :return: True if the product is cmake, else False
 613     :rtype: boolean
 614     '''
 615     build_src = product_info.build_source
 616     return build_src.lower() == 'cmake'
 617
 618 def product_is_vcs(product_info):
 619     '''Know if a product is download using git, svn or cvs (not archive)
 620
 621     :param product_info Config: The configuration specific to
 622                                the product
 623     :return: True if the product is vcs, else False
 624     :rtype: boolean
 625     '''
 626     return product_info.get_source in AVAILABLE_VCS
 627
 628 def product_is_SALOME(product_info):
 629     '''Know if a product is a SALOME module
 630
 631     :param product_info Config: The configuration specific to
 632                                the product
 633     :return: True if the product is a SALOME module, else False
 634     :rtype: boolean
 635     '''
 636     return ("properties" in product_info and
 637             "is_SALOME_module" in product_info.properties and
 638             product_info.properties.is_SALOME_module == "yes")
 639
 640 def product_is_smesh_plugin(product_info):
 641     '''Know if a product is a SMESH plugin
 642
 643     :param product_info Config: The configuration specific to
 644                                the product
 645     :return: True if the product is a SMESH plugin, else False
 646     :rtype: boolean
 647     '''
 648     return ("properties" in product_info and
 649             "smesh_plugin" in product_info.properties and
 650             product_info.properties.smesh_plugin == "yes")
 651
 652 def product_is_cpp(product_info):
 653     '''Know if a product is cpp
 654
 655     :param product_info Config: The configuration specific to
 656                                the product
 657     :return: True if the product is a cpp, else False
 658     :rtype: boolean
 659     '''
 660     return ("properties" in product_info and
 661             "cpp" in product_info.properties and
 662             product_info.properties.cpp == "yes")
 663
 664 def product_compiles(product_info):
 665     '''Know if a product compiles or not (some products do not have a
 666        compilation procedure)
 667
 668     :param product_info Config: The configuration specific to
 669                                the product
 670     :return: True if the product compiles, else False
 671     :rtype: boolean
 672     '''
 673     return not("properties" in product_info and
 674             "compilation" in product_info.properties and
 675             product_info.properties.compilation == "no")
 676
 677 def product_has_script(product_info):
 678     '''Know if a product has a compilation script
 679
 680     :param product_info Config: The configuration specific to
 681                                the product
 682     :return: True if the product it has a compilation script, else False
 683     :rtype: boolean
 684     '''
 685     if "build_source" not in product_info:
 686         # Native case
 687         return False
 688     build_src = product_info.build_source
 689     return build_src.lower() == 'script'
 690
 691 def product_has_env_script(product_info):
 692     '''Know if a product has an environment script
 693
 694     :param product_info Config: The configuration specific to
 695                                the product
 696     :return: True if the product it has an environment script, else False
 697     :rtype: boolean
 698     '''
 699     return "environ" in product_info and "env_script" in product_info.environ
 700
 701 def product_has_patches(product_info):
 702     '''Know if a product has one or more patches
 703
 704     :param product_info Config: The configuration specific to
 705                                the product
 706     :return: True if the product has one or more patches
 707     :rtype: boolean
 708     '''
 709     return "patches" in product_info and len(product_info.patches) > 0
 710
 711 def product_has_logo(product_info):
 712     '''Know if a product has a logo (YACSGEN generate)
 713
 714     :param product_info Config: The configuration specific to
 715                                the product
 716     :return: The path of the logo if the product has a logo, else False
 717     :rtype: Str
 718     '''
 719     if ("properties" in product_info and
 720             "logo" in product_info.properties):
 721         return product_info.properties.logo
 722     else:
 723         return False
 724
 725 def product_has_salome_gui(product_info):
 726     '''Know if a product has a SALOME gui
 727
 728     :param product_info Config: The configuration specific to
 729                                the product
 730     :return: True if the product has a SALOME gui, else False
 731     :rtype: Boolean
 732     '''
 733     return ("properties" in product_info and
 734             "has_salome_gui" in product_info.properties and
 735             product_info.properties.has_salome_gui == "yes")
 736
 737 def product_is_mpi(product_info):
 738     '''Know if a product has openmpi in its dependencies
 739
 740     :param product_info Config: The configuration specific to
 741                                the product
 742     :return: True if the product has openmpi inits dependencies
 743     :rtype: boolean
 744     '''
 745     return "openmpi" in product_info.depend
 746
 747 def product_is_generated(product_info):
 748     '''Know if a product is generated (YACSGEN)
 749
 750     :param product_info Config: The configuration specific to
 751                                the product
 752     :return: True if the product is generated
 753     :rtype: boolean
 754     '''
 755     return ("properties" in product_info and
 756             "generate" in product_info.properties and
 757             product_info.properties.generate == "yes")
 758
 759 def get_product_components(product_info):
 760     '''Get the component list to generate with the product
 761
 762     :param product_info Config: The configuration specific to
 763                                the product
 764     :return: The list of names of the components
 765     :rtype: List
 766
 767     '''
 768     if not product_is_generated(product_info):
 769         return []
 770
 771     compo_list = []
 772     if "component_name" in product_info:
 773         compo_list = product_info.component_name
 774
 775         if isinstance(compo_list, str):
 776             compo_list = [ compo_list ]
 777
 778     return compo_list