CMake, C++ and Jenkins/Continuous integration

Question

I have a cmake sample project that I would like to build on Jenkins running on Ubuntu 15.10. I have installed:

https://wiki.jenkins-ci.org/display/JENKINS/CMake+Plugin

And created two build steps:

1. Run cmake to generate makefiles
2. Run make all from the build dir

I works fine:

[build] $ cmake -G "Unix Makefiles" -D CMAKE_BUILD_TYPE=Debug /var/lib/jenkins/workspace/cmake-test/cmake-gtest/src
-- Configuring done
-- Generating done
-- Build files have been written to: /var/lib/jenkins/workspace/cmake-test/cmake-gtest/build
[build] $ /usr/bin/make
[  4%] Built target libfoo
[  9%] Built target libbar
[ 14%] Built target myApp
[ 52%] Built target gmock
[ 90%] Built target gtest
[100%] Built target testfoo
[cmake-test] $ /bin/sh -xe /tmp/hudson1792271459427590561.sh
+ cd cmake-gtest/build
+ make all
[  4%] Built target libfoo
[  9%] Built target libbar
[ 14%] Built target myApp
[ 52%] Built target gmock
[ 90%] Built target gtest
[100%] Built target testfoo
Finished: SUCCESS

But is this the recommended approach for using cmake in a CI/Jenkins setup?

Currently my cmake/Jenkins build will on each push; 1) generate the makefiles, 2) build the project.

I am a bit worried that the first step 1) generate makefiles would eat up build time and it does not really seem optimal to do this step on each push. Especially since I would not expect to change CMakeLists.txt files that often, but when they change new generated files should of course be used.

Is the above approach common practices that I just have to get used to or have I missed something?

Answer 1

I am not even sure you need this plugin. AFAIR the plugin webpage it is only useful if you want jenkins to use a specific cmake version, or you want a GUI for which cmake variables you might want to set. I just execute cmake from the command line.

For your second part of the question, If you change CMakeLists.txt, the Makefile will automatically rerun cmake, so strictly speaking it is not necessary to run cmake each time. But on the other side cmake configuring is quite fast and most likely takes less time than compiling.

Answer 2

Yes, you can do it in one step.

For example, in my Jenkins environment, when building the Ubuntu jobs I use the CMake plugin for the whole compilation, as it allows multiple build tool invocations.

My screenshot at the bottom of this post is of a CMake step in a job (I use Ninja instead of Unix Makefiles, but the effect is the same).

I use two build invocations:

• Blank - equivalent to calling ninja or make in a shell,
• Install - equivalent to calling DESTDIR=. ninja install.

If I wanted to build additional targets from the makefiles, I could just add extra invocations to this step.

Note that in your screenshot you have a blank invocation in the configuration. This will already be calling make, and as confirmed by your log output, you are in fact compiling your project twice, because of your manual call to make all in the following step.

You can remove your shell step and your project will still build.

---

Regarding your question on best practices and regenerating CMake, I refer you to this article on Jenkins Best Practices where it states:

To ensure a build can be reproducible, the build must be a clean build, which is built fully from Source Code Control. This practice also implies that all code including third-party jars, build scripts, release notes, etc. must be checked into Source Code Control.

Note that I also check "Clean Build" in my CMake step, so that the entire CMake workspace is wiped out and the project is generated from scratch for every build. This ensures there are no issues caused by stale cache variables, etc.

Screenshot of a CMake step in one of my jobs: