diff --git a/src/Components/Web.JS/src/Boot.WebAssembly.Common.ts b/src/Components/Web.JS/src/Boot.WebAssembly.Common.ts index dde64d499d0e..b31a1c4b356f 100644 --- a/src/Components/Web.JS/src/Boot.WebAssembly.Common.ts +++ b/src/Components/Web.JS/src/Boot.WebAssembly.Common.ts @@ -97,10 +97,15 @@ async function startCore(components: RootComponentManager { dispatcher.invokeDotNetStaticMethod('Microsoft.AspNetCore.Components.WebAssembly', 'ApplyHotReloadDelta', id, metadataDelta, ilDelta, pdbDelta, updatedTypes ?? null); }; + Blazor._internal.applyHotReloadDeltas = (deltas: { moduleId: string, metadataDelta: string, ilDelta: string, pdbDelta: string, updatedTypes: number[] }[], loggingLevel: number) => { + return dispatcher.invokeDotNetStaticMethod('Microsoft.AspNetCore.Components.WebAssembly', 'ApplyHotReloadDeltas', deltas, loggingLevel); + }; + Blazor._internal.getApplyUpdateCapabilities = () => dispatcher.invokeDotNetStaticMethod('Microsoft.AspNetCore.Components.WebAssembly', 'GetApplyUpdateCapabilities'); // Configure JS interop diff --git a/src/Components/Web.JS/src/GlobalExports.ts b/src/Components/Web.JS/src/GlobalExports.ts index b285450182da..71d9b052c177 100644 --- a/src/Components/Web.JS/src/GlobalExports.ts +++ b/src/Components/Web.JS/src/GlobalExports.ts @@ -89,7 +89,11 @@ export interface IBlazor { } // APIs invoked by hot reload + + // obsolete: applyHotReload?: (id: string, metadataDelta: string, ilDelta: string, pdbDelta: string | undefined, updatedTypes?: number[]) => void; + + applyHotReloadDeltas?: (deltas: { moduleId: string, metadataDelta: string, ilDelta: string, pdbDelta: string, updatedTypes: number[] }[], loggingLevel: number) => {message: string, severity: number}[]; getApplyUpdateCapabilities?: () => string; hotReloadApplied?: () => void; } diff --git a/src/Components/WebAssembly/WebAssembly/src/HotReload/AgentMessageSeverity.cs b/src/Components/WebAssembly/WebAssembly/src/HotReload/AgentMessageSeverity.cs new file mode 100644 index 000000000000..3ab84cecde97 --- /dev/null +++ b/src/Components/WebAssembly/WebAssembly/src/HotReload/AgentMessageSeverity.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Microsoft.DotNet.HotReload; + +internal enum AgentMessageSeverity : byte +{ + Verbose = 0, + Warning = 1, + Error = 2, +} diff --git a/src/Components/WebAssembly/WebAssembly/src/HotReload/AgentReporter.cs b/src/Components/WebAssembly/WebAssembly/src/HotReload/AgentReporter.cs new file mode 100644 index 000000000000..0950dac4e387 --- /dev/null +++ b/src/Components/WebAssembly/WebAssembly/src/HotReload/AgentReporter.cs @@ -0,0 +1,30 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Linq; + +namespace Microsoft.DotNet.HotReload; + +internal sealed class AgentReporter +{ + private readonly List<(string message, AgentMessageSeverity severity)> _log = []; + + public void Report(string message, AgentMessageSeverity severity) + { + _log.Add((message, severity)); + } + + public IReadOnlyCollection<(string message, AgentMessageSeverity severity)> GetAndClearLogEntries(ResponseLoggingLevel level) + { + lock (_log) + { + var filteredLog = (level != ResponseLoggingLevel.Verbose) + ? _log.Where(static entry => entry.severity != AgentMessageSeverity.Verbose) + : _log; + + var log = filteredLog.ToArray(); + _log.Clear(); + return log; + } + } +} diff --git a/src/Components/WebAssembly/WebAssembly/src/HotReload/HotReloadAgent.cs b/src/Components/WebAssembly/WebAssembly/src/HotReload/HotReloadAgent.cs index 76606a3264e7..b2c50556be7b 100644 --- a/src/Components/WebAssembly/WebAssembly/src/HotReload/HotReloadAgent.cs +++ b/src/Components/WebAssembly/WebAssembly/src/HotReload/HotReloadAgent.cs @@ -1,230 +1,142 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -// Based on the implementation in https://raw.githubusercontent.com/dotnet/sdk/aad0424c0bfaa60c8bd136a92fd131e53d14561a/src/BuiltInTools/DotNetDeltaApplier/HotReloadAgent.cs - using System.Collections.Concurrent; +using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Linq; using System.Reflection; using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; -namespace Microsoft.Extensions.HotReload; +namespace Microsoft.DotNet.HotReload; +#if NET +[System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Hot reload is only expected to work when trimming is disabled.")] +#endif internal sealed class HotReloadAgent : IDisposable { - /// Flags for hot reload handler Types like MVC's HotReloadService. - private const DynamicallyAccessedMemberTypes HotReloadHandlerLinkerFlags = DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods; + private const string MetadataUpdaterTypeName = "System.Reflection.Metadata.MetadataUpdater"; + private const string ApplyUpdateMethodName = "ApplyUpdate"; + private const string GetCapabilitiesMethodName = "GetCapabilities"; + + private delegate void ApplyUpdateDelegate(Assembly assembly, ReadOnlySpan metadataDelta, ReadOnlySpan ilDelta, ReadOnlySpan pdbDelta); - private readonly Action _log; - private readonly AssemblyLoadEventHandler _assemblyLoad; private readonly ConcurrentDictionary> _deltas = new(); private readonly ConcurrentDictionary _appliedAssemblies = new(); - private volatile UpdateHandlerActions? _handlerActions; + private readonly ApplyUpdateDelegate _applyUpdate; + private readonly MetadataUpdateHandlerInvoker _metadataUpdateHandlerInvoker; + + public AgentReporter Reporter { get; } + public string Capabilities { get; } - public HotReloadAgent(Action log) + private HotReloadAgent(AgentReporter reporter, ApplyUpdateDelegate applyUpdate, string capabilities) { - _log = log; - _assemblyLoad = OnAssemblyLoad; - AppDomain.CurrentDomain.AssemblyLoad += _assemblyLoad; + Reporter = reporter; + _metadataUpdateHandlerInvoker = new(reporter); + _applyUpdate = applyUpdate; + Capabilities = capabilities; + + AppDomain.CurrentDomain.AssemblyLoad += OnAssemblyLoad; } - private void OnAssemblyLoad(object? _, AssemblyLoadEventArgs eventArgs) + public static bool TryCreate(AgentReporter reporter, [NotNullWhen(true)] out HotReloadAgent? agent) { - _handlerActions = null; - var loadedAssembly = eventArgs.LoadedAssembly; - var moduleId = TryGetModuleId(loadedAssembly); - if (moduleId is null) - { - return; - } - - if (_deltas.TryGetValue(moduleId.Value, out var updateDeltas) && _appliedAssemblies.TryAdd(loadedAssembly, loadedAssembly)) + GetUpdaterMethodsAndCapabilities(reporter, out var applyUpdate, out var capabilities); + if (applyUpdate != null && !string.IsNullOrEmpty(capabilities)) { - // A delta for this specific Module exists and we haven't called ApplyUpdate on this instance of Assembly as yet. - ApplyDeltas(loadedAssembly, updateDeltas); + agent = new HotReloadAgent(reporter, applyUpdate, capabilities); + return true; } - } - internal sealed class UpdateHandlerActions - { - public List> ClearCache { get; } = new(); - public List> UpdateApplication { get; } = new(); + agent = null; + return false; } - [UnconditionalSuppressMessage("Trimmer", "IL2072", - Justification = "The handlerType passed to GetHandlerActions is preserved by MetadataUpdateHandlerAttribute with DynamicallyAccessedMemberTypes.All.")] - private UpdateHandlerActions GetMetadataUpdateHandlerActions() + public void Dispose() { - // We need to execute MetadataUpdateHandlers in a well-defined order. For v1, the strategy that is used is to topologically - // sort assemblies so that handlers in a dependency are executed before the dependent (e.g. the reflection cache action - // in System.Private.CoreLib is executed before System.Text.Json clears it's own cache.) - // This would ensure that caches and updates more lower in the application stack are up to date - // before ones higher in the stack are recomputed. - var sortedAssemblies = TopologicalSort(AppDomain.CurrentDomain.GetAssemblies()); - var handlerActions = new UpdateHandlerActions(); - foreach (var assembly in sortedAssemblies) - { - foreach (var attr in assembly.GetCustomAttributesData()) - { - // Look up the attribute by name rather than by type. This would allow netstandard targeting libraries to - // define their own copy without having to cross-compile. - if (attr.AttributeType.FullName != "System.Reflection.Metadata.MetadataUpdateHandlerAttribute") - { - continue; - } - - IList ctorArgs = attr.ConstructorArguments; - if (ctorArgs.Count != 1 || - ctorArgs[0].Value is not Type handlerType) - { - _log($"'{attr}' found with invalid arguments."); - continue; - } - - GetHandlerActions(handlerActions, handlerType); - } - } - - return handlerActions; + AppDomain.CurrentDomain.AssemblyLoad -= OnAssemblyLoad; } - internal void GetHandlerActions( - UpdateHandlerActions handlerActions, - [DynamicallyAccessedMembers(HotReloadHandlerLinkerFlags)] Type handlerType) + private static void GetUpdaterMethodsAndCapabilities(AgentReporter reporter, out ApplyUpdateDelegate? applyUpdate, out string? capabilities) { - bool methodFound = false; + applyUpdate = null; + capabilities = null; - if (GetUpdateMethod(handlerType, "ClearCache") is MethodInfo clearCache) + var metadataUpdater = Type.GetType(MetadataUpdaterTypeName + ", System.Runtime.Loader", throwOnError: false); + if (metadataUpdater == null) { - handlerActions.ClearCache.Add(CreateAction(clearCache)); - methodFound = true; + reporter.Report($"Type not found: {MetadataUpdaterTypeName}", AgentMessageSeverity.Error); + return; } - if (GetUpdateMethod(handlerType, "UpdateApplication") is MethodInfo updateApplication) + var applyUpdateMethod = metadataUpdater.GetMethod(ApplyUpdateMethodName, BindingFlags.Public | BindingFlags.Static, binder: null, [typeof(Assembly), typeof(ReadOnlySpan), typeof(ReadOnlySpan), typeof(ReadOnlySpan)], modifiers: null); + if (applyUpdateMethod == null) { - handlerActions.UpdateApplication.Add(CreateAction(updateApplication)); - methodFound = true; + reporter.Report($"{MetadataUpdaterTypeName}.{ApplyUpdateMethodName} not found.", AgentMessageSeverity.Error); + return; } - if (!methodFound) + applyUpdate = (ApplyUpdateDelegate)applyUpdateMethod.CreateDelegate(typeof(ApplyUpdateDelegate)); + + var getCapabilities = metadataUpdater.GetMethod(GetCapabilitiesMethodName, BindingFlags.NonPublic | BindingFlags.Static, binder: null, Type.EmptyTypes, modifiers: null); + if (getCapabilities == null) { - _log($"No invokable methods found on metadata handler type '{handlerType}'. " + - $"Allowed methods are ClearCache, UpdateApplication"); + reporter.Report($"{MetadataUpdaterTypeName}.{GetCapabilitiesMethodName} not found.", AgentMessageSeverity.Error); + return; } - Action CreateAction(MethodInfo update) + try { - Action action = update.CreateDelegate>(); - return types => - { - try - { - action(types); - } - catch (Exception ex) - { - _log($"Exception from '{action}': {ex}"); - } - }; + capabilities = getCapabilities.Invoke(obj: null, parameters: null) as string; } - - MethodInfo? GetUpdateMethod([DynamicallyAccessedMembers(HotReloadHandlerLinkerFlags)] Type handlerType, string name) + catch (Exception e) { - if (handlerType.GetMethod(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static, new[] { typeof(Type[]) }) is MethodInfo updateMethod && - updateMethod.ReturnType == typeof(void)) - { - return updateMethod; - } - - foreach (MethodInfo method in handlerType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance)) - { - if (method.Name == name) - { - _log($"Type '{handlerType}' has method '{method}' that does not match the required signature."); - break; - } - } - - return null; + reporter.Report($"Error retrieving capabilities: {e.Message}", AgentMessageSeverity.Error); } } - internal static List TopologicalSort(Assembly[] assemblies) + private void OnAssemblyLoad(object? _, AssemblyLoadEventArgs eventArgs) { - var sortedAssemblies = new List(assemblies.Length); + _metadataUpdateHandlerInvoker.Clear(); - var visited = new HashSet(StringComparer.Ordinal); - - foreach (var assembly in assemblies) + var loadedAssembly = eventArgs.LoadedAssembly; + var moduleId = TryGetModuleId(loadedAssembly); + if (moduleId is null) { - Visit(assemblies, assembly, sortedAssemblies, visited); + return; } - [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Hot reload is only expected to work when trimming is disabled.")] - static void Visit(Assembly[] assemblies, Assembly assembly, List sortedAssemblies, HashSet visited) + if (_deltas.TryGetValue(moduleId.Value, out var updateDeltas) && _appliedAssemblies.TryAdd(loadedAssembly, loadedAssembly)) { - var assemblyIdentifier = assembly.GetName().Name!; - if (!visited.Add(assemblyIdentifier)) - { - return; - } - - foreach (var dependencyName in assembly.GetReferencedAssemblies()) - { - var dependency = Array.Find(assemblies, a => a.GetName().Name == dependencyName.Name); - if (dependency is not null) - { - Visit(assemblies, dependency, sortedAssemblies, visited); - } - } - - sortedAssemblies.Add(assembly); + // A delta for this specific Module exists and we haven't called ApplyUpdate on this instance of Assembly as yet. + ApplyDeltas(loadedAssembly, updateDeltas); } - - return sortedAssemblies; } - public void ApplyDeltas(IReadOnlyList deltas) + public void ApplyDeltas(IEnumerable deltas) { - for (var i = 0; i < deltas.Count; i++) + foreach (var delta in deltas) { - var item = deltas[i]; + Reporter.Report($"Applying delta to module {delta.ModuleId}.", AgentMessageSeverity.Verbose); + foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) { - if (TryGetModuleId(assembly) is Guid moduleId && moduleId == item.ModuleId) + if (TryGetModuleId(assembly) is Guid moduleId && moduleId == delta.ModuleId) { - MetadataUpdater.ApplyUpdate(assembly, item.MetadataDelta, item.ILDelta, item.PdbBytes ?? ReadOnlySpan.Empty); + _applyUpdate(assembly, delta.MetadataDelta, delta.ILDelta, delta.PdbDelta); } } // Additionally stash the deltas away so it may be applied to assemblies loaded later. - var cachedDeltas = _deltas.GetOrAdd(item.ModuleId, static _ => new()); - cachedDeltas.Add(item); + var cachedDeltas = _deltas.GetOrAdd(delta.ModuleId, static _ => new()); + cachedDeltas.Add(delta); } - try - { - // Defer discovering metadata updata handlers until after hot reload deltas have been applied. - // This should give enough opportunity for AppDomain.GetAssemblies() to be sufficiently populated. - _handlerActions ??= GetMetadataUpdateHandlerActions(); - var handlerActions = _handlerActions; - - Type[]? updatedTypes = GetMetadataUpdateTypes(deltas); - - handlerActions.ClearCache.ForEach(a => a(updatedTypes)); - handlerActions.UpdateApplication.ForEach(a => a(updatedTypes)); - - _log("Deltas applied."); - } - catch (Exception ex) - { - _log(ex.ToString()); - } + _metadataUpdateHandlerInvoker.Invoke(GetMetadataUpdateTypes(deltas)); } - [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Hot reload is only expected to work when trimming is disabled.")] - private static Type[] GetMetadataUpdateTypes(IReadOnlyList deltas) + private Type[] GetMetadataUpdateTypes(IEnumerable deltas) { List? types = null; @@ -236,44 +148,45 @@ private static Type[] GetMetadataUpdateTypes(IReadOnlyList deltas) continue; } - var assemblyTypes = assembly.GetTypes(); - - foreach (var updatedType in delta.UpdatedTypes ?? Array.Empty()) + foreach (var updatedType in delta.UpdatedTypes) { - var type = assemblyTypes.FirstOrDefault(t => t.MetadataToken == updatedType); - if (type != null) + // Must be a TypeDef. + Debug.Assert(MetadataTokens.EntityHandle(updatedType) is { Kind: HandleKind.TypeDefinition, IsNil: false }); + + // The type has to be in the manifest module since Hot Reload does not support multi-module assemblies: + try { + var type = assembly.ManifestModule.ResolveType(updatedType); types ??= new(); types.Add(type); } + catch (Exception e) + { + Reporter.Report($"Failed to load type 0x{updatedType:X8}: {e.Message}", AgentMessageSeverity.Warning); + } } } return types?.ToArray() ?? Type.EmptyTypes; } - public void ApplyDeltas(Assembly assembly, IReadOnlyList deltas) + private void ApplyDeltas(Assembly assembly, IReadOnlyList deltas) { try { foreach (var item in deltas) { - MetadataUpdater.ApplyUpdate(assembly, item.MetadataDelta, item.ILDelta, ReadOnlySpan.Empty); + _applyUpdate(assembly, item.MetadataDelta, item.ILDelta, item.PdbDelta); } - _log("Deltas applied."); + Reporter.Report("Deltas applied.", AgentMessageSeverity.Verbose); } catch (Exception ex) { - _log(ex.ToString()); + Reporter.Report(ex.ToString(), AgentMessageSeverity.Warning); } } - public void Dispose() - { - AppDomain.CurrentDomain.AssemblyLoad -= _assemblyLoad; - } - private static Guid? TryGetModuleId(Assembly loadedAssembly) { try diff --git a/src/Components/WebAssembly/WebAssembly/src/HotReload/MetadataUpdateHandlerInvoker.cs b/src/Components/WebAssembly/WebAssembly/src/HotReload/MetadataUpdateHandlerInvoker.cs new file mode 100644 index 000000000000..fab00eb691cd --- /dev/null +++ b/src/Components/WebAssembly/WebAssembly/src/HotReload/MetadataUpdateHandlerInvoker.cs @@ -0,0 +1,244 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; +using System.Reflection; + +namespace Microsoft.DotNet.HotReload; + +/// +/// Finds and invokes metadata update handlers. +/// +#if NET +[UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Hot reload is only expected to work when trimming is disabled.")] +[UnconditionalSuppressMessage("Trimming", "IL2070", Justification = "Hot reload is only expected to work when trimming is disabled.")] +#endif +internal sealed class MetadataUpdateHandlerInvoker(AgentReporter reporter) +{ + internal sealed class RegisteredActions(IReadOnlyList> clearCache, IReadOnlyList> updateApplication) + { + public void Invoke(Type[] updatedTypes) + { + foreach (var action in clearCache) + { + action(updatedTypes); + } + + foreach (var action in updateApplication) + { + action(updatedTypes); + } + } + + /// + /// For testing. + /// + internal IEnumerable> ClearCache => clearCache; + + /// + /// For testing. + /// + internal IEnumerable> UpdateApplication => updateApplication; + } + + private const string ClearCacheHandlerName = "ClearCache"; + private const string UpdateApplicationHandlerName = "UpdateApplication"; + + private RegisteredActions? _actions; + + /// + /// Call when a new assembly is loaded. + /// + internal void Clear() + => Interlocked.Exchange(ref _actions, null); + + /// + /// Invokes all registerd handlers. + /// + internal void Invoke(Type[] updatedTypes) + { + try + { + // Defer discovering metadata updata handlers until after hot reload deltas have been applied. + // This should give enough opportunity for AppDomain.GetAssemblies() to be sufficiently populated. + var actions = _actions; + if (actions == null) + { + Interlocked.CompareExchange(ref _actions, GetMetadataUpdateHandlerActions(), null); + actions = _actions; + } + + reporter.Report($"Invoking metadata update handlers. {updatedTypes.Length} type(s) updated.", AgentMessageSeverity.Verbose); + + actions.Invoke(updatedTypes); + + reporter.Report("Deltas applied.", AgentMessageSeverity.Verbose); + } + catch (Exception e) + { + reporter.Report(e.ToString(), AgentMessageSeverity.Warning); + } + } + + private IEnumerable GetHandlerTypes() + { + // We need to execute MetadataUpdateHandlers in a well-defined order. For v1, the strategy that is used is to topologically + // sort assemblies so that handlers in a dependency are executed before the dependent (e.g. the reflection cache action + // in System.Private.CoreLib is executed before System.Text.Json clears its own cache.) + // This would ensure that caches and updates more lower in the application stack are up to date + // before ones higher in the stack are recomputed. + var sortedAssemblies = TopologicalSort(AppDomain.CurrentDomain.GetAssemblies()); + + foreach (var assembly in sortedAssemblies) + { + foreach (var attr in TryGetCustomAttributesData(assembly)) + { + // Look up the attribute by name rather than by type. This would allow netstandard targeting libraries to + // define their own copy without having to cross-compile. + if (attr.AttributeType.FullName != "System.Reflection.Metadata.MetadataUpdateHandlerAttribute") + { + continue; + } + + IList ctorArgs = attr.ConstructorArguments; + if (ctorArgs.Count != 1 || + ctorArgs[0].Value is not Type handlerType) + { + reporter.Report($"'{attr}' found with invalid arguments.", AgentMessageSeverity.Warning); + continue; + } + + yield return handlerType; + } + } + } + + public RegisteredActions GetMetadataUpdateHandlerActions() + => GetMetadataUpdateHandlerActions(GetHandlerTypes()); + + /// + /// Internal for testing. + /// + internal RegisteredActions GetMetadataUpdateHandlerActions(IEnumerable handlerTypes) + { + var clearCacheActions = new List>(); + var updateApplicationActions = new List>(); + + foreach (var handlerType in handlerTypes) + { + bool methodFound = false; + + if (GetUpdateMethod(handlerType, ClearCacheHandlerName) is MethodInfo clearCache) + { + clearCacheActions.Add(CreateAction(clearCache)); + methodFound = true; + } + + if (GetUpdateMethod(handlerType, UpdateApplicationHandlerName) is MethodInfo updateApplication) + { + updateApplicationActions.Add(CreateAction(updateApplication)); + methodFound = true; + } + + if (!methodFound) + { + reporter.Report( + $"Expected to find a static method '{ClearCacheHandlerName}' or '{UpdateApplicationHandlerName}' on type '{handlerType.AssemblyQualifiedName}' but neither exists.", + AgentMessageSeverity.Warning); + } + } + + return new RegisteredActions(clearCacheActions, updateApplicationActions); + + Action CreateAction(MethodInfo update) + { + var action = (Action)update.CreateDelegate(typeof(Action)); + return types => + { + try + { + action(types); + } + catch (Exception ex) + { + reporter.Report($"Exception from '{action}': {ex}", AgentMessageSeverity.Warning); + } + }; + } + + MethodInfo? GetUpdateMethod(Type handlerType, string name) + { + if (handlerType.GetMethod(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static, binder: null, [typeof(Type[])], modifiers: null) is MethodInfo updateMethod && + updateMethod.ReturnType == typeof(void)) + { + return updateMethod; + } + + foreach (MethodInfo method in handlerType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance)) + { + if (method.Name == name) + { + reporter.Report($"Type '{handlerType}' has method '{method}' that does not match the required signature.", AgentMessageSeverity.Warning); + break; + } + } + + return null; + } + } + + private IList TryGetCustomAttributesData(Assembly assembly) + { + try + { + return assembly.GetCustomAttributesData(); + } + catch (Exception e) + { + // In cross-platform scenarios, such as debugging in VS through WSL, Roslyn + // runs on Windows, and the agent runs on Linux. Assemblies accessible to Windows + // may not be available or loaded on linux (such as WPF's assemblies). + // In such case, we can ignore the assemblies and continue enumerating handlers for + // the rest of the assemblies of current domain. + reporter.Report($"'{assembly.FullName}' is not loaded ({e.Message})", AgentMessageSeverity.Verbose); + return []; + } + } + + /// + /// Internal for testing. + /// + internal static List TopologicalSort(Assembly[] assemblies) + { + var sortedAssemblies = new List(assemblies.Length); + + var visited = new HashSet(StringComparer.Ordinal); + + foreach (var assembly in assemblies) + { + Visit(assemblies, assembly, sortedAssemblies, visited); + } + + static void Visit(Assembly[] assemblies, Assembly assembly, List sortedAssemblies, HashSet visited) + { + var assemblyIdentifier = assembly.GetName().Name!; + if (!visited.Add(assemblyIdentifier)) + { + return; + } + + foreach (var dependencyName in assembly.GetReferencedAssemblies()) + { + var dependency = Array.Find(assemblies, a => a.GetName().Name == dependencyName.Name); + if (dependency is not null) + { + Visit(assemblies, dependency, sortedAssemblies, visited); + } + } + + sortedAssemblies.Add(assembly); + } + + return sortedAssemblies; + } +} diff --git a/src/Components/WebAssembly/WebAssembly/src/HotReload/ResponseLoggingLevel.cs b/src/Components/WebAssembly/WebAssembly/src/HotReload/ResponseLoggingLevel.cs new file mode 100644 index 000000000000..dd05c372bf2e --- /dev/null +++ b/src/Components/WebAssembly/WebAssembly/src/HotReload/ResponseLoggingLevel.cs @@ -0,0 +1,10 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Microsoft.DotNet.HotReload; + +internal enum ResponseLoggingLevel : byte +{ + WarningsAndErrors = 0, + Verbose = 1, +} diff --git a/src/Components/WebAssembly/WebAssembly/src/HotReload/UpdateDelta.cs b/src/Components/WebAssembly/WebAssembly/src/HotReload/UpdateDelta.cs index 6b8ee89cf58f..d02b1c4d46bf 100644 --- a/src/Components/WebAssembly/WebAssembly/src/HotReload/UpdateDelta.cs +++ b/src/Components/WebAssembly/WebAssembly/src/HotReload/UpdateDelta.cs @@ -1,17 +1,13 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -namespace Microsoft.Extensions.HotReload; +namespace Microsoft.DotNet.HotReload; -internal sealed class UpdateDelta +internal readonly struct UpdateDelta(Guid moduleId, byte[] metadataDelta, byte[] ilDelta, byte[] pdbDelta, int[] updatedTypes) { - public Guid ModuleId { get; set; } - - public byte[] MetadataDelta { get; set; } = default!; - - public byte[] ILDelta { get; set; } = default!; - - public byte[]? PdbBytes { get; set; } - - public int[]? UpdatedTypes { get; set; } + public Guid ModuleId { get; } = moduleId; + public byte[] MetadataDelta { get; } = metadataDelta; + public byte[] ILDelta { get; } = ilDelta; + public byte[] PdbDelta { get; } = pdbDelta; + public int[] UpdatedTypes { get; } = updatedTypes; } diff --git a/src/Components/WebAssembly/WebAssembly/src/HotReload/WebAssemblyHotReload.cs b/src/Components/WebAssembly/WebAssembly/src/HotReload/WebAssemblyHotReload.cs index 8d3bcbd52e87..fc8eafc861f1 100644 --- a/src/Components/WebAssembly/WebAssembly/src/HotReload/WebAssemblyHotReload.cs +++ b/src/Components/WebAssembly/WebAssembly/src/HotReload/WebAssemblyHotReload.cs @@ -2,13 +2,17 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.ComponentModel; -using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.Globalization; -using System.Reflection; -using System.Runtime.InteropServices.JavaScript; -using Microsoft.Extensions.HotReload; +using System.Linq; +using System.Net.Http; +using System.Text.Json; +using Microsoft.AspNetCore.Components.WebAssembly.Services; +using Microsoft.DotNet.HotReload; using Microsoft.JSInterop; +#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member + namespace Microsoft.AspNetCore.Components.WebAssembly.HotReload; /// @@ -16,49 +20,143 @@ namespace Microsoft.AspNetCore.Components.WebAssembly.HotReload; /// code. /// [EditorBrowsable(EditorBrowsableState.Never)] +[UnconditionalSuppressMessage( + "Trimming", + "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", + Justification = "Hot Reload does not support trimming")] public static partial class WebAssemblyHotReload { - private const string BlazorHotReloadModuleName = "blazor-hotreload"; + /// + /// For framework use only. + /// + public readonly struct LogEntry + { + public string Message { get; init; } + public int Severity { get; init; } + } + + /// + /// For framework use only. + /// + internal sealed class Update + { + public int Id { get; set; } + public Delta[] Deltas { get; set; } = default!; + } - private static HotReloadAgent? _hotReloadAgent; - private static readonly UpdateDelta[] _updateDeltas = new[] + /// + /// For framework use only. + /// + public readonly struct Delta { - new UpdateDelta(), - }; + public string ModuleId { get; init; } + public byte[] MetadataDelta { get; init; } + public byte[] ILDelta { get; init; } + public byte[] PdbDelta { get; init; } + public int[] UpdatedTypes { get; init; } + } + + private static readonly AgentReporter s_reporter = new(); + private static readonly JsonSerializerOptions s_jsonSerializerOptions = new(JsonSerializerDefaults.Web); + + private static bool s_initialized; + private static HotReloadAgent? s_hotReloadAgent; internal static async Task InitializeAsync() { if (Environment.GetEnvironmentVariable("__ASPNETCORE_BROWSER_TOOLS") == "true" && OperatingSystem.IsBrowser()) { - // Attempt to read previously applied hot reload deltas if the ASP.NET Core browser tools are available (indicated by the presence of the Environment variable). - // The agent is injected in to the hosted app and can serve this script that can provide results from local-storage. - // See https://github.com/dotnet/aspnetcore/issues/37357#issuecomment-941237000 - await JSHost.ImportAsync(BlazorHotReloadModuleName, "/_framework/blazor-hotreload.js"); - await ReceiveHotReloadAsync(); + s_initialized = true; + + if (!HotReloadAgent.TryCreate(s_reporter, out var agent)) + { + return; + } + + var existingAgent = Interlocked.CompareExchange(ref s_hotReloadAgent, agent, null); + if (existingAgent != null) + { + throw new InvalidOperationException("Hot Reload agent already initialized"); + } + + await ApplyPreviousDeltasAsync(agent); + } + } + + private static async ValueTask ApplyPreviousDeltasAsync(HotReloadAgent agent) + { + string errorMessage; + + using var client = new HttpClient() + { + BaseAddress = new Uri(WebAssemblyNavigationManager.Instance.BaseUri, UriKind.Absolute) + }; + + try + { + var response = await client.GetAsync("/_framework/blazor-hotreload"); + if (response.IsSuccessStatusCode) + { + var deltasJson = await response.Content.ReadAsStringAsync(); + var updates = deltasJson != "" ? JsonSerializer.Deserialize(deltasJson, s_jsonSerializerOptions) : null; + if (updates == null) + { + s_reporter.Report($"No previous updates to apply.", AgentMessageSeverity.Verbose); + return; + } + + var i = 1; + foreach (var update in updates) + { + s_reporter.Report($"Reapplying update {i}/{updates.Length}.", AgentMessageSeverity.Verbose); + + agent.ApplyDeltas( + update.Deltas.Select(d => new UpdateDelta(Guid.Parse(d.ModuleId, CultureInfo.InvariantCulture), d.MetadataDelta, d.ILDelta, d.PdbDelta, d.UpdatedTypes))); + + i++; + } + + return; + } + + errorMessage = $"HTTP GET '/_framework/blazor-hotreload' returned {response.StatusCode}"; + } + catch (Exception e) + { + errorMessage = e.ToString(); } + + s_reporter.Report($"Failed to retrieve and apply previous deltas from the server: ${errorMessage}", AgentMessageSeverity.Error); } + private static HotReloadAgent? GetAgent() + => s_hotReloadAgent ?? (s_initialized ? throw new InvalidOperationException("Hot Reload agent not initialized") : null); + /// /// For framework use only. /// + [Obsolete("Use ApplyHotReloadDeltas instead")] [JSInvokable(nameof(ApplyHotReloadDelta))] public static void ApplyHotReloadDelta(string moduleIdString, byte[] metadataDelta, byte[] ilDelta, byte[] pdbBytes, int[]? updatedTypes) { - // Analyzer has a bug where it doesn't handle ConditionalAttribute: https://github.com/dotnet/roslyn/issues/63464 -#pragma warning disable IDE0200 // Remove unnecessary lambda expression - Interlocked.CompareExchange(ref _hotReloadAgent, new HotReloadAgent(m => Debug.WriteLine(m)), null); -#pragma warning restore IDE0200 // Remove unnecessary lambda expression + GetAgent()?.ApplyDeltas( + [new UpdateDelta(Guid.Parse(moduleIdString, CultureInfo.InvariantCulture), metadataDelta, ilDelta, pdbBytes, updatedTypes ?? [])]); + } - var moduleId = Guid.Parse(moduleIdString, CultureInfo.InvariantCulture); + /// + /// For framework use only. + /// + [JSInvokable(nameof(ApplyHotReloadDeltas))] + public static LogEntry[] ApplyHotReloadDeltas(Delta[] deltas, int loggingLevel) + { + var agent = GetAgent(); - _updateDeltas[0].ModuleId = moduleId; - _updateDeltas[0].MetadataDelta = metadataDelta; - _updateDeltas[0].ILDelta = ilDelta; - _updateDeltas[0].PdbBytes = pdbBytes; - _updateDeltas[0].UpdatedTypes = updatedTypes; + agent?.ApplyDeltas( + deltas.Select(d => new UpdateDelta(Guid.Parse(d.ModuleId, CultureInfo.InvariantCulture), d.MetadataDelta, d.ILDelta, d.PdbDelta, d.UpdatedTypes))); - _hotReloadAgent.ApplyDeltas(_updateDeltas); + return s_reporter.GetAndClearLogEntries((ResponseLoggingLevel)loggingLevel) + .Select(log => new LogEntry() { Message = log.message, Severity = (int)log.severity }).ToArray(); } /// @@ -66,15 +164,5 @@ public static void ApplyHotReloadDelta(string moduleIdString, byte[] metadataDel /// [JSInvokable(nameof(GetApplyUpdateCapabilities))] public static string GetApplyUpdateCapabilities() - { - var method = typeof(System.Reflection.Metadata.MetadataUpdater).GetMethod("GetCapabilities", BindingFlags.NonPublic | BindingFlags.Static, Type.EmptyTypes); - if (method is null) - { - return string.Empty; - } - return (string)method.Invoke(obj: null, parameters: null)!; - } - - [JSImport("receiveHotReloadAsync", BlazorHotReloadModuleName)] - private static partial Task ReceiveHotReloadAsync(); + => GetAgent()?.Capabilities ?? ""; } diff --git a/src/Components/WebAssembly/WebAssembly/src/PublicAPI.Unshipped.txt b/src/Components/WebAssembly/WebAssembly/src/PublicAPI.Unshipped.txt index 7dc5c58110bf..f9836324fe1f 100644 --- a/src/Components/WebAssembly/WebAssembly/src/PublicAPI.Unshipped.txt +++ b/src/Components/WebAssembly/WebAssembly/src/PublicAPI.Unshipped.txt @@ -1 +1,20 @@ #nullable enable +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.Delta() -> void +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.ILDelta.get -> byte[]! +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.ILDelta.init -> void +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.MetadataDelta.get -> byte[]! +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.MetadataDelta.init -> void +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.ModuleId.get -> string! +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.ModuleId.init -> void +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.PdbDelta.get -> byte[]! +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.PdbDelta.init -> void +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.UpdatedTypes.get -> int[]! +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.UpdatedTypes.init -> void +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry.LogEntry() -> void +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry.Message.get -> string! +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry.Message.init -> void +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry.Severity.get -> int +Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry.Severity.init -> void +static Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.ApplyHotReloadDeltas(Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta[]! deltas, int loggingLevel) -> Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry[]! diff --git a/src/Components/WebAssembly/WebAssembly/test/WebAssemblyHotReloadTest.cs b/src/Components/WebAssembly/WebAssembly/test/WebAssemblyHotReloadTest.cs deleted file mode 100644 index 525cb3c7ac0e..000000000000 --- a/src/Components/WebAssembly/WebAssembly/test/WebAssemblyHotReloadTest.cs +++ /dev/null @@ -1,29 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using Microsoft.AspNetCore.Components.RenderTree; -using Microsoft.Extensions.HotReload; - -namespace Microsoft.AspNetCore.Components.WebAssembly.HotReload; - -public class WebAssemblyHotReloadTest -{ - [Fact] - public void WebAssemblyHotReload_DiscoversMetadataHandlers_FromHot() - { - // Arrange - var hotReloadManager = typeof(Renderer).Assembly.GetType("Microsoft.AspNetCore.Components.HotReload.HotReloadManager"); - Assert.NotNull(hotReloadManager); - - var handlerActions = new HotReloadAgent.UpdateHandlerActions(); - var logs = new List(); - var hotReloadAgent = new HotReloadAgent(logs.Add); - - // Act - hotReloadAgent.GetHandlerActions(handlerActions, hotReloadManager); - - // Assert - Assert.Empty(handlerActions.ClearCache); - Assert.Single(handlerActions.UpdateApplication); - } -}