-
Notifications
You must be signed in to change notification settings - Fork 3
/
upstream.sh
executable file
·375 lines (314 loc) · 10.4 KB
/
upstream.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
#!/usr/bin/env bash
# WARNING: This file is autogenerated - changes will be overwritten if not made via https://github.com/pulumi/ci-mgmt
set -e
original_exec="$0"
original_cmd="$1"
usage() {
cat <<EOF
NAME
upstream.sh - Manages applying patches to the upstream submodule.
SYNOPSIS
${original_exec} <init|checkout|rebase|check_in|help> [options]
COMMANDS
init [-f] Initialize the upstream submodule and applies the
patches to the working directory.
checkout [-f] Create a branch in the upstream repository with the
patches applied as commits.
rebase [-o] [-i] Rebase the checked out patches.
check_in Write checkedout commits back to patches, add upstream
and patches changes to the git staging area and exit
checkout mode.
help Print this help message, plus examples.
OPTIONS
-f Force the command to run even if the upstream submodule is modified
-o The new base commit to rebase the patches on top of
-i Run the rebase command interactively
-h Print this help message, plus examples
EOF
}
extended_docs() {
cat <<EOF
DESCRIPTION
We want to maintain changes to the upstream repository in a way that is easy
to manage and track. Rather than creating a fork of the upstream repository,
we maintain a set of patches (in the 'patches' directory) that we can apply
directly to the upstream code in the 'upstream' submodule. Our patches are
never pushed to the remote upstream repository.
EXAMPLES
Discard all changes in upstream and reapply patches to the working directory:
${original_exec} init -f
Moving the patches to a new base commit:
${original_exec} checkout
${original_exec} rebase -o <new_base_commit>
${original_exec} check_in
Interactively edit the patches:
${original_exec} checkout
${original_exec} rebase -i
${original_exec} check_in
Add a new patch:
${original_exec} checkout
# Make changes to the upstream repository
git commit -am "Add new feature"
${original_exec} check_in
EOF
}
assert_upstream_exists() {
if [[ ! -d upstream ]]; then
echo "No 'upstream' directory detected. Aborting."
exit 1
fi
}
assert_not_checked_out() {
current_branch=$(cd upstream && git --no-pager rev-parse --abbrev-ref HEAD)
if [[ "${current_branch}" == "pulumi/patch-checkout" ]]; then
cat <<EOF
Error: 'upstream' submodule checked out on the 'pulumi/patch-checkout' branch.
This was likely caused by running a 'checkout' command but not running
'check_in' afterwards.
To turn the commits in the 'pulumi/patch-checkout' branch back into patches, run:
${original_exec} check_in
To disgard changes in the 'pulumi/patch-checkout' branch, use the 'force' flag (-f):
${original_exec} ${original_cmd} -f
EOF
exit 1
fi
}
assert_is_checked_out() {
current_branch=$(cd upstream && git --no-pager rev-parse --abbrev-ref HEAD)
if [[ "${current_branch}" != "pulumi/patch-checkout" ]]; then
echo "Expected upstream to be checked out on the 'pulumi/patch-checkout' branch, but ${current_branch} is checked out."
exit 1
fi
}
assert_no_rebase_in_progress() {
# Use git to resolve the possible location of files indicating a rebase might be in progress.
rebase_merge_dir=$(cd upstream && git rev-parse --git-path rebase-merge)
rebase_apply_dir=$(cd upstream && git rev-parse --git-path rebase-apply)
if [[ -d "${rebase_merge_dir}" ]] || [[ -d "${rebase_apply_dir}" ]]; then
echo "rebase still in progress in './upstream'. Please resolve the rebase in"
exit 1
fi
}
err_failed_to_apply() {
cat <<EOF
Failed to apply $1.
Hint: to avoid conflicts when updating the upstream submodule, use the
following commands:
1. '${original_exec} checkout' to create a branch with the patches applied as commits
2. '${original_exec} rebase -o <new_base_commit>' to rebase the patches on top of the
new upstream commit. Resolve any conflicts and continue the rebase to completion.
3. '${original_exec} check_in' to create an updated set of patches from the commits
Reset the upstream submodule to the previous known good upstream commit before
trying again. This can be done with:
(cd upstream && git reset --hard <last_known_good_commit>)
git add upstream
EOF
exit 1
}
apply_patches() {
# Iterating over the patches folder in sorted order,
# apply the patch using a 3-way merge strategy. This mirrors the default behavior of 'git merge'
cd upstream
for patch in ../patches/*.patch; do
if ! git apply --3way "${patch}" --allow-empty; then
err_failed_to_apply "$(basename "${patch}")"
fi
done
}
clean_rebases() {
# Clean up any previous in-progress rebases.
cd upstream
rebase_merge_dir=$(git rev-parse --git-path rebase-merge)
rebase_apply_dir=$(git rev-parse --git-path rebase-apply)
rm -rf "${rebase_merge_dir}"
rm -rf "${rebase_apply_dir}"
cd ..
}
clean_branches() {
cd upstream
if git show-ref --verify --quiet refs/heads/pulumi/patch-checkout; then
git branch -D pulumi/patch-checkout
fi
if git show-ref --verify --quiet refs/heads/pulumi/checkout-base; then
git branch -D pulumi/checkout-base
fi
if git show-ref --verify --quiet refs/heads/pulumi/original-base; then
git branch -D pulumi/original-base
fi
cd ..
}
init() {
# Parse additional flags
while getopts "f" flag; do
case "${flag}" in
f) force="true";;
*) echo "Unexpected option ${flag}"; exit 1;;
esac
done
assert_upstream_exists
if [[ "${force}" != "true" ]]; then
assert_not_checked_out
assert_no_rebase_in_progress
fi
git submodule update --force --init
cd upstream && git clean -fxd && cd ..
if [[ "${force}" == "true" ]]; then
clean_rebases
clean_branches
fi
apply_patches
}
checkout() {
# Parse additional flags
while getopts "f" flag; do
case "${flag}" in
f) force="true";;
*) echo "Unexpected option ${flag}"; exit 1;;
esac
done
assert_upstream_exists
if [[ "${force}" != "true" ]]; then
assert_not_checked_out
assert_no_rebase_in_progress
fi
git submodule update --force --init
if [[ "${force}" == "true" ]]; then
clean_rebases
clean_branches
fi
cd upstream
git fetch --all
# Set the 'pulumi/checkout-base' branch to the current commit of the upstream repository
# This is used to track the base commit of the patches
# If rebasing, then this must be moved to the new base commit.
git branch -f pulumi/checkout-base
# Create a new branch 'pulumi/patch-checkout' which will contain the commits for each patch
git checkout -B pulumi/patch-checkout
for patch in ../patches/*.patch; do
if ! git am --3way "${patch}"; then
err_failed_to_apply "$(basename "${patch}")"
fi
done
cat <<EOF
The patches have been checked out as commits in the './upstream' repository.
The 'pulumi/patch-checkout' branch is pointing to the last patch.
The 'pulumi/checkout-base' branch is pointing to the base commit of the patches.
To interactively edit the commits:
${original_exec} rebase -i
To change the base of the patches:
${original_exec} rebase -o <new_base_commit>
Once you have finished editing the commits, run
${original_exec} check_in
EOF
}
rebase() {
# Parse additional flags
onto="pulumi/checkout-base"
interactive="false"
while getopts "io:" flag; do
case "${flag}" in
i) interactive="true";;
o) onto="${OPTARG}";;
*) echo "Unexpected option ${flag}"; exit 1;;
esac
done
assert_is_checked_out
cd upstream
# Fetch the latest changes from the upstream repository
git fetch --all
# Set the "pulumi/original-base" branch to the current base commit of the patches
git branch -f pulumi/original-base pulumi/checkout-base
# Set the "pulumi/patch-checkout" branch to track the "pulumi/original-base" branch
git branch --set-upstream-to=pulumi/original-base pulumi/patch-checkout
# Set the "pulumi/checkout-base" branch to the new base commit ready for formatting the patches after
git branch -f pulumi/checkout-base "${onto}"
# Rebase the 'pulumi/patch-checkout' branch on top of the new base commit
interactive_flag=""
if [[ "${interactive}" == "true" ]]; then
interactive_flag="--interactive"
fi
if ! git rebase --onto "${onto}" ${interactive_flag}; then
echo "Rebase failed. Please resolve the conflicts and run 'git rebase --continue' in the upstream directory."
exit 1
fi
cd ..
}
export_patches() {
# Remove all existing patches before creating the new ones in case they've been renamed or removed.
rm -f patches/*.patch
# Extract patches from the commits in the 'pulumi/patch-checkout' branch into the 'patches' directory.
# Use the 'pulumi/checkout-base' branch to determine the base commit of the patches.
(cd upstream && git format-patch pulumi/checkout-base -o ../patches --zero-commit --no-signature --no-stat --no-numbered)
}
format_patches() {
assert_upstream_exists
assert_is_checked_out
assert_no_rebase_in_progress
export_patches
cat <<EOF
Patches have been created in the 'patches' directory. If you've made changes to
the base, ensure you add 'upstream' to the git stage before running 'init -f'
to exit the checkout mode.
EOF
}
check_in() {
assert_upstream_exists
assert_is_checked_out
assert_no_rebase_in_progress
export_patches
# Check out the new base of the patches
(cd upstream && git checkout pulumi/checkout-base)
# Add the patches and upstream changes to the git staging area
git add patches upstream
# Exit the checkout mode and re-initialize the upstream submodule
git submodule update --force --init
apply_patches
cat <<EOF
Changes to patches and upstream have been staged, exited checkout mode and
re-initializing using updated patches and updated upstream base.
EOF
}
if [[ -z ${original_cmd} ]]; then
echo "Error: command is required."
echo
usage
extended_docs
exit 1
fi
# Check for help flag and short-circuit to print usage.
for arg in "$@"; do
case ${arg} in
"help"|"-h"|"--help")
usage
extended_docs
exit 0
;;
*)
;;
esac
done
# Remove the command argument from the list of arguments to pass to the command.
shift
case ${original_cmd} in
init)
init "$@"
;;
checkout|check_out)
checkout "$@"
;;
rebase)
rebase "$@"
;;
format_patches)
format_patches "$@"
;;
check_in|checkin)
check_in "$@"
;;
*)
echo "Error: unknown command \"${original_cmd}\"."
echo
usage
exit 1
;;
esac