0
0
#!/usr/bin/env bash
set -euo pipefail
root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$root"
usage() {
cat >&2 <<EOF
usage: $0
Run it while a rebase (or merge, or cherry-pick) is stopped on conflicts. For every conflicted path
that a generator writes, it takes one side (ours: during a rebase that is the branch being rebased
onto), reruns the generators and stages the result:
go generate ./api/... deploy/*-apiresourceschema.yaml, deploy/*-apiexport.yaml,
deploy/apiresourceschema-revisions.txt, api/**/zz_generated.register.go and
api/**/zz_generated.conditions.go (cmd/socialweb-apigen -list names
them all), and api/**/zz_generated.deepcopy.go (deepcopy-gen through
hack/codegen.sh)
It never hand-merges generated output. The generators read api/v1alpha1, internal/apigen and
cmd/socialweb-apigen, so a conflict there must be resolved first (the script says so and stops).
It then prints the conflicts that remain (hand-written code, docs, plans) and, when none remain, the
command to continue.
EOF
exit 2
}
[ $# -eq 0 ] || usage
say() { echo "regen-after-rebase: $*" >&2; }
op=""
gitdir="$(git rev-parse --git-dir)"
if [ -d "$gitdir/rebase-merge" ] || [ -d "$gitdir/rebase-apply" ]; then
op=rebase
elif [ -f "$gitdir/MERGE_HEAD" ]; then
op=merge
elif [ -f "$gitdir/CHERRY_PICK_HEAD" ]; then
op=cherry-pick
fi
mapfile -t conflicted < <(git diff --name-only --diff-filter=U)
if [ ${#conflicted[@]} -eq 0 ]; then
say "no conflicted paths${op:+ (a $op is in progress)}; regenerating anyway"
fi
inputs=()
codegen=()
for p in "${conflicted[@]}"; do
case "$p" in
api/*zz_generated.*.go) codegen+=("$p") ;;
api/*.go|internal/apigen/*|cmd/socialweb-apigen/*|hack/codegen.sh) inputs+=("$p") ;;
esac
done
if [ ${#inputs[@]} -gt 0 ]; then
say "the generators read these conflicted paths; resolve them by hand, git add them, then run this again:"
printf ' %s\n' "${inputs[@]}"
exit 1
fi
lockf=deploy/apiresourceschema-revisions.txt
if [ -f "$lockf" ] && [ -n "$(awk '{print $1}' "$lockf" | sort | uniq -d)" ]; then
tmp="$(mktemp -d)"
git show "HEAD:$lockf" >"$tmp/head" 2>/dev/null || : >"$tmp/head"
awk 'NR == FNR { head[$1] = $2; next }
$1 != "" { n[$1]++; h[$1, n[$1]] = $2; if (!($1 in seen)) { seen[$1] = 1; names[++k] = $1 } }
END { for (i = 1; i <= k; i++) { nm = names[i]; pick = h[nm, 1]; for (j = 1; j <= n[nm]; j++) if (h[nm, j] == head[nm]) pick = h[nm, j]; print nm, pick } }' \
"$tmp/head" "$lockf" >"$tmp/lock"
mv "$tmp/lock" "$lockf"
rm -rf "$tmp"
say "$lockf named a revision twice (both sides changed one schema under one revision); kept the HEAD hash. If go generate now asks for a Revision bump, bump it in api/v1alpha1/resources.go and run this again"
fi
for p in "${codegen[@]}"; do
rm -f -- "$p"
say "dropped conflicted $p (regenerated below)"
done
find api \( -name zz_generated.register.go -o -name zz_generated.conditions.go \) -delete
say "hack/codegen.sh"
bash hack/codegen.sh || { say "hack/codegen.sh failed (above): fix the api types it names, git add them, run this again"; exit 1; }
before_out="$(go run ./cmd/socialweb-apigen -root . -list)" || { say "cmd/socialweb-apigen failed (above): fix what it names (for example bump Revision in api/v1alpha1/resources.go), git add it, run this again"; exit 1; }
mapfile -t before < <(echo "$before_out" | tr ' ' '\n' | grep .)
generated=()
for p in "${conflicted[@]}"; do
if printf '%s\n' "${before[@]}" | grep -qxF -- "$p"; then
generated+=("$p")
fi
done
for p in "${generated[@]}"; do
if git cat-file -e ":2:$p" 2>/dev/null; then
git checkout --ours -- "$p"
elif git cat-file -e ":3:$p" 2>/dev/null; then
git checkout --theirs -- "$p"
else
git rm -q --cached -- "$p"
rm -f -- "$p"
fi
say "took ours of $p"
done
say "go generate ./api/..."
go generate ./api/... || { say "go generate failed (above): fix what it names (for example bump Revision in api/v1alpha1/resources.go), git add it, run this again"; exit 1; }
mapfile -t outputs < <(go run ./cmd/socialweb-apigen -root . -list | tr ' ' '\n' | grep .)
for p in "${generated[@]}"; do
if ! printf '%s\n' "${outputs[@]}" | grep -qxF -- "$p"; then
say "warn: $p was taken from one side but apigen no longer writes it; it stays as taken"
fi
done
stage=()
for p in "${outputs[@]}"; do
[ -e "$p" ] && stage+=("$p")
done
git add -- "${stage[@]}"
git add -A -- ':(glob)api/**/zz_generated.*.go'
say "regenerated and staged ${#stage[@]} generated paths (${#generated[@]} were conflicted)"
mapfile -t left < <(git diff --name-only --diff-filter=U)
if [ ${#left[@]} -gt 0 ]; then
say "conflicts that remain (hand-resolve, git add):"
printf ' %s\n' "${left[@]}"
exit 1
fi
case "$op" in
rebase) say "no conflicts remain: git rebase --continue" ;;
merge) say "no conflicts remain: git commit" ;;
cherry-pick) say "no conflicts remain: git cherry-pick --continue" ;;
*) say "no conflicts remain" ;;
esac