name: docker

on:
    push:
        branches:
            - unstable
            - stable
        tags:
            - v*

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

env:
    DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
    DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
    IMAGE_NAME: ${{ github.repository_owner}}/lighthouse
    LCLI_IMAGE_NAME: ${{ github.repository_owner }}/lcli
    # Enable self-hosted runners for the sigp repo only.
    SELF_HOSTED_RUNNERS: ${{ github.repository == 'sigp/lighthouse' }}

jobs:
    # Extract the VERSION which is either `latest` or `vX.Y.Z`, and the VERSION_SUFFIX
    # which is either empty or `-unstable`.
    #
    # It would be nice if the arch didn't get spliced into the version between `latest` and
    # `unstable`, but for now we keep the two parts of the version separate for backwards
    # compatibility.
    extract-version:
        runs-on: ubuntu-22.04
        steps:
            - name: Extract version (if stable)
              if: github.event.ref == 'refs/heads/stable'
              run: |
                    echo "VERSION=latest" >> $GITHUB_ENV
                    echo "VERSION_SUFFIX=" >> $GITHUB_ENV
            - name: Extract version (if unstable)
              if: github.event.ref == 'refs/heads/unstable'
              run: |
                    echo "VERSION=latest" >> $GITHUB_ENV
                    echo "VERSION_SUFFIX=-unstable" >> $GITHUB_ENV
            - name: Extract version (if tagged release)
              if: startsWith(github.event.ref, 'refs/tags')
              run: |
                    echo "VERSION=$(echo ${GITHUB_REF#refs/tags/})" >> $GITHUB_ENV
                    echo "VERSION_SUFFIX=" >> $GITHUB_ENV
        outputs:
            VERSION: ${{ env.VERSION }}
            VERSION_SUFFIX: ${{ env.VERSION_SUFFIX }}
    build-docker-single-arch:
        name: build-docker-${{ matrix.binary }}${{ matrix.features.version_suffix }}
        # Use self-hosted runners only on the sigp repo.
        runs-on: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "release"]') || 'ubuntu-22.04'  }}
        strategy:
            matrix:
                binary: [aarch64,
                         aarch64-portable,
                         x86_64,
                         x86_64-portable]
                features: [
                    {version_suffix: "", env: "gnosis,slasher-lmdb,slasher-mdbx,jemalloc"},
                    {version_suffix: "-dev", env: "jemalloc,spec-minimal"}
                ]
                include:
                    - profile: maxperf

        needs: [extract-version]
        env:
            VERSION: ${{ needs.extract-version.outputs.VERSION }}
            VERSION_SUFFIX: ${{ needs.extract-version.outputs.VERSION_SUFFIX }}
            FEATURE_SUFFIX: ${{ matrix.features.version_suffix }}
        steps:
            - uses: actions/checkout@v3
            - name: Update Rust
              if: env.SELF_HOSTED_RUNNERS == 'false'
              run: rustup update stable
            - name: Dockerhub login
              run: |
                  echo "${DOCKER_PASSWORD}" | docker login --username ${DOCKER_USERNAME} --password-stdin
            - name: Cross build Lighthouse binary
              run: |
                  cargo install cross
                  env CROSS_PROFILE=${{ matrix.profile }} CROSS_FEATURES=${{ matrix.features.env }} make build-${{ matrix.binary }}
            - name: Make bin dir
              run: mkdir ./bin
            - name: Move cross-built binary into Docker scope (if ARM)
              if: startsWith(matrix.binary, 'aarch64')
              run: mv ./target/aarch64-unknown-linux-gnu/${{ matrix.profile }}/lighthouse ./bin
            - name: Move cross-built binary into Docker scope (if x86_64)
              if: startsWith(matrix.binary, 'x86_64')
              run: mv ./target/x86_64-unknown-linux-gnu/${{ matrix.profile }}/lighthouse ./bin
            - name: Map aarch64 to arm64 short arch
              if: startsWith(matrix.binary, 'aarch64')
              run: echo "SHORT_ARCH=arm64" >> $GITHUB_ENV
            - name: Map x86_64 to amd64 short arch
              if: startsWith(matrix.binary, 'x86_64')
              run: echo "SHORT_ARCH=amd64" >> $GITHUB_ENV;
            - name: Set modernity suffix
              if: endsWith(matrix.binary, '-portable') != true
              run: echo "MODERNITY_SUFFIX=-modern" >> $GITHUB_ENV;

            - name: Install QEMU
              if: env.SELF_HOSTED_RUNNERS == 'false'
              run: sudo apt-get update && sudo apt-get install -y qemu-user-static

            - name: Set up Docker Buildx
              if: env.SELF_HOSTED_RUNNERS == 'false'
              uses: docker/setup-buildx-action@v2

            - name: Build and push
              uses: docker/build-push-action@v4
              with:
                file: ./Dockerfile.cross
                context: .
                platforms: linux/${{ env.SHORT_ARCH }}
                push: true
                tags: ${{ env.IMAGE_NAME }}:${{ env.VERSION }}-${{ env.SHORT_ARCH }}${{ env.VERSION_SUFFIX }}${{ env.MODERNITY_SUFFIX }}${{ env.FEATURE_SUFFIX }}

    build-docker-multiarch:
        name: build-docker-multiarch${{ matrix.modernity }}
        runs-on: ubuntu-22.04
        needs: [build-docker-single-arch, extract-version]
        strategy:
            matrix:
                modernity: ["", "-modern"]
        env:
            VERSION: ${{ needs.extract-version.outputs.VERSION }}
            VERSION_SUFFIX: ${{ needs.extract-version.outputs.VERSION_SUFFIX }}
        steps:
            - name: Set up Docker Buildx
              uses: docker/setup-buildx-action@v2

            - name: Dockerhub login
              run: |
                  echo "${DOCKER_PASSWORD}" | docker login --username ${DOCKER_USERNAME} --password-stdin

            - name: Create and push multiarch manifest
              run: |
                  docker buildx imagetools create -t ${IMAGE_NAME}:${VERSION}${VERSION_SUFFIX}${{ matrix.modernity }} \
                      ${IMAGE_NAME}:${VERSION}-arm64${VERSION_SUFFIX}${{ matrix.modernity }} \
                      ${IMAGE_NAME}:${VERSION}-amd64${VERSION_SUFFIX}${{ matrix.modernity }};

    build-docker-lcli:
        runs-on: ubuntu-22.04
        needs: [extract-version]
        env:
            VERSION: ${{ needs.extract-version.outputs.VERSION }}
            VERSION_SUFFIX: ${{ needs.extract-version.outputs.VERSION_SUFFIX }}
        steps:
            - uses: actions/checkout@v3
            - name: Dockerhub login
              run: |
                  echo "${DOCKER_PASSWORD}" | docker login --username ${DOCKER_USERNAME} --password-stdin
            - name: Build lcli and push
              uses: docker/build-push-action@v5
              with:
                  build-args: |
                      FEATURES=portable
                  context: .
                  push: true
                  file: ./lcli/Dockerfile
                  tags: ${{ env.LCLI_IMAGE_NAME }}:${{ env.VERSION }}${{ env.VERSION_SUFFIX }}