V15: Refresh caches on load balanced environments

src/Umbraco.Core/Cache/Refreshers/Implement/ContentCacheRefresher.cs

@@ -20,6 +20,7 @@
     private readonly IDocumentNavigationQueryService _documentNavigationQueryService;
     private readonly IDocumentNavigationManagementService _documentNavigationManagementService;
     private readonly IContentService _contentService;
+    private readonly IDocumentCacheService _documentCacheService;
     private readonly IPublishStatusManagementService _publishStatusManagementService;
     private readonly IIdKeyMap _idKeyMap;
 
@@ -35,16 +36,18 @@
         IDocumentNavigationQueryService documentNavigationQueryService,
         IDocumentNavigationManagementService documentNavigationManagementService,
         IContentService contentService,
-        IPublishStatusManagementService publishStatusManagementService)
+        IPublishStatusManagementService publishStatusManagementService,
+        IDocumentCacheService documentCacheService)
         : base(appCaches, serializer, eventAggregator, factory)
     {
         _idKeyMap = idKeyMap;
         _domainService = domainService;
         _domainCacheService = domainCacheService;
         _documentUrlService = documentUrlService;
         _documentNavigationQueryService = documentNavigationQueryService;
         _documentNavigationManagementService = documentNavigationManagementService;
         _contentService = contentService;
+        _documentCacheService = documentCacheService;
         _publishStatusManagementService = publishStatusManagementService;
     }
 
@@ -107,6 +110,7 @@
             }
 
 
+            HandleMemoryCache(payload);
             HandleRouting(payload);
 
             HandleNavigation(payload);
@@ -143,6 +147,45 @@
         base.Refresh(payloads);
     }
 
+    private void HandleMemoryCache(JsonPayload payload)
+    {
+        Guid key = payload.Key ?? _idKeyMap.GetKeyForId(payload.Id, UmbracoObjectTypes.Document).Result;
+
+        if (payload.Blueprint)
+        {
+            return;
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshNode))
+        {
+            _documentCacheService.RefreshMemoryCacheAsync(key).GetAwaiter().GetResult();
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshBranch))
+        {
+            if (_documentNavigationQueryService.TryGetDescendantsKeys(key, out IEnumerable<Guid> descendantsKeys))
+            {
+                var branchKeys = descendantsKeys.ToList();
+                branchKeys.Add(key);
+
+                foreach (Guid branchKey in branchKeys)
+                {
+                    _documentCacheService.RefreshMemoryCacheAsync(branchKey).GetAwaiter().GetResult();
+                }
+            }
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshAll))
+        {
+            _documentCacheService.ClearMemoryCacheAsync(CancellationToken.None).GetAwaiter().GetResult();
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.Remove))
+        {
+            _documentCacheService.RemoveFromMemoryCacheAsync(key).GetAwaiter().GetResult();
+        }
+    }
+
     private void HandleNavigation(JsonPayload payload)
     {
 

src/Umbraco.Core/Cache/Refreshers/Implement/ContentTypeCacheRefresher.cs

@@ -3,6 +3,7 @@
 using Umbraco.Cms.Core.Models.PublishedContent;
 using Umbraco.Cms.Core.Notifications;
 using Umbraco.Cms.Core.Persistence.Repositories;
+using Umbraco.Cms.Core.PublishedCache;
 using Umbraco.Cms.Core.Serialization;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Services.Changes;
@@ -15,6 +16,9 @@
     private readonly IContentTypeCommonRepository _contentTypeCommonRepository;
     private readonly IPublishedModelFactory _publishedModelFactory;
     private readonly IPublishedContentTypeFactory _publishedContentTypeFactory;
+    private readonly IDocumentCacheService _documentCacheService;
+    private readonly IPublishedContentTypeCache _publishedContentTypeCache;
+    private readonly IMediaCacheService _mediaCacheService;
     private readonly IIdKeyMap _idKeyMap;
 
     public ContentTypeCacheRefresher(
@@ -25,13 +29,19 @@
         IEventAggregator eventAggregator,
         ICacheRefresherNotificationFactory factory,
         IPublishedModelFactory publishedModelFactory,
-        IPublishedContentTypeFactory publishedContentTypeFactory)
+        IPublishedContentTypeFactory publishedContentTypeFactory,
+        IDocumentCacheService documentCacheService,
+        IPublishedContentTypeCache publishedContentTypeCache,
+        IMediaCacheService mediaCacheService)
         : base(appCaches, serializer, eventAggregator, factory)
     {
         _idKeyMap = idKeyMap;
         _contentTypeCommonRepository = contentTypeCommonRepository;
         _publishedModelFactory = publishedModelFactory;
         _publishedContentTypeFactory = publishedContentTypeFactory;
+        _documentCacheService = documentCacheService;
+        _publishedContentTypeCache = publishedContentTypeCache;
+        _mediaCacheService = mediaCacheService;
     }
 
     #region Json
