388 lines
12 KiB
Markdown
388 lines
12 KiB
Markdown
# New deploy_lt.sh Script
|
|
|
|
This is the complete new deployment script for static binary deployment. Save this as `deploy_lt.sh` in the project root.
|
|
|
|
```bash
|
|
#!/bin/bash
|
|
set -e
|
|
|
|
# Colors for output
|
|
RED='\033[0;31m'
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[1;33m'
|
|
BLUE='\033[0;34m'
|
|
NC='\033[0m'
|
|
|
|
print_status() { echo -e "${BLUE}[INFO]${NC} $1"; }
|
|
print_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
|
|
print_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
|
|
print_error() { echo -e "${RED}[ERROR]${NC} $1"; }
|
|
|
|
# Parse command line arguments
|
|
FRESH_INSTALL=false
|
|
MIGRATE_DATA=true
|
|
if [[ "$1" == "--fresh" ]]; then
|
|
FRESH_INSTALL=true
|
|
MIGRATE_DATA=false
|
|
elif [[ "$1" == "--no-migrate" ]]; then
|
|
MIGRATE_DATA=false
|
|
fi
|
|
|
|
# Configuration
|
|
REMOTE_HOST="laantungir.net"
|
|
REMOTE_USER="ubuntu"
|
|
|
|
# New paths (static binary deployment)
|
|
REMOTE_BINARY_DIR="/usr/local/bin/ginxsom"
|
|
REMOTE_BINARY_PATH="$REMOTE_BINARY_DIR/ginxsom-fcgi"
|
|
REMOTE_DB_DIR="/var/lib/ginxsom"
|
|
REMOTE_DB_PATH="$REMOTE_DB_DIR/ginxsom.db"
|
|
REMOTE_BLOB_DIR="/var/www/blobs"
|
|
REMOTE_SOCKET="/tmp/ginxsom-fcgi.sock"
|
|
|
|
# Old paths (for migration)
|
|
OLD_BINARY_PATH="/home/ubuntu/ginxsom/ginxsom.fcgi"
|
|
OLD_DB_PATH="/home/ubuntu/ginxsom/db/ginxsom.db"
|
|
OLD_BLOB_DIR="/var/www/html/blossom"
|
|
|
|
# Local paths
|
|
LOCAL_BINARY="build/ginxsom-fcgi_static_x86_64"
|
|
|
|
print_status "=========================================="
|
|
print_status "Ginxsom Static Binary Deployment"
|
|
print_status "=========================================="
|
|
print_status "Target: $REMOTE_HOST"
|
|
print_status "Binary: $REMOTE_BINARY_PATH"
|
|
print_status "Database: $REMOTE_DB_PATH"
|
|
print_status "Blobs: $REMOTE_BLOB_DIR"
|
|
print_status "Fresh install: $FRESH_INSTALL"
|
|
print_status "Migrate data: $MIGRATE_DATA"
|
|
print_status "=========================================="
|
|
echo ""
|
|
|
|
# Step 1: Verify local binary exists
|
|
print_status "Step 1: Verifying local static binary..."
|
|
if [[ ! -f "$LOCAL_BINARY" ]]; then
|
|
print_error "Static binary not found: $LOCAL_BINARY"
|
|
print_status "Please run: ./build_static.sh"
|
|
exit 1
|
|
fi
|
|
|
|
# Verify it's actually static
|
|
if ldd "$LOCAL_BINARY" 2>&1 | grep -q "not a dynamic executable\|statically linked"; then
|
|
print_success "Binary is static"
|
|
else
|
|
print_warning "Binary may not be fully static - proceeding anyway"
|
|
fi
|
|
|
|
BINARY_SIZE=$(du -h "$LOCAL_BINARY" | cut -f1)
|
|
print_success "Found static binary ($BINARY_SIZE)"
|
|
echo ""
|
|
|
|
# Step 2: Upload binary to server
|
|
print_status "Step 2: Uploading binary to server..."
|
|
scp "$LOCAL_BINARY" $REMOTE_USER@$REMOTE_HOST:/tmp/ginxsom-fcgi_new || {
|
|
print_error "Failed to upload binary"
|
|
exit 1
|
|
}
|
|
print_success "Binary uploaded to /tmp/ginxsom-fcgi_new"
|
|
echo ""
|
|
|
|
# Step 3: Setup directories and install binary
|
|
print_status "Step 3: Setting up directories and installing binary..."
|
|
ssh $REMOTE_USER@$REMOTE_HOST << EOF
|
|
set -e
|
|
|
|
# Create binary directory
|
|
echo "Creating binary directory..."
|
|
sudo mkdir -p $REMOTE_BINARY_DIR
|
|
|
|
# Create database directory
|
|
echo "Creating database directory..."
|
|
sudo mkdir -p $REMOTE_DB_DIR/backups
|
|
sudo chown www-data:www-data $REMOTE_DB_DIR
|
|
sudo chmod 755 $REMOTE_DB_DIR
|
|
|
|
# Create blob storage directory
|
|
echo "Creating blob storage directory..."
|
|
sudo mkdir -p $REMOTE_BLOB_DIR
|
|
sudo chown www-data:www-data $REMOTE_BLOB_DIR
|
|
sudo chmod 755 $REMOTE_BLOB_DIR
|
|
|
|
echo "Directories created successfully"
|
|
EOF
|
|
|
|
if [ $? -ne 0 ]; then
|
|
print_error "Failed to create directories"
|
|
exit 1
|
|
fi
|
|
print_success "Directories created"
|
|
echo ""
|
|
|
|
# Step 4: Migrate data if requested
|
|
if [ "$MIGRATE_DATA" = true ] && [ "$FRESH_INSTALL" = false ]; then
|
|
print_status "Step 4: Migrating existing data..."
|
|
ssh $REMOTE_USER@$REMOTE_HOST << EOF
|
|
set -e
|
|
|
|
# Migrate database
|
|
if [ -f $OLD_DB_PATH ]; then
|
|
echo "Migrating database from $OLD_DB_PATH..."
|
|
sudo cp $OLD_DB_PATH $REMOTE_DB_PATH
|
|
sudo chown www-data:www-data $REMOTE_DB_PATH
|
|
sudo chmod 644 $REMOTE_DB_PATH
|
|
echo "Database migrated"
|
|
elif [ -f $OLD_BLOB_DIR/ginxsom.db ]; then
|
|
echo "Migrating database from $OLD_BLOB_DIR/ginxsom.db..."
|
|
sudo cp $OLD_BLOB_DIR/ginxsom.db $REMOTE_DB_PATH
|
|
sudo chown www-data:www-data $REMOTE_DB_PATH
|
|
sudo chmod 644 $REMOTE_DB_PATH
|
|
echo "Database migrated"
|
|
else
|
|
echo "No existing database found - will be created on first run"
|
|
fi
|
|
|
|
# Migrate blobs
|
|
if [ -d $OLD_BLOB_DIR ] && [ "\$(ls -A $OLD_BLOB_DIR 2>/dev/null)" ]; then
|
|
echo "Migrating blobs from $OLD_BLOB_DIR..."
|
|
# Copy only blob files (SHA256 hashes with extensions)
|
|
sudo find $OLD_BLOB_DIR -type f -regextype posix-extended -regex '.*/[a-f0-9]{64}\.[a-z0-9]+' -exec cp {} $REMOTE_BLOB_DIR/ \; 2>/dev/null || true
|
|
sudo chown -R www-data:www-data $REMOTE_BLOB_DIR
|
|
BLOB_COUNT=\$(ls -1 $REMOTE_BLOB_DIR | wc -l)
|
|
echo "Migrated \$BLOB_COUNT blob files"
|
|
else
|
|
echo "No existing blobs found"
|
|
fi
|
|
EOF
|
|
|
|
if [ $? -eq 0 ]; then
|
|
print_success "Data migration completed"
|
|
else
|
|
print_warning "Data migration had issues - check manually"
|
|
fi
|
|
echo ""
|
|
elif [ "$FRESH_INSTALL" = true ]; then
|
|
print_status "Step 4: Fresh install - removing existing data..."
|
|
ssh $REMOTE_USER@$REMOTE_HOST << EOF
|
|
sudo rm -f $REMOTE_DB_PATH
|
|
sudo rm -rf $REMOTE_BLOB_DIR/*
|
|
echo "Existing data removed"
|
|
EOF
|
|
print_success "Fresh install prepared"
|
|
echo ""
|
|
else
|
|
print_status "Step 4: Skipping data migration (--no-migrate)"
|
|
echo ""
|
|
fi
|
|
|
|
# Step 5: Install minimal dependencies
|
|
print_status "Step 5: Installing minimal dependencies..."
|
|
ssh $REMOTE_USER@$REMOTE_HOST << 'EOF'
|
|
set -e
|
|
|
|
# Check if spawn-fcgi is installed
|
|
if ! command -v spawn-fcgi &> /dev/null; then
|
|
echo "Installing spawn-fcgi..."
|
|
sudo apt-get update -qq
|
|
sudo apt-get install -y spawn-fcgi
|
|
echo "spawn-fcgi installed"
|
|
else
|
|
echo "spawn-fcgi already installed"
|
|
fi
|
|
EOF
|
|
|
|
if [ $? -eq 0 ]; then
|
|
print_success "Dependencies verified"
|
|
else
|
|
print_error "Failed to install dependencies"
|
|
exit 1
|
|
fi
|
|
echo ""
|
|
|
|
# Step 6: Stop existing service and install new binary
|
|
print_status "Step 6: Stopping existing service and installing new binary..."
|
|
ssh $REMOTE_USER@$REMOTE_HOST << EOF
|
|
set -e
|
|
|
|
# Stop any existing ginxsom processes
|
|
echo "Stopping existing ginxsom processes..."
|
|
sudo pkill -f ginxsom-fcgi || true
|
|
sleep 2
|
|
|
|
# Remove old socket
|
|
sudo rm -f $REMOTE_SOCKET
|
|
|
|
# Install new binary
|
|
echo "Installing new binary..."
|
|
sudo mv /tmp/ginxsom-fcgi_new $REMOTE_BINARY_PATH
|
|
sudo chmod +x $REMOTE_BINARY_PATH
|
|
sudo chown root:root $REMOTE_BINARY_PATH
|
|
|
|
echo "Binary installed successfully"
|
|
EOF
|
|
|
|
if [ $? -eq 0 ]; then
|
|
print_success "Binary installed"
|
|
else
|
|
print_error "Failed to install binary"
|
|
exit 1
|
|
fi
|
|
echo ""
|
|
|
|
# Step 7: Start ginxsom FastCGI process
|
|
print_status "Step 7: Starting ginxsom FastCGI process..."
|
|
ssh $REMOTE_USER@$REMOTE_HOST << EOF
|
|
set -e
|
|
|
|
echo "Starting ginxsom FastCGI with configuration:"
|
|
echo " Binary: $REMOTE_BINARY_PATH"
|
|
echo " Database: $REMOTE_DB_PATH"
|
|
echo " Storage: $REMOTE_BLOB_DIR"
|
|
echo " Socket: $REMOTE_SOCKET"
|
|
echo ""
|
|
|
|
sudo spawn-fcgi \
|
|
-M 666 \
|
|
-u www-data \
|
|
-g www-data \
|
|
-s $REMOTE_SOCKET \
|
|
-U www-data \
|
|
-G www-data \
|
|
-d $REMOTE_DB_DIR \
|
|
-- $REMOTE_BINARY_PATH \
|
|
--db-path $REMOTE_DB_PATH \
|
|
--storage-dir $REMOTE_BLOB_DIR
|
|
|
|
# Give it a moment to start
|
|
sleep 2
|
|
|
|
# Verify process is running
|
|
if [ -S $REMOTE_SOCKET ]; then
|
|
echo "FastCGI socket created successfully"
|
|
ls -la $REMOTE_SOCKET
|
|
else
|
|
echo "ERROR: Socket not created"
|
|
exit 1
|
|
fi
|
|
|
|
# Check if process is running
|
|
if pgrep -f ginxsom-fcgi > /dev/null; then
|
|
echo "Process is running (PID: \$(pgrep -f ginxsom-fcgi))"
|
|
else
|
|
echo "WARNING: Process not found by pgrep (may be normal for FastCGI)"
|
|
fi
|
|
EOF
|
|
|
|
if [ $? -eq 0 ]; then
|
|
print_success "FastCGI process started"
|
|
else
|
|
print_error "Failed to start FastCGI process"
|
|
exit 1
|
|
fi
|
|
echo ""
|
|
|
|
# Step 8: Test nginx configuration and reload
|
|
print_status "Step 8: Testing and reloading nginx..."
|
|
ssh $REMOTE_USER@$REMOTE_HOST << 'EOF'
|
|
# Test nginx configuration
|
|
if sudo nginx -t 2>&1; then
|
|
echo "Nginx configuration test passed"
|
|
sudo nginx -s reload
|
|
echo "Nginx reloaded successfully"
|
|
else
|
|
echo "WARNING: Nginx configuration test failed"
|
|
echo "You may need to update nginx configuration manually"
|
|
echo "See docs/STATIC_DEPLOYMENT_PLAN.md for details"
|
|
fi
|
|
EOF
|
|
|
|
if [ $? -eq 0 ]; then
|
|
print_success "Nginx reloaded"
|
|
else
|
|
print_warning "Nginx reload had issues - check configuration"
|
|
fi
|
|
echo ""
|
|
|
|
# Step 9: Test deployment
|
|
print_status "Step 9: Testing deployment..."
|
|
echo ""
|
|
|
|
# Wait a moment for service to fully start
|
|
sleep 2
|
|
|
|
# Test health endpoint
|
|
echo "Testing health endpoint..."
|
|
if curl -k -s --max-time 10 "https://blossom.laantungir.net/health" | grep -q "OK"; then
|
|
print_success "✓ Health check passed"
|
|
else
|
|
print_warning "✗ Health check failed - checking response..."
|
|
curl -k -v --max-time 10 "https://blossom.laantungir.net/health" 2>&1 | head -10
|
|
fi
|
|
|
|
# Test root endpoint
|
|
echo ""
|
|
echo "Testing root endpoint..."
|
|
if curl -k -s --max-time 10 "https://blossom.laantungir.net/" | grep -q "Ginxsom"; then
|
|
print_success "✓ Root endpoint responding"
|
|
else
|
|
print_warning "✗ Root endpoint not responding as expected"
|
|
fi
|
|
|
|
echo ""
|
|
print_status "=========================================="
|
|
print_success "Deployment completed!"
|
|
print_status "=========================================="
|
|
echo ""
|
|
print_status "Service Information:"
|
|
echo " URL: https://blossom.laantungir.net"
|
|
echo " Binary: $REMOTE_BINARY_PATH"
|
|
echo " Database: $REMOTE_DB_PATH"
|
|
echo " Blobs: $REMOTE_BLOB_DIR"
|
|
echo " Socket: $REMOTE_SOCKET"
|
|
echo ""
|
|
print_status "Test Commands:"
|
|
echo " Health: curl -k https://blossom.laantungir.net/health"
|
|
echo " Info: curl -k https://blossom.laantungir.net/"
|
|
echo " Upload: ./tests/file_put_bud02.sh"
|
|
echo ""
|
|
print_status "Server Commands:"
|
|
echo " Check status: ssh $REMOTE_USER@$REMOTE_HOST 'ps aux | grep ginxsom-fcgi'"
|
|
echo " View logs: ssh $REMOTE_USER@$REMOTE_HOST 'sudo journalctl -f | grep ginxsom'"
|
|
echo " Restart: ssh $REMOTE_USER@$REMOTE_HOST 'sudo pkill ginxsom-fcgi && sudo spawn-fcgi ...'"
|
|
echo ""
|
|
|
|
if [ "$FRESH_INSTALL" = true ]; then
|
|
print_warning "Fresh install completed - database and blobs have been reset"
|
|
fi
|
|
|
|
if [ "$MIGRATE_DATA" = true ] && [ "$FRESH_INSTALL" = false ]; then
|
|
print_status "Data migration completed - verify blob count and database"
|
|
echo " Check blobs: ssh $REMOTE_USER@$REMOTE_HOST 'ls -la $REMOTE_BLOB_DIR | wc -l'"
|
|
echo " Check DB: ssh $REMOTE_USER@$REMOTE_HOST 'sudo -u www-data sqlite3 $REMOTE_DB_PATH \"SELECT COUNT(*) FROM blobs;\"'"
|
|
fi
|
|
|
|
echo ""
|
|
print_status "For nginx configuration updates, see: docs/STATIC_DEPLOYMENT_PLAN.md"
|
|
print_status "=========================================="
|
|
```
|
|
|
|
## Usage
|
|
|
|
```bash
|
|
# Normal deployment with data migration
|
|
./deploy_lt.sh
|
|
|
|
# Fresh install (removes all data)
|
|
./deploy_lt.sh --fresh
|
|
|
|
# Deploy without migrating data
|
|
./deploy_lt.sh --no-migrate
|
|
```
|
|
|
|
## Key Changes from Old Script
|
|
|
|
1. **No remote compilation** - uploads pre-built static binary
|
|
2. **New directory structure** - follows FHS standards
|
|
3. **Minimal dependencies** - only spawn-fcgi needed
|
|
4. **Data migration** - automatically migrates from old locations
|
|
5. **Simplified process** - ~30 seconds vs ~5-10 minutes |