version: "3.8"

volumes:
  postgresql_config_data: # volume for postgresql data, used to store the geoserver config through jdbcconfig
  rabbitmq_data: # volume for rabbitmq data, so it doesn't create an anonymous one on each container
  
networks:
  gs-cloud-network:
    driver: bridge
        
services:
  rabbitmq:
    image: rabbitmq:3-management
    restart: always
    environment:
      RABBITMQ_DEFAULT_USER: "guest"
      RABBITMQ_DEFAULT_PASS: "guest"
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    networks:
      - gs-cloud-network
    ports:
      - "5672:5672"
      - "15672:15672"

  database:
    image: org.geoserver.cloud/gs-cloud-database:${TAG}
    environment:
      POSTGRES_DB: "${JDBCCONFIG_DBNAME}"
      POSTGRES_USER: "${JDBCCONFIG_USERNAME}"
      POSTGRES_PASSWORD: "${JDBCCONFIG_PASSWORD}"
    ports:
      - 5432:5432
    networks:
      - gs-cloud-network
    volumes:
      - postgresql_config_data:/var/lib/postgresql/data

  # Eureka service discovery. This is a Discovery First Bootstrap configuration.
  # The discovery service is the only fixed entry point.
  # Browse to http://localhost:8761 to check all services are registered.
  # Run docker-compose -f docker-compose.yml -f docker-compose-discovery-ha.yml to run extra discovery service instances for HA
  discovery:
    image: org.geoserver.cloud/gs-cloud-discovery-service:${TAG}
    environment:
      SERVER_PORT: 8761
      EUREKA_INSTANCE_HOSTNAME: discovery
      JAVA_OPTS: ${DISCOVERY_JAVA_OPTS}
    ports:
      - 8761:8761 # for development, so services can be run from localhost and find the discovery service running on docker
    networks:
      - gs-cloud-network
    healthcheck:
      test: ["CMD", "curl", "-f", "-m", "1", "http://localhost:8761/actuator/health"]
      interval: 1s
      timeout: 1s
      retries: 15

  # Spring Cloud Config service, provides centralized configuration to all
  # microservices. Being a Discovery First Bootstrap configuration, it'll
  # register itself with the Eureka discovery service and can be scaled
  config:
    image: org.geoserver.cloud/gs-cloud-config-service:${TAG}
    depends_on:
      - discovery
    environment:
      EUREKA_SERVER_URL: ${EUREKA_SERVER_URL}
      JAVA_OPTS: ${CONFIG_JAVA_OPTS}
      RABBITMQ_HOST: rabbitmq
    networks:
      - gs-cloud-network
    volumes:
      - ./config:/opt/app/config
    healthcheck:
      test: ["CMD", "curl", "-f", "-m", "1", "http://localhost:8080/actuator/health"]
      interval: 1s
      timeout: 1s
      retries: 15
    # wait until discovery service is available
    command: dockerize -wait http://discovery:8761/actuator/health --timeout 15s java ${CONFIG_JAVA_OPTS} -jar /opt/app/config-service.jar

  # Application facade, provides a single entry point routing to all
  # microservices (e.g. http://localhost:9090/geoserver/wms, http://localhost:9090/geoserver/wfs, etc)
  gateway:
    image: org.geoserver.cloud/gs-cloud-gateway:${TAG}
    depends_on:
      - discovery
      - config
    environment:
      EUREKA_SERVER_URL: ${EUREKA_SERVER_URL}
      JAVA_OPTS: ${GATEWAY_JAVA_OPTS}
    ports:
      - 9090:8080
    networks:
      - gs-cloud-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
    # wait until config service is available
    command: dockerize -wait http://config:8080/gateway-service/default --timeout 30s java ${GATEWAY_JAVA_OPTS} -jar /opt/app/gateway-service.jar

  # WFS microservice, port dynamically allocated to allow scaling (e.g docker-compose scale wfs=5)
  wfs:
    image: org.geoserver.cloud/gs-cloud-wfs:${TAG}
    depends_on:
      - discovery
      - config
      - database
      - rabbitmq
    environment:
      EUREKA_SERVER_URL: ${EUREKA_SERVER_URL}
      JAVA_OPTS: ${WFS_JAVA_OPTS}
      RABBITMQ_HOST: rabbitmq
      JDBCCONFIG_URL: "${JDBCCONFIG_URL}"
      JDBCCONFIG_USERNAME: "${JDBCCONFIG_USERNAME}"
      JDBCCONFIG_PASSWORD: "${JDBCCONFIG_PASSWORD}"
    networks:
      - gs-cloud-network
    #tmpfs: #TODO: avoid runs creating volumes at all
    #  - /tmp
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
    command: dockerize -wait http://config:8080/wfs-service/default --timeout 30s java ${WFS_JAVA_OPTS} -jar /opt/app/wfs-service.jar

  # WMS microservice, port dynamically allocated to allow scaling (e.g docker-compose scale wms=5)
  wms:
    image: org.geoserver.cloud/gs-cloud-wms:${TAG}
    depends_on:
      - discovery
      - config
      - database
      - rabbitmq
    environment:
      EUREKA_SERVER_URL: ${EUREKA_SERVER_URL}
      JAVA_OPTS: ${WMS_JAVA_OPTS}
      RABBITMQ_HOST: rabbitmq
      JDBCCONFIG_URL: "${JDBCCONFIG_URL}"
      JDBCCONFIG_USERNAME: "${JDBCCONFIG_USERNAME}"
      JDBCCONFIG_PASSWORD: "${JDBCCONFIG_PASSWORD}"
    networks:
      - gs-cloud-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
    # wait until config service is available
    command: dockerize -wait http://config:8080/wms-service/default --timeout 30s java ${WMS_JAVA_OPTS} -jar /opt/app/wms-service.jar

  # WCS microservice, port dynamically allocated to allow scaling (e.g docker-compose scale wcs=5)
  wcs:
    image: org.geoserver.cloud/gs-cloud-wcs:${TAG}
    depends_on:
      - discovery
      - config
      - database
      - rabbitmq
    environment:
      EUREKA_SERVER_URL: ${EUREKA_SERVER_URL}
      JAVA_OPTS: ${WCS_JAVA_OPTS}
      RABBITMQ_HOST: rabbitmq
      JDBCCONFIG_URL: "${JDBCCONFIG_URL}"
      JDBCCONFIG_USERNAME: "${JDBCCONFIG_USERNAME}"
      JDBCCONFIG_PASSWORD: "${JDBCCONFIG_PASSWORD}"
    networks:
      - gs-cloud-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
    # wait until config service is available
    command: dockerize -wait http://config:8080/wcs-service/default --timeout 30s java ${WCS_JAVA_OPTS} -jar /opt/app/wcs-service.jar

#  # WPS microservice, port dynamically allocated to allow scaling (e.g docker-compose scale wps=5)
#  wps:
#    image: org.geoserver.cloud/gs-cloud-wps:${TAG}
#    depends_on:
#      - discovery
#      - config
#      - database
#      - rabbitmq
#    environment:
#      EUREKA_SERVER_URL: ${EUREKA_SERVER_URL}
#      JAVA_OPTS: ${WPS_JAVA_OPTS}
#      RABBITMQ_HOST: rabbitmq
#      JDBCCONFIG_URL: "${JDBCCONFIG_URL}"
#      JDBCCONFIG_USERNAME: "${JDBCCONFIG_USERNAME}"
#      JDBCCONFIG_PASSWORD: "${JDBCCONFIG_PASSWORD}"
#    networks:
#      - gs-cloud-network
#    healthcheck:
#      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
#    # wait until config service is available
#    command: dockerize -wait http://config:8080/wps-service/default --timeout 30s java ${WPS_JAVA_OPTS} -jar /opt/app/wps-service.jar

  # REST config microservice, port dynamically allocated to allow scaling (e.g docker-compose scale rest=5)
  rest:
    image: org.geoserver.cloud/gs-cloud-restconfig-v1:${TAG}
    depends_on:
      - discovery
      - config
      - database
      - rabbitmq
    environment:
      EUREKA_SERVER_URL: ${EUREKA_SERVER_URL}
      JAVA_OPTS: ${REST_JAVA_OPTS}
      RABBITMQ_HOST: rabbitmq
      JDBCCONFIG_URL: "${JDBCCONFIG_URL}"
      JDBCCONFIG_USERNAME: "${JDBCCONFIG_USERNAME}"
      JDBCCONFIG_PASSWORD: "${JDBCCONFIG_PASSWORD}"
    networks:
      - gs-cloud-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
    # wait until config service is available
    command: dockerize -wait http://config:8080/restconfig-service/default --timeout 30s java ${REST_JAVA_OPTS} -jar /opt/app/restconfig-service.jar

  # WEB UI microservice
  webui:
    image: org.geoserver.cloud/gs-cloud-web-ui:${TAG}
    depends_on:
      - discovery
      - config
      - database
      - rabbitmq
    environment:
      EUREKA_SERVER_URL: ${EUREKA_SERVER_URL}
      JAVA_OPTS: ${WEBUI_JAVA_OPTS}
      RABBITMQ_HOST: rabbitmq
      JDBCCONFIG_URL: "${JDBCCONFIG_URL}"
      JDBCCONFIG_USERNAME: "${JDBCCONFIG_USERNAME}"
      JDBCCONFIG_PASSWORD: "${JDBCCONFIG_PASSWORD}"
    networks:
      - gs-cloud-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
    # wait until config service is available
    command: dockerize -wait http://config:8080/web-ui/default --timeout 30s java ${WEBUI_JAVA_OPTS} -jar /opt/app/web-ui-service.jar