build-recipe

#
# recipe specific functions for the build script
#
################################################################
#
# Copyright (c) 1995-2014 SUSE Linux Products GmbH
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 or 3 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program (see the file COPYING); if not, write to the
# Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
#
################################################################


BUILDTYPE=
KIWI_PARAMETERS=
BUILD_SKIP_BUNDLE=
BUILD_TOOL_OPTS=()
RPM_BUILD_IN_PLACE=
RPM_RECIPE_IN_SUBDIR=
RPM_NOPREP=
BUILD_CHANGELOG_TIMESTAMP=
BUILD_VCSURL=

for i in spec dsc kiwi productcompose arch collax preinstallimage simpleimage mock livebuild snapcraft debootstrap debbuild appimage docker podman fissile helm flatpak mkosi apk; do
    . "$BUILD_DIR/build-recipe-$i"
done

recipe_setup() {
    recipe_setup_$BUILDTYPE "$@"
}

recipe_prepare() {
    recipe_prepare_$BUILDTYPE "$@"
}

recipe_build() {
    recipe_build_$BUILDTYPE "$@"
}

recipe_run_post_hook() {
    # Hook for running any post build modification scripts provided via a package
    if test -d $BUILD_ROOT/usr/lib/build/post_build.d ; then
        for hook in $BUILD_ROOT/usr/lib/build/post_build.d/*; do
          test -x "$hook" || continue
          if ! chroot $BUILD_ROOT su -c "/usr/lib/build/post_build.d/${hook##*/}" ; then
              cleanup_and_exit 1 "/usr/lib/build/post_build.d/${hook##*/} script failed!"
          fi
        done
    fi
}

recipe_resultdirs () {
    recipe_resultdirs_$BUILDTYPE "$@"
}

recipe_cleanup () {
    recipe_cleanup_$BUILDTYPE "$@"
}

recipe_parse_options() {
    case ${PARAM/#--/-} in
      -buildtool-opt)
	needarg
	BUILD_TOOL_OPTS[${#BUILD_TOOL_OPTS[@]}]=$ARG
	shift
	;;
      -stage)
	needarg
	BUILD_RPM_BUILD_STAGE="$ARG"
	shift
	;;
      -kiwi-parameter)
	test -z "$ARG" && ARG="$1"
	needarg
	KIWI_PARAMETERS="$KIWI_PARAMETERS $ARG"
	shift
	;;
      -skip-bundle)
	BUILD_SKIP_BUNDLE=1
        ;;
      -rpm-build-in-place)
	RPM_BUILD_IN_PLACE=1
        ;;
      -rpm-build-in-place-noprep)
	RPM_BUILD_IN_PLACE=1
	RPM_NOPREP=1
        ;;
      -rpm-recipe-in-subdir)
	RPM_BUILD_IN_PLACE=1
	RPM_RECIPE_IN_SUBDIR=1
	;;
      -rpm-noprep)
	RPM_NOPREP=1
        ;;
      -vcs)
	needarg
	BUILD_VCSURL="$ARG"
	shift
      ;;
      -*)
	return 1
	;;
    esac
    nextargs=("$@")
    return 0
}

