NAnt et double plate-forme de construction - la meilleure façon de construire sur Windows et Mono/Linux

Question

Je suis nouveau à NAnt, mais j'ai une certaine expérience avec Ant et CruiseControl. Ce que je veux faire, c'est que mon projet SVN inclue tous les outils nécessaires (comme NUnit et Mocks, etc.) pour que je puisse vérifier sur une nouvelle machine et construire. Jusqu'ici tout va bien si je veux seulement tourner sur Windows, mais je veux aussi pouvoir aller sur Linux et construire/tester/tourner aussi contre Mono. Je ne veux pas de dépendances externes au projet SVN. Cela ne me dérange pas d'avoir deux ensembles d'outils dans le projet, mais je veux seulement un fichier de construction NAnt

Cela doit être possible - mais comment? Quelles sont les astuces/'pièges pour les jeunes joueurs'

Answer 1

Cela ne devrait pas être un exercice particulièrement difficile. Nous faisons des choses assez similaires sur un de mes projets puisque la moitié de celui-ci fonctionne sur Java en utilisant Ant pour exécuter des cibles pertinentes, et l'autre moitié est .Net (C#) pour l'interface utilisateur. Les projets sont exécutés sur des machines Windows pour le développement, mais les serveurs (Java) exécutent Linux, mais dans l'environnement UAT (linux), nous devons exécuter les nunits (tests d'intégration). Le vrai truc (pas vraiment un truc difficile) derrière cela est d'avoir un fichier de construction NAnt qui peut fonctionner dans les deux environnements, ce qui semble être la même chose que vous essayez de faire ici.

Bien sûr, vous réalisez que vous devez installer sur NAnt Mono premier:

$ export MONO_NO_UNLOAD=1 
$ make clean 
$ make 
$ mono bin/NAnt.exe clean build 

Et puis votre fichier de construction doit être écrit de telle manière qu'il seperates préoccupations. Certaines parties du fichier de construction écrites pour Windows ne fonctionneront pas dans Linux par exemple. Donc, vous avez juste besoin de le diviser en cibles spécifiques dans le fichier de construction. Après cela, il existe plusieurs façons d'exécuter des cibles spécifiques à partir de la ligne de commande. Un exemple pourrait ressembler à ceci:

<project name="DualBuild"> 
    <property name="windowsDotNetPath" value="C:\WINDOWS\Microsoft.NET\Framework\v3.5" /> 
    <property name="windowsSolutionPath" value="D:\WorkingDirectory\branches\1234\source" /> 
    <property name="windowsNUnitPath" value="C:\Program Files\NUnit-Net-2.0 2.2.8\bin" /> 
    <property name="monoPath" value="You get the idea..." /> 

    <target name="BuildAndTestOnWindows" depends="WinUpdateRevision, WinBuild, WinTest" /> 
    <target name="BuildAndTestOnLinux" depends="MonoUpdateRevision, MonoBuild, MonoTest" /> 

    <target name="WinUpdateRevision"> 
    <delete file="${windowsSolutionPath}\Properties\AssemblyInfo.cs" /> 
    <exec program="subwcrev.exe" basedir="C:\Program Files\TortoiseSVN\bin\" 
      workingdir="${windowsSolutionPath}\Properties" 
      commandline="${windowsSolutionPath} .\AssemblyInfoTemplate.cs 
         .\AssemblyInfo.cs" /> 
    <delete file="${windowsSolutionPath}\Properties\AssemblyInfo.cs" /> 
    <exec program="subwcrev.exe" basedir="C:\Program Files\TortoiseSVN\bin\" 
      workingdir="${windowsSolutionPath}\Properties" 
      commandline="${windowsSolutionPath} .\AssemblyInfoTemplate.cs 
         .\AssemblyInfo.cs" /> 
    </target> 

    <target name="WinBuild"> 
    <exec program="msbuild.exe" 
      basedir="${windowsDotNetPath}" 
      workingdir="${windowsSolutionPath}" 
      commandline="MySolution.sln /logger:ThoughtWorks.CruiseControl.MsBuild.XmlLogger, 
         ThoughtWorks.CruiseControl.MsBuild.dll;msbuild-output.xml 
         /nologo /verbosity:normal /noconsolelogger 
         /p:Configuration=Debug /target:Rebuild" /> 
    </target> 

    <target name="WinTest"> 
    <exec program="NCover.Console.exe" 
      basedir="C:\Program Files\NCover" 
      workingdir="${windowsSolutionPath}"> 
     <arg value="//x &quot;ClientCoverage.xml&quot;" /> 
     <arg value="&quot;C:\Program Files\NUnit-Net-2.0 2.2.8\bin 
         \nunit-console.exe&quot; 
         MySolution.nunit /xml=nunit-output.xml /nologo" /> 
    </exec> 
    </target> 

    <target name="MonoUpdateRevision"> 
    You get the idea... 
    </target> 


    <target name="MonoBuild"> 
    You get the idea... 
    </target> 

    <target name="MonoTest"> 
    You get the idea... 
    </target> 

</project> 

Par souci de brièveté, j'ai laissé les deux côtés. La chose intéressante est que vous pouvez utiliser NUnit ainsi que NAnt sur les deux environnements et cela rend les choses vraiment faciles du point de vue de la dépendance. Et pour chaque exécutable, vous pouvez échanger pour d'autres qui fonctionnent dans cet environnement, par exemple (xBuild pour MSBuild, et svn pour tortue etc.)

Pour plus d'aide sur Nunit etc sur Mono, consultez this fantastic post.

Espoir qui aide,

Cheers,

Rob G

Answer 2

Il est intéressant de noter que beaucoup d'outils comme course Nant sur mono 'de la boîte', à savoir

mono nant.exe 

fonctionne

Answer 3

@Rob G - Hey! C'est mon message! ;)

Pour d'autres bons exemples, veillez à parcourir le code source NUnit. Je travaille en étroite collaboration avec Charlie chaque fois que je peux pour m'assurer qu'il est en train de construire et de tester sur Mono. Il essaie de courir quand il le peut aussi.

Answer 4

J'utilise le modèle suivant. Il permet la construction simple sur n'importe quelle plate-forme (build sur Win ou ./build.sh sur linux) et minimise la duplication dans les scripts de construction.

---

L'exécutable NAnt est stocké avec le projet en tools\nant.

Le fichier de configuration build détermine l'outil de construction à utiliser, MSBuild ou xbuild (dans ce cas, pour Windows, la version VS2015 MSBuild est requise, modifiez le chemin comme requis).

La cible de génération build-csproj peut être réutilisée lorsque vous avez plusieurs projets dans une solution. La cible test-project devra être développée pour vos besoins.

build.bat

@tools\nant\nant.exe %* 

build.sh

#!/bin/sh 

/usr/bin/cli tools/nant/NAnt.exe "$@" 

default.build

<?xml version="1.0"?> 
<project name="MyProject" default="all"> 

    <if test="${not property::exists('configuration')}"> 
    <property name="configuration" value="release" readonly="true" /> 
    </if> 

    <if test="${platform::is-windows()}"> 
    <property name="BuildTool" value="C:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exe" readonly="true"/> 
    </if> 
    <if test="${platform::is-unix()}"> 
    <property name="BuildTool" value="xbuild" readonly="true"/> 
    </if> 

    <property name="TestTool" value="tools/mytesttool.exe"/> 

    <target name="all" depends="myproject myprojectlib" /> 

    <target name="build-csproj" description="Build a given csproj"> 
    <!-- Must not be called standalone as it requires some properties set. --> 
    <exec program="${BuildTool}"> 
     <arg path="src/${ProjectName}/${ProjectName}.csproj" /> 
     <arg line="/property:Configuration=${configuration}" /> 
     <arg value="/target:Rebuild" /> 
     <arg value="/verbosity:normal" /> 
     <arg value="/nologo" /> 
    </exec> 
    </target> 

    <target name="test-project"> 
    <!-- Must not be called standalone as it requires some properties set. --> 
    <exec program="${TestTool}"> 
     <arg path="my/${ProjectName}/tests/path/for/tool" /> 
     <arg value="/aproperty=value" /> 
    </exec> 
    </target> 

    <target name="myproject" description="Build the project"> 
    <property name="ProjectName" value="MyProject"/> 
    <call target="build-csproj" /> 
    <call target="test-project" /> 
    </target> 

    <target name="myprojectlib" description="Build the project's library dll"> 
    <property name="ProjectName" value="MyProjectLib"/> 
    <call target="build-csproj" /> 
    <call target="test-project" /> 
    </target> 

</project>