$ sudo apt install btrfs-progs smartmontools

# 1. Revisar el estado de los discos ANTES de usarlos, incluso nuevos
$ sudo smartctl -a /dev/sda | grep -E 'Model|Power_On_Hours|Reallocated'
Device Model:     WDC WD80EFPX-68C4ZN0
  9 Power_On_Hours          0x0032   100   100   000    Old_age   Always  -  4
  5 Reallocated_Sector_Ct   0x0033   100   100   140    Pre-fail  Always  -  0

# 2. Crear el sistema de ficheros en RAID 1 (datos Y metadatos)
$ sudo mkfs.btrfs -L medios -d raid1 -m raid1 /dev/sda /dev/sdb
Label:              medios
UUID:               8f3a2c11-4d5e-4a91-b7c2-1e9d0f8a3b45
Number of devices:  2
Data,RAID1:  8.00TiB
Metadata,RAID1: 8.00GiB

# 3. Montar por UUID, nunca por /dev/sdX (05-04)
$ sudo mkdir -p /srv/medios
$ blkid /dev/sda | grep -oP 'UUID="\K[^"]+'
8f3a2c11-4d5e-4a91-b7c2-1e9d0f8a3b45

# /etc/fstab
# compress=zstd:3  -> comprime lo comprimible; el video ya comprimido lo
#                     detecta y lo salta, asi que no cuesta nada
# noatime          -> no escribir la fecha de acceso en cada lectura:
#                     menos escrituras y mas vida del disco
# nofail           -> SI EL DISCO NO ESTA, EL SISTEMA ARRANCA IGUAL.
#                     Sin esto, un disco desconectado deja el equipo en
#                     modo emergencia, sin red y sin SSH: hay que ir con
#                     teclado y monitor. En casa, imprescindible.
# x-systemd.device-timeout=10 -> no esperar 90 s a un disco ausente
UUID=8f3a2c11-4d5e-4a91-b7c2-1e9d0f8a3b45  /srv/medios  btrfs \
  defaults,compress=zstd:3,noatime,nofail,x-systemd.device-timeout=10  0  0

$ sudo mount -a          # SIEMPRE tras tocar fstab (convencion del curso)
$ findmnt /srv/medios
TARGET      SOURCE    FSTYPE OPTIONS
/srv/medios /dev/sda  btrfs  rw,noatime,compress=zstd:3,nofail

$ sudo btrfs filesystem usage /srv/medios
Overall:
    Device size:                  14.55TiB
    Device allocated:              2.02TiB
    Used:                          2.01TiB
    Free (estimated):              6.26TiB      (min: 6.26TiB)
Data,RAID1: Size:1.01TiB, Used:1.00TiB
   /dev/sda	 1.01TiB
   /dev/sdb	 1.01TiB

# Verifica TODOS los checksums y repara lo que pueda con la otra copia
$ sudo btrfs scrub start -B /srv/medios
scrub done for 8f3a2c11-4d5e-4a91-b7c2-1e9d0f8a3b45
	Total to scrub: 2.01TiB
	Rate: 178.42MiB/s
	Error summary: csum=2
	  Corrected: 2
	  Uncorrectable: 0

# /etc/systemd/system/btrfs-scrub.timer
[Unit]
Description=Barrido mensual de Btrfs en /srv/medios

[Timer]
OnCalendar=Sun *-*-01..07 03:00:00   # primer domingo de cada mes
Persistent=true
RandomizedDelaySec=1h

[Install]
WantedBy=timers.target

# /etc/systemd/system/btrfs-scrub.service
[Unit]
Description=Barrido de Btrfs

[Service]
Type=oneshot
ExecStart=/usr/bin/btrfs scrub start -B -c idle -n 5 /srv/medios
# -c idle -n 5: prioridad de E/S minima, para no molestar si alguien
# esta viendo una pelicula a las 3 de la manana
Nice=19
IOSchedulingClass=idle

$ sudo install -m 0755 -d /etc/apt/keyrings
$ curl -fsSL https://repo.jellyfin.org/jellyfin_team.gpg.key | \
      sudo gpg --dearmor -o /etc/apt/keyrings/jellyfin.gpg
$ sudo chmod 0644 /etc/apt/keyrings/jellyfin.gpg

$ cat <<EOF | sudo tee /etc/apt/sources.list.d/jellyfin.sources
Types: deb
URIs: https://repo.jellyfin.org/ubuntu
Suites: noble
Components: main
Architectures: amd64
Signed-By: /etc/apt/keyrings/jellyfin.gpg
EOF

$ sudo apt update && sudo apt install jellyfin
$ systemctl is-active jellyfin
active

$ gpg --show-keys /etc/apt/keyrings/jellyfin.gpg | head -2
pub   rsa4096 2018-11-08 [SC]
      04B7DA6B1FE10D5E76D9D5A6F5B2F0D5A8E5D6C3

$ sudo systemctl edit jellyfin

# /etc/systemd/system/jellyfin.service.d/override.conf
[Service]
# --- Aislamiento del sistema de ficheros ---
ProtectSystem=strict
ProtectHome=true
PrivateTmp=true
# Solo estas rutas son escribibles
ReadWritePaths=/var/lib/jellyfin /var/log/jellyfin /var/cache/jellyfin /etc/jellyfin
# La biblioteca, SOLO LECTURA: Jellyfin no tiene ninguna razon para
# poder borrar tus peliculas. Es la restriccion mas importante de todas.
ReadOnlyPaths=/srv/medios

