You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
314 lines
10 KiB
314 lines
10 KiB
#!/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 "$@"
|