docker-manager.sh

#!/bin/bash

# =============================================================================
# Docker Version Management Script for wav_parse Project
# =============================================================================
# Features:
# - Automatic version management (keeps latest 3 versions)
# - Build, deploy, rollback operations
# - Container lifecycle management
# - Cleanup of old images and containers
# =============================================================================

set -e  # Exit on any error

# Configuration
PROJECT_NAME="wav_parse"
IMAGE_NAME="zh-asr"
CONTAINER_NAME="asr"
PORT="8000"
MAX_VERSIONS=3
VERSION_FILE=".docker_version"
LOG_FILE="docker-manager.log"

# Model cache configuration
HOST_MODEL_CACHE="$HOME/.cache/modelscope/hub/models/iic"
CONTAINER_MODEL_CACHE="/root/.cache/modelscope/hub/models/iic"

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

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

info() {
    log "${BLUE}INFO${NC}: $1"
}

success() {
    log "${GREEN}SUCCESS${NC}: $1"
}

warning() {
    log "${YELLOW}WARNING${NC}: $1"
}

error() {
    log "${RED}ERROR${NC}: $1"
}

# Get next version number (timestamp format: yyyyMMddHHmm)
get_next_version() {
    date +"%Y%m%d%H%M"
}

# Update version file
update_version() {
    echo "$1" > "$VERSION_FILE"
}

# Get current version
get_current_version() {
    if [[ -f "$VERSION_FILE" ]]; then
        cat "$VERSION_FILE"
    else
        echo "none"
    fi
}

# Get previous version from docker images
get_previous_version() {
    # Get the second latest version from docker images
    docker images "$IMAGE_NAME" --format "{{.Tag}}" | grep -E '^[0-9]{12}$' | sort -r | sed -n '2p'
}

# Stop and remove container
stop_container() {
    info "Stopping container $CONTAINER_NAME..."
    if docker ps -q -f name="$CONTAINER_NAME" | grep -q .; then
        docker stop "$CONTAINER_NAME" || true
        success "Container stopped"
    else
        info "Container $CONTAINER_NAME is not running"
    fi
    
    info "Removing container $CONTAINER_NAME..."
    if docker ps -a -q -f name="$CONTAINER_NAME" | grep -q .; then
        docker rm "$CONTAINER_NAME" || true
        success "Container removed"
    else
        info "Container $CONTAINER_NAME does not exist"
    fi
}

