RepoMirrors/ceph
1
0
Fork 0
mirror of https://github.com/ceph/ceph synced 2024-12-12 14:39:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
457b9560a3
ceph/cmake/modules/Distutils.cmake

144 lines
6.2 KiB
CMake
Raw Normal View History

cmake: install ceph-disk to /usr/sbin * add keyword "INSTALL_SCRIPT" to distutils_install_module(), so we can override the install path of ceph-disk script. * refactor the Distutils.cmake module a little bit, the ${option} variable out lives the CODE snipplet. so we need to reset it at the beginning. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 17:50:21 +00:00
include(CMakeParseArguments)
cmake: install ceph-{detect-init,disk} add a cmake module named Distutils.cmake for setting up python modules using setup.py. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-05-28 07:44:36 +00:00
cmake: install ceph-disk to /usr/sbin * add keyword "INSTALL_SCRIPT" to distutils_install_module(), so we can override the install path of ceph-disk script. * refactor the Distutils.cmake module a little bit, the ${option} variable out lives the CODE snipplet. so we need to reset it at the beginning. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 17:50:21 +00:00
function(distutils_install_module name)
cmake/Distutils.cmake: make pkg files optional, add bin Skip nonexistent 'expected' Python packaging files, and add bin/ as a possible file for symlinking during build (for Python projects with slightly different forms, currently ceph-volume) Signed-off-by: Dan Mick <dan.mick@redhat.com>
2017-07-20 20:54:37 +00:00
set(py_srcs setup.py README.rst requirements.txt test-requirements.txt bin ${name})
cmake: install ceph-{detect-init,disk} add a cmake module named Distutils.cmake for setting up python modules using setup.py. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-05-28 07:44:36 +00:00
foreach(src ${py_srcs})
cmake/Distutils.cmake: make pkg files optional, add bin Skip nonexistent 'expected' Python packaging files, and add bin/ as a possible file for symlinking during build (for Python projects with slightly different forms, currently ceph-volume) Signed-off-by: Dan Mick <dan.mick@redhat.com>
2017-07-20 20:54:37 +00:00
if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${src})
list(APPEND py_clone ${CMAKE_CURRENT_BINARY_DIR}/${src})
add_custom_command(
OUTPUT ${src}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${src}
COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_CURRENT_SOURCE_DIR}/${src} ${src})
endif()
cmake: install ceph-{detect-init,disk} add a cmake module named Distutils.cmake for setting up python modules using setup.py. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-05-28 07:44:36 +00:00
endforeach()
cmake/modules/Distutils: do not add ${name}-clone if already added if `distutils_install_module("foo" ...)` is called mutiple times with different python version, `foo-clone` will be added multiple times as a custom target. which is not allowed: add_custom_target cannot create target "foo-clone" because another target with the same name already exists. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-26 07:35:59 +00:00
if(NOT TARGET ${name}-clone)
add_custom_target(${name}-clone ALL
DEPENDS ${py_clone})
endif()
cmake: pass PYTHON_VERSION explicitly allow `distutils_*()` functions to choose the python according to this parameter, instead of implicitly using the variable of ${PYTHON_VERSION} inherited from the caller. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-18 01:46:51 +00:00
cmake_parse_arguments(DU "" "INSTALL_SCRIPT;PYTHON_VERSION" "" ${ARGN})
if(DU_PYTHON_VERSION)
set(python_version ${DU_PYTHON_VERSION})
else()
set(python_version 3)
endif()
cmake: install ceph-disk to /usr/sbin * add keyword "INSTALL_SCRIPT" to distutils_install_module(), so we can override the install path of ceph-disk script. * refactor the Distutils.cmake module a little bit, the ${option} variable out lives the CODE snipplet. so we need to reset it at the beginning. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 17:50:21 +00:00
install(CODE "
cmake: install python packages into $CMAKE_INSTALL_PREFIX * Distutils.cmake: set --prefix=${CMAKE_INSTALL_PREFIX} for python packages installed using setuptools. it was set to --prefix=/user only when $DESTDIR is set. so if user installs ceph using -DCMAKE_INSTALL_PREFIX, these python packages still go to /usr, which is unexpected. * ceph-disk/CMakeLists.txt: install script into ${CMAKE_INSTALL_SBINDIR} instead of /usr/sbin Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-07-04 03:10:49 +00:00
set(options --prefix=${CMAKE_INSTALL_PREFIX})
cmake: install ceph-disk to /usr/sbin * add keyword "INSTALL_SCRIPT" to distutils_install_module(), so we can override the install path of ceph-disk script. * refactor the Distutils.cmake module a little bit, the ${option} variable out lives the CODE snipplet. so we need to reset it at the beginning. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 17:50:21 +00:00
if(DEFINED ENV{DESTDIR})
if(EXISTS /etc/debian_version)
list(APPEND options --install-layout=deb)
endif()
cmake: do not pass unnecessary param to setup.py --single-version-externally-managed is used for packaging python eggs to deb. so the metadata can be stored in the egg, and can be accessed by user if necessary, see [1]. but this does not apply to users who just want to "make install" without packaging Ceph. the problem is, if we pass --single-version-externally-managed to setup.py, we need to pass --record or --root also. otherwise setuptools complains: error: You must specify --record or --root when building system packages so in this change, we choose not to pass "--single-version-externally-managed", unless $DESTDIR is set. both "ceph.spec.in" and "debian/rules" set $DESTDIR when running "make install". so we can always check $DESTDIR to tell if current "make install" is launched by the packaging script or not. this might not be accurate, but good enough. assuming enduser does not use DESTDIR when running plain "make install". -- [1] https://wiki.debian.org/Python/FAQ#How_should_we_package_Python_eggs.3F Signed-off-by: Kefu Chai <kchai@redhat.com>
2018-11-20 14:13:35 +00:00
list(APPEND options
--root=\$ENV{DESTDIR}
--single-version-externally-managed)
cmake: install ceph-disk to /usr/sbin * add keyword "INSTALL_SCRIPT" to distutils_install_module(), so we can override the install path of ceph-disk script. * refactor the Distutils.cmake module a little bit, the ${option} variable out lives the CODE snipplet. so we need to reset it at the beginning. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 17:50:21 +00:00
if(NOT \"${DU_INSTALL_SCRIPT}\" STREQUAL \"\")
list(APPEND options --install-script=${DU_INSTALL_SCRIPT})
endif()
endif()
execute_process(
cmake: pass PYTHON_VERSION explicitly allow `distutils_*()` functions to choose the python according to this parameter, instead of implicitly using the variable of ${PYTHON_VERSION} inherited from the caller. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-18 01:46:51 +00:00
COMMAND ${Python${python_version}_EXECUTABLE}
cmake: do not pass unnecessary param to setup.py --single-version-externally-managed is used for packaging python eggs to deb. so the metadata can be stored in the egg, and can be accessed by user if necessary, see [1]. but this does not apply to users who just want to "make install" without packaging Ceph. the problem is, if we pass --single-version-externally-managed to setup.py, we need to pass --record or --root also. otherwise setuptools complains: error: You must specify --record or --root when building system packages so in this change, we choose not to pass "--single-version-externally-managed", unless $DESTDIR is set. both "ceph.spec.in" and "debian/rules" set $DESTDIR when running "make install". so we can always check $DESTDIR to tell if current "make install" is launched by the packaging script or not. this might not be accurate, but good enough. assuming enduser does not use DESTDIR when running plain "make install". -- [1] https://wiki.debian.org/Python/FAQ#How_should_we_package_Python_eggs.3F Signed-off-by: Kefu Chai <kchai@redhat.com>
2018-11-20 14:13:35 +00:00
setup.py install \${options}
cmake: install ceph-disk to /usr/sbin * add keyword "INSTALL_SCRIPT" to distutils_install_module(), so we can override the install path of ceph-disk script. * refactor the Distutils.cmake module a little bit, the ${option} variable out lives the CODE snipplet. so we need to reset it at the beginning. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 17:50:21 +00:00
WORKING_DIRECTORY \"${CMAKE_CURRENT_BINARY_DIR}\")")
cmake: install ceph-{detect-init,disk} add a cmake module named Distutils.cmake for setting up python modules using setup.py. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-05-28 07:44:36 +00:00
endfunction(distutils_install_module)
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
cmake: pass PYTHON_VERSION explicitly allow `distutils_*()` functions to choose the python according to this parameter, instead of implicitly using the variable of ${PYTHON_VERSION} inherited from the caller. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-18 01:46:51 +00:00
function(distutils_add_cython_module target name src python_version)
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
get_property(compiler_launcher GLOBAL PROPERTY RULE_LAUNCH_COMPILE)
get_property(link_launcher GLOBAL PROPERTY RULE_LAUNCH_LINK)
fix compilation with distcc and other compiler wrappers When building with ccache, distcc, and other compiler wrappers (such as STLFilt): CC='ccache gcc' CXX='ccache g++' cmake /path/to/ceph make python modules fail to compile since distutils try to execute the wrapper itself without specifying the actual compiler. Although cmake has a special magic switch for compiling with ccache (cmake -DWITH_CCACHE=ON) other tools (distcc) are not supported, and specifying the compiler as CC=/whatever/compiler/is used to work for decades, and it's a good idea to keep it working Signed-off-by: Alexey Sheplyakov <asheplyakov@mirantis.com> Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-09-29 15:25:04 +00:00
# When using ccache, CMAKE_C_COMPILER is ccache executable absolute path
# and the actual C compiler is CMAKE_C_COMPILER_ARG1.
# However with a naive
# set(PY_CC ${compiler_launcher} ${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1})
# distutils tries to execve something like "/usr/bin/cmake gcc" and fails.
# Removing the leading whitespace from CMAKE_C_COMPILER_ARG1 helps to avoid
# the failure.
string(STRIP "${CMAKE_C_COMPILER_ARG1}" c_compiler_arg1)
string(STRIP "${CMAKE_CXX_COMPILER_ARG1}" cxx_compiler_arg1)
# Note: no quotes, otherwise distutils will execute "/usr/bin/ccache gcc"
# CMake's implicit conversion between strings and lists is wonderful, isn't it?
cmake: pass cflags to disutils using CC instead of CFLAGS in python's distutils.ccompiler, linker_exe is composed using CC instead of LDFLAGS. the latter only effects how it builds (shared) library. and put CMAKE_C_FLAGS into the cflags for the compiler for building python C extensions, it's more consistent this way. more importantly, if we build with ASan enabled, the canary program, a.k.a. rados_dummy.c, won't link without proper CFLAGS. without this change, rados.so fails to build with errors like: /usr/bin/ld: /var/ssd/ceph/build/lib/librados.so: undefined reference to `__asan_stack_free_10' /usr/bin/ld: /var/ssd/ceph/build/lib/librados.so: undefined reference to `__asan_report_exp_store8' ... ... clang: error: linker command failed with exit code 1 (use -v to see invocation) Link Error: RADOS library not found make[3]: *** [src/pybind/rados/CMakeFiles/cython_rados.dir/build.make:57: src/pybind/rados/CMakeFiles/cython_rados] Error 1 Signed-off-by: Kefu Chai <kchai@redhat.com>
2018-10-22 04:28:01 +00:00
string(REPLACE " " ";" cflags ${CMAKE_C_FLAGS})
list(APPEND cflags -iquote${CMAKE_SOURCE_DIR}/src/include -w)
cmake: remove cython 0.29's subinterpreter check cython 0.29 introduced a check which prevents multiple python subinterpreters from loading the same module: https://github.com/cython/cython/commit/7e27c7c Unfortunately, this completely breaks ceph-mgr. Until we can figure out a better long term solution, this commit removes cython's subinterpreter check, via some careful abuse of the C preprocessor. This works because when cython is invoked, it first generates some C code, then compiles it. We know it's going to generate C code including: int __Pyx_check_single_interpreter(void) { ... } and: if (__Pyx_check_single_interpreter()) return NULL; So, we can do the following: #define void0 dead_function(void) #define __Pyx_check_single_interpreter(ARG)=ARG ## 0 This replaces the call to __Pyx_check_single_interpreter() with a literal 0, removing the subinterpreter check. The void0 dead_function(void) thing is necessary because the __Pyx_check_single_interpreter() macro also clobbers that function definition, so we need to make sure it's replaced with something that works as a function definition. Fixes: https://tracker.ceph.com/issues/37472 Signed-off-by: Tim Serong <tserong@suse.com>
2018-12-17 11:01:25 +00:00
# This little bit of magic wipes out __Pyx_check_single_interpreter()
cmake: remove cython 0.29's subinterpreter check during install Commit 3bde34af8a removed cython 0.29's subinterpreter check when building the various python modules during `make`, but unforunately they're *rebuilt* during `make install`, with the rebuild overwriting the original build. The original fix was of course missing from the install stage... Fixes: https://tracker.ceph.com/issues/38788 Signed-off-by: Tim Serong <tserong@suse.com>
2019-03-20 07:52:14 +00:00
# Note: this is reproduced in distutils_install_cython_module
cmake: remove cython 0.29's subinterpreter check cython 0.29 introduced a check which prevents multiple python subinterpreters from loading the same module: https://github.com/cython/cython/commit/7e27c7c Unfortunately, this completely breaks ceph-mgr. Until we can figure out a better long term solution, this commit removes cython's subinterpreter check, via some careful abuse of the C preprocessor. This works because when cython is invoked, it first generates some C code, then compiles it. We know it's going to generate C code including: int __Pyx_check_single_interpreter(void) { ... } and: if (__Pyx_check_single_interpreter()) return NULL; So, we can do the following: #define void0 dead_function(void) #define __Pyx_check_single_interpreter(ARG)=ARG ## 0 This replaces the call to __Pyx_check_single_interpreter() with a literal 0, removing the subinterpreter check. The void0 dead_function(void) thing is necessary because the __Pyx_check_single_interpreter() macro also clobbers that function definition, so we need to make sure it's replaced with something that works as a function definition. Fixes: https://tracker.ceph.com/issues/37472 Signed-off-by: Tim Serong <tserong@suse.com>
2018-12-17 11:01:25 +00:00
list(APPEND cflags -D'void0=dead_function\(void\)')
list(APPEND cflags -D'__Pyx_check_single_interpreter\(ARG\)=ARG \#\# 0')
cmake: pass cflags to disutils using CC instead of CFLAGS in python's distutils.ccompiler, linker_exe is composed using CC instead of LDFLAGS. the latter only effects how it builds (shared) library. and put CMAKE_C_FLAGS into the cflags for the compiler for building python C extensions, it's more consistent this way. more importantly, if we build with ASan enabled, the canary program, a.k.a. rados_dummy.c, won't link without proper CFLAGS. without this change, rados.so fails to build with errors like: /usr/bin/ld: /var/ssd/ceph/build/lib/librados.so: undefined reference to `__asan_stack_free_10' /usr/bin/ld: /var/ssd/ceph/build/lib/librados.so: undefined reference to `__asan_report_exp_store8' ... ... clang: error: linker command failed with exit code 1 (use -v to see invocation) Link Error: RADOS library not found make[3]: *** [src/pybind/rados/CMakeFiles/cython_rados.dir/build.make:57: src/pybind/rados/CMakeFiles/cython_rados] Error 1 Signed-off-by: Kefu Chai <kchai@redhat.com>
2018-10-22 04:28:01 +00:00
set(PY_CC ${compiler_launcher} ${CMAKE_C_COMPILER} ${c_compiler_arg1} ${cflags})
fix compilation with distcc and other compiler wrappers When building with ccache, distcc, and other compiler wrappers (such as STLFilt): CC='ccache gcc' CXX='ccache g++' cmake /path/to/ceph make python modules fail to compile since distutils try to execute the wrapper itself without specifying the actual compiler. Although cmake has a special magic switch for compiling with ccache (cmake -DWITH_CCACHE=ON) other tools (distcc) are not supported, and specifying the compiler as CC=/whatever/compiler/is used to work for decades, and it's a good idea to keep it working Signed-off-by: Alexey Sheplyakov <asheplyakov@mirantis.com> Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-09-29 15:25:04 +00:00
set(PY_CXX ${compiler_launcher} ${CMAKE_CXX_COMPILER} ${cxx_compiler_arg1})
set(PY_LDSHARED ${link_launcher} ${CMAKE_C_COMPILER} ${c_compiler_arg1} "-shared")
cmake/modules/Distutils.cmake: add byproduct so add_custom_target() has better idea what is generated. if any target will use it, it can be used as a dependency. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-08 11:27:37 +00:00
cmake: pass PYTHON_VERSION explicitly allow `distutils_*()` functions to choose the python according to this parameter, instead of implicitly using the variable of ${PYTHON_VERSION} inherited from the caller. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-18 01:46:51 +00:00
if(${Python${python_version}_VERSION_MAJOR} STREQUAL "2")
cmake/modules/Distutils.cmake: add byproduct so add_custom_target() has better idea what is generated. if any target will use it, it can be used as a dependency. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-08 11:27:37 +00:00
set(suffix_var "SO")
else()
set(suffix_var "EXT_SUFFIX")
endif()
cmake: pass PYTHON_VERSION explicitly allow `distutils_*()` functions to choose the python according to this parameter, instead of implicitly using the variable of ${PYTHON_VERSION} inherited from the caller. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-18 01:46:51 +00:00
execute_process(COMMAND "${Python${python_version}_EXECUTABLE}" -c
cmake/modules/Distutils.cmake: add byproduct so add_custom_target() has better idea what is generated. if any target will use it, it can be used as a dependency. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-08 11:27:37 +00:00
"from distutils import sysconfig; print(sysconfig.get_config_var('${suffix_var}'))"
RESULT_VARIABLE result
OUTPUT_VARIABLE ext_suffix
ERROR_VARIABLE error
OUTPUT_STRIP_TRAILING_WHITESPACE)
if(NOT result EQUAL 0)
message(FATAL_ERROR "Unable to tell python extension's suffix: ${error}")
endif()
cmake: pass PYTHON_VERSION explicitly allow `distutils_*()` functions to choose the python according to this parameter, instead of implicitly using the variable of ${PYTHON_VERSION} inherited from the caller. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-18 01:46:51 +00:00
set(output_dir "${CYTHON_MODULE_DIR}/lib.${Python${python_version}_VERSION_MAJOR}")
cmake/modules/Distutils.cmake: add setup as a dependency so the extension will be rebuilt if setup.py is updated Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-08 12:15:39 +00:00
set(setup_py ${CMAKE_CURRENT_SOURCE_DIR}/setup.py)
cmake/modules/Distutils.cmake: avoid rebuilding cython ext use the combination of add_custom_command() and add_custom_target() to build cython extensions to avoid rebuilding the cython extension everytime we run "make" Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-08 12:06:06 +00:00
add_custom_command(
OUTPUT ${output_dir}/${name}${ext_suffix}
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
COMMAND
env
fix compilation with distcc and other compiler wrappers When building with ccache, distcc, and other compiler wrappers (such as STLFilt): CC='ccache gcc' CXX='ccache g++' cmake /path/to/ceph make python modules fail to compile since distutils try to execute the wrapper itself without specifying the actual compiler. Although cmake has a special magic switch for compiling with ccache (cmake -DWITH_CCACHE=ON) other tools (distcc) are not supported, and specifying the compiler as CC=/whatever/compiler/is used to work for decades, and it's a good idea to keep it working Signed-off-by: Alexey Sheplyakov <asheplyakov@mirantis.com> Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-09-29 15:25:04 +00:00
CC="${PY_CC}"
CXX="${PY_CXX}"
LDSHARED="${PY_LDSHARED}"
cmake: Suppress warnings on Cython output They are automatically generated code and we don't really control it. Signed-off-by: Adam C. Emerson <aemerson@redhat.com>
2016-11-08 20:43:26 +00:00
OPT=\"-DNDEBUG -g -fwrapv -O2 -w\"
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
LDFLAGS=-L${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
CYTHON_BUILD_DIR=${CMAKE_CURRENT_BINARY_DIR}
pybind: Add CMake support in rados Signed-off-by: Anirudha Bose <ani07nov@gmail.com>
2016-06-13 18:17:09 +00:00
CEPH_LIBDIR=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
cmake: pass PYTHON_VERSION explicitly allow `distutils_*()` functions to choose the python according to this parameter, instead of implicitly using the variable of ${PYTHON_VERSION} inherited from the caller. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-18 01:46:51 +00:00
${Python${python_version}_EXECUTABLE} ${setup_py}
cmake: Also build Python bindings for Python 3 Signed-off-by: Oleh Prypin <oleh@pryp.in>
2016-07-13 12:57:30 +00:00
build --verbose --build-base ${CYTHON_MODULE_DIR}
cmake/modules/Distutils.cmake: add byproduct so add_custom_target() has better idea what is generated. if any target will use it, it can be used as a dependency. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-08 11:27:37 +00:00
--build-platlib ${output_dir}
cmake/modules/Distutils.cmake: add setup as a dependency so the extension will be rebuilt if setup.py is updated Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-08 12:15:39 +00:00
MAIN_DEPENDENCY ${src}
DEPENDS ${setup_py}
cmake/modules/Distutils.cmake: avoid rebuilding cython ext use the combination of add_custom_command() and add_custom_target() to build cython extensions to avoid rebuilding the cython extension everytime we run "make" Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-08 12:06:06 +00:00
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
add_custom_target(${target} ALL
DEPENDS ${output_dir}/${name}${ext_suffix})
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
endfunction(distutils_add_cython_module)
cmake: pass PYTHON_VERSION explicitly allow `distutils_*()` functions to choose the python according to this parameter, instead of implicitly using the variable of ${PYTHON_VERSION} inherited from the caller. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-18 01:46:51 +00:00
function(distutils_install_cython_module name python_version)
cmake: pass LDSHARED env var to distutils otherwise, the default gcc will be used, and the $CMAKE_C_COMPILER passed to the outer CMakeLists.txt won't kick in. moreover, if the building script (ceph.spec for instance) could set the $PATH, and expect that the CMakeLists.txt will use the toolchain executables in the $PATH to build Ceph, distutils will continue using the default $CC for linking the python bindings, on UNIX it will be gcc in the new shell's $PATH, because we are using `install(CODE "... execute_process( ...))` for installing the python bindings. apparently, this is not expected. because the new shell's $PATH is very likely different from the one changed by the building script. to address this, we should always specify the `$LDSHARED` env var explicitly. also, pass env vars using `ENV{}` instead of the `env` command to workaround the issue of https://cmake.org/pipermail/cmake/2015-December/062216.html, because it's not straightforward to set environment variables with spaces in the them using cmake. and because one cannot use add_custom_target() in the script mode of cmake. this leave me only limited options to fix this issue. Signed-off-by: Kefu Chai <kchai@redhat.com>
2017-11-11 17:50:42 +00:00
get_property(compiler_launcher GLOBAL PROPERTY RULE_LAUNCH_COMPILE)
get_property(link_launcher GLOBAL PROPERTY RULE_LAUNCH_LINK)
set(PY_CC "${compiler_launcher} ${CMAKE_C_COMPILER}")
set(PY_LDSHARED "${link_launcher} ${CMAKE_C_COMPILER} -shared")
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
install(CODE "
cmake: pass LDSHARED env var to distutils otherwise, the default gcc will be used, and the $CMAKE_C_COMPILER passed to the outer CMakeLists.txt won't kick in. moreover, if the building script (ceph.spec for instance) could set the $PATH, and expect that the CMakeLists.txt will use the toolchain executables in the $PATH to build Ceph, distutils will continue using the default $CC for linking the python bindings, on UNIX it will be gcc in the new shell's $PATH, because we are using `install(CODE "... execute_process( ...))` for installing the python bindings. apparently, this is not expected. because the new shell's $PATH is very likely different from the one changed by the building script. to address this, we should always specify the `$LDSHARED` env var explicitly. also, pass env vars using `ENV{}` instead of the `env` command to workaround the issue of https://cmake.org/pipermail/cmake/2015-December/062216.html, because it's not straightforward to set environment variables with spaces in the them using cmake. and because one cannot use add_custom_target() in the script mode of cmake. this leave me only limited options to fix this issue. Signed-off-by: Kefu Chai <kchai@redhat.com>
2017-11-11 17:50:42 +00:00
set(ENV{CC} \"${PY_CC}\")
set(ENV{LDSHARED} \"${PY_LDSHARED}\")
cmake: remove cython 0.29's subinterpreter check during install Commit 3bde34af8a removed cython 0.29's subinterpreter check when building the various python modules during `make`, but unforunately they're *rebuilt* during `make install`, with the rebuild overwriting the original build. The original fix was of course missing from the install stage... Fixes: https://tracker.ceph.com/issues/38788 Signed-off-by: Tim Serong <tserong@suse.com>
2019-03-20 07:52:14 +00:00
set(ENV{CPPFLAGS} \"-iquote${CMAKE_SOURCE_DIR}/src/include
-D'void0=dead_function\(void\)' \
-D'__Pyx_check_single_interpreter\(ARG\)=ARG \#\# 0'\")
cmake: pass LDSHARED env var to distutils otherwise, the default gcc will be used, and the $CMAKE_C_COMPILER passed to the outer CMakeLists.txt won't kick in. moreover, if the building script (ceph.spec for instance) could set the $PATH, and expect that the CMakeLists.txt will use the toolchain executables in the $PATH to build Ceph, distutils will continue using the default $CC for linking the python bindings, on UNIX it will be gcc in the new shell's $PATH, because we are using `install(CODE "... execute_process( ...))` for installing the python bindings. apparently, this is not expected. because the new shell's $PATH is very likely different from the one changed by the building script. to address this, we should always specify the `$LDSHARED` env var explicitly. also, pass env vars using `ENV{}` instead of the `env` command to workaround the issue of https://cmake.org/pipermail/cmake/2015-December/062216.html, because it's not straightforward to set environment variables with spaces in the them using cmake. and because one cannot use add_custom_target() in the script mode of cmake. this leave me only limited options to fix this issue. Signed-off-by: Kefu Chai <kchai@redhat.com>
2017-11-11 17:50:42 +00:00
set(ENV{LDFLAGS} \"-L${CMAKE_LIBRARY_OUTPUT_DIRECTORY}\")
set(ENV{CYTHON_BUILD_DIR} \"${CMAKE_CURRENT_BINARY_DIR}\")
set(ENV{CEPH_LIBDIR} \"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}\")
cmake: refactor distutils_install_module to follow the pattern of distutils_install_cython_module Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-07-04 03:26:28 +00:00
set(options --prefix=${CMAKE_INSTALL_PREFIX})
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
if(DEFINED ENV{DESTDIR})
if(EXISTS /etc/debian_version)
cmake: refactor distutils_install_module to follow the pattern of distutils_install_cython_module Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-07-04 03:26:28 +00:00
list(APPEND options --install-layout=deb)
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
endif()
cmake: refactor distutils_install_module to follow the pattern of distutils_install_cython_module Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-07-04 03:26:28 +00:00
list(APPEND options --root=\$ENV{DESTDIR})
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
else()
cmake: refactor distutils_install_module to follow the pattern of distutils_install_cython_module Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-07-04 03:26:28 +00:00
list(APPEND options --root=/)
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
endif()
execute_process(
cmake: pass LDSHARED env var to distutils otherwise, the default gcc will be used, and the $CMAKE_C_COMPILER passed to the outer CMakeLists.txt won't kick in. moreover, if the building script (ceph.spec for instance) could set the $PATH, and expect that the CMakeLists.txt will use the toolchain executables in the $PATH to build Ceph, distutils will continue using the default $CC for linking the python bindings, on UNIX it will be gcc in the new shell's $PATH, because we are using `install(CODE "... execute_process( ...))` for installing the python bindings. apparently, this is not expected. because the new shell's $PATH is very likely different from the one changed by the building script. to address this, we should always specify the `$LDSHARED` env var explicitly. also, pass env vars using `ENV{}` instead of the `env` command to workaround the issue of https://cmake.org/pipermail/cmake/2015-December/062216.html, because it's not straightforward to set environment variables with spaces in the them using cmake. and because one cannot use add_custom_target() in the script mode of cmake. this leave me only limited options to fix this issue. Signed-off-by: Kefu Chai <kchai@redhat.com>
2017-11-11 17:50:42 +00:00
COMMAND
cmake: pass PYTHON_VERSION explicitly allow `distutils_*()` functions to choose the python according to this parameter, instead of implicitly using the variable of ${PYTHON_VERSION} inherited from the caller. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-18 01:46:51 +00:00
${Python${python_version}_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/setup.py
cmake: Also build Python bindings for Python 3 Signed-off-by: Oleh Prypin <oleh@pryp.in>
2016-07-13 12:57:30 +00:00
build --verbose --build-base ${CYTHON_MODULE_DIR}
cmake: pass PYTHON_VERSION explicitly allow `distutils_*()` functions to choose the python according to this parameter, instead of implicitly using the variable of ${PYTHON_VERSION} inherited from the caller. Signed-off-by: Kefu Chai <kchai@redhat.com>
2019-07-18 01:46:51 +00:00
--build-platlib ${CYTHON_MODULE_DIR}/lib.${Python${python_version}_VERSION_MAJOR}
cmake: put cythonized .c files into ${CMAKE_CURRENT_BINARY_DIR} it was put into the directory where .pyx is located. it's not expected in an out-of-tree build. * {rados,rbd,cephfs}/setup.py: use build_ext from cython if possible, fallback to the one from setuptools or distutils * Distutils.cmake: pass --cython-c-in-temp --build-temp and --cython-include-dirs to "build_ext" command Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-07-09 04:58:33 +00:00
build_ext --cython-c-in-temp --build-temp ${CMAKE_CURRENT_BINARY_DIR} --cython-include-dirs ${PROJECT_SOURCE_DIR}/src/pybind/rados
cmake: creage egg_info files into build directory otherwise they will go to the source tree, and "git ls-files" will list them as untracked files, which annoy gitbuilder-ceph-tarball*-cmake gitbuilders. like + echo 'error: Added files:' error: Added files: + cat .git/added-files src/pybind/rados/rados.egg-info/PKG-INFO ... Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-07-08 06:57:41 +00:00
install \${options} --single-version-externally-managed --record /dev/null
egg_info --egg-base ${CMAKE_CURRENT_BINARY_DIR}
--verbose
cmake: install cython modules * fix CYTHON_ADD_MODULE() macro. because python_add_module() offered by FindPythonLibs.cmake creates a target with name of ${name}, which conflicts with existing targets like "rbd" or "rados". so we can not reuse the name in ${name}.pyx. and instead, we should specify the target name explicitly. * add distutils_install_cython_module() function to build and install cython modules. * we can split build and install of cython module, but the install phase always tries to build the module. so keep it this way. will look at it later on. * move the variables initializations into the Distutils.cmake module. Signed-off-by: Kefu Chai <kchai@redhat.com>
2016-06-01 05:38:05 +00:00
WORKING_DIRECTORY \"${CMAKE_CURRENT_SOURCE_DIR}\"
RESULT_VARIABLE install_res)
if(NOT \"\${install_res}\" STREQUAL 0)
message(FATAL_ERROR \"Failed to build and install ${name} python module\")
endif()
")
endfunction(distutils_install_cython_module)
Reference in New Issue Copy Permalink