config.yml

version: 2
jobs:
  build:
    machine:
      image: ubuntu-2004:202010-01
    working_directory: ~/ddev
    environment:
      DRUD_NONINTERACTIVE: "true"
    steps:
    - checkout
    - run: sudo mkdir /home/linuxbrew && sudo chown $(id -u) /home/linuxbrew
    - restore_cache:
        keys:
        - linux-v15
    - run:
        command: ./.circleci/linux_circle_vm_setup.sh
        name: NORMAL Circle VM setup - tools, docker, golang

    - run:
        command: source ~/.bashrc && make staticrequired EXTRA_PATH=/home/linuxbrew/.linuxbrew/bin
        name: staticrequired
    - run:
        command: |
          make linux_amd64 linux_arm64 darwin_amd64 windows_amd64 windows_install EXTRA_PATH=/home/linuxbrew/.linuxbrew/bin
        name: Build the ddev executables
    - run:
        command: ./.circleci/generate_artifacts.sh ~/artifacts
        name: tar/zip up artifacts and make hashes
        no_output_timeout: "40m"
    - store_artifacts:
        path: ~/artifacts
        name: Store artifacts
    - persist_to_workspace:
        root: ~/
        paths: ddev
    - save_cache:
        key: linux-v15
        paths:
        - /home/linuxbrew
        - ~/.ddev/testcache

  lx_nginx_fpm_test:
    machine:
      image: ubuntu-2004:202010-01
    working_directory: ~/ddev
    environment:
      DDEV_TEST_WEBSERVER_TYPE: nginx-fpm
      DRUD_NONINTERACTIVE: "true"
    steps:
    - attach_workspace:
        at: ~/
    - run: sudo mkdir /home/linuxbrew && sudo chown $(id -u) /home/linuxbrew
    - restore_cache:
        keys:
        - linux-v15
    # Run the built-in ddev tests with the executables just built.
    - run:
        command: ./.circleci/linux_circle_vm_setup.sh
        name: Circle VM setup - tools, docker, golang

        # Now build using the regular ddev-only technique - this results in a fully clean set of executables.
    - run:
        command: make -s test EXTRA_PATH=/home/linuxbrew/.linuxbrew/bin
        name: ddev tests
        no_output_timeout: "40m"
    - store_test_results:
        path: /tmp/testresults
    - save_cache:
        key: linux-v15
        paths:
        - /home/linuxbrew
        - ~/.ddev/testcache

  mac_nginx_fpm_test:
    macos:
      xcode: "11.3.1"
    working_directory: ~/ddev
    environment:
      DDEV_TEST_WEBSERVER_TYPE: nginx-fpm
      DRUD_NONINTERACTIVE: "true"
      GOTEST_SHORT: "true"
    steps:
    - attach_workspace:
        at: ~/
    - restore_cache:
        keys:
        - macos-v16
    # Run the built-in ddev tests with the executables just built.
    - run:
        command: ./.circleci/macos_circle_vm_setup.sh
        name: macOS Circle VM setup - tools, docker, golang
        # Now build using the regular ddev-only technique - this results in a fully clean set of executables.
    - run:
        command: make -s test
        name: ddev tests
        no_output_timeout: "40m"
    - save_cache:
        key: macos-v16
        paths:
        - ~/.ddev/testcache
    - store_test_results:
        path: /tmp/testresults

  mac_apache_fpm_test:
    macos:
      xcode: "11.3.1"
    working_directory: ~/ddev
    environment:
      DDEV_TEST_WEBSERVER_TYPE: apache-fpm
      DRUD_NONINTERACTIVE: "true"
      GOTEST_SHORT: "true"
    steps:
    - attach_workspace:
        at: ~/
    - restore_cache:
        keys:
        - macos-v16
    # Run the built-in ddev tests with the executables just built.
    - run:
        command: ./.circleci/macos_circle_vm_setup.sh
        name: macOS Circle VM setup - tools, docker, golang
        # Now build using the regular ddev-only technique - this results in a fully clean set of executables.
    - run:
        command: make -s test
        name: ddev tests
        no_output_timeout: "40m"
    - store_test_results:
        path: /tmp/testresults
    - save_cache:
        key: macos-v16
        paths:
        - ~/.ddev/testcache

  mac_nfsmount_test:
    macos:
      xcode: "11.3.1"
    working_directory: ~/ddev
    environment:
      DDEV_TEST_USE_NFSMOUNT: "true"
      DRUD_NONINTERACTIVE: "true"
      GOTEST_SHORT: "true"
    steps:
    - attach_workspace:
        at: ~/
    - restore_cache:
        keys:
        - macos-v16
    # Run the built-in ddev tests with the executables just built.
    - run:
        command: ./.circleci/macos_circle_vm_setup.sh
        name: macOS Circle VM setup - tools, docker, golang
    - run:
        command: make -s test
        name: ddev tests
        no_output_timeout: "40m"
    - store_test_results:
        path: /tmp/testresults
    - save_cache:
        key: macos-v16
        paths:
        - ~/.ddev/testcache

  lx_apache_fpm_test:
    machine:
      image: ubuntu-2004:202010-01
    working_directory: ~/ddev
    environment:
      DDEV_TEST_WEBSERVER_TYPE: apache-fpm
      # Experiment with only testing TYPO3 with the apache run.
      GOTEST_SHORT: 5
      DRUD_NONINTERACTIVE: "true"
    steps:
    - run: sudo mkdir /home/linuxbrew && sudo chown $(id -u) /home/linuxbrew
    - restore_cache:
        keys:
        - linux-v15
    - attach_workspace:
        at: ~/
    - run:
        command: ./.circleci/linux_circle_vm_setup.sh
        name: Circle VM setup - tools, docker, golang
    # Now build using the regular ddev-only technique - this results in a fully clean set of executables.
    # Run the built-in ddev tests with the executables just built.
    - run:
        command: make -s test EXTRA_PATH=/home/linuxbrew/.linuxbrew/bin
        name: ddev tests
        no_output_timeout: "120m"
    - store_test_results:
        path: /tmp/testresults
    - save_cache:
        key: linux-v15
        paths:
        - /home/linuxbrew
        - ~/.ddev/testcache

  lx_nfsmount_test:
    machine:
      image: ubuntu-2004:202010-01
    working_directory: ~/ddev
    environment:
      DDEV_TEST_USE_NFSMOUNT: true
      # Test only TYPO3 with the apache run.
      GOTEST_SHORT: 5
      DRUD_NONINTERACTIVE: "true"
    steps:
    - run: sudo mkdir /home/linuxbrew && sudo chown $(id -u) /home/linuxbrew
    - restore_cache:
        keys:
        - linux-v15
    - attach_workspace:
        at: ~/
    - run:
        command: ./.circleci/linux_circle_vm_setup.sh
        name: Circle VM setup - tools, docker, golang

        # Now build using the regular ddev-only technique - this results in a fully clean set of executables.
    # Run the built-in ddev tests with the executables just built.
    - run:
        # CircleCI image ubuntu-2004:202010-01 has umask 002, which results in
        # default perms 700 for new directories, which doesn't seem to work with NFS
        command: umask u=rwx,g=rwx,o=rx && make -s test EXTRA_PATH=/home/linuxbrew/.linuxbrew/bin
        name: ddev tests
        no_output_timeout: "120m"
    - store_test_results:
        path: /tmp/testresults
    - save_cache:
        key: linux-v15
        paths:
        - /home/linuxbrew
        - ~/.ddev/testcache

  staticrequired:
    machine:
      image: ubuntu-2004:202010-01
    working_directory: ~/ddev
    environment:
    steps:
    - checkout
    - run: sudo mkdir /home/linuxbrew && sudo chown $(id -u) /home/linuxbrew
    - restore_cache:
        keys:
        - linux-v15
    - run:
        command: ./.circleci/linux_circle_vm_setup.sh
        name: Circle VM setup - tools, docker, golang
    - run:
        command: source ~/.bashrc && make staticrequired EXTRA_PATH=/home/linuxbrew/.linuxbrew/bin
        name: staticrequired

  lx_container_test:
    machine:
      image: ubuntu-2004:202010-01
    working_directory: ~/ddev
    environment:
      GOTEST_SHORT: true
      BUILDKIT_PROGRESS: plain
    steps:
    - checkout
    - run: sudo mkdir /home/linuxbrew && sudo chown $(id -u) /home/linuxbrew
    - restore_cache:
        keys:
        - linux-v15
    - run:
        command: ./.circleci/linux_circle_vm_setup.sh
        name: Circle VM setup - tools, docker, golang
    - run:
        command: ./.circleci/linux_docker_buildx_setup.sh
        name: Docker buildx setup for multi-arch builds

    - run:
        command: |
          . ~/.bashrc
          for dir in containers/*/
              do pushd $dir
              echo "--- Build container $dir"
              time make container DOCKER_ARGS=--no-cache EXTRA_PATH=/home/linuxbrew/.linuxbrew/bin
              echo "--- Test container $dir"
              time make test EXTRA_PATH=/home/linuxbrew/.linuxbrew/bin
              echo "--- Cross-compile container $dir"
              time make multi-arch EXTRA_PATH=/home/linuxbrew/.linuxbrew/bin
              popd
          done
        name: linux container test

    - save_cache:
        key: linux-v15
        paths:
        - /home/linuxbrew
        - ~/.ddev/testcache

  mac_container_test:
    macos:
      xcode: "11.3.1"
    working_directory: ~/ddev
    steps:
    - checkout
    - run:
        command: ./.circleci/macos_circle_vm_setup.sh
        name: macOS Circle VM setup - tools, docker, golang

    - run:
        command: |
          for dir in containers/*
              do pushd $dir
              echo "--- Build container $dir"
              time make container DOCKER_ARGS=--no-cache
              echo "--- Test container $dir"
              time make test
              popd
          done
        name: macos container test

  artifacts:
    machine:
      image: ubuntu-2004:202010-01
    working_directory: ~/ddev
    steps:
    - run: sudo mkdir /home/linuxbrew && sudo chown $(id -u) /home/linuxbrew
    - restore_cache:
        keys:
        - linux-v15
    - attach_workspace:
        at: ~/
    - run:
        command: ./.circleci/generate_artifacts.sh ~/artifacts
        name: tar/zip up artifacts and make hashes
        no_output_timeout: "40m"
    - save_cache:
        key: linux-v15
        paths:
        - /home/linuxbrew
        - ~/.ddev/testcache

    - store_artifacts:
        path: ~/artifacts
        name: Artifact storage


  release_build:
    macos:
      xcode: "11.3.1"
    working_directory: ~/ddev
    environment:
      DDEV_DEBUG: "true"
    steps:
    - checkout
    - run:
        command: ./.circleci/macos_circle_vm_setup.sh
        name: RELEASE BUILD (macOS) Circle VM setup
    - run: echo "version=$(make version)  CIRCLE_TAG=${CIRCLE_TAG}"
    - run:
        command: make -s linux_amd64 linux_arm64 darwin_amd64 windows_amd64 windows_install chocolatey
    - run:
        command: make -s darwin_notarized
        no_output_timeout: 30m

    # We only build the xz version of the docker images on tag build.
    - run:
        command: ./.circleci/generate_artifacts.sh ~/artifacts
        name: tar/zip up artifacts and make hashes
        no_output_timeout: "40m"

    - run:
        command: |
          if [ ! -z "${DDEV_GITHUB_TOKEN}" ]; then
            echo "DDEV_GITHUB_TOKEN provided, pushing release ${CIRCLE_TAG}"
            ghr \
            -prerelease \
            -r $CIRCLE_PROJECT_REPONAME \
            -u $CIRCLE_PROJECT_USERNAME \
            -b "$(cat ./.github/RELEASE_NOTES_TEMPLATE.md)" \
            -t $DDEV_GITHUB_TOKEN \
            "${CIRCLE_TAG}" ~/artifacts
          else
            echo "DDEV_GITHUB_TOKEN not provided, not pushing release $CIRCLE_TAG"
          fi
        name: Upload artifacts to GitHub release page
    - store_artifacts:
        path: ~/artifacts
        name: Artifact storage
    - run:
        name: "Bump homebrew edge release"
        command: ".circleci/bump_homebrew.sh ${HOMEBREW_EDGE_REPOSITORY} ddev ${CIRCLE_TAG} ~/artifacts"
    - run:
        name: "Bump homebrew main release if necessary"
        command: |
          if [ ${CIRCLE_TAG%-*} = ${CIRCLE_TAG} ]; then
            .circleci/bump_homebrew.sh ${HOMEBREW_STABLE_REPOSITORY} ddev ${CIRCLE_TAG} ~/artifacts
          else
            echo "Skipping homebrew main release because ${CIRCLE_TAG} is an edge/prerelease"
          fi
    - run:
        name: Push AUR ddev-bin if necessary
        command: |
            if [ ! -z "${AUR_SSH_PRIVATE_KEY}" ] && [ "${CIRCLE_TAG%-*}" = "${CIRCLE_TAG}" ] ; then
              .circleci/bump_aur.sh ddev-bin ${CIRCLE_TAG} ~/artifacts
            else
              echo "Skipping AUR ddev-bin push"
            fi
    - run:
        name: Push AUR ddev-edge-bin
        command: |
          if [ ! -z "${AUR_SSH_PRIVATE_KEY}" ] ; then
            .circleci/bump_aur.sh ddev-edge-bin ${CIRCLE_TAG} ~/artifacts
          else
            echo "Skipping AUR ddev-edge-bin push"
          fi
    - run:
        name: Upload chocolatey windows release
        command: |
          if [ ! -z "${CHOCOLATEY_API_KEY:-}" ]; then
            echo "Pushing release to chocolatey..."
            pushd .gotmp/bin/windows_amd64/chocolatey
            docker run --rm -v $PWD:/tmp/chocolatey -w /tmp/chocolatey linuturk/mono-choco push -s https://push.chocolatey.org/ --api-key "${CHOCOLATEY_API_KEY}"
            popd
          else
            echo "NOT pushing release to chocolatey because no CHOCOLATEY_API_KEY was provided"
          fi

workflows:
  version: 2
  normal_build_and_test:
    jobs:
    - build
#    - mac_container_test
    - lx_container_test
#    - staticrequired
    - lx_nginx_fpm_test:
        requires:
        - build
#    - mac_nginx_fpm_test:
#        requires:
#        - build
#    - mac_apache_fpm_test:
#        requires:
#        - build
#    - mac_nfsmount_test:
#        requires:
#        - build
    - lx_apache_fpm_test:
        requires:
        - build
#    - lx_apache_cgi_test:
#        requires:
#        - build
    - lx_nfsmount_test:
        requires:
        - build
#    - artifacts:
#        requires:
#        - build

  nightly_build:
    triggers:
      - schedule:
          cron: "0 3 * * *"
          filters:
            branches:
              only:
                - master
                - "pull/[0-9]+"
    jobs:
    - build
    - lx_container_test
    - lx_nginx_fpm_test:
        requires:
        - build

  release_build:
    jobs:
      - release_build:
          context: ddev-local
          filters:
            tags:
              only:
                - "/.*/"
            branches:
              ignore: /.*/