Cómo encadenar las construcciones TFS?

Question

Tengo un escenario en el que quiero llamar a una versión de TFS desde otra, la primera hace la compilación y la segunda realiza la creación. Esto me permitirá hacer varias etapas personalizadas para la misma solución.

Lo sé, puedo llevarlo a cabo con una tarea ejecutiva en la segunda compilación y llamar a tfsbuild.exe para poner en cola una compilación a partir de la primera definición de compilación. ¿Pero me preguntaba si alguien sabía de una mejor manera?

Answer 1

Aquí es cómo lo logré (http://sajojacob.com/2009/08/how-to-chain-tfs-builds/)

Cómo cadena TFS ¿Construye? Publicado el 5 de agosto de 2009 por Sajo - Sin comentarios ↓

Uno de mis colegas @gdurzi me hizo esta pregunta recientemente. Suena bastante sencillo para ser compatible con TFS ¿verdad? Demasiadas peculiaridades con esto. Y recomendé usar la siempre fiel tarea MSBuild para hacer una llamada a TFSBuild.exe para poner en cola una nueva compilación desde el primer TFSBuild.proj con algo como esto

TFSBuild.exe start/queue% TFSSVR%% TEAMPROJECT%% BUILDTYPE %

Un problema con el uso de TFSBuild.exe es que no puede pasar Agentes de compilación como un argumento de línea de comandos que fue un factor decisivo para nosotros.

Existen varios enfoques que puede seguir en función de su escenario particular, así que definamos el escenario aquí, tiene una definición de compilación de MainSuite TFS que construye su proyecto central y desea la posibilidad de tener varias compilaciones en etapas ejecutando el mismo Main_Build para la compilación/creación, pero se debe organizar de forma personalizada para la implementación en función de quién llame a Main_Build. Muy útil cuando tiene un producto que se lanza a múltiples clientes con la necesidad de acciones personalizadas de preconstrucción y postconstrucción por cliente. Así que aquí hay una forma de crear Build Chaining con TFS 2008.

Paso 1: Creemos una tarea personalizada de MSBuild utilizando el modelo de objetos de Team Foundation que pone en cola una compilación utilizando el agente de compilación predeterminado asociado con el archivo de definición Build.

Código de ejemplo para poner en cola: 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); 

Paso 2: Ahora copiar el QueueTFS.dll a una nueva carpeta en TFS en la que desea crear el archivo de definición de Build puesta en escena.

Ahora crearemos un archivo TFSBuild.proj mínimo que utiliza nuestra nueva tarea MSBuild y anula el objetivo EndToEndIteration. Esta será nuestra definición de compilación de etapas que activará la compilación Main_Build. Tenga en cuenta que deberá crear este TFSBuild.proj a mano y simplemente señalar la ubicación del archivo de proyecto desde la UI de definición de compilación a la nueva carpeta.

Código de ejemplo para un TFSBuild.proj mínima:

<?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> 

Paso 3: Editar el archivo de Main_Build TFSBuild.proj con la pre-construcción y las llamadas de destino posterior a la generación.

<Target Name=“BeforeCompile“> 

    <CallTarget Targets=“Custom_PreBuild“/>  

    </Target> 

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

    <CallTarget Targets=“Custom_PostBuild“/> 

    </Target> 

queríamos la capacidad de ejecutar Main_Build por sí mismo, así, para apoyar esto le sumamos las importaciones condicionales en nuestra Main_Build TFSBuild.proj para importar un archivo default objetivos con los objetivos y Custom_PreBuild Custom_PostBuild vacías. $ (CustomTarget) es lo que le pasa como argumento de línea de comandos en el paso 1 para request.CommandLineArguments

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

Paso 4: Ahora cree un archivo de sus objetivos y Custom.Target EmptyCustom.Target con objetivos Custom_PreBuild y Custom_PostBuild y se están hechos.

Agregué soporte para actualizar los pasos de compilación y algunas otras cosas menores que están fuera del alcance de esta entrada de blog, pero espero que esto comience.

Answer 2

Depende de lo que estés tratando de hacer.

1) ¿Desea que la construcción + puesta en escena se ejecute como una sola operación? ¿Para que termine con un informe de compilación consolidado, un archivo de registro, un trabajo en la cola de compilación del servidor, cada paso ejecutado secuencialmente por el mismo agente de compilación que ejecutó el paso anterior?

Si es así, entonces está básicamente en el camino correcto. Sin embargo, no me gustaría <Exec> a tfsbuild.exe: la ejecución de una compilación nueva tiene muchos sobrecargas, y no estoy seguro de cuáles son los posibles efectos secundarios. En cambio, usaría la tarea <Call> para ejecutar las tareas de msbuild definidas en las secuencias de comandos de ensayo.

2) ¿Desea que la "compilación de compilación" coloque en cola una "compilación provisional" separada? ¿Informes separados, archivos de registro, & puntos en la cola? ¿Oportunidad de ser ejecutado en paralelo si tiene múltiples Agentes de compilación?

Si es así, entonces:

• crear una nueva definición (s) de construcción para la estadificación
• añadir algo de código a su definición construcción original que las colas [uno/varios] de las nuevas definiciones de compilación utilizando el Team Build API. Sample code.
• eliminar cualquier cosa no relacionada con el núcleo de la construcción de la definición original de la acumulación
• asegúrese de que las nuevas definiciones "puesta en escena" no tienen ningún activador automático (intervalos de tiempo, eventos de registro, etc)

Answer 3

Son ¿Estás intentando implementar tu solución en tu entorno de ensayo? Si es así un buen método es usar TFSDeployer desde CodePlex que ejecutar un script de PowerShell diferent basado en la calidad de construcción que seleccione ...

Answer 4

Aquí hay otros enlaces útiles. Puede ayudar a otros.

Crea otra definición de compilación y llama a otras definiciones de compilación para que se activen.

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/

argumentos para el traspaso al niño construye.

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

TFS Build Extensión a la cola otra definición de build

http://tfsbuildextensions.codeplex.com/