Bon workflow git régime avec plusieurs développeurs travaillent sur la même tâche
Je suis chef d'équipe dans notre société de développement web, et j'aimerais mettre en œuvre un workflow Git dans notre équipe. La lecture de la documentation et des articles que j'ai trouvé la structure suivante bons pour nous:
Nous avons un référentiel dans un Bitbucket. Maître branche est considérée comme contenant stable de code seulement. Tous les dev doit créer sa propre branche et de mettre en œuvre des fonctionnalités et des corrections de bugs dans son propre branche. Une fois qu'il décide, que son code est prêt, il crée une belle histoire de la branche (à l'aide de rebase, de modification, de cherry-pick etc.) et il pousse à Bitbucket, où se crée un pull request à la branche principale. QA vérifie la fonctionnalité et approuve (ou désapprouve), alors je suis la vérification de code et si c'est ok, je fusionne son travail en master (en avance rapide ou complet pour mieux s'engage histoire).
Mais ce schéma n'est bon que dans un cas, lors de l'unique développeur travaille sur une branche. Dans notre cas, nous avons presque toujours les deux développeurs pour une branche, depuis un développeur travaille sur côté serveur (PHP), et l'autre - côté client (HTML/CSS/JS). Comment ces deux devraient collaborer de manière à ce que s'engager de l'histoire en maître reste propre?
Serveur de dev crée la structure de base des fichiers HTML et un client dev besoins pour obtenir cette structure. Logiquement, serait pour le serveur de dev, pour créer une branche, et pour le client dev de créer sa propre filiale, basée sur le serveur de dev de la branche. Mais cela signifie que le serveur de dev doit publier sa branche dans Bitbucket, ce qui va la faire impossible pour lui de rebase ou changement s'engage, qui sont déjà publiés.
Une autre option est d'attendre, jusqu'à ce que le serveur de dev a terminé son travail, publie branche de nice s'engage histoire et oublie, et seulement après que le client dev commence à travailler dans cette branche, mais cela va entraîner des temps de retard, ce qui est encore pire.
Comment voulez-vous gérer une telle collaboration dans votre flux de travail?
- Il n'est pas nécessaire pour le serveur développeur de publier dans Bitbucket. Il peut "publier" dans d'autres façons, et le client dev peut tirer de l'autre endroit. (Ils ont peut-e-mail bundles uns des autres, ou tirer directement, ou utiliser un autre serveur commun...) Vous avez toujours des problèmes avec un rebase, mais il est maintenant limité à 2 développeurs.
- oui, cela peut être une option, que je pensais aussi, mais je ne voulais pas impliquer 3ème du côté des solutions, comme l'emailing, la commune de serveur ou quoi que ce soit. Direct tirant nous semble préférable de moyens, mais peut compliquer client-dev, car il aura besoin de tirer de Bitbucket et tous les serveurs de devs, il travaille avec l' - il y aura un gâchis avec toutes les télécommandes. Merci pour un conseil!
- "ce qui sera impossible pour lui de rebase ou changement s'engage" pourquoi est-ce? Votre SCM ne doit pas être l'application de ces règles sur les personnels des branches. Changer votre SCM de sorte que seuls les
master
est protégée contre les réécrit.
Vous devez vous connecter pour publier un commentaire.
Je ne peux pas vraiment parler pour le bien-fondé des méthodes décrites dans votre post, mais je peux décrire comment nous avons résolu de collaboration de codage dans le flux de travail que nous utilisons au travail.
Le flux de travail que nous utilisons est l'une des nombreuses branches. Notre structure est donc:
Maître est d'or; seulement la fusion maître de la touche (plus à ce sujet dans un peu).
Il y a une branche dev, prise d'abord par le maître, que tous les devs de travail hors de. Au lieu d'avoir une branche par développeur, nous faisons une fonctionnalité ou un billet, les branches de dev.
Pour chaque discret fonctionnalité (bug, amélioration, etc.), une nouvelle branche locale est fabriqué à partir de dev. Les développeurs n'ont pas à travailler sur la même branche, puisque chaque branche est portée à ce que seul le développeur travaille sur. C'est là que git est pas cher ramification est très pratique.
Une fois que la fonction est prêt, il est fusionné localement retour en dev et vers le cloud (Bitbucket, Github, etc.). Tout le monde conserve la synchronisation de la machine en tirant sur le dev souvent.
Nous sommes, une semaine, un calendrier de sortie, de sorte que chaque semaine, après l'assurance qualité a approuvé la branche dev, une branche de version est faite avec la date dans le nom. Qui est utilisé par la direction générale de la production, en remplacement de la semaine dernière version de la branche.
Une fois que la branche de version est vérifiée par l'assurance qualité en production, la libération de la branche est fusionnée en master (et dev, juste pour être sûr). C'est la seule fois que nous touchons maître, en s'assurant qu'il est aussi propre que possible.
Cela fonctionne bien pour nous avec une équipe de 12. J'espère que ça a été utile. Bonne chance!
git format-patch
). C'est le flux de travail drupal.org les utilisations.MY-PROJECT-13: message
, juste comme vous êtes en train de suggérer. L'ajouter au début du titre a l'avantage supplémentaire que le Jira Git plugin prend le nom de ticket et ayants droit de la validation du ticket dans Jira (il est sensible à la casse, tout de même).Je pense encore personne n'a réellement répondu à la question d'origine de la façon de collaborer dans le topic des branches maintien d'un propre histoire.
La bonne réponse est désolé, vous ne pouvez pas avoir tout ça ensemble. Vous ne pouvez toiletter votre privé d'histoire locale, après que vous publiez quelque chose pour les autres, vous devez travailler sur le dessus de cela.
Le meilleur que vous pourriez faire dans votre cas particulier où le serveur de dev ne se soucie pas de client dev changements est localement fourche client branches de dev/fonctionnalité et rebase la partie sur le dessus de travail de serveur juste avant la fin de la fonction —ou vous détendre vos contraintes et de passer à un autre flux de travail, comme vous l'avez fait 😉
Nous avons l'un des principaux référentiel et chaque développeur a une fourchette de que.
Une branche est créée principal/some_project, le même nom de la branche est alors créé sur chacun des développeurs de fourche, fourche/some_project.
(Nous utilisons smartgit et nous avons aussi une politique de télécommandes sont nommés "principales" et "fork" plutôt que "d'origine" et "en amont" qui vient de confondre les nouveaux utilisateurs).
Chaque développeur dispose également d'une succursale locale nommée some_project.
Les développeurs branche locale some_project pistes de la télécommande de la branche principale/some_project.
Développeurs de faire leur travail local sur la branche some_project et pousser à leur fourche/some_project, de temps à autre, ils créent des pull requests, c'est la façon dont chaque travail du développeur est fusionné en principal/some_project.
De cette façon, les développeurs sont libres de tirer/rebase localement et de les pousser à leurs fourches - c'est à peu près la norme de la fourche de flux de travail. De cette façon, ils obtiennent d'autres développeurs s'engage et peut, de temps à autre pour résoudre l'étrange conflit.
C'est très bien et tout ce qui est nécessaire maintenant est un moyen de fusionner dans les mises à jour constantes qui apparaissent dans principal/maître (par exemple urgent de bugs ou d'autres projets qui sont livrés avant some_project est fini).
- À-vis de ce que nous désigner une "branche de plomb" leur rôle est localement de fusion des mises à jour à partir de maître en some_project à l'aide de fusion (tirez pas, rebase) dans SmartGit. Cela aussi peut parfois générer des conflits et ceux-ci doivent être résolus. Une fois ceci fait que développeur (direction générale de plomb) force pousse à leur fourche/some_project branche puis crée une demande d'extraction de la fusion principale/some_project.
Une fois que la demande d'extraction est fusionné, tous les nouveaux commits qui ont été sur principal/master sont maintenant présent sur les principaux/some_project branche (et rien n'a été relocalisée).
Donc la prochaine fois que chaque développeur est sur some_project et tire (rappel, leur suivi branche principale/some_project) ils vont obtenir toutes les mises à jour qui comprendra les choses fusionnées à partir de directeur/master.
Cela peut sembler longue haleine mais c'est en fait assez simple et robuste (chaque développeur peut également intégrer localement, à partir d'principal/maître, mais il est plus net si une personne le fait, le reste de l'équipe vivons dans un monde simple comme l'unique développeur du flux de travail).
Cela dépend de votre public. "Serveur de dev" peut pousser la "structure de base" à Bitbucket de sorte que le "client dev" auront accès. Oui ce n'potentiellement dire que d'autres auront accès à ces "temporaire" s'engage.
Cependant, ce ne serait un problème si un autre utilisateur ramifiée à partir de l'un de ces s'engage avant ils ont été relocalisée. Sur un projet plus petit/plus petite userbase temporairement ces livraisons pourraient ne jamais être remarqué avant même que cela s'est produit, donc de nier le risque.
La décision est la vôtre, si le risque que quelqu'un ramification de ces temporaire s'engage est trop grande. Si oui, alors vous devrez peut-être créer un deuxième privé Bitbucket repo pour ces changements. Une autre option serait de faire fusionner commet
au lieu de relocalisation, mais ce n'est pas non plus idéal.
Vous pouvez voir Git-flow cela peut vous aider à
http://nvie.com/posts/a-successful-git-branching-model/
Pour la question exacte, plusieurs développeurs sur la même tâche, la réponse courte est la tâche est effectuée dans une direction de l'intégration de cette tâche. Que la "tâche" de la branche est traitée comme "maître" ou "dev" branches dans l'habitude Git flux de travail (comme la plupart ici les réponses fournies). Cette direction de l'intégration est traitée dans le "Git Branche de Fonctionnalité de Flux de travail, élaborés ailleurs.
Cette tâche branche est l'endroit où les développeurs à travailler sur cette tâche, le partage de code utilisant les commandes Git.
Exemple
Pour développer le nouvel écran de démarrage, le développeur en chef (ou quelqu'un) ne
Chaque développeur qui travaille sur cette fonctionnalité: la fonctionnalité de
Maintenant chaque dev va se développer sur leur branche et de créer des pull requests vers fusionne sur la fonctionnalité des éclaboussures sur la centrale de repo Git serveur comme GitHub. Tout comme cela est fait pour la sacro-sainte "maître" de la branche.
Lorsque la fonction est fait, la fonctionnalité-splash est fusionné en maître. Bien sûr, cette fonctionnalité éclaboussures doivent être tenus à jour avec les nouveaux code de maître. Pourrait la fonctionnalité des éclaboussures d'utilisation complet sur le master?
Ce n'est pas mon idée de départ. J'ai lu à ce sujet dans les divers lieux. Notez que dans de nombreux flux de travail les articles de cette tâche spécifique de la branche n'est pas vraiment un concept. Par exemple, dans un article, nous avons des "branches existent généralement dans les développeur de repos seulement, pas d'origine." Peut-être une tâche qui nécessite plus d'un développeur est toujours décomposée en sous-tâches? Je suppose que si vous savez l'avenir et savoir ce qui est requis.
Permettez-moi de vous dire ce que nous faisons ici, alors que plusieurs développeurs travaillent sur le même projet (même parfois de travailler sur les mêmes contrôleurs/modèles/vues).
Tout d'abord notre équipe-conduire créé git-projet avec les deux branches
Ils nous a dit de travailler sur notre environnement local et de créer engage à chaque fois que nous avons terminé l'une des tâche(s).
Maintenant dans le soir (ou de dire l'heure de fermeture - sortie), nous le faisons :
À tous les développeurs qui travaillent sur le même projet Tirez actuelle de la direction du développement de leur localité (ne même le matin - lors du démarrage de la journée).
Alors l'équipe de plomb dit développeur de commettre tous les codes et les repousser un par un, suivie d'une extraction.
Pour ex.
Maintenant le problème des conflits :
Maintenant comment fusionner manuellement : GIT simplement les mises à jour de conflits de fichiers avec tout le contenu comme ceci :
Équipe-conduire les mises à jour de ce fichier après l'analyse de ce :
et crée un commit et push.
De nouveau dans la matinée, nous faisons tirer (juste pour s'assurer que nous n'avons rien manquer de la journée précédente), C'est la façon dont nous travaillons ici.
Les règles à retenir sont:
master
et 1develop
branchedevelop
branchedevelop
develop
branchedevelop
master
, et de créer une balise pour qu'ilDiagramme suivant est l'œil du taureau stratégie suivie sur des équipes à travers le monde (Crédit: prises de ici):