V11: Fix InMemoryAuto modelsbuilder mode (#13107)
* POC of a solution that works * Add razor reference manager * Ensure the compilation options are correct * Move InMemory classes to its own namespace These are all internal, so it should be fine. * Throw proper exceptions when compilation fails * Add CheckSumValidator * Clear the ViewCompiler cache when models changed This means we no longer need the RefreshingRazorViewEngine \o/ * Remove unused constructor injection * Make UmbracoAssemblyLoadContext non internal * Add WIP * Clear the RazorViewEngine cache when generating new models This uses reflection, which isn't super nice, however, the alternative is to clone'n'own the entire RazorViewEngine, which is arguably worse * Fix circular dependency * Remove ModelsChanged event This is no longer necessary * Fix precompiled views path We need to normalize these paths to ensure they matches with the keys in _precompiledViews * Clean * Fix content tests * Add logging * Update the comment in UmbracoBuilderDependencyInjectionExtensions to reflect changes * Remove RefreshingRazorViewEngine as its no longer needed * Remove unused ViewEngine hack from DI * Fix langversion This is required since dotnet 7 is still in preview * Add modelsbuilder tests * Add more tests * fixed comment Co-authored-by: Bjarke Berg <mail@bergmania.dk>
This commit is contained in:
Mole
@@ -0,0 +1,825 @@
|
||||
using System.Collections;
|
||||
using System.Reflection;
|
||||
using System.Reflection.Emit;
|
||||
using System.Runtime.Loader;
|
||||
using System.Text;
|
||||
using System.Text.RegularExpressions;
|
||||
using Microsoft.AspNetCore.Mvc.Razor;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Microsoft.Extensions.Options;
|
||||
using Umbraco.Cms.Core;
|
||||
using Umbraco.Cms.Core.Configuration;
|
||||
using Umbraco.Cms.Core.Configuration.Models;
|
||||
using Umbraco.Cms.Core.Hosting;
|
||||
using Umbraco.Cms.Core.Logging;
|
||||
using Umbraco.Cms.Core.Models.PublishedContent;
|
||||
using Umbraco.Cms.Infrastructure.ModelsBuilder;
|
||||
using Umbraco.Cms.Infrastructure.ModelsBuilder.Building;
|
||||
using Umbraco.Extensions;
|
||||
using File = System.IO.File;
|
||||
|
||||
namespace Umbraco.Cms.Web.Common.ModelsBuilder.InMemoryAuto
|
||||
{
|
||||
internal class InMemoryModelFactory : IAutoPublishedModelFactory, IRegisteredObject, IDisposable
|
||||
{
|
||||
private static readonly Regex s_usingRegex = new Regex("^using(.*);", RegexOptions.Compiled | RegexOptions.Multiline);
|
||||
private static readonly Regex s_aattrRegex = new Regex("^\\[assembly:(.*)\\]", RegexOptions.Compiled | RegexOptions.Multiline);
|
||||
private static readonly Regex s_assemblyVersionRegex = new Regex("AssemblyVersion\\(\"[0-9]+.[0-9]+.[0-9]+.[0-9]+\"\\)", RegexOptions.Compiled);
|
||||
private static readonly string[] s_ourFiles = { "models.hash", "models.generated.cs", "all.generated.cs", "all.dll.path", "models.err", "Compiled" };
|
||||
private readonly ReaderWriterLockSlim _locker = new ReaderWriterLockSlim();
|
||||
private readonly IProfilingLogger _profilingLogger;
|
||||
private readonly ILogger<InMemoryModelFactory> _logger;
|
||||
private readonly FileSystemWatcher? _watcher;
|
||||
private readonly Lazy<UmbracoServices> _umbracoServices; // fixme: this is because of circular refs :(
|
||||
private readonly IHostingEnvironment _hostingEnvironment;
|
||||
private readonly IApplicationShutdownRegistry _hostingLifetime;
|
||||
private readonly ModelsGenerationError _errors;
|
||||
private readonly IPublishedValueFallback _publishedValueFallback;
|
||||
private readonly InMemoryAssemblyLoadContextManager _loadContextManager;
|
||||
private readonly RuntimeCompilationCacheBuster _runtimeCompilationCacheBuster;
|
||||
private readonly Lazy<string> _pureLiveDirectory = null!;
|
||||
private readonly int _debugLevel;
|
||||
private Infos _infos = new Infos { ModelInfos = null, ModelTypeMap = new Dictionary<string, Type>() };
|
||||
private volatile bool _hasModels; // volatile 'cos reading outside lock
|
||||
private bool _pendingRebuild;
|
||||
private int _ver;
|
||||
private int? _skipver;
|
||||
private RoslynCompiler? _roslynCompiler;
|
||||
private ModelsBuilderSettings _config;
|
||||
private bool _disposedValue;
|
||||
|
||||
public InMemoryModelFactory(
|
||||
Lazy<UmbracoServices> umbracoServices,
|
||||
IProfilingLogger profilingLogger,
|
||||
ILogger<InMemoryModelFactory> logger,
|
||||
IOptionsMonitor<ModelsBuilderSettings> config,
|
||||
IHostingEnvironment hostingEnvironment,
|
||||
IApplicationShutdownRegistry hostingLifetime,
|
||||
IPublishedValueFallback publishedValueFallback,
|
||||
InMemoryAssemblyLoadContextManager loadContextManager,
|
||||
RuntimeCompilationCacheBuster runtimeCompilationCacheBuster)
|
||||
{
|
||||
_umbracoServices = umbracoServices;
|
||||
_profilingLogger = profilingLogger;
|
||||
_logger = logger;
|
||||
_config = config.CurrentValue;
|
||||
_hostingEnvironment = hostingEnvironment;
|
||||
_hostingLifetime = hostingLifetime;
|
||||
_publishedValueFallback = publishedValueFallback;
|
||||
_loadContextManager = loadContextManager;
|
||||
_runtimeCompilationCacheBuster = runtimeCompilationCacheBuster;
|
||||
_errors = new ModelsGenerationError(config, _hostingEnvironment);
|
||||
_ver = 1; // zero is for when we had no version
|
||||
_skipver = -1; // nothing to skip
|
||||
|
||||
if (!hostingEnvironment.IsHosted)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
config.OnChange(x => _config = x);
|
||||
_pureLiveDirectory = new Lazy<string>(PureLiveDirectoryAbsolute);
|
||||
|
||||
if (!Directory.Exists(_pureLiveDirectory.Value))
|
||||
{
|
||||
Directory.CreateDirectory(_pureLiveDirectory.Value);
|
||||
}
|
||||
|
||||
// BEWARE! if the watcher is not properly released then for some reason the
|
||||
// BuildManager will start confusing types - using a 'registered object' here
|
||||
// though we should probably plug into Umbraco's MainDom - which is internal
|
||||
_hostingLifetime.RegisterObject(this);
|
||||
_watcher = new FileSystemWatcher(_pureLiveDirectory.Value);
|
||||
_watcher.Changed += WatcherOnChanged;
|
||||
_watcher.EnableRaisingEvents = true;
|
||||
|
||||
// get it here, this need to be fast
|
||||
_debugLevel = _config.DebugLevel;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the currently loaded Live models assembly
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Can be null
|
||||
/// </remarks>
|
||||
public Assembly? CurrentModelsAssembly { get; private set; }
|
||||
|
||||
/// <inheritdoc />
|
||||
public object SyncRoot { get; } = new object();
|
||||
|
||||
private UmbracoServices UmbracoServices => _umbracoServices.Value;
|
||||
|
||||
/// <summary>
|
||||
/// Gets the RoslynCompiler
|
||||
/// </summary>
|
||||
private RoslynCompiler RoslynCompiler
|
||||
{
|
||||
get
|
||||
{
|
||||
if (_roslynCompiler != null)
|
||||
{
|
||||
return _roslynCompiler;
|
||||
}
|
||||
|
||||
_roslynCompiler = new RoslynCompiler();
|
||||
return _roslynCompiler;
|
||||
}
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public bool Enabled => _config.ModelsMode == ModelsMode.InMemoryAuto;
|
||||
|
||||
public IPublishedElement CreateModel(IPublishedElement element)
|
||||
{
|
||||
// get models, rebuilding them if needed
|
||||
Dictionary<string, ModelInfo>? infos = EnsureModels().ModelInfos;
|
||||
if (infos == null)
|
||||
{
|
||||
return element;
|
||||
}
|
||||
|
||||
// be case-insensitive
|
||||
var contentTypeAlias = element.ContentType.Alias;
|
||||
|
||||
// lookup model constructor (else null)
|
||||
infos.TryGetValue(contentTypeAlias, out var info);
|
||||
|
||||
// create model
|
||||
return info is null || info.Ctor is null ? element : info.Ctor(element, _publishedValueFallback);
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public Type GetModelType(string? alias)
|
||||
{
|
||||
Infos infos = EnsureModels();
|
||||
|
||||
// fail fast
|
||||
if (alias is null ||
|
||||
infos.ModelInfos is null ||
|
||||
!infos.ModelInfos.TryGetValue(alias, out ModelInfo? modelInfo) ||
|
||||
modelInfo.ModelType is null)
|
||||
{
|
||||
return typeof(IPublishedElement);
|
||||
}
|
||||
|
||||
return modelInfo.ModelType;
|
||||
}
|
||||
|
||||
// this runs only once the factory is ready
|
||||
// NOT when building models
|
||||
public Type MapModelType(Type type)
|
||||
{
|
||||
Infos infos = EnsureModels();
|
||||
return ModelType.Map(type, infos.ModelTypeMap);
|
||||
}
|
||||
|
||||
// this runs only once the factory is ready
|
||||
// NOT when building models
|
||||
public IList CreateModelList(string? alias)
|
||||
{
|
||||
Infos infos = EnsureModels();
|
||||
|
||||
// fail fast
|
||||
if (alias is null || infos.ModelInfos is null || !infos.ModelInfos.TryGetValue(alias, out ModelInfo? modelInfo))
|
||||
{
|
||||
return new List<IPublishedElement>();
|
||||
}
|
||||
|
||||
Func<IList>? ctor = modelInfo.ListCtor;
|
||||
if (ctor != null)
|
||||
{
|
||||
return ctor();
|
||||
}
|
||||
|
||||
if (modelInfo.ModelType is null)
|
||||
{
|
||||
return new List<IPublishedElement>();
|
||||
}
|
||||
|
||||
Type listType = typeof(List<>).MakeGenericType(modelInfo.ModelType);
|
||||
ctor = modelInfo.ListCtor = ReflectionUtilities.EmitConstructor<Func<IList>>(declaring: listType);
|
||||
|
||||
return ctor is null ? new List<IPublishedElement>() : ctor();
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public void Reset()
|
||||
{
|
||||
if (Enabled)
|
||||
{
|
||||
ResetModels();
|
||||
}
|
||||
}
|
||||
|
||||
// tells the factory that it should build a new generation of models
|
||||
private void ResetModels()
|
||||
{
|
||||
_logger.LogDebug("Resetting models.");
|
||||
|
||||
try
|
||||
{
|
||||
_locker.EnterWriteLock();
|
||||
|
||||
_hasModels = false;
|
||||
_pendingRebuild = true;
|
||||
|
||||
if (!Directory.Exists(_pureLiveDirectory.Value))
|
||||
{
|
||||
Directory.CreateDirectory(_pureLiveDirectory.Value);
|
||||
}
|
||||
|
||||
// clear stuff
|
||||
var modelsHashFile = Path.Combine(_pureLiveDirectory.Value, "models.hash");
|
||||
var dllPathFile = Path.Combine(_pureLiveDirectory.Value, "all.dll.path");
|
||||
|
||||
if (File.Exists(dllPathFile))
|
||||
{
|
||||
File.Delete(dllPathFile);
|
||||
}
|
||||
|
||||
if (File.Exists(modelsHashFile))
|
||||
{
|
||||
File.Delete(modelsHashFile);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_locker.IsWriteLockHeld)
|
||||
{
|
||||
_locker.ExitWriteLock();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ensure that the factory is running with the lastest generation of models
|
||||
internal Infos EnsureModels()
|
||||
{
|
||||
if (_debugLevel > 0)
|
||||
{
|
||||
_logger.LogDebug("Ensuring models.");
|
||||
}
|
||||
|
||||
// don't use an upgradeable lock here because only 1 thread at a time could enter it
|
||||
try
|
||||
{
|
||||
_locker.EnterReadLock();
|
||||
if (_hasModels)
|
||||
{
|
||||
return _infos;
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_locker.IsReadLockHeld)
|
||||
{
|
||||
_locker.ExitReadLock();
|
||||
}
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
_locker.EnterUpgradeableReadLock();
|
||||
|
||||
if (_hasModels)
|
||||
{
|
||||
return _infos;
|
||||
}
|
||||
|
||||
_locker.EnterWriteLock();
|
||||
|
||||
// we don't have models,
|
||||
// either they haven't been loaded from the cache yet
|
||||
// or they have been reseted and are pending a rebuild
|
||||
using (_profilingLogger.DebugDuration<InMemoryModelFactory>("Get models.", "Got models."))
|
||||
{
|
||||
try
|
||||
{
|
||||
Assembly assembly = GetModelsAssembly(_pendingRebuild);
|
||||
|
||||
CurrentModelsAssembly = assembly;
|
||||
|
||||
/*
|
||||
* We used to use an event here, and a RefreshingRazorViewEngine to bust the caches,
|
||||
* this worked by essentially completely recreating the entire ViewEngine/ViewCompiler every time we generate models.
|
||||
* There was this note about first load:
|
||||
* NOTE: That on first load, if there is content, this will execute before the razor view engine
|
||||
* has loaded which means it hasn't yet bound to this event so there's no need to worry about if
|
||||
* it will be eagerly re-generated unnecessarily on first render. BUT we should be aware that if we
|
||||
* change this to use the event aggregator that will no longer be the case.
|
||||
*
|
||||
* Now we have our own ViewCompiler, and clear the caches more directly, however what the comment mentioned
|
||||
* is not really a big problem since this will execute before the razor view engine has loaded,
|
||||
* which means the cache will be empty already.
|
||||
*/
|
||||
_runtimeCompilationCacheBuster.BustCache();
|
||||
|
||||
IEnumerable<Type> types = assembly.ExportedTypes.Where(x => x.Inherits<PublishedContentModel>() || x.Inherits<PublishedElementModel>());
|
||||
_infos = RegisterModels(types);
|
||||
_errors.Clear();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
try
|
||||
{
|
||||
_logger.LogError(e, "Failed to build models.");
|
||||
_logger.LogWarning("Running without models."); // be explicit
|
||||
_errors.Report("Failed to build InMemory models.", e);
|
||||
}
|
||||
finally
|
||||
{
|
||||
CurrentModelsAssembly = null;
|
||||
_infos = new Infos { ModelInfos = null, ModelTypeMap = new Dictionary<string, Type>() };
|
||||
}
|
||||
}
|
||||
|
||||
// don't even try again
|
||||
_hasModels = true;
|
||||
}
|
||||
|
||||
return _infos;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_locker.IsWriteLockHeld)
|
||||
{
|
||||
_locker.ExitWriteLock();
|
||||
}
|
||||
|
||||
if (_locker.IsUpgradeableReadLockHeld)
|
||||
{
|
||||
_locker.ExitUpgradeableReadLock();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public string PureLiveDirectoryAbsolute() => _hostingEnvironment.MapPathContentRoot(Core.Constants.SystemDirectories.TempData + "/InMemoryAuto");
|
||||
|
||||
// This is NOT thread safe but it is only called from within a lock
|
||||
private Assembly ReloadAssembly(string pathToAssembly)
|
||||
{
|
||||
_loadContextManager.RenewAssemblyLoadContext();
|
||||
|
||||
// NOTE: We cannot use in-memory assemblies due to the way the razor engine works which must use
|
||||
// application parts in order to add references to it's own CSharpCompiler.
|
||||
// These parts must have real paths since that is how the references are loaded. In that
|
||||
// case we'll need to work on temp files so that the assembly isn't locked.
|
||||
|
||||
// Get a temp file path
|
||||
// NOTE: We cannot use Path.GetTempFileName(), see this issue:
|
||||
// https://github.com/dotnet/AspNetCore.Docs/issues/3589 which can cause issues, this is recommended instead
|
||||
var tempFile = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
|
||||
File.Copy(pathToAssembly, tempFile, true);
|
||||
|
||||
// Load it in
|
||||
Assembly assembly = _loadContextManager.LoadModelsAssembly(tempFile);
|
||||
|
||||
return assembly;
|
||||
}
|
||||
|
||||
// This is NOT thread safe but it is only called from within a lock
|
||||
private Assembly GetModelsAssembly(bool forceRebuild)
|
||||
{
|
||||
if (!Directory.Exists(_pureLiveDirectory.Value))
|
||||
{
|
||||
Directory.CreateDirectory(_pureLiveDirectory.Value);
|
||||
}
|
||||
|
||||
IList<TypeModel> typeModels = UmbracoServices.GetAllTypes();
|
||||
var currentHash = TypeModelHasher.Hash(typeModels);
|
||||
var modelsHashFile = Path.Combine(_pureLiveDirectory.Value, "models.hash");
|
||||
var modelsSrcFile = Path.Combine(_pureLiveDirectory.Value, "models.generated.cs");
|
||||
var projFile = Path.Combine(_pureLiveDirectory.Value, "all.generated.cs");
|
||||
var dllPathFile = Path.Combine(_pureLiveDirectory.Value, "all.dll.path");
|
||||
|
||||
// caching the generated models speeds up booting
|
||||
// currentHash hashes both the types & the user's partials
|
||||
if (!forceRebuild)
|
||||
{
|
||||
_logger.LogDebug("Looking for cached models.");
|
||||
if (File.Exists(modelsHashFile) && File.Exists(projFile))
|
||||
{
|
||||
var cachedHash = File.ReadAllText(modelsHashFile);
|
||||
if (currentHash != cachedHash)
|
||||
{
|
||||
_logger.LogDebug("Found obsolete cached models.");
|
||||
forceRebuild = true;
|
||||
}
|
||||
|
||||
// else cachedHash matches currentHash, we can try to load an existing dll
|
||||
}
|
||||
else
|
||||
{
|
||||
_logger.LogDebug("Could not find cached models.");
|
||||
forceRebuild = true;
|
||||
}
|
||||
}
|
||||
|
||||
Assembly assembly;
|
||||
if (!forceRebuild)
|
||||
{
|
||||
// try to load the dll directly (avoid rebuilding)
|
||||
//
|
||||
// ensure that the .dll file does not have a corresponding .dll.delete file
|
||||
// as that would mean the the .dll file is going to be deleted and should not
|
||||
// be re-used - that should not happen in theory, but better be safe
|
||||
if (File.Exists(dllPathFile))
|
||||
{
|
||||
var dllPath = File.ReadAllText(dllPathFile);
|
||||
|
||||
_logger.LogDebug($"Cached models dll at {dllPath}.");
|
||||
|
||||
if (File.Exists(dllPath) && !File.Exists(dllPath + ".delete"))
|
||||
{
|
||||
assembly = ReloadAssembly(dllPath);
|
||||
|
||||
ModelsBuilderAssemblyAttribute? attr = assembly.GetCustomAttribute<ModelsBuilderAssemblyAttribute>();
|
||||
if (attr != null && attr.IsInMemory && attr.SourceHash == currentHash)
|
||||
{
|
||||
// if we were to resume at that revision, then _ver would keep increasing
|
||||
// and that is probably a bad idea - so, we'll always rebuild starting at
|
||||
// ver 1, but we remember we want to skip that one - so we never end up
|
||||
// with the "same but different" version of the assembly in memory
|
||||
_skipver = assembly.GetName().Version?.Revision;
|
||||
|
||||
_logger.LogDebug("Loading cached models (dll).");
|
||||
return assembly;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Cached models dll cannot be loaded (invalid assembly).");
|
||||
}
|
||||
else if (!File.Exists(dllPath))
|
||||
{
|
||||
_logger.LogDebug("Cached models dll does not exist.");
|
||||
}
|
||||
else if (File.Exists(dllPath + ".delete"))
|
||||
{
|
||||
_logger.LogDebug("Cached models dll is marked for deletion.");
|
||||
}
|
||||
else
|
||||
{
|
||||
_logger.LogDebug("Cached models dll cannot be loaded (why?).");
|
||||
}
|
||||
}
|
||||
|
||||
// must reset the version in the file else it would keep growing
|
||||
// loading cached modules only happens when the app restarts
|
||||
var text = File.ReadAllText(projFile);
|
||||
Match match = s_assemblyVersionRegex.Match(text);
|
||||
if (match.Success)
|
||||
{
|
||||
text = text.Replace(match.Value, "AssemblyVersion(\"0.0.0." + _ver + "\")");
|
||||
File.WriteAllText(projFile, text);
|
||||
}
|
||||
|
||||
_ver++;
|
||||
try
|
||||
{
|
||||
var assemblyPath = GetOutputAssemblyPath(currentHash);
|
||||
RoslynCompiler.CompileToFile(projFile, assemblyPath);
|
||||
assembly = ReloadAssembly(assemblyPath);
|
||||
File.WriteAllText(dllPathFile, assembly.Location);
|
||||
File.WriteAllText(modelsHashFile, currentHash);
|
||||
TryDeleteUnusedAssemblies(dllPathFile);
|
||||
}
|
||||
catch
|
||||
{
|
||||
ClearOnFailingToCompile(dllPathFile, modelsHashFile, projFile);
|
||||
throw;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Loading cached models (source).");
|
||||
return assembly;
|
||||
}
|
||||
|
||||
// need to rebuild
|
||||
_logger.LogDebug("Rebuilding models.");
|
||||
|
||||
// generate code, save
|
||||
var code = GenerateModelsCode(typeModels);
|
||||
|
||||
// add extra attributes,
|
||||
// IsLive=true helps identifying Assemblies that contain live models
|
||||
// AssemblyVersion is so that we have a different version for each rebuild
|
||||
var ver = _ver == _skipver ? ++_ver : _ver;
|
||||
_ver++;
|
||||
string mbAssemblyDirective = $@"[assembly:ModelsBuilderAssembly(IsInMemory = true, SourceHash = ""{currentHash}"")]
|
||||
[assembly:System.Reflection.AssemblyVersion(""0.0.0.{ver}"")]";
|
||||
code = code.Replace("//ASSATTR", mbAssemblyDirective);
|
||||
File.WriteAllText(modelsSrcFile, code);
|
||||
|
||||
// generate proj, save
|
||||
var projFiles = new Dictionary<string, string>
|
||||
{
|
||||
{ "models.generated.cs", code },
|
||||
};
|
||||
var proj = GenerateModelsProj(projFiles);
|
||||
File.WriteAllText(projFile, proj);
|
||||
|
||||
// compile and register
|
||||
try
|
||||
{
|
||||
var assemblyPath = GetOutputAssemblyPath(currentHash);
|
||||
RoslynCompiler.CompileToFile(projFile, assemblyPath);
|
||||
assembly = ReloadAssembly(assemblyPath);
|
||||
File.WriteAllText(dllPathFile, assemblyPath);
|
||||
File.WriteAllText(modelsHashFile, currentHash);
|
||||
TryDeleteUnusedAssemblies(dllPathFile);
|
||||
}
|
||||
catch
|
||||
{
|
||||
ClearOnFailingToCompile(dllPathFile, modelsHashFile, projFile);
|
||||
throw;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Done rebuilding.");
|
||||
return assembly;
|
||||
}
|
||||
|
||||
private void TryDeleteUnusedAssemblies(string dllPathFile)
|
||||
{
|
||||
if (File.Exists(dllPathFile))
|
||||
{
|
||||
var dllPath = File.ReadAllText(dllPathFile);
|
||||
DirectoryInfo? dirInfo = new DirectoryInfo(dllPath).Parent;
|
||||
IEnumerable<FileInfo>? files = dirInfo?.GetFiles().Where(f => f.FullName != dllPath);
|
||||
if (files is null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
foreach (FileInfo file in files)
|
||||
{
|
||||
try
|
||||
{
|
||||
File.Delete(file.FullName);
|
||||
}
|
||||
catch (UnauthorizedAccessException)
|
||||
{
|
||||
// The file is in use, we'll try again next time...
|
||||
// This shouldn't happen anymore.
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private string GetOutputAssemblyPath(string currentHash)
|
||||
{
|
||||
var dirInfo = new DirectoryInfo(Path.Combine(_pureLiveDirectory.Value, "Compiled"));
|
||||
if (!dirInfo.Exists)
|
||||
{
|
||||
Directory.CreateDirectory(dirInfo.FullName);
|
||||
}
|
||||
|
||||
return Path.Combine(dirInfo.FullName, $"generated.cs{currentHash}.dll");
|
||||
}
|
||||
|
||||
|
||||
private void ClearOnFailingToCompile(string dllPathFile, string modelsHashFile, string projFile)
|
||||
{
|
||||
_logger.LogDebug("Failed to compile.");
|
||||
|
||||
// the dll file reference still points to the previous dll, which is obsolete
|
||||
// now and will be deleted by ASP.NET eventually, so better clear that reference.
|
||||
// also touch the proj file to force views to recompile - don't delete as it's
|
||||
// useful to have the source around for debugging.
|
||||
try
|
||||
{
|
||||
if (File.Exists(dllPathFile))
|
||||
{
|
||||
File.Delete(dllPathFile);
|
||||
}
|
||||
|
||||
if (File.Exists(modelsHashFile))
|
||||
{
|
||||
File.Delete(modelsHashFile);
|
||||
}
|
||||
|
||||
if (File.Exists(projFile))
|
||||
{
|
||||
File.SetLastWriteTime(projFile, DateTime.Now);
|
||||
}
|
||||
}
|
||||
catch
|
||||
{ /* enough */
|
||||
}
|
||||
}
|
||||
|
||||
private static Infos RegisterModels(IEnumerable<Type> types)
|
||||
{
|
||||
Type[] ctorArgTypes = new[] { typeof(IPublishedElement), typeof(IPublishedValueFallback) };
|
||||
var modelInfos = new Dictionary<string, ModelInfo>(StringComparer.InvariantCultureIgnoreCase);
|
||||
var map = new Dictionary<string, Type>();
|
||||
|
||||
foreach (Type type in types)
|
||||
{
|
||||
ConstructorInfo? constructor = null;
|
||||
Type? parameterType = null;
|
||||
|
||||
foreach (ConstructorInfo ctor in type.GetConstructors())
|
||||
{
|
||||
ParameterInfo[] parms = ctor.GetParameters();
|
||||
if (parms.Length == 2 && typeof(IPublishedElement).IsAssignableFrom(parms[0].ParameterType) && typeof(IPublishedValueFallback).IsAssignableFrom(parms[1].ParameterType))
|
||||
{
|
||||
if (constructor != null)
|
||||
{
|
||||
throw new InvalidOperationException($"Type {type.FullName} has more than one public constructor with one argument of type, or implementing, IPropertySet.");
|
||||
}
|
||||
|
||||
constructor = ctor;
|
||||
parameterType = parms[0].ParameterType;
|
||||
}
|
||||
}
|
||||
|
||||
if (constructor == null)
|
||||
{
|
||||
throw new InvalidOperationException($"Type {type.FullName} is missing a public constructor with one argument of type, or implementing, IPropertySet.");
|
||||
}
|
||||
|
||||
PublishedModelAttribute? attribute = type.GetCustomAttribute<PublishedModelAttribute>(false);
|
||||
var typeName = attribute == null ? type.Name : attribute.ContentTypeAlias;
|
||||
|
||||
if (modelInfos.TryGetValue(typeName, out var modelInfo))
|
||||
{
|
||||
throw new InvalidOperationException($"Both types {type.FullName} and {modelInfo.ModelType?.FullName} want to be a model type for content type with alias \"{typeName}\".");
|
||||
}
|
||||
|
||||
// TODO: use Core's ReflectionUtilities.EmitCtor !!
|
||||
// Yes .. DynamicMethod is uber slow
|
||||
// TODO: But perhaps https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.constructorbuilder?view=netcore-3.1 is better still?
|
||||
// See CtorInvokeBenchmarks
|
||||
var meth = new DynamicMethod(string.Empty, typeof(IPublishedElement), ctorArgTypes, type.Module, true);
|
||||
ILGenerator gen = meth.GetILGenerator();
|
||||
gen.Emit(OpCodes.Ldarg_0);
|
||||
gen.Emit(OpCodes.Ldarg_1);
|
||||
gen.Emit(OpCodes.Newobj, constructor);
|
||||
gen.Emit(OpCodes.Ret);
|
||||
var func = (Func<IPublishedElement, IPublishedValueFallback, IPublishedElement>)meth.CreateDelegate(typeof(Func<IPublishedElement, IPublishedValueFallback, IPublishedElement>));
|
||||
|
||||
modelInfos[typeName] = new ModelInfo { ParameterType = parameterType, Ctor = func, ModelType = type };
|
||||
map[typeName] = type;
|
||||
}
|
||||
|
||||
return new Infos { ModelInfos = modelInfos.Count > 0 ? modelInfos : null, ModelTypeMap = map };
|
||||
}
|
||||
|
||||
private string GenerateModelsCode(IList<TypeModel> typeModels)
|
||||
{
|
||||
if (!Directory.Exists(_pureLiveDirectory.Value))
|
||||
{
|
||||
Directory.CreateDirectory(_pureLiveDirectory.Value);
|
||||
}
|
||||
|
||||
foreach (var file in Directory.GetFiles(_pureLiveDirectory.Value, "*.generated.cs"))
|
||||
{
|
||||
File.Delete(file);
|
||||
}
|
||||
|
||||
var builder = new TextBuilder(_config, typeModels);
|
||||
|
||||
var codeBuilder = new StringBuilder();
|
||||
builder.Generate(codeBuilder, builder.GetModelsToGenerate());
|
||||
var code = codeBuilder.ToString();
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
private static string GenerateModelsProj(IDictionary<string, string> files)
|
||||
{
|
||||
// ideally we would generate a CSPROJ file but then we'd need a BuildProvider for csproj
|
||||
// trying to keep things simple for the time being, just write everything to one big file
|
||||
|
||||
// group all 'using' at the top of the file (else fails)
|
||||
var usings = new List<string>();
|
||||
foreach (string k in files.Keys.ToList())
|
||||
{
|
||||
files[k] = s_usingRegex.Replace(files[k], m =>
|
||||
{
|
||||
usings.Add(m.Groups[1].Value);
|
||||
return string.Empty;
|
||||
});
|
||||
}
|
||||
|
||||
// group all '[assembly:...]' at the top of the file (else fails)
|
||||
var aattrs = new List<string>();
|
||||
foreach (string k in files.Keys.ToList())
|
||||
{
|
||||
files[k] = s_aattrRegex.Replace(files[k], m =>
|
||||
{
|
||||
aattrs.Add(m.Groups[1].Value);
|
||||
return string.Empty;
|
||||
});
|
||||
}
|
||||
|
||||
var text = new StringBuilder();
|
||||
foreach (var u in usings.Distinct())
|
||||
{
|
||||
text.Append("using ");
|
||||
text.Append(u);
|
||||
text.Append(";\r\n");
|
||||
}
|
||||
|
||||
foreach (var a in aattrs)
|
||||
{
|
||||
text.Append("[assembly:");
|
||||
text.Append(a);
|
||||
text.Append("]\r\n");
|
||||
}
|
||||
|
||||
text.Append("\r\n\r\n");
|
||||
foreach (KeyValuePair<string, string> f in files)
|
||||
{
|
||||
text.Append("// FILE: ");
|
||||
text.Append(f.Key);
|
||||
text.Append("\r\n\r\n");
|
||||
text.Append(f.Value);
|
||||
text.Append("\r\n\r\n\r\n");
|
||||
}
|
||||
|
||||
text.Append("// EOF\r\n");
|
||||
|
||||
return text.ToString();
|
||||
}
|
||||
|
||||
private void WatcherOnChanged(object sender, FileSystemEventArgs args)
|
||||
{
|
||||
var changed = args.Name;
|
||||
|
||||
// don't reset when our files change because we are building!
|
||||
//
|
||||
// comment it out, and always ignore our files, because it seems that some
|
||||
// race conditions can occur on slow Cloud filesystems and then we keep
|
||||
// rebuilding
|
||||
|
||||
// if (_building && OurFiles.Contains(changed))
|
||||
// {
|
||||
// //_logger.LogInformation<InMemoryModelFactory>("Ignoring files self-changes.");
|
||||
// return;
|
||||
// }
|
||||
|
||||
// always ignore our own file changes
|
||||
if (s_ourFiles.Contains(changed))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogInformation("Detected files changes.");
|
||||
|
||||
// don't reset while being locked
|
||||
lock (SyncRoot)
|
||||
{
|
||||
ResetModels();
|
||||
}
|
||||
}
|
||||
|
||||
public void Stop(bool immediate)
|
||||
{
|
||||
Dispose();
|
||||
|
||||
_hostingLifetime.UnregisterObject(this);
|
||||
}
|
||||
|
||||
protected virtual void Dispose(bool disposing)
|
||||
{
|
||||
if (!_disposedValue)
|
||||
{
|
||||
if (disposing)
|
||||
{
|
||||
if (_watcher is not null)
|
||||
{
|
||||
_watcher.EnableRaisingEvents = false;
|
||||
_watcher.Dispose();
|
||||
}
|
||||
|
||||
_locker.Dispose();
|
||||
}
|
||||
|
||||
_disposedValue = true;
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
|
||||
Dispose(disposing: true);
|
||||
}
|
||||
|
||||
internal class Infos
|
||||
{
|
||||
public Dictionary<string, Type>? ModelTypeMap { get; set; }
|
||||
|
||||
public Dictionary<string, ModelInfo>? ModelInfos { get; set; }
|
||||
}
|
||||
|
||||
internal class ModelInfo
|
||||
{
|
||||
public Type? ParameterType { get; set; }
|
||||
|
||||
public Func<IPublishedElement, IPublishedValueFallback, IPublishedElement>? Ctor { get; set; }
|
||||
|
||||
public Type? ModelType { get; set; }
|
||||
|
||||
public Func<IList>? ListCtor { get; set; }
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user