SConstruct

# -*- mode: python; -*-
import atexit
import copy
import datetime
import errno
import json
import os
import re
import shlex
import shutil
import stat
import subprocess
import sys
import textwrap
import uuid

import SCons

# This must be first, even before EnsureSConsVersion, if
# we are to avoid bulk loading all tools in the DefaultEnvironment.
DefaultEnvironment(tools=[])

# These come from site_scons/mongo. Import these things
# after calling DefaultEnvironment, for the sake of paranoia.
import mongo
import mongo.platform as mongo_platform
import mongo.toolchain as mongo_toolchain
import mongo.generators as mongo_generators

EnsurePythonVersion(3, 6)
EnsureSConsVersion(3, 1, 1)

# Monkey patch SCons.FS.File.release_target_info to be a no-op.
# See https://github.com/SCons/scons/issues/3454
def release_target_info_noop(self):
    pass
SCons.Node.FS.File.release_target_info = release_target_info_noop

from buildscripts import utils
from buildscripts import moduleconfig

import libdeps
import psutil

scons_invocation = '{} {}'.format(sys.executable, ' '.join(sys.argv))
print('scons: running with args {}'.format(scons_invocation))

atexit.register(mongo.print_build_failures)

def add_option(name, **kwargs):

    if 'dest' not in kwargs:
        kwargs['dest'] = name

    if 'metavar' not in kwargs and kwargs.get('type', None) == 'choice':
        kwargs['metavar'] = '[' + '|'.join(kwargs['choices']) + ']'

    AddOption('--' + name, **kwargs)

def get_option(name):
    return GetOption(name)

def has_option(name):
    optval = GetOption(name)
    # Options with nargs=0 are true when their value is the empty tuple. Otherwise,
    # if the value is falsish (empty string, None, etc.), coerce to False.
    return True if optval == () else bool(optval)

def use_system_version_of_library(name):
    return has_option('use-system-all') or has_option('use-system-' + name)

# Returns true if we have been configured to use a system version of any C++ library. If you
# add a new C++ library dependency that may be shimmed out to the system, add it to the below
# list.
def using_system_version_of_cxx_libraries():
    cxx_library_names = ["tcmalloc", "boost"]
    return True in [use_system_version_of_library(x) for x in cxx_library_names]

def make_variant_dir_generator():
    memoized_variant_dir = [False]
    def generate_variant_dir(target, source, env, for_signature):
        if not memoized_variant_dir[0]:
            memoized_variant_dir[0] = env.subst('$BUILD_ROOT/$VARIANT_DIR')
        return memoized_variant_dir[0]
    return generate_variant_dir


# Always randomize the build order to shake out missing edges, and to help the cache:
# http://scons.org/doc/production/HTML/scons-user/ch24s06.html
SetOption('random', 1)

# Options TODOs:
#
# - We should either alphabetize the entire list of options, or split them into logical groups
#   with clear boundaries, and then alphabetize the groups. There is no way in SCons though to
#   inform it of options groups.
#
# - Many of these options are currently only either present or absent. This is not good for
#   scripting the build invocation because it means you need to interpolate in the presence of
#   the whole option. It is better to make all options take an optional on/off or true/false
#   using the nargs='const' mechanism.
#

add_option('ninja',
    choices=['stable', 'next', 'disabled'],
    default='disabled',
    nargs='?',
    const='stable',
    type='choice',
    help='Enable the build.ninja generator tool stable or canary version',
)

add_option('prefix',
    help='installation prefix (conficts with DESTDIR, PREFIX, and --install-mode=hygienic)',
)

add_option('legacy-tarball',
    choices=['true', 'false'],
    default='false',
    const='true',
    nargs='?',
    type='choice',
    help='Build a tarball matching the old MongoDB dist targets',
)

add_option('lint-scope',
    choices=['all', 'changed'],
    default='all',
    type='choice',
    help='Lint files in the current git diff instead of all files'
)

add_option('install-mode',
    choices=['legacy', 'hygienic'],
    default='legacy',
    help='select type of installation',
    nargs=1,
    type='choice',
)

add_option('nostrip',
    help='do not strip installed binaries',
    nargs=0,
)

add_option('build-dir',
    default='#build',
    help='build output directory',
)

add_option('release',
    help='release build',
    nargs=0,
)

add_option('lto',
    help='enable link time optimizations (experimental, except with MSVC)',
    nargs=0,
)

add_option('endian',
    choices=['big', 'little', 'auto'],
    default='auto',
    help='endianness of target platform',
    nargs=1,
    type='choice',
)

add_option('disable-minimum-compiler-version-enforcement',
    help='allow use of unsupported older compilers (NEVER for production builds)',
    nargs=0,
)

add_option('ssl',
    help='Enable or Disable SSL',
    choices=['on', 'off'],
    default='on',
    const='on',
    nargs='?',
    type='choice',
)

add_option('wiredtiger',
    choices=['on', 'off'],
    const='on',
    default='on',
    help='Enable wiredtiger',
    nargs='?',
    type='choice',
)

js_engine_choices = ['mozjs', 'none']
add_option('js-engine',
    choices=js_engine_choices,
    default=js_engine_choices[0],
    help='JavaScript scripting engine implementation',
    type='choice',
)

add_option('server-js',
    choices=['on', 'off'],
    default='on',
    help='Build mongod without JavaScript support',
    type='choice',
)

add_option('libc++',
    help='use libc++ (experimental, requires clang)',
    nargs=0,
)

add_option('use-glibcxx-debug',
    help='Enable the glibc++ debug implementations of the C++ standard libary',
    nargs=0,
)

add_option('noshell',
    help="don't build shell",
    nargs=0,
)

add_option('safeshell',
    help="don't let shell scripts run programs (still, don't run untrusted scripts)",
    nargs=0,
)

add_option('dbg',
    choices=['on', 'off'],
    const='on',
    default='off',
    help='Enable runtime debugging checks',
    nargs='?',
    type='choice',
)

add_option('separate-debug',
    choices=['on', 'off'],
    const='on',
    default='off',
    help='Produce separate debug files (only effective in --install-mode=hygienic)',
    nargs='?',
    type='choice',
)

add_option('spider-monkey-dbg',
    choices=['on', 'off'],
    const='on',
    default='off',
    help='Enable SpiderMonkey debug mode',
    nargs='?',
    type='choice',
)

add_option('opt',
    choices=['on', 'size', 'off'],
    const='on',
    help='Enable compile-time optimization',
    nargs='?',
    type='choice',
)

add_option('sanitize',
    help='enable selected sanitizers',
    metavar='san1,san2,...sanN',
)

add_option('sanitize-coverage',
    help='enable selected coverage sanitizers',
    metavar='cov1,cov2,...covN',
)

add_option('llvm-symbolizer',
    default='llvm-symbolizer',
    help='name of (or path to) the LLVM symbolizer',
)

add_option('durableDefaultOn',
    help='have durable default to on',
    nargs=0,
)

add_option('allocator',
    choices=["auto", "system", "tcmalloc", "tcmalloc-experimental"],
    default="auto",
    help='allocator to use (use "auto" for best choice for current platform)',
    type='choice',
)

add_option('gdbserver',
    help='build in gdb server support',
    nargs=0,
)

add_option('lldb-server',
    help='build in lldb server support',
    nargs=0,
)

add_option('gcov',
    help='compile with flags for gcov',
    nargs=0,
)

add_option('enable-free-mon',
    choices=["auto", "on", "off"],
    default="auto",
    help='Disable support for Free Monitoring to avoid HTTP client library dependencies',
    type='choice',
)

add_option('enable-http-client',
    choices=["auto", "on", "off"],
    default="auto",
    help='Enable support for HTTP client requests (required WinHTTP or cURL)',
    type='choice',
)

add_option('use-sasl-client',
    help='Support SASL authentication in the client library',
    nargs=0,
)

add_option('use-diagnostic-latches',
    choices=['on', 'off'],
    default='on',
    help='Enable annotated Mutex types',
    type='choice',
)

# Most of the "use-system-*" options follow a simple form.
for pack in [
    ('abseil-cpp',),
    ('asio', 'ASIO',),
    ('boost',),
    ('fmt',),
    ('google-benchmark', 'Google benchmark'),
    ('icu', 'ICU'),
    ('intel_decimal128', 'intel decimal128'),
    ('kms-message',),
    ('pcre',),
    ('snappy',),
    ('stemmer',),
    ('tcmalloc',),
    ('libunwind',),
    ('valgrind',),
    ('wiredtiger',),
    ('yaml',),
    ('zlib',),
    ('zstd', 'Zstandard'),
    ]:
    name = pack[0]
    pretty = name
    if len(pack) == 2:
        pretty = pack[1]
    add_option(f'use-system-{name}',
               help=f'use system version of {pretty} library',
               nargs=0)

add_option('system-boost-lib-search-suffixes',
    help='Comma delimited sequence of boost library suffixes to search',
)

add_option('use-system-mongo-c',
    choices=['on', 'off', 'auto'],
    const='on',
    default="auto",
    help="use system version of the mongo-c-driver (auto will use it if it's found)",
    nargs='?',
    type='choice',
)

add_option('use-system-all',
    help='use all system libraries',
    nargs=0,
)

add_option('build-fast-and-loose',
    choices=['on', 'off', 'auto'],
    const='on',
    default='auto',
    help='looser dependency checking',
    nargs='?',
    type='choice',
)

add_option('disable-warnings-as-errors',
    help="Don't add -Werror to compiler command line",
    nargs=0,
)

add_option('detect-odr-violations',
    help="Have the linker try to detect ODR violations, if supported",
    nargs=0,
)

add_option('variables-help',
    help='Print the help text for SCons variables',
    nargs=0,
)

add_option('osx-version-min',
    help='minimum OS X version to support',
)

# https://docs.microsoft.com/en-us/cpp/porting/modifying-winver-and-win32-winnt?view=vs-2017
# https://docs.microsoft.com/en-us/windows-server/get-started/windows-server-release-info
win_version_min_choices = {
    'win10'    : ('0A00', '0000'),
    'ws2016'   : ('0A00', '1607'),
    'ws2019'   : ('0A00', '1809')
}

add_option('win-version-min',
    choices=list(win_version_min_choices.keys()),
    default=None,
    help='minimum Windows version to support',
    type='choice',
)

add_option('cache',
    choices=["all", "nolinked"],
    const='all',
    help='Use an object cache rather than a per-build variant directory (experimental)',
    nargs='?',
)

add_option('cache-dir',
    default='$BUILD_ROOT/scons/cache',
    help='Specify the directory to use for caching objects if --cache is in use',
)

add_option("cxx-std",
    choices=["17"],
    default="17",
    help="Select the C++ langauge standard to build with",
)

def find_mongo_custom_variables():
    files = []
    paths = [path for path in sys.path if 'site_scons' in path]
    for path in paths:
        probe = os.path.join(path, 'mongo_custom_variables.py')
        if os.path.isfile(probe):
            files.append(probe)
    return files

add_option('variables-files',
    default=[],
    action="append",
    help="Specify variables files to load.",
)

link_model_choices = ['auto', 'object', 'static', 'dynamic', 'dynamic-strict', 'dynamic-sdk']
add_option('link-model',
    choices=link_model_choices,
    default='auto',
    help='Select the linking model for the project',
    type='choice'
)

variable_parse_mode_choices=['auto', 'posix', 'other']
add_option('variable-parse-mode',
    choices=variable_parse_mode_choices,
    default=variable_parse_mode_choices[0],
    help='Select which parsing mode is used to interpret command line variables',
    type='choice',
)

add_option('modules',
    help="Comma-separated list of modules to build. Empty means none. Default is all.",
)

add_option('runtime-hardening',
    choices=["on", "off"],
    default="on",
    help="Enable runtime hardening features (e.g. stack smash protection)",
    type='choice',
)

add_option('use-hardware-crc32',
    choices=["on", "off"],
    default="on",
    help="Enable CRC32 hardware accelaration",
    type='choice',
)

add_option('git-decider',
    choices=["on", "off"],
    const='on',
    default="off",
    help="Use git metadata for out-of-date detection for source files",
    nargs='?',
    type="choice",
)

add_option('toolchain-root',
    default=None,
    help="Names a toolchain root for use with toolchain selection Variables files in etc/scons",
)

add_option('msvc-debugging-format',
    choices=["codeview", "pdb"],
    default="codeview",
    help='Debugging format in debug builds using msvc. Codeview (/Z7) or Program database (/Zi). Default is codeview.',
    type='choice',
)

add_option('use-libunwind',
    choices=["on", "off", "auto"],
    const="on",
    default="auto",
    help="Enable libunwind for backtraces",
    nargs="?",
    type='choice',
)

add_option('jlink',
        help="Limit link concurrency. Takes either an integer to limit to or a"
        " float between 0 and 1.0 whereby jobs will be multiplied to get the final"
        " jlink value."
        "\n\nExample: --jlink=0.75 --jobs 8 will result in a jlink value of 6",
        const=0.5,
        default=None,
        nargs='?',
        type=float)

add_option('enable-usdt-probes',
	choices=["on", "off", "auto"],
	default="auto",
	help='Enables USDT probes. Default is auto, which is enabled only on Linux with SystemTap headers',
	type='choice',
    nargs='?',
    const='on',
)

try:
    with open("version.json", "r") as version_fp:
        version_data = json.load(version_fp)

    if 'version' not in version_data:
        print("version.json does not contain a version string")
        Exit(1)
    if 'githash' not in version_data:
        version_data['githash'] = utils.get_git_version()

except IOError as e:
    # If the file error wasn't because the file is missing, error out
    if e.errno != errno.ENOENT:
        print(("Error opening version.json: {0}".format(e.strerror)))
        Exit(1)

    version_data = {
        'version': utils.get_git_describe()[1:],
        'githash': utils.get_git_version(),
    }

except ValueError as e:
    print(("Error decoding version.json: {0}".format(e)))
    Exit(1)

# Setup the command-line variables
def variable_shlex_converter(val):
    # If the argument is something other than a string, propogate
    # it literally.
    if not isinstance(val, str):
        return val
    parse_mode = get_option('variable-parse-mode')
    if parse_mode == 'auto':
        parse_mode = 'other' if mongo_platform.is_running_os('windows') else 'posix'
    return shlex.split(val, posix=(parse_mode == 'posix'))

def variable_arch_converter(val):
    arches = {
        'x86_64': 'x86_64',
        'amd64':  'x86_64',
        'emt64':   'x86_64',
        'x86':    'i386',
    }
    val = val.lower()

    if val in arches:
        return arches[val]

    # Uname returns a bunch of possible x86's on Linux.
    # Check whether the value is an i[3456]86 processor.
    if re.match(r'^i[3-6]86$', val):
        return 'i386'

    # Return whatever val is passed in - hopefully it's legit
    return val

# The Scons 'default' tool enables a lot of tools that we don't actually need to enable.
# On platforms like Solaris, it actually does the wrong thing by enabling the sunstudio
# toolchain first. As such it is simpler and more efficient to manually load the precise
# set of tools we need for each platform.
# If we aren't on a platform where we know the minimal set of tools, we fall back to loading
# the 'default' tool.
def decide_platform_tools():
    if mongo_platform.is_running_os('windows'):
        # we only support MS toolchain on windows
        return ['msvc', 'mslink', 'mslib', 'masm', 'vcredist']
    elif mongo_platform.is_running_os('linux', 'solaris'):
        return ['gcc', 'g++', 'gnulink', 'ar', 'gas']
    elif mongo_platform.is_running_os('darwin'):
        return ['gcc', 'g++', 'applelink', 'ar', 'libtool', 'as', 'xcode']
    else:
        return ["default"]

def variable_tools_converter(val):
    tool_list = shlex.split(val)
    # This list is not sorted intentionally, the order of tool loading
    # matters as some of the tools have dependencies on other tools.
    return tool_list + [
        "distsrc",
        "gziptool",
        "idl_tool",
        "jsheader",
        "mongo_test_execution",
        "mongo_test_list",
        "mongo_benchmark",
        "mongo_integrationtest",
        "mongo_unittest",
        "mongo_libfuzzer",
        "textfile",
    ]

def variable_distsrc_converter(val):
    if not val.endswith("/"):
        return val + "/"
    return val

# Apply the default variables files, and walk the provided
# arguments. Interpret any falsy argument (like the empty string) as
# resetting any prior state. This makes the argument
# --variables-files= destructive of any prior variables files
# arguments, including the default.
variables_files_args = get_option('variables-files')
variables_files = find_mongo_custom_variables()
for variables_file in variables_files_args:
    if variables_file:
        variables_files.append(variables_file)
    else:
        variables_files = []
for vf in variables_files:
    if os.path.isfile(vf):
        print("Using variable customization file {}".format(vf))
    else:
        print("IGNORING missing variable customization file {}".format(vf))

# Attempt to prevent confusion between the different ways of
# specifying file placement between hygienic and non-hygienic
# modes. Re-interpret a value provided for the legacy '--prefix' flag
# as setting `DESTDIR` instead. Note that we can't validate things
# passed in via variables_files, so this is imperfect. However, it is
# also temporary.
if get_option('install-mode') == 'hygienic':
    if has_option('prefix'):
        print("Cannot use the '--prefix' option with '--install-mode=hygienic'. Use the DESTDIR and PREFIX Variables instead")
        Exit(1)
else:
    if 'PREFIX' in ARGUMENTS:
        print("Cannot use the 'PREFIX' Variable without '--install-mode=hygienic'")
        Exit(1)
    if 'DESTDIR' in ARGUMENTS:
        print("Cannot use the 'DESTDIR' Variable without '--install-mode=hygienic', use the '--prefix' flag instead")
        Exit(1)

    if has_option('prefix'):
        ARGUMENTS['DESTDIR'] = get_option('prefix')

env_vars = Variables(
    files=variables_files,
    args=ARGUMENTS
)

sconsflags = os.environ.get('SCONSFLAGS', None)
if sconsflags:
    print(("Using SCONSFLAGS environment variable arguments: %s" % sconsflags))

env_vars.Add('ABIDW',
    help="Configures the path to the 'abidw' (a libabigail) utility")

env_vars.Add('AR',
    help='Sets path for the archiver')

env_vars.Add('ARFLAGS',
    help='Sets flags for the archiver',
    converter=variable_shlex_converter)

env_vars.Add('CCACHE',
    help='Tell SCons where the ccache binary is')

env_vars.Add(
    'CACHE_SIZE',
    help='Maximum size of the SCons cache (in gigabytes)',
    default=32,
    converter=lambda x:int(x)
)

env_vars.Add(
    'CACHE_PRUNE_TARGET',
    help='Maximum percent in-use in SCons cache after pruning',
    default=66,
    converter=lambda x:int(x)
)

env_vars.Add('CC',
    help='Select the C compiler to use')

env_vars.Add('CCFLAGS',
    help='Sets flags for the C and C++ compiler',
    converter=variable_shlex_converter)

env_vars.Add('CFLAGS',
    help='Sets flags for the C compiler',
    converter=variable_shlex_converter)

env_vars.Add('CPPDEFINES',
    help='Sets pre-processor definitions for C and C++',
    converter=variable_shlex_converter,
    default=[])

env_vars.Add('CPPPATH',
    help='Adds paths to the preprocessor search path',
    converter=variable_shlex_converter)

env_vars.Add('CXX',
    help='Select the C++ compiler to use')

env_vars.Add('CXXFLAGS',
    help='Sets flags for the C++ compiler',
    converter=variable_shlex_converter)

env_vars.Add('DESTDIR',
    help='Where hygienic builds will install files',
    default='$BUILD_ROOT/install')

env_vars.Add('GITDIFFFLAGS',
    help='Sets flags for git diff',
    default='')

env_vars.Add('REVISION',
    help='Base git revision',
    default='')

env_vars.Add('ENTERPRISE_REV',
    help='Base git revision of enterprise modules',
    default='')

# Note: This probably is only really meaningful when configured via a variables file. It will
# also override whatever the SCons platform defaults would be.
env_vars.Add('ENV',
    help='Sets the environment for subprocesses')

env_vars.Add('FRAMEWORKPATH',
    help='Adds paths to the linker search path for darwin frameworks',
    converter=variable_shlex_converter)

env_vars.Add('FRAMEWORKS',
    help='Adds extra darwin frameworks to link against',
    converter=variable_shlex_converter)

env_vars.Add('HOST_ARCH',
    help='Sets the native architecture of the compiler',
    converter=variable_arch_converter,
    default=None)

env_vars.Add('ICECC',
    help='Tell SCons where icecream icecc tool is')

env_vars.Add('ICERUN',
    help='Tell SCons where icecream icerun tool is')

env_vars.Add('ICECC_CREATE_ENV',
    help='Tell SCons where icecc-create-env tool is',
    default='icecc-create-env')

env_vars.Add('ICECC_SCHEDULER',
    help='Tell ICECC where the sceduler daemon is running')

env_vars.Add('ICECC_VERSION',
    help='Tell ICECC where the compiler package is')

env_vars.Add('ICECC_VERSION_ARCH',
    help='Tell ICECC the target archicture for the compiler package, if non-native')

env_vars.Add('LIBPATH',
    help='Adds paths to the linker search path',
    converter=variable_shlex_converter)

