The CMake Build system
FOSSology is quite an old and mature project. The project has been using bare metal Makefiles. As the project is growing with new agents and modernization it was required to have a modern build system.
The FOSSology is a suite of well-integrated and synchronized sub-projects (called agents) written in C, C++, and PHP. Most of the major agents are in C, C++ and that made CMake an obvious choice for a new build system for FOSSology. CMake is a versatile set of build, test, and packaging tools and is the most popular choice of C/C++ developers. CMake can be extended to create a build system for other languages too via custom scripts.
GitHub Actions CI/CD
Since the FOSSology project moved on Github, it has used only the free Travis CI service for OSS projects. At the time of writing Travis CI has reduced its free tier CI services. GitHub Actions provides faster builds. Since GitHub Actions is a fully managed service by GitHub, we don’t need to know how to scale and operate the infrastructure to run it.
It is straightforward to use with GitHub because when we fork a repository, the actions automatically get forked. This allows you to test and build projects very efficiently and even run them closer to the developer. Also, you have readily available access to the GitHub API, making it more popular among developers.
Improvements over previous build system and CI
The new build system and CI brings a lot of improvements and features. The list below describes them.
- CMake enforces out-of-source builds. This was already possible with the previous build system but not a strict requirement. This feature keeps the source code clean and makes cleaning the build artifacts easy. (Just remove the build folder :)
- One of the major improvements over the previous build system is faster build times. CMake generates parallel build-enabled configurations for all generators. In our tests, the new build system is at least twice as fast as the previous one. With further improvement in configuration, we will be able to further cut the build times.
- Previously FOSSology can only be built using Unix Makefiles. With CMake, we can now use many other popular generators such as Ninja.
- Now it is also very flexible to choose different compilers. This will help support more platforms and architecture in the future. As of now, we are experimenting with Clang compilers.
- FOSSology is quite an old project and a lot of agent testing code was written in the last decade. Initially, none of them were compatible with the new build system, but we were able to hack most of the test code using better-improved methods. Test times have also improved.
- Migrating from Travis CI to GitHub Actions was another big move and for the most part, it removes the dependency on a third-party CI service. Along with that GitHub Actions provides better build times, tons of new features, and better integration with other GitHub services.
CMake Build System Tasks
||YES||1 functional test needs fix|
||YES||1 functional test needs fix|
||YES||Tests needs fix|
||YES||1 Test failing in CI|
||YES||Unit tests needs fix|
GitHub Actions CI Tasks
|1||build||Added Ubuntu 20.04 GCC 8, 9 and Clang, GCC 7 not working|
|2||c/cpp unit test||Added, delagent, scheduler and ununpack not working|
|3||phpunit tests||Added, delagent and scheduler functional not working|
|5||source install||Not implemented|
(GREEN: COMPLETED, RED: INCOMPLETE, ORANGE: NOT NEEDED/DEPRECATED)
How does it work and how to use it?
The new build system retains the modular and hierarchical structure of the previous build system. On the other hand, the new build system provides several new flags to control the build. The new build system forces out-of-source build instead of the previous in-source builds. This keeps the source clutter-free and reduces the chance of accidentally deleting source files. Testing still needs some in-source artifacts, this will be solved once all the tests are fixed according to the new build system.
Each agent is a complete CMake sub-project with its independent configuration for building, installing, and testing. That means a single agent can be built and installed separately and even removed from the default build without breaking other builds. The directory structure is as below.
. ├── build # temporary directory for build artifacts ├── cmake # CMake modules for FOSSology │ ├── FoPackaging.cmake # CMake Packaging configurations │ ├── FoUtilities.cmake # Custom CMake utilities │ ├── FoVersionFile.cmake # VERSION version.php CMake template file │ ├── SetDefaults.cmake # CMake defaults for this project │ ├── TestInstall.make.in # Template makefile for install during tests │ └── VERSION.in # VERSION file template ├── src │ ├── agent-1 # Agent sub-project │ │ ├── agent # Agent's source code directory │ │ │ ├── agent-source-code │ │ │ └── CMakeLists.txt │ │ ├── agent_tests # Agent's test directory │ │ │ ├── Unit │ │ │ ├── Functional │ │ │ └── CMakeLists.txt │ │ ├── ui # Agent's UI source code │ │ │ ├── templates │ │ │ └── agent-ui-code │ │ └── CMakeLists.txt # Agent's top-level CMake configuration : : │ ├── other agents : : │ └── CMakeLists.txt # Source intermediate CMake configuration : ├── other directories and files : └── CMakeLists.txt # FOSSology Top-level CMake configuration
cmake directory contains customized CMake modules and templates for FOSSology. This directory is required for all the operations. The general workflow of the new build system as well as how to use it is described below.
Since the new build system is still in review. You must fork FOSSology and pull the #2075 pull request branch. Once you are in FOSSology root, run these commands.
git fetch https://github.com/avinal/fossology avinal/feat/buildsystem:buildsystem git checkout buildsystem
The first step towards building is to create a temporary directory for storing intermediate files and build artifacts. By convention we use a directory named
build, but you can use any name. (NOTE: For testing do not use other names)
mkdir build cd build
In the next steps, we will configure the CMake project and generate the required configurations. You can use several flags to control the build. Given below are the flags available for this project.
CMake Flags Description Default -DCMAKE_INSTALL_PREFIX=<path> Sets the install prefix.
-DAGENTS="agent1;agent2..." Only configure these agents. ALL AGENTS -DOFFLINE=<ON/OFF> Controls vendor generation, ON=NO OFF
- Controls build type aka level optimisation
-DTESTING=<ON/OFF> Controls testing config generation OFF -DMONOPACK=<ON/OFF> Package adj2nest and ununpack seperately OFF -GNinja Use Ninja instead of Unix Makefiles Unix MakeFiles
There are lots of inbuilt CMake command-line options you can see them in the official documentation. Once you have chosen your flags we can now configure the project using the following commands.
# From build folder cd <name-of-build-directory> cmake <flags> ..
The next step is to build the project. You can use parallel jobs to build faster. For more options you can type
# Common build command for all generators, # Default number of parallel builds depends on generator used cmake --build . --parallel <no-of-processes> # For Unix Makefiles, no parallel build by default make -j <no-of-processes> # For Ninja, 8+ parallel build by default (depends on system) ninja -j <no-of-processes>
Installing is also as easy as building. You can choose to install only certain components even if you have built the whole project. If you directly invoke the install command without building the project, it will automatically build the project first.
# For Unix Makefiles make install # For Ninja ninja install
While testing has some issues, most of the testing is working fine. For now, you must build and run any test from the FOSSology root directory only. You can choose to configure a single agent if you want to test one agent only. See
ctest --helpfor controlling test runs.
# Common testing command ctest --parallel <no-of-processes> # For Unix Makefiles make test # For Ninja ninja test
You can package FOSSology, the packaging currently lacks copyright and conf files. But for testing purposes, you can use the following commands. Similar to installing, if you run the package command without building the project, it will automatically build the project first. See
cpack --helpfor more packaging options.
# Common testing command cpack # For Unix Makefiles make package # For Ninja ninja package
Known Issues and Drawbacks
Although the transition from Makefiles to CMake and Travis CI to GitHub Actions is almost complete and working as expected. But it is not free of drawbacks and issues. This section outlines the known issues at the time of writing.
- Coverage builds may fail with linking errors.
- Packaging prefix is the same as the install prefix. This requires the developer to set the install prefix manually before packaging to produce packages with the correct directory structure.
- Testing and packaging must be used from the FOSSology root directory. Not doing so may or may not configure the project as intended.
- Previously tests were written hardcoded for the Makefiles. But new build system requires all artifacts to be generated in a separate directory. This required me to add symbolic links wherever a generated script or file is expected. Tests can still leave some artifacts inside source folders.
- There is no easy way to install a particular agent from the FOSSology root directory.
- Packages don't contain copyright, readme, and license files. CMake doesn't provide a way to include these files. This is being tracked by issue #21832.
- While packaging the symbolic links may or may not be dereferenced and hence results in copying the folder too in the target directory.
- Running tests locally may require switching to
- While configured for testing, it may give permission errors.
- Scheduler, Ununpack, and Delagent unit and functional tests are not working. I have added an issue #2084 to track the progress on fixing these tests.
- CMake doesn't generate uninstall targets. The closest thing to uninstall is this snippet. This will be later added to the FOSSology.
While this whole project was challenging, some aspects of it were unforeseen and more challenging. When I decided to go on with this project I just had enough CMake knowledge to write a configuration for a very small project. I had never used CMake on this big scale. On the other side, the FOSSology community is largely unknown to CMake so for all of us it was learned, practiced, and implement. With support from mentors, I was able to overcome this challenge with flying colors.
The other challenge was to understand the old build system, how they are all connected and what is the flow. The complexity can be imagined by the fact that the most of code and configurations were written in the decade before the last decade and haven't changed much since then.
The most challenging task was to make tests work with the new build system. Since tests were mostly hardcoded and the new build system refactored many of the files and directory, the tests were failing initially. The testing part took me the most time. All thanks to my mentor Gaurav and my friend Sarita I was able to hack them to suit the new build system.
Future Development Plans
There is a lot to do with the new build system and CI and it will probably take a year or to reach a maturity point. I was able to meet most of the goals but some of them are remaining.
- Fix the tests, probably renovate them from the ground up.
- Find a hack for packaging problems.
- Improve and optimize the build.
- Modernise the source code, remove old, bloated code and replace them according to new standards.
What did I learn from this project?
This Google Summer of Code was the busiest time of my life for all good reasons. I learned a lot about license compliance and how it all works in the software industry. The next big thing is CMake. As I mentioned I was just a novice user of CMake. Now I am confident that given any other large project I will be able to migrate it/improve it. I got to learn PHP, of which I did not know a single word before GSoC. And finally, I learned about packing and testing. I had these courses but implementing them myself and fixing them was a wholesome experience.
Other than that I improved on my communication and presentation skills. Collaborating with fellow participants was one of the great things that happened during GSoC.
Google Summer of Code is the best thing that has happened to me this year so far. Although there are numerous people to say thanks to, I want to mention key people who were my motivation and support during this period.
First of all, I want to thank and appreciate my mentors Gaurav Mishra, Michael C. Jaeger, Anupam Ghosh, and Shaheem Azmal M MD. Without the help and support from them, all this would not have been possible. They are very polite, knowledgeable, and helpful.
I want to thank my friend and fellow participant Sarita. Thank you for being a collaborator, support, and motivation for attempting GSoC.
Finally, I want to thank, my family and friends. I got to meet many awesome developers as my fellow participants from around the world, I wish we will do more collaboration in the future.
This Blog is licensed under Attribution-NonCommercial 4.0 International