Usage réel du Mercurial avec un serveur de fondation de l'équipe?
Mon magasin utilise TFS & en est généralement satisfait de celui-ci, à l'exception du manque de référentiel local comme des commissions/revêtements. Je commence à utiliser Mercurial moi-même pour vous aider à gérer des morceaux de changements plus petits, puis de les afficher à TFS. Je vois que la subversion a un composant "pont" pour activer automatiquement cela si la VCS centrale est subversion. Je n'ai pas trouvé un pour le système d'équipe. Cela m'encourage que d'autres personnes ont baissé cette voie avec l'intégration de DVC avec des systèmes CVCS.
(1) Est-ce que quelqu'un en connaît-il d'un? Je suis en train de douter (la recherche rapide n'a rien trouvé).
(2) Quelqu'un utilise-t-il Mercurial/TFS de cette manière? Si oui, pouvez-vous partager vos expériences? Je suis particulièrement à la recherche de points de vue sur les problèmes qui pourraient arriver qui ne sont pas évidents en ce qui concerne les engagements à TFS après une activité significative via mercuriale.
Cela semble être une victoire gagnant totale jusqu'à présent avec juste moi en utilisant si pendant quelques jours - mais j'en sais assez pour penser que c'est juste aussi facile.
Je ne sais pas si c'est tout ce que vous ne savez pas déjà, mais j'utilise Mercurial localement pendant un peu de temps, et je pense que les avantages sont accumulés dans les frais généraux supplémentaires de la gestion des deux systèmes de contrôle des sources. Voici comment j'ai fait des choses:
J'ai fait mon coctural TFS un référentiel HG que je considère mon "maître". Je reçois des mises à jour de TFS et engagez-les à ce repo, cela contient donc l'état le plus courant du projet de TFS. La chose importante ici est qu'il n'y a pas de modification de cette question rendue indépendante d'une mise à jour de TFS ou d'une fusion HG (qui est la partie 2)
Chaque fois que je dois faire un changement, je clonage mon "maître" repo et que je fais mon travail là-bas. J'ai découvert qu'un clone par caractéristique ou par histoire est en fait assez facile à gérer et se sent assez propre. Une fois que j'ai terminé une fonctionnalité, je fais un hg fusionnant sur le repo "Master", qui a eu toutes les mises à jour TFS appliquées. Cela me permet d'utiliser des capacités de fusion de mercuriels, qui sont jusqu'à présent supérieures à TFS quant à la question de savoir comment TFS peut prétendre à fusionner du code du tout. Une fois la fusion terminée, je l'engage dans HG, puis vérifiez ces changements dans TFS. La meilleure partie de cela est que lorsque je fais la vérification à TFS, je n'ai rien à fusionner. Très très gentil.
Maintenant, voici les problèmes que j'ai trouvés avec cette approche:
Le plus grand est le fait que TFS soit moche à trouver des changements. Il y a un plugin faire des écrits que vous pouvez utiliser pour rendre les fichiers modifiés écrits lorsqu'ils sont mis à jour/fusionné par Mercurial. Il y a deux options que j'ai trouvées pour cela. Vous pouvez soit forcer TFS à passer à côté, à ce point, il conviendra de vérifier quoi que ce soit d'être enregistré, ou vous pouvez utiliser l'outil de comparer dans l'outil de contrôle source et sélectionner les fichiers modifiés et les vérifier individuellement. Les deux sont merdiques imo
Les liaisons de contrôle source sont toujours présentes au niveau du projet, même si vous excluez les fichiers de contrôle de source TFS de votre référentiel HG (que vous devriez faire). Ce n'est pas entièrement évident que vous n'avez pas ajouté un fichier à la solution, à quel point il essaie l'ajouter au contrôle de la source. Vous pouvez "annuler des changements en attente" et vous débarrasser de l'ajout du contrôle source, mais c'est vraiment ennuyeux.
La bonne nouvelle est que j'ai utilisé cette approche pour travailler à travers une fusion plutôt massive que je pense m'avoir amené à me tourner vers une forme de drogue difficile si j'ai été forcée d'utiliser les outils TFS pour le faire.
Je n'ai pas encore appliqué cela pour mettre à jour des succursales au sein de TFS, mais je suppose que ce serait bien mieux que les options que vous recevez pour la fusion dans TFS. Sur une note connexe, puisque vous pouvez enregistrer des morceaux de fonctionnalité de travail à une fois, l'utilisation de la fusion TFS serait moins problématique, car toutes les modifications nécessaires pour une fonctionnalité seraient ensemble au même endroit.
Une chose que je n'ai pas essayé de faire face à cela dans toute l'équipe. Une partie de la raison est que cela ne doit vraiment pas être une chose à l'échelle de l'équipe. Je travaille à distance, alors disposer d'un référentiel local est une grosse affaire et économise beaucoup de temps. Les autres membres de mon équipe de développement peuvent avoir ou non avoir le même avantage de cette approche, mais je trouve cela assez cool que je peut Sans effectuer la façon dont ils fonctionnent.
Mise à jour Je voulais mettre à jour cette réponse pendant un certain temps avec des informations supplémentaires basées sur des commentaires et certaines de mes expériences travaillant avec de grands référentiels TFS.
Tout d'abord comme @ Eric Hexter indique dans les commentaires, vous pouvez utiliser l'extension Rebase Extension pour mieux intégrer les engagements de vos référentiels de travail dans votre référentiel TFS principal. Cependant, en fonction de la façon dont vous voulez que vos engageurs apparaissent à TFS, vous souhaiterez peut-être utiliser l'extension EXTENSION DE COLLECTIONNE pour raccourcir vos modifications en un seul commit (cela peut faciliter les retombées dans TFS). Il y a aussi la commande "en ligne" de TFS PowerTools qui peut faire le travail de laisser TFS savoir ce qui a plus de plus facilité (merci à Eric pour mentionner que dans son blog post )
Maintenant, quand j'écris à l'origine, je travaillais sur un projet qui n'avait qu'une branche TFS que les développeurs utilisaient et étaient assez petites. Les référentiels de clonage n'étaient donc pas importants. Je me suis retrouvé plus tard travailler sur un projet qui avait un repo d'environ 1,5 Go après la caisse, et beaucoup plus grande après la construction et impliquait la commutation entre les branches de TFS. Il est clair que cette approche n'est pas bien adaptée à cet environnement (en particulier depuis à un moment donné, il était impossible de construire les solutions dans un répertoire arbitraire.
Le problème de la taille est mieux géré en utilisant une technique similaire à des succursales de gits plutôt que de cloner les référentiels à de nouveaux répertoires. Il y a quelques options pour cela. Je pense que le meilleur est en réalité utiliser le Extension de signet et créer des "marque-pages" plutôt que des succursales. Vous pouvez également utiliser des succursales nommées, mais ils ont le léger inconvénient d'être permanents et de voyager avec des clones que vous pouvez faire (si vous souhaitez partager votre hybride NIFTY TFS-HG avec un collègue). Les signets sont locaux à votre repo et indiquent efficacement à un commit et de voyage avec la tête. Ils sont mis en œuvre afin qu'ils puissent être utilisés dans n'importe quel endroit où HG s'attend à une révision (ainsi de fusion, de mises à jour, etc.). Vous pouvez les utiliser pour créer un signet TFS comme "une branche" principale qui obtient uniquement des mises à jour de TFS et fusionne du travail de sujet, ce qui aurait chacun leurs propres signets, et vous pourriez supprimer une fois que vous vous êtes attaqué à TFS. Si vous préférez utiliser des branches nommées, vous pouvez appliquer exactement les mêmes techniques, qui sont pratiques.
Maintenant, le problème de la branche multiple est plus délicat, d'autant plus que les "branches" TFS sont en réalité des copies de chaque fichier de la branche d'origine, ce qui signifie que chaque fois que vous tirez dans des branches de TFS, votre repo va obtenir beaucoup plus grand. Un moyen possible de faire face à cela est une combinaison de branches HG nommées et de signets, de sorte que vous ayez une succursale pour chaque branche TFS, puis créez des signets pour votre travail de ces branches. Le mal de tête réel de ces scénarios traite en fait des espaces de travail TFS à travers tout cela. Vous pouvez supprimer les mappages dans vos espaces de travail et aller assez loin, mais une fois que vous avez mapponnée à votre répertoire de travail, vous devez faire attention à TFS piétinant sur les fichiers (c'est en fait où le TF PowerTools est utile). Essayer de laisser l'espace de travail attaché pendant que vos branches de commutation autour devient laid rapide. Un couple d'outils agréable à avoir dans votre ceinture d'outils sont le HG extension de purge et la commande TF Powertools "Scorch". Tous deux supprimer efficacement les fichiers qui ne sont pas dans la commande de version (techniquement "Scorch" garantissent que TFS et votre correspondance de votre répertoire de travail local, afin de mettre à jour les fichiers également).
Pour moi, cependant, ce processus est devenu assez lourd et d'erreur sujette. Je suis récemment passé à utiliser Git avec git-tfs , puisqu'il gère les espaces de travail TFS pour moi et supprime beaucoup de fardeau associé à ce côté. Malheureusement, il ne semble pas y avoir de "HG-TFS" là-bas n'importe où, ou j'aurais probablement choisi cela.
Si vous n'êtes pas coincé sur Mercurial, il y a un projet d'intégration GIT/TFS que j'utilise appelé Git-TFS. C'est très similaire à Git-Svn, mais pousse à la place/tire de TFS. Vérifiez-le à http://github.com/spraints/git-tfs
Je sais que certaines personnes ont utilisé HgSubversion avec le pont Subversion. Je ne sais pas à quel point cela a fonctionné et je n'ai jamais eu à utiliser TFS.
Autant que je sache, il n'y a pas de pont "plus indigène" que d'utiliser TFS -> Subversion Bridge -> Hgsubversion, mais j'ai également entendu dire qu'il fonctionne assez bien. Ma compréhension extrêmement limitée de TFS suggère que son modèle interne devrait être suffisamment similaire à la subversion pour des choses comme Hgsubversion pour fonctionner très bien.
Je viens de mettre en place un petit outil, HGTFS, qui essaie d'accomplir l'objectif de synchroniser les référentiels mercuriels et TFS. C'est vraiment simple et n'a que trois commandes: cloner, tirer et pousser. Voici mon bitbucket repo:
https://bitbucket.org/thepetender/hgtfs
Il existe également un message de blog décrivant le flux de travail et les scénarios d'utilisation (en fait, les pages Wiki ne sont que des parties de cette entrée de blog):
http://www.olegtarasov.me/post/2013/07/mercurial-a-tfs-bridge- (hgtfs)
Le code est hacky, mais il semble faire le travail. J'apprécierais vraiment les commentaires ou les fourches :)
Voici un script PowerShell que j'utilise pour travailler avec TFS & HG. Pour utiliser, vous devez créer un référentiel HG dans votre dossier TFS (commettez les fichiers de TFS), clonez ce référentiel et travaillez sur le nouveau référentiel. Une fois heureux, vous pouvez exécuter "hgtfs.ps1 pousser" pour repousser les modifications dans TFS de votre référentiel mercurial.
hgtfs.ps1:
param([parameter(Position=0, Mandatory=$true)][string] $action)
$HGDirectory = Get-Location
$TfsDirectory = @(hg paths | where-object { $_.StartsWith("default = ") })[0].SubString(10)
# Pull from TFS
function pull
{
# Todo pull changes one by one brining who did it and the comment into HG
# tf history . /recursive /format:brief /noprompt /version:300~1000 /sort:ascending
# tf properties . /recursive
# Add the changes from TFS into the TFS HG repository
Set-Location $TfsDirectory
tf get . /recursive
hg commit -A -m "Update from TFS"
# Pull / merge the changes from TFS's HG repository
Set-Location $HGDirectory
hg pull
hg merge --tool internal:fail
hg commit -m "Merged from TFS"
""
"The you have the following conflicts which need resolving"
hg resolve -l | write-Host -foregroundcolor "red"
#thg commit
}
# Push to TFS
function Push
{
Set-Location $HGDirectory
hg Push
Set-Location $TfsDirectory
$FilesModified = @()
$FilesRenamed = @{} # Key: old file name .... Val: new file name
$FilesRemoved = @()
$FilesAdded = @()
# Work out what changes have taken place
"Calculating the changes which have been made in HG..."
tfpt scorch /exclude:.hg,*.user | out-null
$AllChanges = hg status --rev .:tip -A
for($i = 0; $i -lt $AllChanges.length ; $i++)
{
$type = $AllChanges[$i].SubString(0, 2)
$fileName = $AllChanges[$i].SubString(2)
switch($type)
{
"M " # Modified files
{
$FilesModified += $fileName
}
"A " # New Files
{
$nextType = $null
$nextFileName = $null
if($AllChanges.length -gt ($i+1))
{
$nextType = $AllChanges[$i+1].SubString(0, 2)
$nextFileName = $AllChanges[$i+1].SubString(2)
}
if($nextType -eq " ")
{
# we have a rename
$FilesRenamed[$nextFileName]=$fileName
$i++
}
else
{
# we're adding the file
$FilesAdded += $fileName
}
}
"R " # Removed
{
if($FilesRenamed.ContainsKey($fileName))
{
continue
}
$FilesRemoved += $fileName
}
"C " # Same
{
continue
}
default
{
"Unknown HG status line: "+$AllChanges[$i]
return -1
}
}
}
# perform the TFS operations
"Renaming files in TFS..."
foreach($file in $FilesRenamed.Keys) {
tf checkout $file | out-null
tf rename $file $FilesRenamed[$file] | out-null
}
"Checking out for edit in TFS..."
foreach($file in $FilesModified) { tf checkout $file | out-null }
"Removing files from TFS..."
foreach($file in $FilesRemoved) { tf delete $file | out-null }
# perform the Mercural update
"Pulling changes out of HG...."
hg update --rev .:tip --clean
# perform any POST TFS operations
"Adding new files to TFS..."
foreach($file in $FilesAdded) { tf add $file }
"Cleaning up..."
tfpt uu /noget
tf checkin
}
if ($action -eq "Push") { Push }
elseif ($action -eq "pull") { pull }
else { "Unknown action ... please supply 'Push' or 'pull'" }
# return to our starting point
Set-Location $HGDirectory
Si vous souhaitez pouvoir travailler avec un DVCS et TFS, je pense que le meilleur moyen est d'installer le Svnbridge pour TFS et l'utilisation Bazar , qui est, Afaik Les seuls DVC qui s'intègrent facilement à SVN et que votre TFS ressemble maintenant à un SVN, vous obtenez par magie l'intégration bazar/tfs
J'ai eu un bon essai pour le faire fonctionner. Je pourrais obtenir Git et TFS jouer ensemble (- link ) via Svnbridge, mais je ne pouvais pas obtenir mercurial de travailler via Svnbridge qui m'a frustré sans fin. Si vous parvenez à le faire fonctionner, laissez-moi savoir, parce que je préfère personnellement mercurial sur git (bien que les deux soient super)