This is mostly a copy from distutils-r1. The function does copy all the
files from one location onto another, preserving whatever possible. It
can be run in parallel too without the risk of race conditions.
As suggested by Ulrich and Zac, I've modified the code to use checks
based on userland rather than tool checking. The code supports BSD and
GNU userlands as defined in the profiles. With any other userland, it
explicitly dies.
---
gx86/eclass/distutils-r1.eclass | 41 +-------------------------------
gx86/eclass/multibuild.eclass | 52 +++++++++++++++++++++++++++++++++++++++++
2 files changed, 53 insertions(+), 40 deletions(-)
diff --git a/gx86/eclass/distutils-r1.eclass b/gx86/eclass/distutils-r1.eclass
index 0982e6c..3c21741 100644
--- a/gx86/eclass/distutils-r1.eclass
+++ b/gx86/eclass/distutils-r1.eclass
@@ -449,49 +449,10 @@ distutils-r1_python_install() {
if [[ ! ${DISTUTILS_SINGLE_IMPL} ]]; then
_distutils-r1_rename_scripts "${root}"
- _distutils-r1_merge_root "${root}" "${D}"
+ multibuild_merge_root "${root}" "${D}"
fi
}
-# @FUNCTION: distutils-r1_merge_root
-# @USAGE: <src-root> <dest-root>
-# @INTERNAL
-# @DESCRIPTION:
-# Merge the directory tree from <src-root> to <dest-root>, removing
-# the <src-root> in the process.
-_distutils-r1_merge_root() {
- local src=${1}
- local dest=${2}
-
- local lockfile=${T}/distutils-r1-merge-lock
-
- if type -P lockf &>/dev/null; then
- # On BSD, we have 'lockf' wrapper.
- tar -C "${src}" -f - -c . \
- | lockf "${lockfile}" tar -x -f - -C "${dest}"
- else
- local lock_fd
- if type -P flock &>/dev/null; then
- # On Linux, we have 'flock' which can lock fd.
- redirect_alloc_fd lock_fd "${lockfile}" '>>'
- flock ${lock_fd}
- else
- ewarn "distutils-r1: no locking service found, please
report."
- fi
-
- cp -a -l -n "${src}"/. "${dest}"/
-
- if [[ ${lock_fd} ]]; then
- # Close the lock file when we are done with it.
- # Prevents deadlock if we aren't in a subshell.
- eval "exec ${lock_fd}>&-"
- fi
- fi
- [[ ${?} == 0 ]] || die "Merging ${EPYTHON} image failed."
-
- rm -rf "${src}"
-}
-
# @FUNCTION: distutils-r1_python_install_all
# @DESCRIPTION:
# The default python_install_all(). It installs the documentation.
diff --git a/gx86/eclass/multibuild.eclass b/gx86/eclass/multibuild.eclass
index a3f1402..1152245 100644
--- a/gx86/eclass/multibuild.eclass
+++ b/gx86/eclass/multibuild.eclass
@@ -238,5 +238,57 @@ run_in_build_dir() {
return ${ret}
}
+# @FUNCTION: multibuild_merge_root
+# @USAGE: <src-root> <dest-root>
+# @DESCRIPTION:
+# Merge the directory tree (fake root) from <src-root> to <dest-root>
+# (the real root). Both directories have to be real, absolute paths
+# (i.e. including ${D}). Source root will be removed.
+#
+# This functions uses locking to support merging during parallel
+# installs.
+multibuild_merge_root() {
+ local src=${1}
+ local dest=${2}
+
+ local lockfile=${T}/multibuild_merge_lock
+ local ret
+
+ if use userland_BSD; then
+ # Locking is done by 'lockf' which can wrap a command.
+ # 'cp -a -n' is broken:
+ # http://www.freebsd.org/cgi/query-pr.cgi?pr=174489
+ # using tar instead which is universal but terribly slow.
+
+ tar -C "${src}" -f - -c . \
+ | lockf "${lockfile}" tar -x -f - -C "${dest}"
+ [[ ${PIPESTATUS[*]} == '0 0' ]]
+ ret=${?}
+ elif use userland_GNU; then
+ # GNU has 'flock' which can't wrap commands but can lock
+ # a fd which is good enough for us.
+ # and cp works with '-a -n'.
+
+ local lock_fd
+ redirect_alloc_fd lock_fd "${lockfile}" '>>'
+ flock ${lock_fd}
+
+ cp -a -l -n "${src}"/. "${dest}"/
+ ret=${?}
+
+ # Close the lock file when we are done with it.
+ # Prevents deadlock if we aren't in a subshell.
+ eval "exec ${lock_fd}>&-"
+ else
+ die "Unsupported userland (${USERLAND}), please report."
+ fi
+
+ if [[ ${ret} -ne 0 ]]; then
+ die "${MULTIBUILD_VARIANT:-(unknown)}: merging image failed."
+ fi
+
+ rm -rf "${src}"
+}
+
_MULTIBUILD=1
fi
--
1.8.1.5
