Comment gérer le développement simultané avec Mercurial?

StackOverflow https://stackoverflow.com/questions/3719019

Question

Ceci est une meilleure question de la pratique, et je pense que la réponse soit « ça dépend ». J'espère juste pour apprendre les scénarios du monde plus réel et les flux de travail.

Tout d'abord, je parle de changements différents pour le même projet, donc pas subrepo s'il vous plaît.

Soit s que vous avez votre base de code dans un dépôt hg. Vous commencez à travailler sur une nouvelle fonctionnalité A, un bug compliqué B est rapporté par votre testeur de confiance (vous testeurs, non?) Compliqué.

Il est trivial si (le correctif pour) B dépend A. Vous simlply ci A alors B ci.

Ma question est de savoir quoi faire quand ils sont indépendants (ou il semble maintenant au moins).

Je peux penser à des façons suivantes:

  1. Utilisez un clone séparé B.
  2. Utilisez anonymes ou branches nommées, ou signets, dans le même référentiel.
  3. Utilisation MQ (avec patch B au-dessus de A).
  4. Utiliser ramifié MQ (je vous expliquerai plus tard).
  5. Utilisation multiple MQ (depuis 1.6)

1 et 2 sont couverts par un excellent un blog par Losh @ Steve liés d'un question légèrement liée.

L'un énorme avantage de 1 sur les autres choix est qu'il ne nécessite pas de reconstruction lorsque vous passez de travailler sur une chose à l'autre, car les fichiers sont physiquement séparés et indépendants. Donc, il est vraiment le seul choix si, par exemple, A et / ou B touche un fichier d'en-tête qui définit une valeur booléenne tri-état et est inclus par des milliers de fichiers C (ne me vous avez pas vu dit pas un tel code existant base).

3 est probablement le plus facile (en termes de configuration et les frais généraux), et vous pouvez retourner l'ordre de A et B si B est un petit et / ou solution d'urgence. Cependant, il peut se compliquer si A et B touche le même fichier (s). Il est facile de gros morceaux de patch correctif qui a échoué à appliquer si les modifications A et B sont orthogonaux dans le même fichier (s), mais sur le plan conceptuel, il est encore un peu risqué.

4 peut vous faire tourner la tête, mais il est le moyen le plus puissant et flexible et évolutive. Je default hg qinit avec -c puisque je veux marque patches travail en cours et pousser / les tirer, mais il ne faut un saut conceptuel pour réaliser que vous pouvez faire une branche dans MQ repo aussi. Voici les étapes (mq = hg --mq):

  1. hg qnew bugA; apporter des modifications pour A; hg qref
  2. mq branch branchA; hg qci
  3. hg qpop; mq up -rtip^
  4. hg qnew bugB; apporter des modifications pour B; hg qref
  5. mq branch branchB; hg qci
  6. Pour travailler sur un nouveau: hg qpop; mq up branchA; hg qpush

Il semble fou de prendre autant d'étapes, et chaque fois que vous devez travailler interrupteur vous devez hg qci; hg qpop; mq up <branch>; hg qpush. Mais considérez ceci: vous avez plusieurs branches de libération nommées dans le même référentiel, et vous avez besoin de travailler sur plusieurs projets et corrections de bugs en même temps pour tous (vous feriez mieux d'obtenir un bonus garanti pour ce genre de travail). Vous me perdrais bientôt avec les autres approches.

Maintenant, mes collègues amateurs de hg, y at-il d'autres / meilleures alternatives?

(UPDATE) qqueue fait presque # 4 obsolète. Description élégante Voir Steve Losh

Était-ce utile?

La solution 2

Il semble que il n'y a pas de choix plus ou mieux que ceux que j'énumérés dans la question. Donc, ici, ils sont à nouveau.

  1. Utiliser un clone par projet.
    • Avantages:. Séparation totale, donc pas de reconstruction lors de la commutation des projets
    • Inconvénients:. Besoins toolchain pour basculer entre les deux clones
  2. Utilisez anonyme ou branches nommées ou signets, dans le même référentiel.
    • Avantages: hg standard (ou tout DVCS) la pratique; propre et clair.
    • Inconvénients:. Doit engager avant de changer et reconstruire après
  3. Utilisation MQ avec un patch (ou plusieurs patchs consécutifs) par projet.
    • Plus:. Simple et facile
    • Inconvénients: doit qrefresh avant commutation et reconstruire après; délicate et risquée si les projets ne sont pas orthogonaux.
  4. Utiliser une branche MQ (ou qqueue dans 1.6+) par projet.
    • Pour: ultra flexible et extensible (pour le nombre de projets simultanés)
    • Inconvénients: doit qrefresh et qcommit avant commutation et la reconstruction après; se sent compliqué.

Comme toujours, il n'y a pas de solution miracle, alors choisissez et choisir le bon pour le travail.

(UPDATE) Pour toute personne qui est en amour avec MQ, en utilisant MQ au-dessus des branches régulières (# 2 + # 3) est probablement la plus courante et la pratique préférable.

Si vous avez deux projets simultanés avec base sur les deux branches (par exemple prochaine version et version actuelle), il est trivial de sauter entre eux comme ceci: 

hg qnew; {coding}; hg qrefresh; {repeat}
hg qfinish -a
hg update -r <branch/bookmark/rev>
hg qimport -r <rev>; {repeat}

Pour la dernière étape, qimport devrait ajouter une option de -a importer une ligne de changesets à la fois. J'espère que Meister Geisler remarque ceci:)

Autres conseils

Je toujours utiliser des branches nommées, parce que permet Mercurial faire son travail: garder votre historique du projet, et de se rappeler pourquoi vous avez fait ce qui change dans quel ordre votre code source. Que ce soit d'avoir un clone ou deux assis sur votre disque est généralement facile, compte tenu de mon style de travail, au moins:

  1. Votre projet manque un processus de construction, de sorte que vous pouvez tester et exécuter les choses à partir du code source? Ensuite, je serai tenté d'avoir un seul clone, et le dos de hg up-et-vient quand je dois travailler sur une autre branche.

  2. Mais si vous avez un buildout, virtualenv ou toute autre structure qui se construit, et qui divergent de force entre les deux branches, puis en faisant un hg up puis d'attendre le processus de construction de relancer peut être une grande douleur , surtout si des choses comme la création d'une base de données exemple sont impliqués. Dans ce cas, je serais certainement utiliser deux clones, celui qui était assis à la pointe du tronc, et celui qui était assis à l'extrémité de la branche fonction d'urgence.

La question est donc, au moment où on vous dit d'arrêter de travailler sur une fonction, et commencer fonction B indépendante, quelles sont les options alternatives sont là pour: Comment gérer le développement simultané avec Mercurial

Let regard sur le problème avec la concurrence enlevé, de la même manière que vous écrivez filetée code- définissent simple flux de travail pour résoudre un problème donné pour vous, et l'appliquer à chaque problème. Mercurial se joindra au travail, une fois qu'il est fait. Donc, programmeur A travaillera sur A. Programmer fonction B fonctionne sur la caractéristique B. Les deux juste arriver à être vous. (Si seulement nous avions des cerveaux multi-core:)

  

Je toujours utiliser des branches nommées, parce que permet Mercurial faire son travail: garder votre historique du projet, et de se rappeler pourquoi vous avez fait ce qui change dans quel ordre votre code source.

Je suis d'accord avec le sentiment de Brandon, mais je me demande s'il négligé cette fonction A n'a pas été testé? Dans le pire des cas, le code compile et passe des tests unitaires, mais certaines méthodes à mettre en œuvre les exigences précédentes, et des méthodes à mettre en œuvre les nouvelles. diff contre la précédente check-in est l'outil que j'utiliserait pour me aider à obtenir sur la bonne voie avec fonction A.

Votre code pour la fonction A à un moment où vous le feriez normalement vérifier dans? Passage de fonction A à travailler sur la caractéristique B est pas une raison de commettre un code à la tête ou à une branche . vérifier uniquement dans le code qui compile et passe vos tests. Ma raison est, si programmeur a besoin de C pour commencer fonction C, une caisse fraîche de cette branche n'est plus le meilleur endroit pour commencer. Garder votre tête de la branche santé, des moyens que vous pouvez répondre rapidement, plus fiable corrections de bugs.

Le but est d'avoir votre (testé et vérifié) l'exécution de code, si vous voulez tout votre code pour finir par fusion dans la tête (de vos branches de développement et de l'héritage). Mon point semble être, je l'ai vu utilisé inefficacement ramification: le code est périmé et non utilisé, la fusion devient plus dur que le problème d'origine.

Seulement votre option 1 est logique pour moi. En général:

  1. Vous devriez penser à votre code fonctionne, avant que quelqu'un d'autre le voit.
  2. Favor la tête sur une branche.
  3. Direction générale et l'enregistrement si quelqu'un d'autre est ramasser le problème.
  4. Direction générale si votre système automatisé ou testeurs ont besoin de votre code uniquement.
  5. Direction si vous faites partie d'une équipe, travaillant sur un problème. Considérez-la tête, voir 1-4.

A l'exception des fichiers de configuration, les processus de construction devrait être une caisse et une seule commande de construction. Il ne devrait pas être plus difficile de passer entre les clones, que pour un nouveau programmeur pour se joindre au projet. (Je reconnais que mon projet a besoin d'un peu de travail ici.)

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top