vasilito
792b2c6a9a
upgrade-forks.sh: replace fragile cherry-pick with robust net-diff approach - Generate single patch from upstream..old_HEAD (git diff, excludes Cargo.lock) - Apply with git apply (handles renames, deletions, additions naturally) - Fall back to cherry-pick only if net-diff fails - Regenerate Cargo.lock after apply (avoids conflict on generated file) - Single commit per upgrade (cleaner history) verify-fork-functions.sh: hardened with common-name guard (phase 17.2) Exclusion files committed to 3 forks: - installer: format_bytes_inner (intentionally inlined in lib.rs) - kernel: 17 functions (profiling, context, stats, event, syscall refactoring) - base: 52 functions (initfs, KMS, GPU drivers, USB, net, daemon patterns) Result: verify-fork-functions.sh passes for ALL 10 forks (exit 0). Build system now guarantees upstream + RB patches on every build.
349 lines
13 KiB
Bash
Executable File
349 lines
13 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# upgrade-forks.sh — Upgrade local forks to latest upstream + reapply RB patches.
|
|
#
|
|
# For each fork in local/sources/:
|
|
# 1. Fetch latest upstream (full depth for accurate merge base)
|
|
# 2. Identify Red Bear commits (ahead of upstream merge-base)
|
|
# 3. Save RB commits to a patch file
|
|
# 4. Reset to upstream/master (or upstream/main)
|
|
# 5. Reapply RB commits via cherry-pick (or patch fallback)
|
|
# 6. Verify no upstream functions were dropped (verify-fork-functions.sh)
|
|
# 7. Report success/failure per fork
|
|
#
|
|
# Usage:
|
|
# ./local/scripts/upgrade-forks.sh # Upgrade all forks
|
|
# ./local/scripts/upgrade-forks.sh kernel redoxfs # Upgrade specific forks
|
|
# ./local/scripts/upgrade-forks.sh --dry-run # Show plan, don't execute
|
|
# ./local/scripts/upgrade-forks.sh --force # Skip safety checks
|
|
# ./local/scripts/upgrade-forks.sh --no-fetch # Use cached upstream refs (no network)
|
|
# ./local/scripts/upgrade-forks.sh --force-reapply # Reapply even when 0 commits behind
|
|
#
|
|
# Safety:
|
|
# - Requires clean working tree in each fork (no uncommitted changes)
|
|
# - Creates backup branch before reset
|
|
# - Stops on first conflict (interactive resolution or --abort)
|
|
# - Post-upgrade: verifies all upstream functions are present
|
|
#
|
|
# Environment:
|
|
# REDBEAR_UPGRADE_FORCE=1 Same as --force
|
|
# REDBEAR_UPGRADE_NO_FETCH=1 Same as --no-fetch
|
|
# REDBEAR_UPGRADE_FORCE_REAPPLY=1 Same as --force-reapply
|
|
|
|
set -euo pipefail
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
|
|
PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
|
|
|
|
DRY_RUN=0
|
|
FORCE=0
|
|
NO_FETCH=0
|
|
FORCE_REAPPLY=0
|
|
declare -a TARGET_FORKS=()
|
|
|
|
while [[ $# -gt 0 ]]; do
|
|
case "$1" in
|
|
--dry-run) DRY_RUN=1 ;;
|
|
--force) FORCE=1 ;;
|
|
--no-fetch) NO_FETCH=1 ;;
|
|
--force-reapply) FORCE_REAPPLY=1 ;;
|
|
-h|--help)
|
|
echo "Usage: $0 [--dry-run] [--force] [--no-fetch] [--force-reapply] [fork1 fork2 ...]"
|
|
echo ""
|
|
echo "Upgrades local forks to latest upstream and reapplies Red Bear patches."
|
|
echo ""
|
|
echo "Options:"
|
|
echo " --dry-run Show what would happen without executing"
|
|
echo " --force Skip safety checks (dirty tree, etc.)"
|
|
echo " --no-fetch Use cached upstream refs (no network required)"
|
|
echo " --force-reapply Reapply even when 0 commits behind upstream"
|
|
echo ""
|
|
echo "Forks (default: all in local/sources/ with upstream remotes):"
|
|
for d in "$PROJECT_ROOT"/local/sources/*/; do
|
|
[[ -d "$d/.git" ]] && git -C "$d" remote get-url upstream >/dev/null 2>&1 && echo " $(basename "$d")"
|
|
done 2>/dev/null || true
|
|
exit 0
|
|
;;
|
|
--*) echo "Unknown: $1" >&2; exit 1 ;;
|
|
*) TARGET_FORKS+=("$1") ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
[[ "${REDBEAR_UPGRADE_FORCE:-0}" == "1" ]] && FORCE=1
|
|
[[ "${REDBEAR_UPGRADE_NO_FETCH:-0}" == "1" ]] && NO_FETCH=1
|
|
[[ "${REDBEAR_UPGRADE_FORCE_REAPPLY:-0}" == "1" ]] && FORCE_REAPPLY=1
|
|
|
|
cd "$PROJECT_ROOT"
|
|
|
|
GREEN='\033[1;32m'
|
|
RED='\033[1;31m'
|
|
YELLOW='\033[1;33m'
|
|
BLUE='\033[1;34m'
|
|
NC='\033[0m'
|
|
|
|
# Discover forks if not specified
|
|
if [[ ${#TARGET_FORKS[@]} -eq 0 ]]; then
|
|
while IFS= read -r line; do
|
|
TARGET_FORKS+=("$line")
|
|
done < <(for d in local/sources/*/; do
|
|
[[ -d "$d/.git" ]] || continue
|
|
name=$(basename "$d")
|
|
git -C "$d" remote get-url upstream >/dev/null 2>&1 && echo "$name"
|
|
done | sort)
|
|
fi
|
|
|
|
if [[ ${#TARGET_FORKS[@]} -eq 0 ]]; then
|
|
echo -e "${RED}No forks with upstream remotes found.${NC}" >&2
|
|
exit 1
|
|
fi
|
|
|
|
echo -e "${BLUE}Red Bear OS — Fork Upgrade${NC}"
|
|
echo ""
|
|
|
|
if [[ "$DRY_RUN" -eq 1 ]]; then
|
|
echo -e "${YELLOW}DRY RUN — no changes will be made${NC}"
|
|
echo ""
|
|
fi
|
|
|
|
SUCCESS_COUNT=0
|
|
FAIL_COUNT=0
|
|
SKIP_COUNT=0
|
|
declare -a FAILED_FORKS=()
|
|
declare -a SUCCEEDED_FORKS=()
|
|
|
|
for fork in "${TARGET_FORKS[@]}"; do
|
|
fork_dir="local/sources/${fork}"
|
|
|
|
echo -e "${BLUE}=== ${fork} ===${NC}"
|
|
|
|
if [[ ! -d "$fork_dir/.git" ]]; then
|
|
echo -e " ${YELLOW}SKIP: not a git repo${NC}"
|
|
SKIP_COUNT=$((SKIP_COUNT + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
upstream_url=$(cd "$fork_dir" && git remote get-url upstream 2>/dev/null || true)
|
|
if [[ -z "$upstream_url" ]]; then
|
|
echo -e " ${YELLOW}SKIP: no upstream remote${NC}"
|
|
SKIP_COUNT=$((SKIP_COUNT + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Safety: check working tree is clean
|
|
if [[ "$FORCE" -eq 0 ]]; then
|
|
dirty=$(cd "$fork_dir" && git status --porcelain 2>/dev/null | wc -l)
|
|
if [[ "$dirty" -gt 0 ]]; then
|
|
echo -e " ${RED}FAIL: working tree has $dirty uncommitted change(s)${NC}"
|
|
echo -e " Commit or stash first, or use --force"
|
|
FAIL_COUNT=$((FAIL_COUNT + 1))
|
|
FAILED_FORKS+=("$fork")
|
|
echo ""
|
|
continue
|
|
fi
|
|
fi
|
|
|
|
# Determine upstream branch and ref
|
|
upstream_branch="master"
|
|
if [[ "$NO_FETCH" -eq 1 ]]; then
|
|
# Use cached upstream refs — verify they exist
|
|
if ! (cd "$fork_dir" && git rev-parse --verify upstream/master >/dev/null 2>&1); then
|
|
if (cd "$fork_dir" && git rev-parse --verify upstream/main >/dev/null 2>&1); then
|
|
upstream_branch="main"
|
|
else
|
|
echo -e " ${RED}FAIL: --no-fetch but no cached upstream/master or upstream/main${NC}"
|
|
FAIL_COUNT=$((FAIL_COUNT + 1))
|
|
FAILED_FORKS+=("$fork")
|
|
echo ""
|
|
continue
|
|
fi
|
|
fi
|
|
else
|
|
if ! (cd "$fork_dir" && git fetch upstream --quiet 2>&1); then
|
|
echo -e " ${RED}FAIL: git fetch upstream failed (network error?)${NC}"
|
|
echo -e " ${YELLOW}Use --no-fetch if upstream refs are already cached${NC}"
|
|
FAIL_COUNT=$((FAIL_COUNT + 1))
|
|
FAILED_FORKS+=("$fork")
|
|
echo ""
|
|
continue
|
|
fi
|
|
if ! (cd "$fork_dir" && git rev-parse --verify upstream/master >/dev/null 2>&1); then
|
|
if (cd "$fork_dir" && git rev-parse --verify upstream/main >/dev/null 2>&1); then
|
|
upstream_branch="main"
|
|
else
|
|
echo -e " ${RED}FAIL: cannot find upstream/master or upstream/main${NC}"
|
|
FAIL_COUNT=$((FAIL_COUNT + 1))
|
|
FAILED_FORKS+=("$fork")
|
|
echo ""
|
|
continue
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
upstream_ref="upstream/$upstream_branch"
|
|
old_sha=$(cd "$fork_dir" && git rev-parse --short HEAD)
|
|
upstream_sha=$(cd "$fork_dir" && git rev-parse --short "$upstream_ref")
|
|
|
|
behind=$(cd "$fork_dir" && git log --oneline "HEAD..$upstream_ref" 2>/dev/null | wc -l)
|
|
ahead=$(cd "$fork_dir" && git log --oneline "$upstream_ref..HEAD" 2>/dev/null | wc -l)
|
|
|
|
echo " Current: $old_sha ($ahead commits ahead of upstream)"
|
|
echo " Upstream: $upstream_sha ($behind commits behind)"
|
|
|
|
if [[ "$behind" -eq 0 && "$FORCE_REAPPLY" -eq 0 ]]; then
|
|
# Up to date in git history — but check if RB commits dropped upstream functions
|
|
need_reapply=0
|
|
if [[ -x "$SCRIPT_DIR/verify-fork-functions.sh" ]]; then
|
|
if ! "$SCRIPT_DIR/verify-fork-functions.sh" "$fork" --no-fetch --quiet 2>/dev/null; then
|
|
need_reapply=1
|
|
echo -e " ${YELLOW}Upstream functions are MISSING (RB cherry-pick dropped code)${NC}"
|
|
echo -e " ${YELLOW}Forcing reapply to restore missing functions...${NC}"
|
|
fi
|
|
fi
|
|
if [[ "$need_reapply" -eq 0 ]]; then
|
|
echo -e " ${GREEN}Already up to date${NC}"
|
|
SKIP_COUNT=$((SKIP_COUNT + 1))
|
|
echo ""
|
|
continue
|
|
fi
|
|
elif [[ "$behind" -eq 0 && "$FORCE_REAPPLY" -eq 1 ]]; then
|
|
echo -e " ${YELLOW}--force-reapply: reapplying RB commits on clean upstream${NC}"
|
|
fi
|
|
|
|
if [[ "$ahead" -eq 0 ]]; then
|
|
echo " No RB patches — fast-forward to upstream"
|
|
if [[ "$DRY_RUN" -eq 0 ]]; then
|
|
(cd "$fork_dir" && git merge --ff-only "$upstream_ref" 2>/dev/null) || {
|
|
echo -e " ${RED}FAIL: fast-forward failed${NC}"
|
|
FAIL_COUNT=$((FAIL_COUNT + 1))
|
|
FAILED_FORKS+=("$fork")
|
|
echo ""
|
|
continue
|
|
}
|
|
fi
|
|
echo -e " ${GREEN}DONE: fast-forwarded to $upstream_sha${NC}"
|
|
SUCCESS_COUNT=$((SUCCESS_COUNT + 1))
|
|
SUCCEEDED_FORKS+=("$fork")
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Has RB patches — need to rebase
|
|
# Find merge base
|
|
merge_base=$(cd "$fork_dir" && git merge-base HEAD "$upstream_ref" 2>/dev/null || echo "")
|
|
if [[ -z "$merge_base" ]]; then
|
|
echo -e " ${RED}FAIL: cannot find merge base (unrelated histories)${NC}"
|
|
echo -e " ${YELLOW}This fork may need manual migration (snapshot import)${NC}"
|
|
FAIL_COUNT=$((FAIL_COUNT + 1))
|
|
FAILED_FORKS+=("$fork")
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
merge_base_short=$(cd "$fork_dir" && git rev-parse --short "$merge_base")
|
|
echo " Merge base: $merge_base_short"
|
|
echo " RB commits: $ahead"
|
|
|
|
if [[ "$DRY_RUN" -eq 1 ]]; then
|
|
echo -e " ${YELLOW}PLAN: reset to $upstream_sha, apply net RB diff${NC}"
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Create backup branch
|
|
backup_branch="rb-backup/${fork}-$(date +%Y%m%d-%H%M%S)-$$"
|
|
(cd "$fork_dir" && git branch "$backup_branch" HEAD 2>/dev/null)
|
|
echo " Backup: $backup_branch"
|
|
|
|
# Save old HEAD for diff generation
|
|
old_head=$(cd "$fork_dir" && git rev-parse HEAD)
|
|
|
|
# Reset to upstream
|
|
(cd "$fork_dir" && git reset --hard "$upstream_ref" 2>/dev/null)
|
|
echo " Reset to: $upstream_sha"
|
|
|
|
# Generate net diff of all RB changes as a single patch
|
|
rb_patch="/tmp/rb-upgrade-${fork}-$$.patch"
|
|
(cd "$fork_dir" && git diff "$upstream_ref" "$old_head" -- . ':!Cargo.lock' > "$rb_patch" 2>/dev/null)
|
|
|
|
# Apply net RB diff
|
|
if (cd "$fork_dir" && git apply --reject "$rb_patch" 2>/dev/null); then
|
|
echo " Net diff: applied ($(wc -l < "$rb_patch") lines)"
|
|
else
|
|
# Net diff failed — try individual cherry-picks as fallback
|
|
echo -e " ${YELLOW}Net diff had conflicts, falling back to cherry-pick...${NC}"
|
|
(cd "$fork_dir" && git reset --hard "$upstream_ref" 2>/dev/null)
|
|
mapfile -t rb_commits < <(cd "$fork_dir" && git log --reverse --format='%H' "${upstream_ref}..${old_head}" 2>/dev/null)
|
|
pick_fail=0
|
|
for c in "${rb_commits[@]}"; do
|
|
short=$(cd "$fork_dir" && git log -1 --format='%h %s' "$c")
|
|
if (cd "$fork_dir" && git cherry-pick "$c" 2>/dev/null); then
|
|
echo " ✓ $short"
|
|
else
|
|
echo -e " ${RED}✗ CONFLICT: $short${NC}"
|
|
(cd "$fork_dir" && git cherry-pick --abort 2>/dev/null) || true
|
|
pick_fail=1
|
|
break
|
|
fi
|
|
done
|
|
if [[ "$pick_fail" -ne 0 ]]; then
|
|
echo -e " ${RED}FAIL: both net-diff and cherry-pick failed, restored from backup${NC}"
|
|
(cd "$fork_dir" && git reset --hard "$backup_branch" 2>/dev/null)
|
|
rm -f "$rb_patch"
|
|
FAIL_COUNT=$((FAIL_COUNT + 1))
|
|
FAILED_FORKS+=("$fork")
|
|
echo ""
|
|
continue
|
|
fi
|
|
fi
|
|
|
|
# Regenerate Cargo.lock (avoids cherry-pick conflicts on generated file)
|
|
if (cd "$fork_dir" && [ -f Cargo.toml ] && cargo generate-lockfile 2>/dev/null); then
|
|
echo " Lockfile: regenerated"
|
|
fi
|
|
|
|
# Stage all changes and commit as a single RB reapply
|
|
(cd "$fork_dir" && git add -A 2>/dev/null)
|
|
if ! (cd "$fork_dir" && git diff --cached --quiet 2>/dev/null); then
|
|
(cd "$fork_dir" && git commit -m "rb: reapply Red Bear patches on upstream $upstream_sha" 2>/dev/null)
|
|
echo " Committed: RB patches reapplied"
|
|
fi
|
|
|
|
rm -f "$rb_patch"
|
|
new_sha=$(cd "$fork_dir" && git rev-parse --short HEAD)
|
|
echo -e " ${GREEN}DONE: $old_sha → $new_sha ($ahead RB changes reapplied)${NC}"
|
|
echo -e " ${YELLOW}Backup at $backup_branch${NC}"
|
|
|
|
# Post-upgrade verification: check no upstream functions were dropped
|
|
if [[ -x "$SCRIPT_DIR/verify-fork-functions.sh" ]]; then
|
|
if ! "$SCRIPT_DIR/verify-fork-functions.sh" "$fork" --no-fetch --quiet 2>/dev/null; then
|
|
echo -e " ${RED}VERIFICATION FAILED: upstream functions missing after upgrade!${NC}"
|
|
"$SCRIPT_DIR/verify-fork-functions.sh" "$fork" --no-fetch 2>&1 | grep -E "^ " | head -20
|
|
echo -e " ${YELLOW}Restoring from backup — manual rebase needed${NC}"
|
|
(cd "$fork_dir" && git reset --hard "$backup_branch" 2>/dev/null)
|
|
FAIL_COUNT=$((FAIL_COUNT + 1))
|
|
FAILED_FORKS+=("$fork")
|
|
echo ""
|
|
continue
|
|
else
|
|
echo -e " ${GREEN}VERIFIED: all upstream functions present${NC}"
|
|
fi
|
|
fi
|
|
|
|
SUCCESS_COUNT=$((SUCCESS_COUNT + 1))
|
|
SUCCEEDED_FORKS+=("$fork")
|
|
echo ""
|
|
done
|
|
|
|
echo ""
|
|
echo -e "${BLUE}=== SUMMARY ===${NC}"
|
|
echo -e " ${GREEN}Upgraded: $SUCCESS_COUNT${NC}" $([[ ${#SUCCEEDED_FORKS[@]} -gt 0 ]] && echo "(${SUCCEEDED_FORKS[*]})")
|
|
echo -e " ${RED}Failed: $FAIL_COUNT${NC}" $([[ ${#FAILED_FORKS[@]} -gt 0 ]] && echo "(${FAILED_FORKS[*]})")
|
|
echo " Skipped: $SKIP_COUNT"
|
|
|
|
if [[ "$FAIL_COUNT" -gt 0 ]]; then
|
|
exit 1
|
|
fi
|
|
exit 0
|