sergio/takana

1#!/usr/bin/env bash
2# espejar-repos.sh — le da una copia FUERA de esta máquina a cada repo que sólo existe acá (SDD 29).
3#
4# ── POR QUÉ EXISTE ──────────────────────────────────────────────────────────────────────────────
5# Medido en gioser el 2026-09-12: **28 repositorios con remoto en la propia máquina, 26 sin ninguna
6# copia fuera**. Entre ellos `tawasuyu`, que produce 10 de los 13 binarios que nadie más provee.
7# Apagar el origen no borra unos servicios: borra EL CÓDIGO CON EL QUE SE VOLVERÍAN A CONSTRUIR, y
8# los clones de trabajo están en el mismo disco que también muere.
9#
10# Hace lo mismo que `scripts/espejo-setup.sh` hace por takana —`pushurl` doble sobre `origin`, de
11# modo que cualquier `git push origin` que ya exista espeje solo— pero sobre un árbol entero.
12#
13# ── LAS CUATRO DECISIONES ───────────────────────────────────────────────────────────────────────
14# 1. **Por defecto NO hace nada.** Imprime lo que haría. Hay que pedirlo con `--apply`. Crear repos
15#    y empujar código a un servicio externo no es algo que deba pasar por correr un script sin leer.
16# 2. **Varios clones del MISMO origen van a UN repo remoto.** En gioser hay cinco clones de
17#    `tawasuyu/tawasuyu` (`tawasuyu`, `-b`, `-j1`, `-arbol`, `tw-deploy`). Crear cinco repos
18#    distintos multiplica la confusión; empujarlos todos al mismo `main` los haría chocar. El
19#    primario empuja normal y los demás van a `refs/heads/clon/<nombre>/*`: **nada se pierde y nada
20#    colisiona**.
21# 3. **Sólo agrega; nunca toca el `fetch` de `origin`.** El canónico sigue siendo el que estaba.
22# 4. **Lo sucio NO viaja, y se dice.** Un espejo guarda historia commiteada, no el árbol de trabajo:
23#    `tawasuyu` tiene 472 ficheros `.rs` modificados sin commitear. Un repo sucio se reporta con su
24#    cuenta, porque creer que está a salvo cuando la mitad del trabajo no está commiteado es
25#    exactamente el fallo que este guión existe para evitar.
26#
27# Uso:
28#   scripts/mudanza/espejar-repos.sh                      # ensayo: dice qué haría
29#   scripts/mudanza/espejar-repos.sh --apply              # crea los repos privados y empuja
30#   scripts/mudanza/espejar-repos.sh --root /mnt/vvv --owner usuario --apply
31set -uo pipefail
32
33OWNER=""; APPLY=0; ROOTS=(); DEPTH=4
34while [ $# -gt 0 ]; do
35  case "$1" in
36    --apply) APPLY=1;;
37    --owner) OWNER="$2"; shift;;
38    --root)  ROOTS+=("$2"); shift;;
39    --depth) DEPTH="$2"; shift;;
40    -h|--help) sed -n '2,30p' "$0"; exit 0;;
41    *) echo "opción desconocida: $1" >&2; exit 2;;
42  esac; shift
43done
44[ ${#ROOTS[@]} -eq 0 ] && ROOTS=(/mnt/vvv /home /opt /srv /var/www)
45
46command -v gh >/dev/null || { echo "✗ falta \`gh\`" >&2; exit 2; }
47if ! gh auth status >/dev/null 2>&1; then
48  echo "✗ \`gh\` no está autenticado. Sin token no se puede crear ni empujar." >&2; exit 2
49fi
50[ -z "$OWNER" ] && OWNER="$(gh api user -q .login 2>/dev/null)"
51[ -z "$OWNER" ] && { echo "✗ no se pudo averiguar la cuenta; pasá --owner" >&2; exit 2; }
52
53# Los nombres/IPs de ESTA máquina, para saber qué remoto es «de acá». No se cablean: se preguntan.
54MIS_IPS="$(ip -4 -o addr show scope global 2>/dev/null | awk '{split($4,a,"/"); print a[1]}')"
55es_local() {  # $1 = url
56  local h="${1#*://}"; h="${h%%/*}"; h="${h##*@}"; h="${h%%:*}"
57  [ -z "$h" ] && return 1
58  case "$h" in localhost|127.0.0.1) return 0;; esac
59  local ip; ip="$(getent ahostsv4 "$h" 2>/dev/null | awk 'NR==1{print $1}')"
60  [ -z "$ip" ] && return 1
61  echo "$MIS_IPS" | grep -qx "$ip"
62}
63
64echo "══ repos sin copia fuera de esta máquina ══"
65[ "$APPLY" = 1 ] || echo "   (ENSAYO — nada se crea ni se empuja; agregá --apply)"
66echo "   cuenta destino: $OWNER · raíces: ${ROOTS[*]}"
67echo
68
69declare -A GRUPO_PRIM GRUPO_N
70CANDIDATOS=()
71while IFS= read -r g; do
72  r="${g%/.git}"
73  urls="$(git -C "$r" config --get-regexp 'remote\..*\.(url|pushurl)' 2>/dev/null | awk '{print $2}')"
74  [ -z "$urls" ] && continue
75  dentro=""; fuera=""
76  while IFS= read -r u; do
77    [ -z "$u" ] && continue
78    if es_local "$u"; then dentro="$u"; else fuera="$u"; fi
79  done <<< "$urls"
80  [ -z "$dentro" ] && continue       # no depende de esta máquina
81  [ -n "$fuera" ] && continue        # ya tiene copia afuera: no se toca
82  # clave del grupo: la RUTA del remoto, no su host ni su puerto — cinco clones del mismo upstream
83  # llegan por URLs distintas y son el mismo proyecto.
84  ruta="${dentro#*://}"; ruta="${ruta##*@}"; ruta="${ruta#*[:/]}"; ruta="${ruta%.git}"
85  clave="$(basename "$(dirname "$ruta")")/$(basename "$ruta")"
86  CANDIDATOS+=("$clave|$r|$dentro")
87  GRUPO_N["$clave"]=$(( ${GRUPO_N["$clave"]:-0} + 1 ))
88done < <(find "${ROOTS[@]}" -maxdepth "$DEPTH" -name .git -prune 2>/dev/null)
89
90[ ${#CANDIDATOS[@]} -eq 0 ] && { echo "   nada que espejar: todos tienen copia fuera."; exit 0; }
91
92# El primario de cada grupo: el clon cuyo HEAD es MÁS NUEVO.
93#
94# ⚠ El primer criterio que escribí era «el que más commits alcanzables tiene», y contra los cinco
95# clones de tawasuyu dio un empate exacto en 9343: `rev-list --all` cuenta las refs de `origin`, que
96# los cinco comparten, así que la métrica estaba dominada por lo que tienen en común y no medía nada.
97# El desempate quedaba en manos del orden del `find` y eligió `tw-deploy` (HEAD del 6/9) sobre
98# `tawasuyu` (del 12/9), que es el que se está trabajando. La fecha del HEAD sí distingue, y es
99# determinista: se compara en ISO, que ordena como texto.
100for c in "${CANDIDATOS[@]}"; do
101  clave="${c%%|*}"; resto="${c#*|}"; r="${resto%%|*}"
102  f="$(git -C "$r" log -1 --format=%cI 2>/dev/null || echo 0)"
103  prev="${GRUPO_PRIM[$clave]:-}"
104  if [ -z "$prev" ] || [[ "$f" > "${prev##*|}" ]]; then GRUPO_PRIM["$clave"]="$r|$f"; fi
105done
106
107# ¿Un clon secundario aporta algo? Se contesta preguntándole al PRIMARIO si ya tiene esos objetos.
108# Medido: los cinco clones de tawasuyu tienen CERO commits que no estén en su remoto, así que
109# empujar cuatro copias bajo `refs/heads/clon/...` sería ruido puro. Namespacear sólo cuando hay
110# historia propia de verdad.
111aporta_algo() {  # $1 = clon secundario   $2 = primario
112  local sha
113  while IFS= read -r sha; do
114    [ -z "$sha" ] && continue
115    git -C "$2" cat-file -e "$sha" 2>/dev/null || return 0
116  done < <(git -C "$1" for-each-ref --format='%(objectname)' refs/heads refs/tags 2>/dev/null)
117  return 1
118}
119
120fallos=0; hechos=0; a_espejar=0; saltados=0; sucios=()
121for c in "${CANDIDATOS[@]}"; do
122  clave="${c%%|*}"; resto="${c#*|}"; r="${resto%%|*}"; dentro="${resto#*|}"
123  nombre="$(basename "$clave")"
124  primario="${GRUPO_PRIM[$clave]%%|*}"
125  es_prim=0; [ "$r" = "$primario" ] && es_prim=1
126  destino="https://github.com/$OWNER/$nombre.git"
127  sucio="$(git -C "$r" status --porcelain 2>/dev/null | wc -l)"
128  [ "$sucio" -gt 0 ] && sucios+=("$(basename "$r"): $sucio fichero(s) sin commitear")
129
130  if [ "$es_prim" = 1 ]; then
131    etq="→ $OWNER/$nombre"
132    refspec="--all"
133  elif aporta_algo "$r" "$primario"; then
134    etq="→ $OWNER/$nombre  bajo refs/heads/clon/$(basename "$r")/*  (tiene historia propia)"
135    refspec="refs/heads/*:refs/heads/clon/$(basename "$r")/*"
136  else
137    printf "  %-30s ·  nada propio que salvar: todo lo suyo ya está en %s\n" \
138           "$(basename "$r")" "$(basename "$primario")"
139    saltados=$((saltados+1)); continue
140  fi
141  a_espejar=$((a_espejar+1))
142  printf "  %-30s %s\n" "$(basename "$r")" "$etq"
143  [ "${GRUPO_N[$clave]}" -gt 1 ] && [ "$es_prim" = 1 ] &&
144    printf "  %-30s   (primario del grupo «%s», %s clones)\n" "" "$clave" "${GRUPO_N[$clave]}"
145
146  [ "$APPLY" = 1 ] || continue
147
148  if ! gh repo view "$OWNER/$nombre" >/dev/null 2>&1; then
149    # ⚠ El error de `gh` se MUESTRA. La primera versión lo mandaba a /dev/null y decía «no se pudo
150    # crear» a secas: los 21 fallaron y el guión no daba ni una pista de por qué. Era el límite de
151    # la API de GitHub agotado —cosa que se resuelve esperando— y sin el mensaje eso parecía un
152    # problema de permisos, de nombre o del propio guión. Un fallo sin su motivo obliga a
153    # reproducirlo a mano para enterarse de algo que la herramienta ya sabía.
154    err="$(gh repo create "$OWNER/$nombre" --private 2>&1)"
155    if [ $? -ne 0 ] || [ -n "${err##*}" ] && ! gh repo view "$OWNER/$nombre" >/dev/null 2>&1; then
156      echo "      ✗ no se pudo crear $OWNER/$nombre: ${err%%$'\n'*}"
157      fallos=$((fallos+1))
158      # Contra el límite de la API no sirve seguir intentando: los 20 restantes van a fallar igual y
159      # cada intento gasta cuota. Se corta y se dice cuándo se puede reintentar.
160      case "$err" in *"rate limit"*|*"RATE_LIMITED"*)
161        reset="$(gh api rate_limit --jq '.resources.graphql.reset // .resources.core.reset' 2>/dev/null)"
162        echo
163        echo "  ✗ LÍMITE DE LA API DE GITHUB AGOTADO — no se intenta con los demás."
164        [ -n "$reset" ] && echo "     se repone a las $(date -d "@$reset" +%H:%M 2>/dev/null)."
165        echo "     Reintentá con el mismo comando: es idempotente, no repite lo ya hecho."
166        exit 1;;
167      esac
168      continue
169    fi
170    echo "      · repo privado creado"
171  fi
172  # `--add --push` sobre `origin`: el fetch sigue siendo el canónico y todo `git push origin` que ya
173  # exista empieza a espejar sin tocar ningún script.
174  git -C "$r" remote get-url --push --all origin 2>/dev/null | grep -qxF "$destino" ||
175    git -C "$r" remote set-url --add --push origin "$destino" 2>/dev/null
176  git -C "$r" remote get-url --push --all origin 2>/dev/null | grep -qxF "$dentro" ||
177    git -C "$r" remote set-url --add --push origin "$dentro" 2>/dev/null
178  if git -C "$r" push "$destino" $refspec >/dev/null 2>&1 &&
179     git -C "$r" push "$destino" --tags >/dev/null 2>&1; then
180    echo "      ✓ empujado"; hechos=$((hechos+1))
181  else
182    echo "      ✗ el push falló"; fallos=$((fallos+1))
183  fi
184done
185
186echo
187if [ ${#sucios[@]} -gt 0 ]; then
188  echo "  ⚠ ${#sucios[@]} repo(s) con trabajo SIN COMMITEAR — el espejo NO lo lleva:"
189  printf '     %s\n' "${sucios[@]}"
190  echo "     Un espejo guarda historia commiteada, no el árbol de trabajo. Commitealo antes de"
191  echo "     apagar el origen, o ese trabajo se va con la máquina."
192fi
193if [ "$APPLY" = 1 ]; then
194  echo "  ${hechos} espejado(s) · ${fallos} fallo(s)"
195  [ "$fallos" -gt 0 ] && exit 1
196else
197  echo "  ${#CANDIDATOS[@]} repo(s) sin copia fuera: ${a_espejar} a espejar, ${saltados} sin historia propia."
198  echo "  Volvé a correrlo con --apply para crearlos (privados) y empujar."
199fi
200exit 0