TFS2010 Object Model – Gestione del versioning
Scritto da
Massimo Bonanni
il
mercoledì 16 marzo 2011
Linguaggio:
•
Framework:
•
Livello: 200
Download pdf
Dopo aver esaminato la gestione dell'item tracking nei
precedenti articoli, in questa puntata della seria vediamo come
interagire con i servizi di version control messi a disposizione
dall'infrastruttura di Team Foundation server.
La classe VersionControlServer
Il primo passo per poter utilizzare le funzionalità di vesrion
control messe a disposizione dall'object model di TFS è quello di
recuperare l'istanza della classe VersionControlServer a partire da
una team project collection.
Questa classe mette a disposizione alcuni metodi per l'accesso
al repository del controllo del codice sorgente.
Per recuperare l'istanza del repository possiamo utilizzare il
metodo GetService della classe TFSTeamProjectCollection:
Dim tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection("http://MioServer:8080/tfs/MiaCollezione")
Dim versionControlServer = CType(tpc.GetService(Of VersionControlServer)(), VersionControlServer)
La classe VersionControlServer mette a disposizione una serie di
funzionalità particolarmente interessanti tra le quali la gestione
delle labels, dei workspaces, delle branche e degli item presenti
nel controllo del codice sorgente.
In questo articolo analizzeremo alcune delle funzionalità più
interessanti rimandando, per le altre, alla documentazione fornita
da MSDN.
Il primo metodo che analizziamo è il GetItems (fornito in ben 13
overload) che ci permette di recuperare un'insieme di item dal
controllo del codice sorgente.
Il metodo permette di recuperare gli item in base al nome
(eventualmente anche composto da caratteri jolly), all'id, alla
versione, al tipo (file, folder, etc., etc.).
In particolare nell'esempio che segue andiamo a recuperare tutti
gli items di un progetto in una collection in base ad un
filtro:
Public Function GetVersionedItems(ByVal collectionUrl As String,
ByVal projectName As String,
ByVal filter As String) As IEnumerable(Of Item)
Dim retList As IEnumerable(Of Item) = Nothing
If Not String.IsNullOrWhiteSpace(collectionUrl) Then
Try
Dim tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(New Uri(collectionUrl),
New UICredentialsProvider())
Dim versionControlServer = CType(tpc.GetService(Of VersionControlServer)(), VersionControlServer)
Dim pathStr = String.Format("$/{0}/{1}", projectName, filter)
retList = versionControlServer.GetItems(pathStr, RecursionType.Full).Items
Catch ex As Exception
Throw
End Try
Else
Throw New ArgumentNullException("collectionUrl must be not null")
End If
Return retList
End Function
Osserviamo che, nel nostro caso, abbiamo utilizzato
RecursionType.Full che consente di iterare la ricerca alle
sottocartelle.
Altri valori di RecursionType sono None e OneLevel che permettono,
rispettivamente, di non attivare la ricorsività o limitare la
ricerca al solo primo livello di cartelle.
Un esempio di utilizzo della precedente funzione è il
seguente:
Dim items = GetVersionedItems("http://MyServer:8080/tfs/MyCollection", "MyProject", "*.vb")
In questo caso recuperiamo tutti gli items con estensione .vb
dal repository del codice sorgente del progetto MyProject della
collezione MyCollection presente nel server MyServer.
La classe Item contiene tutte le proprietà relative all'item
memorizzato nel server del controllo del codice sorgente:
Da notare il metodo DownloadFile che ci permette di salvare il
file all'interno del nostro disco:
Public Sub SaveAllFileItems(items As IEnumerable(Of Item),
destinationPath As String)
For Each Item In items
If Item.ItemType = ItemType.File Then
' recupero il nome del file completo del nome di progetto
'e delle cartelle in cui è contenuto
Dim origFileName = Item.ServerItem.Replace("$/", "")
origFileName = origFileName.Replace("/", "\")
' creo il nome del file con cui salvare l'item
Dim fileName = IO.Path.Combine(destinationPath, origFileName)
Try
Item.DownloadFile(fileName)
Catch ex As Exception
Throw
End Try
End If
Next
End Sub
Il metodo precedente consente di salvare gli item contenuti
nell'argomento items in una cartella su disco.
Ad esempio, per avere la copia dell'ultima versione dei file vb
contenuti nel progetto MyProject della collezione
MyCollection, potremo scrivere:
Dim items = GetVersionedItems("http://myserver:8080/tfs/myCollection", "MyProject", "*.vb")
SaveAllFileItems(items, "c:\appoggio")
Il metodo GetItems della classe VersionControlServer permette di
recuperare anche i file di una determinata versione dei nostri
checkin.
Alcune firme del metodo prevedono la possibilità di passare un
oggetto di tipo VersionSpec.
VersionSpec è una classe astratta che definisce un criterio di
versionamento. Il framework mette a disposizione alcune
implementazioni di VersionSpec:
Se volessimo recuperare i file di progetto ad una certa data (ad
esempio 31/12/2010) potremmo utilizzare un metodo del tipo:
Public Function GetVersionedItems(ByVal collectionUrl As String,
ByVal projectName As String,
ByVal filter As String,
ByVal versionDate As DateTime) As IEnumerable(Of Item)
Dim retList As IEnumerable(Of Item) = Nothing
If Not String.IsNullOrWhiteSpace(collectionUrl) Then
Try
Dim tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(New Uri(collectionUrl),
New UICredentialsProvider())
Dim versionControlServer = CType(tpc.GetService(Of VersionControlServer)(), VersionControlServer)
Dim pathStr = String.Format("$/{0}/{1}", projectName, filter)
Dim dateVerSpec = New DateVersionSpec(versionDate)
retList = versionControlServer.GetItems(pathStr, dateVerSpec, RecursionType.Full).Items
Catch ex As Exception
Throw
End Try
Else
Throw New ArgumentNullException("collectionUrl must be not null")
End If
Return retList
End Function
E scrivere:
Dim items = GetVersionedItems("http://myserver:8080/tfs/myCollection",
"MyProject",
"*.vb",
New DateTime(2010, 12, 31))
La classe VersionControlServer prevede la possibilità,
inoltre, di eseguire delle query per cercare, ad esempio, changset,
labels, workspaces, etc., etc.
Tutti i metodi che consentono di eseguire questo tipo di ricerca
hanno il nome che inizia per Query, così, ad esempio, il metodo
QueryHistory consente di eseguire la ricerca dei changeset
all'interno di TFS.
Il metodo prevede una serie di argomenti che ci consentono di
filtrare la ricerca:
Public Function QueryHistory ( _
path As String, _
version As VersionSpec, _
deletionId As Integer, _
recursion As RecursionType, _
user As String, _
versionFrom As VersionSpec, _
versionTo As VersionSpec, _
maxCount As Integer, _
includeChanges As Boolean, _
slotMode As Boolean _
) As IEnumerable
Gli argomenti hanno il seguente significato:
- path : contiene il percorso da cui recuperare
i changeset in maniera analoga al path utilizzato nel GetItems
visto in precedenza;
- version : oggetto di classe VersionSpec che
identifica la versione a cui far riferimento nella ricerca (deve
essere valorizzato);
- deletionId : eventuale id di cancellazione
dell'elemento. Può anche essere 0 se non utilizzato;
- recursion : tipologia di recursione da
utilizzare. Il valore è analogo a quello del metodo GetItems visto
in precedenza;
- user : username dell'utente autore dei
changesets. Se non interessa un utente specifico utilizzare
String.Empty. Attenzione a non utilizzare Nothing perchè non è
equivalente a String.Empty;
- versionFrom : Oggetto VersionSpec da cui
iniziare la ricerca. Se utilizzato Nothing, la ricerca avviene a
partire dal primo changeset;
- versionTo : Oggetto VersionSpec a cui
terminare la ricerca. Se utilizzato Nothing, la ricerca avviene
fino all'ultimo changeset;
maxCount : numero massimo di changeset restituiti. Se impostato
Int32.MaxValue vengono restituiti tutti i changsets;
- includeChanges : permette di decidere se
recuperare anche le informazioni sui cambiamenti avvenuti
(proprietà Changes) oppure no. Se impostato a True, viene
valorizzata la proprietà Changes con la collezione degli item
interessati al cambiamento. Se impostato a false, la proprietà
Changes dei risultati è nothing;
- slotMode: indentifica la modalità con cui gli
elementi della history vengono presentati.
Il metodo restituisce un oggetto IEnumerable che, di fatto è un
IEnumerable(of Changeset). La classe Changeset ha la seguente
struttura:
Ogni Changeset contiene:
- una collezione di Change, ognuna delle quali contiene un
ChangeType che indica la tipologia di change (Add, Edit, etc.,
etc.) e un Item (dello stesso tipo e significato di quelli visti
nel metodo GetItems);
- una collezione di WorkItems associati (dello stesso tipo di
quelli visti negli articoli dedicati all'Item Tracking).
Un esempio di funzione che può servire a recuperare l'intero
elenco di changeset di un progetto in una collection è il
seguente:
Public Function GetChangesets(ByVal collectionUrl As String,
ByVal projectName As String,
ByVal filter As String,
ByVal versionDate As DateTime) As IEnumerable(Of Changeset)
Dim retList As IEnumerable(Of Changeset) = Nothing
If Not String.IsNullOrWhiteSpace(collectionUrl) Then
Try
Dim tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(New Uri(collectionUrl),
New UICredentialsProvider())
Dim versionControlServer = CType(tpc.GetService(Of VersionControlServer)(), VersionControlServer)
Dim pathStr = String.Format("$/{0}/{1}", projectName, filter)
Dim dateVerSpec = New DateVersionSpec(versionDate)
retList = versionControlServer.QueryHistory(pathStr, dateVerSpec, 0, RecursionType.Full,
String.Empty, Nothing, Nothing, Int32.MaxValue,
True, True).OfType(Of Changeset)().ToList()
Catch ex As Exception
Throw
End Try
Else
Throw New ArgumentNullException("collectionUrl must be not null")
End If
Return retList
End Function
Se volessimo recuperare tutti i changeset del progetto MyProject
nella collection MyCollection di qualsiasi tipo di file e alla data
di oggi, potremmo scrivere:
Dim changesets = GetChangesets("http://MyServer:8080/tfs/MyCollection",
"MyProject",
"*.*",
DateTime.Now)
La classe VersionControlService fornisce altre funzionalità per
la gestione delle label (aggiunta e cancellazione), la gestione dei
workspace (che analizzeremo nel prossimo articolo), la gestione
delle branch e dei pending changes.
Tutte queste funzionalità hanno la peculiarità di poter essere
eseguite senza passare per il workspace (area di lavoro base per
tfs lato client). Nel prossimo articolo vedremo come sia possibile,
invece, recuperare un workspace di un utente e quali operazioni
abbiamo a disposizione utilizzando i servizi offerti da
quest'ultimo.
Riferimenti
[1] Team Foundation Server Architecture: http://msdn.microsoft.com/en-us/library/ms252473.aspx
[2] Extending Team Foundation: http://msdn.microsoft.com/en-us/library/bb130146.aspx
[3] Team Foundation Server 2010 SDK: http://code.msdn.microsoft.com/TfsSdk
[4] Team Foundation Server Team Blog: http://blogs.msdn.com/b/team_foundation/
Tags: TFS,Team Foundation,Team Foundation Server