Git push rejeté après le rebasage de la branche de fonctionnalité

OK, je pensais que c'était un simple scénario git, qu'est-ce qui me manque?

J'ai une mastersuccursale et une featuresuccursale. Je fais un peu de travail master, d'autres feature, puis d'autres encore master. Je me retrouve avec quelque chose comme ça (l'ordre lexicographique implique l'ordre des commits):

A--B--C------F--G  (master)
       \    
        D--E  (feature)

Je n'ai aucun problème à git push origin mastermaintenir la télécommande à masterjour, ni à git push origin feature(lorsqu'elle est activée feature) de maintenir une sauvegarde à distance pour mon featuretravail. Jusqu'à présent, nous sommes bons.

Mais maintenant, je veux rebaser featureau-dessus des F--Gcommits sur master, donc moi git checkout featureet git rebase master. Encore bon. Maintenant nous avons:

A--B--C------F--G  (master)
                 \
                  D'--E'  (feature)

Problème: au moment où je veux sauvegarder le nouveau featureramifié avec branchement git push origin feature, le push est rejeté car l'arborescence a changé en raison du rebasage. Cela ne peut être résolu qu'avec git push --force origin feature.

Je déteste utiliser --forcesans être sûr d'en avoir besoin. Alors, en ai-je besoin? Le rebasage implique- t-il nécessairement que le prochain pushsoit --forcecomplet?

Cette branche de fonctionnalité n'est partagée avec aucun autre développeur, donc je n'ai aucun problème de facto avec la poussée de force, je ne vais pas perdre de données, la question est plus conceptuelle.

Le problème est que cela git pushsuppose que la branche distante peut être rapidement transmise à votre branche locale, c'est-à-dire que toute la différence entre les branches locales et distantes réside dans le fait que local a de nouveaux validations à la fin comme ça:

Z--X--R         <- origin/some-branch (can be fast-forwarded to Y commit)
       \        
        T--Y    <- some-branch

Lorsque vous effectuez des git rebasevalidations, D et E sont appliqués à une nouvelle base et de nouvelles validations sont créées. Cela signifie qu'après rebase, vous avez quelque chose comme ça:

A--B--C------F--G--D'--E'   <- feature-branch
       \  
        D--E                <- origin/feature-branch

Dans cette situation, la succursale distante ne peut pas être transmise rapidement au local. Bien que, théoriquement, la branche locale puisse être fusionnée en distante (évidemment vous n'en avez pas besoin dans ce cas), mais comme elle git pusheffectue uniquement une fusion rapide, elle génère des erreurs et des erreurs.

Et quelle --forceoption ne fait qu'ignorer l'état de la branche distante et la définir sur la validation que vous y insérez. Remplace donc git push --force origin feature-branchsimplement origin/feature-branchavec local feature-branch.

À mon avis, rebaser les branches de fonctionnalités masteret les forcer à revenir au référentiel distant est OK tant que vous êtes le seul à travailler sur cette branche.

Au lieu d'utiliser -f ou --force, les développeurs devraient utiliser

--force-with-lease

Pourquoi? Parce qu'il vérifie les changements de la branche distante, ce qui est absolument une bonne idée. Imaginons que James et Lisa travaillent sur la même branche de fonctionnalité et Lisa a poussé un commit. James rebase maintenant sa branche locale et est rejeté lorsqu'il essaie de pousser. Bien sûr, James pense que cela est dû à un rebase et utilise --force et réécrirait toutes les modifications de Lisa. Si James avait utilisé --force-with-lease, il aurait reçu un avertissement indiquant que quelqu'un d'autre avait commis des commits. Je ne vois pas pourquoi quelqu'un utiliserait --force au lieu de --force-with-lease en poussant après un rebase.

J'utiliserais plutôt "checkout -b" et c'est plus facile à comprendre.

git checkout myFeature
git rebase master
git push origin --delete myFeature
git push origin myFeature

lorsque vous supprimez, vous empêchez d'insérer une branche existante contenant un ID SHA différent. Je supprime uniquement la branche distante dans ce cas.

Une solution à cela est de faire ce que le script de fusion de rebasage de msysGit fait - après le rebase, fusionnez dans l'ancienne tête de featureavec -s ours. Vous vous retrouvez avec le graphe de validation:

A--B--C------F--G (master)
       \         \
        \         D'--E' (feature)
         \           /
          \       --
           \    /
            D--E (old-feature)

... et votre poussée featuresera une avance rapide.

En d'autres termes, vous pouvez faire:

git checkout feature
git branch old-feature
git rebase master
git merge -s ours old-feature
git push origin feature

(Non testé, mais je pense que c'est vrai ...)

Il se peut ou non qu'il n'y ait qu'un seul développeur sur cette branche, qui est maintenant (après le rebase) non aligné avec l'origine / la fonctionnalité.

En tant que tel, je suggère d'utiliser la séquence suivante:

git rebase master
git checkout -b feature_branch_2
git push origin feature_branch_2

Ouais, nouvelle branche, cela devrait résoudre cela sans --force, ce qui, je pense, est généralement un gros inconvénient.

Ma façon d'éviter la poussée de force est de créer une nouvelle branche et de continuer le travail sur cette nouvelle branche et après une certaine stabilité, de supprimer l'ancienne branche qui a été rebasée:

• Redéfinir localement la branche extraite
• Branchement de la branche rebasée vers une nouvelle branche
• Pousser cette branche en tant que nouvelle branche à distance. et supprimer l'ancienne branche sur la télécommande

D'autres ont répondu à votre question. Si vous rebasez une branche, vous devrez forcer à pousser cette branche.

Rebase et un référentiel partagé ne s'entendent généralement pas. C'est réécrire l'histoire. Si d'autres utilisent cette branche ou se sont branchés à partir de cette branche, le rebasage sera assez désagréable.

En général, le rebase fonctionne bien pour la gestion des succursales locales. La gestion des succursales à distance fonctionne mieux avec les fusions explicites (--no-ff).

Nous évitons également de fusionner master dans une branche de fonctionnalité. Au lieu de cela, nous rebase à master mais avec un nouveau nom de branche (par exemple en ajoutant un suffixe de version). Cela évite le problème du rebasage dans le référentiel partagé.

Quel est le problème avec un git merge mastersur la featurebranche? Cela préservera le travail que vous aviez, tout en le gardant séparé de la branche principale.

A--B--C------F--G
       \         \
        D--E------H

Edit: Ah désolé, je n'ai pas lu votre énoncé de problème. Vous aurez besoin de force pendant que vous exécutez a rebase. Toutes les commandes qui modifient l'historique auront besoin de l' --forceargument. Il s'agit d'une sécurité intégrée pour vous empêcher de perdre du travail (l'ancien Det Eserait perdu).

Vous avez donc effectué un git rebasequi a fait ressembler l'arbre (bien qu'il soit partiellement masqué Det Ene se trouve plus dans une branche nommée):

A--B--C------F--G
       \         \
        D--E      D'--E'

Ainsi, lorsque vous essayez de pousser votre nouvelle featurebranche (avec D'et E'en elle), vous perdrez Det E.

Pour moi, suivre les étapes faciles fonctionne:

1. git checkout myFeature
2. git rebase master
3. git push --force-with-lease
4. git branch -f master HEAD
5. git checkout master
6. git pull

Après avoir fait tout ce qui précède, nous pouvons également supprimer la branche myFeature en suivant la commande:

git push origin --delete myFeature

Ce qui suit fonctionne pour moi:

git push -f origin branch_name

et il ne supprime aucun de mon code.

Mais, si vous voulez éviter cela, vous pouvez procéder comme suit:

git checkout master
git pull --rebase
git checkout -b new_branch_name

vous pouvez ensuite sélectionner tous vos commits dans la nouvelle branche. git cherry-pick COMMIT ID puis appuyez sur votre nouvelle branche.

Comme l'OP comprend le problème, cherche juste une meilleure solution ...

Que diriez-vous de cela en tant que pratique?

• Avoir une branche de développement de fonctionnalités réelle (où vous ne rebaserez jamais et ne forcez pas, afin que vos collègues développeurs de fonctionnalités ne vous détestent pas). Ici, récupérez régulièrement ces changements de main avec une fusion. Une histoire plus désordonnée , oui, mais la vie est facile et personne ne s'interrompt dans son travail.

• Avoir une deuxième branche de développement de fonctionnalités, où un membre de l'équipe de fonctionnalités pousse régulièrement toutes les validations de fonctionnalités, voire rebasées, voire forcées. Donc, presque proprement basé sur un commit maître assez récent. Une fois la fonctionnalité terminée, poussez cette branche sur le maître.

Il existe peut-être déjà un nom de modèle pour cette méthode.