env_vars.Add('LIBS',
    help='Adds extra libraries to link against',
    converter=variable_shlex_converter)

env_vars.Add('LINKFLAGS',
    help='Sets flags for the linker',
    converter=variable_shlex_converter)

env_vars.Add('MAXLINELENGTH',
    help='Maximum line length before using temp files',
    # This is very small, but appears to be the least upper bound
    # across our platforms.
    #
    # See https://support.microsoft.com/en-us/help/830473/command-prompt-cmd.-exe-command-line-string-limitation
    default=4095)

# Note: This is only really meaningful when configured via a variables file. See the
# default_buildinfo_environment_data() function for examples of how to use this.
env_vars.Add('MONGO_BUILDINFO_ENVIRONMENT_DATA',
    help='Sets the info returned from the buildInfo command and --version command-line flag',
    default=mongo_generators.default_buildinfo_environment_data())

env_vars.Add('MONGO_DIST_SRC_PREFIX',
    help='Sets the prefix for files in the source distribution archive',
    converter=variable_distsrc_converter,
    default="mongodb-src-r${MONGO_VERSION}")

env_vars.Add('MONGO_DISTARCH',
    help='Adds a string representing the target processor architecture to the dist archive',
    default='$TARGET_ARCH')

env_vars.Add('MONGO_DISTMOD',
    help='Adds a string that will be embedded in the dist archive naming',
    default='')

env_vars.Add('MONGO_DISTNAME',
    help='Sets the version string to be used in dist archive naming',
    default='$MONGO_VERSION')

def validate_mongo_version(key, val, env):
    regex = r'^(\d+)\.(\d+)\.(\d+)-?((?:(rc)(\d+))?.*)?'
    if not re.match(regex, val):
        print(("Invalid MONGO_VERSION '{}', or could not derive from version.json or git metadata. Please add a conforming MONGO_VERSION=x.y.z[-extra] as an argument to SCons".format(val)))
        Exit(1)

env_vars.Add('MONGO_VERSION',
    help='Sets the version string for MongoDB',
    default=version_data['version'],
    validator=validate_mongo_version)

env_vars.Add('MONGO_GIT_HASH',
    help='Sets the githash to store in the MongoDB version information',
    default=version_data['githash'])

env_vars.Add('MSVC_USE_SCRIPT',
    help='Sets the script used to setup Visual Studio.')

env_vars.Add('MSVC_VERSION',
    help='Sets the version of Visual C++ to use (e.g. 14.1 for VS2017, 14.2 for VS2019)',
    default="14.2")

env_vars.Add('NINJA_PREFIX',
    default="build",
    help="""A prefix to add to the beginning of generated ninja
files. Useful for when compiling multiple build ninja files for
different configurations, for instance:

    scons --sanitize=asan --ninja NINJA_PREFIX=asan asan.ninja
    scons --sanitize=tsan --ninja NINJA_PREFIX=tsan tsan.ninja

Will generate the files (respectively):

    asan.ninja
    tsan.ninja

Defaults to build, best used with the generate-ninja alias so you don't have to
reiterate the prefix in the target name and variable.
""")


env_vars.Add('NINJA_SUFFIX',
    help="""A suffix to add to the end of generated build.ninja
files. Useful for when compiling multiple build ninja files for
different configurations, for instance:

    scons --sanitize=asan --ninja NINJA_SUFFIX=asan build.ninja
    scons --sanitize=tsan --ninja NINJA_SUFFIX=tsan build.ninja

Will generate the files (respectively):

    build.ninja.asan
    build.ninja.tsan
""")

env_vars.Add('__NINJA_NO',
    help="Disable the Ninja tool unconditionally. Not intended for human use.",
    default=0)


env_vars.Add('OBJCOPY',
    help='Sets the path to objcopy',
    default=WhereIs('objcopy'))


env_vars.Add('PKGDIR',
    help='Directory in which to build packages and archives',
    default='$VARIANT_DIR/pkgs')

env_vars.Add('PREFIX',
    help='Final installation location of files, will be made into a sub dir of $DESTDIR',
    default='')

# Exposed to be able to cross compile Android/*nix from Windows without ending up with the .exe suffix.
env_vars.Add('PROGSUFFIX',
    help='Sets the suffix for built executable files')

env_vars.Add('RPATH',
    help='Set the RPATH for dynamic libraries and executables',
    converter=variable_shlex_converter)

env_vars.Add('SHCCFLAGS',
    help='Sets flags for the C and C++ compiler when building shared libraries',
    converter=variable_shlex_converter)

env_vars.Add('SHCFLAGS',
    help='Sets flags for the C compiler when building shared libraries',
    converter=variable_shlex_converter)

env_vars.Add('SHCXXFLAGS',
    help='Sets flags for the C++ compiler when building shared libraries',
    converter=variable_shlex_converter)

env_vars.Add('SHELL',
    help='Pick the shell to use when spawning commands')

env_vars.Add('SHLINKFLAGS',
    help='Sets flags for the linker when building shared libraries',
    converter=variable_shlex_converter)

env_vars.Add('TARGET_ARCH',
    help='Sets the architecture to build for',
    converter=variable_arch_converter,
    default=None)

env_vars.Add('TARGET_OS',
    help='Sets the target OS to build for',
    default=mongo_platform.get_running_os_name())

env_vars.Add('TOOLS',
    help='Sets the list of SCons tools to add to the environment',
    converter=variable_tools_converter,
    default=decide_platform_tools())

env_vars.Add('VARIANT_DIR',
    help='Sets the name (or generator function) for the variant directory',
    default=mongo_generators.default_variant_dir_generator,
)

env_vars.Add('VERBOSE',
    help='Control build verbosity (auto, on/off true/false 1/0)',
    default='auto',
)

env_vars.Add('WINDOWS_OPENSSL_BIN',
    help='Sets the path to the openssl binaries for packaging',
    default='c:/openssl/bin')

# -- Validate user provided options --

# A dummy environment that should *only* have the variables we have set. In practice it has
# some other things because SCons isn't quite perfect about keeping variable initialization
# scoped to Tools, but it should be good enough to do validation on any Variable values that
# came from the command line or from loaded files.
variables_only_env = Environment(
    # Disable platform specific variable injection
    platform=(lambda x: ()),
    # But do *not* load any tools, since those might actually set variables. Note that this
    # causes the value of our TOOLS variable to have no effect.
    tools=[],
    # Use the Variables specified above.
    variables=env_vars,
)

# don't run configure if user calls --help
if GetOption('help'):
    try:
        Help('\nThe following variables may also be set like scons VARIABLE=value\n', append=True)
        Help(env_vars.GenerateHelpText(variables_only_env), append=True)
    except TypeError:
        # The append=true kwarg is only supported in scons>=2.4. Without it, calls to Help() clobber
        # the automatically generated options help, which we don't want. Users on older scons
        # versions will need to use --variables-help to learn about which variables we support.
        pass

    Return()

if ('CC' in variables_only_env) != ('CXX' in variables_only_env):
    print('Cannot customize C compiler without customizing C++ compiler, and vice versa')
    Exit(1)

# --- environment setup ---

# If the user isn't using the # to indicate top-of-tree or $ to expand a variable, forbid
# relative paths. Relative paths don't really work as expected, because they end up relative to
# the top level SConstruct, not the invokers CWD. We could in theory fix this with
# GetLaunchDir, but that seems a step too far.
buildDir = get_option('build-dir').rstrip('/')
if buildDir[0] not in ['$', '#']:
    if not os.path.isabs(buildDir):
        print("Do not use relative paths with --build-dir")
        Exit(1)

cacheDir = get_option('cache-dir').rstrip('/')
if cacheDir[0] not in ['$', '#']:
    if not os.path.isabs(cacheDir):
        print("Do not use relative paths with --cache-dir")
        Exit(1)

sconsDataDir = Dir(buildDir).Dir('scons')
SConsignFile(str(sconsDataDir.File('sconsign.py3')))

def printLocalInfo():
    import sys, SCons
    print(( "scons version: " + SCons.__version__ ))
    print(( "python version: " + " ".join( [ repr(i) for i in sys.version_info ] ) ))

printLocalInfo()

boostLibs = [ "filesystem", "program_options", "system", "iostreams", "thread", "log" ]

onlyServer = len( COMMAND_LINE_TARGETS ) == 0 or ( len( COMMAND_LINE_TARGETS ) == 1 and str( COMMAND_LINE_TARGETS[0] ) in [ "mongod" , "mongos" , "test" ] )

releaseBuild = has_option("release")

dbg_opt_mapping = {
    # --dbg, --opt   :   dbg    opt
    ( "on",  None  ) : ( True,  False ),  # special case interaction
    ( "on",  "on"  ) : ( True,  True ),
    ( "on",  "off" ) : ( True,  False ),
    ( "off", None  ) : ( False, True ),
    ( "off", "on"  ) : ( False, True ),
    ( "off", "off" ) : ( False, False ),
    ( "on",  "size"  ) : ( True,  True ),
    ( "off", "size"  ) : ( False, True ),
}
debugBuild, optBuild = dbg_opt_mapping[(get_option('dbg'), get_option('opt'))]
optBuildForSize = True if optBuild and get_option('opt') == "size" else False

if releaseBuild and (debugBuild or not optBuild):
    print("Error: A --release build may not have debugging, and must have optimization")
    Exit(1)

noshell = has_option( "noshell" )

jsEngine = get_option( "js-engine")

serverJs = get_option( "server-js" ) == "on"

usemozjs = (jsEngine.startswith('mozjs'))

if not serverJs and not usemozjs:
    print("Warning: --server-js=off is not needed with --js-engine=none")

# We defer building the env until we have determined whether we want certain values. Some values
# in the env actually have semantics for 'None' that differ from being absent, so it is better
# to build it up via a dict, and then construct the Environment in one shot with kwargs.
#
# Yes, BUILD_ROOT vs BUILD_DIR is confusing. Ideally, BUILD_DIR would actually be called
# VARIANT_DIR, and at some point we should probably do that renaming. Until we do though, we
# also need an Environment variable for the argument to --build-dir, which is the parent of all
# variant dirs. For now, we call that BUILD_ROOT. If and when we s/BUILD_DIR/VARIANT_DIR/g,
# then also s/BUILD_ROOT/BUILD_DIR/g.
envDict = dict(BUILD_ROOT=buildDir,
               BUILD_DIR=make_variant_dir_generator(),
               DIST_ARCHIVE_SUFFIX='.tgz',
               DIST_BINARIES=[],
               MODULE_BANNERS=[],
               MODULE_INJECTORS=dict(),
               ARCHIVE_ADDITION_DIR_MAP={},
               ARCHIVE_ADDITIONS=[],
               PYTHON="$( {} $)".format(sys.executable),
               SERVER_ARCHIVE='${SERVER_DIST_BASENAME}${DIST_ARCHIVE_SUFFIX}',
               UNITTEST_ALIAS='install-unittests',
               # TODO: Move unittests.txt to $BUILD_DIR, but that requires
               # changes to MCI.
               UNITTEST_LIST='$BUILD_ROOT/unittests.txt',
               LIBFUZZER_TEST_ALIAS='install-fuzzertests',
               LIBFUZZER_TEST_LIST='$BUILD_ROOT/libfuzzer_tests.txt',
               INTEGRATION_TEST_ALIAS='install-integration-tests',
               INTEGRATION_TEST_LIST='$BUILD_ROOT/integration_tests.txt',
               BENCHMARK_ALIAS='install-benchmarks',
               BENCHMARK_LIST='$BUILD_ROOT/benchmarks.txt',
               CONFIGUREDIR='$BUILD_ROOT/scons/$VARIANT_DIR/sconf_temp',
               CONFIGURELOG='$BUILD_ROOT/scons/config.log',
               CONFIG_HEADER_DEFINES={},
               LIBDEPS_TAG_EXPANSIONS=[],
               )

# TODO: Remove these when hygienic builds are default.
if get_option('install-mode') != 'hygienic':
    envDict["UNITTEST_ALIAS"] = "unittests"
    envDict["INTEGRATION_TEST_ALIAS"] = "integration_tests"
    envDict["LIBFUZZER_TEST_ALIAS"] = "libfuzzer_tests"
    envDict["BENCHMARK_ALIAS"] = "benchmarks"

env = Environment(variables=env_vars, **envDict)

# Only print the spinner if stdout is a tty
if sys.stdout.isatty():
    Progress(['-\r', '\\\r', '|\r', '/\r'], interval=50)

del envDict

for var in ['CC', 'CXX']:
    if var not in env:
        continue
    path = env[var]
    print('{} is {}'.format(var, path))
    if not os.path.isabs(path):
        which = shutil.which(path)
        if which is None:
            print('{} was not found in $PATH'.format(path))
        else:
            print('{} found in $PATH at {}'.format(path, which))
            path = which

    realpath = os.path.realpath(path)
    if realpath != path:
        print('{} resolves to {}'.format(path, realpath))

env.AddMethod(mongo_platform.env_os_is_wrapper, 'TargetOSIs')
env.AddMethod(mongo_platform.env_get_os_name_wrapper, 'GetTargetOSName')

def fatal_error(env, msg, *args):
    print(msg.format(*args))
    Exit(1)

def conf_error(env, msg, *args):
    print(msg.format(*args))
    print("See {0} for details".format(env.File('$CONFIGURELOG').abspath))
    Exit(1)

env.AddMethod(fatal_error, 'FatalError')
env.AddMethod(conf_error, 'ConfError')

# Normalize the VERBOSE Option, and make its value available as a
# function.
if env['VERBOSE'] == "auto":
    env['VERBOSE'] = not sys.stdout.isatty()
elif env['VERBOSE'] in ('1', "ON", "on", "True", "true", True):
    env['VERBOSE'] = True
elif env['VERBOSE'] in ('0', "OFF", "off", "False", "false", False):
    env['VERBOSE'] = False
else:
    env.FatalError("Invalid value {0} for VERBOSE Variable", env['VERBOSE'])
env.AddMethod(lambda env: env['VERBOSE'], 'Verbose')

if has_option('variables-help'):
    print(env_vars.GenerateHelpText(env))
    Exit(0)

unknown_vars = env_vars.UnknownVariables()
if unknown_vars:
    env.FatalError("Unknown variables specified: {0}", ", ".join(list(unknown_vars.keys())))

def set_config_header_define(env, varname, varval = 1):
    env['CONFIG_HEADER_DEFINES'][varname] = varval
env.AddMethod(set_config_header_define, 'SetConfigHeaderDefine')

detectEnv = env.Clone()

# Identify the toolchain in use. We currently support the following:
# These macros came from
# http://nadeausoftware.com/articles/2012/10/c_c_tip_how_detect_compiler_name_and_version_using_compiler_predefined_macros
toolchain_macros = {
    'GCC': 'defined(__GNUC__) && !defined(__clang__)',
    'clang': 'defined(__clang__)',
    'MSVC': 'defined(_MSC_VER)'
}

def CheckForToolchain(context, toolchain, lang_name, compiler_var, source_suffix):
    test_body = textwrap.dedent("""
    #if {0}
    /* we are using toolchain {0} */
    #else
    #error
    #endif
    """.format(toolchain_macros[toolchain]))

    print_tuple = (lang_name, context.env[compiler_var], toolchain)
    context.Message('Checking if %s compiler "%s" is %s... ' % print_tuple)

    # Strip indentation from the test body to ensure that the newline at the end of the
    # endif is the last character in the file (rather than a line of spaces with no
    # newline), and that all of the preprocessor directives start at column zero. Both of
    # these issues can trip up older toolchains.
    result = context.TryCompile(test_body, source_suffix)
    context.Result(result)
    return result

endian = get_option( "endian" )

if endian == "auto":
    endian = sys.byteorder

# These preprocessor macros came from
# http://nadeausoftware.com/articles/2012/02/c_c_tip_how_detect_processor_type_using_compiler_predefined_macros
#
# NOTE: Remember to add a trailing comma to form any required one
# element tuples, or your configure checks will fail in strange ways.
processor_macros = {
    'arm'        : { 'endian': 'little', 'defines': ('__arm__',) },
    'aarch64'    : { 'endian': 'little', 'defines': ('__arm64__', '__aarch64__')},
    'i386'       : { 'endian': 'little', 'defines': ('__i386', '_M_IX86')},
    'ppc64le'    : { 'endian': 'little', 'defines': ('__powerpc64__',)},
    's390x'      : { 'endian': 'big',    'defines': ('__s390x__',)},
    'sparc'      : { 'endian': 'big',    'defines': ('__sparc',)},
    'x86_64'     : { 'endian': 'little', 'defines': ('__x86_64', '_M_AMD64')},
    'emscripten' : { 'endian': 'little', 'defines': ('__EMSCRIPTEN__', )},
}

def CheckForProcessor(context, which_arch):
    def run_compile_check(arch):
        full_macros = " || ".join([ "defined(%s)" % (v) for v in processor_macros[arch]['defines']])

        if not endian == processor_macros[arch]['endian']:
            return False

        test_body = """
        #if {0}
        /* Detected {1} */
        #else
        #error not {1}
        #endif
        """.format(full_macros, arch)

        return context.TryCompile(textwrap.dedent(test_body), ".c")

    if which_arch:
        ret = run_compile_check(which_arch)
        context.Message('Checking if target processor is %s ' % which_arch)
        context.Result(ret)
        return ret;

    for k in list(processor_macros.keys()):
        ret = run_compile_check(k)
        if ret:
            context.Result('Detected a %s processor' % k)
            return k

    context.Result('Could not detect processor model/architecture')
    return False

# Taken from http://nadeausoftware.com/articles/2012/01/c_c_tip_how_use_compiler_predefined_macros_detect_operating_system
os_macros = {
    "windows": "defined(_WIN32)",
    "solaris": "defined(__sun)",
    "freebsd": "defined(__FreeBSD__)",
    "openbsd": "defined(__OpenBSD__)",
    "iOS": "defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_SIMULATOR",
    "iOS-sim": "defined(__APPLE__) && TARGET_OS_IOS && TARGET_OS_SIMULATOR",
    "tvOS": "defined(__APPLE__) && TARGET_OS_TV && !TARGET_OS_SIMULATOR",
    "tvOS-sim": "defined(__APPLE__) && TARGET_OS_TV && TARGET_OS_SIMULATOR",
    "watchOS": "defined(__APPLE__) && TARGET_OS_WATCH && !TARGET_OS_SIMULATOR",
    "watchOS-sim": "defined(__APPLE__) && TARGET_OS_WATCH && TARGET_OS_SIMULATOR",

    # NOTE: Once we have XCode 8 required, we can rely on the value of TARGET_OS_OSX. In case
    # we are on an older XCode, use TARGET_OS_MAC and TARGET_OS_IPHONE. We don't need to correct
    # the above declarations since we will never target them with anything other than XCode 8.
    "macOS": "defined(__APPLE__) && (TARGET_OS_OSX || (TARGET_OS_MAC && !TARGET_OS_IPHONE))",
    "linux": "defined(__linux__)",
    "android": "defined(__ANDROID__)",
    "emscripten": "defined(__EMSCRIPTEN__)",
}

def CheckForOS(context, which_os):
    test_body = """
    #if defined(__APPLE__)
    #include <TargetConditionals.h>
    #endif
    #if {0}
    /* detected {1} */
    #else
    #error
    #endif
    """.format(os_macros[which_os], which_os)
    context.Message('Checking if target OS {0} is supported by the toolchain... '.format(which_os))
    ret = context.TryCompile(textwrap.dedent(test_body), ".c")
    context.Result(ret)
    return ret

def CheckForCXXLink(context):
    test_body = """
    #include <iostream>
    #include <cstdlib>

    int main() {
        std::cout << "Hello, World" << std::endl;
        return EXIT_SUCCESS;
    }
    """
    context.Message('Checking that the C++ compiler can link a C++ program... ')
    ret = context.TryLink(textwrap.dedent(test_body), ".cpp")
    context.Result(ret)
    return ret

detectConf = Configure(detectEnv, help=False, custom_tests = {
    'CheckForToolchain' : CheckForToolchain,
    'CheckForProcessor': CheckForProcessor,
    'CheckForOS': CheckForOS,
    'CheckForCXXLink': CheckForCXXLink,
})

if not detectConf.CheckCC():
    env.ConfError(
        "C compiler {0} doesn't work",
        detectEnv['CC'])

if not detectConf.CheckCXX():
    env.ConfError(
        "C++ compiler {0} doesn't work",
        detectEnv['CXX'])

if not detectConf.CheckForCXXLink():
    env.ConfError(
        "C++ compiler {0} can't link C++ programs",
        detectEnv['CXX'])

toolchain_search_sequence = [ "GCC", "clang" ]
if mongo_platform.is_running_os('windows'):
    toolchain_search_sequence = [ 'MSVC', 'clang', 'GCC' ]
for candidate_toolchain in toolchain_search_sequence:
    if detectConf.CheckForToolchain(candidate_toolchain, "C++", "CXX", ".cpp"):
        detected_toolchain = candidate_toolchain
        break

if not detected_toolchain:
    env.ConfError("Couldn't identify the C++ compiler")

if not detectConf.CheckForToolchain(detected_toolchain, "C", "CC", ".c"):
    env.ConfError("C compiler does not match identified C++ compiler")

