mailu/.github/workflows/CI.yml

name: CI
on:
  push:
    branches:
      - staging
      - testing
      - '1.8'
      - '1.9'      
      - master
      # test branches, e.g. test-debian
      - test-*

concurrency: ci-${{ github.ref }}

###############################################
# REQUIRED secrets
# DOCKER_UN: ${{ secrets.Docker_Login }}
#    Username of docker login for pushing the images to repo $DOCKER_ORG and $DOCKER_ORG_TESTS
# DOCKER_PW: ${{ secrets.Docker_Password }}
#    Password of docker login for pushing the images to repo $DOCKER_ORG and $DOCKER_ORG_TESTS
# DOCKER_ORG: ${{ secrets.DOCKER_ORG }}
#    The docker repository where the images are pushed to.
# DOCKER_ORG_TESTS: ${{ secrets.DOCKER_ORG_TESTS }}
#    The docker repository for test images. Only used for the branch TESTING (BORS try).
# Add the above secrets to your github repo to determine where the images will be pushed.
################################################
# Code block that is used as one liner.
##!/bin/bash
#version=$( git tag --list "{{ env.MAILU_VERSION }}.*" | tail -1  )
#root_version=${version%.*}
#patch_version=${version##*.}
#if [ "$patch_version" == "" ]
#then
#  pinned_version={{ env.MAILU_VERSION }}.0
#else
#  pinned_version=$root_version.$(expr $patch_version + 1)
#fi
#echo "PINNED_MAILU_VERSION=$pinned_version" >> $GITHUB_ENV

