Usar la revisión SVN para etiquetar la compilación en CCNET

Básicamente tienes dos opciones. O bien escribe un script simple que iniciará y analizará la salida desde

Svn.exe info {cabeza de revisión

Para obtener el número de revisión (entonces generando AssemblyInfo.cs es bastante sencillo) o simplemente utilizar plugin para CCNET. Aquí está:

SVN Revision Labeller es un plugin para CruiseControl.NET que le permite generar etiquetas CruiseControl para su compilaciones, basadas en el número de revisión de su copia de trabajo de Subversion. Este se puede personalizar con un prefijo y / o números de versión mayor/menor.

Http://code.google.com/p/svnrevisionlabeller /

Prefiero la primera opción porque es solo aproximadamente 20 líneas de código:

using System;
using System.Diagnostics;

namespace SvnRevisionNumberParserSample
{
    class Program
    {
        static void Main()
        {
            Process p = Process.Start(new ProcessStartInfo()
                {
                    FileName = @"C:\Program Files\SlikSvn\bin\svn.exe", // path to your svn.exe
                    UseShellExecute = false,
                    RedirectStandardOutput = true,
                    Arguments = "info --revision HEAD",
                    WorkingDirectory = @"C:\MyProject" // path to your svn working copy
                });

            // command "svn.exe info --revision HEAD" will produce a few lines of output
            p.WaitForExit();

            // our line starts with "Revision: "
            while (!p.StandardOutput.EndOfStream)
            {
                string line = p.StandardOutput.ReadLine();
                if (line.StartsWith("Revision: "))
                {
                    string revision = line.Substring("Revision: ".Length);
                    Console.WriteLine(revision); // show revision number on screen                       
                    break;
                }
            }

            Console.Read();
        }
    }
}

He escrito un archivo de compilación NAnt que maneja el análisis de la información SVN y la creación de propiedades. Luego utilizo esos valores de propiedad para una variedad de tareas de compilación, incluida la configuración de la etiqueta en la compilación. Utilizo este objetivo combinado con la etiquetadora de revisión SVN mencionada por lubos hasko con excelentes resultados.

<target name="svninfo" description="get the svn checkout information">
    <property name="svn.infotempfile" value="${build.directory}\svninfo.txt" />
    <exec program="${svn.executable}" output="${svn.infotempfile}">
        <arg value="info" />
    </exec>
    <loadfile file="${svn.infotempfile}" property="svn.info" />
    <delete file="${svn.infotempfile}" />

    <property name="match" value="" />

    <regex pattern="URL: (?'match'.*)" input="${svn.info}" />
    <property name="svn.info.url" value="${match}"/>

    <regex pattern="Repository Root: (?'match'.*)" input="${svn.info}" />
    <property name="svn.info.repositoryroot" value="${match}"/>

    <regex pattern="Revision: (?'match'\d+)" input="${svn.info}" />
    <property name="svn.info.revision" value="${match}"/>

    <regex pattern="Last Changed Author: (?'match'\w+)" input="${svn.info}" />
    <property name="svn.info.lastchangedauthor" value="${match}"/>

    <echo message="URL: ${svn.info.url}" />
    <echo message="Repository Root: ${svn.info.repositoryroot}" />
    <echo message="Revision: ${svn.info.revision}" />
    <echo message="Last Changed Author: ${svn.info.lastchangedauthor}" />
</target>

Encontré este proyecto en Google code. Este es el complemento CCNET para generar la etiqueta en CCNET.

El DLL se prueba con CCNET 1.3 pero funciona con CCNET 1.4 para mí. Estoy usando con éxito este plugin para etiquetar mi compilación.

Ahora pasa a MSBuild...

Si prefiere hacerlo en el lado MSBuild sobre la configuración CCNet, se parece a la extensión de Tareas de la comunidad MSBuild SvnVersion la tarea podría hacer el truco.

Actualmente lo estoy haciendo "manualmente" a través de una tarea prebuild-exec, usando mi herramienta cmdnetsvnrev , pero si alguien conoce una mejor forma de hacerlo integrada en ccnet, me encantaría escuchar : -)

Personalización de archivos csproj para generar automáticamente AssemblyInfo.cs
http://www.codeproject.com/KB/dotnet/Customizing_csproj_files.aspx

Cada vez que creamos un nuevo proyecto C# , Visual Studio pone allí el AssemblyInfo.archivo CS para nosotros. Archivo define los metadatos del ensamblado como su versión, configuración, o productor.

Encontró la técnica anterior para auto-gen AssemblyInfo.cs usando MSBuild. Publicaremos la muestra en breve.

No estoy seguro de si esto funciona con CCNET o no, pero he creado un complemento SVN version para el proyecto Build Version Increment en CodePlex. Esta herramienta es bastante flexible y se puede configurar para crear automáticamente un número de versión para usted usando la revisión svn. No requiere escribir ningún código o editar xml, así que ¡yay!

Espero que esto ayude!

Mi enfoque es usar el complemento antes mencionado para ccnet y una tarea nant echo para generar un archivo VersionInfo.cs que contenga nada más que los atributos de la versión. Solo tengo que incluir el archivo VersionInfo.cs en la compilación

La tarea echo simplemente muestra la cadena que le doy a un archivo.

Si hay una tarea similar de MSBuild, puede usar el mismo enfoque. Esta es la pequeña tarea nant que uso:

<target name="version" description="outputs version number to VersionInfo.cs">
  <echo file="${projectdir}/Properties/VersionInfo.cs">
    [assembly: System.Reflection.AssemblyVersion("$(CCNetLabel)")]
    [assembly: System.Reflection.AssemblyFileVersion("$(CCNetLabel)")]
  </echo>
</target>

Prueba esto:

<ItemGroup>
    <VersionInfoFile Include="VersionInfo.cs"/>
    <VersionAttributes>
        [assembly: System.Reflection.AssemblyVersion("${CCNetLabel}")]
        [assembly: System.Reflection.AssemblyFileVersion("${CCNetLabel}")]
    </VersionAttributes>
</ItemGroup>
<Target Name="WriteToFile">
    <WriteLinesToFile
        File="@(VersionInfoFile)"
        Lines="@(VersionAttributes)"
        Overwrite="true"/>
</Target>

Tenga en cuenta que no soy muy íntimo con MSBuild, por lo que mi guión probablemente no funcionará fuera de la caja y necesita correcciones...

Basado en la solución skolimas actualizé el script NAnt para actualizar también el AssemblyFileVersion. Gracias a skolima por el código!

<target name="setversion" description="Sets the version number to current label.">
        <script language="C#">
            <references>
                    <include name="System.dll" />
            </references>
            <imports>
                    <import namespace="System.Text.RegularExpressions" />
            </imports>
            <code><![CDATA[
                     [TaskName("setversion-task")]
                     public class SetVersionTask : Task
                     {
                      protected override void ExecuteTask()
                      {
                       StreamReader reader = new StreamReader(Project.Properties["filename"]);
                       string contents = reader.ReadToEnd();
                       reader.Close();                     
                       // replace assembly version
                       string replacement = "[assembly: AssemblyVersion(\"" + Project.Properties["label"] + "\")]";
                       contents = Regex.Replace(contents, @"\[assembly: AssemblyVersion\("".*""\)\]", replacement);                                        
                       // replace assembly file version
                       replacement = "[assembly: AssemblyFileVersion(\"" + Project.Properties["label"] + "\")]";
                       contents = Regex.Replace(contents, @"\[assembly: AssemblyFileVersion\("".*""\)\]", replacement);                                        
                       StreamWriter writer = new StreamWriter(Project.Properties["filename"], false);
                       writer.Write(contents);
                       writer.Close();
                      }
                     }
                     ]]>
            </code>
        </script>
        <foreach item="File" property="filename">
            <in>
                    <items basedir="${srcDir}">
                            <include name="**\AssemblyInfo.cs"></include>
                    </items>
            </in>
            <do>
                    <setversion-task />
            </do>
        </foreach>
    </target>

No tengo idea de dónde encontré esto. Pero encontré esto en Internet "en algún lugar".

Esto actualiza todo el AssemblyInfo.archivos cs antes de la compilación.

Funciona como un encanto. Todos mis archivos exe y dll aparecen como 1.2.3.333 (Si "333" era la revisión SVN en ese momento.) (Y la versión original en el AssemblyInfo.el archivo cs aparece como "1.2.3.0")

Proj (ProjectDir) (Where my .el archivo sln reside)

$(SVNToolPath) (apunta a svn.exe)

Son mis variables personalizadas, sus declaraciones / definiciones no se definen a continuación.

Http://msbuildtasks.tigris.org / y/o https://github.com/loresoft/msbuildtasks tiene las tareas (FileUpdate y SvnVersion).

  <Target Name="SubVersionBeforeBuildVersionTagItUp">

    <ItemGroup>
      <AssemblyInfoFiles Include="$(ProjectDir)\**\*AssemblyInfo.cs" />
    </ItemGroup>

    <SvnVersion LocalPath="$(MSBuildProjectDirectory)" ToolPath="$(SVNToolPath)">
      <Output TaskParameter="Revision" PropertyName="MySubVersionRevision" />
    </SvnVersion>

    <FileUpdate Files="@(AssemblyInfoFiles)"
            Regex="(\d+)\.(\d+)\.(\d+)\.(\d+)"
            ReplacementText="$1.$2.$3.$(MySubVersionRevision)" />
  </Target>

EDITAR --------------------------------------------------

Lo anterior puede comenzar a fallar después de que su número de revisión SVN alcance 65534 o superior.

Véase:

Apague la advertencia CS1607

Aquí está el transitoria.

<FileUpdate Files="@(AssemblyInfoFiles)"
Regex="AssemblyFileVersion\(&quot;(\d+)\.(\d+)\.(\d+)\.(\d+)"
ReplacementText="AssemblyFileVersion(&quot;$1.$2.$3.$(SubVersionRevision)" />

El resultado de esto debería ser:

En Windows/Explorer/Archivo/Propiedades.......

La versión del ensamblado será 1.0.0.0.

La versión del archivo será 1.0.0.333 si 333 es la revisión SVN.

Ten cuidado. La estructura utilizada para los números de compilación es solo corta, por lo que tiene un techo sobre cuán alto puede llegar su revisión.

En nuestro caso, ya hemos excedido el límite.

Si intenta introducir el número de compilación 99.99.99.599999, la propiedad file version aparecerá como 99.99.99.10175.