J'ai un référentiel Git sur un serveur de transfert que plusieurs développeurs doivent pouvoir exploiter. git-initsemble avoir un drapeau très proche de ce que je recherche:, --sharedsauf que j'aimerais que plusieurs personnes se rendent dans ce référentiel également. Le git-clone« s --shareddrapeau fait quelque chose de tout à fait différent.

Quel est le moyen le plus simple de modifier les autorisations d'un référentiel existant?

Les autorisations sont un ravageur.

En gros, vous devez vous assurer que tous ces développeurs peuvent écrire dans tout le référentiel git.

Passez à la solution New-Wave pour la méthode supérieure d’octroi de capacités d’écriture à un groupe de développeurs.

La solution standard

Si vous placez tous les développeurs dans un groupe spécialement créé, vous pouvez en principe simplement:

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

Modifiez ensuite le paramètre umaskpour les utilisateurs 002afin que les nouveaux fichiers soient créés avec des autorisations accessibles en écriture au groupe.

Les problèmes avec ceci sont légion; Si vous êtes sur une distribution qui suppose un umaskde 022(comme avoir un usersgroupe commun qui inclut tout le monde par défaut), cela peut créer des problèmes de sécurité ailleurs. Et tôt ou tard, quelque chose va bousiller votre système de permissions soigneusement conçu, mettant le référentiel hors d’action jusqu’à ce que vous obteniez un rootaccès et le corrigiez (c’est-à-dire, relancez les commandes ci-dessus).

La solution New-Wave

Une solution supérieure - bien que moins bien comprise et nécessitant un peu plus de prise en charge des systèmes d’exploitation / des outils - consiste à utiliser les attributs étendus POSIX. Je ne suis venu dans cette région que récemment, donc mes connaissances ne sont pas aussi intéressantes que possible. Mais fondamentalement, une liste de contrôle d'accès étendue permet de définir des autorisations sur plus de 3 emplacements par défaut (utilisateur / groupe / autre).

Alors encore une fois, créez votre groupe, puis lancez:

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

Cela configure la liste de contrôle d'accès étendue pour le groupe afin que les membres du groupe puissent lire / écrire / accéder aux fichiers déjà présents (la première ligne); Ensuite, indiquez également à tous les répertoires existants que la même liste de contrôle d'accès doit être appliquée aux nouveaux fichiers (la deuxième ligne).

J'espère que cela vous amène sur votre chemin.

si vous avez créé le référentiel (ou cloné un nouveau référentiel nu sur un référentiel existant) avec

$ git init --shared=group 

ou

$ git init --shared=0NNN

Git est supposé gérer les autorisations au-delà de ce que votre umask par défaut fournit. Enfin, cela est vrai sur ma version de Git (1.6.3). Bien entendu, cela suppose que vos utilisateurs appartiennent au même groupe.

Si j'avais besoin de gérer des utilisateurs dans plusieurs groupes avec des degrés variables de lecture / écriture, je choisirais la gitose. J'ai aussi entendu parler de gitolite ( http://github.com/sitaramc/gitolite ), un fork de gitosis qui est supposé fournir des autorisations au niveau de la branche, mais je ne peux pas dire que je l'ai tous personnellement utilisé.

Cela n'a pas été dit, je veux donc l'ajouter rapidement.

Pour vous assurer que les problèmes d'autorisations ne coupent pas leur tête laide, assurez-vous de définir les éléments suivants dans le fichier de configuration de votre référentiel partagé git:

[core]
    sharedRepository = true

Cela garantira que les paramètres "umask" de votre système sont respectés.

Le manuel de l'utilisateur Git explique comment partager un référentiel de plusieurs manières.

• Exporter via le démon Git .
• Exporter via HTTP .
• Style CVS / SVN, un seul référentiel partagé où les développeurs poussent / tirent.

Les moyens les plus complexes de partage de référentiels, bien que comportant de nombreuses fonctionnalités, sont les suivants:

• Gitose
• GitHub (ou installation de GitHub Firewall )

Nous utilisons GitHub pour une équipe de 6 développeurs.

Consultez également gitolite pour l'hébergement de votre référentiel git. La gitose n'est apparemment plus en train de se développer.

Un moyen de corriger les autorisations dans le référentiel partagé, afin d'éviter les problèmes d'autorisations lors de l'insertion, consiste à créer un script de hook post-mise à jour qui le fera exactement. Cela devrait fonctionner dans n'importe quelle version de Git.

Supposons que vous ayez un référentiel partagé dans /myrepo.git. Tous les fichiers de ce dépôt appartiennent à mysharedgroup . Tous les utilisateurs poussant vers ce référentiel doivent également appartenir à mysharedgroup . Créez maintenant le fichier suivant (en modifiant mysharedgroup selon vos préférences):

/myrepo.git/hooks/post-update

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

Pour regrouper les éléments de bon conseil des différentes autres réponses et commentaires sur la mise en place d'un nouveau référentiel:

Si vous configurez un nouveau repo myrepodans /srv/gitle groupe mygroup, c'est ce que vous voulez:

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

1. la première ligne crée le répertoire repo
2. la deuxième ligne définit son groupe à mygroup
3. la troisième ligne initialise un rapport nu avec la configuration suivante:
   1. core.bare = true: en faire un repo nu
   2. core.sharedrepository = 1(identique à core.sharedrepository = group): le répertoire repo et tous les répertoires créés ultérieurement y seront gérés par git pour permettre les autorisations de mygrouplecture, d’écriture et d’exécution (avec le bit sgid également défini - de manière à fonctionner avec des utilisateurs pour lesquels ils mygroupne sont pas les leurs. groupe primaire)
   3. receive.denyNonFastforwards = 1: refuser les poussées non rapides vers le repo

Si vous souhaitez ajuster avec précision les autorisations des utilisateurs, des groupes ou des autres utilisateurs, utilisez l' --shared=0NNNemplacement où se NNNtrouvent l'utilisateur, le groupe et les autres bits standard des fichiers (les bits execute et sgid des répertoires seront gérés de manière appropriée par git). Par exemple, cela permet un accès en lecture et en écriture à l'utilisateur, ainsi qu'un accès en lecture seule au groupe (et aucun accès aux autres):

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

Cela permet un accès en lecture et en écriture à l'utilisateur et au groupe (et aucun accès aux autres):

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

Cela permet un accès en lecture et en écriture à l'utilisateur et au groupe, ainsi qu'un accès en lecture seule à d'autres:

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

Notez que si vous n'autorisez pas l'accès en écriture au groupe, assurez-vous d'abord chownde définir le propriétaire du référentiel, puis exécutez la git initcommande en tant qu'utilisateur (pour vous assurer que le référentiel est initialisé avec le propriétaire correct tous les fichiers et sous-répertoires initiaux).

Vous pouvez utiliser git-daemon pour partager le référentiel. Lisez la documentation de git-daemon pour plus d'informations.

MODIFIER:

Consultez également cet article sur 8 façons de partager votre référentiel git .

Faire exactement cela a fonctionné pour moi, pour un référentiel existant. Cela prend conseil de plusieurs réponses et commentaires avant:

À partir du répertoire parent de votre référentiel, sur le serveur:

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 la réponse est celle que je cherchais quand j'ai cherché sur Google pour cette question

git clone --config core.sharedRepository=true