defmodule Example.Health do
  @moduledoc """
  Collect app status for Kubernetes health checks.
  """
  alias Example.Repo

  @app :example
  @repos Application.compile_env(@app, :ecto_repos) || []

  @doc """
  Check if the app has finished booting up.

  This returns app status for the Kubernetes `startupProbe`.
  Kubernetes checks this probe repeatedly until it returns a successful
  response. After that Kubernetes switches to executing the other two probes.
  If the app fails to successfully start before the `failureThreshold` time is
  reached, Kubernetes kills the container and restarts it.

  For example, this check might return OK when the app has started the
  web-server, connected to a DB, connected to external services, and performed
  initial setup tasks such as loading a large cache.
  """
  @spec startup ::
          :ok
          | {:error, {status_code :: non_neg_integer(), reason :: binary()}}
          | {:error, reason :: binary()}
  def startup do
    # Return error if there are available migrations which have not been executed.
    # This supports deployment to AWS ECS using the following strategy:
    # https://engineering.instawork.com/elegant-database-migrations-on-ecs-74f3487da99f
    #
    # By default Elixir migrations lock the database migration table, so they
    # will only run from a single instance.
    migrations =
      @repos
      |> Enum.map(&Ecto.Migrator.migrations/1)
      |> List.flatten()

    if Enum.empty?(migrations) do
      liveness()
    else
      {:error, "Database not migrated"}
    end
  end

  @doc """
  Check if the app is alive and working properly.

  This returns app status for the Kubernetes `livenessProbe`.
  Kubernetes continuously checks if the app is alive and working as expected.
  If it crashes or becomes unresponsive for a specified period of time,
  Kubernetes kills and replaces the container.

  This check should be lightweight, only determining if the server is
  responding to requests and can connect to the DB.
  """
  @spec liveness ::
          :ok
          | {:error, {status_code :: non_neg_integer(), reason :: binary()}}
          | {:error, reason :: binary()}
  def liveness do
    case Ecto.Adapters.SQL.query(Repo, "SELECT 1") do
      {:ok, %{num_rows: 1, rows: [[1]]}} ->
        :ok

      {:error, reason} ->
        {:error, inspect(reason)}
    end
  rescue
    e ->
      {:error, inspect(e)}
  end

  @doc """
  Check if app should be serving public traffic.

  This returns app status for the Kubernetes `readinessProbe`.
  Kubernetes continuously checks if the app should serve traffic. If the
  readiness probe fails, Kubernetes doesn't kill and restart the container,
  instead it marks the pod as "unready" and stops sending traffic to it, e.g.,
  in the ingress.

  This is useful to temporarily stop serving requests. For example, if the app
  gets a timeout connecting to a back end service, it might return an error for
  the readiness probe. After multiple failed attempts, it would switch to
  returning false for the `livenessProbe`, triggering a restart.

  Similarly, the app might return an error if it is overloaded, shedding
  traffic until it has caught up.
  """
  @spec readiness ::
          :ok
          | {:error, {status_code :: non_neg_integer(), reason :: binary()}}
          | {:error, reason :: binary()}
  def readiness do
    liveness()
  end

  @spec basic ::
          :ok
  # | {:error, {status_code :: non_neg_integer(), reason :: binary()}}
  # | {:error, reason :: binary()}
  def basic do
    :ok
  end
end

readinessProbe:
  exec:
    command: ["pg_isready"]
  initialDelaySeconds: 10
  periodSeconds: 5
  timeoutSeconds: 2
  failureThreshold: 20

livenessProbe:
  exec:
    command: ["psql", "-w", "-U", "postgres", "-d", "my-db", "-c", "SELECT 1"]
  periodSeconds: 10
  timeoutSeconds: 2
  failureThreshold: 1

---
version: "3.9"
services:
  deploy:
    image: example-service
    healthcheck:
      test: ["CMD", "curl", "http://127.0.0.1:4001/healthz"]
      start_period: 6s
      interval: 2s
      timeout: 5s
      retries: 20
    depends_on:
      postgres:
        condition: service_healthy

postgres:
  image: postgres:14.1-alpine
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready"]
      start_period: 5s
      interval: 2s
      timeout: 5s
      retries: 20

router:
    image: ghcr.io/apollographql/router:v1.2.1
    ports:
      # GraphQL endpoint
      - "4000:4000"
      # Health check
      - "8088:8088"
    environment:
      # https://www.apollographql.com/docs/router/configuration/overview
      APOLLO_ROUTER_LOG: "debug"
      APOLLO_ROUTER_SUPERGRAPH_PATH: /dist/schema/local.graphql
      APOLLO_ROUTER_CONFIG_PATH: /router.yaml
      APOLLO_ROUTER_HOT_RELOAD: "true"
    volumes:
      - "./apollo-router.yml:/router.yaml"
      - "./supergraph.graphql:/dist/schema/local.graphql"
    healthcheck:
      test: ["CMD-SHELL", "curl", "-v", "--fail", "http://127.0.0.1:8088/health"]
      start_period: 5s
      interval: 2s
      timeout: 5s
      retries: 20
    depends_on:
      deploy:
        condition: service_healthy

livenessProbe:
  exec:
    command:
    - /app/grpc-health-probe
    - -addr=:50051
    - -connect-timeout=5s
    - -rpc-timeout=5s
  failureThreshold: 3
  initialDelaySeconds: 60
  periodSeconds: 10
  successThreshold: 1
  timeoutSeconds: 10
readinessProbe:
  exec:
    command:
    - /app/grpc-health-probe
    - -addr=:50051
    - -connect-timeout=5s
    - -rpc-timeout=5s
  failureThreshold: 3
  initialDelaySeconds: 1
  periodSeconds: 10
  successThreshold: 1
  timeoutSeconds: 10

healthcheck:
  test: ["CMD", "bin/api", "eval", "API.Health.liveness()"]
  start_period: 2s
  interval: 1s
  timeout: 1s