Files
notfiles/scripts/fetch-iso.sh
T

212 lines
7.5 KiB
Bash
Executable File

#!/usr/bin/env bash
# Download the latest NixOS installer ISO into iso/.
#
# The ISO is saved under its real upstream snapshot name (for example
# nixos-graphical-26.05.1234.abcdef-x86_64-linux.iso) so different channel
# heads don't clobber each other, next to a <name>.sha256 sidecar. A stable
# symlink latest-nixos-<edition>-<arch>.iso always points at the newest one.
#
# Downloads go to <name>.part and resume after an interruption. A file only
# gets its final name after its SHA-256 has been verified.
set -euo pipefail
SCRIPT_DIR="$(cd -- "$(dirname -- "$(readlink -f -- "${BASH_SOURCE[0]}")")" && pwd -P)"
# shellcheck source=lib/common.sh
source "$SCRIPT_DIR/lib/common.sh"
usage() {
cat <<'EOF'
Usage: fetch-iso.sh [--channel CH] [--edition ED] [--arch ARCH] [--dest DIR]
--channel CH NixOS channel (default: nixos-26.05)
--edition ED graphical | minimal (default: graphical)
--arch ARCH target architecture (default: x86_64-linux)
--dest DIR output directory (default: iso)
-h, --help show this help
Environment:
NIXOS_CHANNELS_URL base URL override (default: https://channels.nixos.org)
Exit codes: 0 ok, 1 usage error, 2 network/parse failure, 3 checksum mismatch.
EOF
}
CHANNEL="nixos-26.05"
EDITION="graphical"
ARCH="x86_64-linux"
DEST_DIR="iso"
BASE_URL="${NIXOS_CHANNELS_URL:-https://channels.nixos.org}"
CURL_COMMON=(--fail --location --show-error --connect-timeout 20 --retry 3 --retry-delay 2)
[[ "$BASE_URL" == https://* ]] && CURL_COMMON+=(--proto '=https' --proto-redir '=https')
# Files we may need to clean up on exit.
TMP_SUM=""
cleanup() { [[ -z "$TMP_SUM" ]] || rm -f -- "$TMP_SUM"; }
trap cleanup EXIT
parse_args() {
while (($#)); do
case "$1" in
--channel=*) CHANNEL="${1#*=}"; shift ;;
--edition=*) EDITION="${1#*=}"; shift ;;
--arch=*) ARCH="${1#*=}"; shift ;;
--dest=*) DEST_DIR="${1#*=}"; shift ;;
--channel) need_value "$@"; CHANNEL="$2"; shift 2 ;;
--edition) need_value "$@"; EDITION="$2"; shift 2 ;;
--arch) need_value "$@"; ARCH="$2"; shift 2 ;;
--dest) need_value "$@"; DEST_DIR="$2"; shift 2 ;;
-h|--help) usage; exit 0 ;;
*) die "unknown argument: $1 (see --help)" 1 ;;
esac
done
local name value
for name in CHANNEL EDITION ARCH; do
value="${!name}"
[[ "$value" =~ ^[A-Za-z0-9][A-Za-z0-9._-]*$ ]] \
|| die "invalid --${name,,}: '$value'" 1
done
[[ -n "$DEST_DIR" ]] || die "--dest must not be empty" 1
}
# fetch_expected_hash: sets EXPECTED_HASH and REAL_NAME from the upstream
# .sha256 file, validating both: they come from the network and end up in
# file paths and in a checksum file.
fetch_expected_hash() {
local url="$1" hash name rest line
TMP_SUM="$(mktemp "$DEST_DIR/.sha256.XXXXXX")"
log "Fetching ${url}"
curl "${CURL_COMMON[@]}" --silent --max-time 60 --output "$TMP_SUM" "$url" \
|| die "sha256 fetch failed: $url" 2
# Format: "<64 hex> <filename>", where the filename may carry a leading
# '*' (binary-mode marker).
IFS= read -r line < "$TMP_SUM" || true
read -r hash name rest <<<"$line"
name="${name#\*}"
[[ "$hash" =~ ^[0-9a-fA-F]{64}$ ]] \
|| die "upstream checksum file doesn't start with a SHA-256 digest: '${line:0:120}'" 2
[[ -z "$rest" ]] \
|| die "upstream checksum filename contains spaces; refusing: '${line:0:120}'" 2
[[ "$name" =~ ^[A-Za-z0-9][A-Za-z0-9._+-]*\.iso$ && "$name" != *..* ]] \
|| die "upstream checksum names an unexpected file: '${name:0:120}'" 2
EXPECTED_HASH="${hash,,}"
REAL_NAME="$name"
rm -f -- "$TMP_SUM"
TMP_SUM=""
}
matches_hash() { # matches_hash FILE HASH
local actual
actual="$(sha256_of "$1")" || return 2
[[ "$actual" == "$2" ]]
}
write_sidecar() { # atomic: write HASH NAME to <iso>.sha256
local sum="$1" tmp
tmp="$(mktemp "$DEST_DIR/.sidecar.XXXXXX")"
printf '%s %s\n' "$EXPECTED_HASH" "$REAL_NAME" > "$tmp"
chmod 644 -- "$tmp"
mv -f -- "$tmp" "$sum"
}
publish() { # publish ISO: sidecar + latest symlink, then report
write_sidecar "${DEST_DIR}/${REAL_NAME}.sha256"
ln -sfn -- "$REAL_NAME" "${DEST_DIR}/${LATEST_NAME}"
log "${DEST_DIR}/${REAL_NAME}"
log "symlink: ${DEST_DIR}/${LATEST_NAME} -> ${REAL_NAME}"
}
# download PART_FILE: resumable download. Returns 0 on success, otherwise the
# curl exit code. A stale/unusable partial file is discarded and retried once.
download() {
local part="$1" url="$2" attempt rc code
local -a progress=(--silent)
[[ -t 2 ]] && progress=(--progress-bar)
for attempt in 1 2; do
rc=0
code="$(curl "${CURL_COMMON[@]}" "${progress[@]}" --continue-at - \
--write-out '%{http_code}' --output "$part" "$url")" || rc=$?
((rc == 0)) && return 0
# 33 = server can't resume; HTTP 416 = our partial file is longer
# than (or inconsistent with) the remote file. Both mean the partial
# data is useless, so start over once. Anything else (network drop,
# timeout, ...) keeps the partial file so the next run can resume.
if ((attempt == 1)) && { ((rc == 33)) || { ((rc == 22)) && [[ "$code" == 416 ]]; }; }; then
warn "can't resume the partial download; starting over"
rm -f -- "$part"
continue
fi
return "$rc"
done
}
main() {
parse_args "$@"
need_cmd curl
LATEST_NAME="latest-nixos-${EDITION}-${ARCH}.iso"
mkdir -p -- "$DEST_DIR"
# Two concurrent runs would corrupt each other's .part file.
if command -v flock >/dev/null 2>&1; then
exec 9>"$DEST_DIR/.fetch-iso.lock"
flock -n 9 || die "another fetch-iso is already running for $DEST_DIR" 1
fi
fetch_expected_hash "${BASE_URL}/${CHANNEL}/${LATEST_NAME}.sha256"
local iso="${DEST_DIR}/${REAL_NAME}"
local part="${iso}.part"
# Fast path: already have this exact ISO.
if [[ -f "$iso" ]]; then
if matches_hash "$iso" "$EXPECTED_HASH"; then
log "${iso} already present and verified."
publish
return 0
fi
warn "${iso} is present but its SHA-256 doesn't match upstream; replacing it."
rm -f -- "$iso"
fi
# A previous run may have finished downloading but died before verifying.
if [[ -f "$part" ]] && matches_hash "$part" "$EXPECTED_HASH"; then
log "Found a complete partial download; finalizing."
else
local pass resumed
for pass in 1 2; do
resumed=0
if [[ -f "$part" ]]; then
resumed=1
log "Resuming ${part} ($(human "$(stat -c %s -- "$part" 2>/dev/null || stat -f %z -- "$part")") so far)"
fi
log "Downloading ${BASE_URL}/${CHANNEL}/${LATEST_NAME}"
log " -> ${iso}"
download "$part" "${BASE_URL}/${CHANNEL}/${LATEST_NAME}" \
|| die "download failed; re-run to resume (partial file kept: $part)" 2
log "Verifying SHA-256..."
matches_hash "$part" "$EXPECTED_HASH" && break
rm -f -- "$part"
# Resuming glued new bytes onto a bad prefix: retry once from scratch.
if ((resumed && pass == 1)); then
warn "resumed download failed verification; discarding it and starting over"
continue
fi
die "SHA-256 verification failed; discarded the download" 3
done
fi
mv -f -- "$part" "$iso"
publish
}
main "$@"