sergioandClaude Opus 4.8
db84ee6647
Arranca el tier-2 de la escalera (C clasico via Alpine, que trae los parches musl): - import-batch.sh: env PREFER=nix|alpine. Para tandas C, PREFER=alpine antepone Alpine — el import de nix de un C tiene exito (tarball) pero SIN parches musl => romperia al construir. Refactor a 'tiers' ordenados (misma escalera, dos sentidos). - tandas/cli-c.txt: primera tanda C (tree/which/sed/gawk/gzip/tar/jq/file). - importador Alpine: build-deps = SOLO makedepends. El depends de abuild es RUNTIME (gzip depends=less para zless) — no hace falta para compilar y rompia hammer build (buscaba recipes/less.toml). Ahora va como comentario de provenance. Mismo patron que el fix de buildInputs-de-nix en recetas Rust. VALIDADO: import C 8/8 desde Alpine/main con parches musl bajados; gzip pierde el less espurio. test extracts_source_patches_deps_phases actualizado (depends != build-dep). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
87 lines
4.1 KiB
Bash
Executable File
87 lines
4.1 KiB
Bash
Executable File
#!/bin/sh
|
|
# import-batch.sh <pkg...> | import-batch.sh -f <listfile> — Etapa G: importa una TANDA a
|
|
# escala aplicando la ESCALERA DE FALLBACK (memoria etapa-g): por cada paquete intenta primero nix
|
|
# (Rust/Go/CLI moderno, ~100% en musl) y, si el import falla (src no-clasificable, eval error), cae
|
|
# a Alpine (que TRAE los parches de musl) probando `main` y luego `community`. Escribe la receta a
|
|
# OUTDIR/<pkg>.toml y, al final, MIDE EL YIELD POR TIER (nix / alpine / fallaron) — el dato real que
|
|
# decide dónde está la fricción al escalar, sin especular.
|
|
#
|
|
# Es sólo el IMPORT (barato). El trabajo real es construir: encadená con
|
|
# scripts/pin-recipes.sh "$OUTDIR"/*.toml (Fase 2: tag→SHA en lote)
|
|
# scripts/build-repo.sh (Etapa F: pack --build + repo firmado)
|
|
#
|
|
# Ej: scripts/import-batch.sh ripgrep fd bat hyperfine
|
|
# scripts/import-batch.sh -f tandas/cli-rust.txt
|
|
# OUTDIR=recipes/incoming scripts/import-batch.sh sd dust
|
|
# Env: OUTDIR (default recipes), PREFER (nix|alpine; default nix — alpine antepone Alpine para tandas
|
|
# C, que necesitan sus parches musl), NIX_STORE (p.ej. $HOME/.nixstore si /nix/store no es
|
|
# escribible), ALPINE_BRANCH (default master), HAMMER (cmd del cli). Un nombre puede mapear
|
|
# nix→alpine distintos con `nixattr=alpinepkg` (p.ej. `the_silver_searcher=the-silver-searcher`).
|
|
set -eu
|
|
|
|
here=$(dirname "$0")
|
|
OUTDIR="${OUTDIR:-recipes}"
|
|
export OUTDIR # alpine-import.sh baja sus .patch acá
|
|
|
|
# Resolver la lista de paquetes: -f <fichero> (una entrada por línea, '#' comenta) o argumentos.
|
|
if [ "${1:-}" = "-f" ]; then
|
|
[ -n "${2:-}" ] || { echo "uso: import-batch.sh -f <listfile>" >&2; exit 1; }
|
|
pkgs=$(sed -e 's/#.*//' -e '/^[[:space:]]*$/d' "$2")
|
|
else
|
|
[ "$#" -gt 0 ] || { echo "uso: import-batch.sh <pkg...> | -f <listfile>" >&2; exit 1; }
|
|
pkgs=$(printf '%s\n' "$@")
|
|
fi
|
|
|
|
# Orden de fuentes: PREFER=nix (default, tier-1 Rust/Go) o PREFER=alpine (tier-2 C, trae parches musl).
|
|
case "${PREFER:-nix}" in
|
|
alpine) TIERS="alpine-main alpine-community nix" ;;
|
|
nix|*) TIERS="nix alpine-main alpine-community" ;;
|
|
esac
|
|
|
|
mkdir -p "$OUTDIR"
|
|
nix_n=0; alpine_n=0; failed=""; got=""
|
|
|
|
# IFS=newline para tolerar una entrada por línea; restaurar después no hace falta (sub-shell del for).
|
|
OLDIFS=$IFS; IFS='
|
|
'
|
|
for entry in $pkgs; do
|
|
IFS=$OLDIFS
|
|
# Mapeo opcional nixattr=alpinepkg; si no hay '=', el mismo nombre sirve para ambas fuentes.
|
|
case $entry in
|
|
*=*) nixattr=${entry%%=*}; alpinepkg=${entry#*=} ;;
|
|
*) nixattr=$entry; alpinepkg=$entry ;;
|
|
esac
|
|
out="$OUTDIR/${nixattr}.toml"
|
|
|
|
printf '%-24s ' "$nixattr" >&2
|
|
done_pkg=""
|
|
# Orden de fuentes según PREFER (default nix, ~100% Rust/Go). PREFER=alpine antepone Alpine para
|
|
# tandas C: el import de nix de un C tiene éxito (tarball) pero SIN los parches musl ⇒ rompería al
|
|
# construir; Alpine los TRAE. Cada "tier" es una etiqueta y el comando que produce la receta.
|
|
for tier in $TIERS; do
|
|
case $tier in
|
|
nix) src="nix"; cmd_out=$("$here/nix-import.sh" "$nixattr" 2>/dev/null) || cmd_out="" ;;
|
|
alpine-main) src="alpine/main"; cmd_out=$("$here/alpine-import.sh" "$alpinepkg" main 2>/dev/null) || cmd_out="" ;;
|
|
alpine-comm*) src="alpine/community"; cmd_out=$("$here/alpine-import.sh" "$alpinepkg" community 2>/dev/null) || cmd_out="" ;;
|
|
esac
|
|
if [ -n "$cmd_out" ]; then
|
|
printf '%s\n' "$cmd_out" > "$out"
|
|
case $tier in nix) nix_n=$((nix_n + 1)) ;; *) alpine_n=$((alpine_n + 1)) ;; esac
|
|
got="$got $nixattr"; done_pkg=1
|
|
echo "✓ $src" >&2
|
|
break
|
|
fi
|
|
done
|
|
if [ -z "$done_pkg" ]; then
|
|
failed="$failed $nixattr"
|
|
echo "✗ ninguna fuente" >&2
|
|
fi
|
|
done
|
|
|
|
total=$((nix_n + alpine_n))
|
|
echo >&2
|
|
echo "yield import: $total/$((total + $(printf '%s' "$failed" | wc -w))) — nix=$nix_n, alpine=$alpine_n.${failed:+ FALLARON:$failed}" >&2
|
|
echo "recetas en $OUTDIR/.${got:+ Siguiente: pin + build —} ${got:+scripts/pin-recipes.sh}${got:+ $OUTDIR/*.toml}" >&2
|
|
# Salida limpia en stdout: los nombres importados (para encadenar con xargs si se quiere).
|
|
printf '%s\n' $got
|