Binaires dans le contrôle de code source

Lors du développement pour des appareils intégrés et d'autres mondes étranges, il est très probable que votre processus de construction inclura plusieurs binaires propriétaires, en utilisant des versions très spécifiques d'entre eux. La question est donc: font-ils partie de votre contrôle de source? Mes bureaux suivent la règle de "la vérification du contrôle des sources comprend tout ce dont vous avez besoin pour compiler le code" et cela a conduit à de sérieux arguments.

Les principaux arguments que je vois contre cela sont les ballonnements de la base de données de contrôle de source, le manque de fichiers binaires différents ( voir les questions précédentes sur le sujet) . Cela va à l'encontre de la possibilité de vérifier, de construire, en sachant que vous avez l'environnement précis prévu par le développeur précédent et sans rechercher les fichiers appropriés (avec des versions spécifiques, rien de moins!)

L'idée de VERSION CONTROL (abusif: source control) est de vous permettre de revenir en arrière dans l'historique, de récupérer l'effet des modifications, de voir les modifications et pourquoi elles ont été apportées. Il s'agit d'une gamme d'exigences, dont certaines nécessitent des trucs binaires, d'autres non.

Exemple: Pour le travail de firmware intégré, vous aurez normalement une chaîne d'outils complète: soit un compilateur propriétaire qui coûte beaucoup d'argent, soit une version de gcc. Afin d'obtenir l'exécutable d'expédition, vous avez besoin de la chaîne d'outils ainsi que de la source.

Vérifier les chaînes d'outils dans le contrôle de version est pénible, les utilitaires de diff sont horribles (voire pas du tout), mais il n'y a pas d'alternative. Si vous voulez que la chaîne d'outils soit préservée pour le gars qui vient regarder votre code dans 5 ans pour comprendre ce qu'il fait, alors vous n'avez pas le choix: vous DEVEZ également avoir la chaîne d'outils sous contrôle de version.

Au fil des ans, j'ai constaté que la méthode la plus simple pour ce faire est de créer une image ZIP ou ISO du CD d'installation et de l'archiver. Le commentaire d'archivage doit être le numéro de version du fabricant spécifique de la chaîne d'outils. Si gcc ou similaire, regroupez tout ce que vous utilisez dans un gros ZIP et faites de même.

Le cas le plus extrême que j'ai fait est Windows XP Embedded où la "chaîne d'outils" est une machine virtuelle Windows XP en cours d'exécution, qui comprenait (à l'époque) SQL Server et une pile de fichiers de configuration ainsi que des centaines et des centaines de fichiers correctifs. L'installation de l'ensemble du lot et sa mise à jour prenaient environ 2-3 jours. Préserver cela pour la postérité signifiait vérifier l'intégralité de la machine virtuelle dans le contrôle de version. Étant donné que le disque virtuel était composé d'environ 6 x 2 Go d'images, il s'est plutôt bien déroulé. Cela semble exagéré, mais cela a rendu la vie très facile à la personne qui est venue après moi et a dû l'utiliser - 5 ans plus tard.

Résumé: Le contrôle de version est un outil. Utilisez-le pour être efficace, ne vous attardez pas sur des choses comme le sens des mots, et ne l'appelez pas "contrôle de source" parce que c'est plus grand que ça.

Neal Ford soutient dans le programmeur productif que vous devez garder les fichiers binaires dans le contrôle de la source:

Pourquoi garder des binaires? Les projets dépendent aujourd'hui d'une multitude d'outils et de bibliothèques externes. Supposons que vous utilisez l'un des cadres de journalisation les plus populaires (comme Log4J ou Log4Net). Si vous ne générez pas les fichiers binaires pour cette bibliothèque de journalisation dans le cadre de votre processus de génération, vous devez les conserver sous contrôle de version. Cela vous permet de continuer à construire votre logiciel même si le framework ou la bibliothèque en question disparaît (ou, plus probablement, introduit un changement de rupture dans une nouvelle version). Gardez toujours l'univers entier requis pour construire votre logiciel en contrôle de version(moins le système d'exploitation, et même cela est possible avec la virtualisation; voir «Utiliser la virtualisation», plus loin dans ce chapitre). Vous pouvez optimiser la conservation des fichiers binaires en les conservant dans le contrôle de version et sur un lecteur réseau partagé. De cette façon, vous n'avez pas à les traiter toutes les heures, mais ils sont enregistrés au cas où vous auriez besoin de reconstruire quelque chose un an plus tard. Vous ne savez jamais si vous devrez reconstruire quelque chose. Vous le construisez jusqu'à ce qu'il fonctionne, puis oubliez-le. Il est affolant de réaliser que vous devez reconstruire quelque chose d'il y a deux ans et que vous n'avez pas toutes les pièces.

Je ne pourrais pas être plus d'accord; Bien que cela puisse sans doute renverser le VCS pour une tâche pour laquelle il n'a pas été conçu (conserver les binaires), je pense que les avantages l'emportent sur les inconvénients potentiels. Mais, comme le note l'auteur plus tard, la conservation des fichiers binaires dans VCS peut parfois ne pas être une solution pratique, donc d'autres options doivent être envisagées - comme les conserver sur un lecteur réseau mappé.

Si les binaires ne sont pas trop gros, je les garderais certainement dans VCS. Cela semble être encore plus vrai dans votre cas, car les binaires sont probablement petits et vous travaillez avec des versions très spécifiques. Ils peuvent également être difficiles à trouver, pour diverses raisons (les auteurs ont fermé leur site Web ou la version dont vous avez besoin n'est plus répertoriée pour le téléchargement). Bien que peu probable, vous ne savez jamais ce qui se passera dans quelques années.

J'aimerais avoir lu ce livre il y a quelques années, quand je travaillais sur un jeu utilisant une bibliothèque graphique (qui était un fichier dll); J'ai interrompu le développement pendant un certain temps, et quand j'ai voulu continuer, je n'ai pas pu retrouver la DLL car le projet est mort.

En principe, j'apprécie le camp «vérifiez tout ce dont vous avez besoin pour intégrer le contrôle de code source», mais la gestion des dépendances a beaucoup évolué ces dernières années, avec des outils comme Maven, Ivy et NuGet.

De plus, en pratique, je trouve que l'archivage des fichiers binaires crée un certain nombre d'effets secondaires désagréables. Git / Mercurial ne sont pas vraiment adaptés à cela, par exemple, et Subversion et Perforce peuvent vous rendre fou lorsque vous fusionnez des branches qui contiennent des binaires.

Avec une solution de gestion des dépendances, vous spécifiez dans un fichier contrôlé par source dans votre projet les noms de packages et les versions dont votre projet dépend. Presque tous les outils de gestion des dépendances vous permettent de créer un référentiel privé de vos dépendances, en suivant une sorte de convention de version et de dénomination; lorsque vous effectuez une génération, l'outil de gestion des dépendances résoudra toutes vos dépendances open source et propriétaires à partir d'une liste de sources approuvées, puis les placera dans votre cache local. La prochaine fois que vous construirez avec les mêmes dépendances de version, tout est déjà là et ça va beaucoup plus vite.

Votre référentiel privé peut ensuite être sauvegardé avec des outils de sauvegarde de système de fichiers conventionnels.

Cela évite les ralentissements que j'ai connus lorsqu'une tonne de fichiers binaires sont extraits de l'arborescence source et empêche votre référentiel d'avoir beaucoup de fichiers difficiles à différencier. Il n'y a qu'un seul emplacement pour une dépendance donnée, par nom et numéro de version, donc il n'y a pas de conflits de fusion à gérer, et la mise en cache du système de fichiers local signifie que vous n'avez pas à gérer le coût de l'évaluation si votre copie locale a changé lorsque vous tirez des mises à jour.

Le contrôle des sources concerne les sources. Les sources sont ce que vous ne pouvez pas construire à partir d'autres choses. Certains fichiers qualifiés de sources se trouvent être des binaires.

Mon VCS contient de nombreux fichiers binaires, mais chacun est l'unité de sortie d'un produit que je n'ai pas écrit et que je ne gère pas. Cela pourrait être quelque chose comme GNU ccRTP, qui est publié sous forme de tarball compressé. Cette archive tar est ma source, et elle est enregistrée avec toute l'infrastructure dont j'ai besoin pour en faire un produit fini (un Makefile et une spécification RPM dans mon cas) en une seule étape automatisée. Quand il y a une nouvelle version de ccRTP, je traite la nouvelle archive tar comme une source modifiée: elle va dans une copie extraite, est construite, testée et validée dans le VCS. J'ai fait la même chose avec des produits commerciaux qui ne sont pas livrés avec la source (compilateurs, bibliothèques, etc.) et cela fonctionne de la même manière. Au lieu de décompresser-configurer-compiler-package, c'est juste décompresser-package. Le logiciel qui fait les builds nocturnes ne le fait pasmake et obtenir des produits finis.

La plupart des VCS ont des fonctionnalités qui rendent la source lisible par l'homme plus facile à gérer et plus efficace à stocker, mais dire qu'ils ne sont pas adaptés aux binaires n'est pas vraiment vrai si les binaires installés reviennent sans être perturbés. La façon dont un VCS traite les binaires en interne dépend entièrement de la question de savoir si ses auteurs pensaient que tenter de ne stocker que les différences en valait la peine. Personnellement, je pense que le stockage de copies complètes d'une distribution ccRTP à 600 Ko est plus que compensé par la possibilité de baliser une version de celle-ci avec toutes mes autres sources.

Cela me rappelle le problème des "pots dans le référentiel" que Java avait il y a quelque temps. Les personnes créant des applications java ont été utilisées pour pousser leurs dépendances (fichiers binaires jar) dans des référentiels. Tout le monde était satisfait de cela, car nous aurions un système de construction en un clic et l'espace disque est bon marché, alors peu importe. Puis est venu Maven et vous pouvez vous débarrasser de toute cette cruauté binaire et avec un référentiel local uniquement en cache, maintenez toujours les builds bullet-prof. Vous avez toujours un système de construction "en un clic", mais le contrôle de code source n'a pas à se déplacer autour de fichiers binaires qui n'ont aucun sens.

Donc oui, vous pouvez extraire les fichiers binaires du contrôle de code source, mais cela vous obligera à modifier le système de génération pour les obtenir au moment de la génération. Sans logiciel dédié (comme Maven), cela pourrait demander beaucoup d'efforts pour les retirer.

Votre contrôle de source retient les sources de ce que vous faites. Si un blob binaire donné peut être reconstruit à partir des sources, il ne s'agit pas d'une source et ne doit pas aller dans le référentiel de code source. Seuls les blobs non récréatifs doivent apparaître dans le contrôle de source.

Vous avez généralement un autre dossier réseau de référentiel d'objets blob binaires que vous avez créé au fil du temps des sources. Ceux-ci peuvent être déployés auprès des clients ou utilisés dans des projets (au lieu de tout construire à partir de zéro à chaque fois).

Alors, mettez-le si c'est une source. Si non.

Le but est de pouvoir obtenir le dernier code et le compiler sans avoir à installer / configurer quoi que ce soit (donc, un build "en un seul clic").

Dans de nombreux endroits où je me suis rendu, cela signifie vérifier les binaires des dépendances. Dans d'autres, cela signifie que les scripts de build téléchargent et obtiennent automatiquement les dépendances.

Voir cet article de blog de Derek Greer sur le sujet.

Je travaille sur un projet avec deux étapes de construction différentes

• la "construction du programme principal" n'a besoin que de quelques binaires, par rapport aux milliers de fichiers texte de code source, de sorte que les binaires sont archivés dans le référentiel. Cela fonctionne bien.

• la version du programme d'installation nécessite de nombreux composants tiers (certains d'entre eux sont simplement copiés sur le CD d'installation, comme Adobe Reader). Nous ne les mettons pas dans le référentiel. Au lieu de cela, ces composants résident sur un lecteur réseau (même les anciennes versions) et les scripts de génération les copient au bon endroit. Bien sûr, pour avoir des versions reproductibles, tout le monde doit faire attention à ne pas changer de dossier où les composants tiers sont stockés.

Les deux stratégies fonctionnent bien et remplissent l'exigence de "vérification à partir du contrôle de code source inclut tout ce dont vous avez besoin pour compiler le code".

Vous devez conserver tout ce dont vous aurez besoin pour reconstruire des versions spécifiques du produit à un moment donné dans le futur.

Cependant, vous n'avez pas besoin de tout conserver dans le contrôle de code source.

Une entreprise a conservé un rack de serveur gelé (car le système d'exploitation ne fonctionnait que sur ce matériel spécifique et la chaîne d'outils ne fonctionnait que sur ce système d'exploitation et la source dépendait de cette chaîne d'outils). Impossible de vérifier cela dans le contrôle de code source.

Si vous avez besoin de fractionner les exigences pour une build, vous avez alors le problème comptable de garder deux systèmes de contrôle de version synchronisés. Par exemple, la boîte matérielle dans ce placard, ou la machine virtuelle ou les fichiers binaires dans ce volume de sauvegarde préservé, allez avec cette révision du code source SVN, etc. C'est plus compliqué que d'utiliser un système de contrôle de source unique, mais résoluble.

C'est très chaotique de s'enregistrer en binaire dans SCM dans mon esprit. J'avais exécuté un projet très complexe, qui a beaucoup de dépendances avec des bibliothèques tierces. Les principes que nous avons adoptés:

1. Tout le code source est géré avec SCM
2. Toutes les dépendances sont gérées avec Ivy, qui a une excellente intégration d'éclipse.

Cela fonctionne plutôt bien. Nous avons un fichier de configuration sur la version de chaque bibliothèque externe avec laquelle le code source peut être compilé. Ce fichier de configuration est archivé dans SCM, il évolue donc à mesure que le code source évolue. En appliquant cette approche, nous pouvons reproduire exactement une build sans déconner avec la version des bibliothèques externes.

Personnellement, philosophiquement, je suis enclin à laisser le contrôle de la source vérifier les pointeurs vers les gros fichiers binaires (les petites ressources binaires sont OK), et non le contenu du fichier. Ce pointeur contiendrait un hachage du contenu du fichier binaire.

Le fichier binaire lui-même ne serait pas géré par le contrôle de code source. Il serait stocké dans une sorte de bibliothèque où il peut être récupéré à l'aide du pointeur ou du hachage en particulier.

Git LFS et git annex font cela, mais ils essaient également de gérer les fichiers binaires dans une certaine mesure, je ne veux pas qu'ils le fassent. Je veux que Git stocke uniquement les sommes de contrôle et me dise si mes fichiers binaires ont changé ou non - mais je ne veux pas qu'il essaie de les gérer et de les stocker. Je veux le faire moi-même.

Je pense que git peut gérer des fichiers binaires de petite et moyenne taille mais je ne suis pas sûr que ce soit le bon outil pour gérer de gros fichiers binaires.