1042 lines
35 KiB
C#
1042 lines
35 KiB
C#
|
using System;
|
|||
|
|
using System.Collections.Concurrent;
|
|||
|
|
using System.Collections.Generic;
|
|||
|
|
using System.Linq;
|
|||
|
|
using System.Threading;
|
|||
|
|
using System.Threading.Tasks;
|
|||
|
|
using CSharpTest.Net.Collections;
|
|||
|
|
using Umbraco.Core.Logging;
|
|||
|
|
using Umbraco.Core.Models.PublishedContent;
|
|||
|
|
|
|||
|
|
namespace Umbraco.Web.PublishedCache.NuCache
|
|||
|
|
{
|
|||
|
|
// stores content
|
|||
|
|
internal class ContentStore2
|
|||
|
|
{
|
|||
|
|
// this class is an extended version of SnapDictionary
|
|||
|
|
// most of the snapshots management code, etc is an exact copy
|
|||
|
|
// SnapDictionary has unit tests to ensure it all works correctly
|
|||
|
|
|
|||
|
|
private readonly ConcurrentDictionary<int, LinkedNode<ContentNode>> _contentNodes;
|
|||
|
|
private readonly ConcurrentDictionary<int, LinkedNode<object>> _contentRootNodes;
|
|||
|
|
private readonly ConcurrentDictionary<int, LinkedNode<PublishedContentType>> _contentTypesById;
|
|||
|
|
private readonly ConcurrentDictionary<string, LinkedNode<PublishedContentType>> _contentTypesByAlias;
|
|||
|
|
private readonly Dictionary<int, HashSet<int>> _contentTypeNodes;
|
|||
|
|
|
|||
|
|
private readonly ILogger _logger;
|
|||
|
|
private BPlusTree<int, ContentNodeKit> _localDb;
|
|||
|
|
private readonly ConcurrentQueue<GenRefRef> _genRefRefs;
|
|||
|
|
private GenRefRef _genRefRef;
|
|||
|
|
private readonly object _wlocko = new object();
|
|||
|
|
private readonly object _rlocko = new object();
|
|||
|
|
private long _liveGen, _floorGen;
|
|||
|
|
private bool _nextGen, _collectAuto;
|
|||
|
|
private Task _collectTask;
|
|||
|
|
private volatile int _wlocked;
|
|||
|
|
|
|||
|
|
// fixme - collection trigger (ok for now)
|
|||
|
|
// see SnapDictionary notes
|
|||
|
|
private const long CollectMinGenDelta = 8;
|
|||
|
|
|
|||
|
|
#region Ctor
|
|||
|
|
|
|||
|
|
public ContentStore2(ILogger logger, BPlusTree<int, ContentNodeKit> localDb = null)
|
|||
|
|
{
|
|||
|
|
_logger = logger;
|
|||
|
|
_localDb = localDb;
|
|||
|
|
|
|||
|
|
_contentNodes = new ConcurrentDictionary<int, LinkedNode<ContentNode>>();
|
|||
|
|
_contentRootNodes = new ConcurrentDictionary<int, LinkedNode<object>>();
|
|||
|
|
_contentTypesById = new ConcurrentDictionary<int, LinkedNode<PublishedContentType>>();
|
|||
|
|
_contentTypesByAlias = new ConcurrentDictionary<string, LinkedNode<PublishedContentType>>(StringComparer.InvariantCultureIgnoreCase);
|
|||
|
|
_contentTypeNodes = new Dictionary<int, HashSet<int>>();
|
|||
|
|
|
|||
|
|
_genRefRefs = new ConcurrentQueue<GenRefRef>();
|
|||
|
|
_genRefRef = null; // no initial gen exists
|
|||
|
|
_liveGen = _floorGen = 0;
|
|||
|
|
_nextGen = false; // first time, must create a snapshot
|
|||
|
|
_collectAuto = true; // collect automatically by default
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region Locking
|
|||
|
|
|
|||
|
|
public void WriteLocked(Action action)
|
|||
|
|
{
|
|||
|
|
var wtaken = false;
|
|||
|
|
var wcount = false;
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
Monitor.Enter(_wlocko, ref wtaken);
|
|||
|
|
|
|||
|
|
var rtaken = false;
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
Monitor.Enter(_rlocko, ref rtaken);
|
|||
|
|
|
|||
|
|
// see SnapDictionary
|
|||
|
|
try
|
|||
|
|
{ }
|
|||
|
|
finally
|
|||
|
|
{
|
|||
|
|
_wlocked++;
|
|||
|
|
wcount = true;
|
|||
|
|
if (_nextGen == false)
|
|||
|
|
{
|
|||
|
|
// because we are changing things, a new generation
|
|||
|
|
// is created, which will trigger a new snapshot
|
|||
|
|
_nextGen = true;
|
|||
|
|
_liveGen += 1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
finally
|
|||
|
|
{
|
|||
|
|
if (rtaken) Monitor.Exit(_rlocko);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
action();
|
|||
|
|
}
|
|||
|
|
finally
|
|||
|
|
{
|
|||
|
|
if (wcount) _wlocked--;
|
|||
|
|
if (wtaken) Monitor.Exit(_wlocko);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public T WriteLocked<T>(Func<T> func)
|
|||
|
|
{
|
|||
|
|
var wtaken = false;
|
|||
|
|
var wcount = false;
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
Monitor.Enter(_wlocko, ref wtaken);
|
|||
|
|
|
|||
|
|
var rtaken = false;
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
Monitor.Enter(_rlocko, ref rtaken);
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{ }
|
|||
|
|
finally
|
|||
|
|
{
|
|||
|
|
_wlocked++;
|
|||
|
|
wcount = true;
|
|||
|
|
if (_nextGen == false)
|
|||
|
|
{
|
|||
|
|
// because we are changing things, a new generation
|
|||
|
|
// is created, which will trigger a new snapshot
|
|||
|
|
_nextGen = true;
|
|||
|
|
_liveGen += 1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
finally
|
|||
|
|
{
|
|||
|
|
if (rtaken) Monitor.Exit(_rlocko);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return func();
|
|||
|
|
}
|
|||
|
|
finally
|
|||
|
|
{
|
|||
|
|
if (wcount) _wlocked--;
|
|||
|
|
if (wtaken) Monitor.Exit(_wlocko);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private T ReadLocked<T>(Func<bool, T> func)
|
|||
|
|
{
|
|||
|
|
var rtaken = false;
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
Monitor.Enter(_rlocko, ref rtaken);
|
|||
|
|
|
|||
|
|
// we have rlock, so it cannot ++
|
|||
|
|
// it could -- though, so... volatile
|
|||
|
|
var wlocked = _wlocked > 0;
|
|||
|
|
return func(wlocked);
|
|||
|
|
}
|
|||
|
|
finally
|
|||
|
|
{
|
|||
|
|
if (rtaken) Monitor.Exit(_rlocko);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region LocalDb
|
|||
|
|
|
|||
|
|
public void ReleaseLocalDb()
|
|||
|
|
{
|
|||
|
|
WriteLocked(() =>
|
|||
|
|
{
|
|||
|
|
if (_localDb == null) return;
|
|||
|
|
_localDb.Dispose();
|
|||
|
|
_localDb = null;
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region Content types
|
|||
|
|
|
|||
|
|
public void UpdateContentTypes(IEnumerable<int> removedIds, IEnumerable<PublishedContentType> refreshedTypes, IEnumerable<ContentNodeKit> kits)
|
|||
|
|
{
|
|||
|
|
removedIds = removedIds ?? Enumerable.Empty<int>();
|
|||
|
|
refreshedTypes = refreshedTypes ?? Enumerable.Empty<PublishedContentType>();
|
|||
|
|
kits = kits ?? new ContentNodeKit[0];
|
|||
|
|
|
|||
|
|
WriteLocked(() =>
|
|||
|
|
{
|
|||
|
|
foreach (var id in removedIds)
|
|||
|
|
{
|
|||
|
|
// all content should have been deleted - but
|
|||
|
|
if (_contentTypeNodes.ContainsKey(id))
|
|||
|
|
{
|
|||
|
|
foreach (var node in _contentTypeNodes[id])
|
|||
|
|
ClearBranchLocked(node);
|
|||
|
|
_contentTypeNodes.Remove(id);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
LinkedNode<PublishedContentType> link;
|
|||
|
|
if (_contentTypesById.TryGetValue(id, out link) == false || link.Value == null)
|
|||
|
|
continue;
|
|||
|
|
SetValueLocked(_contentTypesById, id, null);
|
|||
|
|
SetValueLocked(_contentTypesByAlias, link.Value.Alias, null);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var temp = new Dictionary<int, HashSet<int>>();
|
|||
|
|
|
|||
|
|
foreach (var type in refreshedTypes)
|
|||
|
|
{
|
|||
|
|
if (_contentTypeNodes.ContainsKey(type.Id) == false)
|
|||
|
|
_contentTypeNodes[type.Id] = new HashSet<int>();
|
|||
|
|
|
|||
|
|
SetValueLocked(_contentTypesById, type.Id, type);
|
|||
|
|
SetValueLocked(_contentTypesByAlias, type.Alias, type);
|
|||
|
|
|
|||
|
|
temp.Add(type.Id, new HashSet<int>(_contentTypeNodes[type.Id]));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// skip missing type
|
|||
|
|
// skip missing parents & unbuildable kits - what else could we do?
|
|||
|
|
foreach (var kit in kits.Where(x =>
|
|||
|
|
temp.ContainsKey(x.ContentTypeId) &&
|
|||
|
|
ParentExistsLocked(x) &&
|
|||
|
|
BuildKit(x)))
|
|||
|
|
{
|
|||
|
|
SetValueLocked(_contentNodes, kit.Node.Id, kit.Node);
|
|||
|
|
if (_localDb != null)
|
|||
|
|
_localDb[kit.Node.Id] = kit;
|
|||
|
|
temp[kit.ContentTypeId].Remove(kit.Node.Id);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// all content should have been refreshed - but...
|
|||
|
|
foreach (var id in temp.Values.SelectMany(x => x))
|
|||
|
|
ClearBranchLocked(id);
|
|||
|
|
|
|||
|
|
if (_localDb != null)
|
|||
|
|
_localDb.Commit();
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void UpdateDataTypes(IEnumerable<int> dataTypeIds, Func<int, PublishedContentType> getContentType)
|
|||
|
|
{
|
|||
|
|
WriteLocked(() =>
|
|||
|
|
{
|
|||
|
|
var contentTypes = _contentTypesById
|
|||
|
|
.Where(kvp =>
|
|||
|
|
kvp.Value.Value != null &&
|
|||
|
|
kvp.Value.Value.PropertyTypes.Any(p => dataTypeIds.Contains(p.DataTypeId)))
|
|||
|
|
.Select(kvp => kvp.Value.Value)
|
|||
|
|
.Select(x => getContentType(x.Id));
|
|||
|
|
|
|||
|
|
foreach (var contentType in contentTypes)
|
|||
|
|
{
|
|||
|
|
// poof, gone, very unlikely and probably an anomaly
|
|||
|
|
if (contentType == null)
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
// again, weird situation
|
|||
|
|
if (_contentTypeNodes.ContainsKey(contentType.Id) == false)
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
foreach (var id in _contentTypeNodes[contentType.Id])
|
|||
|
|
{
|
|||
|
|
LinkedNode<ContentNode> link;
|
|||
|
|
_contentNodes.TryGetValue(id, out link);
|
|||
|
|
if (link == null || link.Value == null)
|
|||
|
|
continue;
|
|||
|
|
var node = new ContentNode(link.Value, contentType);
|
|||
|
|
SetValueLocked(_contentNodes, id, node);
|
|||
|
|
if (_localDb != null)
|
|||
|
|
_localDb[id] = node.ToKit();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (_localDb != null)
|
|||
|
|
_localDb.Commit();
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private bool BuildKit(ContentNodeKit kit)
|
|||
|
|
{
|
|||
|
|
// make sure the kit is valid
|
|||
|
|
if (kit.DraftData == null && kit.PublishedData == null)
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
LinkedNode<PublishedContentType> link;
|
|||
|
|
|
|||
|
|
// unknown = bad
|
|||
|
|
if (_contentTypesById.TryGetValue(kit.ContentTypeId, out link) == false || link.Value == null)
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
// not checking ByAlias, assuming we don't have internal errors
|
|||
|
|
|
|||
|
|
// register
|
|||
|
|
if (_contentTypeNodes.ContainsKey(kit.ContentTypeId) == false)
|
|||
|
|
_contentTypeNodes[kit.ContentTypeId] = new HashSet<int>();
|
|||
|
|
_contentTypeNodes[kit.ContentTypeId].Add(kit.Node.Id);
|
|||
|
|
|
|||
|
|
// and use
|
|||
|
|
kit.Build(link.Value);
|
|||
|
|
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void ReleaseContentTypeLocked(ContentNode content)
|
|||
|
|
{
|
|||
|
|
if (_contentTypeNodes.ContainsKey(content.ContentType.Id) == false)
|
|||
|
|
return; // though, ?!
|
|||
|
|
_contentTypeNodes[content.ContentType.Id].Remove(content.Id);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region Set, Clear, Get
|
|||
|
|
|
|||
|
|
public int Count
|
|||
|
|
{
|
|||
|
|
get { return _contentNodes.Count; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private LinkedNode<TValue> GetHead<TKey, TValue>(ConcurrentDictionary<TKey, LinkedNode<TValue>> dict, TKey key)
|
|||
|
|
where TValue : class
|
|||
|
|
{
|
|||
|
|
LinkedNode<TValue> link;
|
|||
|
|
dict.TryGetValue(key, out link); // else null
|
|||
|
|
return link;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void Set(ContentNodeKit kit)
|
|||
|
|
{
|
|||
|
|
// ReSharper disable LocalizableElement
|
|||
|
|
if (kit.IsEmpty)
|
|||
|
|
throw new ArgumentException("Kit is empty.", "kit");
|
|||
|
|
if (kit.Node.ChildContentIds.Count > 0)
|
|||
|
|
throw new ArgumentException("Kit content cannot have children.", "kit");
|
|||
|
|
// ReSharper restore LocalizableElement
|
|||
|
|
|
|||
|
|
_logger.Debug<ContentStore2>("Set content ID:" + kit.Node.Id);
|
|||
|
|
|
|||
|
|
WriteLocked(() =>
|
|||
|
|
{
|
|||
|
|
// get existing
|
|||
|
|
LinkedNode<ContentNode> link;
|
|||
|
|
_contentNodes.TryGetValue(kit.Node.Id, out link);
|
|||
|
|
var existing = link == null ? null : link.Value;
|
|||
|
|
|
|||
|
|
// else ignore, what else could we do?
|
|||
|
|
if (ParentExistsLocked(kit) == false || BuildKit(kit) == false)
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
// moving?
|
|||
|
|
var moving = existing != null && existing.ParentContentId != kit.Node.ParentContentId;
|
|||
|
|
|
|||
|
|
// manage children
|
|||
|
|
if (existing != null)
|
|||
|
|
kit.Node.ChildContentIds = existing.ChildContentIds;
|
|||
|
|
|
|||
|
|
// set
|
|||
|
|
SetValueLocked(_contentNodes, kit.Node.Id, kit.Node);
|
|||
|
|
if (_localDb != null)
|
|||
|
|
_localDb[kit.Node.Id] = kit;
|
|||
|
|
|
|||
|
|
// manage the tree
|
|||
|
|
if (existing == null)
|
|||
|
|
{
|
|||
|
|
// new, add to parent
|
|||
|
|
AddToParentLocked(kit.Node);
|
|||
|
|
}
|
|||
|
|
else if (moving)
|
|||
|
|
{
|
|||
|
|
// moved, remove existing from its parent, add content to its parent
|
|||
|
|
RemoveFromParentLocked(existing);
|
|||
|
|
AddToParentLocked(kit.Node);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (_localDb != null)
|
|||
|
|
_localDb.Commit();
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void SetAll(IEnumerable<ContentNodeKit> kits)
|
|||
|
|
{
|
|||
|
|
WriteLocked(() =>
|
|||
|
|
{
|
|||
|
|
ClearLocked(_contentNodes);
|
|||
|
|
ClearLocked(_contentRootNodes);
|
|||
|
|
|
|||
|
|
// do NOT clear types else they are gone!
|
|||
|
|
//ClearLocked(_contentTypesById);
|
|||
|
|
//ClearLocked(_contentTypesByAlias);
|
|||
|
|
|
|||
|
|
// skip missing parents & unbuildable kits - what else could we do?
|
|||
|
|
foreach (var kit in kits.Where(x => ParentExistsLocked(x) && BuildKit(x)))
|
|||
|
|
{
|
|||
|
|
SetValueLocked(_contentNodes, kit.Node.Id, kit.Node);
|
|||
|
|
if (_localDb != null)
|
|||
|
|
_localDb[kit.Node.Id] = kit;
|
|||
|
|
AddToParentLocked(kit.Node);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (_localDb != null)
|
|||
|
|
_localDb.Commit();
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void SetBranch(int rootContentId, IEnumerable<ContentNodeKit> kits)
|
|||
|
|
{
|
|||
|
|
WriteLocked(() =>
|
|||
|
|
{
|
|||
|
|
// get existing
|
|||
|
|
LinkedNode<ContentNode> link;
|
|||
|
|
_contentNodes.TryGetValue(rootContentId, out link);
|
|||
|
|
var existing = link == null ? null : link.Value;
|
|||
|
|
|
|||
|
|
// clear
|
|||
|
|
if (existing != null)
|
|||
|
|
{
|
|||
|
|
ClearBranchLocked(existing);
|
|||
|
|
RemoveFromParentLocked(existing);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// now add them all back
|
|||
|
|
// skip missing parents & unbuildable kits - what else could we do?
|
|||
|
|
foreach (var kit in kits.Where(x => ParentExistsLocked(x) && BuildKit(x)))
|
|||
|
|
{
|
|||
|
|
SetValueLocked(_contentNodes, kit.Node.Id, kit.Node);
|
|||
|
|
if (_localDb != null)
|
|||
|
|
_localDb[kit.Node.Id] = kit;
|
|||
|
|
AddToParentLocked(kit.Node);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (_localDb != null)
|
|||
|
|
_localDb.Commit();
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public bool Clear(int id)
|
|||
|
|
{
|
|||
|
|
return WriteLocked(() =>
|
|||
|
|
{
|
|||
|
|
// try to find the content
|
|||
|
|
// if it is not there, nothing to do
|
|||
|
|
LinkedNode<ContentNode> link;
|
|||
|
|
_contentNodes.TryGetValue(id, out link); // else null
|
|||
|
|
if (link == null || link.Value == null) return false;
|
|||
|
|
|
|||
|
|
var content = link.Value;
|
|||
|
|
_logger.Debug<ContentStore2>("Clear content ID:" + content.Id);
|
|||
|
|
|
|||
|
|
// clear the entire branch
|
|||
|
|
ClearBranchLocked(content);
|
|||
|
|
|
|||
|
|
// manage the tree
|
|||
|
|
RemoveFromParentLocked(content);
|
|||
|
|
|
|||
|
|
return true;
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void ClearBranchLocked(int id)
|
|||
|
|
{
|
|||
|
|
LinkedNode<ContentNode> link;
|
|||
|
|
_contentNodes.TryGetValue(id, out link);
|
|||
|
|
if (link == null || link.Value == null)
|
|||
|
|
return;
|
|||
|
|
ClearBranchLocked(link.Value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void ClearBranchLocked(ContentNode content)
|
|||
|
|
{
|
|||
|
|
SetValueLocked(_contentNodes, content.Id, null);
|
|||
|
|
if (_localDb != null)
|
|||
|
|
{
|
|||
|
|
ContentNodeKit kit;
|
|||
|
|
_localDb.TryRemove(content.Id, out kit);
|
|||
|
|
}
|
|||
|
|
ReleaseContentTypeLocked(content);
|
|||
|
|
foreach (var childId in content.ChildContentIds)
|
|||
|
|
{
|
|||
|
|
LinkedNode<ContentNode> link;
|
|||
|
|
if (_contentNodes.TryGetValue(childId, out link) == false || link.Value == null) continue;
|
|||
|
|
ClearBranchLocked(link.Value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private LinkedNode<ContentNode> GetParentLink(ContentNode content)
|
|||
|
|
{
|
|||
|
|
LinkedNode<ContentNode> link;
|
|||
|
|
_contentNodes.TryGetValue(content.ParentContentId, out link); // else null
|
|||
|
|
//if (link == null || link.Value == null)
|
|||
|
|
// throw new Exception("Panic: parent not found.");
|
|||
|
|
return link;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void RemoveFromParentLocked(ContentNode content)
|
|||
|
|
{
|
|||
|
|
// remove from root content index,
|
|||
|
|
// or parent's children index
|
|||
|
|
if (content.ParentContentId < 0)
|
|||
|
|
{
|
|||
|
|
SetValueLocked(_contentRootNodes, content.Id, null);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// obviously parent has to exist
|
|||
|
|
var link = GetParentLink(content);
|
|||
|
|
var parent = link.Value;
|
|||
|
|
if (link.Gen < _liveGen)
|
|||
|
|
parent = parent.CloneParent();
|
|||
|
|
parent.ChildContentIds.Remove(content.Id);
|
|||
|
|
if (link.Gen < _liveGen)
|
|||
|
|
SetValueLocked(_contentNodes, parent.Id, parent);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private bool ParentExistsLocked(ContentNodeKit kit)
|
|||
|
|
{
|
|||
|
|
if (kit.Node.ParentContentId < 0)
|
|||
|
|
return true;
|
|||
|
|
var link = GetParentLink(kit.Node);
|
|||
|
|
return link != null && link.Value != null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void AddToParentLocked(ContentNode content)
|
|||
|
|
{
|
|||
|
|
// add to root content index,
|
|||
|
|
// or parent's children index
|
|||
|
|
if (content.ParentContentId < 0)
|
|||
|
|
{
|
|||
|
|
// need an object reference... just use this...
|
|||
|
|
SetValueLocked(_contentRootNodes, content.Id, this);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// assume parent has been validated and exists
|
|||
|
|
var link = GetParentLink(content);
|
|||
|
|
var parent = link.Value;
|
|||
|
|
if (link.Gen < _liveGen)
|
|||
|
|
parent = parent.CloneParent();
|
|||
|
|
parent.ChildContentIds.Add(content.Id);
|
|||
|
|
if (link.Gen < _liveGen)
|
|||
|
|
SetValueLocked(_contentNodes, parent.Id, parent);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void SetValueLocked<TKey, TValue>(ConcurrentDictionary<TKey, LinkedNode<TValue>> dict, TKey key, TValue value)
|
|||
|
|
where TValue : class
|
|||
|
|
{
|
|||
|
|
// this is safe only because we're write-locked
|
|||
|
|
var link = GetHead(dict, key);
|
|||
|
|
if (link != null)
|
|||
|
|
{
|
|||
|
|
// already in the dict
|
|||
|
|
if (link.Gen != _liveGen)
|
|||
|
|
{
|
|||
|
|
// for an older gen - if value is different then insert a new
|
|||
|
|
// link for the new gen, with the new value
|
|||
|
|
if (link.Value != value)
|
|||
|
|
dict.TryUpdate(key, new LinkedNode<TValue>(value, _liveGen, link), link);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// for the live gen - we can fix the live gen - and remove it
|
|||
|
|
// if value is null and there's no next gen
|
|||
|
|
if (value == null && link.Next == null)
|
|||
|
|
dict.TryRemove(key, out link);
|
|||
|
|
else
|
|||
|
|
link.Value = value;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
dict.TryAdd(key, new LinkedNode<TValue>(value, _liveGen));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void ClearLocked<TKey, TValue>(ConcurrentDictionary<TKey, LinkedNode<TValue>> dict)
|
|||
|
|
where TValue : class
|
|||
|
|
{
|
|||
|
|
WriteLocked(() =>
|
|||
|
|
{
|
|||
|
|
// this is safe only because we're write-locked
|
|||
|
|
foreach (var kvp in dict.Where(x => x.Value != null))
|
|||
|
|
{
|
|||
|
|
if (kvp.Value.Gen < _liveGen)
|
|||
|
|
{
|
|||
|
|
var link = new LinkedNode<TValue>(null, _liveGen, kvp.Value);
|
|||
|
|
dict.TryUpdate(kvp.Key, link, kvp.Value);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
kvp.Value.Value = null;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public ContentNode Get(int id, long gen)
|
|||
|
|
{
|
|||
|
|
return GetValue(_contentNodes, id, gen);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public IEnumerable<ContentNode> GetAtRoot(long gen)
|
|||
|
|
{
|
|||
|
|
// look ma, no lock!
|
|||
|
|
foreach (var kvp in _contentRootNodes)
|
|||
|
|
{
|
|||
|
|
var link = kvp.Value;
|
|||
|
|
while (link != null)
|
|||
|
|
{
|
|||
|
|
if (link.Gen <= gen)
|
|||
|
|
break;
|
|||
|
|
link = link.Next;
|
|||
|
|
}
|
|||
|
|
if (link != null && link.Value != null)
|
|||
|
|
yield return Get(kvp.Key, gen);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private TValue GetValue<TKey, TValue>(ConcurrentDictionary<TKey, LinkedNode<TValue>> dict, TKey key, long gen)
|
|||
|
|
where TValue : class
|
|||
|
|
{
|
|||
|
|
// look ma, no lock!
|
|||
|
|
var link = GetHead(dict, key);
|
|||
|
|
while (link != null)
|
|||
|
|
{
|
|||
|
|
if (link.Gen <= gen)
|
|||
|
|
return link.Value; // may be null
|
|||
|
|
link = link.Next;
|
|||
|
|
}
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public bool IsEmpty(long gen)
|
|||
|
|
{
|
|||
|
|
var has = _contentNodes.Any(x =>
|
|||
|
|
{
|
|||
|
|
var link = x.Value;
|
|||
|
|
while (link != null)
|
|||
|
|
{
|
|||
|
|
if (link.Gen <= gen && link.Value != null)
|
|||
|
|
return true;
|
|||
|
|
link = link.Next;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
});
|
|||
|
|
return has == false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public PublishedContentType GetContentType(int id, long gen)
|
|||
|
|
{
|
|||
|
|
return GetValue(_contentTypesById, id, gen);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public PublishedContentType GetContentType(string alias, long gen)
|
|||
|
|
{
|
|||
|
|
return GetValue(_contentTypesByAlias, alias, gen);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region Snapshots
|
|||
|
|
|
|||
|
|
public Snapshot CreateSnapshot()
|
|||
|
|
{
|
|||
|
|
return ReadLocked(wlocked =>
|
|||
|
|
{
|
|||
|
|
// if no next generation is required, and we already have one,
|
|||
|
|
// use it and create a new snapshot
|
|||
|
|
if (_nextGen == false && _genRefRef != null)
|
|||
|
|
return new Snapshot(this, _genRefRef.GetGenRef()
|
|||
|
|
#if DEBUG
|
|||
|
|
, _logger
|
|||
|
|
#endif
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
// else we need to try to create a new gen ref
|
|||
|
|
// whether we are wlocked or not, noone can rlock while we do,
|
|||
|
|
// so _liveGen and _nextGen are safe
|
|||
|
|
if (wlocked)
|
|||
|
|
{
|
|||
|
|
// write-locked, cannot use latest gen (at least 1) so use previous
|
|||
|
|
var snapGen = _nextGen ? _liveGen - 1 : _liveGen;
|
|||
|
|
|
|||
|
|
// create a new gen ref unless we already have it
|
|||
|
|
if (_genRefRef == null)
|
|||
|
|
_genRefRefs.Enqueue(_genRefRef = new GenRefRef(snapGen));
|
|||
|
|
else if (_genRefRef.Gen != snapGen)
|
|||
|
|
throw new Exception("panic");
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// not write-locked, can use latest gen, create a new gen ref
|
|||
|
|
_genRefRefs.Enqueue(_genRefRef = new GenRefRef(_liveGen));
|
|||
|
|
_nextGen = false; // this is the ONLY thing that triggers a _liveGen++
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// so...
|
|||
|
|
// the genRefRef has a weak ref to the genRef, and is queued
|
|||
|
|
// the snapshot has a ref to the genRef, which has a ref to the genRefRef
|
|||
|
|
// when the snapshot is disposed, it decreases genRefRef counter
|
|||
|
|
// so after a while, one of these conditions is going to be true:
|
|||
|
|
// - the genRefRef counter is zero because all snapshots have properly been disposed
|
|||
|
|
// - the genRefRef weak ref is dead because all snapshots have been collected
|
|||
|
|
// in both cases, we will dequeue and collect
|
|||
|
|
|
|||
|
|
var snapshot = new Snapshot(this, _genRefRef.GetGenRef()
|
|||
|
|
#if DEBUG
|
|||
|
|
, _logger
|
|||
|
|
#endif
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
// reading _floorGen is safe if _collectTask is null
|
|||
|
|
if (_collectTask == null && _collectAuto && _liveGen - _floorGen > CollectMinGenDelta)
|
|||
|
|
CollectAsyncLocked();
|
|||
|
|
|
|||
|
|
return snapshot;
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public Task CollectAsync()
|
|||
|
|
{
|
|||
|
|
lock (_rlocko)
|
|||
|
|
{
|
|||
|
|
return CollectAsyncLocked();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private Task CollectAsyncLocked()
|
|||
|
|
{
|
|||
|
|
if (_collectTask != null)
|
|||
|
|
return _collectTask;
|
|||
|
|
|
|||
|
|
// ReSharper disable InconsistentlySynchronizedField
|
|||
|
|
var task = _collectTask = Task.Run(() => Collect());
|
|||
|
|
_collectTask.ContinueWith(_ =>
|
|||
|
|
{
|
|||
|
|
lock (_rlocko)
|
|||
|
|
{
|
|||
|
|
_collectTask = null;
|
|||
|
|
}
|
|||
|
|
}, TaskContinuationOptions.ExecuteSynchronously);
|
|||
|
|
// ReSharper restore InconsistentlySynchronizedField
|
|||
|
|
|
|||
|
|
return task;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void Collect()
|
|||
|
|
{
|
|||
|
|
// see notes in CreateSnapshot
|
|||
|
|
#if DEBUG
|
|||
|
|
_logger.Debug<ContentStore2>("Collect.");
|
|||
|
|
#endif
|
|||
|
|
GenRefRef genRefRef;
|
|||
|
|
while (_genRefRefs.TryPeek(out genRefRef) && (genRefRef.Count == 0 || genRefRef.WGenRef.IsAlive == false))
|
|||
|
|
{
|
|||
|
|
_genRefRefs.TryDequeue(out genRefRef); // cannot fail since TryPeek has succeeded
|
|||
|
|
_floorGen = genRefRef.Gen;
|
|||
|
|
#if DEBUG
|
|||
|
|
//_logger.Debug<ContentStore2>("_floorGen=" + _floorGen + ", _liveGen=" + _liveGen);
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Collect(_contentNodes);
|
|||
|
|
Collect(_contentRootNodes);
|
|||
|
|
Collect(_contentTypesById);
|
|||
|
|
Collect(_contentTypesByAlias);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void Collect<TKey, TValue>(ConcurrentDictionary<TKey, LinkedNode<TValue>> dict)
|
|||
|
|
where TValue : class
|
|||
|
|
{
|
|||
|
|
// it is OK to enumerate a concurrent dictionary and it does not lock
|
|||
|
|
// it - and here it's not an issue if we skip some items, they will be
|
|||
|
|
// processed next time we collect
|
|||
|
|
|
|||
|
|
long liveGen;
|
|||
|
|
lock (_rlocko) // r is good
|
|||
|
|
{
|
|||
|
|
liveGen = _liveGen;
|
|||
|
|
if (_nextGen == false)
|
|||
|
|
liveGen += 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
foreach (var kvp in dict)
|
|||
|
|
{
|
|||
|
|
var link = kvp.Value;
|
|||
|
|
|
|||
|
|
#if DEBUG
|
|||
|
|
//_logger.Debug<ContentStore2>("Collect id:" + kvp.Key + ", gen:" + link.Gen +
|
|||
|
|
// ", nxt:" + (link.Next == null ? "null" : "link") +
|
|||
|
|
// ", val:" + (link.Value == null ? "null" : "value"));
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
// reasons to collect the head:
|
|||
|
|
// gen must be < liveGen (we never collect live gen)
|
|||
|
|
// next == null && value == null (we have no data at all)
|
|||
|
|
// next != null && value == null BUT gen > floor (noone wants us)
|
|||
|
|
// not live means .Next and .Value are safe
|
|||
|
|
if (link.Gen < liveGen && link.Value == null
|
|||
|
|
&& (link.Next == null || link.Gen <= _floorGen))
|
|||
|
|
{
|
|||
|
|
// not live, null value, no next link = remove that one -- but only if
|
|||
|
|
// the dict has not been updated, have to do it via ICollection<> (thanks
|
|||
|
|
// Mr Toub) -- and if the dict has been updated there is nothing to collect
|
|||
|
|
var idict = dict as ICollection<KeyValuePair<TKey, LinkedNode<TValue>>>;
|
|||
|
|
idict.Remove(kvp);
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// in any other case we're not collecting the head, we need to go to Next
|
|||
|
|
// and if there is no Next, skip
|
|||
|
|
if (link.Next == null)
|
|||
|
|
continue;
|
|||
|
|
|
|||
|
|
// else go to Next and loop while above floor, and kill everything below
|
|||
|
|
while (link.Next != null && link.Next.Gen > _floorGen)
|
|||
|
|
link = link.Next;
|
|||
|
|
link.Next = null;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public async Task WaitForPendingCollect()
|
|||
|
|
{
|
|||
|
|
Task task;
|
|||
|
|
lock (_rlocko)
|
|||
|
|
{
|
|||
|
|
task = _collectTask;
|
|||
|
|
}
|
|||
|
|
if (task != null)
|
|||
|
|
await task;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public long GenCount
|
|||
|
|
{
|
|||
|
|
get { return _genRefRefs.Count; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public long SnapCount
|
|||
|
|
{
|
|||
|
|
get
|
|||
|
|
{
|
|||
|
|
return _genRefRefs.Sum(x => x.Count);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region Unit testing
|
|||
|
|
|
|||
|
|
private TestHelper _unitTesting;
|
|||
|
|
|
|||
|
|
// note: nothing here is thread-safe
|
|||
|
|
internal class TestHelper
|
|||
|
|
{
|
|||
|
|
private readonly ContentStore2 _store;
|
|||
|
|
|
|||
|
|
public TestHelper(ContentStore2 store)
|
|||
|
|
{
|
|||
|
|
_store = store;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public long LiveGen { get { return _store._liveGen; } }
|
|||
|
|
public long FloorGen { get { return _store._floorGen; } }
|
|||
|
|
public bool NextGen { get { return _store._nextGen; } }
|
|||
|
|
public bool CollectAuto { get { return _store._collectAuto; } set { _store._collectAuto = value; } }
|
|||
|
|
|
|||
|
|
public Tuple<long, ContentNode>[] GetValues(int id)
|
|||
|
|
{
|
|||
|
|
LinkedNode<ContentNode> link;
|
|||
|
|
_store._contentNodes.TryGetValue(id, out link); // else null
|
|||
|
|
|
|||
|
|
if (link == null)
|
|||
|
|
return new Tuple<long, ContentNode>[0];
|
|||
|
|
|
|||
|
|
var tuples = new List<Tuple<long, ContentNode>>();
|
|||
|
|
do
|
|||
|
|
{
|
|||
|
|
tuples.Add(Tuple.Create(link.Gen, link.Value));
|
|||
|
|
link = link.Next;
|
|||
|
|
} while (link != null);
|
|||
|
|
return tuples.ToArray();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal TestHelper Test { get { return _unitTesting ?? (_unitTesting = new TestHelper(this)); } }
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region Classes
|
|||
|
|
|
|||
|
|
private class LinkedNode<TValue>
|
|||
|
|
where TValue: class
|
|||
|
|
{
|
|||
|
|
public LinkedNode(TValue value, long gen, LinkedNode<TValue> next = null)
|
|||
|
|
{
|
|||
|
|
Value = value;
|
|||
|
|
Gen = gen;
|
|||
|
|
Next = next;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal readonly long Gen;
|
|||
|
|
|
|||
|
|
// reading & writing references is thread-safe on all .NET platforms
|
|||
|
|
// mark as volatile to ensure we always read the correct value
|
|||
|
|
internal volatile TValue Value;
|
|||
|
|
internal volatile LinkedNode<TValue> Next;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public class Snapshot : IDisposable
|
|||
|
|
{
|
|||
|
|
private readonly ContentStore2 _store;
|
|||
|
|
private readonly GenRef _genRef;
|
|||
|
|
private long _gen;
|
|||
|
|
#if DEBUG
|
|||
|
|
private readonly ILogger _logger;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
//private static int _count;
|
|||
|
|
//private readonly int _thisCount;
|
|||
|
|
|
|||
|
|
internal Snapshot(ContentStore2 store, GenRef genRef
|
|||
|
|
#if DEBUG
|
|||
|
|
, ILogger logger
|
|||
|
|
#endif
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
_store = store;
|
|||
|
|
_genRef = genRef;
|
|||
|
|
_gen = genRef.Gen;
|
|||
|
|
Interlocked.Increment(ref genRef.GenRefRef.Count);
|
|||
|
|
//_thisCount = _count++;
|
|||
|
|
|
|||
|
|
#if DEBUG
|
|||
|
|
_logger = logger;
|
|||
|
|
_logger.Debug<Snapshot>("Creating snapshot.");
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public ContentNode Get(int id)
|
|||
|
|
{
|
|||
|
|
if (_gen < 0)
|
|||
|
|
throw new ObjectDisposedException("snapshot" /*+ " (" + _thisCount + ")"*/);
|
|||
|
|
return _store.Get(id, _gen);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public IEnumerable<ContentNode> GetAtRoot()
|
|||
|
|
{
|
|||
|
|
if (_gen < 0)
|
|||
|
|
throw new ObjectDisposedException("snapshot" /*+ " (" + _thisCount + ")"*/);
|
|||
|
|
return _store.GetAtRoot(_gen);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public PublishedContentType GetContentType(int id)
|
|||
|
|
{
|
|||
|
|
if (_gen < 0)
|
|||
|
|
throw new ObjectDisposedException("snapshot" /*+ " (" + _thisCount + ")"*/);
|
|||
|
|
return _store.GetContentType(id, _gen);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public PublishedContentType GetContentType(string alias)
|
|||
|
|
{
|
|||
|
|
if (_gen < 0)
|
|||
|
|
throw new ObjectDisposedException("snapshot" /*+ " (" + _thisCount + ")"*/);
|
|||
|
|
return _store.GetContentType(alias, _gen);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public bool IsEmpty
|
|||
|
|
{
|
|||
|
|
get
|
|||
|
|
{
|
|||
|
|
if (_gen < 0)
|
|||
|
|
throw new ObjectDisposedException("snapshot" /*+ " (" + _thisCount + ")"*/);
|
|||
|
|
return _store.IsEmpty(_gen);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public long Gen
|
|||
|
|
{
|
|||
|
|
get
|
|||
|
|
{
|
|||
|
|
if (_gen < 0)
|
|||
|
|
throw new ObjectDisposedException("snapshot" /*+ " (" + _thisCount + ")"*/);
|
|||
|
|
return _gen;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void Dispose()
|
|||
|
|
{
|
|||
|
|
if (_gen < 0) return;
|
|||
|
|
#if DEBUG
|
|||
|
|
_logger.Debug<Snapshot>("Dispose snapshot (" + _genRef.GenRefRef.Count + ").");
|
|||
|
|
#endif
|
|||
|
|
_gen = -1;
|
|||
|
|
Interlocked.Decrement(ref _genRef.GenRefRef.Count);
|
|||
|
|
GC.SuppressFinalize(this);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal class GenRefRef
|
|||
|
|
{
|
|||
|
|
public GenRefRef(long gen)
|
|||
|
|
{
|
|||
|
|
Gen = gen;
|
|||
|
|
WGenRef = new WeakReference(null);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public GenRef GetGenRef()
|
|||
|
|
{
|
|||
|
|
// not thread-safe but always invoked from within a lock
|
|||
|
|
var genRef = (GenRef) WGenRef.Target;
|
|||
|
|
if (genRef == null)
|
|||
|
|
WGenRef.Target = genRef = new GenRef(this, Gen);
|
|||
|
|
return genRef;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public readonly long Gen;
|
|||
|
|
public readonly WeakReference WGenRef;
|
|||
|
|
public int Count;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal class GenRef
|
|||
|
|
{
|
|||
|
|
public GenRef(GenRefRef genRefRef, long gen)
|
|||
|
|
{
|
|||
|
|
GenRefRef = genRefRef;
|
|||
|
|
Gen = gen;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public readonly GenRefRef GenRefRef;
|
|||
|
|
public readonly long Gen;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
}
|
|||
|
|
}
|