As permissões são uma praga.

Basicamente, você precisa ter certeza de que todos esses desenvolvedores podem escrever em tudo no repositório git.

Pule para a solução New-Wave para obter o método superior de conceder a um grupo de desenvolvedores capacidade de gravação.

A solução padrão

Se você colocar todos os desenvolvedores em um grupo especialmente criado, você pode, em princípio, apenas fazer:

chgrp -R <whatever group> gitrepo
chmod -R g+swX gitrepo

Em seguida, altere o umaskpara os usuários para 002, para que novos arquivos sejam criados com permissões graváveis ​​em grupo.

Os problemas com isso são muitos; se você estiver em uma distribuição que assume um umask( 022como ter um usersgrupo comum que inclui todos por padrão), isso pode gerar problemas de segurança em outros lugares. E mais cedo ou mais tarde, algo vai estragar seu esquema de permissões cuidadosamente elaborado, colocando o repositório fora de ação até que você tenha rootacesso e o conserte (ou seja, executando novamente os comandos acima).

A solução da nova onda

Uma solução superior - embora menos compreendida e que requer um pouco mais de suporte a SO/ferramentas - é usar atributos estendidos POSIX. Eu só vim para esta área recentemente, então meu conhecimento aqui não é tão bom quanto poderia ser. Mas basicamente, uma ACL estendida é a capacidade de definir permissões em mais do que apenas os 3 slots padrão (usuário/grupo/outro).

Então, mais uma vez, crie seu grupo e execute:

setfacl -R -m g:<whatever group>:rwX gitrepo
find gitrepo -type d | xargs setfacl -R -m d:g:<whatever group>:rwX

Isso configura a ACL estendida para o grupo para que os membros do grupo possam ler/gravar/acessar quaisquer arquivos que já estejam lá (a primeira linha); em seguida, informe também a todos os diretórios existentes que os novos arquivos devem ter essa mesma ACL aplicada (a segunda linha).

Espero que isso te coloque no seu caminho.

se você criou o repositório (ou clonou um novo repositório vazio de um existente) com

$ git init --shared=group 

ou

$ git init --shared=0NNN

O Git deve lidar com permissões acima e além do que seu umask padrão fornece. Por fim, isso é verdade na minha versão do Git (1.6.3). É claro que isso pressupõe que seus usuários estejam no mesmo grupo.

Se eu precisasse de gerenciamento de usuários em vários grupos com vários graus de leitura/gravação, no entanto, eu usaria gitose. Eu também ouvi falar de gitolite ( http://github.com/sitaramc/gitolite ), um fork de gitose que deveria fornecer permissões de nível de ramificação, mas não posso dizer que já o usei pessoalmente.

Isso não foi dito, então eu quero adicioná-lo rapidamente.

Para garantir que os problemas de permissões não cortem sua cabeça feia, certifique-se de definir o seguinte no arquivo de configuração do seu repositório compartilhado git:

[core]
    sharedRepository = true

Isso garantirá que as configurações de "umask" do seu sistema sejam respeitadas.

O Manual do Usuário do Git descreve como compartilhar um repositório de várias maneiras.

• Exportando através do Git Daemon .
• Exportando por HTTP .
• Estilo CVS/SVN, um único repositório compartilhado onde os desenvolvedores fazem push/pull.

Maneiras mais complicadas, embora cheias de recursos, de compartilhar repositórios são:

• Gitose
• GitHub (ou instalação do firewall do GitHub )

Usamos o GitHub para uma equipe de 6 desenvolvedores.

Veja também o gitolite para hospedar seu repositório git. A Gitosis aparentemente não está mais sendo desenvolvida.

Para agregar os bons conselhos das várias outras respostas e comentários sobre a configuração de um novo repositório:

Se você estiver configurando um novo repositório myrepopara /srv/gito grupo mygroup, é isso que você deseja:

mkdir /srv/git/myrepo.git
chgrp mygroup /srv/git/myrepo.git
git init --bare --shared /srv/git/myrepo.git

1. a primeira linha cria o diretório do repositório
2. a segunda linha define seu grupo paramygroup
3. a terceira linha inicializa um repositório vazio com a seguinte configuração:
   1. core.bare = true: torná-lo um repositório simples
   2. core.sharedrepository = 1(igual a core.sharedrepository = group): o diretório repo e todos os diretórios criados posteriormente nele serão gerenciados pelo git para permitir permissões de mygroupleitura, gravação e execução (com o bit sgid definido também -- para trabalhar com usuários para quem mygroupnão é seu grupo primário)
   3. receive.denyNonFastforwards = 1: nega pushes não rápidos para o repositório

Se você quiser ajustar as permissões de usuário, grupo ou outros usuários, use --shared=0NNN, onde NNNestão o usuário padrão, grupo e outros bits para arquivos (os bits execute e sgid nos diretórios serão gerenciados adequadamente pelo git). Por exemplo, isso permite acesso de leitura e gravação ao usuário e acesso somente leitura ao grupo (e nenhum acesso a outro):

git init --bare --shared=0640 /srv/git/myrepo.git

Isso permite acesso de leitura e gravação ao usuário e grupo (e nenhum acesso a outros):

git init --bare --shared=0660 /srv/git/myrepo.git

Isso permite acesso de leitura e gravação ao usuário e grupo e acesso somente leitura a outros:

git init --bare --shared=0664 /srv/git/myrepo.git

Observe que, se você não permitir acesso de gravação ao grupo, certifique-se de usar primeiro chownpara definir o proprietário do repositório e, em seguida, execute o git initcomando como esse usuário (para garantir que o repositório seja inicializado com o proprietário correto para todos os arquivos e subdiretórios iniciais).

Uma maneira de corrigir permissões no repositório compartilhado, para que os usuários não tenham problemas de permissão ao enviar, é criar um script de gancho pós-atualização que fará exatamente isso. Isso deve funcionar em qualquer versão do git.

Suponha que você tenha um repositório compartilhado em /myrepo.git. Todos os arquivos nesse repositório pertencem ao mysharedgroup . Todos os usuários que fazem push para esse repositório também devem pertencer ao mysharedgroup . Agora crie o seguinte arquivo (alterando mysharedgroup para suas preferências):

/myrepo.git/hooks/post-update

#!/bin/sh
chmod -R g+w . 2>/dev/null
chgrp -R mysharedgroup . 2>/dev/null

Você pode usar o git-daemon para compartilhar o repositório. Leia a documentação do git-daemon para obter mais informações.

EDITAR:

Confira também neste artigo 8 maneiras de compartilhar seu repositório git .

Fazer exatamente isso funcionou para mim, para um repositório existente. Isso leva conselhos de várias respostas e comentários antes:

No diretório pai do seu repositório, no servidor:

chgrp -R <whatever group> gitrepo
chmod -R g+wX gitrepo
cd gitrepo
find . -type d -exec chmod g+s {} +
git config core.sharedRepository group

@stevek_mcc a resposta é a que eu estava procurando quando pesquisei essa pergunta no Google

git clone --config core.sharedRepository=true