@@ -114,10 +124,16 @@
             MemberCacheRefresher.RefreshMemberTypes(AppCaches);
         }
 
-        // TODO: We need to clear the HybridCache of any content using the ContentType, but NOT the database cache here, and this should be done within the "WithSafeLiveFactoryReset" to ensure that the factory is locked in the meantime.
-        _publishedModelFactory.WithSafeLiveFactoryReset(() => { });
-
+        _publishedContentTypeCache.ClearContentTypes(payloads.Select(x => x.Id));
         _publishedContentTypeFactory.NotifyDataTypeChanges();
+        _publishedModelFactory.WithSafeLiveFactoryReset(() =>
+        {
+            IEnumerable<int> documentTypeIds = payloads.Where(x => x.ItemType == nameof(IContentType)).Select(x => x.Id);
+            IEnumerable<int> mediaTypeIds = payloads.Where(x => x.ItemType == nameof(IMediaType)).Select(x => x.Id);
+
+            _documentCacheService.RebuildMemoryCacheByContentTypeAsync(documentTypeIds);
+            _mediaCacheService.RebuildMemoryCacheByContentTypeAsync(mediaTypeIds);
+        });
 
         // now we can trigger the event
         base.Refresh(payloads);

src/Umbraco.Core/Cache/Refreshers/Implement/DataTypeCacheRefresher.cs

@@ -3,6 +3,7 @@
 using Umbraco.Cms.Core.Models.PublishedContent;
 using Umbraco.Cms.Core.Notifications;
 using Umbraco.Cms.Core.Persistence.Repositories;
+using Umbraco.Cms.Core.PublishedCache;
 using Umbraco.Cms.Core.Serialization;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Extensions;
@@ -14,6 +15,9 @@
     private readonly IIdKeyMap _idKeyMap;
     private readonly IPublishedModelFactory _publishedModelFactory;
     private readonly IPublishedContentTypeFactory _publishedContentTypeFactory;
+    private readonly IPublishedContentTypeCache _publishedContentTypeCache;
+    private readonly IDocumentCacheService _documentCacheService;
+    private readonly IMediaCacheService _mediaCacheService;
 
     public DataTypeCacheRefresher(
         AppCaches appCaches,
@@ -22,12 +26,18 @@
         IEventAggregator eventAggregator,
         ICacheRefresherNotificationFactory factory,
         IPublishedModelFactory publishedModelFactory,
-        IPublishedContentTypeFactory publishedContentTypeFactory)
+        IPublishedContentTypeFactory publishedContentTypeFactory,
+        IPublishedContentTypeCache publishedContentTypeCache,
+        IDocumentCacheService documentCacheService,
+        IMediaCacheService mediaCacheService)
         : base(appCaches, serializer, eventAggregator, factory)
     {
         _idKeyMap = idKeyMap;
         _publishedModelFactory = publishedModelFactory;
         _publishedContentTypeFactory = publishedContentTypeFactory;
+        _publishedContentTypeCache = publishedContentTypeCache;
+        _documentCacheService = documentCacheService;
+        _mediaCacheService = mediaCacheService;
     }
 
     #region Json
@@ -76,6 +86,7 @@
 
         Attempt<IAppPolicyCache?> dataTypeCache = AppCaches.IsolatedCaches.Get<IDataType>();
 
+        List<IPublishedContentType> removedContentTypes = new();
         foreach (JsonPayload payload in payloads)
         {
             _idKeyMap.ClearCache(payload.Id);
@@ -84,14 +95,25 @@
             {
                 dataTypeCache.Result?.Clear(RepositoryCacheKeys.GetKey<IDataType, int>(payload.Id));
             }
-        }
 
-        // TODO: We need to clear the HybridCache of any content using the ContentType, but NOT the database cache here, and this should be done within the "WithSafeLiveFactoryReset" to ensure that the factory is locked in the meantime.
-        _publishedModelFactory.WithSafeLiveFactoryReset(() => { });
+            removedContentTypes.AddRange(_publishedContentTypeCache.ClearByDataTypeId(payload.Id));
+        }
 
         var changedIds = payloads.Select(x => x.Id).ToArray();
         _publishedContentTypeFactory.NotifyDataTypeChanges(changedIds);
 
+        _publishedModelFactory.WithSafeLiveFactoryReset(() =>
+        {
+            IEnumerable<int> documentTypeIds = removedContentTypes
+                .Where(x => x.ItemType == PublishedItemType.Content)
+                .Select(x => x.Id);
+            _documentCacheService.RebuildMemoryCacheByContentTypeAsync(documentTypeIds).GetAwaiter().GetResult();
+
+            IEnumerable<int> mediaTypeIds = removedContentTypes
+                .Where(x => x.ItemType == PublishedItemType.Media)
+                .Select(x => x.Id);
+            _mediaCacheService.RebuildMemoryCacheByContentTypeAsync(mediaTypeIds);
+        });
         base.Refresh(payloads);
     }
 

src/Umbraco.Core/Cache/Refreshers/Implement/MediaCacheRefresher.cs

@@ -2,6 +2,7 @@
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Notifications;
 using Umbraco.Cms.Core.Persistence.Repositories;
+using Umbraco.Cms.Core.PublishedCache;
 using Umbraco.Cms.Core.Serialization;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Services.Changes;
@@ -16,6 +17,7 @@
     private readonly IMediaNavigationQueryService _mediaNavigationQueryService;
     private readonly IMediaNavigationManagementService _mediaNavigationManagementService;
     private readonly IMediaService _mediaService;
+    private readonly IMediaCacheService _mediaCacheService;
 
     public MediaCacheRefresher(
         AppCaches appCaches,
@@ -25,13 +27,15 @@
         ICacheRefresherNotificationFactory factory,
         IMediaNavigationQueryService mediaNavigationQueryService,
         IMediaNavigationManagementService mediaNavigationManagementService,
-        IMediaService mediaService)
+        IMediaService mediaService,
+        IMediaCacheService mediaCacheService)
         : base(appCaches, serializer, eventAggregator, factory)
     {
         _idKeyMap = idKeyMap;
         _mediaNavigationQueryService = mediaNavigationQueryService;
         _mediaNavigationManagementService = mediaNavigationManagementService;
         _mediaService = mediaService;
+        _mediaCacheService = mediaCacheService;
     }
 
     #region Indirect
@@ -106,6 +110,7 @@
                 }
             }
 
+            HandleMemoryCache(payload);
             HandleNavigation(payload);
         }
 
@@ -115,6 +120,41 @@
         base.Refresh(payloads);
     }
 
+    private void HandleMemoryCache(JsonPayload payload)
+    {
+        Guid key = payload.Key ?? _idKeyMap.GetKeyForId(payload.Id, UmbracoObjectTypes.Document).Result;
+
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshNode))
+        {
+            _mediaCacheService.RefreshMemoryCacheAsync(key).GetAwaiter().GetResult();
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshBranch))
+        {
+            if (_mediaNavigationQueryService.TryGetDescendantsKeys(key, out IEnumerable<Guid> descendantsKeys))
+            {
+                var branchKeys = descendantsKeys.ToList();
+                branchKeys.Add(key);
+
+                foreach (Guid branchKey in branchKeys)
+                {
+                    _mediaCacheService.RefreshMemoryCacheAsync(branchKey).GetAwaiter().GetResult();
+                }
+            }
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshAll))
+        {
+            _mediaCacheService.ClearMemoryCacheAsync(CancellationToken.None).GetAwaiter().GetResult();
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.Remove))
+        {
+            _mediaCacheService.RemoveFromMemoryCacheAsync(key).GetAwaiter().GetResult();
+        }
+    }
+
     private void HandleNavigation(JsonPayload payload)
     {
         if (payload.Key is null)

src/Umbraco.Core/Configuration/Models/NuCacheSettings.cs

@@ -19,6 +19,7 @@ public class NuCacheSettings
     /// <summary>
     ///     Gets or sets a value defining the BTree block size.
     /// </summary>
+    [Obsolete("This property is no longer used")]
     public int? BTreeBlockSize { get; set; }
 
     /// <summary>
@@ -37,8 +38,10 @@ public class NuCacheSettings
     ///     The size to use for nucache Kit batches.  Higher value means more content loaded into memory at a time.
     /// </summary>
     [DefaultValue(StaticKitBatchSize)]
+    [Obsolete("This property is no longer used")]
     public int KitBatchSize { get; set; } = StaticKitBatchSize;
 
+    [Obsolete("This property is no longer used")]
     public bool UnPublishedContentCompression { get; set; } = false;
 
     [DefaultValue(StaticUsePagedSqlQuery)]

src/Umbraco.Core/Constants-Configuration.cs

@@ -66,6 +66,7 @@ public static class Configuration
         public const string ConfigPackageManifests = ConfigPrefix + "PackageManifests";
         public const string ConfigWebhook = ConfigPrefix + "Webhook";
         public const string ConfigCache = ConfigPrefix + "Cache";
+        public const string ConfigCacheEntry = ConfigCache + ":Entry";
 
         public static class NamedOptions
         {
@@ -79,6 +80,13 @@ public static class InstallDefaultData
 
                 public const string MemberTypes = "MemberTypes";
             }
+
+            public static class CacheEntry
+            {
+                public const string Document = "Document";
+
+                public const string Media = "Media";
+            }
         }
     }
 }

