I. Introduction

Suite à mon précédent post, j’ai reçu beaucoup d’e-mails concernant l’installation des build bots. Je dois admettre que mon post précédent n’abordait pas ce sujet en détail et que la documentation à ce sujet est peu importante (en quantité) et confuse, tout comme le mode opératoire recommandé a changé dans la communauté cmake au cours des 15 ans des projets (VTK, ITK). Voici donc un post qui décrit, pas à pas, comment installer vos propres bots en quelques heures et comment les gérer à distance avec git sans jamais avoir à vous reconnecter à eux à nouveau (en théorie, en pratique les s#$%^ arrivent et vous pouvez souhaiter vous connecter de temps en temps pour débugguer les problèmes directement).

Garder le build bot séparé du code principal est une bonne politique car ils pourraient contenir des informations sensibles à propos de votre infrastructure. Par exemple, vous pourriez mentionner une clef d’accès pour transférer le résultat de la compilation (paquets de bibliothèques) et il vaut mieux que cette information reste privée. De plus, avec les réglages actuels, n’importe qui réussissant à avoir accès à votre script de compilation sera capable de lancer tout ce qu’il veut en utilisant votre build bot, ce qui est également quelque chose que vous ne voulez pas voir se produire. Dans notre cas, ceci est plus un tutoriel.

II. Écrire un script pour CTest

Jusqu’ci, j’ai présenté deux façons d’utiliser ctest :

• comme une extension de CMake pour gérer les tests directement à partir des fichiers CMake ;
• comme un client CDash, pour lancer CMake et automatiquement envoyer les résultats des étapes de la mise à niveau, de la configuration, de la compilation et des tests vers un serveur CDash

Il y a une troisième façon d’utiliser CTest : à partir de scripts. Vous pouvez écrire un fichier en utilisant la syntaxe CMake pour initialiser à l’avance les variables CTEST_<> qui serviront à lancer CTest d’une manière contrôlée. Vous tapez ensuite la commande « ctest-S » avec votre fichier en argument pour lancer CTest en mode script.

Quelques variables très utiles permettent de définir le cache CTEST,  ou des variables d’environnement, ou encore les compilateurs à utiliser et tout programme donné ou variable CMake. Cela permet, par exemple, de lancer des compilations 32 bits et 64 bits, en version debug et release, sur une même machine. Un autre exemple est d’avoir plusieurs versions de compilateurs sur une machine donnée et d’avoir des scripts CTest pour utiliser un compilateur spécifique à la fois. Un des meilleurs scripts que j’ai vu, écrit par Gaëtan Lehmann, gérait différentes versions de MSVC et Java sous Windows. Chapeau bas.

On peut obtenir plus d’informations à propos des capacités de CTest sur la vieille page écrite à une époque où on utilisait encore Purifier (ici, ici et là), et une version plus récente ici.

III. Qu’en est-il de libwebrtc ?

Pour cet exemple, j’ai utilisé la méthode la plus récente développée pour ITK v4. Vous trouverez ici un rapide aperçu. Cette version était centrée sur git et elle met en place quelques astuces pour gérer différentes branches, ce qui facilite la mise en place de bots pour les branches de développement.

1. Un script générique qui fait tous les travaux lourds

L’idée est d’avoir un script très général qui gère la plupart des problèmes pour vous et de laisser seulement quelques variables à définir par l’utilisateur. J’ai porté le script générique de manière à ce qu’il soit utilisable pour libwebrtc : libwebrtc_common.cmake. Sauf si vous êtes un puriste, je recommande de ne pas le modifier, ni même de le consulter. Il vous permet maintenant de définir un ensemble de paramètres, certaines variables CMAKE ou CTEST habituelles, ainsi que quelques nouvelles variables du tableau de bord, pour contrôler votre compilation.

• dashboard_model = Nightly | Experimental | Continuous
• dashboard_track = chemin optionnel vers lequel soumettre le tableau de bord
  
• dashboard_loop = répéter jusqu’à ce qu’une durée de N secondes se soit écoulée
  
• dashboard_root_name = changer le nom du répertoire « My Tests »
  
• dashboard_source_name = nom du répertoire contenant les sources (libwebrtc)
• dashboard_binary_name = nom du répertoire où seront placés les binaires (libwebrtc-build)
• dashboard_data_name = nom de la zone de stockage des données externes (ExternalData)
• dashboard_cache = contenu initial du fichier CMakeCache.txt
  
• dashboard_do_cache = toujours écrire CMakeCache.txt
• dashboard_do_coverage = True pour activer la couverture de code (par exemple avec gcov)
• dashboard_do_memcheck = True pour activer la recherche des fuites mémoire (par exemple avec valgrind)
• dashboard_no_clean = True pour sauter l’étape d’effacement de l’arborescence de compilation
• dashboard_no_update = True pour sauter la mise à jour de l’arborescence du code source
  
• CTEST_UPDATE_COMMAND = chemin vers le client git ligne de commande
• CTEST_BUILD_FLAGS = arguments pour l’outil de compilation (par exemple : -j2)
• CTEST_BUILD_TARGET = indique une cible particulière à compiler (à la place de toutes les cibles)
• CTEST_DASHBOARD_ROOT = indique où mettre les arborescences du code source et de compilation
• CTEST_TEST_CTEST = précise s’il faut exécuter ou pas les longs tests CTestTest*
  
• CTEST_TEST_TIMEOUT = pour chaque test, précise quelle est la durée du timeout
• CTEST_COVERAGE_ARGS = arguments pour la commande ctest_coverage
  
• CTEST_TEST_ARGS = arguments pour ctest_test (par exemple : PARALLEL_LEVEL 4)
• CTEST_MEMCHECK_ARGS = arguments pour ctest_memcheck (par défaut CTEST_TEST_ARGS)
• CMAKE_MAKE_PROGRAM = chemin vers l’outil « make » à utiliser
• Options pour configurer les compilations du dépôt expérimental de git :
• dashboard_git_url = définition d’une URL spéciale pour git clone url
  
• dashboard_git_branch = définition d’une branche spéciale à suivre
• dashboard_git_crlf = valeur de la variable core.autocrlf pour le dépôt
  

Si vous voulez étendre la capacité de ce script principal, quelques hameçons sont fournis afin de conserver les choses proprement et de manière compartimentée.

• dashboard_hook_init = fin de l’initialisation, juste avant la boucle
• dashboard_hook_start = début du corps de la boucle, avant ctest_start
• dashboard_hook started = après ctest_start
• dashboard_hook_build = avant ctest_build
• dashboard_hook_test = avant ctest_test
• dashboard_hook_coverage = avant ctest_coverage
• dashboard_hook_memcheck = avant ctest_memcheck
• dashboard_hook_submit = avant ctest_submit
• dashboard_hook_end = fin du corps de la boucle, après ctest_submit

2. Un fichier très simple pour définir un bot

Finalement, cela permet effectivement d’écrire un script de compilation effectivement très simplement :

1. set(CTEST_SITE « Bill_._Our_fearless_leader » )
2. set(CTEST_BUILD_NAME « Ubuntu-12.04-32-Deb » )
3. set(CTEST_BUILD_FLAGS -j8 )
4. set(CTEST_DASHBOARD_ROOT « /home/ubuntu/Dashboards » )
5. set(CTEST_TEST_TIMEOUT 1500 )
6. set(CTEST_BUILD_CONFIGURATION Debug )
7. set(CTEST_CMAKE_GENERATOR « Unix Makefiles » )
8. set(dashboard_model Experimental )
9. include(libwebrtc_common.cmake)

Et … voilà ! Vous avez un build bot linux prêt ! Remplacez « Debug » par « Release » et votre compilation en version release est prête. Pour passer de 32 à 64 bits, comme nous utilisons ninja, vous devez positionner la bonne variable d’environnement, mais ce n’est pas difficile non plus :

1. set(CTEST_ENVIRONMENT
2.     « GYP_DEFINES=’target_arch=x64′ » # ou ia32 pour 32 bits
3. )

Vous trouverez le fichier correspondant ici.

Une mise en garde tout de même, installer l’environnement de développement pour libwebrtc est difficile. Premièrement, cela ne marchera quasiment que sous Ubuntu ; deuxièmement, les scripts d’installation de l’environnement semblent ne pas fonctionner donc vous devrez au final installer manuellement quelques bibliothèques avant de pouvoir compiler. La bonne nouvelle c’est que vous ne devrez le faire qu’une seule fois.

3. Comment automatiser tout cela ?

Maintenant vous êtes armés de nombreux fichiers pour chaque compilation que vous voulez lancer. Vous pourriez très bien lancer plusieurs compilations sur la même machine, par exemple 32/64, Debug/Release. Pour des machines sous Linux, vous pouvez également souhaiter faire une compilation croisée avec des binaires Android (plus sur les cibles pour les mobiles dans un prochain post).

Toutefois, vous avez toujours besoin d’accéder à la machine et de lancer manuellement

1. ctest -S My_Build_script.cmake

pour que cela fonctionne.

Une façon de contouner cela consiste à définir un script (shell) qui lance ces commandes pour vous. Cependant, à chaque fois que vous apportez une modification au script, vous devez à nouveau vous connecter à la machine et mettre à jour manuellement le script local avec la nouvelle version, grrrrr.

C’est ici que cron (sur Linux ou Mac) et le planificateur de tâches (sur Windows) sont très pratiques, car ils peuvent lancer une commande à un jour et une heure prédéfinis pour un utilisateur donné. Ici vous avez deux écoles : les premiers utilisateurs de CMake ont tout conçu de telle sorte qu’il soit possible de configurer leurs ordinateurs (qui restent toujours allumés) pour être utilisés pendant les heures de sommeil. Plus récemment, les développeurs ont mis en place soit un build bot dédié, soit un build bot hébergé, et ils réduisent les coûts en éteignant la machine une fois le travail terminé. Je vais illustrer la deuxième solution pour Linux (et Mac) et les fichiers pour Windows seront fournis sur le compte github, pour ceux que ça intéresse. Spécialement pour les build bots Windows, notez qu’il a été démontré qu’il vaut mieux redémarrer la machine une fois par jour dans tous les cas si vous voulez que cela fonctionne…

Démarrer des instances à distance est facile, tous les fournisseurs de cloud proposent une API de ligne de commande, et vous pouvez maintenir un maître (sur la plus petite instance possible) dont le seul travail consiste à réveiller les bots une fois par jour pour qu’ils récupèrent la dernière version du code, qu’ils configurent la compilation, lancent la compilation et les tests et qu’il soumettent les résultats au tableau de bord. Dans AWS EC2, ça veut dire jouer avec IAM, mais rien de trop difficile, de plus c’est très bien documenté. Sous Linux, le démon cron accepte le mot-clé « reboot », qui indique que la tâche correspondante sera exécutée à chaque fois que l’instance est démarrée.

1. @ reboot/home/ubuntu/Dashboards/Scripts/Bill-runall.sh

Finalement, il vous suffit d’utiliser la commande shutdown dans votre script pour arrêter l’instance quand les tâches sont terminées.

1. shutdown -h now

Il ne nous reste plus qu’à automatiser les mises à jour des scripts.

L’astuce utilisée par la communauté ITK est de conserver les scripts (et la table « cron ») dans un dépôt git et de mettre à jour, en premier, ce dépôt. Dans cet exemple, vous pouvez voir depuis le script shell que nous nous attendons à ce que le répertoire ~/Dashboard/Scripts contienne les scripts de compilation, qu’il existe un répertoire ~/Dashboard/Logs, et que la crontable soit mise à jour au passage. Maintenant il me suffit d’effectuer un commit dans mon dépôt git pour que le bot de compilation se mette à jour automatiquement de lui-même. C’est trop bon !

1. # Aller dans le répertoire de travail
2. cd /home/ubuntu/Dashboards/Scripts
3. # Récupérer la dernière version des scripts
4. git pull -rebase -q
5. # Mettre à jour la crontable
6. crontab ./Bill-crontab
7. # Lancer les compilations et les tests
   
8. ctest -S ./Bill-32-Debug.cmake
9. ctest -S ./Bill-32-Release.cmake
10. # Terminé. Arrêtons l’instance pour ne pas payer trop
11. sudo shutdown -h now

Le script complet avec quelques fonctionnalités supplémentaires est disponible ici.

IV. Conclusion

Cela devrait maintenant être assez clair que mettre en place un build bot pour libwebrtc est relativement facile. Le code fourni dans github devrait rendre cette tâche encore plus facile. Vous êtes libres de mettre en place votre propre build bot, y compris avec des paramètres qui ne sont pas encore présents dans les bots contribuant aujourd’hui au tableau de bord, ce qui permettra de contribuer au jeu… Je devrais faire une mise à jour vers un serveur CDash plus gros ce qui permettra très bientôt d’avoir plus de 10 compilations par jour. J’adorerais voir des gens contribuer pour ajouter la compilation pour ARM, Androïd, iOS…

Si vous trouvez ça utile, faites le connaître autour de vous, et sachez que les commentaires sympas sont eux aussi appréciés. 😉