Refactor build process to support parallel builds in TeamCity

build/Build.AzureWebAppNetCoreShim.cs

@@ -0,0 +1,40 @@
+using System;
+using Calamari.Build.Utilities;
+using JetBrains.Annotations;
+
+namespace Calamari.Build;
+
+public partial class Build
+{
+    [PublicAPI]
+    Target PublishAzureWebAppNetCoreShim =>
+        _ => _.DependsOn(Clean)
+              .Executes(() =>
+                        {
+                            if (!OperatingSystem.IsWindows())
+                            {
+                                Log.Warning("Unable to build Calamari.AzureWebApp.NetCoreShim as it's a .NET 4.6.2 application and can only be compiled on Windows");
+                                return;
+                            }
+
+                            var project = Solution.GetProject("Calamari.AzureWebApp.NetCoreShim");
+                            if (project is null)
+                            {
+                                Log.Error("Failed to find Calamari.AzureWebApp.NetCoreShim project");
+                                return;
+                            }
+
+                            var publishPath = PublishDirectory / project.Name;
+
+                            //as this is the only Net 4.6.2 application left, we do a build and restore here
+                            DotNetPublish(s => s
+                                               .SetConfiguration(Configuration)
+                                               .SetProject(project.Path)
+                                               .SetFramework("net462")
+                                               .SetVersion(NugetVersion.Value)
+                                               .SetInformationalVersion(OctoVersionInfo.Value?.InformationalVersion)
+                                               .SetOutput(publishPath));
+
+                            Ci.ZipFolderAndUploadArtifact(publishPath, ArtifactsDirectory / "netcoreshim.zip");
+                        });
+}

build/Build.Consolidation.cs

@@ -0,0 +1,88 @@
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using Nuke.Common.Tooling;
+using Nuke.Common.Tools.NuGet;
+using Octopus.Calamari.ConsolidatedPackage;
+
+namespace Calamari.Build;
+
+public partial class Build
+{
+    static readonly List<string> NuGetPackagesToExcludeFromConsolidation =
+    [
+        "Octopus.Calamari.CloudAccounts",
+        "Octopus.Calamari.Common",
+        "Octopus.Calamari.ConsolidateCalamariPackages",
+        "Octopus.Calamari.ConsolidatedPackage",
+        "Octopus.Calamari.ConsolidatedPackage.Api"
+    ];
+
+    static AbsolutePath ConsolidateCalamariPackagesProject => KnownPaths.SourceDirectory / "Calamari.ConsolidateCalamariPackages.Tests" / "Calamari.ConsolidateCalamariPackages.Tests.csproj";
+
+    Target PackageConsolidatedCalamariZip =>
+        d =>
+            d.Executes(() =>
+                       {
+                           //Look for all zip files in the artifacts directory that aren't tests
+                           var artifacts = Directory.GetFiles(KnownPaths.ArtifactsDirectory, "*.zip")
+                                                    .Where(a => !NuGetPackagesToExcludeFromConsolidation.Any(a.Contains))
+                                                    .Where(a => a.Contains("Tests"));
+
+                           var packageReferences = artifacts.Select(artifactPath => (artifactPath, projectName: Path.GetFileNameWithoutExtension(artifactPath)))
+                                                            .Where(x => Solution.GetProject(x.projectName) is not null)
+                                                            .Select((x) =>
+                                                                    {
+                                                                        var (artifactPath, projectName) = x;
+                                                                        return new BuildPackageReference
+                                                                        {
+                                                                            Name = projectName,
+                                                                            Version = NugetVersion.Value,
+                                                                            PackagePath = artifactPath
+                                                                        };
+                                                                    })
+                                                            .ToList();
+
+                           var consolidatedPackageDirectory = KnownPaths.ArtifactsDirectory / "consolidated";
+                           consolidatedPackageDirectory.CreateOrCleanDirectory();
+
+                           var (result, packageFilename) = new Consolidate(Log.Logger).Execute(consolidatedPackageDirectory, packageReferences);
+
+                           if (!result)
+                               throw new Exception("Failed to consolidate calamari Packages");
+
+                           ConsolidatedPackagePath = packageFilename;
+                           Log.Information("Created consolidated package zip: {PackageFilename}", packageFilename);
+                       });
+
+    Target CalamariConsolidationVerification =>
+        d =>
+            d.DependsOn(PackageConsolidatedCalamariZip)
+             .OnlyWhenDynamic(() => string.IsNullOrEmpty(TargetRuntime), "TargetRuntime is not restricted")
+             .Executes(() =>
+                       {
+                           Environment.SetEnvironmentVariable("CONSOLIDATED_ZIP", ConsolidatedPackagePath);
+                           Environment.SetEnvironmentVariable("EXPECTED_VERSION", NugetVersion.Value);
+                           Environment.SetEnvironmentVariable("IS_WINDOWS", (OperatingSystem.IsWindows() || !IsLocalBuild).ToString());
+
+                           DotNetTest(s => s
+                                           .SetProjectFile(ConsolidateCalamariPackagesProject)
+                                           .SetConfiguration(Configuration)
+                                           .SetProcessArgumentConfigurator(args =>
+                                                                               args.Add("--logger:\"console;verbosity=detailed\"")
+                                                                                   .Add("--")
+                                                                                   .Add("NUnit.ShowInternalProperties=true")));
+                       });
+
+    [PublicAPI]
+    Target PackCalamariConsolidatedNugetPackage =>
+        d =>
+            d.DependsOn(CalamariConsolidationVerification)
+             .Executes(() =>
+                       {
+                           NuGetPack(s =>
+                                         s.SetTargetPath(BuildDirectory / "Calamari.Consolidated.nuspec")
+                                          .SetBasePath(BuildDirectory)
+                                          .SetVersion(NugetVersion.Value)
+                                          .SetOutputDirectory(ArtifactsDirectory));
+                       });
+}