jobs:
  build:
    name: Build images
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
        with:
          # fetch-depth 0 is required to also retrieve all tags.
          fetch-depth: 0
      - name: Extract branch name
        shell: bash
        run: |
          echo "BRANCH=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
        #For branch TESTING, we set the image tag to PR-xxxx
      - name: Derive MAILU_VERSION and PINNED_MAILU_VERSION for branch testing
        if: ${{ env.BRANCH == 'testing' }}
        shell: bash
        env:
          COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
          DOCKER_ORG_TESTS: ${{ secrets.DOCKER_ORG_TESTS }}
        run: |
          echo "MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "PINNED_MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG_TESTS" >> $GITHUB_ENV
      - name: Derive MAILU_VERSION for other branches than testing
        if: ${{ env.BRANCH != 'testing' }}
        shell: bash
        env:
          DOCKER_ORG: ${{ secrets.DOCKER_ORG }}
        run: |
          echo "MAILU_VERSION=${{ env.BRANCH }}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for normal release x.y
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'staging' && env.BRANCH != 'master' }}
        shell: bash
        run: |
          version=$( git tag --list "${{ env.MAILU_VERSION }}.*" | tail -1  );root_version=${version%.*};patch_version=${version##*.};if [ "$patch_version" == "" ]; then pinned_version=${{ env.MAILU_VERSION }}.0; else pinned_version=$root_version.$(expr $patch_version + 1); fi;echo "PINNED_MAILU_VERSION=$pinned_version" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for staging
        if: ${{ env.BRANCH == 'staging' }}
        shell: bash
        run: |
          echo "PINNED_MAILU_VERSION=staging" >> $GITHUB_ENV      
      - name: Derive PINNED_MAILU_VERSION for master
        if: ${{ env.BRANCH == 'master' }}
        shell: bash
        env:
          GITHUB_SHA: ${{ env.GITHUB_SHA }}
        run: |
          echo "PINNED_MAILU_VERSION=$GITHUB_SHA" >> $GITHUB_ENV
      - name: Create folder for storing images
        run: |
          sudo mkdir -p /images
          sudo chmod 777 /images
      - name: Configure images folder for caching
        uses: actions/cache@v2
        with:
          path: /images
          key: ${{ env.BRANCH }}-${{ github.run_id }}-${{ github.run_number }}
      - name: Check docker-compose version
        run: docker-compose -v
      - name: Login docker
        env:
          DOCKER_UN: ${{ secrets.Docker_Login }}
          DOCKER_PW: ${{ secrets.Docker_Password }}
          DOCKER_ORG: ${{ env.DOCKER_ORG }}
        run: echo "$DOCKER_PW" | docker login --username $DOCKER_UN --password-stdin
      - name: Build all docker images
        env:
          MAILU_VERSION: ${{ env.MAILU_VERSION }}
          PINNED_MAILU_VERSION: ${{ env.PINNED_MAILU_VERSION }}
          DOCKER_ORG: ${{ env.DOCKER_ORG }}
        run: docker-compose -f tests/build.yml build
      - name: Save all docker images
        run: docker save ${{ env.DOCKER_ORG }}/admin ${{ env.DOCKER_ORG }}/clamav ${{ env.DOCKER_ORG }}/docs ${{ env.DOCKER_ORG }}/dovecot ${{ env.DOCKER_ORG }}/fetchmail ${{ env.DOCKER_ORG }}/nginx ${{ env.DOCKER_ORG }}/none ${{ env.DOCKER_ORG }}/postfix ${{ env.DOCKER_ORG }}/radicale ${{ env.DOCKER_ORG }}/rainloop ${{ env.DOCKER_ORG }}/roundcube ${{ env.DOCKER_ORG }}/rspamd ${{ env.DOCKER_ORG }}/setup ${{ env.DOCKER_ORG }}/traefik-certdumper ${{ env.DOCKER_ORG }}/unbound -o /images/images.tar.gz

  test-core:
    name: Perform core tests
    runs-on: ubuntu-latest
    needs:
      - build
    steps:
      - uses: actions/checkout@v2
        with:
          # fetch-depth 0 is required to also retrieve all tags.
          fetch-depth: 0
      - name: Extract branch name
        shell: bash
        run: |
          echo "BRANCH=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
        #For branch TESTING, we set the image tag to PR-xxxx
      - name: Derive MAILU_VERSION and PINNED_MAILU_VERSION for branch testing
        if: ${{ env.BRANCH == 'testing' }}
        shell: bash
        env:
          COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
          DOCKER_ORG_TESTS: ${{ secrets.DOCKER_ORG_TESTS }}
        run: |
          echo "MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "PINNED_MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG_TESTS" >> $GITHUB_ENV
      - name: Derive MAILU_VERSION for other branches than testing
        if: ${{ env.BRANCH != 'testing' }}
        shell: bash
        env:
          DOCKER_ORG: ${{ secrets.DOCKER_ORG }}
        run: |
          echo "MAILU_VERSION=${{ env.BRANCH }}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for normal release x.y
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'master' }}
        shell: bash
        run: |
          version=$( git tag --list "${{ env.MAILU_VERSION }}.*" | tail -1  );root_version=${version%.*};patch_version=${version##*.};if [ "$patch_version" == "" ]; then pinned_version=${{ env.MAILU_VERSION }}.0; else pinned_version=$root_version.$(expr $patch_version + 1); fi;echo "PINNED_MAILU_VERSION=$pinned_version" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for staging
        if: ${{ env.BRANCH == 'staging' }}
        shell: bash
        run: |
          echo "PINNED_MAILU_VERSION=staging" >> $GITHUB_ENV          
      - name: Derive PINNED_MAILU_VERSION for master
        if: ${{ env.BRANCH == 'master' }}
        shell: bash
        env:
          GITHUB_SHA: ${{ env.GITHUB_SHA }}
        run: |
          echo "PINNED_MAILU_VERSION=$GITHUB_SHA" >> $GITHUB_ENV
      - name: Create folder for storing images
        run: |
          sudo mkdir -p /images
          sudo chmod 777 /images
      - name: Configure images folder for caching
        uses: actions/cache@v2
        with:
          path: /images
          key: ${{ env.BRANCH }}-${{ github.run_id }}-${{ github.run_number }}
      - name: Load docker images
        run: docker load -i /images/images.tar.gz
      - name: Install python packages
        run: python3 -m pip install -r tests/requirements.txt
      - name: Copy all certs
        run: sudo -- sh -c 'mkdir -p /mailu && cp -r tests/certs /mailu && chmod 600 /mailu/certs/*'
      - name: Test core suite
        run: python tests/compose/test.py core 2
        env:
          MAILU_VERSION: ${{ env.MAILU_VERSION }}
          PINNED_MAILU_VERSION: ${{ env.PINNED_MAILU_VERSION }}
          DOCKER_ORG: ${{ env.DOCKER_ORG }}

  test-fetchmail:
    name: Perform fetchmail tests
    runs-on: ubuntu-latest
    needs:
      - build
    steps:
      - uses: actions/checkout@v2
        with:
          # fetch-depth 0 is required to also retrieve all tags.
          fetch-depth: 0
      - name: Extract branch name
        shell: bash
        run: |
          echo "BRANCH=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
        #For branch TESTING, we set the image tag to PR-xxxx
      - name: Derive MAILU_VERSION and PINNED_MAILU_VERSION for branch testing
        if: ${{ env.BRANCH == 'testing' }}
        shell: bash
        env:
          COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
          DOCKER_ORG_TESTS: ${{ secrets.DOCKER_ORG_TESTS }}
        run: |
          echo "MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "PINNED_MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG_TESTS" >> $GITHUB_ENV
      - name: Derive MAILU_VERSION for other branches than testing
        if: ${{ env.BRANCH != 'testing' }}
        shell: bash
        env:
          DOCKER_ORG: ${{ secrets.DOCKER_ORG }}
        run: |
          echo "MAILU_VERSION=${{ env.BRANCH }}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for normal release x.y
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'master' }}
        shell: bash
        run: |
          version=$( git tag --list "${{ env.MAILU_VERSION }}.*" | tail -1  );root_version=${version%.*};patch_version=${version##*.};if [ "$patch_version" == "" ]; then pinned_version=${{ env.MAILU_VERSION }}.0; else pinned_version=$root_version.$(expr $patch_version + 1); fi;echo "PINNED_MAILU_VERSION=$pinned_version" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for staging
        if: ${{ env.BRANCH == 'staging' }}
        shell: bash
        run: |
          echo "PINNED_MAILU_VERSION=staging" >> $GITHUB_ENV          
      - name: Derive PINNED_MAILU_VERSION for master
        if: ${{ env.BRANCH == 'master' }}
        shell: bash
        env:
          GITHUB_SHA: ${{ env.GITHUB_SHA }}
        run: |
          echo "PINNED_MAILU_VERSION=$GITHUB_SHA" >> $GITHUB_ENV
      - name: Create folder for storing images
        run: |
          sudo mkdir -p /images
          sudo chmod 777 /images
      - name: Configure images folder for caching
        uses: actions/cache@v2
        with:
          path: /images
          key: ${{ env.BRANCH }}-${{ github.run_id }}-${{ github.run_number }}
      - name: Load docker images
        run: docker load -i /images/images.tar.gz
      - name: Install python packages
        run: python3 -m pip install -r tests/requirements.txt
      - name: Copy all certs
        run: sudo -- sh -c 'mkdir -p /mailu && cp -r tests/certs /mailu && chmod 600 /mailu/certs/*'
      - name: Test fetch
        run: python tests/compose/test.py fetchmail 2
        env:
          MAILU_VERSION: ${{ env.MAILU_VERSION }}
          PINNED_MAILU_VERSION: ${{ env.PINNED_MAILU_VERSION }}
          DOCKER_ORG: ${{ env.DOCKER_ORG }}

  test-filters:
    name: Perform filter tests
    runs-on: ubuntu-latest
    needs:
      - build
    steps:
      - uses: actions/checkout@v2
        with:
          # fetch-depth 0 is required to also retrieve all tags.
          fetch-depth: 0
      - name: Extract branch name
        shell: bash
        run: |
          echo "BRANCH=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
        #For branch TESTING, we set the image tag to PR-xxxx
      - name: Derive MAILU_VERSION and PINNED_MAILU_VERSION for branch testing
        if: ${{ env.BRANCH == 'testing' }}
        shell: bash
        env:
          COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
          DOCKER_ORG_TESTS: ${{ secrets.DOCKER_ORG_TESTS }}
        run: |
          echo "MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "PINNED_MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG_TESTS" >> $GITHUB_ENV
      - name: Derive MAILU_VERSION for other branches than testing
        if: ${{ env.BRANCH != 'testing' }}
        shell: bash
        env:
          DOCKER_ORG: ${{ secrets.DOCKER_ORG }}
        run: |
          echo "MAILU_VERSION=${{ env.BRANCH }}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for normal release x.y
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'master' }}
        shell: bash
        run: |
          version=$( git tag --list "${{ env.MAILU_VERSION }}.*" | tail -1  );root_version=${version%.*};patch_version=${version##*.};if [ "$patch_version" == "" ]; then pinned_version=${{ env.MAILU_VERSION }}.0; else pinned_version=$root_version.$(expr $patch_version + 1); fi;echo "PINNED_MAILU_VERSION=$pinned_version" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for staging
        if: ${{ env.BRANCH == 'staging' }}
        shell: bash
        run: |
          echo "PINNED_MAILU_VERSION=staging" >> $GITHUB_ENV          
      - name: Derive PINNED_MAILU_VERSION for master
        if: ${{ env.BRANCH == 'master' }}
        shell: bash
        env:
          GITHUB_SHA: ${{ env.GITHUB_SHA }}
        run: |
          echo "PINNED_MAILU_VERSION=$GITHUB_SHA" >> $GITHUB_ENV
      - name: Create folder for storing images
        run: |
          sudo mkdir -p /images
          sudo chmod 777 /images
      - name: Configure images folder for caching
        uses: actions/cache@v2
        with:
          path: /images
          key: ${{ env.BRANCH }}-${{ github.run_id }}-${{ github.run_number }}
      - name: Load docker images
        run: docker load -i /images/images.tar.gz
      - name: Install python packages
        run: python3 -m pip install -r tests/requirements.txt
      - name: Copy all certs
        run: sudo -- sh -c 'mkdir -p /mailu && cp -r tests/certs /mailu && chmod 600 /mailu/certs/*'
      - name: Test clamvav
        run: python tests/compose/test.py filters 3
        env:
          MAILU_VERSION: ${{ env.MAILU_VERSION }}
          PINNED_MAILU_VERSION: ${{ env.PINNED_MAILU_VERSION }}
          DOCKER_ORG: ${{ env.DOCKER_ORG }}

  test-rainloop:
    name: Perform rainloop tests
    runs-on: ubuntu-latest
    needs:
      - build
    steps:
      - uses: actions/checkout@v2
        with:
          # fetch-depth 0 is required to also retrieve all tags.
          fetch-depth: 0
      - name: Extract branch name
        shell: bash
        run: |
          echo "BRANCH=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
        #For branch TESTING, we set the image tag to PR-xxxx
      - name: Derive MAILU_VERSION and PINNED_MAILU_VERSION for branch testing
        if: ${{ env.BRANCH == 'testing' }}
        shell: bash
        env:
          COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
          DOCKER_ORG_TESTS: ${{ secrets.DOCKER_ORG_TESTS }}
        run: |
          echo "MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "PINNED_MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG_TESTS" >> $GITHUB_ENV
      - name: Derive MAILU_VERSION for other branches than testing
        if: ${{ env.BRANCH != 'testing' }}
        shell: bash
        env:
          DOCKER_ORG: ${{ secrets.DOCKER_ORG }}
        run: |
          echo "MAILU_VERSION=${{ env.BRANCH }}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for normal release x.y
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'master' }}
        shell: bash
        run: |
          version=$( git tag --list "${{ env.MAILU_VERSION }}.*" | tail -1  );root_version=${version%.*};patch_version=${version##*.};if [ "$patch_version" == "" ]; then pinned_version=${{ env.MAILU_VERSION }}.0; else pinned_version=$root_version.$(expr $patch_version + 1); fi;echo "PINNED_MAILU_VERSION=$pinned_version" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for staging
        if: ${{ env.BRANCH == 'staging' }}
        shell: bash
        run: |
          echo "PINNED_MAILU_VERSION=staging" >> $GITHUB_ENV          
      - name: Derive PINNED_MAILU_VERSION for master
        if: ${{ env.BRANCH == 'master' }}
        shell: bash
        env:
          GITHUB_SHA: ${{ env.GITHUB_SHA }}
        run: |
          echo "PINNED_MAILU_VERSION=$GITHUB_SHA" >> $GITHUB_ENV
      - name: Create folder for storing images
        run: |
          sudo mkdir -p /images
          sudo chmod 777 /images
      - name: Configure images folder for caching
        uses: actions/cache@v2
        with:
          path: /images
          key: ${{ env.BRANCH }}-${{ github.run_id }}-${{ github.run_number }}
      - name: Load docker images
        run: docker load -i /images/images.tar.gz
      - name: Install python packages
        run: python3 -m pip install -r tests/requirements.txt
      - name: Copy all certs
        run: sudo -- sh -c 'mkdir -p /mailu && cp -r tests/certs /mailu && chmod 600 /mailu/certs/*'
      - name: Test rainloop
        run: python tests/compose/test.py rainloop 2
        env:
          MAILU_VERSION: ${{ env.MAILU_VERSION }}
          PINNED_MAILU_VERSION: ${{ env.PINNED_MAILU_VERSION }}
          DOCKER_ORG: ${{ env.DOCKER_ORG }}

  test-roundcube:
    name: Perform roundcube tests
    runs-on: ubuntu-latest
    needs:
      - build
    steps:
      - uses: actions/checkout@v2
        with:
          # fetch-depth 0 is required to also retrieve all tags.
          fetch-depth: 0
      - name: Extract branch name
        shell: bash
        run: |
          echo "BRANCH=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
        #For branch TESTING, we set the image tag to PR-xxxx
      - name: Derive MAILU_VERSION and PINNED_MAILU_VERSION for branch testing
        if: ${{ env.BRANCH == 'testing' }}
        shell: bash
        env:
          COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
          DOCKER_ORG_TESTS: ${{ secrets.DOCKER_ORG_TESTS }}
        run: |
          echo "MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "PINNED_MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG_TESTS" >> $GITHUB_ENV
      - name: Derive MAILU_VERSION for other branches than testing
        if: ${{ env.BRANCH != 'testing' }}
        shell: bash
        env:
          DOCKER_ORG: ${{ secrets.DOCKER_ORG }}
        run: |
          echo "MAILU_VERSION=${{ env.BRANCH }}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for normal release x.y
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'master' }}
        shell: bash
        run: |
          version=$( git tag --list "${{ env.MAILU_VERSION }}.*" | tail -1  );root_version=${version%.*};patch_version=${version##*.};if [ "$patch_version" == "" ]; then pinned_version=${{ env.MAILU_VERSION }}.0; else pinned_version=$root_version.$(expr $patch_version + 1); fi;echo "PINNED_MAILU_VERSION=$pinned_version" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for staging
        if: ${{ env.BRANCH == 'staging' }}
        shell: bash
        run: |
          echo "PINNED_MAILU_VERSION=staging" >> $GITHUB_ENV          
      - name: Derive PINNED_MAILU_VERSION for master
        if: ${{ env.BRANCH == 'master' }}
        shell: bash
        env:
          GITHUB_SHA: ${{ env.GITHUB_SHA }}
        run: |
          echo "PINNED_MAILU_VERSION=$GITHUB_SHA" >> $GITHUB_ENV
      - name: Create folder for storing images
        run: |
          sudo mkdir -p /images
          sudo chmod 777 /images
      - name: Configure images folder for caching
        uses: actions/cache@v2
        with:
          path: /images
          key: ${{ env.BRANCH }}-${{ github.run_id }}-${{ github.run_number }}
      - name: Load docker images
        run: docker load -i /images/images.tar.gz
      - name: Install python packages
        run: python3 -m pip install -r tests/requirements.txt
      - name: Copy all certs
        run: sudo -- sh -c 'mkdir -p /mailu && cp -r tests/certs /mailu && chmod 600 /mailu/certs/*'
      - name: Test roundcube
        run: python tests/compose/test.py roundcube 2
        env:
          MAILU_VERSION: ${{ env.MAILU_VERSION }}
          PINNED_MAILU_VERSION: ${{ env.PINNED_MAILU_VERSION }}
          DOCKER_ORG: ${{ env.DOCKER_ORG }}

  test-webdav:
    name: Perform webdav tests
    runs-on: ubuntu-latest
    needs:
      - build
    steps:
      - uses: actions/checkout@v2
        with:
          # fetch-depth 0 is required to also retrieve all tags.
          fetch-depth: 0
      - name: Extract branch name
        shell: bash
        run: |
          echo "BRANCH=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
        #For branch TESTING, we set the image tag to PR-xxxx
      - name: Derive MAILU_VERSION and PINNED_MAILU_VERSION for branch testing
        if: ${{ env.BRANCH == 'testing' }}
        shell: bash
        env:
          COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
          DOCKER_ORG_TESTS: ${{ secrets.DOCKER_ORG_TESTS }}
        run: |
          echo "MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "PINNED_MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG_TESTS" >> $GITHUB_ENV
      - name: Derive MAILU_VERSION for other branches than testing
        if: ${{ env.BRANCH != 'testing' }}
        shell: bash
        env:
          DOCKER_ORG: ${{ secrets.DOCKER_ORG }}
        run: |
          echo "MAILU_VERSION=${{ env.BRANCH }}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for normal release x.y
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'master' }}
        shell: bash
        run: |
          version=$( git tag --list "${{ env.MAILU_VERSION }}.*" | tail -1  );root_version=${version%.*};patch_version=${version##*.};if [ "$patch_version" == "" ]; then pinned_version=${{ env.MAILU_VERSION }}.0; else pinned_version=$root_version.$(expr $patch_version + 1); fi;echo "PINNED_MAILU_VERSION=$pinned_version" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for staging
        if: ${{ env.BRANCH == 'staging' }}
        shell: bash
        run: |
          echo "PINNED_MAILU_VERSION=staging" >> $GITHUB_ENV          
      - name: Derive PINNED_MAILU_VERSION for master
        if: ${{ env.BRANCH == 'master' }}
        shell: bash
        env:
          GITHUB_SHA: ${{ env.GITHUB_SHA }}
        run: |
          echo "PINNED_MAILU_VERSION=$GITHUB_SHA" >> $GITHUB_ENV
      - name: Create folder for storing images
        run: |
          sudo mkdir -p /images
          sudo chmod 777 /images
      - name: Configure images folder for caching
        uses: actions/cache@v2
        with:
          path: /images
          key: ${{ env.BRANCH }}-${{ github.run_id }}-${{ github.run_number }}
      - name: Load docker images
        run: docker load -i /images/images.tar.gz
      - name: Install python packages
        run: python3 -m pip install -r tests/requirements.txt
      - name: Copy all certs
        run: sudo -- sh -c 'mkdir -p /mailu && cp -r tests/certs /mailu && chmod 600 /mailu/certs/*'
      - name: Test webdav
        run: python tests/compose/test.py webdav 2
        env:
          MAILU_VERSION: ${{ env.MAILU_VERSION }}
          PINNED_MAILU_VERSION: ${{ env.PINNED_MAILU_VERSION }}
          DOCKER_ORG: ${{ env.DOCKER_ORG }}

  deploy:
    name: Deploy images
    runs-on: ubuntu-latest
    needs:
      - build
      - test-core
      - test-fetchmail
      - test-filters
      - test-rainloop
      - test-roundcube
      - test-webdav
    steps:
      - uses: actions/checkout@v2
        with:
          # fetch-depth 0 is required to also retrieve all tags.
          fetch-depth: 0
      - name: Extract branch name
        shell: bash
        run: |
          echo "BRANCH=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
        #For branch TESTING, we set the image tag to PR-xxxx
      - name: Derive MAILU_VERSION and PINNED_MAILU_VERSION for branch testing
        if: ${{ env.BRANCH == 'testing' }}
        shell: bash
        env:
          COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
          DOCKER_ORG_TESTS: ${{ secrets.DOCKER_ORG_TESTS }}
        run: |
          echo "MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "PINNED_MAILU_VERSION=pr-${COMMIT_MESSAGE//[!0-9]/}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG_TESTS" >> $GITHUB_ENV
      - name: Derive MAILU_VERSION for other branches than testing
        if: ${{ env.BRANCH != 'testing' }}
        shell: bash
        env:
          DOCKER_ORG: ${{ secrets.DOCKER_ORG }}
        run: |
          echo "MAILU_VERSION=${{ env.BRANCH }}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for normal release x.y
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'master' }}
        shell: bash
        run: |
          version=$( git tag --list "${{ env.MAILU_VERSION }}.*" | tail -1  );root_version=${version%.*};patch_version=${version##*.};if [ "$patch_version" == "" ]; then pinned_version=${{ env.MAILU_VERSION }}.0; else pinned_version=$root_version.$(expr $patch_version + 1); fi;echo "PINNED_MAILU_VERSION=$pinned_version" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for staging
        if: ${{ env.BRANCH == 'staging' }}
        shell: bash
        run: |
          echo "PINNED_MAILU_VERSION=staging" >> $GITHUB_ENV          
      - name: Derive PINNED_MAILU_VERSION for master
        if: ${{ env.BRANCH == 'master' }}
        shell: bash
        env:
          GITHUB_SHA: ${{ env.GITHUB_SHA }}
        run: |
          echo "PINNED_MAILU_VERSION=$GITHUB_SHA" >> $GITHUB_ENV
      - name: Create folder for storing images
        run: |
          sudo mkdir -p /images
          sudo chmod 777 /images
      - name: Configure images folder for caching
        # For staging we do not deploy images. So we do not have to load them from cache.
        if: ${{ env.BRANCH != 'staging' }}
        uses: actions/cache@v2
        with:
          path: /images
          key: ${{ env.BRANCH }}-${{ github.run_id }}-${{ github.run_number }}
      - name: Load docker images
        if: ${{ env.BRANCH != 'staging' }}
        run: docker load -i /images/images.tar.gz
      - name: Deploy built docker images
        env:
          DOCKER_UN: ${{ secrets.Docker_Login }}
          DOCKER_PW: ${{ secrets.Docker_Password }}
          DOCKER_ORG: ${{ env.DOCKER_ORG }}
          MAILU_VERSION: ${{ env.MAILU_VERSION }}
          PINNED_MAILU_VERSION: ${{ env.PINNED_MAILU_VERSION }}
          BRANCH: ${{ env.BRANCH }}
        run: bash tests/deploy.sh

  tag-release:
    runs-on: ubuntu-latest
    needs:
      - deploy
    steps:
      - uses: actions/checkout@v2
        with:
          # fetch-depth 0 is required to also retrieve all tags.
          fetch-depth: 0
      - name: Extract branch name
        shell: bash
        run: |
          echo "BRANCH=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
      - name: Derive MAILU_VERSION amd DOCKER_ORG
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'staging' && env.BRANCH != 'master' }}
        shell: bash
        env:
          DOCKER_ORG: ${{ secrets.DOCKER_ORG }}
        run: |
          echo "MAILU_VERSION=${{ env.BRANCH }}" >> $GITHUB_ENV
          echo "DOCKER_ORG=$DOCKER_ORG" >> $GITHUB_ENV
      - name: Derive PINNED_MAILU_VERSION for normal release x.y
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'staging' && env.BRANCH != 'master' }}
        shell: bash
        run: |
          version=$( git tag --list "${{ env.MAILU_VERSION }}.*" | tail -1  );root_version=${version%.*};patch_version=${version##*.};if [ "$patch_version" == "" ]; then pinned_version=${{ env.MAILU_VERSION }}.0; else pinned_version=$root_version.$(expr $patch_version + 1); fi;echo "PINNED_MAILU_VERSION=$pinned_version" >> $GITHUB_ENV
      - name: Tag and create release
        if: ${{ env.BRANCH != 'testing' && env.BRANCH != 'staging' && env.BRANCH != 'master' && env.PINNED_MAILU_VERSION != '' }}
        uses: ncipollo/release-action@v1
        with:
          bodyFile: "RELEASE_TEMPLATE.md"
          commit: ${{ env.GITHUB_SHA }}
          tag: ${{ env.PINNED_MAILU_VERSION }}
          token: ${{ secrets.GITHUB_TOKEN }}

 # This job is watched by bors. It only complets if building,testing and deploy worked.
  ci-success:
    name: CI-Done
    #Returns true when none of the **previous** steps have failed or have been canceled.
    if: ${{ success() }}
    needs:
      - deploy
    runs-on: ubuntu-latest
    steps:
      - name: CI/CD succeeded.
        run: exit 0