Je travaille depuis quelque temps sur un projet WPF. Mon client nous met à disposition un automate d’intégration continu sur lequel nous n’avons pas la main en terme de customisation.

Ce dernier permet d’effectuer des étapes importantes telle que l’exécution de tests unitaires, couverture de code, vérification de la qualité de code, … cependant certaines étapes à mon sens sont manquantes.

Dans cet article je vais vous présenter un exemple de processus automatisé que j’utilise en complément qui me permet de sécuriser la livraison de l’application en environnement de test.

Je pars du postulat que sur mon poste de développement, seulement le framework .net et Visual Studio 2010 sont installés.

L’idée est de créer ce script le plus vite possible avec les outils en ma possession

=>Je vais donc créer un script MSBuild

 

Définition des étapes de processus de livraison

 

image

 

Le script est structuré en sept étapes:

  1. GetLatestVersion;
  2. IncrementVersion;
  3. Clean;
  4. Compil;
  5. Deploy;
  6. Check;
  7. CheckinCode;

GetLatestVersion / CheckInCode

Ces targets permettent de réccupérer la dernière version du code et de faire un check-in du code modifié par ce processus. A ce niveau là tout dépend de votre gestionnaire de configuration.

Si vous utilisez Microsoft Team Foundation Server les Tasks sont disponibleq dans Microsoft.TeamFoundation.Build.targets (C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\TeamBuild pour une machine x64).

Sinon, pour les autres gestionnaires de configuration, il suffit d’obtenir des tasks tier:

 

IncrementVersion

Incrémente automatiquement le numéro de version des composants de la solution;

Soit une Custom Task peut être créée, soit les MSBuild Community Tasks offrent une tâche qui permet de modifier le fichier Assemblyinfo.

Clean

Nettoyage du bin des projets de la solutions.  Tous les répertoires bin/debug et bin/release sont nettoyés avec la task suivante:

Code Snippet
  1. <Target Name="Clean">
  2.   <MSBuild Projects="$(SolutionName)" Targets="Clean" />
  3. </Target>

 

Compil

Cette simple target compile la solution dans la configuration définie:

Code Snippet
  1. <Target Name="Compil">
  2.     <MSBuild Projects="$(SolutionName)" Targets="Rebuild" Properties="Configuration=$(Configuration)" />
  3.   </Target>

 

Deploy

La target Deploy copie les fichiers, présents dans le projet de démarrage de la solution, dans le répertoire de destination. Si le répertoire n’existe pas il est créé.

Code Snippet
  1.  
  2. <Target Name="Deploy">
  3.   <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(ExeFiles)" />
  4.   <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(DllFiles)" />
  5.   <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(PdbFiles)" />
  6.   <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(ConfigFiles)" />
  7.   <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(XmlFiles)" />
  8.   <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(IconesFiles)" />
  9. </Target>

 

 

 

 

 

Check

A ce niveau là, j’ai créé une custom task qui, à partir d’un fichier Xml, vérifie les fichiers déposés dans le répertoire de livraison.

Cette custom task vérifie:

  • le nombre de binaires présents;
  • la version de ces binaires;

Dans la partie suivante de ce post, je vais rentrer en détail sur la façon de faire une Custom Task MSBuild.

Voici les grandes lignes du script MSBuild =>MyBuild.proj

Code Snippet
  1. <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="START">
  2.  
  3.   <ItemGroup>
  4.     <SubSteps Include="GetLatestVersionCode" />
  5.     <SubSteps Include="IncrementVersion" />
  6.     <SubSteps Include="Clean" />
  7.     <SubSteps Include="Compil" />
  8.     <SubSteps Include="Deploy" />
  9.     <SubSteps Include="Check" />
  10.     <SubSteps Include="CheckInCode" />
  11.   </ItemGroup>
  12.  
  13.   <ItemGroup>
  14.     <SubCheckSteps Include="CheckDllVersion" />
  15.   </ItemGroup>
  16.   
  17.   <PropertyGroup>
  18.     <Version Condition="'$(Version)' == ''" >1.0.0.23</Version>
  19.     <SolutionName Condition="'$(SolutionName)' == ''" >WPFApplication.sln</SolutionName>
  20.     <Configuration Condition="'$(Configuration)' == ''" >Release</Configuration>
  21.     <OutputFolder Condition="'$(OutputFolder)' == ''" >$(MSBuildProjectDirectory)\WPFApplication\bin\$(Configuration)</OutputFolder>
  22.     <CurrentVersion Condition="'$(CurrentVersion)' == ''" >$(ApplicationPrefix)_V$(Version)_$([System.DateTime]::Now.ToString('yy-MM-dd'))</CurrentVersion>
  23.     <VersionFile Condition="'$(VersionFile)' == ''" >$(MSBuildProjectDirectory)\iCRM.Framework\Application\ProjectInfo.cs</VersionFile>
  24.     <DestinationRootFolder Condition="'$(DestinationRootFolder)' == ''" >c:\Livraison</DestinationRootFolder>
  25.     <DestinationFolder Condition="'$(DestinationFolder)' == ''" >$(DestinationRootFolder)\$(CurrentVersion)</DestinationFolder>
  26.     <TestFile Condition="'$(TestFile)' == ''">$(MSBuildProjectDirectory)\CheckVersion.xml</TestFile>
  27.   </PropertyGroup>
  28.  
  29.   <ItemGroup>
  30.     <ExeFiles Include="$(iCRMOutputFolder)\*.exe" />
  31.     <DllFiles Include="$(iCRMOutputFolder)\*.dll" />
  32.     <PdbFiles Include="$(iCRMOutputFolder)\*.pdb" />
  33.     <ConfigFiles Include="$(iCRMOutputFolder)\*.config" />
  34.     <XmlFiles Include="$(iCRMOutputFolder)\*.xml" />
  35.     <IconesFiles Include="$(iCRMOutputFolder)\*.ico" />
  36.   </ItemGroup>
  37.   
  38.   <Target Name="START" DependsOnTargets="@(SubSteps)">
  39.  
  40.   </Target>
  41.  
  42.   <Target Name="GetLatestVersionCode">
  43.       <!-- Task to get latestet version of code -->
  44.   </Target>
  45.  
  46.   <Target Name="IncrementVersion">
  47.     <!-- Incrementation of assembly version -->
  48.   </Target>
  49.  
  50.   <Target Name="Clean">
  51.     <MSBuild Projects="$(SolutionName)" Targets="Clean" />
  52.   </Target>
  53.  
  54.   <Target Name="Compil">
  55.     <MSBuild Projects="$(SolutionName)" Targets="Rebuild" Properties="Configuration=$(Configuration)" />
  56.   </Target>
  57.  
  58.   <Target Name="Deploy">
  59.     <Message Text="Config" />
  60.     <Message Text="$(OutputFolder)\*.exe" />
  61.     <Message Text="@(ExeFiles)" />
  62.     <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(ExeFiles)" />
  63.     <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(DllFiles)" />
  64.     <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(PdbFiles)" />
  65.     <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(ConfigFiles)" />
  66.     <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(XmlFiles)" />
  67.     <Copy DestinationFolder="$(DestinationFolder)" SourceFiles="@(IconesFiles)" />
  68.   </Target>
  69.  
  70.   <Target Name="Check">
  71.     <!-- Task to check deployment -->
  72.   </Target>
  73.  
  74.   <Target Name="CheckInCode">
  75.     <!-- Task to check-in code -->
  76.   </Target>
  77.  
  78.  
  79. </Project>

