Quels modèles branlants vous conviennent?

notre société utilise actuellement un modèle de branchement simple tronc/release/hotfixes et voudrait des conseils sur les modèles de branchement qui fonctionnent le mieux pour votre entreprise ou votre processus de développement.

  1. les flux de travail / modèles de ramifications

    ci-dessous sont les trois principales descriptions de ce que j'ai vu, mais ils sont partiellement en contradiction les uns avec les autres ou ne vont pas assez loin pour régler les questions suivantes que nous avons exécuter (comme décrit ci-dessous). Ainsi notre équipe jusqu'à présent par défaut à des solutions pas si grandes. Faites-vous quelque chose de mieux?

  2. Fusion vs rebasage (tangled vs histoire séquentielle)

    devrait - on pull --rebase ou attendre avec la fusion de nouveau à la ligne principale jusqu'à ce que votre tâche est terminée? Personnellement je penche vers la fusion car cela préserve une illustration visuelle de la base sur laquelle une tâche a été commencée et terminée, et je préfère même merge --no-ff à cette fin. Elle présente toutefois d'autres inconvénients. Aussi beaucoup n'ont pas réalisé la propriété utile de la fusion - qu'il n'est pas commutative (fusionner une branche thématique en master ne signifie pas fusionner master en la branche thématique).

  3. je cherche un flux de travail naturel

    parfois des erreurs se produisent parce que nos procédures ne saisissent pas une situation spécifique avec des règles simples. Par exemple, une correction nécessaire pour les rejets antérieurs devrait naturellement être basée suffisamment en aval pour pouvoir être fusionnée en amont dans toutes les branches. nécessaire (l'usage de ces termes est-il suffisamment clair?). Toutefois, il se trouve qu'une correction le fait dans le maître avant que le développeur réalise qu'il aurait dû être placé plus en aval, et si cela est déjà poussé (pire encore, fusionné ou quelque chose basé sur elle) alors l'option restante est la cueillette de cerises, avec ses périls associés. Quelles règles simples comme tels utilisez-vous? également dans ce est inclus la maladresse d'un sujet branche nécessairement à l'exclusion d'autres branches du sujet (en supposant qu'ils soient ramifiés à partir d'une base commune). Les développeurs ne veulent pas finir une fonctionnalité pour en lancer une autre qui se sent comme le code qu'ils viennent d'écrire n'est plus là

  4. Comment éviter de créer des conflits de fusion (due à cherry-pick)?

    ce qui semble comme une façon sûre de créer un conflit de fusion est de choisir entre les branches, elles ne peuvent jamais être fusionnées à nouveau? Serait l'application de la même s'engager dans revenir (comment faire?) dans l'une ou l'autre branche peut-être résoudre cette situation? C'est une des raisons pour lesquelles je n'ose pas insister pour un workflow largement basé sur les fusions.

  5. comment se décomposer en branches topiques?

    nous réalisons qu'il serait génial d'assembler une intégration terminée à partir de branches de sujet, mais souvent le travail de nos développeurs n'est pas clairement défini (parfois aussi simple que " poking autour de") et si un code est déjà entré dans un sujet" Divers", il ne peut pas être sorti de là à nouveau, selon la question ci-dessus? Comment définissez-vous/approuvez/diplômez/Libérez-vous vos branches thématiques?

  6. des procédures appropriées comme la révision du code et l'obtention du diplôme seraient bien sûr adorables.

    mais nous ne pouvons tout simplement pas garder les choses assez démêlés pour gérer cela - des suggestions? intégration les branches, les illustrations?

ci-dessous se trouve une liste de questions connexes:

vérifiez aussi ce que Plastic SCM écrit sur développement piloté par la tâche , et si le plastique n'est pas votre choix, étudiez modèle de branchement de nvie et son scripts de soutien .

354
demandé sur Community 2010-04-12 15:23:43
la source

4 ответов

la caractéristique la plus troublante que les nouveaux développeurs de DVCS doivent réaliser est sur le processus de publication :

  • vous pouvez importer (fetch/pull) quelle que soit la distance repo-vous besoin d'une 151970920"
  • , vous pouvez publier (push) pour tout (nu) pensions de titres que vous voulez

de là, vous pouvez respecter quelques règles pour faciliter vos questions:

  • rebase une branche seulement si elle n'a pas été poussé (pas poussé depuis le dernier rebase)
  • seulement pousser à une simple mise en pension (obligatoire depuis Git1.7)
  • suivre Linus conseils sur rebase et fusionne

Maintenant:

flux de travail / modèles de ramifications :

chaque flux de travail est là pour soutenir un processus de gestion de version , et qui est adapté pour chaque projet.

Ce que je peux ajouter au workflow que vous mentionnez est: chaque développeur ne devrait pas créer une branche de fonctionnalité, seulement une branche "current dev", parce que la vérité est: le développeur ne sait souvent pas exactement ce que sa/sa branche va produire: une fonctionnalité, plusieurs (parce que cela a fini par être une fonctionnalité trop complexe), aucune (parce que pas prêt à temps pour la publication), une autre fonctionnalité (parce que l'original avait "morphed"),...

seul un" intégrateur " devrait les branches des fonctionnalités officielles établies sur un repo "central", qui peuvent ensuite être récupérées par les développeurs pour rebaser/fusionner la partie de leur travail qui correspond à cette fonctionnalité.

Fusion vs rebasage (tangled vs histoire séquentielle) :

j'aime ma réponse vous mentionnez (" Flux de travail description de l'utilisation de git pour le développement en interne ")

je cherche un flux de travail naturel :

pour les correctifs, cela peut aider à associer chaque correctif à un ticket d'un suivi de bogue, ce qui aide le développeur à se rappeler où (c'est-à-dire sur quelle branche, c'est-à-dire une branche dédiée "pour les correctifs") il devrait commettre de telles modifications.

Puis hooks peut aider à protéger un repo central contre les poussées de bugs non-validés ou de branches à partir desquelles on ne devrait pas pousser. (pas de solution spécifique ici, tout cela doit être adapté à votre de l'environnement)

Comment éviter de créer des conflits de fusion (en raison de cherry-pick)?

comme indiqué par Jakub Narębski dans sa réponse , la cueillette de cerises devrait être réservée aux situations rares où elle est nécessaire.

Si votre configuration implique beaucoup de choix (i.e. "ce n'est pas rare"), alors quelque chose ne va pas.

Serait d'appliquer la même livraison en revenir (comment faire?)

git revert on devrait s'en occuper, mais ce n'est pas l'idéal.

comment se décomposer en branches topiques?

aussi longtemps qu'une branche n'a pas encore été poussée partout, un développeur devrait réorganiser son histoire d'engage (une fois qu'il/elle voit enfin le développement prend une forme plus définitive et stable) en:

  • plusieurs branches si nécessaire (une par une caractéristique clairement identifiée)
  • un ensemble cohérent de commits à l'intérieur d'une branche (voir parage Git Checkins )

procédures appropriées comme la révision du code et l'obtention du diplôme ?

branches D'intégration (dans une intégration dédiée) repo peut aider le développeur à:

  • rebase son développement sur le dessus de cette distance direction de l'intégration (pull --rebase)
  • résoudre localement
  • pousser le développement à celui des pensions de
  • vérifier avec l'intégrateur qu'il n'y a pas de désordre;)
85
répondu VonC 2017-05-23 15:25:30
la source

je pense, et je pourrais me tromper, que l'une des choses qui est le plus mal comprise au sujet de gitan est sa nature distribuée. Cela fait qu'il est très différent de dire subversion dans les façons dont vous pouvez travailler, bien que vous puissiez imiter SVN behaviour si vous le souhaitez. Le problème est à peu près n'importe quel flux de travail fera, ce qui est grand, mais aussi trompeur.

si j'ai bien compris le développement du noyau (je me concentrerai là-dessus), chacun a son propre dépôt git pour le développement du noyau. Il y a un dépôt, linux-2.6.git, pris en charge par Torvalds, qui agit comme le référentiel de publication. Les gens clonent d'ici s'ils veulent commencer à développer une fonctionnalité contre la branche "release".

D'autres dépôts font du développement. L'idée est de cloner à partir de linux-2.6, se ramifier autant de fois que vous le souhaitez jusqu'à ce qu'un tel point que vous avez un travail "nouvelle" fonctionnalité. Ensuite, lorsque cela est prêt, vous pouvez le mettre à la disposition de quelqu'un considéré de confiance, qui va tirer cette branche de votre dépôt dans le leur et la fusionner dans le mainstream. Dans le noyau linux, cela se produit à plusieurs niveaux (lieutenants de confiance) jusqu'à ce qu'il atteigne linux-2.6.git à quel point il devient le "noyau".

voilà où ça devient confus. Les noms des succursales n'ont pas besoin d'être uniformes d'un dépôt à l'autre. Donc je peux git pull origin master:vanilla-code et obtenir une branche du maître du origin dans une branche dans mon dépôt appelé vanilla-code . Pour autant que je sache ce qui se passe, cela n'a pas vraiment d'importance - il est distribué dans le sens où tous les dépôts sont des pairs les uns des autres et pas seulement partagés entre plusieurs ordinateurs comme SVN.

Donc, avec tout cela à l'esprit:

  1. je pense que c'est à chaque programmeur comment ils font leur ramification. Tout ce dont vous avez besoin est un dépôt central pour gérer les versions, etc. Le coffre pourrait être head . Les rejets pourraient être des étiquettes ou les branches et les "hotfixes" sont probablement des branches en elles-mêmes. En fait, je ferais probablement des releases en tant que branches pour que vous puissiez continuer à les réparer.
  2. Je fusionnerais et pas rebasé. Si par exemple vous prenez un dépôt, le cloner, une branche et faire un dev, puis tirer de votre origin vous devriez, dans votre dépôt, probablement faire une autre branche et fusionner le dernier master dans yourbranch de sorte que quelqu'un d'autre peut tirer vos modifications avec le moins d'effort possible. Y est très rarement un besoin de vraiment rebaser, d'après mon expérience.
  3. je pense que c'est une question de comprendre la façon dont Git fonctionne et ce qu'il peut faire. Cela prend un certain temps et beaucoup de bonne communication - je n'ai vraiment commencé à comprendre ce qui se passait quand j'ai commencé à utiliser git avec d'autres développeurs et même maintenant, certaines choses dont je ne suis pas sûr.
  4. Les conflits de fusion
  5. sont utiles. Je sais, je sais, tu veux que tout fonctionne, mais le fait est que le code change et tu le fais. besoin de fusionner les résultats dans quelque chose qui fonctionne. Les conflits de fusion sont en fait juste plus de programmation. Je n'ai jamais trouvé d'explication facile pour ce qu'il faut faire à leur sujet, alors voici: notez les fichiers qui ont des conflits de fusion, allez les changer en ce qu'ils devraient être, git add . et ensuite git commit .
  6. comme bon vous semble. Comme je l'ai dit, chaque dépôt git des utilisateurs est leur propre pour jouer avec et les noms de branche n'ont pas besoin d'être les mêmes . Si vous avec un référentiel de mise en scène, par exemple, vous pouvez appliquer un schéma de nommage, mais vous n'en avez pas besoin pour chaque développeur, seulement dans le repo de publication.
  7. c'est l'étape de la fusion. Vous ne fusionnez avec les branches de publication, etc. que lorsque vous considérez que le code doit être revu / passer le test de qualité.

j'espère que ça aidera. Je me rends compte que VonC vient de poster une explication très similaire... Je ne peut pas taper assez vite!

Modifier quelques réflexions sur la façon d'utiliser git dans un cadre commercial, comme cela semble pertinent pour l'OP de commentaires:

  • le référentiel de version, nous l'appellerons product.git , est accessible par un certain nombre de programmeurs / techniciens supérieurs responsables de s'occuper réellement du produit lui-même. Ils sont analogues au rôle des responsables dans OSS.
  • ces programmeurs ont probablement aussi en partie conduit le développement de nouvelles versions, afin qu'ils puissent également se coder et maintenir des dépôts varios. Ils peuvent gérer des référentiels de mise en scène pour des fonctionnalités vraiment nouvelles et ils peuvent aussi avoir leurs propres référentiels.
  • ci-dessous, il y a des programmeurs responsables du développement de bits individuels. Par exemple, une personne peut être responsable de l'INTERFACE de travail. Ils ont donc à gérer l'INTERFACE utilisateur.le dépôt git.
  • en dessous d'eux sont les programmeurs réels qui développent les caractéristiques comme leur journée complète de travail de jour.

que se passe-t-il? Eh bien, tout le monde tire au début de chaque jour de la source "amont", c'est-à-dire le dépôt de diffusion (qui contiendra probablement aussi les dernières données des jours précédents). Tout le monde fait ça, directement. Cela ira sur une branche dans leur dépôt, probablement appelé " maître "ou peut-être si vous êtes moi appelé"dernier". Le programmeur fera alors un peu de travail. Ce travail pourrait être quelque chose qu'ils ne savent pas environ, donc ils font une branche, faire le travail. Si ça ne marche pas, ils peuvent supprimer la branche et revenir en arrière. Si c'est le cas, ils devront fusionner dans la branche principale sur laquelle ils travaillent actuellement. Nous dirons que c'est un programmeur D'UI travaillant sur latest-ui donc il fait git checkout latest-ui suivi de git merge abc-ui-mywhizzynewfeature . Il dit ensuite à son responsable technique (le responsable de L'interface utilisateur) Hé, j'ai terminé une telle tâche, tirez-moi. Donc L'interface utilisateur fait git pull user-repo lastest-ui:lastest-ui-suchafeature-abc . Le responsable de L'assurance-chômage l'examine ensuite sur cette branche et dit:, c'est très bien, je vais le fusionner en ui-latest . Il pourrait alors dire à tout le monde en dessous de lui de tirer de lui sur leurs ui-latest branches ou quel que soit le nom qu'ils leur ont donné, et donc le trait est exploré par les devs. Si l'équipe est satisfaite, le responsable de L'interface utilisateur peut demander au responsable des essais de lui retirer les modifications et de les fusionner. Cela se propage à tout le monde (en aval du changement) qui le teste et soumet des rapports de bogue, etc. Enfin, si la caractéristique passe les essais etc, l'un des conduit pourraient fusionner dans la copie de travail actuelle du programme, à quel point toutes les modifications sont ensuite propagées vers le bas. Et ainsi de suite.

ce n'est pas une façon" traditionnelle "de travailler et il est conçu pour être" dirigé par les pairs "plutôt que" hiérarchique " comme SVN/CVS. Essentiellement, tout le monde a accès à commit, mais seulement localement. C'est l'accès au référentiel et qui référentiel de vous désigner comme la libération repo qui vous permet d'utiliser la hiérarchie.

21
répondu 2010-04-12 17:28:28
la source

un modèle que j'ai utilisé avec de bons résultats est le suivant:

Un "béni" repo tout le monde pousse et tire vers/à partir, en gros client-serveur de topologie.

il n'y a pas de branche principale donc aucun développeur ne peut pousser n'importe quel code dans"mainline".

tous les développements se produisent sur les branches thématiques. Nous nommons des noms pour détecter facilement qui en est responsable: jn / newmeature ou JN / issue-1234

il y a aussi une cartographie de près de 1 à 1 entre les branches et les cartes kanban/scrum sur le tableau blanc.

pour libérer une branche il est poussé à la repo bénie et le kanban-card est déplacé pour prêt pour la révision.

alors, si la Direction générale est acceptée par l'examen, elle est candidate à une mainlevée.

une publication se produit lorsqu'un ensemble de branches acceptées sont fusionnées et étiquetées avec un numéro de version.

en poussant la nouvelle étiquette

9
répondu John Nilsson 2015-11-06 01:39:08
la source

personnellement, j'essaie de garder seulement le code prêt à être diffusé dans la branche principale.

quand je travaille sur une nouvelle fonctionnalité ou bugfix je le fais dans une branche. J'ai aussi des tests unitaires dans la branche. Si tout fonctionne bien, c'est seulement alors que je fusionne/rebase de nouveau dans le maître.

j'essaie d'utiliser des conventions de nommage de branches communes, telles que:

  • correction/recursive_loop
  • correction/sql_timeout
  • fonction/new_layout
  • fonction/enhanced_search
2
répondu xero 2015-11-06 01:36:43
la source

Autres questions sur git merge release workflow cherry-pick