Frank/c2

README.md

@@ -64,7 +64,7 @@ Option 1 is recommended if you can use the default worker.
 
 #### Drawbacks:
 - It takes ~10 minutes to build and pack Calamari, however you can reduce this significantly by targeting a specific runtime/framework if you don't need the rest
-    - eg `./build-local.sh -y --framework "net6.0" --runtime "linux-x64"` (note that consolidation tests will not run when targeting a specific runtime)
+    - eg `./build-local.sh -y --framework "net8.0" --runtime "linux-x64"` (note that consolidation tests will not run when targeting a specific runtime)
 - You need to restart Server for Calamari changes to take effect
 
 ### Bonus Variables!

build-local.sh

@@ -39,7 +39,7 @@ StartMessage="${Green}\
 ║  This script is intended to only be run locally and not in CI.                                 ║
 ║                                                                                                ║
 ║  If something unexpected is happening in your build or Calamari changes you may want to run    ║
-║  the full build by running ./build.ps1 and check again as something in the optimizations here  ║
+║  the full build by running ./build.sh and check again as something in the optimizations here  ║
 ║                                                                                                ║
 ║  might have caused an issue.                                                                   ║
 ╬════════════════════════════════════════════════════════════════════════════════════════════════╬\
@@ -51,7 +51,7 @@ WarningMessage="${Yellow}\
 ║ WARNING:                                               ║
 ║ Building Calamari on a non-windows machine will result ║
 ║ in Calmari and Calamari.Cloud nuget packages being     ║
-║ built against net6.0. This means that some             ║
+║ built against net8.0. This means that some             ║
 ║ steps may not work as expected because they require a  ║
 ║ .Net Framework compatible Calamari Nuget Package.      ║
 ╬════════════════════════════════════════════════════════╬\

build.ps1

@@ -55,17 +55,49 @@ else {
         }
     }
 
+    # ----- Octopus Deploy Modification -----
+    #
+    # The default behaviour of the Nuke Bootstrapper (when .NET is not already preinstalled) is
+    # to read from the global.json, then install that exact version. It doesn't roll forward.
+    # This means that if our global.json says 8.0.100, and the latest version is 8.0.200, it will
+    # always install 8.0.100 and we will not pick up any security or bug fixes that 8.0.200 carries.
+    #
+    # This means we would need to manually update our global.json file every time there is a new
+    # .NET SDK available, and then all developers would need to immediately install this on their machines.
+    #
+    # In our builds, we want the same "automatic roll-forward" behaviour that we get when we use the dotnet/sdk:8.0 docker
+    # images -- where we always get the latest patch version of the SDK without manual intervention.
+    #
+    # We achieve this with a small tweak to the Nuke bootstrapper to tell it to install the latest version from
+    # the 8.0 channel, regardless of what's in the global.json.
+
+    Remove-Variable DotNetVersion
+    $DotNetChannel = "8.0"
+    # ----- End Octopus Deploy Modification -----
+
     # Install by channel or version
     $DotNetDirectory = "$TempDirectory\dotnet-win"
     if (!(Test-Path variable:DotNetVersion)) {
-        ExecSafe { & powershell $DotNetInstallFile -InstallDir $DotNetDirectory -Channel $DotNetChannel -NoPath }
+        ExecSafe { & powershell $DotNetInstallFile -InstallDir $DotNetDirectory -Channel $DotNetChannel }
     } else {
-        ExecSafe { & powershell $DotNetInstallFile -InstallDir $DotNetDirectory -Version $DotNetVersion -NoPath }
+        ExecSafe { & powershell $DotNetInstallFile -InstallDir $DotNetDirectory -Version $DotNetVersion }
     }
     $env:DOTNET_EXE = "$DotNetDirectory\dotnet.exe"
+
+    # ----- Octopus Deploy Modification -----
+    # Update the path with the temporary dotnet exe so it can be found by anything be run out of this shell
+    $env:PATH = "$($env:Path);$DotNetDirectory"
+    # We update the global path
+    [Environment]::SetEnvironmentVariable("Path", $env:Path, [System.EnvironmentVariableTarget]::Machine)
+    Write-Output "Updating Path variable to $($env:PATH)"
+    # ----- End Octopus Deploy Modification -----
 }
 
 Write-Output "Microsoft (R) .NET Core SDK version $(& $env:DOTNET_EXE --version)"
 
 ExecSafe { & $env:DOTNET_EXE build $BuildProjectFile /nodeReuse:false /p:UseSharedCompilation=false -nologo -clp:NoSummary --verbosity quiet }
 ExecSafe { & $env:DOTNET_EXE run --project $BuildProjectFile --no-build -- $BuildArguments }
+
+
+
+

build.sh

@@ -44,15 +44,40 @@ else
             unset DOTNET_VERSION
         fi
     fi
+
+    # ----- Octopus Deploy Modification -----
+    #
+    # The default behaviour of the Nuke Bootstrapper (when .NET is not already preinstalled) is
+    # to read from the global.json, then install that exact version. It doesn't roll forward.
+    # This means that if our global.json says 8.0.100, and the latest version is 8.0.200, it will
+    # always install 8.0.100 and we will not pick up any security or bug fixes that 8.0.200 carries.
+    #
+    # This means we would need to manually update our global.json file every time there is a new
+    # .NET SDK available, and then all developers would need to immediately install this on their machines.
+    #
+    # In our builds, we want the same "automatic roll-forward" behaviour that we get when we use the dotnet/sdk:8.0 docker
+    # images -- where we always get the latest patch version of the SDK without manual intervention.
+    #
+    # We achieve this with a small tweak to the Nuke bootstrapper to tell it to install the latest version from
+    # the 8.0 channel, regardless of what's in the global.json.
+
+    unset DOTNET_VERSION
+    DOTNET_CHANNEL="8.0"
+    # ----- End Octopus Deploy Modification -----
 
     # Install by channel or version
     DOTNET_DIRECTORY="$TEMP_DIRECTORY/dotnet-unix"
     if [[ -z ${DOTNET_VERSION+x} ]]; then
-        "$DOTNET_INSTALL_FILE" --install-dir "$DOTNET_DIRECTORY" --channel "$DOTNET_CHANNEL" --no-path
+        "$DOTNET_INSTALL_FILE" --install-dir "$DOTNET_DIRECTORY" --channel "$DOTNET_CHANNEL"
     else
-        "$DOTNET_INSTALL_FILE" --install-dir "$DOTNET_DIRECTORY" --version "$DOTNET_VERSION" --no-path
+        "$DOTNET_INSTALL_FILE" --install-dir "$DOTNET_DIRECTORY" --version "$DOTNET_VERSION"
     fi
     export DOTNET_EXE="$DOTNET_DIRECTORY/dotnet"
+
+    # ----- Octopus Deploy Modification -----
+    # Update the path with the temporary dotnet exe so it can be found by anything be run out of this shell
+    export PATH="$PATH:$DOTNET_DIRECTORY"
+    # ----- End Octopus Deploy Modification -----
 fi
 
 echo "Microsoft (R) .NET Core SDK version $("$DOTNET_EXE" --version)"

build/Build.CalamariTesting.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using JetBrains.Annotations;
+using Nuke.Common;
+using Nuke.Common.Tooling;
+using Nuke.Common.Tools.DotNet;
+using Nuke.Common.CI.TeamCity;
+
+namespace Calamari.Build;
+
+partial class Build
+{
+    [PublicAPI]
+    Target PlatformAgnosticTesting =>
+        target => target
+            .Executes(async () =>
+                      {
+                          var dotnetPath = await LocateOrInstallDotNetSdk();
+
+                          CreateTestRun("Binaries/Calamari.Tests.dll")
+                              .WithDotNetPath(dotnetPath)
+                              .WithFilter("TestCategory = PlatformAgnostic")
+                              .Execute();
+                      });
+
+    [PublicAPI]
+    Target LinuxSpecificTesting =>
+        target => target
+            .Executes(async () =>
+                      {
+                          var dotnetPath = await LocateOrInstallDotNetSdk();
+
+                          CreateTestRun("Binaries/Calamari.Tests.dll")
+                              .WithDotNetPath(dotnetPath)
+                              .WithFilter("TestCategory != Windows & TestCategory != PlatformAgnostic & TestCategory != RunOnceOnWindowsAndLinux")
+                              .Execute();
+                      });
+
+    [PublicAPI]
+    Target OncePerWindowsOrLinuxTesting =>
+        target => target
+            .Executes(async () =>
+                      {
+                          var dotnetPath = await LocateOrInstallDotNetSdk();
+
+                          CreateTestRun("Binaries/Calamari.Tests.dll")
+                              .WithDotNetPath(dotnetPath)
+                              .WithFilter("(TestCategory != Windows & TestCategory != PlatformAgnostic) | TestCategory = RunOnceOnWindowsAndLinux")
+                              .Execute();
+                      });
+
+    [PublicAPI]
+    Target OncePerWindowsTesting =>
+        target => target
+            .Executes(async () =>
+                      {
+                          var dotnetPath = await LocateOrInstallDotNetSdk();
+
+                          CreateTestRun("Binaries/Calamari.Tests.dll")
+                              .WithDotNetPath(dotnetPath)
+                              .WithFilter("TestCategory != macOs & TestCategory != Nix & TestCategory != PlatformAgnostic & TestCategory != nixMacOS & TestCategory != RunOnceOnWindowsAndLinux & TestCategory != ModifiesSystemProxy")
+                              .Execute();
+                      });
+
+    [PublicAPI]
+    Target WindowsSystemProxyTesting =>
+        target => target
+            .Executes(async () =>
+                      {
+                          var dotnetPath = await LocateOrInstallDotNetSdk();
+
+                          CreateTestRun("Binaries/Calamari.Tests.dll")
+                              .WithDotNetPath(dotnetPath)
+                              .WithFilter("TestCategory = Windows & TestCategory = ModifiesSystemProxy")
+                              .Execute();
+                      });
+}

build/Build.CreateTestRun.cs

@@ -0,0 +1,13 @@
+using System.Threading.Tasks;
+
+namespace Calamari.Build;
+
+partial class Build
+{
+
+    CalamariTestRunBuilder CreateTestRun(string projectFileOrDll)
+    {
+        var outputDir = RootDirectory / "outputs";
+        return new CalamariTestRunBuilder(projectFileOrDll, outputDir);
+    }
+}