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 instrucciones simples como:

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

Repositorio de 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, solo para decir qué pasos tomar en este ejemplo.

Magia:

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

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

$ git svn --help

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 usar esta línea para crear una plantilla desde 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 perdido 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 dest_dir-tmpy comenzará a extraer el repositorio SVN. Tenga en cuenta que el indicador "--stdlayout" implica que tiene el diseño SVN "troncal /, ramas /, etiquetas /" común. Si sus difiere de diseño, se familiaricen con --tags, --branches, --trunkopciones (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 . La cadena de URL no debe incluir /trunk, /tago /branches.

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

También tenga en cuenta que si omite el --no-metadataindicador, 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.txtarchivo y luego:

cd dest_dir-tmp
git svn fetch

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

git svn fetch

Cuando se complete, Git registrará el SVN trunken una nueva sucursal. Cualquier otra rama se configura como control remoto. Puede ver las otras ramas SVN con:

git branch -r

Si desea mantener otras ramas remotas en su repositorio, desea crear una rama local para cada una manualmente. (Omita troncal / 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. Debe crear una rama local, hacer 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

Clone su repositorio GIT-SVN en un repositorio Git limpio:

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

Las ramas locales que creó anteriormente desde ramas remotas solo se habrán copiado como ramas remotas en el nuevo repositorio clonado. (Omita troncal / 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 de Subversion a un repositorio de Git . Primero debe crear un archivo que asigne sus nombres de autor de confirmación de Subversion a los responsables de Git ~/authors.txt.

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

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

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

Si está en una Mac, puede obtenerla git-svnde MacPorts mediante la instalación git-core +svn.

Si su repositorio de subversion está en la misma máquina que su repositorio git deseado, entonces puede usar esta sintaxis para el paso de inicio, de lo contrario de todos modos:

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

He utilizado el guión svn2git y funciona como un encanto.

Sugiero que se sienta cómodo con Git antes de intentar usar git-svn constantemente, es decir, mantener SVN como repositorio centralizado y usar Git localmente.

Sin embargo, para una migración simple con todo el historial, estos son algunos pasos simples:

Inicialice el repositorio local:

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

Marque cuánto tiempo atrás desea comenzar a importar revisiones:

git svn fetch -r42

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

En realidad, busca todo desde entonces:

git svn rebase

Puede verificar 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 llevarlo 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 combine automáticamente el maestro remoto con su maestro local, cuando ambos contienen cosas nuevas:

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

Después de eso, puede estar interesado en probar mi propia git_remote_branchherramienta, que ayuda a tratar con sucursales remotas:

Primera publicación explicativa: " Ramas remotas de Git "

Seguimiento de la versión más reciente: " Hora de colaborar con git_remote_branch "

Hay una nueva solución para la migración sin problemas de Subversion a Git (o para usar ambos simultáneamente): SubGit .

Estoy trabajando en este proyecto yo mismo. 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, debe ejecutar:

$ subgit install svn_repos
...
TRANSLATION SUCCESSFUL 

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

En caso de que su repositorio Subversion contenga múltiples proyectos, se crearán múltiples 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 git-svn) y comenzar a usarlo mientras mantiene Subversion todo el tiempo que lo necesite (por ejemplo, para sus herramientas de compilación ya configuradas).

¡Espero que esto ayude!

Consulte la página de manual oficial de git-svn . En particular, busque en "Ejemplos básicos":

Seguimiento y contribución a todo un proyecto administrado por Subversion (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 (frente a 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 gran repositorio.
Por supuesto que necesitas algo de preparación.
Pero no puede detener el proceso de desarrollo, en absoluto.

Aquí está mi camino.

Mi solución se ve así:

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

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

Por supuesto que estoy usando SubGit , mamá. git-svn me hace pantalla azul de la muerte . Solo constantemente. Y git-svn me está aburriendo con el error fatal " nombre de archivo demasiado largo " de Git .

PASOS

1. Descargar SubGit

2. Prepare los comandos de migración y actualización.

Digamos que lo hacemos para Windows (es trivial portar a Linux).
En el directorio bin de instalación de SubGit (subgit-2.XX \ 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 "inicio" es opcional aquí (Windows). Permitirá ver errores al inicio y dejará un shell abierto después de completar el SubGit.

Puede agregar aquí parámetros adicionales similares a git-svn . Solo estoy usando --default-domain myCompanyDomain.com para arreglar el dominio de la dirección de correo electrónico de los autores SVN.
Tengo la estructura del repositorio SVN estándar (troncal / ramas / etiquetas) y no tuvimos problemas con el "mapeo de autores". Así que ya no estoy haciendo nada más.

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

Consejo 1 : Use --minimal-revision YourSvnRevNumber para ver rápidamente cómo se resuelven las cosas (algún tipo de depuración). Especialmente útil es ver nombres de autores resueltos o correos electrónicos.
O para limitar la profundidad del historial de migración.

Consejo 2 : La migración puede interrumpirse ( Ctrl+ C) y restaurarse ejecutando el siguiente comando / archivo de actualización.
No aconsejo hacer esto para grandes repositorios. Recibí la excepción "Memoria insuficiente Java + Windows".

Consejo 3 : es mejor crear una copia de su repositorio de resultados.

Contenido de un archivo / comando para actualizar:

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

Puede ejecutarlo cualquier cantidad de veces cuando desee obtener las confirmaciones del último equipo en su repositorio de Git.

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

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

3. Ejecute el primer comando / archivo. Tomará mucho tiempo para un gran repositorio. 30 horas para mi humilde repositorio.

Es todo
Puede actualizar su repositorio Git desde SVN en cualquier momento y cualquier cantidad de tiempo ejecutando el segundo archivo / comando. Y antes de cambiar de equipo de desarrollo a Git.
Tomará solo unos segundos.

Hay una tarea más útil.

Empuje su repositorio Git local a un repositorio Git remoto

¿Es tu caso? Vamos a proceder

1. Configura tus controles remotos

Correr:

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

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

Por defecto, su Git no puede enviar grandes fragmentos. fatal: el extremo remoto colgó inesperadamente

Corramos por ello:

git config --global http.postBuffer 1073741824

524288000 - 500 MB 1073741824 - 1 GB, etc.

Solucione sus problemas de certificados locales . Si su servidor git usa un certificado roto.

He deshabilitado los certificados .

Además, su servidor Git puede tener limitaciones de cantidad de solicitud que deben corregirse .

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

Ejecutar con un Git local:

git push origin --mirror

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

Si obtiene lo siguiente: error: no puede generar git: No existe tal archivo o directorio ... Para mí, la recreación completa de mi repositorio resuelve este error (30 horas). Puedes probar los siguientes comandos

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

O intenta reinstalar Git ( inútil para mí ). O puede crear ramas a partir de todas sus etiquetas y empujarlas. O, o, o ...

reposurgeon

Para casos complicados, el resurgimiento de Eric S. Raymond es la herramienta de elección. Además de SVN, admite muchos otros sistemas de control de versiones a través del fast-exportformato, y también CVS . El autor informa de conversiones exitosas de repositorios antiguos como Emacs y FreeBSD .

Aparentemente, la herramienta apunta a una conversión casi perfecta (como convertir las svn:ignorepropiedades de SVN en .gitignorearchivos) incluso para diseños de repositorio difíciles con una larga historia. Para muchos casos, otras herramientas pueden ser más fáciles de usar.

Antes de profundizar en la documentación de la reposurgeonlínea de comandos, asegúrese de leer la excelente guía de migración de DVCS que explica 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 realmente útil para generar su author.txt, entre otras cosas.

Tienes que instalar

git
git-svn

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

1. Recupere una lista de todos los confirmadores de Subversion

Subversion simplemente enumera el nombre de usuario para cada confirmación. Los commits de Git tienen datos mucho más ricos, pero en su forma más simple, el autor del commit debe tener un nombre y un correo electrónico en la lista. Por defecto, la herramienta git-svn solo mostrará el nombre de usuario SVN en los campos de autor y correo electrónico. Pero con un poco de trabajo, puede crear una lista de todos los usuarios de SVN y cuáles son sus correspondientes nombres de Git y correos electrónicos. Esta lista puede ser utilizada por git-svn para transformar nombres de usuario simples de svn 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, eliminará los nombres de usuario, eliminará cualquier nombre de usuario duplicado, clasificará los nombres de usuario y los colocará en un archivo "author-transform.txt". Ahora edite cada línea en el archivo. Por ejemplo, convertir:

jwilkins = jwilkins <jwilkins>

dentro de esto:

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

2. Clone el repositorio de Subversion usando git-svn

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

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

3. Convierta svn: ignore las propiedades a .gitignore

Si su repositorio svn estaba usando svn: ignore propiedades, puede convertirlo fácilmente a un archivo .gitignore usando:

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

4. Empuje el repositorio a un repositorio de git desnudo

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

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

Luego empuje el repositorio temporal al nuevo repositorio desnudo.

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. Cambie el nombre de la rama "troncal" a "maestro"

Su rama de desarrollo principal se llamará "troncal", 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 Subversiones en ramas muy cortas en Git con la forma "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 llevará un poco de escritura. :-) Pero no te preocupes; su shell de Unix proporcionará una solicitud secundaria para el comando extralargo que comienza con git for-each-ref.

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

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

Primero use este script bash para escanear su repositorio SVN para las diferentes personas que contribuyeron y para 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

Use esto para crear un authorsarchivo donde asigne los nombres de usuario svn a nombres de usuario y correo electrónico según lo establecido por sus desarrolladores usando git configpropiedades user.namey user.email(tenga en cuenta que para un servicio como GitHub solo es suficiente tener un correo electrónico coincidente).

Luego git svnclone el repositorio svn en un repositorio git, contándole sobre el mapeo:

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

Esto puede tomar mucho tiempo, ya que git svn verificará individualmente cada revisión para cada etiqueta o rama que exista. (tenga en cuenta que las etiquetas en SVN son realmente 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 acelerar esto realmente. Además, si por algún motivo este proceso se interrumpe, puede reanudarlo usando

git svn rebase --continue

En muchos casos has terminado aquí. Pero si su repositorio SVN tiene un diseño no convencional en el que simplemente tiene un directorio en SVN que desea colocar en una rama git, puede hacer algunos pasos adicionales.

Lo más simple es hacer un nuevo repositorio SVN en su servidor que siga la convención y lo use svn copypara poner su directorio en el tronco o una rama. Esta podría ser la única manera si su directorio está en la raíz del repositorio, cuando lo intenté por última vez, git svnsimplemente se negó a hacer un pago.

También puedes hacer esto usando git. Para git svn cloneutilizar simplemente el directorio que desea poner en una rama git.

Despues de correr

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

Tenga en cuenta que esto requiere Git 1.7 o superior.

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

Version corta:

1) clonar svn a partir de 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) buscar datos svn. Este paso es el que lleva más tiempo.

cd gitreponame
git svn fetch

repita git svn fetch hasta que finalice sin error

3) obtener la rama maestra actualizada

git svn rebase

4) Crear ramas locales a partir de ramas 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) Pon 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 publicación o pregúntame.

Podemos usar los git svn clonecomandos de la siguiente manera.

• 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 de Git en local.

El problema es que no convertirá ramas y etiquetas para empujar. Tendrás que hacerlos manualmente. Por ejemplo a continuación para las ramas:

$ 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 empuje master, ramas y etiquetas al repositorio remoto de git.

$ 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

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

Instálalo usando el comando sudo gem install svn2git. Después de eso, ejecuta debajo del comando.

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

Ahora puede enumerar las ramas, etiquetas y empujarlas 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 es por eso que me gusta más que los comandos nativos. Es un buen envoltorio alrededor del git svn clonecomando nativo .

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 esta breve serie de screencasts que acabo de descubrir. El autor lo 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. Ir a archivo -> Nuevo / Clonar y luego hacer lo siguiente:

1. Ingrese la URL SVN remota como la "Ruta de origen / URL".
2. Ingrese sus credenciales cuando se le solicite.
3. Ingrese la ubicación de la carpeta local como la "Ruta de destino".
4. Dale un nombre.
5. En las opciones avanzadas, seleccione "Git" del menú desplegable en "Crear repositorio local de tipo".
6. Opcionalmente, puede especificar una revisión para clonar.
7. Hit Clone.

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

Ahora vaya a Repositorio -> Configuración de 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".

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

Para los usuarios de GitLab , he explicado cómo migré desde SVN aquí:

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

Pasos para migrar de SVN a GitLab

Preparar

• 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.auy:
  • 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 usa para la migración (prueba usando ssh git@git.domain.com.au ).
  • El proyecto favourite-projectse crea en el dev-teamespacio de nombres.
• El archivo users.txtcontiene los detalles relevantes del usuario, un usuario por línea, del formulario username = First Last <address@domain.com.au>, dondeusername encuentra el nombre de usuario proporcionado en los registros SVN. (Consulte el primer enlace en la sección Referencias para obtener detalles, en particular la respuesta del usuario Casey).

Versiones

• Subversion versió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! 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 clonecomando se detendrá, en cuyo caso, actualizar users.txt, cd favourite-projecty git svn fetchcontinuará desde donde se detuvo.
• El estándar trunk- tags- branchesSe requiere el diseño de repositorio de subversion.
• La URL SVN dada al git svn clonecomando se detiene en el nivel inmediatamente superior trunk/, tags/ybranches/ .
• El git svn clonecomando produce una gran cantidad de resultados, incluidas algunas advertencias en la parte superior; Ignoré las advertencias.

Como otro lado, el comando git-stash es un regalo del cielo cuando se trata de git con git-svn dcommits.

Un proceso típico:

1. configurar git repo
2. hacer algo de trabajo en diferentes archivos
3. decide revisar parte del trabajo en, usando git
4. decidir svn-dcommit
5. obtener 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 empujará a GitHub.

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

En aproximadamente 30 líneas de script: clona usando git SVN, crea un archivo .gitignore de SVN :: ignora propiedades, empuja a un repositorio git desnudo, renombra SVN trunk a master, convierte etiquetas SVN a etiquetas git y lo empuja a GitHub mientras conserva las etiquetas.

Me costó mucho mover una docena de repositorios SVN de Google Code a GitHub. No ayudó que usara Windows. Ruby estaba roto en mi vieja caja de Debian y hacer que funcionara en Windows fue una broma. Otras soluciones no funcionaron con las rutas de Cygwin. Incluso una vez que conseguí que algo funcionara, no pude averiguar cómo hacer que las etiquetas se muestren en GitHub (el secreto es --follow-tags).

Al final, improvisé dos scripts cortos y simples, vinculados anteriormente, y funciona muy bien. ¡La solución no necesita ser más complicada que eso!

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

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

Quizás cualquiera pueda usarlo. Crea una carpeta TMP, comprueba el repositorio SVN allí con git y agrega el nuevo origen y lo empuja ... y elimina 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%

Todavía necesita users.txt con sus asignaciones de usuario 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 y / o grandes blobs. 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, use la siguiente sintaxis:

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

Efectivamente usando Git con Subversion es una introducción suave a git-svn. Para los repositorios SVN existentes, git-svn hace esto súper fácil. Si está comenzando un nuevo repositorio, es mucho más fácil crear primero un repositorio SVN vacío y luego importar 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 Ruby a su ruta.

• Instalar svn2git
• Menú de inicio -> Todos los programas -> Ruby -> Iniciar un símbolo del sistema con Ruby

• Luego escriba "gem install svn2git" e ingrese

  Migrar el repositorio de Subversion

• Abra un símbolo del sistema de Ruby y vaya al directorio donde se migrarán los archivos

  Entonces svn2git http: // [ nombre de dominio ] / svn / [raíz del repositorio]

• La migración del proyecto a Git puede demorar algunas horas dependiendo del tamaño del código del proyecto.

• Este paso importante ayuda a crear la estructura del repositorio de Git como se menciona a continuación.

  Troncal SVN (/ Project_components) -> Ramas de Git master SVN (/ Project_components) -> Ramas de Git Etiquetas SVN (/ Project_components) -> Etiquetas de Git

Cree el repositorio remoto y empuje 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 partirá de allí.

A medida que se ejecuta, encontrará autores, y simplemente puede asignarlos a los usuarios en GitHub.

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

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

Un poco más de trabajo para configurarlo, pero cuando terminé la conversión en sí, me llevó minutos donde el otro script pasó horas.

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

Prerrequisitos:

1. git en windows (he usado este) https://git-scm.com/
2. svn con herramientas de consola instaladas (he usado tortuga svn)
3. Volcar el archivo 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 git local, luego remoto)

1. Cree un repositorio vacío (usando herramientas de consola o tortoiseSVN) en el directorio REPO_NAME_FOLDER cd REPO_NAME_PARENT_FOLDER, coloque dumpfile.dump en REPO_NAME_PARENT_FOLDER

2. svnadmin load REPO_NAME_FOLDER < dumpfile.dump Espera esta operación, puede ser larga

3. Este comando es silencioso, así que abra la segunda ventana de cmd: svnserve -d -R --root REPO_NAME_FOLDER ¿Por qué no simplemente usar el archivo: /// ......? Porque el siguiente comando fallará Unable to open ... to URL:, gracias a la respuesta https://stackoverflow.com/a/6300968/4953065

4. Crear nueva carpeta SOURCE_GIT_FOLDER

5. cd SOURCE_GIT_FOLDER
6. git svn clone svn: // localhost / Espere esta operación.

Finalmente, ¿qué tenemos?

Vamos a ver nuestro repositorio local:

git log

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

Entonces 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 svn submodule / folder 'MyModule' en git con historial sin etiquetas ni ramas.

• git svn clone --no-metadata --trunk = SomeFolder1 / SomeFolder2 / SomeFolder3 / MyModule http: // svnhost: port / repo_root_folder / MyModule_temp -A C: \ cheetah \ svn \ autores-transform.txt
• git clone MyModule_temp MyModule
• cd MyModule
• git flow init
• origen de set-url remoto de git https: //userid@stashhost/stash/scm/xyzxyz/MyModule.git
• git push -u maestro de origen
• git push -u origen desarrollar

Para retener svn ignore list, use los comentarios anteriores después del paso 1