#!/usr/bin/bash
# sp-subir: sube un proyecto al servidor de descargas (lo llama "sp subir").
# Pedido del autor, 18/10/2026: que funcione solo desde donde esta el .summa
# del proyecto, que verifique que hay svn y que todo esta comiteado, y que se
# llame "sp subir calcula" parado en el proyecto, o "sp subir LUGAR/calcula".
#
#   sp paquete [LUGAR/]NOMBRE         arma (hacer-pkg)
#   sp subir [--prueba] [--tipo T,...] [LUGAR/]NOMBRE  sube, como UNSTABLE
#   sp estable [--prueba] [LUGAR/]NOMBRE  lo subido pasa a estable
#   sp subir --bootstrap [--prueba] [LUGAR/]summapack   la raiz de descargas:
#                       0-README-como-instalar, el sp autonomo, el
#                       diccionario y fuentesexternas (antes: make
#                       subir-bootstrap)
#   sp subir --comunes-fuentes [--prueba] [LUGAR/]summapack   las fuentes
#                       externas (distros/espejo-fuentes) a comunes/fuentes/
#                       (antes: make subir-comunes-fuentes)
#
# Adonde: el campo SUBIR_A del .summa (pedido del autor, 18/10/2026):
#   SUBIR_A="simusol"   un nombre generico; usuario, servidor y camino salen
#                       de ~/.config/sp/destinos, un renglon por nombre:
#                       simusol publicador@simusol.org:/var/www/.../downloads
#                       (asi el .summa, que es publico, no los muestra)
#   SUBIR_A=""          lo configurado para subir-paquetes
#                       (~/.config/simusol/subir)
#   SUBIR_A="usuario@servidor:/camino"  tal cual, como en scp; esa misma
#                       cadena, literal, es la plantilla que va en lo
#                       publicado (hacer-pkg la pone): sp subir pide cambiarla
# Antes de subir se comprueba que se entra por ssh a usuario@servidor sin
# contrasena (clave); si no, no se sube nada. Las variables SUBIR_SERVIDOR,
# SUBIR_USUARIO y SUBIR_DIR del entorno mandan sobre el .summa (pruebas:
# SUBIR_SERVIDOR=local).
#
# 1. LUGAR/NOMBRE.summa tiene que existir (LUGAR por omision: aca).
# 2. LUGAR tiene que ser una copia de trabajo de svn sin cambios sin comitear
#    (svn status; lo que svn no conoce, "?", no cuenta).
# 3. "sp paquete" arma con LUGAR/hacer-pkg el tar.gz de las fuentes, el
#    .summa con version y los paquetes (si hay cambios sin comitear avisa,
#    pero arma: sirve para probar). "sp subir" usa lo ya armado; si no esta
#    la version actual, llama antes a "sp paquete".
# 4. Sube esos dos con subir-paquetes, como UNSTABLE. "sp estable NOMBRE"
#    lo pasa a estable (subir-paquetes --estable; pedido del autor,
#    18/10/2026). Los binarios (deb, rpm, tgz) no: salen de las bases viejas
#    (summapack/distros) por otro camino.
# 5. Que sube: sin --tipo, todo lo de esa version, de todos los paquetes del
#    .summa (PACKAGES): fuentes (tar.gz), .deb, .rpm y .tgz; con --tipo,
#    solo esos (fuentes, deb, rpm, tgz; separados por coma). El .summa va
#    siempre. Los binarios salen SOLO de lo armado en las bases viejas:
#    summapack/distros/salida/viejas/DISTRIBUCION/ (o $SP_BINARIOS); lo que
#    hacer-pkg arma en esta maquina no se sube (decision del autor,
#    18/10/2026: un .deb de Ubuntu 24.04 no anda en 22.04 ni en Debian 12).
# --prueba: dice que haria (subir-paquetes --prueba), sin subir.
set -euo pipefail
PROGRAMA="sp subir"
AQUI=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
prueba=0 modo=subir tipos=fuentes,deb,rpm,tgz raiz=''
case "${1:-}" in
    --estable-modo) modo=estable; shift ;;
    --paquete-modo) modo=paquete; PROGRAMA="sp paquete"; shift ;;
