Ejercicios de Bash resueltos

#!/bin/bashread -r nombre if [ -z "$nombre" ]; then    echo "Error: nombre vacío"    exit 0fiecho "Hola, $nombre"echo "Tu nombre tiene ${#nombre} letras"

#!/bin/bashread -r n if [[ ! $n =~ ^[0-9]+$ ]] || (( 10#$n == 0 )); then    echo "Error: número no válido"    exit 0fifor i in {1..10}; do    echo "$n x $i = $(( 10#$n * i ))"done

#!/bin/bashread -r nombresaludo="Hola, $nombre"echo "$saludo"

#!/bin/bashlog=$(cat) awk '$3 == "ERROR" { errores++; porIp[$4]++ }$3 == "WARN"  { avisos++ }END {    for (ip in porIp)        if (porIp[ip] > max || (porIp[ip] == max && ip < mejor)) { max = porIp[ip]; mejor = ip }    print "Errores: " errores + 0    print "Avisos: " avisos + 0    print "IP con más errores: " mejor " (" max + 0 ")"}' <<< "$log"

#!/bin/bash# La entrada estándar es el contenido de /etc/passwd usuarios=$(awk -F: '$3 >= 1000 && $3 != 65534 { printf "%d\t%s (%s) -> %s [%s]\n", $3, $1, $3, $6, $7 }' | sort -n | cut -f2-)[ -n "$usuarios" ] && echo "$usuarios"echo "Total: $(grep -c . <<< "$usuarios")"

#!/bin/bashdir=$(mktemp -d)cd "$dir" || exit 1 while read -r f || [ -n "$f" ]; do    [ -z "$f" ] && continue    touch -- "$f"    case $f in        *.sh)  chmod 750 -- "$f" ;;     # rwxr-x---: el dueño lo ejecuta, el grupo lo lee y ejecuta        *.key) chmod 600 -- "$f" ;;     # rw-------: una clave solo la lee su dueño        *)     chmod 644 -- "$f" ;;     # rw-r--r--: lo normal para un fichero de datos    esacdoneLC_ALL=C stat -c '%a %n' -- * | LC_ALL=C sort -k2

#!/bin/bashread -r usoif [ "$uso" -gt 80 ]; then  echo "ALERTA: disco al $uso %"else  echo "OK"fi

#!/bin/bashread -r a bif (( a > b )); then  echo "El mayor es $a"else  echo "El mayor es $b"fi

#!/bin/bashread -r nombreif [ "$nombre" = "Ana López" ]; then  echo "Bienvenida, Ana"else  echo "No te conozco"fi

#!/bin/bashread -r umbral alertas=$(awk -v u="$umbral" 'NR > 1 {    uso = $5    sub(/%/, "", uso)    if (uso + 0 >= u) print "ALERTA: " $NF " al " uso "%"}')if [ -n "$alertas" ]; then echo "$alertas"; else echo "Todo correcto"; fi

#!/bin/bash# Lee el log por la entrada estándarlog=$(cat) fallos=$(grep 'Failed password for' <<< "$log")if [ -n "$fallos" ]; then    awk '{ for (i = 1; i <= NF; i++) if ($i == "from") print $(i + 1) }' <<< "$fallos" |        LC_ALL=C sort | uniq -c | LC_ALL=C sort -b -k1,1nr -k2,2 |        while read -r n ip; do            if (( n >= 5 )); then echo "$ip: $n intentos → BLOQUEAR"; else echo "$ip: $n intentos"; fi        donefiecho "Usuarios inexistentes probados: $(grep -o 'invalid user [^ ]*' <<< "$fallos" | sort -u | grep -c .)"

#!/bin/bashtotal=0while read -r n || [ -n "$n" ]; do  total=$((total + n))doneecho "Total: $total"

#!/bin/bashread -r horah=${hora%%:*}m=${hora##*:}echo $(( 10#$h * 60 + 10#$m ))

#!/bin/bashwhile read -r p || [ -n "$p" ]; do    [ -z "$p" ] && continue    if [[ $p =~ ^[r-][w-][xsS-][r-][w-][xsS-][r-][w-][xtT-]$ ]]; then        # Simbólico → octal        especial=0; octal=""        for t in 0 1 2; do            trio=${p:t*3:3}; v=0            [ "${trio:0:1}" = r ] && v=$((v + 4))            [ "${trio:1:1}" = w ] && v=$((v + 2))            case ${trio:2:1} in x|s|t) v=$((v + 1)) ;; esac                     # s y t llevan la x            case ${trio:2:1} in s|S|t|T) especial=$((especial + (4 >> t))) ;; esac   # 4, 2 o 1            octal+=$v        done        (( especial )) && octal="$especial$octal"        echo "$p = $octal"    elif [[ $p =~ ^[0-7]{3,4}$ ]]; then        # Octal → simbólico        o=$p        [ ${#p} -eq 3 ] && o="0$p"        esp=${o:0:1}; texto=""        for t in 0 1 2; do            d=${o:t+1:1}; r=-; w=-; x=-            (( d & 4 )) && r=r            (( d & 2 )) && w=w            (( d & 1 )) && x=x            if (( esp & (4 >> t) )); then                if (( t == 2 )); then                    if [ $x = x ]; then x=t; else x=T; fi                else                    if [ $x = x ]; then x=s; else x=S; fi                fi            fi            texto+="$r$w$x"        done        echo "$o = $texto"    else        echo "$p: no válido"    fidone

#!/bin/bash# Entrada: un nombre de fichero por línea awk 'NF {    n = split($0, partes, ".")    if (n > 1 && partes[n] != "") ext[tolower(partes[n])]++    else sinext++}END {    for (e in ext) print e ": " ext[e] | "LC_ALL=C sort"    close("LC_ALL=C sort")                  # espera a que sort termine antes de seguir    if (sinext) print "(sin extensión): " sinext}'

#!/bin/bashocteto='(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])'ip_valida="^$octeto\.$octeto\.$octeto\.$octeto\
quot; while read -r ip || [ -n "$ip" ]; do  [ -z "$ip" ] && continue  if [[ $ip =~ $ip_valida ]]; then    echo "IP válida"  else    echo "IP no válida"  fidone

#!/bin/bashread -r entradaip=${entrada%/*}prefijo=${entrada#*/} a_texto() { echo "$(( ($1 >> 24) & 255 )).$(( ($1 >> 16) & 255 )).$(( ($1 >> 8) & 255 )).$(( $1 & 255 ))"; } IFS=. read -r a b c d <<< "$ip"n=$(( (a << 24) | (b << 16) | (c << 8) | d ))mascara=$(( (0xFFFFFFFF << (32 - prefijo)) & 0xFFFFFFFF ))red=$(( n & mascara ))difusion=$(( red | (~mascara & 0xFFFFFFFF) )) echo "Red: $(a_texto $red)"echo "Broadcast: $(a_texto $difusion)"echo "Hosts: $(( (1 << (32 - prefijo)) - 2 ))"

#!/bin/bashexport LC_ALL=C awk '$1 == "objetivo" { objetivo = $2; next }$1 == "capa" {    a = $3 / 100    capa = 1 - (1 - a) ^ $4                  # réplicas en paralelo: la capa cae si caen todas    if (n++ == 0) total = capa; else total = total * capa   # capas en serie: se multiplican    printf "%s: %d × %.2f %% → %.6f %%\n", $2, $4, $3, capa * 100}END {    printf "Total: %.6f %%\n", total * 100    printf "Caída máxima al mes: %.1f min\n", (1 - total) * 43200    if (total * 100 >= objetivo) print "Cumple el objetivo"    else printf "No cumple el objetivo del %.2f %%\n", objetivo}'

#!/bin/bashdeclare -A peso cw activo cuentaorden=()while read -r a b && [ "$a" != "---" ]; do    orden+=("$a"); peso[$a]=$b; cw[$a]=0; activo[$a]=1; cuenta[$a]=0done while read -r evento nombre || [ -n "$evento" ]; do    case $evento in        peticion)            total=0; elegido=""            for s in "${orden[@]}"; do                (( activo[$s] )) || continue                (( cw[$s] += peso[$s], total += peso[$s] ))                if [ -z "$elegido" ] || (( cw[$s] > cw[$elegido] )); then elegido=$s; fi            done            if [ -z "$elegido" ]; then                echo "503 sin servidores"                continue            fi            (( cw[$elegido] -= total, cuenta[$elegido] += 1 ))            echo "→ $elegido"            ;;        caido) activo[$nombre]=0; cw[$nombre]=0; echo "$nombre fuera de servicio" ;;        vuelve) activo[$nombre]=1; cw[$nombre]=0; echo "$nombre de vuelta" ;;    esacdone reparto=()for s in "${orden[@]}"; do reparto+=("$s=${cuenta[$s]}"); done(IFS=,; echo "Reparto: ${reparto[*]}" | sed 's/,/, /g')

#!/bin/bashawk '/^---$/ { bloque++; next }bloque == 0 {                                         # sshd_config    if ($0 ~ /^[ \t]*(#|$)/) next    clave = tolower($1)    if (!(clave in conf)) conf[clave] = $2            # cuenta la primera aparición    next}bloque == 1 && NF >= 3 {                              # puertos en escucha    dir = $2; sub(/:[0-9]+$/, "", dir)    puerto = $2; sub(/.*:/, "", puerto)    if ((dir == "0.0.0.0" || dir == "[::]" || dir == "*") && !(puerto in programa)) {        programa[puerto] = $3        lista[++n] = puerto + 0    }    next}bloque == 2 && $1 == "permitidos" {    m = split($2, p, ",")    for (i = 1; i <= m; i++) permitido[p[i] + 0] = 1}END {    if (tolower(conf["permitrootlogin"]) == "yes") {        print "ALTO: PermitRootLogin yes permite entrar como root con contraseña"; altos++    }    clave = "yes"                                      # valor por defecto    if ("passwordauthentication" in conf) clave = tolower(conf["passwordauthentication"])    if (clave != "no") { print "ALTO: PasswordAuthentication permite contraseñas (usa solo claves)"; altos++ }    intentos = 6    if ("maxauthtries" in conf) intentos = conf["maxauthtries"] + 0    if (intentos > 4) { print "MEDIO: MaxAuthTries " intentos " (recomendado 4 o menos)"; medios++ }    if (tolower(conf["x11forwarding"]) == "yes") { print "MEDIO: X11Forwarding activado sin necesidad"; medios++ }     for (i = 2; i <= n; i++) {                         # ordenar los puertos (inserción)        x = lista[i]        for (j = i - 1; j >= 1 && lista[j] > x; j--) lista[j + 1] = lista[j]        lista[j + 1] = x    }    for (i = 1; i <= n; i++) {        if (!(lista[i] in permitido)) {            print "ALTO: puerto " lista[i] " (" programa[lista[i]] ") abierto a internet"; altos++        }    }    if (altos + medios == 0) print "Resultado: sin problemas"    else print "Resultado: " altos + 0 " altos, " medios + 0 " medios"}'

#!/bin/bashread -r dominio raiz puerto if [ -z "$dominio" ] || [ -z "$raiz" ]; then    echo "Uso: dominio raíz [puerto]"    exit 0fiecho "server {"echo "    listen 80;"echo "    server_name $dominio www.$dominio;"if [ -n "$puerto" ]; then             # aplicación: Nginx hace de proxy inverso    echo "    location / {"    echo "        proxy_pass http://127.0.0.1:$puerto;"    echo "    }"else                                  # sitio estático: Nginx sirve los ficheros    echo "    root $raiz;"    echo "    index index.html;"fiecho "}"

#!/bin/bashlog=$(cat) awk 'NF {    n++    peticiones[$1]++                 # $1 = IP del cliente    if ($9 ~ /^4/) e4++              # $9 = código de estado    if ($9 ~ /^5/) e5++}END {    for (ip in peticiones) {        if (peticiones[ip] > max || (peticiones[ip] == max && ip < mejor)) { max = peticiones[ip]; mejor = ip }    }    printf "Peticiones: %d\nErrores 4xx: %d\nErrores 5xx: %d\nIP con más peticiones: %s (%d)\n", n, e4, e5, mejor, max}' <<< "$log"

#!/bin/bashexport TZ=UTC LC_ALL=Cread -r _ hoy base=$(date -d "$hoy" +%s)while read -r dominio fecha || [ -n "$dominio" ]; do    [ -z "$dominio" ] && continue    echo "$(( ($(date -d "$fecha" +%s) - base) / 86400 )) $dominio"    # días que quedandone | sort -k1,1n -k2,2 | {    criticos=0; avisos=0    while read -r dias dominio; do        if (( dias < 0 )); then            echo "$dominio: CADUCADO hace $(( -dias )) días"; criticos=$((criticos + 1))        elif (( dias <= 7 )); then            echo "$dominio: CRÍTICO: caduca en $dias días"; criticos=$((criticos + 1))        elif (( dias <= 30 )); then            echo "$dominio: AVISO: caduca en $dias días"; avisos=$((avisos + 1))        else            echo "$dominio: ok ($dias días)"        fi    done    echo "Resumen: $criticos críticos, $avisos avisos"}

#!/bin/bashdeclare -A reglawhile read -r origen destino && [ "$origen" != "---" ]; do    regla[$origen]=$destinodone while read -r url || [ -n "$url" ]; do    [ -z "$url" ] && continue    camino=("$url"); actual=$url; bucle=0    while [ -n "${regla[$actual]+x}" ]; do          # mientras haya una regla para la URL actual        actual=${regla[$actual]}        for v in "${camino[@]}"; do [ "$v" = "$actual" ] && bucle=1; done        camino+=("$actual")        (( bucle )) && break    done    saltos=$(( ${#camino[@]} - 1 ))    if (( bucle )); then        texto=${camino[0]}        for (( i = 1; i < ${#camino[@]}; i++ )); do texto+=" → ${camino[i]}"; done        echo "$url: BUCLE $texto"    elif (( saltos == 0 )); then        echo "$url: 200 sin redirección"    elif (( saltos == 1 )); then        echo "$url: 301 → $actual"    else        echo "$url: CADENA de $saltos saltos → $actual (redirige directamente)"    fidone

#!/bin/bashmods=(); pats=()while read -r a b && [ "$a" != "---" ]; do    if [ -n "$b" ]; then mods+=("$a"); pats+=("$b"); else mods+=(""); pats+=("$a"); fidone nombre() { if [ -n "${mods[$1]}" ]; then echo "${mods[$1]} ${pats[$1]}"; else echo "${pats[$1]}"; fi; } while read -r uri || [ -n "$uri" ]; do    [ -z "$uri" ] && continue    elegida=-1    # 1) Coincidencia exacta    for i in "${!pats[@]}"; do        if [ "${mods[i]}" = "=" ] && [ "${pats[i]}" = "$uri" ]; then elegida=$i; break; fi    done    if (( elegida < 0 )); then        # 2) Prefijo más largo (normal o ^~)        prefijo=-1        for i in "${!pats[@]}"; do            case ${mods[i]} in ""|"^~") ;; *) continue ;; esac            if [[ $uri == "${pats[i]}"* ]] && { (( prefijo < 0 )) || (( ${#pats[i]} > ${#pats[prefijo]} )); }; then prefijo=$i; fi        done        if (( prefijo >= 0 )) && [ "${mods[prefijo]}" = "^~" ]; then            elegida=$prefijo        else            # 3) Expresiones regulares, en orden            for i in "${!pats[@]}"; do                case ${mods[i]} in                    "~") [[ $uri =~ ${pats[i]} ]] && { elegida=$i; break; } ;;                    "~*") shopt -s nocasematch                          [[ $uri =~ ${pats[i]} ]] && { shopt -u nocasematch; elegida=$i; break; }                          shopt -u nocasematch ;;                esac            done            # 4) Si ninguna coincide, el prefijo más largo            (( elegida < 0 )) && elegida=$prefijo        fi    fi    if (( elegida < 0 )); then echo "$uri → 404 (ninguna)"; else echo "$uri → $(nombre "$elegida")"; fidone

#!/bin/bashlentos=0; caidos=0while read -r nombre codigo ms || [ -n "$nombre" ]; do    [ -z "$nombre" ] && continue    if [ "$codigo" != 200 ]; then        estado="CAÍDO"; caidos=$((caidos + 1))    elif (( ms >= 500 )); then        estado="LENTO"; lentos=$((lentos + 1))    else        estado="OK"    fi    echo "$nombre: $estado"done if (( caidos > 0 )); then general="CAÍDO"elif (( lentos > 0 )); then general="DEGRADADO"else general="OK"; fiecho "Estado general: $general"

#!/bin/bashawk '# Valor del atributo nombre="…" en la línea actual ("" si no está)function attr(nombre,   largo) {    if (match($0, nombre "=\"[^\"]*\"")) {        largo = length(nombre) + 2        return substr($0, RSTART + largo, RLENGTH - largo - 1)    }    return ""}/^[ \t]*<!--/ { next }                                  # comentarios/<Server[ >]/ {    puerto = attr("port"); orden = attr("shutdown")    print "Apagado: puerto " puerto ", orden " orden    if (puerto != "-1" && orden == "SHUTDOWN") avisos[++n] = "AVISO: puerto de apagado " puerto " con la orden por defecto"}/<Connector[ >]/ {    puerto = attr("port"); protocolo = attr("protocol")    if (protocolo == "") protocolo = "HTTP/1.1"    tls = ""    if (attr("SSLEnabled") == "true") tls = " (TLS)"    print "Conector " puerto " " protocolo tls    dir = attr("address")    if (protocolo ~ /AJP/ && dir != "127.0.0.1" && dir != "::1" && dir != "localhost")        avisos[++n] = "PELIGRO: conector AJP " puerto " accesible desde fuera (Ghostcat)"}/<Host[ >]/ {    host = attr("name"); auto = attr("autoDeploy")    if (auto == "") auto = "true"    print "Host " host " → " attr("appBase") " (autoDeploy=" auto ")"    if (auto == "true") avisos[++n] = "AVISO: autoDeploy activado en " host}END {    for (i = 1; i <= n; i++) print avisos[i]    print "Avisos: " n + 0}'

#!/bin/bashbase=/tmp/apprm -rf "$base" && mkdir -p "$base/releases"orden=()                                 # releases en el orden en que se desplegaron estado() {    if [ ! -L "$base/current" ]; then echo "Sin desplegar"; return; fi    local actual    actual=$(readlink "$base/current")    echo "current → ${actual##*/} (releases: ${orden[*]})"} while read -r accion version || [ -n "$accion" ]; do    case $accion in        desplegar)            if [ -d "$base/releases/$version" ]; then echo "Error: $version ya existe"; continue; fi            mkdir "$base/releases/$version"            ln -sfn "$base/releases/$version" "$base/current"     # el cambio es atómico            orden+=("$version")            while (( ${#orden[@]} > 3 )); do                      # solo las 3 más recientes                rm -rf "$base/releases/${orden[0]}"                orden=("${orden[@]:1}")            done            estado            ;;        rollback)            actual=$(readlink "$base/current" 2>/dev/null); actual=${actual##*/}            anterior=""            for i in "${!orden[@]}"; do                if [ "${orden[i]}" = "$actual" ] && (( i > 0 )); then anterior=${orden[i-1]}; fi            done            if [ -z "$anterior" ]; then echo "Error: no hay versión anterior"; continue; fi            ln -sfn "$base/releases/$anterior" "$base/current"            estado            ;;        estado) estado ;;    esacdone

#!/bin/bashexport LC_ALL=C awk 'BEGIN { split("5 25 50 100", etapa, " "); e = 1 }NF >= 7 {                           # $1 $2 $3 = estable · $5 $6 $7 = canario    n++    pct = etapa[e]    if ($5 < 50) { printf "%d: %d %% → datos insuficientes (%d peticiones)\n", n, pct, $5; next }    te = $2 / $1 * 100    tc = $6 / $5 * 100    if (tc - te > 0.5) {        printf "%d: %d %% → REVERTIDA (errores %.2f %% frente a %.2f %%)\n", n, pct, tc, te; fin = 1; exit    }    if ($7 > $3 * 1.2) {        printf "%d: %d %% → REVERTIDA (latencia %d ms frente a %d ms)\n", n, pct, $7, $3; fin = 1; exit    }    if (pct == 100) { printf "%d: 100 %% → ok, PROMOCIONADA\n", n; fin = 1; exit }    e++    printf "%d: %d %% → ok, pasa al %d %%\n", n, pct, etapa[e]}END { if (!fin) printf "Sin decisión: se mantiene el %d %%\n", etapa[e] }'

#!/bin/bashdockerfile=$(cat)avisos=() sin_version=0; apt_sucio=0; copia_pronto=0; usuario=0; copiado_todo=0instalar='npm (install|ci)|composer install|pip install'while IFS= read -r l; do    if [[ $l =~ ^FROM[[:space:]]+([^[:space:]]+) ]]; then        imagen=${BASH_REMATCH[1]}        [[ $imagen != *:* || $imagen == *:latest ]] && sin_version=1    elif [[ $l =~ ^RUN ]]; then        [[ $l == *"apt-get install"* && $l != *"rm -rf /var/lib/apt/lists"* ]] && apt_sucio=1        [[ $l =~ $instalar ]] && (( copiado_todo )) && copia_pronto=1    elif [[ $l =~ ^COPY[[:space:]]+\.[[:space:]] ]]; then        copiado_todo=1    elif [[ $l =~ ^USER[[:space:]] ]]; then        usuario=1    fidone <<< "$dockerfile" (( sin_version )) && avisos+=("Imagen base sin versión concreta")(( apt_sucio )) && avisos+=("apt-get install sin limpiar la caché")(( copia_pronto )) && avisos+=("Se copia todo el código antes de instalar las dependencias")(( usuario )) || avisos+=("El contenedor se ejecuta como root") if (( ${#avisos[@]} )); then printf '%s\n' "${avisos[@]}"; else echo "Sin avisos"; fi

#!/bin/bashdeclare -A usadoerrores=0 valido() { [[ $1 =~ ^[0-9]+$ ]] && (( 10#$1 >= 1 && 10#$1 <= 65535 )); } while IFS= read -r linea || [ -n "$linea" ]; do    [ -z "$linea" ] && continue    servicio=${linea%%:*}    resto=${linea#*:}    for p in $resto; do        if [[ $p != *:* ]]; then            echo "$servicio: $p solo interno (no se publica)"            continue        fi        host=${p%%:*}; contenedor=${p#*:}        if ! valido "$host" || ! valido "$contenedor"; then            echo "$servicio: $p ERROR puerto no válido"; errores=$((errores + 1)); continue        fi        if [ -n "${usado[$host]}" ]; then            echo "$servicio: $p ERROR el puerto $host ya lo publica ${usado[$host]}"; errores=$((errores + 1)); continue        fi        usado[$host]=$servicio        privilegiado=""        (( host < 1024 )) && privilegiado=" (privilegiado)"        echo "$servicio: $host → $contenedor$privilegiado"    donedoneecho "Publicados: ${#usado[@]}, errores: $errores"

#!/bin/bashdeclare -A deporden=()while IFS=: read -r s d || [ -n "$s" ]; do    [ -z "$s" ] && continue    s=$(echo $s); dep[$s]=$(echo $d); orden+=("$s")done # 1) Dependencias que no existenfor s in "${orden[@]}"; do    for d in ${dep[$s]}; do        if [ -z "${dep[$d]+x}" ]; then echo "Error: $s depende de $d, que no existe"; exit 0; fi    donedone # 2) Ciclos: búsqueda en profundidad en orden alfabéticodeclare -A estado          # 1 = en el camino actual, 2 = terminadopila=()dfs() {    local s=$1 d v texto en=0    estado[$s]=1; pila+=("$s")    for d in $(printf '%s\n' ${dep[$s]} | LC_ALL=C sort); do        if [ "${estado[$d]}" = 1 ]; then                 # vuelve a un servicio del camino: ciclo            texto=""            for v in "${pila[@]}"; do [ "$v" = "$d" ] && en=1; (( en )) && texto+="$v → "; done            echo "Ciclo: $texto$d"; exit 0        fi        [ -z "${estado[$d]}" ] && dfs "$d"    done    estado[$s]=2; unset 'pila[${#pila[@]}-1]'}ordenados=$(printf '%s\n' "${orden[@]}" | LC_ALL=C sort)for s in $ordenados; do [ -z "${estado[$s]}" ] && dfs "$s"; done # 3) Rondas: arrancan a la vez los que ya tienen todas sus dependenciasdeclare -A arrancadohechos=0; ronda=0while (( hechos < ${#orden[@]} )); do    lista=()    for s in $ordenados; do        [ -n "${arrancado[$s]}" ] && continue        listo=1        for d in ${dep[$s]}; do [ -z "${arrancado[$d]}" ] && listo=0; done        (( listo )) && lista+=("$s")    done    for s in "${lista[@]}"; do arrancado[$s]=1; done    hechos=$((hechos + ${#lista[@]})); ronda=$((ronda + 1))    echo "Ronda $ronda: ${lista[*]}"done

#!/bin/bashmapfile -t todobloque=0; v1=(); v2=(); cambiados=()for l in "${todo[@]}"; do    if [ "$l" = "---" ]; then ((bloque++)); continue; fi    [ -z "$l" ] && continue    case $bloque in 0) v1+=("$l") ;; 1) v2+=("$l") ;; 2) cambiados+=("$l") ;; esacdone # ¿Afecta el fichero f a la fuente src de un COPY?afecta() {    local f=$1 src=$2    [ "$src" = "." ] && return 0    [[ $src == *"*"* ]] && { [[ $f == $src ]]; return; }      # patrón con comodín    [ "$f" = "$src" ] || [[ $f == "${src%/}"/* ]]                # fichero o carpeta} roto=0; reutilizadas=0for i in "${!v2[@]}"; do    instr=${v2[i]}; motivo=""    if (( roto )); then        motivo="capa anterior reconstruida"    elif (( i >= ${#v1[@]} )) || [ "$instr" != "${v1[i]}" ]; then        motivo="instrucción cambiada"    else        read -ra partes <<< "$instr"        if [ "${partes[0]}" = COPY ] || [ "${partes[0]}" = ADD ]; then            args=(); otra_etapa=0            for p in "${partes[@]:1}"; do                case $p in --from=*) otra_etapa=1 ;; --*) ;; *) args+=("$p") ;; esac            done            if (( ! otra_etapa )); then                fuentes=("${args[@]:0:${#args[@]}-1}")           # el último es el destino                for f in "${cambiados[@]}"; do                    for src in "${fuentes[@]}"; do                        if afecta "$f" "$src"; then motivo="cambió $f"; break 2; fi                    done                done            fi        fi    fi    if [ -n "$motivo" ]; then        roto=1        echo "$((i + 1)) $instr → RECONSTRUIR ($motivo)"    else        reutilizadas=$((reutilizadas + 1))        echo "$((i + 1)) $instr → caché"    fidoneecho "Capas reutilizadas: $reutilizadas de ${#v2[@]}"

#!/bin/bashawk 'function completo(x) {                  # nombre absoluto    if (x == "@") return origen    if (x ~ /\.$/) return x    return x "." origen}$1 == "$ORIGIN" { origen = $2; next }NF == 0 || /^[ \t]*;/ || /^\$/ { next }     # vacías, comentarios y otras directivas{    i = 2    if ($2 == "IN") i = 3                   # la clase es opcional    tipo = $i    nombre = completo($1)    if (tipo == "A" || tipo == "AAAA") print nombre " " tipo " " $(i + 1)    else if (tipo == "CNAME") print nombre " CNAME " completo($(i + 1))    else if (tipo == "MX") print nombre " MX " $(i + 1) " " completo($(i + 2))    else next    n++}END { print "Registros: " n + 0 }'

#!/bin/bashawk 'function completo(x) {    if (x == "@") return origen    if (x ~ /\.$/) return x    return x "." origen}$1 == "$ORIGIN" { origen = $2; dominio = substr(origen, 1, length(origen) - 1); next }NF == 0 || /^[ \t]*;/ || /^\$/ { next }{    i = 2    if ($2 == "IN") i = 3    nombre = completo($1); tipo = $i    if (!(nombre in visto)) { visto[nombre] = 1; nombres[++nn] = nombre }    if (tipo == "CNAME") cname[nombre] = 1    else otros[nombre] = 1    destino = ""    if (tipo == "CNAME" || tipo == "NS") destino = $(i + 1)    if (tipo == "MX") destino = $(i + 2)    if (destino != "") { n++; rtipo[n] = tipo; rnombre[n] = nombre; rdestino[n] = destino }}END {    for (k = 1; k <= nn; k++) {                          # 1) CNAME en el ápice o con otros registros        x = nombres[k]        if (!(x in cname)) continue        if (x == origen) { print "ERROR: CNAME en el ápice (" x ")"; errores++ }        else if (x in otros) { print "ERROR: " x " tiene un CNAME y otros registros"; errores++ }    }    for (k = 1; k <= n; k++) {                           # 2) MX que apunta a un CNAME        if (rtipo[k] != "MX") continue        d = completo(rdestino[k])        if (d in cname) { print "ERROR: el MX de " rnombre[k] " apunta a " d ", que es un CNAME"; errores++ }    }    for (k = 1; k <= n; k++) {                           # 3) falta el punto final        d = rdestino[k]        if (d ~ /\.$/) continue        if (d == dominio || substr(d, length(d) - length(dominio)) == "." dominio) {            print "AVISO: falta el punto final en «" d "» (se leería " d "." origen ")"; avisos++        }    }    print "Errores: " errores + 0 ", avisos: " avisos + 0}'

#!/bin/bashdeclare -A registro          # "servidor|nombre|tipo" -> "valor ttl"declare -A delegaciones      # servidor -> lista de "dominio|servidor_hijo|ttl"while read -r srv nom tipo val ttl && [ "$srv" != "---" ]; do    if [ "$tipo" = "NS" ]; then delegaciones[$srv]+="$nom|$val|$ttl "; else registro["$srv|$nom|$tipo"]="$val $ttl"; fidone declare -A cacheA cacheNS    # nombre -> "ip caduca" · dominio -> "servidor caduca"contiene() { [[ $2 == "$1" || $2 == *".$1" ]]; }   # ¿el dominio $1 contiene al nombre $2? total=0while read -r t nom || [ -n "$t" ]; do    [ -z "$t" ] && continue    if [ -n "${cacheA[$nom]}" ]; then        read -r ip caduca <<< "${cacheA[$nom]}"        if (( t < caduca )); then echo "$t $nom: $ip (caché)"; continue; fi    fi    # Servidor de partida: la delegación en caché más específica que contenga el nombre    srv=raiz; largo=0    for dom in "${!cacheNS[@]}"; do        read -r hijo caduca <<< "${cacheNS[$dom]}"        if (( t < caduca )) && contiene "$dom" "$nom" && (( ${#dom} > largo )); then srv=$hijo; largo=${#dom}; fi    done    consultas=0; resultado=""    while true; do        consultas=$((consultas + 1))        if [ -n "${registro["$srv|$nom|A"]}" ]; then            read -r ip ttl <<< "${registro["$srv|$nom|A"]}"            cacheA[$nom]="$ip $((t + ttl))"            resultado=$ip; break        fi        siguiente=""; largo=0        for e in ${delegaciones[$srv]}; do            IFS='|' read -r dom hijo ttl <<< "$e"            if contiene "$dom" "$nom" && (( ${#dom} > largo )); then siguiente=$hijo; mejor=$dom; mejorTtl=$ttl; largo=${#dom}; fi        done        [ -z "$siguiente" ] && break                     # nadie sabe más: no existe        cacheNS[$mejor]="$siguiente $((t + mejorTtl))"        srv=$siguiente    done    total=$((total + consultas))    if [ -n "$resultado" ]; then echo "$t $nom: $resultado ($consultas consultas)"; else echo "$t $nom: no existe ($consultas consultas)"; fidoneecho "Consultas totales: $total"

#!/bin/bashawk '# Expresión regular equivalente a un valor LDAP con comodines *function patron(v,   r, i, ch) {    r = "^"    for (i = 1; i <= length(v); i++) {        ch = substr(v, i, 1)        if (ch == "*") r = r ".*"        else if (index("\\.[]()+?^$|{}", ch)) r = r "\\" ch        else r = r ch    }    return r "
quot;}# Evalúa el filtro que empieza en F[pos] para la entrada e (descenso recursivo)function evalua(e,   c, r, sr, fin, item, eq, at, val, re, k) {    pos++                                            # salta el (    c = substr(F, pos, 1)    if (c == "&" || c == "|") {        pos++        r = (c == "&")        while (substr(F, pos, 1) == "(") {            sr = evalua(e)                           # se evalúan todos para avanzar pos            if (c == "&" && !sr) r = 0            if (c == "|" && sr) r = 1        }        pos++                                        # salta el )        return r    }    if (c == "!") {        pos++        r = !evalua(e)        pos++        return r    }    fin = index(substr(F, pos), ")")    item = substr(F, pos, fin - 1)    pos += fin    eq = index(item, "=")    at = tolower(substr(item, 1, eq - 1))    val = tolower(substr(item, eq + 1))    if (val == "*") return cnt[e, at] > 0             # presencia del atributo    re = patron(val)    for (k = 1; k <= cnt[e, at]; k++) if (tolower(vals[e, at, k]) ~ re) return 1    return 0}!filtros && $0 == "---" { filtros = 1; next }!filtros {    if ($0 ~ /^[ \t]*$/) { nueva = 1; next }    if (nueva || ne == 0) { ne++; nueva = 0 }    p = index($0, ":")    at = tolower(substr($0, 1, p - 1))    v = substr($0, p + 1); sub(/^ +/, "", v)    cnt[ne, at]++    vals[ne, at, cnt[ne, at]] = v    if (at == "uid" && !(ne in uid)) uid[ne] = v    next}NF {    F = $0    lista = ""    for (x = 1; x <= ne; x++) {        pos = 1        if (evalua(x)) {            if (lista != "") lista = lista ", "            lista = lista uid[x]        }    }    if (lista == "") lista = "(ninguna)"    print F " → " lista}'

#!/bin/bashwhile read -r version tipo || [ -n "$version" ]; do    [ -z "$version" ] && continue    if [[ ! $version =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then        echo "Versión no válida"        continue    fi    mayor=$((10#${BASH_REMATCH[1]})); menor=$((10#${BASH_REMATCH[2]})); parche=$((10#${BASH_REMATCH[3]}))    case $tipo in        major) echo "$((mayor + 1)).0.0" ;;        minor) echo "$mayor.$((menor + 1)).0" ;;        patch) echo "$mayor.$menor.$((parche + 1))" ;;        *) echo "Versión no válida" ;;    esacdone

#!/bin/bashmapfile -t todobase=(); nuestra=(); suya=(); parte=0for l in "${todo[@]}"; do    if [ "$l" = "---" ]; then ((parte++)); continue; fi    case $parte in 0) base+=("$l") ;; 1) nuestra+=("$l") ;; 2) suya+=("$l") ;; esacdone salida=(); conflictos=0; bloque_n=(); bloque_s=()cerrar() {                                  # vuelca el bloque de conflicto pendiente, si lo hay    (( ${#bloque_n[@]} )) || return 0    salida+=("<<<<<<< nuestra" "${bloque_n[@]}" "=======" "${bloque_s[@]}" ">>>>>>> suya")    conflictos=$((conflictos + 1))    bloque_n=(); bloque_s=()}for i in "${!base[@]}"; do    b=${base[i]}; n=${nuestra[i]}; s=${suya[i]}    if [ "$n" = "$s" ]; then cerrar; salida+=("$n")         # coinciden    elif [ "$n" = "$b" ]; then cerrar; salida+=("$s")       # solo cambió la suya    elif [ "$s" = "$b" ]; then cerrar; salida+=("$n")       # solo cambió la nuestra    else bloque_n+=("$n"); bloque_s+=("$s")                 # cambiaron las dos: conflicto    fidonecerrarprintf '%s\n' "${salida[@]}"echo "Conflictos: $conflictos"

#!/bin/bashrotos=(); novedades=(); correcciones=()formato='^([a-z]+)(\([^)]*\))?(!)?: (.*)
#x27;while IFS= read -r linea || [ -n "$linea" ]; do    [[ $linea =~ $formato ]] || continue          # no sigue la convención    tipo=${BASH_REMATCH[1]}; rompe=${BASH_REMATCH[3]}; descripcion=${BASH_REMATCH[4]}    if [ -n "$rompe" ]; then rotos+=("$descripcion")    elif [ "$tipo" = feat ]; then novedades+=("$descripcion")    elif [ "$tipo" = fix ]; then correcciones+=("$descripcion")    fidone seccion() {                                       # título y elementos; nada si está vacía    local titulo=$1; shift    (( $# )) || return 0    echo "## $titulo"    printf -- '- %s\n' "$@"}seccion "Cambios incompatibles" "${rotos[@]}"seccion "Novedades" "${novedades[@]}"seccion "Correcciones" "${correcciones[@]}" if (( ${#rotos[@]} )); then siguiente=majorelif (( ${#novedades[@]} )); then siguiente=minorelif (( ${#correcciones[@]} )); then siguiente=patchelse siguiente=ninguna; fiechoecho "Siguiente versión: $siguiente"

#!/bin/bashexport LC_ALL=C TZ=UTC minutos() { echo $(( $(date -d "$1 $2" +%s) / 60 )); } n=0; fallos=0; primero=""; ultimo=""entregas=(); pendientes=(); recuperaciones=()while read -r tipo f h _ cf ch resultado || [ -n "$tipo" ]; do    case $tipo in        despliegue)            t=$(minutos "$f" "$h")            n=$((n + 1)); [ -z "$primero" ] && primero=$f; ultimo=$f            entregas+=($(( t - $(minutos "$cf" "$ch") )))       # del commit al despliegue            if [ "$resultado" = fallo ]; then fallos=$((fallos + 1)); pendientes+=("$t"); fi            ;;        restaurado)            t=$(minutos "$f" "$h")            for p in "${pendientes[@]}"; do recuperaciones+=($((t - p))); done            pendientes=()            ;;    esacdone dias=$(( ($(date -d "$ultimo" +%s) - $(date -d "$primero" +%s)) / 86400 + 1 ))mapfile -t orden < <(printf '%s\n' "${entregas[@]}" | sort -n)m=${#orden[@]}if (( m % 2 )); then mediana=${orden[m / 2]}; else mediana=$(( (orden[m / 2 - 1] + orden[m / 2]) / 2 )); fi awk -v n="$n" -v dias="$dias" -v med="$mediana" -v fallos="$fallos" -v rec="${recuperaciones[*]}" 'BEGIN {    printf "Despliegues: %d en %d días (%.1f por semana)\n", n, dias, n / dias * 7    printf "Tiempo de entrega (mediana): %d h %d min\n", int(med / 60), med % 60    printf "Tasa de fallos: %.1f %%\n", fallos / n * 100    k = split(rec, r, " ")    if (k == 0) { print "Tiempo de recuperación (media): —"; exit }    for (i = 1; i <= k; i++) s += r[i]    printf "Tiempo de recuperación (media): %.0f min\n", s / k}'

