Quelle est la meilleure façon de mettre à jour un projet multi-composants

J'ai un programme qui se compose de 5 composants principaux. Je trouve la numérotation des versions standard trop limitative car j'aimerais voir à quelle version se trouve chaque composant.

Quelqu'un a-t-il trouvé un moyen simple de procéder autrement que de les énumérer séparément?

Nous avons exactement le même problème avec notre produit, et nous avons décidé de faire des numéros de version individuels pour chaque composant et la version du produit n'est qu'une version marketing composée des différents composants lors d'une révision spécifique.

Nous avons une "version de version système", qui est un numéro de version standard qui décrit une configuration particulière de composants, puis un fichier séparé répertorie les versions de composants individuelles pour cette version système particulière. Les clients disent 5.2.1 mais nous pouvons rechercher la version individuelle si nécessaire. Habituellement, pour une version majeure, nous synchronisons toutes les versions individuelles afin que tout soit à nouveau construit à partir du même numéro de branche.

La gestion des versions est un problème distinct du développement d'applications basées sur des composants. Soit vous voulez versionner chaque composant, soit vous voulez versionner l'application entière.

Un bon modèle bien connu pour le contrôle de version est de Microsoft :

major version.minor version.build number.revision

Par exemple, vous pouvez voir les fichiers DLL dans la plate-forme .NET pour avoir des versions comme 2.0.3600.1, ou quelque chose comme ça.

Donc, je vous recommande de déterminer d'abord si vous souhaitez mettre à niveau le système entier ou ses composants. Si vous souhaitez versionner le système entier, après chaque intégration, générez le projet entier et augmentez la partie du numéro de build . Sinon, il suffit de versionner chaque composant lors de la construction.

Soyez prudent avec le versioning, cela pourrait vous tuer :-) N'essayez pas de compliquer les choses.

Je pense que l'approche suivante pourrait vous aider:

Versionnez chaque composant individuellement avec le schéma de version de votre choix. D'après vos commentaires, je comprends que vous avez un VCS en place. Je suppose également que chaque composant a un fichier où sa version est conservée (non?). Une fois par jour / semaine (selon ce qui fonctionne le mieux pour votre équipe), ajoutez une balise à l'une des révisions les plus récentes dans VCS qui marque cette révision comme la dernière révision officielle (et éventuellement incrémentez un numéro de super-révision). Maintenant, vous pouvez interroger le VCS pour les révisions avec cette balise, puis rechercher la version des composants dans cette version officielle.

Si vous voulez juste localement, écrivez un petit script qui agrégera la version de chaque composant de l'endroit où est stocké dans le code.

Si vous souhaitez le rendre encore plus sophistiqué, une fois le balisage effectué, vous pouvez consulter les fichiers appartenant à chaque composant, en considérant que vous pouvez identifier les fichiers qui appartiennent à un composant spécifique. En cas de modification, incrémentez la version de ce composant spécifique. L'alternative est de le faire manuellement. Une autre alternative est une combinaison de branchement et de fusion avec le suivi de version.

La plupart des numéros de version utilisent une révision majeure et mineure dictée par le marketing, vous ne pouvez donc pas les utiliser pour suivre les versions de composants individuels. En bref, vous devez trouver une autre partie de la version que vous pouvez utiliser pour suivre les versions de composants individuels et réserver les numéros de version principaux et mineurs pour suivre l'ensemble du package.

Si vous suivez quelque chose de semblable au modèle Microsoft:

major-version.minor-version.build-number.revision

Vous pouvez utiliser le .revision pour suivre la version de chaque composant individuel, et utiliser les numéros de révision mineurs et majeurs pour suivre un changement complet de produit, de la manière habituelle.

Si vous suivez un modèle similaire à celui-ci:

Major-Version.Minor-Version.Build-Number

Vous devrez utiliser le numéro de build pour suivre les versions des composants individuels.

Des livres entiers sont écrits sur le logiciel de version.

Voici une approche que j'utilise.

Chaque pièce a une version sous la forme:

major.minor.developmental

Chacun d'eux est un nombre, commençant à 0.

Pour une version officielle (c'est-à-dire aux clients), la partie développement doit toujours être 0 pour des raisons de politique.

Major est incrémenté par décision marketing.

Minor est incrémenté par la mise sur le marché d'ensembles de fonctionnalités.

Exemple:

• Je commence le développement sur un nouveau composant, donc mon numéro de version sera 0.0.1. Lorsque je remets mon bureau à mes collègues, par exemple, pour des tests internes, le nombre de développement monte à 0,0,2, 0,0,3, etc.

• Je lance cette nouvelle chose sur le marché en tant que 1.0.0, où le seul changement autorisé de la fin du développement à la version était de changer le numéro de version (par exemple, 0.0.43 -> 1.0.0).

• De nouvelles fonctionnalités doivent être ajoutées. Je commence à travailler sur la ligne de base 1.0.0, en ajoutant ces fonctionnalités, donc les versions que je distribue à mes collègues pour les tests sont 1.0.1, 1.0.2, etc.

• Les prochaines fonctionnalités sont commercialisées sous la version 1.1.0.

• Le marketing décide que la prochaine grande chose sera vraiment grosse, donc elle sortira en 2.0.0. Je commence à travailler sur 1.1.1, en progressant à travers 1.1.x et à sortir en 2.0.0.

Et donc le cycle se répète.

Cette approche, pour chaque composant, vous offre une traçabilité des ancêtres.

En interne à votre système de gestion des révisions source (et objet), utilisez des branches et des balises (labels, quelle que soit votre terminologie du jour) pour gérer le développement.

Votre contrôle de révision peut alors gérer chaque composant complètement séparément, avec des branches de développement et des étiquettes / balises pour chacun. Ou vous pouvez les regrouper tous ensemble, auquel cas vous souhaiterez peut-être créer des branches par lot de travail - mais assurez-vous d'étiqueter / étiqueter en libérant chaque composant (et quand vous le faites, étiquetez / étiquetez tout, pas seulement les bits pour le De cette façon, vous avez un instantané de l'état de tout à l'époque.)

Il est probable que votre processus de publication nécessitera une réflexion approfondie. L'utilisation de cette approche comprend certaines étapes manuelles, ce qui peut ne pas être souhaitable - tout dépend de la façon dont votre système de génération insère les numéros de version dans l'objet final. Pour beaucoup de code intégré où les numéros de version ne sont que des numéros nommés (par exemple # définis dans le code C), vous n'avez pas d'autre choix que de tout faire manuellement de toute façon. Les plates-formes de bureau avec de belles interfaces graphiques rendent souvent tout cela beaucoup plus convivial.

Sommaire

Pour moi, le seul moyen fiable de versionner un logiciel est d'utiliser l' identifiant de hachage ou de changeset de votre système de contrôle de version.

Un numéro de version de build global peut être utile, mais il n'est vraiment garanti d'être unique que si vous avez un serveur de build et / ou que vous signez chaque version. Pour beaucoup d'entre nous, ce n'est tout simplement pas viable.

Si votre projet est réparti sur plusieurs référentiels de contrôle de version, vous devrez également créer un mécanisme grâce auquel votre interface utilisateur pourra interroger chaque référentiel dépendant et signaler son hachage à l'utilisateur.

Exemple d'expérience personnelle

Dans un projet chez un employeur précédent, où nous avons eu des problèmes avec notre logiciel (interne) de modification de client et de recompilation, j'ai institué un processus par lequel les hachages mercuriels étaient compilés dans chaque application et bibliothèque. Chaque fois que le logiciel était démarré, une chaîne de révision était créée en interrogeant tous les composants logiciels.

Cette chaîne de révision s'affichait lorsque vous alliez à la page À propos et était écrite dans le fichier journal à chaque démarrage de l'application. C'était de la forme:

Application name     (6a72e7c61f54)
    Library1         (b672a13a41e1)
        Library2     (9cc35769b23a)
    Library2         (9cc35769b23a)
    Library3         (4e9f56a0186a+)
        Library2     (9cc35769b23a)
    Library4         (2e3b08c4ac76)
        Library1     (b672a13a41e1)
            Library2 (9cc35769b23a)

De cela, je pouvais facilement voir qu'ils avaient modifié Library3 et n'avaient pas validé ces modifications dans le référentiel, ils utilisent donc du code qui n'est pas contrôlé. Je pourrais également comparer les hachages avec mon système de test actuel, ainsi je pourrais être en mesure d'identifier qu'ils sont revenus (disons) Library1 à une version plus ancienne.

Cela signifiait que chaque fois qu'ils signalaient un bug, je pouvais toujours reconstruire exactement le code utilisé au moment où le problème s'est produit, ou à tout le moins savoir avec certitude que je ne pouvais pas reproduire la configuration.

Pour plus de détails sur le système de construction que j'ai utilisé, comment j'ai accompli cela, quels problèmes j'ai eu et ce que les gens ont suggéré de les éviter, jetez un œil à ma question Stack Overflow .

Remarque: Ce système n'est vraiment viable que si vous utilisez un système de contrôle des révisions où un hachage donné est garanti pour aboutir au même ensemble de fichiers dans votre répertoire de travail (par exemple git et mercurial) si un répertoire de travail donné peut contenir un mélange de fichiers et les répertoires de plusieurs révisions (par exemple svn), puis tous les paris sont désactivés concernant l'état du répertoire de travail et cette méthode ne fonctionnera pas du tout.