Aquí podría ser tu PUBLICIDAD


Utilice SVN Revision para etiquetar compilación en CCNET

votos
39

Estoy usando CCNET en un proyecto de muestra con SVN como mi control fuente. CCNET está configurado para crear una compilación cada vez que ingresa. CCNET usa MSBuild para compilar el código fuente.

Me gustaría utilizar el último número de revisión para generar AssemblyInfo.csdurante la compilación. ¿Cómo puedo recuperar la última revisión de subversión y usar el valor en CCNET?

Editar: No estoy usando NAnt, solo MSBuild.

Publicado el 04/08/2008 a las 12:37
fuente por usuario hitec
En otros idiomas...        العربية       

12 respuestas

votos
44

CruiseControl.Net 1.4.4 ahora tiene una etiquetadora de versión de ensamblaje , que genera números de versión compatibles con las propiedades de ensamblado de .Net.

En mi proyecto lo tengo configurado como:

<labeller type="assemblyVersionLabeller" incrementOnFailure="true" major="1" minor="2"/>

(Advertencia: assemblyVersionLabellerno comenzará a generar etiquetas basadas en la revisión svn hasta que se produzca una compilación activada por compromiso).

y luego consumir esto de mis proyectos MSBuild con MSBuildCommunityTasks.AssemblyInfo :

<Import Project="$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets"/>
<Target Name="BeforeBuild">
  <AssemblyInfo Condition="'$(CCNetLabel)' != ''" CodeLanguage="CS" OutputFile="Properties\AssemblyInfo.cs" 
  AssemblyTitle="MyTitle" AssemblyCompany="MyCompany" AssemblyProduct="MyProduct"
  AssemblyCopyright="Copyright ©  2009" ComVisible="false" Guid="some-random-guid"
  AssemblyVersion="$(CCNetLabel)" AssemblyFileVersion="$(CCNetLabel)"/>
</Target>

En aras de la completitud, es igual de fácil para los proyectos que usan NAnt en lugar de MSBuild:

<target name="setversion" description="Sets the version number to CruiseControl.Net 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();
               string replacement = "[assembly: AssemblyVersion(\"" + Project.Properties["CCNetLabel"] + "\")]";
               string newText = Regex.Replace(contents, @"\[assembly: AssemblyVersion\("".*""\)\]", replacement);
               StreamWriter writer = new StreamWriter(Project.Properties["filename"], false);
               writer.Write(newText);
               writer.Close();
              }
             }
             ]]>
        </code>
    </script>
    <foreach item="File" property="filename">
        <in>
            <items basedir="..">
                <include name="**\AssemblyInfo.cs"></include>
            </items>
        </in>
        <do>
            <setversion-task />
        </do>
    </foreach>
</target>
Respondida el 10/06/2009 a las 01:37
fuente por usuario skolima


Aquí podría ser tu PUBLICIDAD


votos
14

Tienes básicamente dos opciones. O bien, escribe un script simple que comenzará y analizará el resultado de

Información de svn.exe --REVISION HEAD

obtener el número de revisión (luego generar AssemblyInfo.cs es bastante sencillo) o simplemente usar el complemento para CCNET. Aquí está:

SVN Revision Labeller es un complemento para CruiseControl.NET que le permite generar etiquetas CruiseControl para sus compilaciones, según el número de revisión de su copia de trabajo de Subversion. Esto 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 solo hay 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();
        }
    }
}
Respondida el 04/08/2008 a las 12:56
fuente por usuario lubos hasko

votos
4

He escrito un archivo de compilación NAnt que maneja el análisis de información SVN y la creación de propiedades. Luego uso 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 etiqueta 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>
Respondida el 04/08/2008 a las 02:43
fuente por usuario Justin Walgran

votos
4

Si prefiere hacerlo en el MSBuildlado de la CCNetconfiguración, parece que la tarea de MSBuildla extensión Tareas Comunitarias SvnVersionpuede ser la solución.

Respondida el 04/08/2008 a las 01:03
fuente por usuario Rytmis

votos
4

Encontré este proyecto en el código de google. Este es un CCNETcomplemento para generar la etiqueta en CCNET.

El DLLestá probado CCNET 1.3pero funciona CCNET 1.4para mí. Estoy usando con éxito este complemento para etiquetar mi compilación.

Ahora en pasarlo a MSBuild...

Respondida el 04/08/2008 a las 12:51
fuente por usuario hitec

votos
3

No estoy seguro de si este trabajo con CCNET o no, pero yo he creado una versión plug-in de SVN para la versión Incremento Construir proyecto en CodePlex. Esta herramienta es muy flexible y se puede configurar para crear automáticamente un número de versión para usted, utilizando la revisión SVN. No requiere escribir ningún código o de edición de XML, por lo yay!

Espero que esto sea de ayuda!

Respondida el 12/04/2010 a las 02:04
fuente por usuario grimus

votos
3

Personalizar archivos csproj para autogenerar 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 archivo AssemblyInfo.cs para nosotros. El archivo define los metadatos del conjunto como su versión, configuración o productor.

Encontré la técnica anterior para autoensamblar AssemblyInfo.cs usando MSBuild. Publicaremos la muestra en breve.

Respondida el 04/08/2008 a las 02:22
fuente por usuario hitec

votos
3

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

Respondida el 04/08/2008 a las 12:41
fuente por usuario Michael Stum

votos
2

Ni idea de donde me encontré con esto. Pero encontré esto en el Internet "en algún lugar".

Esto actualiza todos los archivos AssemblyInfo.cs antes de la construcción se lleva a cabo.

Funciona de maravilla. Todos los de mi y la demostración de DLL como 1.2.3.333 exe (Si "333" fueron la revisión de SVN en el momento.) (Y la versión original en el archivo AssemblyInfo.cs fue catalogado como "1.2.3.0")


$ (ProjectDir) (¿Dónde reside mi archivo .sln)

$ (SVNToolPath) (puntos 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 tareas del (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 empezar a fallar después de que su número de revisión SVN alcanza 65534 o superior.

Ver:

Desactivar la advertencia CS1607

Aquí está la solución.

<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 archivos de Windows / Explorador // / Propiedades .......

Versión Asamblea será 1.0.0.0.

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

Respondida el 18/09/2012 a las 06:18
fuente por usuario granadaCoder

votos
2

Basado en la solución skolimas, actualicé el script NAnt para actualizar también 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>
Respondida el 12/09/2009 a las 11:03
fuente por usuario galaktor

votos
2

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

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

Si hay una tarea similar de MSBuild, puede usar el mismo enfoque. Aquí está 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 script probablemente no funcione de inmediato y necesite correcciones ...

Respondida el 03/02/2009 a las 05:16
fuente por usuario R. Martinho Fernandes

votos
1

Ten cuidado. La estructura utilizada para los números de compilación es solo breve, por lo que tiene un techo sobre qué tan alta puede ser su revisión.

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

Si intentas ingresar el número de compilación 99.99.99.599999, la propiedad de la versión del archivo realmente aparecerá como 99.99.99.10175.

Respondida el 03/02/2009 a las 07:34
fuente por usuario Dan


Aquí podría ser tu PUBLICIDAD