Cache assemblies and wasm using content hashes

src/Components/Blazor/Build/src/Tasks/GenerateBlazorBootJson.cs

@@ -2,12 +2,14 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization.Json;
+using System.Text;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
+using ResourceHashesByNameDictionary = System.Collections.Generic.Dictionary<string, string>;
 
 namespace Microsoft.AspNetCore.Blazor.Build
 {
@@ -17,53 +19,107 @@ public class GenerateBlazorBootJson : Task
         public string AssemblyPath { get; set; }
 
         [Required]
-        public ITaskItem[] References { get; set; }
+        public ITaskItem[] Resources { get; set; }
+
+        [Required]
+        public bool DebugBuild { get; set; }
 
         [Required]
         public bool LinkerEnabled { get; set; }
 
+        [Required]
+        public bool CacheBootResources { get; set; }
+
         [Required]
         public string OutputPath { get; set; }
 
         public override bool Execute()
         {
+            using var fileStream = File.Create(OutputPath);
             var entryAssemblyName = AssemblyName.GetAssemblyName(AssemblyPath).Name;
-            var assemblies = References.Select(GetUriPath).OrderBy(c => c, StringComparer.Ordinal).ToArray();
 
-            using var fileStream = File.Create(OutputPath);
-            WriteBootJson(fileStream, entryAssemblyName, assemblies, LinkerEnabled);
+            try
+            {
+                WriteBootJson(fileStream, entryAssemblyName);
+            }
+            catch (Exception ex)
+            {
+                Log.LogErrorFromException(ex);
+            }
 
-            return true;
+            return !Log.HasLoggedErrors;
+        }
 
-            static string GetUriPath(ITaskItem item)
+        // Internal for tests
+        internal void WriteBootJson(Stream output, string entryAssemblyName)
+        {
+            var result = new BootJsonData
             {
-                var outputPath = item.GetMetadata("RelativeOutputPath");
-                if (string.IsNullOrEmpty(outputPath))
+                entryAssembly = entryAssemblyName,
+                cacheBootResources = CacheBootResources,
+                debugBuild = DebugBuild,
+                linkerEnabled = LinkerEnabled,
+                resources = new Dictionary<ResourceType, ResourceHashesByNameDictionary>()
+            };
+
+            // Build a two-level dictionary of the form:
+            // - BootResourceType (e.g., "assembly")
+            //   - UriPath (e.g., "System.Text.Json.dll")
+            //     - ContentHash (e.g., "4548fa2e9cf52986")
+            if (Resources != null)
+            {
+                foreach (var resource in Resources)
                 {
-                    outputPath = Path.GetFileName(item.ItemSpec);
-                }
+                    var resourceTypeMetadata = resource.GetMetadata("BootResourceType");
+                    if (!Enum.TryParse<ResourceType>(resourceTypeMetadata, out var resourceType))
+                    {
+                        throw new NotSupportedException($"Unsupported BootResourceType metadata value: {resourceTypeMetadata}");
+                    }
 
-                return outputPath.Replace('\\', '/');
+                    if (!result.resources.TryGetValue(resourceType, out var resourceList))
+                    {
+                        resourceList = new ResourceHashesByNameDictionary();
+                        result.resources.Add(resourceType, resourceList);
+                    }
+
+                    var resourceFileRelativePath = GetResourceFileRelativePath(resource);
+                    if (!resourceList.ContainsKey(resourceFileRelativePath))
+                    {
+                        resourceList.Add(resourceFileRelativePath, $"sha256-{resource.GetMetadata("FileHash")}");
+                    }
+                }
             }
+
+            var serializer = new DataContractJsonSerializer(typeof(BootJsonData), new DataContractJsonSerializerSettings
+            {
+                UseSimpleDictionaryFormat = true
+            });
+
+            using var writer = JsonReaderWriterFactory.CreateJsonWriter(output, Encoding.UTF8, ownsStream: false, indent: true);
+            serializer.WriteObject(writer, result);
         }
 
-        internal static void WriteBootJson(Stream stream, string entryAssemblyName, string[] assemblies, bool linkerEnabled)
+        private static string GetResourceFileRelativePath(ITaskItem item)
         {
-            var data = new BootJsonData
+            // The build targets use RelativeOutputPath in the case of satellite assemblies, which
+            // will have relative paths like "fr\\SomeAssembly.resources.dll". If RelativeOutputPath
+            // is specified, we want to use all of it.
+            var outputPath = item.GetMetadata("RelativeOutputPath");
+
+            if (string.IsNullOrEmpty(outputPath))
             {
-                entryAssembly = entryAssemblyName,
-                assemblies = assemblies,
-                linkerEnabled = linkerEnabled,
-            };
+                // If RelativeOutputPath was not specified, we assume the item will be placed at the
+                // root of whatever directory is used for its resource type (e.g., assemblies go in _bin)
+                outputPath = Path.GetFileName(item.ItemSpec);
+            }
 
-            var serializer = new DataContractJsonSerializer(typeof(BootJsonData));
-            serializer.WriteObject(stream, data);
+            return outputPath.Replace('\\', '/');
         }
 
+#pragma warning disable IDE1006 // Naming Styles
         /// <summary>
         /// Defines the structure of a Blazor boot JSON file
         /// </summary>
-#pragma warning disable IDE1006 // Naming Styles
         public class BootJsonData
         {
             /// <summary>
@@ -72,15 +128,39 @@ public class BootJsonData
             public string entryAssembly { get; set; }
 
             /// <summary>
-            /// Gets the closure of assemblies to be loaded by Blazor WASM. This includes the application entry assembly.
+            /// Gets the set of resources needed to boot the application. This includes the transitive
+            /// closure of .NET assemblies (including the entrypoint assembly), the dotnet.wasm file,
+            /// and any PDBs to be loaded.
+            ///
+            /// Within <see cref="ResourceHashesByNameDictionary"/>, dictionary keys are resource names,
+            /// and values are SHA-256 hashes formatted in prefixed base-64 style (e.g., 'sha256-abcdefg...')
+            /// as used for subresource integrity checking.
             /// </summary>
-            public string[] assemblies { get; set; }
+            public Dictionary<ResourceType, ResourceHashesByNameDictionary> resources { get; set; }
+
+            /// <summary>
+            /// Gets a value that determines whether to enable caching of the <see cref="resources"/>
+            /// inside a CacheStorage instance within the browser.
+            /// </summary>
+            public bool cacheBootResources { get; set; }
+
+            /// <summary>
+            /// Gets a value that determines if this is a debug build.
+            /// </summary>
+            public bool debugBuild { get; set; }
 
             /// <summary>
             /// Gets a value that determines if the linker is enabled.
             /// </summary>
             public bool linkerEnabled { get; set; }
         }
+
+        public enum ResourceType
+        {
+            assembly,
+            pdb,
+            wasm
+        }
 #pragma warning restore IDE1006 // Naming Styles
     }
 }

src/Components/Blazor/Build/src/targets/Blazor.MonoRuntime.targets

@@ -52,26 +52,6 @@
   <Target
     Name="PrepareBlazorOutputs"
     DependsOnTargets="_ResolveBlazorInputs;_ResolveBlazorOutputs;_GenerateBlazorBootJson">
-
-    <ItemGroup>
-      <MonoWasmFile Include="$(DotNetWebAssemblyRuntimePath)*" />
-      <BlazorJSFile Include="$(BlazorJSPath)" />
-      <BlazorJSFile Include="$(BlazorJSMapPath)" Condition="Exists('$(BlazorJSMapPath)')" />
-
-      <BlazorOutputWithTargetPath Include="@(MonoWasmFile)">
-        <TargetOutputPath>$(BlazorRuntimeWasmOutputPath)%(FileName)%(Extension)</TargetOutputPath>
-      </BlazorOutputWithTargetPath>
-      <BlazorOutputWithTargetPath Include="@(BlazorJSFile)">
-        <TargetOutputPath>$(BaseBlazorRuntimeOutputPath)%(FileName)%(Extension)</TargetOutputPath>
-      </BlazorOutputWithTargetPath>
-    </ItemGroup>
-
-    <ItemGroup Label="Static content supplied by NuGet packages">
-      <_BlazorPackageContentOutput Include="@(BlazorPackageContentFile)" Condition="%(SourcePackage) != ''">
-        <TargetOutputPath>$(BaseBlazorPackageContentOutputPath)%(SourcePackage)\%(RecursiveDir)\%(Filename)%(Extension)</TargetOutputPath>
-      </_BlazorPackageContentOutput>
-      <BlazorOutputWithTargetPath Include="@(_BlazorPackageContentOutput)" />
-    </ItemGroup>
   </Target>
 
   <Target Name="_ResolveBlazorInputs" DependsOnTargets="ResolveReferences;ResolveRuntimePackAssets">
@@ -128,6 +108,11 @@
       Message="Unrecongnized value for BlazorLinkOnBuild: '$(BlazorLinkOnBuild)'. Valid values are 'true' or 'false'."
       Condition="'$(BlazorLinkOnBuild)' != 'true' AND '$(BlazorLinkOnBuild)' != 'false'" />
 
+    <!--
+      These are the items calculated as the closure of the runtime assemblies, either by calling the linker
+      or by calling our custom ResolveBlazorRuntimeDependencies task if the linker was disabled. Other than
+      satellite assemblies, this should include all assemblies needed to run the application.
+    -->
     <ItemGroup>
       <!--
         ReferenceCopyLocalPaths includes all files that are part of the build out with CopyLocalLockFileAssemblies on.
@@ -146,6 +131,49 @@
         <BlazorRuntimeFile>true</BlazorRuntimeFile>
         <TargetOutputPath>$(BlazorRuntimeBinOutputPath)%(FileName)%(Extension)</TargetOutputPath>
         <RelativeOutputPath>%(FileName)%(Extension)</RelativeOutputPath>
