Rehacer una fusión revertida en Git

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

  •  21-08-2019
  •  | 
  •  

Pregunta

Me he encontrado con un pequeño problema aquí:Tenía una rama con un problema específico. 28s en Git, que fusioné en el general develop rama.Resulta que lo hice demasiado rápido, así que usé git-revert para deshacer la fusión.Ahora, sin embargo, ha llegado el momento de fusionar 28s en develop, pero el comando git-merge ve la fusión original y felizmente anuncia que todo está bien y que las ramas ya se han fusionado.¿Qué hago ahora?¿Crear una confirmación 'Revertir "Revertir "28s -> desarrollar"" '?No parece una buena forma de hacerlo, pero no se me ocurre otra por el momento.

Cómo se ve la estructura del árbol:

Git log output

¿Fue útil?

Solución

Usted tiene que "revertir la reversión". Depende de cómo lo que revierte, puede no ser tan fácil como parece. Mira el documento oficial en este tema. 

---o---o---o---M---x---x---W---x---Y
              /
      ---A---B-------------------C---D

para permitir que: 

---o---o---o---M---x---x-------x-------*
              /                       /
      ---A---B-------------------C---D
  

Pero lo hace todo el trabajo? Seguro que lo hace. Se puede volver una fusión, y de una   ángulo puramente técnico, git lo hizo muy natural y no tenía verdadera   Problemas
.   Sólo se considera un cambio de "estado antes de la fusión" a   "Estado después de la fusión", y eso fue todo.
  Nada complicado, nada raro,   nada realmente peligroso. Git lo hará sin siquiera pensar en ello.

     

Así que desde un punto de vista técnico, no hay nada malo con revirtiendo una fusión,   pero desde un ángulo de flujo de trabajo es algo que por lo general debe tratar de   evitar .

     

Si es posible, por ejemplo, si usted encuentra un problema que obtuve fusionaron   en el árbol principal, en lugar de revertir la fusión, intente realmente difícil

     
      
  • biseccionar el problema en la rama que se fusionaron, y simplemente solucionarlo,
    •   
  • o tratar de revertir el cambio individual que lo causó.
    •   
     

Sí, es más complejo, y no, no siempre va a trabajar (a veces   la respuesta es: "Vaya, realmente no debería haber fusionado, porque no era   sin embargo, listo, y realmente necesito para deshacer todos de la fusión "). Así que entonces   en realidad debería revertir la fusión, pero cuando se quiere volver a hacer la fusión, se   ahora tenemos que hacerlo por revertir la operación de revertir.

Otros consejos

Supongamos que usted tiene una historia tan 

---o---o---o---M---W---x-------x-------*
              /                      
      ---A---B

Donde A, B y W no compromete - se revertirá de M

Así que antes de empezar a arreglar encontrado problemas Yo cherry-pick de W comprometo a mi sucursal 

git cherry-pick -x W

A continuación, puedo volver W cometer en mi rama 

git revert W

Después de que pueda seguir fijación.

La historia final podría ser: 

---o---o---o---M---W---x-------x-------*
              /                       /     
      ---A---B---W---W`----------C---D

Cuando envío un PR que se muestra claramente que PR es deshacer Revert y añade algunas nuevas confirmaciones.

Para revertir la operación de revertir sin atornillar su flujo de trabajo demasiado:

  • Crear una copia local de la basura desarrollar
  • Recuperar la operación de revertir cometen en la copia local de desarrollo
  • Combinar que copiar en su rama de la característica, y empujar a su rama de la característica a su servidor git.

Su rama de la característica debe ser ahora capaz de fusionarse con normalidad cuando esté listo para ello. El único inconveniente es que tendrá una fusión tiene unos cuantos extra / revertir compromete en su historia.

Para revertir una reversión en el GIT: 

git revert <commit-hash-of-previous-revert>

En lugar de usar git-revert podrías haber usado este comando en el devel sucursal a tirar a la basura (deshacer) la confirmación de fusión incorrecta (en lugar de simplemente revertirla).

git checkout devel
git reset --hard COMMIT_BEFORE_WRONG_MERGE

Esto también ajustará el contenido del directorio de trabajo en consecuencia. Ten cuidado:

  • Guarda tus cambios en la rama de desarrollo (desde la fusión incorrecta) porque ellos también serán borrados por el git-reset.Todos los compromisos después del que especifique como el git reset ¡La discusión desaparecerá!
  • Además, no haga esto si sus cambios ya fueron retirados de otros repositorios porque el reinicio reescribirá el historial.

Recomiendo estudiar el git-reset página de manual cuidadosamente antes de intentar esto.

Ahora, después del reinicio puedes volver a aplicar tus cambios en devel y luego hazlo 

git checkout devel
git merge 28s

Esta será una verdadera fusión de 28s en devel como la inicial (que ahora es borrado del historial de git).

acabo de encontrar este post cuando se enfrentan al mismo problema. Me parece por encima de wayyy al miedo de hacer recalcitrantes de reposición, etc. voy a terminar de eliminar algo que no quiero, y no será capaz de recuperarlo.

En lugar de eso fuimos a la que quería cometer la rama de volver a, por ejemplo, git checkout 123466t7632723. Convierte a continuación en un git checkout my-new-branch rama. a continuación, he eliminado la rama que no quería más. Por supuesto, esto sólo funciona si usted es capaz de tirar la rama en mal estado.

Yo sugeriría que siga los pasos siguientes para revertir una reversión, por ejemplo SHA1. 

git checkout develop #go to develop branch
git pull             #get the latest from remote/develop branch
git branch users/yourname/revertOfSHA1 #having HEAD referring to develop
git checkout users/yourname/revertOfSHA1 #checkout the newly created branch
git log --oneline --graph --decorate #find the SHA of the revert in the history, say SHA1
git revert SHA1
git push --set-upstream origin users/yourname/revertOfSHA1 #push the changes to remote

Ahora cree PR para la rama users/yourname/revertOfSHA1

  1. crear una nueva rama durante la confirmación antes de la fusión inicial - que llaman 'el desarrollo de base'
  2. realizar rebase interactivo de 'desarrollar' en la parte superior de 'desarrollar-base' (a pesar de que ya está en la parte superior). Durante rebase interactivo, usted tiene la oportunidad de eliminar tanto la fusión cometió, y la confirmación de que invierte la fusión, es decir, eliminar ambos acontecimientos de la historia git

En este punto usted tendrá una limpia 'desarrollar' rama a la que puede combinar su función Brach como lo hace regularmente.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top