transfer.sh

#!/bin/bash

#===============================================================================
# Coolify Migration Tool - TRANSFER SCRIPT
# https://github.com/your-repo/coolify-migration
#
# Run this on your SOURCE server (the one you're migrating FROM)
# This script will create a complete backup and serve it for download
#===============================================================================

set -e

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

# Configuration
BACKUP_DIR="/tmp/coolify-migration"
BACKUP_NAME="coolify-backup-$(date +%Y%m%d-%H%M%S)"
SERVE_PORT="${SERVE_PORT:-9999}"

#-------------------------------------------------------------------------------
# Helper Functions
#-------------------------------------------------------------------------------

log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

cleanup() {
    log_info "Cleaning up temporary files..."
    rm -rf "${BACKUP_DIR}/${BACKUP_NAME}"
}

trap cleanup EXIT

check_root() {
    if [[ $EUID -ne 0 ]]; then
        log_error "This script must be run as root (use sudo)"
        exit 1
    fi
}

check_coolify() {
    if [[ ! -d "/data/coolify" ]]; then
        log_error "Coolify data directory not found at /data/coolify"
        log_error "Is Coolify installed on this server?"
        exit 1
    fi
}

#-------------------------------------------------------------------------------
# Detection Functions
#-------------------------------------------------------------------------------

detect_coolify_version() {
    local version=""
    
    # Try multiple methods to detect version
    if [[ -f "/data/coolify/source/.env" ]]; then
        version=$(grep -E "^COOLIFY_VERSION=" /data/coolify/source/.env 2>/dev/null | cut -d'=' -f2 | tr -d '"' || true)
    fi
    
    if [[ -z "$version" ]] && command -v docker &>/dev/null; then
        version=$(docker inspect coolify 2>/dev/null | grep -oP '"COOLIFY_VERSION=\K[^"]+' | head -1 || true)
    fi
    
    if [[ -z "$version" ]]; then
        # Try to get from running container labels
        version=$(docker inspect coolify 2>/dev/null | jq -r '.[0].Config.Labels["coolify.version"]' 2>/dev/null || true)
    fi
    
    if [[ -z "$version" || "$version" == "null" ]]; then
        log_warn "Could not detect Coolify version automatically"
        read -p "Enter your Coolify version (e.g., 4.0.0-beta.374): " version
    fi
    
    echo "$version"
}

detect_docker_volumes() {
    log_info "Detecting Docker volumes used by Coolify..."
    
    # Get all volumes that are related to Coolify-managed containers
    local volumes=()
    
    # Method 1: Volumes with coolify prefix
    while IFS= read -r vol; do
        volumes+=("$vol")
    done < <(docker volume ls -q 2>/dev/null | grep -E "^coolify-" || true)
    
    # Method 2: Volumes attached to containers with coolify labels
    while IFS= read -r container; do
        while IFS= read -r vol; do
            if [[ ! " ${volumes[*]} " =~ " ${vol} " ]]; then
                volumes+=("$vol")
            fi
        done < <(docker inspect "$container" 2>/dev/null | jq -r '.[0].Mounts[] | select(.Type=="volume") | .Name' 2>/dev/null || true)
    done < <(docker ps -a --filter "label=coolify.managed=true" -q 2>/dev/null || true)
    
    # Method 3: Check /data/coolify for volume references
    if [[ -d "/data/coolify/applications" ]]; then
        while IFS= read -r vol; do
            if [[ ! " ${volumes[*]} " =~ " ${vol} " && -n "$vol" ]]; then
                volumes+=("$vol")
            fi
        done < <(find /data/coolify/applications -name "docker-compose.yml" -exec grep -h "volume:" {} \; 2>/dev/null | grep -oP '^\s*-?\s*\K[a-zA-Z0-9_-]+(?=:)' | sort -u || true)
    fi
    
    printf '%s\n' "${volumes[@]}" | sort -u
}

