Comment revenir à une version plus ancienne de notre code dans Subversion?

https://stackoverflow.com/questions/814433

svn
backport

03-07-2019
|

Question

Je travaille sur un projet avec un ami et je souhaite revenir à une version plus ancienne de notre code et la définir comme étant la version actuelle. Comment je le fais?

J'utilise " anksvn " sur vs08.

J'ai la version que je souhaite sur mon PC, mais la validation échoue. Le message que je reçois est "La validation a échoué, le fichier ou le répertoire est obsolète."

J'ai également le client Subversion sur mon PC.

La solution

En principe, vous devez " fusionner en arrière " - appliquez un diff entre la version actuelle et la version précédente sur la version actuelle (pour obtenir une copie de travail ressemblant à l'ancienne version), puis validez à nouveau. Ainsi, par exemple, pour revenir de la révision 150 (actuelle) à la révision 140:

svn update
svn merge -r 150:140 .
svn commit -m "Rolled back to r140"

Le livre rouge de Subversion a un bonne section à ce sujet .

Autres conseils

Vous ne pouvez appliquer de nouvelles modifications qu'en en-tête de l'historique de subversion.

La raison pour laquelle vous ne pouvez rien faire directement avec la copie de qualité que vous avez sur votre PC est que ses dossiers .svn savent qu'il s'agit d'un code du passé. Une mise à jour est donc nécessaire avant toute commettre.

Trouvez le bon numéro de révision et revenez

Recherchez le numéro de révision de l'ancienne copie souhaitée. Obtenez votre révision actuelle avec:
```
svn info --show-item revision
# or
svn log
```
Ou utilisez:
```
svn update -r <earlier_revision_number>
```
pour vérifier diverses versions plus anciennes de votre projet jusqu'à ce que vous trouviez le bon numéro de révision.
Notez le bon numéro de révision (en supposant 123 pour les exemples ci-dessous).
Mise à jour vers la dernière révision:
```
svn update
```
Annulez toutes les modifications entre la révision souhaitée et la dernière version:
```
svn merge -r HEAD:123 .
svn commit "Reverted to revision 123"
```
(identique à la réponse de Jon Skeet ci-dessus.)

Si vous ne trouvez pas le numéro de révision

Si vous ne trouvez pas l'ancienne copie et que vous voulez simplement valider les fichiers actuellement sur votre PC:

Faites une copie de votre bonne version (mais sans aucun dossier .svn ):
```
cd ..
rsync -ai --exclude=.svn  project/  project-good/
```

Assurez-vous maintenant que vous avez la dernière version:

cd project
svn update
# or make a fresh checkout
svn checkout <url>

Copiez votre bonne version par-dessus la copie de travail.

Cette commande copiera et supprimera également tous les fichiers de l'arborescence de travail qui ne se trouvent pas dans votre copie conforme, mais cela n'affectera pas les dossiers .svn existants.
```
cd ..
rsync -ai --exclude=.svn --delete  project-good/  project/
```
Si vous ne disposez pas de rsync, vous pouvez utiliser cp -a , mais vous devrez également supprimer manuellement tous les fichiers indésirables.
Vous devriez pouvoir commettre ce que vous avez maintenant.
```
cd project
svn commit "Reverted to good copy"
```

Utilisez simplement cette ligne

svn update -r yourOldRevesion

Vous pouvez connaître votre révision actuelle en utilisant:

svn info

La méthode standard d’utilisation de la fusion pour annuler l’enregistrement complet fonctionne très bien, si c’est ce que vous souhaitez faire. Parfois, cependant, tout ce que vous voulez faire est de restaurer un seul fichier. Il n'y a pas de moyen légitime de le faire, mais il y a un hack:

Recherchez la version de votre choix à l'aide de svn log.
Utilisez la sous-commande export de svn:

svn export http: // url-to-your-file @ 123 / tmp / nom de fichier

(où 123 est le numéro de révision d’une bonne version du fichier.) Ensuite, déplacez ou copiez ce fichier unique pour écraser l’ancien. Archivez le fichier modifié et vous avez terminé.

Un peu plus de vieille école

svn diff -r 150:140 > ../r140.patch
patch -p0 < ../r140.patch

alors l'habituel

svn diff
svn commit

Je pense que cela convient le mieux:

Faites la fusion en arrière, par exemple, si le code validé contient la révision de rev 5612 à 5616, il suffit de le fusionner à l'envers. Cela fonctionne de mon côté.

Par exemple:

svn merge -r 5616:5612 https://<your_svn_repository>/

Il contiendrait un code fusionné dans sa version précédente, puis vous pourrez le commettre.

C'est ce que j'ai fait et travaillé pour moi.

Je souhaite annuler les modifications apportées à plusieurs commits que j'ai effectués certaines fois et je souhaite revenir au point de validation précédent.

Aller à l'équipe - > Afficher l'historique.
Cliquez avec le bouton droit de la souris sur la ou sur la plage de révisions que vous souhaitez ignorer.
Sélectionnez l'option "Annuler les modifications". option.

Ceci exécutera une fusion inverse, annulant les modifications de votre copie de travail.

Vérifiez le code et validez.

Cliquez avec le bouton droit de la souris sur la hiérarchie la plus haute que vous souhaitez rétablir, puis sur > > Rétablir ou Revenir à la révision

Cliquez avec le bouton droit sur le projet > Remplacer par > Révision ou URL > Sélectionnez la révision que vous souhaitez annuler.

Maintenant, validez la version du code de mise à jour locale dans le référentiel. Cela va retourner la base de code à la révision spécifique.

La plupart des réponses précédentes utilisaient une fusion inversée, et c'est généralement la bonne réponse. Cependant, il y a une situation (qui vient de m'arriver) où ce n'est pas le cas.

J'ai modifié accidentellement un fichier avec des fins de ligne Unix en fins de ligne DOS lors d'une modification minime et je l'ai validé. Ceci est facilement annulé, soit en modifiant les fins de ligne et en validant à nouveau, soit par une fusion inversée, mais cela a pour effet de faire en sorte que svn blame liste mon édition comme source de chaque ligne du fichier. (Il est intéressant de noter que TortoiseSVN sous Windows n’est pas affecté par cela; seule la ligne de commande svn blame .)

Si vous souhaitez conserver l'historique tel que rapporté par svn blame , je pense que vous devez procéder comme suit:

Supprimez le fichier et validez.
Dans le référentiel, copiez l'ancienne copie conforme du fichier dans l'en-tête et validez-le.
Restaurez les modifications que vous souhaitez conserver.

La suppression est un peu effrayante, mais rappelez-vous que le fichier est toujours enregistré dans le référentiel, sa restauration n’est donc pas une grosse affaire. Voici du code pour illustrer les étapes. Supposons que xxx soit le numéro de révision de la dernière copie conforme.

svn rm svn+ssh://path/to/file
svn copy svn+ssh://path/to/file@xxx svn+ssh://path/to -m"Restore good copy"
svn update
<restore the edits>
svn commit -m"Restore edits"

Notez que pour une copie dans le référentiel, la destination doit être un répertoire et non un nom de fichier.

Synchronisez avec l'ancienne version et validez-la. Cela devrait faire l'affaire.

Voici également une explication de l'annulation des modifications.

La réponse de Jon Skeet est en gros la solution, mais si vous êtes comme moi, vous voudrez peut-être une explication. Le manuel Subversion appelle cela un

Fusion de sélections de cerises

À partir des pages de manuel.

Ce formulaire s'appelle une fusion 'à la sélection':   '-r N: M' fait référence à la différence dans l'histoire du    branche source entre les révisions N et M.

Une "plage inverse" peut être utilisée pour annuler les modifications. Par exemple, quand    source et cible se rapportent à la même branche, une précédente    la révision peut être «annulée». Dans une plage inverse , N est supérieur à M dans    '-r N: M' ou l'option '-c' est utilisée avec un nombre négatif: '-c -M'    est équivalent à '-r M:'. Annuler des modifications comme celle-ci est également connu    comme effectuant une "fusion inverse".

Si la source est un fichier, les différences lui sont appliquées   fichier (utile pour la fusion inverse des modifications précédentes). Autrement,   si la source est un répertoire, la cible par défaut est '.'.

En utilisation normale, la copie de travail doit être à jour, à un seul endroit.    révision sans modifications locales ni sous-arbres commutés.

Exemple:

svn merge -r 2983:289 path/to/file

Ceci remplacera la copie locale [2983] (qui, selon la citation ci-dessus, devrait être synchronisée avec le serveur - votre responsabilité) avec la révision 289 du serveur. La modification est effectuée localement, ce qui signifie que si vous avez une commande propre, vous pouvez alors vérifier les modifications avant de les valider.

Il y a beaucoup de réponses dangereuses sur cette page. Notez que depuis la version 1.6 de SVN, la mise à jour -r peut provoquer des conflits d’arbres, qui se transforment rapidement en cauchemar kafkeresque potentiellement gênant pour la perte de données, dans lequel vous recherchez des informations sur les conflits d’arbres.

La bonne façon de revenir à une version est:

svn merge -r HEAD:12345 .

Où 12345 est le numéro de version. N'oublie pas le point.

Ce qui suit a fonctionné pour moi.

J'ai eu beaucoup de modifications locales et je devais les supprimer de la copie locale et récupérer la dernière version stable en SVN.

Vérifiez l'état de tous les fichiers, y compris des fichiers ignorés.
Grep toutes les lignes pour obtenir les fichiers nouvellement ajoutés et ignorés.
Remplacez ceux-ci par // .
et rm -rf toutes les lignes.

svn status --no-ignore | grep '^ [? I]' | sed " s / ^ [? I] // " | xargs -I {} rm -rf "{}"

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow