Enviar un repositorio git existente a SVN

Así es como lo hicimos funcionar:

Clona tu repositorio git en cualquier lugar de tu máquina. Abrir .git / config y añadir lo siguiente (desde http://www.kerrybuckley.org/2009/10/06/maintaining-a-read-only-svn-mirror-of-a-git-repository/):

[svn-remote "svn"]
    url = https://your.svn.repo
    fetch = :refs/remotes/git-svn

Ahora, desde una ventana de consola, escriba estos:

git svn fetch svn
git checkout -b svn git-svn
git merge master

Ahora, si se rompe aquí por cualquier razón, escriba estas 3 líneas :

git checkout --theirs .
git add .
git commit -m "some message"

Y finalmente, puedes comprometerte a svn

git svn dcommit

Nota: Siempre desecho esa carpeta después.

Salud !

Usar git rebase directamente perderá la primera confirmación. Git lo trata diferente y no puede rebase.

Hay un procedimiento que preservará la historia completa: http://kerneltrap.org/mailarchive/git/2008/10/26/3815034

Transcribiré la solución aquí, pero los créditos son para Björn.

Inicializar git-svn:

git svn init -s --prefix=svn/ https://svn/svn/SANDBOX/warren/test2

El prefijo --le da ramas de seguimiento remoto como "svn / trunk" que es agradable porque no obtienes nombres ambiguos si llamas su local rama sólo "tronco" entonces. And-s es un atajo para el estándar diseño de tronco / etiquetas / ramas.

Obtener el material inicial de svn:

git svn fetch

Ahora busca el hash de tu commit raíz (debería mostrar un solo commit):

git rev-list --parents master | grep '^.\{40\}$'

Luego obtiene el hash de la confirmación del tronco vacío:

git rev-parse svn/trunk

Crear el injerto:

echo <root-commit-hash> <svn-trunk-commit-hash> >> .git/info/grafts

Ahora, "gitk" debería mostrar svn / trunk como la primera confirmación en la que su la rama principal está basada.

Hacer el injerto permanente:

git filter-branch -- ^svn/trunk --all

Suelta el injerto:

rm .git/info/grafts

Gitk todavía debería mostrar svn / trunk en la ascendencia de master

Linealiza tu historial en la parte superior del tronco:

git svn rebase

Y ahora "git svn dcommit-n" debería decirte que va a enviar al baúl.

git svn dcommit

Cree un nuevo directorio en el repositorio subversion para su proyecto.

# svn mkdir --parents svn://ip/path/project/trunk

Cambie a su proyecto administrado por Git e inicialice git-svn.

# git svn init svn://ip/path/project -s
# git svn fetch

Esto creará una única confirmación porque el directorio del proyecto svn todavía está vacío. Ahora rebase todo en ese commit, git svn dcommit y debería haber terminado. Sin embargo, arruinará seriamente tus fechas de confirmación.

Git - > SVN con historial completo de confirmaciones

Tenía un proyecto git y tuve que moverlo a SVN. Así es como lo hice, manteniendo todo el historial de commits. Lo único que se pierde es el tiempo de confirmación original ya que libSVN establecerá la hora local cuando ejecutemos svn dcommit.

Como:

1) Tener un repositorio svn donde queremos importar nuestro material y clonarlo con git-svn:

git svn clone https://path.to/svn/repository repo.git-svn

2) Go hay:

cd repo.git-svn

3) Añadir el remoto del repositorio git (en este ejemplo Im usando C:/Projects/repo.git) desea enviar a svn y darle el nombre old-git:

git remote add old-git file:///C/Projects/repo.git/

4) obtiene la información de la rama master del repositorio old-git al repositorio actual:

git fetch old-git master

5) checkout la rama maestra del antiguo-git remoto en una nueva rama llamada old en el repositorio actual:

git checkout -b old old-git/master

6) Rebase para poner el La cabeza en la parte superior de old-git / master. Esto mantendrá todos tus commits. Lo que esto hace básicamente es tomar todo el trabajo realizado en git y ponerlo encima del trabajo al que está accediendo desde svn.

git rebase master

7) Ahora vuelve a tu rama maestra:

git checkout master

Y puedes ver que tienes un historial de confirmaciones limpio. Esto es lo que quieres enviar a svn.

8) Envía tu trabajo a svn:

git svn dcommit

Eso es todo. Muy limpio, sin hacking, todo funciona perfectamente fuera de la caja. Disfrutar.

Yo propondría una instrucción muy corta en 4 comandos usando SubGit. Vea este post para más detalles.

