it-swarm-pt.tech

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

Eu li o manual do Git, FAQ, Git - SVN curso, etc e todos eles explicam isso e aquilo, mas em nenhum lugar você pode encontrar 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 assim 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 dar, dado este exemplo.

1453
Milan Babuškov

Magia:

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

O Git e o SVN operam de maneira muito diferente. Você precisa aprender Git, e se você quiser acompanhar as mudanças do SVN, você precisa aprender git-svn. A página do manual git-svn tem uma boa seção de exemplos:

$ git svn --help
513
jfm3

Crie um arquivo de usuários (por exemplo, users.txt) para mapear usuários do SVN para o Git:

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

Você pode usar este one-liner para construir um template a partir do 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 no arquivo. Mas depois disso, você pode atualizar o arquivo e a pick-up de onde parou.

Agora, puxe 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 começará a puxar o repositório SVN. Observe que o sinalizador "--stdoutout" indica que você tem o layout comum "trunk /, branches /, tags /" SVN. Se o layout for diferente, familiarize-se com as opções --tags, --branches, --trunk (em geral git svn help).

Todos os protocolos comuns são permitidos: svn://, http://, https://. O 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.

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

Observe também que, se você omitir o sinalizador --no-metadata, o Git anexará informações sobre a revisão SVN correspondente à mensagem de confirmação (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 arquivo users.txt e:

cd dest_dir-tmp
git svn fetch

Você pode ter que repetir o último comando várias vezes, se você tiver um projeto grande, até que todas as subversões sejam buscadas:

git svn fetch

Quando concluído, o Git irá verificar o SVN trunk em um novo ramo. Quaisquer outras ramificações são configuradas como controles remotos. Você pode ver os outros ramos do SVN com:

git branch -r

Se você quiser manter outras ramificações remotas em seu repositório, você deseja criar uma ramificação local para cada uma manualmente. (Ignorar tronco/mestre.) Se você não fizer isso, os ramos não serão clonados na etapa final.

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

Tags são importadas como ramificações. Você precisa criar uma ramificação local, criar uma tag e excluir a ramificação para tê-las 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 limpo do Git:

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 só serão copiadas como ramificações remotas para o novo repositório clonado. (Pular tronco/mestre.) Para cada ramo que você deseja manter:

git checkout -b local_branch Origin/remote_branch

Finalmente, 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
1512
cmcginty

Migrar corretamente seu repositório de subversão para um repositório Git . Primeiro você tem que criar um arquivo que mapeie seus nomes de autores de commit do Subversion para os commiters do Git, digamos ~/authors.txt:

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

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 usando um Mac, poderá obter git-svn do MacPorts instalando git-core +svn.

Se o seu repositório Subversion está 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, da mesma forma:

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

Eu usei o script svn2git e funciona como um encanto.

69
Thiago Leão Moreira

Eu sugiro ficar 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 até onde você deseja começar a importar as revisões:

git svn fetch -r42

(ou apenas "git svn fetch" para todas as revs)

Na verdade, buscar tudo desde então:

git svn rebase

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

gitk

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

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

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

Então, opcionalmente, sincronize sua ramificação principal para que a operação pull combine automaticamente o mestre remoto com seu 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 minha própria ferramenta git_remote_branch, que ajuda a lidar com filiais remotas:

Primeiro post explicativo: " Git remote branches "

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

57
webmat

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

Eu estou trabalhando neste projeto eu mesmo. Usamos o SubGit em nossos repositórios - alguns dos meus colegas de equipe usam o Git e alguns Subversion e até agora funciona muito bem.

Para migrar do Subversion para o Git com o 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 apenas continuar a usar o Subversion e este novo repositório Git juntos: o SubGit garantirá que ambos sejam sempre mantidos em sincronia.

Caso seu repositório Subversion contenha múltiplos projetos, múltiplos 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 o git-svn) e começar a usá-lo enquanto ainda mantém o Subversion enquanto você precisar dele (para suas ferramentas de compilação já configuradas, por exemplo).

Espero que isto ajude!

30
Alexander Kitaev

Veja o arquivo oficial git-svn manpage . Em particular, veja em "Exemplos básicos":

Acompanhando e contribuindo para todo um projeto gerenciado pelo Subversion (completo com um tronco, tags e ramificações):

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

SubGit (vs Tela Azul da Morte)

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

É tudo.

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

subgit import  directory/path/Local.git.Repo

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

Aqui está o meu caminho.

Minha solução parece:

  • Migrar o 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 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 do Git.