# --- Privilegios ---
NoNewPrivileges=true
PrivateDevices=false            # false: necesita /dev/dri para la GPU
DeviceAllow=/dev/dri/renderD128 rw
DeviceAllow=/dev/dri/card0 rw
CapabilityBoundingSet=
AmbientCapabilities=
RestrictSUIDSGID=true

# --- Kernel y memoria ---
ProtectKernelTunables=true
ProtectKernelModules=true
ProtectKernelLogs=true
ProtectControlGroups=true
ProtectProc=invisible
MemoryDenyWriteExecute=false    # .NET usa compilacion JIT: no se puede
LockPersonality=true
RestrictRealtime=true
RestrictNamespaces=true

# --- Red ---
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6 AF_NETLINK
IPAddressAllow=localhost 192.168.1.0/24 10.8.0.0/24
IPAddressDeny=any

# --- Llamadas al sistema ---
SystemCallFilter=@system-service
SystemCallFilter=~@privileged @resources @obsolete
SystemCallArchitectures=native

# --- Limites de recursos (cgroups, 07-05) ---
# Evita que una transcodificacion descontrolada bloquee el equipo
CPUQuota=350%
MemoryMax=3G
IOWeight=50

$ sudo systemctl daemon-reload && sudo systemctl restart jellyfin
$ systemd-analyze security jellyfin
→ Overall exposure level for jellyfin.service: 2.4 OK

