Category: ams

The integration with CI providers is enough straightforward – just see what environments variable those providers have. GitLab and Github has enough documentation – at https://docs.gitlab.com/ee/ci/variables/ and https://docs.github.com/en/actions/reference/environment-variables 

What I have forgot is that there are also CI providers without having necessary source control.

For example AzureDevOps can execute code taken from GitHub

More than that  Heroku stack , that has not source control , have dispersed info – see https://devcenter.heroku.com/changelog-items/630 about SOURCE_VERSION – and no more else about the what other variables it has. I have obtained those via RSCG – but no indication about what is the source control comes.

What can I do ? The solution is to avert the users – I have created https://ignatandrei.github.io/RSCG_AMS/runtimeMessages/NotFound.md .

If you create a Roslyn Source Code Generator that uses inside a base class or a static class, the best way, in my opinion , is to create 2 separate nuget packages : one for the code generated and one for the base class. This way the project that will use your RSCG will use just the nuget package that have the base class and get rid of the generator . More, you can add a third project to register some extensions to Web project .

Let’s see in practice with RSCG_AMS :

I have a NuGet package with the base class AboutMySoftware –  https://www.nuget.org/packages/AMS_Base/

The RSCG generates derived classes of AboutMySoftware  – has a dependency in the AMS_Base   –  the name is RSCG_AMS : https://www.nuget.org/packages/RSCG_AMS/ . This will generate code during the build and will not be included in the output.

Finally, I have an extension for WebAPI – AMSWebAPI – that registers the  endpoint in the Web Project to display /ams url .

I think that this is a normal organization of RSCG projects.

Also, add documentation  for each class / public item generated. There can be projects that will require this ( as a compiler/ property flag )

Now it is time to let others know about the project. And the first step is to make documentation. And , because a picture is worth many words, here is the picture:

Also, instructions about how to use will help the programmers:

For a DLL it is simple :

<ItemGroup>
    <PackageReference Include="AMS_Base" Version="2021.6.29.1820" />
    <PackageReference Include="RSCG_AMS" Version="2021.6.29.1820" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
  </ItemGroup>

For an ASP.NET Core application:

  <PackageReference Include="AMSWebAPI" Version="2021.6.29.1820" />
    <PackageReference Include="AMS_Base" Version="2021.6.29.1820" />
    <PackageReference Include="RSCG_AMS" Version="2021.6.29.1820" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />

and the code will be

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
    endpoints.UseAMS();
});

Now it is time to put some more data – like authors and version. I have read a lot ( and tried a lot) about  CompilerVisibleProperty and  CompilerVisibleItemMetadata ( see https://github.com/dotnet/roslyn/blob/main/docs/features/source-generators.cookbook.md  ) . However, I was unable to get the data ( Authors and Version) from there .

So this is what I was get, to read the csproj near the program:

private ItemsFromCSPROJ TryGetPropertiesFromCSPROJ(GeneratorExecutionContext context)
{
    var ret= new ItemsFromCSPROJ();
    try
    {
        var dirFolder = ((dynamic)(context.Compilation)).Options?.SourceReferenceResolver?.BaseDirectory;
        if (string.IsNullOrWhiteSpace(dirFolder))
            return ret;

        var file = Directory.GetFiles(dirFolder, "*.csproj");
        if (file.Length != 1)
            throw new ArgumentException($"find files at {dirFolder} :{file.Length} ");

        var xmldoc = new XmlDocument();
        xmldoc.Load(file[0]);
        XmlNode node;
        node = xmldoc.SelectSingleNode("//Authors");
        ret.Authors = node?.InnerText;
        node = xmldoc.SelectSingleNode("//Version");
        ret.Version = node?.InnerText;
        return ret;
    }
    catch(Exception )
    {
        //maybe log warning? 
        return ret;
    }

}

Next time I will show how it looks

The problem with RSCG is to differentiate  between the generator and the code generated. In my case , the base class should be in one nuget, the generator in other ( to can remove it from build) and the WebAPI in another.

That took me a whole day and the result is ok . Pain Points:

https://turnerj.com/blog/the-pain-points-of-csharp-source-generators 

CI action and Deploy to nuget

PackageReference Include=”Microsoft.VisualStudio.Web.CodeGeneration.Design

Now it works for WebAPI with

<PackageReference Include=”AMSWebAPI” Version=”2021.6.26.1937″ />
<PackageReference Include=”AMS_Base” Version=”2021.6.26.1937″ />
<PackageReference Include=”RSCG_AMS” Version=”2021.6.26.1937″ ReferenceOutputAssembly=”false” OutputItemType=”Analyzer” />

And I hve seen that I am not the only one to differentiate between CI servers – for example,

https://github.com/VerifyTests/DiffEngine/blob/master/src/DiffEngine/BuildServerDetector.cs

https://github.com/dotnet/Nerdbank.GitVersioning/blob/master/src/NerdBank.GitVersioning/CloudBuildServices/GitLab.cs

https://github.com/cake-build/cake/blob/develop/src/Cake.Common.Tests/Fixtures/Build/GitLabCIInfoFixture.cs

But now the work is done and you can access all AMS via web ,

app.UseEndpoints(endpoints =>
             {
                 endpoints.MapControllers();
                 endpoints.UseAMS();
             });

either to AMS/index.html , either to AMS/all .

Now it should be an easy way to see in the WebAPI. First, return the data for all software that respected that :

public static IEndpointRouteBuilder UseAMS(this IEndpointRouteBuilder endpoints)
{
    endpoints.MapGet("/ams/All", async app =>
    {
                
            var data = AboutMySoftware.AllDefinitions.Select(it => it).ToArray();
        await app.Response.WriteAsJsonAsync(data);
    });
    return endpoints;
}

Now, how can I make a small html to display things ? I can do with Razor Library – but it is too big and maybe the developers do not want to have this dependency. So I decided for https://www.nuget.org/packages/Transplator/  – fairly easy to use. And is another RSCG that converts template code into C#  code.

So now the code looks like this:

public static IEndpointRouteBuilder UseAMS(this IEndpointRouteBuilder endpoints)
{
    endpoints.MapGet("/ams/All", async app =>
    {
                
            var data = AboutMySoftware.AllDefinitions.Select(it => it).ToArray();
        await app.Response.WriteAsJsonAsync(data);
    });
    endpoints.MapGet("/ams/index", app =>
    {
        var response = new ASMTemplate().Render();
        app.Response.ContentType = "text/html";
        return app.Response.WriteAsync(response);
    });
    return endpoints;
}

where the ASMTemplate is

<style>
table {
  font-family: arial, sans-serif;
  border-collapse: collapse;
  width: 100%;
}

td {
  border: 1px solid #dddddd;
  text-align: left;
  padding: 8px;
}

th{
background-color: black;
  color: white;
  border: 1px solid #dddddd;
  text-align: left;
  padding: 8px;
  }
tr:nth-child(even) {
  background-color: #dddddd;
}
</style>

<table>
<tr>
<th>Nr</td>
<th>Component</th>
<th>Date</th>
<th>Commit</th>
<th>RepoUrl</th>
</tr>

{%~ int i=1; ~%}
{%~ foreach(var item in AMS.AboutMySoftware.AllDefinitions){ %}
<tr>
<td>{% i++ %}</td>
<td>{% item.Key %} </td>
<td>{% item.Value.DateGenerated %} </td>
<td>{% item.Value.CommitId %} </td>
<td>{% item.Value.RepoUrl %}</td>
</tr>
{% } %}
</table>

It is time now to make the nuget packages.

The problem that I face now – and must be solved  – is what to do if I have multiple assemblies / dlls / asp.net core that wants to have the About My Software listed ? It will be a name conflict between the classes – or, if we put in different namespaces, will be difficult to find them to be listed .

For the second problem – it is relatively clear – we can have a Dictionary with the key AssemblyName and the value the instance of the AMS class for this assembly.

But how to initialize ?

First thing that I thought – static constructor . In the static constructor for AMS in the each assembly class – add to the above Dictionary the instance.

But , but … the static constructor is not called unless a class instance /static method  is called. So … ?

So ModuleInitializer to the rescue:

https://docs.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices.moduleinitializerattribute?view=net-5.0

The code generated is now ( for an assembly with the name AMSConsole)

public class AboutMySoftware_AMSConsole : AboutMySoftware
{
    [System.Runtime.CompilerServices.ModuleInitializer]
    public static void Add_AboutMySoftware_AMSConsole()
    {
        AboutMySoftware.AllDefinitions.Add("AMSConsole", new AboutMySoftware_AMSConsole());
    }
    public AboutMySoftware_AMSConsole()
    {
        AssemblyName = "AMSConsole";
        DateGenerated = DateTime.ParseExact("20210624191615", "yyyyMMddHHmmss", null);
        CommitId = "not in a CI run";
        RepoUrl = "not in a CI run";
    }


}

The code to retrieve is modified like

Console.WriteLine("Show About My Software versions");
var amsAll = AboutMySoftware.AllDefinitions;
foreach (var amsKV in amsAll)
{
    var ams = amsKV.Value;

    Console.WriteLine($"{amsKV.Key}.{nameof(ams.AssemblyName)} : {ams.AssemblyName}");
    Console.WriteLine($"{amsKV.Key}.{nameof(ams.DateGenerated)} : {ams.DateGenerated}");
    Console.WriteLine($"{amsKV.Key}.{nameof(ams.CommitId)} : {ams.CommitId}");
    Console.WriteLine($"{amsKV.Key}.{nameof(ams.RepoUrl)} : {ams.RepoUrl}");
}

So far so good. Next implementation for WebAPI

Every product should have an About page . In the About page should be listed

1. The product name
2. The version  of the product
3. Link to latest version ?
4. Built date+ time
5. The commit ID
6. The authors
7. Link to the License
8. Other components version and link to about
9. Third Party notices
10. Repository  link ( github, gitlab, …)
11. Documentation Link
12. Release Notes link
13.   Maybe log file ?
14. Maybe latest errors ?
15. Maybe system.info ?

This should be available for

1. any dll – as a class
2. any console project – as Console.WriteLine
3. for any ASP.NET Core app
   1.   as a class
   2. as a  WebAPI
   3. as an HTML UI

You can see an example at https://netcoreblockly.herokuapp.com/AMS