Dans ce script, deux patterns MSBuild sont vraiment intéressants:

  • l’utilisation de DependsOnTarget pour permettre une meilleure granularité de target. Comme pour du code .net, je met le minimum de logique dans une target => 1 target = 1 rôle;
  • la pré-initialisation des properties au début du script afin d’avoir lors de l’exécution du script MSBuild un minimum de paramettres à saisir.

 

Exécution du script

Pour démarrer ce script, ouvrez le Visual Studio Command Prompt (2010) pour avoir MSBuild dans le path.

Naviguez jusqu’à votre fichier proj MyBuild.proj, lancez la ligne de commande suivante:

msbuild MyBuild.proj /p:Version=1.0.0.24

Cette ligne de commande lance le processus pour la version 1.0.0.24, la compilation est faite en release.

Exemple de Custom Task MSBuild

Créez un projet de classe de librairie nommé par exemple MyCustomTaskMSBuild.

Ajouter les références aux dlls Microsoft.Build.Framework.dll:

image

Renommez la classe Class1.cs en MyCustomTask.cs et faites la hériter de l’interface ITask.

Ensuite, à vous de jouer, après avoir surchargé les méthodes/propriétés de ITask, vous pouvez créer un code celui-ci:

Code Snippet
  1. using Microsoft.Build.Framework;
  2.  
  3. namespace MyCustomTaskMSBuild
  4. {
  5.     public class MyCustomTask : ITask
  6.     {
  7.  
  8.         public IBuildEngine BuildEngine
  9.         {
  10.             get; set;
  11.         }
  12.         public ITaskHost HostObject
  13.         {
  14.             get; set;
  15.         }
  16.  
  17.         [Required]
  18.         public string MyInputParam { get; set; }
  19.  
  20.         public bool Execute()
  21.         {
  22.             // Add task logic here
  23.             Trace(string.Format("My First Task - {0}",MyInputParam), MessageImportance.Normal);
  24.             return true;
  25.         }
  26.  
  27.         protected void Trace(string message, MessageImportance importance)
  28.         {
  29.             BuildMessageEventArgs args = new BuildMessageEventArgs(message, string.Empty, TaskName, importance);
  30.             this.BuildEngine.LogMessageEvent(args);
  31.         }
  32.  
  33.         public string TaskName { get { return "My Custom Task"; } }
  34.     }
  35. }

Pour tout ce qui est logging de messages, utilisez la méthode Trace.

J’ai rajouté un MyInputParam, avec l’attribut Required il devient obligatoire lors de l’exécution du script MSBuild.

Comment insérer cette nouvelle Task dans mon fichier proj

En entête du fichier proj, rajoutez la ligne suivante:

Code Snippet
  1. <UsingTask AssemblyFile="MyCustomTaskMSBuild.dll" TaskName="MyCustomTaskMSBuild.MyCustomTask" />

Cette ligne défini le lien avec la Custom Task, il suffit ensuite d’appeller cette Task dans une target comme suit:

Code Snippet
  1.  
  2. <Target Name="test">
  3.   <MyCustomTask MyInputParam="!!!" />
  4. </Target>

Et maintenant, testez:

image

Ensuite, en vie réelle, vérifiez que le ficher proj est dans le même répertoire que la dll de la Custom Task.

Comment debugger cette Custom Task

Pour debugger cetteTask, forcez le projet MyCustomTaskMSBuild à Startup Project.

Etre sûr que le fichier proj est bien dans le répertoire bin\debug du projet MyCustomTaskMSBuild.

Dans l’onglet Debug des propriétés de ce projet. Sélectionner Start exsternal program et pointez vers l’exécutable MSBuild, dans mon cas C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe

image

Dans les Command Line Arguments, il suffit de mettre le nom du fichier MSBuild avec les bons paramètres.

F5 et le debug peut commencer.

Quelques liens

Documentation MSBuild sur MSDN :

Blog de l’équipe MSBuild

- Benoît Sarie -