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
39 ARCHIVE_DIR = "ARCHIVES"
40 PROJECT_DIR = "PROJECT"
42 IGNORED_DIRS = [".git", ".svn"]
43 IGNORED_EXTENSIONS = []
45 PACKAGE_EXT=".tar.gz" # the extension we use for the packages
47 PROJECT_TEMPLATE = """#!/usr/bin/env python
50 # The path to the archive root directory
51 root_path : $PWD + "/../"
53 project_path : $PWD + "/"
55 # Where to search the archives of the products
56 ARCHIVEPATH : $root_path + "ARCHIVES"
57 # Where to search the pyconf of the applications
58 APPLICATIONPATH : $project_path + "applications/"
59 # Where to search the pyconf of the products
60 PRODUCTPATH : $project_path + "products/"
61 # Where to search the pyconf of the jobs of the project
62 JOBPATH : $project_path + "jobs/"
63 # Where to search the pyconf of the machines of the project
64 MACHINEPATH : $project_path + "machines/"
67 LOCAL_TEMPLATE = ("""#!/usr/bin/env python
75 archive_dir : 'default'
82 project_file_paths : [$VARS.salometoolsway + $VARS.sep + \"..\" + $VARS.sep"""
83 """ + \"""" + PROJECT_DIR + """\" + $VARS.sep + "project.pyconf"]
87 # Define all possible option for the package command : sat package <options>
88 parser = src.options.Options()
89 parser.add_option('b', 'binaries', 'boolean', 'binaries',
90 _('Optional: Produce a binary package.'), False)
91 parser.add_option('f', 'force_creation', 'boolean', 'force_creation',
92 _('Optional: Only binary package: produce the archive even if '
93 'there are some missing products.'), False)
94 parser.add_option('s', 'sources', 'boolean', 'sources',
95 _('Optional: Produce a compilable archive of the sources of the '
96 'application.'), False)
97 parser.add_option('', 'with_vcs', 'boolean', 'with_vcs',
98 _('Optional: Do not make archive for products in VCS mode (git, cvs, svn). '
99 'Sat prepare will use VCS mode instead to retrieve them'),
101 parser.add_option('', 'ftp', 'boolean', 'ftp',
102 _('Optional: Do not embed archives for products in archive mode.'
103 'Sat prepare will use ftp instead to retrieve them'),
105 parser.add_option('p', 'project', 'string', 'project',
106 _('Optional: Produce an archive that contains a project.'), "")
107 parser.add_option('t', 'salometools', 'boolean', 'sat',
108 _('Optional: Produce an archive that contains salomeTools.'), False)
109 parser.add_option('n', 'name', 'string', 'name',
110 _('Optional: The name or full path of the archive.'), None)
111 parser.add_option('', 'add_files', 'list2', 'add_files',
112 _('Optional: The list of additional files to add to the archive.'), [])
113 parser.add_option('', 'without_properties', 'properties', 'without_properties',
114 _('Optional: Filter the products by their properties.\n\tSyntax: '
115 '--without_properties <property>:<value>'))
118 def add_files(tar, name_archive, d_content, logger, f_exclude=None):
119 '''Create an archive containing all directories and files that are given in
120 the d_content argument.
122 :param tar tarfile: The tarfile instance used to make the archive.
123 :param name_archive str: The name of the archive to make.
124 :param d_content dict: The dictionary that contain all directories and files
125 to add in the archive.
127 (path_on_local_machine, path_in_archive)
128 :param logger Logger: the logging instance
129 :param f_exclude Function: the function that filters
130 :return: 0 if success, 1 if not.
133 # get the max length of the messages in order to make the display
134 max_len = len(max(d_content.keys(), key=len))
137 # loop over each directory or file stored in the d_content dictionary
138 names = sorted(d_content.keys())
139 DBG.write("add tar names", names)
141 # used to avoid duplications (for pip install in python, or single_install_dir cases)
144 # display information
145 len_points = max_len - len(name) + 3
146 local_path, archive_path = d_content[name]
147 in_archive = os.path.join(name_archive, archive_path)
148 logger.write(name + " " + len_points * "." + " "+ in_archive + " ", 3)
149 # Get the local path and the path in archive
150 # of the directory or file to add
151 # Add it in the archive
153 key=local_path+"->"+in_archive
154 if key not in already_added:
155 tar.add(local_path, arcname=in_archive, exclude=f_exclude)
156 already_added.add(key)
157 logger.write(src.printcolors.printcSuccess(_("OK")), 3)
158 except Exception as e:
159 logger.write(src.printcolors.printcError(_("KO ")), 3)
160 logger.write(str(e), 3)
162 logger.write("\n", 3)
165 def exclude_VCS_and_extensions(filename):
166 ''' The function that is used to exclude from package the link to the
167 VCS repositories (like .git)
169 :param filename Str: The filname to exclude (or not).
170 :return: True if the file has to be exclude
173 for dir_name in IGNORED_DIRS:
174 if dir_name in filename:
176 for extension in IGNORED_EXTENSIONS:
177 if filename.endswith(extension):
181 def produce_relative_launcher(config,
186 '''Create a specific SALOME launcher for the binary package. This launcher
189 :param config Config: The global configuration.
190 :param logger Logger: the logging instance
191 :param file_dir str: the directory where to put the launcher
192 :param file_name str: The launcher name
193 :param binaries_dir_name str: the name of the repository where the binaries
195 :return: the path of the produced launcher
199 # get KERNEL installation path
200 kernel_root_dir = os.path.join(binaries_dir_name, "KERNEL")
202 # set kernel bin dir (considering fhs property)
203 kernel_cfg = src.product.get_product_config(config, "KERNEL")
204 if src.get_property_in_product_cfg(kernel_cfg, "fhs"):
205 bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin")
207 bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin","salome")
209 # check if the application contains an application module
210 # check also if the application has a distene product,
211 # in this case get its licence file name
212 l_product_info = src.product.get_products_infos(config.APPLICATION.products.keys(), config)
213 salome_application_name="Not defined"
214 distene_licence_file_name=False
215 for prod_name, prod_info in l_product_info:
216 # look for a "salome application" and a distene product
217 if src.get_property_in_product_cfg(prod_info, "is_distene") == "yes":
218 distene_licence_file_name = src.product.product_has_licence(prod_info,
219 config.PATHS.LICENCEPATH)
220 if src.get_property_in_product_cfg(prod_info, "is_salome_application") == "yes":
221 salome_application_name=prod_info.name
223 # if the application contains an application module, we set ABSOLUTE_APPLI_PATH to it
224 # if not we set it to KERNEL_INSTALL_DIR, which is sufficient, except for salome test
225 if salome_application_name == "Not defined":
226 app_root_dir=kernel_root_dir
228 app_root_dir=os.path.join(binaries_dir_name, salome_application_name)
231 additional_env['sat_bin_kernel_install_dir'] = "out_dir_Path + " +\
232 config.VARS.sep + bin_kernel_install_dir
233 if "python3" in config.APPLICATION and config.APPLICATION.python3 == "yes":
234 additional_env['sat_python_version'] = 3
236 additional_env['sat_python_version'] = 2
238 additional_env['ABSOLUTE_APPLI_PATH'] = "out_dir_Path" + config.VARS.sep + app_root_dir
240 # create an environment file writer
241 writer = src.environment.FileEnvWriter(config,
247 filepath = os.path.join(file_dir, file_name)
249 writer.write_env_file(filepath,
252 additional_env=additional_env,
253 no_path_init="False",
254 for_package = binaries_dir_name)
256 # Little hack to put out_dir_Path outside the strings
257 src.replace_in_file(filepath, 'r"out_dir_Path', 'out_dir_Path + r"' )
258 src.replace_in_file(filepath, "'out_dir_Path + ", "out_dir_Path + '" )
260 # A hack to put a call to a file for distene licence.
261 # It does nothing to an application that has no distene product
262 if distene_licence_file_name:
263 logger.write("Application has a distene licence file! We use it in package launcher", 5)
264 hack_for_distene_licence(filepath, distene_licence_file_name)
266 # change the rights in order to make the file executable for everybody
278 def hack_for_distene_licence(filepath, licence_file):
279 '''Replace the distene licence env variable by a call to a file.
281 :param filepath Str: The path to the launcher to modify.
283 shutil.move(filepath, filepath + "_old")
285 filein = filepath + "_old"
286 fin = open(filein, "r")
287 fout = open(fileout, "w")
288 text = fin.readlines()
289 # Find the Distene section
291 for i,line in enumerate(text):
292 if "# Set DISTENE License" in line:
296 # No distene product, there is nothing to do
302 del text[num_line +1]
303 del text[num_line +1]
304 text_to_insert =""" try:
305 distene_licence_file="%s"
306 if sys.version_info[0] >= 3 and sys.version_info[1] >= 5:
307 import importlib.util
308 spec_dist = importlib.util.spec_from_file_location("distene_licence", distene_licence_file)
309 distene=importlib.util.module_from_spec(spec_dist)
310 spec_dist.loader.exec_module(distene)
313 distene = imp.load_source('distene_licence', distene_licence_file)
314 distene.set_distene_variables(context)
316 pass\n""" % licence_file
317 text.insert(num_line + 1, text_to_insert)
324 def produce_relative_env_files(config,
328 '''Create some specific environment files for the binary package. These
329 files use relative paths.
331 :param config Config: The global configuration.
332 :param logger Logger: the logging instance
333 :param file_dir str: the directory where to put the files
334 :param binaries_dir_name str: the name of the repository where the binaries
336 :return: the list of path of the produced environment files
339 # create an environment file writer
340 writer = src.environment.FileEnvWriter(config,
345 if src.architecture.is_windows():
347 filename = "env_launch.bat"
350 filename = "env_launch.sh"
353 filepath = writer.write_env_file(filename,
356 for_package = binaries_dir_name)
358 # Little hack to put out_dir_Path as environment variable
359 if src.architecture.is_windows() :
360 src.replace_in_file(filepath, '"out_dir_Path', '"%out_dir_Path%' )
362 src.replace_in_file(filepath, '"out_dir_Path', '"${out_dir_Path}' )
364 # change the rights in order to make the file executable for everybody
376 def produce_install_bin_file(config,
381 '''Create a bash shell script which do substitutions in BIRARIES dir
382 in order to use it for extra compilations.
384 :param config Config: The global configuration.
385 :param logger Logger: the logging instance
386 :param file_dir str: the directory where to put the files
387 :param d_sub, dict: the dictionnary that contains the substitutions to be done
388 :param file_name str: the name of the install script file
389 :return: the produced file
393 filepath = os.path.join(file_dir, file_name)
394 # open the file and write into it
395 # use codec utf-8 as sat variables are in unicode
396 with codecs.open(filepath, "w", 'utf-8') as installbin_file:
397 installbin_template_path = os.path.join(config.VARS.internal_dir,
398 "INSTALL_BIN.template")
400 # build the name of the directory that will contain the binaries
401 binaries_dir_name = config.INTERNAL.config.binary_dir + config.VARS.dist
402 # build the substitution loop
403 loop_cmd = "for f in $(grep -RIl"
405 loop_cmd += " -e "+ key
406 loop_cmd += ' ' + config.INTERNAL.config.install_dir +\
409 loop_cmd += " s?" + key + "?$(pwd)/" + d_sub[key] + "?g\n"
410 loop_cmd += ' " $f\ndone'
413 d["BINARIES_DIR"] = binaries_dir_name
414 d["SUBSTITUTION_LOOP"]=loop_cmd
415 d["INSTALL_DIR"]=config.INTERNAL.config.install_dir
417 # substitute the template and write it in file
418 content=src.template.substitute(installbin_template_path, d)
419 installbin_file.write(content)
420 # change the rights in order to make the file executable for everybody
432 def product_appli_creation_script(config,
436 '''Create a script that can produce an application (EDF style) in the binary
439 :param config Config: The global configuration.
440 :param logger Logger: the logging instance
441 :param file_dir str: the directory where to put the file
442 :param binaries_dir_name str: the name of the repository where the binaries
444 :return: the path of the produced script file
447 template_name = "create_appli.py.for_bin_packages.template"
448 template_path = os.path.join(config.VARS.internal_dir, template_name)
449 text_to_fill = open(template_path, "r").read()
450 text_to_fill = text_to_fill.replace("TO BE FILLED 1",
451 '"' + binaries_dir_name + '"')
454 for product_name in get_SALOME_modules(config):
455 product_info = src.product.get_product_config(config, product_name)
457 if src.product.product_is_smesh_plugin(product_info):
460 if 'install_dir' in product_info and bool(product_info.install_dir):
461 if src.product.product_is_cpp(product_info):
463 for cpp_name in src.product.get_product_components(product_info):
464 line_to_add = ("<module name=\"" +
466 "\" gui=\"yes\" path=\"''' + "
467 "os.path.join(dir_bin_name, \"" +
468 cpp_name + "\") + '''\"/>")
471 line_to_add = ("<module name=\"" +
473 "\" gui=\"yes\" path=\"''' + "
474 "os.path.join(dir_bin_name, \"" +
475 product_name + "\") + '''\"/>")
476 text_to_add += line_to_add + "\n"
478 filled_text = text_to_fill.replace("TO BE FILLED 2", text_to_add)
480 tmp_file_path = os.path.join(file_dir, "create_appli.py")
481 ff = open(tmp_file_path, "w")
482 ff.write(filled_text)
485 # change the rights in order to make the file executable for everybody
486 os.chmod(tmp_file_path,
497 def binary_package(config, logger, options, tmp_working_dir):
498 '''Prepare a dictionary that stores all the needed directories and files to
499 add in a binary package.
501 :param config Config: The global configuration.
502 :param logger Logger: the logging instance
503 :param options OptResult: the options of the launched command
504 :param tmp_working_dir str: The temporary local directory containing some
505 specific directories or files needed in the
507 :return: the dictionary that stores all the needed directories and files to
508 add in a binary package.
509 {label : (path_on_local_machine, path_in_archive)}
513 # Get the list of product installation to add to the archive
514 l_products_name = sorted(config.APPLICATION.products.keys())
515 l_product_info = src.product.get_products_infos(l_products_name,
520 l_sources_not_present = []
521 generate_mesa_launcher = False # a flag to know if we generate a mesa launcher
522 if ("APPLICATION" in config and
523 "properties" in config.APPLICATION and
524 "mesa_launcher_in_package" in config.APPLICATION.properties and
525 config.APPLICATION.properties.mesa_launcher_in_package == "yes") :
526 generate_mesa_launcher=True
528 for prod_name, prod_info in l_product_info:
529 # skip product with property not_in_package set to yes
530 if src.get_property_in_product_cfg(prod_info, "not_in_package") == "yes":
533 # Add the sources of the products that have the property
534 # sources_in_package : "yes"
535 if src.get_property_in_product_cfg(prod_info,
536 "sources_in_package") == "yes":
537 if os.path.exists(prod_info.source_dir):
538 l_source_dir.append((prod_name, prod_info.source_dir))
540 l_sources_not_present.append(prod_name)
542 # ignore the native and fixed products for install directories
543 if (src.product.product_is_native(prod_info)
544 or src.product.product_is_fixed(prod_info)
545 or not src.product.product_compiles(prod_info)):
547 if src.product.check_installation(config, prod_info):
548 l_install_dir.append((prod_name, prod_info.install_dir))
550 l_not_installed.append(prod_name)
552 # Add also the cpp generated modules (if any)
553 if src.product.product_is_cpp(prod_info):
555 for name_cpp in src.product.get_product_components(prod_info):
556 install_dir = os.path.join(config.APPLICATION.workdir,
557 config.INTERNAL.config.install_dir,
559 if os.path.exists(install_dir):
560 l_install_dir.append((name_cpp, install_dir))
562 l_not_installed.append(name_cpp)
564 # check the name of the directory that (could) contains the binaries
565 # from previous detar
566 binaries_from_detar = os.path.join(
567 config.APPLICATION.workdir,
568 config.INTERNAL.config.binary_dir + config.VARS.dist)
569 if os.path.exists(binaries_from_detar):
571 WARNING: existing binaries directory from previous detar installation:
573 To make new package from this, you have to:
574 1) install binaries in INSTALL directory with the script "install_bin.sh"
575 see README file for more details
576 2) or recompile everything in INSTALL with "sat compile" command
577 this step is long, and requires some linux packages to be installed
579 """ % binaries_from_detar)
581 # Print warning or error if there are some missing products
582 if len(l_not_installed) > 0:
583 text_missing_prods = ""
584 for p_name in l_not_installed:
585 text_missing_prods += "-" + p_name + "\n"
586 if not options.force_creation:
587 msg = _("ERROR: there are missing products installations:")
588 logger.write("%s\n%s" % (src.printcolors.printcError(msg),
593 msg = _("WARNING: there are missing products installations:")
594 logger.write("%s\n%s" % (src.printcolors.printcWarning(msg),
598 # Do the same for sources
599 if len(l_sources_not_present) > 0:
600 text_missing_prods = ""
601 for p_name in l_sources_not_present:
602 text_missing_prods += "-" + p_name + "\n"
603 if not options.force_creation:
604 msg = _("ERROR: there are missing products sources:")
605 logger.write("%s\n%s" % (src.printcolors.printcError(msg),
610 msg = _("WARNING: there are missing products sources:")
611 logger.write("%s\n%s" % (src.printcolors.printcWarning(msg),
615 # construct the name of the directory that will contain the binaries
616 binaries_dir_name = config.INTERNAL.config.binary_dir + config.VARS.dist
618 # construct the correlation table between the product names, there
619 # actual install directories and there install directory in archive
621 for prod_name, install_dir in l_install_dir:
622 path_in_archive = os.path.join(binaries_dir_name, os.path.basename(install_dir))
623 d_products[prod_name + " (bin)"] = (install_dir, path_in_archive)
625 for prod_name, source_dir in l_source_dir:
626 path_in_archive = os.path.join("SOURCES", prod_name)
627 d_products[prod_name + " (sources)"] = (source_dir, path_in_archive)
629 # for packages of SALOME applications including KERNEL,
630 # we produce a salome launcher or a virtual application (depending on salome version)
631 if 'KERNEL' in config.APPLICATION.products:
632 VersionSalome = src.get_salome_version(config)
633 # Case where SALOME has the launcher that uses the SalomeContext API
634 if VersionSalome >= 730:
635 # create the relative launcher and add it to the files to add
636 launcher_name = src.get_launcher_name(config)
637 launcher_package = produce_relative_launcher(config,
642 d_products["launcher"] = (launcher_package, launcher_name)
644 # if the application contains mesa products, we generate in addition to the
645 # classical salome launcher a launcher using mesa and called mesa_salome
646 # (the mesa launcher will be used for remote usage through ssh).
647 if generate_mesa_launcher:
648 #if there is one : store the use_mesa property
649 restore_use_mesa_option=None
650 if ('properties' in config.APPLICATION and
651 'use_mesa' in config.APPLICATION.properties):
652 restore_use_mesa_option = config.APPLICATION.properties.use_mesa
654 # activate mesa property, and generate a mesa launcher
655 src.activate_mesa_property(config) #activate use_mesa property
656 launcher_mesa_name="mesa_"+launcher_name
657 launcher_package_mesa = produce_relative_launcher(config,
662 d_products["launcher (mesa)"] = (launcher_package_mesa, launcher_mesa_name)
664 # if there was a use_mesa value, we restore it
665 # else we set it to the default value "no"
666 if restore_use_mesa_option != None:
667 config.APPLICATION.properties.use_mesa=restore_use_mesa_option
669 config.APPLICATION.properties.use_mesa="no"
672 # if we mix binaries and sources, we add a copy of the launcher,
673 # prefixed with "bin",in order to avoid clashes
674 d_products["launcher (copy)"] = (launcher_package, "bin"+launcher_name)
676 # Provide a script for the creation of an application EDF style
677 appli_script = product_appli_creation_script(config,
682 d_products["appli script"] = (appli_script, "create_appli.py")
684 # Put also the environment file
685 env_file = produce_relative_env_files(config,
690 if src.architecture.is_windows():
691 filename = "env_launch.bat"
693 filename = "env_launch.sh"
694 d_products["environment file"] = (env_file, filename)
698 def source_package(sat, config, logger, options, tmp_working_dir):
699 '''Prepare a dictionary that stores all the needed directories and files to
700 add in a source package.
702 :param config Config: The global configuration.
703 :param logger Logger: the logging instance
704 :param options OptResult: the options of the launched command
705 :param tmp_working_dir str: The temporary local directory containing some
706 specific directories or files needed in the
708 :return: the dictionary that stores all the needed directories and files to
709 add in a source package.
710 {label : (path_on_local_machine, path_in_archive)}
715 # Get all the products that are prepared using an archive
716 # unless ftp mode is specified (in this case the user of the
717 # archive will get the sources through the ftp mode of sat prepare
719 logger.write("Find archive products ... ")
720 d_archives, l_pinfo_vcs = get_archives(config, logger)
721 logger.write("Done\n")
724 if not options.with_vcs and len(l_pinfo_vcs) > 0:
725 # Make archives with the products that are not prepared using an archive
726 # (git, cvs, svn, etc)
727 logger.write("Construct archives for vcs products ... ")
728 d_archives_vcs = get_archives_vcs(l_pinfo_vcs,
733 logger.write("Done\n")
736 logger.write("Create the project ... ")
737 d_project = create_project_for_src_package(config,
741 logger.write("Done\n")
744 tmp_sat = add_salomeTools(config, tmp_working_dir)
745 d_sat = {"salomeTools" : (tmp_sat, "salomeTools")}
747 # Add a sat symbolic link if not win
748 if not src.architecture.is_windows():
749 tmp_satlink_path = os.path.join(tmp_working_dir, 'sat')
753 # In the jobs, os.getcwd() can fail
754 t = config.LOCAL.workdir
755 os.chdir(tmp_working_dir)
756 if os.path.lexists(tmp_satlink_path):
757 os.remove(tmp_satlink_path)
758 os.symlink(os.path.join('salomeTools', 'sat'), 'sat')
761 d_sat["sat link"] = (tmp_satlink_path, "sat")
763 d_source = src.merge_dicts(d_archives, d_archives_vcs, d_project, d_sat)
766 def get_archives(config, logger):
767 '''Find all the products that are get using an archive and all the products
768 that are get using a vcs (git, cvs, svn) repository.
770 :param config Config: The global configuration.
771 :param logger Logger: the logging instance
772 :return: the dictionary {name_product :
773 (local path of its archive, path in the package of its archive )}
774 and the list of specific configuration corresponding to the vcs
778 # Get the list of product informations
779 l_products_name = config.APPLICATION.products.keys()
780 l_product_info = src.product.get_products_infos(l_products_name,
784 for p_name, p_info in l_product_info:
785 # skip product with property not_in_package set to yes
786 if src.get_property_in_product_cfg(p_info, "not_in_package") == "yes":
788 # ignore the native and fixed products
789 if (src.product.product_is_native(p_info)
790 or src.product.product_is_fixed(p_info)):
792 if p_info.get_source == "archive":
793 archive_path = p_info.archive_info.archive_name
794 archive_name = os.path.basename(archive_path)
795 d_archives[p_name] = (archive_path,
796 os.path.join(ARCHIVE_DIR, archive_name))
797 if (src.appli_test_property(config,"pip", "yes") and
798 src.product.product_test_property(p_info,"pip", "yes")):
799 # if pip mode is activated, and product is managed by pip
800 pip_wheels_dir=os.path.join(config.LOCAL.archive_dir,"wheels")
801 pip_wheel_pattern=os.path.join(pip_wheels_dir,
802 "%s-%s*" % (p_info.name, p_info.version))
803 pip_wheel_path=glob.glob(pip_wheel_pattern)
804 msg_pip_not_found="Error in get_archive, pip wheel for "\
805 "product %s-%s was not found in %s directory"
806 msg_pip_two_or_more="Error in get_archive, several pip wheels for "\
807 "product %s-%s were found in %s directory"
808 if len(pip_wheel_path)==0:
809 raise src.SatException(msg_pip_not_found %\
810 (p_info.name, p_info.version, pip_wheels_dir))
811 if len(pip_wheel_path)>1:
812 raise src.SatException(msg_pip_two_or_more %\
813 (p_info.name, p_info.version, pip_wheels_dir))
815 pip_wheel_name=os.path.basename(pip_wheel_path[0])
816 d_archives[p_name+" (pip wheel)"]=(pip_wheel_path[0],
817 os.path.join(ARCHIVE_DIR, "wheels", pip_wheel_name))
819 # this product is not managed by archive,
820 # an archive of the vcs directory will be created by get_archive_vcs
821 l_pinfo_vcs.append((p_name, p_info))
823 return d_archives, l_pinfo_vcs
825 def add_salomeTools(config, tmp_working_dir):
826 '''Prepare a version of salomeTools that has a specific local.pyconf file
827 configured for a source package.
829 :param config Config: The global configuration.
830 :param tmp_working_dir str: The temporary local directory containing some
831 specific directories or files needed in the
833 :return: The path to the local salomeTools directory to add in the package
836 # Copy sat in the temporary working directory
837 sat_tmp_path = src.Path(os.path.join(tmp_working_dir, "salomeTools"))
838 sat_running_path = src.Path(config.VARS.salometoolsway)
839 sat_running_path.copy(sat_tmp_path)
841 # Update the local.pyconf file that contains the path to the project
842 local_pyconf_name = "local.pyconf"
843 local_pyconf_dir = os.path.join(tmp_working_dir, "salomeTools", "data")
844 local_pyconf_file = os.path.join(local_pyconf_dir, local_pyconf_name)
845 # Remove the .pyconf file in the root directory of salomeTools if there is
846 # any. (For example when launching jobs, a pyconf file describing the jobs
847 # can be here and is not useful)
848 files_or_dir_SAT = os.listdir(os.path.join(tmp_working_dir, "salomeTools"))
849 for file_or_dir in files_or_dir_SAT:
850 if file_or_dir.endswith(".pyconf") or file_or_dir.endswith(".txt"):
851 file_path = os.path.join(tmp_working_dir,
856 ff = open(local_pyconf_file, "w")
857 ff.write(LOCAL_TEMPLATE)
860 return sat_tmp_path.path
862 def get_archives_vcs(l_pinfo_vcs, sat, config, logger, tmp_working_dir):
863 '''For sources package that require that all products are get using an
864 archive, one has to create some archive for the vcs products.
865 So this method calls the clean and source command of sat and then create
868 :param l_pinfo_vcs List: The list of specific configuration corresponding to
870 :param sat Sat: The Sat instance that can be called to clean and source the
872 :param config Config: The global configuration.
873 :param logger Logger: the logging instance
874 :param tmp_working_dir str: The temporary local directory containing some
875 specific directories or files needed in the
877 :return: the dictionary that stores all the archives to add in the source
878 package. {label : (path_on_local_machine, path_in_archive)}
881 # clean the source directory of all the vcs products, then use the source
882 # command and thus construct an archive that will not contain the patches
883 l_prod_names = [pn for pn, __ in l_pinfo_vcs]
884 if False: # clean is dangerous in user/SOURCES, fixed in tmp_local_working_dir
885 logger.write(_("\nclean sources\n"))
886 args_clean = config.VARS.application
887 args_clean += " --sources --products "
888 args_clean += ",".join(l_prod_names)
889 logger.write("WARNING: get_archives_vcs clean\n '%s'\n" % args_clean, 1)
890 sat.clean(args_clean, batch=True, verbose=0, logger_add_link = logger)
893 logger.write(_("get sources\n"))
894 args_source = config.VARS.application
895 args_source += " --products "
896 args_source += ",".join(l_prod_names)
897 svgDir = sat.cfg.APPLICATION.workdir
898 tmp_local_working_dir = os.path.join(sat.cfg.APPLICATION.workdir, "tmp_package") # to avoid too much big files in /tmp
899 sat.cfg.APPLICATION.workdir = tmp_local_working_dir
900 # DBG.write("SSS sat config.APPLICATION.workdir", sat.cfg.APPLICATION, True)
901 # DBG.write("sat config id", id(sat.cfg), True)
902 # shit as config is not same id() as for sat.source()
903 # sat.source(args_source, batch=True, verbose=5, logger_add_link = logger)
905 source.run(args_source, sat, logger) #use this mode as runner.cfg reference
907 # make the new archives
909 for pn, pinfo in l_pinfo_vcs:
910 path_archive = make_archive(pn, pinfo, tmp_local_working_dir)
911 logger.write("make archive vcs '%s'\n" % path_archive)
912 d_archives_vcs[pn] = (path_archive,
913 os.path.join(ARCHIVE_DIR, pn + ".tgz"))
914 sat.cfg.APPLICATION.workdir = svgDir
915 # DBG.write("END sat config", sat.cfg.APPLICATION, True)
916 return d_archives_vcs
918 def make_archive(prod_name, prod_info, where):
919 '''Create an archive of a product by searching its source directory.
921 :param prod_name str: The name of the product.
922 :param prod_info Config: The specific configuration corresponding to the
924 :param where str: The path of the repository where to put the resulting
926 :return: The path of the resulting archive
929 path_targz = os.path.join(dir_name, archive_name + PACKAGE_EXT)
930 tar_prod = tarfile.open(path_targz_prod, mode='w:gz')
931 local_path = prod_info.source_dir
932 tar_prod.add(local_path,
934 exclude=exclude_VCS_and_extensions)
936 return path_targz_prod
938 def create_project_for_src_package(config, tmp_working_dir, with_vcs, with_ftp):
939 '''Create a specific project for a source package.
941 :param config Config: The global configuration.
942 :param tmp_working_dir str: The temporary local directory containing some
943 specific directories or files needed in the
945 :param with_vcs boolean: True if the package is with vcs products (not
946 transformed into archive products)
947 :param with_ftp boolean: True if the package use ftp servers to get archives
948 :return: The dictionary
949 {"project" : (produced project, project path in the archive)}
953 # Create in the working temporary directory the full project tree
954 project_tmp_dir = os.path.join(tmp_working_dir, PROJECT_DIR)
955 products_pyconf_tmp_dir = os.path.join(project_tmp_dir,
957 compil_scripts_tmp_dir = os.path.join(project_tmp_dir,
960 env_scripts_tmp_dir = os.path.join(project_tmp_dir,
963 patches_tmp_dir = os.path.join(project_tmp_dir,
966 application_tmp_dir = os.path.join(project_tmp_dir,
968 for directory in [project_tmp_dir,
969 compil_scripts_tmp_dir,
972 application_tmp_dir]:
973 src.ensure_path_exists(directory)
975 # Create the pyconf that contains the information of the project
976 project_pyconf_name = "project.pyconf"
977 project_pyconf_file = os.path.join(project_tmp_dir, project_pyconf_name)
978 ff = open(project_pyconf_file, "w")
979 ff.write(PROJECT_TEMPLATE)
980 if with_ftp and len(config.PATHS.ARCHIVEFTP) > 0:
981 ftp_path='ARCHIVEFTP : "'+config.PATHS.ARCHIVEFTP[0]
982 for ftpserver in config.PATHS.ARCHIVEFTP[1:]:
983 ftp_path=ftp_path+":"+ftpserver
985 ff.write("# ftp servers where to search for prerequisite archives\n")
987 # add licence paths if any
988 if len(config.PATHS.LICENCEPATH) > 0:
989 licence_path='LICENCEPATH : "'+config.PATHS.LICENCEPATH[0]
990 for path in config.PATHS.LICENCEPATH[1:]:
991 licence_path=licence_path+":"+path
993 ff.write("\n# Where to search for licences\n")
994 ff.write(licence_path)
999 # Loop over the products to get there pyconf and all the scripts
1000 # (compilation, environment, patches)
1001 # and create the pyconf file to add to the project
1002 lproducts_name = config.APPLICATION.products.keys()
1003 l_products = src.product.get_products_infos(lproducts_name, config)
1004 for p_name, p_info in l_products:
1005 # skip product with property not_in_package set to yes
1006 if src.get_property_in_product_cfg(p_info, "not_in_package") == "yes":
1008 find_product_scripts_and_pyconf(p_name,
1012 compil_scripts_tmp_dir,
1013 env_scripts_tmp_dir,
1015 products_pyconf_tmp_dir)
1017 find_application_pyconf(config, application_tmp_dir)
1019 d_project = {"project" : (project_tmp_dir, PROJECT_DIR )}
1022 def find_product_scripts_and_pyconf(p_name,
1026 compil_scripts_tmp_dir,
1027 env_scripts_tmp_dir,
1029 products_pyconf_tmp_dir):
1030 '''Create a specific pyconf file for a given product. Get its environment
1031 script, its compilation script and patches and put it in the temporary
1032 working directory. This method is used in the source package in order to
1033 construct the specific project.
1035 :param p_name str: The name of the product.
1036 :param p_info Config: The specific configuration corresponding to the
1038 :param config Config: The global configuration.
1039 :param with_vcs boolean: True if the package is with vcs products (not
1040 transformed into archive products)
1041 :param compil_scripts_tmp_dir str: The path to the temporary compilation
1042 scripts directory of the project.
1043 :param env_scripts_tmp_dir str: The path to the temporary environment script
1044 directory of the project.
1045 :param patches_tmp_dir str: The path to the temporary patch scripts
1046 directory of the project.
1047 :param products_pyconf_tmp_dir str: The path to the temporary product
1048 scripts directory of the project.
1051 # read the pyconf of the product
1052 product_pyconf_cfg = src.pyconf.Config(p_info.from_file)
1054 # find the compilation script if any
1055 if src.product.product_has_script(p_info):
1056 compil_script_path = src.Path(p_info.compil_script)
1057 compil_script_path.copy(compil_scripts_tmp_dir)
1059 # find the environment script if any
1060 if src.product.product_has_env_script(p_info):
1061 env_script_path = src.Path(p_info.environ.env_script)
1062 env_script_path.copy(env_scripts_tmp_dir)
1064 # find the patches if any
1065 if src.product.product_has_patches(p_info):
1066 patches = src.pyconf.Sequence()
1067 for patch_path in p_info.patches:
1068 p_path = src.Path(patch_path)
1069 p_path.copy(patches_tmp_dir)
1070 patches.append(os.path.basename(patch_path), "")
1072 if (not with_vcs) and src.product.product_is_vcs(p_info):
1073 # in non vcs mode, if the product is not archive, then make it become archive.
1075 # depending upon the incremental mode, select impacted sections
1076 if "properties" in p_info and "incremental" in p_info.properties and\
1077 p_info.properties.incremental == "yes":
1078 sections = ["default", "default_win", p_info.section, p_info.section+"_win"]
1080 sections = [p_info.section]
1081 for section in sections:
1082 if section in product_pyconf_cfg and "get_source" in product_pyconf_cfg[section]:
1083 DBG.write("sat package set archive mode to archive for product %s and section %s" %\
1085 product_pyconf_cfg[section].get_source = "archive"
1086 if not "archive_info" in product_pyconf_cfg[section]:
1087 product_pyconf_cfg[section].addMapping("archive_info",
1088 src.pyconf.Mapping(product_pyconf_cfg),
1090 product_pyconf_cfg[section].archive_info.archive_name =\
1091 p_info.name + ".tgz"
1093 # write the pyconf file to the temporary project location
1094 product_tmp_pyconf_path = os.path.join(products_pyconf_tmp_dir,
1096 ff = open(product_tmp_pyconf_path, 'w')
1097 ff.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
1098 product_pyconf_cfg.__save__(ff, 1)
1101 def find_application_pyconf(config, application_tmp_dir):
1102 '''Find the application pyconf file and put it in the specific temporary
1103 directory containing the specific project of a source package.
1105 :param config Config: The global configuration.
1106 :param application_tmp_dir str: The path to the temporary application
1107 scripts directory of the project.
1109 # read the pyconf of the application
1110 application_name = config.VARS.application
1111 application_pyconf_path = src.find_file_in_lpath(
1112 application_name + ".pyconf",
1113 config.PATHS.APPLICATIONPATH)
1114 application_pyconf_cfg = src.pyconf.Config(application_pyconf_path)
1116 # Change the workdir
1117 application_pyconf_cfg.APPLICATION.workdir = src.pyconf.Reference(
1118 application_pyconf_cfg,
1120 'VARS.salometoolsway + $VARS.sep + ".."')
1122 # Prevent from compilation in base
1123 application_pyconf_cfg.APPLICATION.no_base = "yes"
1125 #remove products that are not in config (which were filtered by --without_properties)
1126 for product_name in application_pyconf_cfg.APPLICATION.products.keys():
1127 if product_name not in config.APPLICATION.products.keys():
1128 application_pyconf_cfg.APPLICATION.products.__delitem__(product_name)
1130 # write the pyconf file to the temporary application location
1131 application_tmp_pyconf_path = os.path.join(application_tmp_dir,
1132 application_name + ".pyconf")
1134 ff = open(application_tmp_pyconf_path, 'w')
1135 ff.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
1136 application_pyconf_cfg.__save__(ff, 1)
1139 def sat_package(config, tmp_working_dir, options, logger):
1140 '''Prepare a dictionary that stores all the needed directories and files to
1141 add in a salomeTool package.
1143 :param tmp_working_dir str: The temporary local working directory
1144 :param options OptResult: the options of the launched command
1145 :return: the dictionary that stores all the needed directories and files to
1146 add in a salomeTool package.
1147 {label : (path_on_local_machine, path_in_archive)}
1152 # we include sat himself
1153 d_project["all_sat"]=(config.VARS.salometoolsway, "")
1155 # and we overwrite local.pyconf with a clean wersion.
1156 local_pyconf_tmp_path = os.path.join(tmp_working_dir, "local.pyconf")
1157 local_file_path = os.path.join(config.VARS.datadir, "local.pyconf")
1158 local_cfg = src.pyconf.Config(local_file_path)
1159 local_cfg.PROJECTS.project_file_paths=src.pyconf.Sequence(local_cfg.PROJECTS)
1160 local_cfg.LOCAL["base"] = "default"
1161 local_cfg.LOCAL["workdir"] = "default"
1162 local_cfg.LOCAL["log_dir"] = "default"
1163 local_cfg.LOCAL["archive_dir"] = "default"
1164 local_cfg.LOCAL["VCS"] = "None"
1165 local_cfg.LOCAL["tag"] = src.get_salometool_version(config)
1167 # if the archive contains a project, we write its relative path in local.pyconf
1169 project_arch_path = os.path.join("projects", options.project,
1170 os.path.basename(options.project_file_path))
1171 local_cfg.PROJECTS.project_file_paths.append(project_arch_path, "")
1173 ff = open(local_pyconf_tmp_path, 'w')
1174 local_cfg.__save__(ff, 1)
1176 d_project["local.pyconf"]=(local_pyconf_tmp_path, "data/local.pyconf")
1180 def project_package(config, name_project, project_file_path, ftp_mode, tmp_working_dir, embedded_in_sat, logger):
1181 '''Prepare a dictionary that stores all the needed directories and files to
1182 add in a project package.
1184 :param project_file_path str: The path to the local project.
1185 :param ftp_mode boolean: Do not embed archives, the archive will rely on ftp mode to retrieve them.
1186 :param tmp_working_dir str: The temporary local directory containing some
1187 specific directories or files needed in the
1189 :param embedded_in_sat boolean : the project package is embedded in a sat package
1190 :return: the dictionary that stores all the needed directories and files to
1191 add in a project package.
1192 {label : (path_on_local_machine, path_in_archive)}
1196 # Read the project file and get the directories to add to the package
1199 project_pyconf_cfg = config.PROJECTS.projects.__getattr__(name_project)
1202 WARNING: inexisting config.PROJECTS.projects.%s, try to read now from:\n%s\n""" % (name_project, project_file_path))
1203 project_pyconf_cfg = src.pyconf.Config(project_file_path)
1204 project_pyconf_cfg.PWD = os.path.dirname(project_file_path)
1206 paths = {"APPLICATIONPATH" : "applications",
1207 "PRODUCTPATH" : "products",
1209 "MACHINEPATH" : "machines"}
1211 paths["ARCHIVEPATH"] = "archives"
1213 # Loop over the project paths and add it
1214 project_file_name = os.path.basename(project_file_path)
1216 if path not in project_pyconf_cfg:
1219 dest_path = os.path.join("projects", name_project, paths[path])
1220 project_file_dest = os.path.join("projects", name_project, project_file_name)
1222 dest_path = paths[path]
1223 project_file_dest = project_file_name
1225 # Add the directory to the files to add in the package
1226 d_project[path] = (project_pyconf_cfg[path], dest_path)
1228 # Modify the value of the path in the package
1229 project_pyconf_cfg[path] = src.pyconf.Reference(
1232 'project_path + "/' + paths[path] + '"')
1234 # Modify some values
1235 if "project_path" not in project_pyconf_cfg:
1236 project_pyconf_cfg.addMapping("project_path",
1237 src.pyconf.Mapping(project_pyconf_cfg),
1239 project_pyconf_cfg.project_path = src.pyconf.Reference(project_pyconf_cfg,
1242 # we don't want to export these two fields
1243 project_pyconf_cfg.__delitem__("file_path")
1244 project_pyconf_cfg.__delitem__("PWD")
1246 project_pyconf_cfg.__delitem__("ARCHIVEPATH")
1248 # Write the project pyconf file
1249 project_pyconf_tmp_path = os.path.join(tmp_working_dir, project_file_name)
1250 ff = open(project_pyconf_tmp_path, 'w')
1251 ff.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
1252 project_pyconf_cfg.__save__(ff, 1)
1254 d_project["Project hat file"] = (project_pyconf_tmp_path, project_file_dest)
1258 def add_readme(config, options, where):
1259 readme_path = os.path.join(where, "README")
1260 with codecs.open(readme_path, "w", 'utf-8') as f:
1262 # templates for building the header
1264 # This package was generated with sat $version
1267 # Distribution : $dist
1269 In the following, $$ROOT represents the directory where you have installed
1270 SALOME (the directory where this file is located).
1273 readme_compilation_with_binaries="""
1275 compilation based on the binaries used as prerequisites
1276 =======================================================
1278 If you fail to compile the complete application (for example because
1279 you are not root on your system and cannot install missing packages), you
1280 may try a partial compilation based on the binaries.
1281 For that it is necessary to copy the binaries from BINARIES to INSTALL,
1282 and do some substitutions on cmake and .la files (replace the build directories
1284 The procedure to do it is:
1285 1) Remove or rename INSTALL directory if it exists
1286 2) Execute the shell script install_bin.sh:
1289 3) Use SalomeTool (as explained in Sources section) and compile only the
1290 modules you need to (with -p option)
1293 readme_header_tpl=string.Template(readme_header)
1294 readme_template_path_bin = os.path.join(config.VARS.internal_dir,
1295 "README_BIN.template")
1296 readme_template_path_bin_launcher = os.path.join(config.VARS.internal_dir,
1297 "README_LAUNCHER.template")
1298 readme_template_path_bin_virtapp = os.path.join(config.VARS.internal_dir,
1299 "README_BIN_VIRTUAL_APP.template")
1300 readme_template_path_src = os.path.join(config.VARS.internal_dir,
1301 "README_SRC.template")
1302 readme_template_path_pro = os.path.join(config.VARS.internal_dir,
1303 "README_PROJECT.template")
1304 readme_template_path_sat = os.path.join(config.VARS.internal_dir,
1305 "README_SAT.template")
1307 # prepare substitution dictionary
1309 d['user'] = config.VARS.user
1310 d['date'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
1311 d['version'] = src.get_salometool_version(config)
1312 d['dist'] = config.VARS.dist
1313 f.write(readme_header_tpl.substitute(d)) # write the general header (common)
1315 if options.binaries or options.sources:
1316 d['application'] = config.VARS.application
1317 f.write("# Application: " + d['application'] + "\n")
1318 if 'KERNEL' in config.APPLICATION.products:
1319 VersionSalome = src.get_salome_version(config)
1320 # Case where SALOME has the launcher that uses the SalomeContext API
1321 if VersionSalome >= 730:
1322 d['launcher'] = config.APPLICATION.profile.launcher_name
1324 d['virtual_app'] = 'runAppli' # this info is not used now)
1326 # write the specific sections
1327 if options.binaries:
1328 f.write(src.template.substitute(readme_template_path_bin, d))
1329 if "virtual_app" in d:
1330 f.write(src.template.substitute(readme_template_path_bin_virtapp, d))
1332 f.write(src.template.substitute(readme_template_path_bin_launcher, d))
1335 f.write(src.template.substitute(readme_template_path_src, d))
1337 if options.binaries and options.sources and not src.architecture.is_windows():
1338 f.write(readme_compilation_with_binaries)
1341 f.write(src.template.substitute(readme_template_path_pro, d))
1344 f.write(src.template.substitute(readme_template_path_sat, d))
1348 def update_config(config, prop, value):
1349 '''Remove from config.APPLICATION.products the products that have the property given as input.
1351 :param config Config: The global config.
1352 :param prop str: The property to filter
1353 :param value str: The value of the property to filter
1355 # if there is no APPLICATION (ex sat package -t) : nothing to do
1356 if "APPLICATION" in config:
1357 l_product_to_remove = []
1358 for product_name in config.APPLICATION.products.keys():
1359 prod_cfg = src.product.get_product_config(config, product_name)
1360 if src.get_property_in_product_cfg(prod_cfg, prop) == value:
1361 l_product_to_remove.append(product_name)
1362 for product_name in l_product_to_remove:
1363 config.APPLICATION.products.__delitem__(product_name)
1366 '''method that is called when salomeTools is called with --help option.
1368 :return: The text to display for the package command description.
1372 The package command creates a tar file archive of a product.
1373 There are four kinds of archive, which can be mixed:
1375 1 - The binary archive.
1376 It contains the product installation directories plus a launcher.
1377 2 - The sources archive.
1378 It contains the product archives, a project (the application plus salomeTools).
1379 3 - The project archive.
1380 It contains a project (give the project file path as argument).
1381 4 - The salomeTools archive.
1382 It contains code utility salomeTools.
1385 >> sat package SALOME-master --binaries --sources""")
1387 def run(args, runner, logger):
1388 '''method that is called when salomeTools is called with package parameter.
1392 (options, args) = parser.parse_args(args)
1394 # Check that a type of package is called, and only one
1395 all_option_types = (options.binaries,
1397 options.project not in ["", None],
1400 # Check if no option for package type
1401 if all_option_types.count(True) == 0:
1402 msg = _("Error: Precise a type for the package\nUse one of the "
1403 "following options: --binaries, --sources, --project or"
1405 logger.write(src.printcolors.printcError(msg), 1)
1406 logger.write("\n", 1)
1409 # The repository where to put the package if not Binary or Source
1410 package_default_path = runner.cfg.LOCAL.workdir
1412 # if the package contains binaries or sources:
1413 if options.binaries or options.sources:
1414 # Check that the command has been called with an application
1415 src.check_config_has_application(runner.cfg)
1417 # Display information
1418 logger.write(_("Packaging application %s\n") % src.printcolors.printcLabel(
1419 runner.cfg.VARS.application), 1)
1421 # Get the default directory where to put the packages
1422 package_default_path = os.path.join(runner.cfg.APPLICATION.workdir, "PACKAGE")
1423 src.ensure_path_exists(package_default_path)
1425 # if the package contains a project:
1427 # check that the project is visible by SAT
1428 projectNameFile = options.project + ".pyconf"
1430 for i in runner.cfg.PROJECTS.project_file_paths:
1431 baseName = os.path.basename(i)
1432 if baseName == projectNameFile:
1436 if foundProject is None:
1437 local_path = os.path.join(runner.cfg.VARS.salometoolsway, "data", "local.pyconf")
1438 msg = _("""ERROR: the project %(1)s is not visible by salomeTools.
1442 Please add it in file:
1444 {"1": options.project, "2": "\n ".join(runner.cfg.PROJECTS.project_file_paths), "3": local_path})
1445 logger.write(src.printcolors.printcError(msg), 1)
1446 logger.write("\n", 1)
1449 options.project_file_path = foundProject
1450 src.printcolors.print_value(logger, "Project path", options.project_file_path, 2)
1452 # Remove the products that are filtered by the --without_properties option
1453 if options.without_properties:
1454 app = runner.cfg.APPLICATION
1455 logger.trace("without_properties all products:\n %s\n" % PP.pformat(sorted(app.products.keys())))
1456 prop, value = options.without_properties
1457 update_config(runner.cfg, prop, value)
1458 logger.warning("without_properties selected products:\n %s\n" % PP.pformat(sorted(app.products.keys())))
1460 # Remove from config the products that have the not_in_package property
1461 update_config(runner.cfg, "not_in_package", "yes")
1463 # get the name of the archive or build it
1465 if os.path.basename(options.name) == options.name:
1466 # only a name (not a path)
1467 archive_name = options.name
1468 dir_name = package_default_path
1470 archive_name = os.path.basename(options.name)
1471 dir_name = os.path.dirname(options.name)
1473 # suppress extension
1474 if archive_name[-len(".tgz"):] == ".tgz":
1475 archive_name = archive_name[:-len(".tgz")]
1476 if archive_name[-len(".tar.gz"):] == ".tar.gz":
1477 archive_name = archive_name[:-len(".tar.gz")]
1481 dir_name = package_default_path
1482 if options.binaries or options.sources:
1483 archive_name = runner.cfg.APPLICATION.name
1485 if options.binaries:
1486 archive_name += "-"+runner.cfg.VARS.dist
1489 archive_name += "-SRC"
1490 if options.with_vcs:
1491 archive_name += "-VCS"
1494 archive_name += ("salomeTools_" + src.get_salometool_version(runner.cfg))
1499 project_name = options.project
1500 archive_name += ("satproject_" + project_name)
1502 if len(archive_name)==0: # no option worked
1503 msg = _("Error: Cannot name the archive\n"
1504 " check if at least one of the following options was "
1505 "selected : --binaries, --sources, --project or"
1507 logger.write(src.printcolors.printcError(msg), 1)
1508 logger.write("\n", 1)
1511 path_targz = os.path.join(dir_name, archive_name + PACKAGE_EXT)
1513 src.printcolors.print_value(logger, "Package path", path_targz, 2)
1515 # Create a working directory for all files that are produced during the
1516 # package creation and that will be removed at the end of the command
1517 tmp_working_dir = os.path.join(runner.cfg.VARS.tmp_root, runner.cfg.VARS.datehour)
1518 src.ensure_path_exists(tmp_working_dir)
1519 logger.write("\n", 5)
1520 logger.write(_("The temporary working directory: %s\n" % tmp_working_dir),5)
1522 logger.write("\n", 3)
1524 msg = _("Preparation of files to add to the archive")
1525 logger.write(src.printcolors.printcLabel(msg), 2)
1526 logger.write("\n", 2)
1528 d_files_to_add={} # content of the archive
1530 # a dict to hold paths that will need to be substitute for users recompilations
1531 d_paths_to_substitute={}
1533 if options.binaries:
1534 d_bin_files_to_add = binary_package(runner.cfg,
1538 # for all binaries dir, store the substitution that will be required
1539 # for extra compilations
1540 for key in d_bin_files_to_add:
1541 if key.endswith("(bin)"):
1542 source_dir = d_bin_files_to_add[key][0]
1543 path_in_archive = d_bin_files_to_add[key][1].replace(
1544 runner.cfg.INTERNAL.config.binary_dir + runner.cfg.VARS.dist,
1545 runner.cfg.INTERNAL.config.install_dir)
1546 if os.path.basename(source_dir)==os.path.basename(path_in_archive):
1547 # if basename is the same we will just substitute the dirname
1548 d_paths_to_substitute[os.path.dirname(source_dir)]=\
1549 os.path.dirname(path_in_archive)
1551 d_paths_to_substitute[source_dir]=path_in_archive
1553 d_files_to_add.update(d_bin_files_to_add)
1556 d_files_to_add.update(source_package(runner,
1561 if options.binaries:
1562 # for archives with bin and sources we provide a shell script able to
1563 # install binaries for compilation
1564 file_install_bin=produce_install_bin_file(runner.cfg,logger,
1566 d_paths_to_substitute,
1568 d_files_to_add.update({"install_bin" : (file_install_bin, "install_bin.sh")})
1569 logger.write("substitutions that need to be done later : \n", 5)
1570 logger.write(str(d_paths_to_substitute), 5)
1571 logger.write("\n", 5)
1573 # --salomeTool option is not considered when --sources is selected, as this option
1574 # already brings salomeTool!
1576 d_files_to_add.update(sat_package(runner.cfg, tmp_working_dir,
1580 DBG.write("config for package %s" % project_name, runner.cfg)
1581 d_files_to_add.update(project_package(runner.cfg, project_name, options.project_file_path, options.ftp, tmp_working_dir, options.sat, logger))
1583 if not(d_files_to_add):
1584 msg = _("Error: Empty dictionnary to build the archive!\n")
1585 logger.write(src.printcolors.printcError(msg), 1)
1586 logger.write("\n", 1)
1589 # Add the README file in the package
1590 local_readme_tmp_path = add_readme(runner.cfg, options, tmp_working_dir)
1591 d_files_to_add["README"] = (local_readme_tmp_path, "README")
1593 # Add the additional files of option add_files
1594 if options.add_files:
1595 for file_path in options.add_files:
1596 if not os.path.exists(file_path):
1597 msg = _("WARNING: the file %s is not accessible.\n" % file_path)
1599 file_name = os.path.basename(file_path)
1600 d_files_to_add[file_name] = (file_path, file_name)
1602 logger.write("\n", 2)
1603 logger.write(src.printcolors.printcLabel(_("Actually do the package")), 2)
1604 logger.write("\n", 2)
1605 logger.write("\nfiles and directories to add:\n%s\n\n" % PP.pformat(d_files_to_add), 5)
1609 # Creating the object tarfile
1610 tar = tarfile.open(path_targz, mode='w:gz')
1612 # get the filtering function if needed
1613 filter_function = exclude_VCS_and_extensions
1615 # Add the files to the tarfile object
1616 res = add_files(tar, archive_name, d_files_to_add, logger, f_exclude=filter_function)
1618 except KeyboardInterrupt:
1619 logger.write(src.printcolors.printcError("\nERROR: forced interruption\n"), 1)
1620 logger.write(_("Removing the temporary working directory '%s'... ") % tmp_working_dir, 1)
1621 # remove the working directory
1622 shutil.rmtree(tmp_working_dir)
1623 logger.write(_("OK"), 1)
1624 logger.write(_("\n"), 1)
1627 # case if no application, only package sat as 'sat package -t'
1629 app = runner.cfg.APPLICATION
1633 # unconditionaly remove the tmp_local_working_dir
1635 tmp_local_working_dir = os.path.join(app.workdir, "tmp_package")
1636 if os.path.isdir(tmp_local_working_dir):
1637 shutil.rmtree(tmp_local_working_dir)
1639 # remove the tmp directory, unless user has registered as developer
1640 if os.path.isdir(tmp_working_dir) and (not DBG.isDeveloper()):
1641 shutil.rmtree(tmp_working_dir)
1643 # Print again the path of the package
1644 logger.write("\n", 2)
1645 src.printcolors.print_value(logger, "Package path", path_targz, 2)