+      </BlazorOutputWithTargetPath>      
+    </ItemGroup>
+
+    <!--
+      We need to know at build time (not publish time) whether or not to include pdbs in the
+      blazor.boot.json file, so this is controlled by the BlazorEnableDebugging flag, whose
+      default value is determined by the build configuration.
+    -->
+    <ItemGroup Condition="'$(BlazorEnableDebugging)' != 'true'">
+      <BlazorOutputWithTargetPath Remove="@(BlazorOutputWithTargetPath)" Condition="'%(Extension)' == '.pdb'" />
+    </ItemGroup>
+
+    <!--
+      The following itemgroup attempts to extend the set to include satellite assemblies.
+      The mechanism behind this (or whether it's correct) is a bit unclear so
+      https://github.com/dotnet/aspnetcore/issues/18951 tracks the need for follow-up.
+    -->
+    <ItemGroup>
+      <!--
+          ReferenceCopyLocalPaths includes all files that are part of the build out with CopyLocalLockFileAssemblies on.
+          Remove assemblies that are inputs to calculating the assembly closure. Instead use the resolved outputs, since it is the minimal set.
+         -->
+      <_BlazorCopyLocalPaths Include="@(ReferenceCopyLocalPaths)" Condition="'%(Extension)' == '.dll'" />
+      <_BlazorCopyLocalPaths Remove="@(_BlazorManagedRuntimeAssemby)" Condition="'%(Extension)' == '.dll'" />
+
+      <BlazorOutputWithTargetPath Include="@(_BlazorCopyLocalPaths)">
+        <BlazorRuntimeFile>true</BlazorRuntimeFile>
+        <TargetOutputPath>$(BlazorRuntimeBinOutputPath)%(_BlazorCopyLocalPaths.DestinationSubDirectory)%(FileName)%(Extension)</TargetOutputPath>
+        <RelativeOutputPath>%(_BlazorCopyLocalPaths.DestinationSubDirectory)%(FileName)%(Extension)</RelativeOutputPath>
+      </BlazorOutputWithTargetPath>
+    </ItemGroup>
+
+    <ItemGroup>
+      <MonoWasmFile Include="$(DotNetWebAssemblyRuntimePath)*" />
+      <BlazorJSFile Include="$(BlazorJSPath)" />
+      <BlazorJSFile Include="$(BlazorJSMapPath)" Condition="Exists('$(BlazorJSMapPath)')" />
+
+      <BlazorOutputWithTargetPath Include="@(MonoWasmFile)">
+        <TargetOutputPath>$(BlazorRuntimeWasmOutputPath)%(FileName)%(Extension)</TargetOutputPath>
+        <BlazorRuntimeFile>true</BlazorRuntimeFile>
+      </BlazorOutputWithTargetPath>
+      <BlazorOutputWithTargetPath Include="@(BlazorJSFile)">
+        <TargetOutputPath>$(BaseBlazorRuntimeOutputPath)%(FileName)%(Extension)</TargetOutputPath>
       </BlazorOutputWithTargetPath>
     </ItemGroup>
   </Target>
@@ -267,7 +295,7 @@
 
     <ItemGroup>
       <_LinkerResult Include="$(BlazorIntermediateLinkerOutputPath)*.dll" />
-      <_LinkerResult Include="$(BlazorIntermediateLinkerOutputPath)*.pdb" Condition="'$(BlazorEnableDebugging)' == 'true'" />
+      <_LinkerResult Include="$(BlazorIntermediateLinkerOutputPath)*.pdb" />
     </ItemGroup>
 
     <WriteLinesToFile File="$(_BlazorLinkerOutputCache)" Lines="@(_LinkerResult)" Overwrite="true" />
@@ -318,13 +346,27 @@
     Inputs="$(MSBuildAllProjects);@(BlazorOutputWithTargetPath)"
     Outputs="$(BlazorBootJsonIntermediateOutputPath)">
     <ItemGroup>
-      <_BlazorRuntimeFile Include="@(BlazorOutputWithTargetPath->WithMetadataValue('BlazorRuntimeFile', 'true'))" />
+      <_BlazorBootResource Include="@(BlazorOutputWithTargetPath->WithMetadataValue('BlazorRuntimeFile', 'true'))" />
+      <_BlazorBootResource BootResourceType="assembly" Condition="'%(Extension)' == '.dll'" />
+      <_BlazorBootResource BootResourceType="pdb" Condition="'%(Extension)' == '.pdb'" />
+      <_BlazorBootResource BootResourceType="wasm" Condition="'%(Extension)' == '.wasm'" />
     </ItemGroup>
 
+    <GetFileHash Files="@(_BlazorBootResource->HasMetadata('BootResourceType'))" Algorithm="SHA256" HashEncoding="base64">
+      <Output TaskParameter="Items" ItemName="_BlazorBootResourceWithHash" />
+    </GetFileHash>
+
+    <PropertyGroup>
+      <_IsDebugBuild>false</_IsDebugBuild>
+      <_IsDebugBuild Condition="'$(Configuration)' == 'Debug'">true</_IsDebugBuild>
+      <BlazorCacheBootResources Condition="'$(BlazorCacheBootResources)' == ''">true</BlazorCacheBootResources>
+    </PropertyGroup>
     <GenerateBlazorBootJson
       AssemblyPath="@(IntermediateAssembly)"
-      References="@(_BlazorRuntimeFile)"
+      Resources="@(_BlazorBootResourceWithHash)"
+      DebugBuild="$(_IsDebugBuild)"
       LinkerEnabled="$(BlazorLinkOnBuild)"
+      CacheBootResources="$(BlazorCacheBootResources)"
       OutputPath="$(BlazorBootJsonIntermediateOutputPath)" />
 
     <ItemGroup>