# Now that we've detected the toolchain, we add methods to the env
# to get the canonical name of the toolchain and to test whether
# scons is using a particular toolchain.
def get_toolchain_name(self):
    return detected_toolchain.lower()
def is_toolchain(self, *args):
    actual_toolchain = self.ToolchainName()
    for v in args:
        if v.lower() == actual_toolchain:
            return True
    return False

env.AddMethod(get_toolchain_name, 'ToolchainName')
env.AddMethod(is_toolchain, 'ToolchainIs')

if env['TARGET_ARCH']:
    if not detectConf.CheckForProcessor(env['TARGET_ARCH']):
        env.ConfError("Could not detect processor specified in TARGET_ARCH variable")
else:
    detected_processor = detectConf.CheckForProcessor(None)
    if not detected_processor:
        env.ConfError("Failed to detect a supported target architecture")
    env['TARGET_ARCH'] = detected_processor

if env['TARGET_OS'] not in os_macros:
    print("No special config for [{0}] which probably means it won't work".format(env['TARGET_OS']))
elif not detectConf.CheckForOS(env['TARGET_OS']):
    env.ConfError("TARGET_OS ({0}) is not supported by compiler", env['TARGET_OS'])

detectConf.Finish()

env['CC_VERSION'] = mongo_toolchain.get_toolchain_ver(env, 'CC')
env['CXX_VERSION'] = mongo_toolchain.get_toolchain_ver(env, 'CXX')

if not env['HOST_ARCH']:
    env['HOST_ARCH'] = env['TARGET_ARCH']

# In some places we have POSIX vs Windows cpp files, and so there's an additional
# env variable to interpolate their names in child sconscripts

env['TARGET_OS_FAMILY'] = 'posix' if env.TargetOSIs('posix') else env.GetTargetOSName()

# Currently we only use tcmalloc on windows and linux x86_64. Other
# linux targets (power, s390x, arm) do not currently support tcmalloc.
#
# Normalize the allocator option and store it in the Environment. It
# would be nicer to use SetOption here, but you can't reset user
# options for some strange reason in SCons. Instead, we store this
# option as a new variable in the environment.
if get_option('allocator') == "auto":
    # using an allocator besides system on android would require either fixing or disabling
    # gperftools on android
    if env.TargetOSIs('windows') or \
       env.TargetOSIs('linux') and not env.TargetOSIs('android'):
        env['MONGO_ALLOCATOR'] = "tcmalloc"
    else:
        env['MONGO_ALLOCATOR'] = "system"
else:
    env['MONGO_ALLOCATOR'] = get_option('allocator')

if has_option("cache"):
    if has_option("gcov"):
        env.FatalError("Mixing --cache and --gcov doesn't work correctly yet. See SERVER-11084")
    env.CacheDir(str(env.Dir(cacheDir)))

# Normalize the link model. If it is auto, then for now both developer and release builds
# use the "static" mode. Somday later, we probably want to make the developer build default
# dynamic, but that will require the hygienic builds project.
link_model = get_option('link-model')
if link_model == "auto":
    link_model = "static"

# libunwind configuration.
# In which the following globals are set and normalized to bool:
#     - use_libunwind
#     - use_system_libunwind
#     - use_vendored_libunwind
use_libunwind = get_option("use-libunwind")
use_system_libunwind = use_system_version_of_library("libunwind")

# Assume system libunwind works if it's installed and selected.
# Vendored libunwind, however, works only on linux-x86_64.
can_use_libunwind = (use_system_libunwind or
    env.TargetOSIs('linux') and env['TARGET_ARCH'] == 'x86_64')

if use_libunwind == "off":
    use_libunwind = False
    use_system_libunwind = False
elif use_libunwind == "on":
    use_libunwind = True
    if not can_use_libunwind:
        env.ConfError("libunwind not supported on target platform")
        Exit(1)
elif use_libunwind == "auto":
    use_libunwind = can_use_libunwind

use_vendored_libunwind = use_libunwind and not use_system_libunwind
if use_system_libunwind and not use_libunwind:
    print("Error: --use-system-libunwind requires --use-libunwind")
    Exit(1)
if use_libunwind == True:
    env.SetConfigHeaderDefine("MONGO_CONFIG_USE_LIBUNWIND")


# Windows can't currently support anything other than 'object' or 'static', until
# we have both hygienic builds and have annotated functions for export.
if env.TargetOSIs('windows') and link_model not in ['object', 'static', 'dynamic-sdk']:
    env.FatalError("Windows builds must use the 'object', 'dynamic-sdk', or 'static' link models")

# The 'object' mode for libdeps is enabled by setting _LIBDEPS to $_LIBDEPS_OBJS. The other two
# modes operate in library mode, enabled by setting _LIBDEPS to $_LIBDEPS_LIBS.
env['_LIBDEPS'] = '$_LIBDEPS_OBJS' if link_model == "object" else '$_LIBDEPS_LIBS'

env['BUILDERS']['ProgramObject'] = env['BUILDERS']['StaticObject']
env['BUILDERS']['LibraryObject'] = env['BUILDERS']['StaticObject']

env['SHARPREFIX'] = '$LIBPREFIX'
env['SHARSUFFIX'] = '${SHLIBSUFFIX}${LIBSUFFIX}'
env['BUILDERS']['SharedArchive'] = SCons.Builder.Builder(
    action=env['BUILDERS']['StaticLibrary'].action,
    emitter='$SHAREMITTER',
    prefix='$SHARPREFIX',
    suffix='$SHARSUFFIX',
    src_suffix=env['BUILDERS']['SharedLibrary'].src_suffix,
)

if link_model.startswith("dynamic"):

    def library(env, target, source, *args, **kwargs):
        sharedLibrary = env.SharedLibrary(target, source, *args, **kwargs)
        sharedArchive = env.SharedArchive(target, source=sharedLibrary[0].sources, *args, **kwargs)
        sharedLibrary.extend(sharedArchive)
        return sharedLibrary

    env['BUILDERS']['Library'] = library
    env['BUILDERS']['LibraryObject'] = env['BUILDERS']['SharedObject']

    # TODO: Ideally, the conditions below should be based on a
    # detection of what linker we are using, not the local OS, but I
    # doubt very much that we will see the mach-o linker on anything
    # other than Darwin, or a BFD/sun-esque linker elsewhere.

    # On Darwin, we need to tell the linker that undefined symbols are
    # resolved via dynamic lookup; otherwise we get build failures. On
    # other unixes, we need to suppress as-needed behavior so that
    # initializers are ensured present, even if there is no visible
    # edge to the library in the symbol graph.
    #
    # NOTE: The darwin linker flag is only needed because the library
    # graph is not a DAG. Once the graph is a DAG, we will require all
    # edges to be expressed, and we should drop the flag. When that
    # happens, we should also add -z,defs flag on ELF platforms to
    # ensure that missing symbols due to unnamed dependency edges
    # result in link errors.
    #
    # NOTE: The `illegal_cyclic_or_unresolved_dependencies_whitelisted`
    # tag can be applied to a library to indicate that it does not (or
    # cannot) completely express all of its required link dependencies.
    # This can occur for four reasons:
    #
    # - No unique provider for the symbol: Some symbols do not have a
    #   unique dependency that provides a definition, in which case it
    #   is impossible for the library to express a dependency edge to
    #   resolve the symbol
    #
    # - The library is part of a cycle: If library A depends on B,
    #   which depends on C, which depends on A, then it is impossible
    #   to express all three edges in SCons, since otherwise there is
    #   no way to sequence building the libraries. The cyclic
    #   libraries actually work at runtime, because some parent object
    #   links all of them.
    #
    # - The symbol is provided by an executable into which the library
    #   will be linked. The mongo::inShutdown symbol is a good
    #   example.
    #
    # - The symbol is provided by a third-party library, outside of our
    #   control.
    #
    # All of these are defects in the linking model. In an effort to
    # eliminate these issues, we have begun tagging those libraries
    # that are affected, and requiring that all non-tagged libraries
    # correctly express all dependencies. As we repair each defective
    # library, we can remove the tag. When all the tags are removed
    # the graph will be acyclic. Libraries which are incomplete for the
    # final reason, "libraries outside of our control", may remain for
    # reasons beyond our control. Such libraries ideally should
    # have no dependencies (and thus be leaves in our linking DAG).
    # If that condition is met, then the graph will be acyclic.

    if env.TargetOSIs('darwin'):
        if link_model.startswith('dynamic'):
            print("WARNING: Building MongoDB server with dynamic linking " +
                  "on macOS is not supported. Static linking is recommended.")

        if link_model == "dynamic-strict":
            # Darwin is strict by default
            pass
        else:
            def libdeps_tags_expand_incomplete(source, target, env, for_signature):
                # On darwin, since it is strict by default, we need to add a flag
                # when libraries are tagged incomplete.
                if ('illegal_cyclic_or_unresolved_dependencies_whitelisted'
                    in target[0].get_env().get("LIBDEPS_TAGS", [])):
                    return ["-Wl,-undefined,dynamic_lookup"]
                return []
            env['LIBDEPS_TAG_EXPANSIONS'].append(libdeps_tags_expand_incomplete)
    elif env.TargetOSIs('windows'):
        if link_model == "dynamic-strict":
            # Windows is strict by default
            pass
        else:
            def libdeps_tags_expand_incomplete(source, target, env, for_signature):
                # On windows, since it is strict by default, we need to add a flag
                # when libraries are tagged incomplete.
                if ('illegal_cyclic_or_unresolved_dependencies_whitelisted'
                    in target[0].get_env().get("LIBDEPS_TAGS", [])):
                    return ["/FORCE:UNRESOLVED"]
                return []
            env['LIBDEPS_TAG_EXPANSIONS'].append(libdeps_tags_expand_incomplete)
    else:
        env.AppendUnique(LINKFLAGS=["-Wl,--no-as-needed"])

        # Using zdefs doesn't work at all with the sanitizers
        if not has_option('sanitize'):

            if link_model == "dynamic-strict":
                env.AppendUnique(SHLINKFLAGS=["-Wl,-z,defs"])
            else:
                # On BFD/gold linker environments, which are not strict by
                # default, we need to add a flag when libraries are not
                # tagged incomplete.
                def libdeps_tags_expand_incomplete(source, target, env, for_signature):
                    if ('illegal_cyclic_or_unresolved_dependencies_whitelisted'
                        not in target[0].get_env().get("LIBDEPS_TAGS", [])):
                        return ["-Wl,-z,defs"]
                    return []
                env['LIBDEPS_TAG_EXPANSIONS'].append(libdeps_tags_expand_incomplete)

if optBuild:
    env.SetConfigHeaderDefine("MONGO_CONFIG_OPTIMIZED_BUILD")


# Enable the fast decider if explicitly requested or if in 'auto' mode
# and not in conflict with other options like the ninja option which
# sets it's own decider
if (
        get_option('ninja') == 'disabled' and
        get_option('build-fast-and-loose') == 'on' or
        (
            get_option('build-fast-and-loose') == 'auto' and
            not has_option('release')
         )
):
    # See http://www.scons.org/wiki/GoFastButton for details
    env.Decider('MD5-timestamp')
    env.SetOption('max_drift', 1)

# If the user has requested the git decider, enable it if it is available. We want to do this after
# we set the basic decider above, so that we 'chain' to that one.
if get_option('git-decider') == 'on':
    git_decider = Tool('git_decider')
    if git_decider.exists(env):
        git_decider(env)

# On non-windows platforms, we may need to differentiate between flags being used to target an
# executable (like -fPIE), vs those being used to target a (shared) library (like -fPIC). To do so,
# we inject a new family of SCons variables PROG*FLAGS, by reaching into the various COMs.
if not env.TargetOSIs('windows'):
    env["CCCOM"] = env["CCCOM"].replace("$CCFLAGS", "$PROGCCFLAGS")
    env["CXXCOM"] = env["CXXCOM"].replace("$CCFLAGS", "$PROGCCFLAGS")
    env["PROGCCFLAGS"] = ['$CCFLAGS']

    env["CCCOM"] = env["CCCOM"].replace("$CFLAGS", "$PROGCFLAGS")
    env["PROGCFLAGS"] = ['$CFLAGS']

    env["CXXCOM"] = env["CXXCOM"].replace("$CXXFLAGS", "$PROGCXXFLAGS")
    env['PROGCXXFLAGS'] = ['$CXXFLAGS']

    env["LINKCOM"] = env["LINKCOM"].replace("$LINKFLAGS", "$PROGLINKFLAGS")
    env["PROGLINKFLAGS"] = ['$LINKFLAGS']

if not env.Verbose():
    env.Append( CCCOMSTR = "Compiling $TARGET" )
    env.Append( CXXCOMSTR = env["CCCOMSTR"] )
    env.Append( SHCCCOMSTR = "Compiling $TARGET" )
    env.Append( SHCXXCOMSTR = env["SHCCCOMSTR"] )
    env.Append( LINKCOMSTR = "Linking $TARGET" )
    env.Append( SHLINKCOMSTR = env["LINKCOMSTR"] )
    env.Append( ARCOMSTR = "Generating library $TARGET" )

# Link tools other than mslink don't setup TEMPFILE in LINKCOM,
# disabling SCons automatically falling back to a temp file when
# running link commands that are over MAXLINELENGTH. With our object
# file linking mode, we frequently hit even the large linux command
# line length, so we want it everywhere. If we aren't using mslink,
# add TEMPFILE in. For verbose builds when using a tempfile, we need
# some trickery so that we print the command we are running, and not
# just the invocation of the compiler being fed the command file.
if not 'mslink' in env['TOOLS']:
    if env.Verbose():
        env["LINKCOM"] = "${{TEMPFILE('{0}', '')}}".format(env['LINKCOM'])
        env["SHLINKCOM"] = "${{TEMPFILE('{0}', '')}}".format(env['SHLINKCOM'])
        if not 'libtool' in env['TOOLS']:
            env["ARCOM"] = "${{TEMPFILE('{0}', '')}}".format(env['ARCOM'])
    else:
        env["LINKCOM"] = "${{TEMPFILE('{0}', 'LINKCOMSTR')}}".format(env['LINKCOM'])
        env["SHLINKCOM"] = "${{TEMPFILE('{0}', 'SHLINKCOMSTR')}}".format(env['SHLINKCOM'])
        if not 'libtool' in env['TOOLS']:
            env["ARCOM"] = "${{TEMPFILE('{0}', 'ARCOMSTR')}}".format(env['ARCOM'])

if env['_LIBDEPS'] == '$_LIBDEPS_OBJS':
    # The libraries we build in LIBDEPS_OBJS mode are just placeholders for tracking dependencies.
    # This avoids wasting time and disk IO on them.
    def write_uuid_to_file(env, target, source):
        with open(env.File(target[0]).abspath, 'w') as fake_lib:
            fake_lib.write(str(uuid.uuid4()))
            fake_lib.write('\n')

    # We originally did this by setting ARCOM to write_uuid_to_file,
    # this worked more or less by accident. It works when SCons is
    # doing the action execution because when it would subst the
    # command line subst would execute the function as part of string
    # resolution which would have the side effect of writing the
    # file. Since it returned None subst would do some special
    # handling to make sure it never made it to the command line. This
    # breaks Ninja however because we are taking that return value and
    # trying to pass it to the command executor (/bin/sh or
    # cmd.exe) and end up with the function name as a command. The
    # resulting command looks something like `/bin/sh -c
    # 'write_uuid_to_file(env, target, source)`. If we instead
    # actually do what we want and that is make the StaticLibrary
    # builder's action a FunctionAction the Ninja generator will
    # correctly dispatch it and not generate an invalid command
    # line. This also has the side benefit of being more clear that
    # we're expecting a Python function to execute here instead of
    # pretending to be a CommandAction that just happens to not run a
    # command but instead runs a function.
    env["BUILDERS"]["StaticLibrary"].action = SCons.Action.Action(write_uuid_to_file, "Generating placeholder library $TARGET")

libdeps.setup_environment(env, emitting_shared=(link_model.startswith("dynamic")))

# Both the abidw tool and the thin archive tool must be loaded after
# libdeps, so that the scanners they inject can see the library
# dependencies added by libdeps.
if link_model.startswith("dynamic"):
    # Add in the abi linking tool if the user requested and it is
    # supported on this platform.
    if env.get('ABIDW'):
        abilink = Tool('abilink')
        if abilink.exists(env):
            abilink(env)

if env['_LIBDEPS'] == '$_LIBDEPS_LIBS':
    # The following platforms probably aren't using the binutils
    # toolchain, or may be using it for the archiver but not the
    # linker, and binutils currently is the olny thing that supports
    # thin archives. Don't even try on those platforms.
    if not env.TargetOSIs('solaris', 'darwin', 'windows', 'openbsd'):
        env.Tool('thin_archive')

if env.TargetOSIs('linux', 'freebsd', 'openbsd'):
    # NOTE: The leading and trailing spaces here are important. Do not remove them.
    env['LINK_WHOLE_ARCHIVE_LIB_START'] = '-Wl,--whole-archive '
    env['LINK_WHOLE_ARCHIVE_LIB_END'] = ' -Wl,--no-whole-archive'
elif env.TargetOSIs('darwin'):
    # NOTE: The trailing space here is important. Do not remove it.
    env['LINK_WHOLE_ARCHIVE_LIB_START'] = '-Wl,-force_load '
    env['LINK_WHOLE_ARCHIVE_LIB_END'] = ''
elif env.TargetOSIs('solaris'):
    # NOTE: The leading and trailing spaces here are important. Do not remove them.
    env['LINK_WHOLE_ARCHIVE_LIB_START'] = '-Wl,-z,allextract '
    env['LINK_WHOLE_ARCHIVE_LIB_END'] = ' -Wl,-z,defaultextract'
elif env.TargetOSIs('windows'):
    env['LINK_WHOLE_ARCHIVE_LIB_START'] = '/WHOLEARCHIVE'
    env['LINK_WHOLE_ARCHIVE_SEP'] = ':'
    env['LINK_WHOLE_ARCHIVE_LIB_END'] = ''

# ---- other build setup -----
if debugBuild:
    env.SetConfigHeaderDefine("MONGO_CONFIG_DEBUG_BUILD")
else:
    env.AppendUnique( CPPDEFINES=[ 'NDEBUG' ] )

if env.TargetOSIs('linux'):
    env.Append( LIBS=["m"] )
    if not env.TargetOSIs('android'):
        env.Append( LIBS=["resolv"] )

elif env.TargetOSIs('solaris'):
     env.Append( LIBS=["socket","resolv","lgrp"] )

elif env.TargetOSIs('freebsd'):
    env.Append( LIBS=[ "kvm" ] )
    env.Append( CCFLAGS=[ "-fno-omit-frame-pointer" ] )

elif env.TargetOSIs('darwin'):
    env.Append( LIBS=["resolv"] )

elif env.TargetOSIs('openbsd'):
    env.Append( LIBS=[ "kvm" ] )

elif env.TargetOSIs('windows'):
    env['DIST_ARCHIVE_SUFFIX'] = '.zip'

    # If tools configuration fails to set up 'cl' in the path, fall back to importing the whole
    # shell environment and hope for the best. This will work, for instance, if you have loaded
    # an SDK shell.
    for pathdir in env['ENV']['PATH'].split(os.pathsep):
        if os.path.exists(os.path.join(pathdir, 'cl.exe')):
            break
    else:
        print("NOTE: Tool configuration did not find 'cl' compiler, falling back to os environment")
        env['ENV'] = dict(os.environ)

    env.Append(CPPDEFINES=[
    # This tells the Windows compiler not to link against the .lib files
    # and to use boost as a bunch of header-only libraries
        "BOOST_ALL_NO_LIB",
    ])

    env.Append( CPPDEFINES=[ "_UNICODE" ] )
    env.Append( CPPDEFINES=[ "UNICODE" ] )

    # Temporary fixes to allow compilation with VS2017
    env.Append(CPPDEFINES=[
        "_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING",
        "_SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING",
        "_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING",
    ])

    # /EHsc exception handling style for visual studio
    # /W3 warning level
    env.Append(CCFLAGS=["/EHsc","/W3"])

    # Suppress some warnings we don't like, or find necessary to
    # suppress. Please keep this list alphabetized and commented.
    env.Append(CCFLAGS=[

        # C4068: unknown pragma. added so that we can specify unknown
        # pragmas for other compilers.
        "/wd4068",

        # C4244: 'conversion' conversion from 'type1' to 'type2',
        # possible loss of data. An integer type is converted to a
        # smaller integer type.
        "/wd4244",

        # C4267: 'var' : conversion from 'size_t' to 'type', possible
        # loss of data. When compiling with /Wp64, or when compiling
        # on a 64-bit operating system, type is 32 bits but size_t is
        # 64 bits when compiling for 64-bit targets. To fix this
        # warning, use size_t instead of a type.
        "/wd4267",

        # C4290: C++ exception specification ignored except to
        # indicate a function is not __declspec(nothrow). A function
        # is declared using exception specification, which Visual C++
        # accepts but does not implement.
        "/wd4290",

        # C4351: On extremely old versions of MSVC (pre 2k5), default
        # constructing an array member in a constructor's
        # initialization list would not zero the array members "in
        # some cases". Since we don't target MSVC versions that old,
        # this warning is safe to ignore.
        "/wd4351",

        # C4355: 'this' : used in base member initializer list. The
        # this pointer is valid only within nonstatic member
        # functions. It cannot be used in the initializer list for a
        # base class
        "/wd4355",

        # C4373: Older versions of MSVC would fail to make a function
        # in a derived class override a virtual function in the
        # parent, when defined inline and at least one of the
        # parameters is made const. The behavior is incorrect under
        # the standard. MSVC is fixed now, and the warning exists
        # merely to alert users who may have relied upon the older,
        # non-compliant behavior. Our code should not have any
        # problems with the older behavior, so we can just disable
        # this warning.
        "/wd4373",

        # C4800: 'type' : forcing value to bool 'true' or 'false'
        # (performance warning). This warning is generated when a
        # value that is not bool is assigned or coerced into type
        # bool.
        "/wd4800",

        # C5041: out-of-line definition for constexpr static data
        # member is not needed and is deprecated in C++17. We still
        # have these, but we don't want to fix them up before we roll
        # over to C++17.
        "/wd5041",
    ])

    # mozjs-60 requires the following
    #  'declaration' : no matching operator delete found; memory will not be freed if
    #  initialization throws an exception
    env.Append( CCFLAGS=["/wd4291"] )

    # some warnings we should treat as errors:
    # c4013
    #  'function' undefined; assuming extern returning int
    #    This warning occurs when files compiled for the C language use functions not defined
    #    in a header file.
    # c4099
    #  identifier' : type name first seen using 'objecttype1' now seen using 'objecttype2'
    #    This warning occurs when classes and structs are declared with a mix of struct and class
    #    which can cause linker failures
    # c4930
    #  'identifier': prototyped function not called (was a variable definition intended?)
    #     This warning indicates a most-vexing parse error, where a user declared a function that
    #     was probably intended as a variable definition.  A common example is accidentally
    #     declaring a function called lock that takes a mutex when one meant to create a guard
    #     object called lock on the stack.
    env.Append( CCFLAGS=["/we4013", "/we4099", "/we4930"] )

    # Warnings as errors
    if not has_option("disable-warnings-as-errors"):
        env.Append( CCFLAGS=["/WX"] )

    env.Append( CPPDEFINES=["_CONSOLE","_CRT_SECURE_NO_WARNINGS", "_SCL_SECURE_NO_WARNINGS"] )

    # this would be for pre-compiled headers, could play with it later
    #env.Append( CCFLAGS=['/Yu"pch.h"'] )

    # Don't send error reports in case of internal compiler error
    env.Append( CCFLAGS= ["/errorReport:none"] )

    # Select debugging format. /Zi gives faster links but seem to use more memory
    if get_option('msvc-debugging-format') == "codeview":
        env['CCPDBFLAGS'] = "/Z7"
    elif get_option('msvc-debugging-format') == "pdb":
        env['CCPDBFLAGS'] = '/Zi /Fd${TARGET}.pdb'


    # The SCons built-in pdbGenerator always adds /DEBUG, but we would like
    # control over that flag so that users can override with /DEBUG:fastlink
    # for better local builds. So we overwrite the builtin.
    def pdbGenerator(env, target, source, for_signature):
        try:
            return ['/PDB:%s' % target[0].attributes.pdb]
        except (AttributeError, IndexError):
            return None
    env['_PDB'] = pdbGenerator

    # /DEBUG will tell the linker to create a .pdb file
    # which WinDbg and Visual Studio will use to resolve
    # symbols if you want to debug a release-mode image.
    # Note that this means we can't do parallel links in the build.
    #
    # Please also note that this has nothing to do with _DEBUG or optimization.

    # If the user set a /DEBUG flag explicitly, don't add
    # another. Otherwise use the standard /DEBUG flag, since we always
    # want PDBs.
    if not any(flag.startswith('/DEBUG') for flag in env['LINKFLAGS']):
        env.Append(LINKFLAGS=["/DEBUG"])

    # /MD:  use the multithreaded, DLL version of the run-time library (MSVCRT.lib/MSVCR###.DLL)
    # /MDd: Defines _DEBUG, _MT, _DLL, and uses MSVCRTD.lib/MSVCRD###.DLL

    env.Append(CCFLAGS=["/MDd" if debugBuild else "/MD"])

    if optBuild:
        # /O1:  optimize for size
        # /O2:  optimize for speed (as opposed to size)
        # /Oy-: disable frame pointer optimization (overrides /O2, only affects 32-bit)
        # /INCREMENTAL: NO - disable incremental link - avoid the level of indirection for function
        # calls

        optStr = "/O2" if not optBuildForSize else "/O1"
        env.Append( CCFLAGS=[optStr, "/Oy-"] )
        env.Append( LINKFLAGS=["/INCREMENTAL:NO"])
    else:
        env.Append( CCFLAGS=["/Od"] )

    if debugBuild and not optBuild:
        # /RTC1: - Enable Stack Frame Run-Time Error Checking; Reports when a variable is used
        # without having been initialized (implies /Od: no optimizations)
        env.Append( CCFLAGS=["/RTC1"] )

    # Support large object files since some unit-test sources contain a lot of code
    env.Append( CCFLAGS=["/bigobj"] )

    # Set Source and Executable character sets to UTF-8, this will produce a warning C4828 if the
    # file contains invalid UTF-8.
    env.Append( CCFLAGS=["/utf-8" ])

    # Specify standards conformance mode to the compiler.
    env.Append( CCFLAGS=["/permissive-"] )

    # Enables the __cplusplus preprocessor macro to report an updated value for recent C++ language
    # standards support.
    env.Append( CCFLAGS=["/Zc:__cplusplus"] )

    # Tells the compiler to preferentially call global operator delete or operator delete[]
    # functions that have a second parameter of type size_t when the size of the object is available.
    env.Append( CCFLAGS=["/Zc:sizedDealloc"] )

    # Treat volatile according to the ISO standard and do not guarantee acquire/release semantics.
    env.Append( CCFLAGS=["/volatile:iso"] )

    # Tell CL to produce more useful error messages.
    env.Append( CCFLAGS=["/diagnostics:caret"] )

    # This gives 32-bit programs 4 GB of user address space in WOW64, ignored in 64-bit builds.
    env.Append( LINKFLAGS=["/LARGEADDRESSAWARE"] )

    env.Append(
        LIBS=[
            'DbgHelp.lib',
            'Iphlpapi.lib',
            'Psapi.lib',
            'advapi32.lib',
            'bcrypt.lib',
            'crypt32.lib',
            'dnsapi.lib',
            'kernel32.lib',
            'shell32.lib',
            'pdh.lib',
            'version.lib',
            'winmm.lib',
            'ws2_32.lib',
            'secur32.lib',
        ],
    )

# When building on visual studio, this sets the name of the debug symbols file
if env.ToolchainIs('msvc'):
    env['PDB'] = '${TARGET.base}.pdb'

# Python uses APPDATA to determine the location of user installed
# site-packages. If we do not pass this variable down to Python
# subprocesses then anything installed with `pip install --user`
# will be inaccessible leading to import errors.
#
# Use env['PLATFORM'] instead of TargetOSIs since we always want this
# to run on Windows hosts but not always for Windows targets.
if env['PLATFORM'] == 'win32':
    appdata = os.getenv('APPDATA', None)
    if appdata is not None:
        env['ENV']['APPDATA'] = appdata

if env.TargetOSIs('posix'):

    # On linux, C code compiled with gcc/clang -std=c11 causes
    # __STRICT_ANSI__ to be set, and that drops out all of the feature
    # test definitions, resulting in confusing errors when we run C
    # language configure checks and expect to be able to find newer
    # POSIX things. Explicitly enabling _XOPEN_SOURCE fixes that, and
    # should be mostly harmless as on Linux, these macros are
    # cumulative. The C++ compiler already sets _XOPEN_SOURCE, and,
    # notably, setting it again does not disable any other feature
    # test macros, so this is safe to do. Other platforms like macOS
    # and BSD have crazy rules, so don't try this there.
    #
    # Furthermore, as both C++ compilers appears to unconditioanlly
    # define _GNU_SOURCE (because libstdc++ requires it), it seems
    # prudent to explicitly add that too, so that C language checks
    # see a consistent set of definitions.
    if env.TargetOSIs('linux'):
        env.AppendUnique(
            CPPDEFINES=[
                ('_XOPEN_SOURCE', 700),
                '_GNU_SOURCE',
            ],
        )

    # If shared and static object files stripped of their rightmost
    # dot-delimited suffix would collide, modify the shared library
    # ones so that they won't. We do this because if split dwarf is in
    # play, static and dynamic builds would otherwise overwrite each
    # other's .dwo files, because GCC strips the last suffix and adds
    # .dwo, rather than simply appending .dwo to the full filename.
    objsuffelts = env.subst('$OBJSUFFIX').split('.')
    shobjsuffelts = env.subst('$SHOBJSUFFIX').split('.')
    if objsuffelts[0:-1] == shobjsuffelts[0:-1]:
        env['SHOBJSUFFIX'] = '.dyn${OBJSUFFIX}'

    # Everything on OS X is position independent by default.
    if not env.TargetOSIs('darwin'):
        if get_option('runtime-hardening') == "on":
            # If runtime hardening is requested, then build anything
            # destined for an executable with the necessary flags for PIE.
            env.AppendUnique(
                PROGCCFLAGS=['-fPIE'],
                PROGLINKFLAGS=['-pie'],
            )

    # -Winvalid-pch Warn if a precompiled header (see Precompiled Headers) is found in the search path but can't be used.
    env.Append( CCFLAGS=["-fno-omit-frame-pointer",
                         "-fno-strict-aliasing",
                         "-fasynchronous-unwind-tables",
                         "-ggdb" if not env.TargetOSIs('emscripten') else "-g",
                         "-pthread",
                         "-Wall",
                         "-Wsign-compare",
                         "-Wno-unknown-pragmas",
                         "-Winvalid-pch"] )
    # env.Append( " -Wconversion" ) TODO: this doesn't really work yet
    if env.TargetOSIs('linux', 'darwin', 'solaris'):
        if not has_option("disable-warnings-as-errors"):
            env.Append( CCFLAGS=["-Werror"] )

    env.Append( CXXFLAGS=["-Woverloaded-virtual"] )
    if env.ToolchainIs('clang'):
        env.Append( CXXFLAGS=['-Werror=unused-result'] )

    # On OS X, clang doesn't want the pthread flag at link time, or it
    # issues warnings which make it impossible for us to declare link
    # warnings as errors. See http://stackoverflow.com/a/19382663.
    if not (env.TargetOSIs('darwin') and env.ToolchainIs('clang')):
        env.Append( LINKFLAGS=["-pthread"] )

    # SERVER-9761: Ensure early detection of missing symbols in dependent libraries at program
    # startup.
    if env.TargetOSIs('darwin'):
        if env.TargetOSIs('macOS'):
            env.Append( LINKFLAGS=["-Wl,-bind_at_load"] )
    else:
        env.Append( LINKFLAGS=["-Wl,-z,now"] )
        env.Append( LINKFLAGS=["-rdynamic"] )

    env.Append( LIBS=[] )

    #make scons colorgcc friendly
    for key in ('HOME', 'TERM'):
        try:
            env['ENV'][key] = os.environ[key]
        except KeyError:
            pass

    if env.TargetOSIs('linux') and has_option( "gcov" ):
        env.Append( CCFLAGS=["-fprofile-arcs", "-ftest-coverage", "-fprofile-update=single"] )
        env.Append( LINKFLAGS=["-fprofile-arcs", "-ftest-coverage", "-fprofile-update=single"] )

    if optBuild and not optBuildForSize:
        env.Append( CCFLAGS=["-O2"] )
    elif optBuild and optBuildForSize:
        env.Append( CCFLAGS=["-Os"] )
    else:
        env.Append( CCFLAGS=["-O0"] )

    # Promote linker warnings into errors. We can't yet do this on OS X because its linker considers
    # noall_load obsolete and warns about it.
    if not has_option("disable-warnings-as-errors"):
        env.Append(
            LINKFLAGS=[
                '-Wl,-fatal_warnings' if env.TargetOSIs('darwin') else "-Wl,--fatal-warnings",
            ]
        )

wiredtiger = False
if get_option('wiredtiger') == 'on':
    # Wiredtiger only supports 64-bit architecture, and will fail to compile on 32-bit
    # so disable WiredTiger automatically on 32-bit since wiredtiger is on by default
    if env['TARGET_ARCH'] == 'i386':
        env.FatalError("WiredTiger is not supported on 32-bit platforms\n"
            "Re-run scons with --wiredtiger=off to build on 32-bit platforms")
    else:
        wiredtiger = True
        env.SetConfigHeaderDefine("MONGO_CONFIG_WIREDTIGER_ENABLED")

if env['TARGET_ARCH'] == 'i386':
    # If we are using GCC or clang to target 32 bit, set the ISA minimum to 'nocona',
    # and the tuning to 'generic'. The choice of 'nocona' is selected because it
    #  -- includes MMX extenions which we need for tcmalloc on 32-bit
    #  -- can target 32 bit
    #  -- is at the time of this writing a widely-deployed 10 year old microarchitecture
    #  -- is available as a target architecture from GCC 4.0+
    # However, we only want to select an ISA, not the nocona specific scheduling, so we
    # select the generic tuning. For installations where hardware and system compiler rev are
    # contemporaries, the generic scheduling should be appropriate for a wide range of
    # deployed hardware.

    if env.ToolchainIs('GCC', 'clang'):
        env.Append( CCFLAGS=['-march=nocona', '-mtune=generic'] )

# Needed for auth tests since key files are stored in git with mode 644.
if not env.TargetOSIs('windows'):
    for keysuffix in [ "1" , "2", "ForRollover" ]:
        keyfile = "jstests/libs/key%s" % keysuffix
        os.chmod( keyfile , stat.S_IWUSR|stat.S_IRUSR )

# boostSuffixList is used when using system boost to select a search sequence
# for boost libraries.
boostSuffixList = ["-mt", ""]
if get_option("system-boost-lib-search-suffixes") is not None:
    if not use_system_version_of_library("boost"):
        env.FatalError("The --system-boost-lib-search-suffixes option is only valid "
            "with --use-system-boost")
    boostSuffixList = get_option("system-boost-lib-search-suffixes")
    if boostSuffixList == "":
        boostSuffixList = []
    else:
        boostSuffixList = boostSuffixList.split(',')

# discover modules, and load the (python) module for each module's build.py
mongo_modules = moduleconfig.discover_modules('src/mongo/db/modules', get_option('modules'))

# --- check system ---
ssl_provider = None
free_monitoring = get_option("enable-free-mon")
http_client = get_option("enable-http-client")

def isSanitizerEnabled(self, sanitizerName):
    if 'SANITIZERS_ENABLED' not in self:
        return False
    if sanitizerName == 'fuzzer':
        return 'fuzzer-no-link' in self['SANITIZERS_ENABLED']
    return sanitizerName in self['SANITIZERS_ENABLED']

env.AddMethod(isSanitizerEnabled, 'IsSanitizerEnabled')

