Operadores Lógicos y Comparación

#!/bin/bash
# Validación completa de usuario antes de operaciones críticas

usuario_actual=$(whoami)
directorio_trabajo="/home/$usuario_actual/proyectos"

# Verificar múltiples condiciones antes de proceder
if [[ "$usuario_actual" != "root" && -d "$directorio_trabajo" && -w "$directorio_trabajo" ]]; then
    echo "✅ Validación exitosa:"
    echo "   - Usuario no-root: $usuario_actual"
    echo "   - Directorio existe: $directorio_trabajo"
    echo "   - Permisos de escritura: Sí"
    echo
    echo "Procediendo con la operación..."
    
    # Crear proyecto de ejemplo
    proyecto_nuevo="$directorio_trabajo/proyecto_$(date +%Y%m%d)"
    mkdir -p "$proyecto_nuevo"
    echo "Proyecto creado en: $proyecto_nuevo"
    
else
    echo "❌ Error en validación:"
    [[ "$usuario_actual" == "root" ]] && echo "   - No ejecutes como root"
    [[ ! -d "$directorio_trabajo" ]] && echo "   - Directorio no existe: $directorio_trabajo"
    [[ ! -w "$directorio_trabajo" ]] && echo "   - Sin permisos de escritura en: $directorio_trabajo"
    exit 1
fi

#!/bin/bash
# Detector inteligente de dependencias del sistema

echo "=== Detector de Dependencias ==="

# Función para verificar comandos
verificar_comando() {
    if command -v "$1" >/dev/null 2>&1; then
        echo "✅ $1 está disponible"
        return 0
    else
        echo "❌ $1 no está disponible"
        return 1
    fi
}

# Verificar herramientas de desarrollo esenciales
echo "Verificando herramientas de desarrollo..."
dev_tools=0

if verificar_comando "gcc" || verificar_comando "clang" || verificar_comando "tcc"; then
    echo "   Compilador C disponible"
    ((dev_tools++))
fi

if verificar_comando "make" || verificar_comando "ninja" || verificar_comando "bazel"; then
    echo "   Sistema de build disponible"
    ((dev_tools++))
fi

if verificar_comando "git" || verificar_comando "svn" || verificar_comando "hg"; then
    echo "   Control de versiones disponible"
    ((dev_tools++))
fi

# Verificar editores de texto
echo -e "\nVerificando editores de texto..."
if verificar_comando "vim" || verificar_comando "nano" || verificar_comando "emacs"; then
    echo "   Editor de texto en línea de comandos disponible"
    ((dev_tools++))
fi

# Evaluación final
echo -e "\n=== Resultado ==="
if [[ $dev_tools -ge 3 ]]; then
    echo "🎉 Entorno de desarrollo completo ($dev_tools/4 herramientas)"
elif [[ $dev_tools -ge 2 ]]; then
    echo "👍 Entorno de desarrollo básico ($dev_tools/4 herramientas)"
elif [[ $dev_tools -ge 1 ]]; then
    echo "⚠️  Entorno de desarrollo mínimo ($dev_tools/4 herramientas)"
else
    echo "❌ Entorno de desarrollo incompleto (0/4 herramientas)"
fi

#!/bin/bash
# Sistema de validación robusto para scripts críticos

# Variables de configuración
MIN_DISK_SPACE=1000000  # 1GB en KB
MIN_MEMORY=512000       # 512MB en KB
REQUIRED_TOOLS=("curl" "jq" "git")
LOG_FILE="/var/log/mi_script.log"

# Función de logging
log_message() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

# Función de validación completa
validar_sistema() {
    local errores=0
    
    log_message "=== Iniciando validación del sistema ==="
    
    # 1. Verificar que no somos root (para seguridad)
    if [[ $EUID -eq 0 ]]; then
        log_message "❌ ERROR: No ejecutes este script como root"
        ((errores++))
    fi
    
    # 2. Verificar espacio en disco
    disco_disponible=$(df /tmp | tail -1 | awk '{print $4}')
    if [[ $disco_disponible -lt $MIN_DISK_SPACE ]]; then
        log_message "❌ ERROR: Espacio insuficiente en disco"
        log_message "   Requerido: ${MIN_DISK_SPACE}KB, Disponible: ${disco_disponible}KB"
        ((errores++))
    fi
    
    # 3. Verificar memoria disponible
    memoria_disponible=$(free | grep '^Mem:' | awk '{print $7}')
    if [[ $memoria_disponible -lt $MIN_MEMORY ]]; then
        log_message "❌ ERROR: Memoria insuficiente"
        log_message "   Requerida: ${MIN_MEMORY}KB, Disponible: ${memoria_disponible}KB"
        ((errores++))
    fi
    
    # 4. Verificar herramientas requeridas
    for tool in "${REQUIRED_TOOLS[@]}"; do
        if ! command -v "$tool" >/dev/null 2>&1; then
            log_message "❌ ERROR: Herramienta no encontrada: $tool"
            ((errores++))
        fi
    done
    
    # 5. Verificar conectividad de red
    if ! ping -c 1 8.8.8.8 >/dev/null 2>&1; then
        log_message "❌ ERROR: Sin conectividad de red"
        ((errores++))
    fi
    
    # 6. Verificar permisos de escritura
    if [[ ! -w "$(dirname "$LOG_FILE")" ]]; then
        echo "❌ ERROR: Sin permisos para escribir logs en $(dirname "$LOG_FILE")"
        ((errores++))
    fi
    
    # Resultado de la validación
    if [[ $errores -eq 0 ]]; then
        log_message "✅ Validación exitosa - Sistema listo"
        return 0
    else
        log_message "❌ Validación fallida - $errores errores encontrados"
        return 1
    fi
}

