Como posso bifurcar e manter a sincronização com um repositório do Google Code Subversion ao qual não tenho acesso de gravação em um repositório do GitHub?

Quero poder desenvolver meus próprios recursos no meu repositório Git, mas também quero sincronizar com o repositório do Google Code Subversion. Para buscar correções no lado do projeto do Google Code.

Eu sei sobre o git-svn e o usei antes para upstream e downstream para um repositório Subversion sobre o qual eu tinha controle total. Mas não sei como sincronizar com um repositório do Google Code Subversion.

A ramificação remota do git-svn é praticamente a mesma de um remoto Git comum. Portanto, em seu repositório local, você pode ter seu clone git-svn e enviar as alterações para o GitHub. Git não se importa. Se você criar seu clone git-svn e enviar exatamente as mesmas alterações para o GitHub, terá um espelho não oficial do repositório do Google Code. O resto é baunilha Git.

git svn clone http://example.googlecode.com/svn -s
git remote add origin [email protected]:example/example.git
git push origin master

Agora que você tem isso, ocasionalmente você terá que sincronizar o repositório do Subversion com o Git. Será algo como:

git svn rebase
git push

No gitk ou o que seja, isso seria algo como isto:

o [master][remotes/trunk][remotes/origin/master]
|
o
|
o

E quando você executa git svn rebase, você terá o seguinte:

o [master][remotes/trunk]
|
o
|
o [remotes/origin/master]
|
o
|
o

Portanto, agora a execução git pushenviaria esses commits para o GitHub, o ramo [remotes / origin / master] lá. E você voltaria ao cenário no primeiro diagrama de arte ASCII.

O problema agora é: como você trabalha suas alterações no mix? A idéia é que você nunca se comprometa com o mesmo ramo em que está git-svn-rebase-ing e git-push. Você precisa de uma ramificação separada para suas alterações. Caso contrário, você acabaria reorganizando suas alterações sobre as do Subversion, o que poderia incomodar qualquer um que clona seu repositório Git. Me siga? OK, então você cria um ramo, vamos chamá-lo de "recursos". E você faz um commit e o envia ao GitHub para o ramo de recursos. Seu gitk ficaria assim:

o [features][remotes/origin/features]
|
o
|
o [master][remotes/trunk][remotes/origin/master]
|
o

Aqui você tem seus recursos ramificados alguns commits à frente do ramo do Google Code, certo? Então, o que acontece quando você deseja incorporar novidades do Google Code? Você executaria git svn rebaseprimeiro e obteria o seguinte:

                           o [features][remotes/origin/features]
[master][remotes/trunk] o  |
                        |  o
                        o /
                        |/
                        o[remotes/origin/master]
                        |
                        o

Se você git pushdominar, poderá imaginar os [controles remotos / origem / mestre] no mesmo ponto que o mestre. Mas o seu ramo de recursos não possui as alterações. Agora, suas escolhas são mesclar o mestre em recursos ou reestruturar recursos. Uma mesclagem ficaria assim

git checkout features
git merge master 

            o [features]
           /|
          / o [remotes/origin/features]
[master] o  |
         |  o
         o /
         |/
         o
         |
         o

Em seguida, você envia os recursos para o GitHub. Deixei os controles remotos para o mestre economizar espaço, eles estariam no mesmo ponto que o [mestre] .

A abordagem de rebase é um pouco mais ruim - você precisaria pressionar com --force, pois seu push não seria uma mesclagem de avanço rápido (você puxaria o ramo de recursos de baixo de alguém que o clonou). Não é realmente bom fazer isso, mas ninguém pode impedi-lo se você estiver determinado. Isso também facilita algumas coisas, como quando os patches são aceitos upstream na forma ligeiramente reformulada. Isso pouparia ter que mexer com conflitos, você pode apenas refazer a ação - ignorar os patches anteriores. De qualquer forma, uma rebase seria assim:

git rebase master features

         o [features]
         |
         o
         |  o [remotes/origin/features]
[master] o  |
         |  o
         o /
         |/
         o
         |
         o

