Disaster Recovery

#!/bin/bash
# Emergency Git Recovery Automation Script

set -euo pipefail

REPO_PATH="${1:-.}"
BACKUP_DIR="emergency-backup-$(date +%Y%m%d_%H%M%S)"
LOG_FILE="recovery-$(date +%Y%m%d_%H%M%S).log"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}

emergency_backup() {
    log "Creating emergency backup..."
    cp -r "$REPO_PATH/.git" "$BACKUP_DIR"
    log "Backup created at: $BACKUP_DIR"
}

assess_damage() {
    log "Assessing repository damage..."
    
    # Check basic repository structure
    if [[ ! -d "$REPO_PATH/.git" ]]; then
        log "CRITICAL: No .git directory found!"
        return 3
    fi
    
    # Run filesystem check
    cd "$REPO_PATH"
    if ! git fsck --no-reflogs 2>&1 | tee fsck-output.txt; then
        corruption_level=$(grep -c "error\|corrupt\|missing" fsck-output.txt || true)
        log "Found $corruption_level corruption issues"
        return $((corruption_level > 10 ? 2 : 1))
    fi
    
    log "Repository appears healthy"
    return 0
}

recover_objects() {
    log "Attempting object recovery..."
    
    # Create recovery workspace
    mkdir -p recovery-workspace
    
    # Extract all readable objects
    git cat-file --batch-check --batch-all-objects | \
        while read sha1 type size; do 
            if git cat-file -e "$sha1" 2>/dev/null; then
                git cat-file "$type" "$sha1" > "recovery-workspace/$sha1"
            else
                log "Unreadable object: $sha1"
            fi
        done
    
    # Rebuild object database
    for obj in recovery-workspace/*; do
        if [[ -f "$obj" ]]; then
            git hash-object -w "$obj" || log "Failed to re-hash: $(basename "$obj")"
        fi
    done
}

recover_references() {
    log "Recovering branch references..."
    
    # Backup current refs
    cp -r .git/refs .git/refs-backup 2>/dev/null || true
    
    # Try to recover from reflogs
    find .git/logs -name "*" -type f | while read reflog; do
        ref_name=$(echo "$reflog" | sed 's|.git/logs/||')
        if [[ -f "$reflog" ]]; then
            last_commit=$(tail -1 "$reflog" | cut -d' ' -f2)
            if git rev-parse --verify "$last_commit" >/dev/null 2>&1; then
                log "Recovering reference: $ref_name -> $last_commit"
                git update-ref "$ref_name" "$last_commit"
            fi
        fi
    done
}

main() {
    log "Starting emergency Git recovery for: $REPO_PATH"
    
    # Create backup first
    emergency_backup
    
    # Assess damage level
    assess_damage
    damage_level=$?
    
    case $damage_level in
        0)
            log "No recovery needed - repository is healthy"
            ;;
        1)
            log "Minor corruption detected - attempting repair"
            git gc --aggressive
            ;;
        2)
            log "Major corruption detected - full recovery protocol"
            recover_objects
            recover_references
            ;;
        3)
            log "CRITICAL: Repository structure missing - manual intervention required"
            exit 1
            ;;
    esac
    
    # Final verification
    if git fsck --no-reflogs; then
        log "Recovery completed successfully!"
    else
        log "Recovery partially successful - manual intervention may be needed"
    fi
}

# Execute main function
main "$@"