# Función principal
main() {
    # Validar sistema antes de proceder
    if validar_sistema; then
        log_message "Iniciando operación principal..."
        
        # Aquí iría la lógica principal del script
        sleep 2
        log_message "✅ Operación completada exitosamente"
    else
        log_message "❌ No se puede continuar debido a errores de validación"
        exit 1
    fi
}

# Ejecutar script
main

#!/bin/bash
# Analizador inteligente de logs con múltiples criterios

# Configuración
LOG_DIRS=("/var/log" "/var/log/nginx" "/var/log/apache2")
PATRONES_ERROR=("error" "Error" "ERROR" "fail" "FAIL" "critical" "CRITICAL")
PATRONES_WARNING=("warn" "Warning" "WARNING" "notice")
FECHA_HOY=$(date '+%Y-%m-%d')
FECHA_AYER=$(date -d yesterday '+%Y-%m-%d' 2>/dev/null || date -v-1d '+%Y-%m-%d' 2>/dev/null)

# Función para analizar un archivo de log
analizar_log() {
    local archivo="$1"
    local categoria="$2"
    
    if [[ ! -f "$archivo" || ! -r "$archivo" ]]; then
        return 1
    fi
    
    local total_lineas=$(wc -l < "$archivo")
    local errores_hoy=0
    local warnings_hoy=0
    
    # Contar errores de hoy
    for patron in "${PATRONES_ERROR[@]}"; do
        errores_encontrados=$(grep -i "$patron" "$archivo" | grep -c "$FECHA_HOY" 2>/dev/null || echo "0")
        ((errores_hoy += errores_encontrados))
    done
    
    # Contar warnings de hoy
    for patron in "${PATRONES_WARNING[@]}"; do
        warnings_encontrados=$(grep -i "$patron" "$archivo" | grep -c "$FECHA_HOY" 2>/dev/null || echo "0")
        ((warnings_hoy += warnings_encontrados))
    done
    
    # Determinar el estado del log
    if [[ $errores_hoy -gt 50 || ($errores_hoy -gt 10 && $warnings_hoy -gt 100) ]]; then
        estado="🔴 CRÍTICO"
    elif [[ $errores_hoy -gt 10 || $warnings_hoy -gt 50 ]]; then
        estado="🟡 ADVERTENCIA"
    elif [[ $errores_hoy -gt 0 || $warnings_hoy -gt 0 ]]; then
        estado="🟢 NORMAL"
    else
        estado="✅ LIMPIO"
    fi
    
    # Mostrar resumen
    echo "[$categoria] $archivo"
    echo "  Estado: $estado"
    echo "  Total líneas: $total_lineas"
    echo "  Errores hoy: $errores_hoy"
    echo "  Warnings hoy: $warnings_hoy"
    
    # Si hay muchos errores, mostrar los más recientes
    if [[ $errores_hoy -gt 5 ]]; then
        echo "  Errores recientes:"
        for patron in "${PATRONES_ERROR[@]}"; do
            grep -i "$patron" "$archivo" | grep "$FECHA_HOY" | tail -2 | sed 's/^/    /'
        done
    fi
    
    echo
}

# Función principal
main() {
    echo "=== Analizador Inteligente de Logs ==="
    echo "Fecha de análisis: $FECHA_HOY"
    echo
    
    local logs_analizados=0
    local logs_con_errores=0
    
    # Buscar y analizar logs en los directorios especificados
    for directorio in "${LOG_DIRS[@]}"; do
        if [[ -d "$directorio" && -r "$directorio" ]]; then
            echo "Analizando directorio: $directorio"
            
            # Buscar archivos de log comunes
            find "$directorio" -name "*.log" -o -name "access.log*" -o -name "error.log*" | while read -r archivo; do
                if analizar_log "$archivo" "$(basename "$directorio")"; then
                    ((logs_analizados++))
                fi
            done
        fi
    done
    
    echo "=== Resumen Final ==="
    echo "Logs analizados: $logs_analizados"
    echo "Análisis completado: $(date)"
}

# Ejecutar con validaciones previas
if [[ $(id -u) -eq 0 ]]; then
    echo "⚠️  Ejecutando como root - ten cuidado con los permisos"
fi

if ! command -v find >/dev/null || ! command -v grep >/dev/null; then
    echo "❌ Herramientas requeridas no disponibles (find, grep)"
    exit 1
fi

main