compose.yaml

services:
  server:
    user: 1000:1000
    build:
      target: runtime-both
      context: rust
      dockerfile: Dockerfile
    image: ${REGISTRY_NAME:-ghcr.io}/${REPO_NAME:-green-ecolution/streamlet}/server:${VERSION:-latest}
    environment:
      - RUST_LOG=info
      - VALHALLA_DIR=/app/valhalla/currentData
      - OSRM_DIR=/app/osrm/currentData
      - OSRM_FILES=schleswig-holstein-updated.osrm
    healthcheck:
      test:
        ["CMD", "curl", "--max-time", "5", "-f", "http://127.0.0.1:8080/health"]
      interval: 2s
      timeout: 10s
      retries: 5
    volumes:
      - "valhalla_files:/app/valhalla"
      - "osrm_files:/app/osrm"
    depends_on:
      init-server-valhalla:
        condition: service_completed_successfully
      init-server-osrm:
        condition: service_completed_successfully
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.server.rule=Host(`localhost`)"
      - "traefik.http.routers.server.entrypoints=web"

  init-server-osrm:
    user: 1000:1000
    build:
      context: .docker
      dockerfile: Dockerfile.sync
    image: ${REGISTRY_NAME:-ghcr.io}/${REPO_NAME:-green-ecolution/streamlet}/sync:${VERSION:-latest}
    command:
      - init
    environment:
      - S3_ACCESS_KEY=${S3_ACCESS_KEY}
      - S3_SECRET_KEY=${S3_SECRET_KEY}
      - S3_BUCKET=${S3_BUCKET}
      - S3_HOST=storage
      - S3_SCHEME=http
      - S3_PORT=9000
      - TILE_ARCHIVE_PREFIX=osrm-tiles
      - LOCAL_ARCHIVE_NAME=osrm.tar.gz
      - ROUTE_PROVIDER=osrm
      - DEBUG=true
    volumes:
      - "osrm_files:/files"
    depends_on:
      generate-osrm:
        condition: service_completed_successfully

  init-server-valhalla:
    user: 1000:1000
    build:
      context: .docker
      dockerfile: Dockerfile.sync
    command:
      - init
    environment:
      - S3_ACCESS_KEY=${S3_ACCESS_KEY}
      - S3_SECRET_KEY=${S3_SECRET_KEY}
      - S3_BUCKET=${S3_BUCKET}
      - S3_HOST=storage
      - S3_SCHEME=http
      - S3_PORT=9000
      - TILE_ARCHIVE_PREFIX=valhalla-tiles
      - LOCAL_ARCHIVE_NAME=valhalla.tar.gz
      - ROUTE_PROVIDER=valhalla
      - DEBUG=true
    volumes:
      - "valhalla_files:/files"
    depends_on:
      generate-valhalla:
        condition: service_completed_successfully

  sync-server-osrm:
    user: 1000:1000
    build:
      context: .docker
      dockerfile: Dockerfile.sync
    command:
      - sync
    environment:
      - S3_ACCESS_KEY=${S3_ACCESS_KEY}
      - S3_SECRET_KEY=${S3_SECRET_KEY}
      - S3_BUCKET=${S3_BUCKET}
      - S3_HOST=storage
      - S3_SCHEME=http
      - S3_PORT=9000
      - API_URL=http://server:8080
      - SYNC_INTERVAL=600
      - TILE_ARCHIVE_PREFIX=osrm-tiles
      - LOCAL_ARCHIVE_NAME=osrm.tar.gz
      - ROUTE_PROVIDER=osrm
      - DEBUG=true
    volumes:
      - "osrm_files:/files"
    depends_on:
      init-server-osrm:
        condition: service_completed_successfully

  sync-server-valhalla:
    user: 1000:1000
    build:
      context: .docker
      dockerfile: Dockerfile.sync
    command:
      - sync
    environment:
      - S3_ACCESS_KEY=${S3_ACCESS_KEY}
      - S3_SECRET_KEY=${S3_SECRET_KEY}
      - S3_BUCKET=${S3_BUCKET}
      - S3_HOST=storage
      - S3_SCHEME=http
      - S3_PORT=9000
      - API_URL=http://server:8080
      - SYNC_INTERVAL=600
      - TILE_ARCHIVE_PREFIX=valhalla-tiles
      - LOCAL_ARCHIVE_NAME=valhalla.tar.gz
      - ROUTE_PROVIDER=valhalla
      - DEBUG=true
    volumes:
      - "valhalla_files:/files"
    depends_on:
      init-server-valhalla:
        condition: service_completed_successfully

  generate-osrm:
    user: 1000:1000
    build:
      context: .docker
      dockerfile: Dockerfile.osrm
    image: ${REGISTRY_NAME:-ghcr.io}/${REPO_NAME:-green-ecolution/streamlet}/generate-osrm:${VERSION:-latest}
    volumes:
      # - "./rust/osrm:/data"
      - "pbf_data:/tmp/data"
    environment:
      - S3_ACCESS_KEY=${S3_ACCESS_KEY}
      - S3_SECRET_KEY=${S3_SECRET_KEY}
      - S3_BUCKET=${S3_BUCKET}
      - S3_HOST=storage
      - S3_SCHEME=http
      - S3_PORT=9000
      - TILE_ARCHIVE_PREFIX=osrm-tiles
      - DEBUG=true
      - PBF_PATH=/tmp/data/schleswig-holstein-updated.osm.pbf
    depends_on:
      storage:
        condition: service_healthy
      pbf-patch:
        condition: service_completed_successfully

  generate-valhalla:
    user: 1000:1000
    build:
      context: .docker
      dockerfile: Dockerfile.valhalla
    image: ${REGISTRY_NAME:-ghcr.io}/${REPO_NAME:-green-ecolution/streamlet}/generate-valhalla:${VERSION:-latest}
    volumes:
      # - "./rust/valhalla:/custom_files"
      - "pbf_data:/tmp/data"
    environment:
      - S3_ACCESS_KEY=${S3_ACCESS_KEY}
      - S3_SECRET_KEY=${S3_SECRET_KEY}
      - S3_BUCKET=${S3_BUCKET}
      - S3_HOST=storage
      - S3_SCHEME=http
      - S3_PORT=9000
      - TILE_ARCHIVE_PREFIX=valhalla-tiles
      - DEBUG=true
      - PBF_PATH=/tmp/data/schleswig-holstein-updated.osm.pbf
    depends_on:
      storage:
        condition: service_healthy
      pbf-patch:
        condition: service_completed_successfully

  cleanup-tiles:
    user: 1000:1000
    build:
      context: .docker
      dockerfile: Dockerfile.cleanup
    image: ${REGISTRY_NAME:-ghcr.io}/${REPO_NAME:-green-ecolution/streamlet}/cleanup-tiles:${VERSION:-latest}
    entrypoint: [/bin/bash, -c]
    command:
      - while true; do /entrypoint.sh; sleep 600; done;
    environment:
      - S3_ACCESS_KEY=${S3_ACCESS_KEY}
      - S3_SECRET_KEY=${S3_SECRET_KEY}
      - S3_BUCKET=${S3_BUCKET}
      - S3_HOST=storage
      - S3_SCHEME=http
      - S3_PORT=9000
      - TILE_ARCHIVE_PREFIXES=valhalla-tiles,osrm-tiles
      - ARCHIVE_RETENTION=1
    depends_on:
      storage:
        condition: service_healthy

  pbf-patch:
    user: 1000:1000
    build:
      context: pbf-patch
    image: ${REGISTRY_NAME:-ghcr.io}/${REPO_NAME:-green-ecolution/streamlet}/pbf-patch:${VERSION:-latest}
    volumes:
      - "pbf_data:/files/output"
      - "./data/schleswig-holstein-latest.osm.pbf:/tmp/schleswig-holstein-latest.osm.pbf:ro"
    environment:
      - DEBUG=true
      - OUTPUT_FILENAME=schleswig-holstein-updated.osm.pbf
      - PLUGIN_CLIENT_ID=${PLUGIN_CLIENT_ID}
      - PLUGIN_CLIENT_SECRET=${PLUGIN_CLIENT_SECRET}
      # - SKIP_CONSTRUCTION=true
      # - SKIP_PATHS=true
    depends_on:
      storage:
        condition: service_healthy

  storage:
    image: ${REGISTRY_PREFIX}minio/minio:RELEASE.2025-07-23T15-54-02Z
    user: 1000:1000
    environment:
      - MINIO_ROOT_USER=${S3_ACCESS_KEY}
      - MINIO_ROOT_PASSWORD=${S3_SECRET_KEY}
      - MINIO_DEFAULT_BUCKETS=${S3_BUCKET}
    entrypoint: /bin/bash -c
    command:
      - |
        DATA_DIR=$${DATA_DIR:-/data}
        if [[ -n "$$MINIO_DEFAULT_BUCKETS" ]]; then
          minio server /data --address "127.0.0.1:9000" &
          pid=$$!

          trap "kill $$pid" SIGINT SIGTERM ERR

          until curl -sf --max-time 5 http://localhost:9000/minio/health/live; do
            sleep 1
          done

          mc alias set local "http://localhost:9000" "$$MINIO_ROOT_USER" "$$MINIO_ROOT_PASSWORD"

          while IFS="," read -r bucket; do
            bucket=$${bucket#* }
            echo "BUCKET: $$bucket"
            if mc stat local/$$bucket >/dev/null 2>&1; then
              echo "Bucket existiert"
            else
              mc mb local/$$bucket
              mc anonymous set download local/$$bucket
            fi

          done <<< "$$MINIO_DEFAULT_BUCKETS"

          kill $$pid
        fi

        exec minio server /data --console-address ":9001"
    post_start:
      - command: chown -R 1000:1000 /data
        user: root
    healthcheck:
      test:
        [
          "CMD",
          "curl",
          "-sf",
          "--max-time",
          "5",
          "http://localhost:9000/minio/health/live",
        ]
      interval: 2s
      timeout: 10s
      retries: 5
    volumes:
      - minio_data:/data
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.minio.rule=Host(`minio.localhost`)"
      - "traefik.http.routers.minio.entrypoints=web"
      - "traefik.http.routers.minio.service=minio"
      - "traefik.http.services.minio.loadbalancer.server.port=9001"
      - "traefik.http.routers.s3.rule=Host(`s3.localhost`)"
      - "traefik.http.routers.s3.entrypoints=web"
      - "traefik.http.routers.s3.service=s3"
      - "traefik.http.services.s3.loadbalancer.server.port=9000"

  reverse-proxy:
    image: ${REGISTRY_PREFIX}traefik:latest
    extra_hosts:
      - "host.docker.internal:host-gateway"
    command:
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entryPoints.web.address=:3000"
    ports:
      - "127.0.0.1:3000:3000/tcp"
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.traefik.rule=Host(`traefik.localhost`)"
      - "traefik.http.routers.traefik.entrypoints=web"
      - "traefik.http.routers.traefik.service=traefik"
      - "traefik.http.services.traefik.loadbalancer.server.port=8080"

volumes:
  pbf_data:
  minio_data:
  valhalla_files:
  osrm_files: