Layout do repositório GIT para servidor com vários projetos

Uma das coisas que gosto na maneira como tenho o Subversion configurado é que posso ter um único repositório principal com vários projetos. Quando eu quero trabalhar em um projeto, posso verificar apenas esse projeto. Como isso

\main
    \ProductA
    \ProductB
    \Shared

então

svn checkout http://.../main/ProductA

Como um novo usuário do git, quero explorar um pouco das melhores práticas no campo antes de me comprometer com um fluxo de trabalho específico. Pelo que li até agora, git armazena tudo em uma única pasta .git na raiz da árvore do projeto. Então, eu poderia fazer uma de duas coisas.

1. Configure um projeto separado para cada produto.
2. Configure um único projeto massivo e armazene os produtos em subpastas.

Existem dependências entre os produtos, portanto, o único projeto massivo parece apropriado. Estaremos usando um servidor onde todos os desenvolvedores podem compartilhar seu código. Já coloquei isso funcionando em SSH e HTTP e essa parte que adoro. No entanto, os repositórios em SVN já têm muitos GB de tamanho, então arrastar todo o repositório em cada máquina parece uma má ideia - especialmente porque somos cobrados por largura de banda de rede excessiva.

Eu imagino que os repositórios do projeto do kernel do Linux são igualmente grandes, então deve haver uma maneira adequada de lidar com isso com o Git, mas ainda não descobri.

Existem diretrizes ou melhores práticas para trabalhar com repositórios de vários projetos muito grandes?

A diretriz é simples, em relação aos limites do Git :

• um repo por projeto
• um projeto principal com submódulos .

A ideia não é armazenar tudo em um repositório git gigante, mas construir um pequeno repo como um projeto principal, que fará referência aos commits corretos de outros repositórios, cada um representando um projeto ou componente comum próprio.

O OP Paul Alexander comenta :

Isso soa semelhante ao suporte "externo" fornecido pelo subversion.
Nós tentamos isso e achamos extremamente complicado atualizar constantemente as referências de versão nas externas, uma vez que os projetos são desenvolvidos simultaneamente com dependências uns dos outros. Existe outra opção ??

@Paul: sim, em vez de atualizar a versão do projeto principal, você:

• desenvolver seus subprojetos diretamente de dentro do projeto principal (conforme explicado em " Verdadeira natureza dos submódulos "),
• ou você faz referência em um sub-repo originpara o mesmo sub-repo que está sendo desenvolvido em outro lugar: a partir daí, você apenas tem que puxar desse sub-repo as alterações feitas em outro lugar.

Em ambos os casos, não se deve esquecer de comprometer o projeto principal, para registrar a nova configuração. Nenhuma propriedade "externa" para atualizar aqui. Todo o processo é muito mais natural.

Honestamente, isso soa como uma verdadeira dor e qualquer coisa que exija que os desenvolvedores façam algo manualmente cada vez será apenas uma fonte regular de bugs e manutenção.
Acho que vou tentar automatizar isso com alguns scripts no superprojeto.

Eu respondi:

Honestamente, você pode estar certo ... isto é, até a última versão 1.7.1 do Git .
git diffe git statusambos aprenderam a levar em consideração os estados dos submódulos, mesmo se executados a partir do projeto principal.
Você simplesmente não pode perder a modificação do submódulo.

Dito isto:

• os submódulos são diferentes dos externos SVN: veja " Por que os submódulos git são incompatíveis com os externos svn? "
• gerenciar submódulos pode ser complicado: veja " Como exatamente o submódulo git funciona? ".

GitSlave permite que você gerencie vários repositórios independentes como um. Cada repo pode ser manipulado por comandos git regulares, enquanto o gitslave permite que você execute um comando adicional em todos os repos.

super-repo
+- module-a-repo
+- module-b-repo

gits clone url-super-repo
gits commit -a -m "msg"

Repo-per-project tem vantagens com componentização e builds simplificados com ferramentas como Maven. O repo-per-project adiciona proteção ao limitar o escopo do que o desenvolvedor está mudando - em termos de commits errados de lixo.