<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <configuration>
    <mainClass>com.nexussoftware.bibliotech.web.BiblioTechApplication</mainClass>
  </configuration>
</plugin>

./mvnw -pl bibliotech-web clean package
java -jar bibliotech-web/target/bibliotech-web-1.0.0.jar

bibliotech-web-1.0.0.jar
├── META-INF/MANIFEST.MF          ← Main-Class: org.springframework.boot.loader.launch.JarLauncher
├── org/springframework/boot/loader/   ← el cargador
└── BOOT-INF/
    ├── classes/                  ← tu código y tus recursos
    ├── lib/                      ← ~50 jars de dependencias
    └── classpath.idx

$ java -Djarmode=tools -jar bibliotech-web.jar list-layers
dependencies
spring-boot-loader
snapshot-dependencies
application

# Extraer cada capa en su directorio
java -Djarmode=tools -jar bibliotech-web.jar extract --layers --launcher --destination extraido/

<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <configuration>
    <layers>
      <enabled>true</enabled>
    </layers>
  </configuration>
</plugin>

<properties>
  <!-- Fija la fecha de las entradas del jar: sin esto, cada construcción difiere -->
  <project.build.outputTimestamp>2026-08-05T00:00:00Z</project.build.outputTimestamp>
</properties>

./mvnw clean package
sha256sum target/bibliotech-web-1.0.0.jar
# a3f7... (el mismo hash en cualquier máquina, hoy y dentro de un año)

<plugin>
  <groupId>io.github.git-commit-id</groupId>
  <artifactId>git-commit-id-maven-plugin</artifactId>
  <version>9.0.1</version>
  <executions>
    <execution><goals><goal>revision</goal></goals></execution>
  </executions>
  <configuration>
    <generateGitPropertiesFile>true</generateGitPropertiesFile>
    <includeOnlyProperties>
      <property>^git.branch$</property>
      <property>^git.commit.id.abbrev$</property>
      <property>^git.commit.time$</property>
      <property>^git.build.version$</property>
    </includeOnlyProperties>
  </configuration>
</plugin>

$ curl https://bibliotech.nexussoftware.com/actuator/info
{
  "git": {
    "branch": "main",
    "commit": { "id": "a3f7e91", "time": "2026-08-05T09:14:22Z" }
  },
  "build": { "version": "1.4.2", "artifact": "bibliotech-web", "time": "2026-08-05T09:20:11Z" }
}

# ==============================================================================
# ETAPA 1: CONSTRUCCIÓN
# Esta etapa tiene Maven, el JDK completo y el código fuente. Nada de eso
# llega a la imagen final: solo se usa para producir el jar.
# ==============================================================================
FROM eclipse-temurin:21-jdk-alpine AS constructor

WORKDIR /build

# Copiar SOLO los ficheros de dependencias primero.
# Docker cachea cada instrucción: mientras los POM no cambien, la descarga
# de dependencias (el paso más lento, 2-3 minutos) se salta por completo.
COPY .mvn/ .mvn/
COPY mvnw pom.xml ./
COPY bibliotech-dominio/pom.xml          bibliotech-dominio/
COPY bibliotech-aplicacion/pom.xml       bibliotech-aplicacion/
COPY bibliotech-infraestructura/pom.xml  bibliotech-infraestructura/
COPY bibliotech-web/pom.xml              bibliotech-web/
COPY bibliotech-consola/pom.xml          bibliotech-consola/

# go-offline descarga todas las dependencias sin compilar nada.
# --mount=type=cache mantiene ~/.m2 entre construcciones (BuildKit).
RUN --mount=type=cache,target=/root/.m2 \
    ./mvnw -B dependency:go-offline -DskipTests

# AHORA sí copiamos el código fuente. Si solo cambia el código,
# Docker reutiliza la capa anterior y no vuelve a descargar nada.
COPY bibliotech-dominio/src          bibliotech-dominio/src
COPY bibliotech-aplicacion/src       bibliotech-aplicacion/src
COPY bibliotech-infraestructura/src  bibliotech-infraestructura/src
COPY bibliotech-web/src              bibliotech-web/src

# -DskipTests: las pruebas ya se ejecutaron en CI (12-05). Repetirlas aquí
# duplica el tiempo y requeriría Docker dentro de Docker para Testcontainers.
RUN --mount=type=cache,target=/root/.m2 \
    ./mvnw -B -pl bibliotech-web -am clean package -DskipTests

# Extraer el jar en capas
RUN java -Djarmode=tools -jar bibliotech-web/target/bibliotech-web-*.jar \
         extract --layers --launcher --destination extraido

# ==============================================================================
# ETAPA 2: EJECUCIÓN
# Imagen mínima: solo JRE (no JDK), sin Maven, sin código fuente,
# sin herramientas de compilación. Menos superficie, menos vulnerabilidades.
# ==============================================================================
FROM eclipse-temurin:21-jre-alpine AS ejecucion

# Etiquetas OCI estándar: metadatos que las herramientas del ecosistema leen
LABEL org.opencontainers.image.title="BiblioTech" \
      org.opencontainers.image.description="Biblioteca técnica de Nexus Software" \
      org.opencontainers.image.vendor="Nexus Software" \
      org.opencontainers.image.licenses="Proprietary"

# Utilidades mínimas:
#  - curl para el HEALTHCHECK
#  - tzdata para que las zonas horarias funcionen (Alpine no las trae)
#  - dumb-init como PID 1: reenvía señales correctamente al proceso Java
RUN apk add --no-cache curl tzdata dumb-init && \
    rm -rf /var/cache/apk/*

ENV TZ=Europe/Madrid

# ---- Usuario NO root ----
# Si un atacante consigue ejecución de código, no debe tener root en el
# contenedor. Es la mitigación más barata y eficaz que existe.
RUN addgroup -S -g 1001 bibliotech && \
    adduser -S -u 1001 -G bibliotech -h /app bibliotech

WORKDIR /app

# ---- Las capas, en orden de estabilidad (menos cambiante primero) ----
# Cada COPY es una capa de Docker. Al cambiar solo el código, únicamente
# la última capa (~1 MB) se reconstruye y se transfiere.
COPY --from=constructor --chown=bibliotech:bibliotech /build/extraido/dependencies/ ./
COPY --from=constructor --chown=bibliotech:bibliotech /build/extraido/spring-boot-loader/ ./
COPY --from=constructor --chown=bibliotech:bibliotech /build/extraido/snapshot-dependencies/ ./
COPY --from=constructor --chown=bibliotech:bibliotech /build/extraido/application/ ./

USER bibliotech

EXPOSE 8080

# ---- Opciones de la JVM ----
#  MaxRAMPercentage=75      usa el 75 % del límite del contenedor para el heap
#  InitialRAMPercentage=50  arranca con la mitad: menos redimensionados
#  UseG1GC                  GC equilibrado; para <2 vCPU considerar SerialGC
#  ExitOnOutOfMemoryError   ante OOM, morir: que el orquestador reinicie
#                           (una JVM en OOM sirve peticiones a medias, que es peor)
#  HeapDumpOnOutOfMemoryError  volcado para diagnosticar (10-07)
#  file.encoding=UTF-8      explícito: no dependemos del entorno
ENV JAVA_OPTS="\
    -XX:MaxRAMPercentage=75.0 \
    -XX:InitialRAMPercentage=50.0 \
    -XX:+UseG1GC \
    -XX:+ExitOnOutOfMemoryError \
    -XX:+HeapDumpOnOutOfMemoryError \
    -XX:HeapDumpPath=/tmp/volcado.hprof \
    -Djava.security.egd=file:/dev/./urandom \
    -Dfile.encoding=UTF-8"

# Comprobación de salud a nivel de contenedor
HEALTHCHECK --interval=30s --timeout=3s --start-period=45s --retries=3 \
  CMD curl -fsS http://localhost:8080/actuator/health/readiness || exit 1

# dumb-init como PID 1 reenvía SIGTERM al proceso Java: sin esto,
# el apagado ordenado (sección 18) no funciona.
ENTRYPOINT ["dumb-init", "--"]

# Forma "shell" para que $JAVA_OPTS se expanda. exec hace que Java sea
# el proceso hijo directo y reciba las señales.
CMD exec java $JAVA_OPTS org.springframework.boot.loader.launch.JarLauncher

docker build -t bibliotech:1.4.2 -t bibliotech:latest .

docker run -d --name bibliotech \
  -p 8080:8080 \
  --memory=768m --cpus=1.5 \
  -e SPRING_PROFILES_ACTIVE=prod \
  -e BIBLIOTECH_DB_URL=jdbc:postgresql://db:5432/bibliotech \
  -e BIBLIOTECH_DB_USER=bibliotech \
  -e BIBLIOTECH_DB_PASSWORD="$DB_PASSWORD" \
  bibliotech:1.4.2

docker logs -f bibliotech
docker exec bibliotech curl -s localhost:8080/actuator/health

# Todo lo que no hace falta para construir
.git/
.github/
.idea/
.vscode/
*.iml

target/
**/target/