recipe_set_buildtype() {
    BUILDTYPE=
    case ${RECIPEFILE##_service:*:} in
        *.spec|*.src.rpm) BUILDTYPE=spec ;;
        *.dsc) BUILDTYPE=dsc ;;
        *.kiwi) BUILDTYPE=kiwi ;;
        *.productcompose) BUILDTYPE=productcompose ;;
        PKGBUILD) BUILDTYPE=arch ;;
        APKBUILD) BUILDTYPE=apk ;;
        snapcraft.yaml) BUILDTYPE=snapcraft ;;
        appimage.yml) BUILDTYPE=appimage ;;
        Dockerfile|Dockerfile.*) BUILDTYPE=docker ;;
        fissile.yml) BUILDTYPE=fissile ;;
        build.collax) BUILDTYPE=collax ;;
        _preinstallimage) BUILDTYPE=preinstallimage ;;
        simpleimage) BUILDTYPE=simpleimage ;;
        *.livebuild) BUILDTYPE=livebuild ;;
        Chart.yaml) BUILDTYPE=helm ;;
        flatpak.yaml) BUILDTYPE=flatpak ;;
        flatpak.yml) BUILDTYPE=flatpak ;;
        flatpak.json) BUILDTYPE=flatpak ;;
        debian.control) BUILDTYPE=dsc ;;
        debian/control) BUILDTYPE=dsc ;;
        mkosi.*) BUILDTYPE=mkosi ;;
    esac
    if test -z "$BUILDTYPE" ; then
	cleanup_and_exit 1 "I don't know how to build $RECIPEFILE"
    fi
    # we can't query right after vm startup, so we put the BUILDENGINE in the build.data
    if test -z "$RUNNING_IN_VM" ; then
	BUILDENGINE=
	if test -n "$BUILD_DIST" ; then
	    BUILDENGINE=`queryconfig buildengine --dist "$BUILD_DIST" --configdir "$CONFIG_DIR" --archpath "$BUILD_ARCH"`
	    test "$BUILDENGINE" = UNDEFINED && BUILDENGINE=
	    if test -z "$BUILDENGINE" ; then
		BUILDENGINE=`queryconfig --dist "$BUILD_DIST" --configdir "$CONFIG_DIR" --archpath "$BUILD_ARCH" buildflags "buildengine.$BUILDTYPE"`
		test "$BUILDENGINE" = UNDEFINED && BUILDENGINE=
	    fi
	fi
    fi
    # tweak buildtype according to engine
    if test "$BUILDENGINE" = mock -a "$BUILDTYPE" = spec ; then
	BUILDTYPE=mock
    fi
    if test "$BUILDENGINE" = debootstrap -a "$BUILDTYPE" = dsc ; then
	BUILDTYPE=debootstrap
    fi
    if test "$BUILDENGINE" = debbuild -a "$BUILDTYPE" = spec ; then
	BUILDTYPE=debbuild
    fi
    if test "$BUILDENGINE" = podman -a "$BUILDTYPE" = docker ; then
	BUILDTYPE=podman
    fi
}

