#####################################################
#               A note on expansions                #
#####################################################

# Expansions usually appear in the form ${key|default}
# If 'key' is found in the executor's map of currently known
# expansions, the corresponding value is used. If the key can
# not be found, the default is used.
#
# Arbitrary expansions can be specified in the YAML configuration
# files in the following places:
# - The 'expansions' field for buildvariants (branch file)
# - The 'expansions' field for distros (distros file)
#
# A number of 'built-in' expansions are also available for use; these include:
# - environment variables available on the host machine
# - 'workdir' (references the executor's work directory).
# - 'task_id' (references the task id of the task the executor is working on).
# - 'build_variant' (references the executing task's buildvariant).
# - 'config_root' (references the root directory for the executor's configuration artifacts).

stepback: true
command_type: system

# Files that match an ignore-list pattern will not trigger a build, if they're the only modified
# files in the patch.
ignore:
  - ".*"
  - "!.clang-format"
  - "!.eslintrc.yml"
  - "*.md"
  - "*.rst"
  - "*.txt"
  - "/distsrc/**"
  - "/docs/**"
  - "/etc/*.yml"
  - "!/etc/evergreen.yml"
  - "README"

## Some variables for convenience:
variables:

# Used when the tests it runs depend only on mongod, mongos, the mongo shell and the tools.
- &task_template
  name: template
  depends_on:
  - name: compile
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --help
      run_multiple_jobs: false
      max_jobs: 0  # If set in combination with run_multiple_jobs, will cap the number of jobs used.

# Used for tests that invoke resmoke.py and require no additional setup.
- &task_depending_on_all_template
  <<: *task_template
  depends_on:
  - name: compile_all

# Used to list modules to retrieve from GitHub and apply patches if necessary.
- &git_get_project
  command: git.get_project
  params: &git_get_project_params
    directory: src
    revisions: # for each module include revision as <module_name> : ${<module_name>_rev}
      enterprise: ${enterprise_rev}
      rocksdb: ${rocksdb_rev}
      wtdevelop: ${wtdevelop_rev}

- &generate_compile_expansions
  command: shell.exec
  params:
    working_dir: src
    script: |
      set -o errexit
      set -o verbose

      # We get the raw version string (r1.2.3-45-gabcdef) from git
      MONGO_VERSION=$(git describe)
      # If this is a patch build, we add the patch version id to the version string so we know
      # this build was a patch, and which evergreen task it came from
      if [ "${is_patch}" = "true" ] && [ "${bypass_compile|false}" = "false" ]; then
        MONGO_VERSION="$MONGO_VERSION-patch-${version_id}"
      fi

      ${activate_virtualenv}
      # shared scons cache testing
      # if 'shared_scons_cache' enabled and project level 'disable_shared_scons_cache' is not true
      # 'shared_scons_cache is set on a per variant basis
      # 'disable_shared_scons_cache' is set on a project level and applies to all variants
      if [ "${shared_scons_cache}" = "true" ] && [ "${disable_shared_scons_cache}" != "true" ]; then
        echo "Shared cache - mounting file system"
        sudo mount /efs -v || mount /efs
        MONGO_VERSION=$MONGO_VERSION SCONS_CACHE_MODE=${scons_cache_mode|nolinked} USE_SCONS_CACHE=shared IS_PATCH=${is_patch} ${python|/opt/mongodbtoolchain/v2/bin/python2} buildscripts/generate_compile_expansions_shared_cache.py --out compile_expansions.yml
      else
      # Proceed with regular expansions generated
      # This script converts the generated version string into a sanitized version string for
      # use by scons and uploading artifacts as well as information about for the scons cache.
      MONGO_VERSION=$MONGO_VERSION SCONS_CACHE_MODE=${scons_cache_mode|nolinked} USE_SCONS_CACHE=${use_scons_cache|false} ${python|/opt/mongodbtoolchain/v2/bin/python2} buildscripts/generate_compile_expansions.py --out compile_expansions.yml
      fi

- &apply_compile_expansions
  command: expansions.update
  params:
    file: src/compile_expansions.yml

- &jepsen_config_vars
  jepsen_key_time_limit: --key-time-limit 15
  jepsen_protocol_version: --protocol-version 1
  jepsen_read_concern: ""
  jepsen_read_with_find_and_modify: ""
  jepsen_storage_engine: ""
  jepsen_test_name: ""
  # Empirically, we've had greater success in reproducing the issues found in MongoDB versions
  # 3.4.0-rc3 and 3.4.0-rc4 when running Jepsen with at least --time-limit=600.
  jepsen_time_limit: --time-limit 1200
  jepsen_write_concern: ""

# Template for running Jepsen tests
- &run_jepsen_template
  name: run_jepsen_template
  depends_on:
  - name: compile
  commands:
  - func: "do setup"
  - func: "do jepsen setup"
  - func: "run jepsen test"
    vars:
      <<: *jepsen_config_vars

- &jstestfuzz_config_vars
  resmoke_args: --help # resmoke_args needs to be overridden to specify one of the jstestfuzz suites
  should_shuffle: false
  continue_on_failure: false

- &run_jstestfuzz_tests
  func: "run tests"
  # Terminate the function when there has been no output to stdout for 30 minutes. E.g. when something is stuck in an infinite loop.
  # resmoke.py writes the test output to logkeeper and only writes to stdout when starting the next test.
  # resmoke.py not producing output on stdout means that the test is still running and presumably not going to finish.
  # Note that timeout_secs is different from exec_timeout_secs, which applies to a task and times out regardless of whether output has been written to stdout.
  timeout_secs: 1800
  vars:
    <<: *jstestfuzz_config_vars

# Used for tests that invoke 'resmoke.py --suites=jstestfuzz*'.
- &jstestfuzz_template
  name: jstestfuzz_template
  exec_timeout_secs: 14400 # Time out the task if it runs for more than 4 hours.
  depends_on:
  - name: compile
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
  - *run_jstestfuzz_tests

# Templates used by powercycle
- &powercycle_remote_credentials
  private_key_file: $(${posix_workdir})/powercycle.pem
  private_key_remote: ${powercycle_private_key}
  aws_key_remote: ${powercycle_aws_key}
  aws_secret_remote: ${powercycle_aws_secret}

# TODO: Remove psutil from virtualenv_requirements when BUILD-3083 is done
- &powercycle_ec2_instance
  aws_ec2_yml: aws_ec2.yml
  expire_hours: "3"
  ec2_monitor_files: proc.json system.json
  monitor_proc_file: proc.json
  monitor_system_file: system.json
  remote_dir: powercycle
  secret_port: "20001"
  security_group_ids: ${powercycle_aws_security_group_id}
  security_groups: mci powercycle_testing
  subnet_id: ${powercycle_aws_subnet_id}
  ssh_identity: -i ${private_key_file}
  ssh_key_id: ${powercycle_ssh_key_id}
  standard_port: "20000"
  virtualenv_dir: venv_powercycle
  virtualenv_requirements: psutil
  windows_crash_cmd: \"notmyfault/notmyfaultc64.exe -accepteula crash 1\"
  windows_crash_dl: https://download.sysinternals.com/files/NotMyFault.zip
  windows_crash_dir: notmyfault
  windows_crash_zip: notmyfault.zip

- &powercycle_expansions
  params:
     updates:
     - key: backup_path_after
       value: /data/afterrecovery
     - key: backup_path_before
       value: /data/beforerecovery
     - key: db_path
       value: /data/db
     - key: log_path
       value: ${remote_dir}/mongod.log

- &powercycle_test
  ec2_artifacts: ${log_path} ${backup_path_after} ${backup_path_before}
  program_options: --logLevel=info --backupPathBefore=${backup_path_before} --backupPathAfter=${backup_path_after}
  connection_options: --sshUserHost=${ip_address} --sshConnection=\"${ssh_identity} ${ssh_connection_options}\"
  test_options: --testLoops=15 --seedDocNum=10000 --rsync --rsyncExcludeFiles=diagnostic.data/metrics.interim* --validate=local --canary=local
  crash_options: --crashMethod=internal --crashOption=${windows_crash_cmd} --crashWaitTime=45 --jitterForCrashWaitTime=5 --instanceId=${instance_id}
  client_options: --numCrudClients=20 --numFsmClients=20
  mongodb_options: --rootDir=${remote_dir}-${task_id} --mongodbBinDir=${remote_dir}
  mongod_options: --mongodUsablePorts ${standard_port} ${secret_port} --dbPath=${db_path} --logPath=${log_path}
  mongod_extra_options: --mongodOptions=\"--setParameter enableTestCommands=1\"

#######################################
#            Functions                #
#######################################

functions:

  "fetch artifacts" : &fetch_artifacts
    command: s3.get
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      remote_file: ${project}/${build_variant}/${revision}/artifacts/${build_id}.tgz
      bucket: mciuploads
      extract_to: src

  "fetch binaries" : &fetch_binaries
    command: s3.get
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      remote_file: ${mongo_binaries}
      bucket: mciuploads
      local_file: src/mongo-binaries.tgz

  "extract binaries" : &extract_binaries
    command: shell.exec
    params:
      working_dir: src
      script: |
        set -o errexit
        ${decompress} mongo-binaries.tgz
        cp mongodb*/bin/* .

  "check binary version" : &check_binary_version
    command: shell.exec
    params:
      working_dir: src
      script: |
        set -o errexit
        mongo_binary=$(find mongodb*/bin -name mongo${exe})
        # There should only be one mongo shell
        if [ $(echo $mongo_binary | wc -w) -ne 1 ]; then
          echo "There is more than 1 extracted mongo binary: $mongo_binary"
          exit 1
        fi
        # For compile bypass we need to skip the binary version check since we can tag a commit
        # after the base commit binaries were created. This would lead to a mismatch of the binaries
        # and the version from git describe in the compile_expansions.yml.
        if [ "${is_patch}" = "true" ] && [ "${bypass_compile|false}" = "true" ]; then
          echo "Skipping binary version check since we are bypassing compile in this patch build."
          exit 0
        fi
        ${activate_virtualenv}
        bin_ver=$($python -c "import yaml; print(yaml.safe_load(open('compile_expansions.yml'))['version']);" | tr -d '[ \r\n]')
        # Due to SERVER-23810, we cannot use $mongo_binary --quiet --nodb --eval "version();"
        mongo_ver=$($mongo_binary --version | perl -pe '/version v(.*)$/; $_ = $1;' | tr -d '[ \r\n]')
        # The versions must match
        if [ "$bin_ver" != "$mongo_ver" ]; then
          echo "The mongo version is $mongo_ver, expected version is $bin_ver"
          exit 1
        fi

  "get buildnumber" : &get_buildnumber
    command: keyval.inc
    params:
      key: "${build_variant}_master"
      destination: "builder_num"

  "run diskstats": &run_diskstats
    command: shell.exec
    params:
      background: true
      system_log: true
      script: |
        set -o errexit
        set -o verbose

        # On Windows we can use typeperf.exe to dump performance counters.
        if [ "Windows_NT" = "$OS" ]; then
            typeperf -qx PhysicalDisk | grep Disk | grep -v _Total > disk_counters.txt
            typeperf -cf disk_counters.txt -si 5 -o mongo-diskstats
        # Linux: iostat -t option for timestamp.
        elif iostat -tdmx > /dev/null 2>&1; then
            iostat -tdmx 5 > mongo-diskstats
        # OSX: Simulate the iostat timestamp.
        elif iostat -d > /dev/null 2>&1; then
            iostat -d -w 5 | while IFS= read -r line; do printf '%s %s\n' "$(date +'%m/%d/%Y %H:%M:%S')" "$line" >> mongo-diskstats; done
        # Check if vmstat -t is available.
        elif vmstat -td  > /dev/null 2>&1; then
            vmstat -td 5 > mongo-diskstats
        # Check if vmstat -T d is available.
        elif vmstat -T d > /dev/null 2>&1; then
            vmstat -T d 5 > mongo-diskstats
        else
            printf "Cannot collect mongo-diskstats on this platform\n"
        fi

  "collect system resource info": &collect_system_resource_info
    command: shell.exec
    params:
      working_dir: src
      background: true
      system_log: true
      script: |
        ${activate_virtualenv}
        $python buildscripts/collect_resource_info.py -o system_resource_info.json -i 5

  # Run a monitor process as a background, system task to periodically
  # display how many threads interesting processes are using.
  "monitor process threads": &monitor_process_threads
    command: shell.exec
    params:
      background: true
      system_log: true
      script: |
        proc_list="(bsondump|java|lein|mongo|python|_test$|_test\.exe$)"
        if [ "Windows_NT" = "$OS" ]; then
          get_pids() {
            proc_pids=$(tasklist /fo:csv |
                        awk -F'","' '{x=$1; gsub("\"","",x); print $2, x}' |
                        grep -iE $1 |
                        cut -f1 -d ' ');
          }
          get_process_info() {
            proc_name="";
            proc_info=$(wmic process where "ProcessId=\"$1\"" get "Name,ProcessId,ThreadCount" /format:csv 2> /dev/null | grep $1);
            if [ ! -z $proc_info ]; then
              proc_name=$(echo $proc_info | cut -f2 -d ',');
              proc_threads=$(echo $proc_info | cut -f4 -d ',');
            fi;
          }
        else
          get_pids() { proc_pids=$(pgrep $1); }
          get_process_info() {
            proc_name=$(ps -p $1 -o comm=);
            # /proc is available on Linux platforms
            if [ -f /proc/$1/status ]; then
              ${set_sudo}
              proc_threads=$($sudo grep Threads /proc/$1/status | sed "s/\s//g" | cut -f2 -d ":");
            else
              proc_threads=$(ps -AM $1 | grep -vc PID);
            fi;
          }
        fi
        while [ 1 ]
        do
          get_pids $proc_list
          if [ ! -z "$proc_pids" ]; then
            printf "Running process/thread counter\n"
            printf "PROCESS\tPID\tTHREADS\n"
          fi
          for pid in $proc_pids
          do
            get_process_info $pid
            if [ ! -z "$proc_name" ]; then
              printf "$proc_name\t$pid\t$proc_threads\n"
            fi
          done
          sleep 60
        done

  "set up credentials" : &set_up_credentials
    command: shell.exec
    params:
      working_dir: src
      silent: true
      script: |
        cat > mci.buildlogger <<END_OF_CREDS
        slavename='${slave}'
        passwd='${passwd}'
        builder='MCI_${build_variant}'
        build_num=${builder_num}
        build_phase='${task_name}_${execution}'
        END_OF_CREDS

  "set up remote credentials": &set_up_remote_credentials
    command: shell.exec
    params:
      silent: true
      script: |
        set -o errexit

        # Since the macros 'private_key_remote' and 'private_key_file' are not always defined
        # we default to /dev/null to avoid syntax errors of an empty expansion.
        if [ ! -z "${private_key_remote}" ] && [ ! -z "${private_key_file}" ] ; then
          mkdir -p ~/.ssh
          echo -n "${private_key_remote}" > ${private_key_file|/dev/null}
          chmod 0600 ${private_key_file|/dev/null}
        fi

        if [ ! -d ~.aws ]; then
          mkdir -p ~/.aws
        fi

        # If ${aws_profile_remote} is not specified then the config & credentials are
        # stored in the 'default' profile.
        aws_profile="${aws_profile_remote|default}"

        # The profile in the config file is specified as [profile <profile>], except
        # for [default], see http://boto3.readthedocs.io/en/latest/guide/configuration.html
        if [ $aws_profile = "default" ] ; then
          aws_profile_config="[default]"
        else
          aws_profile_config="[profile $aws_profile]"
        fi
        cat <<EOF >> ~/.aws/config
        $aws_profile_config
        region = us-east-1
        EOF

        # The profile in the credentials file is specified as [<profile>].
        cat <<EOF >> ~/.aws/credentials
        [$aws_profile]
        aws_access_key_id = ${aws_key_remote}
        aws_secret_access_key = ${aws_secret_remote}
        EOF

        cat <<EOF > ~/.boto
        [Boto]
        https_validate_certificates = False
        EOF

  "upload debugsymbols" : &upload_debugsymbols
    command: s3.put
    params:
      optional: true
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: src/mongo-debugsymbols.tgz
      remote_file: ${mongo_debugsymbols}
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}

  "fetch debugsymbols archive" : &fetch_debugsymbols_archive
    command: s3.get
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      remote_file: ${mongo_debugsymbols}
      bucket: mciuploads
      local_file: src/mongo-debugsymbols.tgz

  "extract debugsymbols" : &extract_debugsymbols
    command: shell.exec
    params:
      working_dir: src
      script: |
        set -o errexit
        set -o verbose
        # Debug symbols are not created for every variant
        if [ ! -f mongo-debugsymbols.tgz ]; then
          exit
        fi
        ${decompress} mongo-debugsymbols.tgz
        files="mongo mongod mongos"
        file_exts="debug dSYM pdb"
        for file_ext in $file_exts
        do
            for file in $files
            do
                mv mongodb*/$file.$file_ext . 2>/dev/null || true
            done
            rm -r mongodb*/*.$file_ext 2>/dev/null || true
        done
        rm mongo-debugsymbols.tgz 2>/dev/null || true

  "build rocksdb" :
    command: shell.exec
    params:
      script: |
        set -o errexit
        set -o verbose
        if [ "${build_rocksdb|}" = "true" ]; then
        rm -rf rocksdb
        git clone https://github.com/facebook/rocksdb.git
        cd rocksdb
        make USE_RTTI=1 CC=/opt/mongodbtoolchain/v2/bin/gcc CXX=/opt/mongodbtoolchain/v2/bin/g++ static_lib
        fi

  "use WiredTiger develop" :
    command: shell.exec
    params:
      working_dir: src
      script: |
        set -o errexit
        set -o verbose
        if [ "${use_wt_develop|}" = "true" ]; then
        cd src/third_party
        for wtdir in api dist examples ext lang src test tools ; do
          rm -rf wiredtiger/$wtdir
          mv wtdevelop/$wtdir wiredtiger/
        done
        fi

  "setup android toolchain" :
    command: shell.exec
    params:
      script: |
        set -o errexit
        set -o verbose
        if [ "${setup_android_toolchain|}" = "true" ]; then
            ${activate_virtualenv}
            PYTHON=$python ${compile_env|} src/buildscripts/setup-android-toolchain.sh
        fi

  "build cdriver" :
    command: shell.exec
    params:
      script: |
        set -o errexit
        set -o verbose
        if [ "${build_cdriver|}" = "true" ]; then
        CDRIVER_VERSION=1.9.2
        rm -rf mongo-c-driver-$CDRIVER_VERSION
        rm -rf mongo-c-driver
        curl -LO https://github.com/mongodb/mongo-c-driver/releases/download/$CDRIVER_VERSION/mongo-c-driver-$CDRIVER_VERSION.tar.gz
        tar xzf mongo-c-driver-$CDRIVER_VERSION.tar.gz
        mv mongo-c-driver-$CDRIVER_VERSION mongo-c-driver
        cd mongo-c-driver
        # remove this patch once SERVER-33101 is released
        patch -p1 < ../src/buildscripts/mongoc-stat.c.diff
        export ${compile_env|}
        ./configure --prefix=$(pwd)/install --with-libbson=bundled --disable-tests --disable-automatic-init-and-cleanup --disable-ssl --disable-sasl --disable-examples --disable-man-pages --disable-html-docs --disable-shm-counters --disable-shared --enable-static ${cdriver_configure_flags|}
        make
        make install
        fi

  "build new tools" :
    command: shell.exec
    params:
      working_dir: src/src/mongo/gotools
      script: |
        set -o verbose
        set -o errexit

        # make sure newlines in the scripts are handled correctly by windows
        if [ "Windows_NT" = "$OS" ]; then
            set -o igncr
        fi;

        sed -i.bak "s/built-without-version-string/$(git describe)/" common/options/options.go
        sed -i.bak "s/built-without-git-spec/$(git rev-parse HEAD)/" common/options/options.go

        . ./${set_tools_gopath|set_gopath.sh}

        build_tools="bsondump mongostat mongofiles mongoexport mongoimport mongorestore mongodump mongotop"

        if [ "${build_mongoreplay}" = "true" ]; then
            build_tools="$build_tools mongoreplay"
        fi

        for i in $build_tools; do
             ${gorootvars} go build ${tooltags|} -o "../../mongo-tools/$i${exe|}" $i/main/$i.go
             "../../mongo-tools/$i${exe|}" --version
        done

  "get modified patch files" :
    command: shell.exec
    params:
      working_dir: src
      shell: bash
      script: |
        set -o verbose
        set -o errexit

        # For patch builds gather the modified patch files.
        if [ "${is_patch}" = "true" ]; then
          # Get list of patched files
          git diff HEAD --name-only >> patch_files.txt
          if [ -d src/mongo/db/modules/enterprise ]; then
            pushd src/mongo/db/modules/enterprise
            # Update the patch_files.txt in the mongo repo.
            git diff HEAD --name-only >> ~1/patch_files.txt
            popd
          fi
        fi

  "update bypass expansions" : &update_bypass_expansions
    command: expansions.update
    params:
      ignore_missing_file: true
      file: src/bypass_compile_expansions.yml

  "bypass compile and fetch binaries" :
    command: shell.exec
    params:
      continue_on_err: true
      working_dir: src
      script: |
        set -o verbose
        set -o errexit

        # For patch builds determine if we can bypass compile.
        if [ "${is_patch}" = "true" ]; then
          ${activate_virtualenv}
          $python buildscripts/bypass_compile_and_fetch_binaries.py            \
            --project ${project}                                               \
            --buildVariant ${build_variant}                                    \
            --revision ${revision}                                             \
            --patchFile patch_files.txt                                        \
            --outFile bypass_compile_expansions.yml                            \
            --jsonArtifact artifacts.json
        fi

  "do setup" :
  - *fetch_artifacts
  - *update_bypass_expansions
  - *fetch_binaries
  - *extract_binaries
  - *check_binary_version
  - *get_buildnumber
  - *set_up_credentials
  - *run_diskstats
  - *monitor_process_threads
  - *collect_system_resource_info

  "set up virtualenv" :
    command: shell.exec
    type: test
    params:
        script: |
          # exit immediately if virtualenv is not found
          set -o errexit
          set -o verbose

          python_loc=$(which ${python|/opt/mongodbtoolchain/v2/bin/python2})
          if [ "Windows_NT" = "$OS" ]; then
            python_loc=$(cygpath -w $python_loc)
          fi
          # Set up virtualenv in ${workdir}
          virtualenv --python "$python_loc" --system-site-packages "${workdir}/venv"

  "run tests" :
    - command: expansions.update
      params:
        updates:
        - key: aws_key_remote
          value: ${mongodatafiles_aws_key}
        - key: aws_profile_remote
          value: mongodata_aws
        - key: aws_secret_remote
          value: ${mongodatafiles_aws_secret}
    - *set_up_remote_credentials
    - command: shell.exec
      type: test
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          if [ ${disable_unit_tests|false} = "false" ]; then

          # activate the virtualenv if it has been set up
          ${activate_virtualenv}
          pip install boto3==1.5.27

          # Set the TMPDIR environment variable to be a directory in the task's working
          # directory so that temporary files created by processes spawned by resmoke.py get
          # cleaned up after the task completes. This also ensures the spawned processes
          # aren't impacted by limited space in the mount point for the /tmp directory.
          export TMPDIR="${workdir}/tmp"
          mkdir -p $TMPDIR

          if [ -f /proc/self/coredump_filter ]; then
            # Set the shell process (and its children processes) to dump ELF headers (bit 4),
            # anonymous shared mappings (bit 1), and anonymous private mappings (bit 0).
            echo 0x13 > /proc/self/coredump_filter

            if [ -f /sbin/sysctl ]; then
              # Check that the core pattern is set explicitly on our distro image instead
              # of being the OS's default value. This ensures that coredump names are consistent
              # across distros and can be picked up by Evergreen.
              core_pattern=$(/sbin/sysctl -n "kernel.core_pattern")
              if [ "$core_pattern" = "dump_%e.%p.core" ]; then
                echo "Enabling coredumps"
                ulimit -c unlimited
              fi
            fi
          fi

          extra_args=""
          if [ ${run_multiple_jobs|false} = true ]; then
            processor_architecture=$(uname -m)
            num_jobs_available=${num_jobs_available|1}
            # Reduce the number of available jobs by half when running any sharding*, replica_sets*
            # and select jsCore passthrough tasks on Windows and ARM to avoid overwhelming test hosts.
            if [ "Windows_NT" = "$OS" ] || [ "aarch64" = $processor_architecture ]; then
              case "${task_name}" in
              replica_sets_initsync_jscore_passthrough          \
              |replica_sets_initsync_static_jscore_passthrough  \
              |replica_sets_resync_static_jscore_passthrough    \
              |replica_sets*                           \
              |sharding*                              \
              )
                num_jobs_available=$((${num_jobs_available|2} / 2))
                echo "Reducing jobs from ${num_jobs_available|1} to $num_jobs_available"
                ;;
              esac
            fi

            if [ ${max_jobs|0} -gt 0 ] && [ ${max_jobs|0} -lt $num_jobs_available ]; then
              extra_args="$extra_args --jobs=${max_jobs}"
            else
              extra_args="$extra_args --jobs=$num_jobs_available"
            fi
          fi

          if [ ${should_shuffle|true} = true ]; then
            extra_args="$extra_args --shuffle"
          fi

          if [ ${continue_on_failure|true} = true ]; then
            extra_args="$extra_args --continueOnFailure"
          fi

          # Default storageEngineCacheSizeGB to 1. Override on individual test config if needed.
          # resmoke will assign to the appropriate parameter on storage engines that support it.
          set +o errexit
          echo "${resmoke_args}" | grep -q storageEngineCacheSizeGB
          if [ $? -eq 1 ]; then
            extra_args="$extra_args --storageEngineCacheSizeGB=1"
          fi
          set -o errexit

          path_value="$PATH"
          if [ ${variant_path_suffix} ]; then
            path_value="$path_value:${variant_path_suffix}"
          fi
          if [ ${task_path_suffix} ]; then
            path_value="$path_value:${task_path_suffix}"
          fi

          if [ "${is_patch}" = "true" ]; then
            extra_args="$extra_args --tagFile=etc/test_lifecycle.yml --patchBuild"
          else
            extra_args="$extra_args --tagFile=etc/test_retrial.yml"
          fi

          # The "resmoke_wrapper" expansion is used by the 'burn_in_tests' task to wrap the resmoke.py
          # invocation. It doesn't set any environment variables and should therefore come last in
          # this list of expansions.
          set +o errexit
          PATH="$path_value"                              \
              AWS_PROFILE=${aws_profile_remote}           \
              ${gcov_environment}                         \
              ${rlp_environment}                          \
              ${lang_environment}                         \
              ${san_options}                              \
              ${san_symbolizer}                           \
              ${snmp_config_path}                         \
              ${resmoke_wrapper}                          \
              $python buildscripts/evergreen_run_tests.py \
                  ${resmoke_args}                         \
                  $extra_args                             \
                  ${test_flags}                           \
                  --log=buildlogger                       \
                  --staggerJobs=on                        \
                  --taskId=${task_id}                     \
                  --taskName=${task_name}                 \
                  --executionNumber=${execution}          \
                  --projectName=${project}                \
                  --variantName=${build_variant}          \
                  --distroId=${distro_id}                 \
                  --gitRevision=${revision}               \
                  --archiveFile=archive.json              \
                  --reportFile=report.json
          resmoke_exit_code=$?
          set -o errexit

          # 74 is exit code for IOError on POSIX systems.
          if [ $resmoke_exit_code = 74 ]; then
            echo $resmoke_exit_code > run_tests_system_failure
            exit 0
          fi
          exit $resmoke_exit_code
          fi # end if ${disable_unit_tests}

    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o verbose
          if [ -f run_tests_system_failure ]; then
            exit $(cat run_tests_system_failure)
          fi

  "do jepsen setup" :
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit

          # Build libfaketime. A version of libfaketime at least as new as v0.9.6-9-g75896bd is
          # required to use the FAKETIME_NO_CACHE and FAKETIME_TIMESTAMP_FILE environment variables.
          # Additionally, a version of libfaketime containing the changes mentioned in SERVER-29336
          # is required to avoid needing to use libfaketimeMT.so.1 and serializing all calls to
          # fake_clock_gettime() with a mutex.
          git clone --branch=for-jepsen --depth=1 git@github.com:10gen/libfaketime.git
          cd libfaketime
          branch=$(git symbolic-ref --short HEAD)
          commit=$(git show -s --pretty=format:"%h - %an, %ar: %s")
          echo "Git branch: $branch, commit: $commit"
          make PREFIX=$(pwd)/build/ LIBDIRNAME='.' install

          # Add libfaketime to mongo-binaries.tgz so it gets uploaded to each of the LXC containers.
          # The build/ prefix of the shared object will get removed when Jepsen extracts the tarball
          # into the /opt/mongodb/ directory.
          gzip --stdout --decompress ../mongo-binaries.tgz > mongo-binaries.tar
          tar --append --file=mongo-binaries.tar build/libfaketime.so.1
          gzip --stdout mongo-binaries.tar > ../mongo-binaries.tgz
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          git clone --branch=jepsen-mongodb-master --depth=1 git@github.com:10gen/jepsen.git jepsen-mongodb
          cd jepsen-mongodb
          branch=$(git symbolic-ref --short HEAD)
          commit=$(git show -s --pretty=format:"%h - %an, %ar: %s")
          echo "Git branch: $branch, commit: $commit"
          lein install
    - command: shell.exec
      params:
        working_dir: src
        script: |
          # On each LXC host do the following:
          #   Check to see if it's running, if not try to restart it.
          #   Copy the mongodb tarball to /root.
          numVms=5
          exit_failure_code=0
          ${set_sudo}
          for i in $(seq 1 $numVms)
          do
            hostn=n$i
            hostn_log=/var/log/lxc/$hostn.log
            $sudo lxc-wait -n $hostn -s 'RUNNING' -t 0
            lxc_code=$?
            lxc_restarts=0
            # If the LXC host is not running, try 5 times to start it.
            while [ $lxc_code -ne 0 ]
            do
              lxc_restarts=$((lxc_restarts+1))
              echo "Restarting host $hostn, attempt $lxc_restarts"
              # When restarting, increase the logging level to INFO for the LXC log.
              $sudo lxc-start -n $hostn --logpriority=INFO --logfile=$hostn_log -d
              $sudo lxc-wait -n $hostn -s 'RUNNING' -t 60
              lxc_code=$?
              if [ $lxc_restarts -eq 5 ]; then
                break
              fi
            done
            scp -o ConnectTimeout=30 -o ConnectionAttempts=10 mongo-binaries.tgz root@$hostn:
            exit_code=$?
            # If the copy fails, then tail the LXC host log.
            if [ $exit_code -ne 0 ]; then
              echo "Copy to host $hostn failed!"
              $sudo tail -n 100 $hostn_log
              exit_failure_code=$exit_code
            else
              # Cleanup any existing logs from previous runs.
              ssh root@$hostn "rm -f /root/mongod.log /root/stdout.log /opt/mongod/mongod.log /opt/mongod/stdout.log"
            fi
          done
          exit $exit_failure_code

  "run jepsen test" :
    - command: shell.exec
      type: test
      timeout_secs: 2700 # Timeout test if there is no output for more than 45 minutes.
      params:
        working_dir: src/jepsen-mongodb
        script: |
          set -o verbose
          start_time=$(date +%s)
          lein run test --test ${jepsen_test_name}                        \
                        --tarball "file:///root/mongo-binaries.tgz"       \
                        --ssh-private-key ~/.ssh/id_rsa_lxc               \
                        --clock-skew faketime                             \
                        --libfaketime-path /opt/mongodb/libfaketime.so.1  \
                        ${jepsen_key_time_limit}                          \
                        ${jepsen_protocol_version}                        \
                        ${jepsen_read_concern}                            \
                        ${jepsen_read_with_find_and_modify}               \
                        ${jepsen_storage_engine}                          \
                        ${jepsen_time_limit}                              \
                        ${jepsen_write_concern}                           \
                        2>&1                                              \
          | tee jepsen_${task_name}_${execution}.log
          end_time=$(date +%s)
          elapsed_secs=$((end_time-start_time))
          # Since we cannot use PIPESTATUS to get the exit code from the "lein run ..." pipe in dash shell,
          # we will check the output for success, failure or setup error. Note that 'grep' returns with exit code
          # 0 if it finds a match, and exit code 1 if no match is found.
          grep -q "Everything looks good" jepsen_${task_name}_${execution}.log
          grep_exit_code=$?
          if [ $grep_exit_code -eq 0 ]; then
            status='"pass"'
            failures=0
            final_exit_code=0
          else
            grep -q "Analysis invalid" jepsen_${task_name}_${execution}.log
            grep_exit_code=$?
            if [ $grep_exit_code -eq 0 ]; then
              status='"fail"'
              failures=1
              final_exit_code=1
            else
              # If the failure is due to setup, then this is considered a system failure.
              echo $grep_exit_code > jepsen_system_failure_${task_name}_${execution}
              exit 0
            fi
          fi
          # Create report.json
          echo "{\"failures\": $failures, \"results\": [{\"status\": $status, \"exit_code\": $final_exit_code, \"test_file\": \"${task_name}\", \"start\": $start_time, \"end\": $end_time, \"elapsed\": $elapsed_secs}]}" > ../report.json
          exit $final_exit_code
    - command: shell.exec
      params:
        working_dir: src/jepsen-mongodb
        script: |
          set -o verbose
          # Jepsen system failure if file exists.
          if [ -f jepsen_system_failure_${task_name}_${execution} ]; then
            exit $(cat jepsen_system_failure_${task_name}_${execution})
          fi

  "run jstestfuzz":
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          git clone git@github.com:10gen/jstestfuzz.git

          cp mongodb*/bin/mongod .
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          git clone --depth 1 git@github.com:10gen/mongo-enterprise-modules.git jstests/enterprise_tests
          git clone --depth 1 git@github.com:10gen/QA.git jstests/qa_tests
    - command: shell.exec
      type: test
      params:
        working_dir: src/jstestfuzz
        script: |
          set -o errexit
          set -o verbose

          if [ "Windows_NT" = "$OS" ]; then
            # An "npm" directory might not have been created in %APPDATA% by the Windows installer.
            # Work around the issue by specifying a different %APPDATA% path.
            # See: https://github.com/nodejs/node-v0.x-archive/issues/8141
            export APPDATA=${workdir}/npm-app-data
            export PATH="$PATH:/cygdrive/c/Program Files (x86)/nodejs" # Windows location
          else
            export PATH="$PATH:/opt/node/bin"
          fi

          echo "jstestfuzz self-tests are starting"
          set +o errexit
          npm test > npm_test-${task_id}.log 2>&1
          if [ $? -ne 0 ]; then
            which node
            node --version
            which npm
            npm --version
            cat npm_test-${task_id}.log
            exit 1
          fi
          rm -f npm_test-${task_id}.log
          set -o errexit
          echo "jstestfuzz self-tests finished"

          npm run ${npm_command|jstestfuzz} -- --jsTestsDir ../jstests ${jstestfuzz_vars}

    - command: archive.targz_pack
      params:
        target: "jstests.tgz"
        source_dir: "src/jstestfuzz"
        include:
          - "out/*.js"
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: jstests.tgz
        remote_file: ${project}/${build_variant}/${revision}/jstestfuzz/${task_id}-${execution}.tgz
        bucket: mciuploads
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        display_name: Generated Tests - Execution ${execution}

  "run idl tests" :
    - command: shell.exec
      type: test
      params:
        working_dir: src
        script: |
          set -o verbose
          set -o errexit

          ${activate_virtualenv}
          $python buildscripts/idl/run_tests.py

  "run ios sim embedded tests" :
    command: shell.exec
    type: test
    params:
      working_dir: src
      script: |
        set -o verbose
        set -o errexit

        ${activate_virtualenv}
        if [ ${enable_iostvos_sim_tests|false} = "true" ]; then
            ${compile_env|} buildscripts/runiossim.sh ${ios_sim_device} ${ios_sim_runtime} "build/debug/mongo/client/embedded/mongo_embedded_capi_test"
            ${compile_env|} buildscripts/runiossim.sh ${ios_sim_device} ${ios_sim_runtime} "build/debug/mongo/client/embedded/mongo_embedded_transport_test"
        fi

  "run android emulator tests" :
    command: shell.exec
    type: test
    params:
      working_dir: src
      script: |
        set -o verbose
        set -o errexit

        ${activate_virtualenv}
        if [ ${enable_android_emu_tests|false} = "true" ]; then
            # strip because the binaries with debug symbols are too big for the default storage on the emulator
            $(dirname $(pwd))/android_toolchain/bin/aarch64-linux-android-strip "build/debug/mongo/client/embedded/mongo_embedded_capi_test"
            $(dirname $(pwd))/android_toolchain/bin/aarch64-linux-android-strip "build/debug/mongo/client/embedded/mongo_embedded_transport_test"
            ${compile_env|} buildscripts/runandroidsim.sh $(dirname $(pwd))/android_sdk "build/debug/mongo/client/embedded/mongo_embedded_capi_test"
            ${compile_env|} buildscripts/runandroidsim.sh $(dirname $(pwd))/android_sdk "build/debug/mongo/client/embedded/mongo_embedded_transport_test"
        fi

  "run powercycle test" :
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o verbose
          set -o errexit

          if [ ! -z "${virtualenv_requirements}" ]; then
            ${activate_virtualenv}
            pip install ${virtualenv_requirements}
          fi

    - command: shell.exec
      type: test
      params:
        working_dir: src
        shell: bash
        script: |
          set -o verbose
          set -o errexit

          ${set_sudo}
          if [ ! -z $sudo ]; then
            remote_sudo="--remoteSudo"
          fi

          ${activate_virtualenv}
          # The virtualenv bin_dir is different for Linux and Windows
          bin_dir=$(find $VIRTUAL_ENV -name activate | sed -e "s,$VIRTUAL_ENV,,;s,activate,,;s,/,,g")
          cmds=". ${virtualenv_dir|venv}/$bin_dir/activate"
          cmds="$cmds; python -u"
          # The remote python operates in a virtualenv
          remote_python="--remotePython=\"$cmds\""

          # Initialize report.json. The report will be finalized by powertest.py.
          report_json="report.json"
          start_time=$(date +%s)
          status="\"fail\""
          failures=0
          exit_code=1
          end_time=$start_time
          elapsed_secs=0
          echo "{\"failures\": $failures, \"results\": [{\"status\": $status, \"exit_code\": $exit_code, \"test_file\": \"${task_name}\", \"start\": $start_time, \"end\": $end_time, \"elapsed\": $elapsed_secs}]}" > $report_json
          generate_report_json="--reportJsonFile=$report_json"

          # Windows task overrides:
          #   - Execute 10 test loops
          #   - Cap the maximum number of clients to 10 each
          if [ "Windows_NT" = "$OS" ]; then
            test_override=--testLoops=10
            max_clients=10
            for client in --numCrudClients --numFsmClients
            do
              override=$(echo ${client_options} | awk "BEGIN {FS=\" |=\"} {for(j=1;j<=NF;j++) if (\$j~/^$client/) {min=(\$(j+1) < $max_clients) ? \$(j+1) : $max_clients; printf \"%s=%d\", \$j,min}}")
              client_override="$client_override $override"
            done
          fi

          config_file=powertest.yml
          eval $python pytests/powertest.py \
            "--saveConfigOptions=$config_file \
            ${connection_options}  \
            ${program_options}     \
            $generate_report_json  \
            $remote_sudo           \
            $remote_python         \
            ${test_options}        \
            $test_override         \
            ${crash_options}       \
            ${client_options}      \
            $client_override       \
            ${mongodb_options}     \
            ${mongod_options}      \
            ${mongod_extra_options}"
          set +o errexit
          $python -u pytests/powertest.py --configFile=$config_file
          test_status=$?
          aws_ec2=$($python buildscripts/aws_ec2.py --imageId ${instance_id} --mode status)
          echo "Test completed, AMI EC2 instance ${instance_id} status: $aws_ec2"
          exit $test_status

  "do multiversion setup" :
    command: shell.exec
    params:
      working_dir: src
      script: |
        set -o errexit
        set -o verbose

        ${activate_virtualenv}
        # The Windows build variants are running python 2.7.3 and require TLS 1.2 from pyOpenSSL
        pip install 'pyOpenSSL ; sys_platform == "win32" or sys_platform == "cygwin"'

        rm -rf /data/install /data/multiversion
        $python buildscripts/setup_multiversion_mongodb.py   \
          --installDir /data/install                         \
          --linkDir /data/multiversion                       \
          --edition ${multiversion_edition|base}             \
          --platform ${multiversion_platform|linux}          \
          --architecture ${multiversion_architecture|x86_64} \
          --useLatest 3.0 3.2 3.4 3.6

  "do snmp setup" :
    command: shell.exec
    params:
      working_dir: src
      script: |
        set -o errexit
        set -o verbose

        mkdir -p snmpconf
        cp -f src/mongo/db/modules/enterprise/docs/mongod.conf.master snmpconf/mongod.conf

  "do watchdog setup" :
    command: shell.exec
    params:
      working_dir: src
      script: |
        set -o errexit
        set -o verbose

        bash src/mongo/db/modules/enterprise/jstests/watchdog/charybdefs_setup.sh

  "cleanup environment" :
    command: shell.exec
    params:
      script: |
        set -o verbose

        rm -rf src /data/db/* mongo-diskstats* mongo-*.tgz ~/.aws ~/.boto venv

  "kill processes" :
    command: shell.exec
    params:
      silent: true
      script: |
        process_kill_list="(^cl\.exe$|bsondump|java|lein|lldb|mongo|python|_test$|_test\.exe$)"
        # Exclude Evergreen agent processes and other system daemons
        process_exclude_list="(main|tuned|evergreen)"

        if [ "Windows_NT" = "$OS" ]; then
          # Get the list of Windows tasks (tasklist list format):
          # - Transpose the Image Name and PID
          # - The first column has the process ID
          # - The second column (and beyond) has task name
          # - Grep for the task names of interest while ignoring any names that are in the exclude list

          processes=$(tasklist /fo:csv | awk -F'","' '{x=$1; gsub("\"","",x); print $2, x}' | grep -iE "$process_kill_list" | grep -ivE "$process_exclude_list")

          # Kill the Windows process by process ID with force (/f)
          kill_process () { pid=$(echo $1 | cut -f1 -d ' '); echo "Killing process $1"; taskkill /pid "$pid" /f; }
        else
          # Get the list of Unix tasks (pgrep full & long):
          # - Grep for the task names of interest while ignoring any names that are in the exclude list
          # - The first column has the process ID
          # - The second column (and beyond) has task name

          # There are 2 "styles" of pgrep, figure out which one works.
          # Due to https://bugs.launchpad.net/ubuntu/+source/procps/+bug/1501916
          # we cannot rely on the return status ($?) to detect if the option is supported.
          pgrep -f --list-full ".*" 2>&1 | grep -qE "(illegal|invalid|unrecognized) option"
          if [ $? -ne 0 ]; then
            pgrep_list=$(pgrep -f --list-full "$process_kill_list")
          else
            pgrep_list=$(pgrep -f -l "$process_kill_list")
          fi

          # Since a process name might have a CR or LF in it, we need to delete any lines from
          # pgrep which do not start with space(s) and 1 digit and trim any leading spaces.
          processes=$(echo "$pgrep_list" | grep -ivE "$process_exclude_list" | sed -e '/^ *[0-9]/!d; s/^ *//; s/[[:cntrl:]]//g;')

          # Kill the Unix process ID with signal KILL (9)
          kill_process () { pid=$(echo $1 | cut -f1 -d ' '); echo "Killing process $1"; kill -9 $pid; }
        fi
        # Since a full process name can have spaces, the IFS (internal field separator)
        # should not include a space, just a LF & CR
        IFS=$(printf "\n\r")
        for process in $processes
        do
          kill_process "$process"
        done

  "run kitchen":
    command: shell.exec
    type: test
    params:
      shell: bash
      working_dir: src/buildscripts/package_test
      script: |
        set -o errexit

        export KITCHEN_ARTIFACTS_URL="https://s3.amazonaws.com/mciuploads/${project}/${build_variant}/${revision}/artifacts/${build_id}.tgz"
        export KITCHEN_SECURITY_GROUP="${kitchen_security_group}"
        export KITCHEN_SSH_KEY_ID="${kitchen_ssh_key_id}"
        export KITCHEN_SUBNET="${kitchen_subnet}"
        export KITCHEN_VPC="${kitchen_vpc}"

        ${activate_virtualenv}
        # set expiration tag 2 hours in the future, since no test should take this long
        export KITCHEN_EXPIRE="$($python -c 'import datetime; print((datetime.datetime.utcnow() + datetime.timedelta(hours=2)).strftime("%Y-%m-%d %H:%M:%S"))')"

        for i in {1..3}
        do
          if ! kitchen verify "${packager_distro}"; then
            verified="false"
            kitchen destroy "${packager_distro}" || true
            sleep 30
          else
            verified="true"
            break
          fi
        done

        kitchen destroy "${packager_distro}" || true
        test "$verified" = "true"

  "fetch test_lifecycle.yml":
  - command: shell.exec
    type: test
    params:
      working_dir: src
      script: |
        set -o verbose

        ${activate_virtualenv}
        $python buildscripts/fetch_test_lifecycle.py                      \
            --metadataRepo git@github.com:mongodb/mongo-test-metadata.git \
            --lifecycleFile etc/test_lifecycle.yml                        \
            --referencesFile references.yml                               \
            --destinationFile etc/test_lifecycle.yml                      \
            --revision ${revision}                                        \
            ${project}
        exit_code=$?
        if [ ${fail_task_on_error|false} = true ]; then
          exit $exit_code
        else
          exit 0
        fi

  "copy ec2 monitor files": &copy_ec2_monitor_files
    command: shell.exec
    params:
      background: true
      system_log: true
      working_dir: src
      silent: false
      script: |
        while [ 1 ]
        do
          # Tar/zip monitor files on remote host.
          if [ -z "${ec2_monitor_files}" ] || [ -z "${instance_id}" ]; then
            exit 0
          fi
          # Ensure we use the latest ip_address, as it could change if the EC2 instance
          # has been stopped and started.
          ${activate_virtualenv}
          # Specify '--mode start' to ensure the remote instance is running.
          aws_ec2=$($python buildscripts/aws_ec2.py --imageId ${instance_id} --mode start)
          echo "AMI EC2 instance ${instance_id} status: $aws_ec2"
          ip_address=$(echo $aws_ec2 | sed -e "s/[^[:print:]\t]//g; s/.*private_ip_address: //; s/ .*//")
          cmd="${tar|tar} czf ec2_monitor_files.tgz ${ec2_monitor_files}"
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          ssh_connection_options="$ssh_connection_options -o ConnectionAttempts=3"
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@$ip_address                     \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            --commands "$cmd"
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@$ip_address                     \
            --operation "copy_from"                          \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            --file ec2_monitor_files.tgz
          sleep 30
        done

  "set up EC2 instance":
    - command: shell.exec
      params:
        working_dir: src
        script: |

          set -o errexit
          ${activate_virtualenv}
          pip install boto3==1.5.27

          if [ ! -z "${subnet_id}" ]; then
            subnet_id="-n ${subnet_id}"
          fi

          for security_group_id in ${security_group_ids}
          do
            security_group_ids="$security_group_ids -g $security_group_id"
          done

          if [ -z "${security_group_ids}" ]; then
            for security_group in ${security_groups}
            do
              security_groups="$security_groups -s $security_group"
            done
          fi

          if [ ! -z "${expire_hours}" ]; then
            expire_hours="-e ${expire_hours}"
          fi

          # Clone another instance of this host in EC2.
          buildscripts/launch_evergreen_ec2_instance.sh \
            $expire_hours                               \
            -k ${ssh_key_id}                            \
            $security_groups                            \
            $security_group_ids                         \
            $subnet_id                                  \
            -t "AMI Evergreen ${task_id}"               \
            -y ${aws_ec2_yml}

    - command: expansions.update
      params:
        file: src/${aws_ec2_yml}

    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          set -o errexit
          # Copy mount_data_drive.sh script to remote host.
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          ${activate_virtualenv}
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --operation "copy_to"                            \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            --file buildscripts/mount_data_drive.sh

    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          set -o errexit
          # Mount /data on the attached drive(s), more than 1 indicates a RAID set.
          ${set_sudo}
          script_opts="-d '${device_names}'"
          if [ ! -z "${raid_device_name}" ]; then
            script_opts="$script_opts -r ${raid_device_name}"
          fi
          if [ ! -z "${fstype}" ]; then
            script_opts="$script_opts -t ${fstype}"
          fi
          if [ ! -z "${fs_options}" ]; then
            script_opts="$script_opts -o '${fs_options}'"
          fi
          group=$(id -Gn $USER | cut -f1 -d ' ') || true
          user_group="$USER:$group"
          script_opts="$script_opts -u $user_group"
          data_db=/data/db
          set_permission="chmod 777 $data_db"
          if [ "Windows_NT" = "$OS" ]; then
            set_permission="setfacl -s user::rwx,group::rwx,other::rwx $data_db"
          fi
          cmds="$sudo bash mount_data_drive.sh $script_opts; $set_permission; ls -ld $data_db; df; mount"
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          ${activate_virtualenv}
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            --commands "$cmds"

    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          set -o errexit
          # Create remote_dir, if specified as expansion macro and is not '.' (pwd).
          if [[ -z "${remote_dir|}" || ${remote_dir} == "." ]]; then
            exit 0
          fi
          ${set_sudo}
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          group=$(id -Gn $USER | cut -f1 -d ' ') || true
          user_group="$USER:$group"
          set_permission="chmod 777 ${remote_dir}"
          if [ "Windows_NT" = "$OS" ]; then
            set_permission="setfacl -s user::rwx,group::rwx,other::rwx ${remote_dir}"
          fi
          cmds="$sudo mkdir -p ${remote_dir}; $sudo chown $user_group ${remote_dir}; $set_permission; ls -ld ${remote_dir}"
          ${activate_virtualenv}
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            --commands "$cmds"

    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          set -o errexit
          # Copy buildscripts and mongoDB executables to the remote host.
          file_param="--file buildscripts"
          mongo_executables="mongo mongod mongos"
          for executable in $mongo_executables
          do
            file_param="$file_param --file $executable${exe}"
          done
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          ${activate_virtualenv}
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --operation "copy_to"                            \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            $file_param                                      \
            --remoteDir ${remote_dir}

    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          set -o errexit
          # Set up virtualenv on remote.
          cmds="python_loc=\$(which \${python|/opt/mongodbtoolchain/v2/bin/python2})"
          cmds="$cmds; if [ \"Windows_NT\" = \"$OS\" ]; then python_loc=\$(cygpath -w \$python_loc); fi"
          cmds="$cmds; virtualenv --python \$python_loc --system-site-packages ${virtualenv_dir|venv}"
          cmds="$cmds; activate=\$(find ${virtualenv_dir|venv} -name 'activate')"
          cmds="$cmds; . \$activate"
          # Install python modules on remote, if required.
          if [ ! -z "${virtualenv_requirements}" ]; then
            cmds="$cmds; pip install ${virtualenv_requirements}"
          fi
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          ${activate_virtualenv}
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            --commands "$cmds"

    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          set -o errexit
          ${set_sudo}
          # Set up curator to collect system & process stats on remote.
          if [ "Windows_NT" = "$OS" ]; then
             variant=windows-64
          else
             variant=ubuntu1604
          fi
          # Download stable version of curator
          curator_hash=117d1a65256ff78b6d15ab79a1c7088443b936d0
          curator_url="https://s3.amazonaws.com/boxes.10gen.com/build/curator/curator-dist-$variant-$curator_hash.tar.gz"
          cmds="curl -s $curator_url | tar -xzv"
          if [ "Windows_NT" = "$OS" ]; then
            # Since curator runs as SYSTEM user, ensure the output files can be accessed.
            cmds="$cmds; touch ${monitor_system_file}; chmod 777 ${monitor_system_file}"
            cmds="$cmds; cygrunsrv --install curator_sys --path curator --chdir \$HOME --args 'stat system --file ${monitor_system_file}'"
            cmds="$cmds; touch ${monitor_proc_file}; chmod 777 ${monitor_proc_file}"
            cmds="$cmds; cygrunsrv --install curator_proc --path curator --chdir \$HOME --args 'stat process-all --file ${monitor_proc_file}'"
            cmds="$cmds; cygrunsrv --start curator_sys"
            cmds="$cmds; cygrunsrv --start curator_proc"
          else
            cmds="$cmds; cmd=\"@reboot cd \$HOME && $sudo ./curator stat system >> ${monitor_system_file}\""
            cmds="$cmds; (crontab -l ; echo \"\$cmd\") | crontab -"
            cmds="$cmds; cmd=\"@reboot cd \$HOME && $sudo ./curator stat process-all >> ${monitor_proc_file}\""
            cmds="$cmds; (crontab -l ; echo \"\$cmd\") | crontab -"
            cmds="$cmds; crontab -l"
            cmds="$cmds; { $sudo \$HOME/curator stat system --file ${monitor_system_file} > /dev/null 2>&1 & $sudo \$HOME/curator stat process-all --file ${monitor_proc_file} > /dev/null 2>&1 & } & disown"
          fi
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          ${activate_virtualenv}
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            --commands "$cmds"

    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          set -o errexit
          ${set_sudo}
          # Many systems have the firewall disabled, by default. In case the firewall is
          # enabled we add rules for the mongod ports on the remote.
          # RHEL 7 firewall rules
          if [ ! -z "$(which firewall-cmd 2> /dev/null)" ]; then
            cmds="$sudo firewall-cmd --permanent --zone=public --add-port=ssh/tcp"
            cmds="$cmds; $sudo firewall-cmd --permanent --zone=public --add-port=${standard_port}/tcp"
            cmds="$cmds; $sudo firewall-cmd --permanent --zone=public --add-port=${secret_port}/tcp"
            cmds="$cmds; $sudo firewall-cmd --reload"
            cmds="$cmds; $sudo firewall-cmd --list-all"
          # ArchLinux, Debian, RHEL 6 firewall rules
          elif [ ! -z "$($sudo iptables --list 2> /dev/null)" ]; then
            cmds="$sudo iptables -I INPUT 1 -p tcp --dport ssh -j ACCEPT"
            cmds="$cmds; $sudo iptables -I INPUT 1 -p tcp --dport ${standard_port} -j ACCEPT"
            cmds="$cmds; $sudo iptables -I INPUT 1 -p tcp --dport ${secret_port} -j ACCEPT"
            if [ -d /etc/iptables ]; then
              rules_file=/etc/iptables/iptables.rules
            elif [ -f /etc/sysconfig/iptables ]; then
              rules_file=/etc/sysconfig/iptables
            else
              rules_file=/etc/iptables.up.rules
            fi
            cmds="$cmds; $sudo iptables-save | $sudo tee $rules_file"
            cmds="$cmds; $sudo iptables --list-rules"
          elif [ ! -z "$($sudo service iptables status 2> /dev/null)" ]; then
            cmds="$sudo iptables -I INPUT 1 -p tcp --dport ssh -j ACCEPT"
            cmds="$cmds; $sudo iptables -I INPUT 1 -p tcp --dport ${standard_port} -j ACCEPT"
            cmds="$cmds; $sudo iptables -I INPUT 1 -p tcp --dport ${secret_port} -j ACCEPT"
            cmds="$cmds; $sudo service iptables save"
            cmds="$cmds; $sudo service iptables status"
          # Ubuntu firewall rules
          elif [ ! -z "$($sudo ufw status 2> /dev/null)" ]; then
            cmds="$sudo ufw allow ssh/tcp"
            cmds="$cmds; $sudo ufw allow ${standard_port}/tcp"
            cmds="$cmds; $sudo ufw allow ${secret_port}/tcp"
            cmds="$cmds; $sudo ufw reload"
            cmds="$cmds; $sudo ufw status"
          # SuSE firewall rules
          # TODO: Add firewall rules using SuSEfirewall2
          elif [ ! -z "$($sudo /sbin/SuSEfirewall2 help 2> /dev/null)" ]; then
            cmds="$sudo /sbin/SuSEfirewall2 stop"
            cmds="$cmds; $sudo /sbin/SuSEfirewall2 off"
          # Windows firewall rules
          elif [ ! -z "$(netsh advfirewall show store 2> /dev/null)" ]; then
            add_rule="netsh advfirewall firewall add rule"
            cmds="$add_rule name='MongoDB port ${standard_port} in' dir=in action=allow protocol=TCP localport=${standard_port}"
            cmds="$cmds; $add_rule name='MongoDB port ${standard_port} out' dir=in action=allow protocol=TCP localport=${standard_port}"
            cmds="$cmds; $add_rule name='MongoDB port ${secret_port} in' dir=in action=allow protocol=TCP localport=${secret_port}"
            cmds="$cmds; $add_rule name='MongoDB port ${secret_port} out' dir=in action=allow protocol=TCP localport=${secret_port}"
            cmds="$cmds; netsh advfirewall firewall show rule name=all | grep -A 13 'MongoDB'"
          else
            echo "Firewall not active or unknown firewall command on this platform"
            exit 0
          fi
          set -o errexit
          if [ ! -z "$cmds" ]; then
            ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
            ${activate_virtualenv}
            $python buildscripts/remote_operations.py          \
              --verbose                                        \
              --userHost $USER@${ip_address}                   \
              --sshConnectionOptions "$ssh_connection_options" \
              --retries ${ssh_retries|0}                       \
              --commands "$cmds"
          fi

    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          set -o errexit
          if [[ "Windows_NT" != "$OS" || -z "${windows_crash_zip}" ]]; then
            exit 0
          fi
          # Install NotMyFault, used to crash Windows.
          cmds="curl -s -o ${windows_crash_zip} ${windows_crash_dl}"
          cmds="$cmds; unzip -q ${windows_crash_zip} -d ${windows_crash_dir}"
          cmds="$cmds; chmod +x ${windows_crash_dir}/*.exe"
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          ${activate_virtualenv}
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            --commands "$cmds"

    - *copy_ec2_monitor_files


  "set EC2 address":
    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          if [ -z "${instance_id}" ]; then
            exit 0
          fi
          # Ensure we use the latest ip_address, as it could change if the EC2 instance
          # has been stopped and started.
          ${activate_virtualenv}
          # Specify '--mode start' to ensure the remote instance is running.
          aws_ec2=$($python buildscripts/aws_ec2.py --imageId ${instance_id} --mode start)
          echo "AMI EC2 instance ${instance_id} status: $aws_ec2"
          ip_address=$(echo $aws_ec2 | sed -e "s/[^[:print:]\t]//g; s/.*private_ip_address: //; s/ .*//")
          sed -i -e "s/${ip_address}/$ip_address/" ${aws_ec2_yml}
          echo "Instance status: $aws_ec2"

    - command: expansions.update
      params:
        file: src/${aws_ec2_yml}

  "copy EC2 artifacts":
    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          # Tar/zip artifacts on remote host.
          if [ -z "${ec2_artifacts}" ]; then
            exit 0
          fi
          cmd="${tar|tar} czf ec2_artifacts.tgz ${ec2_artifacts}"
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          ${activate_virtualenv}
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            --commands "$cmd"

    - command: shell.exec
      params:
        shell: bash
        working_dir: src
        script: |
          # Copy remote artifacts.
          if [ -z "${ec2_artifacts}" ]; then
            exit 0
          fi
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          ${activate_virtualenv}
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --operation "copy_from"                          \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries|0}                       \
            --file ec2_artifacts.tgz

  "cleanup EC2 instance":
    command: shell.exec
    params:
      working_dir: src
      script: |
        if [ -z ${instance_id} ]; then
          exit 0
        fi
        ${activate_virtualenv}
        echo "Terminating $instance_id"
        aws_ec2=$($python buildscripts/aws_ec2.py --imageId ${instance_id} --mode terminate)
        echo "Terminated AMI EC2 instance: $aws_ec2"

pre:
  - func: "kill processes"
  - func: "cleanup environment"
  # The python virtual environment is installed in ${workdir}, which is created in "set up virtualenv".
  - func: "set up virtualenv"
  - command: expansions.update
    params:
      updates:
      - key: activate_virtualenv
        value: |
          # check if virtualenv is set up
          if [ -d "${workdir}/venv" ]; then
            if [ "Windows_NT" = "$OS" ]; then
              # Need to quote the path on Windows to preserve the separator.
              . "${workdir}/venv/Scripts/activate" 2> /tmp/activate_error.log
            else
              . ${workdir}/venv/bin/activate 2> /tmp/activate_error.log
            fi
            if [ $? -ne 0 ]; then
              echo "Failed to activate virtualenv: $(cat /tmp/activate_error.log)"
            fi
            python=python
          else
            python=${python|/opt/mongodbtoolchain/v2/bin/python2}
          fi
          echo "python set to $(which python)"
      - key: posix_workdir
        value: eval 'if [ "Windows_NT" = "$OS" ]; then echo $(cygpath -u "${workdir}"); else echo ${workdir}; fi'
      # For ssh disable the options GSSAPIAuthentication, CheckHostIP, StrictHostKeyChecking
      # & UserKnownHostsFile, since these are local connections from one AWS instance to another.
      - key: ssh_connection_options
        value: -o GSSAPIAuthentication=no -o CheckHostIP=no -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ConnectTimeout=20 -o ConnectionAttempts=20
      - key: ssh_retries
        value: "10"
      - key: set_sudo
        value: |
          set -o > /tmp/settings.log
          set +o errexit
          grep errexit /tmp/settings.log | grep on
          errexit_on=$?
          # Set errexit "off".
          set +o errexit
          sudo=
          # Use sudo, if it is supported.
          sudo date > /dev/null 2>&1
          if [ $? -eq 0 ]; then
            sudo=sudo
          fi
          # Set errexit "on", if previously enabled.
          if [ $errexit_on -eq 0 ]; then
            set -o errexit
          fi
      - key: mongo_binaries
        value: ${project}/${build_variant}/${revision}/binaries/mongo-${build_id}.${ext|tgz}
      - key: mongo_debugsymbols
        value: ${project}/${build_variant}/${revision}/debugsymbols/debugsymbols-${build_id}.${ext|tgz}
      - key: mongo_shell
        value: ${project}/${build_variant}/${revision}/binaries/mongo-shell-${build_id}.${ext|tgz}

  - command: shell.exec
    params:
      system_log: true
      script: |

        ulimit -a
        # Clear the dmesg ring buffer. The "post" phase will check dmesg for OOM messages.
        ${set_sudo}
        $sudo dmesg -c > /dev/null 2>&1
        if [ $? -eq 0 ]; then
          echo "Cleared the dmesg ring buffer"
        else
          echo "Could not clear the dmesg ring buffer"
        fi


post:
  - command: attach.results
    params:
      file_location: src/report.json
  - command: attach.artifacts
    params:
      optional: true
      ignore_artifacts_for_spawn: false
      files:
        - src/archive.json

  - func: "set EC2 address"
  - func: "copy EC2 artifacts"
  # Gather remote mongo coredumps.
  - command: shell.exec
    params:
      working_dir: "src"
      script: |
        if [ ! -f ${aws_ec2_yml|""} ]; then
          exit 0
        fi
        ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
        remote_dir=${remote_dir|.}
        # Find all core files and move to $remote_dir
        cmds="core_files=\$(/usr/bin/find -H . \( -name '*.core' -o -name '*.mdmp' \) 2> /dev/null)"
        cmds="$cmds; if [ -z \"\$core_files\" ]; then exit 0; fi"
        cmds="$cmds; echo Found remote core files \$core_files, moving to \$(pwd)"
        cmds="$cmds; for core_file in \$core_files"
        cmds="$cmds; do base_name=\$(echo \$core_file | sed 's/.*\///')"
        cmds="$cmds;   if [ ! -f \$base_name ]; then mv \$core_file .; fi"
        cmds="$cmds; done"
        $python buildscripts/remote_operations.py \
          --verbose                                        \
          --userHost $USER@${ip_address}                   \
          --sshConnectionOptions "$ssh_connection_options" \
          --retries ${ssh_retries}                         \
          --commands "$cmds"                               \
          --commandDir $remote_dir
  - command: shell.exec
    params:
      working_dir: "src"
      script: |
        if [ ! -f ${aws_ec2_yml|""} ]; then
          exit 0
        fi
        ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
        remote_dir=${remote_dir|.}
        $python buildscripts/remote_operations.py \
          --verbose                                        \
          --userHost $USER@${ip_address}                   \
          --operation "copy_from"                          \
          --sshConnectionOptions "$ssh_connection_options" \
          --retries ${ssh_retries}                         \
          --file "$remote_dir/*.core"                      \
          --file "$remote_dir/*.mdmp"
        # Since both type of core files do not exist on the same host, this command
        # will always return non-zero. As the core file retrieval is optional, we
        # always exit successfully.
        exit 0
  - func: "cleanup EC2 instance"

  - func: "kill processes"
  # Print out any Out of Memory killed process messages.
  - command: shell.exec
    params:
      system_log: true
      working_dir: src # Temporary files created in src will be cleaned up in "pre".
      script: |
        ${set_sudo}
        # Use dmesg -T option, if supported, to display timestamps.
        dmesg=dmesg
        $sudo dmesg -T > /dev/null 2>&1
        if [ $? -eq 0 ]; then
          dmesg="dmesg -T"
        fi
        $sudo $dmesg 2> /dev/null > dmesg.txt
        if [ $? -ne 0 ]; then
          echo "Cannot check for OOM (Out of memory) killed processes on this platform"
          exit 0
        fi
        grep -iE '(Out of memory|OOM[- ]killer|Killed process)' dmesg.txt > oom.txt
        if [ -s oom.txt ]; then
          echo "OOM (Out of memory) killed processes detected"
          cat oom.txt
        else
          echo "No OOM (Out of memory) killed processes detected"
        fi

  # Cleanup after the watchdog FUSE testing
  - command: shell.exec
    params:
      working_dir: src
      script: |
        if [ -d /data/thrift ]; then
          rm -rf /data/thrift
        fi

        if [ -d /data/charybdefs ]; then
          rm -rf /data/charybdefs
        fi

  # Archive remote EC2 monitor files.
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: src/ec2_monitor_files.tgz
      remote_file: ${project}/${build_variant}/${revision}/remote_ec2/remote_ec2_monitor-${task_id}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: Remote EC2 Monitor - Execution ${execution}
      optional: true

  # Archive remote EC2 artifacts.
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: src/ec2_artifacts.tgz
      remote_file: ${project}/${build_variant}/${revision}/remote_ec2/remote_ec2_artifacts-${task_id}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: Remote EC2 Artifacts - Execution ${execution}
      optional: true

  # Gather and archive the local client logs.
  - command: shell.exec
    params:
      working_dir: src
      script: |
        client_logs=$(ls crud*.log fsm*.log 2> /dev/null)
        if [ ! -z "$client_logs" ]; then
          ${tar|tar} czf client-logs.tgz $client_logs
        fi
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: src/client-logs.tgz
      remote_file: ${project}/${build_variant}/${revision}/client_logs/mongo-client-logs-${task_id}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: Client logs - Execution ${execution}
      optional: true

  # Process and save coverage data.
  - command: shell.exec
    params:
      working_dir: src
      script: |
        if [ -d "./build" ]; then
            file_list=$(find ./build -type f -name "*.gcda")
            if [ -n "$file_list" ]; then
                for gcda_file in $file_list; do
                    /opt/mongodbtoolchain/v2/bin/gcov -i $gcda_file
                done
            fi
        fi
  - command: archive.targz_pack
    params:
      target: "src/gcov-intermediate-files.tgz"
      source_dir: "src"
      include:
        - "*.gcda.gcov"
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: "src/gcov-intermediate-files.tgz"
      remote_file: ${project}/${build_variant}/${revision}/gcov/gcov-intermediate-files-${task_id}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: gcov intermediate files - Execution ${execution}
      optional: true

  # Gather and archive the Jepsen mongod logs.
  - command: shell.exec
    params:
      working_dir: src
      script: |
        # For Jepsen tasks, archive the mongod log files.
        if [ ${distro_id} = "ubuntu1404-jepsen" ]; then
          # Copy mongod.log & stdout.log from each LXC host for archive purposes. Note that
          # stdout.log is also generated as a result of starting mongod.
          # The logs can reside in 1 of 2 places:
          #   If the task completed: /root
          #   If the task failed to complete: /opt/mongodb
          # There may be logs in both places, but the ones in /opt/mongodb should override
          # the ones in /root, since the logs in /root could be from a previous successful run.
          numVms=5
          for i in $(seq 1 $numVms)
          do
            hostn=n$i
            for log_dir in /root /opt/mongodb
            do
              for log in mongod.log stdout.log
              do
                outlog="$(echo $log | cut -f1 -d '.')-n$i.log"
                scp -q root@$hostn:$log_dir/$log $outlog 2> /dev/null
                if [ -f $outlog ]; then
                  echo "Copied $log_dir/$log from $hostn to $outlog"
                fi
              done
            done
          done
        fi
  - command: archive.targz_pack
    params:
      target: "src/jepsen-mongod-logs.tgz"
      source_dir: "src"
      include:
        - "mongod*.log"
        - "stdout*.log"
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: src/jepsen-mongod-logs.tgz
      remote_file: ${project}/${build_variant}/${revision}/jepsen/jepsen-mongod-logs-${task_id}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: Jepsen mongod Logs - ${execution}
      optional: true

  # Gather and archive the Jepsen results.
  - command: archive.targz_pack
    params:
      target: "src/jepsen-results.tgz"
      source_dir: "src/jepsen-mongodb/store"
      include:
        - "./**"
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: src/jepsen-results.tgz
      remote_file: ${project}/${build_variant}/${revision}/jepsen/jepsen-results-${task_id}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: Jepsen Test Results - ${execution}
      optional: true

  # Gather and archive mongo coredumps.
  - command: shell.exec
    params:
      working_dir: "src"
      script: |
        # Find all core files and move to src
        core_files=$(/usr/bin/find -H .. \( -name "*.core" -o -name "*.mdmp" \) 2> /dev/null)
        for core_file in $core_files
        do
          base_name=$(echo $core_file | sed "s/.*\///")
          # Move file if it does not already exist
          if [ ! -f $base_name ]; then
            mv $core_file .
          fi
        done
  - command: archive.targz_pack
    params:
      target: "mongo-coredumps.tgz"
      source_dir: "src"
      include:
        - "./**.core"
        - "./**.mdmp" # Windows: minidumps
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: mongo-coredumps.tgz
      remote_file: ${project}/${build_variant}/${revision}/coredumps/mongo-coredumps-${build_id}-${task_name}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: Core Dumps - Execution ${execution}
      optional: true

  # Gather and archive failed unit test binaries.
  - command: shell.exec
    params:
      working_dir: "src"
      script: |
        mkdir unittest_binaries
        # Find all core files
        core_files=$(/usr/bin/find -H . \( -name "dump_*.core" -o -name "*.mdmp" \) 2> /dev/null)
        for core_file in $core_files
        do
          # A core file name does not always have the executable name that generated it.
          # See http://stackoverflow.com/questions/34801353/core-dump-filename-gets-thread-name-instead-of-executable-name-with-core-pattern
          # On platforms with GDB, we get the binary name from core file
          gdb=/opt/mongodbtoolchain/gdb/bin/gdb
          if [ -f $gdb ]; then
            binary_file=$($gdb -batch --quiet -ex "core $core_file" 2> /dev/null | grep "Core was generated" | cut -f2 -d "\`" | cut -f1 -d "'" | cut -f1 -d " ")
            binary_file_locations=$binary_file
          else
            # Find the base file name from the core file name, note it may be truncated.
            # Remove leading 'dump_' and trailing '.<pid>.core' or '.<pid or time>.mdmp'
            binary_file=$(echo $core_file | sed "s/.*\///;s/dump_//;s/\..*\.core//;s/\..*\.mdmp//")
            # Locate the binary file. Since the base file name might be truncated, the find
            # may return more than 1 file.
            binary_file_locations=$(/usr/bin/find -H . -name "$binary_file*${exe}" 2> /dev/null)
          fi
          if [ -z "$binary_file_locations" ]; then
            echo "Cannot locate the unittest binary file ($binary_file) that generated the core file $core_file"
          fi
          for binary_file_location in $binary_file_locations
          do
            new_binary_file=unittest_binaries/$(echo $binary_file_location | sed "s/.*\///")
            if [ ! -f $new_binary_file ]; then
              mv $binary_file_location $new_binary_file
            fi
            # On Windows if a .pdb symbol file exists, include it in the archive.
            pdb_file=$(echo $binary_file_location | sed "s/\.exe/.pdb/")
            if [ -f $pdb_file ]; then
              new_pdb_file=unittest_binaries/$(echo $pdb_file | sed "s/.*\///")
              mv $pdb_file $new_pdb_file
            fi
          done
        done
  - command: archive.targz_pack
    params:
      target: "mongo-unittests.tgz"
      source_dir: "src/unittest_binaries"
      include:
        - "./*_test${exe}"
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: mongo-unittests.tgz
      remote_file: ${project}/${build_variant}/${revision}/unittests/mongo-unittests-${build_id}-${task_name}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: Unit tests - Execution ${execution}
      optional: true

  # Gather and archive hang_analyzer debugger files.
  - command: archive.targz_pack
    params:
      target: "src/mongo-hanganalyzer.tgz"
      source_dir: "src"
      include:
        - "./debugger*.*"
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: src/mongo-hanganalyzer.tgz
      remote_file: ${project}/${build_variant}/${revision}/hanganalyzer/mongo-hanganalyzer-${build_id}-${task_name}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: Hang Analyzer Output - Execution ${execution}
      optional: true

  # Gather and archive disk statistics.
  - command: archive.targz_pack
    params:
      target: "diskstats.tgz"
      source_dir: "./"
      include:
        - "./mongo-diskstats*"
        - "./mongo-diskstats*.csv"
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: diskstats.tgz
      remote_file: ${project}/${build_variant}/${revision}/diskstats/mongo-diskstats-${task_id}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: Disk Stats - Execution ${execution}
      optional: true

  # Gather and archive system resource information.
  - command: archive.targz_pack
    params:
      target: "system-resource-info.tgz"
      source_dir: src
      include:
        - "./system_resource_info*"
  - command: s3.put
    params:
      aws_key: ${aws_key}
      aws_secret: ${aws_secret}
      local_file: system-resource-info.tgz
      remote_file: ${project}/${build_variant}/${revision}/systemresourceinfo/mongo-system-resource-info-${task_id}-${execution}.tgz
      bucket: mciuploads
      permissions: public-read
      content_type: ${content_type|application/x-gzip}
      display_name: System Resource Info - Execution ${execution}
      optional: true

  # Cleanup steps.
  - command: shell.exec
    params:
      working_dir: src
      script: |
        # removes files from the (local) scons cache when it's over a
        # threshold, to the $prune_ratio percentage. Ideally override
        # these default values in the distro config in evergreen.

        ${activate_virtualenv}
        if [ -d "${scons_cache_path}" ]; then
            $python buildscripts/scons_cache_prune.py --cache-dir '${scons_cache_path}' --cache-size ${scons_cache_size|200} --prune-ratio ${scons_prune_ratio|0.8}
        fi

  - command: shell.exec
    type: test
    params:
      working_dir: src
      shell: bash
      script: |
        set -o verbose
        set -o errexit

        # umount shared scons mounts
        sudo umount /efs || umount /efs

  - func: "cleanup environment"

timeout:
  - func: "fetch debugsymbols archive"
  - func: "extract debugsymbols"
  - func: "set EC2 address"
  - command: shell.exec
    params:
      working_dir: src
      script: |
        set -o verbose

        # We run the hang_analyzer.py script with root privileges when running the Jepsen tests in
        # order to be able to attach to the mongod processes inside the LXC containers.
        sudo=
        if [ ${distro_id} = "ubuntu1404-jepsen" ]; then
          ${set_sudo}
        fi

        hang_analyzer_option="-o file -o stdout -p ${hang_analyzer_processes|dbtest,java,mongo,mongod,mongos,python,_test} -g bsondump,mongodump,mongoexport,mongofiles,mongoimport,mongoreplay,mongorestore,mongostat,mongotop"

        if [ ${hang_analyzer_dump_core|true} = true ]; then
          hang_analyzer_option="-c $hang_analyzer_option"
        fi

        ${activate_virtualenv}
        echo "Calling the hang analyzer: PATH=\"/opt/mongodbtoolchain/gdb/bin:$PATH\" $sudo $python buildscripts/hang_analyzer.py $hang_analyzer_option"
        PATH="/opt/mongodbtoolchain/gdb/bin:$PATH" $sudo $python buildscripts/hang_analyzer.py $hang_analyzer_option

        # Call hang_analyzer.py script for tasks that are running remote mongo processes
        # The file ${aws_ec2_yml} will define the remote's ${ip_address}.
        # Any task which uses remote processes will have previously loaded this file to set these
        # expansion macros.
        if [ -f ${aws_ec2_yml|""} ]; then
          core_ext=core
          if [ "Windows_NT" = "$OS" ]; then
            core_ext=mdmp
          fi
          ssh_connection_options="${ssh_identity} ${ssh_connection_options}"
          # buildscripts must be installed in ${remote_dir} on the remote host.
          remote_dir=${remote_dir|.}

          # Copy mongoDB debug symbols to the remote host.
          debug_files=$(ls *.debug *.dSYM *.pdb 2> /dev/null)
          for debug_file in $debug_files
          do
            file_param="$file_param --file $debug_file"
          done
          if [ ! -z "$file_param" ]; then
            $python buildscripts/remote_operations.py          \
              --verbose                                        \
              --userHost $USER@${ip_address}                   \
              --operation "copy_to"                            \
              --sshConnectionOptions "$ssh_connection_options" \
              --retries ${ssh_retries}                         \
              $file_param                                      \
              --remoteDir $remote_dir
          fi

          # Activate virtualenv on remote host. The virtualenv bin_dir is different for Linux and
          # Windows.
          bin_dir=$(find $VIRTUAL_ENV -name activate | sed -e "s,$VIRTUAL_ENV,,;s,activate,,;s,/,,g")
          cmds=". ${virtualenv_dir|venv}/$bin_dir/activate"
          # In the 'cmds' variable we pass to remote host, use 'python' instead of '$python' since
          # we don't want to evaluate the local python variable, but instead pass the python string
          # so the remote host will use the right python when the virtualenv is sourced.
          cmds="$cmds; cd ${remote_dir}"
          cmds="$cmds; PATH=\"/opt/mongodbtoolchain/gdb/bin:\$PATH\" $sudo python buildscripts/hang_analyzer.py $hang_analyzer_option"
          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries}                         \
            --commands "$cmds"

          $python buildscripts/remote_operations.py          \
            --verbose                                        \
            --userHost $USER@${ip_address}                   \
            --operation "copy_from"                          \
            --sshConnectionOptions "$ssh_connection_options" \
            --retries ${ssh_retries}                         \
            --file "$remote_dir/debugger*.*"                 \
            --file "$remote_dir/*.$core_ext"
        fi

#######################################
#               Tasks                 #
#######################################

## The test_lifecycle_excluded_tasks are a list of tasks names which include:
##   - Non jstests, i.e., compile, unittests
##   - Non standard jstests, i.e., jstestfuzz
## Note that the task name supports glob patterns.
test_lifecycle_excluded_tasks:
- aggregation_fuzzer*
- burn_in_tests
- compile*
- dbtest*
- idl_tests
- integration*
- jepsen*
- jstestfuzz*
- lint
- mongos*
- package
- push
- rollback_fuzzer*
- unittests*
- update_fuzzer*

tasks:

## compile - build all scons targets except unittests ##
- name: compile
  depends_on: []
  commands:
    - command: manifest.load
    - *git_get_project
    - func: "get modified patch files"
    # NOTE: To disable the compile bypass feature, comment out the next line.
    - func: "bypass compile and fetch binaries"
    - func: "update bypass expansions"
    - func: "get buildnumber"
    - func: "set up credentials"
    - func: "build new tools" # noop if ${newtools} is not "true"
    - func: "build rocksdb" # noop if ${build_rocksdb} is not "true"
    - func: "use WiredTiger develop" # noop if ${use_wt_develop} is not "true"
    - *generate_compile_expansions
    # Then we load the generated version data into the agent so we can use it in task definitions
    - *apply_compile_expansions

    - command: shell.exec
      type: test
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          if [ "${is_patch}" = "true" ] && [ "${bypass_compile|false}" = "true" ]; then
            exit 0
          fi
          rm -rf ${install_directory|/data/mongo-install-directory}

          ${activate_virtualenv}
          ${compile_env|} $python ./buildscripts/scons.py ${compile_flags|} ${scons_cache_args|} --use-new-tools --build-mongoreplay="${build_mongoreplay}" --detect-odr-violations core tools dbtest integration_tests dist dist-debugsymbols distsrc-${ext|tgz} ${msi_target|} MONGO_VERSION=${version}

          mv mongodb-src-*.${ext|tgz} distsrc.${ext|tgz}
          mv mongodb-*-debugsymbols.${ext|tgz} mongo-debugsymbols.tgz || true
          mv mongodb-*.${ext|tgz} mongodb-binaries.tgz

          # If strip is on the path (everywhere except windows) then we should strip the test binaries
          # before tarring them up
          if [ -x ${strip_path|/usr/bin/strip} ]; then
            cat build/integration_tests.txt | xargs ${strip_command|/usr/bin/strip}
            ${strip_command|/usr/bin/strip} dbtest
            ${strip_command|/usr/bin/strip} mongobridge
          fi

    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          if [ "${is_patch}" = "true" ] && [ "${bypass_compile|false}" = "true" ]; then
            exit 0
          fi
          ${activate_virtualenv}
          if [ "${has_packages|}" = "true" ] ; then
            cd buildscripts
            $python ${packager_script} --prefix `pwd`/.. --distros ${packager_distro} --tarball `pwd`/../mongodb-binaries.tgz -s ${version} -m HEAD -a ${packager_arch}
            cd ..
          fi

          # Create separate shell archive
          mkdir -p shell-archive/build
          cd shell-archive
          ${platform_decompress|tar xzvf} ../mongodb-binaries.tgz
          find . -mindepth 3 ! -name "mongo${exe}" -type f -exec rm {} \; # delete bin/* except bin/mongo
          $python ../buildscripts/make_archive.py -o mongodb-shell.${ext|tgz} $(find mongodb-* -type f)
          cd ..

    - func: "fetch test_lifecycle.yml"
      vars:
        # Do not fail the task if we fail to fetch the test_lifecycle.yml file
        fail_task_on_error: false

    - command: archive.targz_pack
      params:
        target: "artifacts.tgz"
        source_dir: "src"
        include:
          - "src/mongo/db/modules/enterprise/jstests/**"
          - "compile_expansions.yml"
          - "src/mongo/db/modules/subscription/jstests/**"
          - "src/mongo/db/modules/enterprise/docs/**"
          - "*.exe"
          - "jstests/**"
          - "pytests/**"
          - "./test*"
          - "./dbtest*"
          - "./mongobridge*"
          - "buildscripts/**"
          - "*Example"
          - "*Test"
          - "./**.pdb"
          - "./**.msi"
          - "./etc/*san.suppressions"
          - "./etc/repo_config.yaml"
          - "./etc/test_lifecycle.yml"
          - "./etc/test_retrial.yml"
          - "./build/integration_tests/**"
          - "./build/integration_tests.txt"
          - "./build/**.gcno"
          - "repo/**"
          - "src/mongo/util/options_parser/test_config_files/**"
          - "library_dependency_graph.json"
          - "src/third_party/JSON-Schema-Test-Suite/tests/draft4/**"
          - "bypass_compile_expansions.yml"
          - "patch_files.txt"
          - "artifacts.json"
        exclude_files:
          - "*_test.pdb"
    - func: "upload debugsymbols"
    - command: s3.put
      params:
        optional: true
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: src/mongodb-binaries.tgz
        remote_file: ${mongo_binaries}
        bucket: mciuploads
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        display_name: Binaries
    - command: s3.put
      params:
        optional: true
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: src/shell-archive/mongodb-shell.${ext|tgz}
        remote_file: ${mongo_shell}
        bucket: mciuploads
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        display_name: Shell
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: artifacts.tgz
        remote_file: ${project}/${build_variant}/${revision}/artifacts/${build_id}.tgz
        bucket: mciuploads
        permissions: public-read
        content_type: application/tar
        display_name: Artifacts
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: src/distsrc.${ext|tgz}
        remote_file: ${project}/${build_variant}/${revision}/sources/mongo-src-${build_id}.${ext|tgz}
        bucket: mciuploads
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        display_name: Source tarball
        # We only need to upload the source tarball from one of the build variants
        # because it should be the same everywhere, so just use linux-64/windows-64-2k8.
        build_variants: [ linux-64, windows-64-2k8-ssl ]
    # For patch builds that bypass compile, we upload links to pre-existing tarballs, except for the
    # artifacts.tgz.
    - command: attach.artifacts
      params:
        optional: true
        ignore_artifacts_for_spawn: false
        files:
          - src/artifacts.json

## compile_all - build all scons targets including unittests ##
- name: compile_all
  commands:
    - command: manifest.load
    - *git_get_project
    - func: "get buildnumber"
    - func: "set up credentials"
    - func: "build new tools" # noop if ${newtools} is not "true"
    - func: "build rocksdb" # noop if ${build_rocksdb} is not "true"
    - func: "use WiredTiger develop" # noop if ${use_wt_develop} is not "true"
    - func: "setup android toolchain" # noop if ${setup_android_toolchain} is not "true"
    - func: "build cdriver" # noop if ${build_cdriver} is not "true"
    - *generate_compile_expansions
    # Then we load the generated version data into the agent so we can use it in task definitions.
    - *apply_compile_expansions

    - command: shell.exec
      type: test
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          rm -rf ${install_directory|/data/mongo-install-directory}

          extra_args=""
          if [ -n "${num_scons_compile_all_jobs_available|}" ]; then
            echo "Changing SCons to run with --jobs=${num_scons_compile_all_jobs_available|}"
            extra_args="$extra_args --jobs=${num_scons_compile_all_jobs_available|}"
          fi

          ${activate_virtualenv}
          ${compile_env|} $python ./buildscripts/scons.py ${compile_flags|} ${scons_cache_args|} --use-new-tools --build-mongoreplay="${build_mongoreplay}" --detect-odr-violations $extra_args all ${additional_targets|} MONGO_VERSION=${version}

    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: src/library_dependency_graph.json
        remote_file: ${project}/${build_variant}/${revision}/library_dependency_graph.${build_id}.json
        bucket: mciuploads
        permissions: public-read
        content_type: application/json
        display_name: Library Dependency Graph (library_dependency_graph.json)
        build_variants: [enterprise-ubuntu1604-64]

    # Run the C++ unittests as part of compile_all. The compiled binaries are automatically
    # installed into the top-level directory by SCons.
    # noop if ${disable_unit_tests} is "true"
    - func: "run tests"
      vars:
        resmoke_args: --suites=unittests
        run_multiple_jobs: true

    # Run the iOS embedded CAPI tests in the iOS simulator
    # noop if ${enable_iostvos_sim_tests} is not "true"
    - func: "run ios sim embedded tests"

    # Run the android embedded CAPI tests in the android emulator
    # noop if ${enable_android_emu_tests} is not "true"
    - func: "run android emulator tests"

## lint ##
- name: lint
  depends_on: []
  commands:
    - command: manifest.load
    - *git_get_project
    - command: shell.exec
      type: test
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          ${activate_virtualenv}
          ${compile_env|} $python ./buildscripts/scons.py ${compile_flags|} --stack-size=1024 lint

- <<: *task_template
  name: burn_in_tests
  depends_on:
  - name: compile
  commands:
  - <<: *git_get_project
    # The repository is cloned in a directory distinct from src for the modified test detection
    # because the extraction of the artifacts performed in the 'do setup' causes
    # 'git diff --name-only' to see all tests as modified on Windows (git 1.9.5). See SERVER-30634.
    params:
      <<: *git_get_project_params
      directory: burn_in_tests_clonedir
  - func: "do setup"
  - command: shell.exec
    params:
      working_dir: burn_in_tests_clonedir
      shell: bash
      script: |
        set -o errexit
        set -o verbose
        # If this is a scheduled build, we check for changes against the last scheduled commit.
        if [ "${is_patch}" != "true" ]; then
          burn_in_args="--checkEvergreen"
        fi
        # Copy the dbtest executable from the src dir because burn_in_tests.py calls it to get the
        # list of dbtest suites.
        cp ../src/dbtest${exe} .
        pushd ../src
        ${activate_virtualenv}
        popd
        # Capture a list of new and modified tests.
        $python buildscripts/burn_in_tests.py --branch=${branch_name} --buildVariant=${build_variant} --testListOutfile=jstests/new_tests.json --noExec $burn_in_args
        # Copy the results to the src dir.
        cp jstests/new_tests.json ../src/jstests/new_tests.json
  - func: "do multiversion setup"
  - func: "run tests"
    vars:
      task_path_suffix: /data/multiversion
      resmoke_wrapper: $python buildscripts/burn_in_tests.py --testListFile=jstests/new_tests.json
      resmoke_args: --repeat=2
      run_multiple_jobs: true

- <<: *run_jepsen_template
  name: jepsen_register_findAndModify_WT
  commands:
  - func: "do setup"
  - func: "do jepsen setup"
  - func: "run jepsen test"
    vars:
      <<: *jepsen_config_vars
      jepsen_read_with_find_and_modify: --read-with-find-and-modify
      jepsen_storage_engine: --storage-engine wiredTiger
      jepsen_test_name: register

- <<: *run_jepsen_template
  name: jepsen_register_linearizableRead
  commands:
  - func: "do setup"
  - func: "do jepsen setup"
  - func: "run jepsen test"
    vars:
      <<: *jepsen_config_vars
      jepsen_read_concern: --read-concern linearizable
      jepsen_storage_engine: --storage-engine mmapv1
      jepsen_test_name: register
      # Running Jepsen when using the MMAPv1 storage engine for longer periods of time can lead to
      # out of memory issues and task timeouts during the analysis phase.
      jepsen_time_limit: --time-limit 300

- <<: *run_jepsen_template
  name: jepsen_register_linearizableRead_WT
  commands:
  - func: "do setup"
  - func: "do jepsen setup"
  - func: "run jepsen test"
    vars:
      <<: *jepsen_config_vars
      jepsen_read_concern: --read-concern linearizable
      jepsen_storage_engine: --storage-engine wiredTiger
      jepsen_test_name: register

- <<: *run_jepsen_template
  name: jepsen_set_linearizableRead
  commands:
  - func: "do setup"
  - func: "do jepsen setup"
  - func: "run jepsen test"
    vars:
      <<: *jepsen_config_vars
      jepsen_read_concern: --read-concern linearizable
      jepsen_storage_engine: --storage-engine mmapv1
      jepsen_test_name: set
      # Running Jepsen when using the MMAPv1 storage engine for longer periods of time can lead to
      # out of memory issues and task timeouts during the analysis phase.
      jepsen_time_limit: --time-limit 300

- <<: *run_jepsen_template
  name: jepsen_set_linearizableRead_WT
  commands:
  - func: "do setup"
  - func: "do jepsen setup"
  - func: "run jepsen test"
    vars:
      <<: *jepsen_config_vars
      jepsen_read_concern: --read-concern linearizable
      jepsen_storage_engine: --storage-engine wiredTiger
      jepsen_test_name: set

- <<: *run_jepsen_template
  # We only run this test on wiredTiger since MMAPv1 doesn't support majority read concern.
  name: jepsen_read-concern-majority_WT
  commands:
  - func: "do setup"
  - func: "do jepsen setup"
  - func: "run jepsen test"
    vars:
      <<: *jepsen_config_vars
      jepsen_storage_engine: --storage-engine wiredTiger
      jepsen_test_name: read-concern-majority

- <<: *run_jepsen_template
  # We only run this test on wiredTiger since MMAPv1 doesn't support majority read concern.
  name: jepsen_read-concern-majority_w1_WT
  commands:
  - func: "do setup"
  - func: "do jepsen setup"
  - func: "run jepsen test"
    vars:
      <<: *jepsen_config_vars
      jepsen_storage_engine: --storage-engine wiredTiger
      jepsen_test_name: read-concern-majority
      jepsen_write_concern: --write-concern w1

## jstestfuzz standalone aggregation generational fuzzer ##
- <<: *jstestfuzz_template
  name: aggregation_fuzzer
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 50
      npm_command: aggregation-fuzzer
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=generational_fuzzer

## jstestfuzz standalone update generational fuzzer ##
- <<: *jstestfuzz_template
  name: update_fuzzer
  commands:
  - func: "do setup"
  - func: "do multiversion setup"
  - func: "run jstestfuzz"
    vars:
      npm_command: update-fuzzer
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      task_path_suffix: /data/multiversion
      resmoke_args: --suites=generational_fuzzer

## jstestfuzz replication update generational fuzzer ##
- <<: *jstestfuzz_template
  name: update_fuzzer_replication
  commands:
  - func: "do setup"
  - func: "do multiversion setup"
  - func: "run jstestfuzz"
    vars:
      npm_command: update-fuzzer
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      task_path_suffix: /data/multiversion
      resmoke_args: --suites=generational_fuzzer_replication

## rollback generational fuzzer ##
- <<: *jstestfuzz_template
  name: rollback_fuzzer
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 15
      npm_command: rollback-fuzzer
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=rollback_fuzzer

## jstestfuzz ##
- <<: *jstestfuzz_template
  name: jstestfuzz
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz --storageEngine=wiredTiger

## jstestfuzz concurrent ##
- <<: *jstestfuzz_template
  name: jstestfuzz_concurrent
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 75
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz --storageEngine=wiredTiger --numClientsPerFixture=10

## jstestfuzz concurrent replica set ##
- <<: *jstestfuzz_template
  name: jstestfuzz_concurrent_replication
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 75
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_replication --storageEngine=wiredTiger --numClientsPerFixture=10

## jstestfuzz concurrent replica set with logical session ##
- <<: *jstestfuzz_template
  name: jstestfuzz_concurrent_replication_session
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 75
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_replication_session --storageEngine=wiredTiger --numClientsPerFixture=10

## jstestfuzz concurrent sharded cluster ##
- <<: *jstestfuzz_template
  name: jstestfuzz_concurrent_sharded
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 75
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_sharded --storageEngine=wiredTiger --numClientsPerFixture=10

## jstestfuzz concurrent sharded cluster causal consistency ##
- <<: *jstestfuzz_template
  name: jstestfuzz_concurrent_sharded_causal_consistency
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 75
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_sharded_causal_consistency --storageEngine=wiredTiger --numClientsPerFixture=10

## jstestfuzz concurrent sharded cluster continuous stepdown ##
- <<: *jstestfuzz_template
  name: jstestfuzz_concurrent_sharded_continuous_stepdown
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 25
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_sharded_continuous_stepdown --storageEngine=wiredTiger --numClientsPerFixture=10

## jstestfuzz concurrent sharded cluster with logical session ##
- <<: *jstestfuzz_template
  name: jstestfuzz_concurrent_sharded_session
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 75
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_sharded_session --storageEngine=wiredTiger --numClientsPerFixture=10

## jstestfuzz replica set ##
- <<: *jstestfuzz_template
  name: jstestfuzz_replication
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_replication --storageEngine=wiredTiger

## jstestfuzz initial sync replica set ##
- <<: *jstestfuzz_template
  name: jstestfuzz_replication_initsync
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 75
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_replication_initsync --storageEngine=wiredTiger

## jstestfuzz initial sync replica set ##
- <<: *jstestfuzz_template
  name: jstestfuzz_replication_resync
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 75
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_replication_resync --storageEngine=wiredTiger

## jstestfuzz replica set with logical session ##
- <<: *jstestfuzz_template
  name: jstestfuzz_replication_session
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_replication_session --storageEngine=wiredTiger

## jstestfuzz sharded cluster ##
- <<: *jstestfuzz_template
  name: jstestfuzz_sharded
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_sharded --storageEngine=wiredTiger

## jstestfuzz sharded cluster causal consistency ##
- <<: *jstestfuzz_template
  name: jstestfuzz_sharded_causal_consistency
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_sharded_causal_consistency --storageEngine=wiredTiger

## jstestfuzz sharded cluster continuous stepdown ##
- <<: *jstestfuzz_template
  name: jstestfuzz_sharded_continuous_stepdown
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
    vars:
      jstestfuzz_vars: --numGeneratedFiles 50
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_sharded_continuous_stepdown --storageEngine=wiredTiger

## jstestfuzz sharded cluster with logical session ##
- <<: *jstestfuzz_template
  name: jstestfuzz_sharded_session
  commands:
  - func: "do setup"
  - func: "run jstestfuzz"
  - <<: *run_jstestfuzz_tests
    vars:
      <<: *jstestfuzz_config_vars
      resmoke_args: --suites=jstestfuzz_sharded_session --storageEngine=wiredTiger

## integration test suites ##

- <<: *task_template
  name: aggregation
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=aggregation --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: aggregation_ese
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=aggregation_ese --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: aggregation_auth
  depends_on:
  - name: aggregation
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=aggregation_auth --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: aggregation_facet_unwind_passthrough
  depends_on:
  - name: aggregation
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=aggregation_facet_unwind_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: aggregation_mongos_passthrough
  depends_on:
  - name: aggregation
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=aggregation_mongos_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: aggregation_one_shard_sharded_collections
  depends_on:
  - name: aggregation
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=aggregation_one_shard_sharded_collections --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: aggregation_read_concern_majority_passthrough
  depends_on:
  - name: aggregation
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=aggregation_read_concern_majority_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: aggregation_sharded_collections_passthrough
  depends_on:
  - name: aggregation
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=aggregation_sharded_collections_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: audit
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=audit --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: auth
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=auth --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: auth_audit
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=auth_audit --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: change_streams
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=change_streams --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: change_streams_mongos_passthrough
  depends_on:
  - name: change_streams
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=change_streams_mongos_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: change_streams_secondary_reads
  depends_on:
  - name: change_streams
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=change_streams_secondary_reads --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: change_streams_sharded_collections_passthrough
  depends_on:
  - name: change_streams
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=change_streams_sharded_collections_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: dbtest
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=dbtest --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: disk_mmapv1
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=disk_mmapv1 --storageEngine=mmapv1
      run_multiple_jobs: false

- <<: *task_template
  name: disk_mobile
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=disk_mobile --storageEngine=mobile
      run_multiple_jobs: false

- <<: *task_template
  name: disk_wiredtiger
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=disk_wiredtiger --storageEngine=wiredTiger
      run_multiple_jobs: false

- <<: *task_template
  name: durability
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=durability
      run_multiple_jobs: true

- <<: *task_template
  name: dur_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=dur_jscore_passthrough
      run_multiple_jobs: true

- <<: *task_template
  name: ese
  commands:
  - func: "do setup"
  - command: shell.exec
    type: test
    params:
      working_dir: src
      script: |
        set -o errexit
        set -o verbose

        ${activate_virtualenv}
        python -m pip install -r src/mongo/db/modules/enterprise/jstests/encryptdb/libs/requirements.txt
  - func: "run tests"
    vars:
      resmoke_args: --suites=ese --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: failpoints
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=failpoints --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: failpoints_auth
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=failpoints_auth --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: gle_auth
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=gle_auth --shellWriteMode=legacy --shellReadMode=legacy --excludeWithAnyTags=requires_find_command --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: gle_auth_write_cmd
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=gle_auth --shellWriteMode=commands --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: gle_auth_basics_passthrough
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=gle_auth_basics_passthrough --shellWriteMode=legacy --shellReadMode=legacy --storageEngine=wiredTiger --excludeWithAnyTags=requires_find_command
      run_multiple_jobs: true

- <<: *task_template
  name: gle_auth_basics_passthrough_write_cmd
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=gle_auth_basics_passthrough --shellWriteMode=commands --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: integration_tests_standalone
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=integration_tests_standalone --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: integration_tests_replset
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=integration_tests_replset --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: integration_tests_sharded
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=integration_tests_sharded --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: external_auth
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=external_auth --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_gle_auth_basics_passthrough
  depends_on:
  - name: gle_auth_basics_passthrough
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding_gle_auth_basics_passthrough --shellWriteMode=legacy --shellReadMode=legacy --storageEngine=wiredTiger --excludeWithAnyTags=requires_find_command
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_gle_auth_basics_passthrough_write_cmd
  depends_on:
  - name: gle_auth_basics_passthrough_write_cmd
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding_gle_auth_basics_passthrough --shellWriteMode=commands --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=core --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: jsCore_ese
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=core_ese --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: jsCore_compatibility
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=core --shellReadMode=legacy --shellWriteMode=compatibility --storageEngine=wiredTiger --excludeWithAnyTags=requires_find_command
      run_multiple_jobs: true

- <<: *task_template
  name: jsCore_auth
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=core_auth
      run_multiple_jobs: true

- <<: *task_template
  name: jsCore_minimum_batch_size
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=core_minimum_batch_size --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: jsCore_op_query
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=core_op_query --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: replica_sets_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=replica_sets_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: replica_sets_initsync_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=replica_sets_initsync_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: replica_sets_initsync_static_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=replica_sets_initsync_static_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: replica_sets_resync_static_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=replica_sets_resync_static_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: replica_sets_kill_secondaries_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=replica_sets_kill_secondaries_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: mongosTest
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=mongos_test
      run_multiple_jobs: true

- <<: *task_template
  name: mmap
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=mmap
      run_multiple_jobs: true

- <<: *task_template
  name: multiversion_auth
  commands:
  - func: "do setup"
  - func: "do multiversion setup"
  - func: "run tests"
    vars:
      task_path_suffix: /data/multiversion
      resmoke_args: --suites=multiversion_auth --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: multiversion
  commands:
  - func: "do setup"
  - func: "do multiversion setup"
  - func: "run tests"
    vars:
      task_path_suffix: /data/multiversion
      resmoke_args: --suites=multiversion --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: multiversion_multistorage_engine
  commands:
  - func: "do setup"
  - func: "do multiversion setup"
  - func: "run tests"
    vars:
      task_path_suffix: /data/multiversion
      resmoke_args: --suites=multiversion_multistorage_engine
      run_multiple_jobs: true

- <<: *task_template
  name: noPassthrough
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=no_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: noPassthroughWithMongod
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=no_passthrough_with_mongod --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: bulk_gle_passthrough
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=bulk_gle_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: slow1
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=slow1 --storageEngine=wiredTiger
      run_multiple_jobs: false

- <<: *task_template
  name: serial_run
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=serial_run --storageEngine=wiredTiger
      run_multiple_jobs: false

- <<: *task_template
  name: sharded_collections_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharded_collections_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_jscore_op_query_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding_jscore_op_query_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_jscore_passthrough_wire_ops
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding_jscore_passthrough --storageEngine=wiredTiger --shellReadMode=legacy --shellWriteMode=compatibility --excludeWithAnyTags=requires_find_command
      run_multiple_jobs: true

- <<: *task_template
  name: parallel
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=parallel --storageEngine=wiredTiger

- <<: *task_template
  name: parallel_compatibility
  depends_on:
  - name: jsCore_compatibility
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=parallel --shellReadMode=legacy --shellWriteMode=compatibility --storageEngine=wiredTiger --excludeWithAnyTags=requires_find_command

- <<: *task_template
  name: concurrency
  commands:
  - func: "do setup"
  - func: "run tests"
    timeout_secs: 21600 # 6 hour timeout
    vars:
      resmoke_args: --suites=concurrency --storageEngine=wiredTiger

- <<: *task_template
  name: concurrency_replication
  commands:
  - func: "do setup"
  - func: "run tests"
    timeout_secs: 21600 # 6 hour timeout
    vars:
      resmoke_args: --suites=concurrency_replication --storageEngine=wiredTiger

- <<: *task_template
  name: concurrency_sharded
  exec_timeout_secs: 43200 # 12 hour timeout for the task overall
  commands:
  - func: "do setup"
  - func: "run tests"
    timeout_secs: 21600 # 6 hour timeout for each test
    vars:
      resmoke_args: --suites=concurrency_sharded --storageEngine=wiredTiger

- <<: *task_template
  name: concurrency_sharded_causal_consistency
  commands:
  - func: "do setup"
  - func: "run tests"
    timeout_secs: 21600 # 6 hour timeout for each test
    vars:
      resmoke_args: --suites=concurrency_sharded_causal_consistency --storageEngine=wiredTiger

- <<: *task_template
  name: concurrency_sharded_causal_consistency_and_balancer
  commands:
  - func: "do setup"
  - func: "run tests"
    timeout_secs: 21600 # 6 hour timeout for each test
    vars:
      resmoke_args: --suites=concurrency_sharded_causal_consistency_and_balancer --storageEngine=wiredTiger

- <<: *task_template
  name: concurrency_sharded_with_stepdowns
  commands:
  - func: "do setup"
  - func: "run tests"
    timeout_secs: 21600 # 6 hour timeout for each test
    vars:
      resmoke_args: --suites=concurrency_sharded_with_stepdowns --storageEngine=wiredTiger

- <<: *task_template
  name: concurrency_sharded_with_stepdowns_and_balancer
  commands:
  - func: "do setup"
  - func: "run tests"
    timeout_secs: 21600 # 6 hour timeout for each test
    vars:
      resmoke_args: --suites=concurrency_sharded_with_stepdowns_and_balancer --storageEngine=wiredTiger

- <<: *task_template
  name: concurrency_simultaneous
  commands:
  - func: "do setup"
  - func: "run tests"
    timeout_secs: 21600 # 6 hour timeout
    vars:
      resmoke_args: --suites=concurrency jstests/concurrency/fsm_all_simultaneous.js --storageEngine=wiredTiger

- <<: *task_template
  name: rlp
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=rlp --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: read_concern_linearizable_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=read_concern_linearizable_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: read_concern_majority_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=read_concern_majority_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: write_concern_majority_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=write_concern_majority_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: replica_sets
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=replica_sets --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: replica_sets_ese
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=replica_sets_ese --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: replica_sets_auth
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=replica_sets_auth --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: replica_sets_pv0
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=replica_sets_pv0 --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sasl
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sasl --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharding
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_csrs_continuous_config_stepdown
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding_continuous_config_stepdown --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_ese
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding_ese --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_op_query
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding --shellReadMode=legacy --storageEngine=wiredTiger --excludeWithAnyTags=requires_find_command
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_auth
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding_auth --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_auth_audit
  depends_on:
  - name: sharding_auth
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharding_auth_audit --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharding_last_stable_mongos_and_mixed_shards
  commands:
  - func: "do setup"
  - func: "do multiversion setup"
  - func: "run tests"
    vars:
      task_path_suffix: /data/multiversion
      resmoke_args: --suites=sharding_last_stable_mongos_and_mixed_shards
      run_multiple_jobs: true

- <<: *task_template
  name: snmp
  commands:
  - func: "do setup"
  - func: "do snmp setup"
  - func: "run tests"
    vars:
      snmp_config_path: SNMPCONFPATH=snmpconf
      resmoke_args: --suites=snmp --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: ssl
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=ssl --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sslSpecial
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=ssl_special --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: tool
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=tool --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: jsCore_decimal
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=decimal --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: read_only
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=read_only --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: read_only_sharded
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=read_only_sharded --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: session_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=session_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: causally_consistent_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=causally_consistent_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: causally_consistent_jscore_passthrough_auth
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=causally_consistent_jscore_passthrough_auth --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: sharded_causally_consistent_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=sharded_causally_consistent_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: retryable_writes_jscore_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=retryable_writes_jscore_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: retryable_writes_jscore_stepdown_passthrough
  depends_on:
  - name: jsCore
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=retryable_writes_jscore_stepdown_passthrough --storageEngine=wiredTiger
      run_multiple_jobs: true

- <<: *task_template
  name: watchdog_mmapv1
  commands:
  - func: "do setup"
  - func: "do watchdog setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=watchdog --storageEngine=mmapv1
      run_multiple_jobs: false

- <<: *task_template
  name: watchdog_wiredtiger
  commands:
  - func: "do setup"
  - func: "do watchdog setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=watchdog --storageEngine=wiredTiger
      run_multiple_jobs: false

- <<: *task_template
  name: jsonSchema
  commands:
  - func: "do setup"
  - func: "run tests"
    vars:
      resmoke_args: --suites=json_schema --storageEngine=wiredTiger
      run_multiple_jobs: false

- name: powercycle
  exec_timeout_secs: 7200 # 2 hour timeout for the task overall
  depends_on:
  - name: compile
  commands:
  - func: "do setup"
  - func: "set up remote credentials"
    vars:
      <<: *powercycle_remote_credentials
  - func: "set up EC2 instance"
    vars:
      <<: *powercycle_ec2_instance
  - command: expansions.update
    <<: *powercycle_expansions
  - func: "run powercycle test"
    vars:
      <<: *powercycle_test
      mongod_extra_options: --mongodOptions=\"--setParameter enableTestCommands=1 --storageEngine wiredTiger\"

- name: powercycle_fcv3.6
  exec_timeout_secs: 7200 # 2 hour timeout for the task overall
  depends_on:
  - name: compile
  commands:
  - func: "do setup"
  - func: "set up remote credentials"
    vars:
      <<: *powercycle_remote_credentials
  - func: "set up EC2 instance"
    vars:
      <<: *powercycle_ec2_instance
  - command: expansions.update
    <<: *powercycle_expansions
  - func: "run powercycle test"
    vars:
      <<: *powercycle_test
      client_options: --numCrudClients=20 --numFsmClients=20
      mongod_options: --mongodUsablePorts ${standard_port} ${secret_port} --dbPath=${db_path} --logPath=${log_path} --fcv=3.6
      mongod_extra_options: --mongodOptions=\"--setParameter enableTestCommands=1 --storageEngine wiredTiger\"

- name: powercycle_replication
  exec_timeout_secs: 7200 # 2 hour timeout for the task overall
  depends_on:
  - name: compile
  commands:
  - func: "do setup"
  - func: "set up remote credentials"
    vars:
      <<: *powercycle_remote_credentials
  - func: "set up EC2 instance"
    vars:
      <<: *powercycle_ec2_instance
  - command: expansions.update
    <<: *powercycle_expansions
  - func: "run powercycle test"
    vars:
      <<: *powercycle_test
      mongod_extra_options: --replSet=powercyle --mongodOptions=\"--setParameter enableTestCommands=1 --storageEngine wiredTiger\"

- name: powercycle_replication_smalloplog
  exec_timeout_secs: 7200 # 2 hour timeout for the task overall
  depends_on:
  - name: compile
  commands:
  - func: "do setup"
  - func: "set up remote credentials"
    vars:
      <<: *powercycle_remote_credentials
  - func: "set up EC2 instance"
    vars:
      <<: *powercycle_ec2_instance
  - command: expansions.update
    <<: *powercycle_expansions
  - func: "run powercycle test"
    vars:
      <<: *powercycle_test
      mongod_extra_options: --replSet=powercyle --mongodOptions=\"--setParameter enableTestCommands=1 --oplogSize 20 --storageEngine wiredTiger\"

- name: powercycle_syncdelay
  exec_timeout_secs: 7200 # 2 hour timeout for the task overall
  depends_on:
  - name: compile
  commands:
  - func: "do setup"
  - func: "set up remote credentials"
    vars:
      <<: *powercycle_remote_credentials
  - func: "set up EC2 instance"
    vars:
      <<: *powercycle_ec2_instance
  - command: expansions.update
    <<: *powercycle_expansions
  - func: "run powercycle test"
    vars:
      <<: *powercycle_test
      mongod_extra_options: --mongodOptions=\"--setParameter enableTestCommands=1 --syncdelay 10 --storageEngine wiredTiger\"

- name: powercycle_write_concern_majority
  exec_timeout_secs: 7200 # 2 hour timeout for the task overall
  depends_on:
  - name: compile
  commands:
  - func: "do setup"
  - func: "set up remote credentials"
    vars:
      <<: *powercycle_remote_credentials
  - func: "set up EC2 instance"
    vars:
      <<: *powercycle_ec2_instance
  - command: expansions.update
    <<: *powercycle_expansions
  - func: "run powercycle test"
    vars:
      <<: *powercycle_test
      client_options: "--numCrudClients=20 --numFsmClients=20 --writeConcern='{\"w\": \"majority\"}'"
      mongod_extra_options: --mongodOptions \"--setParameter enableTestCommands=1 --storageEngine wiredTiger\"

- name: idl_tests
  depends_on:
  - name: compile
  commands:
  - func: "do setup"
  - func: "run idl tests"

- name: package
  depends_on:
  - name: compile
  commands:
    - func: "fetch artifacts"
    - func: "set up remote credentials"
      vars:
        private_key_file: ~/.ssh/kitchen.pem
        private_key_remote: ${kitchen_private_key}
        aws_key_remote: ${kitchen_aws_key}
        aws_secret_remote: ${kitchen_aws_secret}
    - func: "run kitchen"

- name: push
  patchable: false
  depends_on:
  - name: "*"
  stepback: false
  commands:
    - func: "fetch artifacts"
    - func: "fetch binaries"
    - command: s3.get
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        remote_file: ${mongo_shell}
        bucket: mciuploads
        local_file: src/mongo-shell.tgz
    - command: s3.get
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        remote_file: ${project}/${build_variant}/${revision}/sources/mongo-src-${build_id}.${ext|tgz}
        bucket: mciuploads
        local_file: src/distsrc.${ext|tgz}
        build_variants: [ linux-64, windows-64-2k8-ssl ]
    - *apply_compile_expansions
    - func: "fetch debugsymbols archive"
    - func: "set up remote credentials"
      vars:
        aws_key_remote: ${repo_aws_key}
        aws_secret_remote: ${repo_aws_secret}
    - command: shell.exec
      params:
        working_dir: src
        silent: true
        script: |
          set -o errexit

          cat <<EOF > notary_env.sh
          export NOTARY_TOKEN=${signing_auth_token_38}
          EOF

          echo "${signing_auth_token_38}" > signing_auth_token

    - command: shell.exec
      params:
        working_dir: src
        script: |
          . ./notary_env.sh

          set -o errexit
          set -o verbose

          mv mongo-binaries.tgz mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}
          mv mongo-shell.tgz mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}
          mv mongo-debugsymbols.tgz mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz} || true
          mv distsrc.${ext|tgz} mongodb-src-${src_suffix}.${ext|tar.gz} || true
          /usr/bin/find build/ -type f | grep msi$ | xargs -I original_filename cp original_filename mongodb-win32-${push_arch}-${suffix}.msi || true

          /usr/local/bin/notary-client.py --key-name "server-3.8" --auth-token-file ${workdir}/src/signing_auth_token --comment "Evergreen Automatic Signing ${revision} - ${build_variant} - ${branch_name}" --notary-url http://notary-service.build.10gen.cc:5000 --skip-missing mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz} mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz} mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz} mongodb-win32-${push_arch}-${suffix}.msi mongodb-src-${src_suffix}.${ext|tar.gz}

          if [ "${has_packages|}" = "true" ]; then
             CURATOR_RELEASE="ea8d75dcc1a587111e7418e2428fb67e267af9fe"
             curl -L -O http://boxes.10gen.com/build/curator/curator-dist-rhel70-$CURATOR_RELEASE.tar.gz
             tar -zxvf curator-dist-rhel70-$CURATOR_RELEASE.tar.gz
             ./curator repo --config ./etc/repo_config.yaml --distro ${packager_distro} --edition ${repo_edition} --version ${version} --arch ${packager_arch} --packages repo
          fi

    # Put the binaries tarball/zipfile
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}
        aws_key: ${aws_key}
        bucket: build-push-testing
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}
    # Put the shell tarball/zipfile
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}
        aws_key: ${aws_key}
        bucket: build-push-testing
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-shell-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}
    # Put the source tarball
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-src-${src_suffix}.${ext|tar.gz}
        aws_key: ${aws_key}
        bucket: build-push-testing
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-src-${src_suffix}-${task_id}.${ext|tar.gz}
        build_variants: [ linux-64, windows-64-2k8-ssl ]

    # Put the debug symbols
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        aws_key: ${aws_key}
        permissions: public-read
        local_file: src/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz}
        bucket: build-push-testing
        content_type: ${content_type|application/x-gzip}
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}-${task_id}.${ext|tgz}
        optional: true

    # Put the binaries tarball signature
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sig
        aws_key: ${aws_key}
        bucket: build-push-testing
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sig

    # Put the shell tarball signature
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sig
        aws_key: ${aws_key}
        bucket: build-push-testing
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-shell-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sig

    # Put the source tarball signature
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-src-${src_suffix}.${ext|tar.gz}.sig
        aws_key: ${aws_key}
        bucket: build-push-testing
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-src-${src_suffix}-${task_id}.${ext|tar.gz}.sig
        build_variants: [ linux-64, windows-64-2k8-ssl ]

    # Put the debug symbols signature
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        aws_key: ${aws_key}
        permissions: public-read
        local_file: src/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz}.sig
        bucket: build-push-testing
        content_type: ${content_type|application/x-gzip}
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}-${task_id}.${ext|tgz}.sig
        optional: true

    # Put the signed MSI file
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        permissions: public-read
        build_variants: ["enterprise-windows-64-2k8", "windows-64-2k8-ssl"]
        local_file: src/mongodb-win32-${push_arch}-${suffix}-signed.msi
        bucket: build-push-testing
        content_type: application/x-msi
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-win32-${push_arch}-${suffix}-${task_id}-signed.msi

    # Put the binaries tarball sha1
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sha1
        aws_key: ${aws_key}
        permissions: public-read
        bucket: build-push-testing
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sha1

    # Put the shell tarball sha1
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sha1
        aws_key: ${aws_key}
        permissions: public-read
        bucket: build-push-testing
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-shell-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sha1

    # Put the source tarball sha1
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-src-${src_suffix}.${ext|tar.gz}.sha1
        aws_key: ${aws_key}
        permissions: public-read
        bucket: build-push-testing
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-src-${src_suffix}-${task_id}.${ext|tar.gz}.sha1
        build_variants: [ linux-64, windows-64-2k8-ssl ]

    # Put the debug symbols sha1
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        aws_key: ${aws_key}
        permissions: public-read
        local_file: src/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz}.sha1
        bucket: build-push-testing
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}-${task_id}.${ext|tgz}.sha1
        optional: true

    # Push the signed MSI sha1
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        permissions: public-read
        build_variants: ["enterprise-windows-64-2k8", "windows-64-2k8-ssl"]
        local_file: src/mongodb-win32-${push_arch}-${suffix}-signed.msi.sha1
        bucket: build-push-testing
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-win32-${push_arch}-${suffix}-${task_id}-signed.msi.sha1

    # Put the binaries tarball sha256
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sha256
        permissions: public-read
        aws_key: ${aws_key}
        bucket: build-push-testing
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sha256

    # Put the shell tarball sha256
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sha256
        permissions: public-read
        aws_key: ${aws_key}
        bucket: build-push-testing
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-shell-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sha256

    # Put the source tarball sha256
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-src-${src_suffix}.${ext|tar.gz}.sha256
        permissions: public-read
        aws_key: ${aws_key}
        bucket: build-push-testing
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-src-${src_suffix}-${task_id}.${ext|tar.gz}.sha256
        build_variants: [ linux-64, windows-64-2k8-ssl ]

    # Put the debug symbols sha256
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz}.sha256
        aws_key: ${aws_key}
        bucket: build-push-testing
        permissions: public-read
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}-${task_id}.${ext|tgz}.sha256
        optional: true

    # Put the signed MSI sha256
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        build_variants: ["enterprise-windows-64-2k8", "windows-64-2k8-ssl"]
        local_file: src/mongodb-win32-${push_arch}-${suffix}-signed.msi.sha256
        bucket: build-push-testing
        permissions: public-read
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-win32-${push_arch}-${suffix}-${task_id}-signed.msi.sha256
        content_type: text/plain

    # Put the binaries tarball md5
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}.md5
        aws_key: ${aws_key}
        bucket: build-push-testing
        permissions: public-read
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.md5

    # Put the shell tarball md5
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}.md5
        aws_key: ${aws_key}
        bucket: build-push-testing
        permissions: public-read
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-shell-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.md5

    # Put the source tarball md5
    - command: s3.put
      params:
        aws_secret: ${aws_secret}
        local_file: src/mongodb-src-${src_suffix}.${ext|tar.gz}.md5
        aws_key: ${aws_key}
        bucket: build-push-testing
        permissions: public-read
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-src-${src_suffix}-${task_id}.${ext|tar.gz}.md5
        build_variants: [ linux-64, windows-64-2k8-ssl ]

    # Put the debug symbols md5
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: src/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz}.md5
        bucket: build-push-testing
        content_type: text/plain
        permissions: public-read
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}-${task_id}.${ext|tgz}.md5
        optional: true

    # Put the signed MSI md5
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        build_variants: ["enterprise-windows-64-2k8", "windows-64-2k8-ssl"]
        local_file: src/mongodb-win32-${push_arch}-${suffix}-signed.msi.md5
        bucket: build-push-testing
        permissions: public-read
        content_type: text/plain
        remote_file: ${push_path}-STAGE/${push_name}/mongodb-win32-${push_arch}-${suffix}-${task_id}-signed.msi.md5

    - command: s3Copy.copy
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        s3_copy_files:
            #Binaries
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}', 'bucket': '${push_bucket}'}}

            #Shell
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-shell-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}', 'bucket': '${push_bucket}'}}

            #Source tarball
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-src-${src_suffix}-${task_id}.${ext|tar.gz}', 'bucket': 'build-push-testing'},
               'destination': {'path': 'src/mongodb-src-${src_suffix}.${ext|tar.gz}', 'bucket': '${push_bucket}'},
               'build_variants': [ 'linux-64', 'windows-64-2k8-ssl' ]}

            #MSI (Windows only)
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-win32-${push_arch}-${suffix}-${task_id}-signed.msi', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-win32-${push_arch}-${suffix}-signed.msi', 'bucket': '${push_bucket}'},
               'build_variants': [ 'enterprise-windows-64-2k8', 'windows-64-2k8-ssl' ]}

            #Binaries Signature
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sig', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sig', 'bucket': '${push_bucket}'}}

            #Shell Signature
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-shell-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sig', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sig', 'bucket': '${push_bucket}'}}

            #Source tarball signature
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-src-${src_suffix}-${task_id}.${ext|tar.gz}.sig', 'bucket': 'build-push-testing'},
               'destination': {'path': 'src/mongodb-src-${src_suffix}.${ext|tar.gz}.sig', 'bucket': '${push_bucket}'},
               'build_variants': [ 'linux-64', 'windows-64-2k8-ssl' ]}

            #SHA1 for binaries
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sha1', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sha1', 'bucket': '${push_bucket}'}}

            #SHA1 for shell
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-shell-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sha1', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sha1', 'bucket': '${push_bucket}'}}

            #SHA1 for source tarball
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-src-${src_suffix}-${task_id}.${ext|tar.gz}.sha1', 'bucket': 'build-push-testing'},
               'destination': {'path': 'src/mongodb-src-${src_suffix}.${ext|tar.gz}.sha1', 'bucket': '${push_bucket}'},
               'build_variants': [ 'linux-64', 'windows-64-2k8-ssl' ]}

            #SHA1 for MSI
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-win32-${push_arch}-${suffix}-${task_id}-signed.msi.sha1', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-win32-${push_arch}-${suffix}-signed.msi.sha1', 'bucket': '${push_bucket}'},
               'build_variants': ['enterprise-windows-64-2k8', 'windows-64-2k8-ssl']}

            #SHA256 for binaries
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sha256', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sha256', 'bucket': '${push_bucket}'}}

            #SHA256 for shell
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-shell-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.sha256', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}.sha256', 'bucket': '${push_bucket}'}}

            #SHA256 for source tarball
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-src-${src_suffix}-${task_id}.${ext|tar.gz}.sha256', 'bucket': 'build-push-testing'},
               'destination': {'path': 'src/mongodb-src-${src_suffix}.${ext|tar.gz}.sha256', 'bucket': '${push_bucket}'},
               'build_variants': [ 'linux-64', 'windows-64-2k8-ssl' ]}

            #SHA256 for MSI files
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-win32-${push_arch}-${suffix}-${task_id}-signed.msi.sha256', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-win32-${push_arch}-${suffix}-signed.msi.sha256', 'bucket': '${push_bucket}'},
               'build_variants': ['enterprise-windows-64-2k8', 'windows-64-2k8-ssl']}

            #MD5 for binaries
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.md5', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-${push_name}-${push_arch}-${suffix}.${ext|tgz}.md5', 'bucket': '${push_bucket}'}}

            #MD5 for shell
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-shell-${push_name}-${push_arch}-${suffix}-${task_id}.${ext|tgz}.md5', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-shell-${push_name}-${push_arch}-${suffix}.${ext|tgz}.md5', 'bucket': '${push_bucket}'}}

            #MD5 for source tarball
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-src-${src_suffix}-${task_id}.${ext|tar.gz}.md5', 'bucket': 'build-push-testing'},
               'destination': {'path': 'src/mongodb-src-${src_suffix}.${ext|tar.gz}.md5', 'bucket': '${push_bucket}'},
               'build_variants': [ 'linux-64', 'windows-64-2k8-ssl' ]}

            #MD5 for MSIs
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-win32-${push_arch}-${suffix}-${task_id}-signed.msi.md5', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-win32-${push_arch}-${suffix}-signed.msi.md5', 'bucket': '${push_bucket}'},
               'build_variants': ['enterprise-windows-64-2k8', 'windows-64-2k8-ssl'], }

    # Debug symbols are not created for all variants and the copy is optional.
    - command: s3Copy.copy
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        optional: true
        s3_copy_files:
            #Debug Symbols
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}-${task_id}.${ext|tgz}', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz}', 'bucket': '${push_bucket}'}}

            #Debug Symbols Signature
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}-${task_id}.${ext|tgz}.sig', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz}.sig', 'bucket': '${push_bucket}'}}

            #SHA1 for debug symbols
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}-${task_id}.${ext|tgz}.sha1', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz}.sha1', 'bucket': '${push_bucket}'}}

            #SHA256 for debugsymbols
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}-${task_id}.${ext|tgz}.sha256', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz}.sha256', 'bucket': '${push_bucket}'}}

            #MD5 for debugsymbols
            - {'source': {'path': '${push_path}-STAGE/${push_name}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}-${task_id}.${ext|tgz}.md5', 'bucket': 'build-push-testing'},
               'destination': {'path': '${push_path}/mongodb-${push_name}-${push_arch}-debugsymbols-${suffix}.${ext|tgz}.md5', 'bucket': '${push_bucket}'}}

- name: fetch_test_lifecycle
  depends_on: []
  commands:
  - *git_get_project
  - func: "fetch test_lifecycle.yml"
    vars:
      # This task is meant to fail if there is an error while fetching test_lifecycle.yml since
      # the compile task won't fail.
      fail_task_on_error: true

- name: update_test_lifecycle
  exec_timeout_secs: 21600 # 6 hour timeout for the task overall
  depends_on: []
  commands:
  - *git_get_project
  - command: shell.exec
    timeout_secs: 14400 # Timeout if there is no output for 4 hours
    type: test
    params:
      working_dir: src
      script: |
        set -o errexit

        # Set up the git ssh private key
        mkdir -p ~/.ssh
        echo -n "${testlifecycle_ssh_key}" > ~/.ssh/test_lifecycle.pem
        chmod 0600 ~/.ssh/test_lifecycle.pem
        export GIT_SSH_COMMAND="ssh -i ~/.ssh/test_lifecycle.pem"

        # Create the jira credentials configuration file
        cat > ~/.jira.yml <<END_OF_CREDS
        server: "https://jira.mongodb.org"
        access_token: "${testlifecycle_jira_access_token}"
        access_token_secret: "${testlifecycle_jira_access_token_secret}"
        consumer_key: "${testlifecycle_jira_consumer_key}"
        key_cert: |
        $(echo "${testlifecycle_jira_key_certificate}" | sed  's/^/  /')
        END_OF_CREDS

        set -o verbose

        ${activate_virtualenv}
        # Install Python modules to support OAuth with pip until it is available in the toolchain.
        pip install cryptography==1.7.2 pyjwt==1.5.3

        # We use a small batch size to avoid hitting the load balancer timeout if the Evergreen
        # API query is not fast enough.
        $python buildscripts/update_test_lifecycle.py                   \
            --project ${project}                                        \
            --requestBatchSize 20                                       \
            --commit                                                    \
            --resmokeTagFile "etc/test_lifecycle.yml"                   \
            --metadataRepo "git@github.com:mongodb/mongo-test-metadata" \
            --referencesFile "references.yml"                           \
            --gitUserName "Test Lifecycle"                              \
            --gitUserEmail "build+testlifecycle@mongodb.com"            \
            --jiraConfig ~/.jira.yml


#######################################
#               Modules               #
#######################################
# if a module is added and to be added to the manifest
# be sure to add the module to git.get_project revisions parameter
modules:
- name: enterprise
  repo: git@github.com:10gen/mongo-enterprise-modules.git
  prefix: src/mongo/db/modules
  branch: master

- name: rocksdb
  repo: git@github.com:mongodb-partners/mongo-rocks.git
  prefix: src/mongo/db/modules
  branch: master

- name: wtdevelop
  repo: git@github.com:wiredtiger/wiredtiger.git
  prefix: src/third_party
  branch: develop

#######################################
#            Buildvariants            #
#######################################

buildvariants:

###########################################
#         Linux buildvariants             #
###########################################

- name: linux-64
  display_name: Linux
  run_on:
  - rhel62-small
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64
    compile_flags: -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars --release
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel62-large
  - name: compile_all
    distros:
    - rhel62-large
  - name: aggregation
  - name: aggregation_auth
  - name: aggregation_mongos_passthrough
  - name: aggregation_one_shard_sharded_collections
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: auth
  - name: change_streams
  - name: change_streams_mongos_passthrough
  - name: change_streams_secondary_reads
  - name: change_streams_sharded_collections_passthrough
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: integration_tests_standalone
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_op_query
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion_auth
  - name: multiversion
  - name: multiversion_multistorage_engine
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: slow1
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: tool
  - name: write_concern_majority_passthrough
  - name: push

- name: linux-64-repeated-execution
  stepback: false
  display_name: ~ Linux Repeated Execution
  run_on:
  - rhel62-small
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    compile_flags: -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    test_flags: --repeat=10 --shuffle
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel62-large
  - name: compile_all
    distros:
    - rhel62-large
  - name: dbtest
  - name: integration_tests_standalone
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: jsCore
  - name: parallel
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous

- &linux-64-debug-template
  name: linux-64-debug
  display_name: "! Linux DEBUG"
  run_on:
  - rhel62-large
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux-debug
    push_arch: x86_64
    num_jobs_available: $(($(grep -c ^processor /proc/cpuinfo) / 2)) # Avoid starting too many mongod's
    compile_flags: --dbg=on --opt=on -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
  - name: compile_all
  - name: aggregation
  - name: aggregation_auth
  - name: aggregation_facet_unwind_passthrough
  - name: aggregation_mongos_passthrough
  - name: aggregation_one_shard_sharded_collections
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: auth
  - name: bulk_gle_passthrough
  - name: causally_consistent_jscore_passthrough
  - name: causally_consistent_jscore_passthrough_auth
  - name: change_streams
  - name: change_streams_mongos_passthrough
  - name: change_streams_sharded_collections_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_sharded_causal_consistency
  - name: concurrency_sharded_causal_consistency_and_balancer
  - name: concurrency_sharded_with_stepdowns
  - name: concurrency_sharded_with_stepdowns_and_balancer
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsonSchema
  - name: mongosTest
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_initsync_jscore_passthrough
  - name: replica_sets_initsync_static_jscore_passthrough
  - name: replica_sets_jscore_passthrough
  - name: replica_sets_kill_secondaries_jscore_passthrough
  - name: replica_sets_resync_static_jscore_passthrough
  - name: replica_sets_pv0
  - name: retryable_writes_jscore_passthrough
  - name: retryable_writes_jscore_stepdown_passthrough
  - name: serial_run
  - name: session_jscore_passthrough
  - name: sharded_causally_consistent_jscore_passthrough
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: slow1
  - name: tool
  - name: write_concern_majority_passthrough

- <<: *linux-64-debug-template
  name: linux-64-debug-wtdevelop
  display_name: "~ Linux DEBUG WiredTiger develop"
  batchtime: 1440 # 1 day
  modules:
  - wtdevelop
  expansions:
    use_wt_develop: true
    num_jobs_available: $(($(grep -c ^processor /proc/cpuinfo) / 2)) # Avoid starting too many mongod's
    compile_flags: --dbg=on --opt=on -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    use_scons_cache: true
    build_mongoreplay: true

- name: linux-64-duroff
  display_name: Linux (No Journal)
  run_on:
  - rhel62-small
  batchtime: 1440 # 1 day
  expansions:
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux-duroff
    push_arch: x86_64
    compile_flags: -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    # Running WiredTiger with --nojournal in a replica set is no longer supported,
    # so this variant does not include replica set tests.
    test_flags: --nojournal --excludeWithAnyTags=requires_journaling,requires_replication,requires_mmapv1
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel62-large
  - name: compile_all
    distros:
    - rhel62-large
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_sharded
  - name: mongosTest

- name: linux-64-lsm
  stepback: false
  display_name: Linux LSM
  run_on:
  - rhel62-small
  batchtime: 1440 # 1 day
  expansions:
    compile_flags: -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    test_flags: --wiredTigerCollectionConfig=type=lsm --wiredTigerIndexConfig=type=lsm --excludeWithAnyTags=requires_mmapv1
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel62-large
  - name: compile_all
    distros:
    - rhel62-large
  - name: aggregation
  - name: auth
  - name: dbtest
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_compatibility
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: slow1
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: tool

- name: ubuntu1204
  display_name: SSL Ubuntu 12.04
  run_on:
  - ubuntu1204-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    tooltags: "-tags ssl"
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64-ubuntu1204
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1204 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    multiversion_platform: ubuntu1204
    multiversion_edition: targeted
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager.py
    packager_arch: x86_64
    packager_distro: ubuntu1204
    repo_edition: org
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1204-build
  - name: compile_all
    distros:
    - ubuntu1204-build
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: slow1
  - name: serial_run
  - name: sharding_jscore_passthrough
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

- name: ubuntu1404
  display_name: SSL Ubuntu 14.04
  run_on:
  - ubuntu1404-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    tooltags: "-tags ssl"
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64-ubuntu1404
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1404 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    multiversion_platform: ubuntu1404
    multiversion_edition: targeted
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager.py
    packager_arch: x86_64
    packager_distro: ubuntu1404
    repo_edition: org
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1404-build
  - name: compile_all
    distros:
    - ubuntu1404-build
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jepsen_register_findAndModify_WT
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_register_linearizableRead
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_register_linearizableRead_WT
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_set_linearizableRead
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_set_linearizableRead_WT
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_read-concern-majority_WT
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_read-concern-majority_w1_WT
    distros:
    - ubuntu1404-jepsen
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: powercycle
  - name: powercycle_fcv3.6
  - name: powercycle_replication
  - name: powercycle_replication_smalloplog
  - name: powercycle_syncdelay
  - name: powercycle_write_concern_majority
  - name: sharding
  - name: sharding_auth
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: slow1
  - name: serial_run
  - name: sharding_jscore_passthrough
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

- name: ubuntu1604
  display_name: SSL Ubuntu 16.04
  run_on:
  - ubuntu1604-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    tooltags: "-tags ssl"
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64-ubuntu1604
    lang_environment: LANG=C
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1604 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    multiversion_platform: ubuntu1604
    multiversion_edition: targeted
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager.py
    packager_arch: x86_64
    packager_distro: ubuntu1604
    repo_edition: org
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1604-build
  - name: compile_all
    distros:
    - ubuntu1604-build
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: slow1
  - name: serial_run
  - name: sharding_jscore_passthrough
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

- name: enterprise-ubuntu1604-arm64
  display_name: Enterprise Ubuntu 16.04 arm64
  modules:
  - enterprise
  run_on:
  - ubuntu1604-arm64-small
  - ubuntu1604-arm64-large
  batchtime: 1440 # 1 day
  expansions:
    gorootvars: PATH=/opt/mongodbtoolchain/v2/bin:$PATH
    tooltags: -gccgoflags "$(pkg-config --libs --cflags libssl libcrypto libsasl2)" -tags 'sasl ssl'
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: arm64-enterprise-ubuntu1604
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1604 -j$(grep -c ^processor /proc/cpuinfo) CCFLAGS="-march=armv8-a+crc -mtune=generic" --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    max_jobs: 8 # Avoid starting too many mongod's on ARM test servers
    test_flags: --excludeWithAnyTags=requires_mmapv1
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: arm64
    packager_distro: ubuntu1604
    repo_edition: enterprise
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1604-arm64-large
  - name: compile_all
    distros:
    - ubuntu1604-arm64-large
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
    distros:
    # There is a known performance issue with the ubuntu1604-arm64-1.linaro.build.10gen.cc host
    # that's part of the ubuntu1604-arm64-large pool. We run the concurrency tests only on the
    # hosts from the ubuntu1604-arm64-small pool to work around this issue.
    - ubuntu1604-arm64-small
  - name: concurrency_replication
    distros:
    - ubuntu1604-arm64-small
  - name: concurrency_sharded
    distros:
    - ubuntu1604-arm64-small
  - name: concurrency_simultaneous
    distros:
    - ubuntu1604-arm64-small
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: slow1
  - name: serial_run
  - name: sharding_jscore_passthrough
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: push
    distros:
    - ubuntu1604-test

- name: ubuntu1604-arm64
  display_name: SSL Ubuntu 16.04 arm64
  run_on:
  - ubuntu1604-arm64-small
  - ubuntu1604-arm64-large
  batchtime: 1440 # 1 day
  expansions:
    gorootvars: PATH=/opt/mongodbtoolchain/v2/bin:$PATH
    tooltags: -gccgoflags "$(pkg-config --libs --cflags libssl libcrypto)" -tags 'ssl'
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: arm64-ubuntu1604
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1604 -j$(grep -c ^processor /proc/cpuinfo) --release CCFLAGS="-march=armv8-a+crc -mtune=generic" --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    max_jobs: 8 # Avoid starting too many mongod's on ARM test servers
    test_flags: --excludeWithAnyTags=requires_mmapv1
    has_packages: true
    packager_script: packager.py
    packager_arch: arm64
    packager_distro: ubuntu1604
    repo_edition: org
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1604-arm64-large
  - name: compile_all
    distros:
    - ubuntu1604-arm64-large
  - name: dbtest
  - name: jsCore
  - name: push
    distros:
    - ubuntu1604-test

- name: enterprise-ubuntu1604-ppc64le
  display_name: Enterprise Ubuntu 16.04 PPC64LE
  modules:
  - enterprise
  run_on:
  - ubuntu1604-power8-build
  - ubuntu1604-power8-test
  batchtime: 1440 # 1 day
  expansions:
    gorootvars: PATH=/opt/mongodbtoolchain/v2/bin:$PATH
    tooltags: -gccgoflags "$(pkg-config --libs --cflags libssl libsasl2 libcrypto)" -tags 'sasl ssl'
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: ppc64le-enterprise-ubuntu1604
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1604 -j$(echo "$(grep -c processor /proc/cpuinfo)/2" | bc) --release CCFLAGS="-mcpu=power8 -mtune=power8 -mcmodel=medium" --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: 2
    test_flags: --excludeWithAnyTags=requires_mmapv1
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: ppc64le
    packager_distro: ubuntu1604
    repo_edition: enterprise
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1604-power8-build
  - name: compile_all
    distros:
    - ubuntu1604-power8-build
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: slow1
  - name: serial_run
  - name: sharding_jscore_passthrough
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: push
    distros:
    - ubuntu1604-test

- name: enterprise-ubuntu1604-s390x
  display_name: Enterprise Ubuntu 16.04 s390x
  modules:
  - enterprise
  run_on:
  - ubuntu1604-zseries-large
  - ubuntu1604-zseries-small
  batchtime: 1440 # 1 day
  stepback: false
  expansions:
    gorootvars: PATH=/opt/mongodbtoolchain/v2/bin:$PATH
    tooltags: -gccgoflags "$(pkg-config --libs --cflags libssl libcrypto libsasl2)" -tags 'sasl ssl'
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: s390x-enterprise-ubuntu1604
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1604 --release -j3 CCFLAGS="-march=z196 -mtune=zEC12" --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: 2
    test_flags: --excludeWithAnyTags=requires_mmapv1
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: s390x
    packager_distro: ubuntu1604
    repo_edition: enterprise
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1604-zseries-large
  - name: compile_all
    distros:
    - ubuntu1604-zseries-large
  - name: aggregation
  - name: aggregation_ese
  - name: aggregation_auth
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: dbtest
  - name: ese
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_op_query
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: replica_sets
  - name: replica_sets_ese
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: sasl
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_ese
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_csrs_continuous_config_stepdown
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: write_concern_majority_passthrough
  - name: push
    distros:
    - ubuntu1604-test

- name: enterprise-linux-64-amazon-ami
  display_name: "Enterprise Amazon Linux"
  modules:
  - enterprise
  run_on:
  - linux-64-amzn-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    tooltags: "-tags 'ssl sasl'"
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: x86_64-enterprise-amzn64
    compile_flags: --ssl MONGO_DISTMOD=amzn64 --release -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: amazon
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - linux-64-amzn-build
  - name: compile_all
    distros:
    - linux-64-amzn-build
  - name: aggregation_auth
  - name: aggregation
  - name: audit
  - name: auth
  - name: auth_audit
  - name: dbtest
  - name: ese
  - name: failpoints_auth
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_auth
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: replica_sets_auth
  - name: replica_sets_ese
  - name: powercycle
  - name: sasl
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_ese
  - name: slow1
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

- name: amazon
  display_name: SSL Amazon Linux
  run_on:
  - linux-64-amzn-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    tooltags: "-tags 'ssl'"
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64-amazon
    compile_flags: --ssl MONGO_DISTMOD=amazon -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    multiversion_platform: amzn64
    multiversion_edition: enterprise
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager.py
    packager_arch: x86_64
    packager_distro: amazon
    repo_edition: org
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - linux-64-amzn-build
  - name: compile_all
    distros:
    - linux-64-amzn-build
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: slow1
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

###########################################
#         Windows buildvariants           #
###########################################

- name: windows-64-2k8-debug
  display_name: "* Windows 2008R2 DEBUG"
  run_on:
  - windows-64-vs2015-small
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    platform_decompress: unzip
    exe: ".exe"
    push_path: win32
    push_bucket: downloads.mongodb.org
    push_name: win32-debug
    push_arch: x86_64-2008plus
    content_type: application/zip
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    compile_flags: --dbg=on --opt=on --win-version-min=ws08r2 -j$(( $(grep -c ^processor /proc/cpuinfo) / 2 )) MONGO_DISTMOD=2008plus
    # We invoke SCons using --jobs = (# of CPUs / 4) to avoid causing out of memory errors due to
    # spawning a large number of linker processes.
    num_scons_compile_all_jobs_available: $(( $(grep -c ^processor /proc/cpuinfo) / 4 ))
    python: python
    ext: zip
    use_scons_cache: true
  tasks:
  - name: compile
    distros:
    - windows-64-vs2015-large
  - name: compile_all
    distros:
    - windows-64-vs2015-large
  - name: aggregation
  - name: aggregation_facet_unwind_passthrough
  - name: aggregation_mongos_passthrough
  - name: aggregation_one_shard_sharded_collections
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: auth
  - name: causally_consistent_jscore_passthrough
  - name: causally_consistent_jscore_passthrough_auth
  - name: sharded_causally_consistent_jscore_passthrough
  - name: change_streams
  - name: change_streams_mongos_passthrough
  - name: change_streams_sharded_collections_passthrough
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: integration_tests_standalone
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: jsCore
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsonSchema
  - name: mongosTest
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: rollback_fuzzer
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
    # Some concurrency workloads require a lot of memory, so we use machines
    # with more RAM for these suites.
  - name: concurrency
    distros:
    - windows-64-vs2015-large
  - name: concurrency_replication
    distros:
    - windows-64-vs2015-large
  - name: concurrency_sharded
    distros:
    - windows-64-vs2015-large
  - name: concurrency_sharded_causal_consistency
    distros:
    - windows-64-vs2015-large
  - name: concurrency_sharded_causal_consistency_and_balancer
    distros:
    - windows-64-vs2015-large
  - name: concurrency_sharded_with_stepdowns
    distros:
    - windows-64-vs2015-large
  - name: concurrency_sharded_with_stepdowns_and_balancer
    distros:
    - windows-64-vs2015-large
  - name: concurrency_simultaneous
    distros:
    - windows-64-vs2015-large
  - name: read_concern_linearizable_passthrough
    distros:
    - windows-64-vs2015-large
  - name: read_concern_majority_passthrough
    distros:
    - windows-64-vs2015-large
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
    distros:
    - windows-64-vs2015-large
  - name: replica_sets_jscore_passthrough
    distros:
    - windows-64-vs2015-large
  - name: replica_sets_initsync_jscore_passthrough
    distros:
    - windows-64-vs2015-large
  - name: replica_sets_initsync_static_jscore_passthrough
    distros:
    - windows-64-vs2015-large
  - name: replica_sets_resync_static_jscore_passthrough
    distros:
    - windows-64-vs2015-large
  - name: replica_sets_kill_secondaries_jscore_passthrough
    distros:
    - windows-64-vs2015-large
  - name: retryable_writes_jscore_passthrough
    distros:
    - windows-64-vs2015-large
  - name: retryable_writes_jscore_stepdown_passthrough
    distros:
    - windows-64-vs2015-large
  - name: session_jscore_passthrough
  - name: sharding
    distros:
    - windows-64-vs2015-large
  - name: tool
  - name: write_concern_majority_passthrough
    distros:
    - windows-64-vs2015-large

- &enterprise-windows-64-2k8-template
  name: enterprise-windows-64-2k8
  display_name: "! Enterprise Windows 2008R2"
  modules:
  - enterprise
  run_on:
  - windows-64-vs2015-small
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    platform_decompress: unzip
    tooltags: "-tags 'ssl sasl'"
    exe: ".exe"
    gorootvars: 'PATH="/cygdrive/c/mingw-w64/x86_64-4.9.1-posix-seh-rt_v3-rev1/mingw64/bin:/cygdrive/c/sasl/:$PATH" CGO_CFLAGS="-D_WIN32_WINNT=0x0601 -DNTDDI_VERSION=0x06010000"'
    push_path: win32
    push_bucket: downloads.10gen.com
    push_name: win32
    push_arch: x86_64-enterprise-windows-64
    msi_target: msi
    content_type: application/zip
    compile_flags: --release --ssl MONGO_DISTMOD=windows-64 CPPPATH="c:/openssl/include c:/sasl/include c:/snmp/include c:/curl/include" LIBPATH="c:/openssl/lib c:/sasl/lib c:/snmp/lib c:/curl/lib" -j$(( $(grep -c ^processor /proc/cpuinfo) / 2 )) --dynamic-windows --win-version-min=ws08r2
    # We invoke SCons using --jobs = (# of CPUs / 4) to avoid causing out of memory errors due to
    # spawning a large number of linker processes.
    num_scons_compile_all_jobs_available: $(( $(grep -c ^processor /proc/cpuinfo) / 4 ))
    python: python
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    ext: zip
    use_scons_cache: true
  tasks:
  - name: compile
    requires:
    - name: burn_in_tests
    distros:
    - windows-64-vs2015-large
  - name: compile_all
    distros:
    - windows-64-vs2015-large
  - name: burn_in_tests
  - name: audit
  - name: auth_audit
  - name: dbtest
  - name: ese
  - name: external_auth
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_decimal
  - name: sharding_ese
    distros:
    - windows-64-vs2015-large
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: replica_sets_auth
  - name: replica_sets_ese
  - name: sasl
  - name: sharding_auth
    distros:
    - windows-64-vs2015-large
  - name: sharding_auth_audit
    distros:
    - windows-64-vs2015-large
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: push
    distros:
    - rhel70-small

- <<: *enterprise-windows-64-2k8-template
  name: enterprise-windows-64-2k8-wtdevelop
  display_name: "~ Enterprise Windows 2008R2 WiredTiger develop"
  batchtime: 1440 # 1 day
  modules:
  - enterprise
  - wtdevelop
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    use_wt_develop: true
    platform_decompress: unzip
    tooltags: "-tags 'ssl sasl'"
    exe: ".exe"
    gorootvars: 'PATH="/cygdrive/c/mingw-w64/x86_64-4.9.1-posix-seh-rt_v3-rev1/mingw64/bin:/cygdrive/c/sasl/:$PATH" CGO_CFLAGS="-D_WIN32_WINNT=0x0601 -DNTDDI_VERSION=0x06010000"'
    msi_target: msi
    content_type: application/zip
    compile_flags: --release --ssl MONGO_DISTMOD=windows-64 CPPPATH="c:/openssl/include c:/sasl/include c:/snmp/include c:/curl/include" LIBPATH="c:/openssl/lib c:/sasl/lib c:/snmp/lib c:/curl/lib" -j$(( $(grep -c ^processor /proc/cpuinfo) / 2 )) --dynamic-windows --win-version-min=ws08r2
    # We invoke SCons using --jobs = (# of CPUs / 4) to avoid causing out of memory errors due to
    # spawning a large number of linker processes.
    num_scons_compile_all_jobs_available: $(( $(grep -c ^processor /proc/cpuinfo) / 4 ))
    python: python
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    ext: zip
    use_scons_cache: true

- name: enterprise-windows-64-2k8-async
  display_name: "~ Enterprise Windows 2008R2 async"
  modules:
  - enterprise
  run_on:
  - windows-64-vs2015-small
  stepback: true
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    platform_decompress: unzip
    tooltags: "-tags 'ssl sasl'"
    exe: ".exe"
    gorootvars: 'PATH="/cygdrive/c/mingw-w64/x86_64-4.9.1-posix-seh-rt_v3-rev1/mingw64/bin:/cygdrive/c/sasl/:$PATH" CGO_CFLAGS="-D_WIN32_WINNT=0x0601 -DNTDDI_VERSION=0x06010000"'
    push_path: win32
    push_bucket: downloads.10gen.com
    push_name: win32
    push_arch: x86_64-enterprise-windows-64
    msi_target: msi
    content_type: application/zip
    compile_flags: --release --ssl MONGO_DISTMOD=windows-64 CPPPATH="c:/openssl/include c:/sasl/include c:/snmp/include c:/curl/include" LIBPATH="c:/openssl/lib c:/sasl/lib c:/snmp/lib c:/curl/lib" -j$(( $(grep -c ^processor /proc/cpuinfo) / 2 )) --dynamic-windows --win-version-min=ws08r2
    # We invoke SCons using --jobs = (# of CPUs / 4) to avoid causing out of memory errors due to
    # spawning a large number of linker processes.
    num_scons_compile_all_jobs_available: $(( $(grep -c ^processor /proc/cpuinfo) / 4 ))
    python: python
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    ext: zip
    use_scons_cache: true
    test_flags: --serviceExecutor=adaptive
  tasks:
  - name: compile
    distros:
    - windows-64-vs2015-large
  - name: jsCore
  - name: replica_sets
  - name: sharding

- name: enterprise-windows-64-2k8-inmem
  display_name: Enterprise Windows 2008R2 (inMemory)
  modules:
  - enterprise
  run_on:
  - windows-64-vs2015-small
  batchtime: 1440 # 1 day
  expansions:
    platform_decompress: unzip
    tooltags: "-tags 'ssl sasl'"
    exe: ".exe"
    gorootvars: 'PATH="/cygdrive/c/mingw-w64/x86_64-4.9.1-posix-seh-rt_v3-rev1/mingw64/bin:/cygdrive/c/sasl/:$PATH" CGO_CFLAGS="-D_WIN32_WINNT=0x0601 -DNTDDI_VERSION=0x06010000"'
    push_path: win32
    push_bucket: downloads.10gen.com
    push_name: win32
    push_arch: x86_64-enterprise-windows-64
    msi_target: msi
    content_type: application/zip
    compile_flags: --release --ssl MONGO_DISTMOD=windows-64 CPPPATH="c:/openssl/include c:/sasl/include c:/snmp/include c:/curl/include" LIBPATH="c:/openssl/lib c:/sasl/lib c:/snmp/lib c:/curl/lib" -j$(( $(grep -c ^processor /proc/cpuinfo) / 2 )) --dynamic-windows --win-version-min=ws08r2
    # We invoke SCons using --jobs = (# of CPUs / 4) to avoid causing out of memory errors due to
    # spawning a large number of linker processes.
    num_scons_compile_all_jobs_available: $(( $(grep -c ^processor /proc/cpuinfo) / 4 ))
    python: python
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    test_flags: --storageEngine=inMemory --excludeWithAnyTags=requires_persistence,requires_journaling,requires_mmapv1
    ext: zip
    use_scons_cache: true
  tasks:
  - name: compile
    distros:
    - windows-64-vs2015-large
  - name: compile_all
    distros:
    - windows-64-vs2015-large
  - name: audit
  - name: auth_audit
  - name: dbtest
  - name: concurrency
    distros:
    - windows-64-vs2015-large  # Some workloads require a lot of memory, use a bigger machine for this suite.
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: read_concern_linearizable_passthrough
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sasl
  - name: sharding_auth
    distros:
    - windows-64-vs2015-large
  - name: sharding_auth_audit
    distros:
    - windows-64-vs2015-large
  - name: snmp
  - name: ssl
  - name: sslSpecial

- name: windows-64-2k8-ssl
  display_name: SSL Windows 2008R2
  run_on:
  - windows-64-vs2015-small
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    platform_decompress: unzip
    exe: ".exe"
    gorootvars: 'PATH="/cygdrive/c/mingw-w64/x86_64-4.9.1-posix-seh-rt_v3-rev1/mingw64/bin:/cygdrive/c/sasl/:$PATH" CGO_CFLAGS="-D_WIN32_WINNT=0x0601 -DNTDDI_VERSION=0x06010000"'
    tooltags: "-tags ssl"
    push_path: win32
    push_bucket: downloads.mongodb.org
    push_name: win32
    push_arch: x86_64-2008plus-ssl
    multiversion_platform: windows_x86_64-2008plus-ssl
    msi_target: msi
    content_type: application/zip
    compile_flags: --release --ssl MONGO_DISTMOD=2008plus-ssl CPPPATH="c:/openssl/include" LIBPATH="c:/openssl/lib" -j$(( $(grep -c ^processor /proc/cpuinfo) / 2 )) --dynamic-windows --win-version-min=ws08r2
    # We invoke SCons using --jobs = (# of CPUs / 4) to avoid causing out of memory errors due to
    # spawning a large number of linker processes.
    num_scons_compile_all_jobs_available: $(( $(grep -c ^processor /proc/cpuinfo) / 4 ))
    python: python
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    ext: zip
    use_scons_cache: true
  tasks:
  - name: compile
    distros:
    - windows-64-vs2015-large
  - name: compile_all
    distros:
    - windows-64-vs2015-large
  - name: aggregation
  - name: aggregation_mongos_passthrough
  - name: aggregation_one_shard_sharded_collections
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: auth
  - name: bulk_gle_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: jsCore
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsonSchema
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_replication_session
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_concurrent_sharded_causal_consistency
  - name: jstestfuzz_concurrent_sharded_continuous_stepdown
  - name: jstestfuzz_concurrent_sharded_session
  - name: jstestfuzz_replication
  - name: jstestfuzz_replication_session
  - name: jstestfuzz_sharded
  - name: jstestfuzz_sharded_causal_consistency
  - name: jstestfuzz_sharded_continuous_stepdown
  - name: jstestfuzz_sharded_session
  - name: mongosTest
  - name: multiversion
  - name: multiversion_auth
  - name: multiversion_multistorage_engine
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: powercycle
  - name: powercycle_fcv3.6
  - name: powercycle_replication
  - name: powercycle_syncdelay
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: replica_sets
  - name: replica_sets_jscore_passthrough
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding
    distros:
    - windows-64-vs2015-large
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_last_stable_mongos_and_mixed_shards
    distros:
    - windows-64-vs2015-large
  - name: slow1
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: update_fuzzer
  - name: update_fuzzer_replication
  - name: write_concern_majority_passthrough
  - name: push
    distros:
    - rhel70-small

- name: enterprise-windows-64-2k8-debug-unoptimized
  display_name: Enterprise Windows 2008R2 DEBUG (Unoptimized)
  modules:
  - enterprise
  run_on:
  - windows-64-vs2015-small
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    platform_decompress: unzip
    tooltags: "-tags 'ssl sasl'"
    exe: ".exe"
    gorootvars: 'PATH="/cygdrive/c/mingw-w64/x86_64-4.9.1-posix-seh-rt_v3-rev1/mingw64/bin:/cygdrive/c/sasl/:$PATH" CGO_CFLAGS="-D_WIN32_WINNT=0x0601 -DNTDDI_VERSION=0x06010000"'
    content_type: application/zip
    compile_flags: --dbg=on --opt=off --ssl MONGO_DISTMOD=2008plus CPPPATH="c:/openssl/include c:/sasl/include c:/snmp/include c:/curl/include" LIBPATH="c:/openssl/lib c:/sasl/lib c:/snmp/lib c:/curl/lib" -j$(( $(grep -c ^processor /proc/cpuinfo) / 2 )) --dynamic-windows --win-version-min=ws08r2
    # We invoke SCons using --jobs = (# of CPUs / 4) to avoid causing out of memory errors due to
    # spawning a large number of linker processes.
    num_scons_compile_all_jobs_available: $(( $(grep -c ^processor /proc/cpuinfo) / 4 ))
    python: python
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    ext: zip
    use_scons_cache: true
  tasks:
  # This variant tests that unoptimized, DEBUG mongos and mongod binaries can run on Windows.
  # It has a minimal amount of tasks because unoptimized builds are slow, which causes
  # timing-sensitive tests to fail.
  - name: compile
    distros:
    - windows-64-vs2015-large
  - name: audit
  # Do not add more tasks to this list.

###########################################
#             OSX buildvariants           #
###########################################

- name: osx-1010-ssl
  display_name: SSL OS X 10.10
  run_on:
  - macos-1012
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    push_path: osx
    push_bucket: downloads.mongodb.org
    push_name: osx-ssl
    push_arch: x86_64
    tooltags: "-tags 'ssl openssl_pre_1.0'"
    gorootvars: CGO_CPPFLAGS=-I/opt/mongodbtoolchain/v2/include CGO_CFLAGS=-mmacosx-version-min=10.10 CGO_LDFLAGS=-mmacosx-version-min=10.10
    compile_env: DEVELOPER_DIR=/Applications/Xcode8.3.app
    compile_flags: --ssl -j$(sysctl -n hw.logicalcpu) --release --libc++ CCFLAGS="-mmacosx-version-min=10.10" LINKFLAGS="-mmacosx-version-min=10.10" CPPPATH=/opt/mongodbtoolchain/v2/include
    multiversion_platform: osx-ssl
    num_jobs_available: 1
    build_mongoreplay: true
  tasks:
  - name: compile
  - name: compile_all
  - name: aggregation
  - name: aggregation_mongos_passthrough
  - name: aggregation_one_shard_sharded_collections
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: auth
  - name: bulk_gle_passthrough
  - name: causally_consistent_jscore_passthrough
  - name: causally_consistent_jscore_passthrough_auth
  - name: sharded_causally_consistent_jscore_passthrough
  - name: change_streams
  - name: change_streams_mongos_passthrough
  - name: change_streams_sharded_collections_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_sharded_causal_consistency
  - name: concurrency_sharded_causal_consistency_and_balancer
  - name: concurrency_sharded_with_stepdowns
  - name: concurrency_sharded_with_stepdowns_and_balancer
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: jsCore
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_replication_session
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_concurrent_sharded_causal_consistency
  - name: jstestfuzz_concurrent_sharded_session
  - name: jstestfuzz_replication
  - name: jstestfuzz_replication_session
  - name: jstestfuzz_sharded
  - name: jstestfuzz_sharded_causal_consistency
  - name: jstestfuzz_sharded_session
  - name: mongosTest
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_majority_passthrough
  - name: replica_sets
  - name: replica_sets_jscore_passthrough
  - name: replica_sets_kill_secondaries_jscore_passthrough
  - name: retryable_writes_jscore_passthrough
  - name: rollback_fuzzer
  - name: serial_run
  - name: session_jscore_passthrough
  - name: sharded_collections_jscore_passthrough
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: slow1
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: update_fuzzer
  - name: update_fuzzer_replication
  - name: write_concern_majority_passthrough
  - name: push
    distros:
    - rhel70-small

- name: osx-1010-debug
  display_name: "* OS X 10.10 DEBUG"
  run_on:
  - macos-1012
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    push_path: osx
    push_bucket: downloads.mongodb.org
    push_name: osx-debug
    push_arch: x86_64
    num_jobs_available: 1
    gorootvars: CGO_CFLAGS=-mmacosx-version-min=10.10 CGO_LDFLAGS=-mmacosx-version-min=10.10
    compile_env: DEVELOPER_DIR=/Applications/Xcode8.3.app
    compile_flags: --dbg=on --opt=on -j$(sysctl -n hw.logicalcpu) --libc++ CCFLAGS="-mmacosx-version-min=10.10" LINKFLAGS="-mmacosx-version-min=10.10"
    build_mongoreplay: true
  tasks:
  - name: compile
  - name: compile_all
  - name: aggregation
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: jsCore
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: mongosTest
  - name: replica_sets
  - name: tool

- name: enterprise-osx-1010
  display_name: Enterprise OS X 10.10
  modules:
  - enterprise
  run_on:
  - macos-1012
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    push_path: osx
    push_bucket: downloads.10gen.com
    push_name: osx
    push_arch: x86_64-enterprise
    tooltags: "-tags 'ssl sasl openssl_pre_1.0'"
    gorootvars: CGO_CPPFLAGS=-I/opt/mongodbtoolchain/v2/include CGO_CFLAGS=-mmacosx-version-min=10.10 CGO_LDFLAGS=-mmacosx-version-min=10.10
    compile_env: DEVELOPER_DIR=/Applications/Xcode8.3.app
    compile_flags: --ssl -j$(sysctl -n hw.logicalcpu) --release --libc++ CCFLAGS="-mmacosx-version-min=10.10" LINKFLAGS="-mmacosx-version-min=10.10" CPPPATH=/opt/mongodbtoolchain/v2/include
    num_jobs_available: 1
    build_mongoreplay: true
  tasks:
  - name: compile
  - name: compile_all
  - name: audit
  - name: auth_audit
  - name: dbtest
  - name: ese
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: replica_sets_auth
  - name: sasl
  - name: ssl
  - name: sslSpecial
  - name: push
    distros:
    - rhel70-small

- name: ios-102-debug
  display_name: "iOS 10.2 DEBUG"
  run_on:
  - macos-1012
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    build_cdriver: true
    cdriver_configure_flags: --build x86_64-apple-darwin16.6.0 --host arm-apple-darwin CC="$(xcrun -f --sdk iphoneos clang)" CXX="$(xcrun -f --sdk iphoneos clang++)" CPPFLAGS="-isysroot $(xcrun --sdk iphoneos --show-sdk-path) -miphoneos-version-min=10.2 -arch arm64 "  CFLAGS="-isysroot $(xcrun --sdk iphoneos --show-sdk-path) -miphoneos-version-min=10.2 -arch arm64 " CXXFLAGS="-isysroot $(xcrun --sdk iphoneos --show-sdk-path) -miphoneos-version-min=10.2 -arch arm64 " LDFLAGS="-miphoneos-version-min=10.2 -arch arm64"
    compile_env: DEVELOPER_DIR=/Applications/Xcode8.3.app
    compile_flags: -j$(sysctl -n hw.logicalcpu) --dbg=on --disable-warnings-as-errors --variables-files=etc/scons/xcode_ios.vars  CPPPATH="$(dirname $PWD)/mongo-c-driver/install/include/libbson-1.0 $(dirname $PWD)/mongo-c-driver/install/include/libmongoc-1.0" LIBPATH="$(dirname $PWD)/mongo-c-driver/install/lib"
    disable_unit_tests: true
  tasks:
  - name: compile_all

- name: ios-sim-102-debug
  display_name: "iOS Simulator 10.2 DEBUG"
  run_on:
  - macos-1012
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    build_cdriver: true
    cdriver_configure_flags: --build x86_64-apple-darwin16.6.0 --host x86_64-apple-darwin CC="$(xcrun -f --sdk iphonesimulator clang)" CXX="$(xcrun -f --sdk iphonesimulator clang++)" CPPFLAGS="-isysroot $(xcrun --sdk iphonesimulator --show-sdk-path) -miphoneos-version-min=10.2 "  CFLAGS="-isysroot $(xcrun --sdk iphonesimulator --show-sdk-path) -miphoneos-version-min=10.2 " CXXFLAGS="-isysroot $(xcrun --sdk iphonesimulator --show-sdk-path) -miphoneos-version-min=10.2 " LDFLAGS="-miphoneos-version-min=10.2 "
    compile_env: DEVELOPER_DIR=/Applications/Xcode8.3.app
    compile_flags: -j$(sysctl -n hw.logicalcpu) --dbg=on --disable-warnings-as-errors --variables-files=etc/scons/xcode_ios_sim.vars CPPPATH="$(dirname $PWD)/mongo-c-driver/install/include/libbson-1.0 $(dirname $PWD)/mongo-c-driver/install/include/libmongoc-1.0" LIBPATH="$(dirname $PWD)/mongo-c-driver/install/lib"
    disable_unit_tests: true
    enable_iostvos_sim_tests: true
    ios_sim_device: iPhone-7
    ios_sim_runtime: iOS-10-3
  tasks:
  - name: compile_all

- name: tvos-101-debug
  display_name: "tvOS 10.1 DEBUG"
  run_on:
  - macos-1012
  batchtime: 1440 # 1 day
  expansions:
    build_cdriver: true
    cdriver_configure_flags: --build x86_64-apple-darwin16.6.0 --host arm-apple-darwin CC="$(xcrun -f --sdk appletvos clang)" CXX="$(xcrun -f --sdk appletvos clang++)" CPPFLAGS="-isysroot $(xcrun --sdk appletvos --show-sdk-path) -mtvos-version-min=10.1 -arch arm64"  CFLAGS="-isysroot $(xcrun --sdk appletvos --show-sdk-path) -mtvos-version-min=10.1 -arch arm64" CXXFLAGS="-isysroot $(xcrun --sdk appletvos --show-sdk-path) -mtvos-version-min=10.1 -arch arm64" LDFLAGS="-mtvos-version-min=10.1 -arch arm64"
    test_flags: --excludeWithAnyTags=requires_mmapv1
    compile_env: DEVELOPER_DIR=/Applications/Xcode8.3.app
    compile_flags: -j$(sysctl -n hw.logicalcpu) --dbg=on --disable-warnings-as-errors --js-engine=none --variables-files=etc/scons/xcode_tvos.vars CPPPATH="$(dirname $PWD)/mongo-c-driver/install/include/libbson-1.0 $(dirname $PWD)/mongo-c-driver/install/include/libmongoc-1.0" LIBPATH="$(dirname $PWD)/mongo-c-driver/install/lib"
    disable_unit_tests: true
  tasks:
  - name: compile_all

- name: tvos-sim-101-debug
  display_name: "tvOS Simulator 10.1 DEBUG"
  run_on:
  - macos-1012
  batchtime: 1440 # 1 day
  expansions:
    build_cdriver: true
    cdriver_configure_flags: --build x86_64-apple-darwin16.6.0 --host x86_64-apple-darwin CC="$(xcrun -f --sdk appletvsimulator clang)" CXX="$(xcrun -f --sdk appletvsimulator clang++)" CPPFLAGS="-isysroot $(xcrun --sdk appletvsimulator --show-sdk-path) -mtvos-version-min=10.1"  CFLAGS="-isysroot $(xcrun --sdk appletvsimulator --show-sdk-path) -mtvos-version-min=10.1" CXXFLAGS="-isysroot $(xcrun --sdk appletvsimulator --show-sdk-path) -mtvos-version-min=10.1" LDFLAGS="-mtvos-version-min=10.1"
    test_flags: --excludeWithAnyTags=requires_mmapv1
    compile_env: DEVELOPER_DIR=/Applications/Xcode8.3.app
    compile_flags: -j$(sysctl -n hw.logicalcpu) --dbg=on --disable-warnings-as-errors --js-engine=none --variables-files=etc/scons/xcode_tvos_sim.vars CPPPATH="$(dirname $PWD)/mongo-c-driver/install/include/libbson-1.0 $(dirname $PWD)/mongo-c-driver/install/include/libmongoc-1.0" LIBPATH="$(dirname $PWD)/mongo-c-driver/install/lib"
    disable_unit_tests: true
    enable_iostvos_sim_tests: true
    ios_sim_device: Apple-TV-1080p
    ios_sim_runtime: tvOS-10-2
  tasks:
  - name: compile_all

- name: android-emulator
  display_name: "Android emulator DEBUG"
  run_on:
  - ubuntu1604-build
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    build_cdriver: true
    cdriver_configure_flags: --prefix=$(pwd)/install --host aarch64-unknown-linux-gnu CC=$(dirname $(pwd))/android_toolchain/bin/clang CXX=$(dirname $(pwd))/android_toolchain/clang++
    compile_env: JAVA_HOME=/opt/java/jdk8/
    compile_flags: -j$(grep -c ^processor /proc/cpuinfo) --dbg=on --android-toolchain-path=$(dirname $(pwd))/android_toolchain --variables-files=etc/scons/android_toolchain.vars CPPPATH="$(dirname $(pwd))/mongo-c-driver/install/include/libbson-1.0 $(dirname $(pwd))/mongo-c-driver/install/include/libmongoc-1.0" LIBPATH="$(dirname $(pwd))/mongo-c-driver/install/lib"
    disable_unit_tests: true
    enable_android_emu_tests: true
    setup_android_toolchain: true
  tasks:
  - name: compile_all

###########################################
#          Redhat buildvariants           #
###########################################

- name: enterprise-rhel-62-64-bit
  display_name: "! Enterprise RHEL 6.2"
  modules:
  - enterprise
  run_on:
  - rhel62-small
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: x86_64-enterprise-rhel62
    rlp_environment: MONGOD_UNITTEST_RLP_LANGUAGE_TEST_BTROOT=/opt/basis
    compile_flags: --ssl MONGO_DISTMOD=rhel62 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars CPPPATH="/opt/basis/rlp/rlp/include /opt/basis/rlp/utilities/include" --use-basis-tech-rosette-linguistics-platform=on
    multiversion_platform: rhel62
    multiversion_edition: targeted
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: rhel62
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    requires:
    - name: burn_in_tests
    - name: lint
    distros:
    - rhel62-large
  - name: compile_all
    distros:
    - rhel62-large
  - name: lint
  - name: burn_in_tests
  - name: rollback_fuzzer
  - name: aggregation
  - name: aggregation_ese
  - name: aggregation_auth
  - name: aggregation_facet_unwind_passthrough
  - name: aggregation_mongos_passthrough
  - name: aggregation_one_shard_sharded_collections
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: causally_consistent_jscore_passthrough
  - name: causally_consistent_jscore_passthrough_auth
  - name: sharded_causally_consistent_jscore_passthrough
  - name: change_streams
  - name: change_streams_mongos_passthrough
  - name: change_streams_secondary_reads
  - name: change_streams_sharded_collections_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_sharded_causal_consistency
  - name: concurrency_sharded_causal_consistency_and_balancer
  - name: concurrency_sharded_with_stepdowns
  - name: concurrency_sharded_with_stepdowns_and_balancer
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_wiredtiger
  - name: ese
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: idl_tests
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_minimum_batch_size
  - name: jsCore_op_query
  - name: jsonSchema
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_replication_session
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_concurrent_sharded_causal_consistency
  - name: jstestfuzz_concurrent_sharded_continuous_stepdown
  - name: jstestfuzz_concurrent_sharded_session
  - name: jstestfuzz_replication
  - name: jstestfuzz_replication_initsync
  - name: jstestfuzz_replication_session
  - name: jstestfuzz_sharded
  - name: jstestfuzz_sharded_causal_consistency
  - name: jstestfuzz_sharded_continuous_stepdown
  - name: jstestfuzz_sharded_session
  - name: mongosTest
  - name: multiversion_auth
  - name: multiversion
  - name: multiversion_multistorage_engine
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
    distros:
    - rhel62-large
  - name: read_concern_majority_passthrough
    distros:
    - rhel62-large
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
    distros:
    - rhel62-large
  - name: replica_sets_ese
    distros:
    - rhel62-large
  - name: replica_sets_auth
    distros:
    - rhel62-large
  - name: replica_sets_pv0
    distros:
    - rhel62-large
  - name: replica_sets_jscore_passthrough
    distros:
    - rhel62-large
  - name: replica_sets_initsync_jscore_passthrough
    distros:
    - rhel62-large
  - name: replica_sets_initsync_static_jscore_passthrough
    distros:
    - rhel62-large
  - name: replica_sets_resync_static_jscore_passthrough
    distros:
    - rhel62-large
  - name: replica_sets_kill_secondaries_jscore_passthrough
    distros:
    - rhel62-large
  - name: retryable_writes_jscore_passthrough
    distros:
    - rhel62-large
  - name: retryable_writes_jscore_stepdown_passthrough
    distros:
    - rhel62-large
  - name: rlp
  - name: sasl
  - name: session_jscore_passthrough
  - name: sharded_collections_jscore_passthrough
  - name: sharding
    distros:
    - rhel62-large
  - name: sharding_ese
    distros:
    - rhel62-large
  - name: sharding_auth
    distros:
    - rhel62-large
  - name: sharding_auth_audit
    distros:
    - rhel62-large
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_last_stable_mongos_and_mixed_shards
    distros:
    - rhel62-large
  - name: sharding_op_query
    distros:
    - rhel62-large
  - name: sharding_csrs_continuous_config_stepdown
    distros:
    - rhel62-large
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: update_fuzzer
  - name: update_fuzzer_replication
  - name: write_concern_majority_passthrough
    distros:
    - rhel62-large
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

- name: enterprise-rhel-62-64-bit-coverage
  display_name: "~ Enterprise RHEL 6.2 DEBUG Code Coverage"
  modules:
  - enterprise
  run_on:
  - rhel62-large
  batchtime: 10080 # 7 days
  stepback: false
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    compile_flags: --dbg=on --gcov --ssl MONGO_DISTMOD=rhel62 -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    multiversion_platform: rhel62
    multiversion_edition: targeted
    num_jobs_available: $(($(grep -c ^processor /proc/cpuinfo) / 2)) # Avoid starting too many mongod's
    # The gcov instrumentation saves the path the .gcno files were created in as the default path
    # for the .gcda files. In Evergreen the path will start with /data/mci/[Hashed ID]/src/... where
    # the hashed ID is unique per task run. GCOV_PREFIX_STRIP is the number of directory levels to
    # strip from the top of the default path before appending to the GCOV_PREFIX (if any).
    gcov_environment: GCOV_PREFIX=$(pwd) GCOV_PREFIX_STRIP=4
    # Mixing --cache and --gcov doesn't work correctly yet. See SERVER-11084
    timeout_secs: 10800 # 3 hour timeout
    use_scons_cache: false
    build_mongoreplay: true
  tasks:
  - name: compile
  - name: compile_all
  - name: rollback_fuzzer
  - name: aggregation
  - name: aggregation_ese
  - name: aggregation_auth
  - name: aggregation_mongos_passthrough
  - name: aggregation_one_shard_sharded_collections
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: change_streams
  - name: change_streams_mongos_passthrough
  - name: change_streams_secondary_reads
  - name: change_streams_sharded_collections_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_sharded_causal_consistency
  - name: concurrency_sharded_causal_consistency_and_balancer
  - name: concurrency_sharded_with_stepdowns
  - name: concurrency_sharded_with_stepdowns_and_balancer
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_wiredtiger
  - name: ese
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_minimum_batch_size
  - name: jsCore_op_query
  - name: mongosTest
  - name: multiversion_auth
  - name: multiversion
  - name: multiversion_multistorage_engine
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
  - name: replica_sets_ese
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: replica_sets_initsync_jscore_passthrough
  - name: replica_sets_initsync_static_jscore_passthrough
  - name: replica_sets_resync_static_jscore_passthrough
  - name: replica_sets_kill_secondaries_jscore_passthrough
  - name: retryable_writes_jscore_passthrough
  - name: sasl
  - name: session_jscore_passthrough
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_ese
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: sharding_op_query
  - name: sharding_csrs_continuous_config_stepdown
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: update_fuzzer
  - name: update_fuzzer_replication
  - name: write_concern_majority_passthrough

- name: enterprise-rhel-70-64-bit
  display_name: "* Enterprise RHEL 7.0"
  modules:
  - enterprise
  run_on:
  - rhel70-small
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: x86_64-enterprise-rhel70
    compile_flags: --ssl MONGO_DISTMOD=rhel70 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: rhel70
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel70
  - name: compile_all
    distros:
    - rhel70
  - name: audit
  - name: auth
  - name: auth_audit
  - name: dbtest
  - name: ese
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: external_auth
  - name: replica_sets_auth
  - name: sasl
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

- name: ubuntu1604-debug
  display_name: "* Ubuntu 16.04 DEBUG"
  run_on:
  - ubuntu1604-test
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    num_jobs_available: $(($(grep -c ^processor /proc/cpuinfo) / 2)) # Avoid starting too many mongod's
    compile_flags: MONGO_DISTMOD=ubuntu1604 --dbg=on --opt=on -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    shared_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1604-build
  - name: jsCore
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: replica_sets_jscore_passthrough
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_auth

- name: rhel62
  display_name: SSL RHEL 6.2
  run_on:
  - rhel62-small
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags ssl"
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64-rhel62
    compile_flags: --ssl MONGO_DISTMOD=rhel62 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    multiversion_platform: rhel62
    multiversion_edition: targeted
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager.py
    packager_arch: x86_64
    packager_distro: rhel62
    repo_edition: org
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel62-large
  - name: compile_all
    distros:
    - rhel62-large
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: slow1
  - name: serial_run
  - name: sharding_jscore_passthrough
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

- name: rhel70
  display_name: SSL RHEL 7.0
  run_on:
  - rhel70-small
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags ssl"
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64-rhel70
    compile_flags: --ssl MONGO_DISTMOD=rhel70 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    multiversion_platform: rhel70
    multiversion_edition: targeted
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager.py
    packager_arch: x86_64
    packager_distro: rhel70
    repo_edition: org
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel70
  - name: compile_all
    distros:
    - rhel70
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
    distros:
    - rhel70
  - name: concurrency_replication
    distros:
    - rhel70
  - name: concurrency_sharded
    distros:
    - rhel70
  - name: concurrency_simultaneous
    distros:
    - rhel70
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: slow1
  - name: serial_run
  - name: sharding_jscore_passthrough
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

- name: enterprise-rhel-71-ppc64le
  display_name: Enterprise RHEL 7.1 PPC64LE
  modules:
  - enterprise
  run_on:
  - rhel71-power8-build
  - rhel71-power8-test
  batchtime: 1440 # 1 day
  stepback: false
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: PATH=/opt/mongodbtoolchain/v2/bin:$PATH
    tooltags: -gccgoflags "$(pkg-config --libs --cflags libssl libsasl2)" -tags 'sasl ssl'
    # We need to compensate for SMT8 setting the cpu count very high and lower the amount of parallelism down
    compile_flags: --ssl MONGO_DISTMOD=rhel71 --release -j$(echo "$(grep -c processor /proc/cpuinfo)/2" | bc) CCFLAGS="-mcpu=power8 -mtune=power8 -mcmodel=medium" --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(echo "$(grep -c processor /proc/cpuinfo)/4" | bc)
    test_flags: --excludeWithAnyTags=requires_mmapv1
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: ppc64le
    packager_distro: rhel71
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: ppc64le-enterprise-rhel71
    repo_edition: enterprise
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel71-power8-build
  - name: compile_all
    distros:
    - rhel71-power8-build
  - name: aggregation
  - name: aggregation_ese
  - name: aggregation_auth
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: dbtest
  - name: ese
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_op_query
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: replica_sets
  - name: replica_sets_ese
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: sasl
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_ese
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_csrs_continuous_config_stepdown
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: write_concern_majority_passthrough
  - name: push
    distros:
    - rhel70-small

- name: enterprise-rhel-72-s390x
  display_name: Enterprise RHEL 7.2 s390x
  modules:
  - enterprise
  run_on:
  - rhel72-zseries-build
  - rhel72-zseries-test
  batchtime: 2880 # 2 days
  stepback: false
  expansions:
    gorootvars: PATH=/opt/mongodbtoolchain/v2/bin:$PATH
    tooltags: -gccgoflags "$(pkg-config --libs --cflags libssl libsasl2)" -tags 'sasl ssl'
    compile_flags: --ssl MONGO_DISTMOD=rhel72 --release -j3 CCFLAGS="-march=z196 -mtune=zEC12" --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: 2
    test_flags: --excludeWithAnyTags=requires_mmapv1
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: s390x
    packager_distro: rhel72
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: s390x-enterprise-rhel72
    repo_edition: enterprise
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel72-zseries-build
  - name: compile_all
    distros:
    - rhel72-zseries-build
  - name: aggregation
  - name: aggregation_ese
  - name: aggregation_auth
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: dbtest
  - name: ese
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_op_query
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: replica_sets
  - name: replica_sets_ese
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: sasl
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_ese
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_csrs_continuous_config_stepdown
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: write_concern_majority_passthrough
  - name: push
    distros:
    - rhel70-small

- name: enterprise-rhel-67-s390x
  display_name: Enterprise RHEL 6.7 s390x
  modules:
  - enterprise
  run_on:
  - rhel67-zseries-build
  - rhel67-zseries-test
  batchtime: 1440 # 1 day
  stepback: false
  expansions:
    gorootvars: PATH=/opt/mongodbtoolchain/v2/bin:$PATH
    tooltags: -gccgoflags "$(pkg-config --libs --cflags libssl libcrypto) -lsasl2" -tags 'sasl ssl'
    compile_flags: --ssl MONGO_DISTMOD=rhel67 --release -j3 CCFLAGS="-march=z9-109 -mtune=z10" --variables-files=etc/scons/mongodbtoolchain_gcc.vars --use-s390x-crc32=off
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    test_flags: --excludeWithAnyTags=requires_mmapv1
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: s390x
    packager_distro: rhel67
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: s390x-enterprise-rhel67
    repo_edition: enterprise
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel67-zseries-build
  - name: compile_all
    distros:
    - rhel67-zseries-build
  - name: aggregation
  - name: aggregation_ese
  - name: aggregation_auth
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: dbtest
  - name: ese
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_minimum_batch_size
  - name: jsCore_op_query
  - name: mongosTest
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: replica_sets
  - name: replica_sets_ese
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: sasl
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_ese
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_csrs_continuous_config_stepdown
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: write_concern_majority_passthrough
  - name: push
    distros:
    - rhel70
    - rhel62-large

###########################################
#          Ubuntu buildvariants           #
###########################################

- name: enterprise-ubuntu1204-64
  display_name: Enterprise Ubuntu 12.04
  modules:
  - enterprise
  run_on:
  - ubuntu1204-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: x86_64-enterprise-ubuntu1204
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1204 --release -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: ubuntu1204
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1204-build
  - name: compile_all
    distros:
    - ubuntu1204-build
  - name: audit
  - name: dbtest
  - name: ese
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: replica_sets_auth
  - name: sasl
  - name: sharding_auth
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push


- name: enterprise-ubuntu1404-64
  display_name: Enterprise Ubuntu 14.04
  modules:
  - enterprise
  run_on:
  - ubuntu1404-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: x86_64-enterprise-ubuntu1404
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1404 --release -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: ubuntu1404
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1404-build
  - name: compile_all
    distros:
    - ubuntu1404-build
  - name: audit
  - name: dbtest
  - name: ese
  - name: jepsen_register_findAndModify_WT
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_register_linearizableRead
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_register_linearizableRead_WT
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_set_linearizableRead
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_set_linearizableRead_WT
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_read-concern-majority_WT
    distros:
    - ubuntu1404-jepsen
  - name: jepsen_read-concern-majority_w1_WT
    distros:
    - ubuntu1404-jepsen
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: replica_sets_auth
  - name: sasl
  - name: sharding_auth
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push


- name: enterprise-ubuntu1604-64
  display_name: Enterprise Ubuntu 16.04 (+Dagger)
  modules:
  - enterprise
  run_on:
  - ubuntu1604-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    lang_environment: LANG=C
    push_arch: x86_64-enterprise-ubuntu1604
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1604 --release -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: ubuntu1604
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
    additional_targets: dagger
  tasks:
  - name: compile
    distros:
    - ubuntu1604-build
  - name: compile_all
    distros:
    - ubuntu1604-build
  - name: audit
  - name: dbtest
  - name: ese
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: replica_sets_auth
  - name: sasl
  - name: sharding_auth
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: watchdog_mmapv1
  - name: watchdog_wiredtiger
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push


- name: enterprise-ubuntu1604-clang-3.8-libcxx
  display_name: "! Enterprise Ubuntu 16.04 (Clang 3.8)"
  modules:
  - enterprise
  run_on:
   - ubuntu1604-test
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    lang_environment: LANG=C
    compile_flags: --link-model=dynamic --ssl CC=/usr/bin/clang-3.8 CXX=/usr/bin/clang++-3.8 -j$(grep -c ^processor /proc/cpuinfo) CPPPATH=/usr/include/libcxxabi/
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1604-build
  - name: compile_all
    distros:
    - ubuntu1604-build

###########################################
#          SUSE buildvariants             #
###########################################

- name: enterprise-suse12-64
  display_name: Enterprise SLES 12
  modules:
  - enterprise
  run_on:
  - suse12-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: x86_64-enterprise-suse12
    compile_flags: --ssl MONGO_DISTMOD=suse12 --release -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: suse12
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - suse12-build
  - name: compile_all
    distros:
    - suse12-build
  - name: audit
  - name: dbtest
  - name: ese
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: replica_sets_auth
  - name: sasl
  - name: sharding_auth
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push


- name: enterprise-suse12-s390x
  display_name: Enterprise SLES 12 s390x
  modules:
  - enterprise
  run_on:
  - suse12-zseries-build
  - suse12-zseries-test
  batchtime: 1440 # 1 day
  stepback: false
  expansions:
    gorootvars: PATH=/opt/mongodbtoolchain/v2/bin:$PATH
    tooltags: -gccgoflags "$(pkg-config --libs --cflags libssl libsasl2)" -tags 'sasl ssl'
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: s390x-enterprise-suse12
    compile_flags: --ssl MONGO_DISTMOD=suse12 --release -j3 CCFLAGS="-march=z196 -mtune=zEC12" --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    test_flags: --excludeWithAnyTags=requires_mmapv1
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: s390x
    packager_distro: suse12
    repo_edition: enterprise
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - suse12-zseries-build
  - name: compile_all
    distros:
    - suse12-zseries-build
  - name: aggregation
  - name: aggregation_ese
  - name: aggregation_auth
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: dbtest
  - name: ese
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_op_query
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: replica_sets
  - name: replica_sets_ese
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: sasl
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_ese
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_csrs_continuous_config_stepdown
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: write_concern_majority_passthrough
  - name: push
    distros:
    - suse12-test

- name: suse12
  display_name: SSL SUSE 12
  run_on:
  - suse12-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags ssl"
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64-suse12
    compile_flags: --ssl MONGO_DISTMOD=suse12 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    multiversion_platform: suse12
    multiversion_edition: targeted
    has_packages: true
    packager_script: packager.py
    packager_arch: x86_64
    packager_distro: suse12
    repo_edition: org
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - suse12-build
  - name: compile_all
    distros:
    - suse12-build
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: slow1
  - name: serial_run
  - name: sharding_jscore_passthrough
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

###########################################
#          Debian buildvariants           #
###########################################

- name: enterprise-debian71-64
  display_name: Enterprise Debian 7.1
  modules:
  - enterprise
  run_on:
  - debian71-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: x86_64-enterprise-debian71
    compile_flags: --ssl MONGO_DISTMOD=debian71 --release -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: debian71
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - debian71-build
  - name: compile_all
    distros:
    - debian71-build
  - name: audit
  - name: dbtest
  - name: ese
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: replica_sets_auth
  - name: sasl
  - name: sharding_auth
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push


- name: enterprise-debian81-64
  display_name: Enterprise Debian 8.1
  modules:
  - enterprise
  run_on:
  - debian81-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: x86_64-enterprise-debian81
    compile_flags: --ssl MONGO_DISTMOD=debian81 --release -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: debian81
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - debian81-build
  - name: compile_all
    distros:
    - debian81-build
  - name: audit
  - name: dbtest
  - name: ese
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: replica_sets_auth
  - name: sasl
  - name: sharding_auth
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push


- name: debian71
  display_name: SSL Debian 7.1
  run_on:
  - debian71-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags ssl"
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64-debian71
    compile_flags: --ssl MONGO_DISTMOD=debian71 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    multiversion_platform: debian71
    multiversion_edition: targeted
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager.py
    packager_arch: x86_64
    packager_distro: debian71
    repo_edition: org
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - debian71-build
  - name: compile_all
    distros:
    - debian71-build
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: slow1
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push


- name: debian81
  display_name: SSL Debian 8.1
  run_on:
  - debian81-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags ssl"
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64-debian81
    compile_flags: --ssl MONGO_DISTMOD=debian81 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    multiversion_platform: debian81
    multiversion_edition: targeted
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager.py
    packager_arch: x86_64
    packager_distro: debian81
    repo_edition: org
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - debian81-build
  - name: compile_all
    distros:
    - debian81-build
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: slow1
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

- name: enterprise-debian92-64
  display_name: Enterprise Debian 9.2
  modules:
  - enterprise
  run_on:
  - debian92-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    push_path: linux
    push_bucket: downloads.10gen.com
    push_name: linux
    push_arch: x86_64-enterprise-debian92
    compile_flags: --ssl MONGO_DISTMOD=debian92 --release -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: debian92
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - debian92-build
  - name: compile_all
    distros:
    - debian92-build
  - name: audit
  - name: dbtest
  - name: ese
  - name: jsCore
  - name: jsCore_auth
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: replica_sets_auth
  - name: sasl
  - name: sharding_auth
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

- name: debian92
  display_name: SSL Debian 9.2
  run_on:
  - debian92-test
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags ssl"
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux
    push_arch: x86_64-debian92
    compile_flags: --ssl MONGO_DISTMOD=debian92 -j$(grep -c ^processor /proc/cpuinfo) --release --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    multiversion_platform: debian92
    multiversion_edition: targeted
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager.py
    packager_arch: x86_64
    packager_distro: debian92
    repo_edition: org
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - debian92-build
  - name: compile_all
    distros:
    - debian92-build
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: dbtest
  - name: disk_wiredtiger
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: multiversion
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: parallel
  - name: parallel_compatibility
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: slow1
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: package
    distros:
    - ubuntu1604-packer
  - name: push

################################
# storage engine buildvariants #
################################

- name: enterprise-rhel-62-64-bit-inmem
  display_name: Enterprise RHEL 6.2 (inMemory)
  modules:
  - enterprise
  run_on:
  - rhel62-small
  batchtime: 1440 # 1 day
  expansions:
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    rlp_environment: MONGOD_UNITTEST_RLP_LANGUAGE_TEST_BTROOT=/opt/basis
    test_flags: --storageEngine=inMemory --excludeWithAnyTags=requires_persistence,requires_journaling,requires_mmapv1
    compile_flags: --ssl MONGO_DISTMOD=rhel62 -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars CPPPATH="/opt/basis/rlp/rlp/include /opt/basis/rlp/utilities/include" --use-basis-tech-rosette-linguistics-platform=on
    multiversion_platform: rhel62
    multiversion_edition: enterprise
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel62-large
  - name: compile_all
    distros:
    - rhel62-large
  - name: aggregation
  - name: aggregation_auth
  - name: aggregation_mongos_passthrough
  - name: aggregation_one_shard_sharded_collections
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: causally_consistent_jscore_passthrough
  - name: causally_consistent_jscore_passthrough_auth
  - name: sharded_causally_consistent_jscore_passthrough
  - name: change_streams
  - name: change_streams_mongos_passthrough
  - name: change_streams_sharded_collections_passthrough
  - name: concurrency
    distros:
    - rhel62-large  # Some workloads require a lot of memory, use a bigger machine for this suite.
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_sharded_causal_consistency
  - name: concurrency_sharded_causal_consistency_and_balancer
  - name: concurrency_sharded_with_stepdowns
  - name: concurrency_sharded_with_stepdowns_and_balancer
  - name: concurrency_simultaneous
  - name: dbtest
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_op_query
  - name: jstestfuzz_concurrent_sharded_continuous_stepdown
  - name: jstestfuzz_sharded_continuous_stepdown
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_replication_session
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_concurrent_sharded_causal_consistency
  - name: jstestfuzz_concurrent_sharded_session
  - name: jstestfuzz_replication
  - name: jstestfuzz_replication_session
  - name: jstestfuzz_sharded
  - name: jstestfuzz_sharded_session
  - name: jstestfuzz_sharded_causal_consistency
  - name: mongosTest
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: retryable_writes_jscore_passthrough
  - name: retryable_writes_jscore_stepdown_passthrough
  - name: rlp
  - name: rollback_fuzzer
  - name: sasl
  - name: session_jscore_passthrough
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: update_fuzzer
  - name: update_fuzzer_replication
  - name: write_concern_majority_passthrough

- name: enterprise-rhel-62-64-bit-mobile
  display_name: Enterprise RHEL 6.2 (mobile)
  modules:
  - enterprise
  run_on:
  - rhel62-small
  batchtime: 1440 # 1 day
  expansions:
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    rlp_environment: MONGOD_UNITTEST_RLP_LANGUAGE_TEST_BTROOT=/opt/basis
    test_flags: --storageEngine=mobile --excludeWithAnyTags=requires_mmapv1,requires_wiredtiger,requires_sharding,requires_replication,SERVER-32709,SERVER-32869,SERVER-32993,SERVER-32997
    compile_flags: --mobile-se=on --ssl MONGO_DISTMOD=rhel62 -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars CPPPATH="/opt/basis/rlp/rlp/include /opt/basis/rlp/utilities/include" --use-basis-tech-rosette-linguistics-platform=on
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel62-large
  - name: compile_all
    distros:
    - rhel62-large
  - name: aggregation
  - name: aggregation_auth
  - name: aggregation_facet_unwind_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: dbtest
  - name: concurrency
    distros:
    - rhel62-large  # Some workloads require a lot of memory, use a bigger machine for this suite.
  - name: concurrency_simultaneous
  - name: disk_mobile
  - name: failpoints
  - name: failpoints_auth
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_minimum_batch_size
  - name: jsCore_op_query
  - name: jsonSchema
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: rlp
  - name: sasl
  - name: serial_run
  - name: session_jscore_passthrough
  - name: snmp

- name: enterprise-osx-1010-mobile
  display_name: Enterprise OS X 10.10 (mobile)
  modules:
  - enterprise
  run_on:
  - macos-1012
  batchtime: 1440 # 1 day
  expansions:
    push_path: osx
    push_bucket: downloads.10gen.com
    push_name: osx
    push_arch: x86_64-enterprise
    gorootvars: CGO_CPPFLAGS=-I/opt/mongodbtoolchain/v2/include CGO_CFLAGS=-mmacosx-version-min=10.10 CGO_LDFLAGS=-mmacosx-version-min=10.10
    tooltags: "-tags 'ssl sasl openssl_pre_1.0'"
    test_flags: --storageEngine=mobile --excludeWithAnyTags=requires_mmapv1,requires_wiredtiger,requires_sharding,requires_replication,SERVER-32709,SERVER-32869,SERVER-32993,SERVER-32997
    compile_env: DEVELOPER_DIR=/Applications/Xcode8.3.app
    compile_flags: --mobile-se=on --ssl -j$(sysctl -n hw.logicalcpu) --release --libc++ CCFLAGS="-mmacosx-version-min=10.10" LINKFLAGS="-mmacosx-version-min=10.10" CPPPATH=/opt/mongodbtoolchain/v2/include
    num_jobs_available: 1
    build_mongoreplay: true
  tasks:
  - name: compile
  - name: compile_all
  - name: aggregation
  - name: aggregation_auth
  - name: aggregation_facet_unwind_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: dbtest
  - name: concurrency
  - name: concurrency_simultaneous
  - name: disk_mobile
  - name: failpoints
  - name: failpoints_auth
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_minimum_batch_size
  - name: jsCore_op_query
  - name: jsonSchema
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: sasl
  - name: serial_run
  - name: session_jscore_passthrough

- name: linux-64-ephemeralForTest
  display_name: Linux (ephemeralForTest)
  run_on:
  - rhel62-small
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --storageEngine=ephemeralForTest --excludeWithAnyTags=requires_persistence,requires_fsync,SERVER-21420,SERVER-21658,requires_journaling,requires_mmapv1,requires_wiredtiger
    compile_flags: -j$(grep -c ^processor /proc/cpuinfo) --dbg=off --opt=on --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel62-large
  - name: compile_all
    distros:
    - rhel62-large
  - name: aggregation
  - name: aggregation_auth
  - name: auth
  - name: concurrency
    distros:
    - rhel62-large  # Some workloads require a lot of memory, use a bigger machine for this suite.
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: dbtest
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_write_cmd
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: integration_tests_standalone
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_op_query
  - name: jsCore_compatibility
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mongosTest
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: bulk_gle_passthrough
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: rollback_fuzzer
  - name: sharding
  - name: sharding_auth
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: tool
  - name: update_fuzzer
  - name: update_fuzzer_replication

- name: enterprise-rhel-71-ppc64le-inmem
  display_name: Enterprise RHEL 7.1 PPC64LE (inMemory) DEBUG
  modules:
  - enterprise
  run_on:
  - rhel71-power8-build
  - rhel71-power8-test
  batchtime: 10080 # 7 days
  stepback: false
  expansions:
    gorootvars: PATH=/opt/mongodbtoolchain/v2/bin:$PATH
    tooltags: -gccgoflags "$(pkg-config --libs --cflags libssl libsasl2)" -tags 'sasl ssl'
    # We need to compensate for SMT8 setting the cpu count very high and lower the amount of parallelism down
    compile_flags: --dbg=on --opt=on --ssl MONGO_DISTMOD=rhel71 -j$(echo "$(grep -c processor /proc/cpuinfo)/2" | bc) CCFLAGS="-mcpu=power8 -mtune=power8 -mcmodel=medium" --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(echo "$(grep -c processor /proc/cpuinfo)/4" | bc)
    test_flags: --storageEngine=inMemory --excludeWithAnyTags=requires_persistence,requires_mmapv1,requires_journaling
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel71-power8-build
  - name: compile_all
    distros:
    - rhel71-power8-build
  - name: aggregation
  - name: aggregation_auth
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: dbtest
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_op_query
  - name: mongosTest
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: sasl
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: write_concern_majority_passthrough

- name: enterprise-rhel-72-s390x-inmem
  display_name: Enterprise RHEL 7.2 s390x (inMemory) DEBUG
  modules:
  - enterprise
  run_on:
  - rhel72-zseries-build
  - rhel72-zseries-test
  batchtime: 10080 # 7 days
  stepback: false
  expansions:
    gorootvars: PATH=/opt/mongodbtoolchain/v2/bin:$PATH
    tooltags: -gccgoflags "$(pkg-config --libs --cflags libssl libsasl2)" -tags 'sasl ssl'
    compile_flags: --dbg=on --opt=on --ssl MONGO_DISTMOD=rhel72 -j3 CCFLAGS="-march=z196 -mtune=zEC12" --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: 2
    test_flags: --storageEngine=inMemory --excludeWithAnyTags=requires_persistence,requires_mmapv1,requires_journaling
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - rhel72-zseries-build
  - name: compile_all
    distros:
    - rhel72-zseries-build
  - name: aggregation
  - name: aggregation_auth
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: concurrency
    distros:
    - rhel72-zseries-build
  - name: concurrency_replication
    distros:
    - rhel72-zseries-build
  - name: concurrency_sharded
    distros:
    - rhel72-zseries-build
  - name: concurrency_simultaneous
    distros:
    - rhel72-zseries-build
  - name: dbtest
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_op_query
  - name: mongosTest
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: sasl
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: write_concern_majority_passthrough

- name: ubuntu1404-rocksdb
  display_name: Ubuntu 14.04 (RocksDB)
  modules:
  - rocksdb
  run_on:
  - ubuntu1404-test
  batchtime: 1440 # 1 day
  expansions:
    build_rocksdb: true
    compile_flags: -j$(grep -c ^processor /proc/cpuinfo) --dbg=off --opt=on CPPPATH=$(readlink -f ../rocksdb/include/) LIBPATH=$(readlink -f ../rocksdb/) LIBS=rocksdb --variables-files=etc/scons/mongodbtoolchain_gcc.vars --runtime-hardening=off
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    test_flags: --storageEngine=rocksdb --excludeWithAnyTags=requires_mmapv1,requires_wiredtiger
    use_scons_cache: true
    build_mongoreplay: true
  stepback: false
  tasks:
  - name: compile
    distros:
    - ubuntu1404-build
  - name: dbtest
  - name: jsCore

###########################################
#     Experimental buildvariants          #
###########################################

- name: ubuntu1604-debug-asan
  display_name: ~ ASAN Enterprise SSL Ubuntu 16.04 DEBUG
  modules:
  - enterprise
  run_on:
  - ubuntu1604-build
  stepback: true
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    tooltags: "-tags 'ssl'"
    # We need llvm-symbolizer in the PATH for ASAN for clang-3.7 or later.
    variant_path_suffix: /opt/mongodbtoolchain/v2/bin
    lang_environment: LANG=C
    san_options: LSAN_OPTIONS="suppressions=etc/lsan.suppressions:report_objects=1" ASAN_OPTIONS=detect_leaks=1:check_initialization_order=true:strict_init_order=true:abort_on_error=1:disable_coredump=0:handle_abort=0:handle_segv=0:handle_sigbus=0:handle_sigill=0:handle_sigfpe=0
    compile_flags: --variables-files=etc/scons/mongodbtoolchain_clang.vars --dbg=on --opt=on --allocator=system --sanitize=address --ssl -j$(grep -c ^processor /proc/cpuinfo) --nostrip
    multiversion_platform: ubuntu1604
    multiversion_edition: targeted
    num_jobs_available: $(($(grep -c ^processor /proc/cpuinfo) / 3)) # Avoid starting too many mongod's under ASAN build.
    build_mongoreplay: true
    hang_analyzer_dump_core: false
  tasks:
  - name: compile
  - name: compile_all
  - name: rollback_fuzzer
  - name: aggregation
  - name: aggregation_ese
  - name: aggregation_auth
  - name: aggregation_facet_unwind_passthrough
  - name: aggregation_mongos_passthrough
  - name: aggregation_one_shard_sharded_collections
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: causally_consistent_jscore_passthrough
  - name: causally_consistent_jscore_passthrough_auth
  - name: sharded_causally_consistent_jscore_passthrough
  - name: change_streams
  - name: change_streams_mongos_passthrough
  - name: change_streams_secondary_reads
  - name: change_streams_sharded_collections_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_sharded_causal_consistency
  - name: concurrency_sharded_causal_consistency_and_balancer
  - name: concurrency_sharded_with_stepdowns
  - name: concurrency_sharded_with_stepdowns_and_balancer
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_wiredtiger
  - name: ese
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_minimum_batch_size
  - name: jsCore_op_query
  - name: jsonSchema
  - name: mongosTest
  - name: multiversion_auth
  - name: multiversion
  - name: multiversion_multistorage_engine
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
  - name: replica_sets_ese
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: replica_sets_initsync_jscore_passthrough
  - name: replica_sets_initsync_static_jscore_passthrough
  - name: replica_sets_resync_static_jscore_passthrough
  - name: replica_sets_kill_secondaries_jscore_passthrough
  - name: retryable_writes_jscore_passthrough
  - name: retryable_writes_jscore_stepdown_passthrough
  - name: sasl
  - name: session_jscore_passthrough
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_ese
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: update_fuzzer
  - name: update_fuzzer_replication
  - name: write_concern_majority_passthrough

- name: ubuntu1604-asan
  display_name: ~ ASAN SSL Ubuntu 16.04
  run_on:
  - ubuntu1604-build
  stepback: true
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    tooltags: "-tags 'ssl'"
    # We need llvm-symbolizer in the PATH for ASAN for clang-3.7 or later.
    variant_path_suffix: /opt/mongodbtoolchain/v2/bin
    lang_environment: LANG=C
    san_options: LSAN_OPTIONS="suppressions=etc/lsan.suppressions:report_objects=1" ASAN_OPTIONS=detect_leaks=1:check_initialization_order=true:strict_init_order=true:abort_on_error=1:disable_coredump=0:handle_abort=0:handle_segv=0:handle_sigbus=0:handle_sigill=0:handle_sigfpe=0
    compile_flags: --variables-files=etc/scons/mongodbtoolchain_clang.vars --opt=on --allocator=system --sanitize=address --ssl -j$(grep -c ^processor /proc/cpuinfo) --nostrip
    num_jobs_available: $(($(grep -c ^processor /proc/cpuinfo) / 3)) # Avoid starting too many mongod's under ASAN build.
    build_mongoreplay: true
    hang_analyzer_dump_core: false
  tasks:
  - name: compile
  - name: compile_all
  - name: aggregation_fuzzer
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_replication_session
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_concurrent_sharded_causal_consistency
  - name: jstestfuzz_concurrent_sharded_continuous_stepdown
  - name: jstestfuzz_concurrent_sharded_session
  - name: jstestfuzz_replication
  - name: jstestfuzz_replication_session
  - name: jstestfuzz_sharded
  - name: jstestfuzz_sharded_causal_consistency
  - name: jstestfuzz_sharded_continuous_stepdown
  - name: jstestfuzz_sharded_session

- name: ubuntu1604-debug-ubsan
  display_name: ~ UBSAN Enterprise Ubuntu 16.04 DEBUG
  modules:
  - enterprise
  run_on:
  - ubuntu1604-build
  stepback: true
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    # We need llvm-symbolizer in the PATH for UBSAN.
    variant_path_suffix: /opt/mongodbtoolchain/v2/bin
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    lang_environment: LANG=C
    san_options: UBSAN_OPTIONS="print_stacktrace=1:handle_abort=0:handle_segv=0:handle_sigbus=0:handle_sigill=0:handle_sigfpe=0"
    compile_flags: --variables-files=etc/scons/mongodbtoolchain_clang.vars --dbg=on --opt=on --allocator=system --sanitize=undefined --ssl -j$(grep -c ^processor /proc/cpuinfo) --nostrip
    multiversion_platform: ubuntu1604
    multiversion_edition: targeted
    num_jobs_available: $(($(grep -c ^processor /proc/cpuinfo) / 3)) # Avoid starting too many mongod's under UBSAN build.
    build_mongoreplay: true
  tasks:
  - name: compile
  - name: compile_all
  - name: aggregation
  - name: aggregation_ese
  - name: rollback_fuzzer
  - name: aggregation_auth
  - name: aggregation_facet_unwind_passthrough
  - name: aggregation_mongos_passthrough
  - name: aggregation_one_shard_sharded_collections
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: causally_consistent_jscore_passthrough
  - name: causally_consistent_jscore_passthrough_auth
  - name: sharded_causally_consistent_jscore_passthrough
  - name: change_streams
  - name: change_streams_mongos_passthrough
  - name: change_streams_secondary_reads
  - name: change_streams_sharded_collections_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_sharded_causal_consistency
  - name: concurrency_sharded_causal_consistency_and_balancer
  - name: concurrency_sharded_with_stepdowns
  - name: concurrency_sharded_with_stepdowns_and_balancer
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_wiredtiger
  - name: ese
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_minimum_batch_size
  - name: jsCore_op_query
  - name: jsonSchema
  - name: mongosTest
  - name: multiversion_auth
  - name: multiversion
  - name: multiversion_multistorage_engine
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
  - name: replica_sets_ese
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: replica_sets_initsync_jscore_passthrough
  - name: replica_sets_initsync_static_jscore_passthrough
  - name: replica_sets_resync_static_jscore_passthrough
  - name: replica_sets_kill_secondaries_jscore_passthrough
  - name: retryable_writes_jscore_passthrough
  - name: retryable_writes_jscore_stepdown_passthrough
  - name: sasl
  - name: session_jscore_passthrough
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_ese
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: update_fuzzer
  - name: update_fuzzer_replication
  - name: write_concern_majority_passthrough

- name: ubuntu1604-debug-aubsan-lite
  display_name: "! {A,UB}SAN Enterprise SSL Ubuntu 16.04 DEBUG"
  modules:
  - enterprise
  run_on:
  - ubuntu1604-build
  stepback: true
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    tooltags: "-tags 'ssl'"
    # We need llvm-symbolizer in the PATH for ASAN for clang-3.7 or later.
    variant_path_suffix: /opt/mongodbtoolchain/v2/bin
    lang_environment: LANG=C
    san_options: UBSAN_OPTIONS="print_stacktrace=1:handle_abort=0:handle_segv=0:handle_sigbus=0:handle_sigill=0:handle_sigfpe=0" LSAN_OPTIONS="suppressions=etc/lsan.suppressions:report_objects=1" ASAN_OPTIONS=detect_leaks=1:check_initialization_order=true:strict_init_order=true:abort_on_error=1:disable_coredump=0:handle_abort=0:handle_segv=0:handle_sigbus=0:handle_sigill=0:handle_sigfpe=0
    compile_flags: --variables-files=etc/scons/mongodbtoolchain_clang.vars --dbg=on --opt=on --allocator=system --sanitize=undefined,address --ssl -j$(grep -c ^processor /proc/cpuinfo) --nostrip
    num_jobs_available: $(($(grep -c ^processor /proc/cpuinfo) / 3)) # Avoid starting too many mongod's under {A,UB}SAN build.
    build_mongoreplay: true
    hang_analyzer_dump_core: false
  tasks:
  - name: compile
  - name: compile_all
  - name: dbtest
  - name: jsCore
  - name: watchdog_wiredtiger

- name: ubuntu1604-debug-aubsan-async
  display_name: "~ {A,UB}SAN Enterprise SSL Ubuntu 16.04 async"
  modules:
  - enterprise
  run_on:
  - ubuntu1604-build
  stepback: true
  batchtime: 1440 # 1 day
  expansions:
    tooltags: "-tags 'ssl'"
    # We need llvm-symbolizer in the PATH for ASAN for clang-3.7 or later.
    variant_path_suffix: /opt/mongodbtoolchain/v2/bin
    lang_environment: LANG=C
    san_options: UBSAN_OPTIONS="print_stacktrace=1:handle_abort=0:handle_segv=0:handle_sigbus=0:handle_sigill=0:handle_sigfpe=0" LSAN_OPTIONS="suppressions=etc/lsan.suppressions:report_objects=1" ASAN_OPTIONS=detect_leaks=1:check_initialization_order=true:strict_init_order=true:abort_on_error=1:disable_coredump=0:handle_abort=0:handle_segv=0:handle_sigbus=0:handle_sigill=0:handle_sigfpe=0
    compile_flags: --variables-files=etc/scons/mongodbtoolchain_clang.vars --dbg=on --opt=on --allocator=system --sanitize=undefined,address --ssl -j$(grep -c ^processor /proc/cpuinfo) --nostrip
    num_jobs_available: $(($(grep -c ^processor /proc/cpuinfo) / 3)) # Avoid starting too many mongod's under {A,UB}SAN build.
    build_mongoreplay: false
    hang_analyzer_dump_core: false
    test_flags: --serviceExecutor=adaptive --excludeWithAnyTags=requires_mmapv1
  tasks:
  - name: compile
  - name: compile_all
  - name: aggregation
  - name: aggregation_ese
  - name: aggregation_auth
  - name: aggregation_facet_unwind_passthrough
  - name: aggregation_read_concern_majority_passthrough
  - name: aggregation_sharded_collections_passthrough
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: causally_consistent_jscore_passthrough
  - name: causally_consistent_jscore_passthrough_auth
  - name: sharded_causally_consistent_jscore_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_wiredtiger
  - name: ese
  - name: failpoints
  - name: failpoints_auth
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: integration_tests_replset
  - name: integration_tests_sharded
  - name: integration_tests_standalone
  - name: jsCore
  - name: jsCore_ese
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_minimum_batch_size
  - name: jsCore_op_query
  - name: mongosTest
  - name: multiversion_auth
  - name: multiversion
  - name: multiversion_multistorage_engine
  - name: noPassthroughWithMongod
  - name: noPassthrough
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_concern_majority_passthrough
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
  - name: replica_sets_ese
  - name: replica_sets_auth
  - name: replica_sets_pv0
  - name: replica_sets_jscore_passthrough
  - name: replica_sets_initsync_jscore_passthrough
  - name: replica_sets_initsync_static_jscore_passthrough
  - name: replica_sets_resync_static_jscore_passthrough
  - name: replica_sets_kill_secondaries_jscore_passthrough
  - name: sasl
  - name: sharded_collections_jscore_passthrough
  - name: sharding
  - name: sharding_ese
  - name: sharding_auth
  - name: sharding_auth_audit
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_last_stable_mongos_and_mixed_shards
  - name: sharding_jscore_passthrough
  - name: sharding_jscore_op_query_passthrough
  - name: sharding_jscore_passthrough_wire_ops
  - name: sharding_op_query
  - name: slow1
  - name: serial_run
  - name: snmp
  - name: ssl
  - name: sslSpecial
  - name: tool
  - name: write_concern_majority_passthrough

- name: enterprise-ubuntu-dynamic-1604-64-bit
  display_name: "* Shared Library Enterprise Ubuntu 16.04"
  modules:
  - enterprise
  expansions:
    test_flags: --excludeWithAnyTags=requires_mmapv1
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: "-tags 'ssl sasl'"
    lang_environment: LANG=C
    compile_flags: --ssl MONGO_DISTMOD=ubuntu1604 -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars --link-model=dynamic
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    shared_scons_cache: true
    scons_cache_mode: all
    build_mongoreplay: true
  tasks:
  - name: compile
    distros:
    - ubuntu1604-build
  - name: compile_all
    distros:
    - ubuntu1604-build

- name: tig-daily-cron
  display_name: "~ TIG Daily Cron"
  run_on:
  - rhel62-large
  batchtime: 1440 # 1 day
  stepback: false
  tasks:
  - name: update_test_lifecycle
  - name: fetch_test_lifecycle
    distros:
    - rhel62-small

- name: enterprise-rhel-62-64-bit-mmapv1
  display_name: Enterprise RHEL 6.2 MMAPv1
  modules:
  - enterprise
  run_on:
  - rhel62-small
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --storageEngine=mmapv1 --excludeWithAnyTags=requires_wiredtiger
    gorootvars: GOROOT=/opt/go PATH="/opt/go/bin:$PATH"
    tooltags: -tags 'ssl sasl'
    rlp_environment: MONGOD_UNITTEST_RLP_LANGUAGE_TEST_BTROOT=/opt/basis
    compile_flags: >-
      --ssl MONGO_DISTMOD=rhel62 -j$(grep -c ^processor /proc/cpuinfo) --release
      --variables-files=etc/scons/mongodbtoolchain_gcc.vars
      CPPPATH="/opt/basis/rlp/rlp/include /opt/basis/rlp/utilities/include"
      --use-basis-tech-rosette-linguistics-platform=on
    multiversion_platform: rhel62
    multiversion_edition: targeted
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    has_packages: true
    packager_script: packager-enterprise.py
    packager_arch: x86_64
    packager_distro: rhel62
    repo_edition: enterprise
    use_scons_cache: true
    build_mongoreplay: true
  tasks:
  - name: compile
  - name: aggregation
  - name: aggregation_fuzzer
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_sharded_causal_consistency
  - name: concurrency_sharded_causal_consistency_and_balancer
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_mmapv1
  - name: dur_jscore_passthrough
  - name: durability
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: jsCore
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_op_query
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_replication_session
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_concurrent_sharded_causal_consistency
  - name: jstestfuzz_concurrent_sharded_continuous_stepdown
  - name: jstestfuzz_concurrent_sharded_session
  - name: jstestfuzz_replication
  - name: jstestfuzz_replication_initsync
  - name: jstestfuzz_replication_resync
  - name: jstestfuzz_replication_session
  - name: jstestfuzz_sharded
  - name: jstestfuzz_sharded_causal_consistency
  - name: jstestfuzz_sharded_continuous_stepdown
  - name: jstestfuzz_sharded_session
  - name: mmap
  - name: multiversion
  - name: multiversion_auth
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
    distros:
    - rhel62-large
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
    distros:
    - rhel62-large
  - name: replica_sets_initsync_jscore_passthrough
    distros:
    - rhel62-large
  - name: replica_sets_initsync_static_jscore_passthrough
    distros:
    - rhel62-large
  - name: replica_sets_jscore_passthrough
    distros:
    - rhel62-large
  - name: replica_sets_resync_static_jscore_passthrough
    distros:
    - rhel62-large
  - name: rlp
  - name: rollback_fuzzer
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding
    distros:
    - rhel62-large
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: slow1
  - name: snmp
  - name: tool
  - name: update_fuzzer
  - name: update_fuzzer_replication

- name: enterprise-windows-64-2k8-mmapv1
  display_name: Enterprise Windows 2008R2 MMAPv1
  modules:
  - enterprise
  run_on:
  - windows-64-vs2015-small
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --storageEngine=mmapv1 --excludeWithAnyTags=requires_wiredtiger
    platform_decompress: unzip
    tooltags: -tags 'ssl sasl'
    exe: .exe
    gorootvars: >-
      PATH="/cygdrive/c/mingw-w64/x86_64-4.9.1-posix-seh-rt_v3-rev1/mingw64/bin:/cygdrive/c/sasl/:$PATH"
      CGO_CFLAGS="-D_WIN32_WINNT=0x0601 -DNTDDI_VERSION=0x06010000"
    multiversion_platform: windows
    multiversion_edition: enterprise
    msi_target: msi
    content_type: application/zip
    compile_flags: >-
      --release --ssl MONGO_DISTMOD=windows-64 CPPPATH="c:/openssl/include
      c:/sasl/include c:/snmp/include c:/curl/include"  LIBPATH="c:/openssl/lib c:/sasl/lib
      c:/snmp/lib c:/curl/lib" -j$(( $(grep -c ^processor /proc/cpuinfo) / 2 )) --dynamic-windows
      --win-version-min=ws08r2
    num_scons_compile_all_jobs_available: $(( $(grep -c ^processor /proc/cpuinfo) / 4 ))
    python: python
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    ext: zip
    use_scons_cache: true
  tasks:
  - name: compile
  - name: aggregation
  - name: aggregation_fuzzer
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: concurrency
    distros:
    - windows-64-vs2015-large
  - name: concurrency_replication
    distros:
    - windows-64-vs2015-large
  - name: concurrency_sharded
    distros:
    - windows-64-vs2015-large
  - name: concurrency_sharded_causal_consistency
    distros:
    - windows-64-vs2015-large
  - name: concurrency_sharded_causal_consistency_and_balancer
    distros:
    - windows-64-vs2015-large
  - name: concurrency_simultaneous
    distros:
    - windows-64-vs2015-large
  - name: dbtest
  - name: disk_mmapv1
  - name: dur_jscore_passthrough
  - name: durability
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: jsCore
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_op_query
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_replication_session
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_concurrent_sharded_causal_consistency
  - name: jstestfuzz_concurrent_sharded_continuous_stepdown
  - name: jstestfuzz_concurrent_sharded_session
  - name: jstestfuzz_replication
  - name: jstestfuzz_replication_initsync
  - name: jstestfuzz_replication_resync
  - name: jstestfuzz_replication_session
  - name: jstestfuzz_sharded
  - name: jstestfuzz_sharded_causal_consistency
  - name: jstestfuzz_sharded_continuous_stepdown
  - name: jstestfuzz_sharded_session
  - name: mmap
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
    distros:
    - windows-64-vs2015-large
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
    distros:
    - windows-64-vs2015-large
  - name: replica_sets_initsync_jscore_passthrough
    distros:
    - windows-64-vs2015-large
  - name: replica_sets_initsync_static_jscore_passthrough
    distros:
    - windows-64-vs2015-large
  - name: replica_sets_jscore_passthrough
    distros:
    - windows-64-vs2015-large
  - name: replica_sets_resync_static_jscore_passthrough
    distros:
    - windows-64-vs2015-large
  - name: rollback_fuzzer
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding
    distros:
    - windows-64-vs2015-large
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: slow1
  - name: snmp
  - name: tool
  - name: update_fuzzer
  - name: update_fuzzer_replication

- name: enterprise-osx-1010-mmapv1
  display_name: Enterprise OS X 10.10 MMAPv1
  modules:
  - enterprise
  run_on:
  - macos-1012
  batchtime: 1440 # 1 day
  expansions:
    test_flags: --storageEngine=mmapv1 --excludeWithAnyTags=requires_wiredtiger
    tooltags: "-tags 'ssl sasl openssl_pre_1.0'"
    gorootvars: >-
      CGO_CPPFLAGS=-I/opt/mongodbtoolchain/v2/include CGO_CFLAGS=-mmacosx-version-min=10.10
      CGO_LDFLAGS=-mmacosx-version-min=10.10
    compile_env: DEVELOPER_DIR=/Applications/Xcode8.3.app
    compile_flags: >-
      --ssl -j$(sysctl -n hw.logicalcpu) --release --libc++ CCFLAGS="-mmacosx-version-min=10.10"
      LINKFLAGS="-mmacosx-version-min=10.10" CPPPATH=/opt/mongodbtoolchain/v2/include
    multiversion_platform: osx
    multiversion_edition: enterprise
    num_jobs_available: 1
    build_mongoreplay: true
  tasks:
  - name: compile
  - name: aggregation
  - name: aggregation_fuzzer
  - name: audit
  - name: auth
  - name: auth_audit
  - name: bulk_gle_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_sharded_causal_consistency
  - name: concurrency_sharded_causal_consistency_and_balancer
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_mmapv1
  - name: dur_jscore_passthrough
  - name: durability
  - name: gle_auth
  - name: gle_auth_basics_passthrough
  - name: gle_auth_basics_passthrough_write_cmd
  - name: gle_auth_write_cmd
  - name: jsCore
  - name: jsCore_compatibility
  - name: jsCore_decimal
  - name: jsCore_op_query
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_replication_session
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_concurrent_sharded_causal_consistency
  - name: jstestfuzz_concurrent_sharded_continuous_stepdown
  - name: jstestfuzz_concurrent_sharded_session
  - name: jstestfuzz_replication
  - name: jstestfuzz_replication_initsync
  - name: jstestfuzz_replication_resync
  - name: jstestfuzz_replication_session
  - name: jstestfuzz_sharded
  - name: jstestfuzz_sharded_causal_consistency
  - name: jstestfuzz_sharded_continuous_stepdown
  - name: jstestfuzz_sharded_session
  - name: mmap
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: read_concern_linearizable_passthrough
  - name: read_only
  - name: read_only_sharded
  - name: replica_sets
  - name: replica_sets_initsync_jscore_passthrough
  - name: replica_sets_initsync_static_jscore_passthrough
  - name: replica_sets_jscore_passthrough
  - name: replica_sets_resync_static_jscore_passthrough
  - name: rollback_fuzzer
  - name: serial_run
  - name: sharded_collections_jscore_passthrough
  - name: sharding_gle_auth_basics_passthrough
  - name: sharding_gle_auth_basics_passthrough_write_cmd
  - name: sharding_jscore_passthrough
  - name: slow1
  - name: tool
  - name: update_fuzzer
  - name: update_fuzzer_replication

- name: linux-64-duroff-mmapv1
  display_name: Linux (No Journal) MMAPv1
  run_on:
  - rhel62-small
  batchtime: 1440 # 1 day
  expansions:
    push_path: linux
    push_bucket: downloads.mongodb.org
    push_name: linux-duroff
    push_arch: x86_64
    compile_flags: -j$(grep -c ^processor /proc/cpuinfo) --variables-files=etc/scons/mongodbtoolchain_gcc.vars
    num_jobs_available: $(grep -c ^processor /proc/cpuinfo)
    test_flags: --nojournal --storageEngine=mmapv1 --excludeWithAnyTags=requires_wiredtiger,requires_journaling
    use_scons_cache: true
    build_mongoreplay: false
  tasks:
  - name: compile
    distros:
    - rhel62-large
  - name: compile_all
    distros:
    - rhel62-large
  - name: aggregation
  - name: aggregation_auth
  - name: aggregation_fuzzer
  - name: auth
  - name: bulk_gle_passthrough
  - name: concurrency
  - name: concurrency_replication
  - name: concurrency_sharded
  - name: concurrency_simultaneous
  - name: dbtest
  - name: disk_mmapv1
  - name: durability
  - name: dur_jscore_passthrough
  - name: failpoints
  - name: failpoints_auth
  - name: jsCore
  - name: jsCore_auth
  - name: jsCore_compatibility
  - name: jstestfuzz
  - name: jstestfuzz_concurrent
  - name: jstestfuzz_concurrent_replication
  - name: jstestfuzz_concurrent_sharded
  - name: jstestfuzz_replication
  - name: jstestfuzz_sharded
  - name: mmap
  - name: noPassthrough
  - name: noPassthroughWithMongod
  - name: parallel
  - name: parallel_compatibility
  - name: replica_sets
  - name: replica_sets_auth
  - name: replica_sets_jscore_passthrough
  - name: serial_run
  - name: sharding
  - name: sharding_auth
  - name: sharding_jscore_passthrough
  - name: slow1
  - name: tool