# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

include(CMakePushCheckState)

# GENERAL OPTIONS.
##################
option(VERBOSE
  "Enable verbose CMake statements and compilation output."
  TRUE)
set(CMAKE_VERBOSE_MAKEFILE ${VERBOSE})

if (NOT WIN32)
  set(DEFAULT_BUILD_SHARED_LIBS TRUE)
else ()
  set(DEFAULT_BUILD_SHARED_LIBS FALSE)
endif ()

option(BUILD_SHARED_LIBS
  "Build shared libraries."
  ${DEFAULT_BUILD_SHARED_LIBS})

option(ENABLE_INSTALL_MODULE_DEPENDENCIES
  "Install third-party bundled dependencies required for module development"
  FALSE)

option(ENABLE_PRECOMPILED_HEADERS
  "Enable auto-generated precompiled headers using cotire"
  ${WIN32})

if (NOT WIN32 AND ENABLE_PRECOMPILED_HEADERS)
  message(
    FATAL_ERROR
    "Precompiled headers are only supported on Windows.  See MESOS-7322.")
endif ()

if (ENABLE_PRECOMPILED_HEADERS)
  # By default Cotire generates both precompiled headers and a "unity" build.
  # A unity build is where all the source files in a target are combined into
  # a single source file to reduce the number of files that need to be opened
  # and read. We disable "unity" builds for now.
  set(COTIRE_ADD_UNITY_BUILD FALSE)
  set(COTIRE_VERBOSE ${VERBOSE})
endif ()

if (CMAKE_GENERATOR MATCHES "Visual Studio")
  # In MSVC 1900, there are two bugs in the linker, one that causes linking
  # libmesos to occasionally take hours, and one that causes us to be able to
  # fail to open the `mesos-x.lib` file. These have been confirmed as bugs with
  # the MSVC backend team by hausdorff.
  set(PREFERRED_TOOLSET "host=x64")
  if (NOT CMAKE_GENERATOR_TOOLSET MATCHES ${PREFERRED_TOOLSET})
    message(
      FATAL_ERROR
      "The x64 toolset MUST be used. See MESOS-6720 for details. "
      "Please use `cmake -T ${PREFERRED_TOOLSET}`.")
  endif ()
endif ()

set(
  MESOS_FINAL_PREFIX
  ${CMAKE_INSTALL_PREFIX}
  CACHE STRING
  "Adjust built-in paths (rpath in shared objects, default paths in Mesos flags
   and so on) so that cmake install output works after being copied into this prefix.
   This is typically used by package managers that use different prefixes on a build
   system and on a target system.")

# TODO(asekretenko): Consider making Mesos tests a separate project
# that would depend on Mesos installation.
option(MESOS_INSTALL_TESTS
  "Add test executables and their dependencies to the install step."
  FALSE)


# 3RDPARTY OPTIONS.
###################
option(
  REBUNDLED
  "Use dependencies from the 3rdparty folder (instead of internet)."
  TRUE)

option(
  UNBUNDLED_LIBARCHIVE
  "Build with an installed libarchive version instead of the bundled."
  FALSE)

set(
  LIBARCHIVE_ROOT_DIR
  ""
  CACHE STRING
  "Specify the path to libarchive, e.g. \"C:\\libarchive-Win64\".")

option(
  ENABLE_LIBEVENT
  "Use libevent instead of libev as the core event loop implementation."
  FALSE)

if (ENABLE_LIBEVENT)
  option(
    UNBUNDLED_LIBEVENT
    "Build libprocess with an installed libevent version instead of the bundled."
    FALSE)

  set(
    LIBEVENT_ROOT_DIR
    ""
    CACHE STRING
    "Specify the path to libevent, e.g. \"C:\\libevent-Win64\".")
endif()

set(
  BOOST_ROOT_DIR
  ""
  CACHE STRING
  "Specify the path to boost.")

if (NOT WIN32)
  set(
    CURL_ROOT_DIR
    ""
    CACHE STRING
    "Specify the path to libcurl.")
endif()

option(
  UNBUNDLED_LEVELDB
  "Build with an installed leveldb version instead of the bundled."
  FALSE)

set(
  LEVELDB_ROOT_DIR
  ""
  CACHE STRING
  "Specify the path to leveldb, e.g. \"C:\\leveldb-Win64\".")

