C # montaj sürümünü CI platformumuz (Hudson) aracılığıyla nasıl otomatik olarak artırabilirim?

Ben ve grubum artan montaj sürüm numaralarında korkunç davranıyor ve sık sık 1.0.0.0 sürümleri olan montajları gönderiyoruz. Açıkçası, bu çok fazla baş ağrısına neden olur.

CI platformumuz aracılığıyla uygulamalarımızla çok daha iyi hale geliyoruz ve assemblyinfo.csderlemelerimizin sürümlerinin o derlemedeki kod değişiklikleriyle otomatik olarak güncellenmesi için dosya içindeki değerleri otomatik olarak artıracak şekilde ayarlamak istiyorum .

Daha önce ( Hudson'ı bulmadan önce ) değeri ya msbuildkomut satırı aracılığıyla artırmanın (hatırlayamıyorum ) bir yolunu kurmuştum, ancak Hudson ile SVN deposunu güncelleyecek ve BAŞKA bir yapıyı tetikleyecek. Hudson, SVN'yi her saat sorgularken, bu yavaş bir sonsuz döngü ile sonuçlanır.

Hudson'ın sürüm numarasını artırması kötü bir fikir mi? Bunu yapmanın alternatif bir yolu ne olabilir?

İdeal olarak, bir çözüm için kriterlerim şunlar olacaktır:

• Bir derlemeden önce yapı numarasını assemblyinfo.csartırır
• Yalnızca değişen montajlardaki yapı numarasını artırır. Hudson her derleme yaptığında proje klasörünü sildiği için bu mümkün olmayabilir.
• Değiştirilen assemblyinfo.cs dosyasını kod deposuna işler (şu anda VisualSVN )
• Hudson'ın bir dahaki sefere değişiklik taraması yaptığında yeni bir yapıyı tetiklemesine neden olmaz

Bunu kafamda çalışarak, toplu dosyalar / komutlar aracılığıyla bunların çoğuna kolayca bir çözüm bulabilirim, ancak tüm fikirlerim Hudson'ın bir sonraki taramada yeni bir yapıyı tetiklemesine neden olur. Benim için her şeyi yapacak birini aramıyorum, sadece bana doğru yönü göster, belki Hudson'ın belirli SVN taahhütlerini görmezden gelmesini sağlayacak bir teknik, vb.

Şimdiye kadar bulduğum her şey, sürüm numarasının otomatik olarak nasıl artırılacağını açıklayan bir makale, hiçbir şey sonsuz bir döngüye dönüştürülebilecek bir CI platformunu hesaba katmıyor.

Basit bir alternatif, sürüm özniteliğini major.minor.*(AssemblyInfo dosya şablonunda açıklandığı gibi) olarak ayarlayarak C # ortamının sizin için derleme sürümünü artırmasına izin vermektir .

Yine de daha kapsamlı bir çözüm arıyor olabilirsiniz.

DÜZENLE (Bir yorumda soruya verilen yanıt):

Kimden AssemblyInfo.cs:

// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Build and Revision Numbers 
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]

AssemblyFileVersion özniteliğini damgalamak için yaptığım şey şu.

AssemblyFileVersion kaldırıldı AssemblyInfo.cs

Projeye AssemblyFileInfo.cs adında yeni, boş bir dosya ekleyin.

Yükleme MSBuild topluluk görevler Hudson inşa makinede veya bir şekilde araç grubu Nuget bağımlılık projenizde.

Proje (csproj) dosyasını düzenleyin, sadece bir msbuild dosyasıdır ve aşağıdakileri ekleyin.

Bir yerde <PropertyGroup>versiyonu belirten bir yer olacak . Bunu, örneğin okur gibi değiştirin

 <Major>1</Major>
 <Minor>0</Minor>
 <!--Hudson sets BUILD_NUMBER and SVN_REVISION -->
 <Build>$(BUILD_NUMBER)</Build>
 <Revision>$(SVN_REVISION)</Revision>

Hudson, proje hudson üzerine kurulduğunda orada gördüğünüz env değişkenlerini sağlar (bunun subversion'dan getirildiği varsayılarak).

Proje dosyasının altına şunu ekleyin:

 <Import Project="$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets" Condition="Exists('$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets')" />
  <Target Name="BeforeBuild" Condition="Exists('$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets')">
    <Message Text="Version: $(Major).$(Minor).$(Build).$(Revision)" />
    <AssemblyInfo CodeLanguage="CS" OutputFile="AssemblyFileInfo.cs" AssemblyFileVersion="$(Major).$(Minor).$(Build).$(Revision)" AssemblyConfiguration="$(Configuration)" Condition="$(Revision) != '' " />
  </Target>

Bu, proje oluşturulmadan önce AssemblyFileVersion özniteliğini dahil etmek için AssemblyFileVersion.cs oluşturmak için MSBuildCommunityTasks kullanır. İsterseniz bunu sürüm özelliklerinin herhangi biri / tümü için yapabilirsiniz.

Sonuç olarak, bir hudson derlemesi verdiğinizde, ortaya çıkan derleme 1.0.HUDSON_BUILD_NR.SVN_REVISION değerinde bir AssemblyFileVersion alır, ör. 1.0.6.2632, bu, hudson'daki 6. derleme #, buit, 2632 numaralı alt sürümden buit anlamına gelir.

İşte yeni bir proje eklerken önceden biraz çalışma gerektiren ancak süreci çok kolay bir şekilde ele alan zarif bir çözüm.

Buradaki fikir, her projenin yalnızca derleme sürüm bilgilerini içeren bir Çözüm dosyasına bağlanmasıdır. Dolayısıyla, derleme sürecinizin yalnızca tek bir dosyayı güncellemesi gerekir ve tüm derleme sürümleri derleme sırasında tek bir dosyadan çeker.

Adımlar:

1. Çözüm dosyasına bir sınıf ekleyin * .cs dosyası, ben min SharedAssemblyProperties.cs adını verdim
2. Bu yeni dosyadan tüm cs bilgilerini kaldırın
3. Bir AssemblyInfo dosyasından derleme bilgilerini kesin: [derleme: AssemblyVersion ("1.0.0.0")] [derleme: AssemblyFileVersion ("1.0.0.0")]
4. "Using System.Reflection;" ifadesini ekleyin dosyaya ekleyin ve ardından verileri yeni cs dosyanıza yapıştırın (eski SharedAssemblyProperties.cs)
5. Projenize mevcut bir öğe ekleyin (bekleyin ... dosyayı eklemeden önce okuyun)
6. Dosyayı seçin ve Ekle'yi tıklamadan önce, ekle düğmesinin yanındaki açılır menüyü tıklayın ve "Bağlantı Olarak Ekle" yi seçin.
7. Çözümdeki tüm mevcut ve yeni projeler için 5. ve 6. adımları tekrarlayın

Dosyayı bir bağlantı olarak eklediğinizde, verileri proje dosyasında depolar ve derleme üzerine derleme sürüm bilgilerini bu tek dosyadan çeker.

Kaynak kontrolünüzde, SharedAssemblyProperties.cs dosyasını artıran bir bat dosyası veya komut dosyası eklersiniz ve tüm projeleriniz bu dosyadan montaj bilgilerini günceller.

Hudson, belirli yollarda ve dosyalarda yapılan değişiklikleri göz ardı edecek şekilde yapılandırılabilir, böylece yeni bir derleme istemez.

İş yapılandırma sayfasında, Kaynak Kod Yönetimi altında , Gelişmiş düğmesine tıklayın. Hariç Tutulan Bölgeler kutusuna , hariç tutmaları eşleştirmek için bir veya daha fazla normal ifade girersiniz.

Örneğin version.properties dosyasındaki değişiklikleri yok saymak için şunları kullanabilirsiniz:

/MyProject/trunk/version.properties

Bu, C # dışındaki diller için çalışacak ve sürüm bilgilerinizi subversion içinde saklamanıza izin verecektir.

.NET bunu sizin için yapar. AssemblyInfo.cs dosyanızda, derleme sürümünüzü major.minor. * Olarak ayarlayın (örneğin: 1.0. *).

Projenizi oluşturduğunuzda sürüm otomatik olarak oluşturulur.

Yapım ve revizyon numaralarının, unix dönemi kullanılarak tarihe göre oluşturulduğuna inanıyorum. Derleme, geçerli güne dayanır ve revizyon, gece yarısından bu yana geçen saniye sayısına bağlıdır.

1.0. * Özelliğinin VS2005 veya VS2008'de çalıştığını hiç görmedim. VS'yi değerleri artıracak şekilde ayarlamak için yapılması gereken bir şey var mı?

AssemblyInfo.cs 1.0. * İle sabit kodlanmışsa, gerçek derleme / revizyon nerede depolanır?

AssemblyInfo'ya 1.0. * Koyduktan sonra, aşağıdaki ifadeyi kullanamayız çünkü ProductVersion artık geçersiz bir değere sahip - VS tarafından atanan değer değil 1.0. * Kullanıyor:

Version version = new Version(Application.ProductVersion);

İç çekiş - bu herkesin sorduğu şeylerden biri gibi görünüyor ama bir şekilde hiçbir zaman kesin bir cevap yok. Yıllar önce bir revizyon numarası oluşturmaya ve bunu bir inşa sonrası sürecin parçası olarak AssemblyInfo'ya kaydetmeye yönelik çözümler gördüm. VS2008 için bu tür bir dansın gerekli olmayacağını umuyordum. Belki VS2010?

Bunu , AssemblyVersion.tt'nin aşağıda yaptığı gibi, söz konusu derleme özniteliklerini ortamdan anında oluşturduğunuz bir metin şablonuyla da yapabileceğinizi varsayıyorum .

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ output extension=".cs" #>
<#
var build = Environment.GetEnvironmentVariable("BUILD_NUMBER");
build = build == null ? "0" : int.Parse(build).ToString();
var revision = Environment.GetEnvironmentVariable("SVN_REVISION");
revision = revision == null ? "0" : int.Parse(revision).ToString();    
#>
using System.Reflection;
[assembly: AssemblyVersion("1.0.<#=build#>.<#=revision#>")]
[assembly: AssemblyFileVersion("1.0.<#=build#>.<#=revision#>")]

MikeS'ın cevabının bir devamı olarak, bunun çalışması için VS + Visual Studio Görselleştirme ve Modelleme SDK'sının yüklenmesi gerektiğini ve proje dosyasını da değiştirmeniz gerektiğini eklemek istedim. Ayrıca Jenkins'i sürüm modülüne sahip bir Windows 2008 R2 sunucu kutusunda çalışan derleme sunucusu olarak kullandığım ve BUILD_NUMBER değerini aldığım da belirtilmelidir.

Metin Şablonu dosyam version.tt şuna benzer

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ output extension=".cs" #>
<#
var build = Environment.GetEnvironmentVariable("BUILD_NUMBER");
build = build == null ? "0" : int.Parse(build).ToString();
var revision = Environment.GetEnvironmentVariable("_BuildVersion");
revision = revision == null ? "5.0.0.0" : revision;    
#>
using System.Reflection;
[assembly: AssemblyVersion("<#=revision#>")]
[assembly: AssemblyFileVersion("<#=revision#>")]

Mülk Gruplarında aşağıdakilere sahibim

<PropertyGroup>
    <TransformOnBuild>true</TransformOnBuild>
    <OverwriteReadOnlyOutputFiles>true</OverwriteReadOnlyOutputFiles>
    <TransformOutOfDateOnly>false</TransformOutOfDateOnly>
</PropertyGroup>

Microsoft.CSharp.targets'ı içe aktardıktan sonra, buna sahibim (VS'yi nereye yüklediğinize bağlı olarak)

<Import Project="C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\TextTemplating\v10.0\Microsoft.TextTemplating.targets" />

Derleme sunucumda, TFS'deki son değişiklik seti numarasını almak için gerçek derlemeden önce metin dönüşümünü çalıştırmak için aşağıdaki komut dosyasına sahibim.

set _Path="C:\Build_Source\foo"

pushd %_Path% 
"%ProgramFiles(x86)%\Microsoft Visual Studio 10.0\Common7\IDE\tf.exe" history . /r /noprompt /stopafter:1 /Version:W > bar
FOR /f "tokens=1" %%foo in ('findstr /R "^[0-9][0-9]*" bar') do set _BuildVersion=5.0.%BUILD_NUMBER%.%%foo
del bar
popd

echo %BUILD_NUMBER%
echo %_BuildVersion%
cd C:\Program Files (x86)\Jenkins\jobs\MyJob\workspace\MyProject
MSBuild MyProject.csproj /t:TransformAll 
...
<rest of bld script>

Bu şekilde derlemeleri VE değişiklik kümelerini takip edebilirim, bu nedenle son derlemeden bu yana hiçbir şey kontrol etmediysem, son basamak değişmemelidir, ancak derleme sürecinde değişiklikler yapmış olabilirim, bu nedenle ikinci son sayıya ihtiyaç olabilir. . Elbette, bir derlemeden önce birden fazla check-in yaparsanız, yalnızca sürüme yansıyan son değişikliği alırsınız. Sanırım gerekli olanı birleştirebilirsiniz.

Eminim daha meraklı bir şeyler yapabilir ve TFS'yi doğrudan tt Şablonu içinden arayabilirsiniz, ancak bu benim için çalışıyor.

Daha sonra bu şekilde çalışma zamanında sürümümü alabilirim

Assembly assembly = Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
return fvi.FileVersion;

Benim çözümüm harici araçların veya komut dosyası dillerinin eklenmesini gerektirmiyor - derleme makinenizde çalışması oldukça garantili. Bu sorunu birkaç kısımda çözüyorum. Öncelikle Jenkins BUILD_NUMBER parametresini bir ortam değişkenine dönüştüren bir BUILD.BAT dosyası oluşturdum. Derleme toplu iş dosyasını çalıştırmak için Jenkins'in "Execute Windows batch command" işlevini Jenkins derlemesi için aşağıdaki bilgileri girerek kullanıyorum:

     ./build.bat --build_id %BUILD_ID% -build_number %BUILD_NUMBER%

Derleme ortamında, aşağıdaki gibi başlayan bir build.bat dosyam var:

     rem build.bat
     set BUILD_ID=Unknown
     set BUILD_NUMBER=0
     :parse_command_line
     IF NOT "%1"=="" (
         IF "%1"=="-build_id" (
             SET BUILD_ID=%2
             SHIFT
             )
         IF "%1"=="-build_number" (
             SET BUILD_NUMBER=%2
             SHIFT
         )
         SHIFT
         GOTO :parse_command_line
     )
     REM your build continues with the environmental variables set
     MSBUILD.EXE YourProject.sln

Bunu yaptıktan sonra, Visual Studio'nun Çözüm Gezgini bölmesinde oluşturulacak projeye sağ tıkladım ve Özellikler'i seçtim, Olayları Oluştur'u seçtim ve aşağıdaki bilgileri otomatik olarak bir .cs dosyası oluşturan Pre-Build Event Command Line olarak girdim mevcut ortam değişkeni ayarlarına dayalı derleme numarası bilgilerini içerir:

     set VERSION_FILE=$(ProjectDir)\Properties\VersionInfo.cs
     if !%BUILD_NUMBER%==! goto no_buildnumber_set
     goto buildnumber_set
     :no_buildnumber_set
     set BUILD_NUMBER=0
     :buildnumber_set
     if not exist %VERSION_FILE% goto no_version_file
     del /q %VERSION_FILE%
     :no_version_file
     echo using System.Reflection; >> %VERSION_FILE%
     echo using System.Runtime.CompilerServices; >> %VERSION_FILE%
     echo using System.Runtime.InteropServices; >> %VERSION_FILE%
     echo [assembly: AssemblyVersion("0.0.%BUILD_NUMBER%.1")] >> %VERSION_FILE%
     echo [assembly: AssemblyFileVersion("0.0.%BUILD_NUMBER%.1")] >> %VERSION_FILE%

Yapı zevkinize göre ayarlamanız gerekebilir. Ana projenin Properties dizininde bir ilk Version.cs dosyası oluşturmak için projeyi manuel olarak bir kez oluşturuyorum. Son olarak, Version.cs dosyasını o projenin Özellikler sekmesinin altında Çözüm Gezgini bölmesine sürükleyerek Visual Studio çözümüne manuel olarak dahil ediyorum. Gelecekteki derlemelerde, Visual Studio bu .cs dosyasını Jenkins derleme zamanında okur ve bundan doğru derleme numarası bilgilerini alır.

Dolayısıyla, farklı sürüm numaralarına sahip montajları olan birkaç projeyi içeren tek bir çözüme sahip bir projemiz var.

Yukarıdaki yöntemlerden birkaçını araştırdıktan sonra, AssemblyInfo.cs dosyasında bul-ve-değiştir yapan bir Powershell betiğini çalıştırmak için bir yapı adımı uyguladım. Hala kaynak kontrolünde 1.0. * Sürüm numarasını kullanıyorum ve Jenkins, msbuild çalışmadan önce sürüm numarasını manuel olarak güncelliyor.

dir **/Properties/AssemblyInfo.cs | %{ (cat $_) | %{$_ -replace '^(\s*)\[assembly: AssemblyVersion\("(.*)\.\*"\)', "`$1[assembly: AssemblyVersion(`"`$2.$build`")"} | Out-File $_ -Encoding "UTF8" }
dir **/Properties/AssemblyInfo.cs | %{ (cat $_) | %{$_ -replace '^(\s*)\[assembly: AssemblyFileVersion\("(.*)\.\*"\)', "`$1[assembly: AssemblyFileVersion(`"`$2.$build`")"} | Out-File $_ -Encoding "UTF8" }

-Encoding "UTF8" seçeneğini ekledim çünkü git, yapmadıysam .cs dosyasını ikili dosyalar olarak işlemeye başladı. Elbette, sonucu gerçekten asla işleyemediğim için bu önemli değildi; sadece test ederken ortaya çıktı.

CI ortamımızın zaten Jenkins yapısını belirli git commit ile ilişkilendirmek için bir tesisi var (Stash eklentisi teşekkürler!), Bu yüzden ona eklenen sürüm numarasıyla git commit olmadığından endişelenmiyorum.

Bu daha basit bir mekanizmadır. Basitçe MSBuild adımından önce bir Windows Toplu İş komutu görev oluşturma adımının eklenmesini ve basit bir bul ve değiştir programının (FART) kullanılmasını içerir.

Toplu Adım

fart --svn -r AssemblyInfo.cs "[assembly: AssemblyVersion(\"1.0.0.0\")]" "[assembly: AssemblyVersion(\"1.0.%BUILD_NUMBER%.%SVN_REVISION%\")]"
if %ERRORLEVEL%==0 exit /b 1
fart --svn -r AssemblyInfo.cs "[assembly: AssemblyFileVersion(\"1.0.0.0\")]" "[assembly: AssemblyFileVersion(\"1.0.%BUILD_NUMBER%.%SVN_REVISION%\")]"
if %ERRORLEVEL%==0 exit /b 1
exit /b 0

Svn dışında bir kaynak kontrolü kullanıyorsanız, scm ortamınız için uygun olan --svn seçeneğini değiştirin.

Osuruk İndir

Önceden oluşturulmuş bir Powershell betiği ( https://gist.github.com/bradjolicoeur/e77c508089aea6614af3 ) kullanarak her başarılı derlemeyi geliştirmek için birkaç yöntem kullanmaya karar verdim ve ardından Global.asax'ta şuna benzer bir şey yapıyorum:

  // We are using debug configuration, so increment our builds.
  if (System.Diagnostics.Debugger.IsAttached)
  {
      string version = System.Reflection.Assembly.GetExecutingAssembly()
                                                       .GetName()
                                                       .Version
                                                       .ToString();

      var psi = new ProcessStartInfo(@"svn", "commit -m \"Version: " + version + "\n \"");
      psi.WorkingDirectory = @"C:\CI\Projects\myproject";
      Process.Start(psi); 
  }

Hala tüm sürecin aşırı karmaşık olduğunu düşünüyorum ve aynı sonucu elde etmek için daha verimli bir yöntem arayacağım. Bunu esas olarak sürümü SVN'ye ve daha sonra çok fazla ek araç olmadan Jenkin'e aktarmak için istedim.