docker-compose.yaml

services:
  upload-service:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: upload-service
    ports:
      - "8080:8080"
    env_file:
      - .env
    environment:
      PG_URL: jdbc:postgresql://postgres:5432/${PG_DB}
      MINIO_ENDPOINT: http://minio:9000
      RABBITMQ_HOST: rabbitmq
      SERVICE_MODE: upload
      STATUS_PORT: 8081
    command:
      - /bin/sh
      - -c
      - |
          if [ -f .env ]; then
            if grep -q '^CONTAINER_ID=' .env; then
              sed -i "s/^CONTAINER_ID=.*/CONTAINER_ID=$$HOSTNAME/" .env
            else
              echo "CONTAINER_ID=$$HOSTNAME" >> .env
            fi
          else
            echo "CONTAINER_ID=$$HOSTNAME" > .env
          fi
          exec java -jar /app/upload-service.jar
    depends_on:
      rabbitmq:
        condition: service_healthy
      minio:
        condition: service_started
      postgres:
        condition: service_healthy
    restart: unless-stopped

  processing-service:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: processing-service
    ports:
      - "8082:8082"
    env_file:
      - .env
    environment:
      PG_URL: jdbc:postgresql://postgres:5432/${PG_DB}
      PG_USER: ${PG_USER}
      PG_PASSWORD: ${PG_PASSWORD}
      MINIO_ENDPOINT: http://minio:9000
      RABBITMQ_HOST: rabbitmq
      SERVICE_MODE: processing
      RABBITMQ_STATUS_QUEUE: processing.events.queue
      RABBITMQ_STATUS_BINDING: upload.status.*
      RABBITMQ_TASK_QUEUE: ${RABBITMQ_TASK_QUEUE}
      RABBITMQ_TASK_BINDING: ${RABBITMQ_TASK_BINDING}
      PROCESSING_SPOOL_ROOT: /app/processing-spool
    volumes:
      - processing_spool:/app/processing-spool
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "python3 -c \"import urllib.request; urllib.request.urlopen('http://localhost:8082/health', timeout=2)\" || exit 1"
        ]
      interval: 15s
      timeout: 5s
      retries: 3
    command:
      - /bin/sh
      - -c
      - exec java -jar /app/processing-service.jar
    depends_on:
      rabbitmq:
        condition: service_healthy
      minio:
        condition: service_started
    restart: unless-stopped

  status-service:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: status-service
    ports:
      - "8081:8081"
    env_file:
      - .env
    environment:
      PG_URL: jdbc:postgresql://postgres:5432/${PG_DB}
      RABBITMQ_HOST: rabbitmq
      SERVICE_MODE: status
    depends_on:
      rabbitmq:
        condition: service_healthy
      postgres:
        condition: service_healthy
    restart: unless-stopped

  streaming-service:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: streaming-service
    ports:
      - "8083:8083"
    env_file:
      - .env
    environment:
      PG_URL: jdbc:postgresql://postgres:5432/${PG_DB}
      MINIO_ENDPOINT: http://minio:9000
      MINIO_PUBLIC_ENDPOINT: ${MINIO_PUBLIC_ENDPOINT:-http://localhost:9000}
      STREAMING_PORT: 8083
    command:
      - /bin/sh
      - -c
      - |
          exec java -jar /app/streaming-service.jar
    depends_on:
      minio:
        condition: service_started
      postgres:
        condition: service_healthy
    restart: unless-stopped

  rabbitmq:
    image: rabbitmq:3-management
    container_name: video-streaming-rabbitmq
    ports:
      - "5672:5672"    # AMQP port
      - "15672:15672"  # Management UI
    environment:
      RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER}
      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASS}
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    healthcheck:
      test: [ "CMD", "rabbitmq-diagnostics", "ping" ]
      interval: 10s
      timeout: 5s
      retries: 5

  minio:
    image: quay.io/minio/minio
    container_name: minio-dev
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      MINIO_ROOT_USER: ${MINIO_ACCESS_KEY}
      MINIO_ROOT_PASSWORD: ${MINIO_SECRET_KEY}
    volumes:
      - minio_data:/data
    command: server /data --console-address ":9001"

  postgres:
    image: postgres:16-alpine
    container_name: video-streaming-postgres
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: ${PG_USER}
      POSTGRES_PASSWORD: ${PG_PASSWORD}
      POSTGRES_DB: ${PG_DB}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./upload-service/docs/db/schema.sql:/docker-entrypoint-initdb.d/schema.sql:ro
    healthcheck:
      test: [ "CMD-SHELL", "pg_isready -U ${PG_USER} -d ${PG_DB}" ]
      interval: 10s
      timeout: 5s
      retries: 5

  node-watcher:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: node-watcher
    env_file:
      - .env
    environment:
      PG_URL: jdbc:postgresql://postgres:5432/${PG_DB}
      RABBITMQ_HOST: rabbitmq
      WATCH_CONTAINER_NAME_PREFIX: upload-service,processing-service
      FAILURE_REASON: container_died
      UPDATE_DB_STATUS: "true"
      PYTHONUNBUFFERED: "1"
      DEBUG_EVENTS: "true"
      DEDUP_WINDOW_SECONDS: "3"
    entrypoint: ["python3", "/app/node-watcher/watcher.py"]
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    depends_on:
      rabbitmq:
        condition: service_healthy
      postgres:
        condition: service_healthy
    restart: unless-stopped

volumes:
  rabbitmq_data:
  minio_data:
  postgres_data:
  processing_spool: