Criar um ficheiro de utilizadores (isto é, users.txt) para mapear os utilizadores de SVN para Git:

user1 = First Last Name <[email protected]>
user2 = First Last Name <[email protected]>
...

Pode usar este 'one-liner' para criar um modelo a partir do seu repositório de SVN existente:

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

O SVN irá parar se encontrar um utilizador de SVN em falta que não esteja no ficheiro. Mas depois disso você pode atualizar o arquivo e pegar onde você parou.

Agora puxa os dados SVN do repositório:

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

Este comando irá criar um novo repositório Git em dest_dir-tmp e começar a extrair o SVN repositorio. Note que a bandeira " --stdlayout "implica que você tem a disposição comum" trunk/, branches/, tags/ " SVN. Se a sua disposição for diferente, familiarize-se com --tags, --branches, --trunk opções (em geral git svn help).

Todos os protocolos comuns são permitidos.: svn://, http://, https://. O URL deverá visar o repositório de base, algo como http://svn.mycompany.com/myrepo/repository isso deve Não incluir /trunk, /tag ou /branches.

Note que depois de executar este command it very often looks like the operation is "hanging/freezed", and it's quite normal that it can be stuck for a long time after initializing the new repository. Eventualmente, você verá mensagens de log que indicam que ele está migrando.

