Comment puis-je pousser la validation modifiée vers le référentiel Git distant?

Quand j'ai un peu travaillé avec mon code source, j'ai fait ma validation habituelle, puis j'ai poussé vers un référentiel distant. Mais j'ai remarqué que j'avais oublié d'organiser mes importations dans le code source. Je fais donc la commande amend pour remplacer le commit précédent:

> git commit --amend

Malheureusement, la validation ne peut pas être repoussée dans le référentiel. Il est rejeté comme ceci:

> git push origin
To //my.remote.repo.com/stuff.git/
 ! [rejected]        master -> master (non-fast forward)
error: failed to push some refs to '//my.remote.repo.com/stuff.git/'

Que devrais-je faire? (Je peux accéder au référentiel distant.)

En fait, j'ai poussé une fois avec --forceet .gitréférentiel et ai été grondé par Linus BIG TIME . En général, cela créera beaucoup de problèmes pour d'autres personnes. Une réponse simple est "Ne le faites pas".

Je vois que d'autres ont donné la recette pour le faire de toute façon, donc je ne les répéterai pas ici. Mais voici une astuce pour récupérer de la situation après avoir poussé le commit modifié avec --force (ou + master).

1. Utilisez git reflogpour trouver l'ancien commit que vous avez modifié (appelez-le old, et nous appellerons le nouveau commit que vous avez créé en modifiant new).
2. Créez une fusion entre oldet new, en enregistrant l'arbre de new, comme git checkout new && git merge -s ours old.
3. Fusionnez cela avec votre maître avec git merge master
4. Mettez à jour votre maître avec le résultat avec git push . HEAD:master
5. Poussez le résultat.

Ensuite , les gens qui étaient assez malheureux pour avoir fondé leur travail sur la commettras vous oblitérée en modifiant et en forçant une poussée verra la fusion résultante verra que vous favorisez newplus old. Leurs fusions ultérieures ne verront pas les conflits entre oldet newqui ont résulté de votre modification, donc ils n'ont pas à souffrir.

Vous voyez une fonctionnalité de sécurité Git. Git refuse de mettre à jour la branche distante avec votre branche, car le commit de tête de votre branche n'est pas un descendant direct du commit de tête actuel de la branche vers laquelle vous poussez.

Si ce n'était pas le cas, alors deux personnes poussant vers le même référentiel à peu près en même temps ne sauraient pas qu'un nouveau commit arrivait en même temps et celui qui poussait le dernier perdrait le travail du pousseur précédent sans aucun des deux les réalisant cela.

Si vous savez que vous êtes la seule personne à pousser et que vous souhaitez pousser un commit modifié ou pousser un commit qui remonte la branche, vous pouvez 'forcer' Git à mettre à jour la branche distante à l'aide du -fcommutateur.

git push -f origin master

Même cela peut ne pas fonctionner car Git permet aux référentiels distants de refuser les poussées non rapides à l'extrémité distante en utilisant la variable de configuration receive.denynonfastforwards. Si tel est le cas, la raison du rejet ressemblera à ceci (notez la partie «rejetée à distance»):

 ! [remote rejected] master -> master (non-fast forward)

Pour contourner ce problème, vous devez soit modifier la configuration du référentiel distant, soit en tant que hack sale, vous pouvez supprimer et recréer la branche ainsi:

git push origin :master
git push origin master

En général, le dernier paramètre à git pushutiliser le format <local_ref>:<remote_ref>, où local_refest le nom de la branche sur le référentiel local et remote_refle nom de la branche sur le référentiel distant. Cette paire de commandes utilise deux raccourcis. :mastera un local_ref nul qui signifie pousser une branche nulle vers le côté distant master, c'est-à-dire supprimer la branche distante. Un nom de branche sans aucun :moyen pousse la branche locale portant le nom donné vers la branche distante du même nom. masterdans cette situation est court pour master:master.

Déclamation rapide: Le fait que personne n'ait publié la réponse simple ici démontre l'hostilité désespérée des utilisateurs manifestée par la CLI Git.

Quoi qu'il en soit, la façon "évidente" de faire cela, en supposant que vous n'avez pas essayé de forcer la poussée, est de tirer en premier. Cela tire le changement que vous avez modifié (et donc plus) pour que vous l'ayez à nouveau.

Une fois que vous avez résolu tous les conflits, vous pouvez recommencer.

Donc:

git pull

Si vous obtenez des erreurs lors de l'extraction, peut-être que quelque chose ne va pas dans la configuration de votre référentiel local (j'avais une mauvaise référence dans la section de la branche .git / config).

Et après

git push

Peut-être obtiendrez-vous un commit supplémentaire avec le sujet racontant une "fusion triviale".

Réponse courte: ne pas pousser les commits modifiés vers un dépôt public.

Réponse longue: quelques commandes Git, comme git commit --amendetgit rebase , réécrivent en fait le graphique d'historique. C'est bien tant que vous n'avez pas publié vos modifications, mais une fois que vous l'avez fait, vous ne devriez vraiment pas fouiner avec l'historique, car si quelqu'un a déjà obtenu vos modifications, alors quand il essaie de tirer à nouveau, il peut échouer . Au lieu de modifier une validation, vous devez simplement effectuer une nouvelle validation avec les modifications.

Cependant, si vous voulez vraiment, vraiment pousser un commit modifié, vous pouvez le faire comme ceci:

$ git push origin +master:master

Le +signe de tête forcera la poussée à se produire, même si elle n'entraîne pas de validation "d'avance rapide". (Une validation rapide se produit lorsque les modifications que vous appuyez sont un descendant direct des modifications déjà présentes dans le référentiel public.)

Voici un moyen très simple et propre de pousser vos modifications après avoir déjà effectué un commit --amend:

git reset --soft HEAD^
git stash
git push -f origin master
git stash pop
git commit -a
git push origin master

Ce qui fait ce qui suit:

• Réinitialisez la tête de branche sur la validation parent.
• Cachez ce dernier commit.
• Forcer la poussée vers la télécommande. La télécommande n'a plus le dernier commit.
• Pop votre cachette.
• Engagez-vous proprement.
• Poussez vers la télécommande.

N'oubliez pas de changer «origine» et «maître» si vous appliquez cela à une autre succursale ou à une autre télécommande.

Je l'ai résolu en supprimant mon commit modifié local et en ajoutant les nouvelles modifications en haut:

# Rewind to commit before conflicting
git reset --soft HEAD~1

# Pull the remote version
git pull

# Add the new commit on top
git add ...
git commit
git push

J'ai eu le même problème.

• Modification accidentelle du dernier commit déjà poussé
• Fait beaucoup de changements localement, commis environ cinq fois
• J'ai essayé de pousser, j'ai eu une erreur, j'ai paniqué, j'ai fusionné la télécommande, j'ai reçu beaucoup de fichiers non-enregistrés, poussé, échoué, etc.

En tant que débutant Git, je pensais que c'était FUBAR complet .

Solution: un peu comme @bara a suggéré + créé une branche de sauvegarde locale

# Rewind to commit just before the pushed-and-amended one.
# Replace <hash> with the needed hash.
# --soft means: leave all the changes there, so nothing is lost.
git reset --soft <hash>

# Create new branch, just for a backup, still having all changes in it.
# The branch was feature/1234, new one - feature/1234-gone-bad
git checkout -b feature/1234-gone-bad

# Commit all the changes (all the mess) not to lose it & not to carry around
git commit -a -m "feature/1234 backup"

# Switch back to the original branch
git checkout feature/1234

# Pull the from remote (named 'origin'), thus 'repairing' our main problem
git pull origin/feature/1234

# Now you have a clean-and-non-diverged branch and a backup of the local changes.
# Check the needed files from the backup branch
git checkout feature/1234-gone-bad -- the/path/to/file.php

Ce n'est peut-être pas une solution rapide et propre, et j'ai perdu mon historique (1 commit au lieu de 5), mais cela a sauvé une journée de travail.

Si vous n'avez pas poussé le code vers votre branche distante (GitHub / Bitbucket), vous pouvez modifier le message de validation sur la ligne de commande comme ci-dessous.

 git commit --amend -m "Your new message"

Si vous travaillez sur une branche spécifique, procédez comme suit:

git commit --amend -m "BRANCH-NAME: new message"

Si vous avez déjà poussé le code avec un mauvais message, vous devez être prudent lorsque vous modifiez le message. Par exemple, après avoir modifié le message de validation et essayé de le pousser à nouveau, vous vous retrouvez avec des problèmes. Pour le rendre lisse, suivez les étapes suivantes.