if (ENABLE_SECCOMP_ISOLATOR)
  option(
    UNBUNDLED_LIBSECCOMP
    "Build with an installed libseccomp version instead of the bundled."
    FALSE)

  set(
    LIBSECCOMP_ROOT_DIR
    ""
    CACHE STRING
    "Specify the path to libseccomp, e.g. \"C:\\libseccomp-Win64\".")
endif ()

option(
  ENABLE_SSL
  "Build libprocess with SSL support."
  FALSE)

option(
  ENABLE_LOCK_FREE_RUN_QUEUE
  "Build libprocess with lock free run queue."
  FALSE)

option(
  ENABLE_LOCK_FREE_EVENT_QUEUE
  "Build libprocess with lock free event queue."
  FALSE)

option(
  ENABLE_LAST_IN_FIRST_OUT_FIXED_SIZE_SEMAPHORE
  "Build libprocess with LIFO fixed size semaphore."
  FALSE)

option(
  ENABLE_NVML
  "Whether to use the NVML headers."
  TRUE)

option(
  PYTHON
  "Command for the Python interpreter, set to `python` if not given."
  "python")

option(
  PYTHON_3
  "Command for the Python 3 interpreter, set to the option PYTHON if not given."
  "")

option(
  ENABLE_NEW_CLI
  "Build the new CLI instead of the old one."
  FALSE)

if (ENABLE_NEW_CLI)
  # We always want to have PYTHON_3 set as it will be used to build the CLI.
  if (NOT PYTHON_3)
    if (PYTHON)
      # Set PYTHON_3 to PYTHON if PYTHON is set but not PYTHON_3.
      set(PYTHON_3 ${PYTHON})
    else ()
      # Set PYTHON_3 to the one CMake finds if PYTHON is not set.
      # PythonInterp sets PYTHON_EXECUTABLE by looking for an interpreter
      # from newest to oldest,, we then use it to set PYTHON and PYTHON_3.
      find_package(PythonInterp)
      if (NOT PYTHONINTERP_FOUND)
        message(FATAL_ERROR "You must have Python set up in order to continue.")
      endif ()
      set(PYTHON ${PYTHON_EXECUTABLE})
      set(PYTHON_3 ${PYTHON})
    endif ()
  endif ()

  # Find `tox` for testing `src/python/lib/`.
  find_program(TOX tox)
  if (NOT TOX)
    message(FATAL_ERROR "'tox' is required in order to run Mesos Python library tests.")
  endif ()

  execute_process(
    COMMAND ${PYTHON_3} -c
      "import sys; print('%d.%d' % (sys.version_info[0], sys.version_info[1]))"
    OUTPUT_VARIABLE PYTHON_3_VERSION
    OUTPUT_STRIP_TRAILING_WHITESPACE)

  if (PYTHON_3_VERSION VERSION_LESS "3.6.0")
    message(FATAL_ERROR
    "You must be running python 3.6 or newer in order to continue.\n"
    "You appear to be running Python ${PYTHON_3_VERSION}.\n"
    "Set the CMake option 'PYTHON_3' to define which interpreter to use.")
  endif ()
endif ()

option(
  ENABLE_JAVA
  "Build Java components. Warning: this is SLOW."
  FALSE)

if (ENABLE_JAVA)
  include(FindJava)
  find_package(Java COMPONENTS Development)

  if (NOT JAVA_FOUND)
    message(FATAL_ERROR "Java was not found!")
  endif ()

  include(FindJNI)
  if (NOT JNI_FOUND)
    message(FATAL_ERROR "JNI Java libraries were not found!")
  endif ()

  find_program(MVN mvn)
  if (NOT MVN)
    message(FATAL_ERROR "Maven was not found!")
  endif ()

  if (Java_FOUND AND JNI_FOUND AND MVN)
    set(HAS_JAVA TRUE)
  endif ()
endif ()

# If 'REBUNDLED' is set to FALSE, this will cause Mesos to build against the
# specified dependency repository. This is especially useful for Windows
# builds, because building on MSVC 1900 requires newer versions of some
# dependencies than the ones bundled in the Mesos repository.
set(
  3RDPARTY_DEPENDENCIES "https://github.com/mesos/3rdparty/raw/master"
  CACHE STRING
    "URL or filesystem path with a fork of the canonical 3rdparty repository")

if (WIN32 AND REBUNDLED)
  message(
    WARNING
    "On Windows, the required versions of:\n"
    "  * curl\n"
    "  * apr\n"
    "  * zlib\n"
    "do not come rebundled in the Mesos repository.  They will be downloaded from "
    "the Internet, even though the `REBUNDLED` flag was set.")
endif ()

if (WIN32 AND ENABLE_LIBEVENT)
  message(
    WARNING
    "The Windows imlementation of libevent is BUGGY. Use it at your own risk. "
    "It does NOT support async I/O. You WILL have problems. Tests WILL fail. "
    "This is NOT supported, and WILL eventually be removed. "
    "When not explicitly enabled, the build will default to the native Windows "
    "IOCP implementation, `libwinio`, built on the Windows Thread Pool API. "
    "See MESOS-8668 for context.")
endif ()


# SYSTEM CHECKS.
################

# Set the default standard to C++11 for all targets.
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Do not use, for example, `-std=gnu++11`.
set(CMAKE_CXX_EXTENSIONS OFF)

# Check that we are targeting a 64-bit architecture.
if (NOT (CMAKE_SIZEOF_VOID_P EQUAL 8))
  message(
    FATAL_ERROR
    "Mesos requires that we compile to a 64-bit target. Following are some "
    "examples of how to accomplish this on some well-used platforms:\n"
    "  * Linux: (on gcc) set `CMAKE_CXX_FLAGS` to include `-m64`:\n"
    "    `cmake -DCMAKE_CXX_FLAGS=-m64 `.\n"
    "  * Windows: use the VS win64 CMake generator:\n"
    "    `cmake -G \"Visual Studio 15 2017 Win64\"`.\n"
    "  * OS X: add `x86_64` to the `CMAKE_OSX_ARCHITECTURES`:\n"
    "    `cmake -DCMAKE_OSX_ARCHITECTURES=x86_64`.\n")
endif ()

if (WIN32)
  # Versions of Visual Studio older than 2017 do not support all core features
  # of C++14, which prevents Mesos from moving past C++11. This adds a
  # non-fatal deprecation warning.
  set(PREFERRED_GENERATOR "Visual Studio 15 2017")
  if (NOT CMAKE_GENERATOR MATCHES ${PREFERRED_GENERATOR})
    message(
      WARNING
      "Mesos does not officially support ${CMAKE_GENERATOR}. "
      "Please use ${PREFERRED_GENERATOR}.")
  endif ()

  # We don't support compilation against mingw headers (which, e.g., Clang on
  # Windows does at this point), because this is likely to cost us more effort
  # to support than it will be worth at least in the short term.
  if (NOT CMAKE_CXX_COMPILER_ID MATCHES MSVC)
    message(
      FATAL_ERROR
      "Mesos does not support compiling on Windows with "
      "${CMAKE_CXX_COMPILER_ID}. Please use MSVC.")
  endif ()

  # MSVC 1900 supports C++11; earlier versions don't. So, warn if you try to
  # use anything else.
  if (${MSVC_VERSION} LESS 1900)
    message(
      FATAL_ERROR
      "Mesos does not support compiling on MSVC versions earlier than 1900. "
      "Please use MSVC 1900 (included with Visual Studio 2015 or later).")
  endif ()
endif ()

# GLOBAL WARNINGS.
##################
if (CMAKE_CXX_COMPILER_ID MATCHES GNU
    OR CMAKE_CXX_COMPILER_ID MATCHES Clang) # Also matches AppleClang.
  # TODO(andschwa): Add `-Wextra`, `-Wpedantic`, `-Wconversion`.
  add_compile_options(
    -Wall
    -Wsign-compare)
elseif (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
  # TODO(andschwa): Switch to `/W4` and re-enable possible-loss-of-data warnings.
  #
  # The last two warnings are disabled (well, put into `/W4`) because
  # there is no easy equivalent to enable them for GCC/Clang without
  # also fixing all the warnings from `-Wconversion`.
  add_compile_options(
    # Like `-Wall`; `/W4` is more like `-Wall -Wextra`.
    /W3
    # Disable permissiveness.
    /permissive-
    # C4244 is a possible loss of data warning for integer conversions.
    /w44244
    # C4267 is a possible loss of data warning when converting from `size_t`.
    /w44267)
endif ()

if (CMAKE_CXX_COMPILER_ID MATCHES Clang)
  add_compile_options(-Wno-inconsistent-missing-override)
endif ()

# POSIX CONFIGURATION.
######################
if (NOT WIN32)
  # Warn about use of format functions that can produce security issues.
  add_compile_options(-Wformat-security)

  # Protect many of the functions with stack guards. The exact flag
  # depends on compiler support.
  CHECK_CXX_COMPILER_FLAG(-fstack-protector-strong STRONG_STACK_PROTECTORS)
  CHECK_CXX_COMPILER_FLAG(-fstack-protector STACK_PROTECTORS)
  if (STRONG_STACK_PROTECTORS)
    add_compile_options(-fstack-protector-strong)
  elseif (STACK_PROTECTORS)
    add_compile_options(-fstack-protector)
  else ()
    message(
      WARNING
      "The compiler ${CMAKE_CXX_COMPILER} cannot apply stack protectors.")
  endif ()

  # Do not omit frame pointers in debug builds to ease debugging and profiling.
  if ((CMAKE_BUILD_TYPE MATCHES Debug) OR
      (CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
    add_compile_options(-fno-omit-frame-pointer)
  endif ()

  # Install layout definitions used in cmake install targets.
  # These are relative to ${CMAKE_INSTALL_PREFIX}.
  #
  # NOTE: Windows and POSIX configurations have to define the same variables,
  # but the layout is different!
  set(MESOS_INSTALL_LAUNCHER  libexec/mesos) # launcher executables
  set(MESOS_INSTALL_RUNTIME   bin)           # all other executables
  set(MESOS_INSTALL_LIBRARIES lib)           # static and shared libraries
  set(MESOS_INSTALL_HEADERS   include)       # headers
  set(MESOS_INSTALL_DATA      share/mesos)   # data (webui, etc.)

  # File layout definitions that are used in the sources
  # (for setting up installed tests and default values of flags).
  #
  # NOTE: If ${MESOS_FINAL_PREFIX} is set to a non-default value
  # (i.e. differs from ${CMAKE_INSTALL_PREFIX}), cmake install output
  # will only work after copying to ${MESOS_FINAL_PREFIX}.

  # - Path for data (webui, etc.).
  set(DATA_INSTALL_PREFIX  ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_DATA})

  # - Path to launcher binaries.
  set(PKG_LIBEXEC_INSTALL_DIR ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_LAUNCHER})

  # - Path to libmesos shared object.
  set(LIB_INSTALL_DIR ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_LIBRARIES})

  # - Path to modules, including test modules.
  set(PKG_MODULE_DIR ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_LIBRARIES})

  # - Path to test-helper and (in the future) test scripts.
  #   TODO(asekretenko): Either port script tests to cmake or drop them.
  set(TEST_LIB_EXEC_DIR ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_RUNTIME})

  # - Path to Mesos binaries, used in tests.
  set(S_BIN_DIR ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_RUNTIME})

  # We add an RPATH pointing to the planned shared libraries location.
  set(CMAKE_INSTALL_RPATH
    "${CMAKE_INSTALL_RPATH};${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_LIBRARIES}")
endif ()

option(ENABLE_GC_UNUSED
  "Enable garbage collection of unused program segments"
  FALSE)

if (ENABLE_GC_UNUSED)
  CMAKE_PUSH_CHECK_STATE()

  set(CMAKE_REQUIRED_FLAGS "-ffunction-sections -fdata-sections -Wl,--gc-sections")
  CHECK_CXX_COMPILER_FLAG("" GC_FUNCTION_SECTIONS)
  if (GC_FUNCTION_SECTIONS)
    add_compile_options(-ffunction-sections -fdata-sections)
    string(APPEND CMAKE_EXE_LINKER_FLAGS " -Wl,--gc-sections")
    string(APPEND CMAKE_SHARED_LINKER_FLAGS " -Wl,--gc-sections")
  else ()
    message(
      FATAL_ERROR
      "The compiler ${CMAKE_CXX_COMPILER} does not support the necessary options to "
      "enable garbage collection of unused sections.")
  endif()

  CMAKE_POP_CHECK_STATE()
endif()

# LINUX CONFIGURATION.
######################
string(COMPARE EQUAL ${CMAKE_SYSTEM_NAME} "Linux" LINUX)

if (LINUX)
  # We currenty only support using the bundled jemalloc on linux.
  # While building it and linking against is actually not a problem
  # on other platforms, to make it actually *useful* we need some
  # additional platform-specific code in the mesos binaries that re-routes
  # all existing malloc/free calls through jemalloc.
  # On linux, that is not necessary because the default malloc implementation
  # explicitly supports replacement via symbol interposition.
  option(
    ENABLE_JEMALLOC_ALLOCATOR
    "Use jemalloc as memory allocator for the master and agent binaries."
    FALSE)

  option(ENABLE_XFS_DISK_ISOLATOR
    "Whether to enable the XFS disk isolator."
    FALSE)

  if (ENABLE_XFS_DISK_ISOLATOR)
    # TODO(andschwa): Check for required headers and libraries.
    message(FATAL_ERROR
      "The XFS disk isolator is not yet supported, see MESOS-9117.")
  endif ()

  option(ENABLE_LAUNCHER_SEALING
    "Whether to enable containerizer launcher sealing via memfd."
    FALSE)

  option(ENABLE_PORT_MAPPING_ISOLATOR
    "Whether to enable the port mapping isolator."
    FALSE)

  if (ENABLE_PORT_MAPPING_ISOLATOR)
    # TODO(andschwa): Check for `libnl-3`.
    message(FATAL_ERROR
      "The port mapping isolator is not yet supported, see MESOS-8993.")
  endif ()

  option(ENABLE_NETWORK_PORTS_ISOLATOR
    "Whether to enable the network ports isolator."
    FALSE)

  if (ENABLE_NETWORK_PORTS_ISOLATOR)
    # TODO(andschwa): Check for `libnl-3`.
    message(FATAL_ERROR
      "The network ports isolator is not yet supported, see MESOS-8993.")
  endif ()

  # Enabled when either the port mapping isolator or network ports
  # isolator is enabled.
  if (ENABLE_PORT_MAPPING_ISOLATOR OR ENABLE_NETWORK_PORTS_ISOLATOR)
    set(ENABLE_LINUX_ROUTING TRUE)
  endif ()

  option(
    ENABLE_SECCOMP_ISOLATOR
    "Whether to enable `linux/seccomp` isolator."
    FALSE)
endif ()

# FREEBSD CONFIGURATION.
######################
string(COMPARE EQUAL ${CMAKE_SYSTEM_NAME} "FreeBSD" FREEBSD)

# There is a problem linking with BFD linkers when using Clang on
# FreeBSD (MESOS-8761). CMake uses the compiler to link, and the
# compiler uses `/usr/bin/ld` by default. On FreeBSD the default
# compiler is Clang but the default linker is GNU ld (BFD). Since LLD
# is available in the base system, and GOLD is available from
# `devel/binutils`, we look for a more modern linker and tell Clang to
# use that instead.
#
# TODO(dforsyth): Understand why this is failing and add a check to
# make sure we have a compatible linker (MESOS-8765), or wait until
# FreeBSD makes lld the default linker.
if (${CMAKE_SYSTEM_NAME} MATCHES FreeBSD
    AND CMAKE_CXX_COMPILER_ID MATCHES Clang)

  find_program(LD_PROGRAM
    NAMES ld.lld ld.gold)

  if (NOT LD_PROGRAM)
    message(FATAL_ERROR
      "Please set LD_PROGRAM to a working (non-BFD) linker (MESOS-8761) to \
      build on FreeBSD.")
  endif ()

  foreach (type EXE SHARED STATIC MODULE)
    string(APPEND CMAKE_${type}_LINKER_FLAGS " -fuse-ld=${LD_PROGRAM}")
  endforeach ()
endif ()

# WINDOWS CONFIGURATION.
########################
if (WIN32)
  # COFF/PE and friends are somewhat limited in the number of sections they
  # allow for an object file. We use this to avoid those problems.
  add_compile_options(/bigobj /vd2)

  # Fix Warning C4530: C++ exception handler used, but unwind semantics are not
  # enabled.
  add_compile_options(/EHsc)

  # Build against the multi-threaded version of the C runtime library (CRT).
  if (BUILD_SHARED_LIBS)
    message(WARNING "Building with shared libraries is a work-in-progress.")
    set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
  endif ()

  if (ENABLE_SSL)
    # NOTE: We don't care about using the debug version because OpenSSL includes
    # an adapter. However, we prefer OpenSSL to use the multi-threaded CRT.
    set(OPENSSL_MSVC_STATIC_RT TRUE)
  endif ()

  # Enable multi-threaded compilation for `cl.exe`.
  add_compile_options(/MP)

  # Force use of Unicode C and C++ Windows APIs.
  add_definitions(-DUNICODE -D_UNICODE)

  # Convenience flags to simplify Windows support in C++ source; used to
  # `#ifdef` out some platform-specific parts of Mesos.  We choose to define
  # a new flag rather than using an existing flag (`_WIN32`) because we want
  # to give the build system fine-grained control over what code is #ifdef'd
  # out in the future.  Using only flags defined by our build system to control
  # this logic is the clearest and most stable way of accomplishing this.
  add_definitions(-D__WINDOWS__)

  # Defines to disable warnings generated by Visual Studio when using
  # deprecated functions in CRT and the use of insecure functions in CRT.
  # TODO(dpravat): Once the entire codebase is changed to use secure CRT
  # functions, these defines should be removed.
  add_definitions(
    -D_SCL_SECURE_NO_WARNINGS
    -D_CRT_SECURE_NO_WARNINGS
    -D_CRT_NONSTDC_NO_WARNINGS)

  # Install layout definitions used in cmake install targets.
  # These are relative to ${CMAKE_INSTALL_PREFIX}.
  #
  # NOTE: Windows and POSIX configurations have to define the same variables,
  # but the layout is different!
  set(MESOS_INSTALL_RUNTIME   bin)           # all executables and DLLs
  set(MESOS_INSTALL_LAUNCHER  ${MESOS_INSTALL_RUNTIME})
  set(MESOS_INSTALL_LIBRARIES lib)           # static libraries
  set(MESOS_INSTALL_HEADERS   include)       # headers
  set(MESOS_INSTALL_DATA      share/mesos)   # data (webui, etc.)

  # File layout definitions that are used in the sources
  # (for setting up installed tests and default values of flags).
  #
  # NOTE: If ${MESOS_FINAL_PREFIX} is set to a non-default value
  # (i.e. differs from ${CMAKE_INSTALL_PREFIX}), cmake install output
  # will only work after copying to ${MESOS_FINAL_PREFIX}.

  #  - Path for data (webui, etc.)
  set(DATA_INSTALL_PREFIX  ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_DATA})

  # - Path to launcher binaries
  set(PKG_LIBEXEC_INSTALL_DIR ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_RUNTIME})

  # - Path to libmesos shared object
  set(LIB_INSTALL_DIR ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_RUNTIME})

  # - Path to modules, including test modules
  set(PKG_MODULE_DIR ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_RUNTIME})

  # - Path to test-helper and (in the future) test scripts.
  #   TODO(asekretenko): Either port script tests to Windows or drop them.
  set(TEST_LIB_EXEC_DIR ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_RUNTIME})

  # - Path to Mesos binaries, used in tests
  set(S_BIN_DIR ${MESOS_FINAL_PREFIX}/${MESOS_INSTALL_RUNTIME})
endif ()


# GLOBAL CONFIGURATION.
#######################
# Produce position independent libraries/executables so that we take
# better advantage of Address space layout randomization (ASLR).
# This helps guard against ROP and return-to-libc attacks,
# and other general exploits that rely on deterministic offsets.
set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)

# TODO(andschwa): Make these non-global.
add_definitions(
  -DPKGLIBEXECDIR="${PKG_LIBEXEC_INSTALL_DIR}"
  -DLIBDIR="${LIB_INSTALL_DIR}"
  -DVERSION="${PACKAGE_VERSION}"
  -DPKGDATADIR="${DATA_INSTALL_PREFIX}")

if (ENABLE_SSL)
  # TODO(andschwa): Make this non-global.
  add_definitions(-DUSE_SSL_SOCKET=1)
endif ()

if (ENABLE_LIBEVENT)
  add_definitions(-DUSE_LIBEVENT=1)
endif ()

# Calculate some build information.
string(TIMESTAMP BUILD_DATE "%Y-%m-%d %H:%M:%S UTC" UTC)
string(TIMESTAMP BUILD_TIME "%s" UTC)
if (WIN32)
  set(BUILD_USER $ENV{USERNAME})
else ()
  set(BUILD_USER $ENV{USER})
endif ()

# NOTE: This is not quite the same as the Autotools build, as most definitions,
# include directories, etc. are embedded as target properties within the CMake
# graph. However, this is simply a "helper" variable anyway, so providing the
# "global" compile definitions (at least, those of this directory), is close
# enough to the intent.
#
# This code sets the variable `BUILD_FLAGS_RAW` to the content of the
# directory's `COMPILE_DEFINITIONS` property. The backslashes are then escaped
# and the final string is saved into the `BUILD_FLAGS` variable.
get_directory_property(BUILD_FLAGS_RAW COMPILE_DEFINITIONS)
string(REPLACE "\"" "\\\"" BUILD_FLAGS "${BUILD_FLAGS_RAW}")

set(BUILD_JAVA_JVM_LIBRARY ${JAVA_JVM_LIBRARY})

# Emit the BUILD_DATE, BUILD_TIME and BUILD_USER definitions into a file.
# This will be updated each time `cmake` is run.
configure_file(
  "${CMAKE_SOURCE_DIR}/src/common/build_config.hpp.in"
  "${CMAKE_BINARY_DIR}/src/common/build_config.hpp"
  @ONLY)

# Create 'src/common/git_version.hpp' only if we did not do so before.
# This protects the results from getting overwritten by additional cmake
# runs outside the reach of the git repository.
if(NOT EXISTS "${CMAKE_BINARY_DIR}/src/common/git_version.hpp")
  # When building from a git clone, the definitions BUILD_GIT_SHA,
  # BUILD_GIT_BRANCH and BUILD_GIT_TAG will be emitted.
  if (IS_DIRECTORY "${CMAKE_SOURCE_DIR}/.git")
    # Optionally set BUILD_GIT_SHA.
    set(DEFINE_BUILD_GIT_SHA "")

    execute_process(
      COMMAND git rev-parse HEAD
      OUTPUT_VARIABLE BUILD_GIT_SHA
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
      ERROR_QUIET
      OUTPUT_STRIP_TRAILING_WHITESPACE)

    if (NOT BUILD_GIT_SHA STREQUAL "")
      set(DEFINE_BUILD_GIT_SHA "#define BUILD_GIT_SHA \"${BUILD_GIT_SHA}\"")
    endif()

    # Optionally set BUILD_GIT_BRANCH.
    set(DEFINE_BUILD_GIT_BRANCH "")

    execute_process(
      COMMAND git symbolic-ref HEAD
      OUTPUT_VARIABLE BUILD_GIT_BRANCH
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
      ERROR_QUIET
      OUTPUT_STRIP_TRAILING_WHITESPACE)

    if (NOT BUILD_GIT_BRANCH STREQUAL "")
      set(DEFINE_BUILD_GIT_BRANCH "#define BUILD_GIT_BRANCH \"${BUILD_GIT_BRANCH}\"")
    endif()

    # Optionally set BUILD_GIT_TAG.
    set(DEFINE_BUILD_GIT_TAG "")

    execute_process(
      COMMAND git describe --exact --tags
      OUTPUT_VARIABLE BUILD_GIT_TAG
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
      ERROR_QUIET
      OUTPUT_STRIP_TRAILING_WHITESPACE)

    if (NOT BUILD_GIT_TAG STREQUAL "")
      set(DEFINE_BUILD_GIT_TAG "#define BUILD_GIT_TAG \"${BUILD_GIT_TAG}\"")
    endif()
  endif ()

  configure_file(
    "${CMAKE_SOURCE_DIR}/src/common/git_version.hpp.in"
    "${CMAKE_BINARY_DIR}/src/common/git_version.hpp"
    @ONLY)
endif()