Set up RAID arrays with mdadm for performance and redundancy

#!/usr/bin/env bash
set -euo pipefail

# Production-quality RAID setup script with mdadm
# Supports Ubuntu, Debian, AlmaLinux, Rocky Linux, CentOS, RHEL, Oracle Linux, Fedora

# Colors for output
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly BLUE='\033[0;34m'
readonly NC='\033[0m'

# Global variables
RAID_LEVEL=""
DEVICES=()
MOUNT_POINT=""
PKG_MGR=""
PKG_INSTALL=""
MDADM_CONF="/etc/mdadm/mdadm.conf"
MD_DEVICE=""

# Cleanup on error
cleanup() {
    local exit_code=$?
    if [[ $exit_code -ne 0 && -n "${MD_DEVICE:-}" ]]; then
        echo -e "${YELLOW}[CLEANUP] Attempting to stop RAID array ${MD_DEVICE}...${NC}"
        mdadm --stop "${MD_DEVICE}" 2>/dev/null || true
        wipefs -af "${MD_DEVICE}" 2>/dev/null || true
    fi
    exit $exit_code
}
trap cleanup ERR

usage() {
    cat << EOF
Usage: $0 <raid_level> <mount_point> <device1> <device2> [device3] [device4]

RAID Levels:
  0   - Striping (min 2 devices, no redundancy)
  1   - Mirroring (exactly 2 devices)
  5   - Parity (min 3 devices, 1 drive fault tolerance)
  6   - Double parity (min 4 devices, 2 drive fault tolerance)
  10  - Stripe+Mirror (exactly 4 devices)

Examples:
  $0 1 /mnt/raid1 /dev/sdb /dev/sdc
  $0 5 /mnt/raid5 /dev/sdb /dev/sdc /dev/sdd
  $0 10 /mnt/raid10 /dev/sdb /dev/sdc /dev/sdd /dev/sde
EOF
    exit 1
}

log() {
    echo -e "${GREEN}$*${NC}"
}

warn() {
    echo -e "${YELLOW}WARNING: $*${NC}" >&2
}

error() {
    echo -e "${RED}ERROR: $*${NC}" >&2
    exit 1
}

detect_distro() {
    if [[ ! -f /etc/os-release ]]; then
        error "Cannot detect distribution: /etc/os-release not found"
    fi
    
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_INSTALL="apt install -y"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_INSTALL="dnf install -y"
            if ! command -v dnf &>/dev/null && command -v yum &>/dev/null; then
                PKG_MGR="yum"
                PKG_INSTALL="yum install -y"
            fi
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_INSTALL="yum install -y"
            ;;
        *)
            error "Unsupported distribution: $ID"
            ;;
    esac
    
    # Handle different mdadm.conf locations
    if [[ "$ID" == "debian" || "$ID" == "ubuntu" ]]; then
        MDADM_CONF="/etc/mdadm/mdadm.conf"
    else
        MDADM_CONF="/etc/mdadm.conf"
    fi
}

check_prerequisites() {
    echo "[1/8] Checking prerequisites..."
    
    if [[ $EUID -ne 0 ]]; then
        error "This script must be run as root or with sudo"
    fi
    
    # Validate RAID level and device count
    local device_count=${#DEVICES[@]}
    case "$RAID_LEVEL" in
        0)
            [[ $device_count -ge 2 ]] || error "RAID 0 requires at least 2 devices"
            MD_DEVICE="/dev/md0"
            ;;
        1)
            [[ $device_count -eq 2 ]] || error "RAID 1 requires exactly 2 devices"
            MD_DEVICE="/dev/md1"
            ;;
        5)
            [[ $device_count -ge 3 ]] || error "RAID 5 requires at least 3 devices"
            MD_DEVICE="/dev/md5"
            ;;
        6)
            [[ $device_count -ge 4 ]] || error "RAID 6 requires at least 4 devices"
            MD_DEVICE="/dev/md6"
            ;;
        10)
            [[ $device_count -eq 4 ]] || error "RAID 10 requires exactly 4 devices"
            MD_DEVICE="/dev/md10"
            ;;
        *)
            error "Invalid RAID level: $RAID_LEVEL"
            ;;
    esac
    
    # Check if devices exist
    for device in "${DEVICES[@]}"; do
        [[ -b "$device" ]] || error "Device $device does not exist or is not a block device"
    done
    
    # Check if mount point parent exists
    local parent_dir
    parent_dir=$(dirname "$MOUNT_POINT")
    [[ -d "$parent_dir" ]] || error "Parent directory $parent_dir does not exist"
}

install_mdadm() {
    echo "[2/8] Installing mdadm..."
    
    if command -v mdadm &>/dev/null; then
        log "mdadm already installed"
        return
    fi
    
    case "$PKG_MGR" in
        apt)
            apt update
            $PKG_INSTALL mdadm
            ;;
        dnf|yum)
            $PKG_INSTALL mdadm
            ;;
    esac
    
    log "mdadm installed successfully"
}

prepare_devices() {
    echo "[3/8] Preparing storage devices..."
    
    warn "This will PERMANENTLY DELETE ALL DATA on: ${DEVICES[*]}"
    echo "Press Ctrl+C within 10 seconds to abort..."
    sleep 10
    
    for device in "${DEVICES[@]}"; do
        log "Wiping $device..."
        wipefs -af "$device"
        dd if=/dev/zero of="$device" bs=1M count=10 status=none
    done
    
    log "All devices prepared"
}

create_raid_array() {
    echo "[4/8] Creating RAID $RAID_LEVEL array..."
    
    local device_count=${#DEVICES[@]}
    
    mdadm --create --verbose "$MD_DEVICE" \
        --level="$RAID_LEVEL" \
        --raid-devices="$device_count" \
        "${DEVICES[@]}"
    
    # Wait for array to be ready
    while [[ ! -b "$MD_DEVICE" ]]; do
        sleep 1
    done
    
    log "RAID array $MD_DEVICE created successfully"
}

format_and_mount() {
    echo "[5/8] Formatting and mounting RAID array..."
    
    # Format with ext4
    mkfs.ext4 -F "$MD_DEVICE"
    
    # Create mount point
    mkdir -p "$MOUNT_POINT"
    chmod 755 "$MOUNT_POINT"
    
    # Mount the array
    mount "$MD_DEVICE" "$MOUNT_POINT"
    
    log "Array formatted and mounted at $MOUNT_POINT"
}

configure_auto_assembly() {
    echo "[6/8] Configuring automatic assembly..."
    
    # Ensure mdadm config directory exists
    mkdir -p "$(dirname "$MDADM_CONF")"
    
    # Generate mdadm configuration
    mdadm --detail --scan >> "$MDADM_CONF"
    chmod 644 "$MDADM_CONF"
    
    # Update initramfs/initrd
    case "$PKG_MGR" in
        apt)
            update-initramfs -u
            ;;
        dnf|yum)
            dracut --force
            ;;
    esac
    
    log "Auto-assembly configured"
}

configure_persistent_mount() {
    echo "[7/8] Configuring persistent mount..."
    
    # Add to fstab
    local uuid
    uuid=$(blkid -s UUID -o value "$MD_DEVICE")
    
    # Use UUID for more reliable mounting
    echo "UUID=$uuid $MOUNT_POINT ext4 defaults,nofail 0 2" >> /etc/fstab
    
    log "Persistent mount configured"
}

enable_monitoring() {
    echo "[8/8] Enabling RAID monitoring..."
    
    # Enable mdmonitor service
    case "$PKG_MGR" in
        apt)
            systemctl enable mdmonitor 2>/dev/null || systemctl enable mdadm 2>/dev/null || true
            systemctl start mdmonitor 2>/dev/null || systemctl start mdadm 2>/dev/null || true
            ;;
        dnf|yum)
            systemctl enable mdmonitor
            systemctl start mdmonitor
            ;;
    esac
    
    log "RAID monitoring enabled"
}

verify_installation() {
    echo -e "\n${BLUE}=== RAID Array Verification ===${NC}"
    
    # Check array status
    log "Array status:"
    mdadm --detail "$MD_DEVICE"
    
    echo
    log "Mount status:"
    df -h "$MOUNT_POINT"
    
    echo
    log "RAID configuration:"
    cat "$MDADM_CONF"
    
    echo -e "\n${GREEN}RAID $RAID_LEVEL array successfully created and configured!${NC}"
    echo -e "Device: ${BLUE}$MD_DEVICE${NC}"
    echo -e "Mount point: ${BLUE}$MOUNT_POINT${NC}"
    echo -e "Used devices: ${BLUE}${DEVICES[*]}${NC}"
}

main() {
    # Parse arguments
    [[ $# -ge 4 ]] || usage
    
    RAID_LEVEL="$1"
    MOUNT_POINT="$2"
    shift 2
    DEVICES=("$@")
    
    detect_distro
    check_prerequisites
    install_mdadm
    prepare_devices
    create_raid_array
    format_and_mount
    configure_auto_assembly
    configure_persistent_mount
    enable_monitoring
    verify_installation
}

main "$@"