Dario Faggioli
d4b795b3fc
- Fix bsc#1204001. Patches are not upstream, and have been picked up and backported from the ML. This is something we usually prefer to avoid, but this is urgent, and the patches looks fine, with high chances for them to be included as they are (and if they're not, we will revisit this, i.e., drop them and re-include the ones that are actually committed) * Patches added: linux-user-add-more-compat-ioctl-definit.patch linux-user-drop-conditionals-for-obsolet.patch linux-user-remove-conditionals-for-many-.patch meson-enforce-a-minimum-Linux-kernel-hea.patch - Improve the output of update_git.sh, by including the list of repos to which we have downstream patches. - Fix: bsc#1202665, CVE-2022-2962 * Patches added: net-tulip-Restrict-DMA-engine-to-memorie.patch OBS-URL: https://build.opensuse.org/request/show/1007904 OBS-URL: https://build.opensuse.org/package/show/Virtualization/qemu?expand=0&rev=735
1099 lines
45 KiB
Bash
1099 lines
45 KiB
Bash
#!/bin/bash
|
|
|
|
set -e
|
|
|
|
# update_git.sh: script to manage package maintenance using a git-based
|
|
# workflow. Commands are as follows:
|
|
# git2pkg (update package spec file and patches from git)
|
|
# pkg2git (update git (frombundle branch) from the package "bundleofbundles")
|
|
# refresh (refresh spec file from spec file template and "bundlofbundles")
|
|
# ci (check-in to obs, avoiding some spec file formatting issues)
|
|
# initbundle (Update/Create bundle only)
|
|
#
|
|
# (default is git2pkg)
|
|
|
|
#==============================================================================
|
|
|
|
clean_up_temp_dirs()
|
|
{
|
|
echo "Cleaning temporary files before exit"
|
|
exit
|
|
rm -rf $GIT_DIR
|
|
rm -rf $CMP_DIR
|
|
rm -rf $BUN_DIR
|
|
exit
|
|
}
|
|
|
|
# handle signals gracefully by cleaning the temporary data used before exit
|
|
trap clean_up_temp_dirs EXIT
|
|
|
|
#==============================================================================
|
|
|
|
check_requirements() {
|
|
RC=0
|
|
if [[ ! -e ./config.sh ]]; then
|
|
echo "ERROR: Missing config.sh configuration script"
|
|
RC=1
|
|
fi
|
|
if [[ ! $(rpm -q git-core) ]]; then
|
|
echo "ERROR: Missing dependency: git-core"
|
|
RC=1
|
|
fi
|
|
if [[ ! $(rpm -q osc) ]]; then
|
|
echo "ERROR: Missing dependency: osc package"
|
|
RC=1
|
|
fi
|
|
if [[ ! $(rpm -q obs-service-format_spec_file) ]]; then
|
|
echo "ERROR: Missing dependency: obs-service-format_spec_file package"
|
|
RC=1
|
|
fi
|
|
ONE_GIG_IN_1K_BLOCKS=1048576
|
|
AVAIL=$(df --output=avail $TMPDIR | tail -1)
|
|
if [[ $AVAIL -lt $ONE_GIG_IN_1K_BLOCKS ]]; then
|
|
echo "ERROR: Please provide at least 1GB available space in $TMPDIR"
|
|
RC=1
|
|
fi
|
|
if [[ "$RC" = "1" ]]; then
|
|
echo "Script requires the above resources. Please resolve to use this workflow"
|
|
exit
|
|
fi
|
|
}
|
|
|
|
#==============================================================================
|
|
|
|
usage() {
|
|
echo "Usage:"
|
|
echo "bash ./git_update.sh <command>"
|
|
echo "description: package maintenance using a git-based workflow. Commands:"
|
|
echo " git2pkg (update package spec file and patches from git. Is default)"
|
|
echo " pkg2git (update git (frombundle branch) from the package "bundleofbundles")"
|
|
echo " refresh (refresh spec file from spec file template and "bundlofbundles")"
|
|
echo " ci (check-in to build service, avoiding some spec file formatting issues)"
|
|
echo " initbundle (Update/Create bundle only)"
|
|
echo "(See script for details on doing 'LATEST' workflow)"
|
|
check_requirements
|
|
}
|
|
|
|
#==============================================================================
|
|
|
|
source ./config.sh
|
|
|
|
# If you're using LATEST, we assume you are an expert so no basic help provided
|
|
if [ "$GIT_UPSTREAM_COMMIT_ISH" != "LATEST" ]; then
|
|
if [ "$1" = "" ]; then
|
|
set -- git2pkg
|
|
else
|
|
case $1 in
|
|
help | -H | -h )
|
|
usage
|
|
exit
|
|
;;
|
|
initbundle | git2pkg | pkg2git | refresh | ci)
|
|
;;
|
|
* )
|
|
echo "Unknown command"
|
|
usage
|
|
exit
|
|
;;
|
|
esac
|
|
fi
|
|
fi
|
|
|
|
check_requirements
|
|
|
|
# As an aid to bypassing issues with our multibuild package and obs (see code
|
|
# below following the osc localrun of osc service localrun format_spec_file),
|
|
# provide an automated way to checkin without needing to type so much
|
|
if [ "$1" = "ci" ]; then
|
|
osc ci -f -n --noservice
|
|
exit
|
|
fi
|
|
|
|
|
|
# TODO: Here we should validate the variables that should be set in config.sh
|
|
|
|
REPO_COUNT=${#PATCH_PATH_MAP[@]}
|
|
if [[ "$REPO_COUNT" != "${#LOCAL_REPO_MAP[@]}" ]]; then
|
|
echo "PATCH_PATH_MAP and LOCAL_REPO_MAP array sizes do not agree - please fix"
|
|
exit
|
|
fi
|
|
|
|
check_requirements
|
|
|
|
# Zero based numbering, so we subtract 1 here:
|
|
if (( (REPO_COUNT * PATCH_RANGE) - 1 > 9999 )); then
|
|
if [[ "$OVERRIDE_FIVE_DIGIT_NUMBERING" = "1" ]]; then
|
|
FIVE_DIGIT_POTENTIAL=0
|
|
else
|
|
FIVE_DIGIT_POTENTIAL=1
|
|
fi
|
|
else
|
|
FIVE_DIGIT_POTENTIAL=0
|
|
fi
|
|
|
|
declare -A COMMIT_IDS_BY_SUBMODULE_PATH
|
|
|
|
# Get version info from the packages' tarball - decode and do some checks
|
|
BASE_RE="qemu-[[:digit:]]+(\.[[:digit:]]+){2,3}(-rc[[:digit:]])?"
|
|
EXTRA_RE="\+git\.[[:digit:]]+\.([[:xdigit:]]+)"
|
|
SUFFIX_RE="\.tar\.xz"
|
|
SIG_SUFFIX_RE="\.tar\.xz\.sig"
|
|
QEMU_TARBALL=($(find -maxdepth 1 -type f -regextype posix-extended -regex \
|
|
"\./$BASE_RE($EXTRA_RE)?$SUFFIX_RE" -printf "%f "))
|
|
QEMU_TARBALL_SIG=($(find -maxdepth 1 -type f -regextype posix-extended -regex \
|
|
"\./$BASE_RE($EXTRA_RE)?$SIG_SUFFIX_RE" -printf "%f "))
|
|
|
|
if [ ${#QEMU_TARBALL[@]} -gt 1 ]; then
|
|
echo "Multiple qemu tarballs detected. Please clean up"
|
|
exit
|
|
fi
|
|
if [ ${#QEMU_TARBALL_SIG[@]} -gt 1 ]; then
|
|
echo "Multiple qemu tarballs signature files detected. Please clean up"
|
|
exit
|
|
fi
|
|
OLD_SOURCE_VERSION_AND_EXTRA=$(echo $QEMU_TARBALL 2>/dev/null | head --bytes=-8\
|
|
| cut --bytes=6-)
|
|
VERSION_EXTRA=$(echo $OLD_SOURCE_VERSION_AND_EXTRA|awk -F+ '{if ($2) print \
|
|
"+"$2}')
|
|
if [ "$OLD_SOURCE_VERSION_AND_EXTRA" = "" ]; then
|
|
echo "ERROR: No tarball found!"
|
|
exit
|
|
fi
|
|
|
|
#==============================================================================
|
|
|
|
initbundle() {
|
|
# The bundle tarball has git bundles stored in a directory structure which mimics the
|
|
# submodule locations in the containing git repo. Also at that same dir level
|
|
# is a file named repo which contains the one line git repo url (with git:// or
|
|
# http(s) prefix). The bundles are named as follows:
|
|
# "{path/}{git_sha}.{bundle}", where {path/} isn't present for
|
|
# the top (qemu) bundle (ie it's for submodules).
|
|
|
|
find $GIT_DIR -mindepth 1 -delete
|
|
find $BUN_DIR -mindepth 1 -delete
|
|
if [[ -e ${LOCAL_REPO_MAP[$i]}/.git/shallow ]]; then
|
|
if [[ -e bundles.tar.xz ]]; then
|
|
tar --extract --xz -f bundles.tar.xz -C $BUN_DIR .
|
|
else
|
|
echo "ERROR: Superproject at ${LOCAL_REPO_MAP[$i]} is shallow (so we assume submodules aren't"
|
|
echo "recursively checked out), and there is not an existing bundle-of-bundles file, so we cannot"
|
|
echo "correctly initialize the packages bundle-of-bundles. Please fully initilize git superproject"
|
|
echo "before doing initbundle"
|
|
exit
|
|
fi
|
|
else
|
|
#TODO: Is there a better way to do this (we don't want the old bundle commit id's relied on HERE for LATEST)
|
|
if [[ "$GIT_UPSTREAM_COMMIT_ISH" = "LATEST" ]]; then
|
|
rm bundles.tar.xz
|
|
fi
|
|
if [[ -e bundles.tar.xz ]]; then
|
|
tar --extract --xz -f bundles.tar.xz -C $BUN_DIR .
|
|
else
|
|
SUBMODULE_COMMIT_IDS=($(git -C ${LOCAL_REPO_MAP[0]} submodule status --recursive| cut -c 2- | awk '{print $1}'))
|
|
SUBMODULE_DIRS=($(git -C ${LOCAL_REPO_MAP[0]} submodule status --recursive| cut -c 2- |awk '{print $2}'))
|
|
SUBMODULE_COUNT=${#SUBMODULE_COMMIT_IDS[@]}
|
|
# TODO: do this with simply math - ie: use (( ... ))
|
|
if [[ "$REPO_COUNT" != "$(expr $SUBMODULE_COUNT + 1)" ]]; then
|
|
echo "ERROR: submodule count doesn't match what's in config.sh"
|
|
exit
|
|
fi
|
|
for (( i=0; i <$SUBMODULE_COUNT; i++ )); do
|
|
mkdir -p $BUN_DIR/${SUBMODULE_DIRS[$i]}
|
|
touch $BUN_DIR/${SUBMODULE_DIRS[$i]}/${SUBMODULE_COMMIT_IDS[$i]}.id
|
|
done
|
|
if [ "$GIT_UPSTREAM_COMMIT_ISH" = "LATEST" ]; then
|
|
GIT_UPSTREAM_COMMIT=$NEW_COMMIT_ISH_FULL
|
|
else
|
|
# TODO: make this smarter, or change something - works for tag, but not normal commit?
|
|
GIT_UPSTREAM_COMMIT=$(git -C ${LOCAL_REPO_MAP[0]} show-ref -d $GIT_UPSTREAM_COMMIT_ISH|grep -F "^{}"|awk '{print $1}')
|
|
if [[ "$GIT_UPSTREAM_COMMIT" = "" ]]; then
|
|
GIT_UPSTREAM_COMMIT=$(git -C ${LOCAL_REPO_MAP[0]} show-ref -d $GIT_UPSTREAM_COMMIT_ISH||awk '{print $1}')
|
|
fi
|
|
if [[ "$GIT_UPSTREAM_COMMIT" = "" ]]; then
|
|
echo "ERROR: Failed to get commit id for $GIT_UPSTREAM_COMMIT_ISH"
|
|
exit
|
|
fi
|
|
fi
|
|
touch $BUN_DIR/$GIT_UPSTREAM_COMMIT.id
|
|
fi
|
|
fi
|
|
|
|
# Now go through all the submodule local repos that are present with a $GIT_BRANCH and create a bundle file for the patches found
|
|
for (( i=0; i <$REPO_COUNT; i++ )); do
|
|
if [[ -e $(readlink -f ${LOCAL_REPO_MAP[$i]}) ]]; then
|
|
SUBDIR=${PATCH_PATH_MAP[$i]}
|
|
GITREPO_COMMIT_ISH=($BUN_DIR/$SUBDIR*.id)
|
|
if [[ $GITREPO_COMMIT_ISH =~ .*(.{40})[.]id ]]; then
|
|
GITREPO_COMMIT_ISH=${BASH_REMATCH[1]}
|
|
echo "Using $GITREPO_COMMIT_ISH"
|
|
PATCH_RANGE_INDEX=$i
|
|
mkdir -p $GIT_DIR/$SUBDIR
|
|
git -C $GIT_DIR/$SUBDIR -c init.defaultBranch=$GIT_BRANCH init
|
|
git -C $GIT_DIR/$SUBDIR remote add origin file://$(readlink -f \
|
|
${LOCAL_REPO_MAP[$PATCH_RANGE_INDEX]})
|
|
if [[ $(git -C $GIT_DIR/$SUBDIR ls-remote --heads origin $GIT_BRANCH) ]]; then
|
|
git -C $GIT_DIR/$SUBDIR fetch --update-shallow origin $GIT_BRANCH
|
|
if [[ $(git -C $GIT_DIR/$SUBDIR rev-list $GITREPO_COMMIT_ISH..FETCH_HEAD) ]]; then
|
|
git -C $GIT_DIR/$SUBDIR bundle create $BUN_DIR/$SUBDIR$GITREPO_COMMIT_ISH.bundle $GITREPO_COMMIT_ISH..FETCH_HEAD
|
|
#TODO: post-process repo info to avoid un-needed diffs (eg git vs https)
|
|
git -C $(readlink -f ${LOCAL_REPO_MAP[$PATCH_RANGE_INDEX]}) remote get-url origin >$BUN_DIR/$SUBDIR/repo
|
|
else
|
|
local localbundle="$BUN_DIR/$SUBDIR$GITREPO_COMMIT_ISH.bundle"
|
|
if [[ -f "$localbundle" ]]; then
|
|
echo "Removing existing $localbundle"
|
|
rm "$localbundle"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
# parameters chosen to allow bundle tarball exact reproducibility
|
|
tar --format gnu --xz \
|
|
--sort=name \
|
|
--numeric-owner \
|
|
--owner=0 \
|
|
--group=0 \
|
|
--mtime="@$(date -r qemu-$SOURCE_VERSION$VERSION_EXTRA.tar.xz +%s)" \
|
|
--create \
|
|
-f bundles.tar.xz -C $BUN_DIR .
|
|
find $BUN_DIR -mindepth 1 -delete
|
|
find $GIT_DIR -mindepth 1 -delete
|
|
}
|
|
|
|
#==============================================================================
|
|
|
|
bundle2local() {
|
|
find $BUN_DIR -mindepth 1 -delete
|
|
tar xJf bundles.tar.xz -C $BUN_DIR
|
|
ID_FILES=$(find $BUN_DIR -printf "%P\n"|grep "id$")
|
|
|
|
for entry in ${ID_FILES[@]}; do
|
|
if [[ $entry =~ ^(.*)[/]*([a-f0-9]{40})[.]id$ ]]; then
|
|
SUBDIR=${BASH_REMATCH[1]}
|
|
GITREPO_COMMIT_ISH=${BASH_REMATCH[2]}
|
|
else
|
|
echo "ERROR! BAD BUNDLE CONTENT!"
|
|
exit
|
|
fi
|
|
for (( i=0; i <$REPO_COUNT; i++ )); do
|
|
if [[ "$SUBDIR" = "${PATCH_PATH_MAP[$i]}" ]]; then
|
|
PATCH_RANGE_INDEX=$i
|
|
break
|
|
fi
|
|
done
|
|
if [[ "$i" = "REPO_COUNT" ]]; then
|
|
echo "ERROR! BUNDLE SUBPROJECT $SUBDIR NOT MENTIONED IN config.sh! Fix!"
|
|
exit
|
|
fi
|
|
|
|
LOCAL_REPO=$(readlink -f ${LOCAL_REPO_MAP[$PATCH_RANGE_INDEX]})
|
|
if [ -e $LOCAL_REPO ]; then
|
|
git -C $LOCAL_REPO remote remove bundlerepo || true
|
|
if [ -e $BUN_DIR/$SUBDIR/$GITREPO_COMMIT_ISH.bundle ]; then
|
|
git -C $LOCAL_REPO remote add bundlerepo $BUN_DIR/$SUBDIR/$GITREPO_COMMIT_ISH.bundle
|
|
git -C $LOCAL_REPO fetch bundlerepo FETCH_HEAD
|
|
git -C $LOCAL_REPO branch -f frombundle FETCH_HEAD
|
|
git -C $LOCAL_REPO remote remove bundlerepo
|
|
else
|
|
# It's problematic to leave "stale" frombundle branches around
|
|
git -C $LOCAL_REPO branch -D frombundle || true
|
|
fi
|
|
else
|
|
if [ -e $BUN_DIR/$SUBDIR/$GITREPO_COMMIT_ISH.bundle ]; then
|
|
# TODO: We should be able to handle this case with some more coding, but for now...
|
|
echo "No local repo $LOCAL_REPO available to process git bundle!"
|
|
if [ "$GIT_UPSTREAM_COMMIT_ISH" = "LATEST" ]; then
|
|
echo "The above is FATAL when doing LATEST processing - please fix"
|
|
exit
|
|
else
|
|
echo "Moving on..."
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
find $BUN_DIR -mindepth 1 -delete
|
|
}
|
|
|
|
#==============================================================================
|
|
|
|
redo_tarball_and_rebase_patches() {
|
|
find $GIT_DIR -mindepth 1 -delete
|
|
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
# CREATE TARBALL, USING FRESH REPO - WE COULD RELY MORE ON LOCAL IF WE WERE MORE CAREFUL
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
# TODO: WHAT IS THIS NEXT LINE EVEN DOING FOR US?? (OK, it's initing a repo, what do we rely on there?)
|
|
# Here, the branch doesn't really matter, and we're not relying on a master branch - we're just making sure we are grabbing latest from upstream
|
|
# (while using a clone of "something close" as a way to quickly get most objects available as quickly as possible)
|
|
git clone -ls ${LOCAL_REPO_MAP[0]} -b $GIT_BRANCH --single-branch $GIT_DIR #&>/dev/null
|
|
echo "Please wait..."
|
|
(cd $GIT_DIR && git remote add upstream \
|
|
$UPSTREAM_GIT_REPO &>/dev/null)
|
|
(cd $GIT_DIR && git remote update upstream &>/dev/null)
|
|
(cd $GIT_DIR && git reset --hard --recurse-submodules $NEW_COMMIT_ISH &>/dev/null)
|
|
# As an alternative, we could add a --recurse-submodules to the checkout instead here as well, right?
|
|
#UPSTREAM DOESNT DO THIS (time takes 17 minutes!):
|
|
# (cd $GIT_DIR && git submodule update --init --recursive &>/dev/null)
|
|
#INSTEAD THESE NEXT TWO LINES ARE WHAT IS DONE (these take 9 minutes and 3 minutes respectively):
|
|
(cd $GIT_DIR && git submodule update --init &>/dev/null)
|
|
(cd $GIT_DIR/roms/edk2 && git submodule update --init &>/dev/null)
|
|
VERSION_EXTRA=+git.$NOW_SECONDS.$NEW_COMMIT_ISH
|
|
if (cd ${LOCAL_REPO_MAP[0]} && git describe --exact-match $NEW_COMMIT_ISH \
|
|
&>/dev/null); then
|
|
if [ "$X" = "50" ]; then
|
|
echo "Ignoring non-standard tag"
|
|
else
|
|
# there is no VERSION_EXTRA
|
|
VERSION_EXTRA=
|
|
fi
|
|
fi
|
|
(cd $GIT_DIR/roms/seabios && git describe --tags --long --dirty > \
|
|
.version)
|
|
(cd $GIT_DIR/roms/skiboot && ./make_version.sh > .version)
|
|
echo "Almost there..."
|
|
tar --exclude=.git --transform "s,$GIT_DIR,qemu-$SOURCE_VERSION," \
|
|
-Pcf qemu-$SOURCE_VERSION$VERSION_EXTRA.tar $GIT_DIR
|
|
osc rm --force qemu-$OLD_SOURCE_VERSION_AND_EXTRA.tar.xz &>/dev/null ||\
|
|
true
|
|
osc rm --force qemu-$OLD_SOURCE_VERSION_AND_EXTRA.tar.xz.sig \
|
|
&>/dev/null || true
|
|
unset QEMU_TARBALL_SIG
|
|
xz -T 0 qemu-$SOURCE_VERSION$VERSION_EXTRA.tar
|
|
osc add qemu-$SOURCE_VERSION$VERSION_EXTRA.tar.xz
|
|
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
# GET THE SUBMODULE COMMIT ID'S FROM THIS NEWLY MINTED QEMU CHECKOUT. WE'LL USE THAT WHEN WE REBASE OUR PATCHES
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
# !! We (perhaps temporarily) do MORE recursive submodules, since we are tracking ALL in these scripts, while upstream doesn't include all in tarball currently
|
|
# !!! THIS IS AT LEAST PARTLY REDUNDANT WITH THE update --init DONE ABOUT 30 LINES AGO
|
|
(cd $GIT_DIR && git submodule update --init --recursive &>/dev/null)
|
|
SUBMODULE_COMMIT_IDS=($(git -C $GIT_DIR submodule status --recursive|awk '{print $1}'))
|
|
SUBMODULE_DIRS=($(git -C $GIT_DIR submodule status --recursive|awk '{print $2}'))
|
|
SUBMODULE_COUNT=${#SUBMODULE_COMMIT_IDS[@]}
|
|
# TODO: do this with simply math - ie: use (( ... ))
|
|
if [[ "$REPO_COUNT" != "$(expr $SUBMODULE_COUNT + 1)" ]]; then
|
|
echo "ERROR: submodule count doesn't match the REPO_COUNT variable in config.sh file!"
|
|
exit
|
|
fi
|
|
# We have the submodule commits, but not in the PATCH ORDER which our config.sh has (see $PATCH_PATH_MAP)
|
|
for (( i=0; i <$REPO_COUNT-1; i++ )); do
|
|
COMMIT_IDS_BY_SUBMODULE_PATH[${SUBMODULE_DIRS[$i]}/]=${SUBMODULE_COMMIT_IDS[$i]}
|
|
done
|
|
COMMIT_IDS_BY_SUBMODULE_PATH[SUPERPROJECT]=$NEW_COMMIT_ISH_FULL
|
|
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
# MOVE BUNDLE COMMITS OVER TO LOCAL frombundle BRANCH
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
bundle2local
|
|
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
# REBASE $GIT_BRANCH's on latest COMMIT_IDS_FROM_SUBMODULE_PATH, after reseting branch to frombundle branch
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
for (( i=0; i <$REPO_COUNT; i++ )); do
|
|
if [[ -e $(readlink -f ${LOCAL_REPO_MAP[$i]}) ]]; then
|
|
if $(git -C ${LOCAL_REPO_MAP[$i]} branch | grep -F "frombundle" >/dev/null); then
|
|
SUBDIR=${PATCH_PATH_MAP[$i]}
|
|
git -C ${LOCAL_REPO_MAP[$i]} checkout -B $GIT_BRANCH frombundle
|
|
if [[ "$SUBDIR" = "" ]]; then
|
|
SUBDIR=SUPERPROJECT
|
|
fi
|
|
if ! $(git -C ${LOCAL_REPO_MAP[$i]} rebase ${COMMIT_IDS_BY_SUBMODULE_PATH[$SUBDIR]} >/dev/null); then
|
|
echo "Rebase of ${LOCAL_REPO_MAP[$i]}, branch $GIT_BRANCH needs manual help"
|
|
REBASE_FAILS="${LOCAL_REPO_MAP[$i]} $REBASE_FAILS"
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
#==============================================================================
|
|
|
|
bundle2spec() {
|
|
rm -f checkpatch.log
|
|
rm -f checkthese
|
|
rm -rf checkdir
|
|
rm -rf savedir
|
|
find $GIT_DIR -mindepth 1 -delete
|
|
find $CMP_DIR -mindepth 1 -delete
|
|
find $BUN_DIR -mindepth 1 -delete
|
|
mkdir savedir
|
|
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
# Handle case of casual user missing local repos.
|
|
# To support this, we must grok the spec file's
|
|
# list of patches for "reuse" in case we don't
|
|
# have local repo to use for extracting bundle
|
|
# contents. (here we assume the existing bundle
|
|
# would then still correspond to the patches
|
|
# listed in spec file for that repo)
|
|
# WARNING:
|
|
# The following groking expects the patch section
|
|
# to be as this script lays it out, not modified!
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
declare -a PATCHES_BY_SUBMODULE_PATH
|
|
IN_PATCH_SECTION=0
|
|
INDEX=$REPO_COUNT # "invalid" since zero based index of objects < one based count of objects
|
|
while IFS= read -r line; do
|
|
if [[ "$line" = "# Patches applied in base project:" ]]; then
|
|
IN_PATCH_SECTION=1
|
|
INDEX=0 # base project is 0 by definition
|
|
continue
|
|
fi
|
|
if [[ "$line" =~ ^..Patches.applied.in.(.*)/:$ ]]; then
|
|
REPO="${BASH_REMATCH[1]}/"
|
|
IN_PATCH_SECTION=1
|
|
for (( i=0; i <$REPO_COUNT; i++ )); do
|
|
if [[ "$REPO" = "${PATCH_PATH_MAP[$i]}" ]]; then
|
|
if [[ "$INDEX" != "$REPO_COUNT" ]]; then
|
|
PATCHES_BY_SUBMODULE_PATH[$INDEX]=$ACCUMULATED_PATCHES
|
|
unset ACCUMULATED_PATCHES
|
|
fi
|
|
INDEX=$i
|
|
break
|
|
fi
|
|
done
|
|
if [[ "$INDEX" = "$REPO_COUNT" ]]; then
|
|
echo "ERROR: Failure groking spec file for patches!"
|
|
exit
|
|
fi
|
|
continue
|
|
fi
|
|
if [[ "$IN_PATCH_SECTION" = "0" ]]; then
|
|
continue
|
|
fi
|
|
if [[ "$line" =~ ^$ ]]; then
|
|
PATCHES_BY_SUBMODULE_PATH[$INDEX]=$ACCUMULATED_PATCHES
|
|
break;
|
|
fi
|
|
if [[ "$line" =~ ^#?Patch[0-9]*:[\ ]*(.*)$ ]]; then
|
|
PATCH="${BASH_REMATCH[1]}"
|
|
#echo "Patch is $PATCH"
|
|
ACCUMULATED_PATCHES="$ACCUMULATED_PATCHES $PATCH"
|
|
continue
|
|
fi
|
|
echo "ERROR: Failure groking spec file for patches!"
|
|
exit
|
|
done < $PKG.spec
|
|
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
# CONVERT BUNDLES INTO COMMITS AND FILL SPEC FILE
|
|
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
tar xJf bundles.tar.xz -C $BUN_DIR
|
|
BUNDLE_FILES=$(find $BUN_DIR -printf "%P\n"|grep "bundle$")
|
|
|
|
for entry in ${BUNDLE_FILES[@]}; do
|
|
if [[ $entry =~ ^(.*)[/]*([a-f0-9]{40})[.]bundle$ ]]; then
|
|
SUBDIR=${BASH_REMATCH[1]}
|
|
GITREPO_COMMIT_ISH=${BASH_REMATCH[2]}
|
|
else
|
|
echo "ERROR! BAD BUNDLE CONTENT!"
|
|
exit
|
|
fi
|
|
for (( i=0; i <$REPO_COUNT; i++ )); do
|
|
if [[ "$SUBDIR" = "${PATCH_PATH_MAP[$i]}" ]]; then
|
|
PATCH_RANGE_INDEX=$i
|
|
break
|
|
fi
|
|
done
|
|
|
|
if [[ -e $(readlink -f ${LOCAL_REPO_MAP[$PATCH_RANGE_INDEX]}) ]]; then
|
|
mkdir -p $GIT_DIR/$SUBDIR
|
|
git -C $GIT_DIR/$SUBDIR -c init.defaultBranch=$GIT_BRANCH init
|
|
git -C $GIT_DIR/$SUBDIR remote add origin file://$(readlink -f \
|
|
${LOCAL_REPO_MAP[$PATCH_RANGE_INDEX]})
|
|
# This tag reference, was added to resolve $GITREPO_COMMIT_ISH, which is tag as commit-id
|
|
# Since origin may be shallow, we need to use the --update-shallow option
|
|
git -C $GIT_DIR/$SUBDIR fetch --update-shallow origin $GIT_BRANCH
|
|
git -C $GIT_DIR/$SUBDIR remote add bundle $BUN_DIR/$entry
|
|
git -C $GIT_DIR/$SUBDIR fetch bundle FETCH_HEAD
|
|
git -C $GIT_DIR/$SUBDIR format-patch -N --suffix= --no-renames -o $CMP_DIR -k --stat=72 \
|
|
--indent-heuristic --zero-commit --no-signature --full-index \
|
|
--src-prefix=a/$SUBDIR --dst-prefix=b/$SUBDIR \
|
|
--start-number=$(expr $PATCH_RANGE_INDEX \* $PATCH_RANGE) \
|
|
$GITREPO_COMMIT_ISH..FETCH_HEAD > /dev/null
|
|
PATCHES_BY_SUBMODULE_PATH[$PATCH_RANGE_INDEX]=""
|
|
else
|
|
# TODO: This doesn't handle numbered patches yet
|
|
COUNTER=$(expr $PATCH_RANGE_INDEX \* $PATCH_RANGE)
|
|
for patchname in ${PATCHES_BY_SUBMODULE_PATH[$PATCH_RANGE_INDEX]}; do
|
|
VALUE="0000"$COUNTER
|
|
if [ "$FIVE_DIGIT_POTENTIAL" = "1" ]; then
|
|
PREFIX=$(echo $VALUE|tail -c 6)
|
|
else
|
|
PREFIX=$(echo $VALUE|tail -c 5)
|
|
fi
|
|
if [[ "$NUMBERED_PATCHES" = "0" ]]; then
|
|
cp $patchname savedir/$PREFIX-$patchname
|
|
else
|
|
cp $patchname savedir/$patchname
|
|
fi
|
|
let COUNTER+=1
|
|
done
|
|
fi
|
|
done
|
|
|
|
find $GIT_DIR -mindepth 1 -delete
|
|
find $BUN_DIR -mindepth 1 -delete
|
|
|
|
(
|
|
CHANGED_COUNT=0
|
|
UNCHANGED_COUNT=0
|
|
DELETED_COUNT=0
|
|
ADDED_COUNT=0
|
|
TOTAL_COUNT=0
|
|
|
|
shopt -s nullglob
|
|
|
|
for i in $CMP_DIR/*; do
|
|
# index line isn't consistent, so cut full index to normal line length
|
|
sed -E -i 's/(^index [a-f0-9]{28})[a-f0-9]{12}([.][.][a-f0-9]{28})[a-f0-9]{12}( [0-9]{6}$)/\1\2\3/' $i
|
|
BASENAME=$(basename $i)
|
|
if [ "$FIVE_DIGIT_POTENTIAL" = "1" ]; then
|
|
if [[ "$BASENAME" =~ ^[[:digit:]]{5}.* ]]; then
|
|
:
|
|
else
|
|
BASENAME=0"$BASENAME"
|
|
fi
|
|
fi
|
|
if [[ "$NUMBERED_PATCHES" = "0" ]]; then
|
|
KEEP_COUNT=40+4+$FIVE_DIGIT_POTENTIAL+1
|
|
else
|
|
KEEP_COUNT=40
|
|
fi
|
|
tail -n +2 $i > $CMP_DIR/"${BASENAME:0:$KEEP_COUNT}".patch
|
|
rm $i
|
|
done
|
|
cp savedir/* $CMP_DIR/ || true
|
|
rm -rf savedir
|
|
# 4 digit xxxx-name used in the dest (remember that if 5 digit potential, then if not now 5 digit, add a 0 in front)
|
|
|
|
if [[ "$NUMBERED_PATCHES" = "0" ]]; then
|
|
for i in [0-9][0-9][0-9][0-9]*-*.patch; do
|
|
osc rm --force "$i"
|
|
done
|
|
# make sure that w/out the numbered prefixes, the patchnames are all unique
|
|
mkdir checkdir
|
|
for i in $CMP_DIR/*; do
|
|
BASENAME=$(basename $i)
|
|
FINALNAME="${BASENAME:4+$FIVE_DIGIT_POTENTIAL+1:40+1+5}"
|
|
if [[ -e checkdir/"$FINALNAME" ]]; then
|
|
echo "ERROR! Patch name $FINALNAME is not unique! Please modify patch subject to achieve uniqueness"
|
|
exit 1
|
|
fi
|
|
cp $i checkdir/"$FINALNAME"
|
|
done
|
|
CHECK_DIR=checkdir
|
|
cp $CMP_DIR/*.patch .
|
|
else
|
|
CHECK_DIR=$CMP_DIR
|
|
fi
|
|
if [ "$FIVE_DIGIT_POTENTIAL" = "0" ]; then
|
|
CHECK_PREFIX="0"
|
|
NUMBERED_PATCH_RE="^[[:digit:]]{4}-.*[.]patch$"
|
|
else
|
|
CHECK_PREFIX="00"
|
|
NUMBERED_PATCH_RE="^[[:digit:]]{5}-.*[.]patch$"
|
|
fi
|
|
for i in $CHECK_DIR/*; do
|
|
BASENAME=$(basename $i)
|
|
if [ -e "$BASENAME" ]; then
|
|
if cmp -s "$i" "$BASENAME"; then
|
|
touch --reference="$BASENAME" "$i"
|
|
rm "$BASENAME"
|
|
let UNCHANGED_COUNT+=1
|
|
else
|
|
if [ "${BASENAME:0:1+$FIVE_DIGIT_POTENTIAL}" = "$CHECK_PREFIX" ]; then
|
|
echo "$BASENAME" >> checkthese
|
|
fi
|
|
rm $BASENAME
|
|
let CHANGED_COUNT+=1
|
|
let TOTAL_COUNT+=1
|
|
fi
|
|
else
|
|
echo " $BASENAME" >> qemu.changes.added
|
|
if [ "${BASENAME:0:1+$FIVE_DIGIT_POTENTIAL}" = "$CHECK_PREFIX" ]; then
|
|
echo "$BASENAME" >> checkthese
|
|
fi
|
|
let ADDED_COUNT+=1
|
|
let TOTAL_COUNT+=1
|
|
fi
|
|
done
|
|
for i in *.patch; do
|
|
if [[ "$i" =~ $NUMBERED_PATCH_RE ]]; then
|
|
if [[ "$NUMBERED_PATCHES" = "1" ]]; then
|
|
osc rm --force $i
|
|
echo " $i" >> qemu.changes.deleted
|
|
let DELETED_COUNT+=1
|
|
let TOTAL_COUNT+=1
|
|
fi
|
|
else
|
|
osc rm --force $i
|
|
echo " $i" >> qemu.changes.deleted
|
|
let DELETED_COUNT+=1
|
|
let TOTAL_COUNT+=1
|
|
fi
|
|
done
|
|
mv $CHECK_DIR/* .
|
|
if [ -e qemu.changes.added ]; then
|
|
xargs osc add < qemu.changes.added
|
|
fi
|
|
|
|
if [[ -e checkthese ]]; then
|
|
tar Jxf qemu-$SOURCE_VERSION$VERSION_EXTRA.tar.xz \
|
|
qemu-$SOURCE_VERSION/scripts/checkpatch.pl --strip-components=2
|
|
for i in $(cat checkthese); do
|
|
./checkpatch.pl --no-tree --terse --no-summary --summary-file \
|
|
--patch $i >> checkpatch.log || true
|
|
done
|
|
fi
|
|
rm -f checkthese
|
|
rm -f checkpatch.pl
|
|
if [ -s checkpatch.log ]; then
|
|
echo "WARNING: Issues reported by qemu patch checker. Please handle" \
|
|
"ERROR items now:"
|
|
cat checkpatch.log
|
|
fi
|
|
rm -f checkpatch.log
|
|
if [ "$TOTAL_COUNT" != "0" -a "$VERSION_EXTRA" != "" -a "$OLD_COMMIT_ISH" =\
|
|
"$NEW_COMMIT_ISH" ]; then
|
|
# Only patches changed: update the version using current timestamp
|
|
VERSION_EXTRA=+git.$NOW_SECONDS.$OLD_COMMIT_ISH
|
|
osc mv qemu-$OLD_SOURCE_VERSION_AND_EXTRA.tar.xz \
|
|
qemu-$SOURCE_VERSION$VERSION_EXTRA.tar.xz
|
|
osc add qemu-$SOURCE_VERSION$VERSION_EXTRA.tar.xz
|
|
fi
|
|
|
|
echo "QEMU version file: $QEMU_VERSION"
|
|
echo "QEMU source version: $SOURCE_VERSION"
|
|
echo "QEMU version extra: $VERSION_EXTRA"
|
|
|
|
# get rid of "rel-" prefix to the seabios version - keep any trailing git info, such as: "-44-g88ab0c1"
|
|
SEABIOS_VERSION=${SEABIOS_VERSION:-$(tar JxfO qemu-$SOURCE_VERSION$VERSION_EXTRA.tar.xz \
|
|
qemu-$SOURCE_VERSION/roms/seabios/.version | cut -c5- | tr '-' '_')}
|
|
|
|
for package in $PKG; do
|
|
while IFS= read -r line; do
|
|
if [ "$line" = "PATCH_FILES" ]; then
|
|
SPNUM=1000
|
|
SP_PATCHES=$(mktemp /tmp/sp-patches-XXXX)
|
|
# Here (and other places below) we try to get ONLY the numbered patches, but it's possible some ACTUAL patch name actually starts with multiple digits, but EXTREMELY unlikely
|
|
# TODO: do this better!
|
|
for i in [0-9][0-9][0-9][0-9]*-*.patch; do
|
|
COMMENT=""
|
|
if grep "^Include-If: " $i &> /dev/null ; then
|
|
COMMENT="#"
|
|
if [[ "$NUMBERED_PATCHES" = "0" ]]; then
|
|
PATCH_NUMBER=${i%%-*}
|
|
echo -e "Source$SPNUM: ${i:${#PATCH_NUMBER}+1:40+1+5}" >> $SP_PATCHES
|
|
else
|
|
echo -e "Source$SPNUM: $i" >> $SP_PATCHES
|
|
fi
|
|
SPNUM=$((SPNUM+1))
|
|
fi
|
|
NUM=${i%%-*}
|
|
DIV=$((10#$NUM/$PATCH_RANGE))
|
|
REM=$((10#$NUM%$PATCH_RANGE))
|
|
if [[ "$REM" = "0" ]]; then
|
|
if [[ "$DIV" = "0" ]]; then
|
|
echo "# Patches applied in base project:"
|
|
else
|
|
echo "# Patches applied in ${PATCH_PATH_MAP[$DIV]}:"
|
|
fi
|
|
fi
|
|
if [[ "$FIVE_DIGIT_POTENTIAL" != "0" ]]; then
|
|
if [[ "$NUMBERED_PATCHES" = "0" ]]; then
|
|
PATCH_NUMBER=${i%%-*}
|
|
echo -e "${COMMENT}Patch$NUM: ${i:${#PATCH_NUMBER}+1:40+1+5}"
|
|
else
|
|
echo -e "${COMMENT}Patch$NUM: $i"
|
|
fi
|
|
else
|
|
if [[ "$NUMBERED_PATCHES" = "0" ]]; then
|
|
PATCH_NUMBER=${i%%-*}
|
|
echo -e "${COMMENT}Patch$NUM: ${i:${#PATCH_NUMBER}+1:40+1+5}"
|
|
else
|
|
echo -e "${COMMENT}Patch$NUM: $i"
|
|
fi
|
|
fi
|
|
done
|
|
|
|
echo
|
|
echo "# Patches that will be applied directly across the spec file"
|
|
cat $SP_PATCHES
|
|
elif [ "$line" = "PATCH_EXEC" ]; then
|
|
unset PREV_S
|
|
for i in [0-9][0-9][0-9][0-9]*-*.patch; do
|
|
S=$(grep "^Include-If: " $i) || true
|
|
NUM=${i%%-*}
|
|
if [ "$PREV_S" != "" -a "$PREV_S" != "$S" ]; then
|
|
echo "%endif"
|
|
fi
|
|
if [ "$S" != "" -a "$S" != "$PREV_S" ]; then
|
|
echo "${S:12}"
|
|
fi
|
|
echo "%patch$NUM -p1"
|
|
PREV_S=$S
|
|
done
|
|
if [ "$PREV_S" != "" ]; then
|
|
echo "%endif"
|
|
fi
|
|
elif [ "$line" = "INSERT_VERSIONING" ]; then
|
|
echo "%define qemuver $QEMU_VERSION$VERSION_EXTRA"
|
|
echo "%define srcver $SOURCE_VERSION$VERSION_EXTRA"
|
|
# For SLE11, where seabios isn't in the qemu tarball:
|
|
if [[ "$SEABIOS_VERSION" != "" ]]; then
|
|
echo "%define sbver $SEABIOS_VERSION"
|
|
fi
|
|
elif [[ "$line" =~ ^Source: ]]; then
|
|
echo "$line"
|
|
if [ ${#QEMU_TARBALL_SIG[@]} -eq 1 ]; then
|
|
# We assume the signature file corresponds - just add .sig
|
|
echo "$line.sig"|sed 's/^Source: /Source99:/'
|
|
fi
|
|
else
|
|
echo "$line"
|
|
fi
|
|
done < $package.spec.in > $CMP_DIR/$package.spec
|
|
if cmp -s $package.spec $CMP_DIR/$package.spec; then
|
|
echo "$package.spec unchanged"
|
|
else
|
|
mv $CMP_DIR/$package.spec $package.spec
|
|
echo "$package.spec regenerated"
|
|
let PACKAGE_CHANGED_COUNT+=1
|
|
fi
|
|
|
|
if [ "$WRITE_LOG" = "1" ]; then
|
|
# Factory requires all deleted and added patches to be mentioned
|
|
if [ -e qemu.changes.deleted ]; then
|
|
echo "* Patches dropped:" >> $package.changes.proposed
|
|
cat qemu.changes.deleted >> $package.changes.proposed
|
|
fi
|
|
if [ -e qemu.changes.added ]; then
|
|
echo "* Patches added:" >> $package.changes.proposed
|
|
cat qemu.changes.added >> $package.changes.proposed
|
|
fi
|
|
if [ -e $package.changes.proposed ]; then
|
|
osc vc --file=$package.changes.proposed $package
|
|
rm -f $package.changes.proposed
|
|
fi
|
|
fi
|
|
done
|
|
if [[ "$NUMBERED_PATCHES" = "0" ]]; then
|
|
rm -f [0-9][0-9][0-9][0-9]*-*.patch
|
|
fi
|
|
if [ -e qemu.changes.deleted ]; then
|
|
rm -f qemu.changes.deleted
|
|
fi
|
|
if [ -e qemu.changes.added ]; then
|
|
rm -f qemu.changes.added
|
|
fi
|
|
echo "git patch summary"
|
|
echo " unchanged: $UNCHANGED_COUNT"
|
|
echo " changed: $CHANGED_COUNT"
|
|
echo " deleted: $DELETED_COUNT"
|
|
echo " added: $ADDED_COUNT"
|
|
)
|
|
|
|
find $CMP_DIR -mindepth 1 -delete
|
|
rm -rf checkdir
|
|
|
|
osc service localrun format_spec_file || true
|
|
# Repair what I feel is incorrect modification of the package name in the header.
|
|
# Be aware that when checking into build service you should use --noservice, since we've
|
|
# already run this and --noservice will prevent the modification from happening at checkin
|
|
# time.
|
|
sed -i 's/^# spec file for package '$PKG'%{name_suffix}$/# spec file for package '$PKG'/g' $PKG.spec
|
|
sed -i 's/^# spec file for package '$PKG'-linux-user$/# spec file for package '$PKG'/g' $PKG.spec
|
|
}
|
|
|
|
#==============================================================================
|
|
|
|
setup_common_vars() {
|
|
if [ "$GIT_UPSTREAM_COMMIT_ISH" = "LATEST" ]; then
|
|
QEMU_VERSION=$(git -C ${LOCAL_REPO_MAP[0]} show upstream/master:VERSION)
|
|
MAJOR_VERSION=$(echo $QEMU_VERSION|awk -F. '{print $1}')
|
|
MINOR_VERSION=$(echo $QEMU_VERSION|awk -F. '{print $2}')
|
|
X=$(echo $QEMU_VERSION|awk -F. '{print $3}')
|
|
# 0 = release, 50 = development cycle, 90..99 equate to release candidates
|
|
if [ "$X" != "0" -a "$X" != "50" ]; then
|
|
if [ "$NEXT_RELEASE_IS_MAJOR" = "0" ]; then
|
|
SOURCE_VERSION=$MAJOR_VERSION.$[$MINOR_VERSION+1].0-rc$[X-90]
|
|
GIT_BRANCH=opensuse-$MAJOR_VERSION.$[$MINOR_VERSION+1]
|
|
else
|
|
SOURCE_VERSION=$[$MAJOR_VERSION+1].0.0-rc$[X-90]
|
|
GIT_BRANCH=opensuse-$[$MAJOR_VERSION+1].0
|
|
fi
|
|
else
|
|
SOURCE_VERSION=$MAJOR_VERSION.$MINOR_VERSION.$X
|
|
if [ "$X" = "0" ]; then
|
|
GIT_BRANCH=opensuse-$MAJOR_VERSION.$[$MINOR_VERSION]
|
|
else
|
|
if [ "$NEXT_RELEASE_IS_MAJOR" = "0" ]; then
|
|
GIT_BRANCH=opensuse-$MAJOR_VERSION.$[$MINOR_VERSION+1]
|
|
else
|
|
GIT_BRANCH=opensuse-$[MAJOR_VERSION+1].0
|
|
fi
|
|
fi
|
|
fi
|
|
else
|
|
SOURCE_VERSION=$OLD_SOURCE_VERSION_AND_EXTRA
|
|
QEMU_VERSION=$(tar JxfO qemu-$SOURCE_VERSION$VERSION_EXTRA.tar.xz qemu-$SOURCE_VERSION/VERSION)
|
|
if [ ! "$QEMU_VERSION" = "$OLD_SOURCE_VERSION_AND_EXTRA" ]; then
|
|
echo "Tarball name (which we decode) doesn't correspond to the VERSION file contained therein"
|
|
exit
|
|
fi
|
|
MAJOR_VERSION=$(echo $QEMU_VERSION|awk -F. '{print $1}')
|
|
MINOR_VERSION=$(echo $QEMU_VERSION|awk -F. '{print $2}')
|
|
GIT_BRANCH=opensuse-$MAJOR_VERSION.$MINOR_VERSION
|
|
fi
|
|
}
|
|
|
|
#==============================================================================
|
|
|
|
# cleanup directories from any previous failed run:
|
|
rm -rf ${TMPDIR}/qemu-???????-git-dir
|
|
rm -rf ${TMPDIR}/qemu-???????-cmp-dir
|
|
rm -rf ${TMPDIR}/qemu-???????-bun-dir
|
|
# Temporary directories used in this script
|
|
GIT_DIR=$(mktemp -d ${TMPDIR}/qemu-XXXXXXX-git-dir)
|
|
CMP_DIR=$(mktemp -d ${TMPDIR}/qemu-XXXXXXX-cmp-dir)
|
|
BUN_DIR=$(mktemp -d ${TMPDIR}/qemu-XXXXXXX-bun-dir)
|
|
|
|
if [[ ! -e $(readlink -f ${LOCAL_REPO_MAP[0]}) ]]; then
|
|
echo "No local repo found at ${LOCAL_REPO_MAP[0]}"
|
|
if [ "$GIT_UPSTREAM_COMMIT_ISH" = "LATEST" ]; then
|
|
echo "Using LATEST config.sh setting is an expert mode. Set up local repos accordingly"
|
|
exit
|
|
fi
|
|
read -p "Would you like me to set that up for you? (Y/N)" -n 1 -r
|
|
echo
|
|
if [[ $REPLY =~ ^[Yy]$ ]]; then
|
|
echo "Got an affirmative answer, proceeding..."
|
|
setup_common_vars
|
|
git -c init.defaultBranch=$GIT_BRANCH init ${LOCAL_REPO_MAP[0]}
|
|
git -C ${LOCAL_REPO_MAP[0]} remote add origin $PACKAGE_MAIN_GIT_REPO &>/dev/null
|
|
git -C ${LOCAL_REPO_MAP[0]} fetch origin +refs/tags/initial:refs/tags/initial --no-tags
|
|
git -C ${LOCAL_REPO_MAP[0]} reset --hard --recurse-submodules initial
|
|
#TODO: The next is not actually used - get rid of when we decide for sure it won't get used
|
|
GIT_UPSTREAM_COMMIT=$(git -C ${LOCAL_REPO_MAP[0]} ls-remote origin |grep -F "$GIT_UPSTREAM_COMMIT_ISH^{}"|awk '{print $1}')
|
|
# Here we've changed to use *COMMIT_ISH, not *_COMMIT - is that an issue?
|
|
git -C ${LOCAL_REPO_MAP[0]} fetch --depth=1 origin +refs/tags/$GIT_UPSTREAM_COMMIT_ISH:refs/tags/$GIT_UPSTREAM_COMMIT_ISH --no-tags
|
|
git -C ${LOCAL_REPO_MAP[0]} remote add upstream $UPSTREAM_GIT_REPO &>/dev/null
|
|
bundle2local
|
|
git -C ${LOCAL_REPO_MAP[0]} checkout -B $GIT_BRANCH frombundle
|
|
echo "We set up a shallow local repo of the package's git superproject at"
|
|
echo "${LOCAL_REPO_MAP[0]}, and initialized it from the bundle."
|
|
echo "(no options processed)"
|
|
echo "If you wish to make the repo complete for all qemu packaging work,"
|
|
echo "unshallow it first with git fetch --unshallow origin --all, then get"
|
|
echo "the submodules updated with git submodule update --init --recursive"
|
|
echo "Be aware that this downloads a LOT of data (that's why we didn't just"
|
|
echo "do that automatically. Then you may also fetch other branches from the"
|
|
echo "origin remote, and get the latest upstream patches from the upstream"
|
|
echo "remote. Refer to config.sh for submodule repos locations you can set"
|
|
echo "up to also work on patches for the superproject's submodules."
|
|
exit
|
|
else
|
|
echo "Script requires qemu superproject local git repo. Please provide in"
|
|
echo "order to use this script."
|
|
fi
|
|
exit
|
|
fi
|
|
# TODO: Perhaps useful: get the current state of the git superproject
|
|
# The following sends output to stdout which we don't want to see
|
|
#git -C ${LOCAL_REPO_MAP[0]} status --untracked-files=no --branch --porcelain=2 \
|
|
# | awk '{print "var"NR"="$3}'
|
|
# $var1 is the current commit
|
|
# $var2 is the current branch or 'detached', if not on a branch
|
|
# $var3 is the current upstream branch (if set), as in eg 'origin/opensuse-5.0'
|
|
# $var4 is not of use to us
|
|
|
|
if [ "$GIT_UPSTREAM_COMMIT_ISH" != "LATEST" ]; then
|
|
if [ ! "$GIT_UPSTREAM_COMMIT_ISH" = "v$OLD_SOURCE_VERSION_AND_EXTRA" ]; then
|
|
echo "Tarball name (which we decode) doesn't correspond to the \$GIT_UPSTREAM_COMMIT_ISH in config.sh"
|
|
exit
|
|
fi
|
|
setup_common_vars
|
|
fi
|
|
# TODO: What checks should be different between LATEST and non-LATEST?
|
|
echo "ALERT: Script using local git repos. Some operations may be time consuming..."
|
|
# TODO: Some of these checks are perhaps not necessary
|
|
for (( i=0; i <$REPO_COUNT; i++ )); do
|
|
if [[ -e $(readlink -f ${LOCAL_REPO_MAP[$i]}) ]]; then
|
|
if [[ -e ${LOCAL_REPO_MAP[$i]}/.git/shallow ]]; then
|
|
echo "${LOCAL_REPO_MAP[$i]} is shallow, skipping checks"
|
|
continue
|
|
fi
|
|
if [[ -d ${LOCAL_REPO_MAP[$i]}/.git/rebase-merge || \
|
|
-d ${LOCAL_REPO_MAP[$i]}/.git/rebase-apply ]]; then
|
|
echo "ERROR! Rebase appears to be in progress in ${LOCAL_REPO_MAP[$i]}. Please resolve"
|
|
exit
|
|
fi
|
|
# TODO: We've not even verified what branch we're on here - so this is a bit misguided!
|
|
if ! git -C ${LOCAL_REPO_MAP[$i]} submodule update --init --recursive &> /dev/null; then
|
|
echo "Please clean up state of local repo ${LOCAL_REPO_MAP[$i]} before using script"
|
|
echo "(ensure git submodule update --init --recursive is successful)"
|
|
exit
|
|
fi
|
|
if [ "$(git -C ${LOCAL_REPO_MAP[$i]} status --porcelain)" ]; then
|
|
echo "Please clean up state of local repo ${LOCAL_REPO_MAP[$i]} before using script"
|
|
echo "(ensure git status --porcelain produces no output)"
|
|
exit
|
|
fi
|
|
# TODO: See about doing the following better (also see what needs to happen for LATEST)
|
|
if [ "$GIT_UPSTREAM_COMMIT_ISH" != "LATEST" ]; then
|
|
if $(git -C ${LOCAL_REPO_MAP[$i]} branch --remote | grep -F "origin/$GIT_BRANCH" >/dev/null); then
|
|
if ! $(git -C ${LOCAL_REPO_MAP[$i]} branch | grep -F "$GIT_BRANCH" >/dev/null); then
|
|
echo "Please clean up state of local repo ${LOCAL_REPO_MAP[$i]} before using script"
|
|
echo "(cannot find branch $GIT_BRANCH, please create a tracking branch of remote origin/$GIT_BRANCH)"
|
|
exit
|
|
fi
|
|
if ! git -C ${LOCAL_REPO_MAP[$i]} checkout $GIT_BRANCH --recurse-submodules -f &> /dev/null; then
|
|
echo "Please clean up state of local repo ${LOCAL_REPO_MAP[$i]} before using script"
|
|
echo "(cannot check out $GIT_BRANCH, incl. it's submodules)"
|
|
exit
|
|
fi
|
|
fi
|
|
fi
|
|
# This does additional setup now that we've possibly grabbed additional submodules
|
|
if ! git -C ${LOCAL_REPO_MAP[$i]} submodule update --init --recursive &> /dev/null; then
|
|
echo "Please clean up state of local repo ${LOCAL_REPO_MAP[$i]} before using script"
|
|
echo "(cannot init and update current branch submodules)"
|
|
exit
|
|
fi
|
|
if [ "$(git -C ${LOCAL_REPO_MAP[$i]} status --porcelain)" ]; then
|
|
echo "Please clean up state of local repo ${LOCAL_REPO_MAP[$i]} before using script"
|
|
echo "(ensure git status --porcelain produces no output)"
|
|
exit
|
|
fi
|
|
fi
|
|
done
|
|
|
|
if [ "$GIT_UPSTREAM_COMMIT_ISH" = "LATEST" ]; then
|
|
if [ "$1" = "continue" ]; then
|
|
CONTINUE_AFTER_REBASE=1
|
|
else
|
|
if [ "$1" = "pause" ]; then
|
|
PAUSE_BEFORE_BUNDLE_CREATION=1
|
|
else
|
|
if [ "$1" ]; then
|
|
echo "ERROR: unrecognized option '$1'. Script in LATEST mode only recognizes 'pause' and 'continue' options"
|
|
exit
|
|
fi
|
|
fi
|
|
fi
|
|
for (( i=0; i <$REPO_COUNT; i++ )); do
|
|
if [[ -e $(readlink -f ${LOCAL_REPO_MAP[$i]}) ]]; then
|
|
git -C ${LOCAL_REPO_MAP[$i]} remote update upstream &> /dev/null
|
|
fi
|
|
done
|
|
NEW_COMMIT_ISH_FULL=$(cd ${LOCAL_REPO_MAP[0]} && git rev-parse upstream/master)
|
|
NEW_COMMIT_ISH=${NEW_COMMIT_ISH_FULL:0:8}
|
|
setup_common_vars
|
|
WRITE_LOG=0
|
|
echo "Processing LATEST upstream changes"
|
|
echo "(If SUCCESS is not printed upon completion, see ~/latest.log for issues)"
|
|
if [[ $QEMU_TARBALL =~ $BASE_RE$EXTRA_RE$SUFFIX_RE ]]; then
|
|
OLD_COMMIT_ISH=${BASH_REMATCH[3]}
|
|
else
|
|
#Assume release (or release candidate) tarball with equivalent tag:
|
|
OLD_COMMIT_ISH=$(cd ${LOCAL_REPO_MAP[0]} && git rev-list --abbrev-commit \
|
|
--abbrev=8 -1 v$OLD_SOURCE_VERSION_AND_EXTRA)
|
|
fi
|
|
if [ ${#QEMU_TARBALL_SIG[@]} -ne 0 ]; then
|
|
echo "INFO: Ignoring signature file: $QEMU_TARBALL_SIG"
|
|
QEMU_TARBALL_SIG=
|
|
fi
|
|
NOW_SECONDS=$(date +%s)
|
|
if [ "$OLD_COMMIT_ISH" != "$NEW_COMMIT_ISH" ]; then
|
|
if [ "$CONTINUE_AFTER_REBASE" = "1" ]; then
|
|
echo "continue after rebase selected but tarball is out of date. Continuing not possible."
|
|
echo "If desired, save your rebase work (eg, branch $GIT_BRANCH), because otherwise it will"
|
|
echo "be lost. Then run script again without the continue option"
|
|
exit
|
|
fi
|
|
redo_tarball_and_rebase_patches &> ~/latest.log # This includes a bundle2local
|
|
if [[ "$REBASE_FAILS" ]]; then
|
|
echo "ERROR! Rebase of the $GIT_BRANCH branch failed in the following local git repos:"
|
|
echo $REBASE_FAILS
|
|
echo "Manually resolve all these rebases, then finish the workflow by passing 'continue' to script"
|
|
if [[ "$PAUSE_BEFORE_BUNDLE_CREATION" = "1" ]]; then
|
|
echo "Feel free to also do the work now occasioned by the selected 'pause' option"
|
|
fi
|
|
exit
|
|
fi
|
|
CONTINUE_AFTER_REBASE=1
|
|
fi
|
|
if [[ "$PAUSE_BEFORE_BUNDLE_CREATION" = "1" ]]; then
|
|
echo "As requested, pausing before re-creating bundle of bundles for additional patch or specfile work"
|
|
echo "(using current 'ready to go' $GIT_BRANCH branch of local repos to produce patches.)"
|
|
echo "When changes are complete, finish the workflow by passing 'continue' to script"
|
|
exit
|
|
fi
|
|
if [ "$CONTINUE_AFTER_REBASE" = "1" ]; then
|
|
initbundle &>> ~/latest.log
|
|
fi
|
|
bundle2spec &>> ~/latest.log
|
|
echo "SUCCESS"
|
|
tail -9 ~/latest.log
|
|
else # not LATEST
|
|
NEW_COMMIT_ISH=
|
|
WRITE_LOG=1
|
|
case $1 in
|
|
initbundle )
|
|
echo "Updating/creating the bundle using the $GIT_BRANCH branch of the local repos."
|
|
echo "(If SUCCESS is not printed upon completion, see ~/initbundle.log for issues)"
|
|
initbundle &> ~/initbundle.log
|
|
echo "SUCCESS"
|
|
;;
|
|
git2pkg )
|
|
echo "Updating the package using the $GIT_BRANCH branch of the local repos."
|
|
echo "(If SUCCESS is not printed upon completion, see ~/git2pkg.log for issues)"
|
|
initbundle &> ~/git2pkg.log
|
|
bundle2spec &>> ~/git2pkg.log
|
|
echo "SUCCESS"
|
|
tail -9 ~/git2pkg.log
|
|
;;
|
|
pkg2git )
|
|
echo "Exporting the package's git bundles to the local repo's frombundle branches..."
|
|
echo "(If SUCCESS is not printed upon completion, see ~/pkg2git.log for issues)"
|
|
bundle2local &> ~/pkg2git.log
|
|
echo "SUCCESS"
|
|
echo "To modify package patches, use the frombundle branch as the basis for updating"
|
|
echo "the $GIT_BRANCH branch with the new patch queue, e.g., like this:"
|
|
echo " git checkout -f --recurse-submodules -B $GIT_BRANCH frombundle"
|
|
echo "in the following repositories:"
|
|
for R in $(grep "Patches applied" $PKG.spec | awk '{print $(NF)}'|sed 's/:$//'); do
|
|
for (( i=0; i <$REPO_COUNT; i++ )); do
|
|
if [ "${R}" = "project" ]; then
|
|
echo " * ${LOCAL_REPO_MAP[0]}"
|
|
continue 2
|
|
fi
|
|
if [ "${R}" = "${PATCH_PATH_MAP[$i]}" ]; then
|
|
echo " * ${LOCAL_REPO_MAP[$i]}"
|
|
continue 2
|
|
fi
|
|
done
|
|
done
|
|
echo "Then make your changes and, when done, export them back to the package with:"
|
|
echo " bash ./update_git.sh git2pkg"
|
|
;;
|
|
refresh )
|
|
echo "Updating the spec file and patches from the spec file template and the bundle"
|
|
echo "of bundles (bundles.tar.xz)"
|
|
echo "(If SUCCESS is not printed upon completion, see ~/refresh.log for issues)"
|
|
bundle2spec &> ~/refresh.log
|
|
echo "SUCCESS"
|
|
tail -9 ~/refresh.log
|
|
;;
|
|
esac
|
|
fi
|
|
exit
|