Note também que se omitir a opção --no-metadata, O Git irá adicionar informação sobre a revisão SVN correspondente à mensagem de commit (i.e. git-svn-id: svn://svn.mycompany.com/myrepo/<branchname/trunk>@<RevisionNumber> <Repository UUID>)

Se não for encontrado um nome de utilizador, actualize o seu ficheiro users.txt então:

cd dest_dir-tmp
git svn fetch

Poderá ter de repetir esse último comando várias vezes, se tiver um grande projecto, até que todos os commits do Subversion tenham sido obtidos:

git svn fetch

Quando concluído, o Git irá verificar o SVN trunk para um novo ramo. Quaisquer outros ramos são configurados como comandos. Você pode ver os outros ramos SVN com:

git branch -r

Se quiser manter outros ramos remotos no seu repositório, deseja criar um ramo local para cada um manualmente. (Ignorar tronco / mestre.) Se você não fizer isso, os ramos não serão clonados no passo final.

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

As marcas são importadas como ramos. Você tem que criar um branch local, fazer uma tag e excluir o branch para tê-los como tags no Git. Para o fazer com a marca "v1":

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

Clone o seu repositório git-SVN num repositório Git limpo:

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

git checkout -b local_branch origin/remote_branch

Finalmente, remova o remoto do seu repositório Git limpo que aponta para o repositório temporário agora apagado:

git remote rm origin

Migra de forma limpa o seu repositório Subversion para um repositório git . Primeiro você tem que criar um arquivo que mapeia seus nomes de autor de commits Subversion para os commiters Git, por exemplo ~/authors.txt:

jmaddox = Jon Maddox <[email protected]>
bigpappa = Brian Biggs <[email protected]>

Depois poderá transferir os dados do Subversion para um repositório Git:

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

Se você está em um Mac, você pode obter git-svn de Macport instalando git-core +svn.

Se o seu repositório subversion estiver na mesma máquina que o seu repositório Git desejado, então você pode usar esta sintaxe para o passo init, caso contrário, todos os mesmos:

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

Usei o script svn2git e funciona como um encanto! https://github.com/nirvdrum/svn2git

Sugiro ficar confortável com o Git antes de tentar usar o git-svn constantemente, ou seja, manter o SVN como o repo centralizado e usar o Git localmente.

Inicializar o repo local:

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

Marque até onde quer começar a importar as revisões:

git svn fetch -r42

(ou apenas "git svn fetch" para todos os revs)

git svn rebase

Você pode verifique o resultado da importação com o Gitk. Não tenho a certeza se isto funciona no Windows, funciona no OSX e no Linux:

gitk

Primeiro crie o seu repo remoto vazio (talvez em GitHub?):

git remote add origin [email protected]:user/project-name.git

Então, sincronize opcionalmente a sua ramificação principal, para que a operação de extracção irá juntar automaticamente o comando remoto com o seu comando local, quando ambos contiverem novos coisas:

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

Depois disso, você pode estar interessado em experimentar a minha própria ferramenta git_remote_branch, que ajuda a lidar com ramos remotos:

Primeira exposição de motivos: "Git ramificações remotas"

Seguimento da versão mais recente: " tempo para o git colaborar com o git_remote_branch"

Existe uma nova solução para a migração suave do Subversion para o Git (ou para usar ambos simultaneamente): SubGit ( http://subgit.com/).

Para migrar do Subversion para o Git com o SubGit, terá de executar:

$ subgit install svn_repos
...
TRANSLATION SUCCESSFUL 

Depois disso você vai obter o repositório Git em svn_repos/.git e may clone, ou apenas continue a usar o Subversion e este novo repositório Git em conjunto: o SubGit certificar-se-á de que ambos são sempre mantidos em sincronia.

No caso do seu repositório Subversion conter vários projectos, então vários repositórios Git serão criados na pasta svn_repos/git. Para personalizar a tradução Antes de executá-la, faça o seguinte:

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

Com SubGit pode migrar para Git puro (não para git-svn) e começar a usá-lo enquanto mantém o Subversion enquanto precisar dele (para o seu ferramentas de compilação já configuradas, por exemplo).

Ver a página oficialgit-svn. Em particular, veja em "exemplos básicos":

Acompanhar e contribuir para todo um projecto gerido pelo Subversion (completo com tronco, etiquetas e ramos):

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

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

SubGit (vs ecrã azul da Morte)

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

+ para actualizar a partir do SVN, um repositório Git criado pelo primeiro comando.

subgit import  directory/path/Local.git.Repo

• migrar o SVN para um Git repositório
• actualiza o repositório Git antes da equipa mudar para .

A migração leva muito tempo para um grande repositório SVN.
Mas a actualização da migração completa apenas segundos.

Degraus

1. Obter O SubGit

2. Prepare os comandos de migração e actualização.

Conteúdo de um ficheiro / comando para a migração:

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

O comando" Iniciar " é opcional aqui (Windows). Permite ver erros em Iniciar e deixar uma shell aberta após a conclusão do SubGit.

Pode adicionar aqui parâmetros adicionais semelhantes ao git-svn . Estou a usar apenas -- default-domain myCompanyDomain.com para corrigir o domínio do endereço de E-mail dos autores do SVN.
Eu tenho a estrutura padrão do repositório SVN (trunk/branches/tags) e nós não tivemos problemas com o "mapeamento de autores". Por isso, não faço mais nada.

(se quiser migrar marcas como os ramos ou o seu SVN tenha várias pastas de ramos / marcas que possa considerar usar a abordagem mais descritiva )

Tip 1 : Use --minimal-revision o seu número Svnrevnumber para ver rapidamente como as coisas evoluem (algum tipo de depuração). Especialmente útil é ver nomes de autor ou e-mails resolvidos.
Ou para limitar a profundidade do histórico de migração.

Dica 2 : a migração pode ser interrompida ( Ctrl + C) e restaurado ao executar a próxima actualização comando / Ficheiro.
Não aconselho fazer isto para grandes repositórios. Eu recebi "Out of memory Java+Windows exception".

Dica 3 : é melhor criar uma cópia do seu repositório de resultados.

Conteúdo de um ficheiro / comando para actualização:

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

Você pode executá-lo em qualquer quantidade de vezes quando você quiser obter os commits da última equipe para o seu repositório Git.

Aviso! Não Toque no seu repositório (criação de ramos, por exemplo).
Vais levar com o próximo erro fatal:

Erro irrecuperável: estão fora de sincronia e não podem ser sincronizados ... Traduzir as revisões do Subversion para commits do Git...

3. execute o primeiro comando/Ficheiro. Vai demorar muito tempo para um grande repositório. 30 horas para o meu humilde repositório.

Enviar o seu repositório de Git local para um repositório de Git remoto

1. Configure os seus comandos

Corre:

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

1. Prepare-se para o envio inicial do seu enorme repositório local de Git para um repositório remoto {[[30]}

git config --global http.postBuffer 1073741824

524288000-500 MB 1073741824 - 1 GB, etc.

Corrige os problemas locais do certificado . Se o seu servidor git usar um certificado inválido.

Tenho certificados desactivados .

Também o seu servidor de Git pode ter um pedido de limitações de quantidade que precisam de ser corrigidas .

1. Empurra toda a migração para o comando da equipa. Repositório Git.

Executar com um Git local:

git push origin --mirror

(git origem do push'*:*' para versões antigas do Git)

Se tiver o seguinte: erro: não é possível desovar o git: nenhum ficheiro ou directório deste tipo ... Para mim a recreação completa do meu repositório resolve este erro (30 horas). Você pode tentar os próximos comandos

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

Ou tentar reinstalar o Git (inútil para mim. Ou você pode criar ramos de todas as suas tags e empurrá-los. Ou, ou...

Reposurgeon

Para casos complicados, o reposurgeon de Eric S. Raymond é a ferramenta de escolha. Além do SVN, ele suporta muitos outros sistemas de controle de versões através do formato fast-export, e também CVS . O autor relata conversões bem sucedidas de repositórios antigos, como Emacs e FreeBSD .

A ferramenta aparentemente tem como objectivo uma conversão quase perfeita (Como converter as propriedades do SVN svn:ignore Para .gitignore Ficheiros) mesmo para layouts de repositório difíceis com uma longa história. Para muitos casos, Outras ferramentas podem ser mais fáceis de usar.

Antes de entrar na documentação da linha de comandos reposurgeon, não se esqueça de ler o excelente guia de migração dos DVCS que passa passo a passo pelo processo de conversão.

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

Esta ferramenta - https://bitbucket.org/atlassian/svn-migration-scripts - também é muito útil para gerar os seus autores.txt entre outras coisas.

Uma resposta algo estendida usando apenas git, SVN, e bash. Ele inclui passos para repositórios SVN que não usam o layout convencional com um layout de diretório trunk/branches/tags (SVN não faz absolutamente nada para fazer valer este tipo de layout).

Primeiro use este programa bash para analisar o seu acordo de SVN para as diferentes pessoas que contribuíram e para gerar um modelo para um ficheiro de mapeamento:

#!/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 isto para criar um ficheiro authors onde mapeia os nomes de utilizador do svn para nomes de utilizador e E-mail como definidos pelos seus programadores que usam git config propriedades user.name e user.email (note que para um serviço como o GitHub só ter um e-mail correspondente é suficiente).

Então tem git svn clonar o repositório svn para um repositório git, contando-o sobre o mapeamento:

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

Isto pode demorar muito tempo, uma vez que o git svn irá verificar individualmente cada revisão para cada marca ou ramo que existe. (note que as etiquetas na SVN são apenas ramos reais, então eles acabam como tal em Git). Você pode acelerar isso removendo antigas tags e branches no SVN que você não precisa.

Correr isto num servidor na mesma rede ou no mesmo servidor também pode acelerar isto. Além disso, se por alguma razão este processo for interrompido, podecontinuar a utilizar

git svn rebase --continue

O mais simples é apenas fazer um novo repo SVN no seu servidor que segue a Convenção e usa svn copy para colocar o seu directório no tronco ou num ramo. Esta pode ser a única maneira se o seu directório estiver na raiz do repo, quando tentei pela última vez isto {[[6]} simplesmente recusou-se a fazer um check-out.

Também pode fazer isto usando o git. Para git svn clone basta usar a pasta que deseja colocar num ramo git.

Depois corre

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

Note que isto exigia Git 1.7 ou superior.

Tens de instalar

git
git-svn

Copiado desta ligação http://john.albin.net/git/convert-subversion-to-git.

1. Obter uma lista de todas as persistência do Subversion

O Subversion simplesmente lista o nome de utilizador para cada persistência. Os commits do Git têm dados muito mais ricos, mas em seu mais simples, o autor do commit precisa ter um nome e E-mail listado. Por padrão, a ferramenta git-svn irá apenas listar o nome de usuário do SVN em ambos os campos de autor e E-mail. Mas com um pouco de trabalho, você pode criar uma lista de todos os usuários SVN e qual é o seu nome git correspondente e E-mails. Esta lista pode ser usada pelo git-svn para transformar nomes de usuário simples do svn em committers próprios do Git.

A partir da raiz da sua saída local do Subversion, execute este comando:

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

Isso irá pegar todas as mensagens de Registo, arrancar os nomes de utilizador, eliminar quaisquer nomes de utilizador duplicados, ordenar os nomes de utilizador e colocá-los numa "transformação de autores".ficheiro txt. Agora editar cada linha no ficheiro. Por exemplo, convert:

jwilkins = jwilkins <jwilkins>

Para isto:

jwilkins = John Albin Wilkins <[email protected]>

2. Clonar o repositório Subversion usando o git-svn

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

Isto fará a transformação padrão git-svn (usando os autores-transformar.o ficheiro txt que criou no Passo 1) e coloque o repositório git na pasta" ~/temp " dentro da sua pasta pessoal.

3. Converter o svn: ignorar as propriedades para .gitignore

Se o seu acordo de svn estava a usar o svn: ignore as propriedades, você pode facilmente converter isto para A.ficheiro gitignore com:

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

4. Enviar o repositório para um repositório de git simples

Primeiro, crie um repositório e faça com que o seu ramo padrão corresponda ao nome do ramo "trunk" do svn.

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

Em seguida, empurre o repositório temporário para o novo repositório bare.

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

Pode agora apagar com segurança o repositório ~/temp.

5. Mudar o nome do ramo" trunk "para " master""

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

6. Limpar os ramos e marcas

O git-svn faz de todas as subversões marcas em ramos muito curtos no GIT da forma "tags / name". Você vai querer converter todos esses ramos em tags Git reais 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

O GitHub agora tem uma funcionalidade para Importar de um repositório de SVN . Mas nunca tentei.

Podemos usar os comandos git svn clone como abaixo.

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

O comando acima irá criar um ficheiro de autores a partir de commits SVN.

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

O comando acima dar-lhe-á o primeiro número de revisão quando o seu projecto SVN for criado.

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

O comando acima irá criar o repositório Git no local.

$ 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 marcas:

$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
$

Agora empurra o mestre, os ramos e as marcas para o repositório 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
$

Utilitário Svn2git

O utilitário Svn2git remove os esforços manuais com ramificações e marcas.

Instale-o com o comando sudo gem install svn2git. Depois disso corre abaixo do comando.

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

$ 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 tens 20 branches e tags, obviamente svn2git irá economizar muito tempo e é por isso que eu gosto mais do que comandos nativos. É um bom invólucro à volta do Comando Nativo.

Para um exemplo completo, consulte a minha entrada no blog .

TortoiseGit Faz isto. veja este post no blog: http://jimmykeen.net/articles/03-nov-2012/how-migrate-from-svn-to-git-windows-using-tortoise-clients

Eu postei um guia passo a Passo (Aqui ) para converter svn para git, incluindo a conversão de tags svn para Git tags e ramificações svn para Git branches.

Versão curta:

Clone svn a partir de um número de revisão específico. (o número da revisão deve ser o mais antigo que deseja migrar)

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

2) Obter dados svn. Este passo é o que leva mais tempo.

cd gitreponame
git svn fetch

Repetir o git svn obter até terminar sem erro

3) get master branch updated

git svn rebase

4) Criar ramificações locais a partir de ramificações svn copiando as referências

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

5) converter as marcas svn em marcas 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 um repositório num lugar melhor como o github

git remotes add newrepo [email protected]:aUser/aProjectName.git
git push newrepo refs/heads/*
git push --tags newrepo

Se quiser mais detalhes, leia o meu post ou Pergunte-me.

Recomendo vivamente esta série curta de screencasts que acabei de descobrir. O autor acompanha-o através das operações básicas, e mostra alguns usos mais avançados.

Se estiver a usar o SourceTree, pode fazer isto directamente a partir da aplicação. Ir para o ficheiro - > Novo / Clone depois faça o seguinte:

1. indique o URL SVN remoto como o"local / URL de origem".
2. Digite as suas credenciais quando for solicitado.
3. indique a localização da pasta local como a"localização de destino".
Dá-lhe um nome.
4. nas Opções Avançadas seleccione " Git "da lista em" Criar local repositório do tipo".
5. pode indicar opcionalmente uma revisão para clone de.
Clone Atingido.

Abra o repo no SourceTree e verá que as suas mensagens de commit também foram migradas.

Agora vá para o repositório - > configuração do repositório e adicione os novos detalhes remotos do repo. Apaga o comando SVN se o desejar (eu fiz isto através da opção "editar o ficheiro de configuração".

Pressione o código para o novo repo remoto quando estiver pronto e Código livremente.

Como outro lado, o comando git-stash é uma dádiva de Deus ao tentar git com o git-svn dcommits.

Um processo típico:

1. estabelecer um acordo de cooperação git
2. trabalhar em ficheiros diferentes
3. decida verificar parte do trabalho, usando o git
4. decide svn-dcommit
5. obter o temido erro "não pode cometer com um índice Sujo".

A solução (necessita do git 1.5.3+):

git stash; git svn dcommit ; git stash apply

Aqui está um script shell simples sem dependências que irá converter um ou mais repositórios SVN para git e empurrá-los para GitHub.

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

Em cerca de 30 linhas de script it: clones usando git SVN, cria A.GITIGNORE file from SVN:: ignore properties, pushes into a bare Git repository, renames SVN trunk to master, converts SVN tags to git tags, and pushes it to GitHub while preserving the tags.

Fui através de um muita dor para mover uma dúzia de repositórios SVN do código Google para o GitHub. Não ajudou eu usar janelas. Ruby estava todo o tipo de quebrada na minha antiga caixa Debian e pô-la a trabalhar no Windows era uma piada. Outras soluções não conseguiram trabalhar com caminhos Cygwin. Mesmo uma vez que eu comecei algo trabalhando, eu não conseguia descobrir como obter as tags para aparecer no GitHub (o segredo é --follow-tags).

Para os usuários do GitLab Eu coloquei um gist sobre como eu migrei do SVN aqui:

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

Passos para migrar de SVN para GitLab

Configuração

• o SVN está hospedado em svn.domain.com.au.
• a SVN é acessível através de http (outros protocolos devem funcionar).
• o GitLab está hospedado em git.domain.com.au e:
  • um grupo é criado com o espaço de nomes dev-team.
  • pelo menos um utilizador a conta é criada, adicionada ao grupo, e tem uma chave SSH para a conta que está sendo usada para a migração (teste usando ssh [email protected]).
  • o projecto {[6] } é criado no espaço de nomes dev-team.
• o ficheiro users.txt contém os detalhes de utilizador relevantes, um utilizador por linha, do formulário username = First Last <[email protected]>, em que username é o nome de utilizador indicado nos registos SVN. (Ver primeira ligação na secção de referências para mais detalhes, em particular resposta pelo utilizador Casey).

Versões

• subversion version 1.6.17 (r1128011)
• git version 1.9.1
• GitLab version 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 [email protected]:dev-team/favourite-project.git
git push --set-upstream gitlab master

Notas

• Se existirem utilizadores desconhecidos, o comando git svn clone irá parar, caso em que, actualizar users.txt, cd favourite-project e git svn fetch continue de onde parou.
• a norma trunk-tags-branches é necessária uma disposição para o repositório SVN.
• o URL SVN dado ao comando git svn clone pára no nível imediatamente acima trunk/, tags/ e branches/
• o comando git svn clone produz uma grande quantidade de Resultados, incluindo alguns avisos no topo; ignorei os avisos.

Https://github.com/onepremise/SGMS

Este programa irá converter os projectos armazenados no SVN com o seguinte formato:

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

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

Cada projecto será sincronizado pelo nome do projecto:

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

Se deseja converter o repo completo, use a seguinte sintaxe:

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

Estou numa máquina do windows e fiz um pequeno lote para transferir um acordo SVN com histórico (mas sem ramificações) para um acordo GIT, apenas chamando

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

@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%

User1 = User One <[email protected]>

usar eficazmente o Git com o Subversion é uma introdução suave ao git-svn. Para repositórios SVN existentes, o git-svn torna isso super fácil. Se você está iniciando um novo repositório, é muito mais fácil primeiro criar um repositório SVN vazio e, em seguida, importar usando o git-svn do que ele está indo na direção oposta. Criar um novo repositório Git então importar para o SVN pode ser feito, mas é um pouco doloroso, especialmente se você é novo para o Git e espera preservar o commit historia.

Baixe o Instalador de Ruby para o Windows e instale a versão mais recente com ele. Adicionar executáveis de Ruby ao seu caminho.

• instalar o svn2git
• iniciar o menu- > Todos os programas - > Ruby - > iniciar uma linha de comandos com Ruby

• Depois escreva "gem install svn2git" e enter

  Migrar o repositório de Subversion

• Abra uma linha de comandos em Ruby e vá para a pasta onde os ficheiros serão migrados

  Depois svn2git http:// [domínio name] / svn / [repositório root]

• Pode levar algumas horas para migrar o projeto para o Git depende do tamanho do Código do projeto.

• Este grande passo ajuda a criar a estrutura do repositório Git como mencionado abaixo.

  SVN (/Project_components) trunk -- > git master SVN (/Project_components) branches -- > Git branches Marcas de SVN (/Project_ componentes) -- > marcas de Git

Criar o repositório remoto e carrega nas mudanças.

À medida que estiver a correr, irá encontrar autores, e você pode simplesmente mapeá-los para os utilizadores no GitHub.

Eu usei-o para alguns repositórios agora, e é bastante preciso e muito mais rápido também! Levou 10 minutos para um repositório com ~4000 commits, e depois levou o meu amigo quatro dias!

Várias respostas aqui referem-se a https://github.com/nirvdrum/svn2git , mas para grandes repositórios isto pode ser lento. Tentei usar https://github.com/svn-all-fast-export/svn2git em vez disso, que é uma ferramenta com exactamente o mesmo nome, mas que foi usada para migrar o KDE do SVN para o Git.

Pré-requisitos:

1. git nas janelas (já usei este) https://git-scm.com/
2. svn com ferramentas de consola instaladas (usei o SVN tartaruga)
3. Descarregue o ficheiro do seu repositório de SVN. svnadmin dump /path/to/repository > repo_name.svn_dump

Passos para alcançar o objectivo final (mover todo o repositório com o histórico para um git, primeiro git local, depois remoto)

1. Criar um repositório vazio (usando as ferramentas da consola ou o tortoiseSVN) no repertório de pastas cd REPO_NAME_PARENT_FOLDER, Coloque dumpfile.despejar no REPO_ NOME_ MÃE_ pasta

2. svnadmin load REPO_NAME_FOLDER < dumpfile.dump Espere por esta operação, pode ser longa.

3. Este comando é silencioso, por isso abra a segunda janela cmd: svnserve -d -R --root REPO_NAME_FOLDER Por que não usar apenas o arquivo:///...... ? Porque o próximo comando falhará com Unable to open ... to URL:, graças à resposta https://stackoverflow.com/a/6300968/4953065

4. Criar uma pasta nova SOURCE_GIT_ pasta

5. cd SOURCE_GIT_FOLDER
6. git svn clone svn: / / localhost / Wait for this operation.

Vamos verificar o nosso repositório Local:

git log

Veja os seus commits anteriores? Se sim - ok

Então agora você tem um repositório de git local totalmente funcional com suas fontes e histórico svn antigo. Agora, se você quiser movê-lo para algum servidor, use os seguintes 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

A converter o submódulo/pasta do svn 'MyModule' para o git com o histórico sem marcas nem ramificações.

• clone git svn -- no-metadata -- trunk=Somebolder1/Somebolder2/Somebolder3 / MyModule http://svnhost:port/repo_root_folder/MyModule_temp - A C:\cheetah\svn\authors-transform.txt
• o git clone o meu Module_temp MyModule
• cd MyModule
• git flow init
• git remote set-url origem https://userid@stashhost/stash/scm/xyzxyz/MyModule.git
• git push-u origin master
• git desenvolvimento da origem push-u

Para manter a lista de ignorar o svn use os comentários acima a seguir ao passo 1