*.md
docs/
LICENSE

# CRÍTICO: nada de esto debe entrar en el contexto de construcción
.env
*.env
**/application-local.yml
*.pem
*.p12
*.jks
secrets/

Dockerfile
.dockerignore
compose.yaml

docker build --no-cache --progress=plain . 2>&1 | head -5
# => transferring context: 1.24MB    (bien)
# Sin .dockerignore sería, típicamente, 250 MB.

./mvnw -pl bibliotech-web spring-boot:build-image \
  -Dspring-boot.build-image.imageName=bibliotech:1.4.2

<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <configuration>
    <image>
      <name>registro.nexussoftware.com/bibliotech:${project.version}</name>
      <env>
        <BP_JVM_VERSION>21</BP_JVM_VERSION>
        <BPE_DELIM_JAVA_TOOL_OPTIONS xml:space="preserve"> </BPE_DELIM_JAVA_TOOL_OPTIONS>
        <BPE_APPEND_JAVA_TOOL_OPTIONS>-XX:MaxRAMPercentage=75</BPE_APPEND_JAVA_TOOL_OPTIONS>
      </env>
    </image>
  </configuration>
</plugin>

<plugin>
  <groupId>com.google.cloud.tools</groupId>
  <artifactId>jib-maven-plugin</artifactId>
  <version>3.4.3</version>
  <configuration>
    <from><image>eclipse-temurin:21-jre-alpine</image></from>
    <to><image>registro.nexussoftware.com/bibliotech:${project.version}</image></to>
    <container>
      <user>1001:1001</user>
      <ports><port>8080</port></ports>
      <jvmFlags>
        <jvmFlag>-XX:MaxRAMPercentage=75.0</jvmFlag>
      </jvmFlags>
    </container>
  </configuration>
</plugin>

./mvnw -pl bibliotech-web jib:build         # publica directamente en el registro
./mvnw -pl bibliotech-web jib:dockerBuild   # o construye en el Docker local

FROM eclipse-temurin:21-jdk-alpine AS jre-minimo
RUN jlink \
    --add-modules java.base,java.logging,java.sql,java.naming,java.management,\
java.instrument,java.security.jgss,java.desktop,jdk.unsupported,jdk.crypto.ec \
    --strip-debug --no-man-pages --no-header-files --compress=2 \
    --output /jre-minimo

$ docker run --memory=512m eclipse-temurin:21-jre java -XX:+PrintFlagsFinal -version | grep MaxHeapSize
   size_t MaxHeapSize = 134217728    # 128 MB = 25 % de 512 MB

docker run -e JAVA_OPTS="-XX:NativeMemoryTracking=summary" bibliotech:1.4.2
docker exec bibliotech jcmd 1 VM.native_memory summary

# compose.yaml
name: bibliotech

services:

  db:
    image: postgres:16-alpine
    container_name: bibliotech-db
    environment:
      POSTGRES_DB: bibliotech
      POSTGRES_USER: bibliotech
      POSTGRES_PASSWORD: ${DB_PASSWORD:-bibliotech}
    ports:
      - "5432:5432"
    volumes:
      - datos-db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U bibliotech -d bibliotech"]
      interval: 5s
      timeout: 3s
      retries: 10
      start_period: 10s

  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: bibliotech:${VERSION:-dev}
    container_name: bibliotech-app
    depends_on:
      db:
        condition: service_healthy      # espera al healthcheck, no solo al arranque
    environment:
      SPRING_PROFILES_ACTIVE: docker
      BIBLIOTECH_DB_URL: jdbc:postgresql://db:5432/bibliotech
      BIBLIOTECH_DB_USER: bibliotech
      BIBLIOTECH_DB_PASSWORD: ${DB_PASSWORD:-bibliotech}
      JAVA_OPTS: "-XX:MaxRAMPercentage=75 -XX:+UseG1GC"
    ports:
      - "8080:8080"
    deploy:
      resources:
        limits:
          memory: 768M
          cpus: '1.5'
    healthcheck:
      test: ["CMD", "curl", "-fsS", "http://localhost:8080/actuator/health/readiness"]
      interval: 15s
      timeout: 3s
      retries: 5
      start_period: 60s
    restart: unless-stopped

volumes:
  datos-db:

docker compose up -d --build       # construir y levantar
docker compose logs -f app         # seguir los registros
docker compose ps                  # estado y salud
docker compose exec db psql -U bibliotech    # entrar a la base de datos
docker compose down                # parar (los datos sobreviven)
docker compose down -v             # parar y BORRAR los datos

java -jar bibliotech-web.jar \
     --spring.config.additional-location=file:/etc/bibliotech/

apiVersion: v1
kind: ConfigMap
metadata:
  name: bibliotech-config
data:
  SPRING_PROFILES_ACTIVE: "prod"
  BIBLIOTECH_PRESTAMO_DIASPORDEFECTO: "15"
  LOGGING_LEVEL_COM_NEXUSSOFTWARE_BIBLIOTECH: "INFO"
---
apiVersion: v1
kind: Secret
metadata:
  name: bibliotech-secretos
type: Opaque
stringData:
  BIBLIOTECH_DB_PASSWORD: "…"        # gestionado con Sealed Secrets o un gestor externo
  METADATOS_API_KEY: "…"

curl -s localhost:8080/actuator/env/bibliotech.multa.importe-por-dia | jq
# muestra el valor efectivo Y de qué fuente vino

<dependency>
  <groupId>org.flywaydb</groupId>
  <artifactId>flyway-core</artifactId>
</dependency>
<dependency>
  <groupId>org.flywaydb</groupId>
  <artifactId>flyway-database-postgresql</artifactId>
</dependency>

spring:
  jpa:
    hibernate:
      ddl-auto: validate        # Hibernate VERIFICA, Flyway MANDA
  flyway:
    enabled: true
    locations: classpath:db/migration
    baseline-on-migrate: true   # para una base de datos que ya existía
    validate-on-migrate: true   # detecta scripts ya aplicados que han cambiado
    out-of-order: false         # no permite aplicar una versión anterior a la última

bibliotech-infraestructura/src/main/resources/db/migration/
├── V1__esquema_inicial.sql
├── V2__indices_catalogo.sql
├── V3__anadir_columna_valor_material.sql
├── V4__tabla_reservas.sql
├── V5__estado_devolucion_y_recargos.sql
└── R__vista_estadisticas_uso.sql        ← R = repetible: se reejecuta si cambia