get_server_ip() {
    # Try multiple methods to get the public IP
    local ip=""
    
    ip=$(curl -4 -s --max-time 5 https://ifconfig.me 2>/dev/null || true)
    
    if [[ -z "$ip" ]]; then
        ip=$(curl -4 -s --max-time 5 https://api.ipify.org 2>/dev/null || true)
    fi
    
    if [[ -z "$ip" ]]; then
        ip=$(curl -4 -s --max-time 5 https://ipecho.net/plain 2>/dev/null || true)
    fi
    
    if [[ -z "$ip" ]]; then
        ip=$(hostname -I | awk '{print $1}')
    fi
    
    echo "$ip"
}

#-------------------------------------------------------------------------------
# Backup Functions
#-------------------------------------------------------------------------------

stop_coolify() {
    log_info "Stopping Coolify services for consistent backup..."
    
    cd /data/coolify/source 2>/dev/null || true
    docker compose down 2>/dev/null || docker-compose down 2>/dev/null || true
    
    log_success "Coolify services stopped"
}

start_coolify() {
    log_info "Restarting Coolify services..."
    
    cd /data/coolify/source 2>/dev/null || true
    docker compose up -d 2>/dev/null || docker-compose up -d 2>/dev/null || true
    
    log_success "Coolify services restarted"
}

backup_coolify_data() {
    log_info "Backing up Coolify data directory..."
    
    mkdir -p "${BACKUP_DIR}/${BACKUP_NAME}/coolify-data"
    
    # Backup entire /data/coolify with preserved permissions
    rsync -a --info=progress2 /data/coolify/ "${BACKUP_DIR}/${BACKUP_NAME}/coolify-data/"
    
    log_success "Coolify data backed up"
}

backup_docker_volumes() {
    log_info "Backing up Docker volumes..."
    
    mkdir -p "${BACKUP_DIR}/${BACKUP_NAME}/docker-volumes"
    
    local volumes
    volumes=$(detect_docker_volumes)
    
    if [[ -z "$volumes" ]]; then
        log_warn "No Docker volumes found to backup"
        return
    fi
    
    local count=0
    local total
    total=$(echo "$volumes" | wc -l)
    
    while IFS= read -r volume; do
        if [[ -n "$volume" ]]; then
            ((count++)) || true
            log_info "Backing up volume ($count/$total): $volume"
            
            # Create a temporary container to access the volume and tar it
            docker run --rm \
                -v "${volume}:/source:ro" \
                -v "${BACKUP_DIR}/${BACKUP_NAME}/docker-volumes:/backup" \
                alpine tar -czf "/backup/${volume}.tar.gz" -C /source . 2>/dev/null || {
                    log_warn "Failed to backup volume: $volume (may be in use or empty)"
                }
        fi
    done <<< "$volumes"
    
    log_success "Docker volumes backed up"
}

backup_docker_networks() {
    log_info "Backing up Docker network configurations..."
    
    mkdir -p "${BACKUP_DIR}/${BACKUP_NAME}/docker-networks"
    
    # Export Coolify-related networks
    docker network ls --format '{{.Name}}' | grep -E "^coolify" | while read -r network; do
        docker network inspect "$network" > "${BACKUP_DIR}/${BACKUP_NAME}/docker-networks/${network}.json" 2>/dev/null || true
    done
    
    log_success "Docker networks backed up"
}

create_metadata() {
    log_info "Creating backup metadata..."
    
    local coolify_version
    coolify_version=$(detect_coolify_version)
    
    # Gather values and escape them properly for JSON
    local backup_date
    local source_hostname
    local source_ip
    local docker_version
    local os_info
    local volumes_json
    
    backup_date=$(date -Iseconds)
    source_hostname=$(hostname | tr -cd '[:print:]')
    source_ip=$(get_server_ip | tr -cd '[:print:]')
    docker_version=$(docker --version 2>/dev/null | grep -oP '\d+\.\d+\.\d+' | head -1 | tr -cd '[:print:]')
    os_info=$(cat /etc/os-release 2>/dev/null | grep PRETTY_NAME | cut -d'"' -f2 | tr -cd '[:print:]' | head -c 100)
    volumes_json=$(detect_docker_volumes | jq -R -s -c 'split("\n") | map(select(length > 0))' 2>/dev/null || echo '[]')
    
    # Use jq to create valid JSON
    jq -n \
        --arg backup_date "$backup_date" \
        --arg source_hostname "$source_hostname" \
        --arg source_ip "$source_ip" \
        --arg coolify_version "$coolify_version" \
        --arg docker_version "$docker_version" \
        --arg os_info "$os_info" \
        --arg backup_name "$BACKUP_NAME" \
        --argjson volumes_backed_up "$volumes_json" \
        '{
            backup_date: $backup_date,
            source_hostname: $source_hostname,
            source_ip: $source_ip,
            coolify_version: $coolify_version,
            docker_version: $docker_version,
            os_info: $os_info,
            backup_name: $backup_name,
            volumes_backed_up: $volumes_backed_up
        }' > "${BACKUP_DIR}/${BACKUP_NAME}/metadata.json"
    
    log_success "Metadata created"
}

create_archive() {
    log_info "Creating final backup archive..."
    
    cd "${BACKUP_DIR}"
    tar -czf "${BACKUP_NAME}.tar.gz" "${BACKUP_NAME}"
    
    local size
    size=$(du -h "${BACKUP_NAME}.tar.gz" | cut -f1)
    
    log_success "Archive created: ${BACKUP_NAME}.tar.gz (${size})"
}

serve_backup() {
    local ip
    ip=$(get_server_ip)
    local archive="${BACKUP_DIR}/${BACKUP_NAME}.tar.gz"
    
    echo ""
    echo "==============================================================================="
    echo -e "${GREEN}BACKUP COMPLETE!${NC}"
    echo "==============================================================================="
    echo ""
    echo -e "Backup file: ${YELLOW}${archive}${NC}"
    echo -e "Size: ${YELLOW}$(du -h "$archive" | cut -f1)${NC}"
    echo ""
    echo "==============================================================================="
    echo -e "${BLUE}DOWNLOAD OPTIONS${NC}"
    echo "==============================================================================="
    echo ""
    echo -e "${YELLOW}Option 1: Direct HTTP Download (recommended)${NC}"
    echo ""
    echo "The backup will be served on port ${SERVE_PORT}. Use this URL in restore.sh:"
    echo ""
    echo -e "  ${GREEN}http://${ip}:${SERVE_PORT}/${BACKUP_NAME}.tar.gz${NC}"
    echo ""
    echo -e "${YELLOW}Option 2: Manual SCP Transfer${NC}"
    echo ""
    echo "From your NEW server, run:"
    echo ""
    echo -e "  ${GREEN}scp root@${ip}:${archive} /tmp/${NC}"
    echo ""
    echo "==============================================================================="
    echo ""
    
    # Check if port is available
    if netstat -tuln 2>/dev/null | grep -q ":${SERVE_PORT} " || ss -tuln 2>/dev/null | grep -q ":${SERVE_PORT} "; then
        log_warn "Port ${SERVE_PORT} is already in use. Set SERVE_PORT env var to use a different port."
        log_info "Example: SERVE_PORT=8888 ./transfer.sh"
        echo ""
        echo "You can manually serve the file with:"
        echo "  cd ${BACKUP_DIR} && python3 -m http.server ${SERVE_PORT}"
        return
    fi
    
    echo -e "${BLUE}Starting HTTP server on port ${SERVE_PORT}...${NC}"
    echo -e "${YELLOW}Press Ctrl+C to stop the server when download is complete.${NC}"
    echo ""
    
    # Restart Coolify before serving (so server stays operational)
    start_coolify
    
    cd "${BACKUP_DIR}"
    
    # Use Python's built-in HTTP server
    if command -v python3 &>/dev/null; then
        python3 -m http.server "${SERVE_PORT}" 2>/dev/null
    elif command -v python &>/dev/null; then
        python -m SimpleHTTPServer "${SERVE_PORT}" 2>/dev/null
    else
        log_error "Python not found. Please manually transfer the backup file."
        log_info "File location: ${archive}"
    fi
}

#-------------------------------------------------------------------------------
# Main Execution
#-------------------------------------------------------------------------------

main() {
    echo ""
    echo "==============================================================================="
    echo "                    COOLIFY MIGRATION - TRANSFER SCRIPT                        "
    echo "==============================================================================="
    echo ""
    
    check_root
    check_coolify
    
    log_info "Starting Coolify backup process..."
    echo ""
    
    # Create backup directory
    mkdir -p "${BACKUP_DIR}/${BACKUP_NAME}"
    
    # Stop Coolify for consistent backup
    stop_coolify
    
    # Backup everything
    backup_coolify_data
    backup_docker_volumes
    backup_docker_networks
    create_metadata
    
    # Create archive
    create_archive
    
    # Serve the backup
    serve_backup
}

main "$@"