docker-compose.yml

volumes:
  aperag-postgres-data: {}
  aperag-qdrant-data: {}
  aperag-redis-data: {}
  aperag-es-data: {}
  aperag-neo4j-data: {}
  aperag-nebula-meta-data: {}
  aperag-nebula-storage-data: {}
  aperag-nebula-logs: {}
  aperag-shared-data: {}

services:
  # ==============================================
  # Application Services (Default startup, excluded from infra)
  # ==============================================
  api: &api
    build:
      context: .
      dockerfile: ./Dockerfile
    image: ${REGISTRY:-docker.io}/apecloud/aperag:${VERSION:-v0.0.0-nightly}
    container_name: aperag-api
    depends_on:
      redis:
        condition: service_healthy
      postgres:
        condition: service_healthy
      qdrant:
        condition: service_healthy
      es:
        condition: service_healthy
    volumes:
      - ~/.cache:/root/.cache
      - aperag-shared-data:/shared
    env_file:
      - .env
      - envs/docker.env.overrides
    ports:
      - "8000:8000"
    command: ["/app/scripts/entrypoint.sh", "/app/scripts/start-api.sh"]
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:8000/health || curl -f http://localhost:8000/docs || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 12  # 12 * 10s = 120s (2 minutes)
      start_period: 30s  # Give API time to start up before first check

  frontend:
    build:
      context: ./web
      dockerfile: ./Dockerfile
    image: ${REGISTRY:-docker.io}/apecloud/aperag-frontend:${VERSION:-v0.0.0-nightly}
    container_name: aperag-frontend
    depends_on:
      api:
        condition: service_healthy
    env_file:
      - web/deploy/env.local.template
    environment:
      - API_SERVER_ENDPOINT=http://api:8000
      - API_SERVER_BASE_PATH=/api/v1
    ports:
      - "3000:3000"

  celeryworker:
    image: ${REGISTRY:-docker.io}/apecloud/aperag:${VERSION:-v0.0.0-nightly}
    build:
      context: .
      dockerfile: ./Dockerfile
    container_name: aperag-celeryworker
    depends_on:
      redis:
        condition: service_healthy
      postgres:
        condition: service_healthy
      qdrant:
        condition: service_healthy
      es:
        condition: service_healthy
    volumes:
      - ~/.cache:/root/.cache
      - ./resources:/data/resources
      - aperag-shared-data:/shared
    env_file:
      - .env
      - envs/docker.env.overrides
    environment:
      - NODE_IP=aperag-celeryworker
      - APERAG_API_BASE_URL=http://aperag-api:8000
    command: ["/app/scripts/entrypoint.sh", "/app/scripts/start-celery-worker.sh"]

  celerybeat:
    image: ${REGISTRY:-docker.io}/apecloud/aperag:${VERSION:-v0.0.0-nightly}
    build:
      context: .
      dockerfile: ./Dockerfile
    container_name: aperag-celerybeat
    env_file:
      - .env
      - envs/docker.env.overrides
    depends_on:
      redis:
        condition: service_healthy
      postgres:
        condition: service_healthy
    environment:
      - NODE_IP=aperag-celerybeat
    command: ["/app/scripts/entrypoint.sh", "/app/scripts/start-celery-beat.sh"]

  flower:
    image: ${REGISTRY:-docker.io}/apecloud/aperag:${VERSION:-v0.0.0-nightly}
    build:
      context: .
      dockerfile: ./Dockerfile
    container_name: aperag-flower
    depends_on:
      redis:
        condition: service_healthy
      postgres:
        condition: service_healthy
    env_file:
      - .env
      - envs/docker.env.overrides
    ports:
      - "5555:5555"
    environment:
      - NODE_IP=aperag-flower
    command: ["/app/scripts/entrypoint.sh", "/app/scripts/start-celery-flower.sh"]

  # ==============================================
  # Infrastructure Services (always available)
  # ==============================================
  postgres:
    image: ${REGISTRY:-docker.io}/apecloud/pgvector:pg16
    container_name: aperag-postgres
    volumes:
      - aperag-postgres-data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_DB=aperag
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d aperag"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s

  redis:
    image: ${REGISTRY:-docker.io}/apecloud/redis:6
    container_name: aperag-redis
    volumes:
      - aperag-redis-data:/data
    ports:
      - "6379:6379"
    healthcheck:
      test: ["CMD-SHELL", "redis-cli ping | grep PONG"]
      interval: 10s
      timeout: 3s
      retries: 5
      start_period: 5s

  qdrant:
    image: ${REGISTRY:-docker.io}/apecloud/qdrant:v1.13.4
    container_name: aperag-qdrant
    volumes:
      - aperag-qdrant-data:/qdrant/storage
    ports:
      - "6333:6333"
    healthcheck:
      test: ["CMD-SHELL", "nc -z localhost 6333 || timeout 3 bash -c '</dev/tcp/localhost/6333' || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s

  es:
    image: ${REGISTRY:-docker.io}/apecloud/elasticsearch:8.8.2
    container_name: aperag-es
    ports:
      - "9200:9200"
    environment:
      - "discovery.type=single-node"
      - "ES_JAVA_OPTS=-Xms1g -Xmx1g"
      - "xpack.security.enabled=false"
      - "ES_REQUIRE_IK_PLUGIN=true"
      - "ES_AUTO_INSTALL_IK=true"
      - "ES_IK_PLUGIN_URL=https://get.infini.cloud/elasticsearch/analysis-ik/8.8.2"
    volumes:
      - aperag-es-data:/usr/share/elasticsearch/data
      - ./scripts/init-es.sh:/usr/share/elasticsearch/bin/init-es.sh
    healthcheck:
      test: ["CMD-SHELL", "bash /usr/share/elasticsearch/bin/init-es.sh check"]
      interval: 10s
      timeout: 5s
      retries: 12 # 12 * 10s = 120s (2 minutes)
      start_period: 10s # Give ES some time to start up before first check
    command: bash /usr/share/elasticsearch/bin/init-es.sh
    restart: on-failure

  jaeger:
    image: jaegertracing/all-in-one:1.60
    container_name: aperag-jaeger
    ports:
      - "16686:16686"  # Jaeger UI
      - "14268:14268"  # HTTP collector
      - "14250:14250"  # gRPC collector
      - "6831:6831/udp"  # UDP agent
      - "6832:6832/udp"  # UDP agent
    environment:
      - COLLECTOR_OTLP_ENABLED=true
      - LOG_LEVEL=info
    restart: unless-stopped
    profiles: ["jaeger"]

  # ==============================================
  # Optional Services
  # ==============================================
  neo4j:
    image: neo4j:5.26.5-enterprise
    container_name: aperag-neo4j
    ports:
      - "7474:7474"  # HTTP
      - "7687:7687"  # Bolt
    environment:
      - NEO4J_AUTH=neo4j/password
      - NEO4J_PLUGINS=["apoc"]
      - NEO4J_ACCEPT_LICENSE_AGREEMENT=yes
      - NEO4J_apoc_export_file_enabled=true
    volumes:
      - aperag-neo4j-data:/data
    profiles: ["neo4j"]

  nebula-metad:
    image: vesoft/nebula-metad:v3.8.0
    container_name: aperag-nebula-metad
    command:
      - --meta_server_addrs=nebula-metad:9559
      - --local_ip=nebula-metad
      - --ws_ip=nebula-metad
      - --port=9559
      - --ws_http_port=19559
      - --data_path=/data/meta
      - --logtostderr=true
      - --redirect_stdout=false
      - --v=0
      - --minloglevel=0
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://nebula-metad:19559/status"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 20s
    ports:
      - "9559:9559"
      - "19559:19559"
    volumes:
      - aperag-nebula-meta-data:/data/meta
      - aperag-nebula-logs:/logs
    restart: on-failure
    profiles: ["nebula"]

  nebula-storaged:
    image: vesoft/nebula-storaged:v3.8.0
    container_name: aperag-nebula-storaged
    command:
      - --meta_server_addrs=nebula-metad:9559
      - --local_ip=nebula-storaged
      - --ws_ip=nebula-storaged
      - --port=9779
      - --ws_http_port=19779
      - --data_path=/data/storage
      - --logtostderr=true
      - --redirect_stdout=false
      - --v=0
      - --minloglevel=0
    depends_on:
      - nebula-metad
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://nebula-storaged:19779/status"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 20s
    ports:
      - "9779:9779"
      - "19779:19779"
    volumes:
      - aperag-nebula-storage-data:/data/storage
      - aperag-nebula-logs:/logs
    restart: on-failure
    profiles: ["nebula"]

  nebula-graphd:
    image: vesoft/nebula-graphd:v3.8.0
    container_name: aperag-nebula-graphd
    command:
      - --meta_server_addrs=nebula-metad:9559
      - --port=9669
      - --local_ip=nebula-graphd
      - --ws_ip=nebula-graphd
      - --ws_http_port=19669
      - --logtostderr=true
      - --redirect_stdout=false
      - --v=0
      - --minloglevel=0
    depends_on:
      - nebula-storaged
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://nebula-graphd:19669/status"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 20s
    ports:
      - "9669:9669"
      - "19669:19669"
    volumes:
      - aperag-nebula-logs:/logs
    restart: on-failure
    profiles: ["nebula"]

  nebula-storage-activator:
    image: vesoft/nebula-console:v3.8.0
    container_name: aperag-nebula-storage-activator
    entrypoint: ""
    environment:
      - ACTIVATOR_RETRY=${ACTIVATOR_RETRY:-30}
    command:
      - sh
      - -c
      - |
        # Phase 1 — register storaged with metad (ADD HOSTS).
        # Returning OK here only means the host is now in metad's
        # registry; metad still needs at least one successful heartbeat
        # round before it marks the host ONLINE, and CREATE SPACE with
        # replica_factor>=1 requires ONLINE hosts — so ADD-HOSTS-success
        # alone is not a green light for callers. See Phase 2 below.
        registered=0
        for i in `seq 1 $$ACTIVATOR_RETRY`; do
          output=$$(nebula-console -addr nebula-graphd -port 9669 -u root -p nebula -e 'ADD HOSTS "nebula-storaged":9779' 2>&1)
          if [ $$? -eq 0 ]; then
            echo "Storage registered via ADD HOSTS."
            registered=1
            break
          fi
          if echo "$$output" | grep -q "Existed"; then
            echo "Storage already registered (ADD HOSTS returned Existed)."
            registered=1
            break
          fi
          if [ $$i -lt $$ACTIVATOR_RETRY ]; then
            echo "Attempt $$i/$$ACTIVATOR_RETRY registering storaged; retrying..."
            sleep 5
            continue
          fi
          echo "Failed to register storaged after $$ACTIVATOR_RETRY attempts."
          echo "$$output"
          exit 1
        done
        if [ "$$registered" -ne 1 ]; then
          echo "Storage never got registered; aborting."
          exit 1
        fi

        # Phase 2 — wait until storaged is visible as ONLINE to metad
        # via the usual heartbeat cycle. Without this poll, the
        # activator can exit 0 while storaged is still OFFLINE, and any
        # immediately-following `CREATE SPACE replica_factor=1` call
        # fails with "Host not enough!" in metad's placement check.
        # This is the Nebula race symptom tracked in task #22.
        for i in `seq 1 $$ACTIVATOR_RETRY`; do
          status=$$(nebula-console -addr nebula-graphd -port 9669 -u root -p nebula -e 'SHOW HOSTS' 2>&1)
          if echo "$$status" | grep -q "ONLINE"; then
            echo "Storaged is ONLINE."
            exit 0
          fi
          echo "Storaged not ONLINE yet (attempt $$i/$$ACTIVATOR_RETRY); retrying..."
          sleep 5
        done
        echo "Storaged failed to reach ONLINE status within $$ACTIVATOR_RETRY attempts."
        echo "$$status"
        exit 1
    depends_on:
      - nebula-graphd
    profiles: ["nebula"]