-- V1__esquema_inicial.sql
CREATE TABLE material (
    id                    BIGSERIAL PRIMARY KEY,
    tipo                  VARCHAR(20)  NOT NULL,   -- discriminador SINGLE_TABLE (ADR-004)
    isbn                  VARCHAR(17)  NOT NULL UNIQUE,
    titulo                VARCHAR(200) NOT NULL,
    autor                 VARCHAR(150),
    anio_publicacion      INTEGER,
    unidades_totales      INTEGER      NOT NULL DEFAULT 1 CHECK (unidades_totales >= 0),
    unidades_disponibles  INTEGER      NOT NULL DEFAULT 1 CHECK (unidades_disponibles >= 0),
    version               BIGINT       NOT NULL DEFAULT 0,   -- @Version (11-03)
    creado_en             TIMESTAMPTZ  NOT NULL DEFAULT now(),
    CONSTRAINT chk_disponibles_no_supera_totales
        CHECK (unidades_disponibles <= unidades_totales)
);

CREATE TABLE empleado (
    id            BIGSERIAL PRIMARY KEY,
    nombre        VARCHAR(150) NOT NULL,
    correo        VARCHAR(200) NOT NULL UNIQUE,
    departamento  VARCHAR(100),
    fecha_alta    DATE         NOT NULL,
    version       BIGINT       NOT NULL DEFAULT 0
);

CREATE TABLE prestamo (
    id                 BIGSERIAL PRIMARY KEY,
    material_id        BIGINT      NOT NULL REFERENCES material(id),
    empleado_id        BIGINT      NOT NULL REFERENCES empleado(id),
    fecha_prestamo     DATE        NOT NULL,
    fecha_vencimiento  DATE        NOT NULL,
    fecha_devolucion   DATE,
    estado             VARCHAR(20) NOT NULL,
    version            BIGINT      NOT NULL DEFAULT 0,
    CONSTRAINT chk_vencimiento_posterior CHECK (fecha_vencimiento >= fecha_prestamo),
    CONSTRAINT chk_devolucion_posterior
        CHECK (fecha_devolucion IS NULL OR fecha_devolucion >= fecha_prestamo)
);

-- Índices para las consultas que de verdad se hacen
CREATE INDEX idx_prestamo_empleado_estado ON prestamo(empleado_id, estado);
CREATE INDEX idx_prestamo_vencimiento     ON prestamo(fecha_vencimiento)
                                          WHERE fecha_devolucion IS NULL;  -- parcial
CREATE INDEX idx_material_titulo          ON material USING gin(to_tsvector('spanish', titulo));

-- Datos de referencia que la aplicación necesita para arrancar
INSERT INTO empleado (nombre, correo, departamento, fecha_alta) VALUES
    ('Marta Ruiz',  '[email protected]',  'Arquitectura', '2024-03-01'),
    ('Diego Alonso','[email protected]','Backend',      '2025-01-15'),
    ('Nuria Vidal', '[email protected]', 'Plataforma',   '2023-09-10');

./mvnw flyway:info       # qué migraciones hay y cuáles están aplicadas
./mvnw flyway:validate   # comprueba las sumas de comprobación
./mvnw flyway:migrate    # aplica las pendientes
./mvnw flyway:repair     # arregla la tabla de control (¡con cuidado!)

@Test
void todasLasMigracionesSeAplicanSobrePostgresLimpio() {
    Flyway flyway = Flyway.configure()
            .dataSource(POSTGRES.getJdbcUrl(), POSTGRES.getUsername(), POSTGRES.getPassword())
            .locations("classpath:db/migration")
            .load();

    MigrateResult resultado = flyway.migrate();

    assertThat(resultado.success).isTrue();
    assertThat(resultado.migrationsExecuted).isGreaterThan(0);
    // Y que el esquema resultante coincide con lo que espera Hibernate:
    assertThatNoException().isThrownBy(() -> validarEsquemaContraEntidades());
}

-- V6__renombrar_columna.sql
ALTER TABLE prestamo RENAME COLUMN fecha_venc TO fecha_vencimiento;

-- FASE 1: V6__anadir_fecha_vencimiento.sql   (compatible con la app v1)
ALTER TABLE prestamo ADD COLUMN fecha_vencimiento DATE;

UPDATE prestamo SET fecha_vencimiento = fecha_venc WHERE fecha_vencimiento IS NULL;

-- Trigger de doble escritura: da igual qué versión de la app escriba
CREATE OR REPLACE FUNCTION sincronizar_fecha_vencimiento() RETURNS TRIGGER AS $$
BEGIN
    IF NEW.fecha_vencimiento IS DISTINCT FROM OLD.fecha_vencimiento THEN
        NEW.fecha_venc := NEW.fecha_vencimiento;
    ELSIF NEW.fecha_venc IS DISTINCT FROM OLD.fecha_venc THEN
        NEW.fecha_vencimiento := NEW.fecha_venc;
    END IF;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER trg_sincronizar_fecha
    BEFORE INSERT OR UPDATE ON prestamo
    FOR EACH ROW EXECUTE FUNCTION sincronizar_fecha_vencimiento();

-- FASE 3: V8__eliminar_fecha_venc.sql   (solo tras confirmar que v1 ya no corre)
DROP TRIGGER IF EXISTS trg_sincronizar_fecha ON prestamo;
DROP FUNCTION IF EXISTS sincronizar_fecha_vencimiento();
ALTER TABLE prestamo DROP COLUMN fecha_venc;
ALTER TABLE prestamo ALTER COLUMN fecha_vencimiento SET NOT NULL;

# /etc/systemd/system/bibliotech.service
[Unit]
Description=BiblioTech - Biblioteca técnica de Nexus Software
After=network.target postgresql.service
Wants=postgresql.service

[Service]
Type=simple
User=bibliotech
Group=bibliotech
WorkingDirectory=/opt/bibliotech

EnvironmentFile=/etc/bibliotech/entorno      # secretos, con permisos 600
ExecStart=/usr/bin/java $JAVA_OPTS -jar /opt/bibliotech/bibliotech-web.jar

SuccessExitStatus=143                        # 128 + SIGTERM: apagado ordenado, no es fallo
Restart=on-failure
RestartSec=10

# Apagado ordenado: SIGTERM, y 60 s antes de SIGKILL
KillSignal=SIGTERM
TimeoutStopSec=60

# Endurecimiento: mínimo privilegio (12-07)
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/var/log/bibliotech /var/lib/bibliotech

StandardOutput=journal
StandardError=journal
SyslogIdentifier=bibliotech

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now bibliotech
sudo systemctl status bibliotech
sudo journalctl -u bibliotech -f

apiVersion: apps/v1
kind: Deployment
metadata:
  name: bibliotech
  labels:
    app: bibliotech
spec:
  replicas: 3                       # tres instancias: alta disponibilidad
  revisionHistoryLimit: 5           # historial para vuelta atrás

  strategy:
    type: RollingUpdate             # actualización progresiva (sección 20)
    rollingUpdate:
      maxSurge: 1                   # como mucho 1 pod extra durante la transición
      maxUnavailable: 0             # NUNCA menos de 3 disponibles: sin corte de servicio

  selector:
    matchLabels:
      app: bibliotech

  template:
    metadata:
      labels:
        app: bibliotech
        version: "1.4.2"
    spec:
      # Margen para que el apagado ordenado termine (sección 18)
      terminationGracePeriodSeconds: 60

      securityContext:              # mínimo privilegio a nivel de pod
        runAsNonRoot: true
        runAsUser: 1001
        fsGroup: 1001

      containers:
        - name: bibliotech
          image: registro.nexussoftware.com/bibliotech:1.4.2   # etiqueta EXACTA, nunca 'latest'
          imagePullPolicy: IfNotPresent

          ports:
            - name: http
              containerPort: 8080

          envFrom:
            - configMapRef: { name: bibliotech-config }
            - secretRef:    { name: bibliotech-secretos }

          resources:
            requests:                # lo que el planificador reserva
              memory: "512Mi"
              cpu: "250m"
            limits:                  # el techo; superarlo en memoria = OOMKilled
              memory: "768Mi"
              cpu: "1500m"

          # --- Sondas (sección 17) ---
          startupProbe:              # protege el arranque: hasta 100 s
            httpGet: { path: /actuator/health/liveness, port: http }
            failureThreshold: 20
            periodSeconds: 5

          livenessProbe:             # ¿sigue vivo? Si no, REINICIAR
            httpGet: { path: /actuator/health/liveness, port: http }
            periodSeconds: 10
            failureThreshold: 3

          readinessProbe:            # ¿puede atender? Si no, SACAR DEL BALANCEADOR
            httpGet: { path: /actuator/health/readiness, port: http }
            periodSeconds: 5
            failureThreshold: 2

          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true       # nada escribe en la raíz
            capabilities: { drop: ["ALL"] }

          volumeMounts:
            - name: tmp
              mountPath: /tmp                  # necesario: Tomcat y los volcados escriben aquí

      volumes:
        - name: tmp
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: bibliotech
spec:
  selector:
    app: bibliotech
  ports:
    - port: 80
      targetPort: http
  type: ClusterIP
---
apiVersion: policy/v1
kind: PodDisruptionBudget           # protege durante el mantenimiento del clúster
metadata:
  name: bibliotech
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app: bibliotech

kubectl apply -f k8s/
kubectl rollout status deployment/bibliotech
kubectl get pods -l app=bibliotech
kubectl logs -f -l app=bibliotech --tail=100
kubectl rollout undo deployment/bibliotech         # vuelta atrás inmediata

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus     # SOLO lo necesario (12-07)
      base-path: /actuator
  endpoint:
    health:
      probes:
        enabled: true                # habilita /health/liveness y /health/readiness
      show-details: when-authorized  # el detalle, solo a quien tiene permiso
      group:
        readiness:
          include: db, diskSpace     # si la BD no responde, no estamos listos
        liveness:
          include: livenessState     # solo el estado del proceso
  health:
    livenessstate:
      enabled: true
    readinessstate:
      enabled: true

$ curl localhost:8080/actuator/health/liveness
{"status":"UP"}

$ curl localhost:8080/actuator/health/readiness
{"status":"UP","components":{"db":{"status":"UP"},"diskSpace":{"status":"UP"}}}

@Component
public class SaludPasarelaMetadatos implements HealthIndicator {

    private final PasarelaMetadatos pasarela;

    @Override
    public Health health() {
        try {
            boolean disponible = pasarela.comprobarDisponibilidad();
            return disponible
                    ? Health.up().withDetail("pasarela", "disponible").build()
                    // DEGRADED, no DOWN: la aplicación funciona sin metadatos externos.
                    // Marcar DOWN aquí sacaría del balanceador una app perfectamente usable.
                    : Health.status("DEGRADED").withDetail("pasarela", "no responde").build();
        } catch (Exception e) {
            return Health.status("DEGRADED").withException(e).build();
        }
    }
}

server:
  shutdown: graceful            # deja de aceptar peticiones nuevas y espera a las actuales

spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s

@Component
public class CierreOrdenado {

    private static final Logger log = LoggerFactory.getLogger(CierreOrdenado.class);

    private final ExecutorService ejecutorImportaciones;

    /**
     * @PreDestroy se ejecuta cuando el contexto de Spring se cierra,
     * lo que ocurre al recibir SIGTERM.
     */
    @PreDestroy
    public void alApagar() {
        log.info("Apagado ordenado: cerrando recursos");

        ejecutorImportaciones.shutdown();     // no acepta tareas nuevas
        try {
            if (!ejecutorImportaciones.awaitTermination(20, TimeUnit.SECONDS)) {
                log.warn("Importaciones sin terminar tras 20 s; forzando");
                ejecutorImportaciones.shutdownNow();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            ejecutorImportaciones.shutdownNow();
        }
        log.info("Apagado ordenado completado");
    }
}

lifecycle:
  preStop:
    exec:
      command: ["sh", "-c", "sleep 10"]     # dar tiempo al balanceador a actualizarse

# Generar el archivo CDS durante la construcción de la imagen
RUN java -XX:ArchiveClassesAtExit=/app/app.jsa \
         -Dspring.context.exit=onRefresh \
         org.springframework.boot.loader.launch.JarLauncher

ENV JAVA_OPTS="$JAVA_OPTS -XX:SharedArchiveFile=/app/app.jsa"

<profile>
  <id>native</id>
  <build>
    <plugins>
      <plugin>
        <groupId>org.graalvm.buildtools</groupId>
        <artifactId>native-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</profile>

./mvnw -Pnative native:compile -pl bibliotech-web
./bibliotech-web/target/bibliotech-web       # arranca en 80 ms

@Service
public class GestorPrestamos {

    private final PropiedadesBiblioTech props;

    public Prestamo prestar(Isbn isbn, Long idEmpleado, Integer dias) {
        if (props.funcionalidades().reservaAutomatica()) {
            // Código nuevo, desplegado pero desactivado hasta que se decida
            return prestarConReservaAutomatica(isbn, idEmpleado, dias);
        }
        return prestarClasico(isbn, idEmpleado, dias);
    }
}

bibliotech:
  funcionalidades:
    reserva-automatica: false          # se activa con una variable de entorno, sin desplegar
    prestamo-prioritario: true
    informe-pdf: false

kubectl rollout undo deployment/bibliotech
docker compose up -d --force-recreate   # con la etiqueta anterior
sudo systemctl stop bibliotech && cp bibliotech-1.4.1.jar bibliotech-web.jar && sudo systemctl start bibliotech

# Copia diaria
pg_dump -h db -U bibliotech -Fc bibliotech > bibliotech-$(date +%F).dump

# Copia previa a CUALQUIER migración destructiva
pg_dump -h db -U bibliotech -Fc bibliotech > pre-migracion-v8-$(date +%F-%H%M).dump

# .github/workflows/cd.yml
name: Entrega continua

on:
  push:
    branches: [main]
    tags: ['v*']

env:
  REGISTRO: ghcr.io
  IMAGEN: ${{ github.repository }}

permissions:
  contents: read
  packages: write
  id-token: write          # para firmar la imagen con cosign

jobs:

  # ---------------------------------------------------------------
  # 1. Reutiliza la verificación completa de 12-05
  # ---------------------------------------------------------------
  verificar:
    uses: ./.github/workflows/ci.yml

  # ---------------------------------------------------------------
  # 2. Construir y publicar la imagen
  # ---------------------------------------------------------------
  imagen:
    name: Construir y publicar imagen
    runs-on: ubuntu-latest
    needs: verificar
    outputs:
      digest: ${{ steps.construir.outputs.digest }}
      etiquetas: ${{ steps.meta.outputs.tags }}

    steps:
      - uses: actions/checkout@v4

      - name: Configurar QEMU
        uses: docker/setup-qemu-action@v3        # para construir para arm64

      - name: Configurar Buildx
        uses: docker/setup-buildx-action@v3

      - name: Autenticarse en el registro
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRO }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Calcular etiquetas y metadatos
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRO }}/${{ env.IMAGEN }}
          tags: |
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}
            type=sha,prefix=,format=short          # trazabilidad al commit
            type=raw,value=latest,enable={{is_default_branch}}

      - name: Construir y publicar
        id: construir
        uses: docker/build-push-action@v6
        with:
          context: .
          platforms: linux/amd64,linux/arm64
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha                    # caché de capas entre ejecuciones
          cache-to: type=gha,mode=max
          provenance: true
          sbom: true                              # inventario de componentes (12-07)

      - name: Analizar vulnerabilidades de la imagen
        uses: aquasecurity/[email protected]
        with:
          image-ref: ${{ env.REGISTRO }}/${{ env.IMAGEN }}@${{ steps.construir.outputs.digest }}
          severity: 'CRITICAL,HIGH'
          exit-code: '1'                          # bloquea si hay vulnerabilidades graves

      - name: Firmar la imagen
        uses: sigstore/cosign-installer@v3
      - run: cosign sign --yes ${{ env.REGISTRO }}/${{ env.IMAGEN }}@${{ steps.construir.outputs.digest }}

  # ---------------------------------------------------------------
  # 3. Preproducción: automático
  # ---------------------------------------------------------------
  preproduccion:
    name: Desplegar en preproducción
    runs-on: ubuntu-latest
    needs: imagen
    environment:
      name: preproduccion
      url: https://preproduccion.bibliotech.nexussoftware.com

    steps:
      - name: Desplegar
        run: |
          kubectl set image deployment/bibliotech \
            bibliotech=${{ env.REGISTRO }}/${{ env.IMAGEN }}@${{ needs.imagen.outputs.digest }} \
            --namespace=preproduccion
          kubectl rollout status deployment/bibliotech -n preproduccion --timeout=5m

      - name: Pruebas de humo
        run: |
          BASE=https://preproduccion.bibliotech.nexussoftware.com
          curl -fsS "$BASE/actuator/health/readiness" | jq -e '.status == "UP"'
          curl -fsS "$BASE/api/materiales?size=1"     | jq -e '.contenido | length >= 0'
          echo "Pruebas de humo correctas"

  # ---------------------------------------------------------------
  # 4. Producción: requiere aprobación manual
  # ---------------------------------------------------------------
  produccion:
    name: Desplegar en producción
    runs-on: ubuntu-latest
    needs: [imagen, preproduccion]
    if: startsWith(github.ref, 'refs/tags/v')     # solo desde una etiqueta de versión
    environment:
      name: produccion                            # con revisores obligatorios configurados
      url: https://bibliotech.nexussoftware.com

    steps:
      - name: Guardar la revisión actual, por si hay que volver
        id: actual
        run: |
          ACTUAL=$(kubectl get deployment/bibliotech -n produccion \
                   -o jsonpath='{.spec.template.spec.containers[0].image}')
          echo "imagen_anterior=$ACTUAL" >> $GITHUB_OUTPUT

      - name: Desplegar (actualización progresiva)
        run: |
          kubectl set image deployment/bibliotech \
            bibliotech=${{ env.REGISTRO }}/${{ env.IMAGEN }}@${{ needs.imagen.outputs.digest }} \
            --namespace=produccion
          kubectl rollout status deployment/bibliotech -n produccion --timeout=10m

      - name: Verificar salud tras el despliegue
        id: verificar
        run: |
          sleep 30
          BASE=https://bibliotech.nexussoftware.com
          for i in $(seq 1 10); do
            if curl -fsS "$BASE/actuator/health/readiness" | jq -e '.status == "UP"' > /dev/null; then
              echo "Instancia sana (intento $i)"; sleep 5
            else
              echo "::error::Verificación de salud fallida"; exit 1
            fi
          done
          # Comprobar que la tasa de errores no se ha disparado
          ERRORES=$(curl -fsS "$BASE/actuator/metrics/http.server.requests?tag=outcome:SERVER_ERROR" \
                    | jq '.measurements[0].value // 0')
          if (( $(echo "$ERRORES > 10" | bc -l) )); then
            echo "::error::Demasiados errores 5xx tras el despliegue"; exit 1
          fi

      - name: Vuelta atrás automática si algo falló
        if: failure()
        run: |
          echo "::warning::Despliegue fallido; volviendo a la versión anterior"
          kubectl rollout undo deployment/bibliotech -n produccion
          kubectl rollout status deployment/bibliotech -n produccion --timeout=5m

      - name: Notificar el resultado
        if: always()
        run: |
          ESTADO="${{ job.status }}"
          curl -X POST "${{ secrets.WEBHOOK_EQUIPO }}" \
            -H 'Content-Type: application/json' \
            -d "{\"texto\":\"Despliegue de BiblioTech ${{ github.ref_name }}: $ESTADO\"}"

// CON 3 INSTANCIAS: esto envía TRES avisos a cada empleado, todos los días
@Scheduled(cron = "0 0 8 * * *")
public void enviarAvisosDiarios() {
    servicioAvisos.avisarVencimientosProximos(3);
}

// Opción A: ShedLock — bloqueo distribuido en la base de datos
@Scheduled(cron = "0 0 8 * * *")
@SchedulerLock(name = "avisosDiarios", lockAtMostFor = "10m", lockAtLeastFor = "1m")
public void enviarAvisosDiarios() {
    servicioAvisos.avisarVencimientosProximos(3);
}

# Opción B: un CronJob de Kubernetes que invoca la CLI de 12-03.
# Ventaja: el planificador no vive en la aplicación.
apiVersion: batch/v1
kind: CronJob
metadata:
  name: bibliotech-avisos
spec:
  schedule: "0 8 * * *"
  concurrencyPolicy: Forbid           # no solapar ejecuciones
  jobTemplate:
    spec:
      backoffLimit: 3
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: cli
              image: registro.nexussoftware.com/bibliotech-cli:1.4.2
              args: ["avisos", "enviar", "--dias-antelacion=3"]
              envFrom:
                - secretRef: { name: bibliotech-secretos }

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: bibliotech
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: bibliotech
  minReplicas: 3
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target: { type: Utilization, averageUtilization: 70 }
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300     # no reducir a la primera bajada: evita oscilación

# ==============================================================================
# ETAPA 1: CONSTRUCCIÓN
# ==============================================================================
FROM eclipse-temurin:21-jdk-alpine AS constructor

WORKDIR /build

COPY .mvn/ .mvn/
COPY mvnw pom.xml ./
COPY bibliotech-dominio/pom.xml          bibliotech-dominio/
COPY bibliotech-aplicacion/pom.xml       bibliotech-aplicacion/
COPY bibliotech-infraestructura/pom.xml  bibliotech-infraestructura/
COPY bibliotech-consola/pom.xml          bibliotech-consola/

RUN --mount=type=cache,target=/root/.m2 \
    ./mvnw -B -pl bibliotech-consola -am dependency:go-offline -DskipTests

COPY bibliotech-dominio/src          bibliotech-dominio/src
COPY bibliotech-aplicacion/src       bibliotech-aplicacion/src
COPY bibliotech-infraestructura/src  bibliotech-infraestructura/src
COPY bibliotech-consola/src          bibliotech-consola/src

RUN --mount=type=cache,target=/root/.m2 \
    ./mvnw -B -pl bibliotech-consola -am clean package -DskipTests

RUN java -Djarmode=tools -jar bibliotech-consola/target/bibliotech-cli.jar \
         extract --layers --launcher --destination extraido

# ==============================================================================
# ETAPA 2: GENERAR EL ARCHIVO CDS
# Se ejecuta la aplicación una vez con --help para que cargue las clases,
# y se memoriza el resultado. Esto recorta ~1,5 s de cada arranque, que
# multiplicado por las ejecuciones de cron sí importa.
# ==============================================================================
FROM eclipse-temurin:21-jre-alpine AS cds

WORKDIR /app
COPY --from=constructor /build/extraido/ ./

RUN java -XX:ArchiveClassesAtExit=/app/cli.jsa \
         org.springframework.boot.loader.launch.JarLauncher --help > /dev/null 2>&1 || true

# ==============================================================================
# ETAPA 3: EJECUCIÓN
# ==============================================================================
FROM eclipse-temurin:21-jre-alpine AS ejecucion

LABEL org.opencontainers.image.title="BiblioTech CLI" \
      org.opencontainers.image.description="Herramienta de línea de comandos de BiblioTech" \
      org.opencontainers.image.vendor="Nexus Software"

# tzdata para las fechas; dumb-init para que Ctrl+C y SIGTERM lleguen al proceso
# (la cancelación limpia de 12-03 depende de esto).
# NO se instala curl: no hay healthcheck que hacer.
RUN apk add --no-cache tzdata dumb-init && rm -rf /var/cache/apk/*
ENV TZ=Europe/Madrid

RUN addgroup -S -g 1001 bibliotech && \
    adduser -S -u 1001 -G bibliotech -h /app bibliotech

WORKDIR /app

COPY --from=cds --chown=bibliotech:bibliotech /app/ ./

USER bibliotech

# Opciones ORIENTADAS AL ARRANQUE, no al rendimiento sostenido.
# El proceso vive segundos: compilar a fondo con C2 no se amortiza nunca.
#   TieredStopAtLevel=1    solo C1: compilación rápida y ligera
#   UseSerialGC            el GC más barato de inicializar (una sola tarea, poca memoria)
#   SharedArchiveFile      usa el CDS de la etapa 2
#   MaxRAMPercentage=75    consciente del cgroup, como siempre
ENV JAVA_OPTS="\
    -XX:TieredStopAtLevel=1 \
    -XX:+UseSerialGC \
    -XX:SharedArchiveFile=/app/cli.jsa \
    -XX:MaxRAMPercentage=75.0 \
    -Xshare:auto \
    -Dspring.main.banner-mode=off \
    -Dfile.encoding=UTF-8"

# SIN EXPOSE: la CLI no escucha en ningún puerto.
# SIN HEALTHCHECK: el proceso termina; no hay nada que vigilar.

ENTRYPOINT ["dumb-init", "--", "sh", "-c", \
            "exec java $JAVA_OPTS org.springframework.boot.loader.launch.JarLauncher \"$@\"", "--"]

# CMD son los argumentos POR DEFECTO, sustituibles al ejecutar
CMD ["--help"]

docker build -f Dockerfile.cli -t bibliotech-cli:1.4.2 .

docker run --rm bibliotech-cli:1.4.2 catalogo listar --formato=json
docker run --rm -e BIBLIOTECH_DB_URL=… bibliotech-cli:1.4.2 avisos enviar --dias-antelacion=3

# Comprobar el efecto del CDS
docker run --rm bibliotech-cli:1.4.2 --version   # ~1,1 s en lugar de ~2,6 s

apiVersion: batch/v1
kind: CronJob
metadata:
  name: bibliotech-avisos-diarios
  labels:
    app: bibliotech
    componente: tareas-programadas
spec:
  schedule: "0 8 * * 1-5"           # de lunes a viernes a las 8:00
  timeZone: "Europe/Madrid"         # Kubernetes 1.27+: fundamental con horario de verano

  concurrencyPolicy: Forbid         # si la anterior sigue corriendo, NO lanzar otra
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  startingDeadlineSeconds: 600      # si el clúster estaba caído, hay 10 min de margen

  jobTemplate:
    spec:
      backoffLimit: 2               # 2 reintentos ante fallo
      activeDeadlineSeconds: 900    # matar si supera 15 minutos
      ttlSecondsAfterFinished: 86400

      template:
        metadata:
          labels:
            app: bibliotech
            tarea: avisos
        spec:
          restartPolicy: OnFailure

          securityContext:
            runAsNonRoot: true
            runAsUser: 1001

          containers:
            - name: cli
              image: registro.nexussoftware.com/bibliotech-cli:1.4.2
              imagePullPolicy: IfNotPresent

              args:
                - "avisos"
                - "enviar"
                - "--dias-antelacion=3"
                - "--silencioso"       # sin decoración: la salida va al log

              envFrom:
                - configMapRef: { name: bibliotech-config }
                - secretRef:    { name: bibliotech-secretos }

              resources:
                requests: { memory: "256Mi", cpu: "100m" }
                limits:   { memory: "512Mi", cpu: "1000m" }

              securityContext:
                allowPrivilegeEscalation: false
                readOnlyRootFilesystem: true
                capabilities: { drop: ["ALL"] }

              volumeMounts:
                - name: tmp
                  mountPath: /tmp

          volumes:
            - name: tmp
              emptyDir: {}

kubectl get cronjob bibliotech-avisos-diarios
kubectl create job --from=cronjob/bibliotech-avisos-diarios prueba-manual   # ejecutar ya
kubectl logs job/prueba-manual

-- V9__partir_nombre_empleado_fase1.sql

ALTER TABLE empleado ADD COLUMN nombre_pila VARCHAR(80);
ALTER TABLE empleado ADD COLUMN apellidos   VARCHAR(120);

-- Poblar con una heurística conservadora:
-- la PRIMERA palabra es el nombre; el resto, los apellidos.
-- Es imperfecta para nombres compuestos ("José María"), y por eso
-- se conserva la columna original y se genera un informe de revisión.
UPDATE empleado
SET nombre_pila = split_part(trim(nombre), ' ', 1),
    apellidos   = NULLIF(trim(substring(trim(nombre) from position(' ' in trim(nombre)) + 1)), '')
WHERE nombre_pila IS NULL;

-- Caso especial: un solo término (sin espacios) → todo es nombre
UPDATE empleado
SET nombre_pila = trim(nombre), apellidos = NULL
WHERE position(' ' in trim(nombre)) = 0;

-- Trigger de sincronía bidireccional: da igual qué versión de la app escriba
CREATE OR REPLACE FUNCTION sincronizar_nombre_empleado() RETURNS TRIGGER AS $$
BEGIN
    IF TG_OP = 'INSERT' THEN
        IF NEW.nombre_pila IS NULL AND NEW.nombre IS NOT NULL THEN
            -- Escribió la app v1 (columna antigua): derivar las nuevas
            NEW.nombre_pila := split_part(trim(NEW.nombre), ' ', 1);
            NEW.apellidos   := NULLIF(trim(substring(trim(NEW.nombre)
                                    from position(' ' in trim(NEW.nombre)) + 1)), '');
        ELSIF NEW.nombre IS NULL AND NEW.nombre_pila IS NOT NULL THEN
            -- Escribió la app v2 (columnas nuevas): derivar la antigua
            NEW.nombre := trim(NEW.nombre_pila || ' ' || COALESCE(NEW.apellidos, ''));
        END IF;
    ELSIF TG_OP = 'UPDATE' THEN
        IF NEW.nombre IS DISTINCT FROM OLD.nombre THEN
            NEW.nombre_pila := split_part(trim(NEW.nombre), ' ', 1);
            NEW.apellidos   := NULLIF(trim(substring(trim(NEW.nombre)
                                    from position(' ' in trim(NEW.nombre)) + 1)), '');
        ELSIF NEW.nombre_pila IS DISTINCT FROM OLD.nombre_pila
           OR NEW.apellidos   IS DISTINCT FROM OLD.apellidos THEN
            NEW.nombre := trim(NEW.nombre_pila || ' ' || COALESCE(NEW.apellidos, ''));
        END IF;
    END IF;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER trg_sincronizar_nombre
    BEFORE INSERT OR UPDATE ON empleado
    FOR EACH ROW EXECUTE FUNCTION sincronizar_nombre_empleado();

-- Vista de revisión manual: los casos que la heurística probablemente falló
CREATE OR REPLACE VIEW v_empleados_revision_nombre AS
SELECT id, nombre, nombre_pila, apellidos,
       CASE
         WHEN nombre_pila IN ('José','Jose','María','Maria','Juan','Ana','Luis','Francisco')
              AND apellidos LIKE '% %'                    THEN 'posible nombre compuesto'
         WHEN apellidos ~ '^(de|del|la|las|los|van|von|di|da) ' THEN 'apellido con partícula'
         WHEN apellidos IS NULL                           THEN 'sin apellidos'
         ELSE 'revisar'
       END AS motivo
FROM empleado
WHERE nombre_pila IN ('José','Jose','María','Maria','Juan','Ana','Luis','Francisco')
   OR apellidos ~ '^(de|del|la|las|los|van|von|di|da) '
   OR apellidos IS NULL;

@Entity
public class Empleado {

    @Column(name = "nombre_pila", length = 80)
    private String nombrePila;

    @Column(name = "apellidos", length = 120)
    private String apellidos;

    /**
     * La columna antigua sigue existiendo y la mantiene el trigger.
     * insertable/updatable a false: JPA NUNCA la escribe.
     * Se conserva mapeada solo para poder leerla si hiciera falta.
     */
    @Column(name = "nombre", insertable = false, updatable = false)
    private String nombreCompletoHeredado;

    public String nombreCompleto() {
        return apellidos == null ? nombrePila : nombrePila + " " + apellidos;
    }
}

-- V11__partir_nombre_empleado_fase3.sql

-- Verificación previa: si algo quedó incoherente, ABORTAR
DO $$
DECLARE incoherentes INTEGER;
BEGIN
    SELECT count(*) INTO incoherentes
    FROM empleado
    WHERE nombre_pila IS NULL
       OR trim(nombre) IS DISTINCT FROM trim(nombre_pila || ' ' || COALESCE(apellidos, ''));

    IF incoherentes > 0 THEN
        RAISE EXCEPTION 'Hay % empleados con nombre incoherente. Revisa v_empleados_revision_nombre antes de contraer.', incoherentes;
    END IF;
END $$;

DROP TRIGGER IF EXISTS trg_sincronizar_nombre ON empleado;
DROP FUNCTION IF EXISTS sincronizar_nombre_empleado();
DROP VIEW IF EXISTS v_empleados_revision_nombre;

ALTER TABLE empleado ALTER COLUMN nombre_pila SET NOT NULL;
ALTER TABLE empleado DROP COLUMN nombre;

CREATE INDEX idx_empleado_apellidos ON empleado(apellidos, nombre_pila);

@Tag("integracion")
class MigracionNombreEmpleadoIT extends PruebaConPostgres {

    @Test
    void particionaCorrectamenteLosNombresConocidos() {
        // Estado inicial: hasta V8, con la columna antigua
        flywayHasta("8");
        jdbc.update("""
                insert into empleado (nombre, correo, fecha_alta) values
                    ('Marta Ruiz',              '[email protected]',  '2024-03-01'),
                    ('Diego Alonso',            '[email protected]',  '2025-01-15'),
                    ('Nuria Vidal',             '[email protected]',  '2023-09-10'),
                    ('José María Pérez Gómez',  '[email protected]',   '2022-05-20'),
                    ('Ana de la Torre',         '[email protected]',    '2021-11-02'),
                    ('Prince',                  '[email protected]', '2020-01-01')
                """);

        flywayHasta("9");     // aplicar la fase 1

        assertThat(consultar("[email protected]"))
                .containsExactly("Marta", "Ruiz");
        assertThat(consultar("[email protected]"))
                .containsExactly("Nuria", "Vidal");

        // Casos difíciles: la heurística los divide mal, y eso es ESPERADO
        assertThat(consultar("[email protected]"))
                .containsExactly("José", "María Pérez Gómez");     // requiere revisión manual
        assertThat(consultar("[email protected]"))
                .containsExactly("Ana", "de la Torre");

        // Un solo término
        assertThat(consultar("[email protected]"))
                .containsExactly("Prince", null);

        // Y todos aparecen en la vista de revisión, que es lo importante:
        // la migración no pretende acertar siempre, pretende NO PERDER DATOS
        // y señalar lo que hay que revisar.
        assertThat(jdbc.queryForList("select correo from v_empleados_revision_nombre", String.class))
                .contains("[email protected]", "[email protected]",
                          "[email protected]");
    }

    @Test
    void elTriggerSincronizaEnAmbasDirecciones() {
        flywayHasta("9");

        // La app v1 escribe la columna antigua
        jdbc.update("insert into empleado (nombre, correo, fecha_alta) values (?,?,?)",
                    "Carlos Sanz", "[email protected]", Date.valueOf("2026-01-01"));
        assertThat(consultar("[email protected]")).containsExactly("Carlos", "Sanz");

        // La app v2 escribe las columnas nuevas
        jdbc.update("""
                insert into empleado (nombre_pila, apellidos, correo, fecha_alta)
                values (?,?,?,?)""",
                "Elena", "Ferrer Rico", "[email protected]", Date.valueOf("2026-01-02"));
        assertThat(jdbc.queryForObject(
                "select nombre from empleado where correo = ?", String.class,
                "[email protected]"))
                .isEqualTo("Elena Ferrer Rico");
    }

    @Test
    void laFase3AbortaSiQuedanIncoherencias() {
        flywayHasta("9");
        // Provocar una incoherencia saltándose el trigger
        jdbc.update("alter table empleado disable trigger trg_sincronizar_nombre");
        jdbc.update("insert into empleado (nombre, correo, fecha_alta) values (?,?,?)",
                    "Sin Partir", "[email protected]", Date.valueOf("2026-01-03"));
        jdbc.update("alter table empleado enable trigger trg_sincronizar_nombre");

        assertThatThrownBy(() -> flywayHasta("11"))
                .hasMessageContaining("nombre incoherente");

        // Y lo más importante: la columna antigua SIGUE AHÍ. Nada se ha perdido.
        assertThat(existeColumna("empleado", "nombre")).isTrue();
    }
}

# k8s/azul-verde/service.yaml
# El Service apunta a UN color. Conmutar = cambiar el selector.
apiVersion: v1
kind: Service
metadata:
  name: bibliotech
  labels: { app: bibliotech }
spec:
  selector:
    app: bibliotech
    color: azul                  # ← esto es lo que cambia en la conmutación
  ports:
    - port: 80
      targetPort: 8080
---
# Service auxiliar para probar el color inactivo SIN tráfico real
apiVersion: v1
kind: Service
metadata:
  name: bibliotech-preview
spec:
  selector:
    app: bibliotech
    color: verde                 # se ajusta antes de las pruebas de humo
  ports:
    - port: 80
      targetPort: 8080
---
# k8s/azul-verde/deployment-plantilla.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: bibliotech-COLOR
  labels: { app: bibliotech, color: COLOR }
spec:
  replicas: 3
  selector:
    matchLabels: { app: bibliotech, color: COLOR }
  template:
    metadata:
      labels: { app: bibliotech, color: COLOR }
    spec:
      terminationGracePeriodSeconds: 60
      containers:
        - name: bibliotech
          image: IMAGEN
          ports: [{ name: http, containerPort: 8080 }]
          envFrom:
            - configMapRef: { name: bibliotech-config }
            - secretRef:    { name: bibliotech-secretos }
          resources:
            requests: { memory: "512Mi", cpu: "250m" }
            limits:   { memory: "768Mi", cpu: "1500m" }
          startupProbe:
            httpGet: { path: /actuator/health/liveness, port: http }
            failureThreshold: 20
            periodSeconds: 5
          readinessProbe:
            httpGet: { path: /actuator/health/readiness, port: http }
            periodSeconds: 5

# .github/workflows/cd-azul-verde.yml
name: Despliegue azul-verde

on:
  push:
    tags: ['v*']

env:
  NAMESPACE: produccion
  REGISTRO: ghcr.io
  IMAGEN: ${{ github.repository }}

jobs:

  # ---------------------------------------------------------------
  # 1. Determinar los colores
  # ---------------------------------------------------------------
  colores:
    runs-on: ubuntu-latest
    outputs:
      activo:   ${{ steps.detectar.outputs.activo }}
      inactivo: ${{ steps.detectar.outputs.inactivo }}
    steps:
      - name: Configurar kubectl
        uses: azure/k8s-set-context@v4
        with:
          kubeconfig: ${{ secrets.KUBECONFIG }}

      - name: Detectar el color activo
        id: detectar
        run: |
          ACTIVO=$(kubectl get service bibliotech -n $NAMESPACE \
                   -o jsonpath='{.spec.selector.color}')
          if [ "$ACTIVO" = "azul" ]; then INACTIVO="verde"; else INACTIVO="azul"; fi
          echo "activo=$ACTIVO"     >> $GITHUB_OUTPUT
          echo "inactivo=$INACTIVO" >> $GITHUB_OUTPUT
          echo "::notice::Activo: $ACTIVO — se desplegará en: $INACTIVO"

  # ---------------------------------------------------------------
  # 2. Desplegar en el color inactivo (sin tráfico)
  # ---------------------------------------------------------------
  desplegar-inactivo:
    runs-on: ubuntu-latest
    needs: colores
    steps:
      - uses: actions/checkout@v4
      - uses: azure/k8s-set-context@v4
        with: { kubeconfig: '${{ secrets.KUBECONFIG }}' }

      - name: Generar y aplicar el Deployment del color inactivo
        run: |
          COLOR=${{ needs.colores.outputs.inactivo }}
          IMG=${{ env.REGISTRO }}/${{ env.IMAGEN }}:${{ github.ref_name }}

          sed -e "s|COLOR|$COLOR|g" -e "s|IMAGEN|$IMG|g" \
              k8s/azul-verde/deployment-plantilla.yaml | kubectl apply -n $NAMESPACE -f -

          kubectl rollout status deployment/bibliotech-$COLOR -n $NAMESPACE --timeout=10m

      - name: Apuntar el Service de previsualización al color inactivo
        run: |
          kubectl patch service bibliotech-preview -n $NAMESPACE \
            -p '{"spec":{"selector":{"app":"bibliotech","color":"${{ needs.colores.outputs.inactivo }}"}}}'

  # ---------------------------------------------------------------
  # 3. Pruebas de humo contra el color inactivo
  # ---------------------------------------------------------------
  humo:
    runs-on: ubuntu-latest
    needs: [colores, desplegar-inactivo]
    steps:
      - uses: azure/k8s-set-context@v4
        with: { kubeconfig: '${{ secrets.KUBECONFIG }}' }

      - name: Ejecutar pruebas contra el color inactivo
        run: |
          kubectl port-forward service/bibliotech-preview 18080:80 -n $NAMESPACE &
          PF=$!
          sleep 8
          set -e

          BASE=http://localhost:18080

          echo "→ Salud"
          curl -fsS "$BASE/actuator/health/readiness" | jq -e '.status == "UP"'

          echo "→ Versión desplegada"
          VERSION=$(curl -fsS "$BASE/actuator/info" | jq -r '.build.version')
          test "v$VERSION" = "${{ github.ref_name }}" \
            || { echo "::error::Versión inesperada: $VERSION"; exit 1; }

          echo "→ Catálogo"
          curl -fsS "$BASE/api/materiales?size=1" | jq -e '.contenido | length >= 0'

          echo "→ Errores esperados (404 y 400)"
          test "$(curl -s -o /dev/null -w '%{http_code}' "$BASE/api/materiales/978-9999999999")" = "404"
          test "$(curl -s -o /dev/null -w '%{http_code}' "$BASE/api/materiales/no-isbn")" = "400"

          kill $PF
          echo "Pruebas de humo correctas"

  # ---------------------------------------------------------------
  # 4. Conmutar el tráfico (con aprobación manual)
  # ---------------------------------------------------------------
  conmutar:
    runs-on: ubuntu-latest
    needs: [colores, humo]
    environment:
      name: produccion            # con revisores obligatorios
      url: https://bibliotech.nexussoftware.com
    steps:
      - uses: azure/k8s-set-context@v4
        with: { kubeconfig: '${{ secrets.KUBECONFIG }}' }

      - name: Conmutar el Service al color nuevo
        run: |
          kubectl patch service bibliotech -n $NAMESPACE \
            -p '{"spec":{"selector":{"app":"bibliotech","color":"${{ needs.colores.outputs.inactivo }}"}}}'
          echo "::notice::Tráfico conmutado a ${{ needs.colores.outputs.inactivo }}"

  # ---------------------------------------------------------------
  # 5. Vigilar 5 minutos; volver atrás si la tasa de error sube
  # ---------------------------------------------------------------
  vigilar:
    runs-on: ubuntu-latest
    needs: [colores, conmutar]
    steps:
      - uses: azure/k8s-set-context@v4
        with: { kubeconfig: '${{ secrets.KUBECONFIG }}' }

      - name: Vigilar la tasa de errores durante 5 minutos
        id: vigilancia
        run: |
          BASE=https://bibliotech.nexussoftware.com
          UMBRAL_ERRORES=0.02          # 2 % de 5xx

          for i in $(seq 1 10); do
            sleep 30

            TOTAL=$(curl -fsS "$BASE/actuator/metrics/http.server.requests" \
                    | jq '.measurements[] | select(.statistic=="COUNT") | .value')
            ERRORES=$(curl -fsS "$BASE/actuator/metrics/http.server.requests?tag=outcome:SERVER_ERROR" \
                      | jq '.measurements[] | select(.statistic=="COUNT") | .value // 0')

            TASA=$(echo "scale=4; $ERRORES / ($TOTAL + 1)" | bc)
            echo "Comprobación $i/10 — total=$TOTAL errores=$ERRORES tasa=$TASA"

            if (( $(echo "$TASA > $UMBRAL_ERRORES" | bc -l) )); then
              echo "::error::Tasa de errores $TASA por encima del umbral $UMBRAL_ERRORES"
              exit 1
            fi

            if ! curl -fsS "$BASE/actuator/health/readiness" | jq -e '.status == "UP"' > /dev/null; then
              echo "::error::La sonda de disponibilidad falla"
              exit 1
            fi
          done
          echo "Vigilancia superada"

      - name: VUELTA ATRÁS automática
        if: failure()
        run: |
          echo "::warning::Volviendo al color ${{ needs.colores.outputs.activo }}"
          # La vuelta atrás es INSTANTÁNEA: el color anterior sigue encendido y sano
          kubectl patch service bibliotech -n $NAMESPACE \
            -p '{"spec":{"selector":{"app":"bibliotech","color":"${{ needs.colores.outputs.activo }}"}}}'

          curl -X POST "${{ secrets.WEBHOOK_EQUIPO }}" \
            -H 'Content-Type: application/json' \
            -d '{"texto":"🔴 BiblioTech ${{ github.ref_name }}: vuelta atrás automática a ${{ needs.colores.outputs.activo }}"}'
          exit 1

  # ---------------------------------------------------------------
  # 6. Retirar el color antiguo, una hora después
  # ---------------------------------------------------------------
  retirar-antiguo:
    runs-on: ubuntu-latest
    needs: [colores, vigilar]
    steps:
      - uses: azure/k8s-set-context@v4
        with: { kubeconfig: '${{ secrets.KUBECONFIG }}' }

      - name: Esperar una hora antes de retirar
        run: sleep 3600      # ventana de seguridad: vuelta atrás instantánea durante 1 hora

      - name: Reducir el color antiguo a cero réplicas
        run: |
          # No se BORRA el Deployment: se escala a 0.
          # Así el manifiesto se conserva y volver a levantarlo es un comando.
          kubectl scale deployment/bibliotech-${{ needs.colores.outputs.activo }} \
            --replicas=0 -n $NAMESPACE

          curl -X POST "${{ secrets.WEBHOOK_EQUIPO }}" \
            -H 'Content-Type: application/json' \
            -d '{"texto":"✅ BiblioTech ${{ github.ref_name }} estable. Color ${{ needs.colores.outputs.activo }} retirado."}'