tipos - ¿qué hace git log-oneline?
no se puede empujar para bifurcar después de rebase (5)
Debes realizar un push forzado, es decir, git push -f origin myNewFeature
Ah, y será mejor que se asegure de que las personas no basen nada en su rama de desarrollo; por lo general, no se supone que publique sucursales en las que está reescribiendo el historial en absoluto (o mejor no reescriba el historial una vez publicado). Una forma sería usar un nombre de rama como wip/myNewFeature y luego mencionar que las ramas wip se volverán a establecer como maestras de vez en cuando.
Usamos git y tenemos una rama principal y ramas de desarrollador. Necesito agregar una nueva característica y luego volver a establecer la base de los commits para masterizar, luego enviar master al servidor CI.
El problema es que si tengo conflictos durante la rebase, no puedo enviar a mi rama de desarrollador remoto (en Github) después de que se complete la rebase, hasta que retire mi rama remota. Esto causa commits duplicados. Cuando no hay conflictos, funciona como se esperaba.
pregunta: después de la resolución de conflictos y la resolución de conflictos, ¿cómo sincronizo mis ramas locales y remotas de desarrollador sin crear confirmaciones duplicadas?
Preparar:
// master branch is the main branch
git checkout master
git checkout -b myNewFeature
// I will work on this at work and at home
git push origin myNewFeature
// work work work on myNewFeature
// master branch has been updated and will conflict with myNewFeature
git pull --rebase origin master
// we have conflicts
// solve conflict
git rebase --continue
//repeat until rebase is complete
git push origin myNewFeature
//ERROR
error: failed to push some refs to ''[email protected]:ariklevy/dropLocker.git''
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Merge the remote changes (e.g. ''git pull'')
hint: before pushing again.
hint: See the ''Note about fast-forwards'' in ''git push --help'' for details.
// do what git says and pull
git pull origin myNewFeature
git push origin myNewFeature
// Now I have duplicate commits on the remote branch myNewFeature
EDITAR
Entonces parece que esto romperá el flujo de trabajo:
developer1 que trabaja en myNewFeature developer2 trabajando en hisNewFeature ambos usan master como rama principal
developer2 fusiona myNewFeature en hisNewFeature
developer1 rebases, resuelve conflictos, luego fuerza empuja a la rama remota para myNewFeature
un par de días después, developer2, fusiona myNewFeature en su NewFeature nuevamente
¿Esto hará que los otros desarrolladores odien el desarrollador1?
En primer lugar, usted y las personas con las que está trabajando necesitan acordar si una rama de tema / desarrollo es para desarrollo compartido o solo la suya. Otros desarrolladores saben que no se fusionarán en mis ramas de desarrollo porque se volverán a configurar en cualquier momento. Por lo general, el flujo de trabajo es el siguiente:
o-----o-----o-----o-----o-----o master
/
o-----o-----o devel0
/
o-----o-----o devel1
Luego, para estar al día con el control remoto, haré lo siguiente:
git fetch origin
git checkout master
git merge --ff origin/master
Lo hago por dos razones. Primero porque me permite ver si hay cambios remotos sin necesidad de cambiar de mi rama de desarrollo. En segundo lugar, es un mecanismo de seguridad para garantizar que no sobrescriba ningún cambio no oculto / comprometido. Además, si no puedo avanzar rápido me uno a la rama principal, eso significa que alguien ha cambiado el maestro remoto (para el cual necesitan ser azotados severamente) o me he comprometido accidentalmente a dominar y necesito limpiar mi extremo.
Luego, cuando el control remoto haya cambiado y haya reenviado rápidamente a la última versión de la base de datos:
git checkout devel0
git rebase master
git push -f origin devel0
Otros desarrolladores saben entonces que necesitarán rebase sus ramas de desarrollo de mi último:
git fetch <remote>
git checkout devel1
git rebase <remote>/devel0
Lo que resulta en una historia mucho más limpia:
o-----o master
/
o-----o-----o devel0
/
o-----o-----o devel1
No combine compromisos de ida y vuelta a su antojo. No solo crea confirmaciones duplicadas y hace que la historia sea imposible de seguir, ya que las regresiones de un cambio específico se vuelven casi imposibles (por eso, en primer lugar, está utilizando el control de versiones, ¿no?). El problema que estás teniendo es el resultado de hacer exactamente esto.
También parece que otros desarrolladores pueden estar haciendo commits en tus ramas de desarrollo. ¿Puedes confirmar esto?
El único momento para fusionarse es cuando su rama temática está lista para ser aceptada en el master .
En otros comentarios. Si varios desarrolladores se están comprometiendo con el mismo repositorio, todos deberían considerar tener ramas con nombre para distinguir entre desarrolladores que desarrollan ramas. Por ejemplo:
git branch ''my-name/devel-branch''
De modo que todas las ramas de tema de los desarrolladores residen dentro de su propio conjunto anidado.
La respuesta general que ya se ha dado - usar git push -f origin myNewFeature cuando se presionan cambios git push -f origin myNewFeature - es un buen punto de partida. Estoy escribiendo esta respuesta para abordar la edición sobre si romperá tu flujo de trabajo.
Si suponemos que va a utilizar git pull --rebase ... (o alguna variación de eso) seguido de un force-push a la rama remota, entonces lo que rompe el flujo de trabajo en su ejemplo es developer2 is fusionando myNewFeature en hisNewFeature . Tiene sentido poder volver a establecer la base de su propia rama de características siempre que nadie más esté trabajando en esa rama, por lo que necesita reglas para delimitar el territorio de la sucursal.
Puede evitar esto: a) estableciendo una regla de que solo se fusionará con el master , o b) creando una rama de develop colectivo, sobre la cual basará su propia rama myNewFeature , y establecerá una regla de la que solo alguna vez se fusionará. master se reservará solo para hitos o lanzamientos (o como quiera que quiera configurarlo), y se develop donde usted empuje cada característica cuando esté listo para integrarse en otras ramas de características.
Creo que esto podría considerarse una versión simplificada del flujo de trabajo de Gitflow.
Lo más importante a tener en cuenta aquí es lo que pull y rebase están haciendo entre bastidores.
Una extracción básicamente hará dos cosas: buscar y fusionar. Cuando incluyas --rebase hará una rebase en lugar de la fusión.
Una rebase es más o menos como guardar todos los cambios locales desde que se ramificó, reenviando rápidamente su rama a la última confirmación en el destino y eliminando los cambios en orden en la parte superior.
(Esto explica por qué puede obtener varias solicitudes de resolución de conflictos al hacer una rebase frente a la resolución de un conflicto que puede obtener con una fusión. Tiene la oportunidad de resolver un conflicto en CADA confirmación que se está modificando para preservar sus compromisos. )
Nunca desea impulsar cambios reubicados en sucursales remotas, ya que esto está reescribiendo el historial. Ofcoarse, nunca es un poco fuerte ya que casi siempre hay excepciones. El caso de que necesite mantener una versión remota de su repositorio local para trabajar en un entorno específico, por ejemplo.
Esto requerirá que presione cambios reestadificados a veces utilizando la fuerza:
git push -f origin newfeature
O en algunos casos, su administrador puede haber eliminado la posibilidad de forzar, por lo que debe eliminar y volver a crear:
git push origin :newfeature
git push origin newfeature
En cualquier caso, debe estar absolutamente seguro de que sabe lo que está haciendo si otra persona colabora con usted en su sucursal remota. Esto puede significar que trabajas en conjunto inicialmente con fusiones y las vuelves a clasificar en un formato de compromiso más manejable justo antes de ir a maestro y eliminar tu rama de trabajo.
Recuerde que casi siempre puede recurrir a GC de git aprovechando:
git reflog
Este es un ENORME salvavidas, ya que puedes restablecer a un estado más estable si te pierdes en toda tu gestión de rebase / conflictos.
Necesitas forzar el empuje a medida que mueves los commits más abajo de la línea. Git espera que agregues commits a la punta de la rama. git push -f origin myNewFeature solucionará su problema.
Consejo: arriba está el uso legítimo de empujar la fuerza. Nunca reescriba la historia en un repositorio de acceso público o mucha gente lo odiará.