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
31 from application import get_SALOME_modules
32 import src.debug as DBG
34 old_python = sys.version_info[0] == 2 and sys.version_info[1] <= 6
41 ARCHIVE_DIR = "ARCHIVES"
42 PROJECT_DIR = "PROJECT"
44 IGNORED_DIRS = [".git", ".svn"]
45 IGNORED_EXTENSIONS = []
47 PACKAGE_EXT=".tar.gz" # the extension we use for the packages
49 if src.architecture.is_windows():
50 PROJECT_TEMPLATE = """#!/usr/bin/env python
53 # The path to the archive root directory
54 root_path : $PWD + "/../"
56 project_path : $PWD + "/"
58 # Where to search the archives of the products
59 ARCHIVEPATH : $root_path + "ARCHIVES"
60 # Where to search the pyconf of the applications
61 APPLICATIONPATH : $project_path + "applications/"
62 # Where to search the pyconf of the products
63 PRODUCTPATH : $project_path + "products/"
64 # Where to search the pyconf of the jobs of the project
65 JOBPATH : $project_path + "jobs/"
66 # Where to search the pyconf of the machines of the project
67 MACHINEPATH : $project_path + "machines/"
70 PROJECT_TEMPLATE = """#!/usr/bin/env python
74 project_path : $PWD + "/"
76 # Where to search the archives of the products
77 ARCHIVEPATH : $project_path + "ARCHIVES"
78 # Where to search the pyconf of the applications
79 APPLICATIONPATH : $project_path + "applications/"
80 # Where to search the pyconf of the products
81 PRODUCTPATH : $project_path + "products/"
82 # Where to search the pyconf of the jobs of the project
83 JOBPATH : $project_path + "jobs/"
84 # Where to search the pyconf of the machines of the project
85 MACHINEPATH : $project_path + "machines/"
89 LOCAL_TEMPLATE = ("""#!/usr/bin/env python
97 archive_dir : 'default'
110 # Define all possible option for the package command : sat package <options>
111 parser = src.options.Options()
112 parser.add_option('b', 'binaries', 'boolean', 'binaries',
113 _('Optional: Produce a binary package.'), False)
114 parser.add_option('f', 'force_creation', 'boolean', 'force_creation',
115 _('Optional: Only binary package: produce the archive even if '
116 'there are some missing products.'), False)
117 parser.add_option('s', 'sources', 'boolean', 'sources',
118 _('Optional: Produce a compilable archive of the sources of the '
119 'application.'), False)
120 parser.add_option('', 'bin_products', 'boolean', 'bin_products',
121 _('Optional: Create binary archives for all products.'), False)
122 parser.add_option('', 'with_vcs', 'boolean', 'with_vcs',
123 _('Optional: Do not make archive for products in VCS mode (git, cvs, svn). '
124 'Sat prepare will use VCS mode instead to retrieve them.'
125 '\n Also, when combined with "--bin_products" option, restrict the building of product archives to VCS products.'),
127 parser.add_option('', 'ftp', 'boolean', 'ftp',
128 _('Optional: Do not embed archives for products in archive mode.'
129 'Sat prepare will use ftp instead to retrieve them'),
131 parser.add_option('e', 'exe', 'string', 'exe',
132 _('Optional: Produce an extra launcher based upon the exe given as argument.'), "")
133 parser.add_option('p', 'project', 'string', 'project',
134 _('Optional: Produce an archive that contains a project.'), "")
135 parser.add_option('t', 'salometools', 'boolean', 'sat',
136 _('Optional: Produce an archive that contains salomeTools.'), False)
137 parser.add_option('n', 'name', 'string', 'name',
138 _('Optional: The name or full path of the archive.'), None)
139 parser.add_option('', 'add_files', 'list2', 'add_files',
140 _('Optional: The list of additional files to add to the archive.'), [])
141 parser.add_option('', 'without_properties', 'properties', 'without_properties',
142 _('Optional: Filter the products by their properties.\n\tSyntax: '
143 '--without_properties <property>:<value>'))
146 def add_files(tar, name_archive, d_content, logger, f_exclude=None):
147 '''Create an archive containing all directories and files that are given in
148 the d_content argument.
150 :param tar tarfile: The tarfile instance used to make the archive.
151 :param name_archive str: The name of the archive to make.
152 :param d_content dict: The dictionary that contain all directories and files
153 to add in the archive.
155 (path_on_local_machine, path_in_archive)
156 :param logger Logger: the logging instance
157 :param f_exclude Function: the function that filters
158 :return: 0 if success, 1 if not.
161 # get the max length of the messages in order to make the display
162 max_len = len(max(d_content.keys(), key=len))
165 # loop over each directory or file stored in the d_content dictionary
166 names = sorted(d_content.keys())
167 DBG.write("add tar names", names)
169 # used to avoid duplications (for pip install in python, or single_install_dir cases)
172 # display information
173 len_points = max_len - len(name) + 3
174 local_path, archive_path = d_content[name]
175 in_archive = os.path.join(name_archive, archive_path)
176 logger.write(name + " " + len_points * "." + " "+ in_archive + " ", 3)
177 # Get the local path and the path in archive
178 # of the directory or file to add
179 # Add it in the archive
181 key=local_path+"->"+in_archive
182 if key not in already_added:
186 exclude=exclude_VCS_and_extensions_26)
190 filter=exclude_VCS_and_extensions)
191 already_added.add(key)
192 logger.write(src.printcolors.printcSuccess(_("OK")), 3)
193 except Exception as e:
194 logger.write(src.printcolors.printcError(_("KO ")), 3)
195 logger.write(str(e), 3)
197 logger.write("\n", 3)
201 def exclude_VCS_and_extensions_26(filename):
202 ''' The function that is used to exclude from package the link to the
203 VCS repositories (like .git) (only for python 2.6)
205 :param filename Str: The filname to exclude (or not).
206 :return: True if the file has to be exclude
209 for dir_name in IGNORED_DIRS:
210 if dir_name in filename:
212 for extension in IGNORED_EXTENSIONS:
213 if filename.endswith(extension):
217 def exclude_VCS_and_extensions(tarinfo):
218 ''' The function that is used to exclude from package the link to the
219 VCS repositories (like .git)
221 :param filename Str: The filname to exclude (or not).
222 :return: None if the file has to be exclude
223 :rtype: tarinfo or None
225 filename = tarinfo.name
226 for dir_name in IGNORED_DIRS:
227 if dir_name in filename:
229 for extension in IGNORED_EXTENSIONS:
230 if filename.endswith(extension):
234 def produce_relative_launcher(config,
239 '''Create a specific SALOME launcher for the binary package. This launcher
242 :param config Config: The global configuration.
243 :param logger Logger: the logging instance
244 :param file_dir str: the directory where to put the launcher
245 :param file_name str: The launcher name
246 :param binaries_dir_name str: the name of the repository where the binaries
248 :return: the path of the produced launcher
252 # set base mode to "no" for the archive - save current mode to restore it at the end
253 if "base" in config.APPLICATION:
254 base_setting=config.APPLICATION.base
257 config.APPLICATION.base="no"
259 # get KERNEL installation path
260 kernel_info = src.product.get_product_config(config, "KERNEL")
261 kernel_base_name=os.path.basename(kernel_info.install_dir)
262 if kernel_info.install_mode == "base":
263 # case of kernel installed in base. the kernel install dir name is different in the archive
264 kernel_base_name=os.path.basename(os.path.dirname(kernel_info.install_dir))
266 kernel_root_dir = os.path.join(binaries_dir_name, kernel_base_name)
268 # set kernel bin dir (considering fhs property)
269 kernel_cfg = src.product.get_product_config(config, "KERNEL")
270 if src.get_property_in_product_cfg(kernel_cfg, "fhs"):
271 bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin")
273 bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin","salome")
275 # check if the application contains an application module
276 # check also if the application has a distene product,
277 # in this case get its licence file name
278 l_product_info = src.product.get_products_infos(config.APPLICATION.products.keys(), config)
279 salome_application_name="Not defined"
280 distene_licence_file_name=False
281 for prod_name, prod_info in l_product_info:
282 # look for a "salome application" and a distene product
283 if src.get_property_in_product_cfg(prod_info, "is_distene") == "yes":
284 distene_licence_file_name = src.product.product_has_licence(prod_info,
285 config.PATHS.LICENCEPATH)
286 if src.get_property_in_product_cfg(prod_info, "is_salome_application") == "yes":
287 salome_application_name=prod_info.name
289 # if the application contains an application module, we set ABSOLUTE_APPLI_PATH to it
290 # if not we set it to KERNEL_INSTALL_DIR, which is sufficient, except for salome test
291 if salome_application_name == "Not defined":
292 app_root_dir=kernel_root_dir
294 app_root_dir=os.path.join(binaries_dir_name, salome_application_name)
297 additional_env['sat_bin_kernel_install_dir'] = "out_dir_Path + " +\
298 config.VARS.sep + bin_kernel_install_dir
299 if "python3" in config.APPLICATION and config.APPLICATION.python3 == "yes":
300 additional_env['sat_python_version'] = 3
302 additional_env['sat_python_version'] = 2
304 additional_env['ABSOLUTE_APPLI_PATH'] = "out_dir_Path" + config.VARS.sep + app_root_dir
305 launcher_name = src.get_launcher_name(config)
306 additional_env['APPLI'] = "out_dir_Path" + config.VARS.sep + file_name
308 # create an environment file writer
309 writer = src.environment.FileEnvWriter(config,
315 filepath = os.path.join(file_dir, file_name)
317 writer.write_env_file(filepath,
320 additional_env=additional_env,
322 for_package = binaries_dir_name)
324 # Little hack to put out_dir_Path outside the strings
325 src.replace_in_file(filepath, 'r"out_dir_Path', 'out_dir_Path + r"' )
326 src.replace_in_file(filepath, "r'out_dir_Path + ", "out_dir_Path + r'" )
328 # A hack to put a call to a file for distene licence.
329 # It does nothing to an application that has no distene product
330 if distene_licence_file_name:
331 logger.write("Application has a distene licence file! We use it in package launcher", 5)
332 hack_for_distene_licence(filepath, distene_licence_file_name)
334 # change the rights in order to make the file executable for everybody
344 # restore modified setting by its initial value
345 config.APPLICATION.base=base_setting
349 def hack_for_distene_licence(filepath, licence_file):
350 '''Replace the distene licence env variable by a call to a file.
352 :param filepath Str: The path to the launcher to modify.
354 shutil.move(filepath, filepath + "_old")
356 filein = filepath + "_old"
357 fin = open(filein, "r")
358 fout = open(fileout, "w")
359 text = fin.readlines()
360 # Find the Distene section
362 for i,line in enumerate(text):
363 if "# Set DISTENE License" in line:
367 # No distene product, there is nothing to do
373 del text[num_line +1]
374 del text[num_line +1]
375 text_to_insert =""" try:
376 distene_licence_file=r"%s"
377 if sys.version_info[0] >= 3 and sys.version_info[1] >= 5:
378 import importlib.util
379 spec_dist = importlib.util.spec_from_file_location("distene_licence", distene_licence_file)
380 distene=importlib.util.module_from_spec(spec_dist)
381 spec_dist.loader.exec_module(distene)
384 distene = imp.load_source('distene_licence', distene_licence_file)
385 distene.set_distene_variables(context)
387 pass\n""" % licence_file
388 text.insert(num_line + 1, text_to_insert)
395 def produce_relative_env_files(config,
400 '''Create some specific environment files for the binary package. These
401 files use relative paths.
403 :param config Config: The global configuration.
404 :param logger Logger: the logging instance
405 :param file_dir str: the directory where to put the files
406 :param binaries_dir_name str: the name of the repository where the binaries
408 :param exe_name str: if given generate a launcher executing exe_name
409 :return: the list of path of the produced environment files
413 # set base mode to "no" for the archive - save current mode to restore it at the end
414 if "base" in config.APPLICATION:
415 base_setting=config.APPLICATION.base
418 config.APPLICATION.base="no"
420 # create an environment file writer
421 writer = src.environment.FileEnvWriter(config,
426 if src.architecture.is_windows():
428 filename = "env_launch.bat"
431 filename = "env_launch.sh"
434 filename=os.path.basename(exe_name)
437 filepath = writer.write_env_file(filename,
440 for_package = binaries_dir_name)
442 # Little hack to put out_dir_Path as environment variable
443 if src.architecture.is_windows() :
444 src.replace_in_file(filepath, '"out_dir_Path', '"%out_dir_Path%' )
445 src.replace_in_file(filepath, '=out_dir_Path', '=%out_dir_Path%' )
446 src.replace_in_file(filepath, ';out_dir_Path', ';%out_dir_Path%' )
448 src.replace_in_file(filepath, '"out_dir_Path', '"${out_dir_Path}' )
449 src.replace_in_file(filepath, ':out_dir_Path', ':${out_dir_Path}' )
452 if src.architecture.is_windows():
453 cmd="\n\nrem Launch exe with user arguments\n%s " % exe_name + "%*"
455 cmd='\n\n# Launch exe with user arguments\n%s "$*"' % exe_name
456 with open(filepath, "a") as exe_launcher:
457 exe_launcher.write(cmd)
459 # change the rights in order to make the file executable for everybody
469 # restore modified setting by its initial value
470 config.APPLICATION.base=base_setting
474 def produce_install_bin_file(config,
479 '''Create a bash shell script which do substitutions in BIRARIES dir
480 in order to use it for extra compilations.
482 :param config Config: The global configuration.
483 :param logger Logger: the logging instance
484 :param file_dir str: the directory where to put the files
485 :param d_sub, dict: the dictionnary that contains the substitutions to be done
486 :param file_name str: the name of the install script file
487 :return: the produced file
491 filepath = os.path.join(file_dir, file_name)
492 # open the file and write into it
493 # use codec utf-8 as sat variables are in unicode
494 with codecs.open(filepath, "w", 'utf-8') as installbin_file:
495 installbin_template_path = os.path.join(config.VARS.internal_dir,
496 "INSTALL_BIN.template")
498 # build the name of the directory that will contain the binaries
499 binaries_dir_name = config.INTERNAL.config.binary_dir + config.VARS.dist
500 # build the substitution loop
501 loop_cmd = "for f in $(grep -RIl"
503 loop_cmd += " -e "+ key
504 loop_cmd += ' ' + config.INTERNAL.config.install_dir +\
507 loop_cmd += " s?" + key + "?$(pwd)/" + d_sub[key] + "?g\n"
508 loop_cmd += ' " $f\ndone'
511 d["BINARIES_DIR"] = binaries_dir_name
512 d["SUBSTITUTION_LOOP"]=loop_cmd
513 d["INSTALL_DIR"]=config.INTERNAL.config.install_dir
515 # substitute the template and write it in file
516 content=src.template.substitute(installbin_template_path, d)
517 installbin_file.write(content)
518 # change the rights in order to make the file executable for everybody
530 def product_appli_creation_script(config,
534 '''Create a script that can produce an application (EDF style) in the binary
537 :param config Config: The global configuration.
538 :param logger Logger: the logging instance
539 :param file_dir str: the directory where to put the file
540 :param binaries_dir_name str: the name of the repository where the binaries
542 :return: the path of the produced script file
545 template_name = "create_appli.py.for_bin_packages.template"
546 template_path = os.path.join(config.VARS.internal_dir, template_name)
547 text_to_fill = open(template_path, "r").read()
548 text_to_fill = text_to_fill.replace("TO BE FILLED 1",
549 '"' + binaries_dir_name + '"')
552 for product_name in get_SALOME_modules(config):
553 product_info = src.product.get_product_config(config, product_name)
555 if src.product.product_is_smesh_plugin(product_info):
558 if 'install_dir' in product_info and bool(product_info.install_dir):
559 if src.product.product_is_cpp(product_info):
561 for cpp_name in src.product.get_product_components(product_info):
562 line_to_add = ("<module name=\"" +
564 "\" gui=\"yes\" path=\"''' + "
565 "os.path.join(dir_bin_name, \"" +
566 cpp_name + "\") + '''\"/>")
569 line_to_add = ("<module name=\"" +
571 "\" gui=\"yes\" path=\"''' + "
572 "os.path.join(dir_bin_name, \"" +
573 product_name + "\") + '''\"/>")
574 text_to_add += line_to_add + "\n"
576 filled_text = text_to_fill.replace("TO BE FILLED 2", text_to_add)
578 tmp_file_path = os.path.join(file_dir, "create_appli.py")
579 ff = open(tmp_file_path, "w")
580 ff.write(filled_text)
583 # change the rights in order to make the file executable for everybody
584 os.chmod(tmp_file_path,
595 def bin_products_archives(config, logger, only_vcs):
596 '''Prepare binary packages for all products
597 :param config Config: The global configuration.
598 :return: the error status
602 logger.write("Make %s binary archives\n" % config.VARS.dist)
603 # Get the default directory where to put the packages
604 binpackage_path = os.path.join(config.APPLICATION.workdir, "PACKAGE", "products")
605 src.ensure_path_exists(binpackage_path)
606 # Get the list of product installation to add to the archive
607 l_products_name = sorted(config.APPLICATION.products.keys())
608 l_product_info = src.product.get_products_infos(l_products_name,
610 # first loop on products : filter products, analyse properties,
611 # and store the information that will be used to create the archive in the second loop
612 l_not_installed=[] # store not installed products for warning at the end
613 for prod_name, prod_info in l_product_info:
614 # ignore the native and fixed products for install directories
615 if (src.get_property_in_product_cfg(prod_info, "not_in_package") == "yes"
616 or src.product.product_is_native(prod_info)
617 or src.product.product_is_fixed(prod_info)
618 or not src.product.product_compiles(prod_info)):
620 if only_vcs and not src.product.product_is_vcs(prod_info):
622 if not src.product.check_installation(config, prod_info):
623 l_not_installed.append(prod_name)
624 continue # product is not installed, we skip it
625 # prepare call to make_bin_archive
626 path_targz_prod = os.path.join(binpackage_path, prod_name + '-' + prod_info.version.replace("/", "_") + "-" + config.VARS.dist + PACKAGE_EXT)
627 targz_prod = tarfile.open(path_targz_prod, mode='w:gz')
628 bin_path = prod_info.install_dir
629 targz_prod.add(bin_path)
631 # Python program to find MD5 hash value of a file
633 with open(path_targz_prod,"rb") as f:
634 bytes = f.read() # read file as bytes
635 readable_hash = hashlib.md5(bytes).hexdigest();
636 with open(path_targz_prod+".md5", "w") as md5sum:
637 md5sum.write("%s %s" % (readable_hash, os.path.basename(path_targz_prod)))
638 logger.write(" archive : %s (md5sum = %s)\n" % (path_targz_prod, readable_hash))
642 def binary_package(config, logger, options, tmp_working_dir):
643 '''Prepare a dictionary that stores all the needed directories and files to
644 add in a binary package.
646 :param config Config: The global configuration.
647 :param logger Logger: the logging instance
648 :param options OptResult: the options of the launched command
649 :param tmp_working_dir str: The temporary local directory containing some
650 specific directories or files needed in the
652 :return: the dictionary that stores all the needed directories and files to
653 add in a binary package.
654 {label : (path_on_local_machine, path_in_archive)}
658 # Get the list of product installation to add to the archive
659 l_products_name = sorted(config.APPLICATION.products.keys())
660 l_product_info = src.product.get_products_infos(l_products_name,
663 # suppress compile time products for binaries-only archives
664 if not options.sources:
665 update_config(config, logger, "compile_time", "yes")
670 l_sources_not_present = []
671 generate_mesa_launcher = False # a flag to know if we generate a mesa launcher
672 if ("APPLICATION" in config and
673 "properties" in config.APPLICATION and
674 "mesa_launcher_in_package" in config.APPLICATION.properties and
675 config.APPLICATION.properties.mesa_launcher_in_package == "yes") :
676 generate_mesa_launcher=True
678 # first loop on products : filter products, analyse properties,
679 # and store the information that will be used to create the archive in the second loop
680 for prod_name, prod_info in l_product_info:
681 # skip product with property not_in_package set to yes
682 if src.get_property_in_product_cfg(prod_info, "not_in_package") == "yes":
685 # Add the sources of the products that have the property
686 # sources_in_package : "yes"
687 if src.get_property_in_product_cfg(prod_info,
688 "sources_in_package") == "yes":
689 if os.path.exists(prod_info.source_dir):
690 l_source_dir.append((prod_name, prod_info.source_dir))
692 l_sources_not_present.append(prod_name)
694 # ignore the native and fixed products for install directories
695 if (src.product.product_is_native(prod_info)
696 or src.product.product_is_fixed(prod_info)
697 or not src.product.product_compiles(prod_info)):
700 # products with single_dir property will be installed in the PRODUCTS directory of the archive
701 is_single_dir=(src.appli_test_property(config,"single_install_dir", "yes") and \
702 src.product.product_test_property(prod_info,"single_install_dir", "yes"))
703 if src.product.check_installation(config, prod_info):
704 l_install_dir.append((prod_name, prod_info.name, prod_info.install_dir,
705 is_single_dir, prod_info.install_mode))
707 l_not_installed.append(prod_name)
709 # Add also the cpp generated modules (if any)
710 if src.product.product_is_cpp(prod_info):
712 for name_cpp in src.product.get_product_components(prod_info):
713 install_dir = os.path.join(config.APPLICATION.workdir,
714 config.INTERNAL.config.install_dir,
716 if os.path.exists(install_dir):
717 l_install_dir.append((name_cpp, name_cpp, install_dir, False, "value"))
719 l_not_installed.append(name_cpp)
721 # check the name of the directory that (could) contains the binaries
722 # from previous detar
723 binaries_from_detar = os.path.join(
724 config.APPLICATION.workdir,
725 config.INTERNAL.config.binary_dir + config.VARS.dist)
726 if os.path.exists(binaries_from_detar):
728 WARNING: existing binaries directory from previous detar installation:
730 To make new package from this, you have to:
731 1) install binaries in INSTALL directory with the script "install_bin.sh"
732 see README file for more details
733 2) or recompile everything in INSTALL with "sat compile" command
734 this step is long, and requires some linux packages to be installed
736 """ % binaries_from_detar)
738 # Print warning or error if there are some missing products
739 if len(l_not_installed) > 0:
740 text_missing_prods = ""
741 for p_name in l_not_installed:
742 text_missing_prods += " - " + p_name + "\n"
743 if not options.force_creation:
744 msg = _("ERROR: there are missing product installations:")
745 logger.write("%s\n%s" % (src.printcolors.printcError(msg),
748 raise src.SatException(msg)
750 msg = _("WARNING: there are missing products installations:")
751 logger.write("%s\n%s" % (src.printcolors.printcWarning(msg),
755 # Do the same for sources
756 if len(l_sources_not_present) > 0:
757 text_missing_prods = ""
758 for p_name in l_sources_not_present:
759 text_missing_prods += "-" + p_name + "\n"
760 if not options.force_creation:
761 msg = _("ERROR: there are missing product sources:")
762 logger.write("%s\n%s" % (src.printcolors.printcError(msg),
765 raise src.SatException(msg)
767 msg = _("WARNING: there are missing products sources:")
768 logger.write("%s\n%s" % (src.printcolors.printcWarning(msg),
772 # construct the name of the directory that will contain the binaries
773 if src.architecture.is_windows():
774 binaries_dir_name = config.INTERNAL.config.binary_dir
776 binaries_dir_name = config.INTERNAL.config.binary_dir + config.VARS.dist
777 # construct the correlation table between the product names, there
778 # actual install directories and there install directory in archive
780 for prod_name, prod_info_name, install_dir, is_single_dir, install_mode in l_install_dir:
781 prod_base_name=os.path.basename(install_dir)
782 if install_mode == "base":
783 # case of a products installed in base.
784 # because the archive is in base:no mode, the name of the install dir is different inside archive
785 # we set it to the product name or by PRODUCTS if single-dir
787 prod_base_name=config.INTERNAL.config.single_install_dir
789 prod_base_name=prod_info_name
790 path_in_archive = os.path.join(binaries_dir_name, prod_base_name)
791 d_products[prod_name + " (bin)"] = (install_dir, path_in_archive)
793 for prod_name, source_dir in l_source_dir:
794 path_in_archive = os.path.join("SOURCES", prod_name)
795 d_products[prod_name + " (sources)"] = (source_dir, path_in_archive)
797 # create an archives of compilation logs, and insert it into the tarball
798 logpath=os.path.join(config.APPLICATION.workdir, "LOGS")
799 path_targz_logs = os.path.join(tmp_working_dir, "logs.tgz")
800 tar_log = tarfile.open(path_targz_logs, mode='w:gz')
801 tar_log.add(logpath, arcname="LOGS")
803 d_products["LOGS"] = (path_targz_logs, "logs.tgz")
805 # for packages of SALOME applications including KERNEL,
806 # we produce a salome launcher or a virtual application (depending on salome version)
807 if 'KERNEL' in config.APPLICATION.products:
808 VersionSalome = src.get_salome_version(config)
809 # Case where SALOME has the launcher that uses the SalomeContext API
810 if VersionSalome >= 730:
811 # create the relative launcher and add it to the files to add
812 launcher_name = src.get_launcher_name(config)
813 launcher_package = produce_relative_launcher(config,
818 d_products["launcher"] = (launcher_package, launcher_name)
820 # if the application contains mesa products, we generate in addition to the
821 # classical salome launcher a launcher using mesa and called mesa_salome
822 # (the mesa launcher will be used for remote usage through ssh).
823 if generate_mesa_launcher:
824 #if there is one : store the use_mesa property
825 restore_use_mesa_option=None
826 if ('properties' in config.APPLICATION and
827 'use_mesa' in config.APPLICATION.properties):
828 restore_use_mesa_option = config.APPLICATION.properties.use_mesa
830 # activate mesa property, and generate a mesa launcher
831 src.activate_mesa_property(config) #activate use_mesa property
832 launcher_mesa_name="mesa_"+launcher_name
833 launcher_package_mesa = produce_relative_launcher(config,
838 d_products["launcher (mesa)"] = (launcher_package_mesa, launcher_mesa_name)
840 # if there was a use_mesa value, we restore it
841 # else we set it to the default value "no"
842 if restore_use_mesa_option != None:
843 config.APPLICATION.properties.use_mesa=restore_use_mesa_option
845 config.APPLICATION.properties.use_mesa="no"
848 # if we mix binaries and sources, we add a copy of the launcher,
849 # prefixed with "bin",in order to avoid clashes
850 launcher_copy_name="bin"+launcher_name
851 launcher_package_copy = produce_relative_launcher(config,
856 d_products["launcher (copy)"] = (launcher_package_copy, launcher_copy_name)
858 # Provide a script for the creation of an application EDF style
859 appli_script = product_appli_creation_script(config,
864 d_products["appli script"] = (appli_script, "create_appli.py")
866 # Put also the environment file
867 env_file = produce_relative_env_files(config,
872 if src.architecture.is_windows():
873 filename = "env_launch.bat"
875 filename = "env_launch.sh"
876 d_products["environment file"] = (env_file, filename)
878 # If option exe, produce an extra launcher based on specified exe
880 exe_file = produce_relative_env_files(config,
886 if src.architecture.is_windows():
887 filename = os.path.basename(options.exe) + ".bat"
889 filename = os.path.basename(options.exe) + ".sh"
890 d_products["exe file"] = (exe_file, filename)
895 def source_package(sat, config, logger, options, tmp_working_dir):
896 '''Prepare a dictionary that stores all the needed directories and files to
897 add in a source package.
899 :param config Config: The global configuration.
900 :param logger Logger: the logging instance
901 :param options OptResult: the options of the launched command
902 :param tmp_working_dir str: The temporary local directory containing some
903 specific directories or files needed in the
905 :return: the dictionary that stores all the needed directories and files to
906 add in a source package.
907 {label : (path_on_local_machine, path_in_archive)}
912 # Get all the products that are prepared using an archive
913 # unless ftp mode is specified (in this case the user of the
914 # archive will get the sources through the ftp mode of sat prepare
916 logger.write("Find archive products ... ")
917 d_archives, l_pinfo_vcs = get_archives(config, logger)
918 logger.write("Done\n")
921 if not options.with_vcs and len(l_pinfo_vcs) > 0:
922 # Make archives with the products that are not prepared using an archive
923 # (git, cvs, svn, etc)
924 logger.write("Construct archives for vcs products ... ")
925 d_archives_vcs = get_archives_vcs(l_pinfo_vcs,
930 logger.write("Done\n")
933 logger.write("Create the project ... ")
934 d_project = create_project_for_src_package(config,
938 logger.write("Done\n")
941 tmp_sat = add_salomeTools(config, tmp_working_dir)
942 d_sat = {"salomeTools" : (tmp_sat, "sat")}
944 # Add a sat symbolic link if not win
945 if not src.architecture.is_windows():
949 # In the jobs, os.getcwd() can fail
950 t = config.LOCAL.workdir
951 os.chdir(tmp_working_dir)
953 # create a symlink, to avoid reference with "salomeTool/.."
955 if os.path.lexists("ARCHIVES"):
956 os.remove("ARCHIVES")
957 os.symlink("../ARCHIVES", "ARCHIVES")
960 d_sat["sat archive link"] = (os.path.join(tmp_working_dir,"PROJECT", "ARCHIVES"),
961 os.path.join("PROJECT", "ARCHIVES"))
963 d_source = src.merge_dicts(d_archives, d_archives_vcs, d_project, d_sat)
966 def get_archives(config, logger):
967 '''Find all the products that are get using an archive and all the products
968 that are get using a vcs (git, cvs, svn) repository.
970 :param config Config: The global configuration.
971 :param logger Logger: the logging instance
972 :return: the dictionary {name_product :
973 (local path of its archive, path in the package of its archive )}
974 and the list of specific configuration corresponding to the vcs
978 # Get the list of product informations
979 l_products_name = config.APPLICATION.products.keys()
980 l_product_info = src.product.get_products_infos(l_products_name,
984 for p_name, p_info in l_product_info:
985 # skip product with property not_in_package set to yes
986 if src.get_property_in_product_cfg(p_info, "not_in_package") == "yes":
988 # ignore the native and fixed products
989 if (src.product.product_is_native(p_info)
990 or src.product.product_is_fixed(p_info)):
992 if p_info.get_source == "archive":
993 archive_path = p_info.archive_info.archive_name
994 archive_name = os.path.basename(archive_path)
995 d_archives[p_name] = (archive_path,
996 os.path.join(ARCHIVE_DIR, archive_name))
997 if (src.appli_test_property(config,"pip", "yes") and
998 src.product.product_test_property(p_info,"pip", "yes")):
999 # if pip mode is activated, and product is managed by pip
1000 pip_wheels_dir=os.path.join(config.LOCAL.archive_dir,"wheels")
1001 pip_wheel_pattern=os.path.join(pip_wheels_dir,
1002 "%s-%s*" % (p_info.name, p_info.version))
1003 pip_wheel_path=glob.glob(pip_wheel_pattern)
1004 msg_pip_not_found="Error in get_archive, pip wheel for "\
1005 "product %s-%s was not found in %s directory"
1006 msg_pip_two_or_more="Error in get_archive, several pip wheels for "\
1007 "product %s-%s were found in %s directory"
1008 if len(pip_wheel_path)==0:
1009 raise src.SatException(msg_pip_not_found %\
1010 (p_info.name, p_info.version, pip_wheels_dir))
1011 if len(pip_wheel_path)>1:
1012 raise src.SatException(msg_pip_two_or_more %\
1013 (p_info.name, p_info.version, pip_wheels_dir))
1015 pip_wheel_name=os.path.basename(pip_wheel_path[0])
1016 d_archives[p_name+" (pip wheel)"]=(pip_wheel_path[0],
1017 os.path.join(ARCHIVE_DIR, "wheels", pip_wheel_name))
1019 # this product is not managed by archive,
1020 # an archive of the vcs directory will be created by get_archive_vcs
1021 l_pinfo_vcs.append((p_name, p_info))
1023 return d_archives, l_pinfo_vcs
1025 def add_salomeTools(config, tmp_working_dir):
1026 '''Prepare a version of salomeTools that has a specific local.pyconf file
1027 configured for a source package.
1029 :param config Config: The global configuration.
1030 :param tmp_working_dir str: The temporary local directory containing some
1031 specific directories or files needed in the
1033 :return: The path to the local salomeTools directory to add in the package
1036 # Copy sat in the temporary working directory
1037 sat_tmp_path = src.Path(os.path.join(tmp_working_dir, "salomeTools"))
1038 sat_running_path = src.Path(config.VARS.salometoolsway)
1039 sat_running_path.copy(sat_tmp_path)
1041 # Update the local.pyconf file that contains the path to the project
1042 local_pyconf_name = "local.pyconf"
1043 local_pyconf_dir = os.path.join(tmp_working_dir, "salomeTools", "data")
1044 local_pyconf_file = os.path.join(local_pyconf_dir, local_pyconf_name)
1045 # Remove the .pyconf file in the root directory of salomeTools if there is
1046 # any. (For example when launching jobs, a pyconf file describing the jobs
1047 # can be here and is not useful)
1048 files_or_dir_SAT = os.listdir(os.path.join(tmp_working_dir, "salomeTools"))
1049 for file_or_dir in files_or_dir_SAT:
1050 if file_or_dir.endswith(".pyconf") or file_or_dir.endswith(".txt"):
1051 file_path = os.path.join(tmp_working_dir,
1054 os.remove(file_path)
1056 ff = open(local_pyconf_file, "w")
1057 ff.write(LOCAL_TEMPLATE)
1060 return sat_tmp_path.path
1062 def get_archives_vcs(l_pinfo_vcs, sat, config, logger, tmp_working_dir):
1063 '''For sources package that require that all products are get using an
1064 archive, one has to create some archive for the vcs products.
1065 So this method calls the clean and source command of sat and then create
1068 :param l_pinfo_vcs List: The list of specific configuration corresponding to
1070 :param sat Sat: The Sat instance that can be called to clean and source the
1072 :param config Config: The global configuration.
1073 :param logger Logger: the logging instance
1074 :param tmp_working_dir str: The temporary local directory containing some
1075 specific directories or files needed in the
1077 :return: the dictionary that stores all the archives to add in the source
1078 package. {label : (path_on_local_machine, path_in_archive)}
1081 # clean the source directory of all the vcs products, then use the source
1082 # command and thus construct an archive that will not contain the patches
1083 l_prod_names = [pn for pn, __ in l_pinfo_vcs]
1084 if False: # clean is dangerous in user/SOURCES, fixed in tmp_local_working_dir
1085 logger.write(_("\nclean sources\n"))
1086 args_clean = config.VARS.application
1087 args_clean += " --sources --products "
1088 args_clean += ",".join(l_prod_names)
1089 logger.write("WARNING: get_archives_vcs clean\n '%s'\n" % args_clean, 1)
1090 sat.clean(args_clean, batch=True, verbose=0, logger_add_link = logger)
1093 logger.write(_("get sources\n"))
1094 args_source = config.VARS.application
1095 args_source += " --products "
1096 args_source += ",".join(l_prod_names)
1097 svgDir = sat.cfg.APPLICATION.workdir
1098 tmp_local_working_dir = os.path.join(sat.cfg.APPLICATION.workdir, "tmp_package") # to avoid too much big files in /tmp
1099 sat.cfg.APPLICATION.workdir = tmp_local_working_dir
1100 # DBG.write("SSS sat config.APPLICATION.workdir", sat.cfg.APPLICATION, True)
1101 # DBG.write("sat config id", id(sat.cfg), True)
1102 # shit as config is not same id() as for sat.source()
1103 # sat.source(args_source, batch=True, verbose=5, logger_add_link = logger)
1105 source.run(args_source, sat, logger) #use this mode as runner.cfg reference
1107 # make the new archives
1109 for pn, pinfo in l_pinfo_vcs:
1110 path_archive = make_archive(pn, pinfo, tmp_local_working_dir)
1111 logger.write("make archive vcs '%s'\n" % path_archive)
1112 d_archives_vcs[pn] = (path_archive,
1113 os.path.join(ARCHIVE_DIR, pn + ".tgz"))
1114 sat.cfg.APPLICATION.workdir = svgDir
1115 # DBG.write("END sat config", sat.cfg.APPLICATION, True)
1116 return d_archives_vcs
1118 def make_bin_archive(prod_name, prod_info, where):
1119 '''Create an archive of a product by searching its source directory.
1121 :param prod_name str: The name of the product.
1122 :param prod_info Config: The specific configuration corresponding to the
1124 :param where str: The path of the repository where to put the resulting
1126 :return: The path of the resulting archive
1129 path_targz_prod = os.path.join(where, prod_name + PACKAGE_EXT)
1130 tar_prod = tarfile.open(path_targz_prod, mode='w:gz')
1131 bin_path = prod_info.install_dir
1132 tar_prod.add(bin_path, arcname=path_targz_prod)
1134 return path_targz_prod
1136 def make_archive(prod_name, prod_info, where):
1137 '''Create an archive of a product by searching its source directory.
1139 :param prod_name str: The name of the product.
1140 :param prod_info Config: The specific configuration corresponding to the
1142 :param where str: The path of the repository where to put the resulting
1144 :return: The path of the resulting archive
1147 path_targz_prod = os.path.join(where, prod_name + PACKAGE_EXT)
1148 tar_prod = tarfile.open(path_targz_prod, mode='w:gz')
1149 local_path = prod_info.source_dir
1151 tar_prod.add(local_path,
1153 exclude=exclude_VCS_and_extensions_26)
1155 tar_prod.add(local_path,
1157 filter=exclude_VCS_and_extensions)
1159 return path_targz_prod
1161 def create_project_for_src_package(config, tmp_working_dir, with_vcs, with_ftp):
1162 '''Create a specific project for a source package.
1164 :param config Config: The global configuration.
1165 :param tmp_working_dir str: The temporary local directory containing some
1166 specific directories or files needed in the
1168 :param with_vcs boolean: True if the package is with vcs products (not
1169 transformed into archive products)
1170 :param with_ftp boolean: True if the package use ftp servers to get archives
1171 :return: The dictionary
1172 {"project" : (produced project, project path in the archive)}
1176 # Create in the working temporary directory the full project tree
1177 project_tmp_dir = os.path.join(tmp_working_dir, PROJECT_DIR)
1178 products_pyconf_tmp_dir = os.path.join(project_tmp_dir,
1180 compil_scripts_tmp_dir = os.path.join(project_tmp_dir,
1183 env_scripts_tmp_dir = os.path.join(project_tmp_dir,
1186 patches_tmp_dir = os.path.join(project_tmp_dir,
1189 application_tmp_dir = os.path.join(project_tmp_dir,
1191 for directory in [project_tmp_dir,
1192 compil_scripts_tmp_dir,
1193 env_scripts_tmp_dir,
1195 application_tmp_dir]:
1196 src.ensure_path_exists(directory)
1198 # Create the pyconf that contains the information of the project
1199 project_pyconf_name = "project.pyconf"
1200 project_pyconf_file = os.path.join(project_tmp_dir, project_pyconf_name)
1201 ff = open(project_pyconf_file, "w")
1202 ff.write(PROJECT_TEMPLATE)
1203 if with_ftp and len(config.PATHS.ARCHIVEFTP) > 0:
1204 ftp_path='ARCHIVEFTP : "'+config.PATHS.ARCHIVEFTP[0]
1205 for ftpserver in config.PATHS.ARCHIVEFTP[1:]:
1206 ftp_path=ftp_path+":"+ftpserver
1208 ff.write("# ftp servers where to search for prerequisite archives\n")
1210 # add licence paths if any
1211 if len(config.PATHS.LICENCEPATH) > 0:
1212 licence_path='LICENCEPATH : "'+config.PATHS.LICENCEPATH[0]
1213 for path in config.PATHS.LICENCEPATH[1:]:
1214 licence_path=licence_path+":"+path
1216 ff.write("\n# Where to search for licences\n")
1217 ff.write(licence_path)
1222 # Loop over the products to get there pyconf and all the scripts
1223 # (compilation, environment, patches)
1224 # and create the pyconf file to add to the project
1225 lproducts_name = config.APPLICATION.products.keys()
1226 l_products = src.product.get_products_infos(lproducts_name, config)
1227 for p_name, p_info in l_products:
1228 # skip product with property not_in_package set to yes
1229 if src.get_property_in_product_cfg(p_info, "not_in_package") == "yes":
1231 find_product_scripts_and_pyconf(p_name,
1235 compil_scripts_tmp_dir,
1236 env_scripts_tmp_dir,
1238 products_pyconf_tmp_dir)
1240 # for the application pyconf, we write directly the config
1241 # don't search for the original pyconf file
1242 # to avoid problems with overwrite sections and rm_products key
1243 write_application_pyconf(config, application_tmp_dir)
1245 d_project = {"project" : (project_tmp_dir, PROJECT_DIR )}
1248 def find_product_scripts_and_pyconf(p_name,
1252 compil_scripts_tmp_dir,
1253 env_scripts_tmp_dir,
1255 products_pyconf_tmp_dir):
1256 '''Create a specific pyconf file for a given product. Get its environment
1257 script, its compilation script and patches and put it in the temporary
1258 working directory. This method is used in the source package in order to
1259 construct the specific project.
1261 :param p_name str: The name of the product.
1262 :param p_info Config: The specific configuration corresponding to the
1264 :param config Config: The global configuration.
1265 :param with_vcs boolean: True if the package is with vcs products (not
1266 transformed into archive products)
1267 :param compil_scripts_tmp_dir str: The path to the temporary compilation
1268 scripts directory of the project.
1269 :param env_scripts_tmp_dir str: The path to the temporary environment script
1270 directory of the project.
1271 :param patches_tmp_dir str: The path to the temporary patch scripts
1272 directory of the project.
1273 :param products_pyconf_tmp_dir str: The path to the temporary product
1274 scripts directory of the project.
1277 # read the pyconf of the product
1278 product_pyconf_cfg = src.pyconf.Config(p_info.from_file)
1280 # find the compilation script if any
1281 if src.product.product_has_script(p_info):
1282 compil_script_path = src.Path(p_info.compil_script)
1283 compil_script_path.copy(compil_scripts_tmp_dir)
1285 # find the environment script if any
1286 if src.product.product_has_env_script(p_info):
1287 env_script_path = src.Path(p_info.environ.env_script)
1288 env_script_path.copy(env_scripts_tmp_dir)
1290 # find the patches if any
1291 if src.product.product_has_patches(p_info):
1292 patches = src.pyconf.Sequence()
1293 for patch_path in p_info.patches:
1294 p_path = src.Path(patch_path)
1295 p_path.copy(patches_tmp_dir)
1296 patches.append(os.path.basename(patch_path), "")
1298 if (not with_vcs) and src.product.product_is_vcs(p_info):
1299 # in non vcs mode, if the product is not archive, then make it become archive.
1301 # depending upon the incremental mode, select impacted sections
1302 if "properties" in p_info and "incremental" in p_info.properties and\
1303 p_info.properties.incremental == "yes":
1304 sections = ["default", "default_win", p_info.section, p_info.section+"_win"]
1306 sections = [p_info.section]
1307 for section in sections:
1308 if section in product_pyconf_cfg and "get_source" in product_pyconf_cfg[section]:
1309 DBG.write("sat package set archive mode to archive for product %s and section %s" %\
1311 product_pyconf_cfg[section].get_source = "archive"
1312 if not "archive_info" in product_pyconf_cfg[section]:
1313 product_pyconf_cfg[section].addMapping("archive_info",
1314 src.pyconf.Mapping(product_pyconf_cfg),
1316 product_pyconf_cfg[section].archive_info.archive_name =\
1317 p_info.name + ".tgz"
1319 if (with_vcs) and src.product.product_is_vcs(p_info):
1320 # in vcs mode we must replace explicitely the git server url
1321 # (or it will not be found later because project files are not exported in archives)
1322 for section in product_pyconf_cfg:
1323 # replace in all sections of the product pyconf the git repo definition by its substitued value (found in p_info)
1324 if "git_info" in product_pyconf_cfg[section]:
1325 for repo in product_pyconf_cfg[section].git_info:
1326 if repo in p_info.git_info:
1327 product_pyconf_cfg[section].git_info[repo] = p_info.git_info[repo]
1329 # write the pyconf file to the temporary project location
1330 product_tmp_pyconf_path = os.path.join(products_pyconf_tmp_dir,
1332 ff = open(product_tmp_pyconf_path, 'w')
1333 ff.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
1334 product_pyconf_cfg.__save__(ff, 1)
1338 def write_application_pyconf(config, application_tmp_dir):
1339 '''Write the application pyconf file in the specific temporary
1340 directory containing the specific project of a source package.
1342 :param config Config: The global configuration.
1343 :param application_tmp_dir str: The path to the temporary application
1344 scripts directory of the project.
1346 application_name = config.VARS.application
1347 # write the pyconf file to the temporary application location
1348 application_tmp_pyconf_path = os.path.join(application_tmp_dir,
1349 application_name + ".pyconf")
1350 with open(application_tmp_pyconf_path, 'w') as f:
1351 f.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
1352 res = src.pyconf.Config()
1353 app = src.pyconf.deepCopyMapping(config.APPLICATION)
1355 # set base mode to "no" for the archive
1358 # Change the workdir
1359 app.workdir = src.pyconf.Reference(
1362 'VARS.salometoolsway + $VARS.sep + ".."')
1363 res.addMapping("APPLICATION", app, "")
1364 res.__save__(f, evaluated=False)
1367 def sat_package(config, tmp_working_dir, options, logger):
1368 '''Prepare a dictionary that stores all the needed directories and files to
1369 add in a salomeTool package.
1371 :param tmp_working_dir str: The temporary local working directory
1372 :param options OptResult: the options of the launched command
1373 :return: the dictionary that stores all the needed directories and files to
1374 add in a salomeTool package.
1375 {label : (path_on_local_machine, path_in_archive)}
1380 # we include sat himself
1381 d_project["all_sat"]=(config.VARS.salometoolsway, "")
1383 # and we overwrite local.pyconf with a clean wersion.
1384 local_pyconf_tmp_path = os.path.join(tmp_working_dir, "local.pyconf")
1385 local_file_path = os.path.join(config.VARS.datadir, "local.pyconf")
1386 local_cfg = src.pyconf.Config(local_file_path)
1387 local_cfg.PROJECTS.project_file_paths=src.pyconf.Sequence(local_cfg.PROJECTS)
1388 local_cfg.LOCAL["base"] = "default"
1389 local_cfg.LOCAL["workdir"] = "default"
1390 local_cfg.LOCAL["log_dir"] = "default"
1391 local_cfg.LOCAL["archive_dir"] = "default"
1392 local_cfg.LOCAL["VCS"] = "None"
1393 local_cfg.LOCAL["tag"] = src.get_salometool_version(config)
1395 # if the archive contains a project, we write its relative path in local.pyconf
1397 project_arch_path = os.path.join("projects", options.project,
1398 os.path.basename(options.project_file_path))
1399 local_cfg.PROJECTS.project_file_paths.append(project_arch_path, "")
1401 ff = open(local_pyconf_tmp_path, 'w')
1402 local_cfg.__save__(ff, 1)
1404 d_project["local.pyconf"]=(local_pyconf_tmp_path, "data/local.pyconf")
1408 def project_package(config, name_project, project_file_path, ftp_mode, tmp_working_dir, embedded_in_sat, logger):
1409 '''Prepare a dictionary that stores all the needed directories and files to
1410 add in a project package.
1412 :param project_file_path str: The path to the local project.
1413 :param ftp_mode boolean: Do not embed archives, the archive will rely on ftp mode to retrieve them.
1414 :param tmp_working_dir str: The temporary local directory containing some
1415 specific directories or files needed in the
1417 :param embedded_in_sat boolean : the project package is embedded in a sat package
1418 :return: the dictionary that stores all the needed directories and files to
1419 add in a project package.
1420 {label : (path_on_local_machine, path_in_archive)}
1424 # Read the project file and get the directories to add to the package
1427 project_pyconf_cfg = config.PROJECTS.projects.__getattr__(name_project)
1430 WARNING: inexisting config.PROJECTS.projects.%s, try to read now from:\n%s\n""" % (name_project, project_file_path))
1431 project_pyconf_cfg = src.pyconf.Config(project_file_path)
1432 project_pyconf_cfg.PWD = os.path.dirname(project_file_path)
1434 paths = {"APPLICATIONPATH" : "applications",
1435 "PRODUCTPATH" : "products",
1437 "MACHINEPATH" : "machines"}
1439 paths["ARCHIVEPATH"] = "archives"
1441 # Loop over the project paths and add it
1442 project_file_name = os.path.basename(project_file_path)
1444 if path not in project_pyconf_cfg:
1447 dest_path = os.path.join("projects", name_project, paths[path])
1448 project_file_dest = os.path.join("projects", name_project, project_file_name)
1450 dest_path = paths[path]
1451 project_file_dest = project_file_name
1453 # Add the directory to the files to add in the package
1454 d_project[path] = (project_pyconf_cfg[path], dest_path)
1456 # Modify the value of the path in the package
1457 project_pyconf_cfg[path] = src.pyconf.Reference(
1460 'project_path + "/' + paths[path] + '"')
1462 # Modify some values
1463 if "project_path" not in project_pyconf_cfg:
1464 project_pyconf_cfg.addMapping("project_path",
1465 src.pyconf.Mapping(project_pyconf_cfg),
1467 project_pyconf_cfg.project_path = src.pyconf.Reference(project_pyconf_cfg,
1470 # we don't want to export these two fields
1471 project_pyconf_cfg.__delitem__("file_path")
1472 project_pyconf_cfg.__delitem__("PWD")
1474 project_pyconf_cfg.__delitem__("ARCHIVEPATH")
1476 # Write the project pyconf file
1477 project_pyconf_tmp_path = os.path.join(tmp_working_dir, project_file_name)
1478 ff = open(project_pyconf_tmp_path, 'w')
1479 ff.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
1480 project_pyconf_cfg.__save__(ff, 1)
1482 d_project["Project hat file"] = (project_pyconf_tmp_path, project_file_dest)
1486 def add_readme(config, options, where):
1487 readme_path = os.path.join(where, "README")
1488 with codecs.open(readme_path, "w", 'utf-8') as f:
1490 # templates for building the header
1492 # This package was generated with sat $version
1495 # Distribution : $dist
1497 In the following, $$ROOT represents the directory where you have installed
1498 SALOME (the directory where this file is located).
1501 if src.architecture.is_windows():
1502 readme_header = readme_header.replace('$$ROOT','%ROOT%')
1503 readme_compilation_with_binaries="""
1505 compilation based on the binaries used as prerequisites
1506 =======================================================
1508 If you fail to compile the complete application (for example because
1509 you are not root on your system and cannot install missing packages), you
1510 may try a partial compilation based on the binaries.
1511 For that it is necessary to copy the binaries from BINARIES to INSTALL,
1512 and do some substitutions on cmake and .la files (replace the build directories
1514 The procedure to do it is:
1515 1) Remove or rename INSTALL directory if it exists
1516 2) Execute the shell script install_bin.sh:
1519 3) Use SalomeTool (as explained in Sources section) and compile only the
1520 modules you need to (with -p option)
1523 readme_header_tpl=string.Template(readme_header)
1524 readme_template_path_bin = os.path.join(config.VARS.internal_dir,
1525 "README_BIN.template")
1526 readme_template_path_bin_launcher = os.path.join(config.VARS.internal_dir,
1527 "README_LAUNCHER.template")
1528 readme_template_path_bin_virtapp = os.path.join(config.VARS.internal_dir,
1529 "README_BIN_VIRTUAL_APP.template")
1530 readme_template_path_src = os.path.join(config.VARS.internal_dir,
1531 "README_SRC.template")
1532 readme_template_path_pro = os.path.join(config.VARS.internal_dir,
1533 "README_PROJECT.template")
1534 readme_template_path_sat = os.path.join(config.VARS.internal_dir,
1535 "README_SAT.template")
1537 # prepare substitution dictionary
1539 d['user'] = config.VARS.user
1540 d['date'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
1541 d['version'] = src.get_salometool_version(config)
1542 d['dist'] = config.VARS.dist
1543 f.write(readme_header_tpl.substitute(d)) # write the general header (common)
1545 if options.binaries or options.sources:
1546 d['application'] = config.VARS.application
1547 d['BINARIES'] = config.INTERNAL.config.binary_dir
1548 d['SEPARATOR'] = config.VARS.sep
1549 if src.architecture.is_windows():
1550 d['operatingSystem'] = 'Windows'
1551 d['PYTHON3'] = 'python3'
1552 d['ROOT'] = '%ROOT%'
1554 d['operatingSystem'] = 'Linux'
1557 f.write("# Application: " + d['application'] + "\n")
1558 if 'KERNEL' in config.APPLICATION.products:
1559 VersionSalome = src.get_salome_version(config)
1560 # Case where SALOME has the launcher that uses the SalomeContext API
1561 if VersionSalome >= 730:
1562 d['launcher'] = config.APPLICATION.profile.launcher_name
1564 d['virtual_app'] = 'runAppli' # this info is not used now)
1566 # write the specific sections
1567 if options.binaries:
1568 f.write(src.template.substitute(readme_template_path_bin, d))
1569 if "virtual_app" in d:
1570 f.write(src.template.substitute(readme_template_path_bin_virtapp, d))
1572 f.write(src.template.substitute(readme_template_path_bin_launcher, d))
1575 f.write(src.template.substitute(readme_template_path_src, d))
1577 if options.binaries and options.sources and not src.architecture.is_windows():
1578 f.write(readme_compilation_with_binaries)
1581 f.write(src.template.substitute(readme_template_path_pro, d))
1584 f.write(src.template.substitute(readme_template_path_sat, d))
1588 def update_config(config, logger, prop, value):
1589 '''Remove from config.APPLICATION.products the products that have the property given as input.
1591 :param config Config: The global config.
1592 :param prop str: The property to filter
1593 :param value str: The value of the property to filter
1595 # if there is no APPLICATION (ex sat package -t) : nothing to do
1596 if "APPLICATION" in config:
1597 l_product_to_remove = []
1598 for product_name in config.APPLICATION.products.keys():
1599 prod_cfg = src.product.get_product_config(config, product_name)
1600 if src.get_property_in_product_cfg(prod_cfg, prop) == value:
1601 l_product_to_remove.append(product_name)
1602 for product_name in l_product_to_remove:
1603 config.APPLICATION.products.__delitem__(product_name)
1604 logger.write("Remove product %s with property %s\n" % (product_name, prop), 5)
1607 '''method that is called when salomeTools is called with --help option.
1609 :return: The text to display for the package command description.
1613 The package command creates a tar file archive of a product.
1614 There are four kinds of archive, which can be mixed:
1616 1 - The binary archive.
1617 It contains the product installation directories plus a launcher.
1618 2 - The sources archive.
1619 It contains the product archives, a project (the application plus salomeTools).
1620 3 - The project archive.
1621 It contains a project (give the project file path as argument).
1622 4 - The salomeTools archive.
1623 It contains code utility salomeTools.
1626 >> sat package SALOME-master --binaries --sources""")
1628 def run(args, runner, logger):
1629 '''method that is called when salomeTools is called with package parameter.
1633 (options, args) = parser.parse_args(args)
1636 # Check that a type of package is called, and only one
1637 all_option_types = (options.binaries,
1639 options.project not in ["", None],
1641 options.bin_products)
1643 # Check if no option for package type
1644 if all_option_types.count(True) == 0:
1645 msg = _("Error: Precise a type for the package\nUse one of the "
1646 "following options: --binaries, --sources, --project or"
1647 " --salometools, --bin_products")
1648 logger.write(src.printcolors.printcError(msg), 1)
1649 logger.write("\n", 1)
1651 do_create_package = options.binaries or options.sources or options.project or options.sat
1653 if options.bin_products:
1654 ret = bin_products_archives(runner.cfg, logger, options.with_vcs)
1657 if not do_create_package:
1660 # continue to create a tar.gz package
1662 # The repository where to put the package if not Binary or Source
1663 package_default_path = runner.cfg.LOCAL.workdir
1664 # if the package contains binaries or sources:
1665 if options.binaries or options.sources or options.bin_products:
1666 # Check that the command has been called with an application
1667 src.check_config_has_application(runner.cfg)
1669 # Display information
1670 logger.write(_("Packaging application %s\n") % src.printcolors.printcLabel(
1671 runner.cfg.VARS.application), 1)
1673 # Get the default directory where to put the packages
1674 package_default_path = os.path.join(runner.cfg.APPLICATION.workdir, "PACKAGE")
1675 src.ensure_path_exists(package_default_path)
1677 # if the package contains a project:
1679 # check that the project is visible by SAT
1680 projectNameFile = options.project + ".pyconf"
1682 for i in runner.cfg.PROJECTS.project_file_paths:
1683 baseName = os.path.basename(i)
1684 if baseName == projectNameFile:
1688 if foundProject is None:
1689 local_path = os.path.join(runner.cfg.VARS.salometoolsway, "data", "local.pyconf")
1690 msg = _("""ERROR: the project %(1)s is not visible by salomeTools.
1694 Please add it in file:
1696 {"1": options.project, "2": "\n ".join(runner.cfg.PROJECTS.project_file_paths), "3": local_path})
1697 logger.write(src.printcolors.printcError(msg), 1)
1698 logger.write("\n", 1)
1701 options.project_file_path = foundProject
1702 src.printcolors.print_value(logger, "Project path", options.project_file_path, 2)
1704 # Remove the products that are filtered by the --without_properties option
1705 if options.without_properties:
1706 prop, value = options.without_properties
1707 update_config(runner.cfg, logger, prop, value)
1709 # Remove from config the products that have the not_in_package property
1710 update_config(runner.cfg, logger, "not_in_package", "yes")
1712 # get the name of the archive or build it
1714 if os.path.basename(options.name) == options.name:
1715 # only a name (not a path)
1716 archive_name = options.name
1717 dir_name = package_default_path
1719 archive_name = os.path.basename(options.name)
1720 dir_name = os.path.dirname(options.name)
1722 # suppress extension
1723 if archive_name[-len(".tgz"):] == ".tgz":
1724 archive_name = archive_name[:-len(".tgz")]
1725 if archive_name[-len(".tar.gz"):] == ".tar.gz":
1726 archive_name = archive_name[:-len(".tar.gz")]
1730 dir_name = package_default_path
1731 if options.binaries or options.sources:
1732 archive_name = runner.cfg.APPLICATION.name
1734 if options.binaries:
1735 archive_name += "-"+runner.cfg.VARS.dist
1738 archive_name += "-SRC"
1739 if options.with_vcs:
1740 archive_name += "-VCS"
1743 archive_name += ("salomeTools_" + src.get_salometool_version(runner.cfg))
1748 archive_name += ("satproject_" + options.project)
1750 if len(archive_name)==0: # no option worked
1751 msg = _("Error: Cannot name the archive\n"
1752 " check if at least one of the following options was "
1753 "selected : --binaries, --sources, --project or"
1755 logger.write(src.printcolors.printcError(msg), 1)
1756 logger.write("\n", 1)
1759 path_targz = os.path.join(dir_name, archive_name + PACKAGE_EXT)
1761 src.printcolors.print_value(logger, "Package path", path_targz, 2)
1763 # Create a working directory for all files that are produced during the
1764 # package creation and that will be removed at the end of the command
1765 tmp_working_dir = os.path.join(runner.cfg.VARS.tmp_root, runner.cfg.VARS.datehour)
1766 src.ensure_path_exists(tmp_working_dir)
1767 logger.write("\n", 5)
1768 logger.write(_("The temporary working directory: %s\n" % tmp_working_dir),5)
1770 logger.write("\n", 3)
1772 msg = _("Preparation of files to add to the archive")
1773 logger.write(src.printcolors.printcLabel(msg), 2)
1774 logger.write("\n", 2)
1776 d_files_to_add={} # content of the archive
1778 # a dict to hold paths that will need to be substitute for users recompilations
1779 d_paths_to_substitute={}
1781 if options.binaries:
1782 d_bin_files_to_add = binary_package(runner.cfg,
1786 # for all binaries dir, store the substitution that will be required
1787 # for extra compilations
1788 for key in d_bin_files_to_add:
1789 if key.endswith("(bin)"):
1790 source_dir = d_bin_files_to_add[key][0]
1791 path_in_archive = d_bin_files_to_add[key][1].replace(
1792 runner.cfg.INTERNAL.config.binary_dir + runner.cfg.VARS.dist,
1793 runner.cfg.INTERNAL.config.install_dir)
1794 if os.path.basename(source_dir)==os.path.basename(path_in_archive):
1795 # if basename is the same we will just substitute the dirname
1796 d_paths_to_substitute[os.path.dirname(source_dir)]=\
1797 os.path.dirname(path_in_archive)
1799 d_paths_to_substitute[source_dir]=path_in_archive
1801 d_files_to_add.update(d_bin_files_to_add)
1803 d_files_to_add.update(source_package(runner,
1808 if options.binaries:
1809 # for archives with bin and sources we provide a shell script able to
1810 # install binaries for compilation
1811 file_install_bin=produce_install_bin_file(runner.cfg,logger,
1813 d_paths_to_substitute,
1815 d_files_to_add.update({"install_bin" : (file_install_bin, "install_bin.sh")})
1816 logger.write("substitutions that need to be done later : \n", 5)
1817 logger.write(str(d_paths_to_substitute), 5)
1818 logger.write("\n", 5)
1820 # --salomeTool option is not considered when --sources is selected, as this option
1821 # already brings salomeTool!
1823 d_files_to_add.update(sat_package(runner.cfg, tmp_working_dir,
1827 DBG.write("config for package %s" % options.project, runner.cfg)
1828 d_files_to_add.update(project_package(runner.cfg, options.project, options.project_file_path, options.ftp, tmp_working_dir, options.sat, logger))
1830 if not(d_files_to_add):
1831 msg = _("Error: Empty dictionnary to build the archive!\n")
1832 logger.write(src.printcolors.printcError(msg), 1)
1833 logger.write("\n", 1)
1836 # Add the README file in the package
1837 local_readme_tmp_path = add_readme(runner.cfg, options, tmp_working_dir)
1838 d_files_to_add["README"] = (local_readme_tmp_path, "README")
1840 # Add the additional files of option add_files
1841 if options.add_files:
1842 for file_path in options.add_files:
1843 if not os.path.exists(file_path):
1844 msg = _("WARNING: the file %s is not accessible.\n" % file_path)
1846 file_name = os.path.basename(file_path)
1847 d_files_to_add[file_name] = (file_path, file_name)
1849 logger.write("\n", 2)
1850 logger.write(src.printcolors.printcLabel(_("Actually do the package")), 2)
1851 logger.write("\n", 2)
1852 logger.write("\nfiles and directories to add:\n%s\n\n" % PP.pformat(d_files_to_add), 5)
1856 # Creating the object tarfile
1857 tar = tarfile.open(path_targz, mode='w:gz')
1859 # get the filtering function if needed
1861 filter_function = exclude_VCS_and_extensions_26
1863 filter_function = exclude_VCS_and_extensions
1865 # Add the files to the tarfile object
1866 res = add_files(tar, archive_name, d_files_to_add, logger, f_exclude=filter_function)
1868 except KeyboardInterrupt:
1869 logger.write(src.printcolors.printcError("\nERROR: forced interruption\n"), 1)
1870 logger.write(_("Removing the temporary working directory '%s'... ") % tmp_working_dir, 1)
1871 # remove the working directory
1872 shutil.rmtree(tmp_working_dir)
1873 logger.write(_("OK"), 1)
1874 logger.write(_("\n"), 1)
1877 # case if no application, only package sat as 'sat package -t'
1879 app = runner.cfg.APPLICATION
1883 # unconditionaly remove the tmp_local_working_dir
1885 tmp_local_working_dir = os.path.join(app.workdir, "tmp_package")
1886 if os.path.isdir(tmp_local_working_dir):
1887 shutil.rmtree(tmp_local_working_dir)
1889 # remove the tmp directory, unless user has registered as developer
1890 if os.path.isdir(tmp_working_dir) and (not DBG.isDeveloper()):
1891 shutil.rmtree(tmp_working_dir)
1893 # Print again the path of the package
1894 logger.write("\n", 2)
1895 src.printcolors.print_value(logger, "Package path", path_targz, 2)