PASSOS

1. Download SubGit

2. Preparar os comandos de migração e atualização.

Vamos dizer que fazemos isso para o Windows (é trivial para portar para o Linux).
No diretório de instalação de um SubGit bin (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 "start" é 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 - domínio-padrão 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ão tivemos problemas com o "mapeamento de autores". Então eu não estou fazendo mais nada.

(Se você quiser migrar tags como branches ou seu SVN tem várias pastas branches/tags você pode considerar usar o mais detalhado SubGit approach )

Dica 1 : Use --minimal-revision YourSvnRevNumber para ver rápido como as coisas se resumem (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 pela execução do próximo comando/arquivo de atualização.
Eu não aconselho fazer isso para grandes repositórios. Recebi "Exceção de Java + Windows sem memória".

Dica 3 : Melhor criar uma cópia do seu repositório bare.

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

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

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

Atenção! Não toque no seu repositório nu (criação de ramos, por exemplo).
Você receberá 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 o Git confirma ...

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

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



Há mais uma tarefa útil.

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

É o seu caso? Vamos prosseguir.

  1. Configure seus controles remotos

Corre:

$ git remote add Origin url://your/repo.git
  1. 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 blocos. fatal: O final remoto desligou inesperadamente

Vamos correr para isso:

git config --global http.postBuffer 1073741824

524288000 - 500 MB 1073741824 - 1 GB, etc.

Corrigir seu local problemas de certificado . Se o seu git-server usa um certificado quebrado.

Eu desabilitei certificados .

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

  1. Push all migration para o repositório Git remoto da equipe.

Execute com um Git local:

git Push Origin --mirror

( git Push Origin '*: *' para versões antigas do Git)

Se você receber o seguinte: erro: não é possível gerar o git: Nenhum 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 de todas as suas tags e enviá-las. Ou, ou, ou ...

13
it3xl

reposurgeon

Para casos complicados, o reposicionamento por Eric S. Raymond é a ferramenta de escolha. Além do SVN, ele suporta muitos outros sistemas de controle de versão 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 .

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

Antes de se aprofundar na documentação da linha de comando reposurgeon, leia o excelente guia de migração DVCS que acompanha o processo de conversão passo a passo.

9
krlmlr

Este guia no site do atlassian é um dos melhores que eu encontrei:

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

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

7
Andrew B

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

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

A partir da raiz do seu 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 vai pegar todas as mensagens de log, arrancar os nomes de usuários, eliminar quaisquer nomes de usuário duplicados, classificar os nomes de usuários e colocá-los em um arquivo “authors-transform.txt”. Agora edite cada linha no arquivo. Por exemplo, converta:

jwilkins = jwilkins <jwilkins>

nisso:

jwilkins = John Albin Wilkins <[email protected]>

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 arquivo authors-transform.txt que você criou na etapa 1) e colocará o repositório git na pasta “~/temp” dentro do seu diretório inicial.

3. Converta as propriedades de svn: ignore em .gitignore

Se seu svn repo estava usando svn: ignore properties, você pode facilmente converter isso em um arquivo .gitignore usando:

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

4. Empurre o repositório para um repositório git simples

Primeiro, crie um repositório vazio e faça com que a ramificação padrão corresponda ao nome da ramificação "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 temp para o novo repositório nu.

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 a ramificação "trunk" para "master"

Seu ramo de desenvolvimento principal será chamado de "trunk", que corresponde ao nome que estava no Subversion. Você deseja renomeá-lo para a ramificação "mestre" padrão do Git usando:

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

6. Limpar galhos e tags

o git-svn faz todas as tags do Subversions em ramificações muito curtas no Git no formato “tags/name”. Você deseja converter todas essas ramificações em tags reais do Git 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 vai demorar um pouco de digitação. :-) Mas não se preocupe; seu unix Shell fornecerá um Prompt secundário para o comando extra-longo que começa com git for-each-ref.

7
Valarpirai

Uma resposta um pouco estendida usando apenas git, SVN e bash. Ele 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 para as 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 <[email protected]>";
done

Use isto para criar um arquivo authors onde você mapeia nomes de usuários svn para nomes de usuários e e-mails como definidos por seus desenvolvedores usando git config properties user.name e user.email (note que para um serviço como o GitHub ter apenas um email correspondente é suficiente).

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

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

Isso pode levar um tempo incrivelmente longo, já que o git svn verificará individualmente cada revisão para cada tag ou branch existente. (note que tags no SVN são apenas ramificações, então elas acabam como no Git). Você pode acelerar isso removendo tags e ramificações antigas no SVN de que 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 este processo for interrompido você can resume-o usando

