cwl_runner_version=$(cd sdk/cwl && python3 arvados_version.py)
}
+# Usage: get_native_arch
+get_native_arch() {
+ # Only amd64 and aarch64 are supported at the moment
+ local native_arch=""
+ case "$HOSTTYPE" in
+ x86_64)
+ native_arch="amd64"
+ ;;
+ aarch64)
+ native_arch="arm64"
+ ;;
+ *)
+ echo "Error: architecture not supported"
+ exit 1
+ ;;
+ esac
+ echo $native_arch
+}
+
handle_ruby_gem() {
local gem_name="$1"; shift
local gem_version="$(nohash_version_from_git)"
fi
}
+# Usage: package_workbench2
+package_workbench2() {
+ local pkgname=arvados-workbench2
+ local src=services/workbench2
+ local dst=/var/www/arvados-workbench2/workbench2
+ local description="Arvados Workbench 2"
+ local version="$(version_from_git)"
+ cd "$WORKSPACE/$src"
+ rm -rf ./build
+ NODE_ENV=production yarn install
+ VERSION="$VERSION" BUILD_NUMBER="$(default_iteration "$pkgname" "$version" yarn)" GIT_COMMIT="$(git rev-parse HEAD | head -c9)" yarn build
+ cd "$WORKSPACE/packages/$TARGET"
+ fpm_build "${WORKSPACE}/$src" "${WORKSPACE}/$src/build/=$dst" "$pkgname" dir "$version" \
+ --license="GNU Affero General Public License, version 3.0" \
+ --description="${description}" \
+ --config-files="/etc/arvados/$pkgname/workbench2.example.json" \
+ "$WORKSPACE/services/workbench2/etc/arvados/workbench2/workbench2.example.json=/etc/arvados/$pkgname/workbench2.example.json"
+}
+
calculate_go_package_version() {
# $__returnvar has the nameref attribute set, which means it is a reference
# to another variable that is passed in as the first argument to this function.
__returnvar="$version"
}
-# Usage: package_go_binary services/foo arvados-foo "Compute foo to arbitrary precision" [apache-2.0.txt]
+# Usage: package_go_binary services/foo arvados-foo [deb|rpm] [amd64|arm64] "Compute foo to arbitrary precision" [apache-2.0.txt]
package_go_binary() {
- local src_path="$1"; shift
- local prog="$1"; shift
- local description="$1"; shift
- local license_file="${1:-agpl-3.0.txt}"; shift
+ local src_path="$1"; shift
+ local prog="$1"; shift
+ local package_format="$1"; shift
+ local target_arch="$1"; shift
+ local description="$1"; shift
+ local license_file="${1:-agpl-3.0.txt}"; shift
+
+ if [[ -n "$ONLY_BUILD" ]] && [[ "$prog" != "$ONLY_BUILD" ]]; then
+ debug_echo -e "Skipping build of $prog package."
+ return 0
+ fi
- if [[ -n "$ONLY_BUILD" ]] && [[ "$prog" != "$ONLY_BUILD" ]]; then
- # arvados-workbench depends on arvados-server at build time, so even when
- # only arvados-workbench is being built, we need to build arvados-server too
- if [[ "$prog" != "arvados-server" ]] || [[ "$ONLY_BUILD" != "arvados-workbench" ]]; then
- return 0
+ native_arch=$(get_native_arch)
+
+ if [[ "$native_arch" != "amd64" ]] && [[ -n "$target_arch" ]] && [[ "$native_arch" != "$target_arch" ]]; then
+ echo "Error: no cross compilation support for Go on $native_arch, can not build $prog for $target_arch"
+ return 1
+ fi
+
+ case "$package_format-$TARGET" in
+ # Older Debian/Ubuntu do not support cross compilation because the
+ # libfuse package does not support multiarch. See
+ # <https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=983477>.
+ # Red Hat-based distributions do not support native cross compilation at
+ # all (they use a qemu-based solution we haven't implemented yet).
+ deb-debian10|deb-ubuntu1804|deb-ubuntu2004|rpm-*)
+ cross_compilation=0
+ if [[ "$native_arch" == "amd64" ]] && [[ -n "$target_arch" ]] && [[ "$native_arch" != "$target_arch" ]]; then
+ echo "Error: no cross compilation support for Go on $native_arch for $TARGET, can not build $prog for $target_arch"
+ return 1
fi
- fi
+ ;;
+ *)
+ cross_compilation=1
+ ;;
+ esac
- native_arch="amd64"
- if [[ "$HOSTTYPE" == "aarch64" ]]; then
- native_arch="arm64"
+ if [[ -n "$target_arch" ]]; then
+ archs=($target_arch)
+ else
+ # No target architecture specified, default to native target. When on amd64
+ # also crosscompile arm64 (when supported).
+ archs=($native_arch)
+ if [[ $cross_compilation -ne 0 ]]; then
+ archs+=("arm64")
fi
+ fi
- if [[ -n "$ARCH" ]]; then
- if [[ "$native_arch" == "amd64" ]] || [[ "$native_arch" == "$ARCH" ]]; then
- package_go_binary_worker "$src_path" "$prog" "$description" "$native_arch" "$ARCH" "$license_file"
- else
- echo "Error: no cross compilation support for Go on $native_arch yet, can not build $prog for $ARCH"
- fi
- else
- archs=($native_arch)
- if [[ "$native_arch" == "amd64" ]]; then
- archs=('amd64' 'arm64')
- fi
- for arch in $archs; do
- package_go_binary_worker "$src_path" "$prog" "$description" "$native_arch" "$arch" "$license_file"
- done
+ for ta in ${archs[@]}; do
+ package_go_binary_worker "$src_path" "$prog" "$package_format" "$description" "$native_arch" "$ta" "$license_file"
+ retval=$?
+ if [[ $retval -ne 0 ]]; then
+ return $retval
fi
+ done
}
-# Usage: package_go_binary services/foo arvados-foo "Compute foo to arbitrary precision" [amd64/arm64] [amd64/arm64] [apache-2.0.txt]
+# Usage: package_go_binary services/foo arvados-foo deb "Compute foo to arbitrary precision" [amd64/arm64] [amd64/arm64] [apache-2.0.txt]
package_go_binary_worker() {
local src_path="$1"; shift
local prog="$1"; shift
+ local package_format="$1"; shift
local description="$1"; shift
local native_arch="${1:-amd64}"; shift
- local arch="${1:-amd64}"; shift
+ local target_arch="${1:-amd64}"; shift
local license_file="${1:-agpl-3.0.txt}"; shift
- debug_echo "package_go_binary $src_path as $prog"
+ debug_echo "package_go_binary $src_path as $prog (native arch: $native_arch, target arch: $target_arch)"
local basename="${src_path##*/}"
calculate_go_package_version go_package_version $src_path
cd $WORKSPACE/packages/$TARGET
- test_package_presence "$prog" "$go_package_version" "go" "" "$arch"
- if [[ "$?" != "0" ]]; then
- return 1
+ test_package_presence "$prog" "$go_package_version" "go" "" "$target_arch"
+ if [[ $? -ne 0 ]]; then
+ return 0
fi
- echo "BUILDING ${arch}"
- if [[ "$arch" == "arm64" ]] && [[ "$native_arch" == "amd64" ]]; then
- if [[ "$FORMAT" == "deb" ]]; then
- CGO_ENABLED=1 CC=aarch64-linux-gnu-gcc GOARCH=${arch} go get -ldflags "-X git.arvados.org/arvados.git/lib/cmd.version=${go_package_version} -X main.version=${go_package_version}" "git.arvados.org/arvados.git/$src_path"
- else
- echo "Error: no cross compilation support for Go on $native_arch ($FORMAT), can not build $prog for $ARCH"
- return
- fi
+ echo "Building $package_format ($target_arch) package for $prog from $src_path"
+ if [[ "$native_arch" == "amd64" ]] && [[ "$target_arch" == "arm64" ]]; then
+ CGO_ENABLED=1 CC=aarch64-linux-gnu-gcc GOARCH=${target_arch} go install -ldflags "-X git.arvados.org/arvados.git/lib/cmd.version=${go_package_version} -X main.version=${go_package_version}" "git.arvados.org/arvados.git/$src_path"
else
- GOARCH=${arch} go get -ldflags "-X git.arvados.org/arvados.git/lib/cmd.version=${go_package_version} -X main.version=${go_package_version}" "git.arvados.org/arvados.git/$src_path"
+ GOARCH=${arch} go install -ldflags "-X git.arvados.org/arvados.git/lib/cmd.version=${go_package_version} -X main.version=${go_package_version}" "git.arvados.org/arvados.git/$src_path"
fi
local -a switches=()
binpath=$GOPATH/bin/${basename}
- if [[ "${arch}" != "${native_arch}" ]]; then
- switches+=("-a${arch}")
- binpath="$GOPATH/bin/linux_${arch}/${basename}"
+ if [[ "${target_arch}" != "${native_arch}" ]]; then
+ switches+=("-a${target_arch}")
+ binpath="$GOPATH/bin/linux_${target_arch}/${basename}"
fi
systemd_unit="$WORKSPACE/${src_path}/${prog}.service"
fpm_build "${WORKSPACE}/${src_path}" "$binpath=/usr/bin/${prog}" "${prog}" dir "${go_package_version}" "--url=https://arvados.org" "--license=GNU Affero General Public License, version 3.0" "--description=${description}" "${switches[@]}"
}
-# Usage: package_go_so lib/foo arvados_foo.so arvados-foo "Arvados foo library"
+# Usage: package_go_so lib/foo arvados_foo.so arvados-foo deb amd64 "Arvados foo library"
package_go_so() {
local src_path="$1"; shift
local sofile="$1"; shift
local pkg="$1"; shift
+ local package_format="$1"; shift
+ local target_arch="$1"; shift # supported: amd64, arm64
local description="$1"; shift
if [[ -n "$ONLY_BUILD" ]] && [[ "$pkg" != "$ONLY_BUILD" ]]; then
+ debug_echo -e "Skipping build of $pkg package."
return 0
fi
return
fi
local version="$(version_from_git)"
- if [ $pkgname = "arvados-api-server" -o $pkgname = "arvados-workbench" ] ; then
+ if [ $pkgname = "arvados-api-server" ] ; then
calculate_go_package_version version cmd/arvados-server "$srcdir"
fi
echo $version
fi
if [[ "$arch" == "" ]]; then
- native_arch="amd64"
+ native_arch=$(get_native_arch)
rpm_native_arch="x86_64"
if [[ "$HOSTTYPE" == "aarch64" ]]; then
- native_arch="arm64"
rpm_native_arch="arm64"
fi
rpm_architecture="$rpm_native_arch"
rpm_architecture="noarch"
deb_architecture="all"
fi
-
- # These python packages have binary components
- if [[ "$pkgname" =~ (ruamel|ciso|pycrypto|pyyaml) ]]; then
- rpm_architecture="$rpm_native_arch"
- deb_architecture="$native_arch"
- fi
else
rpm_architecture=$arch
deb_architecture=$arch
local iteration="$1"; shift
local arch="$1"; shift
if [[ -n "$ONLY_BUILD" ]] && [[ "$pkgname" != "$ONLY_BUILD" ]] ; then
- # arvados-workbench depends on arvados-server at build time, so even when
- # only arvados-workbench is being built, we need to build arvados-server too
- if [[ "$pkgname" != "arvados-server" ]] || [[ "$ONLY_BUILD" != "arvados-workbench" ]]; then
return 1
- fi
fi
local full_pkgname
return 0
fi
else
- centos_repo="http://rpm.arvados.org/CentOS/7/dev/x86_64/"
-
- repo_pkg_list=$(curl -s -o - ${centos_repo})
- echo ${repo_pkg_list} |grep -q ${full_pkgname}
- if [ $? -eq 0 ]; then
+ local rpm_root
+ case "$TARGET" in
+ centos7) rpm_root="CentOS/7/dev" ;;
+ rocky8) rpm_root="CentOS/8/dev" ;;
+ *)
+ echo "FIXME: Don't know RPM URL path for $TARGET, building"
+ return 0
+ ;;
+ esac
+ local rpm_url="http://rpm.arvados.org/$rpm_root/$arch/$full_pkgname"
+
+ if curl -fs -o "$WORKSPACE/packages/$TARGET/$full_pkgname" "$rpm_url"; then
echo "Package $full_pkgname exists upstream, not rebuilding, downloading instead!"
- curl -s -o "$WORKSPACE/packages/$TARGET/${full_pkgname}" ${centos_repo}${full_pkgname}
return 1
- elif test -f "$WORKSPACE/packages/$TARGET/processed/${full_pkgname}" ; then
+ elif [[ -f "$WORKSPACE/packages/$TARGET/processed/$full_pkgname" ]]; then
echo "Package $full_pkgname exists, not rebuilding!"
return 1
else
cd "$srcdir"
mkdir -p tmp
git rev-parse HEAD >git-commit.version
- bundle package --all
+ bundle config set cache_all true
+ bundle package
)
if [[ 0 != "$?" ]] || ! cd "$WORKSPACE/packages/$TARGET"; then
echo "ERROR: $pkgname package prep failed" >&2
fi
# For some reason fpm excludes need to not start with /.
local exclude_root="${railsdir#/}"
- local -a exclude_list=(tmp log coverage Capfile\* \
- config/deploy\* config/application.yml)
- # for arvados-workbench, we need to have the (dummy) config/database.yml in the package
- if [[ "$pkgname" != "arvados-workbench" ]]; then
- exclude_list+=('config/database.yml')
- fi
- for exclude in ${exclude_list[@]}; do
+ for exclude in tmp log coverage Capfile\* \
+ config/deploy\* \
+ config/application.yml \
+ config/database.yml; do
switches+=(-x "$exclude_root/$exclude")
done
fpm_build "${srcdir}" "${pos_args[@]}" "${switches[@]}" \
rm -rf "$scripts_dir"
}
+# Usage: handle_api_server [amd64|arm64]
+handle_api_server () {
+ local target_arch="${1:-amd64}"; shift
+
+ if [[ -n "$ONLY_BUILD" ]] && [[ "$ONLY_BUILD" != "arvados-api-server" ]] ; then
+ debug_echo -e "Skipping build of arvados-api-server package."
+ return 0
+ fi
+
+ native_arch=$(get_native_arch)
+ if [[ "$target_arch" != "$native_arch" ]]; then
+ echo "Error: no cross compilation support for Rails yet, can not build arvados-api-server for $ARCH"
+ echo
+ exit 1
+ fi
+
+ # Build the API server package
+ test_rails_package_presence arvados-api-server "$WORKSPACE/services/api"
+ if [[ "$?" == "0" ]]; then
+ calculate_go_package_version arvados_server_version cmd/arvados-server
+ arvados_server_iteration=$(default_iteration "arvados-server" "$arvados_server_version" "go")
+ handle_rails_package arvados-api-server "$WORKSPACE/services/api" \
+ "$WORKSPACE/agpl-3.0.txt" --url="https://arvados.org" \
+ --description="Arvados API server - Arvados is a free and open source platform for big data science." \
+ --license="GNU Affero General Public License, version 3.0" --depends "arvados-server = ${arvados_server_version}-${arvados_server_iteration}"
+ fi
+}
+
+# Usage: handle_cwltest [deb|rpm] [amd64|arm64]
+handle_cwltest () {
+ local package_format="$1"; shift
+ local target_arch="${1:-amd64}"; shift
+
+ if [[ -n "$ONLY_BUILD" ]] && [[ "$ONLY_BUILD" != "python3-cwltest" ]] ; then
+ debug_echo -e "Skipping build of cwltest package."
+ return 0
+ fi
+ cd "$WORKSPACE"
+ if [[ -e "$WORKSPACE/cwltest" ]]; then
+ rm -rf "$WORKSPACE/cwltest"
+ fi
+ git clone https://github.com/common-workflow-language/cwltest.git
+
+ # The subsequent release of cwltest confirms that files exist on disk, since
+ # our files are in Keep, all the tests fail.
+ # We should add [optional] Arvados support to cwltest so it can access
+ # Keep but for the time being just package the last working version.
+ (cd cwltest && git checkout 2.3.20230108193615)
+
+ # signal to our build script that we want a cwltest executable installed in /usr/bin/
+ mkdir cwltest/bin && touch cwltest/bin/cwltest
+ fpm_build_virtualenv "cwltest" "cwltest" "$package_format" "$target_arch"
+ # The python->python3 metapackage
+ build_metapackage "cwltest" "cwltest"
+ cd "$WORKSPACE"
+ rm -rf "$WORKSPACE/cwltest"
+}
+
+# Usage: handle_arvados_src
+handle_arvados_src () {
+ if [[ -n "$ONLY_BUILD" ]] && [[ "$ONLY_BUILD" != "arvados-src" ]] ; then
+ debug_echo -e "Skipping build of arvados-src package."
+ return 0
+ fi
+ # arvados-src
+ (
+ cd "$WORKSPACE"
+ COMMIT_HASH=$(format_last_commit_here "%H")
+ arvados_src_version="$(version_from_git)"
+
+ cd $WORKSPACE/packages/$TARGET
+ test_package_presence arvados-src "$arvados_src_version" src ""
+
+ if [[ "$?" == "0" ]]; then
+ cd "$WORKSPACE"
+ SRC_BUILD_DIR=$(mktemp -d)
+ # mktemp creates the directory with 0700 permissions by default
+ chmod 755 $SRC_BUILD_DIR
+ git clone $DASHQ_UNLESS_DEBUG "$WORKSPACE/.git" "$SRC_BUILD_DIR"
+ cd "$SRC_BUILD_DIR"
+
+ # go into detached-head state
+ git checkout $DASHQ_UNLESS_DEBUG "$COMMIT_HASH"
+ echo "$COMMIT_HASH" >git-commit.version
+
+ cd $WORKSPACE/packages/$TARGET
+ fpm_build "$WORKSPACE" $SRC_BUILD_DIR/=/usr/local/arvados/src arvados-src 'dir' "$arvados_src_version" "--exclude=usr/local/arvados/src/.git" "--url=https://arvados.org" "--license=GNU Affero General Public License, version 3.0" "--description=The Arvados source code" "--architecture=all"
+
+ rm -rf "$SRC_BUILD_DIR"
+ fi
+ )
+}
+
# Build python packages with a virtualenv built-in
+# Usage: fpm_build_virtualenv arvados-python-client sdk/python [deb|rpm] [amd64|arm64]
fpm_build_virtualenv () {
- PKG=$1
- shift
- PKG_DIR=$1
- shift
- PACKAGE_TYPE=${1:-python}
- shift
- native_arch="amd64"
- if [[ "$HOSTTYPE" == "aarch64" ]]; then
- native_arch="arm64"
+ local pkg=$1; shift
+ local pkg_dir=$1; shift
+ local package_format="$1"; shift
+ local target_arch="${1:-amd64}"; shift
+
+ native_arch=$(get_native_arch)
+
+ if [[ "$pkg" != "arvados-docker-cleaner" ]]; then
+ PYTHON_PKG=$PYTHON3_PKG_PREFIX-$pkg
+ else
+ # Exception to our package naming convention
+ PYTHON_PKG=$pkg
fi
- if [[ -n "$ARCH" ]] && [[ "$ARCH" == "$native_arch" ]]; then
- fpm_build_virtualenv_worker "$PKG" "$PKG_DIR" "$PACKAGE_TYPE" "$ARCH"
- elif [[ -z "$ARCH" ]]; then
- for arch in $native_arch; do
- fpm_build_virtualenv_worker "$PKG" "$PKG_DIR" "$PACKAGE_TYPE" "$arch"
- done
+ if [[ -n "$ONLY_BUILD" ]] && [[ "$PYTHON_PKG" != "$ONLY_BUILD" ]]; then
+ # arvados-python-client sdist should always be built if we are building a
+ # python package.
+ if [[ "$ONLY_BUILD" != "python3-arvados-cwl-runner" ]] &&
+ [[ "$ONLY_BUILD" != "python3-arvados-fuse" ]] &&
+ [[ "$ONLY_BUILD" != "python3-crunchstat-summary" ]] &&
+ [[ "$ONLY_BUILD" != "arvados-docker-cleaner" ]] &&
+ [[ "$ONLY_BUILD" != "python3-arvados-user-activity" ]]; then
+ debug_echo -e "Skipping build of $pkg package."
+ return 0
+ fi
+ fi
+
+ if [[ -n "$target_arch" ]] && [[ "$native_arch" == "$target_arch" ]]; then
+ fpm_build_virtualenv_worker "$pkg" "$pkg_dir" "$package_format" "$native_arch" "$target_arch"
+ elif [[ -z "$target_arch" ]]; then
+ fpm_build_virtualenv_worker "$pkg" "$pkg_dir" "$package_format" "$native_arch" "$native_arch"
else
- echo "Error: no cross compilation support for Python yet, can not build $PKG for $ARCH"
+ echo "Error: no cross compilation support for Python yet, can not build $pkg for $target_arch"
+ return 1
fi
}
# Build python packages with a virtualenv built-in
+# Usage: fpm_build_virtualenv_worker arvados-python-client sdk/python python3 [deb|rpm] [amd64|arm64] [amd64|arm64]
fpm_build_virtualenv_worker () {
- PKG=$1
- shift
- PKG_DIR=$1
- shift
- PACKAGE_TYPE=${1:-python}
- shift
- arch=${1:-amd64}
- shift
+ PKG=$1; shift
+ PKG_DIR=$1; shift
+ local package_format="$1"; shift
+ local native_arch="${1:-amd64}"; shift
+ local target_arch=${1:-amd64}; shift
# Set up
STDOUT_IF_DEBUG=/dev/null
ARVADOS_BUILDING_ITERATION=1
fi
- local python=""
- case "$PACKAGE_TYPE" in
- python3)
- python=python3
- pip=pip3
- PACKAGE_PREFIX=$PYTHON3_PKG_PREFIX
- ;;
- esac
+ local python=$PYTHON3_EXECUTABLE
+ pip=pip3
+ PACKAGE_PREFIX=$PYTHON3_PKG_PREFIX
if [[ "$PKG" != "arvados-docker-cleaner" ]]; then
PYTHON_PKG=$PACKAGE_PREFIX-$PKG
PYTHON_PKG=$PKG
fi
- # arvados-python-client sdist should always be built, to be available
- # for other dependent packages.
- if [[ -n "$ONLY_BUILD" ]] && [[ "arvados-python-client" != "$PKG" ]] && [[ "$PYTHON_PKG" != "$ONLY_BUILD" ]] && [[ "$PKG" != "$ONLY_BUILD" ]]; then
- return 0
- fi
-
cd $WORKSPACE/$PKG_DIR
rm -rf dist/*
PACKAGE_PATH=`(cd dist; ls *tar.gz)`
if [[ "arvados-python-client" == "$PKG" ]]; then
- PYSDK_PATH=`pwd`/dist/
+ PYSDK_PATH="-f $(pwd)/dist/"
fi
if [[ -n "$ONLY_BUILD" ]] && [[ "$PYTHON_PKG" != "$ONLY_BUILD" ]] && [[ "$PKG" != "$ONLY_BUILD" ]]; then
# We can't do this earlier than here, because we need PYTHON_VERSION...
# This isn't so bad; the sdist call above is pretty quick compared to
# the invocation of virtualenv and fpm, below.
- if ! test_package_presence "$PYTHON_PKG" "$UNFILTERED_PYTHON_VERSION" "$PACKAGE_TYPE" "$ARVADOS_BUILDING_ITERATION" "$arch"; then
+ if ! test_package_presence "$PYTHON_PKG" "$UNFILTERED_PYTHON_VERSION" "$python" "$ARVADOS_BUILDING_ITERATION" "$target_arch"; then
return 0
fi
- echo "Building $FORMAT ($arch) package for $PKG from $PKG_DIR"
+ echo "Building $package_format ($target_arch) package for $PKG from $PKG_DIR"
# Package the sdist in a virtualenv
echo "Creating virtualenv..."
echo "wheel version: `build/usr/share/$python/dist/$PYTHON_PKG/bin/wheel version`"
if [[ "$TARGET" != "centos7" ]] || [[ "$PYTHON_PKG" != "python-arvados-fuse" ]]; then
- build/usr/share/$python/dist/$PYTHON_PKG/bin/$pip install $DASHQ_UNLESS_DEBUG $CACHE_FLAG -f $PYSDK_PATH $PACKAGE_PATH
+ build/usr/share/$python/dist/$PYTHON_PKG/bin/$pip install $DASHQ_UNLESS_DEBUG $CACHE_FLAG $PYSDK_PATH $PACKAGE_PATH
else
# centos7 needs these special tweaks to install python-arvados-fuse
build/usr/share/$python/dist/$PYTHON_PKG/bin/$pip install $DASHQ_UNLESS_DEBUG $CACHE_FLAG docutils
- PYCURL_SSL_LIBRARY=nss build/usr/share/$python/dist/$PYTHON_PKG/bin/$pip install $DASHQ_UNLESS_DEBUG $CACHE_FLAG -f $PYSDK_PATH $PACKAGE_PATH
+ PYCURL_SSL_LIBRARY=nss build/usr/share/$python/dist/$PYTHON_PKG/bin/$pip install $DASHQ_UNLESS_DEBUG $CACHE_FLAG $PYSDK_PATH $PACKAGE_PATH
fi
if [[ "$?" != "0" ]]; then
echo "Error, unable to run"
- echo " build/usr/share/$python/dist/$PYTHON_PKG/bin/$pip install $DASHQ_UNLESS_DEBUG $CACHE_FLAG -f $PYSDK_PATH $PACKAGE_PATH"
+ echo " build/usr/share/$python/dist/$PYTHON_PKG/bin/$pip install $DASHQ_UNLESS_DEBUG $CACHE_FLAG $PYSDK_PATH $PACKAGE_PATH"
exit 1
fi
# Finally, generate the package
echo "Creating package..."
- declare -a COMMAND_ARR=("fpm" "-s" "dir" "-t" "$FORMAT")
+ declare -a COMMAND_ARR=("fpm" "-s" "dir" "-t" "$package_format")
- if [[ "${arch}" != "amd64" ]]; then
- COMMAND_ARR+=("-a${arch}")
+ if [[ -n "$target_arch" ]] && [[ "$target_arch" != "amd64" ]]; then
+ COMMAND_ARR+=("-a$target_arch")
fi
if [[ "$MAINTAINER" != "" ]]; then
LICENSE_STRING=`grep license $WORKSPACE/$PKG_DIR/setup.py|cut -f2 -d=|sed -e "s/[',\\"]//g"`
COMMAND_ARR+=('--license' "$LICENSE_STRING")
- if [[ "$FORMAT" == "rpm" ]]; then
- # Make sure to conflict with the old rh-python36 packages we used to publish
- COMMAND_ARR+=('--conflicts' "rh-python36-python-$PKG")
- fi
-
if [[ "$DEBUG" != "0" ]]; then
COMMAND_ARR+=('--verbose' '--log' 'info')
fi
fi
COMMAND_ARR+=('--depends' "$PYTHON3_PACKAGE")
-
- # avoid warning
- COMMAND_ARR+=('--deb-no-default-config-files')
+ case "$package_format" in
+ deb)
+ COMMAND_ARR+=(
+ # Avoid warning
+ --deb-no-default-config-files
+ ) ;;
+ rpm)
+ COMMAND_ARR+=(
+ # Conflict with older packages we used to publish
+ --conflicts "rh-python36-python-$PKG"
+ # Do not generate /usr/lib/.build-id links on RH8+
+ # (otherwise our packages conflict with platform-python)
+ --rpm-rpmbuild-define "_build_id_links none"
+ ) ;;
+ esac
# Append --depends X and other arguments specified by fpm-info.sh in
# the package source dir. These are added last so they can override
echo
echo -e "\n${COMMAND_ARR[@]}\n"
else
- echo `ls *$FORMAT`
- mv $WORKSPACE/$PKG_DIR/dist/*$FORMAT $WORKSPACE/packages/$TARGET/
+ echo `ls *$package_format`
+ mv $WORKSPACE/$PKG_DIR/dist/*$package_format $WORKSPACE/packages/$TARGET/
fi
echo
}
}
# Build packages for everything
-fpm_build () {
+fpm_build() {
# Source dir where fpm-info.sh (if any) will be found.
SRC_DIR=$1
shift
shift
if [[ -n "$ONLY_BUILD" ]] && [[ "$PACKAGE_NAME" != "$ONLY_BUILD" ]] && [[ "$PACKAGE" != "$ONLY_BUILD" ]] ; then
- # arvados-workbench depends on arvados-server at build time, so even when
- # only arvados-workbench is being built, we need to build arvados-server too
- if [[ "$PACKAGE_NAME" != "arvados-server" ]] || [[ "$ONLY_BUILD" != "arvados-workbench" ]]; then
return 0
- fi
fi
local default_iteration_value="$(default_iteration "$PACKAGE" "$VERSION" "$PACKAGE_TYPE")"
FPM_RESULTS=$("${COMMAND_ARR[@]}")
FPM_EXIT_CODE=$?
+ echo "fpm: exit code $FPM_EXIT_CODE" >>$STDOUT_IF_DEBUG
+ echo "$FPM_RESULTS" >>$STDOUT_IF_DEBUG
fpm_verify $FPM_EXIT_CODE $FPM_RESULTS
FPM_RESULTS=$@
FPM_PACKAGE_NAME=''
- if [[ $FPM_RESULTS =~ ([A-Za-z0-9_\.-]*\.)(deb|rpm) ]]; then
+ if [[ $FPM_RESULTS =~ ([A-Za-z0-9_\.~-]*\.)(deb|rpm) ]]; then
FPM_PACKAGE_NAME=${BASH_REMATCH[1]}${BASH_REMATCH[2]}
fi
projects / arvados.git / blobdiff