Créer un dépôt partagé avec Git

De Ensiwiki
Aller à : navigation, rechercher

Cette page explique pas à pas comment créer un dépôt partagé avec Git. un dépôt partagé est un dépôt auquel plusieurs personnes ont accès, et vers lequel elles peuvent faire des push et des pull. Si votre binôme a déjà mis en place ce dépôt, vous pouvez lire la page Utiliser un dépôt existant avec Git pour y accéder.

En projet GL, les dépôts partagés sont les comptes glXX@ensibm.imag.fr. Si vous avez déjà pris l'habitude de ce mode de fonctionnement, cette page devrait vous permettre de reproduire cette configuration en quelques commandes.

On considère le cas de trois étudiants, Alice, Bob et Charlie, ayant chacun un compte à l'Ensimag. Ils travaillent parfois sur un PC de l'école (disons, ensipc42) et parfois sur leur portable (alicelaptop, boblaptop, ...). Les dépôts Git seront hébergés sur la machine depots.ensimag.fr, qui est prévue pour cela à l'Ensimag.

Dans les explications ci-dessous, $annee est le nom de l'année en cours. Par exemple, annee=2014 pour l'année scolaire 2014-2015.

Création du dépôt partagé

Créer un dépôt Git est assez simple. Il s'agit essentiellement de lancer la commande git init. Il n'y a pas besoin de droit particulier, pas besoin d'installer un serveur ... En bref, tout étudiant peut créer un dépôt sur les machine de l'Ensimag.

Pour notre exemple, c'est Alice qui va créer le dépôt. À l'Ensimag, les comptes utilisateurs sont protégés, on ne peut pas créer de répertoire partagés dedans. Alice va donc créer le dépôt dans /depots/$annee/, qui est prévu pour cela. Ce répertoire n'existe que sur le serveur depots.ensimag.fr, et il n'est pas partagé : vous ne le verrez donc pas sur les PCs, mais Git saura y accéder via SSH. Sauf si vous travaillez sur telesun, il faudra donc commencer par ouvrir un shell dessus :

ssh depots.ensimag.fr

On va commencer par créer un dépôt sans arbre de travail, ce qui se fait avec l'option --bare de git init. Pour que les autres membres de l'équipe aient accès à le dépôt, on utilise l'option --shared.

alice@depots.ensimag.fr> mkdir /depots/$annee/alice-et-bob/
alice@depots.ensimag.fr> chmod go-rwx /depots/$annee/alice-et-bob/
alice@depots.ensimag.fr> cd /depots/$annee/alice-et-bob/
alice@depots.ensimag.fr> git init --shared --bare notre-tp.git

Il faut maintenant donner les droits à Bob et Charlie sur ce dépôt. À l'Ensimag, on peut utiliser autoriser-equipe :

alice@depots.ensimag.fr> autoriser-equipe notre-tp.git bob charlie

Le dépôt /depots/$annee/alice-et-bob/notre-tp.git/ sera notre dépôt partagé.

Note : Parfois, il est aussi nécessaire d'executer le script autoriser-equipe sur le répertoire du projet (alice-et-bob dans l'exemple).

alice@depots.ensimag.fr> autoriser-equipe . bob charlie

Commencer à travailler : faire un clone

On ne va pas travailler directement sur le dépôt partagé (qui de toutes façons, n'a pas d'arbre de travail), mais chacun va faire un clone pour récupérer une copie de ce dépôt partagé, sur lequel il travaillera (i.e. utilisera son éditeur de texte, compilera, fera des commits, ...).

Premier git clone

Par exemple, sur un serveur de l'Ensimag, Alice fait un git clone comme ceci :

alice@ensipc42> cd ~/TPs/
alice@ensipc42> git clone ssh://alice@depots.ensimag.fr/depots/$annee/alice-et-bob/notre-tp.git tp1
alice@ensipc42> cd tp1

Import des fichiers du TP

Le dépôt est pour l'instant vide, mais on va bien sûr lui ajouter des fichiers. Si Alice avait commencé son TP dans un autre répertoire, elle peut par exemple faire :