git svn rebase --continue

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

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

Você também pode fazer isso usando o git. Para git svn clone simplesmente use o diretório que você deseja colocar em um branch git.

Depois de correr

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

Note que isso requeria o Git 1.7 ou superior.

6
thoutbeckers

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

6
webmat

Eu postei um guia passo-a-passo ( aqui ) para converter svn in para git incluindo converter svn tags em git tags e svn branches em git branches.

Versão curta:

1) clone svn de um número de revisão específico. (o número de 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. Este passo é o que leva mais tempo.

cd gitreponame
git svn fetch

repetir git svn buscar até terminar sem erro

3) obter master branch atualizado

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 [email protected]:aUser/aProjectName.git
git Push newrepo refs/heads/*
git Push --tags newrepo

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

5
Pablo Belaustegui

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 criará o arquivo de autores a partir das confirmações do SVN.

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

O comando acima fornecerá o primeiro número de revisão quando o projeto 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 criará o repositório Git no local.

O problema é que ele não converterá ramificações e tags em Push. Você terá que fazê-las manualmente. Por exemplo abaixo para ramos:

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

$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 empurre mestre, ramos 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 utility remove esforços manuais com ramificações e tags.

Instale-o usando o comando Sudo gem install svn2git. Depois disso, corra abaixo do comando.

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

Agora você pode listar os ramos, tags e empurrá-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ê tenha 20 branches e tags, obviamente o svn2git vai economizar muito tempo e é por isso que eu gosto mais do que os comandos nativos. É um bom wrapper em torno do comando nativo git svn clone.

Para um exemplo completo, consulte meu entrada de blog .

5
Pankaj

TortoiseGit faz isso. veja este post: 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, hein?

4
CAD bloke

Para GitLab users eu coloquei uma essência sobre como eu migrei do SVN aqui:

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

Etapas para migrar do SVN para o GitLab

Configuração

  • O SVN está hospedado em svn.domain.com.au.
  • O SVN é acessível via http (outros protocolos devem funcionar).
  • O GitLab é 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 tem uma chave SSH para a conta que está sendo usada para a migração (teste usando ssh [email protected]).
    • O projeto favourite-project é criado no namespace dev-team.
  • O arquivo users.txt contém os detalhes relevantes do usuário, um usuário por linha, do formulário username = First Last <[email protected]>, onde username é o nome de usuário fornecido nos logs do SVN. (Veja o primeiro link na seção Referências para mais detalhes, em especial a resposta do usuário Casey).

Versões

  • Versão do Subversion 1.6.17 (r1128011)
  • git versão 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 [email protected]:dev-team/favourite-project.git
git Push --set-upstream gitlab master

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

Notas

  • Se houver usuários desconhecidos, o comando git svn clone será interrompido e, nesse caso, a atualização users.txt, cd favourite-project e git svn fetch continuará de onde parou.
  • O layout padrão trunk-tags-branches para o repositório SVN é necessário.
  • O URL do SVN fornecido para o comando git svn clone para no nível imediatamente acima de trunk/, tags/ e branches/.
  • O comando git svn clone produz muita saída, incluindo alguns avisos no topo; Eu ignorei os avisos.
3
leftclickben

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

  1. Digite o URL do SVN remoto como "Source Path/URL".
  2. Digite suas credenciais quando solicitado.
  3. Digite o local da pasta local como o "caminho de destino".
  4. Dê um nome.
  5. Nas opções avançadas, selecione "Git" na lista suspensa em "Criar repositório local do tipo".
  6. Você pode, opcionalmente, especificar uma revisão para clonar.
  7. Clone da batida.

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 do SVN, se desejar (eu fiz isso através da opção "Editar arquivo de configuração").

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

3
Craig Myles

Eu recomendo altamente isto séries curtas de screencasts eu descobri apenas. O autor percorre as operações básicas e mostra alguns usos mais avançados.

3
ripper234

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

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

Em cerca de 30 linhas de script ele: clona usando o git SVN, cria um arquivo .gitignore a partir do SVN :: ignore properties, envia um repositório git, renomeia o SVN trunk para master, converte tags SVN para git tags e envia para o GitHub preservando as tags.

Eu passei por muita dor para mover uma dúzia de repositórios SVN do Google Code para o GitHub. Não ajudou que eu usei o Windows. Ruby foi todo tipo de coisa quebrada na minha antiga Debian, e fazer com que funcionasse no Windows era uma piada. Outras soluções não funcionaram com os caminhos do Cygwin. Mesmo quando tenho algo funcionando, não consigo descobrir como fazer com que as tags apareçam no GitHub (o segredo é - tags de acompanhamento).

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

2
NateS

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

Um processo típico:

  1. configurar o repositório do git
  2. fazer algum trabalho em arquivos diferentes
  3. decide verificar alguns dos trabalhos, usando o git
  4. decidir svn-dcommit
  5. obter o temido erro "não pode confirmar com um índice sujo".

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

git stash; git svn dcommit ; git stash apply
2
Gregg Lind

Eu estou em uma máquina windows e fiz um pequeno Batch para transferir um repositório SVN com histórico (mas sem filiais) para um repositório GIT apenas ligando

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

Talvez alguém possa usá-lo. Ele cria uma pasta TMP e verifica o repo SVN lá com o git e adiciona a nova origem e empurra-o ... e apaga 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ário como

User1 = User One <[email protected]>
2
cljk

Eu só queria adicionar minha contribuição à comunidade do Git. Eu escrevi um script 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 suporta 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 no SVN com o seguinte formato:

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

Este esquema também é popular e suportado também:

/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 repo completo, use a seguinte sintaxe:

Ex: ./migration https://svnurl.com/basepath .
1
Jason Huntley

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

Pré-requisitos:

  1. git no windows (eu usei este aqui) https://git-scm.com/
  2. svn com ferramentas de console instaladas (eu usei svn de tartaruga)
  3. Arquivo de despejo do seu repositório SVN. svnadmin dump /path/to/repository > repo_name.svn_dump

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

  1. Crie um repositório vazio (usando ferramentas de console ou tortoiseSVN) no diretório REPO_NAME_FOLDER cd REPO_NAME_PARENT_FOLDER, coloque dumpfile.dump em REPO_NAME_PARENT_FOLDER

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

  3. 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

  4. Criar nova pasta SOURCE_GIT_FOLDER

  5. cd SOURCE_GIT_FOLDER
  6. git svn clone svn: // localhost/Aguarde esta operação.

Finalmente, o que nós 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 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

No meu caso, eu não preciso de tags de comando porque o meu repo não tem tags.

Boa sorte!

0
Ruslan Makrenko

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

Conforme ele está sendo executado, ele encontrará autores e você poderá simplesmente mapeá-los para usuários no GitHub.

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

0
Josh Benson

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

0
burkestar

Várias respostas aqui se referem a https://github.com/nirvdrum/svn2git , mas para grandes repositórios isso pode ser lento. Eu tive uma tentativa usando https://github.com/svn-all-fast-export/svn2git em vez disso, que é uma ferramenta com exatamente 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 feito a conversão em si para mim levou minutos onde o outro script passou horas.

0
Zitrax

Baixe o instalador do 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 comando Prompt com Ruby
  • Então digite “gem install svn2git” e digite

    Migrar o repositório do Subversion

  • Abra um prompt do comando Ruby e vá para o diretório em que 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 o Git depende do tamanho do código do projeto.

  • Este importante passo ajuda na criação da estrutura do repositório Git, conforme mencionado abaixo.

    SVN (/ Project_components) trunk -> Git mestre SVN (/ Project_components) ramificações -> Git ramifica tags SVN (/ Project_components) -> tags Git

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

0
Nanda

Eu usei o seguinte script para ler um arquivo de texto que tem uma lista de todos os meus repositórios SVN e convertê-los em Git, e depois usar git clone --bare para converter em um repositório Git simples:

#!/bin/bash
file="list.txt"
while IFS= read -r repo_name
do
 printf '%s\n' "$repo_name"
 Sudo git svn clone --shared --preserve-empty-dirs --authors-file=users.txt file:///programs/svn/$repo_name
 Sudo git clone --bare /programs/git/$repo_name $repo_name.git
 Sudo chown -R www-data:www-data $repo_name.git
 Sudo rm -rf $repo_name
done <"$file"

list.txt tem o formato:

repo1_name
repo2_name

E users.txt tem o formato:

(no author) = Prince Rogers <[email protected]>

www-data é o usuário do servidor web Apache, e é necessária permissão para enviar as alterações por HTTP.

0
Pedro Vicente

Convertendo svn submodule/folder 'MyModule' em git com histórico sem tags nem branches.

Para manter svn ignore list use os comentários acima após o passo 1

0
PShetty