significado - ¿Cuál es la mejor manera de hacer copias de seguridad de múltiples conjuntos de cambios en mercurial?

mercurial svn

Question

Es el método más confiable para ir uno por uno, usando el comando de retroceso para cada uno de los muchos conjuntos de cambios, o hay una manera de crear un gran conjunto de cambios de inversión para cubrir un montón de conjuntos de cambios [editar: no contiguos] .

Si uno por uno, ¿el orden importa? (¿Debería uno ir de último a primer?)

¿Difiere el mejor método si hay fusiones entre diferentes subproyectos en el camino?

¿Esto tiende a ir sin problemas en su experiencia? :-)

Answer 1

Así es como puedes hacerlo con TortoiseHg. Por supuesto que puedes hacer lo mismo con la línea de comandos.

Dada esta historia, donde no querrá deshacerse del conjunto de cambios A, B y C:

1 -- 2 -- A -- B -- C -- 3 -- 4

Primera actualización a la revisión 2.

Luego vuelva a introducir la primera de las revisiones posteriores que desee mantener, en este caso, la revisión 3.

Su historia ahora se ve así:

1 -- 2 -- A -- B -- C
      /
       3 -- 4

Ahora actualice a la revisión 4.

Y finalmente use "Combinar con el local" para fusionar la revisión C con la revisión 4.

En este punto, es crucial que seleccione la opción "Descartar todos los cambios de la revisión del objetivo de combinación (otra)".

Es posible que la descripción no sea la más lógica, pero significa que combina la antigua punta C de nuevo a la rama predeterminada, pero sin los conjuntos de cambios A, B y C.

El resultado es:

1 -- 2 -- A -- B -- C --
      /            /
       3    --    4

Comprométete y ya está.

Answer 2

Lo que se me ocurrió es poco elegante, pero hizo el trabajo, a pesar de que los cambios que necesitaba para retroceder se intercalaron con otro trabajo y tuvieron algunas ramificaciones internas. Esto es lo que hice. (Comentarios y mejoras son bienvenidos.)

Obtuve una lista de todos los conjuntos de cambios (que luego utilicé para generar los comandos a continuación):

hg log -r ''keyword(xyz)'' --template ''{rev}/n''

Generé un parche para cada conjunto de cambios:

hg diff -p -U 8 --reverse -c 15094 > 15094.rev.patch
hg diff -p -U 8 --reverse -c 15095 > 15095.rev.patch
...

Luego, aplica cada parche inverso. Aquí el orden importa, último a primero:

hg import -m "reversing changeset 15302" 15302.rev.patch
hg import -m "reversing changeset 15292" 15292.rev.patch
...

Este proceso se interrumpió varias veces debido a fusiones que no se realizaban automáticamente, en las que tuve que aplicar manualmente los cambios a un archivo desde su archivo .rej y luego confirmar manualmente, antes de retomar las importaciones donde las había dejado.

Finalmente (en otro clon ... ¿mencioné que hice todo esto en un clon?) hg histedit -o todo el conjunto de conjuntos de cambios inversos en un conjunto de cambios usando hg histedit -o y su comando de plegado.

Ahora tengo un único conjunto de cambios que debería poder revertir y aplicar si decido volver a poner el trabajo en una fecha posterior (aunque si cruzo ese puente, podría aplicar los parches "hacia adelante" de forma gradual de nuevo en orden para obtener mejor culpa / anotar información)

Answer 3

Si no quieres los cambios de "retroceso" en tu historial, también podrías hacer otra cosa:
Haga un clon de su repositorio, pero solo hasta el último conjunto de cambios del que no quiera deshacerse.

Consulte Mercurial: Repare un historial borked para ver un ejemplo de cómo hacer esto.

Si su repositorio era local, eso es todo lo que tiene que hacer.
Pero si los conjuntos de cambios incorrectos ya se habían enviado a un repositorio central, necesitaría acceso al servidor para eliminar el repositorio allí y reemplazarlo por su clon.
Además, si alguien más ya se retiró del repositorio con los conjuntos de cambios incorrectos, debe eliminar y volver a clonar (de lo contrario, los conjuntos de cambios malos están nuevamente en el repositorio central tan pronto como una de las otras personas vuelva a presionar).
Depende de las circunstancias si esta solución es buena para usted ...

Answer 4

Si no tiene fusiones en el camino, puede retroceder cada cambio individual (en orden inverso) o, si hay muchos de ellos, hacerlo con un gran parche inverso.

Si tiene buenos conjuntos de cambios en la parte superior de los que necesita retroceder, confirme mejor el parche inverso en la parte superior del conjunto de cambios incorrectos más recientes y luego vuelva a basarlos en la punta de la rama.

1 -- 2 -- A -- B -- C -- 3 -- 4
                     /
                      C''B''A''

$ hg up C
$ hg diff -r C:2 > backout.diff
$ hg import --no-commit backout.diff
$ hg ci -m "Backout A, B, C"
$ hg up 4
$ hg rebase -s C''B''A -d .

Habrá problemas si desea anular los conjuntos de cambios de combinación , consulte esta página wiki para obtener más información.

En tal caso, si es posible, considere volver a hacer la rama y eliminar el antiguo linaje. De lo contrario, es posible que deba abandonar la rama por completo, recuperando los buenos conjuntos de cambios mediante injerto o trasplante.

Answer 5

Hay opción de rebase para rebase .

La answer Helgi se puede actualizar a:

1 -- A -- 2 -- B -- 3 -- C -- 4 -- 5
                          /
                           C'' -- B'' -- A''

$ hg update --clean C
$ hg backout --rev C --message "Backed out changeset: C"
$ hg backout --rev B
$ hg commit --message "Backed out changeset: B"
$ hg backout --rev A
$ hg commit --message "Backed out changeset: A"
$ hg rebase --collapse --source C'' --dest 5
$ hg commit --message "Backed out C, B, A"

lo que dará lugar a la siguiente

1 -- A -- 2 -- B -- 3 -- C -- 4 -- 5 -- C''B''A''

Sin embargo, retirarse en una rama separada puede provocar un conflicto [lógico] en la fusión posterior.

1 -- A -- 2 -- B -- 3 -- X  --  4 
                     /           /
                      B'' -- A'' -- M

si X depende de A o B , entonces M tendrá conflicto (al menos conflicto lógico) .