V15: Hybrid Caching (#16938)

* Update to dotnet 9 and update nuget packages * Update umbraco code version * Update Directory.Build.props Co-authored-by: Elitsa Marinovska <21998037+elit0451@users.noreply.github.com> * Include preview version in pipeline * update template projects * update global json with specific version * Update version.json to v15 * Rename TrimStart and TrimEnd to string specific * Rename to Exact * Update global.json Co-authored-by: Ronald Barendse <ronald@barend.se> * Remove includePreviewVersion * Rename to trim exact * Add new Hybridcache project * Add tests * Start implementing PublishedContent.cs * Implement repository for content * Refactor to use async everywhere * Add cache refresher * make public as needed for serialization * Use content type cache to get content type out * Refactor to use ContentCacheNode model, that goes in the memory cache * Remove content node kit as its not needed * Implement tests for ensuring caching * Implement better asserts * Implement published property * Refactor to use mapping * Rename to document tests * Update to test properties * Create more tests * Refactor mock tests into own file * Update property test * Fix published version of content * Change default cache level to elements * Refactor to always have draft * Refactor to not use PublishedModelFactory * Added tests * Added and updated tests * Fixed tests * Don't return empty object with id * More tests * Added key * Another key * Refactor CacheService to be responsible for using the hybrid cache * Use notification handler to remove deleted content from cache * Add more tests for missing functions * Implement missing methods * Remove HasContent as it pertains to routing * Fik up test * formatting * refactor variable names * Implement variant tests * Map all the published content properties * Get item out of cache first, to assert updated * Implement member cache * Add member test * Implement media cache * Implement property tests for media tests * Refactor tests to use extension method * Add more media tests * Refactor properties to no longer have element caching * Don't use property cache level * Start implementing seeding * Only seed when main * Add Immutable for performance * Implement permanent seeding of content * Implement cache settings * Implement tests for seeding * Update package version * start refactoring nurepo * Refactor so draft & published nodes are cached individually * Refactor RefreshContent to take node instead of IContent * Refactor media to also use cache nodes * Remove member from repo as it isn't cached * Refactor media to not include preview, as media has no draft * create new benchmark project * POC Integration benchmarks with custom api controllers * Start implementing content picker tests * Implement domain cache * Rework content cache to implement interface * Start implementing elements cache * Implement published snapshot service * Publish snapshot tests * Use snapshot for elements cache * Create test proving we don't clear cache when updating content picker * Clear entire elements cache * Remove properties from element cache, when content gets updated. * Rename methods to async * Refactor to use old cache interfaces instead of new ones * Remove snapshot, as it is no longer needed * Fix tests building * Refactor domaincache to not have snapshots * Delete benchmarks * Delete benchmarks * Add HybridCacheProject to Umbraco * Add comment to route value transformer * Implement is draft * remove snapshot from property * V15 updated the hybrid caching integration tests to use ContentEditingService (#16947) * Added builder extension withParentKey * Created builder with ContentEditingService * Added usage of the ContentEditingService to SETUP * Started using ContentEditingService builder in tests * Updated builder extensions * Fixed builder * Clean up * Clean up, not done * Added Ids * Remove entries from cache on delete * Fix up seeding logic * Don't register hybrid cache twice * Change seeded entry options * Update hybrid cache package * Fix up published property to work with delivery api again * Fix dependency injection to work with tests * Fix naming * Dont make caches nullable * Make content node sealed * Remove path and other unused from content node * Remove hacky 2 phase ctor * Refactor to actually set content templates * Remove umbraco context * Remove "HasBy" methods * rename property data * Delete obsolete legacy stuff * Add todo for making expiration configurable * Add todo in UmbracoContext * Add clarifying comment in content factory * Remove xml stuff from published property * Fix according to review * Make content type cache injectible * Make content type cache injectible * Rename to database cache repository * Rename to document cache * Add TODO * Refactor to async * Rename to async * Make everything async * Remove duplicate line from json schema * Move Hybrid cache project * Remove leftover file * Refactor to use keys * Refactor published content to no longer have content data, as it is on the node itself * Refactor to member to use proper content node ctor * Move tests to own folder * Add immutable objects to property and content data for performance * Make property data public * Fix member caching to be singleton * Obsolete GetContentType * Remove todo * Fix naming * Fix lots of exposed errors due to scope test * Add final scope tests * Rename to document cache service * Rename test files * Create new doc type tests * Add ignore to tests * Start implementing refresh for content type save * Clear contenttype cache when contenttype is updated * Fix test Teh contenttype is not upated unless the property is dirty * Use init for ContentSourceDto * Fix get by key in PublishedContentTypeCache * Remove ContentType from PublishedContentTypeCache when contenttype is deleted * Update to preview 7 * Fix versions * Increase timeout for sqlite integration tests * Undo timeout increase * Try and undo init change to ContentSourceDto * That wasn't it chief * Try and make DomainAndUrlsTests non NonParallelizable * Update versions * Only run cache tests on linux for now --------- Co-authored-by: Elitsa Marinovska <21998037+elit0451@users.noreply.github.com> Co-authored-by: Ronald Barendse <ronald@barend.se> Co-authored-by: Andreas Zerbst <andr317c@live.dk> Co-authored-by: Sven Geusens <sge@umbraco.dk> Co-authored-by: Andreas Zerbst <73799582+andr317c@users.noreply.github.com> Co-authored-by: nikolajlauridsen <nikolajlauridsen@protonmail.ch>
2024-09-10 00:49:18 +09:00
parent dcd6f1fbf4
commit 2704d4a34a
102 changed files with 5881 additions and 132 deletions
--- a/src/Umbraco.PublishedCache.HybridCache/Serialization/MsgPackContentNestedDataSerializer.cs
+++ b/src/Umbraco.PublishedCache.HybridCache/Serialization/MsgPackContentNestedDataSerializer.cs
@@ -0,0 +1,147 @@
+using System.Text;
+using K4os.Compression.LZ4;
+using MessagePack;
+using MessagePack.Resolvers;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.PropertyEditors;
+
+namespace Umbraco.Cms.Infrastructure.HybridCache.Serialization;
+
+/// <summary>
+///     Serializes/Deserializes <see cref="ContentCacheDataModel" /> document to the SQL Database as bytes using
+///     MessagePack
+/// </summary>
+internal sealed class MsgPackContentNestedDataSerializer : IContentCacheDataSerializer
+{
+    private readonly MessagePackSerializerOptions _options;
+    private readonly IPropertyCacheCompression _propertyOptions;
+
+    public MsgPackContentNestedDataSerializer(IPropertyCacheCompression propertyOptions)
+    {
+        _propertyOptions = propertyOptions ?? throw new ArgumentNullException(nameof(propertyOptions));
+
+        MessagePackSerializerOptions? defaultOptions = ContractlessStandardResolver.Options;
+        IFormatterResolver? resolver = CompositeResolver.Create(
+
+            // TODO: We want to be able to intern the strings for aliases when deserializing like we do for Newtonsoft but I'm unsure exactly how
+            // to do that but it would seem to be with a custom message pack resolver but I haven't quite figured out based on the docs how
+            // to do that since that is part of the int key -> string mapping operation, might have to see the source code to figure that one out.
+            // There are docs here on how to build one of these: https://github.com/neuecc/MessagePack-CSharp/blob/master/README.md#low-level-api-imessagepackformattert
+            // and there are a couple examples if you search on google for them but this will need to be a separate project.
+            // NOTE: resolver custom types first
+            // new ContentNestedDataResolver(),
+
+            // finally use standard resolver
+            defaultOptions.Resolver);
+
+        _options = defaultOptions
+            .WithResolver(resolver)
+            .WithCompression(MessagePackCompression.Lz4BlockArray)
+            .WithSecurity(MessagePackSecurity.UntrustedData);
+    }
+
+    public ContentCacheDataModel? Deserialize(IReadOnlyContentBase content, string? stringData, byte[]? byteData, bool published)
+    {
+        if (byteData != null)
+        {
+            ContentCacheDataModel? cacheModel =
+                MessagePackSerializer.Deserialize<ContentCacheDataModel>(byteData, _options);
+            Expand(content, cacheModel, published);
+            return cacheModel;
+        }
+
+        if (stringData != null)
+        {
+            // NOTE: We don't really support strings but it's possible if manually used (i.e. tests)
+            var bin = Convert.FromBase64String(stringData);
+            ContentCacheDataModel? cacheModel = MessagePackSerializer.Deserialize<ContentCacheDataModel>(bin, _options);
+            Expand(content, cacheModel, published);
+            return cacheModel;
+        }
+
+        return null;
+    }
+
+    public ContentCacheDataSerializationResult Serialize(IReadOnlyContentBase content, ContentCacheDataModel model, bool published)
+    {
+        Compress(content, model, published);
+        var bytes = MessagePackSerializer.Serialize(model, _options);
+        return new ContentCacheDataSerializationResult(null, bytes);
+    }
+
+    public string ToJson(byte[] bin)
+    {
+        var json = MessagePackSerializer.ConvertToJson(bin, _options);
+        return json;
+    }
+
+    /// <summary>
+    ///     Used during serialization to compress properties
+    /// </summary>
+    /// <param name="content"></param>
+    /// <param name="model"></param>
+    /// <param name="published"></param>
+    /// <remarks>
+    ///     This will essentially 'double compress' property data. The MsgPack data as a whole will already be compressed
+    ///     but this will go a step further and double compress property data so that it is stored in the nucache file
+    ///     as compressed bytes and therefore will exist in memory as compressed bytes. That is, until the bytes are
+    ///     read/decompressed as a string to be displayed on the front-end. This allows for potentially a significant
+    ///     memory savings but could also affect performance of first rendering pages while decompression occurs.
+    /// </remarks>
+    private void Compress(IReadOnlyContentBase content, ContentCacheDataModel model, bool published)
+    {
+        if (model.PropertyData is null)
+        {
+            return;
+        }
+
+        foreach (KeyValuePair<string, PropertyData[]> propertyAliasToData in model.PropertyData)
+        {
+            if (_propertyOptions.IsCompressed(content, propertyAliasToData.Key, published))
+            {
+                foreach (PropertyData property in propertyAliasToData.Value.Where(x =>
+                             x.Value != null && x.Value is string))
+                {
+                    if (property.Value is string propertyValue)
+                    {
+                        property.Value = LZ4Pickler.Pickle(Encoding.UTF8.GetBytes(propertyValue));
+                    }
+                }
+
+                foreach (PropertyData property in propertyAliasToData.Value.Where(x =>
+                             x.Value != null && x.Value is int intVal))
+                {
+                    property.Value = Convert.ToBoolean((int?)property.Value);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Used during deserialization to map the property data as lazy or expand the value
+    /// </summary>
+    /// <param name="content"></param>
+    /// <param name="nestedData"></param>
+    /// <param name="published"></param>
+    private void Expand(IReadOnlyContentBase content, ContentCacheDataModel nestedData, bool published)
+    {
+        if (nestedData.PropertyData is null)
+        {
+            return;
+        }
+
+        foreach (KeyValuePair<string, PropertyData[]> propertyAliasToData in nestedData.PropertyData)
+        {
+            if (_propertyOptions.IsCompressed(content, propertyAliasToData.Key, published))
+            {
+                foreach (PropertyData property in propertyAliasToData.Value.Where(x => x.Value != null))
+                {
+                    if (property.Value is byte[] byteArrayValue)
+                    {
+                        property.Value = new LazyCompressedString(byteArrayValue);
+                    }
+                }
+            }
+        }
+    }
+}