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
30 from application import get_SALOME_modules
31 import src.debug as DBG
38 ARCHIVE_DIR = "ARCHIVES"
39 PROJECT_DIR = "PROJECT"
41 IGNORED_DIRS = [".git", ".svn"]
42 IGNORED_EXTENSIONS = []
44 PROJECT_TEMPLATE = """#!/usr/bin/env python
47 # The path to the archive root directory
48 root_path : $PWD + "/../"
50 project_path : $PWD + "/"
52 # Where to search the archives of the products
53 ARCHIVEPATH : $root_path + "ARCHIVES"
54 # Where to search the pyconf of the applications
55 APPLICATIONPATH : $project_path + "applications/"
56 # Where to search the pyconf of the products
57 PRODUCTPATH : $project_path + "products/"
58 # Where to search the pyconf of the jobs of the project
59 JOBPATH : $project_path + "jobs/"
60 # Where to search the pyconf of the machines of the project
61 MACHINEPATH : $project_path + "machines/"
64 LOCAL_TEMPLATE = ("""#!/usr/bin/env python
72 archive_dir : 'default'
79 project_file_paths : [$VARS.salometoolsway + $VARS.sep + \"..\" + $VARS.sep"""
80 """ + \"""" + PROJECT_DIR + """\" + $VARS.sep + "project.pyconf"]
84 # Define all possible option for the package command : sat package <options>
85 parser = src.options.Options()
86 parser.add_option('b', 'binaries', 'boolean', 'binaries',
87 _('Optional: Produce a binary package.'), False)
88 parser.add_option('f', 'force_creation', 'boolean', 'force_creation',
89 _('Optional: Only binary package: produce the archive even if '
90 'there are some missing products.'), False)
91 parser.add_option('s', 'sources', 'boolean', 'sources',
92 _('Optional: Produce a compilable archive of the sources of the '
93 'application.'), False)
94 parser.add_option('', 'with_vcs', 'boolean', 'with_vcs',
95 _('Optional: Do not make archive for products in VCS mode (git, cvs, svn). '
96 'Sat prepare will use VCS mode instead to retrieve them'),
98 parser.add_option('', 'ftp', 'boolean', 'ftp',
99 _('Optional: Do not embed archives for products in archive mode.'
100 'Sat prepare will use ftp instead to retrieve them'),
102 parser.add_option('p', 'project', 'string', 'project',
103 _('Optional: Produce an archive that contains a project.'), "")
104 parser.add_option('t', 'salometools', 'boolean', 'sat',
105 _('Optional: Produce an archive that contains salomeTools.'), False)
106 parser.add_option('n', 'name', 'string', 'name',
107 _('Optional: The name or full path of the archive.'), None)
108 parser.add_option('', 'add_files', 'list2', 'add_files',
109 _('Optional: The list of additional files to add to the archive.'), [])
110 parser.add_option('', 'without_commercial', 'boolean', 'without_commercial',
111 _('Optional: do not add commercial licence.'), False)
112 parser.add_option('', 'without_properties', 'properties', 'without_properties',
113 _('Optional: Filter the products by their properties.\n\tSyntax: '
114 '--without_properties <property>:<value>'))
117 def add_files(tar, name_archive, d_content, logger, f_exclude=None):
118 '''Create an archive containing all directories and files that are given in
119 the d_content argument.
121 :param tar tarfile: The tarfile instance used to make the archive.
122 :param name_archive str: The name of the archive to make.
123 :param d_content dict: The dictionary that contain all directories and files
124 to add in the archive.
126 (path_on_local_machine, path_in_archive)
127 :param logger Logger: the logging instance
128 :param f_exclude Function: the function that filters
129 :return: 0 if success, 1 if not.
132 # get the max length of the messages in order to make the display
133 max_len = len(max(d_content.keys(), key=len))
136 # loop over each directory or file stored in the d_content dictionary
137 names = sorted(d_content.keys())
138 DBG.write("add tar names", names)
141 # display information
142 len_points = max_len - len(name) + 3
143 local_path, archive_path = d_content[name]
144 in_archive = os.path.join(name_archive, archive_path)
145 logger.write(name + " " + len_points * "." + " "+ in_archive + " ", 3)
146 # Get the local path and the path in archive
147 # of the directory or file to add
148 # Add it in the archive
150 tar.add(local_path, arcname=in_archive, exclude=f_exclude)
151 logger.write(src.printcolors.printcSuccess(_("OK")), 3)
152 except Exception as e:
153 logger.write(src.printcolors.printcError(_("KO ")), 3)
154 logger.write(str(e), 3)
156 logger.write("\n", 3)
159 def exclude_VCS_and_extensions(filename):
160 ''' The function that is used to exclude from package the link to the
161 VCS repositories (like .git)
163 :param filename Str: The filname to exclude (or not).
164 :return: True if the file has to be exclude
167 for dir_name in IGNORED_DIRS:
168 if dir_name in filename:
170 for extension in IGNORED_EXTENSIONS:
171 if filename.endswith(extension):
175 def produce_relative_launcher(config,
180 with_commercial=True):
181 '''Create a specific SALOME launcher for the binary package. This launcher
184 :param config Config: The global configuration.
185 :param logger Logger: the logging instance
186 :param file_dir str: the directory where to put the launcher
187 :param file_name str: The launcher name
188 :param binaries_dir_name str: the name of the repository where the binaries
190 :return: the path of the produced launcher
194 # get KERNEL installation path
195 kernel_root_dir = os.path.join(binaries_dir_name, "KERNEL")
197 # set kernel bin dir (considering fhs property)
198 kernel_cfg = src.product.get_product_config(config, "KERNEL")
199 if src.get_property_in_product_cfg(kernel_cfg, "fhs"):
200 bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin")
202 bin_kernel_install_dir = os.path.join(kernel_root_dir,"bin","salome")
204 # check if the application contains an application module
205 l_product_info = src.product.get_products_infos(config.APPLICATION.products.keys(), config)
206 salome_application_name="Not defined"
207 for prod_name, prod_info in l_product_info:
208 # look for a salome application
209 if src.get_property_in_product_cfg(prod_info, "is_salome_application") == "yes":
210 salome_application_name=prod_info.name
212 # if the application contains an application module, we set ABSOLUTE_APPLI_PATH to it
213 # if not we set it to KERNEL_INSTALL_DIR, which is sufficient, except for salome test
214 if salome_application_name == "Not defined":
215 app_root_dir=kernel_root_dir
217 app_root_dir=os.path.join(binaries_dir_name, salome_application_name)
219 # Get the launcher template and do substitutions
220 if "python3" in config.APPLICATION and config.APPLICATION.python3 == "yes":
221 withProfile = src.fileEnviron.withProfile3
223 withProfile = src.fileEnviron.withProfile
225 withProfile = withProfile.replace(
226 "ABSOLUTE_APPLI_PATH'] = 'KERNEL_INSTALL_DIR'",
227 "ABSOLUTE_APPLI_PATH'] = out_dir_Path + '" + config.VARS.sep + app_root_dir + "'")
228 withProfile = withProfile.replace(
229 " 'BIN_KERNEL_INSTALL_DIR'",
230 " out_dir_Path + '" + config.VARS.sep + bin_kernel_install_dir + "'")
232 before, after = withProfile.split("# here your local standalone environment\n")
234 # create an environment file writer
235 writer = src.environment.FileEnvWriter(config,
240 filepath = os.path.join(file_dir, file_name)
241 # open the file and write into it
242 launch_file = open(filepath, "w")
243 launch_file.write(before)
245 writer.write_cfgForPy_file(launch_file,
246 for_package = binaries_dir_name,
247 with_commercial=with_commercial)
248 launch_file.write(after)
251 # Little hack to put out_dir_Path outside the strings
252 src.replace_in_file(filepath, 'r"out_dir_Path', 'out_dir_Path + r"' )
254 # A hack to put a call to a file for distene licence.
255 # It does nothing to an application that has no distene product
256 hack_for_distene_licence(filepath)
258 # change the rights in order to make the file executable for everybody
270 def hack_for_distene_licence(filepath):
271 '''Replace the distene licence env variable by a call to a file.
273 :param filepath Str: The path to the launcher to modify.
275 shutil.move(filepath, filepath + "_old")
277 filein = filepath + "_old"
278 fin = open(filein, "r")
279 fout = open(fileout, "w")
280 text = fin.readlines()
281 # Find the Distene section
283 for i,line in enumerate(text):
284 if "# Set DISTENE License" in line:
288 # No distene product, there is nothing to do
294 del text[num_line +1]
295 del text[num_line +1]
296 text_to_insert =""" import imp
298 distene = imp.load_source('distene_licence', '/data/tmpsalome/salome/prerequis/install/LICENSE/dlim8.var.py')
299 distene.set_distene_variables(context)
302 text.insert(num_line + 1, text_to_insert)
309 def produce_relative_env_files(config,
313 '''Create some specific environment files for the binary package. These
314 files use relative paths.
316 :param config Config: The global configuration.
317 :param logger Logger: the logging instance
318 :param file_dir str: the directory where to put the files
319 :param binaries_dir_name str: the name of the repository where the binaries
321 :return: the list of path of the produced environment files
324 # create an environment file writer
325 writer = src.environment.FileEnvWriter(config,
331 filepath = writer.write_env_file("env_launch.sh",
334 for_package = binaries_dir_name)
336 # Little hack to put out_dir_Path as environment variable
337 src.replace_in_file(filepath, '"out_dir_Path', '"${out_dir_Path}' )
339 # change the rights in order to make the file executable for everybody
351 def produce_install_bin_file(config,
356 '''Create a bash shell script which do substitutions in BIRARIES dir
357 in order to use it for extra compilations.
359 :param config Config: The global configuration.
360 :param logger Logger: the logging instance
361 :param file_dir str: the directory where to put the files
362 :param d_sub, dict: the dictionnary that contains the substitutions to be done
363 :param file_name str: the name of the install script file
364 :return: the produced file
368 filepath = os.path.join(file_dir, file_name)
369 # open the file and write into it
370 # use codec utf-8 as sat variables are in unicode
371 with codecs.open(filepath, "w", 'utf-8') as installbin_file:
372 installbin_template_path = os.path.join(config.VARS.internal_dir,
373 "INSTALL_BIN.template")
375 # build the name of the directory that will contain the binaries
376 binaries_dir_name = "BINARIES-" + config.VARS.dist
377 # build the substitution loop
378 loop_cmd = "for f in $(grep -RIl"
380 loop_cmd += " -e "+ key
381 loop_cmd += ' INSTALL); do\n sed -i "\n'
383 loop_cmd += " s?" + key + "?$(pwd)/" + d_sub[key] + "?g\n"
384 loop_cmd += ' " $f\ndone'
387 d["BINARIES_DIR"] = binaries_dir_name
388 d["SUBSTITUTION_LOOP"]=loop_cmd
390 # substitute the template and write it in file
391 content=src.template.substitute(installbin_template_path, d)
392 installbin_file.write(content)
393 # change the rights in order to make the file executable for everybody
405 def product_appli_creation_script(config,
409 '''Create a script that can produce an application (EDF style) in the binary
412 :param config Config: The global configuration.
413 :param logger Logger: the logging instance
414 :param file_dir str: the directory where to put the file
415 :param binaries_dir_name str: the name of the repository where the binaries
417 :return: the path of the produced script file
420 template_name = "create_appli.py.for_bin_packages.template"
421 template_path = os.path.join(config.VARS.internal_dir, template_name)
422 text_to_fill = open(template_path, "r").read()
423 text_to_fill = text_to_fill.replace("TO BE FILLED 1",
424 '"' + binaries_dir_name + '"')
427 for product_name in get_SALOME_modules(config):
428 product_info = src.product.get_product_config(config, product_name)
430 if src.product.product_is_smesh_plugin(product_info):
433 if 'install_dir' in product_info and bool(product_info.install_dir):
434 if src.product.product_is_cpp(product_info):
436 for cpp_name in src.product.get_product_components(product_info):
437 line_to_add = ("<module name=\"" +
439 "\" gui=\"yes\" path=\"''' + "
440 "os.path.join(dir_bin_name, \"" +
441 cpp_name + "\") + '''\"/>")
444 line_to_add = ("<module name=\"" +
446 "\" gui=\"yes\" path=\"''' + "
447 "os.path.join(dir_bin_name, \"" +
448 product_name + "\") + '''\"/>")
449 text_to_add += line_to_add + "\n"
451 filled_text = text_to_fill.replace("TO BE FILLED 2", text_to_add)
453 tmp_file_path = os.path.join(file_dir, "create_appli.py")
454 ff = open(tmp_file_path, "w")
455 ff.write(filled_text)
458 # change the rights in order to make the file executable for everybody
459 os.chmod(tmp_file_path,
470 def binary_package(config, logger, options, tmp_working_dir):
471 '''Prepare a dictionary that stores all the needed directories and files to
472 add in a binary package.
474 :param config Config: The global configuration.
475 :param logger Logger: the logging instance
476 :param options OptResult: the options of the launched command
477 :param tmp_working_dir str: The temporary local directory containing some
478 specific directories or files needed in the
480 :return: the dictionary that stores all the needed directories and files to
481 add in a binary package.
482 {label : (path_on_local_machine, path_in_archive)}
486 # Get the list of product installation to add to the archive
487 l_products_name = sorted(config.APPLICATION.products.keys())
488 l_product_info = src.product.get_products_infos(l_products_name,
493 l_sources_not_present = []
494 generate_mesa_launcher = False # a flag to know if we generate a mesa launcher
495 if ("APPLICATION" in config and
496 "properties" in config.APPLICATION and
497 "mesa_launcher_in_package" in config.APPLICATION.properties and
498 config.APPLICATION.properties.mesa_launcher_in_package == "yes") :
499 generate_mesa_launcher=True
501 for prod_name, prod_info in l_product_info:
502 # skip product with property not_in_package set to yes
503 if src.get_property_in_product_cfg(prod_info, "not_in_package") == "yes":
506 # Add the sources of the products that have the property
507 # sources_in_package : "yes"
508 if src.get_property_in_product_cfg(prod_info,
509 "sources_in_package") == "yes":
510 if os.path.exists(prod_info.source_dir):
511 l_source_dir.append((prod_name, prod_info.source_dir))
513 l_sources_not_present.append(prod_name)
515 # ignore the native and fixed products for install directories
516 if (src.product.product_is_native(prod_info)
517 or src.product.product_is_fixed(prod_info)
518 or not src.product.product_compiles(prod_info)):
520 if src.product.check_installation(prod_info):
521 l_install_dir.append((prod_name, prod_info.install_dir))
523 l_not_installed.append(prod_name)
525 # Add also the cpp generated modules (if any)
526 if src.product.product_is_cpp(prod_info):
528 for name_cpp in src.product.get_product_components(prod_info):
529 install_dir = os.path.join(config.APPLICATION.workdir,
531 if os.path.exists(install_dir):
532 l_install_dir.append((name_cpp, install_dir))
534 l_not_installed.append(name_cpp)
536 # check the name of the directory that (could) contains the binaries
537 # from previous detar
538 binaries_from_detar = os.path.join(config.APPLICATION.workdir, "BINARIES-" + config.VARS.dist)
539 if os.path.exists(binaries_from_detar):
541 WARNING: existing binaries directory from previous detar installation:
543 To make new package from this, you have to:
544 1) install binaries in INSTALL directory with the script "install_bin.sh"
545 see README file for more details
546 2) or recompile everything in INSTALL with "sat compile" command
547 this step is long, and requires some linux packages to be installed
549 """ % binaries_from_detar)
551 # Print warning or error if there are some missing products
552 if len(l_not_installed) > 0:
553 text_missing_prods = ""
554 for p_name in l_not_installed:
555 text_missing_prods += "-" + p_name + "\n"
556 if not options.force_creation:
557 msg = _("ERROR: there are missing products installations:")
558 logger.write("%s\n%s" % (src.printcolors.printcError(msg),
563 msg = _("WARNING: there are missing products installations:")
564 logger.write("%s\n%s" % (src.printcolors.printcWarning(msg),
568 # Do the same for sources
569 if len(l_sources_not_present) > 0:
570 text_missing_prods = ""
571 for p_name in l_sources_not_present:
572 text_missing_prods += "-" + p_name + "\n"
573 if not options.force_creation:
574 msg = _("ERROR: there are missing products sources:")
575 logger.write("%s\n%s" % (src.printcolors.printcError(msg),
580 msg = _("WARNING: there are missing products sources:")
581 logger.write("%s\n%s" % (src.printcolors.printcWarning(msg),
585 # construct the name of the directory that will contain the binaries
586 binaries_dir_name = "BINARIES-" + config.VARS.dist
588 # construct the correlation table between the product names, there
589 # actual install directories and there install directory in archive
591 for prod_name, install_dir in l_install_dir:
592 path_in_archive = os.path.join(binaries_dir_name, prod_name)
593 d_products[prod_name + " (bin)"] = (install_dir, path_in_archive)
595 for prod_name, source_dir in l_source_dir:
596 path_in_archive = os.path.join("SOURCES", prod_name)
597 d_products[prod_name + " (sources)"] = (source_dir, path_in_archive)
599 # for packages of SALOME applications including KERNEL,
600 # we produce a salome launcher or a virtual application (depending on salome version)
601 if 'KERNEL' in config.APPLICATION.products:
602 VersionSalome = src.get_salome_version(config)
603 # Case where SALOME has the launcher that uses the SalomeContext API
604 if VersionSalome >= 730:
605 # create the relative launcher and add it to the files to add
606 launcher_name = src.get_launcher_name(config)
607 launcher_package = produce_relative_launcher(config,
612 not(options.without_commercial))
613 d_products["launcher"] = (launcher_package, launcher_name)
615 # if the application contains mesa products, we generate in addition to the
616 # classical salome launcher a launcher using mesa and called mesa_salome
617 # (the mesa launcher will be used for remote usage through ssh).
618 if generate_mesa_launcher:
619 #if there is one : store the use_mesa property
620 restore_use_mesa_option=None
621 if ('properties' in config.APPLICATION and
622 'use_mesa' in config.APPLICATION.properties):
623 restore_use_mesa_option = config.APPLICATION.properties.use_mesa
625 # activate mesa property, and generate a mesa launcher
626 src.activate_mesa_property(config) #activate use_mesa property
627 launcher_mesa_name="mesa_"+launcher_name
628 launcher_package_mesa = produce_relative_launcher(config,
633 not(options.without_commercial))
634 d_products["launcher (mesa)"] = (launcher_package_mesa, launcher_mesa_name)
636 # if there was a use_mesa value, we restore it
637 # else we set it to the default value "no"
638 if restore_use_mesa_option != None:
639 config.APPLICATION.properties.use_mesa=restore_use_mesa_option
641 config.APPLICATION.properties.use_mesa="no"
644 # if we mix binaries and sources, we add a copy of the launcher,
645 # prefixed with "bin",in order to avoid clashes
646 d_products["launcher (copy)"] = (launcher_package, "bin"+launcher_name)
648 # Provide a script for the creation of an application EDF style
649 appli_script = product_appli_creation_script(config,
654 d_products["appli script"] = (appli_script, "create_appli.py")
656 # Put also the environment file
657 env_file = produce_relative_env_files(config,
662 d_products["environment file"] = (env_file, "env_launch.sh")
666 def source_package(sat, config, logger, options, tmp_working_dir):
667 '''Prepare a dictionary that stores all the needed directories and files to
668 add in a source package.
670 :param config Config: The global configuration.
671 :param logger Logger: the logging instance
672 :param options OptResult: the options of the launched command
673 :param tmp_working_dir str: The temporary local directory containing some
674 specific directories or files needed in the
676 :return: the dictionary that stores all the needed directories and files to
677 add in a source package.
678 {label : (path_on_local_machine, path_in_archive)}
683 # Get all the products that are prepared using an archive
684 # unless ftp mode is specified (in this case the user of the
685 # archive will get the sources through the ftp mode of sat prepare
687 logger.write("Find archive products ... ")
688 d_archives, l_pinfo_vcs = get_archives(config, logger)
689 logger.write("Done\n")
692 if not options.with_vcs and len(l_pinfo_vcs) > 0:
693 # Make archives with the products that are not prepared using an archive
694 # (git, cvs, svn, etc)
695 logger.write("Construct archives for vcs products ... ")
696 d_archives_vcs = get_archives_vcs(l_pinfo_vcs,
701 logger.write("Done\n")
704 logger.write("Create the project ... ")
705 d_project = create_project_for_src_package(config,
709 logger.write("Done\n")
712 tmp_sat = add_salomeTools(config, tmp_working_dir)
713 d_sat = {"salomeTools" : (tmp_sat, "salomeTools")}
715 # Add a sat symbolic link if not win
716 if not src.architecture.is_windows():
717 tmp_satlink_path = os.path.join(tmp_working_dir, 'sat')
721 # In the jobs, os.getcwd() can fail
722 t = config.LOCAL.workdir
723 os.chdir(tmp_working_dir)
724 if os.path.lexists(tmp_satlink_path):
725 os.remove(tmp_satlink_path)
726 os.symlink(os.path.join('salomeTools', 'sat'), 'sat')
729 d_sat["sat link"] = (tmp_satlink_path, "sat")
731 d_source = src.merge_dicts(d_archives, d_archives_vcs, d_project, d_sat)
734 def get_archives(config, logger):
735 '''Find all the products that are get using an archive and all the products
736 that are get using a vcs (git, cvs, svn) repository.
738 :param config Config: The global configuration.
739 :param logger Logger: the logging instance
740 :return: the dictionary {name_product :
741 (local path of its archive, path in the package of its archive )}
742 and the list of specific configuration corresponding to the vcs
746 # Get the list of product informations
747 l_products_name = config.APPLICATION.products.keys()
748 l_product_info = src.product.get_products_infos(l_products_name,
752 for p_name, p_info in l_product_info:
753 # skip product with property not_in_package set to yes
754 if src.get_property_in_product_cfg(p_info, "not_in_package") == "yes":
756 # ignore the native and fixed products
757 if (src.product.product_is_native(p_info)
758 or src.product.product_is_fixed(p_info)):
760 if p_info.get_source == "archive":
761 archive_path = p_info.archive_info.archive_name
762 archive_name = os.path.basename(archive_path)
764 l_pinfo_vcs.append((p_name, p_info))
766 d_archives[p_name] = (archive_path,
767 os.path.join(ARCHIVE_DIR, archive_name))
768 return d_archives, l_pinfo_vcs
770 def add_salomeTools(config, tmp_working_dir):
771 '''Prepare a version of salomeTools that has a specific local.pyconf file
772 configured for a source package.
774 :param config Config: The global configuration.
775 :param tmp_working_dir str: The temporary local directory containing some
776 specific directories or files needed in the
778 :return: The path to the local salomeTools directory to add in the package
781 # Copy sat in the temporary working directory
782 sat_tmp_path = src.Path(os.path.join(tmp_working_dir, "salomeTools"))
783 sat_running_path = src.Path(config.VARS.salometoolsway)
784 sat_running_path.copy(sat_tmp_path)
786 # Update the local.pyconf file that contains the path to the project
787 local_pyconf_name = "local.pyconf"
788 local_pyconf_dir = os.path.join(tmp_working_dir, "salomeTools", "data")
789 local_pyconf_file = os.path.join(local_pyconf_dir, local_pyconf_name)
790 # Remove the .pyconf file in the root directory of salomeTools if there is
791 # any. (For example when launching jobs, a pyconf file describing the jobs
792 # can be here and is not useful)
793 files_or_dir_SAT = os.listdir(os.path.join(tmp_working_dir, "salomeTools"))
794 for file_or_dir in files_or_dir_SAT:
795 if file_or_dir.endswith(".pyconf") or file_or_dir.endswith(".txt"):
796 file_path = os.path.join(tmp_working_dir,
801 ff = open(local_pyconf_file, "w")
802 ff.write(LOCAL_TEMPLATE)
805 return sat_tmp_path.path
807 def get_archives_vcs(l_pinfo_vcs, sat, config, logger, tmp_working_dir):
808 '''For sources package that require that all products are get using an
809 archive, one has to create some archive for the vcs products.
810 So this method calls the clean and source command of sat and then create
813 :param l_pinfo_vcs List: The list of specific configuration corresponding to
815 :param sat Sat: The Sat instance that can be called to clean and source the
817 :param config Config: The global configuration.
818 :param logger Logger: the logging instance
819 :param tmp_working_dir str: The temporary local directory containing some
820 specific directories or files needed in the
822 :return: the dictionary that stores all the archives to add in the source
823 package. {label : (path_on_local_machine, path_in_archive)}
826 # clean the source directory of all the vcs products, then use the source
827 # command and thus construct an archive that will not contain the patches
828 l_prod_names = [pn for pn, __ in l_pinfo_vcs]
829 if False: # clean is dangerous in user/SOURCES, fixed in tmp_local_working_dir
830 logger.write(_("\nclean sources\n"))
831 args_clean = config.VARS.application
832 args_clean += " --sources --products "
833 args_clean += ",".join(l_prod_names)
834 logger.write("WARNING: get_archives_vcs clean\n '%s'\n" % args_clean, 1)
835 sat.clean(args_clean, batch=True, verbose=0, logger_add_link = logger)
838 logger.write(_("get sources\n"))
839 args_source = config.VARS.application
840 args_source += " --products "
841 args_source += ",".join(l_prod_names)
842 svgDir = sat.cfg.APPLICATION.workdir
843 tmp_local_working_dir = os.path.join(sat.cfg.APPLICATION.workdir, "tmp_package") # to avoid too much big files in /tmp
844 sat.cfg.APPLICATION.workdir = tmp_local_working_dir
845 # DBG.write("SSS sat config.APPLICATION.workdir", sat.cfg.APPLICATION, True)
846 # DBG.write("sat config id", id(sat.cfg), True)
847 # shit as config is not same id() as for sat.source()
848 # sat.source(args_source, batch=True, verbose=5, logger_add_link = logger)
850 source.run(args_source, sat, logger) #use this mode as runner.cfg reference
852 # make the new archives
854 for pn, pinfo in l_pinfo_vcs:
855 path_archive = make_archive(pn, pinfo, tmp_local_working_dir)
856 logger.write("make archive vcs '%s'\n" % path_archive)
857 d_archives_vcs[pn] = (path_archive,
858 os.path.join(ARCHIVE_DIR, pn + ".tgz"))
859 sat.cfg.APPLICATION.workdir = svgDir
860 # DBG.write("END sat config", sat.cfg.APPLICATION, True)
861 return d_archives_vcs
863 def make_archive(prod_name, prod_info, where):
864 '''Create an archive of a product by searching its source directory.
866 :param prod_name str: The name of the product.
867 :param prod_info Config: The specific configuration corresponding to the
869 :param where str: The path of the repository where to put the resulting
871 :return: The path of the resulting archive
874 path_targz_prod = os.path.join(where, prod_name + ".tgz")
875 tar_prod = tarfile.open(path_targz_prod, mode='w:gz')
876 local_path = prod_info.source_dir
877 tar_prod.add(local_path,
879 exclude=exclude_VCS_and_extensions)
881 return path_targz_prod
883 def create_project_for_src_package(config, tmp_working_dir, with_vcs, with_ftp):
884 '''Create a specific project for a source package.
886 :param config Config: The global configuration.
887 :param tmp_working_dir str: The temporary local directory containing some
888 specific directories or files needed in the
890 :param with_vcs boolean: True if the package is with vcs products (not
891 transformed into archive products)
892 :param with_ftp boolean: True if the package use ftp servers to get archives
893 :return: The dictionary
894 {"project" : (produced project, project path in the archive)}
898 # Create in the working temporary directory the full project tree
899 project_tmp_dir = os.path.join(tmp_working_dir, PROJECT_DIR)
900 products_pyconf_tmp_dir = os.path.join(project_tmp_dir,
902 compil_scripts_tmp_dir = os.path.join(project_tmp_dir,
905 env_scripts_tmp_dir = os.path.join(project_tmp_dir,
908 patches_tmp_dir = os.path.join(project_tmp_dir,
911 application_tmp_dir = os.path.join(project_tmp_dir,
913 for directory in [project_tmp_dir,
914 compil_scripts_tmp_dir,
917 application_tmp_dir]:
918 src.ensure_path_exists(directory)
920 # Create the pyconf that contains the information of the project
921 project_pyconf_name = "project.pyconf"
922 project_pyconf_file = os.path.join(project_tmp_dir, project_pyconf_name)
923 ff = open(project_pyconf_file, "w")
924 ff.write(PROJECT_TEMPLATE)
926 ftp_path='ARCHIVEFTP : "'+config.PATHS.ARCHIVEFTP[0]
927 for ftpserver in config.PATHS.ARCHIVEFTP[1:]:
928 ftp_path=ftp_path+":"+ftpserver
930 ff.write("# ftp servers where to search for prerequisite archives\n")
935 # Loop over the products to get there pyconf and all the scripts
936 # (compilation, environment, patches)
937 # and create the pyconf file to add to the project
938 lproducts_name = config.APPLICATION.products.keys()
939 l_products = src.product.get_products_infos(lproducts_name, config)
940 for p_name, p_info in l_products:
941 # skip product with property not_in_package set to yes
942 if src.get_property_in_product_cfg(p_info, "not_in_package") == "yes":
944 find_product_scripts_and_pyconf(p_name,
948 compil_scripts_tmp_dir,
951 products_pyconf_tmp_dir)
953 find_application_pyconf(config, application_tmp_dir)
955 d_project = {"project" : (project_tmp_dir, PROJECT_DIR )}
958 def find_product_scripts_and_pyconf(p_name,
962 compil_scripts_tmp_dir,
965 products_pyconf_tmp_dir):
966 '''Create a specific pyconf file for a given product. Get its environment
967 script, its compilation script and patches and put it in the temporary
968 working directory. This method is used in the source package in order to
969 construct the specific project.
971 :param p_name str: The name of the product.
972 :param p_info Config: The specific configuration corresponding to the
974 :param config Config: The global configuration.
975 :param with_vcs boolean: True if the package is with vcs products (not
976 transformed into archive products)
977 :param compil_scripts_tmp_dir str: The path to the temporary compilation
978 scripts directory of the project.
979 :param env_scripts_tmp_dir str: The path to the temporary environment script
980 directory of the project.
981 :param patches_tmp_dir str: The path to the temporary patch scripts
982 directory of the project.
983 :param products_pyconf_tmp_dir str: The path to the temporary product
984 scripts directory of the project.
987 # read the pyconf of the product
988 product_pyconf_path = src.find_file_in_lpath(p_name + ".pyconf",
989 config.PATHS.PRODUCTPATH)
990 product_pyconf_cfg = src.pyconf.Config(product_pyconf_path)
992 # find the compilation script if any
993 if src.product.product_has_script(p_info):
994 compil_script_path = src.Path(p_info.compil_script)
995 compil_script_path.copy(compil_scripts_tmp_dir)
996 product_pyconf_cfg[p_info.section].compil_script = os.path.basename(
997 p_info.compil_script)
998 # find the environment script if any
999 if src.product.product_has_env_script(p_info):
1000 env_script_path = src.Path(p_info.environ.env_script)
1001 env_script_path.copy(env_scripts_tmp_dir)
1002 product_pyconf_cfg[p_info.section].environ.env_script = os.path.basename(
1003 p_info.environ.env_script)
1004 # find the patches if any
1005 if src.product.product_has_patches(p_info):
1006 patches = src.pyconf.Sequence()
1007 for patch_path in p_info.patches:
1008 p_path = src.Path(patch_path)
1009 p_path.copy(patches_tmp_dir)
1010 patches.append(os.path.basename(patch_path), "")
1012 product_pyconf_cfg[p_info.section].patches = patches
1015 # put in the pyconf file the resolved values
1016 for info in ["git_info", "cvs_info", "svn_info"]:
1018 for key in p_info[info]:
1019 product_pyconf_cfg[p_info.section][info][key] = p_info[
1022 # if the product is not archive, then make it become archive.
1023 if src.product.product_is_vcs(p_info):
1024 product_pyconf_cfg[p_info.section].get_source = "archive"
1025 if not "archive_info" in product_pyconf_cfg[p_info.section]:
1026 product_pyconf_cfg[p_info.section].addMapping("archive_info",
1027 src.pyconf.Mapping(product_pyconf_cfg),
1029 product_pyconf_cfg[p_info.section
1030 ].archive_info.archive_name = p_info.name + ".tgz"
1032 # write the pyconf file to the temporary project location
1033 product_tmp_pyconf_path = os.path.join(products_pyconf_tmp_dir,
1035 ff = open(product_tmp_pyconf_path, 'w')
1036 ff.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
1037 product_pyconf_cfg.__save__(ff, 1)
1040 def find_application_pyconf(config, application_tmp_dir):
1041 '''Find the application pyconf file and put it in the specific temporary
1042 directory containing the specific project of a source package.
1044 :param config Config: The global configuration.
1045 :param application_tmp_dir str: The path to the temporary application
1046 scripts directory of the project.
1048 # read the pyconf of the application
1049 application_name = config.VARS.application
1050 application_pyconf_path = src.find_file_in_lpath(
1051 application_name + ".pyconf",
1052 config.PATHS.APPLICATIONPATH)
1053 application_pyconf_cfg = src.pyconf.Config(application_pyconf_path)
1055 # Change the workdir
1056 application_pyconf_cfg.APPLICATION.workdir = src.pyconf.Reference(
1057 application_pyconf_cfg,
1059 'VARS.salometoolsway + $VARS.sep + ".."')
1061 # Prevent from compilation in base
1062 application_pyconf_cfg.APPLICATION.no_base = "yes"
1064 #remove products that are not in config (which were filtered by --without_properties)
1065 for product_name in application_pyconf_cfg.APPLICATION.products.keys():
1066 if product_name not in config.APPLICATION.products.keys():
1067 application_pyconf_cfg.APPLICATION.products.__delitem__(product_name)
1069 # write the pyconf file to the temporary application location
1070 application_tmp_pyconf_path = os.path.join(application_tmp_dir,
1071 application_name + ".pyconf")
1073 ff = open(application_tmp_pyconf_path, 'w')
1074 ff.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
1075 application_pyconf_cfg.__save__(ff, 1)
1078 def project_package(config, name_project, project_file_path, ftp_mode, tmp_working_dir, logger):
1079 '''Prepare a dictionary that stores all the needed directories and files to
1080 add in a project package.
1082 :param project_file_path str: The path to the local project.
1083 :param ftp_mode boolean: Do not embed archives, the archive will rely on ftp mode to retrieve them.
1084 :param tmp_working_dir str: The temporary local directory containing some
1085 specific directories or files needed in the
1087 :return: the dictionary that stores all the needed directories and files to
1088 add in a project package.
1089 {label : (path_on_local_machine, path_in_archive)}
1093 # Read the project file and get the directories to add to the package
1096 project_pyconf_cfg = config.PROJECTS.projects.__getattr__(name_project)
1099 WARNING: inexisting config.PROJECTS.projects.%s, try to read now from:\n%s\n""" % (name_project, project_file_path))
1100 project_pyconf_cfg = src.pyconf.Config(project_file_path)
1101 project_pyconf_cfg.PWD = os.path.dirname(project_file_path)
1103 paths = {"APPLICATIONPATH" : "applications",
1104 "PRODUCTPATH" : "products",
1106 "MACHINEPATH" : "machines"}
1108 paths["ARCHIVEPATH"] = "archives"
1110 # Loop over the project paths and add it
1112 if path not in project_pyconf_cfg:
1114 # Add the directory to the files to add in the package
1115 d_project[path] = (project_pyconf_cfg[path], paths[path])
1116 # Modify the value of the path in the package
1117 project_pyconf_cfg[path] = src.pyconf.Reference(
1120 'project_path + "/' + paths[path] + '"')
1122 # Modify some values
1123 if "project_path" not in project_pyconf_cfg:
1124 project_pyconf_cfg.addMapping("project_path",
1125 src.pyconf.Mapping(project_pyconf_cfg),
1127 project_pyconf_cfg.project_path = src.pyconf.Reference(project_pyconf_cfg,
1131 # Write the project pyconf file
1132 project_file_name = os.path.basename(project_file_path)
1133 project_pyconf_tmp_path = os.path.join(tmp_working_dir, project_file_name)
1134 ff = open(project_pyconf_tmp_path, 'w')
1135 ff.write("#!/usr/bin/env python\n#-*- coding:utf-8 -*-\n\n")
1136 project_pyconf_cfg.__save__(ff, 1)
1138 d_project["Project hat file"] = (project_pyconf_tmp_path, project_file_name)
1142 def add_readme(config, options, where):
1143 readme_path = os.path.join(where, "README")
1144 with codecs.open(readme_path, "w", 'utf-8') as f:
1146 # templates for building the header
1148 # This package was generated with sat $version
1151 # Distribution : $dist
1153 In the following, $$ROOT represents the directory where you have installed
1154 SALOME (the directory where this file is located).
1157 readme_compilation_with_binaries="""
1159 compilation based on the binaries used as prerequisites
1160 =======================================================
1162 If you fail to compile the complete application (for example because
1163 you are not root on your system and cannot install missing packages), you
1164 may try a partial compilation based on the binaries.
1165 For that it is necessary to copy the binaries from BINARIES to INSTALL,
1166 and do some substitutions on cmake and .la files (replace the build directories
1168 The procedure to do it is:
1169 1) Remove or rename INSTALL directory if it exists
1170 2) Execute the shell script install_bin.sh:
1173 3) Use SalomeTool (as explained in Sources section) and compile only the
1174 modules you need to (with -p option)
1177 readme_header_tpl=string.Template(readme_header)
1178 readme_template_path_bin = os.path.join(config.VARS.internal_dir,
1179 "README_BIN.template")
1180 readme_template_path_bin_launcher = os.path.join(config.VARS.internal_dir,
1181 "README_LAUNCHER.template")
1182 readme_template_path_bin_virtapp = os.path.join(config.VARS.internal_dir,
1183 "README_BIN_VIRTUAL_APP.template")
1184 readme_template_path_src = os.path.join(config.VARS.internal_dir,
1185 "README_SRC.template")
1186 readme_template_path_pro = os.path.join(config.VARS.internal_dir,
1187 "README_PROJECT.template")
1188 readme_template_path_sat = os.path.join(config.VARS.internal_dir,
1189 "README_SAT.template")
1191 # prepare substitution dictionary
1193 d['user'] = config.VARS.user
1194 d['date'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
1195 d['version'] = config.INTERNAL.sat_version
1196 d['dist'] = config.VARS.dist
1197 f.write(readme_header_tpl.substitute(d)) # write the general header (common)
1199 if options.binaries or options.sources:
1200 d['application'] = config.VARS.application
1201 f.write("# Application: " + d['application'] + "\n")
1202 if 'KERNEL' in config.APPLICATION.products:
1203 VersionSalome = src.get_salome_version(config)
1204 # Case where SALOME has the launcher that uses the SalomeContext API
1205 if VersionSalome >= 730:
1206 d['launcher'] = config.APPLICATION.profile.launcher_name
1208 d['virtual_app'] = 'runAppli' # this info is not used now)
1210 # write the specific sections
1211 if options.binaries:
1212 f.write(src.template.substitute(readme_template_path_bin, d))
1213 if "virtual_app" in d:
1214 f.write(src.template.substitute(readme_template_path_bin_virtapp, d))
1216 f.write(src.template.substitute(readme_template_path_bin_launcher, d))
1219 f.write(src.template.substitute(readme_template_path_src, d))
1221 if options.binaries and options.sources:
1222 f.write(readme_compilation_with_binaries)
1225 f.write(src.template.substitute(readme_template_path_pro, d))
1228 f.write(src.template.substitute(readme_template_path_sat, d))
1232 def update_config(config, prop, value):
1233 '''Remove from config.APPLICATION.products the products that have the property given as input.
1235 :param config Config: The global config.
1236 :param prop str: The property to filter
1237 :param value str: The value of the property to filter
1239 # if there is no APPLICATION (ex sat package -t) : nothing to do
1240 if "APPLICATION" in config:
1241 l_product_to_remove = []
1242 for product_name in config.APPLICATION.products.keys():
1243 prod_cfg = src.product.get_product_config(config, product_name)
1244 if src.get_property_in_product_cfg(prod_cfg, prop) == value:
1245 l_product_to_remove.append(product_name)
1246 for product_name in l_product_to_remove:
1247 config.APPLICATION.products.__delitem__(product_name)
1250 '''method that is called when salomeTools is called with --help option.
1252 :return: The text to display for the package command description.
1256 The package command creates a tar file archive of a product.
1257 There are four kinds of archive, which can be mixed:
1259 1 - The binary archive.
1260 It contains the product installation directories plus a launcher.
1261 2 - The sources archive.
1262 It contains the product archives, a project (the application plus salomeTools).
1263 3 - The project archive.
1264 It contains a project (give the project file path as argument).
1265 4 - The salomeTools archive.
1266 It contains code utility salomeTools.
1269 >> sat package SALOME-master --binaries --sources""")
1271 def run(args, runner, logger):
1272 '''method that is called when salomeTools is called with package parameter.
1276 (options, args) = parser.parse_args(args)
1278 # Check that a type of package is called, and only one
1279 all_option_types = (options.binaries,
1281 options.project not in ["", None],
1284 # Check if no option for package type
1285 if all_option_types.count(True) == 0:
1286 msg = _("Error: Precise a type for the package\nUse one of the "
1287 "following options: --binaries, --sources, --project or"
1289 logger.write(src.printcolors.printcError(msg), 1)
1290 logger.write("\n", 1)
1293 # The repository where to put the package if not Binary or Source
1294 package_default_path = runner.cfg.LOCAL.workdir
1296 # if the package contains binaries or sources:
1297 if options.binaries or options.sources:
1298 # Check that the command has been called with an application
1299 src.check_config_has_application(runner.cfg)
1301 # Display information
1302 logger.write(_("Packaging application %s\n") % src.printcolors.printcLabel(
1303 runner.cfg.VARS.application), 1)
1305 # Get the default directory where to put the packages
1306 package_default_path = os.path.join(runner.cfg.APPLICATION.workdir, "PACKAGE")
1307 src.ensure_path_exists(package_default_path)
1309 # if the package contains a project:
1311 # check that the project is visible by SAT
1312 projectNameFile = options.project + ".pyconf"
1314 for i in runner.cfg.PROJECTS.project_file_paths:
1315 baseName = os.path.basename(i)
1316 if baseName == projectNameFile:
1320 if foundProject is None:
1321 local_path = os.path.join(runner.cfg.VARS.salometoolsway, "data", "local.pyconf")
1322 msg = _("""ERROR: the project %(1)s is not visible by salomeTools.
1326 Please add it in file:
1328 {"1": options.project, "2": "\n ".join(runner.cfg.PROJECTS.project_file_paths), "3": local_path})
1329 logger.write(src.printcolors.printcError(msg), 1)
1330 logger.write("\n", 1)
1333 options.project_file_path = foundProject
1334 src.printcolors.print_value(logger, "Project path", options.project_file_path, 2)
1336 # Remove the products that are filtered by the --without_properties option
1337 if options.without_properties:
1338 app = runner.cfg.APPLICATION
1339 logger.trace("without_properties all products:\n %s\n" % PP.pformat(sorted(app.products.keys())))
1340 prop, value = options.without_properties
1341 update_config(runner.cfg, prop, value)
1342 logger.warning("without_properties selected products:\n %s\n" % PP.pformat(sorted(app.products.keys())))
1344 # Remove from config the products that have the not_in_package property
1345 update_config(runner.cfg, "not_in_package", "yes")
1347 # get the name of the archive or build it
1349 if os.path.basename(options.name) == options.name:
1350 # only a name (not a path)
1351 archive_name = options.name
1352 dir_name = package_default_path
1354 archive_name = os.path.basename(options.name)
1355 dir_name = os.path.dirname(options.name)
1357 # suppress extension
1358 if archive_name[-len(".tgz"):] == ".tgz":
1359 archive_name = archive_name[:-len(".tgz")]
1360 if archive_name[-len(".tar.gz"):] == ".tar.gz":
1361 archive_name = archive_name[:-len(".tar.gz")]
1365 dir_name = package_default_path
1366 if options.binaries or options.sources:
1367 archive_name = runner.cfg.APPLICATION.name
1369 if options.binaries:
1370 archive_name += "-"+runner.cfg.VARS.dist
1373 archive_name += "-SRC"
1374 if options.with_vcs:
1375 archive_name += "-VCS"
1378 project_name = options.project
1379 archive_name += ("PROJECT-" + project_name)
1382 archive_name += ("salomeTools_" + runner.cfg.INTERNAL.sat_version)
1383 if len(archive_name)==0: # no option worked
1384 msg = _("Error: Cannot name the archive\n"
1385 " check if at least one of the following options was "
1386 "selected : --binaries, --sources, --project or"
1388 logger.write(src.printcolors.printcError(msg), 1)
1389 logger.write("\n", 1)
1392 path_targz = os.path.join(dir_name, archive_name + ".tgz")
1394 src.printcolors.print_value(logger, "Package path", path_targz, 2)
1396 # Create a working directory for all files that are produced during the
1397 # package creation and that will be removed at the end of the command
1398 tmp_working_dir = os.path.join(runner.cfg.VARS.tmp_root, runner.cfg.VARS.datehour)
1399 src.ensure_path_exists(tmp_working_dir)
1400 logger.write("\n", 5)
1401 logger.write(_("The temporary working directory: %s\n" % tmp_working_dir),5)
1403 logger.write("\n", 3)
1405 msg = _("Preparation of files to add to the archive")
1406 logger.write(src.printcolors.printcLabel(msg), 2)
1407 logger.write("\n", 2)
1409 d_files_to_add={} # content of the archive
1411 # a dict to hold paths that will need to be substitute for users recompilations
1412 d_paths_to_substitute={}
1414 if options.binaries:
1415 d_bin_files_to_add = binary_package(runner.cfg,
1419 # for all binaries dir, store the substitution that will be required
1420 # for extra compilations
1421 for key in d_bin_files_to_add:
1422 if key.endswith("(bin)"):
1423 source_dir = d_bin_files_to_add[key][0]
1424 path_in_archive = d_bin_files_to_add[key][1].replace("BINARIES-" + runner.cfg.VARS.dist,"INSTALL")
1425 if os.path.basename(source_dir)==os.path.basename(path_in_archive):
1426 # if basename is the same we will just substitute the dirname
1427 d_paths_to_substitute[os.path.dirname(source_dir)]=\
1428 os.path.dirname(path_in_archive)
1430 d_paths_to_substitute[source_dir]=path_in_archive
1432 d_files_to_add.update(d_bin_files_to_add)
1435 d_files_to_add.update(source_package(runner,
1440 if options.binaries:
1441 # for archives with bin and sources we provide a shell script able to
1442 # install binaries for compilation
1443 file_install_bin=produce_install_bin_file(runner.cfg,logger,
1445 d_paths_to_substitute,
1447 d_files_to_add.update({"install_bin" : (file_install_bin, "install_bin.sh")})
1448 logger.write("substitutions that need to be done later : \n", 5)
1449 logger.write(str(d_paths_to_substitute), 5)
1450 logger.write("\n", 5)
1452 # --salomeTool option is not considered when --sources is selected, as this option
1453 # already brings salomeTool!
1455 d_files_to_add.update({"salomeTools" : (runner.cfg.VARS.salometoolsway, "")})
1458 DBG.write("config for package %s" % project_name, runner.cfg)
1459 d_files_to_add.update(project_package(runner.cfg, project_name, options.project_file_path, options.ftp, tmp_working_dir, logger))
1461 if not(d_files_to_add):
1462 msg = _("Error: Empty dictionnary to build the archive!\n")
1463 logger.write(src.printcolors.printcError(msg), 1)
1464 logger.write("\n", 1)
1467 # Add the README file in the package
1468 local_readme_tmp_path = add_readme(runner.cfg, options, tmp_working_dir)
1469 d_files_to_add["README"] = (local_readme_tmp_path, "README")
1471 # Add the additional files of option add_files
1472 if options.add_files:
1473 for file_path in options.add_files:
1474 if not os.path.exists(file_path):
1475 msg = _("WARNING: the file %s is not accessible.\n" % file_path)
1477 file_name = os.path.basename(file_path)
1478 d_files_to_add[file_name] = (file_path, file_name)
1480 logger.write("\n", 2)
1481 logger.write(src.printcolors.printcLabel(_("Actually do the package")), 2)
1482 logger.write("\n", 2)
1483 logger.write("\nfiles and directories to add:\n%s\n\n" % PP.pformat(d_files_to_add), 5)
1487 # Creating the object tarfile
1488 tar = tarfile.open(path_targz, mode='w:gz')
1490 # get the filtering function if needed
1491 filter_function = exclude_VCS_and_extensions
1493 # Add the files to the tarfile object
1494 res = add_files(tar, archive_name, d_files_to_add, logger, f_exclude=filter_function)
1496 except KeyboardInterrupt:
1497 logger.write(src.printcolors.printcError("\nERROR: forced interruption\n"), 1)
1498 logger.write(_("Removing the temporary working directory '%s'... ") % tmp_working_dir, 1)
1499 # remove the working directory
1500 shutil.rmtree(tmp_working_dir)
1501 logger.write(_("OK"), 1)
1502 logger.write(_("\n"), 1)
1505 # case if no application, only package sat as 'sat package -t'
1507 app = runner.cfg.APPLICATION
1511 # unconditionaly remove the tmp_local_working_dir
1513 tmp_local_working_dir = os.path.join(app.workdir, "tmp_package")
1514 if os.path.isdir(tmp_local_working_dir):
1515 shutil.rmtree(tmp_local_working_dir)
1517 # have to decide some time
1518 DBG.tofix("make shutil.rmtree('%s') effective" % tmp_working_dir, "", DBG.isDeveloper())
1520 # Print again the path of the package
1521 logger.write("\n", 2)
1522 src.printcolors.print_value(logger, "Package path", path_targz, 2)