cat << EOF

while [[ $# -gt 0 ]]; do

case $1 in

-e|--environment)

ENVIRONMENT="$2"

shift 2

;;

-v|--version)

VERSION="$2"

shift 2

;;

-s|--strategy)

DEPLOYMENT_STRATEGY="$2"

shift 2

;;

-d|--dry-run)

DRY_RUN="true"

shift

;;

-t|--skip-tests)

SKIP_TESTS="true"

shift

;;

-h|--health-timeout)

HEALTH_CHECK_TIMEOUT="$2"

shift 2

;;

-r|--no-rollback)

ROLLBACK_ON_FAILURE="false"

shift

;;

--help)

usage

exit 0

;;

*)

error "Unknown option: $1"

usage

exit 1

;;

esac

done

case $ENVIRONMENT in

dev|staging|prod)

log "Deploying to $ENVIRONMENT environment"

;;

*)

error "Invalid environment: $ENVIRONMENT. Must be one of: dev, staging, prod"

exit 1

;;

esac

case $DEPLOYMENT_STRATEGY in

rolling|blue-green|canary)

log "Using $DEPLOYMENT_STRATEGY deployment strategy"

;;

*)

error "Invalid deployment strategy: $DEPLOYMENT_STRATEGY. Must be one of: rolling, blue-green, canary"

exit 1

;;

esac

log "Validating prerequisites..."

# Check required tools

local required_tools=("kubectl" "docker" "helm" "jq")

for tool in "${required_tools[@]}"; do

if ! command -v "$tool" &> /dev/null; then

error "$tool is required but not installed"

exit 1

fi

done

# Check kubectl context

if ! kubectl config current-context &> /dev/null; then

error "kubectl context not set. Please configure kubectl"

exit 1

fi

# Check Docker registry access

if [[ -n "${DOCKER_REGISTRY:-}" ]]; then

if ! docker info &> /dev/null; then

error "Docker daemon is not running"

exit 1

fi

fi

# Check Helm

if ! helm version &> /dev/null; then

error "Helm is not properly configured"

exit 1

fi

success "All prerequisites validated"

if [[ "$SKIP_TESTS" == "true" ]]; then

warn "Skipping pre-deployment tests"

return 0

fi

log "Running pre-deployment tests..."

cd "$PROJECT_ROOT"

# Run unit tests

if ! npm run test:unit; then

error "Unit tests failed"

return 1

fi

# Run integration tests

if ! npm run test:integration; then

error "Integration tests failed"

return 1

fi

# Run security checks

if ! npm run security:check; then

warn "Security checks failed, but continuing deployment"

fi

# Run linting

if ! npm run lint; then

error "Linting failed"

return 1

fi

success "Pre-deployment tests passed"

log "Building and pushing Docker images..."

local registry="${DOCKER_REGISTRY:-ghcr.io}"

local image_name="${registry}/sightedit/sightedit"

local image_tag="${VERSION}"

cd "$PROJECT_ROOT"

# Build image

if [[ "$DRY_RUN" == "false" ]]; then

docker build \

--build-arg VERSION="$VERSION" \

--build-arg ENVIRONMENT="$ENVIRONMENT" \

-t "${image_name}:${image_tag}" \

-t "${image_name}:latest" \

.

# Push images

docker push "${image_name}:${image_tag}"

if [[ "$image_tag" != "latest" ]]; then

docker push "${image_name}:latest"

fi

else

log "DRY RUN: Would build and push ${image_name}:${image_tag}"

fi

success "Docker images built and pushed"

log "Deploying application using $DEPLOYMENT_STRATEGY strategy..."

case $DEPLOYMENT_STRATEGY in

rolling)

deploy_rolling

;;

blue-green)

deploy_blue_green

;;

canary)

deploy_canary

;;

esac

success "Application deployment initiated"

log "Performing rolling deployment..."

local namespace="sightedit"

local deployment_name="sightedit-backend"

if [[ "$DRY_RUN" == "false" ]]; then

# Update image in deployment

kubectl set image \

deployment/$deployment_name \

backend="ghcr.io/sightedit/sightedit:$VERSION" \

-n "$namespace"

# Wait for rollout to complete

kubectl rollout status \

deployment/$deployment_name \

-n "$namespace" \

--timeout=600s

else

log "DRY RUN: Would perform rolling update on $deployment_name"

fi

log "Performing blue-green deployment..."

if [[ "$DRY_RUN" == "false" ]]; then

# Use Argo Rollouts for blue-green deployment

kubectl argo rollouts set image \

sightedit-backend-blue-green \

backend="ghcr.io/sightedit/sightedit:$VERSION" \

-n sightedit

# Wait for analysis to complete

kubectl argo rollouts get rollout \

sightedit-backend-blue-green \

-n sightedit \

--watch

else

log "DRY RUN: Would perform blue-green deployment"

fi

log "Performing canary deployment..."

if [[ "$DRY_RUN" == "false" ]]; then

# Use Argo Rollouts for canary deployment

kubectl argo rollouts set image \

sightedit-backend-canary \

backend="ghcr.io/sightedit/sightedit:$VERSION" \

-n sightedit

# Monitor canary progress

kubectl argo rollouts get rollout \

sightedit-backend-canary \

-n sightedit \

--watch

else

log "DRY RUN: Would perform canary deployment"

fi

log "Performing health checks..."

local namespace="sightedit"

local service_name="sightedit-backend-service"

local health_endpoint="/health"

local timeout=$HEALTH_CHECK_TIMEOUT

local interval=10

local elapsed=0

if [[ "$DRY_RUN" == "true" ]]; then

log "DRY RUN: Would perform health checks"

return 0

fi

# Port forward to access the service

kubectl port-forward \

"service/$service_name" 8080:3000 \

-n "$namespace" &

local port_forward_pid=$!

# Wait for port forward to be ready

sleep 5

# Perform health checks

while [[ $elapsed -lt $timeout ]]; do

if curl -f "http://localhost:8080$health_endpoint" &> /dev/null; then

success "Health check passed"

kill $port_forward_pid 2>/dev/null || true

return 0

fi

log "Health check failed, retrying in ${interval}s... (${elapsed}s/${timeout}s)"

sleep $interval

elapsed=$((elapsed + interval))

done

kill $port_forward_pid 2>/dev/null || true

error "Health checks failed after ${timeout}s"

return 1

log "Rolling back deployment..."

local namespace="sightedit"

local deployment_name="sightedit-backend"

if [[ "$DRY_RUN" == "false" ]]; then

case $DEPLOYMENT_STRATEGY in

rolling)

kubectl rollout undo deployment/$deployment_name -n "$namespace"

kubectl rollout status deployment/$deployment_name -n "$namespace"

;;

blue-green|canary)

kubectl argo rollouts abort sightedit-backend-* -n "$namespace"

kubectl argo rollouts undo sightedit-backend-* -n "$namespace"

;;

esac

else

log "DRY RUN: Would rollback deployment"

fi

success "Rollback completed"

local status=$1

local message=$2

if [[ -n "${SLACK_WEBHOOK_URL:-}" ]]; then

local color

case $status in

success) color="good" ;;

warning) color="warning" ;;

error) color="danger" ;;

*) color="#000000" ;;

esac

curl -X POST -H 'Content-type: application/json' \

--data "{

}" \

"$SLACK_WEBHOOK_URL" || warn "Failed to send Slack notification"

fi

log "Performing cleanup..."

# Kill any background processes

jobs -p | xargs -r kill 2>/dev/null || true

# Clean up temporary files

rm -f /tmp/sightedit-deploy-*.tmp || true

log "Cleanup completed"

log "Starting SightEdit deployment..."

log "Environment: $ENVIRONMENT"

log "Version: $VERSION"

log "Strategy: $DEPLOYMENT_STRATEGY"

log "Dry Run: $DRY_RUN"

log "Log File: $LOG_FILE"

# Trap for cleanup on exit

trap cleanup EXIT

# Start deployment

local deployment_success=false

if validate_prerequisites &&

run_pre_deployment_tests &&

build_and_push_images &&

deploy_application &&

perform_health_checks; then

deployment_success=true

success "Deployment completed successfully!"

send_notification "success" "✅ Deployment to $ENVIRONMENT completed successfully"

else

error "Deployment failed"

send_notification "error" "❌ Deployment to $ENVIRONMENT failed"

if [[ "$ROLLBACK_ON_FAILURE" == "true" && "$DRY_RUN" == "false" ]]; then

warn "Initiating automatic rollback..."

if rollback_deployment; then

send_notification "warning" "⚠️ Deployment failed but rollback completed successfully"

else

send_notification "error" "🚨 Deployment and rollback both failed - manual intervention required"

fi

fi

fi

# Exit with appropriate code

if [[ "$deployment_success" == "true" ]]; then

exit 0

else

exit 1

fi