Scott Hanselman

A few months back I moved my CI/CD (Continuous Integration/Continuous Development) to Azure DevOps for free. You get 1800 build minutes a month FREE and I'm not even close to using it with three occasionally-updated sites building on it. Earlier this week I wrote about making a cleaner and more intentional azure-pipelines.yml for an ASP.NET Core Web App

I was working/pairing with Damian today because I wanted to get my git commit hashes and build ids embedded into the actual website so I could see exactly what commit is in production.

That's live on hanselminutes.com righ tnow and looks like this

© Copyright 2020, Scott Hanselman. Design by @jzy, Powered by .NET Core 3.1.2 and deployed from commit 6b48de via build 20200310.7

There's a few things here and it's all in my ASP.NET Web App's main layout page called _layout.cshtml. You can look all about ASP.NET Core 101, .NET and C# over at https://dot.net/videos if you'd like. They've lovely videos.

So let's take this footer apart, shall we?

<div class="copyright">&copy; Copyright @DateTime.Now.Year, 
 <a href="https://www.hanselman.com">Scott Hanselman</a>. 
 Design by <a href="http://www.8164.org/">@@jzy</a>, 
 Powered by @System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription
 and deployed from commit <a href="https://github.com/shanselman/hanselminutes-core/commit/@appInfo.GitHash">@appInfo.ShortGitHash</a>
  via build <a href="https://dev.azure.com/hanselman/Hanselminutes%20Website/_build/results?buildId=@appInfo.BuildId&view=results">@appInfo.BuildNumber</a> 
</div>        

First, the obvious floating copyright year. Then a few credits that are hard coded.

Next, a call to @System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription which gives me this string ".NET Core 3.1.2" Note that there was a time for a while where that Property was somewhat goofy, but no longer.

I have two kinds of things I want to store along with my build artifact and output.

• I want the the Git commit hash of the code that was deployed.
  • Then I want to link it back to my source control. Note that my site is a private repo so you'll get a 404
• I want the Build Number and the Build ID
  • This way I can link back to my Azure DevOps site

Adding a Git Commit Hash to your .NET assembly

There's lots of Assembly-level attributes you can add to your .NET assembly. One lovely one is AssemblyInformationalVersion and if you pass in SourceRevisionId on the dotnet build command line, it shows up in there automatically. Here's an example:

[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d6b3d432970c9acbc21ecd22c9f5578892385305")]
[assembly: AssemblyProduct("hanselminutes.core")]
[assembly: AssemblyTitle("hanselminutes.core")]
[assembly: AssemblyVersion("1.0.0.0")]

From this command line:

dotnet build --configuration Release /p:SourceRevisionId=d6b3d432970c9acbc21ecd22c9f5578892385305

But where does that hash come from? Well, Azure Dev Ops includes it in an environment variable so you can make a YAML task like this:

- task: DotNetCoreCLI@2
  displayName: 'dotnet build $(buildConfiguration)'
  inputs:
    command: 'build'
    arguments: '-r $(rid) --configuration $(buildConfiguration) /p:SourceRevisionId=$(Build.SourceVersion)'

Sweet. That will put in VERSION+HASH, so we'll pull that out of a utility class Damian made like this (full class will be shown later)

public string GitHash
{
    get
    {
        if (string.IsNullOrEmpty(_gitHash))
        {
            var version = "1.0.0+LOCALBUILD"; // Dummy version for local dev
            var appAssembly = typeof(AppVersionInfo).Assembly;
            var infoVerAttr = (AssemblyInformationalVersionAttribute)appAssembly
                .GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute)).FirstOrDefault();

            if (infoVerAttr != null && infoVerAttr.InformationalVersion.Length > 6)
            {
                // Hash is embedded in the version after a '+' symbol, e.g. 1.0.0+a34a913742f8845d3da5309b7b17242222d41a21
                version = infoVerAttr.InformationalVersion;
            }
            _gitHash = version.Substring(version.IndexOf('+') + 1);
            
        }

        return _gitHash;
    }
}

Displaying it is then trivial given the helper class we'll see in a minute. Note that hardcoded paths for my private repo. No need to make things complex.

deployed from commit <a href="https://github.com/shanselman/hanselminutes-core/commit/@appInfo.GitHash">@appInfo.ShortGitHash</a>

Getting and Displaying Azure DevOps Build Number and Build ID

This one is a little more complex. We could theoretically tunnel this info into an assembly as well but it's just as easy, if not easier to put it into a text file and make sure it's part of the ContentRootPath (meaning it's just in the root of the website's folder).

To be clear, an option: There are ways to put this info in an Attribute but not without messing around with your csproj using some not-well-documented stuff. I like a clean csproj so I like this. Ideally there'd be another thing like SourceRevisionID to carry this metadata.

You'd need to do something like this, and then pull it out with reflection. Meh.

<ItemGroup>
  <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute" Condition="$(BuildNumber) != ''" >
    <_Parameter1>BuildNumber</_Parameter1>
    <_Parameter2>$(BuildNumber)</_Parameter2>
  </AssemblyAttribute>
  <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute" Condition="$(BuildId) != ''" >
    <_Parameter1>BuildId</_Parameter1>
    <_Parameter2>$(BuildId)</_Parameter2>
  </AssemblyAttribute>
</ItemGroup>

Those $(BuildNumber) and $(BuildId) dealies are build variables. Again, this csproj messing around is not for me.

Instead, a simple text file, coming along for the ride.

- script: 'echo -e "$(Build.BuildNumber)\n$(Build.BuildId)" > .buildinfo.json'
  displayName: "Emit build number"
  workingDirectory: '$(Build.SourcesDirectory)/hanselminutes.core'
  failOnStderr: true

I'm cheating a little as I gave it the .json extension, only because JSON files are copying and brought along as "Content." If it didn't have an extension I would need to copy it manually, again, with my csproj:

<ItemGroup>
  <Content Include=".buildinfo">
    <CopyToOutputDirectory>Always</CopyToOutputDirectory>
  </Content>
</ItemGroup>

So, to be clear, two build variables inside a little text file. Then make a little helper class from Damian. Again, that file is in ContentRootPath and was zipped up and deployed with our web app.

public class AppVersionInfo
{
    private static readonly string _buildFileName = ".buildinfo.json";
    private string _buildFilePath;
    private string _buildNumber;
    private string _buildId;
    private string _gitHash;
    private string _gitShortHash;

    public AppVersionInfo(IHostEnvironment hostEnvironment)
    {
        _buildFilePath = Path.Combine(hostEnvironment.ContentRootPath, _buildFileName);
    }

    public string BuildNumber
    {
        get
        {
            // Build number format should be yyyyMMdd.# (e.g. 20200308.1)
            if (string.IsNullOrEmpty(_buildNumber))
            {
                if (File.Exists(_buildFilePath))
                {
                    var fileContents = File.ReadLines(_buildFilePath).ToList();

                    // First line is build number, second is build id
                    if (fileContents.Count > 0)
                    {
                        _buildNumber = fileContents[0];
                    }
                    if (fileContents.Count > 1)
                    {
                        _buildId = fileContents[1];
                    }
                }

                if (string.IsNullOrEmpty(_buildNumber))
                {
                    _buildNumber = DateTime.UtcNow.ToString("yyyyMMdd") + ".0";
                }

                if (string.IsNullOrEmpty(_buildId))
                {
                    _buildId = "123456";
                }
            }

            return _buildNumber;
        }
    }

    public string BuildId
    {
        get
        {
            if (string.IsNullOrEmpty(_buildId))
            {
                var _ = BuildNumber;
            }

            return _buildId;
        }
    }

    public string GitHash
    {
        get
        {
            if (string.IsNullOrEmpty(_gitHash))
            {
                var version = "1.0.0+LOCALBUILD"; // Dummy version for local dev
                var appAssembly = typeof(AppVersionInfo).Assembly;
                var infoVerAttr = (AssemblyInformationalVersionAttribute)appAssembly
                    .GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute)).FirstOrDefault();

                if (infoVerAttr != null && infoVerAttr.InformationalVersion.Length > 6)
                {
                    // Hash is embedded in the version after a '+' symbol, e.g. 1.0.0+a34a913742f8845d3da5309b7b17242222d41a21
                    version = infoVerAttr.InformationalVersion;
                }
                _gitHash = version.Substring(version.IndexOf('+') + 1);
                
            }

            return _gitHash;
        }
    }

    public string ShortGitHash
    {
        get
        {
            if (string.IsNullOrEmpty(_gitShortHash))
            {
                _gitShortHash = GitHash.Substring(GitHash.Length - 6, 6);
            }
            return _gitShortHash;
        }
    }
}

How do we access this class? Simple! It's a Singleton added in one line in Startup.cs's ConfigureServices():

services.AddSingleton<AppVersionInfo>();

Then injected in one line in our _layout.cshtml!

@inject AppVersionInfo appInfo

Then I can use it and it's easy. I could put an environment tag around it to make it only show up in staging:

<environment include="Staging">
    <cache expires-after="@TimeSpan.FromDays(30)">
        <div class="copyright">&copy; Copyright @DateTime.Now.Year, <a href="https://www.hanselman.com">Scott Hanselman</a>. Design by <a href="http://www.8164.org/">@@jzy</a>, Powered by @System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription and deployed from commit <a href="https://github.com/shanselman/hanselminutes-core/commit/@appInfo.GitHash">@appInfo.ShortGitHash</a> via build <a href="https://dev.azure.com/hanselman/Hanselminutes%20Website/_build/results?buildId=@appInfo.BuildId&view=results">@appInfo.BuildNumber</a> </div>
    </cache>
</environment>

I could also wrap it all in a cache tag like this. Worst case for a few days/weeks at the start of a new year the Year is off.

<cache expires-after="@TimeSpan.FromDays(30)">

<cache>

Thoughts on this technique?

Sponsor: This week's sponsor is...me! This blog and my podcast has been a labor of love for over 18 years. Your sponsorship pays my hosting bills for both AND allows me to buy gadgets to review AND the occasional taco. Join me!

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By