¿Cómo migro un repositorio SVN con historial a un nuevo repositorio Git?

https://stackoverflow.com/questions/79165

09-06-2019
|

Pregunta

Leí el manual de Git, las preguntas frecuentes, el curso intensivo de Git - SVN, etc.y todos explican esto y aquello, pero en ninguna parte puedes encontrar una instrucción simple como:

Repositorio SVN en: svn://myserver/path/to/svn/repos

Repositorio Git en: git://myserver/path/to/git/repos

git-do-the-magic-svn-import-with-history \
svn://myserver/path/to/svn/repos \
git://myserver/path/to/git/repos

No espero que sea tan simple y no espero que sea un solo comando.Pero sí espero que no intente explicar nada, sólo que diga qué pasos seguir dado este ejemplo.

Solución

Magia:

$ git svn clone http://svn/repo/here/trunk

Git y SVN funcionan de manera muy diferente.Necesita aprender Git y, si desea realizar un seguimiento de los cambios desde SVN en sentido ascendente, debe aprender git-svn.El git-svn La página de manual tiene una buena sección de ejemplos:

$ git svn --help

Otros consejos

Cree un archivo de usuarios (es decir, users.txt) para asignar usuarios SVN a Git:

user1 = First Last Name <email@address.com>
user2 = First Last Name <email@address.com>
...

Puede utilizar esta frase breve para crear una plantilla a partir de su repositorio SVN existente:

svn log -q | awk -F '|' '/^r/ {sub("^ ", "", $2); sub(" $", "", $2); print $2" = "$2" <"$2">"}' | sort -u > users.txt

SVN se detendrá si encuentra un usuario SVN faltante que no está en el archivo.Pero después de eso, puede actualizar el archivo y continuar donde lo dejó.

Ahora extraiga los datos SVN del repositorio:

git svn clone --stdlayout --no-metadata --authors-file=users.txt svn://hostname/path dest_dir-tmp

Este comando creará un nuevo repositorio Git en dest_dir-tmp y comience a extraer el repositorio SVN.Tenga en cuenta que el indicador "--stdlayout" implica que tiene el diseño SVN común "troncal/, ramas/, etiquetas/".Si su diseño difiere, familiarícese con --tags, --branches, --trunk opciones (en general git svn help).

Se permiten todos los protocolos comunes: svn://, http://, https://.La URL debe apuntar al repositorio base, algo así como http://svn.mycompany.com/myrepo/repository.Eso debe no incluir /trunk, /tag o /branches.

Tenga en cuenta que después de ejecutar este comando, muy a menudo parece que la operación está "colgada/congelada", y es bastante normal que pueda permanecer bloqueada durante mucho tiempo después de inicializar el nuevo repositorio.Con el tiempo, verá mensajes de registro que indican que se está migrando.

