Stratégies de gestion du code source - création de branches, marquage, forgeage, etc. - pour les applications Web

Question

Cette publication ici ( Comment gérez-vous les révisions de base de données sur un projet de taille moyenne avec des branches? ) m'a demandé comment utiliser au mieux un projet Web en utilisant la création de branches et le déploiement pour le développement, la transition et la production (avec des copies locales).

Nous n'avons pas les "communiqués". En soi: si une fonctionnalité est assez grande pour être remarquée, nous la poussons en direct (après les tests requis, etc.), sinon nous en groupons quelques-unes et, quand elle se sent "confortable", nous les poussons en direct. L’objectif est de ne jamais déployer un déploiement plus d’une ou deux fois par mois environ, car un site en constante évolution tend à gêner les utilisateurs.

Voici comment nous le faisons, et cela semble un peu cassant (j'utilise actuellement svn mais envisage de passer à git):

1. Deux " branches " - DEV et STAGE avec une version donnée de STAGE marquée TRUNK
   • Le développeur extrait une copie de TRUNK pour chaque modification et crée une branche pour celui-ci
   • Le développeur travaille localement, en enregistrant le code fréquemment (comme pour voter tôt et souvent)
   • Lorsque le développeur le souhaite, il n'est pas totalement cassé, fusionnez la branche avec DEV et déployez-le sur le site de développement.
   • Répétez les étapes 3 à 4 autant de fois que nécessaire jusqu'à ce que le changement soit "terminé"
   .
   • Fusionnez la branche de changement avec STAGING, déployez-la sur le site de la scène. Effectuez les tests finaux attendus.
   • Après un certain temps, marquez une révision donnée de STAGE comme étant le TRONC, puis poussez le tronc en direct
   • Fusionne TRUNK et redéfinit DEV pour le garder synchronisé

Maintenant, certaines de ces étapes ont une complexité considérable et sont très difficiles à faire en pratique (TRUNK - > DEV casse toujours), donc je dois imaginer qu'il existe un meilleur moyen.

Pensées?

Answer 1

Le branchement est pratique si vous vous attendez à ce que le travail ne soit PAS terminé à temps et si vous ne disposez pas d’un nombre suffisant de tests pour effectuer une intégration continue. J'ai tendance à constater un développement insensé des succursales dans les magasins où les tâches de programmation sont beaucoup trop lourdes pour pouvoir être réalisées de manière prévisible. La direction souhaite donc attendre jusqu'à la sortie d'une version pour déterminer quelles fonctionnalités devraient être disponibles. Si vous effectuez ce type de travail, vous pouvez envisager d'utiliser le contrôle de version distribuée, où CHAQUE répertoire de travail est une branche naturelle et vous obtenez toute l'enregistrement local et l'historique local que vous pouvez manger sans faire de mal à qui que ce soit. Vous pouvez même fusionner avec d’autres développeurs en dehors du coffre.

Ma préférence est que nous travaillions dans un coffre instable avec des branches pour les candidats à la publication, lesquelles sont ensuite étiquetées pour publication et qui deviennent ensuite le flot des correctifs d'urgence. Dans un tel système, vous avez très rarement plus de trois branches (dernière version, candidate à la dernière version, coffre instable). Cela fonctionne si vous utilisez TDD et que vous avez un CI sur le trunk instable. Et si vous souhaitez que toutes les tâches soient réparties de manière à pouvoir livrer le code aussi souvent que vous le souhaitez (généralement, une tâche ne doit durer qu'un à deux jours et peut être dissociée sans toutes les autres tâches qui composent sa fonctionnalité). Ainsi, les programmeurs prennent leur travail en main, extraient le tronc, le synchronisent et en archivent à tout moment tous les tests réussis. Le trunk instable est toujours disponible pour créer une branche en tant que release candidate (si tous les tests réussissent) et par conséquent, la release devient un non-événement.

Globalement, de meilleurs moyens: moins de branches, des tâches plus courtes, un délai de publication plus court, plus de tests.

Answer 2

Une idée évidente serait davantage de "rebaser". (fusionne plus souvent de "STAGE" parent "STAGE d'environnement à" enfant "d'environnement" DEV "dans la branche développeur) afin de minimiser l'impact final de TRUNK- & DEV, qui ne serait plus nécessaire.

C'est-à-dire que tout ce qui est fait dans STAGE et qui doit entrer en production à la fois (TRUNK) doit être fusionné dès que possible dans les branches DEV et private devs, sinon ces fusions tardives sont toujours pénibles.

MAIS, si le workflow de fusion ci-dessus est trop gênant, je suggérerais une branche REBASE, basée sur le dernier DEV juste après une version (nouveau TRUNK). La rebase TRUNK- & DEV deviendrait TRUNK- > REBASE, où tous les problèmes seraient résolus, puis une fusion finale DEV- > REBASE pour vérifier que tout développeur en cours est compatible avec le nouveau système mis à jour. Une dernière fusion triviale de REBASE à DEV (et à des branches de développement privées) viendrait compléter le processus.
L’intérêt d’une branche est d’isoler un effort de développement qui ne peut être mené en même temps que d’autres efforts de développement en cours. Si TRUNK- > DEV est trop compliqué pour accompagner les DEV actuels, il doit être isolé. D'où la proposition de branche 'REBASE'.

Answer 3

Lisez ceci: http://oreilly.com/catalog/practicalperforce/chapter/ ch07.pdf

Answer 4

Nous utilisons SVN dans le magasin où je travaille. Bien que nous développions C ++, la gestion de version est assez universelle. Ce qui suit est notre approche, vous pouvez décider de ce qui est raisonnable pour votre approche, le cas échéant.

Pour nous, TOUS les développements ont lieu dans une branche. Nous avons des branches pour chaque bogue et chaque fonctionnalité. Idéalement, cette branche est consacrée UNIQUEMENT à 1 fonction, mais parfois, cela n’est pas censé être.

Lorsque le travail est terminé, testé et "prêt". nous fusionnons les modifications dans le coffre. Notre règle est qu’à aucun moment, le coffre n’aura pu déchiffrer du code. Si le code endommagé doit trouver sa place dans le coffre, sa réparation devient la priorité 1.

Les versions sont créées lorsque toutes les fonctionnalités sont terminées et fusionnées: une branche pour la version est créée comme une balise. La balise nous permet de récupérer un shapshot si nous en avons besoin. La branche nous permet notre support de version précédente. La correction des bogues dans une version publiée se fait en allant dans la branche de cette version, qui en dérive. Lorsque tout va bien, les modifications sont fusionnées dans la branche de l'édition et, si vous le souhaitez, jusqu'au coffre.