#!/bin/bashset -f                                   # que los * de las rutas no se expandan como ficherosjobs=(); declare -A ctxenjobs=1while IFS= read -r l || [ -n "$l" ]; do    [ -z "$l" ] && continue    if [ "$l" = "---" ]; then enjobs=0; continue; fi    if (( enjobs )); then jobs+=("$l"); else ctx[${l%%=*}]=${l#*=}; fidone IFS=, read -ra cambios <<< "${ctx[cambios]}"declare -A res                           # job -> ok | FALLO | cancelado | omitidofallido=0coincide() { local x=$1 p; shift; for p in "$@"; do [[ $x == $p ]] && return 0; done; return 1; } for l in "${jobs[@]}"; do    read -r nombre opciones <<< "$l"    needs=""; ramas=""; rutas=""    for o in $opciones; do        case $o in needs=*) needs=${o#needs=} ;; ramas=*) ramas=${o#ramas=} ;; rutas=*) rutas=${o#rutas=} ;; esac    done    IFS=, read -ra deps <<< "$needs"    estado=""    for d in "${deps[@]}"; do        case ${res[$d]} in FALLO|cancelado) estado="cancelado (por $d)"; break ;; esac    done    if [ -z "$estado" ]; then        for d in "${deps[@]}"; do [ "${res[$d]}" = omitido ] && { estado="omitido (depende de $d)"; break; }; done    fi    if [ -z "$estado" ] && [ -n "$ramas" ]; then        IFS=, read -ra pr <<< "$ramas"        coincide "${ctx[rama]}" "${pr[@]}" || estado="omitido (rama)"    fi    if [ -z "$estado" ] && [ -n "$rutas" ]; then        IFS=, read -ra pr <<< "$rutas"        alguno=0        for f in "${cambios[@]}"; do coincide "$f" "${pr[@]}" && alguno=1; done        (( alguno )) || estado="omitido (sin cambios)"    fi    if [ -z "$estado" ]; then        if coincide "$nombre" ${ctx[fallan]//,/ }; then estado="FALLO"; fallido=1; else estado="ok"; fi    fi    res[$nombre]=${estado%% *}    echo "$nombre: $estado"doneif (( fallido )); then echo "Resultado: fallido"; else echo "Resultado: éxito"; fi

#!/bin/bashdeclare -A usosproblemas=0 privilegiados=()while read -r servicio mapeo || [ -n "$servicio" ]; do    [ -z "$servicio" ] && continue    host=${mapeo%%:*}    if [ -z "${usos[$host]}" ]; then usos[$host]=$servicio; else usos[$host]+=", $servicio"; fi    (( host < 1024 )) && privilegiados+=("PRIVILEGIADO $servicio: $host")done for host in $(printf '%s\n' "${!usos[@]}" | sort -n); do    if [[ ${usos[$host]} == *,* ]]; then          # más de un servicio en el mismo puerto        echo "CONFLICTO $host: ${usos[$host]}"        problemas=$((problemas + 1))    fidonefor p in "${privilegiados[@]}"; do    echo "$p"    problemas=$((problemas + 1))done(( problemas )) || echo "Sin problemas"

#!/bin/bashn=0; ok=0; error=0; omitido=0; total=0; lento=""; maximo=-1; primer_error=""while read -r paso estado segundos || [ -n "$paso" ]; do    [ -z "$paso" ] && continue    n=$((n + 1))    case $estado in        ok) ok=$((ok + 1)) ;;        error) error=$((error + 1)); [ -z "$primer_error" ] && primer_error=$paso ;;        omitido) omitido=$((omitido + 1)); continue ;;      # no cuenta en el tiempo    esac    total=$((total + segundos))    if (( segundos > maximo )); then maximo=$segundos; lento=$paso; fidone echo "Pasos: $n (ok: $ok, error: $error, omitido: $omitido)"echo "Duración total: $((total / 60)) min $((total % 60)) s"echo "Paso más lento: $lento ($maximo s)"if [ -n "$primer_error" ]; then echo "Primer error: $primer_error"; else echo "Resultado: correcto"; fi

#!/bin/bashexport TZ=UTC LC_ALL=Cread -r hoy h=$(date -d "$hoy" +%s)conservadas=0; borradas=0while read -r f; do    fecha=${f:7:10}    t=$(date -d "$fecha" +%s 2>/dev/null) || continue        # fecha imposible: se ignora    dias=$(( (h - t) / 86400 ))    dia_semana=$(date -d "$fecha" +%u)                      # 7 = domingo    if (( dias <= 6 )) || { (( dias <= 30 )) && [ "$dia_semana" = 7 ]; }; then        echo "CONSERVAR $f"; conservadas=$((conservadas + 1))    else        echo "BORRAR $f"; borradas=$((borradas + 1))    fidone < <(grep -E '^backup-[0-9]{4}-[0-9]{2}-[0-9]{2}\.tar\.gz
#x27; | sort -r)echo "Conservadas: $conservadas · Borradas: $borradas"

#!/bin/bash# Orden de texto byte a byte: así sort y [[ < ]] ordenan igual en cualquier máquinaexport LC_ALL=C declare -A por_ip por_ruta rutas_404total=0bytes_total=0invalidas=0c2=0 c3=0 c4=0 c5=0 while read -r ip _ _ _ _ metodo ruta _ codigo bytes _; do  [ -z "$ip" ] && continue  if [ -z "$bytes" ] || ! [[ $codigo =~ ^[0-9]{3}$ ]]; then    invalidas=$((invalidas + 1))    continue  fi  total=$((total + 1))  por_ip[$ip]=$(( ${por_ip[$ip]:-0} + 1 ))  por_ruta[$ruta]=$(( ${por_ruta[$ruta]:-0} + 1 ))  # Una respuesta sin cuerpo trae «-» en lugar del tamaño  [ "$bytes" != "-" ] && bytes_total=$((bytes_total + bytes))  case ${codigo:0:1} in    2) c2=$((c2 + 1)) ;;    3) c3=$((c3 + 1)) ;;    4) c4=$((c4 + 1)) ;;    5) c5=$((c5 + 1)) ;;  esac  [ "$codigo" = "404" ] && rutas_404[$ruta]=1done if [ "$total" -eq 0 ]; then  echo "No hay peticiones válidas."  exit 0fi echo "Peticiones: $total"echo "Visitantes distintos: ${#por_ip[@]}"echo "Respuestas: 2xx $c2 · 3xx $c3 · 4xx $c4 · 5xx $c5"echo "Datos enviados: $((bytes_total / 1024)) KB" echo "IPs con más peticiones:"for ip in "${!por_ip[@]}"; do  echo "${por_ip[$ip]} $ip"done | sort -k1,1nr -k2,2 | head -n 3 | while read -r n ip; do  printf "%3d %s\n" "$n" "$ip"done mejor=""for ruta in "${!por_ruta[@]}"; do  n=${por_ruta[$ruta]}  if [ -z "$mejor" ] || [ "$n" -gt "${por_ruta[$mejor]}" ] || { [ "$n" -eq "${por_ruta[$mejor]}" ] && [[ $ruta < $mejor ]]; }; then    mejor=$ruta  fidoneveces=${por_ruta[$mejor]}[ "$veces" -eq 1 ] && palabra="vez" || palabra="veces"echo "Página más pedida: $mejor ($veces $palabra)" if [ ${#rutas_404[@]} -eq 0 ]; then  echo "Errores 404: ninguno"else  echo "Errores 404:"  printf "%s\n" "${!rutas_404[@]}" | sort | while read -r ruta; do    echo "  $ruta"  donefi [ "$invalidas" -gt 0 ] && echo "Líneas no válidas: $invalidas"exit 0

#!/bin/bash# Genera las órdenes para dar de alta usuarios a partir de un CSV, sin ejecutarlas (modo simulación)export LC_ALL=C # «Lucía Martín Ruiz» → «lmartinr»: sin tildes ni eñes, en minúsculas y solo letrasnormalizar() {  local s=$1 i  local con=(á é í ó ú ü ñ Á É Í Ó Ú Ü Ñ) sin=(a e i o u u n a e i o u u n)  for i in "${!con[@]}"; do    s=${s//${con[$i]}/${sin[$i]}}  done  s=${s,,}  echo "${s//[^a-z]/}"} read -r palabra lista_gruposif [ "$palabra" != "GRUPOS" ] || [ -z "$lista_grupos" ]; then  echo "La primera línea debe ser GRUPOS grupo1,grupo2…"  exit 0fiIFS=',' read -r -a grupos <<< "$lista_grupos" declare -A existe por_gruporead -r palabra lista_existenif [ "$palabra" = "EXISTEN" ]; then  IFS=',' read -r -a cuentas <<< "$lista_existen"  for c in "${cuentas[@]}"; do existe[$c]=1; done  numero=2else  echo "Falta la línea EXISTEN"  exit 0fi altas=0while IFS=';' read -r nombre ape1 ape2 grupo resto; do  numero=$((numero + 1))  [ -z "$nombre$ape1$ape2$grupo" ] && continue  if [ -z "$nombre" ] || [ -z "$ape1" ] || [ -z "$grupo" ] || [ -n "$resto" ]; then    echo "# Línea $numero: faltan o sobran campos"    continue  fi  valido=0  for g in "${grupos[@]}"; do [ "$g" = "$grupo" ] && valido=1; done  if [ $valido -eq 0 ]; then    echo "# Línea $numero: grupo desconocido $grupo"    continue  fi   # Primero se normaliza y después se toma la inicial: con LC_ALL=C, ${s:0:1} es un byte, y la Í ocupa dos  n=$(normalizar "$nombre")  a1=$(normalizar "$ape1")  a2=$(normalizar "$ape2")  base="${n:0:1}$a1${a2:0:1}"  login=$base  n=2  # Si el login ya existe (en el sistema o en este mismo fichero), se le añade un número  while [ -n "${existe[$login]}" ]; do    login="$base$n"    n=$((n + 1))  done  existe[$login]=1  completo="$nombre $ape1${ape2:+ $ape2}"  echo "useradd -m -s /bin/bash -g $grupo -c \"$completo\" $login"  echo "chage -d 0 $login"  por_grupo[$grupo]=$(( ${por_grupo[$grupo]:-0} + 1 ))  altas=$((altas + 1))done resumen=""for g in "${grupos[@]}"; do  resumen+="${resumen:+, }$g ${por_grupo[$g]:-0}"doneecho "# Altas: $altas ($resumen)"

#!/bin/bash# Política abuelo-padre-hijo: 7 diarias, domingos de las últimas 4 semanas y el día 1 de los últimos 6 mesesexport LC_ALL=C read -r palabra hoyif [ "$palabra" != "HOY" ] || ! date -d "$hoy" +%F >/dev/null 2>&1 || [ "$(date -d "$hoy" +%F)" != "$hoy" ]; then  echo "La primera línea debe ser HOY AAAA-MM-DD"  exit 0fidia_hoy=$(( $(date -u -d "$hoy" +%s) / 86400 ))mes_hoy=$(( 10#$(date -d "$hoy" +%Y) * 12 + 10#$(date -d "$hoy" +%m) )) declare -A fichero_defechas=()while read -r nombre; do  [ -z "$nombre" ] && continue  if [[ ! $nombre =~ ^backup-([0-9]{4}-[0-9]{2}-[0-9]{2})\.tar\.gz$ ]] || [ "$(date -d "${BASH_REMATCH[1]}" +%F 2>/dev/null)" != "${BASH_REMATCH[1]}" ]; then    echo "Ignorado (nombre no válido): $nombre"    continue  fi  fecha=${BASH_REMATCH[1]}  if [[ $fecha > $hoy ]]; then    echo "Ignorado (fecha futura): $nombre"    continue  fi  fichero_de[$fecha]=$nombre  fechas+=("$fecha")done if [ ${#fechas[@]} -eq 0 ]; then  echo "No hay copias"  exit 0fi # Las fechas en formato AAAA-MM-DD se ordenan bien como texto: de la más reciente a la más antiguamapfile -t ordenadas < <(printf "%s\n" "${fechas[@]}" | sort -ru)conservar=0borrar=0liberado=()for i in "${!ordenadas[@]}"; do  f=${ordenadas[$i]}  motivos=""  [ "$i" -lt 7 ] && motivos="diaria"  dias=$(( dia_hoy - $(date -u -d "$f" +%s) / 86400 ))  if [ "$(date -d "$f" +%u)" -eq 7 ] && [ "$dias" -lt 28 ]; then    motivos+="${motivos:+, }semanal"  fi  meses=$(( mes_hoy - (10#$(date -d "$f" +%Y) * 12 + 10#$(date -d "$f" +%m)) ))  if [ "$(date -d "$f" +%d)" = "01" ] && [ "$meses" -lt 6 ]; then    motivos+="${motivos:+, }mensual"  fi  if [ -n "$motivos" ]; then    echo "CONSERVAR ${fichero_de[$f]} ($motivos)"    conservar=$((conservar + 1))  else    echo "BORRAR    ${fichero_de[$f]}"    borrar=$((borrar + 1))  fidoneecho "Se conservan $conservar y se borran $borrar"

#!/bin/bash# Lee la salida de «df -P» y avisa de los sistemas de ficheros que se llenanexport LC_ALL=C read -r palabra aviso criticoif [ "$palabra" != "UMBRALES" ] || ! [[ $aviso =~ ^[0-9]+$ && $critico =~ ^[0-9]+$ ]] || [ "$aviso" -ge "$critico" ] || [ "$critico" -gt 100 ]; then  echo "La primera línea debe ser UMBRALES aviso crítico (aviso < crítico <= 100)"  exit 0fi # KiB → «12,3 GiB» con un decimal, redondeadogib() {  local decimas=$(( ($1 * 10 + 524288) / 1048576 ))  echo "$((decimas / 10)),$((decimas % 10)) GiB"} filas=()libre_total=0read -r _   # cabecera de dfwhile read -r dispositivo bloques usado libre capacidad montaje; do  [ -z "$dispositivo" ] && continue  # Sistemas de ficheros virtuales: no ocupan disco  case $dispositivo in    tmpfs|devtmpfs|overlay|squashfs|udev|none) continue ;;  esac  [[ $dispositivo == /dev/loop* ]] && continue  porcentaje=${capacidad%\%}  libre_total=$((libre_total + libre))  if [ "$porcentaje" -ge "$critico" ]; then estado="URGENTE"  elif [ "$porcentaje" -ge "$aviso" ]; then estado="AVISO"  else estado="OK"; fi  linea=$(printf "%-8s %3d%%  %-12s usado %s de %s" "$estado" "$porcentaje" "$montaje" "$(gib "$usado")" "$(gib $((usado + libre)))")  if [ "$estado" != "OK" ]; then    # Lo que hay que liberar para bajar del umbral de aviso: usado - aviso% del total, redondeado hacia arriba    sobra=$(( usado * 100 - aviso * (usado + libre) ))    liberar=$(( (sobra + 100 * 1048576 - 1) / (100 * 1048576) ))    linea+=" · libera $liberar GiB para bajar del $aviso %"  fi  filas+=("$porcentaje|$montaje|$linea")done if [ ${#filas[@]} -eq 0 ]; then  echo "No hay sistemas de ficheros que vigilar"  exit 0fi# Del más lleno al más vacío; a igual porcentaje, por punto de montajeprintf "%s\n" "${filas[@]}" | sort -t'|' -k1,1nr -k2,2 | cut -d'|' -f3-echo "Libre en total: $(gib "$libre_total")"

#!/bin/bash# Revisa un fichero de sitios de Nginx (como /etc/nginx/sites-available/web) y avisa de los fallos típicosexport LC_ALL=C n=0 profundidad=0 numero=0declare -a inicio fin puertos nombres raiz retorno proxy cert clave autoindex while IFS= read -r linea || [ -n "$linea" ]; do  numero=$((numero + 1))  linea=${linea%%#*}                                   # quita los comentarios  linea="${linea#"${linea%%[![:space:]]*}"}"           # y los espacios de los extremos  linea="${linea%"${linea##*[![:space:]]}"}"  [ -z "$linea" ] && continue   if [[ $linea =~ ^server[[:space:]]*\{$ ]] && [ "$profundidad" -eq 0 ]; then    n=$((n + 1)); inicio[$n]=$numero; profundidad=1    continue  fi  if [[ $linea == *"{" ]]; then                        # un bloque location o similar    if [ "$profundidad" -eq 0 ]; then echo "Error: bloque fuera de un server en la línea $numero"; exit 0; fi    profundidad=$((profundidad + 1))    continue  fi  if [ "$linea" = "}" ]; then    if [ "$profundidad" -eq 0 ]; then echo "Error: llave de cierre sin abrir en la línea $numero"; exit 0; fi    profundidad=$((profundidad - 1))    [ "$profundidad" -eq 0 ] && fin[$n]=$numero    continue  fi  if [ "$profundidad" -eq 0 ]; then echo "Error: directiva fuera de un server en la línea $numero"; exit 0; fi   linea=${linea%;}  read -r directiva valor <<< "$linea"  case $directiva in    listen)      puerto=${valor%% *}; puerto=${puerto##*:}        # «[::]:443 ssl» → 443      [[ $valor == *" ssl"* ]] && puerto+=" ssl"      [[ " ${puertos[$n]} " == *" $puerto "* ]] || puertos[$n]="${puertos[$n]:+${puertos[$n]} }$puerto" ;;    server_name) nombres[$n]=$valor ;;    root) [ -z "${raiz[$n]}" ] && raiz[$n]=$valor ;;    return) retorno[$n]=${valor#* } ;;    proxy_pass) [ -z "${proxy[$n]}" ] && proxy[$n]=$valor ;;    ssl_certificate) cert[$n]=1 ;;    ssl_certificate_key) clave[$n]=1 ;;    autoindex) [ "$valor" = "on" ] && autoindex[$n]=1 ;;  esacdone if [ "$profundidad" -ne 0 ]; then echo "Error: llaves sin cerrar"; exit 0; fiif [ "$n" -eq 0 ]; then echo "No hay ningún bloque server"; exit 0; fi avisos=()declare -A servidores_de     # «nombre puerto» → número de servidoresdeclare -A redirige          # nombre → 1 si su servidor del 80 redirige a httpsdeclare -A en443for i in $(seq 1 "$n"); do  [ -z "${puertos[$i]}" ] && puertos[$i]="80"  if [ -n "${retorno[$i]}" ]; then hace="redirige a ${retorno[$i]}"  elif [ -n "${proxy[$i]}" ]; then hace="proxy a ${proxy[$i]}"  elif [ -n "${raiz[$i]}" ]; then hace="sirve ${raiz[$i]}"  else hace="no sirve nada"; fi  echo "Servidor $i (líneas ${inicio[$i]}-${fin[$i]}): puerto ${puertos[$i]// / y } · ${nombres[$i]:-(sin nombre)} · $hace" | sed 's/ y ssl/ ssl/g'   if [[ " ${puertos[$i]}" == *" ssl"* ]]; then    faltan=""    [ -z "${cert[$i]}" ] && faltan="ssl_certificate"    [ -z "${clave[$i]}" ] && faltan="${faltan:+$faltan y }ssl_certificate_key"    [ -n "$faltan" ] && avisos+=("Servidor $i: usa ssl pero le falta $faltan")  fi  [ -n "${autoindex[$i]}" ] && avisos+=("Servidor $i: autoindex activado (muestra la lista de ficheros)")  [ "$hace" = "no sirve nada" ] && avisos+=("Servidor $i: no tiene root, return ni proxy_pass")   for nombre in ${nombres[$i]}; do    for p in ${puertos[$i]// ssl/}; do      servidores_de["$nombre $p"]=$(( ${servidores_de["$nombre $p"]:-0} + 1 ))      if [ "$p" = "80" ] && [[ ${retorno[$i]} == https://* ]]; then redirige[$nombre]=1; fi      [ "$p" = "443" ] && en443[$nombre]=1    done  donedone # Avisos por nombre de dominio, en orden alfabéticomapfile -t claves < <(printf "%s\n" "${!servidores_de[@]}" | sort)for k in "${claves[@]}"; do  [ -z "$k" ] && continue  [ "${servidores_de[$k]}" -gt 1 ] && avisos+=("${k% *}: aparece en ${servidores_de[$k]} servidores del puerto ${k#* }")donemapfile -t seguros < <(printf "%s\n" "${!en443[@]}" | sort)for nombre in "${seguros[@]}"; do  [ -z "$nombre" ] && continue  [ -z "${redirige[$nombre]}" ] && avisos+=("$nombre: el puerto 80 no redirige a HTTPS")done if [ ${#avisos[@]} -eq 0 ]; then  echo "Sin avisos"else  echo "Avisos:"  for a in "${avisos[@]}"; do echo "  - $a"; donefi

#!/bin/bash# Despliegue por releases (como Capistrano o Deployer): cada versión en su carpeta y un enlace «current»# que se cambia de golpe. Modo simulación: escribe las órdenes en lugar de ejecutarlas.export LC_ALL=CBASE=/var/www/tiendaMAX_RELEASES=3 releases=()          # carpetas de releases, de la más antigua a la más recienteactual="" read -r palabra restoif [ "$palabra" != "RELEASES" ]; then  echo "La primera línea debe ser RELEASES r1 r2… (puede estar vacía)"  exit 0fifor r in $resto; do releases+=("$r"); done[ ${#releases[@]} -gt 0 ] && actual=${releases[-1]} indice_de() {           # posición de una release en el array, o -1  local i  for i in "${!releases[@]}"; do [ "${releases[$i]}" = "$1" ] && { echo "$i"; return; }; done  echo -1} while read -r orden a b; do  [ -z "$orden" ] && continue  case ${orden^^} in    DESPLIEGA)      if [[ ! $a =~ ^[0-9]{8}-[0-9]{4}$ ]] || [[ ! $b =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then        echo "# Uso: DESPLIEGA AAAAMMDD-HHMM vX.Y.Z"; continue      fi      if [ "$(indice_de "$a")" -ge 0 ]; then echo "# La release $a ya existe"; continue; fi      if [ ${#releases[@]} -gt 0 ] && [[ $a < ${releases[-1]} ]]; then echo "# La release $a es anterior a ${releases[-1]}"; continue; fi      echo "# Desplegando $b en $a"      echo "git clone --depth 1 --branch $b https://git.ejemplo.com/tienda.git $BASE/releases/$a"      echo "ln -s $BASE/shared/.env $BASE/releases/$a/.env"      echo "composer install --no-dev --optimize-autoloader --working-dir=$BASE/releases/$a"      # El cambio de versión es atómico: se crea un enlace temporal y se renombra sobre «current»      echo "ln -sfn $BASE/releases/$a $BASE/current.tmp && mv -T $BASE/current.tmp $BASE/current"      echo "systemctl reload php8.3-fpm"      releases+=("$a")      actual=$a      # Solo se conservan las últimas releases, sin borrar nunca la actual      while [ ${#releases[@]} -gt $MAX_RELEASES ]; do        echo "rm -rf $BASE/releases/${releases[0]}"        releases=("${releases[@]:1}")      done      ;;    ROLLBACK)      i=$(indice_de "$actual")      if [ -z "$actual" ] || [ "$i" -le 0 ]; then echo "# No hay una release anterior a la que volver"; continue; fi      anterior=${releases[$((i - 1))]}      echo "# Volviendo de $actual a $anterior"      echo "ln -sfn $BASE/releases/$anterior $BASE/current.tmp && mv -T $BASE/current.tmp $BASE/current"      echo "systemctl reload php8.3-fpm"      actual=$anterior      ;;    ESTADO)      if [ ${#releases[@]} -eq 0 ]; then echo "# Sin releases"; continue; fi      echo "# Releases (${#releases[@]}):"      for r in "${releases[@]}"; do        [ "$r" = "$actual" ] && echo "#   $r  ← current" || echo "#   $r"      done      ;;    *) echo "# Orden desconocida: $orden" ;;  esacdone