esac
fallar() { echo "$PROGRAMA: $*" >&2; exit 1; }
while [ $# -gt 0 ]; do
    case "$1" in
        --prueba) prueba=1 ;;
        --bootstrap) raiz=bootstrap ;;
        --comunes-fuentes) raiz=comunes-fuentes ;;
        --tipo) [ $# -ge 2 ] || fallar "--tipo necesita fuentes, deb, rpm o tgz"; tipos=$2; shift ;;
        --tipo=*) tipos=${1#*=} ;;
        -h|--help) sed -n '2,53s/^# \{0,1\}//p' "$0"; exit 0 ;;
        -*) fallar "opcion desconocida: $1 (--help)" ;;
        *) break ;;
    esac
    shift
done
subir=$AQUI/subir-paquetes
[ -x "$subir" ] || subir=$(command -v subir-paquetes || true)
[ -n "$subir" ] || fallar "falta subir-paquetes (de summapack)"
opc=(); [ $prueba = 0 ] || opc=(--prueba)
[ $modo != estable ] || PROGRAMA="sp estable"
[ $# = 1 ] || fallar "uso: sp $modo [--prueba] [--tipo T,...] [LUGAR/]NOMBRE"
objetivo=$1
nombre=$(basename "$objetivo")
case "$objetivo" in */*) lugar=$(dirname "$objetivo") ;; *) lugar=. ;; esac
lugar=$(cd "$lugar" 2>/dev/null && pwd) || fallar "no existe la carpeta de $objetivo"
summa=$lugar/$nombre.summa

# 1. el .summa
[ -f "$summa" ] || fallar "no esta $summa: correr desde la carpeta del proyecto (la que tiene $nombre.summa) o dar LUGAR/$nombre"
# la version completa, AÑO.MAYOR.MENOR.rREV-N (sp-version): la revision de
# svn va en el nombre, asi lo armado antes de un commit no se confunde
sv=$AQUI/sp-version; [ -x "$sv" ] || sv=$(command -v sp-version || true)
[ -n "$sv" ] || fallar "falta sp-version (de summapack)"
version=$("$sv" "$lugar") || fallar "no se pudo saber la version de $nombre"
[ -n "$version" ] || fallar "$summa no dice VERSION"
# la plantilla de lo publicado: hay que poner el destino propio
if [ $modo != paquete ] && grep -qx 'SUBIR_A="usuario@servidor:/camino"' "$summa"; then
    fallar "SUBIR_A en $summa es la plantilla (usuario@servidor:/camino): cambiar SUBIR_A en el .summa por el destino real (usuario@servidor:/camino) o por un nombre de ~/.config/sp/destinos"
fi

# adonde se sube: SUBIR_A del .summa, y que se entre por ssh sin contrasena
destino_de_summa() {
    local a
    a=$(sed -n 's/^SUBIR_A="\(.*\)"$/\1/p' "$summa" | tail -1)
    if [ -n "${SUBIR_SERVIDOR:-}" ]; then
        echo "adonde: el del entorno (SUBIR_SERVIDOR=$SUBIR_SERVIDOR${SUBIR_DIR:+, SUBIR_DIR=$SUBIR_DIR})"
        return 0
    fi
    [ "$a" != "usuario@servidor:/camino" ] || fallar "SUBIR_A en $summa es la plantilla (usuario@servidor:/camino): cambiar SUBIR_A en el .summa por el destino real (usuario@servidor:/camino) o por un nombre de ~/.config/sp/destinos"
    grep -q '^SUBIR_A=' "$summa" || fallar "$summa no dice SUBIR_A (adonde se sube): agregar SUBIR_A=\"simusol\" (o \"\")"
    if [ -z "$a" ]; then
        # lo de subir-paquetes: su configuracion (o sus valores por omision)
        local c=${XDG_CONFIG_HOME:-$HOME/.config}/simusol/subir u='' sv='' d=''
        if [ -f "$c" ]; then
            u=$(sed -n 's/^SUBIR_USUARIO=//p' "$c" | tail -1 | tr -d '"'"'"); sv=$(sed -n 's/^SUBIR_SERVIDOR=//p' "$c" | tail -1 | tr -d '"'"'"); d=$(sed -n 's/^SUBIR_DIR=//p' "$c" | tail -1 | tr -d '"'"'")
        fi
        [ -n "$u" ] && [ -n "$sv" ] && [ -n "$d" ] || fallar "SUBIR_A vacio y falta SUBIR_USUARIO, SUBIR_SERVIDOR o SUBIR_DIR en $c"
        a="$u@$sv:$d"
    fi
    case "$a" in
        *@*:/*) ;;
        *)  # nombre generico: ~/.config/sp/destinos
            local f=${XDG_CONFIG_HOME:-$HOME/.config}/sp/destinos r
            r=$(sed -n "s/^$a[[:space:]]\{1,\}//p" "$f" 2>/dev/null | tail -1 || true)
            [ -n "$r" ] || fallar "SUBIR_A=\"$a\": falta un renglon \"$a usuario@servidor:/camino\" en $f"
            a=$r
            case "$a" in *@*:/*) ;; *) fallar "en $f, $a tiene que ser usuario@servidor:/camino" ;; esac ;;
    esac
    export SUBIR_USUARIO=${a%%@*} SUBIR_SERVIDOR=${a#*@}; SUBIR_SERVIDOR=${SUBIR_SERVIDOR%%:*}
    export SUBIR_DIR=${a#*:}
    echo "adonde: $SUBIR_USUARIO@$SUBIR_SERVIDOR:$SUBIR_DIR"
    if ! ssh -o BatchMode=yes -o ConnectTimeout=15 "$SUBIR_USUARIO@$SUBIR_SERVIDOR" true 2>/dev/null; then
        fallar "no se puede entrar por ssh a $SUBIR_USUARIO@$SUBIR_SERVIDOR sin contrasena desde esta maquina; habilitarlo (ssh-copy-id $SUBIR_USUARIO@$SUBIR_SERVIDOR) y volver a probar"
    fi
}
# Localizar la fuente versionada de un proyecto propio. La configuracion de
# pruebas puede dar un directorio adicional con SP_SUBIR_PROYECTOS.
buscar_proyecto() {
    local p=$1 base d
    for base in ${SP_SUBIR_PROYECTOS:-} "$AQUI/../.." "$AQUI/../../.."; do
        for d in "$base/$p" "$base/$p-6.0" "$base/$p-7.0" "$base/calcula/$p" "$base/calcula/$p-6.0" "$base/calcula/$p-7.0"; do
            if [ -f "$d/$p.summa" ] && [ -x "$d/hacer-pkg" ]; then (cd "$d" && pwd); return 0; fi
        done
    done
    return 1
}
# La vista estable del servidor se comprueba antes de subir y antes de
# estabilizar. Si falta una dependencia propia, se sube y estabiliza primero.
comprobar_compatibilidad() {   # CANDIDATO.summa
    local candidato=$1 tmp orden faltantes consumidor dep minimo actual dir version vueltas=0
    while [ "$vueltas" -lt 30 ]; do
        vueltas=$((vueltas + 1))
        tmp=$(mktemp -d)
        if [ "${SUBIR_SERVIDOR:-}" = local ]; then
            for orden in "$SUBIR_DIR"/*.summa; do [ -f "$orden" ] && cp "$orden" "$tmp/"; done
        else
            printf -v orden 'cd %q && tar -cf - -- *.summa' "$SUBIR_DIR"
            ssh "$SUBIR_USUARIO@$SUBIR_SERVIDOR" "$orden" | tar -xf - -C "$tmp" || { rm -rf "$tmp"; fallar "no se pudieron consultar los .summa estables"; }
        fi
        faltantes=$("$AQUI/sp-comprobar-repo" --faltantes "$tmp" "$candidato") || { rm -rf "$tmp"; fallar "no se pudieron interpretar los requisitos"; }
        rm -rf "$tmp"
        [ -n "$faltantes" ] || return 0
        IFS=$'\t' read -r consumidor dep minimo actual <<< "$faltantes"
        case ":${SP_SUBIR_CADENA:-}:$nombre:" in *":$dep:"*) fallar "dependencia circular al publicar: ${SP_SUBIR_CADENA:+$SP_SUBIR_CADENA:}$nombre:$dep" ;; esac
        dir=$(buscar_proyecto "$dep") || fallar "$consumidor requiere $dep >= $minimo, pero no encuentro sus fuentes para subirlas"
        version=$("$sv" "$dir") || fallar "no puedo determinar la version local de $dep"
        if command -v dpkg >/dev/null 2>&1; then
            dpkg --compare-versions "$version" ge "$minimo" || fallar "$consumidor requiere $dep >= $minimo; la fuente local solo da $version"
        elif [ "$(printf '%s\n%s\n' "$version" "$minimo" | sort -V | tail -1)" != "$version" ]; then
            fallar "$consumidor requiere $dep >= $minimo; la fuente local solo da $version"
        fi
        echo "$consumidor necesita $dep >= $minimo (estable: $actual); se publica primero $dep $version"
        if [ "$prueba" = 1 ]; then
            echo "  [prueba] sp subir $dir/$dep; sp estable $dir/$dep"
            return 0
        fi
        SP_SUBIR_CADENA="${SP_SUBIR_CADENA:+$SP_SUBIR_CADENA:}$nombre" "$0" "$dir/$dep"
        SP_SUBIR_CADENA="${SP_SUBIR_CADENA:+$SP_SUBIR_CADENA:}$nombre" "$0" --estable-modo "$dir/$dep"
    done
    fallar "la cadena de dependencias no converge despues de $vueltas publicaciones"
}
# la raiz de descargas (solo summapack): archivos sueltos, sin version
if [ -n "$raiz" ]; then
    [ "$nombre" = summapack ] || fallar "--$raiz es de summapack"
    destino_de_summa
    if [ $raiz = bootstrap ]; then
        "$lugar/distros/armar-sp"
        sub='' archivos=("$lugar/doc/0-README-como-instalar" "$lugar/distros/salida/sp"
            "$lugar/share/summapack/data/diccionariodepaquetes" "$lugar/share/summapack/data/fuentesexternas")
    else
        [ -f "$lugar/distros/salida/comunes/fuentes/SHA256SUMS" ] || fallar "falta correr distros/espejo-fuentes"
        sub=comunes/fuentes/ archivos=("$lugar"/distros/salida/comunes/fuentes/*)
    fi
    echo "se sube a ${SUBIR_DIR:-?}/$sub:"; for f in "${archivos[@]}"; do echo "  ${f##*/}"; done
    [ $prueba = 0 ] || { echo "(--prueba: no se subio nada)"; exit 0; }
    if [ "${SUBIR_SERVIDOR:-}" = local ]; then
        mkdir -p "$SUBIR_DIR/$sub" && cp "${archivos[@]}" "$SUBIR_DIR/$sub"
    else
        [ -z "$sub" ] || ssh "$SUBIR_USUARIO@$SUBIR_SERVIDOR" "mkdir -p '$SUBIR_DIR/$sub'"
        scp "${archivos[@]}" "$SUBIR_USUARIO@$SUBIR_SERVIDOR:$SUBIR_DIR/$sub"
    fi
    echo "listo"
    exit 0
fi
if [ $modo = estable ]; then
    destino_de_summa
    if [ "${SUBIR_SERVIDOR:-}" = local ]; then
        pendiente="$SUBIR_DIR/$nombre/otros/${nombre}_UNSTABLE.summa"
    else
        pendiente_tmp=$(mktemp -d)
        pendiente="$pendiente_tmp/${nombre}_UNSTABLE.summa"
        printf -v orden 'cat %q' "$SUBIR_DIR/$nombre/otros/${nombre}_UNSTABLE.summa"
        if ! ssh "$SUBIR_USUARIO@$SUBIR_SERVIDOR" "$orden" > "$pendiente" 2>/dev/null; then pendiente=''; fi
    fi
    if [ -n "$pendiente" ] && [ -f "$pendiente" ]; then comprobar_compatibilidad "$pendiente"; fi
    [ "${SUBIR_SERVIDOR:-}" = local ] || rm -rf "$pendiente_tmp"
    "$subir" "${opc[@]}" --estable "$nombre"
    [ $prueba = 1 ] || echo "$nombre: lo subido quedo estable"
    exit 0
fi

# lo primero: el sistema de versiones se sincroniza con el MANIFIESTO (lo que
# este ahi y no versionado se agrega, sin comitear; pedido del autor,
# 20/10/2026); asi sp subir ve esos agregados como cambios sin comitear
if [ -f "$lugar/MANIFIESTO" ]; then
    m=$AQUI/sp-manifiesto; [ -x "$m" ] || m=$(command -v sp-manifiesto || true)
    [ -n "$m" ] || fallar "falta sp-manifiesto (de summapack)"
    "$m" sincronizar "$lugar" || fallar "el MANIFIESTO de $lugar no coincide con la carpeta"
fi

# 2. svn, y todo comiteado
command -v svn >/dev/null || fallar "hace falta svn"
svn info "$lugar" > /dev/null 2>&1 || fallar "$lugar no es una copia de trabajo de svn"
cambios=$(svn status -q "$lugar" 2>/dev/null || true)
if [ -n "$cambios" ]; then
    echo "$cambios" >&2
    [ $modo = paquete ] || fallar "hay cambios sin comitear en $lugar: comitear antes de subir"
    echo "$PROGRAMA: aviso: hay cambios sin comitear; se arma igual (para subir hay que comitear)" >&2
fi
echo "$nombre $version, de $lugar (svn r$(svn info --show-item last-changed-revision "$lugar"), sin cambios sin comitear)"

# 3. armar (sp paquete; sp subir tambien, si no esta armada la version
# actual: pedido del autor, 18/10/2026)
armado() {
    # armado y no mas viejo que el ultimo commit del proyecto (si no, se
    # subiria algo que no es lo comiteado)
    local f d ultimo
    # el commit mas reciente de cualquier archivo del proyecto (el de la
    # carpeta sola no cambia hasta un svn update)
    ultimo=$(date -d "$(svn info -R --show-item last-changed-date "$lugar" 2>/dev/null | cut -d' ' -f1 | sort | tail -1)" +%s 2>/dev/null || echo 0)
    for f in "${nombre}_$version.tar.gz" "${nombre}_$version.summa"; do
        for d in "$lugar" "$(dirname "$lugar")"; do
            [ -f "$d/$f" ] && [ "$(stat -c %Y "$d/$f")" -ge "$ultimo" ] && continue 2
        done
        return 1
    done
}
if [ $modo = subir ] && ! armado; then
    echo "$nombre $version no esta armado (o es anterior al ultimo commit): primero sp paquete"
    [ $prueba = 0 ] || { echo "  [prueba] (cd $lugar && ./hacer-pkg)"; exit 0; }
    # solo las fuentes: los binarios que se suben son los de las bases viejas
    HACER_PKG_SOLO_FUENTES=1 "$0" --paquete-modo "$objetivo" || exit 1
fi
if [ $modo = paquete ]; then
    [ -x "$lugar/hacer-pkg" ] || fallar "no esta $lugar/hacer-pkg"
    [ $prueba = 0 ] || { echo "  [prueba] (cd $lugar && ./hacer-pkg)"; exit 0; }
    log=$(mktemp)
    echo "==> armando con hacer-pkg (todo en $log)"
    ( cd "$lugar" && ./hacer-pkg ) > "$log" 2>&1 || { tail -20 "$log"; fallar "hacer-pkg fallo (todo en $log)"; }
    grep -E '^  [^ ].*\(y \.md5\)' "$log" | sed 's/  (y \.md5)//' || true
    echo "$nombre $version armado; para subirlo: sp subir $objetivo"
    exit 0
fi

# los dos archivos: donde los deja hacer-pkg (al lado del proyecto, o en la
# carpeta de arriba: calcula y puyuspa)
archivos=()
for f in "${nombre}_$version.tar.gz" "${nombre}_$version.summa"; do
    encontrado=''
    for d in "$lugar" "$(dirname "$lugar")"; do
        [ -f "$d/$f" ] && { encontrado=$d/$f; break; }
    done
    [ -n "$encontrado" ] || fallar "no esta $f (armarlo con: sp paquete $objetivo)"
    archivos+=("$encontrado")
done
tar_armado=${archivos[0]}

destino_de_summa
comprobar_compatibilidad "${archivos[1]}"

# los binarios de esa version, de las bases viejas
quiere() { case ",$tipos," in *",$1,"*) return 0 ;; *) return 1 ;; esac; }
for t in ${tipos//,/ }; do
    case "$t" in fuentes|deb|rpm|tgz) ;; *) fallar "--tipo desconocido: $t (fuentes, deb, rpm, tgz)" ;; esac
done
quiere fuentes || archivos=("${archivos[1]}")   # sin el tar.gz: solo el .summa
binarios=${SP_BINARIOS:-$AQUI/../distros/salida/viejas}
paquetes=$(sed -n 's/^PACKAGES="\(.*\)"$/\1/p' "$summa" | tail -1)
# Si el proyecto ya ofrece un formato binario estable, la nueva version debe
# traerlo tambien. Armar solamente las familias que faltan en sus contenedores
# antiguos; la fuente se prueba aparte en los actuales.
binario_presente() {   # PAQUETE FAMILIA
    local q=$1 familia=$2 f
    case "$familia" in
        ubuntu) for f in "$binarios/ubuntu/${q}_${version}_"*.deb; do [ ! -f "$f" ] || return 0; done ;;
        fedora|suse) for f in "$binarios/$familia/${q}-${version}.$familia."*.rpm; do [ ! -f "$f" ] || return 0; done ;;
        arch) for f in "$binarios/arch/${q}_${version}+arch_"*.tgz; do [ ! -f "$f" ] || return 0; done ;;
    esac
    return 1
}
asegurar_binarios() {
    local lista orden viejo q familia clave tar_arch d
    local -a entornos=()
    local -A necesarios=() faltan=()
    if ! quiere deb && ! quiere rpm && ! quiere tgz; then return 0; fi
    if [ "${SUBIR_SERVIDOR:-}" = local ]; then
        lista=$(find "$SUBIR_DIR/$nombre" -maxdepth 1 -type f -printf '%f\n' 2>/dev/null || true)
    else
        printf -v orden "find %q -maxdepth 1 -type f -printf '%%f\\n'" "$SUBIR_DIR/$nombre"
        lista=$(ssh "$SUBIR_USUARIO@$SUBIR_SERVIDOR" "$orden" 2>/dev/null || true)
    fi
    for q in $paquetes; do
        for viejo in $lista; do
            case "$viejo" in
                "$q"_*.deb) necesarios[$q/ubuntu]=1 ;;
                "$q"-*.fedora.*.rpm) necesarios[$q/fedora]=1 ;;
                "$q"-*.suse.*.rpm) necesarios[$q/suse]=1 ;;
                "$q"_*+arch_*.tgz) necesarios[$q/arch]=1 ;;
            esac
        done
    done
    for clave in "${!necesarios[@]}"; do
        q=${clave%/*}; familia=${clave##*/}
        binario_presente "$q" "$familia" || faltan[$familia]=1
    done
    [ ${#faltan[@]} -gt 0 ] || return 0
    for familia in ubuntu fedora suse; do
        [ -z "${faltan[$familia]:-}" ] || entornos+=("$familia-viejo")
    done
    echo "$nombre $version: faltan binarios de ${!faltan[*]}; se arman en los contenedores antiguos"
    [ "$prueba" = 0 ] || return 0
    if [ ${#entornos[@]} -gt 0 ]; then
        "$AQUI/../distros/armar-paquetes" --proyecto "$nombre" "${entornos[@]}" || fallar "no se pudieron armar los binarios de $nombre"
    fi
    if [ -n "${faltan[arch]:-}" ]; then
        tar_arch=$tar_armado
        [ -f "$tar_arch" ] || fallar "falta el tar.gz de $nombre para Arch"
        d=$AQUI/../distros
        mkdir -p "$binarios/arch"
        podman run --rm -v "$lugar":/fuentes:ro,z -v "$AQUI/..":/summapack:ro,z \
            -v "$d":/distros:ro,z -v "$binarios/arch":/salida:z \
            localhost/simusol-arch-viejo:desarrollo bash /distros/dentro.sh arch arch "${tar_arch##*/}" \
            || fallar "no se pudieron armar los TGZ de Arch para $nombre"
    fi
    for clave in "${!necesarios[@]}"; do
        q=${clave%/*}; familia=${clave##*/}
        binario_presente "$q" "$familia" || fallar "falta $q $version para $familia despues de compilar"
    done
}
[ $modo != subir ] || asegurar_binarios
hay_bin=0
if quiere deb || quiere rpm || quiere tgz; then
    if [ -d "$binarios" ]; then
        for q in $paquetes; do
            for d in "$binarios"/*/; do
                quiere deb && for f in "$d${q}_${version}_"*.deb; do [ -f "$f" ] && { archivos+=("$f"); hay_bin=1; }; done
                quiere rpm && for f in "$d${q}-${version}."*.rpm; do [ -f "$f" ] && { archivos+=("$f"); hay_bin=1; }; done
                quiere tgz && for f in "$d${q}_${version}"[_+]*.tgz; do [ -f "$f" ] && { archivos+=("$f"); hay_bin=1; }; done
            done
        done
    fi
    [ $hay_bin = 1 ] || echo "$PROGRAMA: aviso: no hay binarios de $nombre $version en $binarios (los arma la base vieja de cada distribucion); se suben solo las fuentes y el .summa" >&2
fi
echo "se sube:"; for f in "${archivos[@]}"; do echo "  ${f#$(dirname "$(dirname "$f")")/}"; done

# 4. subir, como UNSTABLE
"$subir" "${opc[@]}" "${archivos[@]}"
[ $prueba = 1 ] || echo "$nombre $version subido como UNSTABLE; para dejarlo estable: sp estable $nombre"
