2009-07-24 31 views
14

Ho uno scenario in cui voglio chiamare una build TFS da un'altra, la prima esegue la build e la seconda esegue la staging. Questo mi consentirà di eseguire più staging personalizzati per la stessa soluzione.Come concatenare le build TFS?

Lo so, posso estrarlo con un'attività exec nella seconda build e chiamare tfsbuild.exe per accodare una build dalla prima definizione di build. Ma si stava chiedendo se qualcuno sapeva di un modo migliore?

+1

Siamo passati a CC.NET - che supporta facilmente questo tipo di scenario. – Sneal

+0

L'ho fatto anche molte volte con CC.NET, deve esserci un modo pulito di fare lo stesso con TFS, presumo! – user22242

risposta

5

Ecco come ho realizzato questa (http://sajojacob.com/2009/08/how-to-chain-tfs-builds/)

Come catena TFS costruisce? Pubblicato il 5 agosto 2009 da Sajo - Nessun commento ↓

Uno dei miei colleghi @ gdurzi mi ha recentemente posto questa domanda. Sembra abbastanza semplice da essere supportato immediatamente con TFS? Troppe stranezze con questo. E ho consigliato di utilizzare l'attività MSBuild sempre fedele per effettuare una chiamata a TFSBuild.exe per accodare una nuova build dal primo TFSBuild.proj con qualcosa di simile a

TFSBuild.exe avvio/coda% TFSSVR%% TEAMPROJECT%% BUILDTYPE %

Un problema con l'utilizzo di TFSBuild.exe è che non è possibile passare agli agenti di compilazione come un argomento della riga di comando che è stato un compromesso per noi.

Esistono diversi approcci che è possibile effettuare in base al proprio scenario particolare, quindi definiamo lo scenario qui, si dispone di una definizione di build TFS Main_Build che crea il progetto principale e si desidera la possibilità di avere più build di gestione temporanea che eseguono lo stesso Main_Build per la compilazione/creazione, ma essere personalizzato per l'implementazione basata su chi chiama Main_Build. Molto utile quando si dispone di un prodotto che viene distribuito a più client con la necessità di azioni personalizzate pre-build e post-build per client. Ecco un modo per creare Chaining con TFS 2008.

Passaggio 1: Creiamo un'attività MSBuild personalizzata utilizzando il modello a oggetti Team Foundation che accoda una build utilizzando l'agente di creazione predefinito associato al file di definizione Build.

Codice di esempio per la fila: QueueTFS.cs

using Microsoft.TeamFoundation.Client; 
using Microsoft.TeamFoundation.Build.Client; 

// Get the team foundation server. 
TeamFoundationServer _tfsServer = TeamFoundationServerFactory.GetServer(_tfs); 

// Get the IBuildServer 
IBuildServer buildServer = (IBuildServer)_tfsServer.GetService(typeof(IBuildServer)); 

// Get the build definition for which a build is to be queued. 
IBuildDefinition definition = buildServer.GetBuildDefinition(teamProject, buildDefinition); 

// Create a build request for the build definition. 
IBuildRequest request = definition.CreateBuildRequest(); 
request.CommandLineArguments = "Pass any custom command line args here"; // Ex: Custom Targets file 

// Queue the build. 
buildServer.QueueBuild(request, QueueOptions.None); 

Fase 2: Ora copiare il QueueTFS.dll in una nuova cartella in TFS in cui si desidera creare il file di definizione build messa in scena.

Ora creiamo un file TFSBuild.proj minimale che utilizza la nostra nuova attività MSBuild e sovrascrive la destinazione EndToEndIteration. Questa sarà la nostra build build di Staging che attiverà la build di Main_Build. Nota che dovrai creare questo TFSBuild.proj a mano e semplicemente puntare il percorso del file di progetto dall'interfaccia utente di definizione Build alla nuova cartella.

Codice di esempio per un TFSBuild.proj minima:

<?xml version="1.0" encoding="utf-8"?> 
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> 
<Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\TeamBuild\Microsoft.TeamFoundation.Build.targets" /> 
    <UsingTask TaskName="MyNewCustomTFSTask" AssemblyFile="QueueTFS.dll"/> 
    <Target Name="EndToEndIteration"> 
    <Message Text="About to trigger main build" Importance="high"/> 
    < MyNewCustomTFSTask TFS="http://TFSServer.com:8080/" TeamProject="TeamProject" BuildDefinition="Main_Build" TargetsFile="Custom.Target" XYZ="XYZ" /> 
    <!-- When everything is done, change the status of the task to "Succeeded" --> 
    <SetBuildProperties TeamFoundationServerUrl="$(TeamFoundationServerUrl)" BuildUri="$(BuildUri)" TestStatus="Succeeded" CompilationStatus="Succeeded"/> 
    </Target> 
</Project> 

Fase 3: Modificare il file Main_Build TFSBuild.proj con la pre-compilazione e chiamate di destinazione post-generazione.

<Target Name=“BeforeCompile“> 

    <CallTarget Targets=“Custom_PreBuild“/>  

    </Target> 

    <Target Name=“AfterDropBuild“ Condition=“‘$(BuildBreak)’!=’true’“>  

    <CallTarget Targets=“Custom_PostBuild“/> 

    </Target> 

Abbiamo voluto la possibilità di eseguire Main_Build da solo così, per sostenere questo aggiungiamo le importazioni condizionali nel nostro Main_Build TFSBuild.proj per importare un file default bersagli con Custom_PreBuild e Custom_PostBuild obiettivi vuoti. $ (CustomTarget) è quello che si potrebbe passare come argomento della riga di comando nel passaggio 1 per request.CommandLineArguments

<Import Project="$(CustomTarget)" Condition="'$(CustomTarget)'!=''"/> 
<!--Import CustomContoso.Target if no partner is passed in—> 
<Import Project="EmptyCustom.Target" Condition="'$(CustomTarget)'==''"/> 

Fase 4: Ora creare il file i vostri obiettivi e Custom.Target EmptyCustom.Target con Custom_PreBuild e Custom_PostBuild obiettivi e si sono fatti.

Ho aggiunto il supporto per l'aggiornamento dei passaggi di costruzione e alcune altre cose minori che non rientrano nell'ambito di questo post del blog, ma si spera che questo possa iniziare.

7

Dipende da ciò che si sta tentando di fare.

1) Si desidera eseguire la fase di compilazione + come un'unica operazione? In questo modo si finisce con un report di build consolidato, un file di log, un lavoro nella coda di build del server, ogni fase eseguita in sequenza dallo stesso Build Agent che ha eseguito il passaggio precedente?

Se è così, allora sei praticamente sulla strada giusta. Non lo farei con lo strumento tfsbuild.exe, tuttavia - l'esecuzione di un'intera nuova build ha un sacco di spese generali, e non sono sicuro di quali siano i potenziali effetti collaterali. Invece, vorrei usare l'attività <Call> per eseguire le attività di msbuild definite negli script di staging.

2) Vuoi che la "build build" faccia effettivamente la coda a una "build di staging" separata? Report separati, file di registro, punti & nella coda? Opportunità da eseguire in parallelo se si dispone di più agenti di compilazione?

Se è così, allora:

  • creare una nuova definizione di compilazione (s) per la stadiazione
  • aggiungere del codice alla tua definizione di compilazione originale che le code [uno/più] delle nuove definizioni di compilazione utilizzando il API Team Build. Sample code.
  • rimuovere tutto quanto non legate al core costruire dalla definizione di compilazione originale
  • assicurarsi che le nuove definizioni "messa in scena" non hanno alcun trigger automatici (intervalli di tempo, eventi checkin, ecc)
+0

Preferibilmente il passaggio 1, ma l'attività non può essere utilizzata come suggerito. In questo caso, la build di staging deve essere il driver della build. Chiama il core build e quindi esegue la staging personalizzata. Il problema con l'utilizzo di un file proj di TFSBuild è che il file di definizione TFSBuild creato tramite l'interfaccia utente imposta tutte le proprietà del percorso in base alla soluzione scelta. (Come concordato, la definizione di build di staging non dovrebbe ricostruire la soluzione) un dolore per ottenere i percorsi configurati per chiamare il giusto file TFSBuild.proj di base senza codificarli. – user22242

+0

Non capisco il problema. Perché non memorizzare gli script di staging nella stessa directory degli script di compilazione? In realtà, anche questo non è necessario, basta assicurarsi che i percorsi relativi rimangano gli stessi. ///// Se ciò non aiuta, si prega di fornire maggiori dettagli su ciò che si sta tentando di fare. Quali sono esattamente le cose che ti aspetti che accadano nella "prima build" e nella "seconda build?" Quali compiti hanno in comune e cosa deve essere personalizzato? –

+0

BTW, a seconda di cosa si sta tentando di fare, Team Build potrebbe non essere affatto l'approccio giusto. Ad esempio, i miei ambienti di test sono impostati su un modello "pull" anziché su "push". Ogni macchina si abbona al sistema di notifica TFS. Quando viene generato un evento BuildCompletion, un servizio sulla macchina verifica i vari criteri configurati per quella casella e redeploys un ambiente di test come appropriato. –

0

Are stai cercando di distribuire la tua soluzione al tuo ambiente di staging? Se è così un buon metodo è quello di utilizzare TFSDeployer da CodePlex che eseguire uno script PowerShell spettacolo diverso in base alla qualità di costruzione che si seleziona ...

+1

Posso piuttosto farlo in CC invece di gestire la curva di apprendimento per TFSDeployer per un compito piuttosto semplice come questo. Perché dovrebbe essere così difficile fare qualcosa di così semplice in TFS che è necessario fare affidamento su altri strumenti? Sono sorpreso che molte persone non parlino nemmeno di build TFS incatenate – user22242

+2

La generazione concatenata potrebbe battere la mia numerazione della versione. Io uso una singola build per creare tutti gli "Artefatti" e quindi ho bisogno di distribuirlo su DEV, quindi su Test di sistema, quindi su QA, Beta e infine su Live. Questo è fatto in modo che non ci sia assolutamente la possibilità di una build contaminata (check-in per sviluppatori). Se c'è un problema, torniamo su DEV. Questo viene fatto su ogni ramo di funzionalità fino a quando non viene passato QA/UAT prima di essere unito a main e Branched per una release. :) –

1

Ecco altri link utili. Potrebbe aiutare gli altri.

Creare un'altra definizione di build e richiamare altre definizioni di build da attivare.

http://blogs.objectsharp.com/post/2012/02/04/Create-a-Master-Build-that-calls-other-Builds.aspx

http://blog.stangroome.com/2011/09/06/queue-another-team-build-when-one-team-build-succeeds/

Passaggio di argomenti per bambino costruisce.

http://blog.stangroome.com/2014/02/19/queue-a-team-build-from-another-and-pass-parameters/

TFS Costruire estensione a coda un'altra Corporatura Definizione

http://tfsbuildextensions.codeplex.com/

Problemi correlati