Como faço para migrar um repositório SVN com histórico para um novo repositório Git?

https://stackoverflow.com/questions/79165

09-06-2019
|

Pergunta

Eu li o manual do Git, FAQ, curso intensivo de Git - SVN, etc.e todos explicam isso e aquilo, mas em nenhum lugar você encontra uma instrução simples como:

Repositório SVN em: svn://myserver/path/to/svn/repos

Repositório Git em: 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

Não espero que seja tão simples e não espero que seja um único comando.Mas espero que não tente explicar nada - apenas para dizer que passos tomar dado este exemplo.

Solução

Magia:

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

Git e SVN operam de maneira muito diferente.Você precisa aprender Git e, se quiser rastrear alterações do upstream do SVN, precisa aprender git-svn.O git-svn A página de manual tem uma boa seção de exemplos:

$ git svn --help

Outras dicas

Crie um arquivo de usuários (ou seja, users.txt) para mapear usuários SVN para Git:

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

Você pode usar este one-liner para construir um modelo a partir de seu repositório 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 usuário SVN ausente que não esteja no arquivo.Mas depois disso você pode atualizar o arquivo e continuar de onde parou.

Agora extraia os dados SVN do repositório:

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

Este comando criará um novo repositório Git em dest_dir-tmp e comece a extrair o repositório SVN.Observe que o sinalizador "--stdlayout" implica que você tem o layout SVN comum "trunk/, branch/, tags/".Se o seu layout 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://.A URL deve ter como alvo o repositório base, algo como http://svn.mycompany.com/myrepo/repository.Isso deve não incluir /trunk, /tag ou /branches.

Observe que depois de executar este comando muitas vezes parece que a operação está "travada/congelada", e é normal que ela possa ficar travada por um longo tempo após inicializar o novo repositório.Eventualmente, você verá mensagens de log que indicam que está migrando.

Observe também que se você omitir o --no-metadata flag, o Git anexará informações sobre a revisão SVN correspondente à mensagem de commit (ou seja, git-svn-id: svn://svn.mycompany.com/myrepo/<branchname/trunk>@<RevisionNumber> <Repository UUID>)

Se um nome de usuário não for encontrado, atualize seu users.txt arquivo então:

cd dest_dir-tmp
git svn fetch

Você pode ter que repetir o último comando várias vezes, se tiver um projeto grande, até que todos os commits do Subversion tenham sido obtidos:

git svn fetch

Quando concluído, o Git fará o checkout do SVN trunk em um novo ramo.Quaisquer outras filiais são configuradas como remotas.Você pode visualizar as outras ramificações do SVN com:

git branch -r

Se quiser manter outras ramificações remotas em seu repositório, você deseja criar uma ramificação local para cada uma manualmente.(Ignore trunk/master.) Se você não fizer isso, as ramificações não serão clonadas na etapa final.

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

As tags são importadas como ramificações.Você tem que criar um branch local, fazer uma tag e deletar o branch para tê-los como tags no Git.Para fazer isso com a tag "v1":

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

Clone seu repositório GIT-SVN em um repositório Git limpo:

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

As ramificações locais que você criou anteriormente a partir de ramificações remotas serão copiadas apenas como ramificações remotas para o novo repositório clonado.(Ignore trunk/master.) Para cada branch que você deseja manter:

git checkout -b local_branch origin/remote_branch

Por fim, remova o controle remoto do seu repositório Git limpo que aponta para o repositório temporário agora excluído:

git remote rm origin

Migre de forma limpa seu repositório Subversion para um repositório Git.Primeiro você precisa criar um arquivo que mapeie os nomes dos autores do commit do Subversion para os commiters do Git, digamos ~/authors.txt:

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

Então você pode baixar os dados do Subversion em 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ê estiver em um Mac, poderá obter git-svn do MacPorts instalando git-core +svn.

Se o seu repositório de subversão estiver na mesma máquina que o repositório Git desejado, você poderá usar essa sintaxe para a etapa init, caso contrário, mesmo assim:

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

Eu usei o script svn2git e funciona perfeitamente.

Sugiro que você se sinta confortável com o Git antes de tentar usar o git-svn constantemente, ou seja,mantendo o SVN como repositório centralizado e usando o Git localmente.

No entanto, para uma migração simples com todo o histórico, aqui estão alguns passos simples:

Inicialize o repositório local:

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

Marque há quanto tempo você deseja começar a importar revisões:

git svn fetch -r42

(ou apenas "git svn fetch" para todas as rotações)

Na verdade, busque tudo desde então:

git svn rebase

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

gitk

Quando você tiver seu repositório SVN clonado localmente, você pode querer enviá-lo para um repositório Git centralizado para facilitar a colaboração.

Primeiro crie seu repositório remoto vazio (talvez em GitHub?):

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

Em seguida, opcionalmente, sincronize seu branch principal para que a operação pull mescle automaticamente o mestre remoto com o mestre local, quando ambos contiverem coisas novas:

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

Depois disso, você pode estar interessado em experimentar o meu próprio git_remote_branch ferramenta, que ajuda a lidar com filiais remotas:

Primeira postagem explicativa:"Ramos remotos do Git"

Acompanhamento da versão mais recente:"É hora de colaborar com git_remote_branch"

Existe uma nova solução para uma migração tranquila do Subversion para o Git (ou para usar ambos simultaneamente): SubGit.

Estou trabalhando neste projeto sozinho.Usamos SubGit em nossos repositórios - alguns de meus colegas de equipe usam Git e alguns Subversion e até agora funciona muito bem.

Para migrar do Subversion para Git com SubGit você precisa executar:

$ subgit install svn_repos
...
TRANSLATION SUCCESSFUL

Depois disso, você obterá o repositório Git em svn_repos/.git e poderá cloná-lo, ou simplesmente continuar a usar o Subversion e este novo repositório Git juntos:O SubGit garantirá que ambos estejam sempre sincronizados.

Caso seu repositório Subversion contenha vários projetos, vários repositórios Git serão criados no diretório 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 você pode migrar para o Git puro (não para o git-svn) e começar a usá-lo enquanto mantém o Subversion pelo tempo que precisar (para suas ferramentas de construção já configuradas, por exemplo).

Espero que isto ajude!

Veja o oficial página de manual do git-svn.Em particular, consulte "Exemplos Básicos":

Rastreando e contribuindo para um projeto gerenciado por subversão inteiro (completo com um porta-malas, tags e ramificações):

# 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 isso:http://git-scm.com/book/en/Git-and-Other-Systems-Migrating-to-Git

SubGit (vs Tela Azul da Morte)

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

É tudo.

+ Para atualizar do SVN, um repositório Git criado pelo primeiro comando.

subgit import  directory/path/Local.git.Repo

Usei uma maneira de migrar para o Git instantaneamente para um repositório enorme.
Claro que você precisa de alguma preparação.
Mas você não pode interromper o processo de desenvolvimento.

Aqui está o meu caminho.

Minha solução se parece com:

Migrar SVN para um repositório Git
Atualize o repositório Git antes de a equipe mudar para.

A migração leva muito tempo para um grande repositório SVN.
Mas a atualização da migração concluída leva apenas alguns segundos.

Claro que estou usando SubGit, mamãe.git-svn me faz Tela azul da morte.Apenas constantemente.E o git-svn está me entediando com o "nome do arquivo muito longo" erro fatal.

PASSOS

1. Baixar SubGit

2. Prepare comandos de migração e atualização.

Digamos que façamos isso para Windows (é trivial migrar para Linux).
Na instalação de um SubGit caixa diretório (subgit-2.X.X\bin), crie dois arquivos .bat.

Conteúdo de um arquivo/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).Isso permitirá ver erros no início e deixar um shell aberto após a conclusão do SubGit.

Você pode adicionar aqui parâmetros adicionais semelhantes ao git-svn.estou usando apenas --default-domain meuDomíniodaEmpresa.com para corrigir o domínio do endereço de e-mail dos autores do SVN.
Eu tenho a estrutura do repositório SVN padrão (tronco/ramos/tags) e não tivemos problemas com o "mapeamento de autores".Então não estou fazendo mais nada.

(Se você deseja migrar tags como ramificações ou se seu SVN tiver várias pastas de ramificações/tags, você pode considerar usar o SubGit mais detalhado abordagem)

Dica 1:Use --minimal-revision YourSvnRevNumber para ver rapidamente como as coisas acontecem (algum tipo de depuração).Especialmente útil é ver nomes de autores 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 executando o próximo comando/arquivo de atualização.
Não aconselho fazer isso para grandes repositórios.Recebi "Exceção Java + Windows sem memória".

Dica 3:Melhor criar uma cópia do seu repositório vazio de resultados.

Conteúdo de um arquivo/comando para atualização:

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

