# Crear estructura completa de proyecto
mkdir -p proyecto/{src,docs,tests,config,logs,tmp,backups}
mkdir -p proyecto/src/{main,lib,utils}
mkdir -p proyecto/docs/{api,user,dev}
mkdir -p proyecto/tests/{unit,integration,performance}

# Verificar estructura creada
tree proyecto/
proyecto/
├── backups/
├── config/
├── docs/
│   ├── api/
│   ├── dev/
│   └── user/
├── logs/
├── src/
│   ├── lib/
│   ├── main/
│   └── utils/
├── tests/
│   ├── integration/
│   ├── performance/
│   └── unit/
└── tmp/

# Crear con permisos específicos
mkdir -m 755 public_dir          # rwxr-xr-x
mkdir -m 700 private_dir         # rwx------
mkdir -m 775 shared_dir          # rwxrwxr-x

# Crear directorios con propietario específico (como root)
sudo mkdir -p /opt/miapp/{bin,etc,var,log}
sudo chown -R usuario:grupo /opt/miapp
sudo chmod -R 755 /opt/miapp

#!/bin/bash
# create_project_structure.sh - Generador de estructura estándar de proyectos

PROJECT_NAME="$1"
PROJECT_TYPE="${2:-web}"  # web, api, desktop, mobile

if [[ -z "$PROJECT_NAME" ]]; then
    echo "Uso: $0 nombre_proyecto [tipo]"
    echo "Tipos disponibles: web, api, desktop, mobile"
    exit 1
fi

# Validar que no existe el directorio
if [[ -d "$PROJECT_NAME" ]]; then
    echo "❌ Error: El directorio '$PROJECT_NAME' ya existe"
    exit 1
fi

echo "🏗️  Creando estructura de proyecto: $PROJECT_NAME (tipo: $PROJECT_TYPE)"

# Función para crear estructura web
create_web_structure() {
    local project="$1"
    
    # Estructura básica
    mkdir -p "$project"/{src,public,docs,tests,config,scripts,logs}
    
    # Subdirectorios específicos web
    mkdir -p "$project"/src/{components,pages,styles,assets,utils,hooks}
    mkdir -p "$project"/public/{images,css,js,fonts}
    mkdir -p "$project"/tests/{unit,e2e,integration}
    mkdir -p "$project"/docs/{design,api,deployment}
    mkdir -p "$project"/config/{development,production,testing}
    
    # Archivos básicos
    touch "$project"/README.md
    touch "$project"/.gitignore
    touch "$project"/package.json
    echo "node_modules/\n*.log\ndist/\nbuild/" > "$project"/.gitignore
}

# Función para crear estructura API
create_api_structure() {
    local project="$1"
    
    mkdir -p "$project"/{src,tests,docs,config,scripts,logs,data}
    mkdir -p "$project"/src/{controllers,models,routes,middleware,utils,services}
    mkdir -p "$project"/tests/{unit,integration,load}
    mkdir -p "$project"/docs/{api,swagger,postman}
    mkdir -p "$project"/config/{database,auth,cors}
    mkdir -p "$project"/data/{migrations,seeds,backups}
    
    touch "$project"/README.md
    touch "$project"/.env.example
    touch "$project"/server.js
}

# Función para crear estructura desktop
create_desktop_structure() {
    local project="$1"
    
    mkdir -p "$project"/{src,resources,docs,tests,build,dist}
    mkdir -p "$project"/src/{main,renderer,shared,assets}
    mkdir -p "$project"/resources/{icons,images,fonts}
    mkdir -p "$project"/tests/{unit,integration,ui}
    mkdir -p "$project"/build/{scripts,configs}
    
    touch "$project"/README.md
    touch "$project"/main.js
    touch "$project"/package.json
}

# Crear estructura según el tipo
case "$PROJECT_TYPE" in
    "web")
        create_web_structure "$PROJECT_NAME"
        ;;
    "api")
        create_api_structure "$PROJECT_NAME"
        ;;
    "desktop")
        create_desktop_structure "$PROJECT_NAME"
        ;;
    "mobile")
        mkdir -p "$PROJECT_NAME"/{src,assets,tests,docs,android,ios}
        mkdir -p "$PROJECT_NAME"/src/{components,screens,services,utils,store}
        mkdir -p "$PROJECT_NAME"/assets/{images,fonts,sounds}
        ;;
    *)
        echo "❌ Tipo de proyecto no reconocido: $PROJECT_TYPE"
        exit 1
        ;;
esac

# Establecer permisos apropiados
chmod 755 "$PROJECT_NAME"
find "$PROJECT_NAME" -type d -exec chmod 755 {} \;
find "$PROJECT_NAME" -type f -exec chmod 644 {} \;

# Crear archivo de información del proyecto
cat > "$PROJECT_NAME"/project_info.txt << EOF
Proyecto: $PROJECT_NAME
Tipo: $PROJECT_TYPE
Creado: $(date)
Usuario: $(whoami)
Hostname: $(hostname)

Estructura creada por: create_project_structure.sh
EOF

# Mostrar estructura creada
echo "✅ Estructura creada exitosamente"
echo
echo "📁 Estructura del proyecto:"
tree "$PROJECT_NAME" -L 3 2>/dev/null || find "$PROJECT_NAME" -type d | head -20

echo
echo "📋 Próximos pasos:"
echo "   cd $PROJECT_NAME"
echo "   git init"
echo "   # Comenzar desarrollo"

# Sincronización básica (local)
rsync -av /origen/ /destino/
# -a: modo archivo (preserva permisos, fechas, enlaces)
# -v: verbose (mostrar progreso)

# Sincronización con exclusiones
rsync -av --exclude='*.log' --exclude='tmp/' /proyecto/ /respaldo/

# Sincronización con progreso detallado
rsync -av --progress --stats /datos/ /backup/

# Sincronización en seco (simular sin hacer cambios)
rsync -av --dry-run /origen/ /destino/

# Sincronización remota
rsync -av -e ssh /local/ usuario@servidor:/remoto/

# Sincronización bidireccional (cuidado con conflictos)
rsync -av --delete /dir1/ /dir2/
rsync -av --delete /dir2/ /dir1/

# Sincronización con filtros complejos
rsync -av \
  --include='*.php' \
  --include='*.js' \
  --include='*/' \
  --exclude='*' \
  /proyecto/src/ /produccion/src/

#!/bin/bash
# advanced_sync.sh - Sincronizador avanzado de directorios

# Configuración
SOURCE_DIR="$1"
TARGET_DIR="$2"
CONFIG_FILE="$3"
LOG_DIR="/var/log/sync"
LOG_FILE="$LOG_DIR/sync_$(date +%Y%m%d_%H%M%S).log"

# Crear directorio de logs
mkdir -p "$LOG_DIR"

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

