CMakeLists.txt

cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
include(cmake/version.cmake)
get_version(${CMAKE_SOURCE_DIR}/prime_server/prime_server.hpp "PRIME_SERVER_")
project(prime_server LANGUAGES CXX C VERSION ${PRIME_SERVER_VERSION_MAJOR}.${PRIME_SERVER_VERSION_MINOR}.${PRIME_SERVER_VERSION_PATCH})
INCLUDE(GNUInstallDirs)

# Use a C++17 enabled compiler
set(CMAKE_CXX_STANDARD 17)

option(ENABLE_WALL "Convert compiler warnings to errors" ON)
option(ENABLE_WERROR "Convert compiler warnings to errors. Requires ENABLE_WALL" ON)
option(ENABLE_TESTS "Build the test suite (pulls in the test/testing submodule)" ON)

# What type of build
if(NOT MSVC_IDE) # TODO: May need to be extended for Xcode, CLion, etc.
  if(NOT CMAKE_BUILD_TYPE)
    message(STATUS "No build type specified, defaulting to Release")
    set(CMAKE_BUILD_TYPE Release)
  endif()
endif()
if(CMAKE_BUILD_TYPE MATCHES Debug)
  message(STATUS "Configuring in debug mode")
elseif(CMAKE_BUILD_TYPE MATCHES Release)
  message(STATUS "Configuring in release mode")
elseif(CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
  message(STATUS "Configuring in release mode with debug flags")
elseif(CMAKE_BUILD_TYPE MATCHES MinRelSize)
  message(STATUS "Configuring in release mode with minimized size")
else()
  set(CMAKE_BUILD_TYPE Release)
  message(STATUS "Unrecognized build type defaulting to release")
endif()

# Show all warnings and treat as errors
if(MSVC AND ENABLE_WALL)
  add_compile_options(/W4)
  if(ENABLE_WERROR)
  	add_compile_options(/WX)
  endif()
elseif(ENABLE_WALL)
  add_compile_options(-Wall -Wextra -pedantic)
  if(ENABLE_WERROR)
  	add_compile_options(-Werror)
  endif()
endif()

option(ENABLE_SANITIZERS "Use all the integrated sanitizers for Debug build" OFF)
option(ENABLE_ADDRESS_SANITIZER "Use memory sanitizer for Debug build" OFF)
option(ENABLE_UNDEFINED_SANITIZER "Use UB sanitizer for Debug build" OFF)
include(cmake/sanitizer.cmake)

# Handle the dependencies
find_package(CURL 7.22.0 QUIET)
if(CURL_FOUND)
  set(CURL_LDFLAGS CURL::libcurl)
else()
  find_package(PkgConfig REQUIRED)
  pkg_check_modules(CURL REQUIRED libcurl>=7.22.0)
endif()

find_package(ZeroMQ 4.1.4 QUIET)
if(ZeroMQ_FOUND)
  set(ZMQ_LDFLAGS libzmq)
  get_target_property(ZMQ_INCLUDEDIR libzmq INTERFACE_INCLUDE_DIRECTORIES)
else()
  find_package(PkgConfig REQUIRED)
  pkg_check_modules(ZMQ REQUIRED libzmq>=4.1.4)
endif()

find_package(czmq 3.0 QUIET)
if(czmq_FOUND)
  set(CZMQ_LDFLAGS czmq)
  get_target_property(CZMQ_INCLUDEDIR czmq INTERFACE_INCLUDE_DIRECTORIES)
else()
  find_package(PkgConfig REQUIRED)
  pkg_check_modules(CZMQ REQUIRED libczmq>=3.0)
endif()

include_directories(${CURL_INCLUDEDIR} ${ZMQ_INCLUDEDIR} ${CZMQ_INCLUDEDIR})

find_package(Threads REQUIRED)

# Prevent Windows.h from defining min/max macros and pulling in rarely-used headers,
# and silence MSVC's deprecation warnings for portable C functions like getenv()
if(WIN32)
  add_compile_definitions(WIN32_LEAN_AND_MEAN NOMINMAX _CRT_SECURE_NO_WARNINGS)
endif()

# Include the hpp files
include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/prime_server)

set(PRIME_LIBRARY_HEADERS
	${CMAKE_SOURCE_DIR}/prime_server/prime_server.hpp
	${CMAKE_SOURCE_DIR}/prime_server/http_util.hpp
	${CMAKE_SOURCE_DIR}/prime_server/netstring_protocol.hpp
	${CMAKE_SOURCE_DIR}/prime_server/zmq_helpers.hpp
	${CMAKE_SOURCE_DIR}/prime_server/http_protocol.hpp)

set(PRIME_LIBRARY_SOURCES
	${CMAKE_SOURCE_DIR}/src/logging/logging.hpp
	${CMAKE_SOURCE_DIR}/src/http_protocol.cpp
	${CMAKE_SOURCE_DIR}/src/http_util.cpp
	${CMAKE_SOURCE_DIR}/src/netstring_protocol.cpp
	${CMAKE_SOURCE_DIR}/src/prime_server.cpp
	${CMAKE_SOURCE_DIR}/src/zmq_helpers.cpp)

# Build the library
add_library(prime_server SHARED ${PRIME_LIBRARY_SOURCES})
# On Windows, auto-generate dllexport/dllimport decorations
set_target_properties(prime_server PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
target_link_libraries(prime_server
  PUBLIC
    ${ZMQ_LDFLAGS}
  PRIVATE
    ${CZMQ_LDFLAGS}
    ${CURL_LDFLAGS})
if(WIN32)
  target_link_libraries(prime_server PRIVATE ws2_32)
endif()

# Build executables
add_executable(prime_echod ${CMAKE_SOURCE_DIR}/src/prime_echod.cpp)
target_link_libraries(prime_echod prime_server ${CMAKE_THREAD_LIBS_INIT})

add_executable(prime_filed ${CMAKE_SOURCE_DIR}/src/prime_filed.cpp)
target_link_libraries(prime_filed prime_server ${CMAKE_THREAD_LIBS_INIT})

add_executable(prime_httpd ${CMAKE_SOURCE_DIR}/src/prime_httpd.cpp)
target_link_libraries(prime_httpd prime_server ${CMAKE_THREAD_LIBS_INIT})

add_executable(prime_serverd ${CMAKE_SOURCE_DIR}/src/prime_serverd.cpp)
target_link_libraries(prime_serverd prime_server ${CMAKE_THREAD_LIBS_INIT})

add_executable(prime_proxyd ${CMAKE_SOURCE_DIR}/src/prime_proxyd.cpp)
target_link_libraries(prime_proxyd prime_server ${CMAKE_THREAD_LIBS_INIT})

add_executable(prime_workerd ${CMAKE_SOURCE_DIR}/src/prime_workerd.cpp)
target_link_libraries(prime_workerd prime_server ${CMAKE_THREAD_LIBS_INIT})

# README example -- built by CI to catch API drift, not installed
add_executable(art ${CMAKE_SOURCE_DIR}/src/art.cpp)
target_link_libraries(art prime_server ${CMAKE_THREAD_LIBS_INIT})

# TODO(nils): AFAIU the project version shouldn't be the SO version
set_target_properties(prime_server PROPERTIES
	PUBLIC_HEADER "${PRIME_LIBRARY_HEADERS}"
	SOVERSION ${PROJECT_VERSION_MAJOR}
	VERSION ${PROJECT_VERSION})

# Install paths
set(pkgconfigdir "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
set(VERSION ${PROJECT_VERSION})

install(TARGETS prime_server
	EXPORT libprime_serverTargets
	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
	INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
	PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/prime_server)

install(EXPORT libprime_serverTargets
	FILE libprime_serverTargets.cmake
	NAMESPACE libprime_server::
	DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libprime_server)

include(CMakePackageConfigHelpers)
configure_package_config_file(
	"${CMAKE_CURRENT_SOURCE_DIR}/cmake/libprime_serverConfig.cmake.in"
	"${CMAKE_CURRENT_BINARY_DIR}/libprime_serverConfig.cmake"
	INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libprime_server)
write_basic_package_version_file(
	"${CMAKE_CURRENT_BINARY_DIR}/libprime_serverConfigVersion.cmake"
	VERSION ${PROJECT_VERSION}
	COMPATIBILITY SameMajorVersion)
install(FILES
	"${CMAKE_CURRENT_BINARY_DIR}/libprime_serverConfig.cmake"
	"${CMAKE_CURRENT_BINARY_DIR}/libprime_serverConfigVersion.cmake"
	DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libprime_server)

install(TARGETS prime_echod
	prime_filed
	prime_httpd
	prime_serverd
	prime_proxyd
	prime_workerd DESTINATION ${CMAKE_INSTALL_BINDIR})

# pkg-config stuff, also make it compatible with autotools
set(prefix ${CMAKE_INSTALL_PREFIX})
set(exec_prefix ${prefix})
set(libdir ${prefix}/${CMAKE_INSTALL_LIBDIR})
set(includedir ${prefix}/${CMAKE_INSTALL_INCLUDEDIR})

configure_file(
	${CMAKE_CURRENT_SOURCE_DIR}/libprime_server.pc.in
	${CMAKE_CURRENT_BINARY_DIR}/libprime_server.pc
	@ONLY)
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/libprime_server.pc" DESTINATION ${pkgconfigdir})

# uninstall target
configure_file(cmake/uninstall.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/prime_server_uninstall.cmake @ONLY)
add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/prime_server_uninstall.cmake)

# Add tests - Requires CTest and the test/testing submodule
if(ENABLE_TESTS)
enable_testing()

add_executable(http ${CMAKE_SOURCE_DIR}/test/http.cpp)
target_link_libraries(http prime_server ${CMAKE_THREAD_LIBS_INIT})
add_test(http http)

add_executable(interrupt ${CMAKE_SOURCE_DIR}/test/interrupt.cpp)
target_link_libraries(interrupt prime_server ${CMAKE_THREAD_LIBS_INIT})
add_test(interrupt interrupt)

add_executable(netstring ${CMAKE_SOURCE_DIR}/test/netstring.cpp)
target_link_libraries(netstring prime_server ${CMAKE_THREAD_LIBS_INIT})
add_test(netstring netstring)

add_executable(shaping ${CMAKE_SOURCE_DIR}/test/shaping.cpp)
target_link_libraries(shaping prime_server ${CMAKE_THREAD_LIBS_INIT})
add_test(shaping shaping)

add_executable(shutdown ${CMAKE_SOURCE_DIR}/test/shutdown.cpp)
target_link_libraries(shutdown prime_server ${CMAKE_THREAD_LIBS_INIT})
add_test(shutdown shutdown)

add_executable(zmq ${CMAKE_SOURCE_DIR}/test/zmq.cpp)
target_link_libraries(zmq prime_server ${CMAKE_THREAD_LIBS_INIT})
add_test(zmq zmq)
endif()