aboutsummaryrefslogtreecommitdiffstats
path: root/pkgs/populate/src/sh.rs
diff options
context:
space:
mode:
Diffstat (limited to 'pkgs/populate/src/sh.rs')
-rw-r--r--pkgs/populate/src/sh.rs261
1 files changed, 260 insertions, 1 deletions
diff --git a/pkgs/populate/src/sh.rs b/pkgs/populate/src/sh.rs
index 1a2d2c7..8282370 100644
--- a/pkgs/populate/src/sh.rs
+++ b/pkgs/populate/src/sh.rs
@@ -522,7 +522,7 @@ require_flakes() {
}
"#;
-/// The definitions shell code generated for flakes uses.
+/// The definitions the shell code for flakes uses.
pub fn prelude() -> String {
[
&use_state(),
@@ -730,3 +730,262 @@ nix eval --impure --raw --expr '
'
"#;
}
+
+/// Shell code for drawing inputs of flakes in sources from other sources,
+/// and for deriving what flake and flake-input sources that get patched,
+/// get their lock files rewritten, or are materialized deliver. Each gets
+/// the definitions of prelude and DEFINITIONS. Populate decides what to
+/// do, from what these send back.
+pub mod draw {
+ /// Defines own_lock DIR, apply_patches PATCH_DIR NAME, and write_key
+ /// KEY_FILE KEY.
+ ///
+ /// Nix rewrites lock files in place, which also changes what else is a
+ /// hard link to the lock file, e.g. in a backup, or what it is a
+ /// symlink to. So own_lock replaces the lock file of the flake in DIR
+ /// by a copy first. The copy goes to a new file, so nothing that's
+ /// there already gets written through.
+ ///
+ /// apply_patches applies the patches in PATCH_DIR, in order, to the
+ /// working directory, failing, naming the patch and the source NAME, if
+ /// one doesn't apply.
+ ///
+ /// write_key writes KEY to a new file, which then replaces KEY_FILE, so
+ /// nothing at its place gets written through, e.g. a symlink.
+ pub const DEFINITIONS: &str = r#"
+own_lock() {
+ if test -e "$1"/flake.lock; then
+ own_lock_copy=$(mktemp "$1"/.flake.lock.XXXXXX)
+ cp -p "$1"/flake.lock "$own_lock_copy"
+ mv -f "$own_lock_copy" "$1"/flake.lock
+ fi
+}
+apply_patches() {
+ ls "$1" | while read -r patch; do
+ if ! patch -p1 -s --batch --no-backup-if-mismatch -i "$1"/"$patch" >&2; then
+ >&2 printf 'error: patch %s does not apply to source %s\n' \
+ "$(printf %s "$patch" | cut -c6-)" "$2"
+ exit 1
+ fi
+ done
+}
+write_key() {
+ key_file=$(mktemp "$1".XXXXXX)
+ printf '%s\n' "$2" > "$key_file"
+ mv -f "$key_file" "$1"
+}
+"#;
+
+ /// use_state SENTINEL NAME...
+ pub const USE_STATE: &str = r#"
+use_state "$@"
+"#;
+
+ /// resolve PATH...: prints, for each PATH, what's there and where it
+ /// resolves to, as two fields, each ending in a null byte. The first
+ /// holds d if PATH is a directory, g if it has .git, s if it has
+ /// .gitmodules, and f if it has flake.nix.
+ pub const RESOLVE: &str = r#"
+for path; do
+ resolved=$(readlink -f "$path") || resolved=
+ flags=
+ if test -d "$path"; then flags=${flags}d; fi
+ if test -e "$path"/.git; then flags=${flags}g; fi
+ if test -e "$path"/.gitmodules; then flags=${flags}s; fi
+ if test -e "$path"/flake.nix; then flags=${flags}f; fi
+ printf '%s\0%s\0' "$flags" "$resolved"
+done
+"#;
+
+ /// metadata URL NAME OVERRIDE...: prints what nix flake metadata prints
+ /// for the flake at URL, of the source NAME, as Nix locks it now, with
+ /// an empty flake in place of each input at an OVERRIDE path, which
+ /// gets drawn from a source and may not be reachable as the flake's
+ /// lock file pins it.
+ pub const METADATA: &str = r#"
+url=$1 name=$2
+shift 2
+empty=$(mktemp -d)
+echo '{ outputs = _: {}; }' > "$empty"/flake.nix
+n=$#
+while test "$n" -gt 0; do
+ set -- "$@" --override-input "$1" "path:$empty"
+ shift
+ n=$((n - 1))
+done
+if ! nix flake metadata --json --no-write-lock-file "$@" "$url"; then
+ rm -R "$empty"
+ >&2 printf 'error: source %s draws inputs from other sources, but its flake can'"'"'t be locked\n' \
+ "$name"
+ exit 1
+fi
+rm -R "$empty"
+"#;
+
+ /// lock DIR URL ARG...: rewrites the lock file of the flake in DIR,
+ /// at URL, with nix flake lock's arguments ARG.
+ pub const LOCK: &str = r#"
+dir=$1 url=$2
+shift 2
+own_lock "$dir"
+nix flake lock "$@" "$url" >&2
+"#;
+
+ /// derived_state DIR TARGET_PATH PATCH_DIR DRAWN...: removes what an
+ /// interrupted run left in the source's derived state DIR, and prints
+ /// what tells whether the copy there needs to be made again, as fields
+ /// ending in null bytes: where DIR/original resolves to, the key of the
+ /// copy, the store path DIR/result links to, if the store has it, link
+ /// or directory, if TARGET_PATH is one, a line of sha256sum for each
+ /// patch in PATCH_DIR, an empty field, and the hash of each DRAWN path,
+ /// or nothing if it resolves into the store.
+ pub const DERIVED_STATE: &str = r#"
+dir=$1 target_path=$2 patch_dir=$3
+shift 3
+remove_tree "$dir"/work
+printf '%s\0' "$(readlink -f "$dir"/original)"
+if test -e "$dir"/key; then
+ printf '%s\0' "$(cat "$dir"/key)"
+else
+ printf '\0'
+fi
+if result=$(readlink "$dir"/result) &&
+ nix-store --check-validity "$result" 2>/dev/null; then
+ printf '%s\0' "$result"
+else
+ printf '\0'
+fi
+if test -L "$target_path"; then
+ printf 'link\0'
+elif test -d "$target_path"; then
+ printf 'directory\0'
+else
+ printf '\0'
+fi
+if test -n "$patch_dir"; then
+ ls "$patch_dir" | while read -r patch; do
+ printf '%s\0' "$(sha256sum "$patch_dir"/"$patch")"
+ done
+fi
+printf '\0'
+for drawn; do
+ drawn=$(readlink -f "$drawn")
+ case $drawn in
+ /nix/store/*) printf '\0' ;;
+ *) printf '%s\0' "$(nix-hash --type sha256 "$drawn")" ;;
+ esac
+done
+"#;
+
+ /// materialize ORIGINAL WORK TARGET_PATH TARGET_NAME PATCH_DIR NAME
+ /// KEY_FILE KEY: puts a copy of ORIGINAL, made in WORK and patched with
+ /// the patches in PATCH_DIR, if that isn't empty, at TARGET_PATH, and
+ /// writes its key. TARGET_NAME is TARGET_PATH's name in messages, and
+ /// NAME the source's.
+ pub const MATERIALIZE: &str = r#"
+original=$1 work=$2 target_path=$3 target_name=$4 patch_dir=$5 name=$6
+key_file=$7 key=$8
+cp -R "$original" "$work"
+chmod -R u+w "$work"
+if test -n "$patch_dir"; then
+ (
+ cd "$work"
+ apply_patches "$patch_dir" "$name"
+ )
+fi
+remove_foreign_link "$target_path" "$target_name"
+rm -fR "$target_path"
+mv "$work" "$target_path"
+write_key "$key_file" "$key"
+"#;
+
+ /// add DIR PATH SUBDIR TARGET_PATH TARGET_NAME RESULT PATCH_DIR NAME
+ /// KEY ARG...: links SUBDIR of the store path RESULT at TARGET_PATH.
+ /// If RESULT is empty, that's a copy of the store path PATH, made in
+ /// the source's derived state DIR, patched with the patches in
+ /// PATCH_DIR, if that isn't empty, with the lock file of its flake in
+ /// SUBDIR rewritten with nix flake lock's arguments ARG, if any, and
+ /// added to the store, rooted by DIR/result, with its key in DIR/key.
+ /// TARGET_NAME is TARGET_PATH's name in messages, and NAME the
+ /// source's.
+ pub const ADD: &str = r#"
+dir=$1 path=$2 subdir=$3 target_path=$4 target_name=$5 result=$6
+patch_dir=$7 name=$8 key=$9
+shift 9
+if test -z "$result"; then
+ # The copy keeps the name of the store path.
+ mkdir "$dir"/work
+ work=$(readlink -f "$dir"/work)/$(basename "$path" | cut -c34-)
+ cp -R "$path" "$work"
+ chmod -R u+w "$work"
+ if test -n "$patch_dir"; then
+ (
+ cd "$work"/"$subdir"
+ apply_patches "$patch_dir" "$name"
+ )
+ fi
+ if test $# -gt 0; then
+ # Not just the path, which Nix takes for the enclosing Git work tree,
+ # if any.
+ nix flake lock "$@" "path:$(url_path "$work")${subdir:+?dir=$subdir}" >&2
+ fi
+ result=$(nix-store --add-fixed --recursive sha256 "$work")
+ remove_tree "$dir"/work
+ nix-store --realise "$result" --add-root "$dir"/result --indirect >/dev/null
+ write_key "$dir"/key "$key"
+fi
+make_room_for_link "$target_path" "$target_name"
+# The source's derived state roots the store path.
+ln -fns "$result${subdir:+/$subdir}" "$target_path"
+"#;
+
+ /// generate DIR TEXT: makes DIR a flake, with TEXT as its flake.nix,
+ /// and locks it.
+ pub const GENERATE: &str = r#"
+dir=$1 text=$2
+mkdir -p "$(dirname "$dir")"
+rm -fR "$dir"
+mkdir "$dir"
+cd "$dir"
+printf %s "$text" > flake.nix
+# Not just ., which Nix takes for the enclosing Git work tree, if any.
+nix flake lock "path:$(url_path "$(pwd -P)")" >&2
+"#;
+
+ /// clean_up SENTINEL NAMES NOT_FLAKES GENERATED DERIVED PATCHED: removes
+ /// the state sources don't need anymore. Each argument after SENTINEL
+ /// is a list of source names, separated by blanks: of all sources, of
+ /// those that are neither flake nor flake-input sources, whose roots
+ /// for the garbage collector go, and of those that have a generated
+ /// flake, derived state, and patches.
+ pub const CLEAN_UP: &str = r#"
+sentinel=$1
+# The names are portable file names, so splitting them at blanks is fine.
+# shellcheck disable=SC2086
+use_state "$sentinel" $2
+# shellcheck disable=SC2086
+for name in $3; do
+ rm -fR "$sentinel"/flake-inputs/"$name"
+done
+if test -d "$sentinel"/flake-inputs &&
+ test -z "$(ls -A "$sentinel"/flake-inputs)"; then
+ rmdir "$sentinel"/flake-inputs
+fi
+remove_stale() {
+ stale_dir=$1
+ shift
+ if test -d "$stale_dir"; then
+ remove_others "$stale_dir" '' "$@"
+ if test -z "$(ls -A "$stale_dir")"; then
+ rmdir "$stale_dir"
+ fi
+ fi
+}
+# shellcheck disable=SC2086
+remove_stale "$sentinel"/flakes $4
+# shellcheck disable=SC2086
+remove_stale "$sentinel"/derived $5
+# shellcheck disable=SC2086
+remove_stale "$sentinel"/patches $6
+"#;
+}