Index

aptitude install git-core

Il y a certainement mieux pour initialiser mais bon. Voilà une méthode de A-Z d'initialisation d'un nouveau repos :

En local sur un client :

mkdir mon_projet
cd mon_projet
git init

Ensuite on y met nos premiers fichiers :

touch README

On fait notre premier ajout/commit :

git add .
git commit

Ensuite on le clone au format bare :

cd ..
git clone --bare monprojet monprojet.git

Ensuite on met notre clone sur un serveur public :

scp -r monprojet.git/ user@srv:public_git/monprojet.git/

On peut ensuite faire un clone du projet en local :

git clone ssh://user@srv/home/user/public_git/monprojet.git monprojet_local

On peut maintenant utiliser ce clone normalement : add, commit, push, …

Éditer le fichier /etc/inetd.conf et ajouter la ligne suivante :

git     stream  tcp4    nowait  root    /usr/bin/git-daemon -- --inetd --syslog --verbose --export-all --base-path=[BASE] --timeout=60 --user-path=public_git

[BASE] : le chemin de base de l'accès = la racine des urls d'accès
- Exemple:
  - URL :

git://srv/toto

[BASE] : /home
Alors la racine du repos sera /home/toto
–user-path : Le dossier dans les homes des utilisateurs qui seront partagé grâce à une URL en ~user (ici ~toto = $HOME/public_git)

Restart openbsd-inetd : /etc/init.d/openbsd-inetd restart

Avec git-daemon-run

Installer le paquet git-daemon-run :
```
apt-get install git-daemon-run
```
Editer le fichier de lancement du daemon : /etc/sv/git-daemon/run

Exemple d'une configuration avec un utilisateur git :

#!/bin/sh
exec 2>&1
echo 'git-daemon starting.'
exec chpst -ugit \
  "$(git --exec-path)"/git-daemon --verbose --reuseaddr --export-all --enable=receive-pack \
    --base-path=/home/git /home/git

Pour contrôler le service :

Démarrage :
```
sv start git-daemon
```
Arrêt :
```
sv stop git-daemon
```
Redémarrage :
```
sv restart git-daemon
```

Suivie des logs dans le fichier : /var/log/git-daemon/current

git config --global user.email "user@email.com"
git config --global user.name "User Name"

Remarque : Les infos sont stockées dans ˜/.gitconfig

Via protocole Git :

git clone git://srv/~toto/monprojet monprojet_local

Via SSH :

git clone ssh://toto@srv/home/toto/public_git/monprojet monprojet_local

monprojet_local : Chemin local du repo

git checkout -b prod origin/prod

Connaitre le statut des fichiers modifié/ajouté/supprimé :
```
git status
```

Ajouter un nouveau fichier :
```
git add file1 file2 ...
```

Supprimer un fichier :
```
git rm file1
```

Bouger/renomer un fichier :
```
git mv file-old file-new
```

Commiter (local) :
```
git commit [-a]
```

Envoyer ses commits sur le serveur remote :
```
git push
```

Récupérer les derniers commits des autres dans son repos :
```
git pull
```

Modifier le dernier commit (non propagé) :

Faire les modifications souhaitées et les ajouter avec la commande git add
Commiter en modifiant le dernier commit :
```
git commit --amend
```

Modifier un commit spécifique (non propagé) :
- Via “fixup” :
  1. commiter vos modifications à fusionner dans le précédent commit via la commande suivante en indiquant l'ID du commit à modifier
```
git commit --fixup=38b184620e5d0da47de4c6d7ed81e807af479fb2
```
  2. exécuter ensuite la commande suivante en indiquant l'ID du commit à modifier (attention au ^ à la fin de l'ID du commit) :
```
git rebase --interactive '38b184620e5d0da47de4c6d7ed81e807af479fb2^' --autostash --autosquash
```
- Via une édition manuelle :
  1. exécuter la commande suivante en indiquant l'ID du commit à modifier (attention au ^ à la fin de l'ID du commit) :
```
git rebase --interactive '38b184620e5d0da47de4c6d7ed81e807af479fb2^' --autostash
```
  2. Dans l'éditeur s'ouvrant, repérer la ligne spécifiant le commit à modifier et remplacer pick par edit. Enregistrer et quitter l'éditeur.
  3. Effectuer la modification souhaitez puis commiter à l'aide de la commande suivante :
```
git commit --all --amend --no-edit
```
  4. Vous pouvez constater que votre commit à bien été modifié à l'aide de la commande git show
  5. Pour revenir à votre working tree intégrant vos commits suivants, exécuter la commande suivante :
```
git rebase --continue
```

Supprimer le dernier commit (en conservant les modifications) :
```
git reset HEAD^
```
Supprimer le dernier commit (en suppriant les modifications) :
```
git reset --hard HEAD^
```

Remarque : C'est la même chose qu'un git fetch puis un git merge

Voir la liste des commits :
```
git log
```

Remarque : On peut rajouter un nom de fichier pour voir seulement les commits impactant ce fichier.

Générer des patchs à partir de vos commits :
- repérer dans git log l'ID du commit précédent le(s) commit(s) pour lesquel vous souhaitez générer les patchs
- lancer la commande suivante :
```
git format-patch [ID commit précédent]
```
Appliquer un patch sans comiter :
```
git apply [patch]
```
Appliquer un patch et le comiter avec les informations fournis dans celui-ci :
```
git am --signoff -k < [patch]
```

Remarques :

le paramètre –signoff permet d'ajouter une ligne Signed-off-by: dans le message du commit avec vos informations.
le paramètre -k permet de conserver les éventuels flag présent dans le message de commit (infos entre crochets)