Veuillez lire l'intégralité de la réponse avant de le faire

git commit --amend -m "BRANCH-NAME : your new message"

git push -f origin BRANCH-NAME                # Not a best practice. Read below why?

Remarque importante: lorsque vous utilisez directement la poussée forcée, vous pouvez vous retrouver avec des problèmes de code que d'autres développeurs travaillent sur la même branche. Donc, pour éviter ces conflits, vous devez extraire le code de votre branche avant d'effectuer une poussée forcée :

 git commit --amend -m "BRANCH-NAME : your new message"
 git pull origin BRANCH-NAME
 git push -f origin BRANCH-NAME

Il s'agit de la meilleure pratique lors de la modification du message de validation, s'il a déjà été poussé.

Si vous savez que personne n'a retiré votre commit non modifié, utilisez l' --force-with-leaseoption de git push.

Dans TortoiseGit, vous pouvez faire la même chose sous "Push ..." options "Force: May discard" et vérification des "changements connus".

Force (peut ignorer les modifications connues) permet au référentiel distant d'accepter une poussée non rapide plus sûre. Cela peut entraîner la perte de validations du référentiel distant; utilisez-le avec précaution. Cela peut éviter de perdre des modifications inconnues d'autres personnes sur la télécommande. Il vérifie si la branche du serveur pointe vers le même commit que la branche de suivi à distance (changements connus). Si oui, une poussée forcée sera effectuée. Sinon, il sera rejeté. Étant donné que git n'a pas de balises de suivi à distance, les balises ne peuvent pas être remplacées à l'aide de cette option.

Vous obtenez cette erreur car la télécommande Git a déjà ces fichiers de validation. Vous devez forcer la poussée de la branche pour que cela fonctionne:

git push -f origin branch_name

Assurez-vous également que vous extrayez le code à distance, car quelqu'un d'autre de votre équipe aurait pu pousser vers la même branche.

git pull origin branch_name

C'est l'un des cas où nous devons forcer le push sur commit à distance.

Voici un moyen très simple et propre de pousser vos modifications après avoir déjà fait un git add "your files"et git commit --amend:

git push origin master -f

ou:

git push origin master --force

Si vous utilisez Visual Studio Code, vous pouvez essayer cette extension pour vous faciliter la tâche.

https://marketplace.visualstudio.com/items?itemName=cimdalli.git-commit-amend-push-force

Comme vous pouvez le comprendre par son nom, il exécute les commandes consécutivement

• git commit --amend
• git push --force

J'ai dû résoudre ce problème en tirant du référentiel distant et gérer les conflits de fusion qui se sont produits, commettre puis pousser. Mais j'ai l'impression qu'il y a une meilleure façon.

J'ai continué à faire ce que Git m'a dit de faire. Donc:

• Impossible de pousser en raison d'un commit modifié.
• Je fais un pull comme suggéré.
• La fusion échoue. donc je le répare manuellement.
• Créez un nouveau commit (étiqueté "merge") et poussez-le.
• Cela semble fonctionner!

Remarque: le commit modifié était le dernier.

Ce qui suit a fonctionné pour moi lors du changement d'Auteur et de Committer d'un commit.

git push -f origin master

Git était assez intelligent pour comprendre qu'il s'agissait de commits de deltas identiques qui ne différaient que dans la section méta-informations.

Les chefs locaux et distants ont indiqué les commits en question.

Ici, comment j'ai corrigé une modification dans un commit précédent:

1. Enregistrez votre travail jusqu'à présent.
2. Rangez vos modifications pour l'instant si elles sont effectuées: git stashvotre copie de travail est maintenant propre à l'état de votre dernier commit.
3. Apportez les modifications et les correctifs.
4. Validez les modifications en mode "Modifier" :git commit --all --amend

5. Votre éditeur vous demandera un message de journal (par défaut, l'ancien message de journal). Enregistrez et quittez l'éditeur lorsque vous en êtes satisfait.

   Les nouvelles modifications sont ajoutées à l'ancien commit. Voyez par vous-même avec git logetgit diff HEAD^

6. Réappliquez vos modifications cachées, le cas échéant: git stash apply