Actualice el flujo descendente reemplazando con el flujo ascendente y volviendo a aplicar los cambios descendentes, utilizando git?

Usando git, ¿hay una buena manera de get lo último de la stream ascendente y volver a aplicar nuestros cambios indirectos ? En lugar de fusionar la twig ascendente con la twig descendente que ya contiene nuestros cambios descendentes, volver a aplicar los cambios indirectos al nuevo ascendente sería más eficiente.

Tengo una situación que imagino que no es única: tenemos cambios en nuestra twig descendente que el upstream no aceptará o aún no ha aceptado, pero tenemos que mantener periódicamente (muy grandes) los cambios ascendentes de un equipo mucho más grande (por órdenes de magnitud) que el nuestro.

Es mucho mejor para nosotros adaptar nuestros cambios de código descendente a los cambios en sentido ascendente, y no al revés, ya que a la inversa sería mucho más trabajo a la larga en cada fusión. Volver a aplicar nuestros cambios indirectos (y adaptarlos al nuevo upstream) es mucho más limpio y seguro que fusionar los cambios ascendentes en nuestros cambios posteriores, y nos permite revisar mejor cómo nuestros cambios posteriores modifican el nuevo upstream.

La combinación tradicional aguas arriba en el método descendente sería:

  1. git checkout origin/master
  2. git merge upstream/master , resolviendo conflictos entre nuevos cambios upstream y nuestros cambios downstream

Un método intensivo en mano de obra para volver a aplicar los cambios posteriores al nuevo upstream podría ser:

  1. Crea una list de cambios en sentido descendente para mantener a través de git log , llamémosle list de retener
  2. Reemplazar contenido de origen / maestro con el command upstream / master : git para hacer una twig como otra
  3. git cherry: selecciona cada cambio anterior de la list de mantenimiento en origen / maestro , resolviendo conflictos

Una forma de pensarlo es que necesitamos algo similar a git rebase pero que funcione con twigs "no públicas" públicas, que reubiquen en sentido descendente / maestro utilizando el último upstream / master. git rebase sí mismo no suele ser aceptable, ya que rompería la regla de oro del rebase; nunca vuelva a establecer una bifurcación "pública".

Alguien tiene un mejor método? ¡Gracias por adelantado!

Asumir twigs de la siguiente manera:

 A - B - C - D - E - F - G <- upstream/master | \ - X - Y - Z <- origin/master <- HEAD 

En primer lugar, reemplace los contenidos de origen / master por upstream / master por git merge upstream/master -Xtheirs . Llame a esta combinación de compromiso "R". (Si creó nuevos files en su sucursal, debe eliminarlos).

 A - B - C - D - E - F - G <- upstream/master | | \ | - X - Y - Z - R <- origin/master <- HEAD 

Segundo, ejecute git rebase -i --onto origin/master upstream/master origin/master^ . Este command abre un editor con contenidos como:

 pick 5db64e4 X pick d0744fe Y pick 550d34b Z # Rebase 0cbeed6..550d34b onto 86590a3 (3 command(s)) # # Commands: # p, pick = use commit # r, reword = use commit, but edit the commit message # e, edit = use commit, but stop for amending # s, squash = use commit, but meld into previous commit # f, fixup = like "squash", but discard this commit's log message # x, exec = run command (the rest of the line) using shell # d, drop = remove commit # # These lines can be re-ordenetworking; they are executed from top to bottom. # # If you remove a line here THAT COMMIT WILL BE LOST. # # However, if you remove everything, the rebase will be aborted. # # Note that empty commits are commented out 

Simplemente cierre el editor, luego los cambios realizados por X, Y y Z se fusionarán en origen / maestro. (Debe resolver los conflictos aquí si los hubiera).

 A - B - C - D - E - F - G <- upstream/master | | \ | - X - Y - Z - R <- origin/master | \ - X' - Y' - Z' <- HEAD 

3. °, ejecute git branch -f origin/master HEAD para mover el origen / master a la punta.

 A - B - C - D - E - F - G <- upstream/master | | \ | - X - Y - Z - R | \ - X' - Y' - Z' <- origin/master <- HEAD 

Por último, ejecute git checkout origin/master para conectar el HEAD.

 A - B - C - D - E - F - G <- upstream/master | | \ | - X - Y - Z - R | \ - X' - Y' - Z' <- origin/master <- HEAD 

No estoy seguro de entender correctamente la motivación detrás de tu pregunta. Asumiré que está al tanto de todas las posibillidades de las estrategias y opciones de rebase debido a la respuesta de desbordamiento que señaló.

Tal vez los parches te ayudarán. Si desea simular el "cherry picking" de la "list de mantener", haga un parche que contenga cada confirmación que deba aplicar a otra sucursal:

 git format-patch --stdout first_commit_hash^..last_commit_hash > commits.patch 

Verifica en la sucursal deseada que está en el estado que deseas y aplica el parche

 git am -3 --signoff < commits.patch 

La opción -3 hará una combinación de tres vías si hay conflictos.

La opción de cierre agregará datos adicionales sobre quién hizo un parche

Los commits aplicados contendrán metadatos