[TFS2010] MOVIENDO/SINCRONIZANDO CONTENIDOS ENTRE DIFERENTES TEAM PROJECTS (II)

image47dd1de4

Buenas,

hace un par de días escribí un post donde comenté como se podía utilizar TFS Integration Platform para sincronizar/mover contenidos entre 2 Team Projects. El ejemplo era bastante simple:

Copiar contenidos desde Tailspin Toys hacia TPA

El resultado fué un éxito (cosa simple cuando hay pocos datos a mover), y el post de hoy aprovecha ese punto de partida para dar solución a otro escenario

¿Qué sucede si se han generado nuevos contenidos o se han modificado contenidos en Tailspin Toys?

Pues la solución es utilizar el mismo proyecto de integración que utilizamos en el post original. Por ejemplo, si analizamos los cambios en los WorkItems podremos ver que el WorkItem 24 ha sufrido algunos cambios en el Team Project de origen:

image

De la misma forma, el archivo de la solución [Tailspin Toys\Development\Iteration 2\TailspinToys.sln] ha sufrido algunas modificaciones en el Team Project de origen:

image

Ahora bien, si lanzamos nuevamente el proyecto de sincronización desde la herramienta de TFS Integration Platform, podremos ver que en el proceso de Discovery > Analysis > Migration, hay nuevos elementos que se migran desde el Team Project de origen al Team Project de destino. De 30/113 elementos iniciales, ahora estamos en 31/121.

image

Si vemos el resultado de la migración, que ahora es más bien sincronización entre Tailspin Toys y TPA, veremos que la solución incluye el último cambio efectuado en el Source Control:

image

y el WorkItem 99 relacionado con el WI 24, tambien ha incorporado los cambios en su histórico:

image

En el próximo post, como utilizar una agenda para tener este proceso “casi automático”.

 

 

Saludos @ Home

El Bruno

   

Advertisements

[VS2010] HowTo: Configurar WinMerge como herramienta por defecto para analizar diferencias y realizar merge entre archivos

image47dd1de4

Buenas,

hoy toca destapar un par de post de la lista de borradores, en este caso los pasos para utilizar WinMerge como la herramienta por defeto para analizar diferencias entre archivos en Visual Studio 2010.

Tutorial

1. Primero lo más obvio; descargar la última versión disponible desde http://winmerge.org/

2. Abrir Visual Studio 2010

3. Acceder al menu [Tools // Options]

image

4. Presionar el botón [Configure User Tools]

5. Seleccionamos la opción [Add]

6. Agregamos la opción de Comparar, pero en este caso utilizando WinMerge utilizando los siguientes valores:

  • Extension: .*
  • Operation: Compare
  • Command: C:\Program Files (x86)\WinMerge\WinMergeU.exe
  • Arguments: /e /x /s /wl /dl %6 /dr %7 %1 %2

image

7. Confirmamos la configuración con [OK]

8. Agregamos la opción de Merge, utilizando WinMerge utilizando los siguientes valores:

  • Extension: .*
  • Operation: Merge
  • Command: C:\Program Files (x86)\WinMerge\WinMergeU.exe
  • Arguments: /e /s /x /ub /dl %6 /dr %7 %1 %2 %4

image

9. Confirmamos la configuración con [OK]

10. Deberíamos ver la configuarción completa similar a la siguiente:

image

11. Done !!!

 

Saludos @ Home

El Bruno

   

[TEAMBUILD2010] HowTo: Crear una Custom Activity para Team Build 2010

image47dd1de4

Buenas,

el siguiente tutorial muestra como crear una actividad personalizada para Team Build para Team Foundation Server 2010. En este caso concreto una actividad para mostrar información en el log de la ejecución de una build.

Tutorial

1. Creamos un nuevo proyecto del tipo Class Library. En este caso lo llamo [ElBruno.TeamBuild]

2. Agregamos las siguientes referencias:

  • System.Activities
  • Microsoft.TeamFoundation.Build.Workflow.dll
  • C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0\Microsoft.TeamFoundation.Build.Client.dll
  • C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0\Microsoft.TeamFoundation.Client.dll
  • C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0\Microsoft.TeamFoundation.VersionControl.Client.dll

Aclaración: Si bien inicialmente no utilizaremos todas las referencias, dejo este post de ejemplo para futuras referencias.

3. A continuación vamos a agregar algo de código en el proyecto. Primero borramos la clase [Class1.cs], agregamos un directorio llamado [Activities] y agregamos un nuevo elemento del tipo [Code Activity] llamado [DisplayInformation]

image

 

4. En la clase definimos 2 parámetros para la actividad:

  • Message, el mensaje a mostrar en el Log.
  • MessageImportance, el nivel de importancia del mensaje.

En el override Execute() utilizamos la funcion TrackBuildMessage() para mostrar esta información:

   1: using System.Activities;

   2: using Microsoft.TeamFoundation.Build.Client;

   3: using Microsoft.TeamFoundation.Build.Workflow.Activities;

   4:  

   5: namespace ElBruno.TeamBuild.Activities

   6: {

   7:     [BuildActivity(HostEnvironmentOption.All)]

   8:     public sealed class DisplayInformation : CodeActivity

   9:     {

  10:         [RequiredArgument]

  11:         public InArgument<string> Message { get; set; }

  12:         [RequiredArgument]

  13:         public BuildMessageImportance MessageImportance { get; set; }

  14:  

  15:         protected override void Execute(CodeActivityContext context)

  16:         {

  17:             var textIn = context.GetValue(Message);

  18:             context.TrackBuildMessage(textIn, MessageImportance);

  19:         }

  20:     }

  21: }

5. Compilamos el proyecto y ya tenemos nuestra actividad para utilizar desde TFS2010.

6. Para tener acceso a esta actividad desde el editor de Visual Studio 2010, iremos por el camino fácil > copiaremos la dll compilada en el directorio de ensamblados de Visual Studio 2010:

[C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\]

Aclaración: Existe un método más elegante para probar esta actividad, eso lo explicaré en un futuro post.

7. Una vez copiado ya podemos utilizar esta actividad desde una definición de Build en Team Foundation Server 2010. Antes de modificar el template de ejecución de Builds, crearemos una copia del mismo y agregaremos el ensamblado a una ubicación específica del Source Control de TFS2010. En este caso en la ubicación

$//<TeamProjectName>/BuildDemo

8. Dentro de esta ubicación subimos los ensamblados compilados del proyecto

  • ElBruno.TeamBuild.dll
  • ElBruno.TeamBuild.pdb

9. Desde la ubicación de los templates de Team Foundation Server 2010, usualmente en [$/<TeamProjectName>/BuildProcessTemplates] copiamos el archivo [DefaultTemplate.xaml] al directorio [BuildDemo]. Una vez subidos todos los archivos, debería quedar similar a la siguiente imagen:

image

 

10. Creamos una definición de Build (que compile un proyecto cualquiera) y a continuación modificaremos la plantilla de build que utiliza esta definición. Para este ejemplo, he creado una build llamada [BlogCustomActivities].

image

 

11. En la sección [Process] editamos el Build Template con el que trabaja la build. Seleccionamos [New] y en el formulario de configuración seleccionamos el template que hemos copiado en el paso 7.

image

 

12. Lanzamos una build para ver que la misma funcione correctamente. No deberíamos tener ningún problema:

image

 

13. En este punto editaremos la plantilla de ejecución de la Build para utilizar la actividad que hemos creado en los primeros pasos. Editamos la plantilla que hemos copiado en el paso 7. Deberiamos ver el editor de WF como muestra la siguiente imagen:

image

 

14. Dentro de la Toolbox, agregamos una nueva sección llamada [Custom Build Activities] y agregamos nuestra actividad en la misma.

image

 

15. Agregamos una actividad de este tipo al inicio de la build, como tiene una propiedad pública requerida veremos que el editor marca un error de diseño:

image

 

16. Completamos la propiedad [Message], en este caso además cambio la importancia por el valor [High]

image

 

17. Protejemos la plantilla [DefaultTemplate.xaml]

18. A continuación debemos modificar el Build Controller que orquesta la ejecución de las builds. Para esto seleccionamos el nodo [Builds] desde el Team Explorer, desplegamos el menú contextual y seleccionamos la opción [Manage Build Controllers]

image

 

19. Desplegamos las propiedades del mismo, y configuramos la opción [Version control path to custom assemblies: ] indicando en el mismo el path donde hemos subido los ensamblados de la custom activity.

image

Aclaración: esta accíón reinicia el Build Controller, con lo que el mismo no estará disponible inmediatamente.

20. Lanzamos una nueva build de este tipo y ya podremos ver el mensaje personalizado en el log de ejecución de la misma.

image

 

Pues como introducción a actividades personalizadas, creo que me sirve. En próximos posts un par de escenarios más complejos Open-mouthed smile

 

Saludos @ Home

El Bruno

   

[VS2010] HowTo: Capturar la salida de la consola en una aplicacion WinForms

image47dd1de4

Buenas,

hoy toca el post tonto del día, pero cuando quiero acordarme cómo se hacía esto, pues tengo que abrir código viejuno para verlo. Así que aquí está es escenario:

Capturar la salida del buffer de la consola (por ejemplo: Console.Write() o similares) en una caja de texto en una aplicación Winforms.

Pues una vez que tienes un proyecto WinForm con un formulario, una caja de texto llamada txtConsole y un botón btnAddLine para agregar nuevas líneas, puedes resolver el escenario con el siguiente código, donde la línea importante es la línea 10.

   1: public partial class Form1 : Form

   2: {

   3:     private int i = 0;

   4:     public Form1()

   5:     {

   6:         InitializeComponent();

   7:     }

   8:     private void Form1_Load(object sender, EventArgs e)

   9:     {

  10:         Console.SetOut(new TextBoxWriter(txtConsole));

  11:     }

  12:     private void btnAddLine_Click(object sender, EventArgs e)

  13:     {

  14:         i++;

  15:         Console.WriteLine("new line: {0}", i);

  16:     }

  17: }

¿Simple no? Eso jugando un poco con Console y con Console.SetOut(), pues soluciona el problema.

image

Ahoar bien, si en este momento dejaste de leer el post, te vas a dar con la cabeza contra la pared, porque en realidad lo interesante está en la implementación que querramos hacer del TextWriter con el que trabajaremos en Out de la consola. En este caso la clase se llama TextBoxWriter y posee el siguiente código:

   1: public class TextBoxWriter : TextWriter

   2: {

   3:     private TextBox control;

   4:     private StringBuilder bufferStringBuilder;

   5:  

   6:     public TextBoxWriter(TextBox txtConsole)

   7:     {

   8:         control = txtConsole;

   9:         control.HandleCreated += ControlHandleCreated;

  10:     }

  11:  

  12:     public override void Write(string format)

  13:     {

  14:         if (control.IsHandleCreated)

  15:             AppendText(format);

  16:         else

  17:             BufferText(format);

  18:     }

  19:     public override void WriteLine(string format)

  20:     {

  21:         Write(format + "\r\n");

  22:     }

  23:  

  24:     private void BufferText(string format)

  25:     {

  26:         if (bufferStringBuilder == null)

  27:         {

  28:             bufferStringBuilder = new StringBuilder();

  29:         }

  30:         bufferStringBuilder.Append(format);

  31:     }

  32:  

  33:     private void AppendText(string format)

  34:     {

  35:         if (bufferStringBuilder != null)

  36:         {

  37:             control.AppendText(bufferStringBuilder.ToString());

  38:             bufferStringBuilder = null;

  39:         }

  40:         control.AppendText(format);

  41:     }

  42:  

  43:     void ControlHandleCreated(object sender, EventArgs e)

  44:     {

  45:         if (bufferStringBuilder != null)

  46:         {

  47:             control.AppendText(bufferStringBuilder.ToString());

  48:             bufferStringBuilder = null;

  49:         }

  50:     }

  51:  

  52:     public override Encoding Encoding

  53:     {

  54:         get { throw new NotImplementedException(); }

  55:     }

  56: }

Una vez más, este código es solo un ejemplo para el post, hace falta refactorizarlo, acomodarlo al escenario de utilización concreto, etc.; pero sirve para que hagan copy & paste y destruyan algún proyecto en producción.

Y claro, si quieres lo puedes portar a WPF, o lo que mejor te fit you Open-mouthed smile

El código del ejemplo lo puedes descargar desde aquí.

http://cid-bef06dffdb192125.office.live.com/embedicon.aspx/Code%20Samples/2011%2003%2013%20Capturar%20la%20salida%20de%20la%20consola.zip

Saludos @ Home

El Bruno

   

[TFS2010] HowTo: Sincronizar contenidos desde SubVersion hacia TFS2010 [I]

image47dd1de4

Buenas,

después de mi pequeño post de hace 2 días:

[TFS2010] HowTo: Exportar el contenido completo de un repositorio de SubVersion a otro repositorio de Subversion

hoy mostraré un pequeño tutorial para mostrar como importar al source control de Team Foundation 2010 el contenido de un repositorio de SubVersion. Para esto utilizaremos las herramientas de integratión de TFS Integration Platform.

Tutorial

1. En primer lugar, debemos instalar las herramientas de integración. Es importante seleccionar el adaptador de SubVersion (en estado Alpha), para que tengamos acceso al mismo al momento de realizar la migración.

image

Actualmente se pueden descargar desde http://tfsintegration.codeplex.com/releases/view/35476

2. El instalador requiere de una instancia de SQL Server para guardar las definiciones de integración y el progreso de los mismos. Si no tienes un SQL Server a mano, puedes instalar y utilizar la versión Express de SQL Server. http://www.microsoft.com/downloads/es-es/details.aspx?FamilyID=58CE885D-508B-45C8-9FD3-118EDD8E6FFF

3. La plataforma de integración cuenta con una herramienta que visualmente nos permite definir los procesos de migración o integración. Lanzamos la misma y creamos un nuevo proyecto desde el menú [Configuration // Create New].

4. La creación de un nuevo proyecto requiere una plantilla inicial, seleccionamos el archivo [C:\Program Files\Microsoft Team Foundation Server Integration Tools\Configurations\Subversion\Subversion_to_TFS.xml] para crear el nuevo proyecto. En este punto podremos ver el formulario de configuración del proceso de migración. Pera este ejemplo el nombre del proceso será [Subversion to TFS 2010 23]

image

 

5. Editamos la opción [Left Source] y en la misma configuramos los datos de acceso a nuestro repositorio de SubVersion. Para este ejemplo, utilizo el acceso por file system, pero puede realizarse por cualquiera de los protocolos que soporta SubVersion.

image

 

6. Configuramos el acceso al servidor Team Foundation Server 2010 en la sección [Right Source].

7. En este punto podemos acceder a paths específicos de ambos repositorios para identificar directorios a migrar.

image

 

7. Si bien la opción para la selección de subdirectorios funciona correctamente en el editor, me he encontrado problemas seleccionado subdirectorios en SubVersion al momento de migrarlos. Con la selección de carpetas de TFS 2010 no hay problema, funciona correctamente.

image

 

8. Guardamos la configuración [Save To Database]

9. Lanzamos el proceso de sincronización a través del menú [Current Migration // Start]. Dependiendo de la cantidad de elementos a migrar, este proceso puede tardar bastante (incluso días).

10. Una vez terminado podremos ver el proceso completo como muestra la siguiente imagen:

image

 

Cada una de las acciones realizadas se detalla en el gráfico historico que se muestra en la sección inferior. La siguiente imagen muestra el detalle de la 5ta revisión procesada, con la cantidad de archivos y comentario relacionados a la misma.

image

 

11. Si accedemos al histórico de algún elemento en el repositorio de subVersion podremos ver si histórico de la siguiente forma (gracias a TortoiseSvn)

image

 

Si analizamos la misma información en el histórico del Source Control de TFS2010, veremos que la información es la misma. Y a cada elemento del histórico se le ha agregado un sufijo especificando el origen desde un proceso de TFS Integration Platform.

image

En el próximo post, como actualizar los datos “en caliente” hacia Team Foundation Server 2010 cuando se ha seguido trabajando con SubVersion.

 

 

Saludos @ Home

El Bruno

   

[TFS2010] HowTo: Exportar el contenido completo de un repositorio de SubVersion a otro repositorio de Subversion

image47dd1de4

Buenas,

en este post no pienso hablar nada de Team Foundation Server 2010 o de Visual Studio 2010, pero me servirá como referencia para próximos posts sobre la utilización TFS Integration Platform. Asi que a lo que vamos …

El escenario que intento abarcar en este post se refiere a la necesidad de exportar el contenido completo de un repositorio de SubVersion a otro repositorio, incluyendo revisiones, histórico, etc. Para este ejemplo, trabajaré con uno de los clientes más populares de SubVersion: TortoiseSvn. Los siguientes pasos describen como realizar la exportación / sincronización.

Tutorial

1. Suponiendo que tenemos un repositorio de SubVersion creado en el directorio [C:\Demo\OldRepo], crearemos un nuevo repositorio en el directorio [C:\Demo\NewRepo]

2. Para esto, en Windows Explorer seleccionamos el directorio, desplegamos el menú contextual y seleccionamos la opción [TortoiseSVN // Create repository here]

image

Una vez creado podremos ver que dentro del mismo, se crea una estructura de carpetas propia de un repositorio de SubVersion.

 

3. Si queremos validar el contenido vación del repositorio, desplegamos nuevamente el menú contextual desde Windows Explorer y seleccionamos la opción [TortoiseSVN // Repo-browser]. En la url ponemos el acceso al repositorio recién creado, y veremos como el mismo está vacío.

image

 

4. Ahora comenzamos la sincronización utilizando el comando svnsync. Para realizar una sincronización, necesitamos ejecutar 2 pasos con este comando:

   1: CD "C:\Program Files\Subversion\bin"

   2: svnsync initialize "file:///C:/Demo/NewRepo" "file:///C:/Demo/OldRepo" 

   3: svnsync sync file:///C:/Demo/NewRepo

Pero sin embargo cuando realizamos esta acción, nos encontramos con el siguiente mensaje de error:

   1: Microsoft Windows [Version 6.0.6002]

   2: Copyright (c) 2006 Microsoft Corporation.  All rights reserved.

   3:  

   4: C:\Users\Administrator>;CD "C:\Program Files\Subversion\bin"

   5:  

   6: C:\Program Files\Subversion\bin>;svnsync initialize "file:///C:/Demo/NewRepo" "fi

   7: le:///C:/Demo/OldRepo"

   8: svnsync: Repository has not been enabled to accept revision propchanges;

   9: ask the administrator to create a pre-revprop-change hook

  10:  

  11: C:\Program Files\Subversion\bin>

Esta información nos indica que debemos crear un hook para admitir los cambios en las revisiones en el repositorio.

 

5. Si vemos el contenido del directorio [C:\Demo\NewRepo\hooks] veremos que en el mismo existe el archivo pero con extension .tmpl. Esta extensión es un template que se utilza mayormente en UNIX. Para nuestro caso crearemos un nuevo archivo con el mismo nombre pero con extensión .bat y dentro delmismo agregaremos la siguiente línea:

   1: @exit 0

Por ejemplo:

image

 

6. Ahora si, ya podremos iniciar la sincronización. Cuando ejecutamos el primer comando veremos el siguiente mensaje:

   1: C:\Program Files\Subversion\bin>;svnsync initialize "file:///C:/Demo/NewRepo" "fi

   2: le:///C:/Demo/OldRepo"

   3: Copied properties for revision 0.

7. Cuando ejecutamos la sincronización, veremos como se mueven las revisiones al repositorio de destino:

   1: C:\Program Files\Subversion\bin>;svnsync sync "file:///C:/Demo/NewRepo"

   2: Transmitting file data ...........

   3: Committed revision 1.

   4: Copied properties for revision 1.

   5: Transmitting file data .

   6: Committed revision 2.

   7: Copied properties for revision 2.

   8: Transmitting file data .

   9: Committed revision 3.

  10: Copied properties for revision 3.

  11: Transmitting file data .

  12: Committed revision 4.

  13: Copied properties for revision 4.

  14: Transmitting file data ......

  15: Committed revision 5.

  16: Copied properties for revision 5.

  17: Transmitting file data ...

  18: Committed revision 6.

  19: Copied properties for revision 6.

  20: Transmitting file data ...

  21: Committed revision 7.

  22: Copied properties for revision 7.

  23: Transmitting file data ...

  24: Committed revision 8.

  25: Copied properties for revision 8.

  26:  

  27: C:\Program Files\Subversion\bin>

Este proceso puede tardar bastante de acuerdo a la cantidad de revisiones y tamaño de las mismas.

8. Una vez finalizado el proceso, si refrescamos el Repo-browser, podremos ver como se han sincronizado los contenidos al nuevo repositorio

image

 

Pues por ahora esto es todo. En próximos posts … porque esto es importante para TFS Integration Platform.

 

 

Saludos @ Home

El Bruno

   

[TFS2010] HowTo: Incluir scripts de MSBuild en una definición de Build de TFS2010

image47dd1de4

Buenas,

después de mi visita por Barcelona la semana pasada al equipo del AlegreBandolero, Marc Rubiño y su gente, pues uno de los temas que quedó pendiente era evaluar la capacidad de lanzar scripts de MSBuild desde una definición de build de Team Foundation Server 2010. Ahora bien, esto que no es para nada complicado tiene un par de puntos a tener en cuenta relativos a la configuración de la build en Team Foundation Server 2010 y del script de MSBuild. Los siguientes pasos demuestran como incluir un script de MSBuild que muestra unmensaje en la consola de progreso de Builds de Team Foundation Server 2010.

Tutorial

1. Para este caso en particular, utilizaré una definición ya creada de una build que se encarga de compilar y lanzar un par de tests sobre código almacenado en TFS. Como se puede ver en la siguiente imagen, la build hasta el momento funciona correctamente

image

2. Para probar este escenario, he creado el siguiente proyecto que muestra un mensaje utilizando una tarea del tipo BuildStep (de lo que hable hace bastante tiempo por aquí). Este es el código de ejemplo de la tarea, que como pueden ver, simplemente muestra un mensaje en el Log del Build.

   1: <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"

   2:          ToolsVersion="4.0" InitialTargets="Target1">

   3:   <Target Name="Target1">

   4:     <DisplayTinos />

   5:   </Target>

   6:   <UsingTask TaskName="DisplayTinos" TaskFactory="CodeTaskFactory"

   7:         AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll" >

   8:     <ParameterGroup />

   9:     <Task>

  10:       <Using Namespace="System"/>

  11:       <Using Namespace="System.IO"/>

  12:       <Code Type="Fragment" Language="cs">

  13:         <![CDATA[

  14: Log.LogMessage("Hola Valentino!");

  15: //Log.LogError("Hola Martina!");

  16: ]]>

  17:       </Code>

  18:     </Task>

  19:   </UsingTask>

  20: </Project>

3. Ahora bien, para poder incluir este archivo dentro del proceso de ejecución de un build en TFS2010, es necesario que el mismo esté protegido dentro del repositorio de código fuente. Para esta demo, he seguido un criterio bastante simple y he reutilizado alguno de mis posts sobre MSBuild en una carpeta llamada [MSBuild]. Esta carpeta se baja como parte del Workspace que tiene asociado la definición del Build con lo que ya tenemos acceso a los proyectos de MSBuild.

image

4. En este paso modificaremos el archivo xaml que representa el proceso de ejecucion de TFS Build 2010. Para esto copiaremos el archivo [DefaultTemplate.xaml] a una carperta del Source Control que nos permitirá aplicar los cambios correspondientes en nuestro proceso de Build. Por defecto, los archivos de WF para las builds se encuentran en [$\BuildProcessTemplates]

image

Para este ejemplo lo copiaremos y renombraremos en otro directorio [$/LabsAgile/Build/Dev/src/BuildProcessTemplate], por ejemplo

image

 

5. En este paso, modificaremos la definición del workflow para que lance un proyecto de MSBuild. Para esto editaremos el mismo y accederemos a la siguiente sección:

  • Process
    • Run on Agent
      • Try, Compile, Test …
        • Compile Test and Associate Change Sets
          • Try Compile and Test
            • Compile and Test
              • ForEach Configuration in BuildSettings.PlatformConfiguration
                • ForEach Project in BuildSettings.ProjectsToBuild
                  • CompileTheProject

Una vez dentro, agregaremos una actividad del tipo [MSBuild] al final de la acción de compilar el proyecto. Esta actividad nos permite invocar a un proyecto de MSBuild.

image

 

6. Para que la actividad se pueda lanzar correctamente, debemos configurar las siguientes propiedades de la misma:

  • LogFile: el nombre del archivo de log sobre el que se generará la información.
    • Value: “DemoMSbuild.log”
  • LogFileDropLocation: la ubicación del archivo de log
    • Value: BuildDetail.DropLocation + “\logs”
  • Project: define el proyecto de MSBuild que se lanzará como parte del proceso de build
    • Value: SourcesDirectory + “\Build\Dev\src\MsBuild\DemoTasks.proj”
  • Targets: define las targets que se invocarán
    • Value: New String() { “Target1”}

 

image

También podemos agregar argumentos a la línea de comandos, definir el nivel de trazas, la versión de MSBuild, etc.

7. Una vez que hemos terminado de modificar el xaml, lo guardamos y lo protegemos en el Source Control.

8. A continuación ya podemos asignar este WF a nuestra definición de build de TFS2010. En este paso, editamos la definición de la Build y en la sección [Process] seleccionamos desde el Source Control el archivo de WF que hemos modificado a nuestra build.

image

9. Si todas las configuraciones son correctas, cuando lanzamos una build, en el log de la misma, después de la compilación de cada solución, podremos ver una llamada a nuestro proyecto de MSBuild. El siguiente extracto del log, muestra estas llamadas:

   1: Run MSBuild for Project

   2: C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe /nologo /noconsolelogger 

   3: "C:\Builds\1\LabsAgile\Build MsBuild Integration\Sources\Build\Dev\src\BuildDemo\BuildDemo.sln" 

   4: /m:1 /fl /flp:"logfile=C:\Builds\1\LabsAgile\Build 

   5:   MsBuild Integration\Sources\Build\Dev\src\BuildDemo\BuildDemo.log;encoding=Unicode;verbosity=normal" 

   6: /p:SkipInvalidConfigurations=true  

   7: /p:OutDir="C:\Builds\1\LabsAgile\Build MsBuild Integration\Binaries\\" 

   8: /p:Configuration="Debug" /p:Platform="Any CPU" 

   9: /p:VCBuildOverride="C:\Builds\1\LabsAgile\Build MsBuild 

  10:   Integration\Sources\Build\Dev\src\BuildDemo\BuildDemo.sln.Any CPU.Debug.vsprops"  

  11: /dl:WorkflowCentralLogger, "c:\Program Files\Microsoft Team Foundation Server 

  12:   2010\Tools\Microsoft.TeamFoundation.Build.Server.Logger.dll";

  13:   "Verbosity=Normal;BuildUri=vstfs:///Build/Build/35;InformationNodeId=2902;

  14:   TargetsNotLogged=GetNativeManifest,GetCopyToOutputDirectoryItems,

  15:   GetTargetPath;TFSUrl=http://win-gs9gmujits8:8080/tfs/DefaultCollection;

  16:   "*WorkflowForwardingLogger,"c:\Program Files\Microsoft Team Foundation Server 

  17:   2010\Tools\Microsoft.TeamFoundation.Build.Server.Logger.dll";"Verbosity=Normal;"

  18:  

  19: 00:00

  20: Built $/LabsAgile/Build/Dev/src/BuildDemo/BuildDemo.sln for default targets.

  21:  

  22: 00:00

  23: Built $/LabsAgile/Build/Dev/src/BuildDemo/BuildDemo/BuildDemo.csproj for default targets.

  24:  

  25: 00:00

  26: Built $/LabsAgile/Build/Dev/src/BuildDemo/BuildDemo.Tests/BuildDemo.Tests.csproj for default targets.

  27:  

  28: 00:00

  29: Built $/LabsAgile/Build/Dev/src/BuildDemo/BuildDemo/BuildDemo.csproj for default targets.

  30: MSBuild Log File

  31:  

  32: 00:04

  33: MSBuild

  34:  

  35: 00:00

  36: Built $/LabsAgile/Build/Dev/src/MsBuild/DemoTasks.proj for target(s) Target1.

  37: C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe /nologo /noconsolelogger 

  38: "C:\Builds\1\LabsAgile\Build MsBuild Integration\Sources\Build\Dev\src\MsBuild\DemoTasks.proj" 

  39: /m:1 /t:"Target1" /fl /flp:"logfile=DemoMSBuild.log;encoding=Unicode;verbosity=normal" 

  40: /p:RunCodeAnalysis="False"  /dl:WorkflowCentralLogger,"c:\Program Files\Microsoft Team Foundation 

  41:   Server 2010\Tools\Microsoft.TeamFoundation.Build.Server.Logger.dll";

  42:   "Verbosity=Normal;BuildUri=vstfs:///Build/Build/35;InformationNodeId=2910;

  43:   TFSUrl=http://win-gs9gmujits8:8080/tfs/DefaultCollection;"*WorkflowForwardingLogger,

  44:   "c:\Program Files\Microsoft Team Foundation Server 2010\Tools\Microsoft.TeamFoundation.Build.Server.Logger.dll";

  45:   "Verbosity=Normal;"

10. Finalmente si accedemos al directorio de [DROPS] de la build, en el directorio de logs, podremos ver el archivo creado con el output de la ejecución de nuestro proyecto de MSBuild.

 image

Pues bien, en los próximos días un poco de integración más complicada y algún que otro ejemplo interesante.

 

Saludos @ Home

El Bruno

   

[VS2010] Creando un entornode para probar TFS2010 + Ecplise en 10 minutos y totalmente gratis

image47dd1de4

Buenas,

si quieres probar un poco las opciones de integración que nos da el nuevo Microsoft Visual Studio Team Explorer Everywhere 2010 with SP1 y Eclipse, pues aqui pongo un paso a paso para crear este entorno de prueba en aproximadamente 10 minutos.

1. Descarga las máquinas virtuales para probar Visual Studio 2010 y Team Foundation Server 2010 desde aquí, luego lo único que necesitas es Virtual PC o Hyper-V para ejecutar las máquinas virtuales.

2. Descarga Eclipse desde aquí. Si no tienes instalada la máquina virtual de Java, instala la misma desde aquí.

3. Sigue los pasos de instalación de Team Explorer Everywhere que comento aquí. Aquí pueden ver una instalación con la versión que incluye el Service Pack 1

image

4. Conectar Eclipse con Team Foundation Server 2010.

5. Done !!! en 10 minutos ya podemos probar un entorno mixto de TFS + Java.

 

Saludos @ Home

El Bruno

   

Descargas