# Ejecutar Dragonfly con Docker
docker run -d \
    --name dragonfly \
    -p 6379:6379 \
    -v dragonfly_data:/data \
    --ulimit memlock=-1 \
    --restart unless-stopped \
    docker.dragonflydb.io/dragonflydb/dragonfly:latest

# Verificar que responde
docker exec dragonfly redis-cli ping
# Respuesta: PONG

# Ver versión y estadísticas
docker exec dragonfly redis-cli info server | grep -E "version|hz|threads"

# Descargar el binario más reciente para Linux amd64
DRAGONFLY_VERSION=$(curl -s https://api.github.com/repos/dragonflydb/dragonfly/releases/latest \
    | grep tag_name | cut -d '"' -f 4)

curl -L "https://github.com/dragonflydb/dragonfly/releases/download/${DRAGONFLY_VERSION}/dragonfly-x86_64.tar.gz" \
    -o dragonfly.tar.gz

tar -xzf dragonfly.tar.gz
sudo mv dragonfly-x86_64 /usr/local/bin/dragonfly
sudo chmod +x /usr/local/bin/dragonfly

# Verificar la instalación
dragonfly --version

# Crear usuario del sistema
sudo useradd -r -s /bin/false dragonfly
sudo mkdir -p /var/lib/dragonfly /var/log/dragonfly
sudo chown dragonfly:dragonfly /var/lib/dragonfly /var/log/dragonfly

# Crear archivo de configuración
sudo cat > /etc/dragonfly/dragonfly.conf << 'EOF'
# Configuración de Dragonfly
--bind=127.0.0.1
--port=6379
--requirepass=contraseña_segura
--dir=/var/lib/dragonfly
--dbfilename=dump.rdb
--logfile=/var/log/dragonfly/dragonfly.log
--maxmemory=2gb
--maxmemory_policy=allkeys-lru
EOF

sudo mkdir -p /etc/dragonfly
sudo chown dragonfly:dragonfly /etc/dragonfly/dragonfly.conf

# Crear servicio systemd
sudo cat > /etc/systemd/system/dragonfly.service << 'EOF'
[Unit]
Description=Dragonfly In-Memory Data Store
After=network.target

[Service]
Type=simple
User=dragonfly
Group=dragonfly
WorkingDirectory=/var/lib/dragonfly
ExecStart=/usr/local/bin/dragonfly --flagfile=/etc/dragonfly/dragonfly.conf
Restart=always
RestartSec=5

# Límites del sistema para alto rendimiento
LimitNOFILE=65535
LimitMEMLOCK=infinity

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable dragonfly
sudo systemctl start dragonfly
sudo systemctl status dragonfly

sudo cat > /etc/dragonfly/dragonfly.conf << 'EOF'
# ================================================================
# Configuración de Dragonfly para producción
# ================================================================

# ---- RED ----
--bind=127.0.0.1
--port=6379

# Puerto adicional para Memcached (compatibilidad)
--memcache_port=11211

# Contraseña de acceso
--requirepass=contraseña_muy_segura

# ---- ALMACENAMIENTO ----
--dir=/var/lib/dragonfly
--dbfilename=dump.rdb

# Intervalo de guardado automático (segundos)
--save_schedule=0 * * * *  # Cada hora

# ---- MEMORIA ----
--maxmemory=4gb
--maxmemory_policy=allkeys-lru

# ---- RENDIMIENTO ----
# Número de hilos (0 = automático, usa todos los núcleos)
--num_shards=0

# Habilitar io_uring para mejor rendimiento en kernel 5.1+
--force_epoll=false

# Tamaño del pipeline de comandos
--pipeline_squash=true

# ---- LOGS ----
--logfile=/var/log/dragonfly/dragonfly.log
--logtostderr=false
--alsologtostderr=false

EOF

sudo systemctl restart dragonfly

# Verificar configuración activa
redis-cli -h 127.0.0.1 -p 6379 -a "contraseña_muy_segura" info all | grep -E "maxmemory|threads|version"

# Conectar con redis-cli estándar
redis-cli -p 6379 -a "contraseña_muy_segura"

# Comandos básicos
SET clave "valor"
GET clave

# Hashes
HSET usuario:1 nombre "María López" email "[email protected]" rol "admin"
HGETALL usuario:1
HINCRBY usuario:1 visitas 1

# Listas
RPUSH cola:emails "[email protected]" "[email protected]"
BLPOP cola:emails 0  # Bloquear hasta que haya un elemento

# Sets con puntuación (Sorted Sets)
ZADD articulos:populares 1520 "como-instalar-nginx" 890 "vps-guia" 2100 "docker-tutorial"
ZREVRANGEBYSCORE articulos:populares +inf -inf WITHSCORES LIMIT 0 5

# Streams (Redis 5.0 compatible)
XADD metricas:servidor * cpu 45 memoria 62 disco 78
XREAD COUNT 10 STREAMS metricas:servidor 0

# Lua scripting
redis-cli -p 6379 -a "contraseña" EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 mi:clave mi:valor

# Pub/Sub
redis-cli -p 6379 -a "contraseña" SUBSCRIBE canal:alertas &
redis-cli -p 6379 -a "contraseña" PUBLISH canal:alertas "Servidor caído"

# Conectar al puerto Memcached de Dragonfly
# Instalar cliente memcached-cli para pruebas
sudo apt-get install -y libmemcached-tools

# Operaciones básicas via protocolo Memcached
memcstat --servers=127.0.0.1:11211
memccp --servers=127.0.0.1:11211 /tmp/archivo-a-cachear

# Via telnet para pruebas rápidas
echo -e "set mi_clave 0 60 5\r\nhola!\r\nquit" | nc 127.0.0.1 11211
echo -e "get mi_clave\r\nquit" | nc 127.0.0.1 11211

# Ver información de la arquitectura
redis-cli -p 6379 -a "contraseña" info server | grep -E "threads|shards"

# Verificar el uso de CPU por hilo (todos deben estar ocupados bajo carga)
top -H -p $(pgrep dragonfly)

# El número de shards (particiones internas) determina el paralelismo
# Por defecto: un shard por núcleo de CPU

# Verificar la distribución de claves entre shards
redis-cli -p 6379 -a "contraseña" debug shard-count

# Configurar manualmente el número de shards (para testing)
# En producción, dejar en 0 para autodetección
# --num_shards=8  # Para servidor de 8 núcleos

# Instalar herramienta de benchmark
sudo apt-get install -y redis-tools

# Benchmark básico con 100.000 operaciones
redis-benchmark -p 6379 -a "contraseña" -n 100000 -q

# Benchmark de alto rendimiento con pipeline
redis-benchmark \
    -p 6379 \
    -a "contraseña" \
    -t set,get \
    -n 10000000 \
    -c 200 \
    -P 50 \
    --threads 8

# Comparar con Redis si está disponible:
# redis-benchmark -p 6380 -n 10000000 -c 200 -P 50 --threads 8

# Ver uso actual de memoria
redis-cli -p 6379 -a "contraseña" info memory

# Campos importantes:
# used_memory_human: memoria usada por datos
# used_memory_rss_human: memoria real del proceso
# maxmemory_human: límite configurado
# mem_fragmentation_ratio: ratio de fragmentación (ideal: 1.0-1.5)

# Configurar política de evicción
redis-cli -p 6379 -a "contraseña" config set maxmemory-policy allkeys-lru

# Políticas disponibles:
# noeviction: no eliminar datos (devuelve error si hay OOM)
# allkeys-lru: eliminar cualquier clave por LRU (más común)
# volatile-lru: solo eliminar claves con TTL por LRU
# allkeys-lfu: eliminar por frecuencia de uso (LFU)
# allkeys-random: eliminar aleatoriamente

# Ver estadísticas de evicción
redis-cli -p 6379 -a "contraseña" info stats | grep evicted

# Configurar alertas de memoria
cat > /usr/local/bin/check-dragonfly-memory.sh << 'EOF'
#!/bin/bash
# Monitorizar uso de memoria de Dragonfly

MAX_PORCENTAJE=90
REDIS_PASS="contraseña"

# Obtener uso de memoria en porcentaje
MEMORIA_INFO=$(redis-cli -p 6379 -a "$REDIS_PASS" info memory)
USADO=$(echo "$MEMORIA_INFO" | grep "used_memory:" | cut -d: -f2 | tr -d '[:space:]')
MAXIMO=$(redis-cli -p 6379 -a "$REDIS_PASS" config get maxmemory | tail -1)

if [ "$MAXIMO" -gt 0 ]; then
    PORCENTAJE=$((USADO * 100 / MAXIMO))
    
    if [ "$PORCENTAJE" -gt "$MAX_PORCENTAJE" ]; then
        echo "ALERTA: Dragonfly al ${PORCENTAJE}% de memoria ($USADO / $MAXIMO bytes)"
        # Enviar alerta al sistema de monitorización
    fi
fi
EOF

chmod +x /usr/local/bin/check-dragonfly-memory.sh

# Script de benchmark comparativo
cat > /usr/local/bin/benchmark-dragonfly.sh << 'EOF'
#!/bin/bash
# Benchmark comparativo Dragonfly vs Redis

OPERACIONES=1000000
CONCURRENCIA=100
PIPELINE=32

echo "=== Benchmark de Dragonfly (puerto 6379) ==="
redis-benchmark \
    -p 6379 \
    -a "contraseña" \
    -t set,get,incr,hset,sadd \
    -n $OPERACIONES \
    -c $CONCURRENCIA \
    -P $PIPELINE \
    -q

echo ""
echo "=== Benchmark de Redis (puerto 6380, si disponible) ==="
redis-benchmark \
    -p 6380 \
    -t set,get,incr,hset,sadd \
    -n $OPERACIONES \
    -c $CONCURRENCIA \
    -P $PIPELINE \
    -q 2>/dev/null || echo "Redis no disponible en puerto 6380"
EOF

chmod +x /usr/local/bin/benchmark-dragonfly.sh
bash /usr/local/bin/benchmark-dragonfly.sh

# OPCIÓN 1: Migración directa con DUMP/RESTORE (sin tiempo de inactividad breve)
# Instalar redis-dump
npm install -g redis-dump

# Exportar datos de Redis
redis-dump -h redis-host -p 6379 -a "redis-pass" > /tmp/redis-backup.json

# Importar en Dragonfly
cat /tmp/redis-backup.json | redis-load -h 127.0.0.1 -p 6379 -a "dragonfly-pass"

# OPCIÓN 2: Replicación temporal
# Configurar Dragonfly como réplica de Redis existente
redis-cli -p 6379 -a "dragonfly-pass" replicaof redis-original 6379

# Verificar sincronización
redis-cli -p 6379 -a "dragonfly-pass" info replication

# Cuando esté sincronizado, promover a primario
redis-cli -p 6379 -a "dragonfly-pass" replicaof no one

# OPCIÓN 3: RDB snapshot
# En Redis original:
redis-cli -h redis-host bgsave
# Esperar a que termine:
redis-cli -h redis-host lastsave

# Copiar el dump.rdb
scp redis-host:/var/lib/redis/dump.rdb /var/lib/dragonfly/dump.rdb
sudo chown dragonfly:dragonfly /var/lib/dragonfly/dump.rdb
sudo systemctl restart dragonfly

# Verificar datos
redis-cli -p 6379 -a "dragonfly-pass" dbsize
redis-cli -p 6379 -a "dragonfly-pass" info keyspace

# Dragonfly requiere memlock ilimitado
sudo cat >> /etc/security/limits.d/dragonfly.conf << 'EOF'
dragonfly soft memlock unlimited
dragonfly hard memlock unlimited
EOF

# O configurar en el servicio systemd:
# LimitMEMLOCK=infinity (ya incluido en el servicio de arriba)
sudo systemctl daemon-reload && sudo systemctl restart dragonfly

# Verificar si hay comandos SCAN o keyspace notifications activos
redis-cli -p 6379 -a "pass" info stats | grep keyspace_hits

# Verificar conexiones activas
redis-cli -p 6379 -a "pass" client list | wc -l

# Usar redis-cli latency para diagnosticar
redis-cli -p 6379 -a "pass" --latency-history -i 5

# Verificar si el swap está en uso (penaliza enormemente el rendimiento)
free -h
cat /proc/meminfo | grep Swap