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); }