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         # Save the install_dir key if there is any
 266         if "install_dir" in prod_info and not "install_dir_save" in prod_info:
 267             prod_info.install_dir_save = prod_info.install_dir
 268
 269         # if it is not the first time the install_dir is computed, it means
 270         # that install_dir_save exists and it has to be taken into account.
 271         if "install_dir_save" in prod_info:
 272             prod_info.install_dir = prod_info.install_dir_save
 273
 274         # Set the install_dir key
 275         prod_info.install_dir = get_install_dir(config, base, version, prod_info)
 276
 277     return prod_info
 278
 279 def get_product_section(config, product_name, version, section=None):
 280     '''Get the product description from the configuration
 281
 282     :param config Config: The global configuration
 283     :param product_name str: The product name
 284     :param version str: The version of the product
 285     :param section str: The searched section (if not None, the section is
 286                         explicitly given
 287     :return: The product description
 288     :rtype: Config
 289     '''
 290
 291     # if section is not None, try to get the corresponding section
 292     if section:
 293         if section not in config.PRODUCTS[product_name]:
 294             return None
 295         # returns specific information for the given version
 296         prod_info = config.PRODUCTS[product_name][section]
 297         prod_info.section = section
 298         return prod_info
 299
 300     # If it exists, get the information of the product_version
 301     if "version_" + version in config.PRODUCTS[product_name]:
 302         # returns specific information for the given version
 303         prod_info = config.PRODUCTS[product_name]["version_" + version]
 304         prod_info.section = "version_" + version
 305         return prod_info
 306
 307     # Else, check if there is a description for multiple versions
 308     l_section_name = config.PRODUCTS[product_name].keys()
 309     l_section_ranges = [section_name for section_name in l_section_name
 310                         if VERSION_DELIMITER in section_name]
 311     for section_range in l_section_ranges:
 312         minimum, maximum = section_range.split(VERSION_DELIMITER)
 313         if (src.only_numbers(version) >= src.only_numbers(minimum)
 314                     and src.only_numbers(version) <= src.only_numbers(maximum)):
 315             # returns specific information for the versions
 316             prod_info = config.PRODUCTS[product_name][section_range]
 317             prod_info.section = section_range
 318             return prod_info
 319
 320     # Else, get the standard informations
 321     if "default" in config.PRODUCTS[product_name]:
 322         # returns the generic information (given version not found)
 323         prod_info = config.PRODUCTS[product_name].default
 324         prod_info.section = "default"
 325         return prod_info
 326
 327     # if noting was found, return None
 328     return None
 329
 330 def get_install_dir(config, base, version, prod_info):
 331     '''Compute the installation directory of a given product
 332
 333     :param config Config: The global configuration
 334     :param base str: This corresponds to the value given by user in its
 335                      application.pyconf for the specific product. If "yes", the
 336                     user wants the product to be in base. If "no", he wants the
 337                     product to be in the application workdir
 338     :param version str: The version of the product
 339     :param product_info Config: The configuration specific to
 340                                the product
 341
 342     :return: The path of the product installation
 343     :rtype: str
 344     '''
 345     install_dir = ""
 346     in_base = False
 347     if (("install_dir" in prod_info and prod_info.install_dir == "base")
 348                                                             or base == "yes"):
 349         in_base = True
 350     if (base == "no" or ("no_base" in config.APPLICATION
 351                          and config.APPLICATION.no_base == "yes")):
 352         in_base = False
 353
 354     if in_base:
 355         install_dir = get_base_install_dir(config, prod_info, version)
 356     else:
 357         if "install_dir" not in prod_info or prod_info.install_dir == "base":
 358             # Set it to the default value (in application directory)
 359             install_dir = os.path.join(config.APPLICATION.workdir,
 360                                                 "INSTALL",
 361                                                 prod_info.name)
 362         else:
 363             install_dir = prod_info.install_dir
 364
 365     return install_dir
 366
 367 def get_base_install_dir(config, prod_info, version):
 368     '''Compute the installation directory of a product in base
 369
 370     :param config Config: The global configuration
 371     :param product_info Config: The configuration specific to
 372                                the product
 373     :param version str: The version of the product
 374     :return: The path of the product installation
 375     :rtype: str
 376     '''
 377     base_path = src.get_base_path(config)
 378     prod_dir = os.path.join(base_path, prod_info.name + "-" + version)
 379     if not os.path.exists(prod_dir):
 380         return os.path.join(prod_dir, "config-1")
 381
 382     exists, install_dir = check_config_exists(config, prod_dir, prod_info)
 383     if exists:
 384         return install_dir
 385
 386     # Find the first config-<i> directory that is available in the product
 387     # directory
 388     found = False
 389     label = 1
 390     while not found:
 391         install_dir = os.path.join(prod_dir, "config-%i" % label)
 392         if os.path.exists(install_dir):
 393             label+=1
 394         else:
 395             found = True
 396
 397     return install_dir
 398
 399 def check_config_exists(config, prod_dir, prod_info):
 400     '''Verify that the installation directory of a product in a base exists
 401        Check all the config-<i> directory and verify the sat-config.pyconf file
 402        that is in it
 403
 404     :param config Config: The global configuration
 405     :param prod_dir str: The product installation directory path
 406                          (without config-<i>)
 407     :param product_info Config: The configuration specific to
 408                                the product
 409     :return: True or false is the installation is found or not
 410              and if it is found, the path of the found installation
 411     :rtype: (boolean, str)
 412     '''
 413     # check if the directories or files of the directory corresponds to the
 414     # directory installation of the product
 415     l_dir_and_files = os.listdir(prod_dir)
 416     for dir_or_file in l_dir_and_files:
 417         oExpr = re.compile(config_expression)
 418         if not(oExpr.search(dir_or_file)):
 419             # not config-<i>, not interesting
 420             continue
 421         # check if there is the file sat-config.pyconf file in the installation
 422         # directory
 423         config_file = os.path.join(prod_dir, dir_or_file, src.CONFIG_FILENAME)
 424         if not os.path.exists(config_file):
 425             continue
 426
 427         # If there is no dependency, it is the right path
 428         if len(prod_info.depend)==0:
 429             compile_cfg = src.pyconf.Config(config_file)
 430             if len(compile_cfg) == 0:
 431                 return True, os.path.join(prod_dir, dir_or_file)
 432             continue
 433
 434         # check if there is the config described in the file corresponds the
 435         # dependencies of the product
 436         config_corresponds = True
 437         compile_cfg = src.pyconf.Config(config_file)
 438         for prod_dep in prod_info.depend:
 439             # if the dependency is not in the config,
 440             # the config does not correspond
 441             if prod_dep not in compile_cfg:
 442                 config_corresponds = False
 443                 break
 444             else:
 445                 prod_dep_info = get_product_config(config, prod_dep, False)
 446                 # If the version of the dependency does not correspond,
 447                 # the config does not correspond
 448                 if prod_dep_info.version != compile_cfg[prod_dep]:
 449                     config_corresponds = False
 450                     break
 451
 452         for prod_name in compile_cfg:
 453             if prod_name not in prod_info.depend:
 454                 config_corresponds = False
 455                 break
 456
 457         if config_corresponds:
 458             return True, os.path.join(prod_dir, dir_or_file)
 459
 460     return False, None
 461
 462
 463
 464 def get_products_infos(lproducts, config):
 465     '''Get the specific configuration of a list of products
 466
 467     :param lproducts List: The list of product names
 468     :param config Config: The global configuration
 469     :return: the list of tuples
 470              (product name, specific configuration of the product)
 471     :rtype: [(str, Config)]
 472     '''
 473     products_infos = []
 474     # Loop on product names
 475     for prod in lproducts:
 476         # Get the specific configuration of the product
 477         prod_info = get_product_config(config, prod)
 478         if prod_info is not None:
 479             products_infos.append((prod, prod_info))
 480         else:
 481             msg = _("The %s product has no definition "
 482                     "in the configuration.") % prod
 483             raise src.SatException(msg)
 484     return products_infos
 485
 486 def get_product_dependencies(config, product_info):
 487     '''Get recursively the list of products that are
 488        in the product_info dependencies
 489
 490     :param config Config: The global configuration
 491     :param product_info Config: The configuration specific to
 492                                the product
 493     :return: the list of products in dependence
 494     :rtype: list
 495     '''
 496     if "depend" not in product_info or product_info.depend == []:
 497         return []
 498     res = []
 499     for prod in product_info.depend:
 500         if prod == product_info.name:
 501             continue
 502         if prod not in res:
 503             res.append(prod)
 504         prod_info = get_product_config(config, prod)
 505         dep_prod = get_product_dependencies(config, prod_info)
 506         for prod_in_dep in dep_prod:
 507             if prod_in_dep not in res:
 508                 res.append(prod_in_dep)
 509     return res
 510
 511 def check_installation(product_info):
 512     '''Verify if a product is well installed. Checks install directory presence
 513        and some additional files if it is defined in the config
 514
 515     :param product_info Config: The configuration specific to
 516                                the product
 517     :return: True if it is well installed
 518     :rtype: boolean
 519     '''
 520     if not product_compiles(product_info):
 521         return True
 522     install_dir = product_info.install_dir
 523     if not os.path.exists(install_dir):
 524         return False
 525     if ("present_files" in product_info and
 526         "install" in product_info.present_files):
 527         for file_relative_path in product_info.present_files.install:
 528             file_path = os.path.join(install_dir, file_relative_path)
 529             if not os.path.exists(file_path):
 530                 return False
 531     return True
 532
 533 def product_is_sample(product_info):
 534     '''Know if a product has the sample type
 535
 536     :param product_info Config: The configuration specific to
 537                                the product
 538     :return: True if the product has the sample type, else False
 539     :rtype: boolean
 540     '''
 541     if 'type' in product_info:
 542         ptype = product_info.type
 543         return ptype.lower() == 'sample'
 544     else:
 545         return False
 546
 547 def product_is_salome(product_info):
 548     '''Know if a product is of type salome
 549
 550     :param product_info Config: The configuration specific to
 551                                the product
 552     :return: True if the product is salome, else False
 553     :rtype: boolean
 554     '''
 555     if 'type' in product_info:
 556         ptype = product_info.type
 557         return ptype.lower() == 'salome'
 558     else:
 559         return False
 560
 561 def product_is_fixed(product_info):
 562     '''Know if a product is fixed
 563
 564     :param product_info Config: The configuration specific to
 565                                the product
 566     :return: True if the product is fixed, else False
 567     :rtype: boolean
 568     '''
 569     get_src = product_info.get_source
 570     return get_src.lower() == 'fixed'
 571
 572 def product_is_native(product_info):
 573     '''Know if a product is native
 574
 575     :param product_info Config: The configuration specific to
 576                                the product
 577     :return: True if the product is native, else False
 578     :rtype: boolean
 579     '''
 580     get_src = product_info.get_source
 581     return get_src.lower() == 'native'
 582
 583 def product_is_dev(product_info):
 584     '''Know if a product is in dev mode
 585
 586     :param product_info Config: The configuration specific to
 587                                the product
 588     :return: True if the product is in dev mode, else False
 589     :rtype: boolean
 590     '''
 591     dev = product_info.dev
 592     return dev.lower() == 'yes'
 593
 594 def product_is_debug(product_info):
 595     '''Know if a product is in debug mode
 596
 597     :param product_info Config: The configuration specific to
 598                                the product
 599     :return: True if the product is in debug mode, else False
 600     :rtype: boolean
 601     '''
 602     debug = product_info.debug
 603     return debug.lower() == 'yes'
 604
 605 def product_is_autotools(product_info):
 606     '''Know if a product is compiled using the autotools
 607
 608     :param product_info Config: The configuration specific to
 609                                the product
 610     :return: True if the product is autotools, else False
 611     :rtype: boolean
 612     '''
 613     build_src = product_info.build_source
 614     return build_src.lower() == 'autotools'
 615
 616 def product_is_cmake(product_info):
 617     '''Know if a product is compiled using the cmake
 618
 619     :param product_info Config: The configuration specific to
 620                                the product
 621     :return: True if the product is cmake, else False
 622     :rtype: boolean
 623     '''
 624     build_src = product_info.build_source
 625     return build_src.lower() == 'cmake'
 626
 627 def product_is_vcs(product_info):
 628     '''Know if a product is download using git, svn or cvs (not archive)
 629
 630     :param product_info Config: The configuration specific to
 631                                the product
 632     :return: True if the product is vcs, else False
 633     :rtype: boolean
 634     '''
 635     return product_info.get_source in AVAILABLE_VCS
 636
 637 def product_is_SALOME(product_info):
 638     '''Know if a product is a SALOME module
 639
 640     :param product_info Config: The configuration specific to
 641                                the product
 642     :return: True if the product is a SALOME module, else False
 643     :rtype: boolean
 644     '''
 645     return ("properties" in product_info and
 646             "is_SALOME_module" in product_info.properties and
 647             product_info.properties.is_SALOME_module == "yes")
 648
 649 def product_is_smesh_plugin(product_info):
 650     '''Know if a product is a SMESH plugin
 651
 652     :param product_info Config: The configuration specific to
 653                                the product
 654     :return: True if the product is a SMESH plugin, else False
 655     :rtype: boolean
 656     '''
 657     return ("properties" in product_info and
 658             "smesh_plugin" in product_info.properties and
 659             product_info.properties.smesh_plugin == "yes")
 660
 661 def product_is_cpp(product_info):
 662     '''Know if a product is cpp
 663
 664     :param product_info Config: The configuration specific to
 665                                the product
 666     :return: True if the product is a cpp, else False
 667     :rtype: boolean
 668     '''
 669     return ("properties" in product_info and
 670             "cpp" in product_info.properties and
 671             product_info.properties.cpp == "yes")
 672
 673 def product_compiles(product_info):
 674     '''Know if a product compiles or not (some products do not have a
 675        compilation procedure)
 676
 677     :param product_info Config: The configuration specific to
 678                                the product
 679     :return: True if the product compiles, else False
 680     :rtype: boolean
 681     '''
 682     return not("properties" in product_info and
 683             "compilation" in product_info.properties and
 684             product_info.properties.compilation == "no")
 685
 686 def product_has_script(product_info):
 687     '''Know if a product has a compilation script
 688
 689     :param product_info Config: The configuration specific to
 690                                the product
 691     :return: True if the product it has a compilation script, else False
 692     :rtype: boolean
 693     '''
 694     if "build_source" not in product_info:
 695         # Native case
 696         return False
 697     build_src = product_info.build_source
 698     return build_src.lower() == 'script'
 699
 700 def product_has_env_script(product_info):
 701     '''Know if a product has an environment script
 702
 703     :param product_info Config: The configuration specific to
 704                                the product
 705     :return: True if the product it has an environment script, else False
 706     :rtype: boolean
 707     '''
 708     return "environ" in product_info and "env_script" in product_info.environ
 709
 710 def product_has_patches(product_info):
 711     '''Know if a product has one or more patches
 712
 713     :param product_info Config: The configuration specific to
 714                                the product
 715     :return: True if the product has one or more patches
 716     :rtype: boolean
 717     '''
 718     return "patches" in product_info and len(product_info.patches) > 0
 719
 720 def product_has_logo(product_info):
 721     '''Know if a product has a logo (YACSGEN generate)
 722
 723     :param product_info Config: The configuration specific to
 724                                the product
 725     :return: The path of the logo if the product has a logo, else False
 726     :rtype: Str
 727     '''
 728     if ("properties" in product_info and
 729             "logo" in product_info.properties):
 730         return product_info.properties.logo
 731     else:
 732         return False
 733
 734 def product_has_salome_gui(product_info):
 735     '''Know if a product has a SALOME gui
 736
 737     :param product_info Config: The configuration specific to
 738                                the product
 739     :return: True if the product has a SALOME gui, else False
 740     :rtype: Boolean
 741     '''
 742     return ("properties" in product_info and
 743             "has_salome_gui" in product_info.properties and
 744             product_info.properties.has_salome_gui == "yes")
 745
 746 def product_is_mpi(product_info):
 747     '''Know if a product has openmpi in its dependencies
 748
 749     :param product_info Config: The configuration specific to
 750                                the product
 751     :return: True if the product has openmpi inits dependencies
 752     :rtype: boolean
 753     '''
 754     return "openmpi" in product_info.depend
 755
 756 def product_is_generated(product_info):
 757     '''Know if a product is generated (YACSGEN)
 758
 759     :param product_info Config: The configuration specific to
 760                                the product
 761     :return: True if the product is generated
 762     :rtype: boolean
 763     '''
 764     return ("properties" in product_info and
 765             "generate" in product_info.properties and
 766             product_info.properties.generate == "yes")
 767
 768 def get_product_components(product_info):
 769     '''Get the component list to generate with the product
 770
 771     :param product_info Config: The configuration specific to
 772                                the product
 773     :return: The list of names of the components
 774     :rtype: List
 775
 776     '''
 777     if not product_is_generated(product_info):
 778         return []
 779
 780     compo_list = []
 781     if "component_name" in product_info:
 782         compo_list = product_info.component_name
 783
 784         if isinstance(compo_list, str):
 785             compo_list = [ compo_list ]
 786
 787     return compo_list