Traiter une grande demande de pull

Je travaille actuellement sur un projet avec une équipe qui utilise un workflow git. C'est assez simple, le maître doit être dans un état déployable et les branches sont utilisées pour créer des fonctionnalités et des correctifs. Chaque fois qu'une fonctionnalité ou un correctif est terminé et testé, nous le transférons au maître dès que possible. L'idée est que les branches doivent être aussi petites que possible pour faciliter leur fusion dans le master. Nous avons une politique selon laquelle tout code poussé vers la branche principale doit être dans un état déployable et réussir les tests.

Nous avons une situation où l'un des développeurs a fait beaucoup de travail (valant quelques mois) sur une seule branche et cette branche n'a pas encore été fusionnée dans le maître. Il y a maintenant quelques fonctionnalités distinctes et un tas de commits sur cette branche, essentiellement cette branche aurait vraiment dû être fusionnée en quelques fois déjà, mais jusqu'à présent ne l'a pas été. La plupart du code est en bon état avec des tests unitaires qui pourraient être réintégrés dans le maître mais les modifications les plus récentes ne devraient certainement pas l'être car elles ne sont pas terminées et ne sont pas testées.

Quelle est la meilleure façon de faire face à une telle situation où une branche est vraiment loin des autres? De quelles manières pouvons-nous éviter que les succursales obtiennent un très grand nombre de validations de Master à l'avenir?

Laissez le développeur qui est parti pendant quelques mois sans fusionner le réparer. Peut-être qu'ils peuvent obtenir un gros morceau de code à fusionner, peut-être qu'ils peuvent obtenir un tas de petits morceaux à fusionner un à la fois. Dans tous les cas, ils devraient faire les démarches pour résoudre le problème, car ils l'ont causé.

Quelle est la meilleure façon de faire face à une telle situation où une branche est vraiment loin des autres?

En général, ne vous en faites pas: c'est le problème de l'autre développeur. Si deux branches sont vraiment trop éloignées l'une de l'autre pour fusionner, alors elles ne font plus vraiment partie du même projet et vous avez une fourchette de facto. S'il s'agit d'un projet open source, ce n'est peut-être même pas un problème.

Si ce développeur est vraiment génial et que son code est meilleur / plus intelligent / plus important que le reste de l'équipe réunie, alors cela vaut la peine d'en faire votre problème au lieu du leur. Sinon, ce n'est pas le cas.

Pour répondre à la question littérale: la meilleure façon de faire face à ce genre de situation est de ne pas entrer dans ce genre de situation.

De quelles manières pouvons-nous éviter que les succursales obtiennent un très grand nombre de validations de Master à l'avenir?

Assurez-vous que tout le monde remarque que le développeur qui est resté des mois sans fusion doit résoudre le problème qu'il a causé. Assurez-vous que tout le monde sait qu'il est plus facile de s'engager à maîtriser fréquemment que rarement, car moins de changements signifie moins de possibilités de conflits.

Assurez-vous que les gens savent qu'ils peuvent se retirer du maître pour rester à jour avec les changements des autres.

"Si vous fusionnez tous les jours, tout à coup, vous n'arrivez jamais au point où vous avez d'énormes conflits difficiles à résoudre." --Linus Torvalds

Cette citation est tirée d'un discours qu'il a prononcé sur Google, voici la transcription et voici la vidéo .

Si vous avez une validation que vous connaissez et que toutes les validations précédentes sont bien testées et doivent être fusionnées, alors dérivez simplement de cette dernière bonne validation et fusionnez la nouvelle branche avec master.

Si vous avez des commits que vous souhaitez fusionner, mais qu'ils sont entrecoupés d'autres commits qui ne sont pas prêts pour la production, alors je vois 2 possibilités:

1. Créez une nouvelle branche et choisissez de bons commits, fusionnez avec master.
2. Essayez de rebaser les commits indésirables vers le haut (peut-être sur une nouvelle branche juste pour être sûr).

En ce qui concerne les méthodes de prévention, essayez de définir des règles d'équipe amusantes comme "Celui qui ne fusionne pas avec le maître dans une semaine commandera une pizza pendant un mois".

Tout d'abord, voyez s'il existe vraiment des validations distinctes qui peuvent être fusionnées ou sélectionnées, comme le suggère @Maciej Chalpuk. Si tel est le cas, alors la situation n'est vraiment pas si mauvaise, et je ne m'en inquiéterais pas trop à l'avenir.

Cependant, si la situation réelle est que plusieurs fonctionnalités ont été développées simultanément dans une même branche, au sein des mêmes commits, il devient alors beaucoup plus difficile à gérer. Heureusement, la méthode de prévention est intégrée: obligez le développeur à séparer les modifications de chaque fonctionnalité dans des branches distinctes et à extraire les demandes avant de les fusionner. Vous obtiendrez tous les deux vos fusions atomiques et dissuaderez ce développeur de le faire dans l'avenir.

Le processus réel de séparation des fonctionnalités est entièrement manuel. Créez de nouvelles branches hors du maître et copiez les modifications de la méga branche qui lui sont liées. Compilez, testez la fonctionnalité, envoyez et émettez une demande d'extraction. Moins les changements de code sont entremêlés, plus il sera facile de le faire. S'il piratait une seule méthode pour chacun d'eux, eh bien, amusez-vous. Il ne recommencera pas.

Voici une solution simple.

Suivez les fonctionnalités que cette personne a implémentées et accédez à chaque validation sur cette branche qui a été mise à jour par fonctionnalité. Prenez ce commit et fusionnez-le avec le référentiel maître.

Permettez-moi de décomposer cela sous la forme d'un exemple.

Soit: la branche A est la branche du maître Branche A + = branche A + nouvelle fonctionnalité 1 branche A ++ = branche A + nouvelle fonctionnalité 2 et ainsi de suite et ainsi de suite

Ce que vous devez faire est de retourner à: Direction A +

Prenez la branche A + et fusionnez-la avec Master.

Allez maintenant dans la branche A ++ et fusionnez-la avec (Master + branche A +).

Répétez jusqu'à ce que vous ayez atteint la branche finale A + ... + qui est stable.

Cette méthode peut sembler contre-intuitive au début, mais si vous fusionnez chaque nouvelle fonctionnalité distincte avec le maître, il devient facile de basculer entre la branche principale " par fonctionnalité ajoutée "

De quelles manières pouvons-nous éviter que les succursales obtiennent un très grand nombre de validations de Master à l'avenir?

Je pense que ma solution ci-dessus indique quelle future méthode vous devriez adopter. Choisissez une méthode par fonction ou par tâche pour chaque branche.

Je suggérerais d'utiliser une approche de:

pré-master et master

master: Niveau final / production. Est modifié pas souvent. Est considéré comme toujours stable

pré-master: la zone où une nouvelle fonctionnalité est ajoutée au code existant. Testé minutieusement pour fonctionner avec la base de code existante, et est l'endroit où d'autres branches peuvent se bifurquer pour l'implémentation de nouvelles fonctionnalités.

Vous devriez également essayer de regrouper des fonctionnalités et de viser le ciblage de version.

Ciblage de version: spécifiez un nombre arbitraire qui servira d'espace réservé pour la branche principale. "Dans V1.0.0, nous voudrons obtenir les fonctionnalités X, Y, Z. V1.0.0 aura également toutes ces fonctionnalités disponibles: ..."

En maintenant une version par rapport à master, cela peut aussi être un moyen de maintenir "master" stable et prêt pour la production à tout moment.

Résoudre le problème de la demande de tirage important est une chose, et il existe de bonnes réponses à ce sujet. Mais en ce qui concerne les succursales qui sont très obsolètes, vous voudrez peut-être revoir vos processus de gestion du travail d'équipe.

Si vous travaillez dans un cadre Agile ou SCRUM, l'équipe devrait vraiment se demander pourquoi la fonctionnalité n'a pas été terminée et fusionnée dans le cadre de l'itération / sprint. S'il était "trop ​​grand" pour tenir dans une itération, il aurait dû être décomposé en morceaux plus petits.

Cela soulève également une question de propriété du code - au sein de votre équipe, les développeurs individuels possèdent-ils leur propre travail séparément, ou toute l'équipe travaille-t-elle ensemble pour s'assurer que les éléments sont terminés?

Bien sûr, ce qui précède suppose que votre équipe fait partie d'une structure d'entreprise. S'il s'agit d'un projet open source avec des contributeurs bénévoles, c'est une autre histoire. En général, ces projets ont un contrôle plus lâche sur les flux de travail, mais la responsabilité de générer des demandes de tirage acceptables incombe plus souvent aux contributeurs individuels.

À bien des égards, cela devient une question de processus. Peut-être que votre processus nécessaire comprend la vérification périodique (hebdomadaire? Mensuelle?) Des succursales non fusionnées de longue durée. Certains outils facilitent la vérification visuelle; par exemple sur github, visitez le lien "branches" et il montre à quel point chaque branche est en avance / en retard.