$ sudo -u jellyfin touch /srv/medios/prueba
touch: no se puede efectuar `touch' sobre '/srv/medios/prueba': Sistema de ficheros de sólo lectura

$ sudo apt install vainfo intel-media-va-driver-non-free

# 1. ¿Existe el dispositivo de renderizado?
$ ls -l /dev/dri/
crw-rw---- 1 root video  226,   0 ago 18 09:02 card0
crw-rw---- 1 root render 226, 128 ago 18 09:02 renderD128

# 2. ¿Qué sabe hacer?
$ vainfo --display drm --device /dev/dri/renderD128 2>/dev/null | \
      grep -E 'Driver version|VAProfileH264High|VAProfileHEVCMain|VAProfileAV1'
vainfo: Driver version: Intel iHD driver for Intel(R) Gen Graphics - 24.1.0
      VAProfileH264High               : VAEntrypointVLD        (decodifica)
      VAProfileH264High               : VAEntrypointEncSliceLP (codifica)
      VAProfileHEVCMain               : VAEntrypointVLD
      VAProfileHEVCMain10             : VAEntrypointVLD
      VAProfileAV1Profile0            : VAEntrypointVLD

$ sudo usermod -aG render,video jellyfin
$ id jellyfin
uid=996(jellyfin) gid=996(jellyfin) grupos=996(jellyfin),44(video),993(render)
$ sudo systemctl restart jellyfin

# Con una reproduccion en curso que este transcodificando
$ ps -eo pcpu,comm | grep ffmpeg
  6.2 ffmpeg

$ sudo intel_gpu_top -s 1000 | head -8
 Freq MHz    IRQ RC6     Power W        IMC MiB/s
 req  act        %       gpu   pkg     rd     wr
 850  842   1284  12    3.21  8.94   412.1  188.4

 ENGINES     BUSY                     MI_SEM MI_WAIT
 Render/3D   4.12% |█                |      0%      0%
 Video       78.44% |███████████████ |      0%      0%
 VideoEnhance 2.10% |                |      0%      0%

/srv/medios/
├── peliculas/
│   ├── El Verdugo (1963)/
│   │   ├── El Verdugo (1963) - 1080p.mkv
│   │   ├── El Verdugo (1963).es.srt
│   │   └── poster.jpg
│   └── Metropolis (1927)/
│       └── Metropolis (1927) - 1080p.mkv
├── series/
│   └── Nombre de la Serie (2019)/
│       ├── Season 01/
│       │   ├── Nombre de la Serie S01E01.mkv
│       │   └── Nombre de la Serie S01E02.mkv
│       └── Season 02/
│           └── Nombre de la Serie S02E01.mkv
├── musica/
│   └── Artista/
│       └── Album (2004)/
│           ├── 01 - Primera cancion.flac
│           └── 02 - Segunda cancion.flac
└── fotos/
    └── 2026/
        └── 2026-07 Vacaciones Pirineos/

# Ver que haria antes de hacerlo (convencion --dry-run del curso)
$ for f in /srv/medios/entrada/*.mkv; do
      nuevo="$(basename "$f" | sed -E 's/\.(1080p|720p|x264|WEB-DL)//gI; s/\./ /g')"
      printf '%s\n  -> %s\n' "$f" "$nuevo"
  done

$ sudo groupadd -f medios
$ sudo usermod -aG medios jellyfin
$ sudo usermod -aG medios "$USER"
$ sudo chown -R root:medios /srv/medios
$ sudo find /srv/medios -type d -exec chmod 2775 {} +   # SGID: hereda grupo
$ sudo find /srv/medios -type f -exec chmod 0664 {} +

# /etc/samba/smb.conf (tras copiar el original a .bak-2026-08-18)
[global]
    workgroup = CASA
    server string = Servidor de medios
    security = user
    map to guest = never                  # NADA de invitados

    # SMB1 esta roto por diseno (WannaCry se propago por ahi).
    # Minimo SMB2; SMB3 aporta cifrado.
    server min protocol = SMB2
    client min protocol = SMB2
    server smb encrypt = desired

    # Escuchar SOLO en la LAN y la VPN, nunca en todas las interfaces
    interfaces = 127.0.0.1 192.168.1.0/24 10.8.0.0/24
    bind interfaces only = yes
    hosts allow = 127.0.0.1 192.168.1.0/24 10.8.0.0/24
    hosts deny = 0.0.0.0/0

    # Sin impresoras: elimina superficie de ataque y ruido en el registro
    load printers = no
    printing = bsd
    printcap name = /dev/null
    disable spoolss = yes

    log level = 1
    log file = /var/log/samba/log.%m
    max log size = 1000

[medios]
    path = /srv/medios
    comment = Biblioteca familiar
    browseable = yes
    read only = yes                       # por defecto, SOLO LECTURA
    # Solo estos usuarios pueden escribir
    write list = @medios
    valid users = @medios
    create mask = 0664
    directory mask = 2775
    force group = medios
    vfs objects = recycle                 # papelera: salva de borrados
    recycle:repository = .papelera
    recycle:keeptree = yes
    recycle:versions = yes

[fotos]
    path = /srv/medios/fotos
    valid users = @medios
    read only = no
    create mask = 0664
    directory mask = 2775
    force group = medios

$ sudo apt install samba
$ testparm -s >/dev/null && echo "configuracion valida"   # el nginx -t de Samba
configuracion valida

# Los usuarios de Samba son INDEPENDIENTES de los del sistema, aunque
# el nombre coincida. Hay que crearlos explicitamente.
$ sudo smbpasswd -a marta
New SMB password: ********
$ sudo smbpasswd -e marta

$ sudo systemctl restart smbd nmbd
$ smbclient -L //192.168.1.20 -U marta
	Sharename       Type      Comment
	---------       ----      -------
	medios          Disk      Biblioteca familiar
	fotos           Disk

$ sudo apt install nfs-kernel-server
$ echo '/srv/medios 192.168.1.0/24(ro,sync,no_subtree_check,root_squash)' | \
      sudo tee -a /etc/exports
$ sudo exportfs -ra
$ sudo exportfs -v
/srv/medios   192.168.1.0/24(ro,sync,no_subtree_check,root_squash)

$ sudo ufw allow from 192.168.1.0/24 to any app Samba
$ sudo ufw allow from 192.168.1.0/24 to any port 8096 proto tcp comment 'Jellyfin'
$ sudo ufw allow from 192.168.1.0/24 to any port 2049 proto tcp comment 'NFS'
$ sudo ufw status | head -6
Estado: activo
Hasta                      Acción      Desde
-----                      ------      -----
Samba                      ALLOW       192.168.1.0/24
8096/tcp (Jellyfin)        ALLOW       192.168.1.0/24
2049/tcp (NFS)             ALLOW       192.168.1.0/24

# /etc/nginx/sites-available/jellyfin — solo si decides exponerlo
server {
    listen 443 ssl;
    http2 on;
    server_name medios.midominio.example;

    ssl_certificate     /etc/letsencrypt/live/medios.midominio.example/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/medios.midominio.example/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;

    add_header Strict-Transport-Security "max-age=63072000" always;
    add_header X-Content-Type-Options "nosniff" always;

    # Limite de tasa contra fuerza bruta sobre el formulario de acceso
    limit_req zone=login burst=5 nodelay;
    client_max_body_size 20M;

    location / {
        proxy_pass http://127.0.0.1:8096;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        # WebSocket: Jellyfin lo usa para el estado de reproduccion
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        # Sin buffering: es video en streaming
        proxy_buffering off;
    }
}

# ~/medios/compose.yml (fragmento ilustrativo)
services:
  sonarr:
    image: lscr.io/linuxserver/sonarr:latest
    environment:
      - PUID=1000
      - PGID=1002          # grupo medios
      - TZ=Europe/Madrid
    volumes:
      - ./sonarr-config:/config
      - /srv/medios/series:/series
    ports:
      - "127.0.0.1:8989:8989"   # SOLO localhost: se llega por VPN
    restart: unless-stopped

#!/usr/bin/env bash
#
# respaldo_casa.sh - Copias del servidor de medios domestico
#
# Estrategia:
#   - Insustituible (fotos, documentos) -> restic fuera de casa
#   - Configuracion de Jellyfin         -> restic, diario
#   - Peliculas y musica                -> instantanea Btrfs local
#
set -euo pipefail

readonly SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
source "${SCRIPT_DIR}/lib/comunes.sh"

readonly CASA_MEDIOS="${CASA_MEDIOS:-/srv/medios}"
readonly CASA_SNAP="${CASA_SNAP:-/srv/medios/.instantaneas}"
export RESTIC_REPOSITORY="${RESTIC_REPOSITORY:-b2:midominio-medios:/}"

umask 077

instantanea_local() {
    local nombre="${CASA_SNAP}/$(date +%F)"
    [[ -d "$nombre" ]] && { log "instantanea de hoy ya existe"; return 0; }
    # Instantanea de solo lectura: no ocupa espacio hasta que algo cambia
    btrfs subvolume snapshot -r "$CASA_MEDIOS" "$nombre" \
        || morir 73 "no se pudo crear la instantanea"
    log "instantanea creada: $nombre"

    # Retencion: conservar 7 diarias
    local sobrantes
    mapfile -t sobrantes < <(find "$CASA_SNAP" -maxdepth 1 -type d -name '20*' \
        | sort -r | tail -n +8)
    local s
    for s in "${sobrantes[@]:-}"; do
        [[ -n "$s" ]] || continue
        btrfs subvolume delete "$s" && log "instantanea antigua eliminada: $s"
    done
}

respaldo_externo() {
    requiere_comando restic
    RESTIC_PASSWORD="$(pass casa/restic)" \
    restic backup \
        "${CASA_MEDIOS}/fotos" \
        "${CASA_MEDIOS}/documentos" \
        /var/lib/jellyfin \
        /etc/jellyfin \
        --exclude-caches \
        --exclude '*/metadata/*' \
        --tag casa \
        || morir 74 "restic fallo"

    RESTIC_PASSWORD="$(pass casa/restic)" \
    restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune
}

verificar() {
    # Una copia no verificada no es una copia (05-08)
    RESTIC_PASSWORD="$(pass casa/restic)" \
    restic check --read-data-subset=2% || morir 74 "la verificacion de restic fallo"
    log "verificacion correcta"
}

main() {
    requiere_comando btrfs
    instantanea_local
    respaldo_externo
    verificar
    log "respaldo completado"
}

main "$@"

$ sudo btrfs subvolume list /srv/medios
ID 258 gen 4412 top level 5 path .instantaneas/2026-08-16
ID 259 gen 4488 top level 5 path .instantaneas/2026-08-17
ID 260 gen 4501 top level 5 path .instantaneas/2026-08-18

# Recuperar algo borrado por error: es una simple copia
$ sudo cp -a /srv/medios/.instantaneas/2026-08-17/fotos/2026-07 /srv/medios/fotos/

Coste anual = Potencia media (W) x 8760 h / 1000 x precio del kWh

$ sudo apt install powertop lm-sensors
$ sudo sensors-detect --auto >/dev/null

# Calibrar primero (tarda unos minutos y mide el consumo de cada estado)
$ sudo powertop --calibrate
$ sudo powertop --auto-tune       # aplica los ajustes recomendados

$ sudo powertop --time=60 --csv=/tmp/energia.csv >/dev/null
$ grep -A6 'Power est' /tmp/energia.csv | head -8
The battery reports a discharge rate of 12.4 W
Usage       Events/s   Category       Description
  6.2 ms/s     14.1     Proceso        ffmpeg
  1.1 ms/s      8.4     Proceso        jellyfin

# /etc/systemd/system/powertop.service
[Unit]
Description=Ajustes de ahorro energetico de PowerTOP
After=multi-user.target

[Service]
Type=oneshot
ExecStart=/usr/sbin/powertop --auto-tune
RemainAfterExit=true

[Install]
WantedBy=multi-user.target

$ sudo apt install hdparm

# -B 127: gestion de energia agresiva pero SIN aparcar el cabezal a cada
#         rato (los valores < 128 permiten parada; 254 la desactiva)
# -S 120: parar tras 120 x 5 s = 10 minutos de inactividad
$ sudo hdparm -B 127 -S 120 /dev/sda

# /etc/hdparm.conf — persistente entre reinicios
/dev/disk/by-id/ata-WDC_WD80EFPX-68C4ZN0_WD-CA0J1234 {
    apm = 127
    spindown_time = 120
}

$ sensors
coretemp-isa-0000
Package id 0:  +42.0°C  (high = +100.0°C, crit = +100.0°C)

$ sudo smartctl -A /dev/sda | grep -i temperature
194 Temperature_Celsius     0x0022   118   105   000    Old_age   Always  -  38

# ~/casa-infra/roles/medios/defaults/main.yml
---
medios_punto_montaje: /srv/medios
medios_uuid: 8f3a2c11-4d5e-4a91-b7c2-1e9d0f8a3b45
medios_grupo: medios
medios_gid: 1002
medios_red_lan: 192.168.1.0/24
medios_red_vpn: 10.8.0.0/24
medios_usuarios_samba: [marta, luis]
medios_acelerar_hw: true
medios_dispositivo_gpu: /dev/dri/renderD128
medios_hdparm_spindown: 120
medios_subdirectorios: [peliculas, series, musica, fotos, documentos]

# ~/casa-infra/roles/medios/tasks/main.yml
---
- name: Instalar paquetes base
  ansible.builtin.apt:
    name:
      - btrfs-progs
      - smartmontools
      - samba
      - hdparm
      - powertop
      - restic
    state: present
    update_cache: true
  tags: [paquetes]

- name: Paquetes de aceleracion por hardware
  ansible.builtin.apt:
    name: [vainfo, intel-media-va-driver-non-free]
    state: present
  when: medios_acelerar_hw | bool
  tags: [gpu]

- name: Clave del repositorio de Jellyfin en keyrings
  ansible.builtin.get_url:
    url: https://repo.jellyfin.org/jellyfin_team.gpg.key
    dest: /etc/apt/keyrings/jellyfin.asc
    mode: '0644'
  tags: [paquetes]

- name: Repositorio de Jellyfin
  ansible.builtin.deb822_repository:
    name: jellyfin
    types: deb
    uris: https://repo.jellyfin.org/ubuntu
    suites: "{{ ansible_distribution_release }}"
    components: main
    architectures: amd64
    signed_by: /etc/apt/keyrings/jellyfin.asc
  register: repo_jellyfin
  tags: [paquetes]

- name: Instalar Jellyfin
  ansible.builtin.apt:
    name: jellyfin
    state: present
    update_cache: "{{ repo_jellyfin.changed }}"
  tags: [paquetes]

# --- Almacenamiento ---
- name: Comprobar que el sistema de ficheros existe antes de montarlo
  ansible.builtin.command: "blkid -U {{ medios_uuid }}"
  register: blk
  changed_when: false
  failed_when: blk.rc != 0

- name: Montar la biblioteca por UUID con nofail
  ansible.posix.mount:
    path: "{{ medios_punto_montaje }}"
    src: "UUID={{ medios_uuid }}"
    fstype: btrfs
    opts: defaults,compress=zstd:3,noatime,nofail,x-systemd.device-timeout=10
    state: mounted

- name: Grupo de la biblioteca
  ansible.builtin.group:
    name: "{{ medios_grupo }}"
    gid: "{{ medios_gid }}"
    state: present

- name: Estructura de directorios con SGID
  ansible.builtin.file:
    path: "{{ medios_punto_montaje }}/{{ item }}"
    state: directory
    owner: root
    group: "{{ medios_grupo }}"
    mode: '2775'
  loop: "{{ medios_subdirectorios }}"

- name: Anadir jellyfin a los grupos necesarios
  ansible.builtin.user:
    name: jellyfin
    groups: "{{ [medios_grupo] + (['render', 'video'] if medios_acelerar_hw else []) }}"
    append: true
  notify: Reiniciar jellyfin

- name: Drop-in de endurecimiento de jellyfin
  ansible.builtin.template:
    src: jellyfin-override.conf.j2
    dest: /etc/systemd/system/jellyfin.service.d/override.conf
    owner: root
    group: root
    mode: '0644'
  notify:
    - Recargar systemd
    - Reiniciar jellyfin

- name: Configuracion de Samba
  ansible.builtin.template:
    src: smb.conf.j2
    dest: /etc/samba/smb.conf
    owner: root
    group: root
    mode: '0644'
    backup: true
    validate: 'testparm -s %s'    # el nginx -t de Samba (08-01)
  notify: Reiniciar samba

- name: Cortafuegos — solo LAN y VPN
  community.general.ufw:
    rule: allow
    src: "{{ item.0 }}"
    port: "{{ item.1 }}"
    proto: tcp
  loop: "{{ [medios_red_lan, medios_red_vpn] | product(['445', '8096']) | list }}"
  tags: [firewall]

- name: Timers de barrido, SMART y respaldo
  ansible.builtin.copy:
    src: "{{ item }}"
    dest: "/etc/systemd/system/{{ item }}"
    mode: '0644'
  loop:
    - btrfs-scrub.service
    - btrfs-scrub.timer
    - respaldo-casa.service
    - respaldo-casa.timer
  notify: Recargar systemd

- name: Activar los timers
  ansible.builtin.systemd:
    name: "{{ item }}"
    enabled: true
    state: started
    daemon_reload: true
  loop: [btrfs-scrub.timer, respaldo-casa.timer, smartd.service]

# --- Verificacion ---
- name: Verificar que la aceleracion por hardware es visible
  ansible.builtin.command: "vainfo --display drm --device {{ medios_dispositivo_gpu }}"
  register: va
  changed_when: false
  failed_when: "'VAProfileH264High' not in va.stdout"
  when: medios_acelerar_hw | bool
  tags: [verificar]

- name: Verificar que Jellyfin responde
  ansible.builtin.uri:
    url: "http://127.0.0.1:8096/health"
    status_code: 200
  retries: 5
  delay: 3
  tags: [verificar]

# Actualizaciones de seguridad desatendidas (06-06)
$ sudo apt install unattended-upgrades
$ sudo dpkg-reconfigure -plow unattended-upgrades

# /etc/apt/apt.conf.d/50unattended-upgrades
Unattended-Upgrade::Automatic-Reboot "true";
Unattended-Upgrade::Automatic-Reboot-Time "05:30";
Unattended-Upgrade::Automatic-Reboot-WithUsers "false";

$ sudo btrfs subvolume snapshot -r /var/lib/jellyfin \
      /srv/medios/.instantaneas/jellyfin-pre-$(date +%F)

$ sudo systemctl enable --now smartd

# Prueba corta semanal, larga mensual, y aviso por correo
$ sudo tee /etc/smartd.conf <<'EOF'
DEVICESCAN -a -o on -S on -n standby,q \
  -s (S/../.././02|L/../(01|15)/./03) \
  -W 4,45,50 \
  -m root -M exec /usr/share/smartmontools/smartd-runner
EOF
$ sudo systemctl restart smartd

$ sudo smartctl -A /dev/sda | \
      awk '$1 ~ /^(5|187|188|197|198)$/ {printf "%-28s %s\n", $2, $10}'
Reallocated_Sector_Ct        0
Reported_Uncorrect           0
Command_Timeout              0
Current_Pending_Sector       0
Offline_Uncorrectable        0

# El sintoma: errores en el journal
$ sudo journalctl -k --since today | grep -iE 'ata[0-9]|I/O error|medium error'
kernel: ata2.00: exception Emask 0x0 SAct 0x0 SErr 0x0 action 0x0
kernel: blk_update_request: I/O error, dev sdb, sector 1928374656

$ sudo btrfs device stats /srv/medios
[/dev/sda].write_io_errs    0
[/dev/sda].read_io_errs     0
[/dev/sda].corruption_errs  0
[/dev/sdb].write_io_errs    142
[/dev/sdb].read_io_errs     2891
[/dev/sdb].corruption_errs  18

# 1. NO desmontar ni apagar. Con RAID 1 el sistema sigue funcionando.
#    Primero, comprobar que hay copia de lo insustituible.
$ RESTIC_PASSWORD=$(pass casa/restic) restic snapshots --tag casa | tail -3

# 2. Si el disco AUN responde: reemplazo en caliente (lo ideal).
#    Btrfs copia del disco viejo lo que puede y del espejo lo que no.
$ sudo btrfs replace start -f /dev/sdb /dev/sdc /srv/medios
$ sudo btrfs replace status /srv/medios
0.8% done, 0 write errs, 0 uncorr. read errs

# 3. Si el disco YA NO responde: montar en modo degradado y anadir uno nuevo
$ sudo mount -o degraded,compress=zstd:3 UUID=8f3a2c11-... /srv/medios
$ sudo btrfs device add /dev/sdc /srv/medios
$ sudo btrfs device remove missing /srv/medios
$ sudo btrfs balance start -dconvert=raid1 -mconvert=raid1 /srv/medios

# 4. Verificar que se ha restablecido la redundancia
$ sudo btrfs filesystem df /srv/medios
Data, RAID1: total=1.01TiB, used=1.00TiB
Metadata, RAID1: total=8.00GiB, used=6.12GiB

# 5. Barrido completo para confirmar que todo esta integro
$ sudo btrfs scrub start -B /srv/medios

# 1. ¿Esta transcodificando? El panel de Jellyfin lo dice, y tambien esto:
$ ps -eo pid,pcpu,args | grep '[f]fmpeg' | head -1
  8814 191.2 /usr/lib/jellyfin-ffmpeg/ffmpeg -i /srv/medios/peliculas/...
    -c:v libx264 -preset veryfast -b:v 3000000 ...

# 2. ¿Por que transcodifica? Analizar el fichero
$ ffprobe -v error -show_entries stream=index,codec_type,codec_name,width,height,channels \
      -of csv=p=0 "/srv/medios/peliculas/Pelicula (2019)/Pelicula (2019).mkv"
0,video,hevc,3840,2160
1,audio,dts,8
2,subtitle,hdmv_pgs_subtitle

# 3. ¿Que soporta el televisor? En el registro de Jellyfin, tras reproducir:
$ sudo journalctl -u jellyfin --since "10 min ago" | grep -i 'transcod\|reason'
[INF] Transcoding reason: VideoCodecNotSupported, AudioCodecNotSupported,
      SubtitleCodecNotSupported

# 4. ¿Es la red? Wi-Fi del salon frente a cable
$ iperf3 -c 192.168.1.45 -t 10 -R
[  5]   0.00-10.00  sec  58.2 MBytes  48.8 Mbits/sec

# --- MEDIDA 1: activar la aceleracion por hardware (impacto inmediato) ---
$ vainfo --display drm --device /dev/dri/renderD128 | grep -c EncSlice
6
$ sudo usermod -aG render,video jellyfin
$ sudo systemctl restart jellyfin
# Y en el panel: Reproduccion > VAAPI, /dev/dri/renderD128,
# marcando HEVC, HEVC 10 bits, VP9 y "codificacion HEVC"

# Verificar el efecto
$ ps -eo pcpu,args | grep '[f]fmpeg' | awk '{print $1}'
5.8
$ sudo intel_gpu_top -s 1000 | grep Video
 Video      74.12% |██████████████   |

# --- MEDIDA 2: extraer los subtitulos a fichero externo ---
# Los PGS graficos fuerzan la transcodificacion de VIDEO aunque el
# codec sea compatible: hay que "quemarlos" sobre la imagen. Los .srt
# se envian aparte y el cliente los dibuja.
$ ffmpeg -i "Pelicula (2019).mkv" -map 0:s:0 -c:s srt "Pelicula (2019).es.srt"

# --- MEDIDA 3: convertir solo el audio problematico, sin tocar el video ---
# -c:v copy no recodifica el video: son segundos, no horas, y sin
# ninguna perdida de calidad de imagen.
$ ffmpeg -i entrada.mkv -c:v copy -c:s copy \
      -c:a ac3 -b:a 640k -ac 6 salida.mkv

# --- MEDIDA 4: cable Ethernet o PLC hasta el salon ---
$ iperf3 -c 192.168.1.45 -t 10 -R
[  5]   0.00-10.00  sec  1.09 GBytes  938 Mbits/sec

NIVEL 1 - Insustituible (402 GB): fotos, documentos, configuracion
  Copia 1: Btrfs RAID 1 local (el original)
  Copia 2: disco externo USB cifrado, mensual, en un cajon
  Copia 3: restic en la nube, diaria, cifrada de extremo a extremo
  -> 3 copias, 2 medios, 1 fuera de casa. 3-2-1 completo.

NIVEL 2 - Recuperable con esfuerzo (800 GB): musica
  Copia 1: Btrfs RAID 1 local
  Copia 2: el mismo disco externo USB, mensual
  -> Sin copia en la nube: 800 GB al mes no compensan 40 h de trabajo.

NIVEL 3 - Recuperable (4,8 TB): peliculas
  Copia 1: Btrfs RAID 1 local
  Copia 2: los discos originales en la estanteria (ya la tienes)
  -> Sin copia adicional. El RAID cubre el fallo de un disco y los
     originales cubren el resto.

# --- Nivel 1: restic en la nube, diario ---
$ export RESTIC_REPOSITORY="b2:midominio-medios:/"
$ restic init                    # una sola vez

# La frase de paso, en pass (06-05). Si se pierde, la copia es
# ILEGIBLE: no hay recuperacion posible. Va tambien en papel, en casa
# de un familiar, dentro de un sobre cerrado.
$ pass generate casa/restic 40

# --- Nivel 1 y 2: disco externo USB cifrado, mensual ---
# LUKS (06-05): si pierdes el disco, los datos no son legibles
$ sudo cryptsetup luksFormat /dev/sdd1
$ sudo cryptsetup open /dev/sdd1 respaldo-externo
$ sudo mkfs.btrfs -L respaldo /dev/mapper/respaldo-externo

# Copia mensual. --delete se usa CON CUIDADO: si el origen esta
# desmontado, rsync borraria el destino entero. La comprobacion previa
# no es opcional.
$ mountpoint -q /srv/medios || { echo "origen no montado; abortando"; exit 1; }
$ sudo rsync -aHAX --delete --info=progress2 \
      /srv/medios/{fotos,documentos,musica}/ /mnt/respaldo/
$ sudo umount /mnt/respaldo && sudo cryptsetup close respaldo-externo

# Automatico, semanal
$ restic check --read-data-subset=5%

# Manual, trimestral: restaurar de verdad un fichero y ABRIRLO
$ restic restore latest --include '/srv/medios/fotos/2019' --target /tmp/prueba
$ sha256sum /tmp/prueba/srv/medios/fotos/2019/IMG_4412.jpg \
            /srv/medios/fotos/2019/IMG_4412.jpg
a3f1...  /tmp/prueba/srv/medios/fotos/2019/IMG_4412.jpg
a3f1...  /srv/medios/fotos/2019/IMG_4412.jpg

#!/usr/bin/env bash
#
# revision_casa.sh - Revision de salud del servidor de medios domestico
#
# Codigos de salida:
#   0 = correcto   1 = aviso   2 = critico
#
# Pensado para ejecutarse desde un timer diario, con silencio si todo
# va bien: solo un estado != 0 produce notificacion.
#
set -euo pipefail

readonly SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
source "${SCRIPT_DIR}/lib/comunes.sh"

readonly CASA_MEDIOS="${CASA_MEDIOS:-/srv/medios}"
readonly CASA_DISCOS="${CASA_DISCOS:-/dev/sda /dev/sdb}"
readonly CASA_UMBRAL_ESPACIO="${CASA_UMBRAL_ESPACIO:-85}"
readonly CASA_UMBRAL_TEMP="${CASA_UMBRAL_TEMP:-45}"
readonly CASA_UMBRAL_COPIA_H="${CASA_UMBRAL_COPIA_H:-36}"
readonly CASA_UMBRAL_SCRUB_D="${CASA_UMBRAL_SCRUB_D:-45}"

umask 027
estado_global=0

registrar() {
    local nivel="$1" msg="$2"
    case "$nivel" in
        ok)      log "OK      $msg" ;;
        aviso)   error "AVISO   $msg"; (( estado_global < 1 )) && estado_global=1 ;;
        critico) error "CRITICO $msg"; estado_global=2 ;;
    esac
    return 0
}

comprobar_montaje() {
    if ! mountpoint -q "$CASA_MEDIOS"; then
        registrar critico "$CASA_MEDIOS NO esta montado"
        return 0
    fi
    registrar ok "biblioteca montada"

    # Con 'nofail', un disco ausente NO impide arrancar: hay que
    # comprobar explicitamente que estan los dos dispositivos.
    local n
    n="$(btrfs filesystem show "$CASA_MEDIOS" | grep -c '^\s*devid')"
    if (( n < 2 )); then
        registrar critico "solo $n dispositivo(s): el RAID 1 esta DEGRADADO"
    else
        registrar ok "RAID 1 con $n dispositivos"
    fi
}

comprobar_espacio() {
    mountpoint -q "$CASA_MEDIOS" || return 0
    # 'df' miente con Btrfs en RAID: se usa la salida propia de btrfs
    local libre_b total_b usado_pct
    libre_b="$(btrfs filesystem usage -b "$CASA_MEDIOS" | \
        awk '/Free \(estimated\)/{gsub(/[^0-9]/,"",$3); print $3}')"
    total_b="$(btrfs filesystem usage -b "$CASA_MEDIOS" | \
        awk '/Device size/{gsub(/[^0-9]/,"",$3); print $3/2}')"
    usado_pct=$(( 100 - (libre_b * 100 / total_b) ))

    if (( usado_pct >= 95 )); then
        registrar critico "biblioteca al ${usado_pct}% ($(formatear_bytes "$libre_b") libres)"
    elif (( usado_pct >= CASA_UMBRAL_ESPACIO )); then
        registrar aviso "biblioteca al ${usado_pct}%"
    else
        registrar ok "espacio al ${usado_pct}% ($(formatear_bytes "$libre_b") libres)"
    fi
}

comprobar_errores_btrfs() {
    mountpoint -q "$CASA_MEDIOS" || return 0
    local total
    total="$(btrfs device stats "$CASA_MEDIOS" | awk '{s+=$2} END {print s+0}')"
    if (( total > 0 )); then
        registrar critico "btrfs acumula $total errores de E/S o corrupcion"
        btrfs device stats "$CASA_MEDIOS" | awk '$2>0 {print "         " $0}' >&2
    else
        registrar ok "sin errores de E/S ni corrupcion"
    fi
}

comprobar_scrub() {
    mountpoint -q "$CASA_MEDIOS" || return 0
    local fecha dias
    fecha="$(btrfs scrub status "$CASA_MEDIOS" | \
        awk -F': ' '/Scrub started/{print $2}')" || true
    if [[ -z "${fecha:-}" ]]; then
        registrar aviso "no consta ningun barrido ejecutado"
        return 0
    fi
    dias=$(( ( $(date +%s) - $(date -d "$fecha" +%s) ) / 86400 ))
    if (( dias > CASA_UMBRAL_SCRUB_D )); then
        registrar aviso "ultimo barrido hace $dias dias"
    else
        registrar ok "ultimo barrido hace $dias dias"
    fi
}

comprobar_discos() {
    requiere_comando smartctl
    local d
    for d in $CASA_DISCOS; do
        [[ -b "$d" ]] || { registrar critico "$d no existe"; continue; }

        # -n standby: NO despertar un disco parado solo para mirarlo
        local salida
        salida="$(smartctl -A -H -n standby "$d" 2>/dev/null)" || true
        if grep -q 'STANDBY' <<<"$salida"; then
            registrar ok "$d en reposo (no se despierta)"
            continue
        fi

        # Los atributos que predicen fallos, no el veredicto global
        local realoc pendientes ilegibles temp
        realoc="$(awk '$1==5   {print $10+0}' <<<"$salida")"
        pendientes="$(awk '$1==197 {print $10+0}' <<<"$salida")"
        ilegibles="$(awk '$1==198 {print $10+0}' <<<"$salida")"
        temp="$(awk '$1==194 {print $10+0}' <<<"$salida")"

        if (( ${ilegibles:-0} > 0 || ${pendientes:-0} > 0 )); then
            registrar critico "$d: $pendientes pendientes, $ilegibles ilegibles: SUSTITUIR"
        elif (( ${realoc:-0} > 0 )); then
            registrar aviso "$d: $realoc sectores reasignados: vigilar"
        else
            registrar ok "$d sin sectores dañados"
        fi

        if (( ${temp:-0} >= 50 )); then
            registrar critico "$d a ${temp}C"
        elif (( ${temp:-0} >= CASA_UMBRAL_TEMP )); then
            registrar aviso "$d a ${temp}C (ideal < 45)"
        fi
    done
}

comprobar_servicios() {
    local s
    for s in jellyfin smbd smartd; do
        systemctl is-active --quiet "$s" \
            && registrar ok "$s activo" \
            || registrar critico "$s NO esta activo"
    done

    # Que responda, no solo que el proceso exista
    if curl -sf -m 5 -o /dev/null http://127.0.0.1:8096/health; then
        registrar ok "jellyfin responde"
    else
        registrar critico "jellyfin no responde en 8096"
    fi
}

comprobar_copias() {
    local marca=/var/lib/respaldo-casa/ultima-correcta
    if [[ ! -f "$marca" ]]; then
        registrar critico "no hay constancia de ninguna copia correcta"
        return 0
    fi
    local horas
    horas=$(( ( $(date +%s) - $(stat -c %Y "$marca") ) / 3600 ))
    if (( horas > CASA_UMBRAL_COPIA_H * 2 )); then
        registrar critico "ultima copia correcta hace ${horas} h"
    elif (( horas > CASA_UMBRAL_COPIA_H )); then
        registrar aviso "ultima copia correcta hace ${horas} h"
    else
        registrar ok "ultima copia correcta hace ${horas} h"
    fi
}

comprobar_aceleracion() {
    [[ -e /dev/dri/renderD128 ]] || { registrar aviso "sin GPU accesible"; return 0; }
    if vainfo --display drm --device /dev/dri/renderD128 2>/dev/null | \
            grep -q VAEntrypointEncSlice; then
        registrar ok "aceleracion por hardware disponible"
    else
        registrar aviso "la GPU no expone codificacion por hardware"
    fi
}

main() {
    requiere_comando btrfs
    requiere_comando curl

    comprobar_montaje
    comprobar_espacio
    comprobar_errores_btrfs
    comprobar_scrub
    comprobar_discos
    comprobar_servicios
    comprobar_copias
    comprobar_aceleracion

    case "$estado_global" in
        0) log "servidor de medios correcto" ;;
        1) error "revision con AVISOS" ;;
        2) error "revision en estado CRITICO" ;;
    esac
    return "$estado_global"
}

main "$@"

$ shellcheck ~/scripts/revision_casa.sh && echo "sin avisos"
sin avisos

$ ~/scripts/revision_casa.sh; echo "estado: $?"
[2026-08-18 08:00:03] OK      biblioteca montada
[2026-08-18 08:00:03] OK      RAID 1 con 2 dispositivos
[2026-08-18 08:00:03] OK      espacio al 28% (6,3 TiB libres)
[2026-08-18 08:00:04] OK      sin errores de E/S ni corrupcion
[2026-08-18 08:00:04] OK      ultimo barrido hace 12 dias
[2026-08-18 08:00:04] OK      /dev/sda en reposo (no se despierta)
[2026-08-18 08:00:04] OK      /dev/sdb en reposo (no se despierta)
[2026-08-18 08:00:05] OK      jellyfin activo
[2026-08-18 08:00:05] OK      smbd activo
[2026-08-18 08:00:05] OK      smartd activo
[2026-08-18 08:00:05] OK      jellyfin responde
[2026-08-18 08:00:05] OK      ultima copia correcta hace 6 h
[2026-08-18 08:00:06] OK      aceleracion por hardware disponible
[2026-08-18 08:00:06] servidor de medios correcto
estado: 0

# /etc/systemd/system/revision-casa.timer
[Unit]
Description=Revision diaria del servidor de medios

[Timer]
OnCalendar=*-*-* 08:00:00
Persistent=true

[Install]
WantedBy=timers.target

# /etc/systemd/system/revision-casa.service
[Unit]
Description=Revision de salud del servidor de medios
# Notificar SOLO si falla: silencio si todo va bien
OnFailure=notificar-casa@%n.service

[Service]
Type=oneshot
User=operador
ExecStart=/home/operador/scripts/revision_casa.sh