private void Changed(object sender, EventArgs <string> e)
{
if (PathDependency.IsChanged(e.Data, _path))
{
OnChanged(null);
}
}
public void Cache_DependencyCounts()
{
Test((builder) => { builder.UseCacheProvider(new SnMemoryCache()); },
() =>
{
Cache.Reset();
var idArray = CreateSafeContentQuery("InTree:/Root").Execute().Nodes
.Select(n => n.Id).ToArray();
var countBefore = Cache.Count;
Assert.IsTrue(countBefore > idArray.Length * 2);
var eventCountsBefore = Cache.Events.GetCounts();
var totalEventCountBefore = eventCountsBefore.Select(x => x.Value.Sum()).Sum();
Assert.IsTrue(totalEventCountBefore > countBefore * 2);
PathDependency.FireChanged("/Root/System");
var countAfter = Cache.Count;
var eventCountsAfter = Cache.Events.GetCounts();
var totalEventCountAfter = eventCountsAfter.Select(x => x.Value.Sum()).Sum();
Assert.IsTrue(0 < countAfter);
Assert.IsTrue(countAfter < countBefore);
Assert.IsTrue(totalEventCountAfter > countAfter * 2);
Assert.IsTrue(totalEventCountAfter < totalEventCountBefore);
PathDependency.FireChanged("/Root");
var countFinal = Cache.Count;
var eventCountsFinal = Cache.Events.GetCounts();
var totalEventCountFinal = eventCountsFinal.Select(x => x.Value.Sum()).Sum();
Assert.AreEqual(0, countFinal);
Assert.AreEqual(0, totalEventCountFinal);
});
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
PathDependency.Unsubscribe(Changed);
}
}
// ====================================================================== Transaction callback
internal static void RemoveFromCache(NodeDataParticipant participant) // orig name: OnNodeDataCommit
{
// Do not fire any events if the node is new:
// it cannot effect any other content
if (participant.IsNewNode)
{
return;
}
var data = participant.Data;
// Remove items from Cache by the OriginalPath, before getting an update
// of a - occassionally differring - path from the database
if (data.PathChanged)
{
PathDependency.FireChanged(data.OriginalPath);
}
if (data.ContentListTypeId != 0 && data.ContentListId == 0)
{
// If list, invalidate full subtree
PathDependency.FireChanged(data.Path);
}
else
{
// If not a list, invalidate item
NodeIdDependency.FireChanged(data.Id);
}
}
/* ================================================================================= */
private string InsertCacheWithPathDependency(Node node)
{
var cacheKey = "NodeData." + node.VersionId;
var dependencies = new PathDependency(node.Path);
Cache.Insert(cacheKey, node.Data, dependencies);
return(cacheKey);
}
public PathChangeMonitor(string path)
{
_path = path;
try
{
PathDependency.Subscribe(Changed);
}
finally
{
InitializationComplete();
}
}
public void Cache_Builtin_PathDependency()
{
Test((builder) => { builder.UseCacheProvider(new SnMemoryCache()); },
() =>
{
var cache = DistributedApplication.Cache;
var root = CreateTestFolder(Repository.Root);
// create node1 and cache it with it own NodeIdDependency
var node1 = CreateTestFolder(root);
var node11 = CreateTestFolder(node1);
var node12 = CreateTestFolder(node1);
var node2 = CreateTestFolder(root);
var node21 = CreateTestFolder(node2);
var node22 = CreateTestFolder(node2);
cache.Reset();
var rootKey = InsertCacheWithPathDependency(cache, root);
var node1Key = InsertCacheWithPathDependency(cache, node1);
var node11Key = InsertCacheWithPathDependency(cache, node11);
var node12Key = InsertCacheWithPathDependency(cache, node12);
var node2Key = InsertCacheWithPathDependency(cache, node2);
var node21Key = InsertCacheWithPathDependency(cache, node21);
var node22Key = InsertCacheWithPathDependency(cache, node22);
// pre-check: all nodes are in the cache
Assert.IsTrue(IsInCache(rootKey));
Assert.IsTrue(IsInCache(node1Key));
Assert.IsTrue(IsInCache(node11Key));
Assert.IsTrue(IsInCache(node12Key));
Assert.IsTrue(IsInCache(node2Key));
Assert.IsTrue(IsInCache(node21Key));
Assert.IsTrue(IsInCache(node22Key));
// TEST: Remove the subree of the node1
PathDependency.FireChanged(node1.Path);
// check: only node1 subtree is removed
Assert.IsTrue(IsInCache(rootKey));
Assert.IsFalse(IsInCache(node1Key));
Assert.IsFalse(IsInCache(node11Key));
Assert.IsFalse(IsInCache(node12Key));
Assert.IsTrue(IsInCache(node2Key));
Assert.IsTrue(IsInCache(node21Key));
Assert.IsTrue(IsInCache(node22Key));
});
}
public void Cache_Builtin_PathDependency()
{
Test2((services) => { services.AddSingleton <ISnCache, SnMemoryCache>(); },
() =>
{
var root = CreateTestFolder(Repository.Root);
// create node1 and cache it with it own NodeIdDependency
var node1 = CreateTestFolder(root);
var node11 = CreateTestFolder(node1);
var node12 = CreateTestFolder(node1);
var node2 = CreateTestFolder(root);
var node21 = CreateTestFolder(node2);
var node22 = CreateTestFolder(node2);
Cache.Reset();
var rootKey = InsertCacheWithPathDependency(root);
var node1Key = InsertCacheWithPathDependency(node1);
var node11Key = InsertCacheWithPathDependency(node11);
var node12Key = InsertCacheWithPathDependency(node12);
var node2Key = InsertCacheWithPathDependency(node2);
var node21Key = InsertCacheWithPathDependency(node21);
var node22Key = InsertCacheWithPathDependency(node22);
// pre-check: all nodes are in the cache
Assert.IsTrue(IsInCache(rootKey));
Assert.IsTrue(IsInCache(node1Key));
Assert.IsTrue(IsInCache(node11Key));
Assert.IsTrue(IsInCache(node12Key));
Assert.IsTrue(IsInCache(node2Key));
Assert.IsTrue(IsInCache(node21Key));
Assert.IsTrue(IsInCache(node22Key));
// TEST: Remove the subree of the node1
PathDependency.FireChanged(node1.Path);
// check: only node1 subtree is removed
Assert.IsTrue(IsInCache(rootKey));
Assert.IsFalse(IsInCache(node1Key));
Assert.IsFalse(IsInCache(node11Key));
Assert.IsFalse(IsInCache(node12Key));
Assert.IsTrue(IsInCache(node2Key));
Assert.IsTrue(IsInCache(node21Key));
Assert.IsTrue(IsInCache(node22Key));
});
}
private void RemoveFromCache(NodeData data)
{
// Remove items from Cache by the OriginalPath, before getting an update
// of a - occassionally differring - path from the database
if (data.PathChanged)
{
PathDependency.FireChanged(data.OriginalPath);
}
if (data.ContentListTypeId != 0 && data.ContentListId == 0)
{
// If list, invalidate full subtree
PathDependency.FireChanged(data.Path);
}
else
{
// If not a list, invalidate item
NodeIdDependency.FireChanged(data.Id);
}
}
internal static void RemoveBreakPermissionInheritance(Node node)
{
DataProvider.Current.RemoveBreakInheritance(node.Id);
NodeIdDependency.FireChanged(node.Id);
PathDependency.FireChanged(node.Path);
}