Você pode executá-lo quantas vezes quiser quando quiser obter os últimos commits da equipe em seu repositório Git.

Aviso! Não mexa no seu repositório vazio (criação de ramificações, por exemplo).
Você cometerá o próximo erro fatal:

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

3. Execute o primeiro comando/arquivo.Levará muito tempo para um grande repositório.30 horas para meu humilde repositório.

É tudo.
Você pode atualizar seu repositório Git do SVN a qualquer momento, executando o segundo arquivo/comando.E antes de mudar sua equipe de desenvolvimento para Git.
Levará apenas alguns segundos.

Há mais uma tarefa útil.

Envie seu repositório Git local para um repositório Git remoto

É o seu caso?Vamos prosseguir.

Configure seus controles remotos

Correr:

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

Prepare-se para o envio inicial do seu enorme repositório Git local para um repositório remoto

Por padrão, seu Git não pode enviar grandes pedaços.fatal:A extremidade remota desligou inesperadamente

Vamos correr:

git config --global http.postBuffer 1073741824

524288000 - 500 MB 1073741824 - 1 GB, etc.

Corrija seu local problemas de certificado.Se o seu servidor git usar um certificado quebrado.

eu desativei certificados.

Além disso, seu servidor Git pode ter um solicitar limitações de valor que precisam ser corrigidas.

Empurre todas as migrações para o repositório Git remoto da equipe.

Execute com um Git local:

git push origin --mirror

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

Se você obtiver o seguinte: erro:não é possível gerar git:Não existe tal arquivo ou diretório...Para mim a recriação completa do meu repositório resolve esse erro (30 horas).Você pode tentar os próximos comandos

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

Ou tente reinstalar o Git (inútil para mim).Ou você pode criar ramificações a partir de todas as suas tags e enviá-las.Ou, ou, ou...

repocirurgião

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

A ferramenta aparentemente visa uma conversão quase perfeita (como converter SVNs svn:ignore propriedades para .gitignore arquivos) mesmo para layouts de repositório difíceis com um longo histórico.Em muitos casos, outras ferramentas podem ser mais fáceis de usar.

Antes de nos aprofundarmos na documentação do reposurgeon linha de comando, certifique-se de ler o excelente Guia de migração DVCS que aborda o processo de conversão passo a passo.

Este guia no site da Atlassian é um dos melhores que encontrei:

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

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

Você tem que instalar

git
git-svn

Copiado deste link http://john.albin.net/git/convert-subversion-to-git.

1.Recuperar uma lista de todos os committers do Subversion

O Subversion simplesmente lista o nome de usuário para cada commit.Os commits do Git têm dados muito mais ricos, mas na sua forma mais simples, o autor do commit precisa ter um nome e email listados.Por padrão, a ferramenta git-svn listará apenas o nome de usuário do SVN nos campos autor e email.Mas com um pouco de trabalho, você pode criar uma lista de todos os usuários do SVN e quais são seus nomes e e-mails correspondentes no Git.Esta lista pode ser usada pelo git-svn para transformar nomes de usuário simples do svn em committers Git adequados.

Na raiz do checkout 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á capturar todas as mensagens de log, extrair os nomes de usuário, eliminar quaisquer nomes de usuário duplicados, classificar os nomes de usuário e colocá-los em um arquivo “authors-transform.txt”.Agora edite cada linha do arquivo.Por exemplo, converta:

jwilkins = jwilkins <jwilkins>

nisso:

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

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

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

Isso fará a transformação git-svn padrão (usando o arquivoauthors-transform.txt que você criou na etapa 1) e colocará o repositório git na pasta “~/temp” dentro do seu diretório inicial.

3.Converter propriedades svn:ignore em .gitignore

Se o seu repositório svn estava usando propriedades svn:ignore, você pode facilmente converter isso para um arquivo .gitignore usando:

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

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

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

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

Em seguida, envie o repositório temporário para o novo repositório vazio.

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

Agora você pode excluir com segurança o repositório ~/temp.

5.Renomeie o branch “trunk” para “master”

Seu branch de desenvolvimento principal será denominado “trunk”, que corresponde ao nome que tinha no Subversion.Você vai querer renomeá-lo para o branch “master” padrão do Git usando:

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

6.Limpe filiais e tags

git-svn transforma todas as tags do Subversions em ramificações muito curtas no Git no formato “tags/nome”.Você desejará converter todas essas ramificações 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

