petru
244a472691
- 1 - I updated [`.maintain-custom-release.sh`](/config/workspace/gitea-dev/gitea/.maintain-custom-release.sh) so `Sync upstream release target commits` validates only the configured `UPSTREAM_RELEASE_TARGET_REF` when one is set, instead of still failing on a missing local `upstream/release/...` remote-tracking branch after successfully fetching a target tag such as `v1.26.1`.
2441 lines
81 KiB
Bash
Executable File
2441 lines
81 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
|
|
set -euo pipefail
|
|
|
|
# This script maintains a custom release branch on top of an upstream release
|
|
# line while keeping your own local custom commits.
|
|
# It is designed for flows such as:
|
|
# - base tag: v1.26.0-rc0
|
|
# - upstream release line: release/v1.26
|
|
# - custom maintenance: release/v1.26-custom
|
|
# - custom release tags: v1.26.0-custom, v1.26.1-custom
|
|
# It:
|
|
# 1. fetches the upstream release line and upstream compare branch;
|
|
# 2. creates or reuses a persistent custom maintenance branch;
|
|
# 3. cherry-picks missing upstream release commits onto that branch;
|
|
# 4. cherry-picks only your custom commits from your source branch;
|
|
# 5. keeps a backup branch, exact worktree snapshot, and saved stash so the
|
|
# original state can be restored safely if something is not OK.
|
|
|
|
BASE_TAG="${BASE_TAG:-v1.26.0-rc0}"
|
|
UPSTREAM_RELEASE_BRANCH="${UPSTREAM_RELEASE_BRANCH:-release/v1.26}"
|
|
UPSTREAM_RELEASE_TARGET_REF="${UPSTREAM_RELEASE_TARGET_REF:-}"
|
|
MAINTENANCE_BRANCH="${MAINTENANCE_BRANCH:-release/v1.26-custom}"
|
|
CUSTOM_SOURCE_BRANCH="${CUSTOM_SOURCE_BRANCH:-main}"
|
|
UPSTREAM_COMPARE_BRANCH="${UPSTREAM_COMPARE_BRANCH:-main}"
|
|
CUSTOM_TAG_SUFFIX="${CUSTOM_TAG_SUFFIX:--custom}"
|
|
REMOTE_NAME="${REMOTE_NAME:-upstream}"
|
|
REMOTE_URL="${REMOTE_URL:-https://github.com/go-gitea/gitea.git}"
|
|
RUNTIME_ENV_FILE="${RUNTIME_ENV_FILE:-/tmp/.maintain-custom-release.env}"
|
|
|
|
DEFAULT_BASE_TAG="$BASE_TAG"
|
|
DEFAULT_UPSTREAM_RELEASE_BRANCH="$UPSTREAM_RELEASE_BRANCH"
|
|
DEFAULT_UPSTREAM_RELEASE_TARGET_REF="$UPSTREAM_RELEASE_TARGET_REF"
|
|
DEFAULT_MAINTENANCE_BRANCH="$MAINTENANCE_BRANCH"
|
|
DEFAULT_CUSTOM_SOURCE_BRANCH="$CUSTOM_SOURCE_BRANCH"
|
|
DEFAULT_UPSTREAM_COMPARE_BRANCH="$UPSTREAM_COMPARE_BRANCH"
|
|
DEFAULT_CUSTOM_TAG_SUFFIX="$CUSTOM_TAG_SUFFIX"
|
|
|
|
REPO_ROOT=""
|
|
GIT_DIR=""
|
|
STATE_FILE=""
|
|
SNAPSHOT_ROOT=""
|
|
RESTORE_POINT_ROOT=""
|
|
LEGACY_RESTORE_POINT_ROOT=""
|
|
CURRENT_BRANCH=""
|
|
BACKUP_BRANCH=""
|
|
STASH_REF=""
|
|
STASH_HASH=""
|
|
STATE_BRANCH=""
|
|
STATE_ENTRY_BRANCH=""
|
|
STATE_BACKUP_BRANCH=""
|
|
STATE_STASH_HASH=""
|
|
STATE_REMOTE_NAME=""
|
|
STATE_REMOTE_URL=""
|
|
STATE_BASE_TAG=""
|
|
STATE_UPSTREAM_RELEASE_BRANCH=""
|
|
STATE_UPSTREAM_RELEASE_TARGET_REF=""
|
|
STATE_UPSTREAM_COMPARE_BRANCH=""
|
|
STATE_CUSTOM_SOURCE_BRANCH=""
|
|
STATE_MAINTENANCE_BRANCH=""
|
|
STATE_START_HEAD=""
|
|
STATE_SNAPSHOT_PATH=""
|
|
STATE_PENDING_COMMITS=""
|
|
STATE_ACTION_LABEL=""
|
|
STATE_STATUS=""
|
|
STATE_FETCH_REF_STATES=""
|
|
STATE_CREATED_MAINTENANCE_BRANCH=""
|
|
STATE_UPDATED_AT=""
|
|
FETCH_REF_STATES=""
|
|
MAINTENANCE_BRANCH_WAS_CREATED="0"
|
|
SELECTED_RESTORE_POINT=""
|
|
SELECTED_STASH_TARGET=""
|
|
SELECTED_SNAPSHOT_TARGET=""
|
|
|
|
say() {
|
|
printf '%s\n' "$*"
|
|
}
|
|
|
|
die() {
|
|
say "ERROR: $*" >&2
|
|
exit 1
|
|
}
|
|
|
|
save_runtime_settings() {
|
|
cat >"$RUNTIME_ENV_FILE" <<EOF
|
|
BASE_TAG=$(printf '%q' "$BASE_TAG")
|
|
UPSTREAM_RELEASE_BRANCH=$(printf '%q' "$UPSTREAM_RELEASE_BRANCH")
|
|
UPSTREAM_RELEASE_TARGET_REF=$(printf '%q' "$UPSTREAM_RELEASE_TARGET_REF")
|
|
MAINTENANCE_BRANCH=$(printf '%q' "$MAINTENANCE_BRANCH")
|
|
CUSTOM_SOURCE_BRANCH=$(printf '%q' "$CUSTOM_SOURCE_BRANCH")
|
|
UPSTREAM_COMPARE_BRANCH=$(printf '%q' "$UPSTREAM_COMPARE_BRANCH")
|
|
CUSTOM_TAG_SUFFIX=$(printf '%q' "$CUSTOM_TAG_SUFFIX")
|
|
EOF
|
|
}
|
|
|
|
load_runtime_settings() {
|
|
if [ -f "$RUNTIME_ENV_FILE" ]; then
|
|
# shellcheck disable=SC1090
|
|
. "$RUNTIME_ENV_FILE"
|
|
fi
|
|
|
|
BASE_TAG="${BASE_TAG:-$DEFAULT_BASE_TAG}"
|
|
UPSTREAM_RELEASE_BRANCH="${UPSTREAM_RELEASE_BRANCH:-$DEFAULT_UPSTREAM_RELEASE_BRANCH}"
|
|
UPSTREAM_RELEASE_TARGET_REF="${UPSTREAM_RELEASE_TARGET_REF:-$DEFAULT_UPSTREAM_RELEASE_TARGET_REF}"
|
|
MAINTENANCE_BRANCH="${MAINTENANCE_BRANCH:-$DEFAULT_MAINTENANCE_BRANCH}"
|
|
CUSTOM_SOURCE_BRANCH="${CUSTOM_SOURCE_BRANCH:-$DEFAULT_CUSTOM_SOURCE_BRANCH}"
|
|
UPSTREAM_COMPARE_BRANCH="${UPSTREAM_COMPARE_BRANCH:-$DEFAULT_UPSTREAM_COMPARE_BRANCH}"
|
|
CUSTOM_TAG_SUFFIX="${CUSTOM_TAG_SUFFIX:-$DEFAULT_CUSTOM_TAG_SUFFIX}"
|
|
|
|
save_runtime_settings
|
|
}
|
|
|
|
show_usage() {
|
|
cat <<EOF
|
|
Usage: $(basename "$0") [command]
|
|
|
|
Environment defaults:
|
|
BASE_TAG=$BASE_TAG
|
|
UPSTREAM_RELEASE_BRANCH=$UPSTREAM_RELEASE_BRANCH
|
|
UPSTREAM_RELEASE_TARGET_REF=${UPSTREAM_RELEASE_TARGET_REF:-<branch-head>}
|
|
MAINTENANCE_BRANCH=$MAINTENANCE_BRANCH
|
|
CUSTOM_SOURCE_BRANCH=$CUSTOM_SOURCE_BRANCH
|
|
UPSTREAM_COMPARE_BRANCH=$UPSTREAM_COMPARE_BRANCH
|
|
CUSTOM_TAG_SUFFIX=$CUSTOM_TAG_SUFFIX
|
|
|
|
Available commands:
|
|
configure
|
|
Interactively update the current in-memory config values for this run.
|
|
create-restore-point [label]
|
|
Create a manual restore point for the current state, including a backup branch and an exact worktree snapshot.
|
|
list-restore-points
|
|
List available manual restore points created by this script.
|
|
restore-point [restore-point-dir-or-name]
|
|
Restore a manual restore point by path or by its final directory name. If omitted, the latest point for the current branch is used.
|
|
delete-restore-point <restore-point-dir-or-name>
|
|
Delete a manual restore point and its associated backup branch.
|
|
status
|
|
Show the current config, branch state, and saved recovery metadata.
|
|
bootstrap
|
|
Create or switch to the maintenance branch from BASE_TAG without importing any commits.
|
|
fetch
|
|
Fetch both the upstream compare branch and the upstream release target ref.
|
|
fetch-upstream-compare
|
|
Fetch only upstream/$UPSTREAM_COMPARE_BRANCH.
|
|
fetch-upstream-target
|
|
Fetch only the configured upstream release target ref, or upstream/$UPSTREAM_RELEASE_BRANCH when no target ref is set.
|
|
plan
|
|
Show which upstream release commits and which custom commits would be imported next.
|
|
sync-upstream-compare
|
|
Import only the missing commits from upstream/\$UPSTREAM_COMPARE_BRANCH, usually upstream/main.
|
|
sync-upstream-target
|
|
Import only the missing commits from the configured upstream release target ref, or from upstream/\$UPSTREAM_RELEASE_BRANCH when no target ref is set.
|
|
sync-custom
|
|
Import only your custom commits from \$CUSTOM_SOURCE_BRANCH, cherry-picking them from oldest to newest.
|
|
sync-all
|
|
Import missing upstream compare-branch commits, then upstream release-target commits, and finally your custom commits.
|
|
continue
|
|
Continue an interrupted cherry-pick sequence and finish any remaining queued commits.
|
|
rollback [backup-branch|snapshot-dir]
|
|
Restore the saved pre-import state, or an explicit backup branch / snapshot.
|
|
restore-stash
|
|
Re-apply the saved pre-import local stash from the last recorded state.
|
|
restore-snapshot [snapshot-dir]
|
|
Restore the exact saved repository snapshot from the last recorded real action, or from a specific snapshot directory.
|
|
tag <upstream-version-tag>
|
|
Create an annotated custom release tag like <tag>\$CUSTOM_TAG_SUFFIX on the maintenance branch.
|
|
help
|
|
Show this help text.
|
|
|
|
If no command is provided and the script is run from a terminal, an interactive
|
|
menu is shown.
|
|
|
|
Interactive menu structure:
|
|
- Manual Backups >
|
|
create, list, restore, delete manual restore points
|
|
- Fetch upstreams >
|
|
fetch upstream/main compare ref or the configured release target ref
|
|
- Sync >
|
|
sync compare commits, release-target commits, custom commits, or all
|
|
- Rollback >
|
|
choose the saved rollback state, a saved backup branch, or a snapshot
|
|
- Restore >
|
|
restore the saved stash or an exact snapshot, or open Delete Restore >
|
|
|
|
In every submenu:
|
|
- press Enter for Back
|
|
- or type b / B for Back
|
|
- type 0 for Exit
|
|
|
|
Recommended order:
|
|
1. Run: ./.maintain-custom-release.sh status
|
|
2. Optional but recommended: ./.maintain-custom-release.sh create-restore-point before-custom-release-work
|
|
3. First release on a new series:
|
|
- run: ./.maintain-custom-release.sh bootstrap
|
|
4. Fetch what you need:
|
|
- upstream/main or your configured compare branch: ./.maintain-custom-release.sh fetch-upstream-compare
|
|
- upstream release target ref: ./.maintain-custom-release.sh fetch-upstream-target
|
|
- or both: ./.maintain-custom-release.sh fetch
|
|
5. Run: ./.maintain-custom-release.sh plan
|
|
6. Then import in the order you want:
|
|
- upstream/main or your configured compare branch first: ./.maintain-custom-release.sh sync-upstream-compare
|
|
- upstream release target next: ./.maintain-custom-release.sh sync-upstream-target
|
|
- only your custom commits: ./.maintain-custom-release.sh sync-custom
|
|
- or both in one step: ./.maintain-custom-release.sh sync-all
|
|
- for a fixed upstream release such as v1.26.0, set UPSTREAM_RELEASE_TARGET_REF first
|
|
7. Later patch releases on the same series:
|
|
- keep the same upstream minor release branch, for example release/v1.26
|
|
- run the sync step you want, usually: ./.maintain-custom-release.sh sync-all
|
|
8. If cherry-pick stops with conflicts:
|
|
- either resolve them and continue with: ./.maintain-custom-release.sh continue
|
|
- or return safely with: ./.maintain-custom-release.sh rollback
|
|
9. If you want to return to an explicitly saved manual checkpoint:
|
|
- run: ./.maintain-custom-release.sh restore-point
|
|
10. When the branch looks correct:
|
|
- run: ./.maintain-custom-release.sh tag v1.26.0
|
|
which creates: v1.26.0-custom
|
|
EOF
|
|
}
|
|
|
|
prompt_with_default() {
|
|
local prompt="$1" current_value="$2" reply=""
|
|
|
|
printf '%s [%s]: ' "$prompt" "$current_value" >&2
|
|
read -r reply
|
|
if [ -n "$reply" ]; then
|
|
printf '%s\n' "$reply"
|
|
else
|
|
printf '%s\n' "$current_value"
|
|
fi
|
|
}
|
|
|
|
prompt_with_default_allow_clear() {
|
|
local prompt="$1" current_value="$2" reply=""
|
|
|
|
printf '%s [%s]: ' "$prompt" "$current_value" >&2
|
|
read -r reply
|
|
if [ "$reply" = "-" ]; then
|
|
printf '\n'
|
|
elif [ -n "$reply" ]; then
|
|
printf '%s\n' "$reply"
|
|
else
|
|
printf '%s\n' "$current_value"
|
|
fi
|
|
}
|
|
|
|
self_update_external_copy_if_needed() {
|
|
local repo_root="" invoked_path="" canonical_path="" tmp_runtime_path="/tmp/.maintain-custom-release.sh"
|
|
|
|
repo_root="$(git rev-parse --show-toplevel 2>/dev/null || true)"
|
|
|
|
case "$0" in
|
|
/*) invoked_path="$0" ;;
|
|
*) invoked_path="$(pwd -P)/$0" ;;
|
|
esac
|
|
[ -f "$invoked_path" ] || invoked_path="$tmp_runtime_path"
|
|
if [ -f "$invoked_path" ]; then
|
|
invoked_path="$(cd "$(dirname "$invoked_path")" && pwd -P)/$(basename "$invoked_path")"
|
|
fi
|
|
|
|
if [ -n "$repo_root" ]; then
|
|
canonical_path="$(cd "$repo_root" && pwd -P)/.maintain-custom-release.sh"
|
|
else
|
|
canonical_path=""
|
|
fi
|
|
|
|
if [ -n "$canonical_path" ] && [ -f "$canonical_path" ]; then
|
|
if [ ! -f "$tmp_runtime_path" ] || ! cmp -s "$tmp_runtime_path" "$canonical_path"; then
|
|
cp "$canonical_path" "$tmp_runtime_path"
|
|
chmod +x "$tmp_runtime_path" >/dev/null 2>&1 || true
|
|
say "Updated the temporary runtime script copy: $tmp_runtime_path"
|
|
fi
|
|
if [ "$invoked_path" != "$tmp_runtime_path" ]; then
|
|
exec "$tmp_runtime_path" "$@"
|
|
fi
|
|
return 0
|
|
fi
|
|
|
|
if [ -f "$tmp_runtime_path" ] && [ "$invoked_path" != "$tmp_runtime_path" ]; then
|
|
say "Repo copy is unavailable in the current checkout. Relaunching from the temporary runtime copy: $tmp_runtime_path"
|
|
exec "$tmp_runtime_path" "$@"
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
normalize_upstream_release_branch() {
|
|
local fallback_branch=""
|
|
|
|
if git rev-parse --verify "refs/remotes/$REMOTE_NAME/$UPSTREAM_RELEASE_BRANCH" >/dev/null 2>&1; then
|
|
return
|
|
fi
|
|
|
|
if [[ "$UPSTREAM_RELEASE_BRANCH" =~ ^release/v([0-9]+)\.([0-9]+)\.[0-9]+$ ]]; then
|
|
fallback_branch="release/v${BASH_REMATCH[1]}.${BASH_REMATCH[2]}"
|
|
if git rev-parse --verify "refs/remotes/$REMOTE_NAME/$fallback_branch" >/dev/null 2>&1; then
|
|
say "Configured upstream release branch '$UPSTREAM_RELEASE_BRANCH' does not exist. Using '$fallback_branch' instead."
|
|
UPSTREAM_RELEASE_BRANCH="$fallback_branch"
|
|
save_runtime_settings
|
|
return
|
|
fi
|
|
fi
|
|
|
|
die "Remote branch '$REMOTE_NAME/$UPSTREAM_RELEASE_BRANCH' was not found."
|
|
}
|
|
|
|
ensure_git_repo() {
|
|
local raw_git_dir
|
|
|
|
REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" || die "This script must be run inside a git repository."
|
|
raw_git_dir="$(git rev-parse --git-dir)"
|
|
case "$raw_git_dir" in
|
|
/*) GIT_DIR="$raw_git_dir" ;;
|
|
*) GIT_DIR="$REPO_ROOT/$raw_git_dir" ;;
|
|
esac
|
|
STATE_FILE="$GIT_DIR/.maintain-custom-release-state"
|
|
SNAPSHOT_ROOT="$GIT_DIR/.maintain-custom-release-snapshots"
|
|
RESTORE_POINT_ROOT="$GIT_DIR/.maintain-custom-release-restore-points"
|
|
LEGACY_RESTORE_POINT_ROOT="$GIT_DIR/.manual-restore-points"
|
|
}
|
|
|
|
write_state() {
|
|
{
|
|
printf 'STATE_BRANCH=%q\n' "$STATE_BRANCH"
|
|
printf 'STATE_ENTRY_BRANCH=%q\n' "$STATE_ENTRY_BRANCH"
|
|
printf 'STATE_BACKUP_BRANCH=%q\n' "$STATE_BACKUP_BRANCH"
|
|
printf 'STATE_STASH_HASH=%q\n' "$STATE_STASH_HASH"
|
|
printf 'STATE_REMOTE_NAME=%q\n' "$STATE_REMOTE_NAME"
|
|
printf 'STATE_REMOTE_URL=%q\n' "$STATE_REMOTE_URL"
|
|
printf 'STATE_BASE_TAG=%q\n' "$STATE_BASE_TAG"
|
|
printf 'STATE_UPSTREAM_RELEASE_BRANCH=%q\n' "$STATE_UPSTREAM_RELEASE_BRANCH"
|
|
printf 'STATE_UPSTREAM_RELEASE_TARGET_REF=%q\n' "$STATE_UPSTREAM_RELEASE_TARGET_REF"
|
|
printf 'STATE_UPSTREAM_COMPARE_BRANCH=%q\n' "$STATE_UPSTREAM_COMPARE_BRANCH"
|
|
printf 'STATE_CUSTOM_SOURCE_BRANCH=%q\n' "$STATE_CUSTOM_SOURCE_BRANCH"
|
|
printf 'STATE_MAINTENANCE_BRANCH=%q\n' "$STATE_MAINTENANCE_BRANCH"
|
|
printf 'STATE_START_HEAD=%q\n' "$STATE_START_HEAD"
|
|
printf 'STATE_SNAPSHOT_PATH=%q\n' "$STATE_SNAPSHOT_PATH"
|
|
printf 'STATE_PENDING_COMMITS=%q\n' "$STATE_PENDING_COMMITS"
|
|
printf 'STATE_ACTION_LABEL=%q\n' "$STATE_ACTION_LABEL"
|
|
printf 'STATE_STATUS=%q\n' "$STATE_STATUS"
|
|
printf 'STATE_FETCH_REF_STATES=%q\n' "$STATE_FETCH_REF_STATES"
|
|
printf 'STATE_CREATED_MAINTENANCE_BRANCH=%q\n' "$STATE_CREATED_MAINTENANCE_BRANCH"
|
|
printf 'STATE_UPDATED_AT=%q\n' "$(date +%Y-%m-%dT%H:%M:%S)"
|
|
} >"$STATE_FILE"
|
|
}
|
|
|
|
load_state() {
|
|
ensure_git_repo
|
|
[ -f "$STATE_FILE" ] || return 1
|
|
# shellcheck disable=SC1090
|
|
. "$STATE_FILE"
|
|
[ -n "${STATE_BASE_TAG:-}" ] && BASE_TAG="$STATE_BASE_TAG"
|
|
[ -n "${STATE_UPSTREAM_RELEASE_BRANCH:-}" ] && UPSTREAM_RELEASE_BRANCH="$STATE_UPSTREAM_RELEASE_BRANCH"
|
|
if [ -n "${STATE_UPSTREAM_RELEASE_TARGET_REF:-}" ] || [ "${STATE_UPSTREAM_RELEASE_TARGET_REF+x}" = "x" ]; then
|
|
UPSTREAM_RELEASE_TARGET_REF="${STATE_UPSTREAM_RELEASE_TARGET_REF:-}"
|
|
fi
|
|
[ -n "${STATE_UPSTREAM_COMPARE_BRANCH:-}" ] && UPSTREAM_COMPARE_BRANCH="$STATE_UPSTREAM_COMPARE_BRANCH"
|
|
[ -n "${STATE_CUSTOM_SOURCE_BRANCH:-}" ] && CUSTOM_SOURCE_BRANCH="$STATE_CUSTOM_SOURCE_BRANCH"
|
|
[ -n "${STATE_MAINTENANCE_BRANCH:-}" ] && MAINTENANCE_BRANCH="$STATE_MAINTENANCE_BRANCH"
|
|
return 0
|
|
}
|
|
|
|
worktree_has_local_changes() {
|
|
! git diff --quiet || ! git diff --cached --quiet || [ -n "$(git ls-files --others --exclude-standard)" ]
|
|
}
|
|
|
|
has_cherry_pick_in_progress() {
|
|
[ -e "$(git rev-parse --git-path CHERRY_PICK_HEAD)" ]
|
|
}
|
|
|
|
sanitize_ref_name() {
|
|
printf '%s\n' "${1//\//-}"
|
|
}
|
|
|
|
sanitize_storage_name() {
|
|
local raw_value="${1:-}" sanitized=""
|
|
|
|
sanitized="${raw_value//\//-}"
|
|
sanitized="${sanitized// /-}"
|
|
sanitized="${sanitized//:/-}"
|
|
sanitized="${sanitized//[^[:alnum:]._-]/-}"
|
|
printf '%s\n' "$sanitized"
|
|
}
|
|
|
|
ensure_rsync_available() {
|
|
command -v rsync >/dev/null 2>&1 || die "rsync is required for exact repository snapshots."
|
|
}
|
|
|
|
snapshot_repo_dir() {
|
|
printf '%s\n' "$1/repo"
|
|
}
|
|
|
|
is_valid_snapshot_dir() {
|
|
[ -d "$1" ] && [ -d "$(snapshot_repo_dir "$1")" ]
|
|
}
|
|
|
|
snapshot_metadata_value() {
|
|
local snapshot_dir="$1" key="$2"
|
|
|
|
[ -f "$snapshot_dir/metadata.txt" ] || return 1
|
|
sed -n "s/^${key}=//p" "$snapshot_dir/metadata.txt" | head -n 1
|
|
}
|
|
|
|
restore_point_refs_file() {
|
|
printf '%s\n' "$1/script-managed-refs.txt"
|
|
}
|
|
|
|
restore_point_snapshots_file() {
|
|
printf '%s\n' "$1/script-managed-snapshots.txt"
|
|
}
|
|
|
|
capture_script_managed_refs() {
|
|
git for-each-ref --format='%(refname)|%(objectname)' \
|
|
"refs/remotes/$REMOTE_NAME" \
|
|
"refs/heads/$MAINTENANCE_BRANCH" \
|
|
"refs/heads/backup/maint-"
|
|
}
|
|
|
|
cleanup_current_script_managed_refs() {
|
|
local current_ref current_oid
|
|
|
|
while IFS='|' read -r current_ref current_oid; do
|
|
[ -n "$current_ref" ] || continue
|
|
git update-ref -d "$current_ref" >/dev/null 2>&1 || true
|
|
done < <(capture_script_managed_refs)
|
|
}
|
|
|
|
save_script_managed_restore_state() {
|
|
local restore_point_dir="$1" refs_file snapshots_file
|
|
|
|
refs_file="$(restore_point_refs_file "$restore_point_dir")"
|
|
snapshots_file="$(restore_point_snapshots_file "$restore_point_dir")"
|
|
|
|
capture_script_managed_refs | sort >"$refs_file"
|
|
|
|
if [ -d "$SNAPSHOT_ROOT" ]; then
|
|
find "$SNAPSHOT_ROOT" -mindepth 2 -maxdepth 2 -type d -printf '%P\n' | sort >"$snapshots_file"
|
|
else
|
|
: >"$snapshots_file"
|
|
fi
|
|
|
|
if [ -f "$STATE_FILE" ]; then
|
|
cp "$STATE_FILE" "$restore_point_dir/.maintain-custom-release-state.saved"
|
|
else
|
|
rm -f "$restore_point_dir/.maintain-custom-release-state.saved"
|
|
fi
|
|
}
|
|
|
|
restore_script_managed_refs() {
|
|
local restore_point_dir="$1" refs_file current_ref current_oid saved_oid
|
|
|
|
refs_file="$(restore_point_refs_file "$restore_point_dir")"
|
|
if [ ! -f "$refs_file" ]; then
|
|
cleanup_current_script_managed_refs
|
|
return 0
|
|
fi
|
|
|
|
while IFS='|' read -r current_ref current_oid; do
|
|
[ -n "$current_ref" ] || continue
|
|
if ! grep -Fq "${current_ref}|" "$refs_file"; then
|
|
git update-ref -d "$current_ref" >/dev/null 2>&1 || true
|
|
fi
|
|
done < <(capture_script_managed_refs)
|
|
|
|
while IFS='|' read -r current_ref saved_oid; do
|
|
[ -n "$current_ref" ] || continue
|
|
[ -n "$saved_oid" ] || continue
|
|
git update-ref "$current_ref" "$saved_oid"
|
|
done <"$refs_file"
|
|
}
|
|
|
|
restore_script_managed_snapshots() {
|
|
local restore_point_dir="$1" snapshots_file current_snapshot rel_path current_branch_dir
|
|
|
|
snapshots_file="$(restore_point_snapshots_file "$restore_point_dir")"
|
|
if [ ! -f "$snapshots_file" ]; then
|
|
rm -rf "$SNAPSHOT_ROOT"
|
|
return 0
|
|
fi
|
|
[ -d "$SNAPSHOT_ROOT" ] || return 0
|
|
|
|
while IFS= read -r current_snapshot; do
|
|
[ -n "$current_snapshot" ] || continue
|
|
rel_path="${current_snapshot#$SNAPSHOT_ROOT/}"
|
|
if ! grep -Fxq "$rel_path" "$snapshots_file"; then
|
|
rm -rf "$current_snapshot"
|
|
fi
|
|
done < <(find "$SNAPSHOT_ROOT" -mindepth 2 -maxdepth 2 -type d | sort)
|
|
|
|
while IFS= read -r current_branch_dir; do
|
|
[ -n "$current_branch_dir" ] || continue
|
|
if [ -z "$(find "$current_branch_dir" -mindepth 1 -maxdepth 1 -type d -print -quit)" ]; then
|
|
rmdir "$current_branch_dir" 2>/dev/null || true
|
|
fi
|
|
done < <(find "$SNAPSHOT_ROOT" -mindepth 1 -maxdepth 1 -type d | sort)
|
|
|
|
if [ -z "$(find "$SNAPSHOT_ROOT" -mindepth 1 -maxdepth 1 -print -quit)" ]; then
|
|
rmdir "$SNAPSHOT_ROOT" 2>/dev/null || true
|
|
fi
|
|
}
|
|
|
|
restore_script_managed_state_file() {
|
|
local restore_point_dir="$1" saved_state_file
|
|
|
|
saved_state_file="$restore_point_dir/.maintain-custom-release-state.saved"
|
|
if [ -f "$saved_state_file" ]; then
|
|
cp "$saved_state_file" "$STATE_FILE"
|
|
else
|
|
rm -f "$STATE_FILE"
|
|
fi
|
|
}
|
|
|
|
cleanup_temporary_restore_artifacts() {
|
|
local safety_backup_branch="${1:-}" safety_snapshot_dir="${2:-}"
|
|
|
|
if [ -n "$safety_backup_branch" ] && git show-ref --verify --quiet "refs/heads/$safety_backup_branch"; then
|
|
git branch -D "$safety_backup_branch" >/dev/null
|
|
fi
|
|
if [ -n "$safety_snapshot_dir" ] && [ -d "$safety_snapshot_dir" ]; then
|
|
rm -rf "$safety_snapshot_dir"
|
|
fi
|
|
}
|
|
|
|
create_worktree_snapshot_for_reason() {
|
|
local reason="$1" safe_branch_name timestamp snapshot_dir snapshot_dir_repo
|
|
|
|
ensure_rsync_available
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
timestamp="$(date +%Y%m%d-%H%M%S)"
|
|
snapshot_dir="$SNAPSHOT_ROOT/$safe_branch_name/${timestamp}-${reason}"
|
|
snapshot_dir_repo="$(snapshot_repo_dir "$snapshot_dir")"
|
|
|
|
mkdir -p "$snapshot_dir_repo"
|
|
rsync --archive --delete --exclude='.git' "$REPO_ROOT"/ "$snapshot_dir_repo"/
|
|
|
|
{
|
|
printf 'branch=%s\n' "$CURRENT_BRANCH"
|
|
printf 'head=%s\n' "$(git rev-parse HEAD)"
|
|
printf 'created_at=%s\n' "$(date +%Y-%m-%dT%H:%M:%S)"
|
|
printf 'reason=%s\n' "$reason"
|
|
} >"$snapshot_dir/metadata.txt"
|
|
|
|
printf '%s\n' "$snapshot_dir"
|
|
}
|
|
|
|
restore_worktree_snapshot() {
|
|
local snapshot_dir="$1" snapshot_dir_repo
|
|
|
|
ensure_rsync_available
|
|
is_valid_snapshot_dir "$snapshot_dir" || die "Snapshot directory '$snapshot_dir' is not valid."
|
|
snapshot_dir_repo="$(snapshot_repo_dir "$snapshot_dir")"
|
|
|
|
rsync --archive --delete --exclude='.git' "$snapshot_dir_repo"/ "$REPO_ROOT"/
|
|
}
|
|
|
|
find_latest_snapshot_for_current() {
|
|
local safe_branch_name snapshot_branch_dir
|
|
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
snapshot_branch_dir="$SNAPSHOT_ROOT/$safe_branch_name"
|
|
[ -d "$snapshot_branch_dir" ] || return 1
|
|
find "$snapshot_branch_dir" -mindepth 1 -maxdepth 1 -type d | sort -r | head -n 1
|
|
}
|
|
|
|
find_latest_restore_point_for_current() {
|
|
local validation_mode="${1:-valid}" restore_point_dir source_branch
|
|
|
|
while IFS= read -r restore_point_dir; do
|
|
[ -n "$restore_point_dir" ] || continue
|
|
restore_point_matches_mode "$restore_point_dir" "$validation_mode" || continue
|
|
source_branch="$(snapshot_metadata_value "$restore_point_dir" source_branch || true)"
|
|
if [ "$source_branch" = "$CURRENT_BRANCH" ]; then
|
|
printf '%s\n' "$restore_point_dir"
|
|
return 0
|
|
fi
|
|
done < <(list_all_restore_points)
|
|
|
|
return 1
|
|
}
|
|
|
|
list_all_restore_points() {
|
|
{
|
|
if [ -d "$RESTORE_POINT_ROOT" ]; then
|
|
find "$RESTORE_POINT_ROOT" -mindepth 2 -maxdepth 2 -type d
|
|
fi
|
|
if [ -d "$LEGACY_RESTORE_POINT_ROOT" ]; then
|
|
find "$LEGACY_RESTORE_POINT_ROOT" -mindepth 1 -maxdepth 1 -type d
|
|
fi
|
|
} | sort -r
|
|
}
|
|
|
|
is_restore_point_candidate_dir() {
|
|
local target_dir="$1"
|
|
|
|
[ -d "$target_dir" ] || return 1
|
|
case "$target_dir" in
|
|
"$RESTORE_POINT_ROOT"/*) ;;
|
|
"$LEGACY_RESTORE_POINT_ROOT"/*) ;;
|
|
*) return 1 ;;
|
|
esac
|
|
is_valid_snapshot_dir "$target_dir"
|
|
}
|
|
|
|
restore_point_has_live_backup_branch() {
|
|
local target_dir="$1" backup_branch=""
|
|
|
|
backup_branch="$(snapshot_metadata_value "$target_dir" backup_branch || true)"
|
|
[ -n "$backup_branch" ] || return 0
|
|
git show-ref --verify --quiet "refs/heads/$backup_branch"
|
|
}
|
|
|
|
is_valid_restore_point_dir() {
|
|
local target_dir="$1"
|
|
|
|
is_restore_point_candidate_dir "$target_dir" || return 1
|
|
restore_point_has_live_backup_branch "$target_dir"
|
|
}
|
|
|
|
restore_point_matches_mode() {
|
|
local target_dir="$1" validation_mode="${2:-valid}"
|
|
|
|
case "$validation_mode" in
|
|
valid) is_valid_restore_point_dir "$target_dir" ;;
|
|
candidate) is_restore_point_candidate_dir "$target_dir" ;;
|
|
*) die "Unknown restore-point validation mode: $validation_mode" ;;
|
|
esac
|
|
}
|
|
|
|
resolve_restore_point_dir() {
|
|
local requested_target="${1:-}" validation_mode="${2:-valid}" direct_target="" branch_target=""
|
|
local -a matches=()
|
|
|
|
if [ -z "$requested_target" ]; then
|
|
find_latest_restore_point_for_current "$validation_mode"
|
|
return
|
|
fi
|
|
|
|
if [ -d "$requested_target" ]; then
|
|
direct_target="$(cd "$requested_target" && pwd -P)"
|
|
if restore_point_matches_mode "$direct_target" "$validation_mode"; then
|
|
printf '%s\n' "$direct_target"
|
|
return
|
|
fi
|
|
fi
|
|
|
|
branch_target="$RESTORE_POINT_ROOT/$(sanitize_ref_name "$CURRENT_BRANCH")/$requested_target"
|
|
if [ -d "$branch_target" ] && restore_point_matches_mode "$branch_target" "$validation_mode"; then
|
|
printf '%s\n' "$branch_target"
|
|
return
|
|
fi
|
|
|
|
mapfile -t matches < <(list_all_restore_points | grep -E "/${requested_target}$" || true)
|
|
if [ "${#matches[@]}" -eq 1 ] && restore_point_matches_mode "${matches[0]}" "$validation_mode"; then
|
|
printf '%s\n' "${matches[0]}"
|
|
return
|
|
fi
|
|
if [ "${#matches[@]}" -gt 1 ]; then
|
|
die "More than one restore point matches '$requested_target'. Use the full path."
|
|
fi
|
|
|
|
die "Restore point '$requested_target' was not found."
|
|
}
|
|
|
|
create_restore_point_branch_for_label() {
|
|
local label="$1" safe_branch_name safe_label timestamp branch_name
|
|
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
safe_label="$(sanitize_storage_name "$label")"
|
|
[ -n "$safe_label" ] || safe_label="manual"
|
|
timestamp="$(date +%Y%m%d-%H%M%S)"
|
|
branch_name="backup/restore-point-${safe_branch_name}-${safe_label}-${timestamp}"
|
|
|
|
git branch "$branch_name" HEAD >/dev/null
|
|
printf '%s\n' "$branch_name"
|
|
}
|
|
|
|
create_manual_restore_point() {
|
|
local label="${1:-manual}" safe_branch_name safe_label timestamp restore_point_dir restore_point_repo_dir
|
|
local restore_point_backup_branch current_head
|
|
|
|
ensure_rsync_available
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
safe_label="$(sanitize_storage_name "$label")"
|
|
[ -n "$safe_label" ] || safe_label="manual"
|
|
timestamp="$(date +%Y%m%d-%H%M%S)"
|
|
restore_point_dir="$RESTORE_POINT_ROOT/$safe_branch_name/${timestamp}-${safe_label}"
|
|
restore_point_repo_dir="$(snapshot_repo_dir "$restore_point_dir")"
|
|
restore_point_backup_branch="$(create_restore_point_branch_for_label "$safe_label")"
|
|
current_head="$(git rev-parse HEAD)"
|
|
|
|
mkdir -p "$restore_point_repo_dir"
|
|
rsync --archive --delete --exclude='.git' "$REPO_ROOT"/ "$restore_point_repo_dir"/
|
|
|
|
{
|
|
printf 'branch=%s\n' "$CURRENT_BRANCH"
|
|
printf 'source_branch=%s\n' "$CURRENT_BRANCH"
|
|
printf 'head=%s\n' "$current_head"
|
|
printf 'created_at=%s\n' "$(date +%Y-%m-%dT%H:%M:%S)"
|
|
printf 'label=%s\n' "$label"
|
|
printf 'backup_branch=%s\n' "$restore_point_backup_branch"
|
|
printf 'reason=manual_restore_point\n'
|
|
} >"$restore_point_dir/metadata.txt"
|
|
|
|
save_script_managed_restore_state "$restore_point_dir"
|
|
|
|
printf '%s\n' "$restore_point_dir"
|
|
}
|
|
|
|
ensure_no_noncherrypick_git_operation_in_progress() {
|
|
local git_path
|
|
for git_path in MERGE_HEAD REVERT_HEAD BISECT_LOG rebase-merge rebase-apply; do
|
|
if [ -e "$(git rev-parse --git-path "$git_path")" ]; then
|
|
die "A git operation is already in progress ($git_path). Finish it before running this script."
|
|
fi
|
|
done
|
|
}
|
|
|
|
ensure_no_git_operation_in_progress() {
|
|
local git_path
|
|
for git_path in CHERRY_PICK_HEAD MERGE_HEAD REVERT_HEAD BISECT_LOG rebase-merge rebase-apply; do
|
|
if [ -e "$(git rev-parse --git-path "$git_path")" ]; then
|
|
die "A git operation is already in progress ($git_path). Finish it before running this script."
|
|
fi
|
|
done
|
|
|
|
if [ -n "$(git diff --name-only --diff-filter=U)" ]; then
|
|
die "There are unmerged files in the working tree. Resolve them first."
|
|
fi
|
|
}
|
|
|
|
ensure_current_branch() {
|
|
CURRENT_BRANCH="$(git symbolic-ref --quiet --short HEAD || true)"
|
|
[ -n "$CURRENT_BRANCH" ] || die "Detached HEAD is not supported. Check out a branch first."
|
|
}
|
|
|
|
ensure_current_branch_with_state_fallback() {
|
|
CURRENT_BRANCH="$(git symbolic-ref --quiet --short HEAD || true)"
|
|
if [ -n "$CURRENT_BRANCH" ]; then
|
|
return
|
|
fi
|
|
|
|
if load_state && [ -n "${STATE_BRANCH:-}" ]; then
|
|
CURRENT_BRANCH="$STATE_BRANCH"
|
|
return
|
|
fi
|
|
|
|
die "Detached HEAD is not supported here and no saved branch state was found."
|
|
}
|
|
|
|
ensure_upstream_remote() {
|
|
local current_remote_url
|
|
|
|
if current_remote_url="$(git remote get-url "$REMOTE_NAME" 2>/dev/null)"; then
|
|
if [ "$current_remote_url" != "$REMOTE_URL" ]; then
|
|
die "Remote '$REMOTE_NAME' points to '$current_remote_url', expected '$REMOTE_URL'."
|
|
fi
|
|
return
|
|
fi
|
|
|
|
say "Adding remote '$REMOTE_NAME'..."
|
|
git remote add "$REMOTE_NAME" "$REMOTE_URL"
|
|
}
|
|
|
|
ensure_release_refs_exist() {
|
|
git rev-parse --verify "$BASE_TAG" >/dev/null 2>&1 || die "Base tag '$BASE_TAG' does not exist locally. Fetch tags first."
|
|
normalize_upstream_release_branch
|
|
git rev-parse --verify "$CUSTOM_SOURCE_BRANCH" >/dev/null 2>&1 || die "Custom source branch '$CUSTOM_SOURCE_BRANCH' does not exist locally."
|
|
git rev-parse --verify "refs/remotes/$REMOTE_NAME/$UPSTREAM_COMPARE_BRANCH" >/dev/null 2>&1 || die "Remote compare branch '$REMOTE_NAME/$UPSTREAM_COMPARE_BRANCH' was not found."
|
|
}
|
|
|
|
ensure_base_tag_exists() {
|
|
git rev-parse --verify "$BASE_TAG" >/dev/null 2>&1 || die "Base tag '$BASE_TAG' does not exist locally. Fetch tags first."
|
|
}
|
|
|
|
ensure_upstream_compare_ref_exists() {
|
|
git rev-parse --verify "refs/remotes/$REMOTE_NAME/$UPSTREAM_COMPARE_BRANCH" >/dev/null 2>&1 || die "Remote compare branch '$REMOTE_NAME/$UPSTREAM_COMPARE_BRANCH' was not found."
|
|
}
|
|
|
|
ensure_upstream_target_ref_exists() {
|
|
local source_ref=""
|
|
|
|
if [ -n "$UPSTREAM_RELEASE_TARGET_REF" ]; then
|
|
source_ref="$(resolve_upstream_release_import_ref)"
|
|
git rev-parse --verify "$source_ref" >/dev/null 2>&1 || die "Upstream release target ref '$source_ref' was not found locally."
|
|
return
|
|
fi
|
|
|
|
normalize_upstream_release_branch
|
|
source_ref="$(resolve_upstream_release_import_ref)"
|
|
git rev-parse --verify "$source_ref" >/dev/null 2>&1 || die "Upstream release target ref '$source_ref' was not found locally."
|
|
}
|
|
|
|
capture_fetch_ref_states() {
|
|
local branch ref oid seen_branches=""
|
|
|
|
FETCH_REF_STATES=""
|
|
for branch in "$UPSTREAM_RELEASE_BRANCH" "$UPSTREAM_COMPARE_BRANCH"; do
|
|
case " $seen_branches " in
|
|
*" $branch "*) continue ;;
|
|
esac
|
|
seen_branches="$seen_branches $branch"
|
|
ref="refs/remotes/$REMOTE_NAME/$branch"
|
|
if git show-ref --verify --quiet "$ref"; then
|
|
oid="$(git rev-parse "$ref")"
|
|
FETCH_REF_STATES="${FETCH_REF_STATES}${ref}|1|${oid}"$'\n'
|
|
else
|
|
FETCH_REF_STATES="${FETCH_REF_STATES}${ref}|0|"$'\n'
|
|
fi
|
|
done
|
|
}
|
|
|
|
restore_fetch_ref_states() {
|
|
local ref existed oid
|
|
|
|
[ -n "${STATE_FETCH_REF_STATES:-}" ] || return 0
|
|
|
|
while IFS='|' read -r ref existed oid; do
|
|
[ -n "$ref" ] || continue
|
|
if [ "$existed" = "1" ] && [ -n "$oid" ]; then
|
|
git update-ref "$ref" "$oid"
|
|
else
|
|
git update-ref -d "$ref" >/dev/null 2>&1 || true
|
|
fi
|
|
done <<< "${STATE_FETCH_REF_STATES}"
|
|
}
|
|
|
|
resolve_upstream_release_import_ref() {
|
|
if [ -n "$UPSTREAM_RELEASE_TARGET_REF" ]; then
|
|
git rev-parse --verify "$UPSTREAM_RELEASE_TARGET_REF" >/dev/null 2>&1 || die "Configured upstream release target ref '$UPSTREAM_RELEASE_TARGET_REF' does not exist locally."
|
|
printf '%s\n' "$UPSTREAM_RELEASE_TARGET_REF"
|
|
return
|
|
fi
|
|
|
|
printf '%s/%s\n' "$REMOTE_NAME" "$UPSTREAM_RELEASE_BRANCH"
|
|
}
|
|
|
|
maintenance_branch_exists() {
|
|
git show-ref --verify --quiet "refs/heads/$MAINTENANCE_BRANCH"
|
|
}
|
|
|
|
ensure_on_maintenance_branch() {
|
|
if ! maintenance_branch_exists; then
|
|
die "Maintenance branch '$MAINTENANCE_BRANCH' does not exist yet. Run 'bootstrap' first."
|
|
fi
|
|
|
|
if [ "$CURRENT_BRANCH" = "$MAINTENANCE_BRANCH" ]; then
|
|
return
|
|
fi
|
|
|
|
if worktree_has_local_changes; then
|
|
die "Current branch is '$CURRENT_BRANCH'. Switch to '$MAINTENANCE_BRANCH' with a clean worktree first."
|
|
fi
|
|
|
|
git switch "$MAINTENANCE_BRANCH" >/dev/null
|
|
CURRENT_BRANCH="$MAINTENANCE_BRANCH"
|
|
}
|
|
|
|
create_or_switch_to_maintenance_branch() {
|
|
MAINTENANCE_BRANCH_WAS_CREATED="0"
|
|
if maintenance_branch_exists; then
|
|
ensure_on_maintenance_branch
|
|
return
|
|
fi
|
|
|
|
if [ "$CURRENT_BRANCH" != "$MAINTENANCE_BRANCH" ] && worktree_has_local_changes; then
|
|
die "Create the maintenance branch from a clean worktree."
|
|
fi
|
|
|
|
git switch -c "$MAINTENANCE_BRANCH" "$BASE_TAG" >/dev/null
|
|
MAINTENANCE_BRANCH_WAS_CREATED="1"
|
|
CURRENT_BRANCH="$MAINTENANCE_BRANCH"
|
|
say "Created maintenance branch '$MAINTENANCE_BRANCH' from '$BASE_TAG'."
|
|
}
|
|
|
|
create_backup_branch_for_reason() {
|
|
local reason="$1" safe_branch_name timestamp branch_name
|
|
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
timestamp="$(date +%Y%m%d-%H%M%S)"
|
|
branch_name="backup/maint-${safe_branch_name}-${reason}-${timestamp}"
|
|
|
|
git branch "$branch_name" HEAD >/dev/null
|
|
printf '%s\n' "$branch_name"
|
|
}
|
|
|
|
find_latest_backup_branch_for_current() {
|
|
local safe_branch_name
|
|
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
git for-each-ref --sort=-creatordate --format='%(refname:short)' "refs/heads/backup/maint-${safe_branch_name}-*" | head -n 1
|
|
}
|
|
|
|
list_backup_branches_for_current() {
|
|
local safe_branch_name
|
|
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
git for-each-ref --sort=-creatordate --format='%(refname:short)' "refs/heads/backup/maint-${safe_branch_name}-*"
|
|
}
|
|
|
|
list_snapshot_dirs_for_current() {
|
|
local safe_branch_name snapshot_branch_dir
|
|
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
snapshot_branch_dir="$SNAPSHOT_ROOT/$safe_branch_name"
|
|
[ -d "$snapshot_branch_dir" ] || return 0
|
|
find "$snapshot_branch_dir" -mindepth 1 -maxdepth 1 -type d | sort -r
|
|
}
|
|
|
|
associated_backup_branch_for_snapshot() {
|
|
local target_snapshot="$1" relative_path="" snapshot_branch_name="" snapshot_name=""
|
|
local snapshot_timestamp="" snapshot_reason=""
|
|
|
|
case "$target_snapshot" in
|
|
"$SNAPSHOT_ROOT"/*) ;;
|
|
*) return 1 ;;
|
|
esac
|
|
|
|
relative_path="${target_snapshot#$SNAPSHOT_ROOT/}"
|
|
snapshot_branch_name="${relative_path%%/*}"
|
|
snapshot_name="${relative_path#*/}"
|
|
|
|
[ -n "$snapshot_branch_name" ] || return 1
|
|
[ -n "$snapshot_name" ] || return 1
|
|
[ "$snapshot_branch_name" != "$relative_path" ] || return 1
|
|
[ "$snapshot_name" != "$relative_path" ] || return 1
|
|
|
|
if [[ "$snapshot_name" =~ ^([0-9]{8}-[0-9]{6})-(.+)$ ]]; then
|
|
snapshot_timestamp="${BASH_REMATCH[1]}"
|
|
snapshot_reason="${BASH_REMATCH[2]}"
|
|
printf 'backup/maint-%s-%s-%s\n' "$snapshot_branch_name" "$snapshot_reason" "$snapshot_timestamp"
|
|
return 0
|
|
fi
|
|
|
|
printf 'backup/maint-%s-%s\n' "$snapshot_branch_name" "$snapshot_name"
|
|
}
|
|
|
|
prepare_safety_before_real_action() {
|
|
local backup_reason="$1"
|
|
|
|
STATE_START_HEAD="$(git rev-parse HEAD)"
|
|
BACKUP_BRANCH="$(create_backup_branch_for_reason "$backup_reason")"
|
|
STATE_SNAPSHOT_PATH="$(create_worktree_snapshot_for_reason "$backup_reason")"
|
|
say "Safety backup branch created: $BACKUP_BRANCH"
|
|
say "Exact worktree snapshot created: $STATE_SNAPSHOT_PATH"
|
|
}
|
|
|
|
stash_current_changes() {
|
|
local stash_prefix="$1" timestamp stash_name
|
|
|
|
STASH_REF=""
|
|
STASH_HASH=""
|
|
if ! worktree_has_local_changes; then
|
|
say "No local tracked/untracked changes to stash."
|
|
return
|
|
fi
|
|
|
|
timestamp="$(date +%Y%m%d-%H%M%S)"
|
|
stash_name="${stash_prefix}-$(sanitize_ref_name "$CURRENT_BRANCH")-${timestamp}"
|
|
|
|
say "Stashing local tracked and untracked changes..."
|
|
git stash push --include-untracked --message "$stash_name" >/dev/null
|
|
STASH_REF="$(git stash list -1 --format='%gd')"
|
|
[ -n "$STASH_REF" ] || die "Failed to locate the created stash entry."
|
|
STASH_HASH="$(git rev-parse "$STASH_REF")"
|
|
[ -n "$STASH_HASH" ] || die "Failed to resolve the created stash hash."
|
|
say "Local changes saved in $STASH_REF"
|
|
}
|
|
|
|
fetch_upstream_compare_ref() {
|
|
say "Fetching latest compare-branch changes from $REMOTE_NAME/$UPSTREAM_COMPARE_BRANCH..."
|
|
git fetch --prune --no-tags "$REMOTE_NAME" "+refs/heads/$UPSTREAM_COMPARE_BRANCH:refs/remotes/$REMOTE_NAME/$UPSTREAM_COMPARE_BRANCH"
|
|
}
|
|
|
|
fetch_upstream_target_ref() {
|
|
local target_ref="${UPSTREAM_RELEASE_TARGET_REF:-}"
|
|
|
|
if [ -z "$target_ref" ]; then
|
|
say "Fetching latest release-branch changes from $REMOTE_NAME/$UPSTREAM_RELEASE_BRANCH..."
|
|
git fetch --prune --no-tags "$REMOTE_NAME" "+refs/heads/$UPSTREAM_RELEASE_BRANCH:refs/remotes/$REMOTE_NAME/$UPSTREAM_RELEASE_BRANCH"
|
|
return
|
|
fi
|
|
|
|
if git fetch --no-tags "$REMOTE_NAME" "+refs/tags/$target_ref:refs/tags/$target_ref" >/dev/null 2>&1; then
|
|
say "Fetched upstream release target tag: $target_ref"
|
|
return
|
|
fi
|
|
|
|
say "Fetching configured release target branch/ref from $REMOTE_NAME/$target_ref..."
|
|
git fetch --prune --no-tags "$REMOTE_NAME" "+refs/heads/$target_ref:refs/remotes/$REMOTE_NAME/$target_ref"
|
|
}
|
|
|
|
fetch_upstream_refs() {
|
|
fetch_upstream_compare_ref
|
|
if [ "$UPSTREAM_COMPARE_BRANCH" != "$UPSTREAM_RELEASE_BRANCH" ] || [ -n "$UPSTREAM_RELEASE_TARGET_REF" ]; then
|
|
fetch_upstream_target_ref
|
|
fi
|
|
}
|
|
|
|
update_state() {
|
|
STATE_BRANCH="$CURRENT_BRANCH"
|
|
STATE_BACKUP_BRANCH="$BACKUP_BRANCH"
|
|
STATE_STASH_HASH="$STASH_HASH"
|
|
STATE_REMOTE_NAME="$REMOTE_NAME"
|
|
STATE_REMOTE_URL="$REMOTE_URL"
|
|
STATE_BASE_TAG="$BASE_TAG"
|
|
STATE_UPSTREAM_RELEASE_BRANCH="$UPSTREAM_RELEASE_BRANCH"
|
|
STATE_UPSTREAM_RELEASE_TARGET_REF="$UPSTREAM_RELEASE_TARGET_REF"
|
|
STATE_UPSTREAM_COMPARE_BRANCH="$UPSTREAM_COMPARE_BRANCH"
|
|
STATE_CUSTOM_SOURCE_BRANCH="$CUSTOM_SOURCE_BRANCH"
|
|
STATE_MAINTENANCE_BRANCH="$MAINTENANCE_BRANCH"
|
|
STATE_ENTRY_BRANCH="${STATE_ENTRY_BRANCH:-$CURRENT_BRANCH}"
|
|
STATE_FETCH_REF_STATES="${STATE_FETCH_REF_STATES:-}"
|
|
STATE_CREATED_MAINTENANCE_BRANCH="${STATE_CREATED_MAINTENANCE_BRANCH:-0}"
|
|
write_state
|
|
}
|
|
|
|
find_stash_ref_by_hash() {
|
|
local target_hash="$1" hash ref
|
|
|
|
while read -r hash ref; do
|
|
if [ "$hash" = "$target_hash" ]; then
|
|
printf '%s\n' "$ref"
|
|
return 0
|
|
fi
|
|
done < <(git stash list --format='%H %gd')
|
|
return 1
|
|
}
|
|
|
|
drop_stash_by_hash_if_present() {
|
|
local target_hash="$1" stash_ref
|
|
|
|
[ -n "$target_hash" ] || return 0
|
|
if stash_ref="$(find_stash_ref_by_hash "$target_hash")"; then
|
|
git stash drop "$stash_ref" >/dev/null
|
|
fi
|
|
}
|
|
|
|
restore_stash() {
|
|
local keep_saved_copy="${1:-0}" restore_target
|
|
|
|
if [ -z "$STASH_HASH" ] && [ -z "$STASH_REF" ]; then
|
|
return
|
|
fi
|
|
|
|
restore_target="${STASH_HASH:-$STASH_REF}"
|
|
say "Restoring stashed local changes from $restore_target..."
|
|
if git stash apply --index "$restore_target"; then
|
|
STASH_REF=""
|
|
if [ "$keep_saved_copy" -eq 0 ]; then
|
|
drop_stash_by_hash_if_present "$STASH_HASH"
|
|
STASH_HASH=""
|
|
STATE_STASH_HASH=""
|
|
else
|
|
STATE_STASH_HASH="${STASH_HASH:-$restore_target}"
|
|
fi
|
|
STATE_STATUS="completed"
|
|
update_state
|
|
if [ "$keep_saved_copy" -eq 0 ]; then
|
|
say "Local changes restored successfully."
|
|
else
|
|
say "Local changes restored successfully. The original stash was kept for rollback safety."
|
|
fi
|
|
return
|
|
fi
|
|
|
|
STATE_STATUS="restore_conflict"
|
|
update_state
|
|
say "Conflicts occurred while restoring local changes."
|
|
say "Backup branch kept at: $BACKUP_BRANCH"
|
|
say "Stash kept at: $restore_target"
|
|
say "Resolve the conflicts manually, or return safely with: ./.maintain-custom-release.sh rollback"
|
|
exit 1
|
|
}
|
|
|
|
ordered_upstream_release_commits_for_ref() {
|
|
local target_ref="$1" source_ref="" available_commit_shas="" commit
|
|
|
|
source_ref="$(resolve_upstream_release_import_ref)"
|
|
|
|
available_commit_shas="$(git cherry -v "$target_ref" "$source_ref" | awk '$1=="+"{print $2}')"
|
|
[ -n "$available_commit_shas" ] || return 0
|
|
|
|
while IFS= read -r commit; do
|
|
[ -n "$commit" ] || continue
|
|
if printf '%s\n' "$available_commit_shas" | grep -Fxq "$commit"; then
|
|
printf '%s\n' "$commit"
|
|
fi
|
|
done < <(git rev-list --reverse "${target_ref}..$source_ref")
|
|
}
|
|
|
|
ordered_upstream_compare_commits_for_ref() {
|
|
local target_ref="$1" source_ref="$REMOTE_NAME/$UPSTREAM_COMPARE_BRANCH" available_commit_shas="" commit
|
|
|
|
available_commit_shas="$(git cherry -v "$target_ref" "$source_ref" | awk '$1=="+"{print $2}')"
|
|
[ -n "$available_commit_shas" ] || return 0
|
|
|
|
while IFS= read -r commit; do
|
|
[ -n "$commit" ] || continue
|
|
if printf '%s\n' "$available_commit_shas" | grep -Fxq "$commit"; then
|
|
printf '%s\n' "$commit"
|
|
fi
|
|
done < <(git rev-list --reverse "${target_ref}..$source_ref")
|
|
}
|
|
|
|
ordered_custom_commits_not_in_ref() {
|
|
local target_ref="$1" custom_commit_shas="" still_missing_shas="" commit
|
|
|
|
custom_commit_shas="$(git cherry -v "$REMOTE_NAME/$UPSTREAM_COMPARE_BRANCH" "$CUSTOM_SOURCE_BRANCH" | awk '$1=="+"{print $2}')"
|
|
[ -n "$custom_commit_shas" ] || return 0
|
|
|
|
still_missing_shas="$(git cherry -v "$target_ref" "$CUSTOM_SOURCE_BRANCH" | awk '$1=="+"{print $2}')"
|
|
[ -n "$still_missing_shas" ] || return 0
|
|
|
|
while IFS= read -r commit; do
|
|
[ -n "$commit" ] || continue
|
|
if printf '%s\n' "$custom_commit_shas" | grep -Fxq "$commit" && printf '%s\n' "$still_missing_shas" | grep -Fxq "$commit"; then
|
|
printf '%s\n' "$commit"
|
|
fi
|
|
done < <(git rev-list --reverse "$REMOTE_NAME/$UPSTREAM_COMPARE_BRANCH..$CUSTOM_SOURCE_BRANCH")
|
|
}
|
|
|
|
show_commit_list() {
|
|
local header="$1" found_any=0 commit
|
|
shift
|
|
|
|
say "$header"
|
|
while IFS= read -r commit; do
|
|
[ -n "$commit" ] || continue
|
|
found_any=1
|
|
git show --no-patch --date=short --format=' - %h | %ad | %s' "$commit"
|
|
done
|
|
|
|
if [ "$found_any" -eq 0 ]; then
|
|
say " none"
|
|
fi
|
|
}
|
|
|
|
run_configure() {
|
|
say "Interactive configuration"
|
|
BASE_TAG="$(prompt_with_default "Base tag" "$BASE_TAG")"
|
|
UPSTREAM_RELEASE_BRANCH="$(prompt_with_default "Upstream release branch (for example release/v1.26)" "$UPSTREAM_RELEASE_BRANCH")"
|
|
UPSTREAM_RELEASE_TARGET_REF="$(prompt_with_default_allow_clear "Upstream release target ref (example v1.26.0, use - to clear)" "$UPSTREAM_RELEASE_TARGET_REF")"
|
|
MAINTENANCE_BRANCH="$(prompt_with_default "Custom maintenance branch" "$MAINTENANCE_BRANCH")"
|
|
CUSTOM_SOURCE_BRANCH="$(prompt_with_default "Custom source branch" "$CUSTOM_SOURCE_BRANCH")"
|
|
UPSTREAM_COMPARE_BRANCH="$(prompt_with_default "Upstream compare branch" "$UPSTREAM_COMPARE_BRANCH")"
|
|
CUSTOM_TAG_SUFFIX="$(prompt_with_default "Custom tag suffix" "$CUSTOM_TAG_SUFFIX")"
|
|
save_runtime_settings
|
|
say "Configuration updated for the current run."
|
|
}
|
|
|
|
show_plan() {
|
|
local plan_ref
|
|
|
|
ensure_git_repo
|
|
ensure_current_branch_with_state_fallback
|
|
ensure_base_tag_exists
|
|
ensure_upstream_compare_ref_exists
|
|
ensure_upstream_target_ref_exists
|
|
|
|
if maintenance_branch_exists; then
|
|
plan_ref="$MAINTENANCE_BRANCH"
|
|
else
|
|
plan_ref="$BASE_TAG"
|
|
fi
|
|
|
|
say "Plan target ref: $plan_ref"
|
|
show_commit_list "Upstream compare branch commits to import next:" < <(ordered_upstream_compare_commits_for_ref "$plan_ref")
|
|
show_commit_list "Upstream release target commits to import next:" < <(ordered_upstream_release_commits_for_ref "$plan_ref")
|
|
show_commit_list "Custom commits to import next (oldest first):" < <(ordered_custom_commits_not_in_ref "$plan_ref")
|
|
}
|
|
|
|
set_pending_commits_from_array() {
|
|
local pending=("$@")
|
|
STATE_PENDING_COMMITS="${pending[*]}"
|
|
}
|
|
|
|
pending_commits_to_array() {
|
|
read -r -a PENDING_COMMITS_ARRAY <<< "${STATE_PENDING_COMMITS:-}"
|
|
}
|
|
|
|
finish_import_sequence() {
|
|
STASH_HASH="${STATE_STASH_HASH:-}"
|
|
STASH_REF=""
|
|
restore_stash 1
|
|
STATE_PENDING_COMMITS=""
|
|
STATE_ACTION_LABEL=""
|
|
STATE_STATUS="completed"
|
|
update_state
|
|
say "Import sequence completed."
|
|
say "Safety backup branch available at: $BACKUP_BRANCH"
|
|
say "Safety snapshot available at: $STATE_SNAPSHOT_PATH"
|
|
if [ -n "$STATE_STASH_HASH" ]; then
|
|
say "Original pre-import stash retained for rollback at: $STATE_STASH_HASH"
|
|
fi
|
|
}
|
|
|
|
continue_pending_sequence() {
|
|
local pending=() commit
|
|
|
|
pending_commits_to_array
|
|
pending=("${PENDING_COMMITS_ARRAY[@]}")
|
|
|
|
while [ "${#pending[@]}" -gt 0 ]; do
|
|
commit="${pending[0]}"
|
|
say "Cherry-picking: $(git show --no-patch --format='%h %s' "$commit")"
|
|
if ! git cherry-pick -x "$commit"; then
|
|
set_pending_commits_from_array "${pending[@]}"
|
|
STATE_STATUS="cherry_pick_conflict"
|
|
update_state
|
|
say "Cherry-pick stopped because of conflicts."
|
|
say "Conflicting commit: $(git show --no-patch --format='%h %s' CHERRY_PICK_HEAD)"
|
|
say "Resolve conflicts and continue with: ./.maintain-custom-release.sh continue"
|
|
say "Or return safely with: ./.maintain-custom-release.sh rollback"
|
|
exit 1
|
|
fi
|
|
pending=("${pending[@]:1}")
|
|
set_pending_commits_from_array "${pending[@]}"
|
|
STATE_STATUS="import_in_progress"
|
|
update_state
|
|
done
|
|
|
|
finish_import_sequence
|
|
}
|
|
|
|
start_import_sequence() {
|
|
local action_label="$1"
|
|
shift
|
|
local selected_commits=("$@")
|
|
|
|
[ "${#selected_commits[@]}" -gt 0 ] || {
|
|
say "No commits need to be imported for '$action_label'."
|
|
return 0
|
|
}
|
|
|
|
prepare_safety_before_real_action "before-${action_label}"
|
|
stash_current_changes "pre-${action_label}"
|
|
set_pending_commits_from_array "${selected_commits[@]}"
|
|
STATE_ACTION_LABEL="$action_label"
|
|
STATE_STATUS="prepared"
|
|
update_state
|
|
continue_pending_sequence
|
|
}
|
|
|
|
collect_upstream_compare_commits_for_current_branch() {
|
|
ordered_upstream_compare_commits_for_ref "$CURRENT_BRANCH"
|
|
}
|
|
|
|
collect_upstream_target_commits_for_current_branch() {
|
|
ordered_upstream_release_commits_for_ref "$CURRENT_BRANCH"
|
|
}
|
|
|
|
collect_custom_commits_for_current_branch() {
|
|
ordered_custom_commits_not_in_ref "$CURRENT_BRANCH"
|
|
}
|
|
|
|
run_status() {
|
|
local stash_count latest_backup latest_snapshot latest_restore_point
|
|
|
|
ensure_git_repo
|
|
ensure_current_branch_with_state_fallback
|
|
ensure_upstream_remote
|
|
|
|
stash_count="$(git stash list | wc -l | tr -d ' ')"
|
|
latest_backup="$(find_latest_backup_branch_for_current || true)"
|
|
latest_snapshot="$(find_latest_snapshot_for_current || true)"
|
|
latest_restore_point="$(find_latest_restore_point_for_current || true)"
|
|
|
|
say "Repository: $(git rev-parse --show-toplevel)"
|
|
say "Current branch: $CURRENT_BRANCH"
|
|
say "Maintenance branch: $MAINTENANCE_BRANCH"
|
|
say "Base tag: $BASE_TAG"
|
|
say "Upstream release branch: $REMOTE_NAME/$UPSTREAM_RELEASE_BRANCH"
|
|
say "Upstream release target ref: ${UPSTREAM_RELEASE_TARGET_REF:-$REMOTE_NAME/$UPSTREAM_RELEASE_BRANCH}"
|
|
say "Custom source branch: $CUSTOM_SOURCE_BRANCH"
|
|
say "Upstream compare branch: $REMOTE_NAME/$UPSTREAM_COMPARE_BRANCH"
|
|
say "Custom tag suffix: $CUSTOM_TAG_SUFFIX"
|
|
say "Working tree:"
|
|
if ! worktree_has_local_changes; then
|
|
say " clean"
|
|
else
|
|
git status --short
|
|
fi
|
|
say "Stash entries: $stash_count"
|
|
say "Latest backup for current branch: ${latest_backup:-none}"
|
|
say "Latest snapshot for current branch: ${latest_snapshot:-none}"
|
|
say "Latest restore point for current branch: ${latest_restore_point:-none}"
|
|
if load_state; then
|
|
say "Saved state: $STATE_STATUS"
|
|
say "Saved backup branch: ${STATE_BACKUP_BRANCH:-none}"
|
|
say "Saved starting commit: ${STATE_START_HEAD:-none}"
|
|
say "Saved exact snapshot: ${STATE_SNAPSHOT_PATH:-none}"
|
|
say "Saved original stash: ${STATE_STASH_HASH:-none}"
|
|
say "Saved action label: ${STATE_ACTION_LABEL:-none}"
|
|
say "Saved pending commits: ${STATE_PENDING_COMMITS:-none}"
|
|
else
|
|
say "Saved state: none"
|
|
fi
|
|
}
|
|
|
|
run_create_restore_point() {
|
|
local label="${1:-manual}" restore_point_dir=""
|
|
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch_with_state_fallback
|
|
|
|
restore_point_dir="$(create_manual_restore_point "$label")"
|
|
say "Manual restore point created: $restore_point_dir"
|
|
say "Associated backup branch: $(snapshot_metadata_value "$restore_point_dir" backup_branch || true)"
|
|
}
|
|
|
|
collect_restore_point_paths() {
|
|
local validation_mode="${1:-valid}" restore_point_dir
|
|
|
|
if [ ! -d "$RESTORE_POINT_ROOT" ] && [ ! -d "$LEGACY_RESTORE_POINT_ROOT" ]; then
|
|
return 0
|
|
fi
|
|
|
|
while IFS= read -r restore_point_dir; do
|
|
[ -n "$restore_point_dir" ] || continue
|
|
restore_point_matches_mode "$restore_point_dir" "$validation_mode" || continue
|
|
printf '%s\n' "$restore_point_dir"
|
|
done < <(list_all_restore_points)
|
|
}
|
|
|
|
show_restore_point_entry() {
|
|
local entry_number="$1" restore_point_dir="$2" validation_mode="${3:-valid}"
|
|
local source_branch head_value backup_branch created_at
|
|
|
|
source_branch="$(snapshot_metadata_value "$restore_point_dir" source_branch || true)"
|
|
head_value="$(snapshot_metadata_value "$restore_point_dir" head || true)"
|
|
backup_branch="$(snapshot_metadata_value "$restore_point_dir" backup_branch || true)"
|
|
created_at="$(snapshot_metadata_value "$restore_point_dir" created_at || true)"
|
|
|
|
say "$entry_number) $restore_point_dir"
|
|
say " source branch: ${source_branch:-unknown}"
|
|
say " head: ${head_value:-unknown}"
|
|
say " created at: ${created_at:-unknown}"
|
|
say " backup branch: ${backup_branch:-none}"
|
|
|
|
if [ "$validation_mode" = "candidate" ] && ! is_valid_restore_point_dir "$restore_point_dir"; then
|
|
say " status: orphaned"
|
|
fi
|
|
}
|
|
|
|
run_list_restore_points() {
|
|
local restore_point_dir found_any=0 entry_number=1
|
|
|
|
ensure_git_repo
|
|
|
|
while IFS= read -r restore_point_dir; do
|
|
[ -n "$restore_point_dir" ] || continue
|
|
found_any=1
|
|
show_restore_point_entry "$entry_number" "$restore_point_dir" valid
|
|
entry_number=$((entry_number + 1))
|
|
done < <(collect_restore_point_paths valid)
|
|
|
|
if [ "$found_any" -eq 0 ]; then
|
|
say "No valid restore points found."
|
|
fi
|
|
}
|
|
|
|
select_restore_point_interactively() {
|
|
local validation_mode="$1" action_label="$2" selection="" restore_point_dir=""
|
|
local -a restore_point_dirs=()
|
|
|
|
SELECTED_RESTORE_POINT=""
|
|
mapfile -t restore_point_dirs < <(collect_restore_point_paths "$validation_mode")
|
|
if [ "${#restore_point_dirs[@]}" -eq 0 ]; then
|
|
if [ "$validation_mode" = "valid" ]; then
|
|
say "No valid restore points found."
|
|
else
|
|
say "No restore points found."
|
|
fi
|
|
return 1
|
|
fi
|
|
|
|
for i in "${!restore_point_dirs[@]}"; do
|
|
show_restore_point_entry "$((i + 1))" "${restore_point_dirs[$i]}" "$validation_mode"
|
|
done
|
|
|
|
printf 'Choose backup number to %s [0 cancel]: ' "$action_label"
|
|
read -r selection
|
|
|
|
case "$selection" in
|
|
0|"") return 1 ;;
|
|
*[!0-9]*) say "Invalid selection: $selection"; return 1 ;;
|
|
esac
|
|
|
|
if [ "$selection" -lt 1 ] || [ "$selection" -gt "${#restore_point_dirs[@]}" ]; then
|
|
say "Invalid selection: $selection"
|
|
return 1
|
|
fi
|
|
|
|
restore_point_dir="${restore_point_dirs[$((selection - 1))]}"
|
|
SELECTED_RESTORE_POINT="$restore_point_dir"
|
|
return 0
|
|
}
|
|
|
|
run_fetch_all() {
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
fetch_upstream_refs
|
|
say "Latest upstream compare branch and release target refs fetched."
|
|
}
|
|
|
|
run_fetch_upstream_compare() {
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
fetch_upstream_compare_ref
|
|
say "Latest upstream compare branch ref fetched."
|
|
}
|
|
|
|
run_fetch_upstream_target() {
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
fetch_upstream_target_ref
|
|
say "Latest upstream release target ref fetched."
|
|
}
|
|
|
|
run_bootstrap() {
|
|
local entry_branch=""
|
|
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
entry_branch="$CURRENT_BRANCH"
|
|
ensure_base_tag_exists
|
|
prepare_safety_before_real_action "before-bootstrap"
|
|
create_or_switch_to_maintenance_branch
|
|
STATE_ENTRY_BRANCH="$entry_branch"
|
|
STATE_FETCH_REF_STATES=""
|
|
STATE_CREATED_MAINTENANCE_BRANCH="$MAINTENANCE_BRANCH_WAS_CREATED"
|
|
STATE_PENDING_COMMITS=""
|
|
STATE_ACTION_LABEL="bootstrap"
|
|
STATE_STATUS="bootstrap_completed"
|
|
update_state
|
|
say "Maintenance branch ready: $MAINTENANCE_BRANCH"
|
|
say "Next step: run sync-upstream-compare, sync-upstream-target, sync-custom, or sync-all."
|
|
}
|
|
|
|
run_sync_upstream_compare() {
|
|
local -a selected_commits=()
|
|
local commit
|
|
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
STATE_ENTRY_BRANCH="${STATE_ENTRY_BRANCH:-$CURRENT_BRANCH}"
|
|
if [ -z "${STATE_FETCH_REF_STATES:-}" ]; then
|
|
capture_fetch_ref_states
|
|
STATE_FETCH_REF_STATES="$FETCH_REF_STATES"
|
|
fi
|
|
STATE_CREATED_MAINTENANCE_BRANCH="${STATE_CREATED_MAINTENANCE_BRANCH:-0}"
|
|
fetch_upstream_compare_ref
|
|
ensure_upstream_compare_ref_exists
|
|
ensure_on_maintenance_branch
|
|
|
|
while IFS= read -r commit; do
|
|
[ -n "$commit" ] || continue
|
|
selected_commits+=("$commit")
|
|
done < <(collect_upstream_compare_commits_for_current_branch)
|
|
|
|
start_import_sequence "sync-upstream-compare" "${selected_commits[@]}"
|
|
}
|
|
|
|
run_sync_upstream_target() {
|
|
local -a selected_commits=()
|
|
local commit
|
|
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
STATE_ENTRY_BRANCH="${STATE_ENTRY_BRANCH:-$CURRENT_BRANCH}"
|
|
if [ -z "${STATE_FETCH_REF_STATES:-}" ]; then
|
|
capture_fetch_ref_states
|
|
STATE_FETCH_REF_STATES="$FETCH_REF_STATES"
|
|
fi
|
|
STATE_CREATED_MAINTENANCE_BRANCH="${STATE_CREATED_MAINTENANCE_BRANCH:-0}"
|
|
fetch_upstream_target_ref
|
|
ensure_upstream_target_ref_exists
|
|
ensure_on_maintenance_branch
|
|
|
|
while IFS= read -r commit; do
|
|
[ -n "$commit" ] || continue
|
|
selected_commits+=("$commit")
|
|
done < <(collect_upstream_target_commits_for_current_branch)
|
|
|
|
start_import_sequence "sync-upstream-target" "${selected_commits[@]}"
|
|
}
|
|
|
|
run_sync_custom() {
|
|
local -a selected_commits=()
|
|
local commit
|
|
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
STATE_ENTRY_BRANCH="${STATE_ENTRY_BRANCH:-$CURRENT_BRANCH}"
|
|
if [ -z "${STATE_FETCH_REF_STATES:-}" ]; then
|
|
capture_fetch_ref_states
|
|
STATE_FETCH_REF_STATES="$FETCH_REF_STATES"
|
|
fi
|
|
STATE_CREATED_MAINTENANCE_BRANCH="${STATE_CREATED_MAINTENANCE_BRANCH:-0}"
|
|
fetch_upstream_compare_ref
|
|
ensure_release_refs_exist
|
|
ensure_on_maintenance_branch
|
|
|
|
while IFS= read -r commit; do
|
|
[ -n "$commit" ] || continue
|
|
selected_commits+=("$commit")
|
|
done < <(collect_custom_commits_for_current_branch)
|
|
|
|
start_import_sequence "sync-custom" "${selected_commits[@]}"
|
|
}
|
|
|
|
run_sync_all() {
|
|
STATE_ENTRY_BRANCH=""
|
|
STATE_FETCH_REF_STATES=""
|
|
STATE_CREATED_MAINTENANCE_BRANCH="0"
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
run_sync_upstream_compare
|
|
run_sync_upstream_target
|
|
run_sync_custom
|
|
}
|
|
|
|
run_continue() {
|
|
ensure_git_repo
|
|
ensure_current_branch_with_state_fallback
|
|
ensure_upstream_remote
|
|
load_state || die "No saved import state was found."
|
|
[ "$CURRENT_BRANCH" = "${STATE_BRANCH:-$CURRENT_BRANCH}" ] || die "Saved import state belongs to branch '$STATE_BRANCH'. Check out that branch first."
|
|
has_cherry_pick_in_progress || die "There is no in-progress cherry-pick to continue."
|
|
|
|
BACKUP_BRANCH="${STATE_BACKUP_BRANCH:-}"
|
|
STASH_HASH="${STATE_STASH_HASH:-}"
|
|
STATE_STATUS="import_in_progress"
|
|
update_state
|
|
|
|
say "Continuing cherry-pick..."
|
|
GIT_EDITOR=: git cherry-pick --continue
|
|
|
|
pending_commits_to_array
|
|
if [ "${#PENDING_COMMITS_ARRAY[@]}" -gt 0 ]; then
|
|
set_pending_commits_from_array "${PENDING_COMMITS_ARRAY[@]:1}"
|
|
update_state
|
|
fi
|
|
|
|
continue_pending_sequence
|
|
}
|
|
|
|
run_restore_saved_stash() {
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch_with_state_fallback
|
|
load_state || die "No saved state was found."
|
|
[ "$CURRENT_BRANCH" = "${STATE_BRANCH:-$CURRENT_BRANCH}" ] || die "Saved state belongs to branch '$STATE_BRANCH'. Check out that branch first."
|
|
[ -n "${STATE_STASH_HASH:-}" ] || die "There is no saved pre-import stash to restore."
|
|
if worktree_has_local_changes; then
|
|
die "The working tree is not clean. Commit, stash, or discard current changes before restoring the saved stash."
|
|
fi
|
|
|
|
prepare_safety_before_real_action "before-restore-stash"
|
|
STASH_HASH="$STATE_STASH_HASH"
|
|
STASH_REF=""
|
|
restore_stash 1
|
|
say "Saved pre-import local changes restored."
|
|
}
|
|
|
|
list_stash_entries() {
|
|
git stash list --format='%gd%x09%H%x09%gs'
|
|
}
|
|
|
|
select_stash_interactively() {
|
|
local choice stash_ref stash_hash stash_subject
|
|
local -a stash_rows=()
|
|
|
|
SELECTED_STASH_TARGET=""
|
|
ensure_git_repo
|
|
load_state || true
|
|
mapfile -t stash_rows < <(list_stash_entries)
|
|
if [ "${#stash_rows[@]}" -eq 0 ]; then
|
|
say "No stash entries found."
|
|
return 1
|
|
fi
|
|
|
|
say "Stash entries:"
|
|
for i in "${!stash_rows[@]}"; do
|
|
IFS=$'\t' read -r stash_ref stash_hash stash_subject <<<"${stash_rows[$i]}"
|
|
if [ -n "${STATE_STASH_HASH:-}" ] && [ "$stash_hash" = "$STATE_STASH_HASH" ]; then
|
|
say " $((i + 1))) ${stash_ref} [saved state] - ${stash_subject}"
|
|
else
|
|
say " $((i + 1))) ${stash_ref} - ${stash_subject}"
|
|
fi
|
|
done
|
|
say " B) Back"
|
|
say " 0) Exit"
|
|
printf 'Choose stash [Enter=Back]: '
|
|
read -r choice
|
|
|
|
case "$choice" in
|
|
0) exit 0 ;;
|
|
""|[bB]) return 1 ;;
|
|
*[!0-9]*)
|
|
say "Invalid menu selection: $choice"
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
if [ "$choice" -lt 1 ] || [ "$choice" -gt "${#stash_rows[@]}" ]; then
|
|
say "Invalid menu selection: $choice"
|
|
return 1
|
|
fi
|
|
|
|
SELECTED_STASH_TARGET="${stash_rows[$((choice - 1))]}"
|
|
return 0
|
|
}
|
|
|
|
run_delete_saved_stash() {
|
|
local target_spec="${1:-}" stash_ref="" stash_hash="" stash_subject=""
|
|
|
|
ensure_git_repo
|
|
load_state || true
|
|
|
|
if [ -n "$target_spec" ]; then
|
|
if [[ "$target_spec" == *$'\t'* ]]; then
|
|
IFS=$'\t' read -r stash_ref stash_hash stash_subject <<<"$target_spec"
|
|
else
|
|
stash_ref="$target_spec"
|
|
stash_hash="$(git rev-parse "$stash_ref" 2>/dev/null || true)"
|
|
fi
|
|
else
|
|
[ -n "${STATE_STASH_HASH:-}" ] || die "There is no saved pre-import stash to delete."
|
|
stash_hash="$STATE_STASH_HASH"
|
|
stash_ref="$(find_stash_ref_by_hash "$stash_hash" || true)"
|
|
fi
|
|
|
|
[ -n "$stash_ref" ] || [ -n "$stash_hash" ] || die "There is no saved pre-import stash to delete."
|
|
|
|
if [ -n "$stash_hash" ]; then
|
|
drop_stash_by_hash_if_present "$stash_hash"
|
|
elif [ -n "$stash_ref" ]; then
|
|
git stash drop "$stash_ref" >/dev/null
|
|
fi
|
|
|
|
if [ -n "${STATE_STASH_HASH:-}" ] && [ "$stash_hash" = "$STATE_STASH_HASH" ]; then
|
|
STATE_STASH_HASH=""
|
|
write_state
|
|
say "Deleted the saved pre-import stash reference."
|
|
else
|
|
say "Deleted stash: ${stash_ref:-$stash_hash}"
|
|
fi
|
|
}
|
|
|
|
run_rollback() {
|
|
local explicit_target="${1:-}" reset_target="" reset_snapshot=""
|
|
local original_restore_stash_hash="" original_restore_start_head=""
|
|
local original_action_backup_branch="" original_action_snapshot=""
|
|
local rollback_safety_snapshot="" rollback_safety_backup="" rollback_safety_start_head=""
|
|
local preserve_stash_hash=""
|
|
local restore_branch_after="" created_branch_name="" remove_created_branch="0"
|
|
local needs_state_branch_switch="0" allow_entry_branch_bootstrap_rollback="0"
|
|
|
|
ensure_git_repo
|
|
ensure_no_noncherrypick_git_operation_in_progress
|
|
load_state || true
|
|
ensure_current_branch_with_state_fallback
|
|
ensure_upstream_remote
|
|
|
|
if [ -z "$explicit_target" ] && [ -n "${STATE_BRANCH:-}" ] && [ "$CURRENT_BRANCH" != "$STATE_BRANCH" ]; then
|
|
needs_state_branch_switch="1"
|
|
fi
|
|
|
|
if [ -n "$explicit_target" ] && is_valid_snapshot_dir "$explicit_target"; then
|
|
reset_snapshot="$explicit_target"
|
|
elif [ -n "$explicit_target" ]; then
|
|
git show-ref --verify --quiet "refs/heads/$explicit_target" || die "Backup branch '$explicit_target' does not exist."
|
|
reset_target="$explicit_target"
|
|
else
|
|
if [ "$needs_state_branch_switch" = "1" ] &&
|
|
[ "${STATE_ACTION_LABEL:-}" = "bootstrap" ] &&
|
|
[ "${STATE_CREATED_MAINTENANCE_BRANCH:-0}" = "1" ] &&
|
|
[ -n "${STATE_ENTRY_BRANCH:-}" ] &&
|
|
[ "$CURRENT_BRANCH" = "$STATE_ENTRY_BRANCH" ]; then
|
|
allow_entry_branch_bootstrap_rollback="1"
|
|
needs_state_branch_switch="0"
|
|
fi
|
|
|
|
if [ "$needs_state_branch_switch" = "1" ]; then
|
|
die "Saved state belongs to branch '$STATE_BRANCH'. Check out that branch or pass an explicit backup branch or snapshot."
|
|
fi
|
|
if [ -n "${STATE_SNAPSHOT_PATH:-}" ] && is_valid_snapshot_dir "$STATE_SNAPSHOT_PATH"; then
|
|
reset_snapshot="$STATE_SNAPSHOT_PATH"
|
|
fi
|
|
if [ -n "${STATE_START_HEAD:-}" ]; then
|
|
reset_target="$STATE_START_HEAD"
|
|
elif [ -n "${STATE_BACKUP_BRANCH:-}" ]; then
|
|
reset_target="$STATE_BACKUP_BRANCH"
|
|
else
|
|
reset_target="$(find_latest_backup_branch_for_current || true)"
|
|
fi
|
|
fi
|
|
|
|
if [ -z "$reset_target" ] && [ -n "$reset_snapshot" ]; then
|
|
reset_target="$(snapshot_metadata_value "$reset_snapshot" head || true)"
|
|
fi
|
|
|
|
[ -n "$reset_target" ] || [ -n "$reset_snapshot" ] || die "No saved rollback target was found."
|
|
|
|
original_restore_stash_hash="${STATE_STASH_HASH:-}"
|
|
original_restore_start_head="${STATE_START_HEAD:-}"
|
|
original_action_backup_branch="${STATE_BACKUP_BRANCH:-}"
|
|
original_action_snapshot="${STATE_SNAPSHOT_PATH:-}"
|
|
restore_branch_after="${STATE_ENTRY_BRANCH:-}"
|
|
created_branch_name="${STATE_BRANCH:-$MAINTENANCE_BRANCH}"
|
|
remove_created_branch="${STATE_CREATED_MAINTENANCE_BRANCH:-0}"
|
|
if [ -z "$original_restore_start_head" ] && [ -n "$reset_snapshot" ]; then
|
|
original_restore_start_head="$(snapshot_metadata_value "$reset_snapshot" head || true)"
|
|
fi
|
|
|
|
if has_cherry_pick_in_progress; then
|
|
say "Aborting in-progress cherry-pick before rollback..."
|
|
git cherry-pick --abort || die "Failed to abort the in-progress cherry-pick."
|
|
fi
|
|
|
|
if [ -n "$(git diff --name-only --diff-filter=U)" ]; then
|
|
die "There are still unmerged files in the working tree. Resolve or discard them before rollback."
|
|
fi
|
|
|
|
prepare_safety_before_real_action "before-rollback"
|
|
rollback_safety_backup="$BACKUP_BRANCH"
|
|
rollback_safety_snapshot="$STATE_SNAPSHOT_PATH"
|
|
rollback_safety_start_head="$STATE_START_HEAD"
|
|
|
|
preserve_stash_hash=""
|
|
if worktree_has_local_changes; then
|
|
stash_current_changes "pre-rollback-preserve"
|
|
preserve_stash_hash="$STASH_HASH"
|
|
fi
|
|
|
|
if [ "$needs_state_branch_switch" = "1" ]; then
|
|
if git show-ref --verify --quiet "refs/heads/$STATE_BRANCH"; then
|
|
git switch "$STATE_BRANCH" >/dev/null
|
|
CURRENT_BRANCH="$STATE_BRANCH"
|
|
else
|
|
die "Saved state branch '$STATE_BRANCH' does not exist anymore."
|
|
fi
|
|
fi
|
|
|
|
if [ -n "$reset_target" ]; then
|
|
say "Resetting '$CURRENT_BRANCH' to '$reset_target'..."
|
|
git reset --hard "$reset_target" >/dev/null
|
|
fi
|
|
|
|
if [ -n "$original_restore_stash_hash" ]; then
|
|
STASH_HASH="$original_restore_stash_hash"
|
|
STASH_REF=""
|
|
BACKUP_BRANCH="$rollback_safety_backup"
|
|
say "Restoring original pre-import local changes..."
|
|
restore_stash 1
|
|
fi
|
|
|
|
if [ -n "$reset_snapshot" ]; then
|
|
say "Restoring exact worktree snapshot from: $reset_snapshot"
|
|
restore_worktree_snapshot "$reset_snapshot"
|
|
fi
|
|
|
|
if [ "$allow_entry_branch_bootstrap_rollback" = "1" ]; then
|
|
restore_branch_after="${STATE_ENTRY_BRANCH:-$restore_branch_after}"
|
|
fi
|
|
|
|
restore_fetch_ref_states
|
|
|
|
if [ -n "$restore_branch_after" ] && [ "$CURRENT_BRANCH" != "$restore_branch_after" ] && ! worktree_has_local_changes; then
|
|
git switch "$restore_branch_after" >/dev/null
|
|
CURRENT_BRANCH="$restore_branch_after"
|
|
fi
|
|
|
|
if [ "$remove_created_branch" = "1" ] && [ -n "$created_branch_name" ] && git show-ref --verify --quiet "refs/heads/$created_branch_name"; then
|
|
git branch -D "$created_branch_name" >/dev/null
|
|
say "Removed created maintenance branch: $created_branch_name"
|
|
fi
|
|
|
|
say "Rollback completed."
|
|
say "Restored starting commit: ${original_restore_start_head:-$reset_target}"
|
|
if [ -n "$reset_snapshot" ]; then
|
|
say "Restored snapshot: $reset_snapshot"
|
|
fi
|
|
if [ -n "$preserve_stash_hash" ]; then
|
|
STATE_BRANCH="$CURRENT_BRANCH"
|
|
STATE_ENTRY_BRANCH="$CURRENT_BRANCH"
|
|
STATE_BACKUP_BRANCH="$rollback_safety_backup"
|
|
STATE_STASH_HASH="$preserve_stash_hash"
|
|
STATE_REMOTE_NAME="$REMOTE_NAME"
|
|
STATE_REMOTE_URL="$REMOTE_URL"
|
|
STATE_BASE_TAG="$BASE_TAG"
|
|
STATE_UPSTREAM_RELEASE_BRANCH="$UPSTREAM_RELEASE_BRANCH"
|
|
STATE_UPSTREAM_RELEASE_TARGET_REF="$UPSTREAM_RELEASE_TARGET_REF"
|
|
STATE_UPSTREAM_COMPARE_BRANCH="$UPSTREAM_COMPARE_BRANCH"
|
|
STATE_CUSTOM_SOURCE_BRANCH="$CUSTOM_SOURCE_BRANCH"
|
|
STATE_MAINTENANCE_BRANCH="$MAINTENANCE_BRANCH"
|
|
STATE_START_HEAD="$rollback_safety_start_head"
|
|
STATE_SNAPSHOT_PATH="$rollback_safety_snapshot"
|
|
STATE_PENDING_COMMITS=""
|
|
STATE_ACTION_LABEL=""
|
|
STATE_STATUS="rollback_completed"
|
|
STATE_FETCH_REF_STATES=""
|
|
STATE_CREATED_MAINTENANCE_BRANCH="0"
|
|
write_state
|
|
say "Safety backup of the pre-rollback state kept at: $rollback_safety_backup"
|
|
say "Safety snapshot of the pre-rollback state kept at: $rollback_safety_snapshot"
|
|
say "Safety stash of the pre-rollback local changes kept at: $preserve_stash_hash"
|
|
else
|
|
if [ -z "$explicit_target" ]; then
|
|
cleanup_temporary_restore_artifacts "$original_action_backup_branch" "$original_action_snapshot"
|
|
fi
|
|
cleanup_temporary_restore_artifacts "$rollback_safety_backup" "$rollback_safety_snapshot"
|
|
rm -f "$STATE_FILE"
|
|
say "Temporary rollback safety artifacts were cleaned up."
|
|
fi
|
|
}
|
|
|
|
run_restore_snapshot() {
|
|
local target_snapshot="${1:-}" restore_safety_backup="" restore_safety_snapshot=""
|
|
local restore_safety_start_head="" restore_start_head="" preserve_stash_hash=""
|
|
|
|
ensure_git_repo
|
|
ensure_no_noncherrypick_git_operation_in_progress
|
|
load_state || die "No saved state was found."
|
|
ensure_current_branch_with_state_fallback
|
|
ensure_upstream_remote
|
|
|
|
if [ -z "$target_snapshot" ]; then
|
|
target_snapshot="${STATE_SNAPSHOT_PATH:-}"
|
|
fi
|
|
is_valid_snapshot_dir "$target_snapshot" || die "No valid saved snapshot was found to restore."
|
|
restore_start_head="${STATE_START_HEAD:-}"
|
|
if [ -z "$restore_start_head" ]; then
|
|
restore_start_head="$(snapshot_metadata_value "$target_snapshot" head || true)"
|
|
fi
|
|
[ -n "$restore_start_head" ] || die "No saved starting commit was found for the snapshot restore."
|
|
|
|
if has_cherry_pick_in_progress; then
|
|
say "Aborting in-progress cherry-pick before snapshot restore..."
|
|
git cherry-pick --abort || die "Failed to abort the in-progress cherry-pick."
|
|
fi
|
|
|
|
if [ -n "$(git diff --name-only --diff-filter=U)" ]; then
|
|
die "There are still unmerged files in the working tree. Resolve or discard them before restoring the snapshot."
|
|
fi
|
|
|
|
prepare_safety_before_real_action "before-restore-snapshot"
|
|
restore_safety_backup="$BACKUP_BRANCH"
|
|
restore_safety_snapshot="$STATE_SNAPSHOT_PATH"
|
|
restore_safety_start_head="$STATE_START_HEAD"
|
|
|
|
if worktree_has_local_changes; then
|
|
stash_current_changes "pre-restore-snapshot-preserve"
|
|
preserve_stash_hash="$STASH_HASH"
|
|
fi
|
|
|
|
say "Resetting '$CURRENT_BRANCH' to '$restore_start_head' before snapshot restore..."
|
|
git reset --hard "$restore_start_head" >/dev/null
|
|
|
|
if [ -n "${STATE_STASH_HASH:-}" ]; then
|
|
STASH_HASH="$STATE_STASH_HASH"
|
|
STASH_REF=""
|
|
BACKUP_BRANCH="$restore_safety_backup"
|
|
say "Restoring saved pre-import local changes..."
|
|
restore_stash 1
|
|
fi
|
|
|
|
say "Restoring exact worktree snapshot from: $target_snapshot"
|
|
restore_worktree_snapshot "$target_snapshot"
|
|
|
|
say "Snapshot restore completed."
|
|
if [ -n "$preserve_stash_hash" ]; then
|
|
STATE_BRANCH="$CURRENT_BRANCH"
|
|
STATE_BACKUP_BRANCH="$restore_safety_backup"
|
|
STATE_STASH_HASH="$preserve_stash_hash"
|
|
STATE_REMOTE_NAME="$REMOTE_NAME"
|
|
STATE_REMOTE_URL="$REMOTE_URL"
|
|
STATE_BASE_TAG="$BASE_TAG"
|
|
STATE_UPSTREAM_RELEASE_BRANCH="$UPSTREAM_RELEASE_BRANCH"
|
|
STATE_UPSTREAM_RELEASE_TARGET_REF="$UPSTREAM_RELEASE_TARGET_REF"
|
|
STATE_UPSTREAM_COMPARE_BRANCH="$UPSTREAM_COMPARE_BRANCH"
|
|
STATE_CUSTOM_SOURCE_BRANCH="$CUSTOM_SOURCE_BRANCH"
|
|
STATE_MAINTENANCE_BRANCH="$MAINTENANCE_BRANCH"
|
|
STATE_START_HEAD="$restore_safety_start_head"
|
|
STATE_SNAPSHOT_PATH="$restore_safety_snapshot"
|
|
STATE_PENDING_COMMITS=""
|
|
STATE_ACTION_LABEL=""
|
|
STATE_STATUS="snapshot_restored"
|
|
write_state
|
|
say "Safety backup of the pre-restore state kept at: $restore_safety_backup"
|
|
say "Safety snapshot of the pre-restore state kept at: $restore_safety_snapshot"
|
|
say "Safety stash of the pre-restore local changes kept at: $preserve_stash_hash"
|
|
else
|
|
cleanup_temporary_restore_artifacts "$restore_safety_backup" "$restore_safety_snapshot"
|
|
rm -f "$STATE_FILE"
|
|
say "Temporary snapshot-restore safety artifacts were cleaned up."
|
|
fi
|
|
}
|
|
|
|
run_delete_snapshot() {
|
|
local target_snapshot="${1:-}"
|
|
local associated_backup_branch=""
|
|
|
|
ensure_git_repo
|
|
load_state || true
|
|
|
|
if [ -z "$target_snapshot" ]; then
|
|
target_snapshot="${STATE_SNAPSHOT_PATH:-}"
|
|
fi
|
|
|
|
[ -n "$target_snapshot" ] || die "There is no saved snapshot to delete."
|
|
is_valid_snapshot_dir "$target_snapshot" || die "Snapshot '$target_snapshot' is not valid."
|
|
|
|
rm -rf "$target_snapshot"
|
|
associated_backup_branch="$(associated_backup_branch_for_snapshot "$target_snapshot" || true)"
|
|
if [ -n "$associated_backup_branch" ] && git show-ref --verify --quiet "refs/heads/$associated_backup_branch"; then
|
|
git branch -D "$associated_backup_branch" >/dev/null
|
|
say "Deleted associated backup branch: $associated_backup_branch"
|
|
fi
|
|
if [ "${STATE_SNAPSHOT_PATH:-}" = "$target_snapshot" ]; then
|
|
STATE_SNAPSHOT_PATH=""
|
|
write_state
|
|
fi
|
|
say "Deleted snapshot: $target_snapshot"
|
|
}
|
|
|
|
select_snapshot_interactively() {
|
|
local choice target_snapshot
|
|
local -a snapshot_dirs=()
|
|
|
|
SELECTED_SNAPSHOT_TARGET=""
|
|
ensure_git_repo
|
|
load_state || true
|
|
ensure_current_branch_with_state_fallback
|
|
mapfile -t snapshot_dirs < <(list_snapshot_dirs_for_current)
|
|
if [ "${#snapshot_dirs[@]}" -eq 0 ]; then
|
|
say "No snapshots found."
|
|
return 1
|
|
fi
|
|
|
|
say "Snapshots:"
|
|
for i in "${!snapshot_dirs[@]}"; do
|
|
target_snapshot="${snapshot_dirs[$i]}"
|
|
if [ -n "${STATE_SNAPSHOT_PATH:-}" ] && [ "$target_snapshot" = "$STATE_SNAPSHOT_PATH" ]; then
|
|
say " $((i + 1))) $(basename "$target_snapshot") [saved state]"
|
|
else
|
|
say " $((i + 1))) $(basename "$target_snapshot")"
|
|
fi
|
|
done
|
|
say " B) Back"
|
|
say " 0) Exit"
|
|
printf 'Choose snapshot [Enter=Back]: '
|
|
read -r choice
|
|
|
|
case "$choice" in
|
|
0) exit 0 ;;
|
|
""|[bB]) return 1 ;;
|
|
*[!0-9]*)
|
|
say "Invalid menu selection: $choice"
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
if [ "$choice" -lt 1 ] || [ "$choice" -gt "${#snapshot_dirs[@]}" ]; then
|
|
say "Invalid menu selection: $choice"
|
|
return 1
|
|
fi
|
|
|
|
SELECTED_SNAPSHOT_TARGET="${snapshot_dirs[$((choice - 1))]}"
|
|
return 0
|
|
}
|
|
|
|
run_restore_restore_point() {
|
|
local requested_target="${1:-}" restore_point_dir=""
|
|
local restore_source_branch="" restore_head="" restore_backup_branch=""
|
|
local restore_safety_backup="" restore_safety_snapshot="" restore_safety_start_head=""
|
|
local preserve_stash_hash=""
|
|
|
|
ensure_git_repo
|
|
ensure_no_noncherrypick_git_operation_in_progress
|
|
ensure_current_branch_with_state_fallback
|
|
|
|
restore_point_dir="$(resolve_restore_point_dir "$requested_target")"
|
|
[ -n "$restore_point_dir" ] || die "No restore point was found."
|
|
restore_source_branch="$(snapshot_metadata_value "$restore_point_dir" source_branch || true)"
|
|
restore_head="$(snapshot_metadata_value "$restore_point_dir" head || true)"
|
|
restore_backup_branch="$(snapshot_metadata_value "$restore_point_dir" backup_branch || true)"
|
|
[ -n "$restore_head" ] || die "Restore point '$restore_point_dir' does not include a saved HEAD."
|
|
|
|
if has_cherry_pick_in_progress; then
|
|
say "Aborting in-progress cherry-pick before restore point restore..."
|
|
git cherry-pick --abort || die "Failed to abort the in-progress cherry-pick."
|
|
fi
|
|
|
|
if [ -n "$(git diff --name-only --diff-filter=U)" ]; then
|
|
die "There are still unmerged files in the working tree. Resolve or discard them before restoring the restore point."
|
|
fi
|
|
|
|
prepare_safety_before_real_action "before-restore-point"
|
|
restore_safety_backup="$BACKUP_BRANCH"
|
|
restore_safety_snapshot="$STATE_SNAPSHOT_PATH"
|
|
restore_safety_start_head="$STATE_START_HEAD"
|
|
|
|
if worktree_has_local_changes; then
|
|
stash_current_changes "pre-restore-point-preserve"
|
|
preserve_stash_hash="$STASH_HASH"
|
|
fi
|
|
|
|
if [ -n "$restore_source_branch" ] && [ "$CURRENT_BRANCH" != "$restore_source_branch" ]; then
|
|
if git show-ref --verify --quiet "refs/heads/$restore_source_branch"; then
|
|
git switch "$restore_source_branch" >/dev/null
|
|
else
|
|
git switch -c "$restore_source_branch" "$restore_head" >/dev/null
|
|
fi
|
|
CURRENT_BRANCH="$restore_source_branch"
|
|
fi
|
|
|
|
say "Resetting '$CURRENT_BRANCH' to '$restore_head' before restore point restore..."
|
|
git reset --hard "$restore_head" >/dev/null
|
|
|
|
say "Restoring exact worktree from restore point: $restore_point_dir"
|
|
restore_worktree_snapshot "$restore_point_dir"
|
|
|
|
restore_script_managed_refs "$restore_point_dir"
|
|
restore_script_managed_snapshots "$restore_point_dir"
|
|
restore_script_managed_state_file "$restore_point_dir"
|
|
|
|
say "Restore point restored: $restore_point_dir"
|
|
say "Original restore-point backup branch: ${restore_backup_branch:-none}"
|
|
if [ -n "$preserve_stash_hash" ]; then
|
|
STATE_BRANCH="$CURRENT_BRANCH"
|
|
STATE_BACKUP_BRANCH="$restore_safety_backup"
|
|
STATE_STASH_HASH="$preserve_stash_hash"
|
|
STATE_REMOTE_NAME="$REMOTE_NAME"
|
|
STATE_REMOTE_URL="$REMOTE_URL"
|
|
STATE_BASE_TAG="$BASE_TAG"
|
|
STATE_UPSTREAM_RELEASE_BRANCH="$UPSTREAM_RELEASE_BRANCH"
|
|
STATE_UPSTREAM_RELEASE_TARGET_REF="$UPSTREAM_RELEASE_TARGET_REF"
|
|
STATE_UPSTREAM_COMPARE_BRANCH="$UPSTREAM_COMPARE_BRANCH"
|
|
STATE_CUSTOM_SOURCE_BRANCH="$CUSTOM_SOURCE_BRANCH"
|
|
STATE_MAINTENANCE_BRANCH="$MAINTENANCE_BRANCH"
|
|
STATE_START_HEAD="$restore_safety_start_head"
|
|
STATE_SNAPSHOT_PATH="$restore_safety_snapshot"
|
|
STATE_PENDING_COMMITS=""
|
|
STATE_ACTION_LABEL="restore-point"
|
|
STATE_STATUS="restore_point_restored"
|
|
write_state
|
|
say "Safety backup of the pre-restore state kept at: $restore_safety_backup"
|
|
say "Safety snapshot of the pre-restore state kept at: $restore_safety_snapshot"
|
|
say "Safety stash of the pre-restore local changes kept at: $preserve_stash_hash"
|
|
else
|
|
cleanup_temporary_restore_artifacts "$restore_safety_backup" "$restore_safety_snapshot"
|
|
say "Temporary restore-point safety artifacts were cleaned up."
|
|
fi
|
|
}
|
|
|
|
run_delete_restore_point() {
|
|
local requested_target="${1:-}" restore_point_dir="" restore_point_backup_branch="" restore_point_parent=""
|
|
|
|
[ -n "$requested_target" ] || die "Provide the restore point path or name to delete."
|
|
ensure_git_repo
|
|
restore_point_dir="$(resolve_restore_point_dir "$requested_target" candidate)"
|
|
restore_point_backup_branch="$(snapshot_metadata_value "$restore_point_dir" backup_branch || true)"
|
|
restore_point_parent="$(dirname "$restore_point_dir")"
|
|
|
|
rm -rf "$restore_point_dir"
|
|
if [ -n "$restore_point_backup_branch" ] && git show-ref --verify --quiet "refs/heads/$restore_point_backup_branch"; then
|
|
git branch -D "$restore_point_backup_branch" >/dev/null
|
|
fi
|
|
rmdir "$restore_point_parent" >/dev/null 2>&1 || true
|
|
|
|
say "Deleted restore point: $restore_point_dir"
|
|
if [ -n "$restore_point_backup_branch" ]; then
|
|
say "Deleted associated backup branch: $restore_point_backup_branch"
|
|
fi
|
|
}
|
|
|
|
run_tag_release() {
|
|
local upstream_version_tag="${1:-}" custom_tag=""
|
|
|
|
[ -n "$upstream_version_tag" ] || die "Provide the upstream release tag, for example: v1.26.0"
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
ensure_on_maintenance_branch
|
|
|
|
custom_tag="${upstream_version_tag}${CUSTOM_TAG_SUFFIX}"
|
|
git rev-parse --verify "$custom_tag" >/dev/null 2>&1 && die "Tag '$custom_tag' already exists."
|
|
|
|
git tag -a "$custom_tag" -m "Custom release ${custom_tag} from ${MAINTENANCE_BRANCH}"
|
|
say "Created custom tag: $custom_tag"
|
|
}
|
|
|
|
show_backups_menu() {
|
|
local choice restore_point_label restore_point_target delete_restore_point_target
|
|
|
|
while true; do
|
|
cat <<EOF
|
|
Manual Backups:
|
|
1) Create manual restore point
|
|
2) List manual restore points
|
|
3) Restore manual restore point
|
|
4) Delete manual restore point
|
|
B) Back
|
|
0) Exit
|
|
EOF
|
|
printf 'Choose an action [Enter=Back]: '
|
|
read -r choice
|
|
|
|
case "$choice" in
|
|
1)
|
|
printf 'Optional restore point label [manual]: '
|
|
read -r restore_point_label
|
|
run_create_restore_point "${restore_point_label:-manual}"
|
|
;;
|
|
2) run_list_restore_points ;;
|
|
3)
|
|
select_restore_point_interactively valid restore || continue
|
|
restore_point_target="$SELECTED_RESTORE_POINT"
|
|
run_restore_restore_point "$restore_point_target"
|
|
return
|
|
;;
|
|
4)
|
|
select_restore_point_interactively candidate delete || continue
|
|
delete_restore_point_target="$SELECTED_RESTORE_POINT"
|
|
run_delete_restore_point "$delete_restore_point_target"
|
|
;;
|
|
""|[bB]) return ;;
|
|
0) exit 0 ;;
|
|
*) say "Invalid menu selection: $choice" ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
show_fetch_upstreams_menu() {
|
|
local choice current_target_label
|
|
|
|
while true; do
|
|
current_target_label="${UPSTREAM_RELEASE_TARGET_REF:-$UPSTREAM_RELEASE_BRANCH}"
|
|
cat <<EOF
|
|
Fetch upstreams:
|
|
1) Fetch upstream/main compare ref
|
|
2) Fetch upstream release target ref [${current_target_label}]
|
|
B) Back
|
|
0) Exit
|
|
EOF
|
|
printf 'Choose an action [Enter=Back]: '
|
|
read -r choice
|
|
|
|
case "$choice" in
|
|
1) run_fetch_upstream_compare ;;
|
|
2) run_fetch_upstream_target ;;
|
|
""|[bB]) return ;;
|
|
0) exit 0 ;;
|
|
*) say "Invalid menu selection: $choice" ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
show_sync_menu() {
|
|
local choice current_target_label
|
|
|
|
while true; do
|
|
current_target_label="${UPSTREAM_RELEASE_TARGET_REF:-$UPSTREAM_RELEASE_BRANCH}"
|
|
cat <<EOF
|
|
Sync:
|
|
1) Sync upstream/main compare commits
|
|
2) Sync upstream release target commits [${current_target_label}]
|
|
3) Sync custom commits (oldest first)
|
|
4) Sync all
|
|
B) Back
|
|
0) Exit
|
|
EOF
|
|
printf 'Choose an action [Enter=Back]: '
|
|
read -r choice
|
|
|
|
case "$choice" in
|
|
1) run_sync_upstream_compare; return ;;
|
|
2) run_sync_upstream_target; return ;;
|
|
3) run_sync_custom; return ;;
|
|
4) run_sync_all; return ;;
|
|
""|[bB]) return ;;
|
|
0) exit 0 ;;
|
|
*) say "Invalid menu selection: $choice" ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
show_restore_menu() {
|
|
local choice snapshot_target=""
|
|
|
|
while true; do
|
|
cat <<EOF
|
|
Restore:
|
|
1) Restore saved stash
|
|
2) Restore exact snapshot
|
|
3) Delete Restore >
|
|
B) Back
|
|
0) Exit
|
|
EOF
|
|
printf 'Choose an action [Enter=Back]: '
|
|
read -r choice
|
|
|
|
case "$choice" in
|
|
1) run_restore_saved_stash; return ;;
|
|
2)
|
|
printf 'Optional snapshot path (leave empty for saved state): '
|
|
read -r snapshot_target
|
|
run_restore_snapshot "$snapshot_target"
|
|
return
|
|
;;
|
|
3) show_delete_restore_menu ;;
|
|
""|[bB]) return ;;
|
|
0) exit 0 ;;
|
|
*) say "Invalid menu selection: $choice" ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
show_delete_restore_menu() {
|
|
local choice snapshot_target=""
|
|
|
|
while true; do
|
|
cat <<EOF
|
|
Delete Restore:
|
|
1) Delete saved stash >
|
|
2) Delete saved exact snapshot >
|
|
3) Delete exact snapshot by path
|
|
B) Back
|
|
0) Exit
|
|
EOF
|
|
printf 'Choose an action [Enter=Back]: '
|
|
read -r choice
|
|
|
|
case "$choice" in
|
|
1)
|
|
select_stash_interactively || continue
|
|
run_delete_saved_stash "$SELECTED_STASH_TARGET"
|
|
;;
|
|
2)
|
|
select_snapshot_interactively || continue
|
|
run_delete_snapshot "$SELECTED_SNAPSHOT_TARGET"
|
|
;;
|
|
3)
|
|
printf 'Snapshot path to delete: '
|
|
read -r snapshot_target
|
|
[ -n "$snapshot_target" ] || continue
|
|
run_delete_snapshot "$snapshot_target"
|
|
;;
|
|
""|[bB]) return ;;
|
|
0) exit 0 ;;
|
|
*) say "Invalid menu selection: $choice" ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
show_rollback_menu() {
|
|
local choice current_target target
|
|
local -a rollback_targets=()
|
|
local -a rollback_labels=()
|
|
|
|
ensure_git_repo
|
|
load_state || true
|
|
ensure_current_branch_with_state_fallback
|
|
|
|
if [ -n "${STATE_START_HEAD:-}" ] || [ -n "${STATE_BACKUP_BRANCH:-}" ] || { [ -n "${STATE_SNAPSHOT_PATH:-}" ] && is_valid_snapshot_dir "$STATE_SNAPSHOT_PATH"; }; then
|
|
rollback_targets+=("__SAVED_STATE__")
|
|
rollback_labels+=("Saved rollback state")
|
|
fi
|
|
|
|
if [ -n "${STATE_BACKUP_BRANCH:-}" ] && git show-ref --verify --quiet "refs/heads/$STATE_BACKUP_BRANCH"; then
|
|
rollback_targets+=("$STATE_BACKUP_BRANCH")
|
|
rollback_labels+=("Saved backup branch [$STATE_BACKUP_BRANCH]")
|
|
fi
|
|
|
|
if [ -n "${STATE_SNAPSHOT_PATH:-}" ] && is_valid_snapshot_dir "$STATE_SNAPSHOT_PATH"; then
|
|
rollback_targets+=("$STATE_SNAPSHOT_PATH")
|
|
rollback_labels+=("Saved snapshot [$(basename "$STATE_SNAPSHOT_PATH")]")
|
|
fi
|
|
|
|
while IFS= read -r target; do
|
|
[ -n "$target" ] || continue
|
|
case " ${rollback_targets[*]} " in
|
|
*" $target "*) continue ;;
|
|
esac
|
|
rollback_targets+=("$target")
|
|
rollback_labels+=("Backup branch [$target]")
|
|
done < <(list_backup_branches_for_current)
|
|
|
|
while IFS= read -r target; do
|
|
[ -n "$target" ] || continue
|
|
case " ${rollback_targets[*]} " in
|
|
*" $target "*) continue ;;
|
|
esac
|
|
rollback_targets+=("$target")
|
|
rollback_labels+=("Snapshot [$(basename "$target")]")
|
|
done < <(list_snapshot_dirs_for_current)
|
|
|
|
if [ "${#rollback_targets[@]}" -eq 0 ]; then
|
|
say "No rollback targets found."
|
|
return
|
|
fi
|
|
|
|
while true; do
|
|
say "Rollback:"
|
|
for i in "${!rollback_targets[@]}"; do
|
|
say " $((i + 1))) ${rollback_labels[$i]}"
|
|
done
|
|
say " B) Back"
|
|
say " 0) Exit"
|
|
printf 'Choose an action [Enter=Back]: '
|
|
read -r choice
|
|
|
|
case "$choice" in
|
|
0) exit 0 ;;
|
|
""|[bB]) return ;;
|
|
*[!0-9]*)
|
|
say "Invalid menu selection: $choice"
|
|
continue
|
|
;;
|
|
esac
|
|
|
|
if [ "$choice" -ge 1 ] && [ "$choice" -le "${#rollback_targets[@]}" ]; then
|
|
current_target="${rollback_targets[$((choice - 1))]}"
|
|
if [ "$current_target" = "__SAVED_STATE__" ]; then
|
|
run_rollback ""
|
|
else
|
|
run_rollback "$current_target"
|
|
fi
|
|
return
|
|
fi
|
|
|
|
say "Invalid menu selection: $choice"
|
|
done
|
|
}
|
|
|
|
show_menu() {
|
|
local choice tag_value
|
|
|
|
while true; do
|
|
cat <<EOF
|
|
Available actions:
|
|
1) Edit configuration
|
|
2) Manual Backups >
|
|
3) Show status
|
|
4) Bootstrap maintenance branch
|
|
5) Fetch upstreams >
|
|
6) Show import plan
|
|
7) Sync >
|
|
8) Continue interrupted import
|
|
9) Rollback >
|
|
10) Restore >
|
|
11) Create custom release tag
|
|
12) Help
|
|
0) Exit
|
|
EOF
|
|
printf 'Choose an action: '
|
|
read -r choice
|
|
|
|
case "$choice" in
|
|
1) run_configure ;;
|
|
2) show_backups_menu ;;
|
|
3) run_status ;;
|
|
4) run_bootstrap ;;
|
|
5) show_fetch_upstreams_menu ;;
|
|
6) show_plan ;;
|
|
7) show_sync_menu ;;
|
|
8) run_continue; return ;;
|
|
9) show_rollback_menu ;;
|
|
10) show_restore_menu ;;
|
|
11)
|
|
printf 'Enter the upstream version tag to mark, for example v1.26.0: '
|
|
read -r tag_value
|
|
run_tag_release "$tag_value"
|
|
return
|
|
;;
|
|
12) show_usage ;;
|
|
0) exit 0 ;;
|
|
*) say "Invalid menu selection: $choice" ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
main() {
|
|
self_update_external_copy_if_needed "$@"
|
|
load_runtime_settings
|
|
|
|
case "${1:-menu}" in
|
|
configure) run_configure ;;
|
|
create-restore-point) run_create_restore_point "${2:-manual}" ;;
|
|
list-restore-points) run_list_restore_points ;;
|
|
restore-point|restore-restore-point) run_restore_restore_point "${2:-}" ;;
|
|
delete-restore-point) run_delete_restore_point "${2:-}" ;;
|
|
status) run_status ;;
|
|
fetch) run_fetch_all ;;
|
|
fetch-upstream-compare) run_fetch_upstream_compare ;;
|
|
fetch-upstream-target) run_fetch_upstream_target ;;
|
|
plan) show_plan ;;
|
|
bootstrap) run_bootstrap ;;
|
|
sync-upstream|sync-upstream-target) run_sync_upstream_target ;;
|
|
sync-upstream-compare) run_sync_upstream_compare ;;
|
|
sync-custom) run_sync_custom ;;
|
|
sync-all) run_sync_all ;;
|
|
continue) run_continue ;;
|
|
rollback) run_rollback "${2:-}" ;;
|
|
restore-stash) run_restore_saved_stash ;;
|
|
restore-snapshot) run_restore_snapshot "${2:-}" ;;
|
|
tag) run_tag_release "${2:-}" ;;
|
|
help|-h|--help) show_usage ;;
|
|
menu)
|
|
if [ -t 0 ] && [ -t 1 ]; then
|
|
show_menu
|
|
else
|
|
show_usage
|
|
fi
|
|
;;
|
|
*)
|
|
die "Unknown command: $1. Run with 'help' to see available options."
|
|
;;
|
|
esac
|
|
}
|
|
|
|
main "$@"
|