alice@ensipc42> cd ~/TPs/tp1/
alice@ensipc42> cp ~/TPs/tp1-commence-sans-git/*.c .
alice@ensipc42> git add *.c
alice@ensipc42> git commit -m "Import des fichiers du TP"

Pour importer les fichiers, et terminer par :

alice@ensipc42> git push --all

pour envoyer ces fichiers au dépôt (l'option --all est nécessaire pour le premier push).

Bien sûr, si le TP n'était pas commencé, il faudrait remplacer le cp .../*.c . par du travail. Mais dans tous les cas, les travaux d'édition de texte se font dans le clone, et non dans le dépôt partagé.

Faire un clone depuis les autres machines

Alice veut travailler également sur son portable, donc elle fait :

alicelaptop> cd ~/TPs/
alicelaptop> git clone ssh://alice@depots.ensimag.fr/depots/$annee/alice-et-bob/notre-tp.git tp1
alicelaptop> cd tp1

Comme Alice s'est renseignée sur les Clés SSH, elle n'a pas besoin de taper son mot de passe à chaque fois.

De son côté, Bob travaille sur son portable et fait :

boblaptop> cd ~/TPs/
boblaptop> git clone ssh://bob@depots.ensimag.fr/depots/$annee/alice-et-bob/notre-tp.git tp1
boblaptop> cd tp1

Bob a fait bien attention d'utiliser son login à l'Ensimag (et non celui d'Alice) comme login dans l'URL du dépôt (bob@depots.ensimag.fr). Depuis l'Ensimag, Bob peut utiliser exactement la même commande.

Enregistrer des modifications : commit

On peut alors travailler localement avec Git, avec les commandes usuelles :

  • git status : pour savoir où on en est.
  • git diff HEAD : voir les modifications depuis le dernier commit.
  • git add, git rm : ajouter/supprimer des fichiers du prochain commit.
  • git commit -a : enregistrer l'état courant des fichiers dans un commit.

Publier ses modifications : push

Après un ou plusieurs commits, on peut les envoyer au dépôt partagé avec git push :

git push

Il faudra peut-être faire un git pull avant si le dépôt partagé contient des commits que nous n'avons pas encore.

Récupérer les modifications des autres : pull

Pour récupérer les modifications envoyées par les autres au dépôt partagé, on fait un git pull :

git pull

Cette commande ne doit en générale être lancée que quand il n'y a pas de changements non « commités » dans l'arbre de travail.

Détails techniques

Cette section n'est pas nécessaire pour appliquer les explications, mais peuvent servir aux curieux ...

Pourquoi git init --shared ?

Quand Git compacte un dépôt (ce qu'il fait automatiquement de temps à autres, cf. git gc), il crée un fichier .git/objects/pack/pack-*.pack. Si on n'a pas utilisé l'option --shared, avec Git <= v1.7.0.2, il va faire un chmod dessus pour enlever les droits au groupe. Malheureusement, en présence d'ACL, cette action va modifier le masque d'ACL et couper les droits aux autres membres de l'équipe. Heureusement, ce bug de Git est corrigé depuis. Si on a un Git récent, on peut donc omettre ce --shared.

Et si je n'ai pas autoriser-equipe ?

autoriser-equipe est un script tout simple qui positionne les ACLs pour autoriser une liste de logins à accéder à un répertoire, et positionne l'ACL par défaut pour que les nouveaux fichiers héritent de ces ACLs. La page Access Control List donne un exemple d'utilisation, il suffit d'adapter les commandes setfacl à votre cas.

Pourquoi un dépôt partagé ?

Git permet effectivement des manières de travailler beaucoup plus flexibles que le travail avec un et un seul dépôt partagé. On peut en fait faire des push et des pull depuis n'importe quel dépôt vers n'importe quelle autre. Mais l'auteur de cette page a jugé que le mode avec un dépôt partagé était moins déroutant pour les débutants, et que les autres pouvaient lire la documentation. Plus concrètement :

  • On n'a à faire git init et se poser les questions de permissions qu'une seule fois.
  • On peut faire des git push et git pull sans argument, donc sans trop se poser de question.
  • En cas de panique, on peut refaire un git clone.
  • On évite l'épineux problème du git push vers un dépôt « non-bare ».