config.in.yml

# When a task that used to pass starts to fail
# Go through all versions that may have been skipped to detect
# when the task started failing
stepback: true

# Mark a failure as a system/bootstrap failure (purple box) rather then a task
# failure by default.
# Actual testing tasks are marked with `type: test`
command_type: system

# Protect ourself against rogue test case, or curl gone wild, that runs forever
# Good rule of thumb: the averageish length a task takes, times 5
# That roughly accounts for variable system performance for various buildvariants
exec_timeout_secs: 1200

# What to do when evergreen hits the timeout (`post:` tasks are run automatically)
timeout:
  - command: subprocess.exec
    params:
      binary: ls
      args:
        - "-la"

functions:
  "fetch source":
    # Executes git clone and applies the submitted patch, if any
    - command: git.get_project
      params:
        directory: "src"
        shallow_clone: true # speed things up by limiting clone depth to 100

    # Make an evergreen expansion file with dynamic values
    - command: subprocess.exec
      params:
        working_dir: "src"
        binary: bash
        env:
          is_patch: ${is_patch}
          project: ${project}
        args:
        - .evergreen/prepare-shell.sh

    # Load the expansion file to make an evergreen variable with the current unique version
    - command: expansions.update
      params:
        file: src/expansion.yml

  "bootstrap mongo-orchestration":
    - command: subprocess.exec
      params:
        binary: bash
        add_expansions_to_env: true
        env:
          # The following is the settings for how we want to launch mongodb
          MONGODB_VERSION: ${VERSION}
          TOPOLOGY: ${TOPOLOGY}
          AUTH: ${AUTH}
          SSL: ${SSL}
          ORCHESTRATION_FILE: ${ORCHESTRATION_FILE}
          REQUIRE_API_VERSION: ${REQUIRE_API_VERSION}
          LOAD_BALANCER: ${LOAD_BALANCER}
          COMPRESSOR: ${COMPRESSOR}
          # These are paths necessary for launching mongodb
          DRIVERS_TOOLS: ${DRIVERS_TOOLS}
          MONGODB_BINARIES: ${MONGODB_BINARIES}
        args:
          - src/.evergreen/run-orchestration.sh

    # run-orchestration generates expansion file with the MONGODB_URI for the cluster
    - command: expansions.update
      params:
        file: mo-expansion.yml

  "bootstrap mongohoused":
    - command: shell.exec
      params:
        script: |
          ${PREPARE_SHELL}
          DRIVERS_TOOLS="${DRIVERS_TOOLS}" bash ${DRIVERS_TOOLS}/.evergreen/atlas_data_lake/build-mongohouse-local.sh
    - command: shell.exec
      params:
        background: true
        script: |
          ${PREPARE_SHELL}
          DRIVERS_TOOLS="${DRIVERS_TOOLS}" bash ${DRIVERS_TOOLS}/.evergreen/atlas_data_lake/run-mongohouse-local.sh

  "bootstrap kms servers":
    - command: subprocess.exec
      params:
        background: true
        working_dir: src
        binary: bash
        args:
          - .evergreen/run-kms-servers.sh
        env:
          DRIVERS_TOOLS: ${DRIVERS_TOOLS}
  "run tests":
    - command: shell.exec
      type: test
      params:
        silent: true
        working_dir: "src"
        script: |
          if [ -n "${CLIENT_ENCRYPTION}" ]; then
            cat <<EOT > prepare_client_encryption.sh
            export CLIENT_ENCRYPTION=${CLIENT_ENCRYPTION}
            export CSFLE_KMS_PROVIDERS='${CSFLE_KMS_PROVIDERS}'
            export AWS_ACCESS_KEY_ID='${AWS_ACCESS_KEY_ID}'
            export AWS_SECRET_ACCESS_KEY='${AWS_SECRET_ACCESS_KEY}'
            export AWS_DEFAULT_REGION='us-east-1'
            export KMIP_TLS_CA_FILE="${DRIVERS_TOOLS}/.evergreen/x509gen/ca.pem"
            export KMIP_TLS_CERT_FILE="${DRIVERS_TOOLS}/.evergreen/x509gen/client.pem"
          EOT
          fi
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        timeout_secs: 300
        shell: bash
        script: |
          ${PREPARE_SHELL}

          if [ -n "${CLIENT_ENCRYPTION}" ]; then
            # Disable xtrace (just in case it was accidentally set).
            set +x
            . ./prepare_client_encryption.sh
            rm -f ./prepare_client_encryption.sh
          fi

          export VERSION=${VERSION}
          export DRIVERS_TOOLS=${DRIVERS_TOOLS}

          source ${PROJECT_DIRECTORY}/.evergreen/prepare-crypt-shared-lib.sh

          echo "CRYPT_SHARED_LIB_PATH: $CRYPT_SHARED_LIB_PATH"

          MONGODB_URI="${MONGODB_URI}" \
          AUTH=${AUTH} SSL=${SSL} TEST_CSFLE=true \
          MONGODB_API_VERSION="${MONGODB_API_VERSION}" \
          NODE_VERSION=${NODE_VERSION} SKIP_DEPS=${SKIP_DEPS|1} \
            bash ${PROJECT_DIRECTORY}/.evergreen/run-tests.sh

  "run serverless tests":
    - command: timeout.update
      params:
        exec_timeout_secs: 1800
    - command: shell.exec
      type: test
      params:
        silent: true
        working_dir: src
        script: |
          cat <<EOT > prepare_client_encryption.sh
            export CLIENT_ENCRYPTION=${CLIENT_ENCRYPTION}
            export CSFLE_KMS_PROVIDERS='${CSFLE_KMS_PROVIDERS}'
            export AWS_ACCESS_KEY_ID='${AWS_ACCESS_KEY_ID}'
            export AWS_SECRET_ACCESS_KEY='${AWS_SECRET_ACCESS_KEY}'
            export AWS_DEFAULT_REGION='us-east-1'
            export KMIP_TLS_CA_FILE="${DRIVERS_TOOLS}/.evergreen/x509gen/ca.pem"
            export KMIP_TLS_CERT_FILE="${DRIVERS_TOOLS}/.evergreen/x509gen/client.pem"
          EOT
    - command: shell.exec
      type: test
      params:
        working_dir: src
        timeout_secs: 300
        shell: bash
        script: |
          ${PREPARE_SHELL}

          # Disable xtrace (just in case it was accidentally set).
          set +x
          source ./prepare_client_encryption.sh
          rm -f ./prepare_client_encryption.sh

          export VERSION=${VERSION}
          export DRIVERS_TOOLS=${DRIVERS_TOOLS}

          source ${PROJECT_DIRECTORY}/.evergreen/prepare-crypt-shared-lib.sh

          echo "CRYPT_SHARED_LIB_PATH: $CRYPT_SHARED_LIB_PATH"

          # Get access to the AWS temporary credentials:
          echo "adding temporary AWS credentials to environment"
          # CSFLE_AWS_TEMP_ACCESS_KEY_ID, CSFLE_AWS_TEMP_SECRET_ACCESS_KEY, CSFLE_AWS_TEMP_SESSION_TOKEN
          . "$DRIVERS_TOOLS"/.evergreen/csfle/set-temp-creds.sh

          MONGODB_URI="${MONGODB_URI}" \
          AUTH=${AUTH} SSL=${SSL} TEST_CSFLE=true \
          MONGODB_API_VERSION="${MONGODB_API_VERSION}"

          export MONGODB_API_VERSION="${MONGODB_API_VERSION}"
          export AUTH="auth"
          export SSL="ssl"
          export SERVERLESS="1"
          export SERVERLESS_ATLAS_USER="${SERVERLESS_ATLAS_USER}"
          export SERVERLESS_ATLAS_PASSWORD="${SERVERLESS_ATLAS_PASSWORD}"
          export SERVERLESS_URI="${SERVERLESS_URI}"

          echo "setting SERVERLESS_URI: $SERVERLESS_URI"

          export MONGODB_URI="${SERVERLESS_URI}"
          export SINGLE_MONGOS_LB_URI="${SERVERLESS_URI}"

          # Setting MULTI_MONGOS to the SERVERLESS_URI is intentional
          # LB tests pick one host out of the comma separated list
          # so just passing the one host is equivalent
          export MULTI_MONGOS_LB_URI="${SERVERLESS_URI}"

          bash ${PROJECT_DIRECTORY}/.evergreen/run-serverless-tests.sh

  "start-load-balancer":
    - command: shell.exec
      params:
        script: |
          MONGODB_URI=${MONGODB_URI} bash ${DRIVERS_TOOLS}/.evergreen/run-load-balancer.sh start
    - command: expansions.update
      params:
        file: lb-expansion.yml

  "stop-load-balancer":
    - command: shell.exec
      params:
        script: |
          bash ${DRIVERS_TOOLS}/.evergreen/run-load-balancer.sh stop

  "run-lb-tests":
    - command: shell.exec
      type: test
      params:
        working_dir: src
        timeout_secs: 300
        script: |
          ${PREPARE_SHELL}

          MONGODB_URI="${MONGODB_URI}" \
          AUTH=${AUTH} \
          SSL=${SSL} \
          MONGODB_API_VERSION="${MONGODB_API_VERSION}" \
          NODE_VERSION=${NODE_VERSION} \
          SINGLE_MONGOS_LB_URI="${SINGLE_MONGOS_LB_URI}" \
          MULTI_MONGOS_LB_URI="${MULTI_MONGOS_LB_URI}" \
          TOPOLOGY="${TOPOLOGY}" \
          SKIP_DEPS=${SKIP_DEPS|1} \
          LOAD_BALANCER="${LOAD_BALANCER}" \
            bash ${PROJECT_DIRECTORY}/.evergreen/run-tests.sh

  "run-compression-tests":
    - command: shell.exec
      type: test
      params:
        working_dir: src
        timeout_secs: 300
        script: |
          ${PREPARE_SHELL}

          MONGODB_URI="${MONGODB_URI}" \
          AUTH=${AUTH} \
          SSL=${SSL} \
          MONGODB_API_VERSION="${MONGODB_API_VERSION}" \
          NODE_VERSION=${NODE_VERSION} \
          TOPOLOGY="${TOPOLOGY}" \
          COMPRESSOR="${COMPRESSOR}" \
          SKIP_DEPS=${SKIP_DEPS|1} \
            bash ${PROJECT_DIRECTORY}/.evergreen/run-tests.sh

  "run lint checks":
    - command: subprocess.exec
      type: test
      params:
        working_dir: "src"
        timeout_secs: 60
        env:
          PROJECT_DIRECTORY: ${PROJECT_DIRECTORY}
        binary: bash
        args:
          - "${PROJECT_DIRECTORY}/.evergreen/run-lint-checks.sh"

  "run unit tests":
    - command: subprocess.exec
      type: test
      params:
        working_dir: "src"
        timeout_secs: 60
        env:
          PROJECT_DIRECTORY: ${PROJECT_DIRECTORY}
        binary: bash
        args:
          - "${PROJECT_DIRECTORY}/.evergreen/run-unit-tests.sh"

  "check types":
    - command: subprocess.exec
      type: test
      params:
        working_dir: "src"
        timeout_secs: 60
        env:
          PROJECT_DIRECTORY: ${PROJECT_DIRECTORY}
          TS_VERSION: ${TS_VERSION}
          TS_CHECK: CHECK_TYPES
        binary: bash
        args:
          - "${PROJECT_DIRECTORY}/.evergreen/run-typescript.sh"

  "compile driver":
    - command: subprocess.exec
      type: test
      params:
        working_dir: "src"
        timeout_secs: 60
        env:
          PROJECT_DIRECTORY: ${PROJECT_DIRECTORY}
          TS_VERSION: ${TS_VERSION}
          TS_CHECK: COMPILE_DRIVER
        binary: bash
        args:
          - "${PROJECT_DIRECTORY}/.evergreen/run-typescript.sh"

  "run mongosh integration tests":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          export DISTRO_ID=${distro_id}
          bash ${PROJECT_DIRECTORY}/.evergreen/run-mongosh-integration-tests.sh

  "cleanup":
    - command: shell.exec
      params:
        silent: true
        script: |
          ${PREPARE_SHELL}
          rm -rf $DRIVERS_TOOLS || true

  "fix absolute paths":
    - command: shell.exec
      params:
        silent: true
        script: |
          ${PREPARE_SHELL}
          for filename in $(find ${DRIVERS_TOOLS} -name \*.json); do
            perl -p -i -e "s|ABSOLUTE_PATH_REPLACEMENT_TOKEN|${DRIVERS_TOOLS}|g" $filename
          done

  "windows fix":
    - command: shell.exec
      params:
        silent: true
        script: |
          ${PREPARE_SHELL}
          # for i in $(find ${DRIVERS_TOOLS}/.evergreen ${PROJECT_DIRECTORY}/.evergreen -name \*.sh); do
          #   cat $i | tr -d '\r' > $i.new
          #   mv $i.new $i
          # done
          # Copy client certificate because symlinks do not work on Windows.
          cp ${DRIVERS_TOOLS}/.evergreen/x509gen/client.pem ${MONGO_ORCHESTRATION_HOME}/lib/client.pem

  "make files executable":
    - command: shell.exec
      params:
        silent: true
        script: |
          ${PREPARE_SHELL}
          for i in $(find ${DRIVERS_TOOLS}/.evergreen ${PROJECT_DIRECTORY}/.evergreen -name \*.sh); do
            chmod +x $i
          done

  "install dependencies":
    - command: shell.exec
      type: setup
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          NODE_LTS_NAME=${NODE_LTS_NAME} MSVS_VERSION=${MSVS_VERSION} NPM_OPTIONS=${NPM_OPTIONS}\
            bash ${PROJECT_DIRECTORY}/.evergreen/install-dependencies.sh
    - command: expansions.update
      params:
        file: src/deps-expansion.yml

  "run atlas tests":
    - command: shell.exec
      type: test
      params:
        silent: true
        working_dir: "src"
        script: |
          cat <<EOT > prepare_atlas_connectivity.sh
          export ATLAS_CONNECTIVITY='${ATLAS_CONNECTIVITY}'
          EOT
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          # Disable xtrace (just in case it was accidentally set).
          set +x
          . ./prepare_atlas_connectivity.sh
          rm -f ./prepare_atlas_connectivity.sh

          export PROJECT_DIRECTORY="$(pwd)"
          export NODE_LTS_NAME='${NODE_LTS_NAME}'

          bash ${PROJECT_DIRECTORY}/.evergreen/run-atlas-tests.sh

  "run socks5 tests":
    - command: shell.exec
      type: test
      params:
        silent: true
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          cat <<EOT > prepare_client_encryption.sh
          export CLIENT_ENCRYPTION='${CLIENT_ENCRYPTION}'
          export CSFLE_KMS_PROVIDERS='${CSFLE_KMS_PROVIDERS}'
          export AWS_ACCESS_KEY_ID='${AWS_ACCESS_KEY_ID}'
          export AWS_SECRET_ACCESS_KEY='${AWS_SECRET_ACCESS_KEY}'
          export CSFLE_GIT_REF='${CSFLE_GIT_REF}'
          export CDRIVER_GIT_REF='${CDRIVER_GIT_REF}'
          EOT
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}

          export PYTHON_BINARY=$([ "Windows_NT" = "$OS" ] && echo "/cygdrive/c/python/python38/python.exe" || echo "/opt/mongodbtoolchain/v3/bin/python3")
          export PROJECT_DIRECTORY="$(pwd)"
          export DRIVERS_TOOLS="${DRIVERS_TOOLS}"
          export NODE_LTS_NAME='${NODE_LTS_NAME}'
          export MONGODB_URI="${MONGODB_URI}"
          export SSL="${SSL}"

          # Disable xtrace (just in case it was accidentally set).
          set +x
          . ./prepare_client_encryption.sh
          rm -f ./prepare_client_encryption.sh

          bash ${PROJECT_DIRECTORY}/.evergreen/run-socks5-tests.sh

  "run kerberos tests":
    - command: shell.exec
      type: test
      params:
        working_dir: src
        script: |
          export PROJECT_DIRECTORY="$(pwd)"
          export KRB5_KEYTAB='${gssapi_auth_keytab_base64}'
          export KRB5_PRINCIPAL='${gssapi_auth_principal}'
          export MONGODB_URI='${gssapi_auth_mongodb_uri}'
          export NODE_LTS_NAME='${NODE_LTS_NAME}'

          bash ${PROJECT_DIRECTORY}/.evergreen/run-kerberos-tests.sh

  "run ldap tests":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          export PROJECT_DIRECTORY="$(pwd)"
          export MONGODB_URI='${plain_auth_mongodb_uri}'
          export NODE_LTS_NAME='${NODE_LTS_NAME}'

          bash ${PROJECT_DIRECTORY}/.evergreen/run-ldap-tests.sh

  "run data lake tests":
      - command: shell.exec
        type: test
        params:
          working_dir: src
          script: |
            export PROJECT_DIRECTORY="$(pwd)"
            export MONGODB_URI='mongodb://mhuser:pencil@localhost'
            export NODE_LTS_NAME='${NODE_LTS_NAME}'

            bash ${PROJECT_DIRECTORY}/.evergreen/run-data-lake-tests.sh

  "run tls tests":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          export PROJECT_DIRECTORY="$(pwd)"
          export NODE_LTS_NAME=${NODE_LTS_NAME}
          export DRIVERS_TOOLS="${DRIVERS_TOOLS}"
          export SSL_CA_FILE="${SSL_CA_FILE}"
          export SSL_KEY_FILE="${SSL_KEY_FILE}"
          export MONGODB_URI="${MONGODB_URI}"

          bash ${PROJECT_DIRECTORY}/.evergreen/run-tls-tests.sh

  "add aws auth variables to file":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        silent: true
        script: |
          cat <<EOF > ${DRIVERS_TOOLS}/.evergreen/auth_aws/aws_e2e_setup.json
          {
              "iam_auth_ecs_account" : "${iam_auth_ecs_account}",
              "iam_auth_ecs_secret_access_key" : "${iam_auth_ecs_secret_access_key}",
              "iam_auth_ecs_account_arn": "arn:aws:iam::557821124784:user/authtest_fargate_user",
              "iam_auth_ecs_cluster": "${iam_auth_ecs_cluster}",
              "iam_auth_ecs_task_definition": "${iam_auth_ecs_task_definition}",
              "iam_auth_ecs_subnet_a": "${iam_auth_ecs_subnet_a}",
              "iam_auth_ecs_subnet_b": "${iam_auth_ecs_subnet_b}",
              "iam_auth_ecs_security_group": "${iam_auth_ecs_security_group}",
              "iam_auth_assume_aws_account" : "${iam_auth_assume_aws_account}",
              "iam_auth_assume_aws_secret_access_key" : "${iam_auth_assume_aws_secret_access_key}",
              "iam_auth_assume_role_name" : "${iam_auth_assume_role_name}",
              "iam_auth_ec2_instance_account" : "${iam_auth_ec2_instance_account}",
              "iam_auth_ec2_instance_secret_access_key" : "${iam_auth_ec2_instance_secret_access_key}",
              "iam_auth_ec2_instance_profile" : "${iam_auth_ec2_instance_profile}"
          }
          EOF

  "setup aws env":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        shell: bash
        script: |
          ${PREPARE_SHELL}
          cd ${DRIVERS_TOOLS}/.evergreen/auth_aws
          . ./activate-authawsvenv.sh
          cd -

  "run aws auth test with regular aws credentials":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        shell: bash
        script: |
          ${PREPARE_SHELL}
          cd ${DRIVERS_TOOLS}/.evergreen/auth_aws
          . ./activate-authawsvenv.sh
          ${MONGODB_BINARIES}/mongo aws_e2e_regular_aws.js
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        silent: true
        script: |
          cat <<'EOF' > "${PROJECT_DIRECTORY}/prepare_mongodb_aws.sh"
            alias urlencode='python -c "import sys, urllib as ul; print ul.quote_plus(sys.argv[1])"'
            USER=$(urlencode ${iam_auth_ecs_account})
            PASS=$(urlencode ${iam_auth_ecs_secret_access_key})
            export MONGODB_URI="mongodb://$USER:$PASS@localhost:27017/aws?authMechanism=MONGODB-AWS"
          EOF
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          ${PROJECT_DIRECTORY}/.evergreen/run-mongodb-aws-test.sh

  "run aws auth test with assume role credentials":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        shell: bash
        script: |
          ${PREPARE_SHELL}
          cd ${DRIVERS_TOOLS}/.evergreen/auth_aws
          . ./activate-authawsvenv.sh
          ${MONGODB_BINARIES}/mongo aws_e2e_assume_role.js
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        silent: true
        script: |
          cat <<'EOF' > "${PROJECT_DIRECTORY}/prepare_mongodb_aws.sh"
            alias urlencode='python -c "import sys, urllib as ul; print ul.quote_plus(sys.argv[1])"'
            USER=$(jq -r '.AccessKeyId' ${DRIVERS_TOOLS}/.evergreen/auth_aws/creds.json)
            USER=$(urlencode $USER)
            PASS=$(jq -r '.SecretAccessKey' ${DRIVERS_TOOLS}/.evergreen/auth_aws/creds.json)
            PASS=$(urlencode $PASS)
            SESSION_TOKEN=$(jq -r '.SessionToken' ${DRIVERS_TOOLS}/.evergreen/auth_aws/creds.json)
            SESSION_TOKEN=$(urlencode $SESSION_TOKEN)
            export MONGODB_URI="mongodb://$USER:$PASS@localhost:27017/aws?authMechanism=MONGODB-AWS&authMechanismProperties=AWS_SESSION_TOKEN:$SESSION_TOKEN"
          EOF
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          ${PROJECT_DIRECTORY}/.evergreen/run-mongodb-aws-test.sh

  "run aws auth test with aws EC2 credentials":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        shell: bash
        script: |
          ${PREPARE_SHELL}
          # Write an empty prepare_mongodb_aws so no auth environment variables
          # are set.
          echo "" > "${PROJECT_DIRECTORY}/prepare_mongodb_aws.sh"
          cd ${DRIVERS_TOOLS}/.evergreen/auth_aws
          . ./activate-authawsvenv.sh
          ${MONGODB_BINARIES}/mongo aws_e2e_ec2.js
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          export IS_EC2=true
          ${PROJECT_DIRECTORY}/.evergreen/run-mongodb-aws-test.sh

  "run aws auth test with aws credentials as environment variables":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        silent: true
        script: |
          cd ${DRIVERS_TOOLS}/.evergreen/auth_aws
          ${MONGODB_BINARIES}/mongo --verbose aws_e2e_regular_aws.js
          cd -
          cat <<EOF > "${PROJECT_DIRECTORY}/prepare_mongodb_aws.sh"
            export AWS_ACCESS_KEY_ID=${iam_auth_ecs_account}
            export AWS_SECRET_ACCESS_KEY=${iam_auth_ecs_secret_access_key}
            export MONGODB_URI="mongodb://localhost:27017/aws?authMechanism=MONGODB-AWS"
          EOF
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          ${PROJECT_DIRECTORY}/.evergreen/run-mongodb-aws-test.sh

  "run aws auth test with aws credentials and session token as environment variables":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        silent: true
        script: |
          cd ${DRIVERS_TOOLS}/.evergreen/auth_aws
          ${MONGODB_BINARIES}/mongo --verbose aws_e2e_assume_role.js
          cd -
          cat <<'EOF' > "${PROJECT_DIRECTORY}/prepare_mongodb_aws.sh"
            export AWS_ACCESS_KEY_ID=$(jq -r '.AccessKeyId' ${DRIVERS_TOOLS}/.evergreen/auth_aws/creds.json)
            export AWS_SECRET_ACCESS_KEY=$(jq -r '.SecretAccessKey' ${DRIVERS_TOOLS}/.evergreen/auth_aws/creds.json)
            export AWS_SESSION_TOKEN=$(jq -r '.SessionToken' ${DRIVERS_TOOLS}/.evergreen/auth_aws/creds.json)
            export MONGODB_URI="mongodb://localhost:27017/aws?authMechanism=MONGODB-AWS"
          EOF
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          ${PROJECT_DIRECTORY}/.evergreen/run-mongodb-aws-test.sh

  "run aws ECS auth test":
    - command: shell.exec
      type: test
      params:
        working_dir: src
        shell: bash
        script: |
          ${PREPARE_SHELL}
          AUTH_AWS_DIR=${DRIVERS_TOOLS}/.evergreen/auth_aws
          ECS_SRC_DIR=$AUTH_AWS_DIR/src

          # fix issue with `TestData` in SERVER-46340
          sed -i '1s+^+TestData = {};\n+' $AUTH_AWS_DIR/lib/ecs_hosted_test.js

          # pack up project directory to ssh it to the container
          mkdir -p $ECS_SRC_DIR/.evergreen
          cp $PROJECT_DIRECTORY/.evergreen/run-mongodb-aws-ecs-test.sh $ECS_SRC_DIR/.evergreen
          tar -czf $ECS_SRC_DIR/src.tgz -C $PROJECT_DIRECTORY .

          cd $AUTH_AWS_DIR
          cat <<EOF > setup.js
            const mongo_binaries = "$MONGODB_BINARIES";
            const project_dir = "$ECS_SRC_DIR";
          EOF

          cat setup.js
          . ./activate-authawsvenv.sh
          ${MONGODB_BINARIES}/mongo --nodb setup.js aws_e2e_ecs.js

  "run-ocsp-test":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}

          CA_FILE="$DRIVERS_TOOLS/.evergreen/ocsp/rsa/ca.pem" \
          OCSP_TLS_SHOULD_SUCCEED="${OCSP_TLS_SHOULD_SUCCEED}" \
          bash ${PROJECT_DIRECTORY}/.evergreen/run-ocsp-tests.sh

  "run-valid-ocsp-server":
    - command: shell.exec
      params:
        script: |
          cd ${DRIVERS_TOOLS}/.evergreen/ocsp
          export PYTHON_BINARY=$([ "Windows_NT" = "$OS" ] && echo "/cygdrive/c/python/python38/python.exe" || echo "/opt/mongodbtoolchain/v3/bin/python3")
          export PYTHON_VENV_PATH=$([ "Windows_NT" = "$OS" ] && echo "./venv/Scripts" || echo "./venv/bin")

          $PYTHON_BINARY -m venv ./venv
          $PYTHON_VENV_PATH/pip3 install -r ${DRIVERS_TOOLS}/.evergreen/ocsp/mock-ocsp-responder-requirements.txt

    - command: shell.exec
      params:
        background: true
        script: |
          cd ${DRIVERS_TOOLS}/.evergreen/ocsp
          nohup $PYTHON_VENV_PATH/python3 ocsp_mock.py \
            --ca_file rsa/ca.pem \
            --ocsp_responder_cert rsa/ca.crt \
            --ocsp_responder_key rsa/ca.key \
            -p 8100 -v

  "run-revoked-ocsp-server":
    - command: shell.exec
      params:
        script: |
          cd ${DRIVERS_TOOLS}/.evergreen/ocsp

          export PYTHON_BINARY=$([ "Windows_NT" = "$OS" ] && echo "/cygdrive/c/python/python38/python.exe" || echo "/opt/mongodbtoolchain/v3/bin/python3")
          export PYTHON_VENV_PATH=$([ "Windows_NT" = "$OS" ] && echo "./venv/Scripts" || echo "./venv/bin")

          $PYTHON_BINARY -m venv ./venv
          $PYTHON_VENV_PATH/pip3 install -r ${DRIVERS_TOOLS}/.evergreen/ocsp/mock-ocsp-responder-requirements.txt

    - command: shell.exec
      params:
        background: true
        script: |
          cd ${DRIVERS_TOOLS}/.evergreen/ocsp
          nohup $PYTHON_VENV_PATH/python3 ocsp_mock.py \
            --ca_file rsa/ca.pem \
            --ocsp_responder_cert rsa/ca.crt \
            --ocsp_responder_key rsa/ca.key \
            -p 8100 \
            -v \
            --fault revoked

  "run custom csfle tests":
    - command: shell.exec
      type: test
      params:
        silent: true
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          cat <<EOT > prepare_client_encryption.sh
          export CLIENT_ENCRYPTION='${CLIENT_ENCRYPTION}'
          export CSFLE_KMS_PROVIDERS='${CSFLE_KMS_PROVIDERS}'
          export AWS_ACCESS_KEY_ID='${AWS_ACCESS_KEY_ID}'
          export AWS_SECRET_ACCESS_KEY='${AWS_SECRET_ACCESS_KEY}'
          export CSFLE_GIT_REF='${CSFLE_GIT_REF}'
          export CDRIVER_GIT_REF='${CDRIVER_GIT_REF}'
          EOT
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        timeout_secs: 60
        shell: bash
        script: |
          ${PREPARE_SHELL}

          # Disable xtrace (just in case it was accidentally set).
          set +x
          source ./prepare_client_encryption.sh
          rm -f ./prepare_client_encryption.sh

          export VERSION=${VERSION}
          export DRIVERS_TOOLS=${DRIVERS_TOOLS}

          source ${PROJECT_DIRECTORY}/.evergreen/prepare-crypt-shared-lib.sh
          export MONGODB_URI="${MONGODB_URI}"

          echo "CRYPT_SHARED_LIB_PATH: $CRYPT_SHARED_LIB_PATH"

          bash ${PROJECT_DIRECTORY}/.evergreen/run-custom-csfle-tests.sh

  "run custom snappy tests":
    - command: subprocess.exec
      params:
        working_dir: "src"
        timeout_secs: 60
        env:
          MONGODB_URI: ${MONGODB_URI}
          PROJECT_DIRECTORY: ${PROJECT_DIRECTORY}
        binary: bash
        args:
          - "${PROJECT_DIRECTORY}/.evergreen/run-snappy-version-test.sh"

  "run lambda handler example tests":
    - command: subprocess.exec
      params:
        working_dir: "src"
        timeout_secs: 60
        env:
          MONGODB_URI: ${MONGODB_URI}
          PROJECT_DIRECTORY: ${PROJECT_DIRECTORY}
        binary: bash
        args:
          - "${PROJECT_DIRECTORY}/.evergreen/run-lambda-tests.sh"

  "run lambda handler example tests with aws auth":
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        silent: true
        script: |
          cd ${DRIVERS_TOOLS}/.evergreen/auth_aws
          ${MONGODB_BINARIES}/mongo --verbose aws_e2e_regular_aws.js
          cd -
          cat <<EOF > "${PROJECT_DIRECTORY}/prepare_mongodb_aws.sh"
            export AWS_ACCESS_KEY_ID=${iam_auth_ecs_account}
            export AWS_SECRET_ACCESS_KEY=${iam_auth_ecs_secret_access_key}
          EOF
    - command: shell.exec
      type: test
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          ${PROJECT_DIRECTORY}/.evergreen/run-lambda-aws-tests.sh

  "run bson-ext test":
    - command: subprocess.exec
      type: test
      params:
        working_dir: "src"
        timeout_secs: 60
        env:
          PROJECT_DIRECTORY: ${PROJECT_DIRECTORY}
          MONGODB_URI: ${MONGODB_URI}
          TEST_NPM_SCRIPT: ${TEST_NPM_SCRIPT}
        binary: bash
        args:
          - '${PROJECT_DIRECTORY}/.evergreen/run-bson-ext-test.sh'


  "upload test results":
    # Upload the xunit-format test results.
    - command: attach.xunit_results
      params:
        file: "src/xunit.xml"

  "upload coverage report":
    - command: shell.exec
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          npx nyc report --reporter=json
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file:  src/coverage/coverage-final.json
        optional: true
        # Upload the coverage report for all tasks in a single build to the same directory.
        # TODO NODE-4707 - change upload directory to ${UPLOAD_BUCKET}
        # This change will require changing the `download and merge coverage` func as well
        remote_file: mongo-node-driver/${revision}/${version_id}/coverage.${build_variant}.${task_name}.json
        bucket: mciuploads
        permissions: public-read
        content_type: application/json
        display_name: "Raw Coverage Report"

  "download and merge coverage":
    - command: shell.exec
      params:
        working_dir: "src"
        script: |
          ${PREPARE_SHELL}
          export AWS_ACCESS_KEY_ID=${aws_key}
          export AWS_SECRET_ACCESS_KEY=${aws_secret}

          # Download all the task coverage files.
          # NOTE: All coverage files are too large for V8 to handle the resulting call to
          #       JSON.stringify from within nyc, so with stick to Fermiun to include the
          #       compression tests.
          aws s3 cp --recursive s3://mciuploads/mongo-node-driver/${revision}/${version_id}/ \
            coverage/ \
            --exclude "*rhel80-large*" \
            --include "*fermiun"

          # npx does not recognize the dependency so install it directly.
          npm install @istanbuljs/nyc-config-typescript
          cd coverage
          sed -i'' -e 's/\/data\/mci\/.\{32\}\/src\///g' *
          ls -la
          cd ..
          npx nyc merge coverage/ merged-coverage/coverage.json
          npx nyc report -t merged-coverage/ --reporter=html --report-dir coverage-report

          aws s3 cp coverage-report/ \
            s3://mciuploads/mongo-node-driver/${revision}/${version_id}/coverage/ \
            --recursive \
            --acl public-read \
            --region us-east-1
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file:  src/coverage-report/index.html
        remote_file: mongo-node-driver/${revision}/${version_id}/coverage/index.html
        bucket: mciuploads
        permissions: public-read
        content_type: text/html
        display_name: "Coverage Report HTML"

  "run spec driver benchmarks":
    - command: subprocess.exec
      type: test
      params:
        working_dir: "src"
        env:
          PROJECT_DIRECTORY: ${PROJECT_DIRECTORY}
          MONGODB_URI: ${MONGODB_URI}
        binary: bash
        args:
          - ${PROJECT_DIRECTORY}/.evergreen/run-benchmarks.sh

tasks:
  - name: "test-serverless"
    tags: ["serverless"]
    commands:
      - func: install dependencies
      - func: bootstrap kms servers
      - func: "run serverless tests"

  - name: run-spec-benchmark-tests
    tags:
      - run-spec-benchmark-tests
      - performance
    exec_timeout_secs: 3600
    commands:
      - func: install dependencies
        vars:
          NODE_LTS_NAME: hydrogen
      - func: bootstrap mongo-orchestration
        vars:
          VERSION: rapid
          TOPOLOGY: server
          AUTH: noauth
      - func: run spec driver benchmarks
      - command: perf.send
        params:
          file: src/results.json

task_groups:
  - name: serverless_task_group
    setup_group_can_fail_task: true
    setup_group_timeout_secs: 1800 # 30 minutes
    setup_group:
      - func: "fetch source"
      - command: shell.exec
        params:
          shell: "bash"
          script: |
            ${PREPARE_SHELL}
            set +o xtrace
            LOADBALANCED=ON \
            SERVERLESS_DRIVERS_GROUP=${SERVERLESS_DRIVERS_GROUP} \
            SERVERLESS_API_PUBLIC_KEY=${SERVERLESS_API_PUBLIC_KEY} \
            SERVERLESS_API_PRIVATE_KEY=${SERVERLESS_API_PRIVATE_KEY} \
              bash ${DRIVERS_TOOLS}/.evergreen/serverless/create-instance.sh
      - command: expansions.update
        params:
          file: serverless-expansion.yml
    teardown_group:
      - func: "upload test results"
      - command: shell.exec
        params:
          script: |
            ${PREPARE_SHELL}
            set +o xtrace
            SERVERLESS_DRIVERS_GROUP=${SERVERLESS_DRIVERS_GROUP} \
            SERVERLESS_API_PUBLIC_KEY=${SERVERLESS_API_PUBLIC_KEY} \
            SERVERLESS_API_PRIVATE_KEY=${SERVERLESS_API_PRIVATE_KEY} \
            SERVERLESS_INSTANCE_NAME=${SERVERLESS_INSTANCE_NAME} \
              bash ${DRIVERS_TOOLS}/.evergreen/serverless/delete-instance.sh
    tasks:
      - ".serverless"

pre:
  - func: "fetch source"
  - func: "windows fix"
  - func: "fix absolute paths"
  - func: "make files executable"

post:
  - func: "upload test results"
  - func: "upload coverage report"
  - func: "cleanup"

ignore:
  - '*.md'
buildvariants:
  - name: performance-tests
    display_name: Performance Test
    run_on: rhel80-large
    tasks:
      - run-spec-benchmark-tests