E então você teria que fazer git push --forceisso. Você pode ver por que você precisa forçá-lo, a história tem um grande e velho cisma, desde [controles remotos / origem / recursos] até os novos [recursos] pós-rebase atuais .

Tudo isso funciona, mas é muito esforço. Se você for um colaborador regular, a melhor aposta seria trabalhar assim por um tempo, enviar alguns patches a montante e ver se você pode obter acesso de confirmação ao Subversion. Caso contrário, talvez não envie suas alterações para o GitHub. Mantenha-os locais e tente aceitá-los de qualquer maneira.

serviço svn2github

O site http://svn2github.com/ fornece um serviço para bifurcar qualquer repositório SVN acessível ao público no Github (em https://github.com/svn2github/projectname ). Eu tentei; ao pressionar "Make a mirror", aparentemente não fez nada por alguns segundos e exibiu a mensagem "error", mas realmente funcionou. De fato, o novo repositório foi criado, contendo o código do repositório SVN.

Você então bifurcaria o repositório criado e trabalharia em sua própria bifurcação. Você enviaria suas alterações ao projeto upstream usando o rastreador de erros.

Observando os repositórios existentes sob o usuário do Github do serviço (por exemplo, "svn2github pressionado para dominar no svn2github / haxe 5 horas atrás"), ele parece extrair regularmente alterações do repositório SVN. Não há informações sobre quem executa o serviço no site, então eu não apostaria que ele continuasse sendo executado indefinidamente, mas funciona por enquanto (e, se algum dia for interrompido, você ainda poderá atualizar manualmente o seu fork).

Plataforma de lançamento

Se você não usar o Git e o Github, outra alternativa é usar o Launchpad.net. A barra de ativação pode importar automaticamente repositórios SVN (também CVS) para uma ramificação pessoal do bzr. Para fazer isso, crie um projeto da Barra de ativação, vá para a nova página de importação , selecione Subversion e insira a URL (por exemplo http://projectname.googlecode.com/svn/trunk/). Dependendo do tamanho do projeto, a importação inicial pode levar algumas horas. As importações subsequentes serão executadas periodicamente.

Para obter mais documentação, consulte Importação de VCS na Ajuda da barra de ativação .

Um passo a passo para sincronizar do Google Code para o GitHub está disponível em fnokd.com . O autor usa um servidor remoto sempre ativo e um trabalho cron para automatizar a sincronização e mantém o tronco SVN em uma ramificação do GitHub chamada "fornecedor".

O GitHub agora suporta a importação direta de projetos de subversão (consulte http://help.github.com/import-from-subversion/ ). Apenas crie um novo repositório e clique em "Importar do Subversion" na tela "Próximas etapas". Porém, ele não suporta mais sincronizações: /.

Hmm .. Na minha empresa eu estava fazendo quase o mesmo. Apenas tendo os repositórios .svn e .git no mesmo diretório (você faz o check-out do svn repo e cria o git repo nesta cópia de trabalho).

Então, usando svn up e git push fez a coisa. Claro que se você diverge muito, terá que mesclar as coisas manualmente.

Não tenho muita certeza do que você deseja, mas é claro que você pode extrair de um repositório do subversion e enviar para um repositório Git da mesma cópia de trabalho. E você também pode git svn dcommitvoltar ao repositório do subversion. Você não pode sincronizar o repositório GitHub com o repositório subversion. Além disso, quando você tiver confirmações em sua cópia de trabalho que ainda não estão no repositório do subversion, será necessário refazê-las se o repositório do subversion for atualizado, forçando você a git push --forceconfirmar o "novo" no GitHub.

Encontrei estas instruções no blog de Yu-Jie Lin :

Primeiro clone o repositório Subversion e envie para o Git:

git svn clone https://foo.googlecode.com/svn/ git-foo 
cd git-foo
git remote add git-foo [email protected]:username/foo.git 
git push git-foo master

Após confirmar no repositório Subversion, execute

cd /path/to/git-foo
git svn fetch 
git svn rebase 
git push git-foo master