tag - svn merge branch to trunk
Utilice SVN Revision para etiquetar compilación en CCNET (12)
Personalizar archivos csproj para autogenerar AssemblyInfo.cs
http://www.codeproject.com/KB/dotnet/Customizing_csproj_files.aspxCada 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.
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.cs durante 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.
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 cmdnetsvnrev de hacerlo, me encantaría escuchar :-)
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>
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: assemblyVersionLabeller no comenzará a generar etiquetas basadas en la revisión svn hasta que se produzca una compilación activada por commit real).
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>
Encontré this proyecto en el código de google. Este es el complemento CCNET para generar la etiqueta en CCNET .
La DLL se prueba con CCNET 1.3 pero funciona con CCNET 1.4 para mí. Estoy usando con éxito este complemento para etiquetar mi compilación.
Ahora en pasarlo a MSBuild ...
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>
Mi enfoque es usar el complemento antes mencionado para ccnet y una tarea VersionInfo.cs echo para generar un archivo VersionInfo.cs que no 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 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 ...
No estoy seguro de si esto funciona con CCNET o no, pero he creado un complemento de versión SVN para el proyecto Build Version Increment en CodePlex. Esta herramienta es bastante flexible y se puede configurar para que cree automáticamente un número de versión para usted usando la revisión svn. No requiere escribir ningún código ni editar xml, ¡así que sí!
¡Espero que esto ayude!
No tengo idea de dónde encontré esto. Pero encontré esto en internet "en algún lugar".
Esto actualiza todos los archivos AssemblyInfo.cs antes de que se lleve a cabo la compilación.
Funciona de maravilla. Todos mis exe y dll aparecen como 1.2.3.333 (Si "333" fue la revisión de SVN en ese momento). (Y la versión original en el archivo AssemblyInfo.cs estaba en la lista como "1.2.3.0")
$ (ProjectDir) (Donde reside mi archivo .sln)
$ (SVNToolPath) (apunta a svn.exe)
son mis variables personalizadas, sus declaraciones / definiciones no se definen a continuación.
MSBuildCommunityTasks.AssemblyInfo 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 de SVN alcance 65534 o más.
Ver:
Aquí está la solución.
<FileUpdate Files="@(AssemblyInfoFiles)"
Regex="AssemblyFileVersion/("(/d+)/.(/d+)/.(/d+)/.(/d+)"
ReplacementText="AssemblyFileVersion("$1.$2.$3.$(SubVersionRevision)" />
El resultado de esto debería ser:
En Windows / Explorer // Archivo / Propiedades .......
La versión de ensamblaje será 1.0.0.0.
La versión del archivo será 1.0.0.333 si 333 es la revisión SVN.
Si prefiere hacerlo en el lado de MSBuild través de la configuración de CCNet , parece que la tarea MSBuildCommunityTasks.AssemblyInfo la extensión de tareas de MSBuild Community puede hacer el truco.
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.
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.
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();
}
}
}