Git-tfs : Utilisation de Git avec un serveur TFS

(ou comment utiliser Git en environnement hostile!)

Mise à jour le 23/03/2013 : Suite à la version 0.17 de git-tfs et amélioration des commandes (grace à un alias de auto-stash!)
Mise à jour le 14/01/2014 : Suite à la version 0.19.2 de git-tfs et amélioration des commandes (grace à l’option -I!)

Le controleur de code source TFS est bien souvent utilisé en entreprise.

Cependant, parmis les contrôleurs de code source, TFS est celui le plus détesté par les développeurs :( et Git celui le plus apprécié .

Le contrôleur de code source Git apporte pourtant une plus grande souplesse d’utilisation et de nombreux avantages par rapport à le gestion de code source de TFS.

Nous allons donc voir comment nous pouvons utiliser Git en local tout en utilisant TFS côté serveur et ainsi en tirer de nombreux avantages.

1.Installation des outils nécessaires

Avant-propos : Pour consulter l’aide d’une commande git :

git commit -h //aide de la ligne de commande
git help commit //aide html complete de la commande (page man)

2.Configuration de Git & GitExtension

3 moyens…

git config --global user.name "Ton Nom"
git config --global user.email ton_mail@valtech.fr

Les configurations nécessaires pour faire fonctionner Git sous Windows!:

git config --global core.ignorecase true
git config --global core.autocrlf false

Consultation de la liste des configurations :

git config -l
git config --global -l
git config --local -l
notepad++ -multiInst -notabbar

MergeTool : p4merge
MergeTool Path :

C:/Program Files (x86)/p4merge/p4merge.exe

MergeTool command :

"C:/Program Files (x86)/p4merge/p4merge.exe" "$BASE" "$LOCAL" "$REMOTE" "$MERGED"

Difftool : p4merge
Difftool Path :

C:/Program Files (x86)/p4merge/p4merge.exe

Difftool command :

"C:/Program Files (x86)/p4merge/p4merge.exe" "$LOCAL" "$REMOTE"

3.Rappels sur Git!

Git est :

Exemple de graphe acyclique --historique du dépot--
Exemple de graphe acyclique représentant l’historique du dépot

Toute manipulation de Git ne fait que manipuler ce graphe… (Ne jamais l’oublier et essayer de visualiser cela!!)
…en ne faisant qu’ajouter des commits!

4.Présentation de GitExtension

Interface de GitExtension montrant le DAG d’historique du dépot

Démo…

5.Utilisation de Git-TFS:

Note :

5.1. Clonage du dépôt TFS

Commande de clone (dans le répertoire courant) du dépot TFS avec historique (conseillé! mais long…):

git tfs clone http://monServeurTfs:8080/tfs/DepotTfs $/MonProjet/NomDuTronc .

exemple:

git tfs clone https://tfs.codeplex.com:443/tfs/TFS16 $/valtechgittfs/trunk . --username=vtccds_cp@snd --password=vtccds

Note : Attention à ne cloner que le répertoire correspondant à la branche principale du projet (le tronc) et non pas tout le dépot entier!

Commande de clone (dans le répertoire courant) du dépot TFS sans historique (dernier changeset):

git tfs quick-clone http://monServeurTfs:8080/tfs/DepotTfs $/MonProjet/NomDuTronc .

exemple:

git tfs quick-clone https://tfs.codeplex.com:443/tfs/TFS16 $/valtechgittfs/trunk . --username=vtccds_cp@snd --password=vtccds

Convient pour un développement ponctuel ou lorsqu’on n’a pas besoin de l’historique…

Note :

5.2. Récupération des commits de TFS (sans merge ni rebase dans branche master)

git tfs fetch

5.3. Création des commits locaux

Lors des commits locaux dans Git, l’association de Workitems se fait par l’ajout des meta-données suivantes dans la description du commit

#2198 //Pour associer un workitem

5.4. Synchroniser ses modifications avec TFS

Cette commande (comme certaines commande de git) nécessite de n’avoir aucune modification non commité dans son espace de travail.
Pour cela, git fourni une commande ‘stash’ pour mettre de côté les modifications si on ne veut pas les commiter. Elle s’utilise comme cela :

git stash save //pour mettre les modifications de côté
//Execution d'une commande git...
git stash pop //pour récupérer les modifications mises de côté

Pour nous faciliter grandement la tâche, nous allons donc rajouter un alias ‘s’ qui stash avant la commande et stash pop après la commande, si besoin.

Ajouter donc cette ligne d’alias dans votre fichier .gitconfig (après la ligne [alias])

s = !sh -c \"git stash save | grep 'No local changes to save' && git $* || (git $* && git stash pop) \"

Cet alias s’utilise, avec n’importe quelle commande git, en intercalant la lettre ‘s’ (comme stash) juste après le nom de la commande ‘git’ de la façon suivante :

git s rebase maBranche

La commande pour synchroniser ses modifications avec la dernière version de TFS est donc la suivante (en utilisant l’alias ‘s’ défini ci-dessus) :

git s tfs pull --rebase

5.5. Report des commits locaux sur le serveur TFS

Méthode facile mais déconseillée :

git tfs ct

Cette commande ouvre la fenêtre de commit de TFS (message + association de workitems) mais crée un commit de merge (moche et peut y avoir des conflits de merge au moment du commit :( )

Méthode conseillée :

git tfs rcheckin

Cette commande réapplique les commits sur le serveur TFS. Cependant, nécessite d’être à jour par rapport aux commits sur TFS et d’avoir “rebasé” ses commits locaux. Cependant, une option --quick et --autorebase permet de faire tout cela.

Cette commande nécessite également de ne pas avoir de modifications dans l’espace de travail donc nous allons également utiliser notre alias ‘s’.

Pour commiter sur TFS, la commande est donc :

git s tfs rcheckin --quick --autorebase

ou, en version courte :

git s tfs rcheckin --quick -a

5.6.Gestion d’une branche de TFS:

Deux options se dessinent:
- créer une branche avec git-tfs
- récupérer une branche déjà exitante sur TFS

La création d’une branche à partir de n’importe lequel des commits existant (il suffit de faire un checkout sur le bon commit avant de créer la branche) se fait en utilisant la commande:

git tfs branch $/MonProjet/BrancheACréer <nomOptionnelLocalDeMaBranche> --comment="Commentaire de création de la branche"

La récupération d’une branche TFS exitante grâce à la commande “init-branch” :

git tfs branch --init $/MyProject/MyTFSBranch //Pour récupérer une branche spécifique
git tfs branch --init --all //Pour récupérer toutes les branches existantes
ex :
git tfs branch --init $/valtechgittfs/branche1

A l’identique des commandes utilisées pour travailler sur la branche principale, on utilisera les même commandes que définies précédement en l’option -I qui sélectionne automatiquement la bonne branche tfs. Cette option a l’avantage de fonctionner aussi bien avec la branche prinipale qu’avec les autre branches. On peut donc l’utiliser en permanence.

Récupération des commits d’une branche:

git tfs fetch -I

Synchroniser ses modifications avec la dernière version de la branche sur TFS:

git s tfs pull --rebase -I

Commiter sur la branche sur TFS:

git s tfs rcheckin --quick -a -I

5.7.Scripts GitExtension:

Il peut être pratique de créer dans GitExtension les scripts décrit ci-dessous basée sur le commandes décrites précédement; elles sont disponibles par un clic droit dans le Browser de GitExtension.
Pour cela, allez dans le menu “Settings”→“Settings…”→Onglet “Scripts” et ajoutez une ligne où on remplira les 3 champs requis par les valeurs de chaque ligne :

Name Cmd. Arguments
Tfs.Fetch git tfs fetch -I
Tfs.Rebase git s tfs pull --rebase -I
Tfs.Commit git s tfs rcheckin --quick --autorebase -I

5.8.Nouvelle commandes de gestion des branches

Depuis la version 0.17 de git-tfs, on peut maintenant gérer un peu mieux les branches.
Outre la nouvelle commande de création des branches présentée précédement, nous pouvonc maintenant…

- afficher les branches gérées localement

git tfs branch

- afficher toutes les branches TFS

git tfs branch -r

- renomer un branche locale

git tfs branch --move oldName newName

- effacer une branche locale

git tfs branch --delete myBranch

Note : Pour plus d’informations, vous pouvez toujours consulter l’aide avec la commande :

git tfs branch --help

5.9.Travailler avec les shelvesets

Liste de ses commits réservés

git tfs shelve-list

Ceux d’un autre utilisateur:

git tfs shelve-list -u LOGIN_UTILISATEUR

Créer une branche à partir d’un shelveset:

git tfs unshelve MonShelveset MaBranche

Créer un commit réservé de la branche courante:

git tfs shelve MonShelveset

Avantage de la branche Git sur le shelveset TFS :

6.Utilisation de Git

git stash save //pour mettre de côté
git stash pop //pour récupérer le dernier stash mis de côté

Le merge :

  1. crée un commit supplémentaire pour réunir les 2 branches.
  2. Il permet de matérialiser l’introduction d’une fonctionnalité dans une branche.
  3. Cette opération peut être réalisée avec des fichiers modifiés dans l’espace de travail.
le DAG après un merge : le commit C6 est un commit de merge

Le rebase :

  1. réapplique les commit d’une branche sur un commit.
  2. Il permet d’avoir un historique linéaire.
  3. Cette opération ne peut être réalisée avec des fichiers modifiés dans l’espace de travail (nécessité de faire un stash auparavant).
le DAG après un rebase : le commit C3 est réappliqué sur la branche master… 
git rebase -i HEAD~n (avec 'n' à remplacer par le nombre de commit qu'on veut réécrire)

Attention : Ne pas enfreindre la règle de base!!!

git reflog => voire l'historique des modification
git branch MaBranche d995afd => creation d'une branche sur un commit (en indiquant son sha1)

7. Aperçu de Git-TF

8. Retour d’expérience

Avantages:

Inconvénients:

9. Conclusion

Beaucoup d’avantages avec cependant quelques petits désagréments (si on ne possède pas la version 2012 de VisualStudio)
Le meilleur résumé serait celui ci : “TFS est une solution d’archivage de code source, là où Git est un outil facilitant le développement”

PS :


Philippe Miossec 14 January 2014
blog comments powered by Disqus