src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Configuration.cs

@@ -104,6 +104,10 @@
         builder.Services.Configure<InstallDefaultDataSettings>(
             Constants.Configuration.NamedOptions.InstallDefaultData.MemberTypes,
             builder.Config.GetSection($"{Constants.Configuration.ConfigInstallDefaultData}:{Constants.Configuration.NamedOptions.InstallDefaultData.MemberTypes}"));
+        builder.Services.Configure<CacheEntrySettings>(Constants.Configuration.NamedOptions.CacheEntry.Media,
+            builder.Config.GetSection($"{Constants.Configuration.ConfigCacheEntry}:{Constants.Configuration.NamedOptions.CacheEntry.Media}"));
+        builder.Services.Configure<CacheEntrySettings>(Constants.Configuration.NamedOptions.CacheEntry.Document,
+            builder.Config.GetSection($"{Constants.Configuration.ConfigCacheEntry}:{Constants.Configuration.NamedOptions.CacheEntry.Document}"));
 
         // TODO: Remove this in V12
         // This is to make the move of the AllowEditInvariantFromNonDefault setting from SecuritySettings to ContentSettings backwards compatible

src/Umbraco.Core/Models/CacheEntrySettings.cs

@@ -0,0 +1,19 @@
+using System.ComponentModel;
+
+namespace Umbraco.Cms.Core.Models;
+
+public class CacheEntrySettings
+{
+    internal const string StaticLocalCacheDuration = "1.00:00:00";
+    internal const string StaticRemoteCacheDuration = "365.00:00:00";
+    internal const string StaticSeedCacheDuration = "365.00:00:00";
+
+    [DefaultValue(StaticLocalCacheDuration)]
+    public  TimeSpan LocalCacheDuration { get; set; } = TimeSpan.Parse(StaticLocalCacheDuration);
+
+    [DefaultValue(StaticRemoteCacheDuration)]
+    public  TimeSpan RemoteCacheDuration { get; set; } = TimeSpan.Parse(StaticRemoteCacheDuration);
+
+    [DefaultValue(StaticSeedCacheDuration)]
+    public  TimeSpan SeedCacheDuration { get; set; } = TimeSpan.Parse(StaticSeedCacheDuration);
+}

src/Umbraco.Core/Models/CacheSettings.cs

@@ -7,7 +7,6 @@ namespace Umbraco.Cms.Core.Models;
 public class CacheSettings
 {
     internal const int StaticDocumentBreadthFirstSeedCount = 100;
-
     internal const int StaticMediaBreadthFirstSeedCount = 100;
     internal const string StaticSeedCacheDuration = "365.00:00:00";
 
@@ -20,10 +19,10 @@ public class CacheSettings
     [DefaultValue(StaticDocumentBreadthFirstSeedCount)]
     public int DocumentBreadthFirstSeedCount { get; set; } = StaticDocumentBreadthFirstSeedCount;
 
-
     [DefaultValue(StaticMediaBreadthFirstSeedCount)]
     public int MediaBreadthFirstSeedCount { get; set; } = StaticDocumentBreadthFirstSeedCount;
 
+    [Obsolete("Use Cache:Entry:Document:SeedCacheDuration instead")]
     [DefaultValue(StaticSeedCacheDuration)]
     public TimeSpan SeedCacheDuration { get; set; } = TimeSpan.Parse(StaticSeedCacheDuration);
 }