.net - net - NAnt y construcción de doble plataforma: la mejor forma de construir en Windows Y Mono/Linux

mono.net download

Question

Soy nuevo en NAnt pero tengo algo de experiencia con Ant y CruiseControl.

Lo que quiero hacer es que mi proyecto SVN incluya todas las herramientas necesarias (como NUnit y Mocks, etc.) para que pueda verificar en una nueva máquina y construir. Esta estrategia es resumida por JP Boodhoo aquí.

Hasta ahora todo bien si solo quiero ejecutar en Windows, pero también quiero poder verificar en Linux y construir / probar / ejecutar contra Mono también. No quiero dependencias externas al proyecto SVN. No me importa tener dos juegos de herramientas en el proyecto, pero solo quiero un archivo de construcción NAnt

Esto debe ser posible, pero ¿cómo? ¿Cuáles son los trucos / ''trampas para jugadores jóvenes''

Answer 1

@Rob G - ¡Oye! Esa es mi publicación! ;)

Para algunos otros buenos ejemplos, asegúrese de navegar por el código fuente de NUnit. Trabajo estrechamente con Charlie siempre que puedo para asegurarme de que está construyendo y probando en Mono. Él intenta correr cada vez que puede también.

Answer 2

Vale la pena señalar que muchas herramientas como Nant se ejecutan en mono ''fuera de la caja'', es decir,

mono nant.exe

trabajos

Answer 3

Esto no debería ser un ejercicio particularmente difícil. Hacemos algunas cosas bastante similares en uno de mis proyectos, ya que la mitad se ejecuta en Java utilizando Ant para ejecutar objetivos relevantes, y la otra mitad es .Net (C #) para la interfaz de usuario. Los proyectos se ejecutan en máquinas Windows para desarrollo, pero los servidores (Java) ejecutan Linux, pero en el entorno UAT (Linux) necesitamos ejecutar los nunits (pruebas de integración). El verdadero truco (que en realidad no es un truco difícil) es tener un archivo de compilación NAnt que se pueda ejecutar en ambos entornos, lo que parece ser lo mismo que intenta hacer aquí.

Por supuesto, te das cuenta de que primero tendrás que instalar NAnt en Mono:

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

Y luego su archivo de compilación debe estar escrito de tal manera que separe las preocupaciones. Algunas partes del archivo de compilación escrito para Windows no funcionarán en Linux, por ejemplo. Entonces realmente solo necesitas dividirlo en objetivos específicos en el archivo de compilación. Después de eso, hay varias formas de ejecutar objetivos específicos desde la línea de comando. Un ejemplo podría verse así:

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

Para abreviar, he dejado ambos lados afuera. Lo bueno es que puedes usar NUnit y NAnt en ambos entornos, y eso hace las cosas realmente fáciles desde el punto de vista de la dependencia. Y para cada ejecutable puede intercambiar para otros que trabajan en ese entorno, por ejemplo (xBuild para MSBuild y svn para tortuga, etc.)

Para obtener más ayuda sobre Nunit, etc. en Mono, echa un vistazo a esta fantástica publicación .

Espero que ayude,

Aclamaciones,

Rob G

Answer 4

Yo uso la siguiente plantilla. Permite la creación simple en cualquier plataforma ( build en Win o ./build.sh en Linux) y minimiza la duplicación en los scripts de compilación.

El ejecutable NAnt se almacena con el proyecto en tools/nant .

El archivo de configuración de compilación determina qué herramienta de compilación usar, ya sea MSBuild o xbuild (en este caso, para Windows, requiero la versión MSBuild VS2015, cambie la ruta según sea necesario).

El objetivo de compilación build-csproj puede reutilizarse para cuando tenga varios proyectos dentro de una solución.

El objetivo del test-project debería ampliarse según sus necesidades.

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>