# expands all directories into files
expand_recipe_directories() {
    local f t ff found types subdir
    if test -z "$RECIPEFILES" ; then
	set -- "`pwd`"
    else
	set -- "${RECIPEFILES[@]}"
    fi
    RECIPEFILES=()
    for f in "$@" ; do
	if test "$f" = "${f#/}" ; then
	    f="`pwd`/$f"
	fi
	if test -d "$f" ; then
	    if test -z "$types" ; then
		if test -n "$BUILD_DIST" ; then
		    case $(queryconfig --dist "$BUILD_DIST" --configdir "$CONFIG_DIR" --archpath "$BUILD_ARCH" type) in
			dsc) types=".dsc" ;;
			kiwi) types=".kiwi" ;;
			productcompose) types=".productcompose" ;;
			arch) types="PKGBUILD" ;;
			apk) types="APKBUILD" ;;
			collax) types="build.collax" ;;
			livebuild) types=".livebuild" ;;
			snapcraft) types="snapcraft.yaml" ;;
			mkosi) types="mkosi." ;;
		    esac
		fi
		types="$types .spec _specsubdir:package _specsubdir:dist .dsc PKGBUILD APKBUILD Dockerfile build.collax .kiwi .productcompose .src.rpm .nosrc.rpm simpleimage snapcraft.yaml Chart.yaml flatpak.yaml flatpak.json mkosi."
	    fi
	    for t in $types ; do
		found=
		subdir=
		if test "$t" != ${t#_specsubdir:} ; then
		    test -n "$RPM_BUILD_IN_PLACE" && continue
		    subdir="${t#_specsubdir:}"
		    t="$subdir/*.spec"
		fi
		if test "$t" = mkosi. ; then
		    files=("$f"/$t*)
		else
		    files=("$f"/*$t)
		fi
		for ff in "${files[@]}"; do
		    test -f "$ff" || continue
		    RECIPEFILES=("${RECIPEFILES[@]}" "$ff")
		    found=true
		done
		if test -n "$found" -a -n "$subdir" ; then
		    echo "spec files found in '$subdir' directory, enabling build-in-place mode"
		    RPM_BUILD_IN_PLACE=1
		    RPM_RECIPE_IN_SUBDIR=1
		fi
		test -n "$found" && break
		if test "$t" = .dsc -a -f "$f/debian.control" ; then
		    RECIPEFILES=("${RECIPEFILES[@]}" "$f/debian.control")
		    break
		fi
		if test "$t" = .dsc -a -f "$f/debian/control" ; then
		    RECIPEFILES=("${RECIPEFILES[@]}" "$f/debian/control")
		    break
		fi
	    done
	else
	    RECIPEFILES[${#RECIPEFILES[@]}]="$f"
	fi
    done
    if test -z "$RECIPEFILES" ; then
	cleanup_and_exit 1 "no recipe files found in $@. exit..."
    fi
}

# extract macros from configuration
# these are potentialy also used in non-rpm builds
recipe_setup_macros() {
    spec_setup_macros
}

# generate a .build-changelog file from a .changes file
recipe_create_changelog() {
   rm -f $BUILD_ROOT/.build-changelog $BUILD_ROOT/.build-changelog-timestamp
   case $1 in
	*.dsc) CFFORMAT=debian ;;
	*) CFFORMAT=rpm ;;
    esac
    # add --emailonly option for sles builds
    if test "$CFFORMAT" = rpm ; then
	case `queryconfig --dist "$BUILD_DIST" --configdir "$CONFIG_DIR" --archpath "$BUILD_ARCH" eval '%{?is_opensuse}/%{?!fullname_in_changelog:%{?suse_version}}'` in
	  *[1-9]*/*) ;;
	  */*[1-9]*) CFFORMAT="$CFFORMAT --emailonly" ;;
	esac
    fi
    echo "running changelog2spec --target $CFFORMAT --file $1"
    if ! $BUILD_DIR/changelog2spec --target $CFFORMAT --timestampfile "$BUILD_ROOT/.build-changelog-timestamp" --file "$1" > $BUILD_ROOT/.build-changelog ; then 
	rm -f $BUILD_ROOT/.build-changelog $BUILD_ROOT/.build-changelog-timestamp
    fi
    BUILD_CHANGELOG_TIMESTAMP=
    if test -s "$BUILD_ROOT/.build-changelog-timestamp" ; then
	read BUILD_CHANGELOG_TIMESTAMP < "$BUILD_ROOT/.build-changelog-timestamp" 
    fi
    rm -f $BUILD_ROOT/.build-changelog-timestamp
}

recipe_needs_build_binaries() {
    test "$BUILDTYPE" = mock && return 0
    test "$BUILDTYPE" = debootstrap && return 0
    test "$BUILDTYPE" = livebuild && return 0
    test "$BUILDTYPE" = snapcraft && return 0
    test "$BUILDTYPE" = appimage && return 0
    test "$BUILDTYPE" = mkosi && return 0
    test "$BUILDTYPE" = preinstallimage && return 1
    grep -E '^#[[:blank:]]*needsbinariesforbuild[[:blank:]]*$' >/dev/null <"$1" && return 0
    return 1
}

recipe_build_time_statistics() {
    if test "$DO_STATISTICS" = 1 -a -n "$RECIPE_BUILD_START_TIME" -a -n "$TOPDIR" -a -n "$RUNNING_IN_VM" ; then
	mkdir -p "$TOPDIR/OTHER"
	echo "TIME_main_build: $(( `date +%s` - $RECIPE_BUILD_START_TIME))"  >> "$TOPDIR/OTHER/_statistics"
	RECIPE_BUILD_START_TIME=
    fi
}

recipe_checks_config() {
    if test -z "$DO_CHECKS"; then
        local nochecks=$(queryconfig \
                --dist "$BUILD_DIST" --configdir "$CONFIG_DIR" \
                --archpath "$BUILD_ARCH" buildflags nochecks
            )
        test -n "$nochecks" && DO_CHECKS=false || DO_CHECKS=true
    fi
}

recipe_gendiff() {
    local obsgendiff=$(queryconfig \
            --dist "$BUILD_DIST" --configdir "$CONFIG_DIR" \
            --archpath "$BUILD_ARCH" buildflags obsgendiff
        )

    if test -n "$obsgendiff"; then
         if test -d "$BUILD_ROOT/usr/lib/build/obsgendiff.d"; then
             for script in "$BUILD_ROOT"/usr/lib/build/obsgendiff.d/*; do
                 if test -x "$script" && ! chroot "$BUILD_ROOT" "/usr/lib/build/obsgendiff.d/${script##*/}" ; then
                     cleanup_and_exit 1 "/usr/lib/build/obsgendiff.d/${script##*/} script failed!"
                 fi
             done
         else
             cleanup_and_exit 1 "ERROR: obsgendiff enabled but no script installed"
         fi
    fi
}