Traiter avec une grande demande de traction
Je travaille actuellement sur un projet avec une équipe qui utilise un flux de travail GIT. C'est assez simple, le maître devrait être dans un état déployable et des succursales sont utilisés pour créer des fonctionnalités et des correctifs. Chaque fois que nous avons une fonctionnalité ou un bugfix terminé et testé, nous déplacons cela à Master dès que possible. L'idée est que les branches devraient être aussi petites que possible pour que cela soit plus facile de les fusionner dans le Maître. Nous avons une politique que tout code poussé vers la branche principale devrait être dans un état déployable et transmettre les tests.
Nous avons une situation dans laquelle l'un des développeurs a fait beaucoup de travail (quelques mois d'une valeur) sur une seule branche et cette succursale n'a pas encore été fusionnée dans le maître. Il y a maintenant quelques caractéristiques distinctes et un tas de commettre de cette branche, essentiellement cette succursale aurait réellement été fusionnée dans quelques reprises, mais jusqu'à présent n'a pas été. La majeure partie du code est dans un bon état avec des tests unitaires qui pourraient être fusionnés dans le Master, mais les changements les plus récents ne doivent certainement pas être tels qu'ils ne sont pas terminés et ne sont pas testés.
Quelle est la meilleure façon de gérer une telle situation où une branche est vraiment loin des autres? Quels moyens pouvons-nous éviter les succursales d'obtenir un très grand nombre de commits de Maître à l'avenir?
Laissez le développeur qui est allé pendant quelques mois sans la fusionner. Peut-être qu'ils peuvent obtenir un gros morceau de code pour fusionner, peut-être qu'ils peuvent avoir un tas de petits morceaux pour fusionner une à la fois. En tout état de cause, ils devraient faire le travail pour résoudre le problème, car ils l'ont causée.
Quelle est la meilleure façon de gérer une telle situation où une branche est vraiment loin des autres?
En général, ne vous inquiétez pas pour cela: c'est le problème de l'autre développeur. Si deux branches sont vraiment trop loin à fusionner, ils ne font plus partie du même projet et vous avez une fourchette defacto. Si c'est un projet open source, cela peut ne pas être un problème.
Si ce développeur est vraiment brillant et que leur code est meilleur/plus intelligent/plus important que le reste de l'équipe combinée, il vaut la peine de lui faire votre problème au lieu de leur problème. Sinon, ce n'est pas le cas.
Pour répondre à la question littérale: le Le meilleur La façon de traiter ce type de situation est de ne pas se mettre dans ce type de situation.
Quels moyens pouvons-nous éviter les succursales d'obtenir un très grand nombre de commits de Maître à l'avenir?
Assurez-vous que tout le monde remarque que le développeur qui est allé pendant des mois sans fusion est de devoir résoudre le problème qu'ils ont 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 tirer du maître pour rester au courant des changements d'autres personnes.
"Si vous fusionnez chaque jour, vous n'allez jamais au point où vous avez d'énormes conflits difficiles à résoudre." --Linus Torvalds
Cette citation provient d'une conversation qu'il a donnée sur Google, voici la transcription , et voici la vidéo .
Si vous avez un engagement que vous connaissez cela et que tous les commentations précédents sont bien testés et devraient être fusionnés, puis simplement brancher de cette dernière bonne commission et fusionner la nouvelle branche avec Master.
Si vous avez des engagements que vous souhaitez fusionner, mais ils sont entrecoupés d'autres engagements qui ne sont pas prêts à la production, puis je vois 2 possibilités:
- Créez une nouvelle succursale, et Cherry Choisissez de bons commits, fusionner avec Maître.
- Essayez de rebaisser indésirable commet le sommet (peut-être sur une nouvelle branche juste pour être en sécurité).
En ce qui concerne les méthodes de prévention, essayez de définir des règles d'équipe amusantes comme "une qui ne fusionne pas avec Maître dans une semaine, commandera une pizza pendant un mois".
Voici une solution simple.
Suivez les caractéristiques que cette personne a mis en œuvre et accédez à chaque commit sur cette branche mise à jour par fonction. Prenez cela commettre et fusionnez-le avec le Master Repo.
Permettez-moi de casser cela sous la forme d'un exemple.
> Let: Branch A be the branch from the master
> Branch A+ = Branch A + new feature 1
> Branch A++ = Branch A + new feature 2
> and so on and so forth
>
> What you need to do is to go back to: Branch A+
>
> Take Branch A+ and merge it with Master.
>
> Now go to Branch A++ and merge it with (Master + Branch A+).
>
> Repeat until you've reached the final Branch A+...+ that is stable.
Cette méthode peut sembler contre-intuitive au début, mais si vous fusionnez chaque nouvelle fonctionnalité séparée par elle-même avec le maître, il devient facile de faire cycle entre la branche principale " par addition fonctionnalité "
Quels moyens pouvons-nous éviter les succursales d'obtenir un très grand nombre de commits de Maître à l'avenir?
Je pense que ma solution ci-dessus indique quelle méthode future vous devriez adopter. Allez avec une fonctionnalité ou par méthode de tâche pour chaque branche.
Je suggérerais d'utiliser une approche de:
pré-maître et maître
master: niveau final/production. Est modifié pas souvent. Est considéré comme toujours stable
pré-maître: la zone où une nouvelle fonctionnalité est ajoutée au code existant. Est essentiellement testé pour travailler avec la base de code existante et est l'endroit où d'autres branches peuvent faire une fourchette pour une nouvelle implémentation de fonctionnalités.
Vous devriez également essayer de grouper les fonctionnalités et visant la visibilité de la version.
Version-ciblage: Spécifiez un nombre arbitraire qui agira comme un espace réservé pour la branche principale. "En V1.0.0, nous voudrons atteindre des fonctionnalités X, Y, Z. V1.0.0 aura également toutes ces fonctionnalités disponibles: ..."
En maintenant une version contre Master, il peut également être un moyen de garder "maître" stables et prêts à la production en tout temps.
Tout d'abord, voir s'il y a vraiment des engagements distincts qui peuvent être fusionnés ou choisi des cerises, comme suggérer par @maciej Chalpuk. Si tel est le cas, la situation n'est vraiment pas si mauvaise et je ne m'inquiéterais pas trop à l'avenir.
Toutefois, si la situation réelle est que plusieurs fonctionnalités ont été développées simultanément dans une seule branche, dans les mêmes engagements, il devient alors une douleur beaucoup plus importante à traiter. Heureusement, la méthode de prévention est intégrée: exiger que le développeur séparait les modifications de chaque fonctionnalité dans des branches distinctes et tirez des demandes avant de les fusionner. Vous obtiendrez tous les deux vos fonts atomiques, ainsi que de dissuader ce développeur de le faire l'avenir.
Le processus réel de séparation des caractéristiques est entièrement manuel. Créez de nouvelles branches hors de la maîtrise et copiez les modifications de la succursale de Mega qui y sont liées. Compilez, testez la fonctionnalité, appuyez et émettez une requête de traction. Les changements de code sont mélangés, plus il sera facile de faire. S'il piratait une seule méthode pour toutes, bien, amusez-vous. Il ne le fera plus.
Fixer le problème de la grande demande de traction est une chose et il y a de bonnes réponses à ce sujet. Mais comme pour traiter des succursales qui deviennent débuts loin, vous voudrez peut-être revisiter vos processus pour faire face aux travaux d'équipe.
Si vous travaillez dans un cadre agile ou Scrum, l'équipe devrait vraiment demander pourquoi la fonctionnalité n'a pas été complétée et fusionnée dans le cadre de l'itération/Sprint. Si c'était "trop gros" pour tenir dans une itération, il aurait dû être divisé en petits morceaux.
Cela soulève également une question de propriété de code - au sein de votre équipe, les développeurs individuels possèdent-ils leurs propres travaux séparément, ou l'équipe complète travaille-t-elle ensemble pour s'assurer que les points faits?
Bien sûr, ce qui précède suppose que votre équipe se situe dans une sorte de structure de l'entreprise. S'il s'agit d'un projet open-source avec des contributeurs bénévoles, c'est une autre histoire. Généralement, de tels projets ont un contrôle plus souple sur les flux de travail, mais l'ONUS pour générer des demandes de pull acceptables tombe plus souvent sur les contributeurs individuels.
À bien des égards, cela devient une question de processus. Peut-être que votre processus nécessaire inclut la vérification périodiquement (hebdomadaire? Mensuel?) Pour des branches longues et non méritées. Certains outils rendent cela simple à vérifier visuellement; par exemple. Sur GitHub, visitez le lien "Branches" et montre à quel point l'avance/derrière chaque branche est.