/// <summary>
/// Executed when the cache updates, which means we can know what the new URL is for a given document
/// </summary>
/// <param name="sender"></param>
/// <param name="cacheRefresherEventArgs"></param>
private void PageCacheRefresher_CacheUpdated(PageCacheRefresher sender, CacheRefresherEventArgs cacheRefresherEventArgs)
{
// only on master / single, not on replicas!
if (IsReplicaServer)
{
return;
}
// simply getting OldRoutes will register it in the request cache,
// so whatever we do with it, try/finally it to ensure it's cleared
try
{
foreach (var oldRoute in OldRoutes)
{
// assuming we cannot have 'CacheUpdated' for only part of the infos else we'd need
// to set a flag in 'Published' to indicate which entities have been refreshed ok
CreateRedirect(oldRoute.Key, oldRoute.Value.Item1, oldRoute.Value.Item2);
}
}
finally
{
OldRoutes.Clear();
RequestCache.ClearCacheItem(ContextKey3);
}
}
/// <summary>
/// When the page cache is refreshed, we'll check if any articulate root nodes were included in the refresh, if so we'll set a flag
/// on the current request to rebuild the routes at the end of the request
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// This will also work for load balanced scenarios since this event executes on all servers
/// </remarks>
private static void PageCacheRefresher_CacheUpdated(PageCacheRefresher sender, Umbraco.Core.Cache.CacheRefresherEventArgs e)
{
if (UmbracoContext.Current == null)
{
return;
}
switch (e.MessageType)
{
case MessageType.RefreshById:
case MessageType.RemoveById:
var item = UmbracoContext.Current.ContentCache.GetById((int)e.MessageObject);
if (item != null && item.DocumentTypeAlias.InvariantEquals("Articulate"))
{
//ensure routes are rebuilt
ApplicationContext.Current.ApplicationCache.RequestCache.GetCacheItem("articulate-refresh-routes", () => true);
}
break;
case MessageType.RefreshByInstance:
case MessageType.RemoveByInstance:
var content = e.MessageObject as IContent;
if (content == null)
{
return;
}
if (content.ContentType.Alias.InvariantEquals("Articulate"))
{
//ensure routes are rebuilt
UmbracoContext.Current.Application.ApplicationCache.RequestCache.GetCacheItem("articulate-refresh-routes", () => true);
}
break;
}
}
private void PageCacheRefresher_CacheUpdated(PageCacheRefresher sender, CacheRefresherEventArgs e)
{
if (e.MessageType == Umbraco.Core.Sync.MessageType.RefreshAll)
{
VortoUrlRouteCache.Current.StartNewCacheFile();
}
}
private void PageCacheRefresher_CacheUpdated(PageCacheRefresher sender, CacheRefresherEventArgs e)
{
if (e.MessageType == MessageType.RefreshByInstance && e.MessageObject is IContent instance)
{
GuidToIdCache.TryAdd(instance);
}
}
private static void CacheRefresherBaseOnCacheUpdated(PageCacheRefresher sender, CacheRefresherEventArgs cacheRefresherEventArgs)
{
// Do not configure if Enterspeed is not configured in Umbraco
if (EnterspeedContext.Current?.Configuration == null ||
!EnterspeedContext.Current.Configuration.IsConfigured)
{
return;
}
var umbracoHelper = UmbracoContextHelper.GetUmbracoHelper();
var jobs = new List <EnterspeedJob>();
switch (cacheRefresherEventArgs.MessageType)
{
case MessageType.RefreshById:
var refreshContent =
umbracoHelper.TypedContent((int)cacheRefresherEventArgs.MessageObject);
if (refreshContent != null)
{
var culture = refreshContent.GetCulture()?.IetfLanguageTag?.ToLowerInvariant();
var now = DateTime.UtcNow;
jobs.Add(new EnterspeedJob
{
ContentId = refreshContent.Id,
Culture = culture,
JobType = EnterspeedJobType.Publish,
State = EnterspeedJobState.Pending,
CreatedAt = now,
UpdatedAt = now,
});
}
break;
case MessageType.RefreshByInstance:
var node = umbracoHelper.TypedContent(((IContent)cacheRefresherEventArgs.MessageObject).Id);
if (node != null)
{
var culture = node.GetCulture()?.IetfLanguageTag?.ToLowerInvariant();
var now = DateTime.UtcNow;
jobs.Add(new EnterspeedJob
{
ContentId = node.Id,
Culture = culture,
JobType = EnterspeedJobType.Publish,
State = EnterspeedJobState.Pending,
CreatedAt = now,
UpdatedAt = now,
});
}
break;
}
EnqueueJobs(jobs);
}
void PageCacheRefresher_CacheUpdated(PageCacheRefresher sender, CacheRefresherEventArgs e)
{
// var a = (IContent) e.MessageObject;
// if (a.ContentType.Alias != "BlogFolder" || a.ContentType.Alias != "BlogPost")
// return;
//if(e.MessageType == MessageType.RefreshById || e.MessageType == MessageType.RefreshByInstance)
// sender.Remove(a);
}
/// <summary>
/// Content cache was updated.
/// </summary>
private void PageCacheRefresher_CacheUpdated(PageCacheRefresher sender,
CacheRefresherEventArgs e)
{
var kind = e.MessageType;
if (kind == MessageType.RefreshById || kind == MessageType.RemoveById)
{
var id = e.MessageObject as int?;
if (id.HasValue)
{
var contentService = ApplicationContext.Current.Services.ContentService;
var node = contentService.GetById(id.Value);
if (node != null)
{
HandleChangedContent(new[] { node });
}
}
}
}
private void ContentService_RepublishAll(PageCacheRefresher sender, CacheRefresherEventArgs e)
{
if (e.MessageType == MessageType.RefreshAll && AllowProcessing)
{
var contents = new Stack <Umbraco.Core.Models.IContent>();
var contentService = ApplicationContext.Current.Services.ContentService;
var found = new List <Umbraco.Core.Models.IContent>();
foreach (var content in contentService.GetChildren(Umbraco.Core.Constants.System.Root))
{
if (content.Published)
{
contents.Push(content);
}
}
while (contents.Count != 0)
{
var content = contents.Pop();
foreach (var child in contentService.GetChildren(content.Id))
{
if (child.Published)
{
contents.Push(child);
}
}
found.Add(content);
if (found.Count == BatchSize)
{
Sync(found.Select(x => x.Key), found);
found.Clear();
System.Threading.Thread.Sleep(BatchSleep);
}
}
Sync(found.Select(x => x.Key), found);
}
}
/// <summary>
/// When the page cache is refreshed, we'll check if any articulate root nodes were included in the refresh, if so we'll set a flag
/// on the current request to rebuild the routes at the end of the request
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// This will also work for load balanced scenarios since this event executes on all servers
/// </remarks>
private static void PageCacheRefresher_CacheUpdated(PageCacheRefresher sender, Umbraco.Core.Cache.CacheRefresherEventArgs e)
{
if (UmbracoContext.Current == null)
{
return;
}
switch (e.MessageType)
{
case MessageType.RefreshById:
case MessageType.RemoveById:
var item = UmbracoContext.Current.ContentCache.GetById((int)e.MessageObject);
if (item != null && item.DocumentTypeAlias.InvariantEquals("Articulate"))
{
//ensure routes are rebuilt
ApplicationContext.Current.ApplicationCache.RequestCache.GetCacheItem("articulate-refresh-routes", () => true);
}
break;
case MessageType.RefreshByInstance:
case MessageType.RemoveByInstance:
var content = e.MessageObject as IContent;
if (content == null)
{
return;
}
//TODO: There is a case when there are URL conflicts with Articulate data that when the other data is unpublished
// we'd want to rebuild articulate routes, but not sure how to handle that and we don't want to rebuild everytime
// something is unpublished
if (content.ContentType.Alias.InvariantEquals("Articulate"))
{
//ensure routes are rebuilt
ApplicationContext.Current.ApplicationCache.RequestCache.GetCacheItem("articulate-refresh-routes", () => true);
}
break;
}
}
/// <summary>
/// Handles index management for all published content events - basically handling published/unpublished
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// This will execute on all servers taking part in load balancing
/// </remarks>
static void PublishedPageCacheRefresherCacheUpdated(PageCacheRefresher sender, CacheRefresherEventArgs e)
{
if (Suspendable.ExamineEvents.CanIndex == false)
{
return;
}
switch (e.MessageType)
{
case MessageType.RefreshById:
var c1 = ApplicationContext.Current.Services.ContentService.GetById((int)e.MessageObject);
if (c1 != null)
{
ReIndexForContent(c1, true);
}
break;
case MessageType.RemoveById:
//This is triggered when the item has been unpublished or trashed (which also performs an unpublish).
var c2 = ApplicationContext.Current.Services.ContentService.GetById((int)e.MessageObject);
if (c2 != null)
{
// So we need to delete the index from all indexes not supporting unpublished content.
DeleteIndexForEntity(c2.Id, true);
// We then need to re-index this item for all indexes supporting unpublished content
ReIndexForContent(c2, false);
}
break;
case MessageType.RefreshByInstance:
var c3 = e.MessageObject as IContent;
if (c3 != null)
{
ReIndexForContent(c3, true);
}
break;
case MessageType.RemoveByInstance:
//This is triggered when the item has been unpublished or trashed (which also performs an unpublish).
var c4 = e.MessageObject as IContent;
if (c4 != null)
{
// So we need to delete the index from all indexes not supporting unpublished content.
DeleteIndexForEntity(c4.Id, true);
// We then need to re-index this item for all indexes supporting unpublished content
ReIndexForContent(c4, false);
}
break;
case MessageType.RefreshAll:
case MessageType.RefreshByJson:
default:
//We don't support these for examine indexing
break;
}
}
private void PageCacheRefresherCacheUpdated(PageCacheRefresher sender, Core.Cache.CacheRefresherEventArgs e)
{
// After content has been updated clear content finder cache.
ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch("MultilingualContentFinder");
}
/// <summary>
/// The page cache refresher cache updated event handler.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="CacheRefresherEventArgs"/> containing information about the event.</param>
private void PageCacheRefresherCacheUpdated(PageCacheRefresher sender, CacheRefresherEventArgs e)
{
this.ClearCache();
}
/// <summary>
/// When the page cache is refreshed, we'll check if any articulate root nodes were included in the refresh, if so we'll set a flag
/// on the current request to rebuild the routes at the end of the request
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// This will also work for load balanced scenarios since this event executes on all servers
/// </remarks>
void PageCacheRefresher_CacheUpdated(PageCacheRefresher sender, Umbraco.Core.Cache.CacheRefresherEventArgs e)
{
if (UmbracoContext.Current == null) return;
switch (e.MessageType)
{
case MessageType.RefreshById:
case MessageType.RemoveById:
var item = UmbracoContext.Current.ContentCache.GetById((int) e.MessageObject);
if (item != null && item.DocumentTypeAlias.InvariantEquals("Articulate"))
{
//add the unpublished entities to the request cache
ApplicationContext.Current.ApplicationCache.RequestCache.GetCacheItem("articulate-refresh-routes", () => true);
}
break;
case MessageType.RefreshByInstance:
case MessageType.RemoveByInstance:
var content = e.MessageObject as IContent;
if (content == null) return;
if (content.ContentType.Alias.InvariantEquals("Articulate"))
{
//add the unpublished entities to the request cache
UmbracoContext.Current.Application.ApplicationCache.RequestCache.GetCacheItem("articulate-refresh-routes", () => true);
}
break;
}
}
private void PageCacheRefresher_CacheUpdated(PageCacheRefresher sender, CacheRefresherEventArgs e)
{
Cache.Instance.RemoveByPrefix(typeof(NodeGetterCachedProxy).ToString());
}
private void PageCacheRefresherOnCacheUpdated(PageCacheRefresher sender, CacheRefresherEventArgs cacheRefresherEventArgs)
{
_logService.Debug <ClearDonutOutputCache>("PageCacheRefresherOnCacheUpdated");
ClearCache();
}
private void PageCacheRefresherOnCacheUpdated(PageCacheRefresher sender,
CacheRefresherEventArgs cacheRefresherEventArgs)
{
ClearCache();
}
private void PageCacheRefresherCacheUpdated(PageCacheRefresher sender, Core.Cache.CacheRefresherEventArgs e)
{
// After content has been updated clear content finder cache.
this.ClearCache();
}
private void PageCacheRefresherOnCacheUpdated(PageCacheRefresher sender, CacheRefresherEventArgs cacheRefresherEventArgs)
{
Log.Debug("Clearing output cache");
ClearCache();
}
