Jak mogę automatycznie zwiększać wersję zestawu C # za pośrednictwem naszej platformy CI (Hudson)?

Ja i moja grupa jesteśmy horrendalni, jeśli chodzi o zwiększanie numerów wersji zestawu i często wysyłamy zestawy w wersjach 1.0.0.0. Oczywiście powoduje to wiele bólów głowy.

Nasze praktyki są coraz lepsze dzięki naszej platformie CI i naprawdę chciałbym ustawić automatyczne zwiększanie wartości w assemblyinfo.cspliku, tak aby wersje naszych zestawów były automatycznie aktualizowane wraz ze zmianami kodu w tym zestawie.

Wcześniej ustawiłem (zanim znaleźliśmy Hudson ) sposób na zwiększenie wartości za pomocą jednego z nichmsbuild lub z linii poleceń (nie pamiętam), ale z Hudsonem, który zaktualizuje repozytorium SVN i uruchomi INNĄ kompilację. Spowodowałoby to powolną nieskończoną pętlę, gdy Hudson sonduje SVN co godzinę.

Czy zwiększenie numeru wersji przez Hudsona to zły pomysł? Jaki byłby inny sposób na zrobienie tego?

Idealnie byłoby, gdyby moje kryteria rozwiązania były takie, które:

• Zwiększa numer kompilacji assemblyinfo.csprzed kompilacją
• Zwiększa numer kompilacji tylko w zmienionych zespołach. Może to nie być możliwe, ponieważ Hudson czyści folder projektu za każdym razem, gdy tworzy kompilację
• Zatwierdza zmieniony plik assemblyinfo.cs do repozytorium kodu (obecnie VisualSVN )
• Nie powoduje, że Hudson wyzwoli nową kompilację podczas następnego skanowania w poszukiwaniu zmian

Pracując nad tym w mojej głowie, mogłem łatwo znaleźć rozwiązanie większości tego problemu za pomocą plików wsadowych / poleceń, ale wszystkie moje pomysły spowodowałyby, że Hudson uruchomiłby nową kompilację przy następnym skanowaniu. Nie szukam kogoś, kto zrobi wszystko za mnie, po prostu wskaż mi właściwy kierunek, może technikę, która pozwoli Hudsonowi zignorować pewne zatwierdzenia SVN itp.

Wszystko, co do tej pory znalazłem, to tylko artykuł wyjaśniający, jak uzyskać automatyczne zwiększanie numeru wersji, nic nie bierze pod uwagę platformy CI, która mogłaby zostać spleciona w nieskończoną pętlę.

Prostą alternatywą jest zezwolenie środowisku C # na zwiększenie wersji zestawu przez ustawienie atrybutu wersji na major.minor.*(zgodnie z opisem w szablonie pliku AssemblyInfo).

Być może jednak szukasz bardziej kompleksowego rozwiązania.

EDYCJA (odpowiedź na pytanie w komentarzu):

Od 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.*")]

Oto, co zrobiłem, aby oznaczyć atrybut AssemblyFileVersion.

Usunięto AssemblyFileVersion z AssemblyInfo.cs

Dodaj nowy, pusty plik o nazwie AssemblyFileInfo.cs do projektu.

Zainstaluj zestaw narzędzi zadań społeczności MSBuild na maszynie kompilacji Hudson lub jako zależność NuGet w projekcie.

Edytuj plik projektu (csproj), to tylko plik msbuild i dodaj następujący plik.

Gdzieś będzie <PropertyGroup>podająca wersję. Zmień to tak, by czytało np

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

Hudson dostarcza te zmienne env, które widzisz tam, gdy projekt jest budowany w hudson (zakładając, że został pobrany z subversion).

U dołu pliku projektu dodaj

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

Używa MSBuildCommunityTasks do generowania AssemblyFileVersion.cs w celu uwzględnienia atrybutu AssemblyFileVersion przed skompilowaniem projektu. Jeśli chcesz, możesz to zrobić dla dowolnego / wszystkich atrybutów wersji.

W rezultacie za każdym razem, gdy wydasz kompilację hudson, otrzymany zestaw otrzyma AssemblyFileVersion 1.0.HUDSON_BUILD_NR.SVN_REVISION np. 1.0.6.2632, co oznacza szóstą kompilację # w hudson, zbudowaną z wersji 2632 Subversion.

Oto eleganckie rozwiązanie, które wymaga trochę pracy z góry podczas dodawania nowego projektu, ale bardzo łatwo obsługuje ten proces.

Pomysł polega na tym, że każdy projekt łączy się z plikiem rozwiązania, który zawiera tylko informacje o wersji zestawu. Tak więc proces kompilacji musi tylko zaktualizować jeden plik, a wszystkie wersje zespołu są pobierane z jednego pliku podczas kompilacji.

Kroki:

1. Dodaj klasę do pliku rozwiązania * .cs, nazwałem min SharedAssemblyProperties.cs
2. Usuń wszystkie informacje cs z tego nowego pliku
3. Wytnij informacje o zespole z pliku AssemblyInfo: [assembly: AssemblyVersion ("1.0.0.0")] [assembly: AssemblyFileVersion ("1.0.0.0")]
4. Dodaj instrukcję „using System.Reflection;” do pliku, a następnie wklej dane do nowego pliku cs (ex SharedAssemblyProperties.cs)
5. Dodaj istniejący element do projektu (poczekaj ... przeczytaj przed dodaniem pliku)
6. Wybierz plik i zanim klikniesz Dodaj, kliknij listę rozwijaną obok przycisku Dodaj i wybierz „Dodaj jako łącze”.
7. Powtórz kroki 5 i 6 dla wszystkich istniejących i nowych projektów w rozwiązaniu

Po dodaniu pliku jako łącza zapisuje on dane w pliku projektu, a po kompilacji pobiera informacje o wersji zespołu z tego jednego pliku.

W kontroli źródła dodajesz plik bat lub plik skryptu, który po prostu zwiększa plik SharedAssemblyProperties.cs, a wszystkie projekty zaktualizują informacje o zespole z tego pliku.

Hudson można skonfigurować tak, aby ignorował zmiany w określonych ścieżkach i plikach, tak aby nie wyświetlał monitów o nową kompilację.

Na stronie konfiguracji zadania w obszarze Zarządzanie kodami źródłowymi kliknij przycisk Zaawansowane . W polu Wykluczone regiony należy wprowadzić co najmniej jedno wyrażenie regularne, aby dopasować wykluczenia.

Na przykład, aby zignorować zmiany w pliku version.properties , możesz użyć:

/MyProject/trunk/version.properties

To zadziała dla języków innych niż C # i pozwoli ci przechowywać informacje o wersji w subversion.

.NET robi to za Ciebie. W pliku AssemblyInfo.cs ustaw wersję zestawu na major.minor. * (Na przykład: 1.0. *).

Podczas tworzenia projektu wersja jest generowana automatycznie.

Wydaje mi się, że numery kompilacji i wersji są generowane na podstawie daty, przy użyciu epoki systemu Unix. Kompilacja jest oparta na bieżącym dniu, a wersja na podstawie liczby sekund, które upłynęły od północy.

Nigdy nie widziałem, aby funkcja 1.0. * Działała w VS2005 lub VS2008. Czy jest coś, co należy zrobić, aby ustawić VS na zwiększanie wartości?

Jeśli AssemblyInfo.cs jest zakodowane na stałe w 1.0. *, To gdzie jest przechowywana rzeczywista kompilacja / wersja?

Po umieszczeniu 1.0. * W AssemblyInfo, nie możemy użyć następującej instrukcji, ponieważ ProductVersion ma teraz nieprawidłową wartość - używa 1.0. *, A nie wartości przypisanej przez VS:

Version version = new Version(Application.ProductVersion);

Westchnienie - wydaje się, że to jedna z tych rzeczy, o które wszyscy pytają, ale jakoś nigdy nie ma solidnej odpowiedzi. Wiele lat temu widziałem rozwiązania do generowania numeru wersji i zapisywania go w AssemblyInfo jako część procesu po kompilacji. Miałem nadzieję, że ten rodzaj tańca nie będzie potrzebny w VS2008. Może VS2010?

Zakładam, że można to również zrobić za pomocą szablonu tekstowego, w którym tworzy się atrybuty zespołu w locie ze środowiska, tak jak poniżej AssemblyVersion.tt.

<#@ 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#>")]

W ramach kontynuacji odpowiedzi MikeSa chciałem dodać, że aby to działało, należy zainstalować VS + Visual Studio Visualization and Modeling SDK, a także zmodyfikować plik projektu. Należy również wspomnieć, że używam Jenkinsa jako serwera kompilacji działającego na serwerze Windows 2008 R2 z modułem wersji, gdzie otrzymuję BUILD_NUMBER.

Plik mojego szablonu tekstowego version.tt wygląda następująco

<#@ 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#>")]

W grupach właściwości mam następujące elementy

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

po zaimportowaniu Microsoft.CSharp.targets mam to (w zależności od tego, gdzie instalujesz VS

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

Na moim serwerze kompilacji mam następujący skrypt, aby uruchomić transformację tekstu przed rzeczywistą kompilacją, aby uzyskać ostatni numer zestawu zmian na TFS

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>

W ten sposób mogę śledzić kompilacje ORAZ zestawy zmian, więc jeśli nic nie sprawdzałem od ostatniej kompilacji, ostatnia cyfra nie powinna się zmieniać, jednak mogłem dokonać zmian w procesie budowania, stąd potrzeba przedostatniej liczby . Oczywiście, jeśli wykonasz wiele zameldowań przed kompilacją, zobaczysz tylko ostatnią zmianę odzwierciedloną w wersji. Myślę, że można by to połączyć.

Jestem pewien, że możesz zrobić coś bardziej wyszukanego i zadzwonić do TFS bezpośrednio z szablonu tt, jednak to działa dla mnie.

Mogę wtedy pobrać moją wersję w takim czasie wykonywania

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

Moje rozwiązanie nie wymaga dodawania zewnętrznych narzędzi ani języków skryptowych - z dużym prawdopodobieństwem będzie działać na komputerze, na którym się kompiluję. Rozwiązuję ten problem w kilku częściach. Najpierw utworzyłem plik BUILD.BAT, który konwertuje parametr Jenkins BUILD_NUMBER na zmienną środowiskową. Używam funkcji „Wykonaj polecenie wsadowe systemu Windows” Jenkinsa, aby uruchomić plik wsadowy kompilacji, wprowadzając następujące informacje dotyczące kompilacji Jenkins:

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

W środowisku kompilacji mam plik build.bat, który zaczyna się w następujący sposób:

     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

Gdy to zrobiłem, kliknąłem prawym przyciskiem myszy projekt do zbudowania w okienku Eksplorator rozwiązań programu Visual Studio i wybrałem Właściwości, wybierz opcję Zdarzenia kompilacji i wprowadziłem następujące informacje jako wiersz polecenia przed kompilacją zdarzenia, który automatycznie tworzy plik .cs zawierające informacje o numerze kompilacji na podstawie aktualnych ustawień zmiennych środowiskowych:

     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%

Może być konieczne dostosowanie się do gustu budowy. Raz buduję projekt ręcznie, aby wygenerować początkowy plik Version.cs w katalogu Właściwości głównego projektu. Na koniec ręcznie dołączam plik Version.cs do rozwiązania Visual Studio, przeciągając go do okienka Eksplorator rozwiązań poniżej karty Właściwości dla tego projektu. W przyszłych kompilacjach program Visual Studio odczytuje następnie ten plik .cs w czasie kompilacji Jenkins i pobiera z niego prawidłowe informacje o numerze kompilacji.

Mamy więc projekt z jednym rozwiązaniem, które zawiera kilka projektów, które mają zestawy o różnych numerach wersji.

Po zbadaniu kilku z powyższych metod właśnie zaimplementowałem krok kompilacji, aby uruchomić skrypt Powershell, który wykonuje wyszukiwanie i zamianę w pliku AssemblyInfo.cs. Nadal używam numeru wersji 1.0. * W kontroli źródła, a Jenkins po prostu ręcznie aktualizuje numer wersji przed uruchomieniem msbuild.

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

Dodałem opcję -Encoding "UTF8", ponieważ git zaczął traktować plik .cs jako pliki binarne, jeśli tego nie zrobiłem. To prawda, to nie miało znaczenia, ponieważ tak naprawdę nigdy nie popełniłem wyniku; po prostu wyszło, gdy testowałem.

Nasze środowisko CI ma już możliwość kojarzenia kompilacji Jenkinsa z konkretnym zatwierdzeniem git (dzięki wtyczce Stash!), Więc nie martwię się, że nie ma git commit z dołączonym numerem wersji.

To jest prostszy mechanizm. Wymaga to po prostu dodania kroku kompilacji zadania Windows Batch przed krokiem MSBuild i użycia prostego programu znajdź i zamień (FART).

Krok wsadowy

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

Jeśli używasz kontroli źródła innej niż svn, zmień opcję --svn na odpowiednią dla swojego środowiska scm.

Pobierz Fart

Zdecydowałem się użyć kilku metod przy użyciu wstępnie kompilowanego skryptu Powershell ( https://gist.github.com/bradjolicoeur/e77c508089aea6614af3 ), aby zwiększyć przyrost przy każdej udanej kompilacji, a następnie w Global.asax mam coś takiego:

  // 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); 
  }

Nadal uważam, że cały proces jest zbyt skomplikowany i zamierzam przyjrzeć się bardziej wydajnej metodzie osiągnięcia tego samego wyniku. Chciałem tego głównie do przekazania wersji do SVN, a następnie do Jenkina bez zbyt wielu dodatkowych narzędzi.