Esta etapa exigirá um pouco de digitação.:-) Mas não se preocupe;seu shell unix fornecerá um > prompt secundário para o comando extra longo que começa com git for-each-ref.

GitHub agora tem um recurso para importar de um repositório SVN.Eu nunca tentei, no entanto.

Uma resposta um tanto estendida usando apenas git, SVN e bash.Inclui etapas para repositórios SVN que não usam o layout convencional com um layout de diretório trunk/branches/tags (o SVN não faz absolutamente nada para impor esse tipo de layout).

Primeiro, use este script bash para verificar seu repositório SVN em busca de diferentes pessoas que contribuíram e para gerar um modelo para um arquivo 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 isso para criar um authors arquivo onde você mapeia nomes de usuário svn para nomes de usuário e e-mail conforme definido por seus desenvolvedores usando git config propriedades user.name e user.email (observe que para um serviço como o GitHub, basta ter um e-mail correspondente).

Então tenha git svn clone o repositório svn para um repositório git, informando sobre o mapeamento:

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

Isso pode levar muito tempo, pois o git svn verificará individualmente cada revisão de cada tag ou branch existente.(observe que as tags no SVN são apenas ramificações, então elas acabam como tal no Git).Você pode acelerar isso removendo tags e ramificações antigas do SVN que você não precisa.

Executar isso em um servidor na mesma rede ou no mesmo servidor também pode realmente acelerar isso.Além disso, se por algum motivo esse processo for interrompido, você pode retome-o usando

git svn rebase --continue

Em muitos casos, você terminou aqui.Mas se o seu repositório SVN tiver um layout não convencional, onde você simplesmente tem um diretório no SVN que deseja colocar em uma ramificação git, você pode executar algumas etapas extras.

O mais simples é apenas criar um novo repositório SVN em seu servidor que siga as convenções e use svn copy para colocar seu diretório em trunk ou branch.Esta pode ser a única maneira se o seu diretório estiver na raiz do repositório, quando tentei isso pela última vez git svn simplesmente se recusou a fazer uma finalização da compra.

Você também pode fazer isso usando git.Para git svn clone simplesmente use o diretório que deseja colocar em uma ramificação git.

Depois da corrida

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

Observe que isso exigia Git 1.7 ou superior.

Postei um guia passo a passo (aqui) para converter svn em git, incluindo a conversão de tags svn em tags git e ramificações svn em ramificações git.

Versão curta:

1) clone o svn de um número de revisão específico.(o número da revisão deve ser o mais antigo que você deseja migrar)

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

2) buscar dados svn.Esta etapa é a que leva mais tempo.

cd gitreponame
git svn fetch

repita git svn fetch até terminar sem erro

3) atualize o branch master

git svn rebase

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

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

5) converter tags svn em tags 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 em um lugar melhor como o github

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

Se você quiser mais detalhes, leia meu publicar ou pergunte-me.

Podemos usar git svn clone comandos 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 criará o arquivo de autores a partir de commits SVN.

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

O comando acima fornecerá o primeiro número de revisão quando seu projeto SVN foi criado.

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

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

O problema é que ele não converte ramificações e tags em push.Você terá que fazê-los manualmente.Por exemplo abaixo para filiais:

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

Agora envie master, ramificações e tags 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

svn2git utilitário remove esforços manuais com ramificações e tags.

Instale-o usando o comando sudo gem install svn2git.Depois disso, execute o comando abaixo.

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

Agora você pode listar os ramos, tags e enviá-los facilmente.

$ 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

Imagine que você tem 20 ramificações e tags, obviamente o svn2git vai economizar muito tempo e é por isso que gosto mais dele do que dos comandos nativos.É um belo invólucro em torno do nativo git svn clone comando.

Para um exemplo completo, consulte meu entrada do blog.

O TortoiseGit faz isso.veja esta postagem do blog: http://jimmykeen.net/articles/03-nov-2012/how-migrate-from-svn-to-git-windows-using-tortoise-clients

Sim, eu sei que responder com links não é esplêndido, mas é uma solução, né?

Eu recomendo isso curta série de screencasts Acabei de descobrir.O autor orienta você nas operações básicas e mostra alguns usos mais avançados.

Se você estiver usando o SourceTree, poderá fazer isso diretamente do aplicativo.Vá para Arquivo -> Novo/Clone e faça o seguinte:

Insira o URL do SVN remoto como "Caminho/URL de origem".
Insira suas credenciais quando solicitado.
Insira o local da pasta local como “Caminho de destino”.
Dê um nome a ele.
Nas opções avançadas, selecione "Git" a partir do menu suspenso em "Criar repositório local do tipo".
Opcionalmente, você pode especificar uma revisão da qual clonar.
Clique em Clonar.

Abra o repositório no SourceTree e você verá que suas mensagens de commit também foram migradas.

Agora vá para Repositório -> Configurações do repositório e adicione os novos detalhes do repositório remoto.Exclua o controle remoto SVN se desejar (fiz isso através da opção "Editar arquivo de configuração".

Envie o código para o novo repositório remoto quando estiver pronto e codifique livremente.

Para GitLab usuários, coloquei uma ideia geral de como migrei do SVN aqui:

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

Etapas para migrar do SVN para o GitLab

Configurar

SVN está hospedado em svn.domain.com.au.
SVN é acessível via http (outros protocolos devem funcionar).
GitLab está hospedado em git.domain.com.au e:
- Um grupo é criado com o namespace dev-team.
- Pelo menos uma conta de usuário é criada, adicionada ao grupo e possui uma chave SSH para a conta que está sendo usada para a migração (teste usando ssh git@git.domain.com.au).
- O projeto favourite-project é criado no dev-team espaço para nome.
O arquivo users.txt contém os detalhes relevantes do usuário, um usuário por linha, do formulário username = First Last <address@domain.com.au>, onde username é o nome de usuário fornecido nos logs do SVN.(Veja o primeiro link na seção Referências para detalhes, em particular a resposta do usuário Casey).

Versões

subversão versão 1.6.17 (r1128011)
versão git 1.9.1
GitLab versão 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

É isso!Recarregue a página do projeto na UI da web do GitLab e você verá todos os commits e arquivos agora listados.

Notas

Se houver usuários desconhecidos, o git svn clone o comando irá parar; nesse caso, atualize users.txt, cd favourite-project e git svn fetch continuará de onde parou.
O padrão trunk-tags-branches layout para repositório SVN é necessário.
O URL SVN fornecido ao git svn clone comando para no nível imediatamente acima trunk/, tags/ e branches/.
O git svn clone O comando produz muitos resultados, incluindo alguns avisos no topo;Ignorei os avisos.

Além disso, o comando git-stash é uma dádiva de Deus ao tentar git com git-svn dcommits.

Um processo típico:

configurar repositório git
faça algum trabalho em arquivos diferentes
decida verificar parte do trabalho, usando git
decidir svn-dcommit
obtenha o temido erro "não é possível confirmar com um índice sujo".

A solução (requer git 1.5.3+):

git stash; git svn dcommit ; git stash apply

Aqui está um script de shell simples, sem dependências, que converterá um ou mais repositórios SVN em git e os enviará para o GitHub.

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

Em cerca de 30 linhas de script:clona usando git SVN, cria um arquivo .gitignore a partir das propriedades SVN::ignore, envia para um repositório git vazio, renomeia o tronco SVN para master, converte tags SVN em tags git e envia-o para GitHub enquanto preserva as tags.

Passei por muita dificuldade para mover uma dúzia de repositórios SVN do Google Code para o GitHub.Não ajudou o fato de eu usar o Windows.Ruby estava todo quebrado na minha antiga caixa Debian e fazê-lo funcionar no Windows foi uma piada.Outras soluções não funcionaram com caminhos Cygwin.Mesmo depois de fazer algo funcionar, não consegui descobrir como fazer com que as tags aparecessem no GitHub (o segredo é --follow-tags).

No final, juntei dois scripts curtos e simples, vinculados acima, e funcionou muito bem.A solução não precisa ser mais complicada que isso!

Estou em uma máquina Windows e fiz um pequeno lote para transferir um repositório SVN com histórico (mas sem ramificações) para um repositório GIT apenas ligando

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

Talvez qualquer um possa usá-lo.Ele cria uma pasta TMP, verifica o repositório SVN com git e adiciona a nova origem e envia por push ...e exclui a pasta novamente.

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

Você ainda precisa do users.txt com seus mapeamentos de usuários, como

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

Eu só queria adicionar minha contribuição à comunidade Git.Eu escrevi um script bash simples que automatiza a importação completa.Ao contrário de outras ferramentas de migração, esta ferramenta depende do git nativo em vez do jGit.Esta ferramenta também oferece suporte a repositórios com um grande histórico de revisões e/ou grandes blobs.Está disponível via github:

https://github.com/onepremise/SGMS

Este script irá converter projetos armazenados em SVN com o seguinte formato:

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

Este esquema também é popular e suportado:

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

Cada projeto será sincronizado pelo nome do projeto:

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

Se você deseja converter o repositório completo, use a seguinte sintaxe:

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

Usando efetivamente Git com Subversion é uma introdução gentil ao git-svn.Para repositórios SVN existentes, o git-svn torna isso muito fácil.Se você estiver iniciando um novo repositório, é muito mais fácil primeiro criar um repositório SVN vazio e depois importar usando git-svn do que ir na direção oposta.Criar um novo repositório Git e depois importar para o SVN pode ser feito, mas é um pouco doloroso, especialmente se você for novo no Git e espera preservar o histórico de commits.

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

Instale o svn2git
Menu Iniciar -> Todos os programas -> Ruby -> Iniciar um prompt de comando com Ruby
Em seguida, digite “gem install svn2git” e digite

Migrar repositório Subversion
Abra um prompt de comando Ruby e vá para o diretório para onde os arquivos serão migrados

Então svn2git http://[domínio nome]/svn/ [raiz do repositório]
Pode levar algumas horas para migrar o projeto para Git, dependendo do tamanho do código do projeto.
Esta etapa principal ajuda na criação da estrutura do repositório Git conforme mencionado abaixo.

SVN (/Project_Components) Trunk -> Git Master SVN (/Project_Components) Branches -> Git Branches svn (/Project_components) tags -> tags git

Crie o repositório remoto e envie as alterações.

GitHub tem um importador.Depois de criar o repositório, você poderá importar de um repositório existente, por meio de sua URL.Ele solicitará suas credenciais, se aplicável, e partirá daí.

Durante a execução, ele encontrará autores e você poderá simplesmente mapeá-los para usuários no GitHub.

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

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

Um pouco mais de trabalho para configurá-lo, mas quando concluída, a conversão em si levou minutos, enquanto o outro script levou horas.

Existem diferentes métodos para atingir esse objetivo.Eu tentei alguns deles e encontrei um que realmente funcionava com apenas git e svn instalados no sistema operacional Windows.

Pré-requisitos:

git no Windows (eu usei este) https://git-scm.com/
svn com ferramentas de console instaladas (usei o tortoise svn)
Arquivo de despejo do seu repositório SVN.svnadmin dump /path/to/repository > repo_name.svn_dump

Etapas para atingir o objetivo final (mover todo o repositório com histórico para um git, primeiro git local e depois remoto)

Crie um repositório vazio (usando ferramentas de console ou tortoiseSVN) no diretório REPO_NAME_FOLDERcd REPO_NAME_PARENT_FOLDER, coloque dumpfile.dump em REPO_NAME_PARENT_FOLDER
svnadmin load REPO_NAME_FOLDER < dumpfile.dump Aguarde esta operação, pode demorar muito
Este comando é silencioso, então abra a segunda janela do cmd: svnserve -d -R --root REPO_NAME_FOLDER Por que não usar apenas file:///......?Porque o próximo comando falhará com Unable to open ... to URL:, graças à resposta https://stackoverflow.com/a/6300968/4953065
Crie uma nova pasta SOURCE_GIT_FOLDER
cd SOURCE_GIT_FOLDER
git svn clone svn://localhost/ Aguarde esta operação.

Finalmente, o que temos?

Vamos verificar nosso repositório local:

git log

Veja seus commits anteriores?Se sim - ok

Então agora você tem um repositório git local totalmente funcional com suas fontes e histórico antigo do SVN.Agora, se 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

No meu caso, não preciso do comando tags porque meu repositório não tem tags.

Boa sorte!

Convertendo o submódulo/pasta svn 'MyModule' em git com histórico sem tags nem ramificações.

clone git svn--no-metadata--Trunk = someFolder1/someFolder2/someFolder3/myModule http://svnhost:port/repo_root_folder/MyModule_temp -A C: Cheetah Svn Authors-transform.txt
git clone MeuModule_temp MeuModule
cd Meu Módulo
git fluxo de inicialização
origem do URL do conjunto remoto do githttps://userid@stashhost/stash/scm/xyzxyz/MyModule.git
git push -u mestre de origem
git push -u origem desenvolver

Para reter a lista de ignorados do svn use os comentários acima após o passo 1

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow