From d20cab69f31805bbe06375e5a8ae192e1a6d06ff Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Thu, 27 Jun 2019 17:37:33 -0400 Subject: [PATCH 01/12] Add CMake configuration file and export installed targets --- .travis.yml | 2 +- CMakeLists.txt | 65 +++++++++++++++++++----- README.md | 35 ++++++------- cmake/FindRdKafka.cmake | 66 ++++++++++++++++--------- cmake/config.cmake.in | 40 +++++++++++++++ cppkafka.h.in => cmake/cppkafka.h.in | 0 cppkafka.pc.in => cmake/cppkafka.pc.in | 4 +- examples/CMakeLists.txt | 3 +- include/CMakeLists.txt | 1 - include/cppkafka/CMakeLists.txt | 2 +- src/CMakeLists.txt | 68 ++++++++++++++++++++------ tests/CMakeLists.txt | 5 +- 12 files changed, 213 insertions(+), 78 deletions(-) create mode 100644 cmake/config.cmake.in rename cppkafka.h.in => cmake/cppkafka.h.in (100%) rename cppkafka.pc.in => cmake/cppkafka.pc.in (81%) delete mode 100644 include/CMakeLists.txt diff --git a/.travis.yml b/.travis.yml index d681984c..76549de7 100644 --- a/.travis.yml +++ b/.travis.yml @@ -37,7 +37,7 @@ script: - ./configure --prefix=./install && make libs && make install - cd .. - mkdir build && cd build - - cmake .. -DRDKAFKA_ROOT_DIR=../librdkafka/install/ -DKAFKA_TEST_INSTANCE=localhost:9092 + - cmake .. -DCPPKAFKA_CMAKE_VERBOSE=ON -DRDKAFKA_ROOT=./librdkafka/install -DKAFKA_TEST_INSTANCE=localhost:9092 - make examples - make tests - ./tests/cppkafka_tests diff --git a/CMakeLists.txt b/CMakeLists.txt index eebfa5f4..928e9661 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,12 +1,19 @@ -cmake_minimum_required(VERSION 2.8.1) -project(cppkafka) +cmake_minimum_required(VERSION 3.9.2) +project(CppKafka) + +#Allows using '_ROOT' to point to a package install dir. After CMake v3.14 this becomes default behavior. +#cmake_policy(SET CMP0074 NEW) + +include(GNUInstallDirs) +include(CMakePackageConfigHelpers) # Set the version number. set(CPPKAFKA_VERSION_MAJOR 0) set(CPPKAFKA_VERSION_MINOR 3) set(CPPKAFKA_VERSION_REVISION 1) set(CPPKAFKA_VERSION "${CPPKAFKA_VERSION_MAJOR}.${CPPKAFKA_VERSION_MINOR}.${CPPKAFKA_VERSION_REVISION}") -set(RDKAFKA_MIN_VERSION 0x00090400) +set(RDKAFKA_MIN_VERSION "0.9.4") +set(RDKAFKA_MIN_VERSION_HEX 0x00090400) if (NOT CMAKE_CXX_FLAGS) # Set default compile flags for the project @@ -23,7 +30,6 @@ if (NOT CMAKE_CXX_FLAGS) set(CMAKE_CXX_FLAGS "-std=c++11 -Wall") endif() endif() -set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/") # Set output directories set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib) @@ -38,13 +44,27 @@ option(CPPKAFKA_BOOST_STATIC_LIBS "Link with Boost static libraries." ON) option(CPPKAFKA_BOOST_USE_MULTITHREADED "Use Boost multithreaded libraries." ON) option(CPPKAFKA_RDKAFKA_STATIC_LIB "Link with Rdkafka static library." OFF) -math(EXPR BITS "8*${CMAKE_SIZEOF_VOID_P}") +# Add FindRdKafka.cmake +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/") -# Properly set the output directory -if (${BITS} EQUAL 64) - set(LIBDIR "lib64") -else() - set(LIBDIR "lib") +# Maintain previous compatibility +if (RDKAFKA_ROOT_DIR) + set(RdKafka_ROOT ${RDKAFKA_ROOT_DIR}) +elseif (RDKAFKA_ROOT) + set(RdKafka_ROOT ${RDKAFKA_ROOT}) +endif() + +if (RdKafka_ROOT) + if (NOT IS_ABSOLUTE ${RdKafka_ROOT}) + set(RdKafka_ROOT "${CMAKE_SOURCE_DIR}/${RdKafka_ROOT}") + endif() +endif() + +if (RDKAFKA_DIR) + set(RdKafka_DIR ${RDKAFKA_DIR}) # For older versions of find_package + if (NOT IS_ABSOLUTE ${RdKafka_ROOT}) + set(RdKafka_DIR "${CMAKE_SOURCE_DIR}/${RdKafka_DIR}") + endif() endif() # Disable output from find_package macro @@ -60,19 +80,23 @@ else() message(STATUS "Build will generate a static library.") set(CPPKAFKA_LIBRARY_TYPE STATIC) add_definitions("-DCPPKAFKA_STATIC=1") + set(CMAKE_POSITION_INDEPENDENT_CODE ON) endif() if (CPPKAFKA_RDKAFKA_STATIC_LIB) add_definitions("-DLIBRDKAFKA_STATICLIB") endif() +if (NOT CPPKAFKA_CONFIG_DIR) + set(CPPKAFKA_CONFIG_DIR lib/cmake/${PROJECT_NAME}) +endif() + if (NOT CPPKAFKA_PKGCONFIG_DIR) set(CPPKAFKA_PKGCONFIG_DIR share/pkgconfig) endif() # Look for Boost (just need boost.optional headers here) find_package(Boost REQUIRED ${FIND_PACKAGE_QUIET}) -find_package(RdKafka REQUIRED ${FIND_PACKAGE_QUIET}) if (Boost_FOUND) find_package(Boost COMPONENTS program_options ${FIND_PACKAGE_QUIET}) @@ -89,8 +113,25 @@ if (Boost_FOUND) endif() endif() +# Try to find the RdKafka configuration file if present. +# This will search default system locations as well as RdKafka_ROOT and RdKafka_Dir paths if specified. +find_package(RdKafka ${FIND_PACKAGE_QUIET} CONFIG) +set(RDKAFKA_TARGET_IMPORTS ${RdKafka_FOUND}) +if (NOT RdKafka_FOUND) + message(STATUS "RdKafkaConfig.cmake not found. Please set RDKAFKA_ROOT or RDKAFKA_DIR if a config file is installed. Attempting to find module instead...") + find_package(RdKafka REQUIRED ${FIND_PACKAGE_QUIET} MODULE) + if (NOT RdKafka_FOUND) + message(FATAL_ERROR "RdKafka module not found. Please set RDKAFKA_ROOT to the install path.") + else() + message(STATUS "RdKafka module found.") + endif() +else() + set(RdKafka_DEPENDENCIES RdKafka::rdkafka) + message(STATUS "RdKafka configuration file found: ${RdKafka_CONFIG}") +endif() + add_subdirectory(src) -add_subdirectory(include) +add_subdirectory(include/cppkafka) # Examples target if (NOT CPPKAFKA_DISABLE_EXAMPLES AND Boost_PROGRAM_OPTIONS_FOUND) diff --git a/README.md b/README.md index c9ae7d70..a0ebf770 100644 --- a/README.md +++ b/README.md @@ -54,10 +54,9 @@ int main() { In order to compile _cppkafka_ you need: * _librdkafka >= 0.9.4_ -* _CMake_ -* A compiler with good C++11 support (e.g. gcc >= 4.8). This was tested successfully on -_g++ 4.8.3_. -* The boost library. +* _CMake >= 3.10_ +* A compiler with good C++11 support (e.g. gcc >= 4.8). This was tested successfully on _g++ 4.8.3_. +* The boost library (for boost::optional) Now, in order to build, just run: @@ -66,12 +65,14 @@ mkdir build cd build cmake .. make +make install ``` ## CMake options The following cmake options can be specified: -* `RDKAFKA_ROOT_DIR` : Specify a different librdkafka install directory. +* `RDKAFKA_ROOT` : Specify a different librdkafka install directory. +* `RDKAFKA_DIR` : Specify a different directory where the RdKafkaConfig.cmake is installed. * `BOOST_ROOT` : Specify a different Boost install directory. * `CPPKAFKA_CMAKE_VERBOSE` : Generate verbose output. Default is `OFF`. * `CPPKAFKA_BUILD_SHARED` : Build cppkafka as a shared library. Default is `ON`. @@ -80,25 +81,12 @@ The following cmake options can be specified: * `CPPKAFKA_BOOST_STATIC_LIBS` : Link with Boost static libraries. Default is `ON`. * `CPPKAFKA_BOOST_USE_MULTITHREADED` : Use Boost multi-threaded libraries. Default is `ON`. * `CPPKAFKA_RDKAFKA_STATIC_LIB` : Link to Rdkafka static library. Default is `OFF`. +* `CPPKAFKA_CONFIG_DIR` : Install location of the cmake configuration files. Default is `lib/cmake/cppkafka`. * `CPPKAFKA_PKGCONFIG_DIR` : Install location of the .pc file. Default is `share/pkgconfig`. Example: ```Shell -cmake -DRDKAFKA_ROOT_DIR=/some/other/dir -DCPPKAFKA_BUILD_SHARED=OFF ... -``` - -The `RDKAFKA_ROOT_DIR` must contain the following structure. If the system -architecture is 64-bit and both `lib` and `lib64` folders are available, the `lib64` -folder location will be selected by cmake. - -```Shell -${RDKAFKA_ROOT_DIR}/ - | - + include/librdkafka/rdkafka.h - | - + lib/librdkafka.a - | - + lib64/librdkafka.a (optional) +cmake -DRDKAFKA_ROOT=/some/other/dir -DCPPKAFKA_BUILD_SHARED=OFF ... ``` # Using @@ -108,6 +96,13 @@ If you want to use _cppkafka_, you'll need to link your application with: * _cppkafka_ * _rdkafka_ +If using CMake, this is simplified by doing: +```cmake +find_package(CppKafka REQUIRED) + +target_link_libraries( CppKafka::cppkafka) +``` + # Documentation You can generate the documentation by running `make docs` inside the build directory. This requires diff --git a/cmake/FindRdKafka.cmake b/cmake/FindRdKafka.cmake index e1df5ed7..006c9dd2 100644 --- a/cmake/FindRdKafka.cmake +++ b/cmake/FindRdKafka.cmake @@ -1,5 +1,10 @@ -# Override default CMAKE_FIND_LIBRARY_SUFFIXES -# (Allows optional prioritization of static libraries during resolution) +# This find module helps find the RdKafka module. It exports the following variables: +# - RdKafka_INCLUDE_DIR : The directory where rdkafka.h is located. +# - RdKafka_LIBNAME : The name of the library, i.e. librdkafka.a, librdkafka.so, etc. +# - RdKafka_LIBRARY_DIR : The directory where the library is located. +# - RdKafka_LIBRARY_PATH : The full library path i.e. ${RdKafka_LIBRARY_DIR}/${RdKafka_LIBNAME} +# - RdKafka_DEPENDENCIES : Libs needed to link with RdKafka + if (CPPKAFKA_RDKAFKA_STATIC_LIB) set(RDKAFKA_PREFIX ${CMAKE_STATIC_LIBRARY_PREFIX}) set(RDKAFKA_SUFFIX ${CMAKE_STATIC_LIBRARY_SUFFIX}) @@ -8,48 +13,65 @@ else() set(RDKAFKA_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX}) endif() -find_path(RDKAFKA_ROOT_DIR - NAMES include/librdkafka/rdkafka.h -) +set(RdKafka_LIBNAME ${RDKAFKA_PREFIX}rdkafka${RDKAFKA_SUFFIX}) -find_path(RDKAFKA_INCLUDE_DIR +find_path(RdKafka_INCLUDE_DIR NAMES librdkafka/rdkafka.h - HINTS ${RDKAFKA_ROOT_DIR}/include + HINTS ${RdKafka_ROOT}/include +) + +find_path(RdKafka_LIBRARY_DIR + NAMES ${RdKafka_LIBNAME} rdkafka + HINTS ${RdKafka_ROOT}/lib ${RdKafka_ROOT}/lib64 +) + +find_library(RdKafka_LIBRARY_PATH + NAMES ${RdKafka_LIBNAME} rdkafka + HINTS ${RdKafka_LIBRARY_DIR} ) # Check lib paths if (CPPKAFKA_CMAKE_VERBOSE) get_property(FIND_LIBRARY_32 GLOBAL PROPERTY FIND_LIBRARY_USE_LIB32_PATHS) get_property(FIND_LIBRARY_64 GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS) - MESSAGE(STATUS "RDKAFKA search 32-bit library paths: ${FIND_LIBRARY_32}") - MESSAGE(STATUS "RDKAFKA search 64-bit library paths: ${FIND_LIBRARY_64}") + message(STATUS "RDKAFKA search 32-bit library paths: ${FIND_LIBRARY_32}") + message(STATUS "RDKAFKA search 64-bit library paths: ${FIND_LIBRARY_64}") + message(STATUS "RdKafka_ROOT = ${RdKafka_ROOT}") + message(STATUS "RdKafka_INCLUDE_DIR = ${RdKafka_INCLUDE_DIR}") + message(STATUS "RdKafka_LIBNAME = ${RdKafka_LIBNAME}") + message(STATUS "RdKafka_LIBRARY_PATH = ${RdKafka_LIBRARY_PATH}") + message(STATUS "RdKafka_LIBRARY_DIR = ${RdKafka_LIBRARY_DIR}") endif() -find_library(RDKAFKA_LIBRARY - NAMES ${RDKAFKA_PREFIX}rdkafka${RDKAFKA_SUFFIX} rdkafka - HINTS ${RDKAFKA_ROOT_DIR}/lib -) - include(FindPackageHandleStandardArgs) find_package_handle_standard_args(RDKAFKA DEFAULT_MSG - RDKAFKA_LIBRARY - RDKAFKA_INCLUDE_DIR + RdKafka_LIBNAME + RdKafka_LIBRARY_DIR + RdKafka_LIBRARY_PATH + RdKafka_INCLUDE_DIR ) -set(CONTENTS "#include \n #if RD_KAFKA_VERSION >= ${RDKAFKA_MIN_VERSION}\n int main() { }\n #endif") +set(CONTENTS "#include \n #if RD_KAFKA_VERSION >= ${RDKAFKA_MIN_VERSION_HEX}\n int main() { }\n #endif") set(FILE_NAME ${CMAKE_CURRENT_BINARY_DIR}/rdkafka_version_test.c) file(WRITE ${FILE_NAME} ${CONTENTS}) -try_compile(HAVE_VALID_KAFKA_VERSION ${CMAKE_CURRENT_BINARY_DIR} +try_compile(RdKafka_FOUND ${CMAKE_CURRENT_BINARY_DIR} SOURCES ${FILE_NAME} - CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${RDKAFKA_INCLUDE_DIR}") + CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${RdKafka_INCLUDE_DIR}") -if (HAVE_VALID_KAFKA_VERSION) +if (RdKafka_FOUND) + if (CPPKAFKA_RDKAFKA_STATIC_LIB) + set(RdKafka_DEPENDENCIES ${RdKafka_LIBNAME} pthread rt ssl crypto dl z) + else() + set(RdKafka_DEPENDENCIES ${RdKafka_LIBNAME} pthread) + endif() + include_directories(SYSTEM ${RdKafka_INCLUDE_DIR}) + link_directories(${RdKafka_LIBRARY_DIR}) message(STATUS "Found valid rdkafka version") mark_as_advanced( - RDKAFKA_ROOT_DIR - RDKAFKA_INCLUDE_DIR RDKAFKA_LIBRARY + RdKafka_LIBRARY_DIR + RdKafka_INCLUDE_DIR ) else() message(FATAL_ERROR "Failed to find valid rdkafka version") diff --git a/cmake/config.cmake.in b/cmake/config.cmake.in new file mode 100644 index 00000000..c0e7f959 --- /dev/null +++ b/cmake/config.cmake.in @@ -0,0 +1,40 @@ +@PACKAGE_INIT@ + +include(CMakeFindDependencyMacro) + +# Add FindRdKafka.cmake +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}") + +# Find boost optional +find_dependency(Boost REQUIRED) + +# Try to find the RdKafka configuration file if present. +# This will search default system locations as well as RdKafka_ROOT and RdKafka_Dir paths if specified. +find_dependency(RdKafka QUIET CONFIG) +set(RDKAFKA_TARGET_IMPORTS ${RdKafka_FOUND}) +if (NOT RdKafka_FOUND) + message(STATUS "RdKafkaConfig.cmake not found. Please set RDKAFKA_ROOT or RDKAFKA_DIR if a config file is installed. Attempting to find module instead...") + find_dependency(RdKafka REQUIRED QUIET MODULE) + if (NOT RdKafka_FOUND) + message(FATAL_ERROR "RdKafka module not found. Please set RDKAFKA_ROOT to the install path.") + else() + message(STATUS "RdKafka module found.") + endif() +else() + set(RdKafka_DEPENDENCIES RdKafka::rdkafka) + message(STATUS "RdKafka configuration file found: ${RdKafka_CONFIG}") +endif() + +include("${CMAKE_CURRENT_LIST_DIR}/@TARGET_EXPORT_NAME@.cmake") + +# Export 'CppKafka_ROOT' +set_and_check(@PROJECT_NAME@_ROOT "@PACKAGE_CMAKE_INSTALL_PREFIX@") + +# Export 'CppKafka_INSTALL_INCLUDE_DIR' +set_and_check(@PROJECT_NAME@_INSTALL_INCLUDE_DIR "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@") + +# Export 'CppKafka_INSTALL_LIB_DIR' +set_and_check(@PROJECT_NAME@_INSTALL_LIB_DIR "@PACKAGE_CMAKE_INSTALL_LIBDIR@") + +# Validate installed components +check_required_components("@PROJECT_NAME@") diff --git a/cppkafka.h.in b/cmake/cppkafka.h.in similarity index 100% rename from cppkafka.h.in rename to cmake/cppkafka.h.in diff --git a/cppkafka.pc.in b/cmake/cppkafka.pc.in similarity index 81% rename from cppkafka.pc.in rename to cmake/cppkafka.pc.in index 7d573257..0ba0ac4d 100644 --- a/cppkafka.pc.in +++ b/cmake/cppkafka.pc.in @@ -1,7 +1,7 @@ prefix=@CMAKE_INSTALL_PREFIX@ exec_prefix=${prefix} -libdir=${prefix}/@LIBDIR@ -sharedlibdir=${prefix}/@LIBDIR@ +libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ +sharedlibdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ includedir=${prefix}/include Name: cppkafka diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index 7622061b..f8c3842b 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -1,11 +1,10 @@ -link_libraries(cppkafka ${RDKAFKA_LIBRARY} ${Boost_LIBRARIES} pthread rt ssl crypto dl z) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include) -include_directories(SYSTEM ${RDKAFKA_INCLUDE_DIR}) add_custom_target(examples) macro(create_example example_name) string(REPLACE "_" "-" sanitized_name ${example_name}) add_executable(${sanitized_name} EXCLUDE_FROM_ALL "${example_name}_example.cpp") + target_link_libraries(${sanitized_name} cppkafka ${RdKafka_DEPENDENCIES} Boost::boost Boost::program_options) add_dependencies(examples ${sanitized_name}) endmacro() diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt deleted file mode 100644 index 08a7e388..00000000 --- a/include/CMakeLists.txt +++ /dev/null @@ -1 +0,0 @@ -add_subdirectory(cppkafka) diff --git a/include/cppkafka/CMakeLists.txt b/include/cppkafka/CMakeLists.txt index 18bd1bd5..0a0518f8 100644 --- a/include/cppkafka/CMakeLists.txt +++ b/include/cppkafka/CMakeLists.txt @@ -10,7 +10,7 @@ function(make_cppkafka_header) endforeach() #create file from template - configure_file(${PROJECT_SOURCE_DIR}/cppkafka.h.in ${CPPKAFKA_HEADER} @ONLY) + configure_file(${PROJECT_SOURCE_DIR}/cmake/cppkafka.h.in ${CPPKAFKA_HEADER} @ONLY) endfunction() # Run file generation function diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index d5d50fe9..06b7b3fe 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -26,34 +26,72 @@ set(SOURCES utils/roundrobin_poll_strategy.cpp ) -include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include/cppkafka) -include_directories(SYSTEM ${Boost_INCLUDE_DIRS} ${RDKAFKA_INCLUDE_DIR}) +set(TARGET_NAME cppkafka) +set(PKG_DIR "${PROJECT_SOURCE_DIR}/package") +set(PKG_CONFIG_FILE "${PKG_DIR}/${TARGET_NAME}.pc") +set(CONFIG_FILE "${PKG_DIR}/${PROJECT_NAME}Config.cmake") +set(VERSION_FILE "${PKG_DIR}/${PROJECT_NAME}ConfigVersion.cmake") +set(FIND_RDKAFKA_FILE "${PROJECT_SOURCE_DIR}/cmake/FindRdKafka.cmake") +set(NAMESPACE "${PROJECT_NAME}::") +set(TARGET_EXPORT_NAME ${PROJECT_NAME}Targets) -add_library(cppkafka ${CPPKAFKA_LIBRARY_TYPE} ${SOURCES}) -set_target_properties(cppkafka PROPERTIES VERSION ${CPPKAFKA_VERSION} - SOVERSION ${CPPKAFKA_VERSION}) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include/cppkafka) +include_directories(SYSTEM ${Boost_INCLUDE_DIRS}) -set(DEPENDENCIES ${RDKAFKA_LIBRARY}) +add_library(${TARGET_NAME} ${CPPKAFKA_LIBRARY_TYPE} ${SOURCES}) +set_target_properties(${TARGET_NAME} PROPERTIES VERSION ${CPPKAFKA_VERSION} + SOVERSION ${CPPKAFKA_VERSION}) +# In CMake >= 3.15 Boost::boost == Boost::headers +set(DEPENDENCIES ${RdKafka_DEPENDENCIES}) if (WIN32) # On windows ntohs and related are in ws2_32 set(DEPENDENCIES ${DEPENDENCIES} ws2_32.lib) endif() -target_link_libraries(cppkafka ${DEPENDENCIES}) -target_include_directories(cppkafka PUBLIC ${PROJECT_SOURCE_DIR}/include) +target_link_libraries(${TARGET_NAME} PRIVATE ${DEPENDENCIES}) +# Install cppkafka target and specify all properties needed for the exported file install( - TARGETS cppkafka - LIBRARY DESTINATION ${LIBDIR} - ARCHIVE DESTINATION ${LIBDIR} + TARGETS ${TARGET_NAME} + EXPORT ${TARGET_EXPORT_NAME} + LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" + RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" + INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" COMPONENT dev ) -# Generate package configuration file -set(PKG_CONFIG ${PROJECT_SOURCE_DIR}/package/cppkafka.pc) -configure_file(${PROJECT_SOURCE_DIR}/cppkafka.pc.in ${PKG_CONFIG} @ONLY) +# Install the exported file +install( + EXPORT "${TARGET_EXPORT_NAME}" + NAMESPACE "${NAMESPACE}" + DESTINATION "${CPPKAFKA_CONFIG_DIR}" +) + +# Generate and install pkgconfig file +configure_file(${PROJECT_SOURCE_DIR}/cmake/cppkafka.pc.in ${PKG_CONFIG_FILE} @ONLY) install( FILES ${PKG_CONFIG} - DESTINATION ${CPPKAFKA_PKGCONFIG_DIR} + DESTINATION "${CPPKAFKA_PKGCONFIG_DIR}" COMPONENT pkgconfig ) + +# Generate CMAKE configuration file and exported targets +configure_package_config_file( + "${PROJECT_SOURCE_DIR}/cmake/config.cmake.in" + "${CONFIG_FILE}" + INSTALL_DESTINATION "${CPPKAFKA_CONFIG_DIR}" + PATH_VARS CMAKE_INSTALL_PREFIX CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR +) + +# Generate version file +write_basic_package_version_file( + "${VERSION_FILE}" + VERSION ${CPPKAFKA_VERSION} + COMPATIBILITY AnyNewerVersion +) + +install( + FILES "${CONFIG_FILE}" "${VERSION_FILE}" "${FIND_RDKAFKA_FILE}" + DESTINATION "${CPPKAFKA_CONFIG_DIR}" +) diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 95750d91..3fdb8e00 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,6 +1,5 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include/) include_directories(SYSTEM ${CATCH_INCLUDE}) -include_directories(SYSTEM ${RDKAFKA_INCLUDE_DIR}) set(KAFKA_TEST_INSTANCE "kafka-vm:9092" CACHE STRING "The kafka instance to which to connect to run tests") @@ -24,6 +23,8 @@ add_executable(cppkafka_tests # Main file test_main.cpp ) -target_link_libraries(cppkafka_tests cppkafka ${RDKAFKA_LIBRARY} pthread rt ssl crypto dl z) + +# In CMake >= 3.15 Boost::boost == Boost::headers +target_link_libraries(cppkafka_tests cppkafka ${RdKafka_DEPENDENCIES} Boost::boost Boost::program_options ) add_dependencies(tests cppkafka_tests) add_test(cppkafka cppkafka_tests) From 40e8559158f4adbdb5b591bc89a6ab977dce3aaa Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Sat, 29 Jun 2019 12:38:13 -0400 Subject: [PATCH 02/12] Remove warning for cmake policy CMP0074 --- CMakeLists.txt | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 928e9661..b7fdadc4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,8 +1,9 @@ cmake_minimum_required(VERSION 3.9.2) project(CppKafka) - -#Allows using '_ROOT' to point to a package install dir. After CMake v3.14 this becomes default behavior. -#cmake_policy(SET CMP0074 NEW) +if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.12.0") + # Use _ROOT variable to find configuration files + cmake_policy(SET CMP0074 NEW) +endif() include(GNUInstallDirs) include(CMakePackageConfigHelpers) @@ -47,6 +48,10 @@ option(CPPKAFKA_RDKAFKA_STATIC_LIB "Link with Rdkafka static library." OFF) # Add FindRdKafka.cmake set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/") +if (NOT CPPKAFKA_CONFIG_DIR) + set(CPPKAFKA_CONFIG_DIR lib/cmake/${PROJECT_NAME}) +endif() + # Maintain previous compatibility if (RDKAFKA_ROOT_DIR) set(RdKafka_ROOT ${RDKAFKA_ROOT_DIR}) From c4b6a9543805c61cdb68996e2fc8dbae23d14e1e Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Sun, 30 Jun 2019 19:24:27 -0400 Subject: [PATCH 03/12] Fixes per code review --- CMakeLists.txt | 5 ++--- README.md | 2 +- cmake/FindRdKafka.cmake | 18 ++++++++++-------- cmake/config.cmake.in | 5 ++--- examples/CMakeLists.txt | 2 +- src/CMakeLists.txt | 7 +++---- tests/CMakeLists.txt | 2 +- 7 files changed, 20 insertions(+), 21 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b7fdadc4..45077bdc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -123,15 +123,14 @@ endif() find_package(RdKafka ${FIND_PACKAGE_QUIET} CONFIG) set(RDKAFKA_TARGET_IMPORTS ${RdKafka_FOUND}) if (NOT RdKafka_FOUND) - message(STATUS "RdKafkaConfig.cmake not found. Please set RDKAFKA_ROOT or RDKAFKA_DIR if a config file is installed. Attempting to find module instead...") + message(STATUS "RdKafkaConfig.cmake not found. Attempting to find module instead...") find_package(RdKafka REQUIRED ${FIND_PACKAGE_QUIET} MODULE) if (NOT RdKafka_FOUND) - message(FATAL_ERROR "RdKafka module not found. Please set RDKAFKA_ROOT to the install path.") + message(FATAL_ERROR "RdKafka module not found. Please set RDKAFKA_ROOT to the install path or RDKAFKA_DIR pointing to the RdKafka configuration file location.") else() message(STATUS "RdKafka module found.") endif() else() - set(RdKafka_DEPENDENCIES RdKafka::rdkafka) message(STATUS "RdKafka configuration file found: ${RdKafka_CONFIG}") endif() diff --git a/README.md b/README.md index a0ebf770..d0243c80 100644 --- a/README.md +++ b/README.md @@ -54,7 +54,7 @@ int main() { In order to compile _cppkafka_ you need: * _librdkafka >= 0.9.4_ -* _CMake >= 3.10_ +* _CMake >= 3.9.2_ * A compiler with good C++11 support (e.g. gcc >= 4.8). This was tested successfully on _g++ 4.8.3_. * The boost library (for boost::optional) diff --git a/cmake/FindRdKafka.cmake b/cmake/FindRdKafka.cmake index 006c9dd2..02d3abf9 100644 --- a/cmake/FindRdKafka.cmake +++ b/cmake/FindRdKafka.cmake @@ -3,14 +3,16 @@ # - RdKafka_LIBNAME : The name of the library, i.e. librdkafka.a, librdkafka.so, etc. # - RdKafka_LIBRARY_DIR : The directory where the library is located. # - RdKafka_LIBRARY_PATH : The full library path i.e. ${RdKafka_LIBRARY_DIR}/${RdKafka_LIBNAME} -# - RdKafka_DEPENDENCIES : Libs needed to link with RdKafka +# - RdKafka::rdkafka : Imported library containing all above properties set. if (CPPKAFKA_RDKAFKA_STATIC_LIB) set(RDKAFKA_PREFIX ${CMAKE_STATIC_LIBRARY_PREFIX}) set(RDKAFKA_SUFFIX ${CMAKE_STATIC_LIBRARY_SUFFIX}) + set(RDKAFKA_LIBRARY_TYPE STATIC) else() set(RDKAFKA_PREFIX ${CMAKE_SHARED_LIBRARY_PREFIX}) set(RDKAFKA_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX}) + set(RDKAFKA_LIBRARY_TYPE SHARED) endif() set(RdKafka_LIBNAME ${RDKAFKA_PREFIX}rdkafka${RDKAFKA_SUFFIX}) @@ -60,13 +62,13 @@ try_compile(RdKafka_FOUND ${CMAKE_CURRENT_BINARY_DIR} CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${RdKafka_INCLUDE_DIR}") if (RdKafka_FOUND) - if (CPPKAFKA_RDKAFKA_STATIC_LIB) - set(RdKafka_DEPENDENCIES ${RdKafka_LIBNAME} pthread rt ssl crypto dl z) - else() - set(RdKafka_DEPENDENCIES ${RdKafka_LIBNAME} pthread) - endif() - include_directories(SYSTEM ${RdKafka_INCLUDE_DIR}) - link_directories(${RdKafka_LIBRARY_DIR}) + add_library(RdKafka::rdkafka ${RDKAFKA_LIBRARY_TYPE} IMPORTED GLOBAL) + set(RDKAFKA_DEPENDENCIES pthread rt ssl crypto dl z) + set_target_properties(RdKafka::rdkafka PROPERTIES + IMPORTED_NAME RdKafka + IMPORTED_LOCATION "${RdKafka_LIBRARY_PATH}" + INTERFACE_INCLUDE_DIRECTORIES "${RdKafka_INCLUDE_DIR}" + INTERFACE_LINK_LIBRARIES "${RDKAFKA_DEPENDENCIES}") message(STATUS "Found valid rdkafka version") mark_as_advanced( RDKAFKA_LIBRARY diff --git a/cmake/config.cmake.in b/cmake/config.cmake.in index c0e7f959..0505c35b 100644 --- a/cmake/config.cmake.in +++ b/cmake/config.cmake.in @@ -13,15 +13,14 @@ find_dependency(Boost REQUIRED) find_dependency(RdKafka QUIET CONFIG) set(RDKAFKA_TARGET_IMPORTS ${RdKafka_FOUND}) if (NOT RdKafka_FOUND) - message(STATUS "RdKafkaConfig.cmake not found. Please set RDKAFKA_ROOT or RDKAFKA_DIR if a config file is installed. Attempting to find module instead...") + message(STATUS "RdKafkaConfig.cmake not found. Attempting to find module instead...") find_dependency(RdKafka REQUIRED QUIET MODULE) if (NOT RdKafka_FOUND) - message(FATAL_ERROR "RdKafka module not found. Please set RDKAFKA_ROOT to the install path.") + message(FATAL_ERROR "RdKafka module not found. Please set RDKAFKA_ROOT to the install path or RDKAFKA_DIR pointing to the RdKafka configuration file location.") else() message(STATUS "RdKafka module found.") endif() else() - set(RdKafka_DEPENDENCIES RdKafka::rdkafka) message(STATUS "RdKafka configuration file found: ${RdKafka_CONFIG}") endif() diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index f8c3842b..547f1df4 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -4,7 +4,7 @@ add_custom_target(examples) macro(create_example example_name) string(REPLACE "_" "-" sanitized_name ${example_name}) add_executable(${sanitized_name} EXCLUDE_FROM_ALL "${example_name}_example.cpp") - target_link_libraries(${sanitized_name} cppkafka ${RdKafka_DEPENDENCIES} Boost::boost Boost::program_options) + target_link_libraries(${sanitized_name} cppkafka RdKafka::rdkafka Boost::boost Boost::program_options) add_dependencies(examples ${sanitized_name}) endmacro() diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 06b7b3fe..ad48c8d0 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -27,7 +27,7 @@ set(SOURCES ) set(TARGET_NAME cppkafka) -set(PKG_DIR "${PROJECT_SOURCE_DIR}/package") +set(PKG_DIR "${CMAKE_BINARY_DIR}/package") set(PKG_CONFIG_FILE "${PKG_DIR}/${TARGET_NAME}.pc") set(CONFIG_FILE "${PKG_DIR}/${PROJECT_NAME}Config.cmake") set(VERSION_FILE "${PKG_DIR}/${PROJECT_NAME}ConfigVersion.cmake") @@ -42,12 +42,11 @@ add_library(${TARGET_NAME} ${CPPKAFKA_LIBRARY_TYPE} ${SOURCES}) set_target_properties(${TARGET_NAME} PROPERTIES VERSION ${CPPKAFKA_VERSION} SOVERSION ${CPPKAFKA_VERSION}) # In CMake >= 3.15 Boost::boost == Boost::headers -set(DEPENDENCIES ${RdKafka_DEPENDENCIES}) +target_link_libraries(${TARGET_NAME} PRIVATE RdKafka::rdkafka Boost::boost) if (WIN32) # On windows ntohs and related are in ws2_32 - set(DEPENDENCIES ${DEPENDENCIES} ws2_32.lib) + target_link_libraries(${TARGET_NAME} PRIVATE ws2_32.lib) endif() -target_link_libraries(${TARGET_NAME} PRIVATE ${DEPENDENCIES}) # Install cppkafka target and specify all properties needed for the exported file install( diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 3fdb8e00..fd3b424f 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -25,6 +25,6 @@ add_executable(cppkafka_tests ) # In CMake >= 3.15 Boost::boost == Boost::headers -target_link_libraries(cppkafka_tests cppkafka ${RdKafka_DEPENDENCIES} Boost::boost Boost::program_options ) +target_link_libraries(cppkafka_tests cppkafka RdKafka::rdkafka Boost::boost Boost::program_options ) add_dependencies(tests cppkafka_tests) add_test(cppkafka cppkafka_tests) From 11a6e4213bd4317e3f816850958c2c10aef113f7 Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Sun, 30 Jun 2019 19:37:42 -0400 Subject: [PATCH 04/12] Remove comment from config file relating to not finding the RdKafka config file. --- cmake/config.cmake.in | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/cmake/config.cmake.in b/cmake/config.cmake.in index 0505c35b..af412ace 100644 --- a/cmake/config.cmake.in +++ b/cmake/config.cmake.in @@ -13,15 +13,7 @@ find_dependency(Boost REQUIRED) find_dependency(RdKafka QUIET CONFIG) set(RDKAFKA_TARGET_IMPORTS ${RdKafka_FOUND}) if (NOT RdKafka_FOUND) - message(STATUS "RdKafkaConfig.cmake not found. Attempting to find module instead...") - find_dependency(RdKafka REQUIRED QUIET MODULE) - if (NOT RdKafka_FOUND) - message(FATAL_ERROR "RdKafka module not found. Please set RDKAFKA_ROOT to the install path or RDKAFKA_DIR pointing to the RdKafka configuration file location.") - else() - message(STATUS "RdKafka module found.") - endif() -else() - message(STATUS "RdKafka configuration file found: ${RdKafka_CONFIG}") + find_dependency(RdKafka REQUIRED MODULE) endif() include("${CMAKE_CURRENT_LIST_DIR}/@TARGET_EXPORT_NAME@.cmake") From 0d2356f7dddecd766f0bf57535336a97e94af022 Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Mon, 1 Jul 2019 11:52:38 -0400 Subject: [PATCH 05/12] Changed link libraries to PUBLIC so they get exported in the CppKafkaTargets.cmake --- src/CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index ad48c8d0..72b37a4d 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -42,10 +42,10 @@ add_library(${TARGET_NAME} ${CPPKAFKA_LIBRARY_TYPE} ${SOURCES}) set_target_properties(${TARGET_NAME} PROPERTIES VERSION ${CPPKAFKA_VERSION} SOVERSION ${CPPKAFKA_VERSION}) # In CMake >= 3.15 Boost::boost == Boost::headers -target_link_libraries(${TARGET_NAME} PRIVATE RdKafka::rdkafka Boost::boost) +target_link_libraries(${TARGET_NAME} PUBLIC RdKafka::rdkafka Boost::boost) if (WIN32) # On windows ntohs and related are in ws2_32 - target_link_libraries(${TARGET_NAME} PRIVATE ws2_32.lib) + target_link_libraries(${TARGET_NAME} PUBLIC ws2_32.lib) endif() # Install cppkafka target and specify all properties needed for the exported file From ee30fabc2a8cc9e54f2dcbb13922ca79e1f077fd Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Mon, 1 Jul 2019 14:57:19 -0400 Subject: [PATCH 06/12] Added INTERFACE_LINK_DIRECTORIES to the RdKafka::rdkafka properties --- cmake/FindRdKafka.cmake | 1 + 1 file changed, 1 insertion(+) diff --git a/cmake/FindRdKafka.cmake b/cmake/FindRdKafka.cmake index 02d3abf9..0c0bdc81 100644 --- a/cmake/FindRdKafka.cmake +++ b/cmake/FindRdKafka.cmake @@ -68,6 +68,7 @@ if (RdKafka_FOUND) IMPORTED_NAME RdKafka IMPORTED_LOCATION "${RdKafka_LIBRARY_PATH}" INTERFACE_INCLUDE_DIRECTORIES "${RdKafka_INCLUDE_DIR}" + INTERFACE_LINK_DIRECTORIES "${RdKafka_LIBRARY_DIR}" INTERFACE_LINK_LIBRARIES "${RDKAFKA_DEPENDENCIES}") message(STATUS "Found valid rdkafka version") mark_as_advanced( From 591e8abe4fcfe7f1820f8968bcd5cce25f49a5f7 Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Mon, 1 Jul 2019 15:25:05 -0400 Subject: [PATCH 07/12] Changed include_directories to taget_include_directories and removed Boost path since it's automatically pulled in via Boost::headers --- src/CMakeLists.txt | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 72b37a4d..77b892a3 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -35,10 +35,8 @@ set(FIND_RDKAFKA_FILE "${PROJECT_SOURCE_DIR}/cmake/FindRdKafka.cmake") set(NAMESPACE "${PROJECT_NAME}::") set(TARGET_EXPORT_NAME ${PROJECT_NAME}Targets) -include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include/cppkafka) -include_directories(SYSTEM ${Boost_INCLUDE_DIRS}) - add_library(${TARGET_NAME} ${CPPKAFKA_LIBRARY_TYPE} ${SOURCES}) +target_include_directories(${TARGET_NAME} PUBLIC $) set_target_properties(${TARGET_NAME} PROPERTIES VERSION ${CPPKAFKA_VERSION} SOVERSION ${CPPKAFKA_VERSION}) # In CMake >= 3.15 Boost::boost == Boost::headers From 097184c648a7c610c24c9e3164ce6fc307b72e4e Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Mon, 1 Jul 2019 17:58:38 -0400 Subject: [PATCH 08/12] Added COMPONENT tags to the install targets. Also when installing TARGETS, the COMPONENT cannot appear after INCLUDES DESTINATION as it will be considered part of the destination. --- src/CMakeLists.txt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 77b892a3..71d64e7d 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -50,17 +50,18 @@ endif() install( TARGETS ${TARGET_NAME} EXPORT ${TARGET_EXPORT_NAME} + COMPONENT binaries LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" - COMPONENT dev ) # Install the exported file install( EXPORT "${TARGET_EXPORT_NAME}" NAMESPACE "${NAMESPACE}" + COMPONENT config DESTINATION "${CPPKAFKA_CONFIG_DIR}" ) @@ -91,4 +92,5 @@ write_basic_package_version_file( install( FILES "${CONFIG_FILE}" "${VERSION_FILE}" "${FIND_RDKAFKA_FILE}" DESTINATION "${CPPKAFKA_CONFIG_DIR}" + COMPONENT config ) From 4bddb2241c70517dddd2dde2fa93fc8e4b97adec Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Tue, 2 Jul 2019 14:52:21 -0400 Subject: [PATCH 09/12] Added INSTALL_RPATH and INSTALL_RPATH_USE_LINK_PATH to CppKafka target to allow discoverability of the RdKafka.so w/o having to update LD_LIBRARY_PATH --- src/CMakeLists.txt | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 71d64e7d..23f2bcaf 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -37,8 +37,15 @@ set(TARGET_EXPORT_NAME ${PROJECT_NAME}Targets) add_library(${TARGET_NAME} ${CPPKAFKA_LIBRARY_TYPE} ${SOURCES}) target_include_directories(${TARGET_NAME} PUBLIC $) -set_target_properties(${TARGET_NAME} PROPERTIES VERSION ${CPPKAFKA_VERSION} - SOVERSION ${CPPKAFKA_VERSION}) +set_target_properties(${TARGET_NAME} PROPERTIES + ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_INSTALL_LIBDIR}" + ARCHIVE_OUTPUT_NAME "${TARGET_NAME}" + LIBRARY_OUTPUT_DIRECTORY "${CMAKE_INSTALL_LIBDIR}" + LIBRARY_OUTPUT_NAME "${TARGET_NAME}" + INSTALL_RPATH "${CMAKE_INSTALL_LIBDIR}" + INSTALL_RPATH_USE_LINK_PATH TRUE + VERSION ${CPPKAFKA_VERSION} + SOVERSION ${CPPKAFKA_VERSION}) # In CMake >= 3.15 Boost::boost == Boost::headers target_link_libraries(${TARGET_NAME} PUBLIC RdKafka::rdkafka Boost::boost) if (WIN32) From ad800a57650e0ed0fd97dd6291bc712a9036e32a Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Tue, 2 Jul 2019 15:30:33 -0400 Subject: [PATCH 10/12] Added RdKafka hex version so that FindRdKafka.cmake can compile the test code. Changed find_dependency to find_package for the RdKafka config so that the script is not automatically exited on failure --- cmake/FindRdKafka.cmake | 2 +- cmake/config.cmake.in | 4 +++- src/CMakeLists.txt | 2 +- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/cmake/FindRdKafka.cmake b/cmake/FindRdKafka.cmake index 0c0bdc81..a7f30680 100644 --- a/cmake/FindRdKafka.cmake +++ b/cmake/FindRdKafka.cmake @@ -54,7 +54,7 @@ find_package_handle_standard_args(RDKAFKA DEFAULT_MSG ) set(CONTENTS "#include \n #if RD_KAFKA_VERSION >= ${RDKAFKA_MIN_VERSION_HEX}\n int main() { }\n #endif") -set(FILE_NAME ${CMAKE_CURRENT_BINARY_DIR}/rdkafka_version_test.c) +set(FILE_NAME ${CMAKE_CURRENT_BINARY_DIR}/rdkafka_version_test.cpp) file(WRITE ${FILE_NAME} ${CONTENTS}) try_compile(RdKafka_FOUND ${CMAKE_CURRENT_BINARY_DIR} diff --git a/cmake/config.cmake.in b/cmake/config.cmake.in index af412ace..89a4e4dd 100644 --- a/cmake/config.cmake.in +++ b/cmake/config.cmake.in @@ -5,12 +5,14 @@ include(CMakeFindDependencyMacro) # Add FindRdKafka.cmake set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}") +set(RDKAFKA_MIN_VERSION_HEX "@RDKAFKA_MIN_VERSION_HEX@") + # Find boost optional find_dependency(Boost REQUIRED) # Try to find the RdKafka configuration file if present. # This will search default system locations as well as RdKafka_ROOT and RdKafka_Dir paths if specified. -find_dependency(RdKafka QUIET CONFIG) +find_package(RdKafka QUIET CONFIG) set(RDKAFKA_TARGET_IMPORTS ${RdKafka_FOUND}) if (NOT RdKafka_FOUND) find_dependency(RdKafka REQUIRED MODULE) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 23f2bcaf..c49b600e 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -86,7 +86,7 @@ configure_package_config_file( "${PROJECT_SOURCE_DIR}/cmake/config.cmake.in" "${CONFIG_FILE}" INSTALL_DESTINATION "${CPPKAFKA_CONFIG_DIR}" - PATH_VARS CMAKE_INSTALL_PREFIX CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR + PATH_VARS RDKAFKA_MIN_VERSION_HEX CMAKE_INSTALL_PREFIX CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR ) # Generate version file From 20b806037bb4f566861070c80890f273aba58a50 Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Wed, 3 Jul 2019 18:01:28 -0400 Subject: [PATCH 11/12] Added options to conditionally disable installation of configuration files --- CMakeLists.txt | 2 ++ README.md | 2 ++ cmake/config.cmake.in | 2 +- src/CMakeLists.txt | 68 +++++++++++++++++++++++-------------------- 4 files changed, 41 insertions(+), 33 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 45077bdc..3caed5b1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -44,6 +44,8 @@ option(CPPKAFKA_DISABLE_EXAMPLES "Disable build of cppkafka examples." OFF) option(CPPKAFKA_BOOST_STATIC_LIBS "Link with Boost static libraries." ON) option(CPPKAFKA_BOOST_USE_MULTITHREADED "Use Boost multithreaded libraries." ON) option(CPPKAFKA_RDKAFKA_STATIC_LIB "Link with Rdkafka static library." OFF) +option(CPPKAFKA_EXPORT_PKGCONFIG "Generate 'cppkafka.pc' file" ON) +option(CPPKAFKA_EXPORT_CMAKE_CONFIG "Generate CMake config, target and version files." ON) # Add FindRdKafka.cmake set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/") diff --git a/README.md b/README.md index d0243c80..5301930c 100644 --- a/README.md +++ b/README.md @@ -83,6 +83,8 @@ The following cmake options can be specified: * `CPPKAFKA_RDKAFKA_STATIC_LIB` : Link to Rdkafka static library. Default is `OFF`. * `CPPKAFKA_CONFIG_DIR` : Install location of the cmake configuration files. Default is `lib/cmake/cppkafka`. * `CPPKAFKA_PKGCONFIG_DIR` : Install location of the .pc file. Default is `share/pkgconfig`. +* `CPPKAFKA_EXPORT_PKGCONFIG` : Generate `cppkafka.pc` file. Default is `ON`. +* `CPPKAFKA_EXPORT_CMAKE_CONFIG` : Generate CMake config, target and version files. Default is `ON`. Example: ```Shell diff --git a/cmake/config.cmake.in b/cmake/config.cmake.in index 89a4e4dd..32f43981 100644 --- a/cmake/config.cmake.in +++ b/cmake/config.cmake.in @@ -11,7 +11,7 @@ set(RDKAFKA_MIN_VERSION_HEX "@RDKAFKA_MIN_VERSION_HEX@") find_dependency(Boost REQUIRED) # Try to find the RdKafka configuration file if present. -# This will search default system locations as well as RdKafka_ROOT and RdKafka_Dir paths if specified. +# This will search default system locations as well as RdKafka_ROOT and RdKafka_DIR paths if specified. find_package(RdKafka QUIET CONFIG) set(RDKAFKA_TARGET_IMPORTS ${RdKafka_FOUND}) if (NOT RdKafka_FOUND) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index c49b600e..4c23cfc6 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -64,40 +64,44 @@ install( INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" ) -# Install the exported file -install( - EXPORT "${TARGET_EXPORT_NAME}" - NAMESPACE "${NAMESPACE}" - COMPONENT config - DESTINATION "${CPPKAFKA_CONFIG_DIR}" -) +if (CPPKAFKA_EXPORT_PKGCONFIG) + # Generate and install pkgconfig file + configure_file(${PROJECT_SOURCE_DIR}/cmake/cppkafka.pc.in ${PKG_CONFIG_FILE} @ONLY) -# Generate and install pkgconfig file -configure_file(${PROJECT_SOURCE_DIR}/cmake/cppkafka.pc.in ${PKG_CONFIG_FILE} @ONLY) + install( + FILES ${PKG_CONFIG} + DESTINATION "${CPPKAFKA_PKGCONFIG_DIR}" + COMPONENT pkgconfig + ) +endif() -install( - FILES ${PKG_CONFIG} - DESTINATION "${CPPKAFKA_PKGCONFIG_DIR}" - COMPONENT pkgconfig -) +if (CPPKAFKA_EXPORT_CMAKE_CONFIG) + # Install the exported file + install( + EXPORT "${TARGET_EXPORT_NAME}" + NAMESPACE "${NAMESPACE}" + COMPONENT config + DESTINATION "${CPPKAFKA_CONFIG_DIR}" + ) -# Generate CMAKE configuration file and exported targets -configure_package_config_file( - "${PROJECT_SOURCE_DIR}/cmake/config.cmake.in" - "${CONFIG_FILE}" - INSTALL_DESTINATION "${CPPKAFKA_CONFIG_DIR}" - PATH_VARS RDKAFKA_MIN_VERSION_HEX CMAKE_INSTALL_PREFIX CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR -) + # Generate CMAKE configuration file and exported targets + configure_package_config_file( + "${PROJECT_SOURCE_DIR}/cmake/config.cmake.in" + "${CONFIG_FILE}" + INSTALL_DESTINATION "${CPPKAFKA_CONFIG_DIR}" + PATH_VARS RDKAFKA_MIN_VERSION_HEX CMAKE_INSTALL_PREFIX CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR + ) -# Generate version file -write_basic_package_version_file( - "${VERSION_FILE}" - VERSION ${CPPKAFKA_VERSION} - COMPATIBILITY AnyNewerVersion -) + # Generate version file + write_basic_package_version_file( + "${VERSION_FILE}" + VERSION ${CPPKAFKA_VERSION} + COMPATIBILITY AnyNewerVersion + ) -install( - FILES "${CONFIG_FILE}" "${VERSION_FILE}" "${FIND_RDKAFKA_FILE}" - DESTINATION "${CPPKAFKA_CONFIG_DIR}" - COMPONENT config -) + install( + FILES "${CONFIG_FILE}" "${VERSION_FILE}" "${FIND_RDKAFKA_FILE}" + DESTINATION "${CPPKAFKA_CONFIG_DIR}" + COMPONENT config + ) +endif() From dd6ec44c27dbce1ea4a0f8668daf045d16e8d390 Mon Sep 17 00:00:00 2001 From: Alexander Damian Date: Wed, 17 Jul 2019 10:20:43 -0400 Subject: [PATCH 12/12] Updated pkg_config file name --- src/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 4c23cfc6..5b8649b5 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -69,7 +69,7 @@ if (CPPKAFKA_EXPORT_PKGCONFIG) configure_file(${PROJECT_SOURCE_DIR}/cmake/cppkafka.pc.in ${PKG_CONFIG_FILE} @ONLY) install( - FILES ${PKG_CONFIG} + FILES ${PKG_CONFIG_FILE} DESTINATION "${CPPKAFKA_PKGCONFIG_DIR}" COMPONENT pkgconfig )