Http://code.google.com/p/support/wiki/ImportingFromGit

Necesitaba confirmar mi repositorio Git existente a un repositorio SVN vacío.

Así es como me las arreglé para hacer esto:

$ git checkout master
$ git branch svn
$ git svn init -s --prefix=svn/ --username <user> https://path.to.repo.com/svn/project/
$ git checkout svn
$ git svn fetch
$ git reset --hard remotes/svn/trunk
$ git merge master
$ git svn dcommit

Funcionó sin problemas. Espero que esto ayude a alguien.

Dado que tuve que autorizarme con un nombre de usuario diferente al repositorio svn (mi origen usa autenticación de clave privada/pública), tuve que usar la propiedad username username.

Si quieres seguir trabajando con git como tu repositorio principal y solo necesitas "exportar" las revisiones a svn de vez en cuando, puedes usar tailor para mantener el repositorio svn sincronizado. Puede copiar revisiones entre diferentes sistemas de control de código fuente y actualizaría el svn con los cambios que realice en git.

No he probado una conversión git -> svn, pero para un ejemplo de svn -> svn vea esta respuesta.

Si no tienes que usar ningún svn específico y estás usando Github puedes usar su conector svn.

Más información aquí https://github.com/blog/1178-collaborating-on-github-with-subversion

Me gustaría compartir una gran herramienta que se utiliza en la comunidad de WordPress llamada Scatter

Http://evansolomon.me/notes/git-wordpress-plugins-and-a-bit-of-sanity-scatter /

Esto permite a los usuarios enviar su repositorio git a WordPress.org SVN automáticamente. En teoría, este código se puede aplicar a cualquier repositorio SVN.

Puede hacer un nuevo repositorio svn. Exporta tu proyecto git (desarrollando el .archivos git). Agrégalo al repositorio svn (inicializando el repositorio con lo que tenías hasta ahora en git). A continuación, utilice las instrucciones para importar repositorios svn en un proyecto git nuevo.

Pero esto perderá su historial anterior de git.

Solo quiero compartir algo de mi experiencia con la respuesta aceptada. Hice todos los pasos y todo estaba bien antes de ejecutar el último paso

git svn dcommit

Git git svn dcommit

Uso del valor no inicializado $u en sustitución (s///) en /usr/lib/perl5/vendor_perl/5.22/Git/SVN.pm línea 101.

Uso del valor no inicializado u u en la concatenación (.) o cadena en /usr/lib/perl5/vendor_perl/5.22/Git / SVN.pm línea 101. refs / mandos a distancia / origen / CABEZA: " https://192.168.2.101/svn/PROJECT_NAME 'no se encuentra en"

Encontré este hilo https://github.com/nirvdrum/svn2git/issues/50

Y finalmente la solución que apliqué en el siguiente archivo en la línea 101 / usr / lib / perl5 / vendor_perl / 5.22/Git / SVN.pm

Sustituí

$u =~ s!^\Q$url\E(/|$)!! or die

I sustituye por

if(!$u) {
    $u = $pathname;
}else {
    $u =~ s!^\Q$url\E(/|$)!! or die
    "$refname: '$url' not found in '$u'\n";
}

Esto solucionó mi problema

En mi caso, tuve que iniciar un proyecto limpio desde SVN

$ Project> git svn init protocol://path/to/repo -s
$ Project> git svn fetch

Agrega todas las fuentes de tu proyecto...

$ Project> git add .
$ Project> git commit -m "Importing project sources"
$ Project> git svn dcommit

Sé que esta es una pregunta muy antigua, pero recientemente tuve que migrar varios repositorios Git a SVN, y después de probar todas las soluciones que pude encontrar, lo que finalmente funcionó para mí fue Mercurial (sí, usando un tercero VCS). Usando esta guía, se me ocurrió el siguiente proceso (en Linux, pero la idea básica debería funcionar también en Windows).

1. Los paquetes necesarios:

   $ sudo apt-get install git subversion mercurial python-subversion
   

2. Mercurial necesita ser configurado agregando el siguiente a ~/.hgrc:

   [extensions]
   hgext.convert=
   

3. Crear algunos directorios de trabajo temporales (tenía varios repositorios para migrar, así que creé directorios para las versiones SVN y Git, para mantenerlos separados):

   $ mkdir svn
   $ mkdir git
   

4. Hacer un repositorio SVN local vacío:

   $ svnadmin create svn/project
   

5. Clona el repositorio Git existente:

   $ git clone server/path/project.git git/project
   

6. Deja que Mercurial haga lo suyo: {[21]]}

   $ hg convert --dest-type svn git/project svn/project
   

7. Ahora el repositorio SVN debería contener el historial completo de confirmaciones, pero no con las marcas de tiempo originales. Si esto no es un problema, omita la siguiente parte al paso 11.

8. Con un poco de trabajo, la fecha y hora de cada confirmación se puede cambiar. Dado que mis repositorios son bastante pequeños, era factible para mí hacerlo manualmente. Primero, cree un gancho pre-revprop-change en el repositorio SVN con el siguiente contenido, para permitir que se modifique la propiedad necesaria:

   #!/bin/bash
   exit 0;
   

   Este script tiene que ser ejecutable:

   $ chmod +x svn/project/hooks/pre-revprop-change
   

9. Mercurial se creó una copia de trabajo del repositorio SVN, llamado project - wc, así que cambie a él y edite los tiempos de confirmación:

   $ cd project-wc
   $ svn propedit svn:date --revprop -r 1
   

   Ingrese la fecha y hora correctas (¡preste atención a las zonas horarias!) y guardar, debería recibir un mensaje que diga "Set new value for property svn: date on revision 1".
   Ahora enjuague y repita para cada otra revisión.

10. Opcionalmente verifique el historial de confirmaciones para asegurarse de que todo se vea bien:

    $ svn log -r 1:HEAD
    

    Entonces vuelve a subir uno nivel:

    $ cd ..
    

11. Volcar el repositorio:

    $ svnadmin dump svn/project > project.dump
    

12. Y cargue el volcado en su servidor Subversion. Hecho!

Este proceso probablemente también trabajaría directamente entre repositorios remotos, pero me pareció más fácil trabajar con repositorios locales. Arreglar los tiempos de confirmación fue mucho trabajo, pero en general el proceso fue mucho más sencillo que cualquier otro método que encontré.

Otra secuencia que funcionó (con algunos comentarios en cada paso):

1. instalar git-svn y subversion conjuntos de herramientas:

sudo apt-get install git-svn subversion

1. cambiar dentro de la PROJECT_FOLDER

cd PROJECT_FOLDER

1. crear la ruta del proyecto en el servidor Subversion (desafortunadamente el plugin actual git-svn tiene un defecto en comparación con TortoiseSVN) no es capaz de almacenar el código fuente directamente en el PROJECT_FOLDER en su lugar por defecto cargará todo el código en PROJECT_FOLDER/trunk

svn mkdir --parents protocol:///path/to/repo/PROJECT_FOLDER/trunk -m "creating git repo placeholder" este es el lugar donde trunk al final del camino es obligatorio

1. inicializar git-svn el contexto del plugin dentro de la carpeta .git

git svn init -s protocol:///path/to/repo/PROJECT_FOLDER este es el lugar donde trunk al final del camino es innecesario

1. obtener una información de repositorio vacía Subversion

git svn fetch este paso ayuda a sincronizar el servidor Subversion con el complemento git-svn. este es el momento en que git-svn plugin establece remotes/origin ruta y la asocia con la subcarpeta trunk en el lado del servidor

1. rebase old git las confirmaciones ocurrieron antes de que el complemento git-svn se involucrara en el proceso (este paso es opcional)

git rebase origin/trunk

1. agregue archivos nuevos / modificados a commit (este paso es regular para las actividades git y es opcional)

git add .

1. confirme los archivos recién agregados en el repositorio local git (esto el paso es opcional y solo es aplicable si se ha utilizado el paso 7)

git commit -m "Importing git repo"

1. enviando todo el historial de cambios del proyecto al servidor Subversion

git svn dcommit

¿Qué pasa si no quieres enviar CADA confirmación que hagas en Git al repositorio SVN? ¿Qué pasa si solo quieres enviar confirmaciones selectivamente por la tubería? Bien. Tengo una mejor solución.

Guardo un repositorio git local donde todo lo que hago es buscar y fusionar desde SVN. De esa manera puedo asegurarme de que estoy incluyendo todos los mismos cambios que SVN, pero mantengo mi historial de confirmaciones separado del SVN por completo.

Entonces guardo una copia local SVN separada que está en una carpeta separada. Ese es el que hago commits de vuelta a SVN, y simplemente uso la utilidad de línea de comandos SVN para eso.

Cuando estoy listo para confirmar el estado de mi repositorio local de git en SVN, simplemente copio todo el desorden de archivos en la copia local de trabajo de SVN y lo confirmo desde allí usando SVN en lugar de git.

De esta manera nunca tengo que hacer ningún rebasing, porque rebasing es como freebasing.