def doConfigure(myenv):
    global wiredtiger
    global ssl_provider
    global free_monitoring
    global http_client

    # Check that the compilers work.
    #
    # TODO: Currently, we have some flags already injected. Eventually, this should test the
    # bare compilers, and we should re-check at the very end that TryCompile and TryLink still
    # work with the flags we have selected.
    if myenv.ToolchainIs('msvc'):
        compiler_minimum_string = "Microsoft Visual Studio 2019 16.4"
        compiler_test_body = textwrap.dedent(
        """
        #if !defined(_MSC_VER)
        #error
        #endif

        #if _MSC_VER < 1924
        #error %s or newer is required to build MongoDB
        #endif

        int main(int argc, char* argv[]) {
            return 0;
        }
        """ % compiler_minimum_string)
    elif myenv.ToolchainIs('gcc'):
        compiler_minimum_string = "GCC 8.2"
        compiler_test_body = textwrap.dedent(
        """
        #if !defined(__GNUC__) || defined(__clang__)
        #error
        #endif

        #if (__GNUC__ < 8) || (__GNUC__ == 8 && __GNUC_MINOR__ < 2)
        #error %s or newer is required to build MongoDB
        #endif

        int main(int argc, char* argv[]) {
            return 0;
        }
        """ % compiler_minimum_string)
    elif myenv.ToolchainIs('clang'):
        compiler_minimum_string = "clang 7.0 (or Apple XCode 10.0)"
        compiler_test_body = textwrap.dedent(
        """
        #if !defined(__clang__)
        #error
        #endif

        #if defined(__apple_build_version__)
        #if __apple_build_version__ < 10010046
        #error %s or newer is required to build MongoDB
        #endif
        #elif (__clang_major__ < 7) || (__clang_major__ == 7 && __clang_minor__ < 0)
        #error %s or newer is required to build MongoDB
        #endif

        int main(int argc, char* argv[]) {
            return 0;
        }
        """ % (compiler_minimum_string, compiler_minimum_string))
    else:
        myenv.ConfError("Error: can't check compiler minimum; don't know this compiler...")

    def CheckForMinimumCompiler(context, language):
        extension_for = {
            "C" : ".c",
            "C++" : ".cpp",
        }
        context.Message("Checking if %s compiler is %s or newer..." %
                        (language, compiler_minimum_string))
        result = context.TryCompile(compiler_test_body, extension_for[language])
        context.Result(result)
        return result;

    conf = Configure(myenv, help=False, custom_tests = {
        'CheckForMinimumCompiler' : CheckForMinimumCompiler,
    })

    c_compiler_validated = conf.CheckForMinimumCompiler('C')
    cxx_compiler_validated = conf.CheckForMinimumCompiler('C++')

    suppress_invalid = has_option("disable-minimum-compiler-version-enforcement")
    if releaseBuild and suppress_invalid:
        env.FatalError("--disable-minimum-compiler-version-enforcement is forbidden with --release")

    if not (c_compiler_validated and cxx_compiler_validated):
        if not suppress_invalid:
            env.ConfError("ERROR: Refusing to build with compiler that does not meet requirements")
        print("WARNING: Ignoring failed compiler version check per explicit user request.")
        print("WARNING: The build may fail, binaries may crash, or may run but corrupt data...")

    # Figure out what our minimum windows version is. If the user has specified, then use
    # that.
    if env.TargetOSIs('windows'):
        if has_option('win-version-min'):
            win_version_min = get_option('win-version-min')
        else:
            # If no minimum version has beeen specified, use our default
            win_version_min = 'win10'

        env['WIN_VERSION_MIN'] = win_version_min
        win_version_min = win_version_min_choices[win_version_min]
        env.Append( CPPDEFINES=[("_WIN32_WINNT", "0x" + win_version_min[0])] )
        env.Append( CPPDEFINES=[("BOOST_USE_WINAPI_VERSION", "0x" + win_version_min[0])] )
        env.Append( CPPDEFINES=[("NTDDI_VERSION", "0x" + win_version_min[0] + win_version_min[1])] )

    conf.Finish()

    # We require macOS 10.12 or newer
    if env.TargetOSIs('darwin'):

        # TODO: Better error messages, mention the various -mX-version-min-flags in the error, and
        # single source of truth for versions, plumbed through #ifdef ladder and error messages.
        def CheckDarwinMinima(context):
            test_body = """
            #include <Availability.h>
            #include <AvailabilityMacros.h>
            #include <TargetConditionals.h>

            #if TARGET_OS_OSX && (__MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_12)
            #error 1
            #endif
            """

            context.Message("Checking for sufficient {0} target version minimum... ".format(context.env['TARGET_OS']))
            ret = context.TryCompile(textwrap.dedent(test_body), ".c")
            context.Result(ret)
            return ret

        conf = Configure(myenv, help=False, custom_tests={
            "CheckDarwinMinima" : CheckDarwinMinima,
        })

        if not conf.CheckDarwinMinima():
            conf.env.ConfError("Required target minimum of macOS 10.12 not found")

        conf.Finish()

    def AddFlagIfSupported(env, tool, extension, flag, link, **mutation):
        def CheckFlagTest(context, tool, extension, flag):
            if link:
                if tool == 'C':
                    test_body = """
                    #include <stdlib.h>
                    #include <stdio.h>
                    int main() {
                        printf("Hello, World!");
                        return EXIT_SUCCESS;
                    }"""
                elif tool == 'C++':
                    test_body = """
                    #include <iostream>
                    #include <cstdlib>
                    int main() {
                        std::cout << "Hello, World!" << std::endl;
                        return EXIT_SUCCESS;
                    }"""
                context.Message('Checking if linker supports %s... ' % (flag))
                ret = context.TryLink(textwrap.dedent(test_body), extension)
            else:
                test_body = ""
                context.Message('Checking if %s compiler supports %s... ' % (tool, flag))
                ret = context.TryCompile(textwrap.dedent(test_body), extension)
            context.Result(ret)
            return ret

        if env.ToolchainIs('msvc'):
            env.FatalError("AddFlagIfSupported is not currently supported with MSVC")

        test_mutation = mutation
        if env.ToolchainIs('gcc'):
            test_mutation = copy.deepcopy(mutation)
            # GCC helpfully doesn't issue a diagnostic on unknown flags of the form -Wno-xxx
            # unless other diagnostics are triggered. That makes it tough to check for support
            # for -Wno-xxx. To work around, if we see that we are testing for a flag of the
            # form -Wno-xxx (but not -Wno-error=xxx), we also add -Wxxx to the flags. GCC does
            # warn on unknown -Wxxx style flags, so this lets us probe for availablity of
            # -Wno-xxx.
            for kw in list(test_mutation.keys()):
                test_flags = test_mutation[kw]
                for test_flag in test_flags:
                    if test_flag.startswith("-Wno-") and not test_flag.startswith("-Wno-error="):
                        test_flags.append(re.sub("^-Wno-", "-W", test_flag))

        cloned = env.Clone()
        cloned.Append(**test_mutation)

        # For GCC, we don't need anything since bad flags are already errors, but
        # adding -Werror won't hurt. For clang, bad flags are only warnings, so we need -Werror
        # to make them real errors.
        cloned.Append(CCFLAGS=['-Werror'])
        conf = Configure(cloned, help=False, custom_tests = {
                'CheckFlag' : lambda ctx : CheckFlagTest(ctx, tool, extension, flag)
        })
        available = conf.CheckFlag()
        conf.Finish()
        if available:
            env.Append(**mutation)
        return available

    def AddToCFLAGSIfSupported(env, flag):
        return AddFlagIfSupported(env, 'C', '.c', flag, False, CFLAGS=[flag])

    def AddToCCFLAGSIfSupported(env, flag):
        return AddFlagIfSupported(env, 'C', '.c', flag, False, CCFLAGS=[flag])

    def AddToCXXFLAGSIfSupported(env, flag):
        return AddFlagIfSupported(env, 'C++', '.cpp', flag, False, CXXFLAGS=[flag])

    def AddToLINKFLAGSIfSupported(env, flag):
        return AddFlagIfSupported(env, 'C', '.c', flag, True, LINKFLAGS=[flag])

    def AddToSHLINKFLAGSIfSupported(env, flag):
        return AddFlagIfSupported(env, 'C', '.c', flag, True, SHLINKFLAGS=[flag])


    if myenv.ToolchainIs('clang', 'gcc'):
        # This warning was added in g++-4.8.
        AddToCCFLAGSIfSupported(myenv, '-Wno-unused-local-typedefs')

        # Clang likes to warn about unused functions, which seems a tad aggressive and breaks
        # -Werror, which we want to be able to use.
        AddToCCFLAGSIfSupported(myenv, '-Wno-unused-function')

        # TODO: Note that the following two flags are added to CCFLAGS even though they are
        # really C++ specific. We need to do this because SCons passes CXXFLAGS *before*
        # CCFLAGS, but CCFLAGS contains -Wall, which re-enables the warnings we are trying to
        # suppress. In the future, we should move all warning flags to CCWARNFLAGS and
        # CXXWARNFLAGS and add these to CCOM and CXXCOM as appropriate.
        #
        # Clang likes to warn about unused private fields, but some of our third_party
        # libraries have such things.
        AddToCCFLAGSIfSupported(myenv, '-Wno-unused-private-field')

        # Prevents warning about using deprecated features (such as auto_ptr in c++11)
        # Using -Wno-error=deprecated-declarations does not seem to work on some compilers,
        # including at least g++-4.6.
        AddToCCFLAGSIfSupported(myenv, "-Wno-deprecated-declarations")

        # As of clang-3.4, this warning appears in v8, and gets escalated to an error.
        AddToCCFLAGSIfSupported(myenv, "-Wno-tautological-constant-out-of-range-compare")

        # As of clang in Android NDK 17, these warnings appears in boost and/or ICU, and get escalated to errors
        AddToCCFLAGSIfSupported(myenv, "-Wno-tautological-constant-compare")
        AddToCCFLAGSIfSupported(myenv, "-Wno-tautological-unsigned-zero-compare")
        AddToCCFLAGSIfSupported(myenv, "-Wno-tautological-unsigned-enum-zero-compare")

        # New in clang-3.4, trips up things mostly in third_party, but in a few places in the
        # primary mongo sources as well.
        AddToCCFLAGSIfSupported(myenv, "-Wno-unused-const-variable")

        # Prevents warning about unused but set variables found in boost version 1.49
        # in boost/date_time/format_date_parser.hpp which does not work for compilers
        # GCC >= 4.6. Error explained in https://svn.boost.org/trac/boost/ticket/6136 .
        AddToCCFLAGSIfSupported(myenv, "-Wno-unused-but-set-variable")

        # This has been suppressed in gcc 4.8, due to false positives, but not in clang.  So
        # we explicitly disable it here.
        AddToCCFLAGSIfSupported(myenv, "-Wno-missing-braces")

        # Suppress warnings about not consistently using override everywhere in a class. It seems
        # very pedantic, and we have a fair number of instances.
        AddToCCFLAGSIfSupported(myenv, "-Wno-inconsistent-missing-override")

        # Don't issue warnings about potentially evaluated expressions
        AddToCCFLAGSIfSupported(myenv, "-Wno-potentially-evaluated-expression")

        # Warn about moves of prvalues, which can inhibit copy elision.
        AddToCXXFLAGSIfSupported(myenv, "-Wpessimizing-move")

        # Warn about redundant moves, such as moving a local variable in a return that is different
        # than the return type.
        AddToCXXFLAGSIfSupported(myenv, "-Wredundant-move")

        # Disable warning about variables that may not be initialized
        # Failures are triggered in the case of boost::optional in GCC 4.8.x
        # TODO: re-evaluate when we move to GCC 5.3
        # see: http://stackoverflow.com/questions/21755206/how-to-get-around-gcc-void-b-4-may-be-used-uninitialized-in-this-funct
        AddToCXXFLAGSIfSupported(myenv, "-Wno-maybe-uninitialized")

        # Disable warning about templates that can't be implicitly instantiated. It is an attempt to
        # make a link error into an easier-to-debug compiler failure, but it triggers false
        # positives if explicit instantiation is used in a TU that can see the full definition. This
        # is a problem at least for the S2 headers.
        AddToCXXFLAGSIfSupported(myenv, "-Wno-undefined-var-template")

        # This warning was added in clang-4.0, but it warns about code that is required on some
        # platforms. Since the warning just states that 'explicit instantiation of [a template] that
        # occurs after an explicit specialization has no effect', it is harmless on platforms where
        # it isn't required
        AddToCXXFLAGSIfSupported(myenv, "-Wno-instantiation-after-specialization")

        # This warning was added in clang-5 and flags many of our lambdas. Since it isn't actively
        # harmful to capture unused variables we are suppressing for now with a plan to fix later.
        AddToCCFLAGSIfSupported(myenv, "-Wno-unused-lambda-capture")

        # This warning was added in clang-5 and incorrectly flags our implementation of
        # exceptionToStatus(). See https://bugs.llvm.org/show_bug.cgi?id=34804
        AddToCCFLAGSIfSupported(myenv, "-Wno-exceptions")

        # Enable sized deallocation support.
        AddToCXXFLAGSIfSupported(myenv, '-fsized-deallocation')

        # This warning was added in Apple clang version 11 and flags many explicitly defaulted move
        # constructors and assignment operators for being implicitly deleted, which is not useful.
        AddToCXXFLAGSIfSupported(myenv, "-Wno-defaulted-function-deleted")

        # SERVER-44856: Our windows builds complain about unused
        # exception parameters, but GCC and clang don't seem to do
        # that for us automatically. In the interest of making it more
        # likely to catch these errors early, add the (currently clang
        # only) flag that turns it on.
        AddToCXXFLAGSIfSupported(myenv, "-Wunused-exception-parameter")

        # Check if we can set "-Wnon-virtual-dtor" when "-Werror" is set. The only time we can't set it is on
        # clang 3.4, where a class with virtual function(s) and a non-virtual destructor throws a warning when
        # it shouldn't.
        def CheckNonVirtualDtor(context):

            test_body = """
            class Base {
            public:
                virtual void foo() const = 0;
            protected:
                ~Base() {};
            };

            class Derived : public Base {
            public:
                virtual void foo() const {}
            };
            """

            context.Message('Checking -Wnon-virtual-dtor for false positives... ')
            ret = context.TryCompile(textwrap.dedent(test_body), ".cpp")
            context.Result(ret)
            return ret

        myenvClone = myenv.Clone()
        myenvClone.Append( CCFLAGS=['-Werror'] )
        myenvClone.Append( CXXFLAGS=["-Wnon-virtual-dtor"] )
        conf = Configure(myenvClone, help=False, custom_tests = {
            'CheckNonVirtualDtor' : CheckNonVirtualDtor,
        })
        if conf.CheckNonVirtualDtor():
            myenv.Append( CXXFLAGS=["-Wnon-virtual-dtor"] )
        conf.Finish()

        # As of XCode 9, this flag must be present (it is not enabled
        # by -Wall), in order to enforce that -mXXX-version-min=YYY
        # will enforce that you don't use APIs from ZZZ.
        if env.TargetOSIs('darwin'):
            AddToCCFLAGSIfSupported(env, '-Wunguarded-availability')

    if get_option('runtime-hardening') == "on":
        # Enable 'strong' stack protection preferentially, but fall back to 'all' if it is not
        # available. Note that we need to add these to the LINKFLAGS as well, since otherwise we
        # might not link libssp when we need to (see SERVER-12456).
        if myenv.ToolchainIs('gcc', 'clang'):
            if AddToCCFLAGSIfSupported(myenv, '-fstack-protector-strong'):
                myenv.Append(
                    LINKFLAGS=[
                        '-fstack-protector-strong',
                    ]
                )
            elif AddToCCFLAGSIfSupported(myenv, '-fstack-protector-all'):
                myenv.Append(
                    LINKFLAGS=[
                        '-fstack-protector-all',
                    ]
                )

        if myenv.ToolchainIs('clang'):
            # TODO: There are several interesting things to try here, but they each have
            # consequences we need to investigate.
            #
            # - fsanitize=bounds: This does static bounds checking. We can
            #   probably turn this on along with fsanitize-trap so that we
            #   don't depend on the ASAN runtime.
            #
            # - fsanitize=safestack: This looks very interesting, and is
            #   probably what we want. However there are a few problems:
            #
            #   - It relies on having the RT library available, and it is
            #     unclear whether we can ship binaries that depend on
            #     that.
            #
            #   - It is incompatible with a shared object build.
            #
            #   - It may not work with SpiderMonkey due to needing to
            #     inform the GC about the stacks so that mark-sweep
            #
            # - fsanitize=cfi: Again, very interesting, however it
            #   requires LTO builds.
            pass

    if has_option('osx-version-min'):
        message="""
        The --osx-version-min option is no longer supported.

        To specify a target minimum for Darwin platforms, please explicitly add the appropriate options
        to CCFLAGS and LINKFLAGS on the command line:

        macOS: scons CCFLAGS="-mmacosx-version-min=10.11" LINKFLAGS="-mmacosx-version-min=10.11" ..
        iOS  : scons CCFLAGS="-miphoneos-version-min=10.3" LINKFLAGS="-miphoneos-version-min=10.3" ...
        tvOS : scons CCFLAGS="-mtvos-version-min=10.3" LINKFLAGS="-tvos-version-min=10.3" ...

        Note that MongoDB requires macOS 10.10, iOS 10.2, or tvOS 10.2 or later.
        """
        myenv.ConfError(textwrap.dedent(message))

    usingLibStdCxx = False
    if has_option('libc++'):
        if not myenv.ToolchainIs('clang'):
            myenv.FatalError('libc++ is currently only supported for clang')
        if AddToCXXFLAGSIfSupported(myenv, '-stdlib=libc++'):
            myenv.Append(LINKFLAGS=['-stdlib=libc++'])
        else:
            myenv.ConfError('libc++ requested, but compiler does not support -stdlib=libc++' )
    else:
        def CheckLibStdCxx(context):
            test_body = """
            #include <vector>
            #if !defined(__GLIBCXX__)
            #error
            #endif
            """

            context.Message('Checking if we are using libstdc++... ')
            ret = context.TryCompile(textwrap.dedent(test_body), ".cpp")
            context.Result(ret)
            return ret

        conf = Configure(myenv, help=False, custom_tests = {
            'CheckLibStdCxx' : CheckLibStdCxx,
        })
        usingLibStdCxx = conf.CheckLibStdCxx()
        conf.Finish()

    if myenv.ToolchainIs('msvc'):
        if get_option('cxx-std') == "17":
            myenv.AppendUnique(CCFLAGS=['/std:c++17'])
    else:
        if get_option('cxx-std') == "17":
            if not AddToCXXFLAGSIfSupported(myenv, '-std=c++17'):
                myenv.ConfError('Compiler does not honor -std=c++17')

        if not AddToCFLAGSIfSupported(myenv, '-std=c11'):
            myenv.ConfError("C++14/17 mode selected for C++ files, but can't enable C11 for C files")

    if using_system_version_of_cxx_libraries():
        print( 'WARNING: System versions of C++ libraries must be compiled with C++14/17 support' )

    def CheckCxx17(context):
        test_body = """
        #if __cplusplus < 201703L
        #error
        #endif
        namespace NestedNamespaceDecls::AreACXX17Feature {};
        """

        context.Message('Checking for C++17... ')
        ret = context.TryCompile(textwrap.dedent(test_body), ".cpp")
        context.Result(ret)
        return ret

    conf = Configure(myenv, help=False, custom_tests = {
        'CheckCxx17' : CheckCxx17,
    })

    if get_option('cxx-std') == "17" and not conf.CheckCxx17():
        myenv.ConfError('C++17 support is required to build MongoDB')

    conf.Finish()

    # C11 memset_s - a secure memset
    def CheckMemset_s(context):
        test_body = """
        #define __STDC_WANT_LIB_EXT1__ 1
        #include <cstring>
        int main(int argc, char* argv[]) {
            void* data = nullptr;
            return memset_s(data, 0, 0, 0);
        }
        """

        context.Message('Checking for memset_s... ')
        ret = context.TryLink(textwrap.dedent(test_body), ".cpp")
        context.Result(ret)
        return ret

    conf = Configure(env, custom_tests = {
        'CheckMemset_s' : CheckMemset_s,
    })
    if conf.CheckMemset_s():
        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_HAVE_MEMSET_S")

    if conf.CheckFunc('strnlen'):
        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_HAVE_STRNLEN")

    # Gblic 2.25+, OpenBSD 5.5+ and FreeBSD 11.0+ offer explicit_bzero, a secure way to zero memory
    if conf.CheckFunc('explicit_bzero'):
        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_HAVE_EXPLICIT_BZERO")

    conf.Finish()

    # If we are using libstdc++, check to see if we are using a
    # libstdc++ that is older than our GCC minimum of 5.3.0. This is
    # primarly to help people using clang on OS X but forgetting to
    # use --libc++ (or set the target OS X version high enough to get
    # it as the default). We would, ideally, check the __GLIBCXX__
    # version, but for various reasons this is not workable. Instead,
    # we switch on the fact that the <experimental/filesystem> header
    # wasn't introduced until libstdc++ 5.3.0. Yes, this is a terrible
    # hack.
    if usingLibStdCxx:
        def CheckModernLibStdCxx(context):
            test_body = """
            #if !__has_include(<experimental/filesystem>)
            #error "libstdc++ from GCC 5.3.0 or newer is required"
            #endif
            """

            context.Message('Checking for libstdc++ 5.3.0 or better... ')
            ret = context.TryCompile(textwrap.dedent(test_body), ".cpp")
            context.Result(ret)
            return ret

        conf = Configure(myenv, help=False, custom_tests = {
            'CheckModernLibStdCxx' : CheckModernLibStdCxx,
        })

        suppress_invalid = has_option("disable-minimum-compiler-version-enforcement")
        if not conf.CheckModernLibStdCxx() and not suppress_invalid:
            myenv.ConfError("When using libstdc++, MongoDB requires libstdc++ from GCC 5.3.0 or newer")

        conf.Finish()

    if has_option("use-glibcxx-debug"):
        # If we are using a modern libstdc++ and this is a debug build and we control all C++
        # dependencies, then turn on the debugging features in libstdc++.
        # TODO: Need a new check here.
        if not debugBuild:
            myenv.FatalError("--use-glibcxx-debug requires --dbg=on")
        if not usingLibStdCxx:
            myenv.FatalError("--use-glibcxx-debug is only compatible with the GNU implementation "
                "of the C++ standard libary")
        if using_system_version_of_cxx_libraries():
            myenv.FatalError("--use-glibcxx-debug not compatible with system versions of "
                "C++ libraries.")
        myenv.Append(CPPDEFINES=["_GLIBCXX_DEBUG"]);

    # Check if we have a modern Windows SDK
    if env.TargetOSIs('windows'):
        def CheckWindowsSDKVersion(context):

            test_body = """
            #include <windows.h>
            #if !defined(NTDDI_WINBLUE)
            #error Need Windows SDK Version 8.1 or higher
            #endif
            """

            context.Message('Checking Windows SDK is 8.1 or newer... ')
            ret = context.TryCompile(textwrap.dedent(test_body), ".c")
            context.Result(ret)
            return ret

        conf = Configure(myenv, help=False, custom_tests = {
            'CheckWindowsSDKVersion' : CheckWindowsSDKVersion,
        })

        if not conf.CheckWindowsSDKVersion():
            myenv.ConfError('Windows SDK Version 8.1 or higher is required to build MongoDB')

        conf.Finish()

    # Check if we are on a POSIX system by testing if _POSIX_VERSION is defined.
    def CheckPosixSystem(context):

        test_body = """
        // POSIX requires the existence of unistd.h, so if we can't include unistd.h, we
        // are definitely not a POSIX system.
        #include <unistd.h>
        #if !defined(_POSIX_VERSION)
        #error not a POSIX system
        #endif
        """

        context.Message('Checking if we are on a POSIX system... ')
        ret = context.TryCompile(textwrap.dedent(test_body), ".c")
        context.Result(ret)
        return ret

    conf = Configure(myenv, help=False, custom_tests = {
        'CheckPosixSystem' : CheckPosixSystem,
    })
    posix_system = conf.CheckPosixSystem()

    conf.Finish()

    # Check if we are on a system that support the POSIX clock_gettime function
    #  and the "monotonic" clock.
    posix_monotonic_clock = False
    if posix_system:
        def CheckPosixMonotonicClock(context):

            test_body = """
            #include <unistd.h>
            #if !(defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0)
            #error POSIX clock_gettime not supported
            #elif !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0)
            #error POSIX monotonic clock not supported
            #endif
            """

            context.Message('Checking if the POSIX monotonic clock is supported... ')
            ret = context.TryCompile(textwrap.dedent(test_body), ".c")
            context.Result(ret)
            return ret

        conf = Configure(myenv, help=False, custom_tests = {
            'CheckPosixMonotonicClock' : CheckPosixMonotonicClock,
        })
        posix_monotonic_clock = conf.CheckPosixMonotonicClock()

        # On 32-bit systems, we need to define this in order to get access to
        # the 64-bit versions of fseek, etc.
        # except on 32 bit android where it breaks boost
        if not conf.CheckTypeSize('off_t', includes="#include <sys/types.h>", expect=8):
            if not env.TargetOSIs('android'):
                myenv.Append(CPPDEFINES=["_FILE_OFFSET_BITS=64"])

        conf.Finish()

    if has_option('sanitize'):

        if not myenv.ToolchainIs('clang', 'gcc'):
            env.FatalError('sanitize is only supported with clang or gcc')

        if myenv.ToolchainIs('gcc'):
            # GCC's implementation of ASAN depends on libdl.
            env.Append(LIBS=['dl'])

        sanitizer_list = get_option('sanitize').split(',')

        using_lsan = 'leak' in sanitizer_list
        using_asan = 'address' in sanitizer_list or using_lsan
        using_tsan = 'thread' in sanitizer_list
        using_ubsan = 'undefined' in sanitizer_list
        using_fsan = 'fuzzer' in sanitizer_list

        if env['MONGO_ALLOCATOR'] in ['tcmalloc', 'tcmalloc-experimental'] and (using_lsan or using_asan):
            # There are multiply defined symbols between the sanitizer and
            # our vendorized tcmalloc.
            env.FatalError("Cannot use --sanitize=leak or --sanitize=address with tcmalloc")

        # If the user asked for leak sanitizer, turn on the detect_leaks
        # ASAN_OPTION. If they asked for address sanitizer as well, drop
        # 'leak', because -fsanitize=leak means no address.
        #
        # --sanitize=leak:           -fsanitize=leak, detect_leaks=1
        # --sanitize=address,leak:   -fsanitize=address, detect_leaks=1
        # --sanitize=address:        -fsanitize=address
        #
        if using_lsan:
            if using_asan:
                myenv['ENV']['ASAN_OPTIONS'] = "detect_leaks=1"
            myenv['ENV']['LSAN_OPTIONS'] = "suppressions=%s" % myenv.File("#etc/lsan.suppressions").abspath
            if 'address' in sanitizer_list:
                sanitizer_list.remove('leak')

        if using_fsan:
            def CheckForFuzzerCompilerSupport(context):

                test_body = """
                #include <stddef.h>
                #include <stdint.h>

                // fuzz_target.cc
                extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
                    return 0;
                }
                """

                context.Message("Checking if libfuzzer is supported by the compiler... ")

                context.env.AppendUnique(LINKFLAGS=['-fprofile-instr-generate',
                                                    '-fcoverage-mapping',
                                                    '-fsanitize=fuzzer'],
                                         CCFLAGS=['-fprofile-instr-generate','-fcoverage-mapping'])

                ret = context.TryLink(textwrap.dedent(test_body), ".cpp")
                context.Result(ret)
                return ret

            confEnv = myenv.Clone()
            fuzzerConf = Configure(confEnv, help=False, custom_tests = {
                    'CheckForFuzzerCompilerSupport': CheckForFuzzerCompilerSupport,
                })
            if not fuzzerConf.CheckForFuzzerCompilerSupport():
                myenv.FatalError("libfuzzer is not supported by the compiler")
            fuzzerConf.Finish()

            # We can't include the fuzzer flag with the other sanitize flags
            # The libfuzzer library already has a main function, which will cause the dependencies check
            # to fail
            sanitizer_list.remove('fuzzer')
            sanitizer_list.append('fuzzer-no-link')
            # These flags are needed to generate a coverage report
            myenv.Append(LINKFLAGS=['-fprofile-instr-generate','-fcoverage-mapping'])
            myenv.Append(CCFLAGS=['-fprofile-instr-generate','-fcoverage-mapping'])

        sanitizer_option = '-fsanitize=' + ','.join(sanitizer_list)

        if AddToCCFLAGSIfSupported(myenv, sanitizer_option):
            myenv.Append(LINKFLAGS=[sanitizer_option])
            myenv.Append(CCFLAGS=['-fno-omit-frame-pointer'])
        else:
            myenv.ConfError('Failed to enable sanitizers with flag: {0}', sanitizer_option )

        myenv['SANITIZERS_ENABLED'] = sanitizer_list

        if has_option('sanitize-coverage') and using_fsan:
            sanitize_coverage_list = get_option('sanitize-coverage')
            sanitize_coverage_option = '-fsanitize-coverage=' + sanitize_coverage_list
            if AddToCCFLAGSIfSupported(myenv,sanitize_coverage_option):
                myenv.Append(LINKFLAGS=[sanitize_coverage_option])
            else:
                myenv.ConfError('Failed to enable -fsanitize-coverage with flag: {0}', sanitize_coverage_option )


        blackfiles_map = {
            "address" : myenv.File("#etc/asan.blacklist"),
            "leak" : myenv.File("#etc/asan.blacklist"),
            "thread" : myenv.File("#etc/tsan.blacklist"),
            "undefined" : myenv.File("#etc/ubsan.blacklist"),
        }

        # Select those unique black files that are associated with the
        # currently enabled sanitizers, but filter out those that are
        # zero length.
        blackfiles = {v for (k, v) in blackfiles_map.items() if k in sanitizer_list}
        blackfiles = [f for f in blackfiles if os.stat(f.path).st_size != 0]

        # Filter out any blacklist options that the toolchain doesn't support.
        supportedBlackfiles = []
        blackfilesTestEnv = myenv.Clone()
        for blackfile in blackfiles:
            if AddToCCFLAGSIfSupported(blackfilesTestEnv, "-fsanitize-blacklist=%s" % blackfile):
                supportedBlackfiles.append(blackfile)
        blackfilesTestEnv = None
        blackfiles = sorted(supportedBlackfiles)

        # If we ended up with any blackfiles after the above filters,
        # then expand them into compiler flag arguments, and use a
        # generator to return at command line expansion time so that
        # we can change the signature if the file contents change.
        if blackfiles:
            blacklist_options=["-fsanitize-blacklist=%s" % blackfile for blackfile in blackfiles]
            def SanitizerBlacklistGenerator(source, target, env, for_signature):
                if for_signature:
                    return [f.get_csig() for f in blackfiles]
                return blacklist_options
            myenv.AppendUnique(
                SANITIZER_BLACKLIST_GENERATOR=SanitizerBlacklistGenerator,
                CCFLAGS="${SANITIZER_BLACKLIST_GENERATOR}",
                LINKFLAGS="${SANITIZER_BLACKLIST_GENERATOR}",
            )

        llvm_symbolizer = get_option('llvm-symbolizer')
        if os.path.isabs(llvm_symbolizer):
            if not myenv.File(llvm_symbolizer).exists():
                print("WARNING: Specified symbolizer '%s' not found" % llvm_symbolizer)
                llvm_symbolizer = None
        else:
            llvm_symbolizer = myenv.WhereIs(llvm_symbolizer)

        tsan_options = ""
        if llvm_symbolizer:
            myenv['ENV']['ASAN_SYMBOLIZER_PATH'] = llvm_symbolizer
            myenv['ENV']['LSAN_SYMBOLIZER_PATH'] = llvm_symbolizer
            tsan_options = "external_symbolizer_path=\"%s\" " % llvm_symbolizer
        elif using_lsan:
            myenv.FatalError("Using the leak sanitizer requires a valid symbolizer")

        if using_asan:
            # Unfortunately, abseil requires that we make these macros
            # (this, and THREAD_ and UNDEFINED_BEHAVIOR_ below) set,
            # because apparently it is too hard to query the running
            # compiler. We do this unconditionally because abseil is
            # basically pervasive via the 'base' library.
            myenv.AppendUnique(CPPDEFINES=['ADDRESS_SANITIZER'])

        if using_tsan:
            tsan_options += "suppressions=\"%s\" " % myenv.File("#etc/tsan.suppressions").abspath
            myenv['ENV']['TSAN_OPTIONS'] = tsan_options
            myenv.AppendUnique(CPPDEFINES=['THREAD_SANITIZER'])

        if using_ubsan:
            # By default, undefined behavior sanitizer doesn't stop on
            # the first error. Make it so. Newer versions of clang
            # have renamed the flag.
            # However, this flag cannot be included when using the fuzzer sanitizer
            # if we want to suppress errors to uncover new ones.
            if not using_fsan and not AddToCCFLAGSIfSupported(myenv, "-fno-sanitize-recover"):
                AddToCCFLAGSIfSupported(myenv, "-fno-sanitize-recover=undefined")
            myenv.AppendUnique(CPPDEFINES=['UNDEFINED_BEHAVIOR_SANITIZER'])

    if myenv.ToolchainIs('msvc') and optBuild:
        # http://blogs.msdn.com/b/vcblog/archive/2013/09/11/introducing-gw-compiler-switch.aspx
        #
        myenv.Append( CCFLAGS=["/Gw", "/Gy"] )
        myenv.Append( LINKFLAGS=["/OPT:REF"])

        # http://blogs.msdn.com/b/vcblog/archive/2014/03/25/linker-enhancements-in-visual-studio-2013-update-2-ctp2.aspx
        #
        myenv.Append( CCFLAGS=["/Zc:inline"])

    if myenv.ToolchainIs('gcc', 'clang'):
        # This tells clang/gcc to use the gold linker if it is available - we prefer the gold linker
        # because it is much faster. Don't use it if the user has already configured another linker
        # selection manually.
        if not any(flag.startswith('-fuse-ld=') for flag in env['LINKFLAGS']):
            if AddToLINKFLAGSIfSupported(myenv, '-fuse-ld=lld') or AddToLINKFLAGSIfSupported(myenv, '-fuse-ld=gold'):
                if link_model.startswith("dynamic"):
                    AddToLINKFLAGSIfSupported(myenv, '-Wl,--gdb-index')

            # Our build is already parallel.
            AddToLINKFLAGSIfSupported(myenv, '-Wl,--no-threads')

        # Explicitly enable GNU build id's if the linker supports it.
        AddToLINKFLAGSIfSupported(myenv, '-Wl,--build-id')

        # Explicitly use the new gnu hash section if the linker offers
        # it, except on android since older runtimes seem to not
        # support it. For that platform, use 'both'.
        if env.TargetOSIs('android'):
            AddToLINKFLAGSIfSupported(myenv, '-Wl,--hash-style=both')
        else:
            AddToLINKFLAGSIfSupported(myenv, '-Wl,--hash-style=gnu')

        # Try to have the linker tell us about ODR violations. Don't
        # use it when using clang with libstdc++, as libstdc++ was
        # probably built with GCC. That combination appears to cause
        # false positives for the ODR detector. See SERVER-28133 for
        # additional details.
        if (get_option('detect-odr-violations') and
                not (myenv.ToolchainIs('clang') and usingLibStdCxx)):
            AddToLINKFLAGSIfSupported(myenv, '-Wl,--detect-odr-violations')

        # Disallow an executable stack. Also, issue a warning if any files are found that would
        # cause the stack to become executable if the noexecstack flag was not in play, so that we
        # can find them and fix them. We do this here after we check for ld.gold because the
        # --warn-execstack is currently only offered with gold.
        AddToLINKFLAGSIfSupported(myenv, "-Wl,-z,noexecstack")
        AddToLINKFLAGSIfSupported(myenv, "-Wl,--warn-execstack")

        # If possible with the current linker, mark relocations as read-only.
        AddToLINKFLAGSIfSupported(myenv, "-Wl,-z,relro")

    # Avoid deduping symbols on OS X debug builds, as it takes a long time.
    if not optBuild and myenv.ToolchainIs('clang') and env.TargetOSIs('darwin'):
        AddToLINKFLAGSIfSupported(myenv, "-Wl,-no_deduplicate")

    # Apply any link time optimization settings as selected by the 'lto' option.
    if has_option('lto'):
        if myenv.ToolchainIs('msvc'):
            # Note that this is actually more aggressive than LTO, it is whole program
            # optimization due to /GL. However, this is historically what we have done for
            # windows, so we are keeping it.
            #
            # /GL implies /LTCG, so no need to say it in CCFLAGS, but we do need /LTCG on the
            # link flags.
            myenv.Append(CCFLAGS=['/GL'])
            myenv.Append(LINKFLAGS=['/LTCG'])
            myenv.Append(ARFLAGS=['/LTCG'])
        elif myenv.ToolchainIs('gcc', 'clang'):
            # For GCC and clang, the flag is -flto, and we need to pass it both on the compile
            # and link lines.
            if not AddToCCFLAGSIfSupported(myenv, '-flto') or \
                    not AddToLINKFLAGSIfSupported(myenv, '-flto'):
                myenv.ConfError("Link time optimization requested, "
                    "but selected compiler does not honor -flto" )

            if myenv.TargetOSIs('darwin'):
                AddToLINKFLAGSIfSupported(myenv, '-Wl,-object_path_lto,${TARGET}.lto')

        else:
            myenv.ConfError("Don't know how to enable --lto on current toolchain")

    if get_option('runtime-hardening') == "on" and optBuild:
        # Older glibc doesn't work well with _FORTIFY_SOURCE=2. Selecting 2.11 as the minimum was an
        # emperical decision, as that is the oldest non-broken glibc we seem to require. It is possible
        # that older glibc's work, but we aren't trying.
        #
        # https://gforge.inria.fr/tracker/?func=detail&group_id=131&atid=607&aid=14070
        # https://github.com/jedisct1/libsodium/issues/202
        def CheckForGlibcKnownToSupportFortify(context):
            test_body="""
            #include <features.h>
            #if !__GLIBC_PREREQ(2, 11)
            #error
            #endif
            """
            context.Message('Checking for glibc with non-broken _FORTIFY_SOURCE...')
            ret = context.TryCompile(textwrap.dedent(test_body), ".c")
            context.Result(ret)
            return ret

        conf = Configure(myenv, help=False, custom_tests = {
            'CheckForFortify': CheckForGlibcKnownToSupportFortify,
        })

        # Fortify only possibly makes sense on POSIX systems, and we know that clang is not a valid
        # combination:
        #
        # http://lists.llvm.org/pipermail/cfe-dev/2015-November/045852.html
        #
        if env.TargetOSIs('posix') and not env.ToolchainIs('clang') and conf.CheckForFortify():
            conf.env.Append(
                CPPDEFINES=[
                    ('_FORTIFY_SOURCE', 2),
                ],
            )

        myenv = conf.Finish()

    # We set this to work around https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43052
    if not myenv.ToolchainIs('msvc'):
        AddToCCFLAGSIfSupported(myenv, "-fno-builtin-memcmp")

    def CheckThreadLocal(context):
        test_body = """
        thread_local int tsp_int = 1;
        int main(int argc, char** argv) {{
            return !(tsp_int == argc);
        }}
        """
        context.Message('Checking for storage class thread_local ')
        ret = context.TryLink(textwrap.dedent(test_body), ".cpp")
        context.Result(ret)
        return ret

    conf = Configure(myenv, help=False, custom_tests = {
        'CheckThreadLocal': CheckThreadLocal
    })
    if not conf.CheckThreadLocal():
        env.ConfError("Compiler must support the thread_local storage class")
    conf.Finish()

    def CheckCXX14EnableIfT(context):
        test_body = """
        #include <cstdlib>
        #include <type_traits>

        template <typename = void>
        struct scons {
            bool hasSupport() { return false; }
        };

        template <>
        struct scons<typename std::enable_if_t<true>> {
            bool hasSupport() { return true; }
        };

        int main(int argc, char **argv) {
            scons<> SCons;
            return SCons.hasSupport() ? EXIT_SUCCESS : EXIT_FAILURE;
        }
        """
        context.Message('Checking for C++14 std::enable_if_t support...')
        ret = context.TryCompile(textwrap.dedent(test_body), '.cpp')
        context.Result(ret)
        return ret

    # Check for std::enable_if_t support without using the __cplusplus macro
    conf = Configure(myenv, help=False, custom_tests = {
        'CheckCXX14EnableIfT' : CheckCXX14EnableIfT,
    })

    if conf.CheckCXX14EnableIfT():
        conf.env.SetConfigHeaderDefine('MONGO_CONFIG_HAVE_STD_ENABLE_IF_T')

    # pthread_setname_np was added in GLIBC 2.12, and Solaris 11.3
    if posix_system:
        myenv = conf.Finish()

        def CheckPThreadSetNameNP(context):
            compile_test_body = textwrap.dedent("""
            #ifndef _GNU_SOURCE
            #define _GNU_SOURCE
            #endif
            #include <pthread.h>

            int main() {
                pthread_setname_np(pthread_self(), "test");
                return 0;
            }
            """)

            context.Message("Checking if pthread_setname_np is supported... ")
            result = context.TryCompile(compile_test_body, ".cpp")
            context.Result(result)
            return result

        conf = Configure(myenv, custom_tests = {
            'CheckPThreadSetNameNP': CheckPThreadSetNameNP,
        })

        if conf.CheckPThreadSetNameNP():
            conf.env.SetConfigHeaderDefine("MONGO_CONFIG_HAVE_PTHREAD_SETNAME_NP")

    myenv = conf.Finish()

    def CheckBoostMinVersion(context):
        compile_test_body = textwrap.dedent("""
        #include <boost/version.hpp>

        #if BOOST_VERSION < 104900
        #error
        #endif
        """)

        context.Message("Checking if system boost version is 1.49 or newer...")
        result = context.TryCompile(compile_test_body, ".cpp")
        context.Result(result)
        return result

    conf = Configure(myenv, custom_tests = {
        'CheckBoostMinVersion': CheckBoostMinVersion,
    })

    libdeps.setup_conftests(conf)

    ### --ssl checks
    def checkOpenSSL(conf):
        sslLibName = "ssl"
        cryptoLibName = "crypto"
        sslLinkDependencies = ["crypto", "dl"]
        if conf.env.TargetOSIs('freebsd'):
            sslLinkDependencies = ["crypto"]

        if conf.env.TargetOSIs('windows'):
            sslLibName = "ssleay32"
            cryptoLibName = "libeay32"
            sslLinkDependencies = ["libeay32"]

        # Used to import system certificate keychains
        if conf.env.TargetOSIs('darwin'):
            conf.env.AppendUnique(FRAMEWORKS=[
                'CoreFoundation',
                'Security',
            ])

        def maybeIssueDarwinSSLAdvice(env):
            if env.TargetOSIs('macOS'):
                advice = textwrap.dedent(
                    """\
                    NOTE: Recent versions of macOS no longer ship headers for the system OpenSSL libraries.
                    NOTE: Either build without the --ssl flag, or describe how to find OpenSSL.
                    NOTE: Set the include path for the OpenSSL headers with the CPPPATH SCons variable.
                    NOTE: Set the library path for OpenSSL libraries with the LIBPATH SCons variable.
                    NOTE: If you are using HomeBrew, and have installed OpenSSL, this might look like:
                    \tscons CPPPATH=/usr/local/opt/openssl/include LIBPATH=/usr/local/opt/openssl/lib ...
                    NOTE: Consult the output of 'brew info openssl' for details on the correct paths."""
                )
                print(advice)
                brew = env.WhereIs('brew')
                if brew:
                    try:
                        # TODO: If we could programmatically extract the paths from the info output
                        # we could give a better message here, but brew info's machine readable output
                        # doesn't seem to include the whole 'caveats' section.
                        message = subprocess.check_output([brew, "info", "openssl"]).decode('utf-8')
                        advice = textwrap.dedent(
                            """\
                            NOTE: HomeBrew installed to {0} appears to have OpenSSL installed.
                            NOTE: Consult the output from '{0} info openssl' to determine CPPPATH and LIBPATH."""
                        ).format(brew, message)

                        print(advice)
                    except:
                        pass

        if not conf.CheckLibWithHeader(
                cryptoLibName,
                ["openssl/crypto.h"],
                "C",
                "SSLeay_version(0);",
                autoadd=True):
            maybeIssueDarwinSSLAdvice(conf.env)
            conf.env.ConfError("Couldn't find OpenSSL crypto.h header and library")

        def CheckLibSSL(context):
            res = SCons.Conftest.CheckLib(context,
                     libs=[sslLibName],
                     extra_libs=sslLinkDependencies,
                     header='#include "openssl/ssl.h"',
                     language="C",
                     call="SSL_version(NULL);",
                     autoadd=True)
            context.did_show_result = 1
            return not res

        conf.AddTest("CheckLibSSL", CheckLibSSL)

        if not conf.CheckLibSSL():
           maybeIssueDarwinSSLAdvice(conf.env)
           conf.env.ConfError("Couldn't find OpenSSL ssl.h header and library")

        def CheckLinkSSL(context):
            test_body = """
            #include <openssl/err.h>
            #include <openssl/ssl.h>
            #include <stdlib.h>

            int main() {
                SSL_library_init();
                SSL_load_error_strings();
                ERR_load_crypto_strings();

                OpenSSL_add_all_algorithms();
                ERR_free_strings();

                return EXIT_SUCCESS;
            }
            """
            context.Message("Checking that linking to OpenSSL works...")
            ret = context.TryLink(textwrap.dedent(test_body), ".c")
            context.Result(ret)
            return ret

        conf.AddTest("CheckLinkSSL", CheckLinkSSL)

        if not conf.CheckLinkSSL():
            maybeIssueDarwinSSLAdvice(conf.env)
            conf.env.ConfError("SSL is enabled, but is unavailable")

        if conf.CheckDeclaration(
            "FIPS_mode_set",
            includes="""
                #include <openssl/crypto.h>
                #include <openssl/evp.h>
            """):
            conf.env.SetConfigHeaderDefine('MONGO_CONFIG_HAVE_FIPS_MODE_SET')

        if conf.CheckDeclaration(
            "d2i_ASN1_SEQUENCE_ANY",
            includes="""
                #include <openssl/asn1.h>
            """):
            conf.env.SetConfigHeaderDefine('MONGO_CONFIG_HAVE_ASN1_ANY_DEFINITIONS')

        def CheckOpenSSL_EC_DH(context):
            compile_test_body = textwrap.dedent("""
            #include <openssl/ssl.h>

            int main() {
                SSL_CTX_set_ecdh_auto(0, 0);
                SSL_set_ecdh_auto(0, 0);
                return 0;
            }
            """)

            context.Message("Checking if SSL_[CTX_]_set_ecdh_auto is supported... ")
            result = context.TryCompile(compile_test_body, ".cpp")
            context.Result(result)
            return result

        def CheckOpenSSL_EC_KEY_new(context):
            compile_test_body = textwrap.dedent("""
            #include <openssl/ssl.h>
            #include <openssl/ec.h>

            int main() {
                SSL_CTX_set_tmp_ecdh(0, 0);
                EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
                EC_KEY_free(0);
                return 0;
            }
            """)

            context.Message("Checking if EC_KEY_new_by_curve_name is supported... ")
            result = context.TryCompile(compile_test_body, ".cpp")
            context.Result(result)
            return result

        conf.AddTest("CheckOpenSSL_EC_DH", CheckOpenSSL_EC_DH)
        if conf.CheckOpenSSL_EC_DH():
            conf.env.SetConfigHeaderDefine('MONGO_CONFIG_HAVE_SSL_SET_ECDH_AUTO')

        conf.AddTest("CheckOpenSSL_EC_KEY_new", CheckOpenSSL_EC_KEY_new)
        if conf.CheckOpenSSL_EC_KEY_new():
            conf.env.SetConfigHeaderDefine('MONGO_CONFIG_HAVE_SSL_EC_KEY_NEW')

    # We require ssl by default unless the user has specified --ssl=off
    require_ssl = get_option("ssl") != "off"

    # The following platform checks setup both
    # ssl_provider for TLS implementation
    # and MONGO_CRYPTO for hashing support.
    #
    # MONGO_CRYPTO is always enabled regardless of --ssl=on/off
    # However, ssl_provider will be rewritten to 'none' if --ssl=off
    if conf.env.TargetOSIs('windows'):
        # SChannel on Windows
        ssl_provider = 'windows'
        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_SSL_PROVIDER", "MONGO_CONFIG_SSL_PROVIDER_WINDOWS")
        conf.env.Append( MONGO_CRYPTO=["windows"] )

    elif conf.env.TargetOSIs('darwin', 'macOS'):
        # SecureTransport on macOS
        ssl_provider = 'apple'
        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_SSL_PROVIDER", "MONGO_CONFIG_SSL_PROVIDER_APPLE")
        conf.env.Append( MONGO_CRYPTO=["apple"] )
        conf.env.AppendUnique(FRAMEWORKS=['CoreFoundation', 'Security'])

    elif require_ssl:
        checkOpenSSL(conf)
        # Working OpenSSL available, use it.
        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_SSL_PROVIDER", "MONGO_CONFIG_SSL_PROVIDER_OPENSSL")
        conf.env.Append( MONGO_CRYPTO=["openssl"] )
        ssl_provider = 'openssl'

    else:
        # If we don't need an SSL build, we can get by with TomCrypt.
        conf.env.Append( MONGO_CRYPTO=["tom"] )

    if require_ssl:
        # Either crypto engine is native,
        # or it's OpenSSL and has been checked to be working.
        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_SSL")
        print("Using SSL Provider: {0}".format(ssl_provider))
    else:
        ssl_provider = "none"

    def checkHTTPLib(required=False):
        # WinHTTP available on Windows
        if env.TargetOSIs("windows"):
            return True

        # libcurl on all other platforms
        if conf.CheckLibWithHeader(
            "curl",
            ["curl/curl.h"], "C",
            "curl_global_init(0);",
            autoadd=False):
            return True

        if required:
            env.ConfError("Could not find <curl/curl.h> and curl lib")

        return False

    if use_system_version_of_library("pcre"):
        conf.FindSysLibDep("pcre", ["pcre"])
        conf.FindSysLibDep("pcrecpp", ["pcrecpp"])
    else:
        env.Prepend(CPPDEFINES=['PCRE_STATIC'])

    if use_system_version_of_library("snappy"):
        conf.FindSysLibDep("snappy", ["snappy"])

    if use_system_version_of_library("zlib"):
        conf.FindSysLibDep("zlib", ["zdll" if conf.env.TargetOSIs('windows') else "z"])

    if use_system_version_of_library("zstd"):
        conf.FindSysLibDep("zstd", ["libzstd" if conf.env.TargetOSIs('windows') else "zstd"])

    if use_system_version_of_library("stemmer"):
        conf.FindSysLibDep("stemmer", ["stemmer"])

    if use_system_version_of_library("yaml"):
        conf.FindSysLibDep("yaml", ["yaml-cpp"])

    if use_system_version_of_library("fmt"):
        conf.FindSysLibDep("fmt", ["fmt"])

    if use_system_version_of_library("libunwind"):
        conf.FindSysLibDep("unwind", ["unwind"])

    if use_system_version_of_library("intel_decimal128"):
        conf.FindSysLibDep("intel_decimal128", ["bid"])

    if use_system_version_of_library("icu"):
        conf.FindSysLibDep("icudata", ["icudata"])
        # We can't use FindSysLibDep() for icui18n and icuuc below, since SConf.CheckLib() (which
        # FindSysLibDep() relies on) doesn't expose an 'extra_libs' parameter to indicate that the
        # library being tested has additional dependencies (icuuc depends on icudata, and icui18n
        # depends on both). As a workaround, we skip the configure check for these two libraries and
        # manually assign the library name. We hope that if the user has icudata installed on their
        # system, then they also have icu18n and icuuc installed.
        conf.env['LIBDEPS_ICUI18N_SYSLIBDEP'] = 'icui18n'
        conf.env['LIBDEPS_ICUUC_SYSLIBDEP'] = 'icuuc'

    if wiredtiger and use_system_version_of_library("wiredtiger"):
        if not conf.CheckCXXHeader( "wiredtiger.h" ):
            myenv.ConfError("Cannot find wiredtiger headers")
        conf.FindSysLibDep("wiredtiger", ["wiredtiger"])

    conf.env.Append(
        CPPDEFINES=[
            ("BOOST_THREAD_VERSION", "5"),
            "BOOST_THREAD_USES_DATETIME",
            "BOOST_SYSTEM_NO_DEPRECATED",
            "BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS",
            "BOOST_ENABLE_ASSERT_DEBUG_HANDLER",
            "BOOST_LOG_NO_SHORTHAND_NAMES",
            "BOOST_LOG_USE_NATIVE_SYSLOG",
            "BOOST_LOG_WITHOUT_THREAD_ATTR",
            "ABSL_FORCE_ALIGNED_ACCESS",
        ]
    )

    if link_model.startswith("dynamic") and not link_model == 'dynamic-sdk':
        conf.env.AppendUnique(
            CPPDEFINES=[
                "BOOST_LOG_DYN_LINK",
            ]
    )

    if use_system_version_of_library("boost"):
        if not conf.CheckCXXHeader( "boost/filesystem/operations.hpp" ):
            myenv.ConfError("can't find boost headers")
        if not conf.CheckBoostMinVersion():
            myenv.ConfError("system's version of boost is too old. version 1.49 or better required")

        # Note that on Windows with using-system-boost builds, the following
        # FindSysLibDep calls do nothing useful (but nothing problematic either)
        #
        # NOTE: Pass --system-boost-lib-search-suffixes= to suppress these checks, which you
        # might want to do if using autolib linking on Windows, for example.
        if boostSuffixList:
            for b in boostLibs:
                boostlib = "boost_" + b
                conf.FindSysLibDep(
                    boostlib,
                    [boostlib + suffix for suffix in boostSuffixList],
                    language='C++')
    if posix_system:
        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_HAVE_HEADER_UNISTD_H")
        conf.CheckLib('rt')
        conf.CheckLib('dl')

    if posix_monotonic_clock:
        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_HAVE_POSIX_MONOTONIC_CLOCK")

    if get_option('use-diagnostic-latches') == 'off':
        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_USE_RAW_LATCHES")

    if (conf.CheckCXXHeader( "execinfo.h" ) and
        conf.CheckDeclaration('backtrace', includes='#include <execinfo.h>') and
        conf.CheckDeclaration('backtrace_symbols', includes='#include <execinfo.h>') and
        conf.CheckDeclaration('backtrace_symbols_fd', includes='#include <execinfo.h>')):

        conf.env.SetConfigHeaderDefine("MONGO_CONFIG_HAVE_EXECINFO_BACKTRACE")

    conf.env["_HAVEPCAP"] = conf.CheckLib( ["pcap", "wpcap"], autoadd=False )

    if env.TargetOSIs('solaris'):
        conf.CheckLib( "nsl" )

    conf.env['MONGO_BUILD_SASL_CLIENT'] = bool(has_option("use-sasl-client"))
    if conf.env['MONGO_BUILD_SASL_CLIENT'] and not conf.CheckLibWithHeader(
            "sasl2",
            ["stddef.h","sasl/sasl.h"],
            "C",
            "sasl_version_info(0, 0, 0, 0, 0, 0);",
            autoadd=False ):
        myenv.ConfError("Couldn't find SASL header/libraries")

    # requires ports devel/libexecinfo to be installed
    if env.TargetOSIs('freebsd', 'openbsd'):
        if not conf.CheckLib("execinfo"):
            myenv.ConfError("Cannot find libexecinfo, please install devel/libexecinfo.")

    # 'tcmalloc' needs to be the last library linked. Please, add new libraries before this
    # point.
    if myenv['MONGO_ALLOCATOR'] == 'tcmalloc':
        if use_system_version_of_library('tcmalloc'):
            conf.FindSysLibDep("tcmalloc", ["tcmalloc"])
    elif myenv['MONGO_ALLOCATOR'] in ['system', 'tcmalloc-experimental']:
        pass
    else:
        myenv.FatalError("Invalid --allocator parameter: $MONGO_ALLOCATOR")

    def CheckStdAtomic(context, base_type, extra_message):
        test_body = """
        #include <atomic>

        int main(int argc, char* argv[]) {{
            std::atomic<{0}> x;

            x.store(0);
            // Use argc to ensure we can't optimize everything away.
            {0} y = argc;
            x.fetch_add(y);
            x.fetch_sub(y);
            x.exchange(y);
            if (x.compare_exchange_strong(y, x) && x.is_lock_free())
                return 0;
            return x.load();
        }}
        """.format(base_type)

        context.Message(
            "Checking if std::atomic<{0}> works{1}... ".format(
                base_type, extra_message
            )
        )

        ret = context.TryLink(textwrap.dedent(test_body), ".cpp")
        context.Result(ret)
        return ret
    conf.AddTest("CheckStdAtomic", CheckStdAtomic)

    def check_all_atomics(extra_message=''):
        for t in ('int64_t', 'uint64_t', 'int32_t', 'uint32_t'):
            if not conf.CheckStdAtomic(t, extra_message):
                return False
        return True

    if not check_all_atomics():
        if not conf.CheckLib('atomic', symbol=None, header=None, language='C', autoadd=1):
            myenv.ConfError("Some atomic ops are not intrinsically supported, but "
                "no libatomic found")
        if not check_all_atomics(' with libatomic'):
            myenv.ConfError("The toolchain does not support std::atomic, cannot continue")

    def CheckExtendedAlignment(context, size):
        test_body = """
            #include <atomic>
            #include <mutex>
            #include <cstddef>

            static_assert(alignof(std::max_align_t) < {0}, "whatever");

            alignas({0}) std::mutex aligned_mutex;
            alignas({0}) std::atomic<int> aligned_atomic;

            struct alignas({0}) aligned_struct_mutex {{
                std::mutex m;
            }};

            struct alignas({0}) aligned_struct_atomic {{
                std::atomic<int> m;
            }};

            struct holds_aligned_mutexes {{
                alignas({0}) std::mutex m1;
                alignas({0}) std::mutex m2;
            }} hm;

            struct holds_aligned_atomics {{
                alignas({0}) std::atomic<int> a1;
                alignas({0}) std::atomic<int> a2;
            }} ha;
        """.format(size)

        context.Message('Checking for extended alignment {0} for concurrency types... '.format(size))
        ret = context.TryCompile(textwrap.dedent(test_body), ".cpp")
        context.Result(ret)
        return ret

    conf.AddTest('CheckExtendedAlignment', CheckExtendedAlignment)

    # If we don't have a specialized search sequence for this
    # architecture, assume 64 byte cache lines, which is pretty
    # standard. If for some reason the compiler can't offer that, try
    # 32.
    default_alignment_search_sequence = [ 64, 32 ]

    # The following are the target architectures for which we have
    # some knowledge that they have larger cache line sizes. In
    # particular, POWER8 uses 128 byte lines and zSeries uses 256. We
    # start at the goal state, and work down until we find something
    # the compiler can actualy do for us.
    extended_alignment_search_sequence = {
        'ppc64le' : [ 128, 64, 32 ],
        's390x' : [ 256, 128, 64, 32 ],
    }

    for size in extended_alignment_search_sequence.get(env['TARGET_ARCH'], default_alignment_search_sequence):
        if conf.CheckExtendedAlignment(size):
            conf.env.SetConfigHeaderDefine("MONGO_CONFIG_MAX_EXTENDED_ALIGNMENT", size)
            break

    def CheckMongoCMinVersion(context):
        compile_test_body = textwrap.dedent("""
        #include <mongoc/mongoc.h>

        #if !MONGOC_CHECK_VERSION(1,13,0)
        #error
        #endif
        """)

        context.Message("Checking if mongoc version is 1.13.0 or newer...")
        result = context.TryCompile(compile_test_body, ".cpp")
        context.Result(result)
        return result

    conf.AddTest('CheckMongoCMinVersion', CheckMongoCMinVersion)

    if env.TargetOSIs('darwin'):
        def CheckMongoCFramework(context):
            context.Message("Checking for mongoc_get_major_version() in darwin framework mongoc...")
            test_body = """
            #include <mongoc/mongoc.h>

            int main() {
                mongoc_get_major_version();

                return EXIT_SUCCESS;
            }
            """

            lastFRAMEWORKS = context.env['FRAMEWORKS']
            context.env.Append(FRAMEWORKS=['mongoc'])
            result = context.TryLink(textwrap.dedent(test_body), ".c")
            context.Result(result)
            context.env['FRAMEWORKS'] = lastFRAMEWORKS
            return result

        conf.AddTest('CheckMongoCFramework', CheckMongoCFramework)

    mongoc_mode = get_option('use-system-mongo-c')
    conf.env['MONGO_HAVE_LIBMONGOC'] = False
    if mongoc_mode != 'off':
        if conf.CheckLibWithHeader(
                ["mongoc-1.0"],
                ["mongoc/mongoc.h"],
                "C",
                "mongoc_get_major_version();",
                autoadd=False ):
            conf.env['MONGO_HAVE_LIBMONGOC'] = "library"
        if not conf.env['MONGO_HAVE_LIBMONGOC'] and env.TargetOSIs('darwin') and conf.CheckMongoCFramework():
            conf.env['MONGO_HAVE_LIBMONGOC'] = "framework"
        if not conf.env['MONGO_HAVE_LIBMONGOC'] and mongoc_mode == 'on':
            myenv.ConfError("Failed to find the required C driver headers")
        if conf.env['MONGO_HAVE_LIBMONGOC'] and not conf.CheckMongoCMinVersion():
            myenv.ConfError("Version of mongoc is too old. Version 1.13+ required")

    # ask each module to configure itself and the build environment.
    moduleconfig.configure_modules(mongo_modules, conf)

    # Resolve --enable-free-mon
    if free_monitoring == "auto":
        if 'enterprise' not in conf.env['MONGO_MODULES']:
            free_monitoring = "on"
        else:
            free_monitoring = "off"

    if free_monitoring == "on":
        checkHTTPLib(required=True)

    # Resolve --enable-http-client
    if http_client == "auto":
        if checkHTTPLib():
            http_client = "on"
        else:
            print("Disabling http-client as libcurl was not found")
            http_client = "off"
    elif http_client == "on":
        checkHTTPLib(required=True)

    # Sanity check.
    # We know that http_client was explicitly disabled here,
    # because the free_monitoring check would have failed if no http lib were available.
    if (free_monitoring == "on") and (http_client == "off"):
        env.ConfError("FreeMonitoring requires an HTTP client which has been explicitly disabled")

    if env['TARGET_ARCH'] == "ppc64le":
        # This checks for an altivec optimization we use in full text search.
        # Different versions of gcc appear to put output bytes in different
        # parts of the output vector produced by vec_vbpermq.  This configure
        # check looks to see which format the compiler produces.
        #
        # NOTE: This breaks cross compiles, as it relies on checking runtime functionality for the
        # environment we're in.  A flag to choose the index, or the possibility that we don't have
        # multiple versions to support (after a compiler upgrade) could solve the problem if we
        # eventually need them.
        def CheckAltivecVbpermqOutput(context, index):
            test_body = """
                #include <altivec.h>
                #include <cstring>
                #include <cstdint>
                #include <cstdlib>

                int main() {{
                    using Native = __vector signed char;
                    const size_t size = sizeof(Native);
                    const Native bits = {{ 120, 112, 104, 96, 88, 80, 72, 64, 56, 48, 40, 32, 24, 16, 8, 0 }};

                    uint8_t inputBuf[size];
                    std::memset(inputBuf, 0xFF, sizeof(inputBuf));

                    for (size_t offset = 0; offset <= size; offset++) {{
                        Native vec = vec_vsx_ld(0, reinterpret_cast<const Native*>(inputBuf));

                        uint64_t mask = vec_extract(vec_vbpermq(vec, bits), {0});

                        size_t initialZeros = (mask == 0 ? size : __builtin_ctzll(mask));
                        if (initialZeros != offset) {{
			    return 1;
                        }}

                        if (offset < size) {{
                            inputBuf[offset] = 0;  // Add an initial 0 for the next loop.
                        }}
                    }}

		    return 0;
                }}
            """.format(index)

            context.Message('Checking for vec_vbperm output in index {0}... '.format(index))
            ret = context.TryRun(textwrap.dedent(test_body), ".cpp")
            context.Result(ret[0])
            return ret[0]

        conf.AddTest('CheckAltivecVbpermqOutput', CheckAltivecVbpermqOutput)

        outputIndex = next((idx for idx in [0,1] if conf.CheckAltivecVbpermqOutput(idx)), None)
        if outputIndex is not None:
            conf.env.SetConfigHeaderDefine("MONGO_CONFIG_ALTIVEC_VEC_VBPERMQ_OUTPUT_INDEX", outputIndex)
        else:
            myenv.ConfError("Running on ppc64le, but can't find a correct vec_vbpermq output index.  Compiler or platform not supported")

    myenv = conf.Finish()

    conf = Configure(myenv)
    usdt_enabled = get_option('enable-usdt-probes')
    usdt_provider = None
    if usdt_enabled in ('auto', 'on'):
        if env.TargetOSIs('linux'):
            if conf.CheckHeader('sys/sdt.h'):
                usdt_provider = 'SDT'
        # can put other OS targets here
        if usdt_enabled == 'on' and not usdt_provider:
             myenv.ConfError("enable-usdt-probes flag was set to on, but no USDT provider could be found")
        elif usdt_provider:
            conf.env.SetConfigHeaderDefine("MONGO_CONFIG_USDT_ENABLED")
            conf.env.SetConfigHeaderDefine("MONGO_CONFIG_USDT_PROVIDER", usdt_provider)
    return conf.Finish()


env = doConfigure( env )
env["NINJA_SYNTAX"] = "#site_scons/third_party/ninja_syntax.py"

# Now that we are done with configure checks, enable ccache and
# icecream, if available. Per the rules declared in the icecream tool,
# load the ccache tool first.
env.Tool('ccache')

if env.ToolchainIs("clang"):
    env["ICECC_COMPILER_TYPE"] = "clang"
elif env.ToolchainIs("gcc"):
    env["ICECC_COMPILER_TYPE"] = "gcc"

env.Tool('icecream')

if get_option('ninja') != 'disabled':
    if get_option('ninja') == 'stable':
        ninja_builder = Tool("ninja")
        ninja_builder.generate(env)

        # Explicitly add all generated sources to the DAG so NinjaBuilder can
        # generate rules for them. SCons if the files don't exist will not wire up
        # the dependencies in the DAG because it cannot scan them. The Ninja builder
        # does not care about the actual edge here as all generated sources will be
        # pushed to the "bottom" of it's DAG via the order_only dependency on
        # _generated_sources (an internal phony target)
        if get_option('install-mode') == 'hygienic':
            env.Alias("install-common-base", env.Alias("generated-sources"))
        else:
            env.Alias("all", env.Alias("generated-sources"))
            env.Alias("core", env.Alias("generated-sources"))

        if env.get("NINJA_SUFFIX") and env["NINJA_SUFFIX"][0] != ".":
            env["NINJA_SUFFIX"] = "." + env["NINJA_SUFFIX"]

        if get_option("install-mode") == "hygienic":
            ninja_build = env.Ninja(
                target="${NINJA_PREFIX}.ninja$NINJA_SUFFIX",
                source=[
                    env.Alias("install-all-meta"),
                    env.Alias("test-execution-aliases"),
                ],
            )
        else:
            ninja_build = env.Ninja(
                target="${NINJA_PREFIX}.ninja$NINJA_SUFFIX",
                source=[
                    env.Alias("all"),
                    env.Alias("test-execution-aliases"),
                ],
            )

        env.Alias("generate-ninja", ninja_build)
    else:
        ninja_builder = Tool("ninja_next")
        ninja_builder.generate(env)
        env.Default(env.Alias("install-all-meta"))

    # idlc.py has the ability to print it's implicit dependencies
    # while generating, Ninja can consume these prints using the
    # deps=msvc method.
    env.AppendUnique(IDLCFLAGS=[
        "--write-dependencies-inline",
    ])
    env.NinjaRule(
        rule="IDLC",
        command="cmd /c $cmd" if env.TargetOSIs("windows") else "$cmd",
        description="Generating $out",
        deps="msvc",
        pool="local_pool",
    )

    def get_idlc_command(env, node, action, targets, sources, executor=None):
        _, variables = env.NinjaGetShellCommand(node, action, targets, sources, executor=executor)
        variables["msvc_deps_prefix"] = "import file:"
        return "IDLC", variables

    env.NinjaRuleMapping("$IDLCCOM", get_idlc_command)
    env.NinjaRuleMapping(env["IDLCCOM"], get_idlc_command)

    # We can create empty files for FAKELIB in Ninja because it
    # does not care about content signatures. We have to
    # write_uuid_to_file for FAKELIB in SCons because SCons does.
    env.NinjaRule(
        rule="FAKELIB",
        command="cmd /c copy 1>NUL NUL $out" if env["PLATFORM"] == "win32" else "touch $out",
    )

    def fakelib_in_ninja(env, node):
        """Generates empty .a files"""
        return {
            "outputs": [node.get_path()],
            "rule": "FAKELIB",
            "implicit": [str(s) for s in node.sources],
        }

    env.NinjaRegisterFunctionHandler("write_uuid_to_file", fakelib_in_ninja)

    def ninja_test_list_builder(env, node):
        test_files = [test_file.path for test_file in env["MONGO_TEST_REGISTRY"][node.path]]
        files = "\\n".join(test_files)
        return {
            "outputs": node.get_path(),
            "rule": "TEST_LIST",
            "implicit": test_files,
            "variables": {
                "files": files,
            }
        }

    env.NinjaRule(
        rule="TEST_LIST",
        description="Compiling test list: $out",
        command="{prefix}echo {flags} '$files' > '$out'".format(
            prefix="cmd.exe /c " if env["PLATFORM"] == "win32" else "",
            flags="-n" if env["PLATFORM"] != "win32" else "",
        ),
    )
    env.NinjaRegisterFunctionHandler("test_list_builder_action", ninja_test_list_builder)


# TODO: Later, this should live somewhere more graceful.
if get_option('install-mode') == 'hygienic':

    if get_option('separate-debug') == "on" or env.TargetOSIs("windows"):
        env.Tool('separate_debug')

    env["AUTO_ARCHIVE_TARBALL_SUFFIX"] = "tgz"

    env["AIB_META_COMPONENT"] = "all"
    env["AIB_BASE_COMPONENT"] = "common"
    env["AIB_DEFAULT_COMPONENT"] = "mongodb"

    env.Tool('auto_install_binaries')
    env.Tool('auto_archive')

    env.DeclareRoles(
        roles=[

            env.Role(
                name="base",
            ),

            env.Role(
                name="debug",
            ),

            env.Role(
                name="dev",
                dependencies=[
                    "runtime"
                ],
            ),

            env.Role(
                name="meta",
            ),

            env.Role(
                name="runtime",
                dependencies=[
                    # On windows, we want the runtime role to depend
                    # on the debug role so that PDBs end in the
                    # runtime package.
                    "debug" if env.TargetOSIs('windows') else None,
                ],
                silent=True,
            ),
        ],
        base_role="base",
        meta_role="meta",
    )

    def _aib_debugdir(source, target, env, for_signature):
        for s in source:
            origin = getattr(s.attributes, "debug_file_for", None)
            oentry = env.Entry(origin)
            osuf = oentry.get_suffix()
            map_entry = env["AIB_SUFFIX_MAP"].get(osuf)
            if map_entry:
                return map_entry[0]

        return "Unable to find debuginfo for {}".format(str(source))

    env["PREFIX_DEBUGDIR"] = _aib_debugdir

    env.AddSuffixMapping({
        "$PROGSUFFIX": env.SuffixMap(
            directory="$PREFIX_BINDIR",
            default_role="runtime",
        ),

        "$SHLIBSUFFIX": env.SuffixMap(
            directory="$PREFIX_BINDIR" \
            if mongo_platform.get_running_os_name() == "windows" \
            else "$PREFIX_LIBDIR",
            default_role="runtime",
        ),

        ".debug": env.SuffixMap(
            directory="$PREFIX_DEBUGDIR",
            default_role="debug",
        ),

        ".dSYM": env.SuffixMap(
            directory="$PREFIX_DEBUGDIR",
            default_role="debug",
        ),

        ".pdb": env.SuffixMap(
            directory="$PREFIX_DEBUGDIR",
            default_role="debug",
        ),
    })

    env.AddPackageNameAlias(
        component="dist",
        role="runtime",
        name="mongodb-dist",
    )

    env.AddPackageNameAlias(
        component="dist",
        role="debug",
        name="mongodb-dist-debugsymbols",
    )

    env.AddPackageNameAlias(
        component="dist-test",
        role="runtime",
        name="mongodb-binaries",
    )

    env.AddPackageNameAlias(
        component="dist-test",
        role="debug",
        name="mongo-debugsymbols",
    )

    env.AddPackageNameAlias(
        component="dbtest",
        role="runtime",
        name="dbtest-binary",
    )

    env.AddPackageNameAlias(
        component="dbtest",
        role="debug",
        name="dbtest-debugsymbols",
    )

    env.AddPackageNameAlias(
        component="shell",
        role="runtime",
        name="mongodb-shell",
    )

    env.AddPackageNameAlias(
        component="shell",
        role="debug",
        name="mongodb-shell-debugsymbols",
    )

    env.AddPackageNameAlias(
        component="mongocryptd",
        role="runtime",
        name="mongodb-cryptd",
    )

    env.AddPackageNameAlias(
        component="mongocryptd",
        role="debug",
        name="mongodb-cryptd-debugsymbols",
    )

    env.AddPackageNameAlias(
        component="mh",
        role="runtime",
        # TODO: we should be able to move this to where the mqlrun binary is
        # defined when AIB correctly uses environments instead of hooking into
        # the first environment used.
        name="mh-binaries",
    )

    env.AddPackageNameAlias(
        component="mh",
        role="debug",
        # TODO: we should be able to move this to where the mqlrun binary is
        # defined when AIB correctly uses environments instead of hooking into
        # the first environment used.
        name="mh-debugsymbols",
    )

    if env['PLATFORM'] == 'posix':
        env.AppendUnique(
            RPATH=[
                # In the future when we want to improve dynamic builds
                # we should set this to $PREFIX ideally
                 env.Literal('\\$$ORIGIN/../lib'),
            ],
            LINKFLAGS=[
                # Most systems *require* -z,origin to make origin work, but android
                # blows up at runtime if it finds DF_ORIGIN_1 in DT_FLAGS_1.
                # https://android.googlesource.com/platform/bionic/+/cbc80ba9d839675a0c4891e2ab33f39ba51b04b2/linker/linker.h#68
                # https://android.googlesource.com/platform/bionic/+/cbc80ba9d839675a0c4891e2ab33f39ba51b04b2/libc/include/elf.h#215
                '-Wl,-z,origin' if not env.TargetOSIs('android') else [],
                '-Wl,--enable-new-dtags',
            ],
            SHLINKFLAGS=[
                # -h works for both the sun linker and the gnu linker.
                "-Wl,-h,${TARGET.file}",
            ]
        )
    elif env['PLATFORM'] == 'darwin':
        env.AppendUnique(
            LINKFLAGS=[
                '-Wl,-rpath,@loader_path/../lib',
                '-Wl,-rpath,@loader_path/../Frameworks'
            ],
            SHLINKFLAGS=[
                "-Wl,-install_name,@rpath/${TARGET.file}",
            ],
        )
elif get_option('separate-debug') == "on":
    env.FatalError('Cannot use --separate-debug without --install-mode=hygienic')


# If the flags in the environment are configured for -gsplit-dwarf,
# inject the necessary emitter.
split_dwarf = Tool('split_dwarf')
if split_dwarf.exists(env):
    split_dwarf(env)

# Load the compilation_db tool. We want to do this after configure so we don't end up with
# compilation database entries for the configure tests, which is weird.
if get_option('ninja') == 'disabled':
    env.Tool("compilation_db")

# If we can, load the dagger tool for build dependency graph introspection.
# Dagger is only supported on Linux and OSX (not Windows or Solaris).
should_dagger = ( mongo_platform.is_running_os('osx') or mongo_platform.is_running_os('linux')  ) and "dagger" in COMMAND_LINE_TARGETS

if should_dagger:
    env.Tool("dagger")

incremental_link = Tool('incremental_link')
if incremental_link.exists(env):
    incremental_link(env)

# Resource Files are Windows specific
def env_windows_resource_file(env, path):
    if env.TargetOSIs('windows'):
        return [ env.RES(path) ]
    else:
        return []

env.AddMethod(env_windows_resource_file, 'WindowsResourceFile')

# --- lint ----

if get_option('lint-scope') == 'changed':
    patch_file = env.Command(
        target="$BUILD_DIR/current.git.patch",
        source=[env.WhereIs("git")],
        action="${SOURCES[0]} diff $GITDIFFFLAGS > $TARGET"
    )

    env.AlwaysBuild(patch_file)

    pylinters = env.Command(
        target="#lint-pylinters",
        source=[
            "buildscripts/pylinters.py",
            patch_file,
        ],
        action="$PYTHON ${SOURCES[0]} lint-patch ${SOURCES[1]}"
    )

    clang_format = env.Command(
        target="#lint-clang-format",
        source=[
            "buildscripts/clang_format.py",
            patch_file,
        ],
        action="$PYTHON ${SOURCES[0]} lint-patch ${SOURCES[1]}"
    )

    eslint = env.Command(
        target="#lint-eslint",
        source=[
            "buildscripts/eslint.py",
            patch_file,
        ],
        action="REVISION=$REVISION ENTERPRISE_REV=$ENTERPRISE_REV $PYTHON ${SOURCES[0]} lint-git-diff"
    )

else:
    pylinters = env.Command(
        target="#lint-pylinters",
        source=[
            "buildscripts/pylinters.py",
        ],
        action="$PYTHON ${SOURCES[0]} lint-all"
    )

    clang_format = env.Command(
        target="#lint-clang-format",
        source=[
            "buildscripts/clang_format.py",
        ],
        action="$PYTHON ${SOURCES[0]} lint-all"
    )

    eslint = env.Command(
        target="#lint-eslint",
        source=[
            "buildscripts/eslint.py",
        ],
        action="$PYTHON ${SOURCES[0]} --dirmode lint jstests/ src/mongo",
    )

lint_py = env.Command(
    target="#lint-lint.py",
    source=["buildscripts/quickcpplint.py"],
    action="$PYTHON ${SOURCES[0]} lint",
)

lint_errorcodes = env.Command(
    target="#lint-errorcodes",
    source=["buildscripts/errorcodes.py"],
    action="$PYTHON ${SOURCES[0]} --quiet",
)

env.Alias( "lint" , [ lint_py, eslint, clang_format, pylinters, lint_errorcodes ] )
env.Alias( "lint-fast" , [ eslint, clang_format, pylinters, lint_errorcodes ] )
env.AlwaysBuild( "lint" )
env.AlwaysBuild( "lint-fast" )

#  ----  INSTALL -------

def getSystemInstallName():
    arch_name = env.subst('$MONGO_DISTARCH')

    # We need to make sure the directory names inside dist tarballs are permanently
    # consistent, even if the target OS name used in scons is different. Any differences
    # between the names used by env.TargetOSIs/env.GetTargetOSName should be added
    # to the translation dictionary below.
    os_name_translations = {
        'windows': 'win32',
        'macOS': 'macos'
    }
    os_name = env.GetTargetOSName()
    os_name = os_name_translations.get(os_name, os_name)
    n = os_name + "-" + arch_name

    if len(mongo_modules):
            n += "-" + "-".join(m.name for m in mongo_modules)

    dn = env.subst('$MONGO_DISTMOD')
    if len(dn) > 0:
        n = n + "-" + dn

    return n

# This function will add the version.txt file to the source tarball
# so that versioning will work without having the git repo available.
def add_version_to_distsrc(env, archive):
    version_file_path = env.subst("$MONGO_DIST_SRC_PREFIX") + "version.json"
    if version_file_path not in archive:
        version_data = {
            'version': env['MONGO_VERSION'],
            'githash': env['MONGO_GIT_HASH'],
        }
        archive.append_file_contents(
            version_file_path,
            json.dumps(
                version_data,
                sort_keys=True,
                indent=4,
                separators=(',', ': ')
            )
        )

env.AddDistSrcCallback(add_version_to_distsrc)

env['SERVER_DIST_BASENAME'] = env.subst('mongodb-%s-$MONGO_DISTNAME' % (getSystemInstallName()))
env['MH_DIST_BASENAME'] = 'mh'
if get_option('legacy-tarball') == 'true':
    if ('tar-dist' not in COMMAND_LINE_TARGETS and
        'zip-dist' not in COMMAND_LINE_TARGETS and
        'archive-dist' not in COMMAND_LINE_TARGETS):
        env.FatalError('option --legacy-tarball only valid with an archive-dist target')
    env['PREFIX'] = '$SERVER_DIST_BASENAME'

module_sconscripts = moduleconfig.get_module_sconscripts(mongo_modules)

# The following symbols are exported for use in subordinate SConscript files.
# Ideally, the SConscript files would be purely declarative.  They would only
# import build environment objects, and would contain few or no conditional
# statements or branches.
#
# Currently, however, the SConscript files do need some predicates for
# conditional decision making that hasn't been moved up to this SConstruct file,
# and they are exported here, as well.
Export([
    'debugBuild',
    'endian',
    'free_monitoring',
    'get_option',
    'has_option',
    'http_client',
    'module_sconscripts',
    'optBuild',
    'serverJs',
    'ssl_provider',
    'use_libunwind',
    'use_system_libunwind',
    'use_system_version_of_library',
    'use_vendored_libunwind',
    'usemozjs',
    'wiredtiger',
])

def injectMongoIncludePaths(thisEnv):
    thisEnv.AppendUnique(CPPPATH=['$BUILD_DIR'])
env.AddMethod(injectMongoIncludePaths, 'InjectMongoIncludePaths')

def injectModule(env, module, **kwargs):
    injector = env['MODULE_INJECTORS'].get(module)
    if injector:
        return injector(env, **kwargs)
    return env
env.AddMethod(injectModule, 'InjectModule')

if get_option('ninja') == 'disabled':
    compileCommands = env.CompilationDatabase('compile_commands.json')
    compileDb = env.Alias("compiledb", compileCommands)


msvc_version = ""
if 'MSVC_VERSION' in env and env['MSVC_VERSION']:
    msvc_version = "--version " + env['MSVC_VERSION'] + " "

# Microsoft Visual Studio Project generation for code browsing
if get_option("ninja") == "disabled":
    vcxprojFile = env.Command(
        "mongodb.vcxproj",
        compileCommands,
        r"$PYTHON buildscripts\make_vcxproj.py " + msvc_version + "mongodb")
    vcxproj = env.Alias("vcxproj", vcxprojFile)

# TODO: maybe make these work like the other archive- hygienic aliases
# even though they aren't piped through AIB?
distSrc = env.DistSrc("distsrc.tar", NINJA_SKIP=True)
env.NoCache(distSrc)
env.Alias("distsrc-tar", distSrc)

distSrcGzip = env.GZip(
    target="distsrc.tgz",
    source=[distSrc],
    NINJA_SKIP=True)
env.NoCache(distSrcGzip)
env.Alias("distsrc-tgz", distSrcGzip)

distSrcZip = env.DistSrc("distsrc.zip", NINJA_SKIP=True)
env.NoCache(distSrcZip)
env.Alias("distsrc-zip", distSrcZip)

env.Alias("distsrc", "distsrc-tgz")

# Defaults for SCons provided flags. SetOption only sets the option to our value
# if the user did not provide it. So for any flag here if it's explicitly passed
# the values below set with SetOption will be overwritten.
#
# Default j to the number of CPUs on the system. Note: in containers this
# reports the number of CPUs for the host system. Perhaps in a future version of
# psutil it will instead report the correct number when in a container.
#
# The presence of the variable ICECC means the icecream tool is
# enabled and so the default j value should scale accordingly. In this
# scenario multiply the cpu count by 8 to set a reasonable default since the
# cluster can handle many more jobs than your local machine but is
# still throttled by your cpu count in the sense that you can only
# handle so many python threads sending out jobs.
#
# psutil.cpu_count returns None when it can't determine the number. This always
# fails on BSD's for example.
cpu_count = psutil.cpu_count()
if cpu_count is not None and 'ICECC' in env and get_option("ninja") == "disabled":
    env.SetOption('num_jobs', 8 * cpu_count)
elif cpu_count is not None:
    env.SetOption('num_jobs', cpu_count)


# Do this as close to last as possible before reading SConscripts, so
# that any tools that may have injected other things via emitters are included
# among the side effect adornments.
#
# TODO: Move this to a tool.
if has_option('jlink'):
    jlink = get_option('jlink')
    if jlink <= 0:
        env.FatalError("The argument to jlink must be a positive integer or float")
    elif jlink < 1 and jlink > 0:
        jlink = env.GetOption('num_jobs') * jlink
        jlink = round(jlink)
        if jlink < 1.0:
            print("Computed jlink value was less than 1; Defaulting to 1")
            jlink = 1.0

    jlink = int(jlink)
    target_builders = ['Program', 'SharedLibrary', 'LoadableModule']

    # A bound map of stream (as in stream of work) name to side-effect
    # file. Since SCons will not allow tasks with a shared side-effect
    # to execute concurrently, this gives us a way to limit link jobs
    # independently of overall SCons concurrency.
    jlink_stream_map = dict()

    def jlink_emitter(target, source, env):
        name = str(target[0])
        se_name = "#jlink-stream" + str(hash(name) % jlink)
        se_node = jlink_stream_map.get(se_name, None)
        if not se_node:
            se_node = env.Entry(se_name)
            # This may not be necessary, but why chance it
            env.NoCache(se_node)
            jlink_stream_map[se_name] = se_node
        env.SideEffect(se_node, target)
        return (target, source)

    for target_builder in target_builders:
        builder = env['BUILDERS'][target_builder]
        base_emitter = builder.emitter
        new_emitter = SCons.Builder.ListEmitter([base_emitter, jlink_emitter])
        builder.emitter = new_emitter

# Keep this late in the game so that we can investigate attributes set by all the tools that have run.
if has_option("cache"):
    if get_option("cache") == "nolinked":
        def noCacheEmitter(target, source, env):
            for t in target:
                try:
                    if getattr(t.attributes, 'thin_archive', False):
                        continue
                except(AttributeError):
                    pass
                env.NoCache(t)
            return target, source

        def addNoCacheEmitter(builder):
            origEmitter = builder.emitter
            if SCons.Util.is_Dict(origEmitter):
                for k,v in origEmitter:
                    origEmitter[k] = SCons.Builder.ListEmitter([v, noCacheEmitter])
            elif SCons.Util.is_List(origEmitter):
                origEmitter.append(noCacheEmitter)
            else:
                builder.emitter = SCons.Builder.ListEmitter([origEmitter, noCacheEmitter])

        addNoCacheEmitter(env['BUILDERS']['Program'])
        addNoCacheEmitter(env['BUILDERS']['StaticLibrary'])
        addNoCacheEmitter(env['BUILDERS']['SharedLibrary'])
        addNoCacheEmitter(env['BUILDERS']['LoadableModule'])


resmoke_install_dir = env.subst("$PREFIX_BINDIR") if get_option("install-mode") == "hygienic" else env.Dir("#").abspath
resmoke_install_dir = os.path.normpath(resmoke_install_dir).replace("\\", r"\\")

# Much blood sweat and tears were shed getting to this point. Any version of
# this that uses SCons builders and a scanner will either not regenerate when it
# should, cause everything to rebuild, or conflict with ninja. Sometimes all
# three. So we've decieded it's best to just write this file here every time
# because it's the only solution that always works.
with open("resmoke.ini", "w") as resmoke_config:
    resmoke_config.write("""
[resmoke]
install_dir = {install_dir}
""".format(install_dir=resmoke_install_dir))

env.SConscript(
    dirs=[
        'src',
    ],
    duplicate=False,
    exports=[
        'env',
    ],
    variant_dir='$BUILD_DIR',
)

# TODO: find a way to consolidate SConscript calls to one call in
# SConstruct so they all use variant_dir
env.SConscript(
    dirs=[
        'jstests',
    ],
    duplicate=False,
    exports=[
        'env',
    ],
)


if get_option("install-mode") != "hygienic":
    allTargets = ['core', 'tools', 'unittests', 'integration_tests', 'libfuzzer_tests', 'benchmarks']

    if not has_option('noshell') and usemozjs:
        allTargets.extend(['dbtest'])

    env.Alias('all', allTargets)

# run the Dagger tool if it's installed
if should_dagger:
    dependencyDb = env.Alias("dagger", env.Dagger('library_dependency_graph.json'))
    # Require everything to be built before trying to extract build dependency information
    env.Requires(dependencyDb, 'all')

# Declare the cache prune target
cachePrune = env.Command(
    target="#cache-prune",
    source=[
        "#buildscripts/scons_cache_prune.py",
    ],
    action="$PYTHON ${SOURCES[0]} --cache-dir=${CACHE_DIR.abspath} --cache-size=${CACHE_SIZE} --prune-ratio=${CACHE_PRUNE_TARGET/100.00}",
    CACHE_DIR=env.Dir(cacheDir),
)

env.AlwaysBuild(cachePrune)

if get_option('install-mode') == 'hygienic':
    env.FinalizeInstallDependencies()


# We don't want installing files to cause them to flow into the cache,
# since presumably we can re-install them from the origin if needed.
env.NoCache(env.FindInstalledFiles())

# Substitute environment variables in any build targets so that we can
# say, for instance:
#
# > scons --prefix=/foo/bar '$DESTDIR'
# or
# > scons \$BUILD_DIR/mongo/base
#
# That way, you can reference targets under the variant dir or install
# path via an invariant name.
#
# We need to replace the values in the BUILD_TARGETS object in-place
# because SCons wants it to be a particular object.
for i, s in enumerate(BUILD_TARGETS):
    BUILD_TARGETS[i] = env.subst(s)