remove - git tag best practices

Git fusionando hotfix a múltiples sucursales

Question

He estado tratando de envolver mi cabeza alrededor de los modelos de ramificación de git. He estado buscando en http://nvie.com/posts/a-successful-git-branching-model/ algunas ideas y proveniente de Subversion. Una cosa que realmente esperaba era hacer un cambio en un solo lugar fusionándolo con todas las ramas que lo necesitaran. En Subversion, terminamos haciendo una gran cantidad de código alrededor.

Sin embargo todavía no entiendo esto completamente. Este es un tipo de flujo de trabajo estándar que tengo y siempre generará conflictos.

# create new version branch
git checkout master
git checkout -b v3
vim pom.xml  # change branch version to "3.1-SNAPSHOT"
git commit -a
git checkout master
vim pom.xml  # change master version to "4.0-SNAPSHOT"
git commit -a

Así que el maestro está en 4.0-SNAPSHOT y la rama está en 3.1-SNAPSHOT.

No quiero crear un hotfix en la rama y moverlo al tronco.

git checkout v3
git checkout -b hotfix
vim file.txt  # make a bugfix change
git commit -a
git checkout v3
git merge hotfix  # this works fine
git checkout master
git merge hotfix  # this has a conflict since both branches have changed the version

Entiendo por qué está sucediendo y tiene sentido. ¿Hay una mejor manera de hacer esto?

Leí sobre cherry-pick, que probé y funciona:

git checkout v3
git cherry-pick a518b0b75eaf28868
git checkout master
git cherry-pick a518b0b75eaf28868

Sin embargo, esa no parece ser la forma "correcta" de manejar esto. ¿Alguna sugerencia?

Answer 1

En el caso, usted está trabajando en la rama "4.0" y tiene que hacer una corrección en "3.1", puede volver a generar "4.0" después de confirmar "3.1":

git checkout 4.0 # you are on the feature brnach 4.0
git stash # save current work so you can check out other branch
git checkout 3.1    
git commit -a -m "bug fix" # do editing and commit
git checkout "4.0"
git stash apply # get back your changes
git rebase "3.1" # change 4.1 so it branches of the current head of "3.1"

Answer 2

Realmente, su respuesta depende de si desea que sus árboles se basen en el mismo historial ... Por ejemplo, 4.0 se basa en la última versión 3.X + todos los cambios en 4.0 ...

Personalmente, no lo recomiendo una vez que decida comenzar una nueva (s) rama (s) para una nueva versión (s). En un momento dado, el software está tomando una dirección diferente, por lo que sus sucursales también deberían hacerlo.

Esto deja a git cherry-pick como tu solución ideal. Haga el cambio en cualquier rama que tenga más sentido, y luego elija las versiones anteriores. Esto es lo mismo que si hubiera revisado la rama anterior y hubiera aplicado manualmente el mismo cambio, y haya realizado una nueva confirmación. Lo mantiene limpio y al punto.

Git Merge o Rebase intentarán integrar el historial de las sucursales, cada uno a su manera, lo cual sospecho que no querrá cuando arregle errores en el backporting, etc.

Answer 3

Si desea obtener información técnica, puede crear el hotfix a partir de un ancestro común:

git merge-base v3 master
git checkout -b hotfix <whatever you got from merge-base>
# make your fix
git checkout v3 && git merge --no-ff hotfix
git checkout master && git merge --no-ff hotfix

        v3--------v3 (hotfixed)
       /         /
ancestor----hotfix
       /         /
        master----master (hotfixed)

La --no-ff está ahí para resaltar que Git creará una confirmación de fusión, manteniendo la etiqueta de la rama de la revisión en la punta de la revisión, en lugar de tirar de la etiqueta a v3 o master . (Puede omitir la bandera y obtener el mismo comportamiento, ya que la rama de la hotfix tiene un compromiso que no está en master o v3 . Más información en los documentos ).

Personalmente, creo que eso es una exageración. Me gustaría ir con gahooa: hacer la revisión en la rama que tenga sentido, luego fusionar o elegir según cómo desee que las ramas se relacionen entre sí.

Answer 4

También he estado luchando con esta pregunta, y creo que si está dispuesto a cambiar un poco su estrategia de versiones (es decir, a partir de las versiones -SNAPSHOT que recomienda Maven), esto podría resolverse utilizando una versión fija ( como SNAPSHOT o 0.0.0-SNAPSHOT) en master (o cualquiera que sea su rama de desarrollo). (El sufijo SNAPSHOT es importante, si está utilizando Maven, ya que Maven trata los artefactos con versión SNAPSHOT de manera diferente a los demás).

De hecho, creo que querría instituir una política de solo cambiar el número de versión en su rama de producción (desde la que se crean versiones) o en sucursales que son solo para fines de versión (por ejemplo, cambiar los números de versión) y que nunca pretende fusionar de nuevo a la rama de desarrollo.

Todavía no he usado esta estrategia, pero estaba pensando en eso, y creo que empezaré a intentarlo.