path: root/seaweedfs-rdma-sidecar/scripts/demo-e2e.sh

#!/bin/bash

# SeaweedFS RDMA End-to-End Demo Script
# This script demonstrates the complete integration between SeaweedFS and the RDMA sidecar

set -e

# Configuration
RDMA_ENGINE_SOCKET="/tmp/rdma-engine.sock"
DEMO_SERVER_PORT=8080
RUST_ENGINE_PID=""
DEMO_SERVER_PID=""

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

print_header() {
    echo -e "\n${PURPLE}===============================================${NC}"
    echo -e "${PURPLE}$1${NC}"
    echo -e "${PURPLE}===============================================${NC}\n"
}

print_step() {
    echo -e "${CYAN}🔵 $1${NC}"
}

print_success() {
    echo -e "${GREEN}✅ $1${NC}"
}

print_warning() {
    echo -e "${YELLOW}⚠️  $1${NC}"
}

print_error() {
    echo -e "${RED}❌ $1${NC}"
}

cleanup() {
    print_header "CLEANUP"
    
    if [[ -n "$DEMO_SERVER_PID" ]]; then
        print_step "Stopping demo server (PID: $DEMO_SERVER_PID)"
        kill $DEMO_SERVER_PID 2>/dev/null || true
        wait $DEMO_SERVER_PID 2>/dev/null || true
    fi
    
    if [[ -n "$RUST_ENGINE_PID" ]]; then
        print_step "Stopping Rust RDMA engine (PID: $RUST_ENGINE_PID)"
        kill $RUST_ENGINE_PID 2>/dev/null || true
        wait $RUST_ENGINE_PID 2>/dev/null || true
    fi
    
    # Clean up socket
    rm -f "$RDMA_ENGINE_SOCKET"
    
    print_success "Cleanup complete"
}

# Set up cleanup on exit
trap cleanup EXIT

build_components() {
    print_header "BUILDING COMPONENTS"
    
    print_step "Building Go components..."
    go build -o bin/demo-server ./cmd/demo-server
    go build -o bin/test-rdma ./cmd/test-rdma
    go build -o bin/sidecar ./cmd/sidecar
    print_success "Go components built"
    
    print_step "Building Rust RDMA engine..."
    cd rdma-engine
    cargo build --release
    cd ..
    print_success "Rust RDMA engine built"
}

start_rdma_engine() {
    print_header "STARTING RDMA ENGINE"
    
    print_step "Starting Rust RDMA engine..."
    ./rdma-engine/target/release/rdma-engine-server --debug &
    RUST_ENGINE_PID=$!
    
    # Wait for engine to be ready
    print_step "Waiting for RDMA engine to be ready..."
    for i in {1..10}; do
        if [[ -S "$RDMA_ENGINE_SOCKET" ]]; then
            print_success "RDMA engine ready (PID: $RUST_ENGINE_PID)"
            return 0
        fi
        sleep 1
    done
    
    print_error "RDMA engine failed to start"
    exit 1
}

start_demo_server() {
    print_header "STARTING DEMO SERVER"
    
    print_step "Starting SeaweedFS RDMA demo server..."
    ./bin/demo-server --port $DEMO_SERVER_PORT --rdma-socket "$RDMA_ENGINE_SOCKET" --enable-rdma --debug &
    DEMO_SERVER_PID=$!
    
    # Wait for server to be ready
    print_step "Waiting for demo server to be ready..."
    for i in {1..10}; do
        if curl -s "http://localhost:$DEMO_SERVER_PORT/health" > /dev/null 2>&1; then
            print_success "Demo server ready (PID: $DEMO_SERVER_PID)"
            return 0
        fi
        sleep 1
    done
    
    print_error "Demo server failed to start"
    exit 1
}

test_health_check() {
    print_header "HEALTH CHECK TEST"
    
    print_step "Testing health endpoint..."
    response=$(curl -s "http://localhost:$DEMO_SERVER_PORT/health")
    
    if echo "$response" | jq -e '.status == "healthy"' > /dev/null; then
        print_success "Health check passed"
        echo "$response" | jq '.'
    else
        print_error "Health check failed"
        echo "$response"
        exit 1
    fi
}

test_capabilities() {
    print_header "CAPABILITIES TEST"
    
    print_step "Testing capabilities endpoint..."
    response=$(curl -s "http://localhost:$DEMO_SERVER_PORT/stats")
    
    if echo "$response" | jq -e '.enabled == true' > /dev/null; then
        print_success "RDMA capabilities retrieved"
        echo "$response" | jq '.'
    else
        print_warning "RDMA not enabled, but HTTP fallback available"
        echo "$response" | jq '.'
    fi
}

test_needle_read() {
    print_header "NEEDLE READ TEST"
    
    print_step "Testing RDMA needle read..."
    response=$(curl -s "http://localhost:$DEMO_SERVER_PORT/read?volume=1&needle=12345&cookie=305419896&size=1024")
    
    if echo "$response" | jq -e '.success == true' > /dev/null; then
        is_rdma=$(echo "$response" | jq -r '.is_rdma')
        source=$(echo "$response" | jq -r '.source')
        duration=$(echo "$response" | jq -r '.duration')
        data_size=$(echo "$response" | jq -r '.data_size')
        
        if [[ "$is_rdma" == "true" ]]; then
            print_success "RDMA fast path used! Duration: $duration, Size: $data_size bytes"
        else
            print_warning "HTTP fallback used. Duration: $duration, Size: $data_size bytes"
        fi
        
        echo "$response" | jq '.'
    else
        print_error "Needle read failed"
        echo "$response"
        exit 1
    fi
}

test_benchmark() {
    print_header "PERFORMANCE BENCHMARK"
    
    print_step "Running performance benchmark..."
    response=$(curl -s "http://localhost:$DEMO_SERVER_PORT/benchmark?iterations=5&size=2048")
    
    if echo "$response" | jq -e '.benchmark_results' > /dev/null; then
        rdma_ops=$(echo "$response" | jq -r '.benchmark_results.rdma_ops')
        http_ops=$(echo "$response" | jq -r '.benchmark_results.http_ops')
        avg_latency=$(echo "$response" | jq -r '.benchmark_results.avg_latency')
        throughput=$(echo "$response" | jq -r '.benchmark_results.throughput_mbps')
        ops_per_sec=$(echo "$response" | jq -r '.benchmark_results.ops_per_sec')
        
        print_success "Benchmark completed:"
        echo -e "  ${BLUE}RDMA Operations:${NC} $rdma_ops"
        echo -e "  ${BLUE}HTTP Operations:${NC} $http_ops"
        echo -e "  ${BLUE}Average Latency:${NC} $avg_latency"
        echo -e "  ${BLUE}Throughput:${NC} $throughput MB/s"
        echo -e "  ${BLUE}Operations/sec:${NC} $ops_per_sec"
        
        echo -e "\n${BLUE}Full benchmark results:${NC}"
        echo "$response" | jq '.benchmark_results'
    else
        print_error "Benchmark failed"
        echo "$response"
        exit 1
    fi
}

test_direct_rdma() {
    print_header "DIRECT RDMA ENGINE TEST"
    
    print_step "Testing direct RDMA engine communication..."
    
    echo "Testing ping..."
    ./bin/test-rdma ping 2>/dev/null && print_success "Direct RDMA ping successful" || print_warning "Direct RDMA ping failed"
    
    echo -e "\nTesting capabilities..."
    ./bin/test-rdma capabilities 2>/dev/null | head -15 && print_success "Direct RDMA capabilities successful" || print_warning "Direct RDMA capabilities failed"
    
    echo -e "\nTesting direct read..."
    ./bin/test-rdma read --volume 1 --needle 12345 --size 1024 2>/dev/null > /dev/null && print_success "Direct RDMA read successful" || print_warning "Direct RDMA read failed"
}

