public Task <bool> UpdateAsync(IActiveLock activeLock, CancellationToken cancellationToken)
{
var isUpdating = _locks.ContainsKey(activeLock.StateToken);
_locks[activeLock.StateToken] = ToActiveLock(activeLock);
return(Task.FromResult(isUpdating));
}
/// <summary>
/// Adds a lock to be tracked by this cleanup task.
/// </summary>
/// <param name="lockManager">The lock manager that created this active lock.</param>
/// <param name="activeLock">The active lock to track</param>
public void Add(ILockManager lockManager, IActiveLock activeLock)
{
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace($"Adding lock {activeLock}");
}
// Don't track locks with infinite timeout
if (activeLock.Timeout == TimeoutHeader.Infinite)
{
return;
}
lock (_syncRoot)
{
var newLockItem = new ActiveLockItem(lockManager, activeLock);
_activeLocks.Add(activeLock.Expiration, newLockItem);
if (_mostRecentExpirationLockItem != null &&
newLockItem.Expiration >= _mostRecentExpirationLockItem.Expiration)
{
// New item is not the most recent to expire
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"New lock {activeLock.StateToken} item is not the most recent item");
}
return;
}
_mostRecentExpirationLockItem = newLockItem;
ConfigureTimer(newLockItem);
}
}
public Task <bool> UpdateAsync(IActiveLock activeLock, CancellationToken cancellationToken)
{
var entry = ToEntry(activeLock);
_connection.InsertOrReplace(entry);
return(Task.FromResult(true));
}
public Task <bool> AddAsync(IActiveLock activeLock, CancellationToken cancellationToken)
{
var entry = ToEntry(activeLock);
var affectedRows = _connection.Insert(entry);
return(Task.FromResult(affectedRows != 0));
}
private static ActiveLock ToActiveLock(IActiveLock activeLock)
{
if (activeLock is ActiveLock l)
{
return(l);
}
return(_mapper.Map <ActiveLock>(activeLock));
}
/// <inheritdoc />
public Task <bool> AddAsync(IActiveLock activeLock, CancellationToken cancellationToken)
{
if (_locks.ContainsKey(activeLock.StateToken))
{
return(Task.FromResult(false));
}
_locks = _locks.Add(activeLock.StateToken, activeLock);
return(Task.FromResult(true));
}
/// <inheritdoc />
public Task <bool> UpdateAsync(IActiveLock activeLock, CancellationToken cancellationToken)
{
var hadKey = _locks.ContainsKey(activeLock.StateToken);
if (hadKey)
{
_locks = _locks.Remove(activeLock.StateToken);
}
_locks = _locks.Add(activeLock.StateToken, activeLock);
return(Task.FromResult(hadKey));
}
/// <summary>
/// Removes the active lock so that it isn't tracked any more by this cleanup task.
/// </summary>
/// <param name="activeLock">The active lock to remove</param>
public void Remove(IActiveLock activeLock)
{
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace($"Try removing lock {activeLock}");
}
lock (_syncRoot)
{
IReadOnlyCollection <ActiveLockItem> lockItems;
if (!_activeLocks.TryGetValue(activeLock.Expiration, out lockItems))
{
// Lock item not found
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"Lock {activeLock.StateToken} is not tracked any more.");
}
return;
}
var lockItem = lockItems
.FirstOrDefault(x => string.Equals(x.ActiveLock.StateToken, activeLock.StateToken, StringComparison.Ordinal));
if (lockItem == null)
{
// Lock item not found
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"Lock {activeLock.StateToken} is not tracked any more.");
}
return;
}
// Remove lock item
_activeLocks.Remove(lockItem.Expiration, lockItem);
if (_mostRecentExpirationLockItem != null && lockItem.ActiveLock.StateToken == _mostRecentExpirationLockItem.ActiveLock.StateToken)
{
// Removed lock item was the most recent
_mostRecentExpirationLockItem = FindMostRecentExpirationItem();
if (_mostRecentExpirationLockItem != null)
{
// Found a new one and reconfigure timer
ConfigureTimer(_mostRecentExpirationLockItem);
}
else if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("No more locks to cleanup.");
}
}
}
}
private static ActiveLock Refresh(IActiveLock activeLock, DateTime lastRefresh, TimeSpan timeout)
{
return(new ActiveLock(
activeLock.Path,
activeLock.Href,
activeLock.Recursive,
activeLock.GetOwner(),
LockAccessType.Parse(activeLock.AccessType),
LockShareMode.Parse(activeLock.ShareMode),
timeout,
activeLock.Issued,
lastRefresh,
activeLock.StateToken));
}
private ActiveLockEntry ToEntry(IActiveLock activeLock)
{
return(activeLock as ActiveLockEntry
?? new ActiveLockEntry()
{
StateToken = activeLock.StateToken,
Path = activeLock.Path,
Recursive = activeLock.Recursive,
Href = activeLock.Href,
Owner = activeLock.GetOwner()?.ToString(SaveOptions.OmitDuplicateNamespaces),
AccessType = activeLock.AccessType,
ShareMode = activeLock.ShareMode,
Timeout = activeLock.Timeout,
Expiration = activeLock.Expiration,
Issued = activeLock.Issued,
LastRefresh = activeLock.LastRefresh,
});
}
/// <summary>
/// Creates an <see cref="XElement"/> for a <see cref="IActiveLock"/>
/// </summary>
/// <param name="l">The active lock to create the <see cref="XElement"/> for</param>
/// <param name="omitOwner">Should the owner be omitted?</param>
/// <param name="omitToken">Should the lock state token be omitted?</param>
/// <returns>The newly created <see cref="XElement"/> for the active lock</returns>
public static XElement ToXElement(this IActiveLock l, bool omitOwner = false, bool omitToken = false)
{
var timeout = l.Timeout == TimeoutHeader.Infinite ? "Infinite" : $"Second-{l.Timeout.TotalSeconds:F0}";
var depth = l.Recursive ? DepthHeader.Infinity : DepthHeader.Zero;
var lockScope = LockShareMode.Parse(l.ShareMode);
var lockType = LockAccessType.Parse(l.AccessType);
var owner = l.GetOwner();
var result = new XElement(
WebDavXml.Dav + "activelock",
new XElement(
WebDavXml.Dav + "lockscope",
new XElement(lockScope.Name)),
new XElement(
WebDavXml.Dav + "locktype",
new XElement(lockType.Name)),
new XElement(
WebDavXml.Dav + "depth",
depth.Value));
if (owner != null && !omitOwner)
{
result.Add(owner);
}
result.Add(
new XElement(
WebDavXml.Dav + "timeout",
timeout));
if (!omitToken)
{
result.Add(
new XElement(
WebDavXml.Dav + "locktoken",
new XElement(WebDavXml.Dav + "href", l.StateToken)));
}
result.Add(
new XElement(
WebDavXml.Dav + "lockroot",
new XElement(WebDavXml.Dav + "href", l.Href)));
return(result);
}
public ActiveLockItem(ILockManager lockManager, IActiveLock activeLock)
{
LockManager = lockManager;
ActiveLock = activeLock;
}
/// <summary>
/// Gets called when a lock was released
/// </summary>
/// <param name="activeLock">The lock that was released</param>
protected virtual void OnLockReleased(IActiveLock activeLock)
{
LockReleased?.Invoke(this, new LockEventArgs(activeLock));
}
public ActiveLockItem([NotNull] ILockManager lockManager, [NotNull] IActiveLock activeLock)
{
LockManager = lockManager;
ActiveLock = activeLock;
}
/// <summary>
/// Initializes a new instance of the <see cref="LockResult"/> class.
/// </summary>
/// <param name="activeLock">The active lock when locking succeeded</param>
public LockResult(IActiveLock activeLock)
{
Lock = activeLock;
}
/// <summary>
/// Initializes a new instance of the <see cref="LockEventArgs"/> class.
/// </summary>
/// <param name="activeLock">The lock that got added to or remoted from the lock manager</param>
public LockEventArgs(IActiveLock activeLock)
{
Lock = activeLock;
}