240 lines
9.4 KiB
Bash
Executable File
240 lines
9.4 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
set -e
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
|
|
|
|
# Colors
|
|
RED='\033[0;31m'
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[1;33m'
|
|
BLUE='\033[0;34m'
|
|
NC='\033[0m'
|
|
|
|
usage() {
|
|
echo "Usage: $0 [dev|prod]"
|
|
echo ""
|
|
echo "Initialize database schema and create admin user."
|
|
echo ""
|
|
echo " dev - Initialize dev environment (minikube, default namespace)"
|
|
echo " prod - Initialize prod environment (requires confirmation)"
|
|
exit 1
|
|
}
|
|
|
|
ENV="${1:-dev}"
|
|
|
|
if [[ "$ENV" != "dev" && "$ENV" != "prod" ]]; then
|
|
echo -e "${RED}Error: Environment must be 'dev' or 'prod'${NC}"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$ENV" == "prod" ]]; then
|
|
KUBECTL="kubectl --context=prod"
|
|
BASE_URL="https://dexorder.ai"
|
|
MCP_URL="https://dexorder.ai/mcp"
|
|
echo -e "${YELLOW}⚠️ WARNING: Initializing PRODUCTION environment!${NC}"
|
|
echo -e "${YELLOW}kubectl context: prod${NC}"
|
|
read -p "Are you sure you want to continue? (yes/no): " confirm
|
|
if [[ "$confirm" != "yes" ]]; then
|
|
echo "Aborted."
|
|
exit 0
|
|
fi
|
|
else
|
|
KUBECTL="kubectl"
|
|
BASE_URL="http://dexorder.local"
|
|
MCP_URL="http://localhost:8080/mcp"
|
|
fi
|
|
|
|
# ---------- MinIO Bucket Initialization ----------
|
|
|
|
echo ""
|
|
echo -e "${BLUE}=== MinIO Storage Setup ===${NC}"
|
|
echo ""
|
|
|
|
echo -e "${BLUE}Waiting for MinIO pod...${NC}"
|
|
$KUBECTL wait --for=condition=ready --timeout=120s pod -l app=minio 2>/dev/null || {
|
|
echo -e "${YELLOW}⚠️ MinIO not ready after 120s, skipping bucket setup${NC}"
|
|
}
|
|
|
|
MINIO_POD=$($KUBECTL get pods -l app=minio -o jsonpath='{.items[0].metadata.name}' 2>/dev/null)
|
|
if [ -n "$MINIO_POD" ]; then
|
|
echo -e "${GREEN}→${NC} Ensuring warehouse bucket exists..."
|
|
MINIO_USER=$($KUBECTL exec "$MINIO_POD" -- sh -c 'echo $MINIO_ROOT_USER' 2>/dev/null | tr -d '\r')
|
|
MINIO_PASS=$($KUBECTL exec "$MINIO_POD" -- sh -c 'echo $MINIO_ROOT_PASSWORD' 2>/dev/null | tr -d '\r')
|
|
$KUBECTL exec "$MINIO_POD" -- mc alias set local http://localhost:9000 "$MINIO_USER" "$MINIO_PASS" > /dev/null 2>&1
|
|
$KUBECTL exec "$MINIO_POD" -- mc mb --ignore-existing local/warehouse > /dev/null 2>&1
|
|
echo -e "${GREEN}✓ Warehouse bucket ready${NC}"
|
|
else
|
|
echo -e "${YELLOW}⚠️ MinIO pod not found, skipping bucket setup${NC}"
|
|
fi
|
|
|
|
# ---------- Schema Initialization ----------
|
|
|
|
echo ""
|
|
echo -e "${BLUE}=== Schema Initialization ===${NC}"
|
|
echo ""
|
|
|
|
echo -e "${BLUE}Waiting for postgres pod...${NC}"
|
|
$KUBECTL wait --for=condition=ready --timeout=180s pod -l app=postgres 2>/dev/null || {
|
|
echo -e "${RED}Postgres not ready after 180s${NC}"
|
|
exit 1
|
|
}
|
|
|
|
PG_POD=$($KUBECTL get pods -l app=postgres -o jsonpath='{.items[0].metadata.name}' 2>/dev/null)
|
|
if [ -z "$PG_POD" ]; then
|
|
echo -e "${RED}No postgres pod found${NC}"
|
|
exit 1
|
|
fi
|
|
echo -e "${GREEN}Found postgres pod: $PG_POD${NC}"
|
|
|
|
# Wait for postgres to accept connections
|
|
echo -e "${BLUE}Waiting for postgres to accept connections...${NC}"
|
|
for i in $(seq 1 30); do
|
|
if $KUBECTL exec "$PG_POD" -- psql -U postgres -d iceberg -c "SELECT 1;" > /dev/null 2>&1; then
|
|
echo -e "${GREEN}Postgres ready${NC}"
|
|
break
|
|
fi
|
|
if [[ $i -eq 30 ]]; then
|
|
echo -e "${RED}Postgres not accepting connections after 60s${NC}"
|
|
exit 1
|
|
fi
|
|
sleep 2
|
|
done
|
|
|
|
# Check if schema exists
|
|
TABLE_COUNT=$($KUBECTL exec "$PG_POD" -- psql -U postgres -d iceberg -t \
|
|
-c "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'user';" \
|
|
2>/dev/null | tr -d ' \n')
|
|
|
|
if [[ "$TABLE_COUNT" == "1" ]]; then
|
|
echo -e "${GREEN}✓ Schema already initialized${NC}"
|
|
else
|
|
echo -e "${BLUE}Applying gateway schema...${NC}"
|
|
$KUBECTL exec -i "$PG_POD" -- psql -U postgres -d iceberg < "$ROOT_DIR/gateway/schema.sql"
|
|
echo -e "${GREEN}✓ Schema applied${NC}"
|
|
fi
|
|
|
|
# ---------- Admin User Creation ----------
|
|
|
|
echo ""
|
|
echo -e "${BLUE}=== Admin User Setup ===${NC}"
|
|
echo ""
|
|
|
|
if [[ "$ENV" == "dev" ]]; then
|
|
# Dev: use fixed credentials
|
|
USER_EMAIL="tim@dexorder.ai"
|
|
USER_PASSWORD="test1234"
|
|
USER_NAME="Tim"
|
|
LICENSE_TYPE="pro"
|
|
echo -e "${BLUE}Using dev defaults: $USER_EMAIL / $USER_PASSWORD ($LICENSE_TYPE)${NC}"
|
|
else
|
|
# Prod: prompt for credentials
|
|
read -p "Admin email: " USER_EMAIL
|
|
read -rs -p "Admin password (min 8 chars): " USER_PASSWORD
|
|
echo ""
|
|
echo -e "${BLUE}Password captured: ${#USER_PASSWORD} characters${NC}"
|
|
if [[ ${#USER_PASSWORD} -lt 8 ]]; then
|
|
echo -e "${RED}✗ Password must be at least 8 characters${NC}"
|
|
exit 1
|
|
fi
|
|
read -p "Admin display name: " USER_NAME
|
|
read -p "License type [free|pro|enterprise] (default: pro): " LICENSE_TYPE
|
|
LICENSE_TYPE="${LICENSE_TYPE:-pro}"
|
|
fi
|
|
|
|
# Check if user already exists
|
|
EXISTING_ID=$($KUBECTL exec "$PG_POD" -- psql -U postgres -d iceberg -t \
|
|
-c "SELECT id FROM \"user\" WHERE email = '$USER_EMAIL';" \
|
|
2>/dev/null | tr -d ' \n')
|
|
|
|
if [ -n "$EXISTING_ID" ]; then
|
|
echo -e "${GREEN}✓ User already exists in database ($USER_EMAIL)${NC}"
|
|
USER_ID="$EXISTING_ID"
|
|
else
|
|
# Register via API
|
|
echo -e "${BLUE}Waiting for gateway...${NC}"
|
|
$KUBECTL wait --for=condition=available --timeout=120s deployment/gateway 2>/dev/null || {
|
|
echo -e "${YELLOW}⚠️ Gateway not ready after 120s, trying anyway${NC}"
|
|
}
|
|
sleep 3
|
|
|
|
echo -e "${GREEN}→${NC} Registering user via API..."
|
|
PAYLOAD=$(jq -n \
|
|
--arg email "$USER_EMAIL" \
|
|
--arg password "$USER_PASSWORD" \
|
|
--arg name "$USER_NAME" \
|
|
'{email: $email, password: $password, name: $name}')
|
|
|
|
HTTP_CODE=$(curl -s -o /tmp/dexorder-init-response.json -w "%{http_code}" \
|
|
-X POST "$BASE_URL/api/auth/register" \
|
|
-H "Content-Type: application/json" \
|
|
-d "$PAYLOAD")
|
|
|
|
if [[ "$HTTP_CODE" == "200" || "$HTTP_CODE" == "201" ]]; then
|
|
echo -e "${GREEN}✓ User registered via API${NC}"
|
|
elif [[ "$HTTP_CODE" == "400" ]]; then
|
|
RESPONSE=$(cat /tmp/dexorder-init-response.json 2>/dev/null)
|
|
# Check if this is a "user already exists" 400 vs a validation error
|
|
if echo "$RESPONSE" | grep -qi "already exist\|user already\|duplicate"; then
|
|
echo -e "${YELLOW}⚠️ User already exists, continuing...${NC}"
|
|
else
|
|
echo -e "${RED}✗ Registration failed (400):${NC}"
|
|
echo "$RESPONSE"
|
|
rm -f /tmp/dexorder-init-response.json
|
|
exit 1
|
|
fi
|
|
else
|
|
echo -e "${RED}✗ API returned HTTP $HTTP_CODE${NC}"
|
|
cat /tmp/dexorder-init-response.json 2>/dev/null || true
|
|
rm -f /tmp/dexorder-init-response.json
|
|
exit 1
|
|
fi
|
|
rm -f /tmp/dexorder-init-response.json
|
|
|
|
sleep 2
|
|
|
|
USER_ID=$($KUBECTL exec "$PG_POD" -- psql -U postgres -d iceberg -t \
|
|
-c "SELECT id FROM \"user\" WHERE email = '$USER_EMAIL';" \
|
|
2>/dev/null | tr -d ' \n')
|
|
fi
|
|
|
|
if [ -z "$USER_ID" ]; then
|
|
echo -e "${RED}User not found in database after registration. Is the gateway running?${NC}"
|
|
exit 1
|
|
fi
|
|
echo -e "${GREEN}User ID: $USER_ID${NC}"
|
|
|
|
# Build license JSON based on type
|
|
case "$LICENSE_TYPE" in
|
|
enterprise)
|
|
LICENSE_JSON='{"licenseType":"enterprise","features":{"maxIndicators":200,"maxStrategies":100,"maxBacktestDays":1825,"realtimeData":true,"customExecutors":true,"apiAccess":true},"resourceLimits":{"maxConcurrentSessions":20,"maxMessagesPerDay":10000,"maxTokensPerMessage":32768,"rateLimitPerMinute":300},"k8sResources":{"memoryRequest":"1Gi","memoryLimit":"4Gi","cpuRequest":"500m","cpuLimit":"4000m","storage":"50Gi","tmpSizeLimit":"1Gi","enableIdleShutdown":true,"idleTimeoutMinutes":120},"preferredModel":{"provider":"anthropic","model":"claude-opus-4-6","temperature":0.7}}'
|
|
;;
|
|
free)
|
|
LICENSE_JSON='{"licenseType":"free","features":{"maxIndicators":10,"maxStrategies":3,"maxBacktestDays":30,"realtimeData":false,"customExecutors":false,"apiAccess":false},"resourceLimits":{"maxConcurrentSessions":1,"maxMessagesPerDay":100,"maxTokensPerMessage":4096,"rateLimitPerMinute":20},"k8sResources":{"memoryRequest":"256Mi","memoryLimit":"512Mi","cpuRequest":"100m","cpuLimit":"500m","storage":"2Gi","tmpSizeLimit":"128Mi","enableIdleShutdown":true,"idleTimeoutMinutes":30},"preferredModel":{"provider":"anthropic","model":"claude-haiku-4-5-20251001","temperature":0.7}}'
|
|
;;
|
|
pro|*)
|
|
LICENSE_JSON='{"licenseType":"pro","features":{"maxIndicators":50,"maxStrategies":20,"maxBacktestDays":365,"realtimeData":true,"customExecutors":true,"apiAccess":true},"resourceLimits":{"maxConcurrentSessions":5,"maxMessagesPerDay":1000,"maxTokensPerMessage":8192,"rateLimitPerMinute":60},"k8sResources":{"memoryRequest":"512Mi","memoryLimit":"2Gi","cpuRequest":"250m","cpuLimit":"2000m","storage":"10Gi","tmpSizeLimit":"256Mi","enableIdleShutdown":true,"idleTimeoutMinutes":60},"preferredModel":{"provider":"anthropic","model":"claude-sonnet-4-6","temperature":0.7}}'
|
|
;;
|
|
esac
|
|
|
|
echo -e "${GREEN}→${NC} Creating $LICENSE_TYPE license..."
|
|
$KUBECTL exec "$PG_POD" -- psql -U postgres -d iceberg -c "
|
|
INSERT INTO user_licenses (user_id, email, license, mcp_server_url)
|
|
VALUES (
|
|
'$USER_ID',
|
|
'$USER_EMAIL',
|
|
'$LICENSE_JSON',
|
|
'$MCP_URL'
|
|
)
|
|
ON CONFLICT (user_id) DO UPDATE SET
|
|
license = EXCLUDED.license,
|
|
updated_at = NOW();
|
|
" > /dev/null
|
|
|
|
echo -e "${GREEN}✓ User ready: $USER_EMAIL ($LICENSE_TYPE)${NC}"
|
|
echo ""
|
|
echo -e "${BLUE}Initialization complete.${NC}"
|
|
if [[ "$ENV" == "dev" ]]; then
|
|
echo -e "${BLUE}Login at http://dexorder.local with $USER_EMAIL / $USER_PASSWORD${NC}"
|
|
fi
|