# Clean up old images (keep only latest N versions)
cleanup_old_images() {
    info "Cleaning up old images (keeping latest $MAX_VERSIONS versions)..."
    
    # Get all image versions with timestamp format, sorted by creation time (newest first)
    local images=($(docker images "$IMAGE_NAME" --format "{{.Tag}}" | grep -E '^[0-9]{12}$' | sort -r))
    
    if [[ ${#images[@]} -gt $MAX_VERSIONS ]]; then
        local to_remove=("${images[@]:$MAX_VERSIONS}")
        for tag in "${to_remove[@]}"; do
            info "Removing old image: $IMAGE_NAME:$tag"
            docker rmi "$IMAGE_NAME:$tag" || warning "Failed to remove $IMAGE_NAME:$tag"
        done
        success "Cleaned up ${#to_remove[@]} old images"
    else
        info "No old images to clean up (current count: ${#images[@]})"
    fi
}

# Build new image
build_image() {
    local version=$1
    local tag="$version"  # 直接使用时间戳作为tag
    
    info "Building new image: $IMAGE_NAME:$tag ($(format_version_display $version))"
    
    # Build the image
    docker build -t "$IMAGE_NAME:$tag" .
    
    # Tag as latest
    docker tag "$IMAGE_NAME:$tag" "$IMAGE_NAME:latest"
    
    success "Image built successfully: $IMAGE_NAME:$tag"
}

# Format version for display
format_version_display() {
    local version=$1
    if [[ ${#version} -eq 12 ]]; then
        # Format: 202412151430 -> 2024-12-15 14:30
        echo "${version:0:4}-${version:4:2}-${version:6:2} ${version:8:2}:${version:10:2}"
    else
        echo "$version"
    fi
}

# Start container
start_container() {
    local version=${1:-"latest"}
    local tag="$version"
    
    if [[ "$version" == "latest" ]]; then
        tag="latest"
    fi
    
    info "Starting container with image: $IMAGE_NAME:$tag"
    
    # Check if model cache directory exists
    if [[ ! -d "$HOST_MODEL_CACHE" ]]; then
        warning "Model cache directory not found: $HOST_MODEL_CACHE"
        warning "Container will download models on first use"
    else
        info "Using model cache from: $HOST_MODEL_CACHE"
    fi
    
    # Start container with health check, restart policy, and model cache volume
    docker run -d \
        --name="$CONTAINER_NAME" \
        --restart=unless-stopped \
        -p "$PORT:8000" \
        -v "$HOST_MODEL_CACHE:$CONTAINER_MODEL_CACHE" \
        -e LAZY_LOAD_MODEL=true \
        -e PYTHONUNBUFFERED=1 \
        -e PYTHONDONTWRITEBYTECODE=1 \
        --health-cmd="python /app/health_check.py" \
        --health-interval=20s \
        --health-timeout=15s \
        --health-retries=5 \
        --health-start-period=120s \
        "$IMAGE_NAME:$tag"
    
    success "Container started successfully"
    
    # Wait for container to be healthy
    info "Waiting for container to be healthy..."
    local max_wait=300  # 5 minutes for model loading
    local wait_time=0
    
    while [[ $wait_time -lt $max_wait ]]; do
        local health_status=$(docker inspect --format='{{.State.Health.Status}}' "$CONTAINER_NAME" 2>/dev/null || echo "unknown")
        
        if [[ "$health_status" == "healthy" ]]; then
            success "Container is healthy and ready!"
            break
        elif [[ "$health_status" == "unhealthy" ]]; then
            error "Container is unhealthy"
            docker logs "$CONTAINER_NAME"
            exit 1
        else
            info "Container health status: $health_status (waiting...)"
            sleep 10
            wait_time=$((wait_time + 10))
        fi
    done
    
    if [[ $wait_time -ge $max_wait ]]; then
        warning "Timeout waiting for container to be healthy"
        docker logs "$CONTAINER_NAME"
    fi
}

# Deploy (build and start)
deploy() {
    local version=$(get_next_version)
    
    info "Starting deployment of version $version"
    
    # Stop current container
    stop_container
    
    # Build new image
    build_image "$version"
    
    # Clean up old images
    cleanup_old_images
    
    # Start new container
    start_container "$version"
    
    # Update version file
    update_version "$version"
    
    success "Deployment completed successfully! Version: $version"
    info "Application is running on http://localhost:$PORT"
    info "Health check: http://localhost:$PORT/system/health"
    info "System status: http://localhost:$PORT/system/status"
}

# Rollback to previous version
rollback() {
    local target_version=${1:-""}
    local current_version=$(get_current_version)
    
    if [[ -z "$target_version" ]]; then
        # Get the previous version automatically
        target_version=$(get_previous_version)
        if [[ -z "$target_version" ]]; then
            error "No previous version found"
            list_versions
            exit 1
        fi
    fi
    
    # Check if target image exists
    if ! docker images -q "$IMAGE_NAME:$target_version" | grep -q .; then
        error "Image $IMAGE_NAME:$target_version not found"
        list_versions
        exit 1
    fi
    
    info "Rolling back from version $current_version to version $target_version"
    info "Target version: $(format_version_display $target_version)"
    
    # Stop current container
    stop_container
    
    # Start container with target version
    start_container "$target_version"
    
    # Update version file
    update_version "$target_version"
    
    success "Rollback completed successfully! Now running version: $target_version"
}

# List available versions
list_versions() {
    info "Available versions:"
    echo "TAG                 CREATED             SIZE        FORMATTED TIME"
    echo "-------------------------------------------------------------------"
    
    # Show latest tag
    docker images "$IMAGE_NAME:latest" --format "{{.Tag}}\t\t{{.CreatedAt}}\t{{.Size}}" 2>/dev/null | head -1
    
    # Show timestamped versions with formatted display
    docker images "$IMAGE_NAME" --format "{{.Tag}}\t{{.CreatedAt}}\t{{.Size}}" | \
        grep -E '^[0-9]{12}' | \
        sort -r | \
        while IFS=$'\t' read -r tag created size; do
            formatted_time=$(format_version_display "$tag")
            printf "%-20s%-20s%-12s%s\n" "$tag" "$created" "$size" "$formatted_time"
        done
}

# Show container status
status() {
    info "Container status:"
    docker ps -a -f name="$CONTAINER_NAME" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}\t{{.Image}}"
    
    if docker ps -q -f name="$CONTAINER_NAME" | grep -q .; then
        echo ""
        info "Container logs (last 10 lines):"
        docker logs --tail=10 "$CONTAINER_NAME"
        
        echo ""
        info "Health check status:"
        local health_status=$(docker inspect --format='{{.State.Health.Status}}' "$CONTAINER_NAME" 2>/dev/null || echo "unknown")
        echo "Health: $health_status"
        
        if command -v curl >/dev/null 2>&1; then
            echo ""
            info "Quick health check:"
            curl -s "http://localhost:$PORT/system/health" | python3 -m json.tool 2>/dev/null || echo "Health check endpoint not responding"
        fi
    fi
}

# Show logs
logs() {
    local lines=${1:-50}
    if docker ps -q -f name="$CONTAINER_NAME" | grep -q .; then
        docker logs -f --tail="$lines" "$CONTAINER_NAME"
    else
        error "Container $CONTAINER_NAME is not running"
        exit 1
    fi
}

# Cleanup everything (dangerous!)
cleanup_all() {
    warning "This will remove ALL containers and images for this project!"
    read -p "Are you sure? (y/N): " -n 1 -r
    echo
    if [[ $REPLY =~ ^[Yy]$ ]]; then
        stop_container
        docker rmi $(docker images -q "$IMAGE_NAME") || true
        rm -f "$VERSION_FILE"
        success "Cleanup completed"
    else
        info "Cleanup cancelled"
    fi
}

# Show help
show_help() {
    cat << EOF
Docker Manager for $PROJECT_NAME

Usage: $0 [COMMAND] [OPTIONS]

Commands:
    deploy                    Build new version and deploy
    rollback [TIMESTAMP]      Rollback to previous version (or specified timestamp)
    start [TIMESTAMP]         Start container with specified version (default: latest)
    stop                      Stop and remove container
    restart                   Restart current container
    status                    Show container status and logs
    logs [LINES]              Show container logs (default: 50 lines)
    versions                  List available image versions
    cleanup                   Remove all images and containers (DANGEROUS!)
    help                      Show this help message

Examples:
    $0 deploy                      # Deploy new version with timestamp
    $0 rollback                    # Rollback to previous version
    $0 rollback 202412151430       # Rollback to specific timestamp
    $0 start 202412151430          # Start container with specific version
    $0 logs 100                    # Show last 100 log lines
    $0 status                      # Show current status

Configuration:
    Project: $PROJECT_NAME
    Image: $IMAGE_NAME
    Container: $CONTAINER_NAME
    Port: $PORT
    Max versions: $MAX_VERSIONS
    Host model cache: $HOST_MODEL_CACHE
    Container model cache: $CONTAINER_MODEL_CACHE

Version Format:
    Versions use timestamp format: yyyyMMddHHmm (e.g., 202412151430 = 2024-12-15 14:30)
    This provides better traceability and automatic chronological ordering.

Model Cache:
    The script automatically mounts your local ModelScope cache directory
    to the container, avoiding re-downloading models on each deployment.

EOF
}

# Main script logic
main() {
    local command=${1:-"help"}
    
    case $command in
        "deploy")
            deploy
            ;;
        "rollback")
            rollback "$2"
            ;;
        "start")
            stop_container
            start_container "$2"
            ;;
        "stop")
            stop_container
            ;;
        "restart")
            stop_container
            start_container
            ;;
        "status")
            status
            ;;
        "logs")
            logs "$2"
            ;;
        "versions"|"list")
            list_versions
            ;;
        "cleanup")
            cleanup_all
            ;;
        "help"|"-h"|"--help")
            show_help
            ;;
        *)
            error "Unknown command: $command"
            show_help
            exit 1
            ;;
    esac
}

# Check if Docker is available
if ! command -v docker >/dev/null 2>&1; then
    error "Docker is not installed or not in PATH"
    exit 1
fi

# Create log file if it doesn't exist
touch "$LOG_FILE"

# Run main function
main "$@"