show_demo_urls() {
    print_header "DEMO SERVER INFORMATION"
    
    echo -e "${GREEN}🌐 Demo server is running at: http://localhost:$DEMO_SERVER_PORT${NC}"
    echo -e "${GREEN}📱 Try these URLs:${NC}"
    echo -e "  ${BLUE}Home page:${NC}          http://localhost:$DEMO_SERVER_PORT/"
    echo -e "  ${BLUE}Health check:${NC}       http://localhost:$DEMO_SERVER_PORT/health"
    echo -e "  ${BLUE}Statistics:${NC}         http://localhost:$DEMO_SERVER_PORT/stats"
    echo -e "  ${BLUE}Read needle:${NC}        http://localhost:$DEMO_SERVER_PORT/read?volume=1&needle=12345&cookie=305419896&size=1024"
    echo -e "  ${BLUE}Benchmark:${NC}          http://localhost:$DEMO_SERVER_PORT/benchmark?iterations=5&size=2048"
    
    echo -e "\n${GREEN}📋 Example curl commands:${NC}"
    echo -e "  ${CYAN}curl \"http://localhost:$DEMO_SERVER_PORT/health\" | jq '.'${NC}"
    echo -e "  ${CYAN}curl \"http://localhost:$DEMO_SERVER_PORT/read?volume=1&needle=12345&size=1024\" | jq '.'${NC}"
    echo -e "  ${CYAN}curl \"http://localhost:$DEMO_SERVER_PORT/benchmark?iterations=10\" | jq '.benchmark_results'${NC}"
}

interactive_mode() {
    print_header "INTERACTIVE MODE"
    
    show_demo_urls
    
    echo -e "\n${YELLOW}Press Enter to run automated tests, or Ctrl+C to exit and explore manually...${NC}"
    read -r
}

main() {
    print_header "🚀 SEAWEEDFS RDMA END-TO-END DEMO"
    
    echo -e "${GREEN}This demonstration shows:${NC}"
    echo -e "  ✅ Complete Go ↔ Rust IPC integration"
    echo -e "  ✅ SeaweedFS RDMA client with HTTP fallback" 
    echo -e "  ✅ High-performance needle reads via RDMA"
    echo -e "  ✅ Performance benchmarking capabilities"
    echo -e "  ✅ Production-ready error handling and logging"
    
    # Check dependencies
    if ! command -v jq &> /dev/null; then
        print_error "jq is required for this demo. Please install it: brew install jq"
        exit 1
    fi
    
    if ! command -v curl &> /dev/null; then
        print_error "curl is required for this demo."
        exit 1
    fi
    
    # Build and start components
    build_components
    start_rdma_engine
    sleep 2  # Give engine time to fully initialize
    start_demo_server
    sleep 2  # Give server time to connect to engine
    
    # Show interactive information
    interactive_mode
    
    # Run automated tests
    test_health_check
    test_capabilities
    test_needle_read
    test_benchmark
    test_direct_rdma
    
    print_header "🎉 END-TO-END DEMO COMPLETE!"
    
    echo -e "${GREEN}All tests passed successfully!${NC}"
    echo -e "${BLUE}Key achievements demonstrated:${NC}"
    echo -e "  🚀 RDMA fast path working with mock operations"
    echo -e "  🔄 Automatic HTTP fallback when RDMA unavailable"
    echo -e "  📊 Performance monitoring and benchmarking"
    echo -e "  🛡️  Robust error handling and graceful degradation"
    echo -e "  🔌 Complete IPC protocol between Go and Rust"
    echo -e "  ⚡ Session management with proper cleanup"
    
    print_success "SeaweedFS RDMA integration is ready for hardware deployment!"
    
    # Keep server running for manual testing
    echo -e "\n${YELLOW}Demo server will continue running for manual testing...${NC}"
    echo -e "${YELLOW}Press Ctrl+C to shutdown.${NC}"
    
    # Wait for user interrupt
    wait
}

# Run the main function
main "$@"