También tenga en cuenta que si omite el --no-metadata bandera, Git agregará información sobre la revisión SVN correspondiente al mensaje de confirmación (es decir, git-svn-id: svn://svn.mycompany.com/myrepo/<branchname/trunk>@<RevisionNumber> <Repository UUID>)

Si no se encuentra un nombre de usuario, actualice su users.txt archivo entonces:

cd dest_dir-tmp
git svn fetch

Es posible que tengas que repetir ese último comando varias veces, si tienes un proyecto grande, hasta que se hayan obtenido todas las confirmaciones de Subversion:

git svn fetch

Cuando esté completo, Git verificará el SVN. trunk en una nueva sucursal.Cualquier otra sucursal se configura como remota.Puedes ver las otras sucursales de SVN con:

git branch -r

Si desea mantener otras sucursales remotas en su repositorio, deberá crear una sucursal local para cada una manualmente.(Omita tronco/maestro). Si no hace esto, las ramas no se clonarán en el paso final.

git checkout -b local_branch remote_branch
# It's OK if local_branch and remote_branch are the same name

Las etiquetas se importan como ramas.Tienes que crear una rama local, crear una etiqueta y eliminar la rama para tenerlas como etiquetas en Git.Para hacerlo con la etiqueta "v1":

git checkout -b tag_v1 remotes/tags/v1
git checkout master
git tag v1 tag_v1
git branch -D tag_v1

Clona tu repositorio GIT-SVN en un repositorio Git limpio:

git clone dest_dir-tmp dest_dir
rm -rf dest_dir-tmp
cd dest_dir

Las sucursales locales que creó anteriormente a partir de sucursales remotas solo se habrán copiado como sucursales remotas en el nuevo repositorio clonado.(Omitir tronco/maestro). Para cada rama que desee conservar:

git checkout -b local_branch origin/remote_branch

Finalmente, elimine el control remoto de su repositorio Git limpio que apunta al repositorio temporal ahora eliminado:

git remote rm origin

Migre limpiamente su repositorio Subversion a un repositorio Git.Primero debe crear un archivo que asigne los nombres de los autores de las confirmaciones de Subversion a los confirmadores de Git, digamos ~/authors.txt:

jmaddox = Jon Maddox <jon@gmail.com>
bigpappa = Brian Biggs <bigpappa@gmail.com>

Luego puedes descargar los datos de Subversion en un repositorio Git:

mkdir repo && cd repo
git svn init http://subversion/repo --no-metadata
git config svn.authorsfile ~/authors.txt
git svn fetch

Si estás en una Mac, puedes obtener git-svn desde MacPorts instalando git-core +svn.

Si su repositorio de subversión está en la misma máquina que el repositorio de Git deseado, puede usar esta sintaxis para el paso de inicio, de lo contrario, de lo contrario de todos modos:

git svn init file:///home/user/repoName --no-metadata

utilicé el secuencia de comandos svn2git y funciona a las mil maravillas.

Sugiero sentirse cómodo con Git antes de intentar usar git-svn constantemente, es decir.manteniendo SVN como repositorio centralizado y usando Git localmente.

Sin embargo, para una migración sencilla con todo el historial, estos son unos sencillos pasos:

Inicialice el repositorio local:

mkdir project
cd project
git svn init http://svn.url

Marque desde qué fecha desea comenzar a importar revisiones:

git svn fetch -r42

(o simplemente "git svn fetch" para todas las revoluciones)

En realidad, recupera todo desde entonces:

git svn rebase

Puedes comprobar el resultado de la importación con Gitk.No estoy seguro de si esto funciona en Windows, funciona en OSX y Linux:

gitk

Cuando haya clonado su repositorio SVN localmente, es posible que desee enviarlo a un repositorio Git centralizado para facilitar la colaboración.

Primero cree su repositorio remoto vacío (tal vez en GitHub?):

git remote add origin git@github.com:user/project-name.git

Luego, opcionalmente, sincronice su rama principal para que la operación de extracción fusione automáticamente el maestro remoto con su maestro local, cuando ambos contengan cosas nuevas:

git config branch.master.remote origin
git config branch.master.merge refs/heads/master

Después de eso, quizás te interese probar mi propio git_remote_branch herramienta, que ayuda a lidiar con sucursales remotas:

Primer post explicativo:"ramas remotas de git"

Seguimiento de la versión más reciente:"Es hora de empezar a colaborar con git_remote_branch"

Existe una nueva solución para una migración fluida de Subversion a Git (o para usar ambos simultáneamente): subgit.

Yo mismo estoy trabajando en este proyecto.Usamos SubGit en nuestros repositorios; algunos de mis compañeros de equipo usan Git y algunos Subversion y hasta ahora funciona muy bien.

Para migrar de Subversion a Git con SubGit necesitas ejecutar:

$ subgit install svn_repos
...
TRANSLATION SUCCESSFUL

Después de eso, obtendrás el repositorio Git en svn_repos/.git y podrás clonarlo, o simplemente continuar usando Subversion y este nuevo repositorio Git juntos:SubGit se asegurará de que ambos se mantengan siempre sincronizados.

En caso de que su repositorio de Subversion contenga varios proyectos, se crearán varios repositorios Git en el directorio svn_repos/git.Para personalizar la traducción antes de ejecutarla, haga lo siguiente:

$ subgit configure svn_repos
$ edit svn_repos/conf/subgit.conf (change mapping, add authors mapping, etc)
$ subgit install svn_repos

Con subgit puede migrar a Git puro (no a git-svn) y comenzar a usarlo manteniendo Subversion todo el tiempo que lo necesite (para sus herramientas de compilación ya configuradas, por ejemplo).

¡Espero que esto ayude!

ver el oficial página de manual de git-svn.En particular, consulte "Ejemplos básicos":

Seguimiento y contribuyendo a un proyecto administrado por la subversión completo (completo con un tronco, etiquetas y ramas):

# Clone a repo (like git clone):
    git svn clone http://svn.foo.org/project -T trunk -b branches -t tags

Pro Git 8.2 lo explica:http://git-scm.com/book/en/Git-and-Other-Systems-Migrating-to-Git

subgit (contra la pantalla azul de la muerte)

subgit import --svn-url url://svn.serv/Bla/Bla  directory/path/Local.git.Repo

Es todo.

+ Para actualizar desde SVN, un repositorio Git creado por el primer comando.

subgit import  directory/path/Local.git.Repo

Utilicé una forma de migrar a Git instantáneamente para un repositorio enorme.
Por supuesto que necesitas algo de preparación.
Pero no es posible detener el proceso de desarrollo en absoluto.

Este es mi camino.

Mi solución se parece a:

Migrar SVN a un repositorio Git
Actualice el repositorio de Git justo antes de que el equipo cambie a.

La migración lleva mucho tiempo para un repositorio SVN grande.
Pero la actualización de la migración completada es solo unos segundos.

Por supuesto que estoy usando subgit, mamá.git-svn me hace Pantalla azul de muerte.Simplemente constantemente.Y git-svn me está aburriendo con "Git"nombre de archivo demasiado largo" error fatal.

PASOS

1. Descargar SubGit

2. Preparar comandos de migración y actualización.

Digamos que lo hacemos para Windows (es trivial trasladarlo a Linux).
En la instalación de un SubGit papelera directorio (subgit-2.X.X\bin), cree dos archivos .bat.

Contenido de un archivo/comando para la migración:

start    subgit import --svn-url url://svn.serv/Bla/Bla  directory/path/Local.git.Repo

El comando "iniciar" es opcional aquí (Windows).Permitirá ver errores al inicio y dejará un shell abierto después de completar SubGit.

Puedes agregar aquí parámetros adicionales similares a git-svn.estoy usando solo --dominio predeterminado miEmpresaDominio.com para arreglar el dominio de la dirección de correo electrónico de los autores de SVN.
Tengo la estructura del repositorio SVN estándar (tronco/ramas/etiquetas) y no tuvimos problemas con el "mapeo de autores".Así que ya no hago nada.

(Si desea migrar etiquetas como ramas o si su SVN tiene varias carpetas de ramas/etiquetas, puede considerar utilizar el SubGit más detallado acercarse)

Consejo 1:Utilice --minimal-revision YourSvnRevNumber para ver rápidamente cómo se desarrollan las cosas (una especie de depuración).Especialmente útil es ver nombres de autores o correos electrónicos resueltos.
O limitar la profundidad de la historia migratoria.

Consejo 2:La migración puede verse interrumpida (Control + C) y se restaura ejecutando el siguiente comando/archivo de actualización.
No recomiendo hacer esto para repositorios grandes.He recibido "Excepción de Java+Windows sin memoria".

Consejo 3:Es mejor crear una copia de su repositorio básico de resultados.

Contenido de un archivo/comando para actualizar:

start    subgit import  directory/path/Local.git.Repo

Puede ejecutarlo tantas veces como desee cuando desee obtener las confirmaciones del último equipo en su repositorio Git.

¡Advertencia! No toque su repositorio vacío (creación de ramas, por ejemplo).
Cometerás el siguiente error fatal:

Error irrecuperable:no están sincronizados y no se pueden sincronizar...Traduciendo revisiones de Subversion a confirmaciones de Git...

3. Ejecute el primer comando/archivo.Un repositorio grande llevará mucho tiempo.30 horas para mi humilde repositorio.

Es todo.
Puede actualizar su repositorio Git desde SVN en cualquier momento ejecutando el segundo archivo/comando.Y antes de cambiar su equipo de desarrollo a Git.
Sólo te llevará unos segundos.

Hay una tarea más útil.

Empuje su repositorio Git local a un repositorio Git remoto

¿Es tu caso?Procedamos.

Configura tus controles remotos

Correr:

$ git remote add origin url://your/repo.git

Prepárese para el envío inicial de su enorme repositorio Git local a un repositorio remoto

De forma predeterminada, tu Git no puede enviar fragmentos grandes.fatal:El extremo remoto se colgó inesperadamente

Corramos por ello:

git config --global http.postBuffer 1073741824

524288000 - 500 MB 1073741824 - 1 GB, etc.

Arregla tu local problemas con el certificado.Si su servidor git usa un certificado roto.

he inhabilitado certificados.

Además, su servidor Git puede tener un Solicitar limitaciones de monto que deben corregirse.

Impulsar toda la migración al repositorio Git remoto del equipo.

Ejecutar con un Git local:

git push origin --mirror

(git push origen '*:*' para versiones antiguas de Git)

Si obtiene lo siguiente: error:no se puede generar git:El fichero o directorio no existe...A mi la recreación completa de mi repositorio me soluciona este error (30 horas).Puedes probar los siguientes comandos.

git push origin --all
git push origin --tags

O intentar reinstalar Git (inútil para mi).O puede crear ramas a partir de todas sus etiquetas y enviarlas.O, o, o...

reposcirujano

Para casos complicados, reposurgeon por Eric S.raimon es la herramienta de elección.Además de SVN, admite muchos otros sistemas de control de versiones a través del fast-export formato, y también CVS.El autor informa conversiones exitosas de depósitos antiguos como Emacs y FreeBSD.

La herramienta aparentemente apunta a una conversión casi perfecta (como convertir SVN svn:ignore propiedades para .gitignore archivos) incluso para diseños de repositorio difíciles con una larga historia.En muchos casos, otras herramientas pueden resultar más fáciles de utilizar.

Antes de profundizar en la documentación del reposurgeon línea de comando, asegúrese de leer el excelente Guía de migración DVCS que repasa el proceso de conversión paso a paso.

Esta guía en el sitio web de Atlassian es una de las mejores que he encontrado:

https://www.atlassian.com/git/migration

Esta herramienta - https://bitbucket.org/atlassian/svn-migration-scripts - También es muy útil para generar tus autores.txt, entre otras cosas.

Tienes que instalar

git
git-svn

Copiado de este enlace http://john.albin.net/git/convert-subversion-to-git.

1.Recuperar una lista de todos los confirmadores de Subversion

Subversion simplemente enumera el nombre de usuario para cada confirmación.Las confirmaciones de Git tienen datos mucho más completos, pero en su forma más simple, el autor de la confirmación debe tener un nombre y un correo electrónico en la lista.De forma predeterminada, la herramienta git-svn solo incluirá el nombre de usuario SVN en los campos de autor y correo electrónico.Pero con un poco de trabajo, puedes crear una lista de todos los usuarios de SVN y cuáles son sus nombres de Git y correos electrónicos correspondientes.git-svn puede utilizar esta lista para transformar nombres de usuario de svn simples en confirmadores de Git adecuados.

Desde la raíz de su pago local de Subversion, ejecute este comando:

svn log -q | awk -F '|' '/^r/ {sub("^ ", "", $2); sub(" $", "", $2); print $2" = "$2" <"$2">"}' | sort -u > authors-transform.txt

Eso capturará todos los mensajes de registro, extraerá los nombres de usuario, eliminará los nombres de usuario duplicados, ordenará los nombres de usuario y los colocará en un archivo "authors-transform.txt".Ahora edite cada línea del archivo.Por ejemplo, convierta:

jwilkins = jwilkins <jwilkins>

dentro de esto:

jwilkins = John Albin Wilkins <johnalbin@example.com>

2.Clonar el repositorio de Subversion usando git-svn

git svn clone [SVN repo URL] --no-metadata -A authors-transform.txt --stdlayout ~/temp

Esto realizará la transformación estándar de git-svn (usando el archivo autores-transform.txt que creó en el paso 1) y colocará el repositorio de git en la carpeta “~/temp” dentro de su directorio de inicio.

3.Convertir svn: ignorar propiedades a .gitignore

Si su repositorio svn usaba las propiedades svn:ignore, puede convertirlo fácilmente en un archivo .gitignore usando:

cd ~/temp
git svn show-ignore > .gitignore
git add .gitignore
git commit -m 'Convert svn:ignore properties to .gitignore.'

4.Empujar el repositorio a un repositorio git simple

Primero, cree un repositorio simple y haga que su rama predeterminada coincida con el nombre de la rama "troncal" de svn.

git init --bare ~/new-bare.git
cd ~/new-bare.git
git symbolic-ref HEAD refs/heads/trunk

Luego, envíe el repositorio temporal al nuevo repositorio básico.

cd ~/temp
git remote add bare ~/new-bare.git
git config remote.bare.push 'refs/remotes/*:refs/heads/*'
git push bare

Ahora puede eliminar de forma segura el repositorio ~/temp.

5.Cambiar el nombre de la rama "troncal" a "maestra"

Su rama de desarrollo principal se llamará "tronco", que coincide con el nombre que tenía en Subversion.Querrás cambiarle el nombre a la rama "maestra" estándar de Git usando:

cd ~/new-bare.git
git branch -m trunk master

6.Limpiar ramas y etiquetas.

git-svn convierte todas las etiquetas de Subversions en ramas muy cortas en Git con el formato "etiquetas/nombre".Querrás convertir todas esas ramas en etiquetas Git reales usando:

cd ~/new-bare.git
git for-each-ref --format='%(refname)' refs/heads/tags |
cut -d / -f 4 |
while read ref
do
  git tag "$ref" "refs/heads/tags/$ref";
  git branch -D "tags/$ref";
done

Este paso requerirá un poco de escritura.:-) Pero no te preocupes;su shell Unix proporcionará un mensaje secundario para el comando extralargo que comienza con git for-each-ref.

GitHub ahora tiene una función para importar desde un repositorio SVN.Aunque nunca lo intenté.

Una respuesta algo extendida usando solo git, SVN y bash.Incluye pasos para repositorios SVN que no utilizan el diseño convencional con un diseño de directorio troncal/sucursales/etiquetas (SVN no hace absolutamente nada para imponer este tipo de diseño).

Primero use este script bash para escanear su repositorio SVN en busca de las diferentes personas que contribuyeron y generar una plantilla para un archivo de mapeo:

#!/usr/bin/env bash
authors=$(svn log -q | grep -e '^r' | awk 'BEGIN { FS = "|" } ; { print $2 }' | sort | uniq)
for author in ${authors}; do
  echo "${author} = NAME <USER@DOMAIN>";
done

Utilice esto para crear un authors archivo donde asigna nombres de usuario svn a nombres de usuario y correo electrónico según lo establecido por sus desarrolladores usando git config propiedades user.name y user.email (tenga en cuenta que para un servicio como GitHub solo tener un correo electrónico coincidente es suficiente).

Entonces ten git svn clonar el repositorio svn a un repositorio git, informándole sobre el mapeo:

git svn clone --authors-file=authors --stdlayout svn://example.org/Folder/projectroot

Esto puede llevar mucho tiempo, ya que git svn comprobará individualmente cada revisión de cada etiqueta o rama que exista.(tenga en cuenta que las etiquetas en SVN son en realidad ramas, por lo que terminan como tales en Git).Puede acelerar esto eliminando etiquetas y ramas antiguas en SVN que no necesita.

Ejecutar esto en un servidor en la misma red o en el mismo servidor también puede acelerarlo.Además, si por alguna razón este proceso se interrumpe poder reanudarlo usando

git svn rebase --continue

En muchos casos, ya terminaste aquí.Pero si su repositorio SVN tiene un diseño poco convencional en el que simplemente tiene un directorio en SVN que desea colocar en una rama de git, puede realizar algunos pasos adicionales.

Lo más simple es crear un nuevo repositorio SVN en su servidor que siga las convenciones y el uso. svn copy para poner su directorio en una troncal o una rama.Esta podría ser la única manera si su directorio está completamente en la raíz del repositorio, la última vez que probé esto git svn simplemente se negó a realizar el pago.

También puedes hacer esto usando git.Para git svn clone simplemente use el directorio que desea colocar en una rama de git.

Despues de correr

git branch --set-upstream master git-svn
git svn rebase

Tenga en cuenta que esto requería Git 1.7 o superior.

He publicado una guía paso a paso (aquí) para convertir svn a git, incluida la conversión de etiquetas svn a etiquetas git y ramas svn a ramas git.

Version corta:

1) clonar svn desde un número de revisión específico.(el número de revisión debe ser el más antiguo que desea migrar)

git svn clone --username=yourSvnUsername -T trunk_subdir -t tags_subdir -b branches_subdir -r aRevisionNumber svn_url gitreponame

2) recuperar datos svn.Este paso es el que lleva más tiempo.

cd gitreponame
git svn fetch

repita git svn fetch hasta que termine sin error

3) actualizar la rama maestra

git svn rebase

4) Cree sucursales locales a partir de sucursales svn copiando referencias

cp .git/refs/remotes/origin/* .git/refs/heads/

5) convertir etiquetas svn en etiquetas git

git for-each-ref refs/remotes/origin/tags | sed 's#^.*\([[:xdigit:]]\{40\}\).*refs/remotes/origin/tags/\(.*\)$#\2 \1#g' | while read p; do git tag -m "tag from svn" $p; done

6) Coloque un repositorio en un lugar mejor como github.

git remotes add newrepo git@github.com:aUser/aProjectName.git
git push newrepo refs/heads/*
git push --tags newrepo

Si quieres más detalles lee mi correo o pregúntame.

Nosotros podemos usar git svn clone comandos como se muestra a continuación.

svn log -q <SVN_URL> | awk -F '|' '/^r/ {sub("^ ", "", $2); sub(" $", "", $2); print $2" = "$2" <"$2">"}' | sort -u > authors.txt

El comando anterior creará un archivo de autores a partir de confirmaciones SVN.

svn log --stop-on-copy <SVN_URL>

El comando anterior le dará el primer número de revisión cuando se creó su proyecto SVN.

git svn clone -r<SVN_REV_NO>:HEAD --no-minimize-url --stdlayout --no-metadata --authors-file authors.txt <SVN_URL>

El comando anterior creará el repositorio Git en local.

El problema es que no convierte ramas y etiquetas para enviar.Tendrás que hacerlos manualmente.Por ejemplo a continuación para sucursales:

$ git remote add origin https://github.com/pankaj0323/JDProjects.git
$ git branch -a
* master
  remotes/origin/MyDevBranch
  remotes/origin/tags/MyDevBranch-1.0
  remotes/origin/trunk
$$ git checkout -b MyDevBranch origin/MyDevBranch
Branch MyDevBranch set up to track remote branch MyDevBranch from origin.
Switched to a new branch 'MyDevBranch'
$ git branch -a
* MyDevBranch
  master
  remotes/origin/MyDevBranch
  remotes/origin/tags/MyDevBranch-1.0
  remotes/origin/trunk
$

Para etiquetas:

$git checkout origin/tags/MyDevBranch-1.0
Note: checking out 'origin/tags/MyDevBranch-1.0'.
You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b new_branch_name

HEAD is now at 3041d81... Creating a tag
$ git branch -a
* (detached from origin/tags/MyDevBranch-1.0)
  MyDevBranch
  master
  remotes/origin/MyDevBranch
  remotes/origin/tags/MyDevBranch-1.0
  remotes/origin/trunk
$ git tag -a MyDevBranch-1.0 -m "creating tag"
$git tag
MyDevBranch-1.0
$

Ahora envíe master, sucursales y etiquetas al repositorio git remoto.

$ git push origin master MyDevBranch MyDevBranch-1.0
Counting objects: 14, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (11/11), done.
Writing objects: 100% (14/14), 2.28 KiB | 0 bytes/s, done.
Total 14 (delta 3), reused 0 (delta 0)
To https://github.com/pankaj0323/JDProjects.git
 * [new branch]      master -> master
 * [new branch]      MyDevBranch -> MyDevBranch
 * [new tag]         MyDevBranch-1.0 -> MyDevBranch-1.0
$

utilidad svn2git

svn2git La utilidad elimina los esfuerzos manuales con ramas y etiquetas.

Instálalo usando el comando sudo gem install svn2git.Después de eso, ejecute el siguiente comando.

$ svn2git <SVN_URL> --authors authors.txt --revision <SVN_REV_NO>

Ahora puedes enumerar las ramas, etiquetas y enviarlas fácilmente.

$ git remote add origin https://github.com/pankaj0323/JDProjects.git
$ git branch -a
  MyDevBranch
* master
  remotes/svn/MyDevBranch
  remotes/svn/trunk
$ git tag
  MyDevBranch-1.0
$ git push origin master MyDevBranch MyDevBranch-1.0

Imagina que tienes 20 ramas y etiquetas, obviamente svn2git te ahorrará mucho tiempo y por eso me gusta más que los comandos nativos.Es un buen complemento para los nativos. git svn clone dominio.

Para un ejemplo completo, consulte mi Entrada de blog.

TortoiseGit hace esto.vea esta publicación de blog: http://jimmykeen.net/articles/03-nov-2012/how-migrate-from-svn-to-git-windows-using-tortoise-clients

Sí, sé que responder con enlaces no es espléndido pero es una solución, ¿eh?

Recomiendo mucho esto serie corta de screencasts Acabo de descubrir.El autor le guía a través de las operaciones básicas y muestra algunos usos más avanzados.

Si está utilizando SourceTree, puede hacerlo directamente desde la aplicación.Vaya a Archivo -> Nuevo/Clonar y luego haga lo siguiente:

Ingrese la URL SVN remota como "Ruta de origen/URL".
Ingrese sus credenciales cuando se le solicite.
Ingrese la ubicación de la carpeta local como "Ruta de destino".
Dale un nombre.
En las opciones avanzadas, seleccione "GIT" del menú desplegable en "Crear repositorio local de tipo".
Opcionalmente, puede especificar una revisión desde la cual clonar.
Pulsa Clonar.

Abra el repositorio en SourceTree y verá que sus mensajes de confirmación también se han migrado.

Ahora vaya a Repositorio -> Configuración del repositorio y agregue los nuevos detalles del repositorio remoto.Elimine el control remoto SVN si lo desea (lo hice a través de la opción "Editar archivo de configuración").

Envíe el código al nuevo repositorio remoto cuando esté listo y codifique libremente.

Para GitLab usuarios, he explicado lo esencial sobre cómo migre desde SVN aquí:

https://gist.github.com/leftclickben/322b7a3042cbe97ed2af

Pasos para migrar de SVN a GitLab

Configuración

SVN está alojado en svn.domain.com.au.
Se puede acceder a SVN a través de http (otros protocolos deberían funcionar).
GitLab está alojado en git.domain.com.au y:
- Se crea un grupo con el espacio de nombres. dev-team.
- Se crea al menos una cuenta de usuario, se agrega al grupo y tiene una clave SSH para la cuenta que se utiliza para la migración (pruebe usando ssh git@git.domain.com.au).
- El proyecto favourite-project se crea en el dev-team espacio de nombres.
El archivo users.txt contiene los detalles de usuario relevantes, un usuario por línea, del formulario username = First Last <address@domain.com.au>, dónde username es el nombre de usuario proporcionado en los registros SVN.(Consulte el primer enlace en la sección Referencias para obtener más detalles, en particular la respuesta del usuario Casey).

Versiones

versión de subversión 1.6.17 (r1128011)
git versión 1.9.1
GitLab versión 7.2.1 ff1633f
Servidor Ubuntu 14.04

Comandos

bash
git svn clone --stdlayout --no-metadata -A users.txt 
http://svn.domain.com.au/svn/repository/favourite-project
cd favourite-project
git remote add gitlab git@git.domain.com.au:dev-team/favourite-project.git
git push --set-upstream gitlab master

¡Eso es todo!Vuelva a cargar la página del proyecto en la interfaz de usuario web de GitLab y verá todas las confirmaciones y archivos ahora enumerados.

Notas

Si hay usuarios desconocidos, el git svn clone El comando se detendrá, en cuyo caso, se actualizará. users.txt, cd favourite-project y git svn fetch continuará desde donde se detuvo.
El estandar trunk-tags-branches Se requiere diseño para el repositorio SVN.
La URL SVN proporcionada al git svn clone El comando se detiene en el nivel inmediatamente superior. trunk/, tags/ y branches/.
El git svn clone El comando produce muchos resultados, incluidas algunas advertencias en la parte superior;Ignoré las advertencias.

Aparte de eso, el comando git-stash es una bendición cuando se intenta git con git-svn dcommits.

Un proceso típico:

configurar el repositorio de git
trabajar un poco en diferentes archivos
decide verificar parte del trabajo, usando git
decidir svn-dcommit
obtiene el temido error "no se puede confirmar con un índice sucio".

La solución (requiere git 1.5.3+):

git stash; git svn dcommit ; git stash apply

Aquí hay un script de shell simple sin dependencias que convertirá uno o más repositorios SVN a git y los enviará a GitHub.

https://gist.github.com/NathanSweet/7327535

En unas 30 líneas de guión:clona usando git SVN, crea un archivo .gitignore a partir de propiedades SVN::ignore, lo inserta en un repositorio de git simple, cambia el nombre del tronco SVN a maestro, convierte etiquetas SVN en etiquetas git y lo envía a GitHub conservando las etiquetas.

Pasé por muchas dificultades para mover una docena de repositorios SVN de Google Code a GitHub.No ayudó que usara Windows.Ruby estaba completamente roto en mi antiguo sistema Debian y lograr que funcionara en Windows era una broma.Otras soluciones no funcionaron con las rutas de Cygwin.Incluso una vez que algo funcionó, no pude entender cómo hacer que las etiquetas aparecieran en GitHub (el secreto es --follow-tags).

Al final, preparé dos guiones breves y sencillos, vinculados arriba, y funciona muy bien.¡La solución no tiene por qué ser más complicada que eso!

Estoy en una máquina con Windows e hice un pequeño lote para transferir un repositorio SVN con historial (pero sin ramas) a un repositorio GIT con solo llamar

transfer.bat http://svn.my.address/svn/myrepo/trunk https://git.my.address/orga/myrepo

Quizás cualquiera pueda usarlo.Crea una carpeta TMP, verifica el repositorio SVN allí con git, agrega el nuevo origen y lo empuja...y borra la carpeta nuevamente.

@echo off 
SET FROM=%1 
SET TO=%2 
SET TMP=tmp_%random%

echo from:  %FROM% 
echo to:    %TO% 
echo tmp:   %TMP%

pause

git svn clone  --no-metadata --authors-file=users.txt %FROM% %TMP%  
cd %TMP% 
git remote add origin %TO% 
git push --set-upstream origin master


cd .. 
echo delete %TMP% ... 
pause

rmdir /s /q %TMP%

Aún necesitas el archivo users.txt con tus asignaciones de usuarios como

User1 = User One <u.1@xxx.com>

Solo quería agregar mi contribución a la comunidad Git.Escribí un script bash simple que automatiza la importación completa.A diferencia de otras herramientas de migración, esta herramienta se basa en git nativo en lugar de jGit.Esta herramienta también admite repositorios con un gran historial de revisiones o blobs de gran tamaño.Está disponible a través de github:

https://github.com/onepremise/SGMS

Este script convertirá proyectos almacenados en SVN con el siguiente formato:

/trunk
  /Project1
  /Project2
/branches
     /Project1
     /Project2
/tags
 /Project1
 /Project2

Este esquema también es popular y compatible:

/Project1
     /trunk
     /branches
     /tags
/Project2
     /trunk
     /branches
     /tags

Cada proyecto se sincronizará por nombre de proyecto:

Ex: ./migration https://svnurl.com/basepath project1

Si desea convertir el repositorio completo, utilice la siguiente sintaxis:

Ex: ./migration https://svnurl.com/basepath .

Usar Git de manera efectiva con Subversion es una suave introducción a git-svn.Para los repositorios SVN existentes, git-svn hace que esto sea muy fácil.Si está iniciando un nuevo repositorio, es mucho más fácil crear primero un repositorio SVN vacío y luego importarlo usando git-svn que ir en la dirección opuesta.Se puede crear un nuevo repositorio de Git y luego importarlo a SVN, pero es un poco doloroso, especialmente si eres nuevo en Git y esperas preservar el historial de confirmaciones.

Descargue el instalador de Ruby para Windows e instale la última versión con él.Agregue ejecutables de Ruby a su ruta.

Instalar svn2git
Menú Inicio -> Todos los programas -> Ruby -> Iniciar un símbolo del sistema con Ruby
Luego escribe “gem install svn2git” e ingresa

Migrar el repositorio de Subversion
Abra un símbolo del sistema de Ruby y vaya al directorio donde se van a migrar los archivos.

Entonces svn2git http://[dominio nombre]/svn/ [raíz del repositorio]
Puede llevar algunas horas migrar el proyecto a Git dependiendo del tamaño del código del proyecto.
Este paso importante ayuda a crear la estructura del repositorio Git como se menciona a continuación.

SVN (/Project_Components) Trunk -> Git Master Svn (/Project_Components) Ramas -> Ramas Git Svn (/Project_Components) Etiquetas -> Etiquetas Git

Cree el repositorio remoto y envíe los cambios.

GitHub tiene un importador.Una vez que haya creado el repositorio, puede importar desde un repositorio existente, a través de su URL.Le pedirá sus credenciales, si corresponde, y continuará desde allí.

Mientras se ejecuta, encontrará autores y podrá simplemente asignarlos a los usuarios en GitHub.

¡Lo he usado para algunos repositorios ahora, y es bastante preciso y también mucho más rápido!Le tomó 10 minutos a un repositorio con ~4000 confirmaciones, ¡y después a mi amigo le tomó cuatro días!

Varias respuestas aquí se refieren a https://github.com/nirvdrum/svn2git, pero para repositorios grandes esto puede resultar lento.Intenté usar https://github.com/svn-all-fast-export/svn2git en cambio, es una herramienta con exactamente el mismo nombre pero que se usó para migrar KDE de SVN a Git.

Un poco más de trabajo para configurarlo, pero cuando lo hice, la conversión en sí me tomó minutos, mientras que el otro script pasó horas.

Existen diferentes métodos para lograr este objetivo.Probé algunos de ellos y encontré uno que realmente funciona con solo git y svn instalados en el sistema operativo Windows.

Requisitos previos:

git en windows (he usado este) https://git-scm.com/
svn con herramientas de consola instaladas (he usado tortoise svn)
Archivo de volcado de su repositorio SVN.svnadmin dump /path/to/repository > repo_name.svn_dump

Pasos para lograr el objetivo final (mover todo el repositorio con historial a un git, primero un git local y luego un git remoto)

Cree un repositorio vacío (usando herramientas de consola o tortoiseSVN) en el directorio REPO_NAME_FOLDERcd REPO_NAME_PARENT_FOLDER, coloque dumpfile.dump en REPO_NAME_PARENT_FOLDER
svnadmin load REPO_NAME_FOLDER < dumpfile.dump Espere esta operación, puede que sea larga.
Este comando es silencioso, así que abra la segunda ventana de cmd: svnserve -d -R --root REPO_NAME_FOLDER ¿Por qué no usar file:///......??Porque el siguiente comando fallará con Unable to open ... to URL:, gracias a la respuesta https://stackoverflow.com/a/6300968/4953065
Crear nueva carpeta SOURCE_GIT_FOLDER
cd SOURCE_GIT_FOLDER
git svn clone svn://localhost/ Espere esta operación.

Finalmente, ¿qué tenemos?

Revisemos nuestro repositorio local:

git log

¿Ves tus compromisos anteriores?Si es así, está bien

Ahora tiene un repositorio git local completamente funcional con sus fuentes y su antiguo historial de svn.Ahora, si desea moverlo a algún servidor, use los siguientes comandos:

git remote add origin https://fullurlpathtoyourrepo/reponame.git
git push -u origin --all # pushes up the repo and its refs for the first time
git push -u origin --tags # pushes up any tags

En mi caso, no necesito el comando de etiquetas porque mi repositorio no tiene etiquetas.

¡Buena suerte!

Convirtiendo el submódulo/carpeta svn 'MyModule' en git con historial sin etiquetas ni ramas.

Git SVN Clone-No-Metadata --trunk = SomeFolder1/SomeFolder2/SomeFolder3/MyModule http://svnhost:puerto/repo_root_folder/MyModule_temp -A c: cheetah svn authors-transform.txt
git clone MiMódulo_temp MiMódulo
cd Mi módulo
inicio de flujo de git
origen remoto de configuración de URL de githttps://userid@stashhost/stash/scm/xyzxyz/MyModule.git
git push -u origen maestro
git push -u origen desarrollar

Para conservar la lista de ignorados de svn, utilice los comentarios anteriores después del paso 1

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow