Come posso ripristinare un commit SVN?

Ho trovato vari esempi di come ripristinare un commit SVN come

svn merge -r [current_version]:[previous_version] [repository_url]

o

svn merge -c -[R] .

Ma nessuno dei due sembra funzionare. Ho provato quei comandi e ho controllato i file che sono stati modificati a mano.

Come posso ripristinare un commit con la revisione numero 1944? Come posso verificare che il ripristino sia stato eseguito (senza guardare nel file effettivo le modifiche sono state ripristinate)?

Entrambi gli esempi devono funzionare, ma

svn merge -r UPREV:LOWREV . annulla intervallo

svn merge -c -REV . annulla revisione singola

in questa sintassi - se la directory corrente è WC e (come deve essere fatto dopo ogni unione), eseguirai il commit dei risultati

Vuoi vedere i registri?

Se si utilizza il client TortoiseSVN , è possibile farlo facilmente tramite la finestra di dialogo Mostra registro .

svn merge -r 1944:1943 .dovrebbe ripristinare le modifiche di r1944 nella copia di lavoro. È quindi possibile rivedere le modifiche nella copia di lavoro (con diff), ma è necessario eseguire il commit per applicare il ripristino nel repository.

Innanzitutto, ripristina la copia di lavoro nel 1943.

> svn merge -c -1943 .

Secondo, controlla cosa sta per essere commesso.

> svn status

In terzo luogo, esegui il commit della versione 1945.

> svn commit -m "Fix bad commit."

In quarto luogo, guarda il nuovo registro.

> svn log -l 4

------------------------------------------------------------------------
1945 | myname | 2015-04-20 19:20:51 -0700 (Mon, 20 Apr 2015) | 1 line

Fix bad commit.
------------------------------------------------------------------------
1944 | myname | 2015-04-20 19:09:58 -0700 (Mon, 20 Apr 2015) | 1 line

This is the bad commit that I made.
------------------------------------------------------------------------
1943 | myname | 2015-04-20 18:36:45 -0700 (Mon, 20 Apr 2015) | 1 line

This was a good commit.
------------------------------------------------------------------------

È impossibile "annullare il commit" di una revisione, ma è possibile ripristinare la copia di lavoro alla versione 1943 e impegnarla come versione 1945. Le versioni 1943 e 1945 saranno identiche, annullando efficacemente le modifiche.

Quanto segue farà una corsa a secco, come dice. HEAD è la versione corrente, PREV è precedente, quindi il percorso del tuo file o elemento di commit:

svn merge --dry-run -rHEAD:PREV https://example.com/svn/myproject/trunk

Se la corsa a secco sembra buona, esegui il comando senza --dry-run

Verificare la modifica nella revisione e ripetere il commit. Per cercare i numeri di versione provare:

svn log

F=code.c
REV=123
svn diff -c $REV $F | patch -R -p0 \
    && svn commit -m "undid rev $REV" $F

Alex, prova questo: svn merge [WorkingFolderPath] -r 1944: 1943

Sebbene i suggerimenti già forniti possano funzionare per alcune persone, non funziona per il mio caso. Quando eseguono l'unione, gli utenti a rev 1443cui eseguono l' aggiornamento rev 1445, sincronizzano comunque tutti i file modificati 1444anche se sono uguali 1443all'unione. Avevo bisogno che gli utenti finali non vedessero affatto l'aggiornamento.

Se si desidera nascondere completamente il commit, è possibile creare un nuovo ramo alla revisione corretta e quindi scambiare i rami. L'unica cosa è che è necessario rimuovere e aggiungere nuovamente tutti i blocchi.

copy -r 1443 file:///<your_branch> file:///<your_branch_at_correct_rev>
svn move file:///<your_branch> file:///<backup_branch>
svn move file:///<your_branch_at_correct_rev> file:///<your_branch>

Questo ha funzionato per me, forse sarà utile a qualcun altro là fuori =)

svn merge -c -M PATH

Questo mi ha salvato la vita.

Stavo avendo lo stesso problema, dopo essere tornato indietro non vedevo il vecchio codice. Dopo aver eseguito il comando sopra ho ottenuto un codice pulito della vecchia versione.

Ho provato quanto sopra, ( svn merge) e hai ragione, lo fa jack. però

svn update -r <revision> <target> [-R]

sembra funzionare, ma non è permanente (il mio svn mostra semplicemente una vecchia revisione). Quindi ho dovuto

mv <target> <target backup>
svn update <target>
mv <target backup> <target>
svn commit -m "Reverted commit on <target>" <target>

Nel mio caso particolare il mio obiettivo è interfaces/AngelInterface.php. Ho apportato modifiche al file, li ho impegnati, ho aggiornato il computer di build con il compilatore phpdoc e ho scoperto che le mie modifiche erano una perdita di tempo. svn log interfaces/AngelInterface.phpmostra la mia modifica come r22060 e il commit precedente su quel file era r22059. Quindi posso svn update -r 22059 interfaces/AngelInterface.phpe finisco con il codice com'era di nuovo in -r22059. Poi :-

mv interfaces/AngelInterface.php interfaces/AngelInterface.php~
svn update interfaces/AngelInterface.php
mv interfaces/AngelInterface.php~ interfaces/AngelInterface.php
svn commit -m "reverted -r22060" interfaces/AngelInterface.php

In alternativa, potrei fare la stessa cosa su una directory, specificando . -Ral posto di interfaces/AngelInterface.phptutto quanto sopra.

Se si desidera rimuovere completamente i commit dalla cronologia, è anche possibile eseguire un dump del repository a una revisione specifica, quindi importare tale dump. In particolare:

svnrdump dump -r 1:<rev> <url> > filename.dump

Il comando svnrdump svolge la stessa funzione del dump svnadmin ma funziona su un repository remoto.

Quindi importa semplicemente il file di dump nel tuo repository preferito. Questo è stato testato per funzionare bene su Beanstalk.