# Validar argumentos
if [[ $# -lt 2 ]]; then
    echo "Uso: $0   [archivo_config]"
    echo "Ejemplo: $0 /home/user/docs /backup/docs sync.conf"
    exit 1
fi

# Cargar configuración si existe
if [[ -f "$CONFIG_FILE" ]]; then
    source "$CONFIG_FILE"
    log_message "INFO" "Configuración cargada desde: $CONFIG_FILE"
else
    # Configuración por defecto
    EXCLUDE_PATTERNS=(
        "*.tmp"
        "*.log"
        "*.cache"
        ".DS_Store"
        "Thumbs.db"
        "node_modules/"
        ".git/"
        "*.pyc"
        "__pycache__/"
    )
    SYNC_OPTIONS="-av"
    BANDWIDTH_LIMIT=""
    COMPRESSION=true
    DELETE_EXCLUDED=false
    MAKE_BACKUP=true
    BACKUP_DIR="backups/"
fi

log_message "INFO" "Iniciando sincronización"
log_message "INFO" "Origen: $SOURCE_DIR"
log_message "INFO" "Destino: $TARGET_DIR"

# Verificar que el directorio origen existe
if [[ ! -d "$SOURCE_DIR" ]]; then
    log_message "ERROR" "Directorio origen no existe: $SOURCE_DIR"
    exit 1
fi

# Crear directorio destino si no existe
if [[ ! -d "$TARGET_DIR" ]]; then
    log_message "INFO" "Creando directorio destino: $TARGET_DIR"
    mkdir -p "$TARGET_DIR" || {
        log_message "ERROR" "No se pudo crear directorio destino"
        exit 1
    }
fi

# Construir comando rsync
RSYNC_CMD="rsync $SYNC_OPTIONS"

# Agregar exclusiones
for pattern in "${EXCLUDE_PATTERNS[@]}"; do
    RSYNC_CMD+=" --exclude='$pattern'"
done

# Opciones adicionales
if [[ "$COMPRESSION" == true ]]; then
    RSYNC_CMD+=" -z"
fi

if [[ -n "$BANDWIDTH_LIMIT" ]]; then
    RSYNC_CMD+=" --bwlimit=$BANDWIDTH_LIMIT"
fi

if [[ "$DELETE_EXCLUDED" == true ]]; then
    RSYNC_CMD+=" --delete"
fi

if [[ "$MAKE_BACKUP" == true ]]; then
    RSYNC_CMD+=" --backup --backup-dir=$BACKUP_DIR"
fi

# Agregar progreso y estadísticas
RSYNC_CMD+=" --progress --stats"

# Agregar directorios
RSYNC_CMD+=" '$SOURCE_DIR/' '$TARGET_DIR/'"

log_message "INFO" "Ejecutando comando: $RSYNC_CMD"

# Ejecutar sincronización
start_time=$(date +%s)
eval "$RSYNC_CMD" 2>&1 | tee -a "$LOG_FILE"
exit_code=${PIPESTATUS[0]}
end_time=$(date +%s)
duration=$((end_time - start_time))

# Evaluar resultado
if [[ $exit_code -eq 0 ]]; then
    log_message "SUCCESS" "Sincronización completada exitosamente en ${duration}s"
else
    log_message "ERROR" "Sincronización falló con código de salida: $exit_code"
fi

# Generar estadísticas
log_message "INFO" "Generando estadísticas post-sincronización"
{
    echo "=== ESTADÍSTICAS DE SINCRONIZACIÓN ==="
    echo "Fecha: $(date)"
    echo "Origen: $SOURCE_DIR"
    echo "Destino: $TARGET_DIR"
    echo "Duración: ${duration}s"
    echo "Código de salida: $exit_code"
    echo
    echo "Espacio utilizado:"
    du -sh "$SOURCE_DIR" 2>/dev/null | awk '{print "  Origen: " $1}'
    du -sh "$TARGET_DIR" 2>/dev/null | awk '{print "  Destino: " $1}'
    echo
    echo "Archivos más recientes en destino:"
    find "$TARGET_DIR" -type f -newer "$LOG_FILE" 2>/dev/null | head -10 || echo "  Ninguno"
} >> "$LOG_FILE"

# Cleanup de logs antiguos (mantener últimos 30 días)
find "$LOG_DIR" -name "sync_*.log" -type f -mtime +30 -delete 2>/dev/null

log_message "INFO" "Log guardado en: $LOG_FILE"

exit $exit_code

#!/bin/bash
# disk_analyzer.sh - Analizador avanzado de uso de disco

TARGET_DIR="${1:-.}"
REPORT_FILE="disk_analysis_$(date +%Y%m%d_%H%M%S).html"
THRESHOLD_MB=100

# Función para convertir bytes a formato legible
human_readable() {
    local bytes=$1
    local units=("B" "KB" "MB" "GB" "TB")
    local unit=0
    
    while [[ $bytes -gt 1024 && $unit -lt 4 ]]; do
        bytes=$((bytes / 1024))
        ((unit++))
    done
    
    echo "${bytes}${units[$unit]}"
}

# Generar reporte HTML
cat > "$REPORT_FILE" << 'EOF'




    
    


EOF

# Header del reporte
cat >> "$REPORT_FILE" << EOF
    

        
📊 Análisis de Uso de Disco
        
Directorio analizado: $(realpath "$TARGET_DIR")
        
Fecha: $(date)
        
Host: $(hostname)
    
EOF

echo "🔍 Analizando directorio: $TARGET_DIR"
echo "📊 Generando reporte: $REPORT_FILE"

# 1. RESUMEN GENERAL
echo "
" >> "$REPORT_FILE"
echo "
📋 Resumen General
" >> "$REPORT_FILE"

TOTAL_SIZE=$(du -sb "$TARGET_DIR" 2>/dev/null | cut -f1)
TOTAL_FILES=$(find "$TARGET_DIR" -type f 2>/dev/null | wc -l)
TOTAL_DIRS=$(find "$TARGET_DIR" -type d 2>/dev/null | wc -l)

cat >> "$REPORT_FILE" << EOF

    
Métrica
Valor
    
Tamaño Total
$(human_readable $TOTAL_SIZE)
    
Archivos
$TOTAL_FILES
    
Directorios
$TOTAL_DIRS
    
Última modificación
$(stat -c %y "$TARGET_DIR" 2>/dev/null | cut -d'.' -f1)

EOF

echo "
" >> "$REPORT_FILE"

# 2. TOP DIRECTORIOS
echo "
" >> "$REPORT_FILE"
echo "
📁 Top 10 Directorios por Tamaño
" >> "$REPORT_FILE"
echo "" >> "$REPORT_FILE"
echo "" >> "$REPORT_FILE"

du -sb "$TARGET_DIR"/* 2>/dev/null | sort -nr | head -10 | while read size path; do
    percentage=$(( (size * 100) / TOTAL_SIZE ))
    bar_width=$(( percentage > 100 ? 100 : percentage ))
    
    # Determinar clase de color
    if [[ $percentage -gt 50 ]]; then
        bar_class="progress-critical"
    elif [[ $percentage -gt 25 ]]; then
        bar_class="progress-warning"
    else
        bar_class=""
    fi
    
    cat >> "$REPORT_FILE" << EOF

EOF
done

echo "
Directorio
Tamaño
% del Total
Barra

    
$(basename "$path")
    
$(human_readable $size)
    
${percentage}%
    

        

            

        
    
" >> "$REPORT_FILE"

# 3. ARCHIVOS GRANDES
echo "
" >> "$REPORT_FILE"
echo "
📄 Archivos Más Grandes
" >> "$REPORT_FILE"
echo "" >> "$REPORT_FILE"
echo "" >> "$REPORT_FILE"

find "$TARGET_DIR" -type f -size +${THRESHOLD_MB}M 2>/dev/null | \
xargs ls -la 2>/dev/null | sort -k5 -nr | head -20 | \
while read -r permissions links owner group size month day time_or_year filepath; do
    filename=$(basename "$filepath")
    dirpath=$(dirname "$filepath" | sed "s|^$TARGET_DIR/||")
    
    cat >> "$REPORT_FILE" << EOF

EOF
done

echo "
Archivo
Tamaño
Directorio
Última Modificación

    
$filename
    
$(human_readable $size)
    
$dirpath
    
$month $day $time_or_year
" >> "$REPORT_FILE"

# 4. ANÁLISIS POR TIPO DE ARCHIVO
echo "
" >> "$REPORT_FILE"
echo "
🎯 Análisis por Tipo de Archivo
" >> "$REPORT_FILE"

# Crear archivo temporal para estadísticas por extensión
TEMP_FILE=$(mktemp)
find "$TARGET_DIR" -type f 2>/dev/null | while read file; do
    extension="${file##*.}"
    if [[ "$extension" == "$(basename "$file")" ]]; then
        extension="sin_extension"
    fi
    size=$(stat -c%s "$file" 2>/dev/null || echo 0)
    echo "$extension $size"
done > "$TEMP_FILE"

echo "" >> "$REPORT_FILE"
echo "" >> "$REPORT_FILE"

awk '{ext[$1]++; size[$1]+=$2} END {
    for(e in ext) print ext[e], size[e], e
}' "$TEMP_FILE" | sort -nr | head -15 | while read count total_size ext; do
    percentage=$(( (total_size * 100) / TOTAL_SIZE ))
    cat >> "$REPORT_FILE" << EOF

EOF
done

echo "
Extensión
Archivos
Tamaño Total
% del Total

    
.$ext
    
$count
    
$(human_readable $total_size)
    
${percentage}%
" >> "$REPORT_FILE"

# 5. ARCHIVOS ANTIGUOS (no modificados en 6 meses)
echo "
" >> "$REPORT_FILE"
echo "
🕰️ Archivos Antiguos (sin modificar >6 meses)
" >> "$REPORT_FILE"

OLD_FILES=$(find "$TARGET_DIR" -type f -mtime +180 2>/dev/null | wc -l)
OLD_SIZE=$(find "$TARGET_DIR" -type f -mtime +180 2>/dev/null -exec stat -c%s {} + 2>/dev/null | awk '{sum+=$1} END {print sum+0}')

if [[ $OLD_FILES -gt 0 ]]; then
    cat >> "$REPORT_FILE" << EOF

    
⚠️ Archivos antiguos detectados:
    

        
Cantidad: $OLD_FILES archivos
        
Espacio ocupado: $(human_readable $OLD_SIZE)
        
% del total: $(( (OLD_SIZE * 100) / TOTAL_SIZE ))%
    

EOF
else
    echo "
✅ No se encontraron archivos antiguos
" >> "$REPORT_FILE"
fi

echo "
" >> "$REPORT_FILE"

# Cerrar HTML
echo "" >> "$REPORT_FILE"

# Cleanup
rm -f "$TEMP_FILE" 2>/dev/null

echo "✅ Análisis completado"
echo "📄 Reporte generado: $REPORT_FILE"
echo "🌐 Abrir con: firefox $REPORT_FILE"

# Mostrar resumen en terminal
echo
echo "📊 RESUMEN RÁPIDO:"
echo "   Tamaño total: $(human_readable $TOTAL_SIZE)"
echo "   Archivos: $TOTAL_FILES"
echo "   Directorios: $TOTAL_DIRS"
if [[ $OLD_FILES -gt 0 ]]; then
    echo "   ⚠️ Archivos antiguos: $OLD_FILES ($(human_readable $OLD_SIZE))"
fi

# Crear directorio compartido con SGID
mkdir /shared/project
chmod 2775 /shared/project  # rwxrwsr-x
chgrp developers /shared/project

# Verificar que funciona
ls -ld /shared/project
drwxrwsr-x 2 root developers 4096 oct 15 10:30 /shared/project

# Todos los archivos creados heredarán el grupo 'developers'
touch /shared/project/test.txt
ls -l /shared/project/test.txt
-rw-r--r-- 1 usuario developers 0 oct 15 10:31 test.txt

# Configurar directorio temporal con sticky bit
mkdir /tmp/shared
chmod 1777 /tmp/shared  # rwxrwxrwt
ls -ld /tmp/shared
drwxrwxrwt 2 root root 4096 oct 15 10:32 /tmp/shared

# ACLs (Access Control Lists) - más granular
# Instalar herramientas ACL si no están disponibles
# sudo apt-get install acl

# Dar permisos específicos a usuario
setfacl -m u:alice:rx /proyecto/datos
setfacl -m g:developers:rwx /proyecto/src

# Ver ACLs
getfacl /proyecto/datos
# file: proyecto/datos
# owner: root
# group: root
# user::rwx
# user:alice:r-x
# group::r-x
# mask::r-x
# other::---

# Establecer ACLs por defecto (para nuevos archivos)
setfacl -d -m g:developers:rwx /proyecto/src

# Remover ACLs
setfacl -x u:alice /proyecto/datos