public async Task AquireLockTest()
{
var duration = TimeSpan.FromSeconds(15);
var name = "constantinos"; // using a random name :)
var @lock = await _LockManager.AcquireLock(name, duration);
using (@lock) {
await Task.Delay(TimeSpan.FromSeconds(0.5));
}
var @lock2 = await _LockManager.AcquireLock(name, duration);
using (@lock2) {
await Task.Delay(TimeSpan.FromSeconds(0.5));
}
}
public async Task <Releaser> AcquireLock(ulong pageId, LockTypeEnum lockType)
{
int lockId = lockManager.LockIdForPage(pageId);
if (lockType != LockTypeEnum.Shared)
{
throw new ReadOnlyTranCantAcquireExLockException();
}
lock (lck)
{
if (locksHeld.ContainsKey(lockId))
{
// Return dummy leaser. You don't really own this lock.
// This probably needs to change.
throw new TranAlreadyHoldingLock();
}
}
var releaser = await lockManager.AcquireLock(lockType, pageId, this.transactionId);
lock (lck)
{
locksHeld.Add(lockId, lockType);
}
releaser.SetReleaseCallback(() => this.ReleaseLock(lockId));
return(releaser);
}
/// <summary>
/// Try Aquire the lock. If success it will return a successful <see cref="LockLeaseResult"/>.
/// If the lockmanger throws a <seealso cref="LockManagerLockException"/> it will catch that and return a failed <see cref="LockLeaseResult"/>
/// </summary>
/// <param name="manager"></param>
/// <param name="name"></param>
/// <returns></returns>
public static async Task <LockLeaseResult> TryAquireLock(this ILockManager manager, string name)
{
try {
var @lock = await manager.AcquireLock(name);
return(LockLeaseResult.Success(@lock));
} catch (LockManagerLockException) {
return(LockLeaseResult.Fail());
}
}
/// <summary>
/// Try aquire the lock. If success it will return a successful <see cref="LockLeaseResult"/>.
/// If the <see cref="ILockManager"/> throws a <seealso cref="LockManagerException"/> it will catch that and return a failed <see cref="LockLeaseResult"/>.
/// </summary>
/// <param name="manager">The instance of <see cref="ILockManager"/>.</param>
/// <param name="name">Topic or name.</param>
/// <param name="duration">The duration the lease will be active. Defaults 30 seconds.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>The task the represent the asynchronous operation result for acquiring the lock.</returns>
public static async Task <LockLeaseResult> TryAcquireLock(this ILockManager manager, string name, TimeSpan?duration = null, CancellationToken cancellationToken = default)
{
try {
var @lock = await manager.AcquireLock(name, duration, cancellationToken);
return(LockLeaseResult.Success(@lock));
} catch (LockManagerException) {
return(LockLeaseResult.Fail());
}
}
private async Task <Releaser> AcquireLockInternal(ulong pageId, LockTypeEnum lockType, bool forceCallerOwnership)
{
ILockManager lockManager = this.pageManager.GetLockManager();
int lockId = lockManager.LockIdForPage(pageId);
lock (lck)
{
if (locksHeld.ContainsKey(lockId))
{
return(new Releaser());
}
}
var releaser = await lockManager.AcquireLock(lockType, pageId, this.transactionId).ConfigureAwait(continueOnCapturedContext: false);
lock (lck)
{
locksHeld.Add(lockId, lockType);
}
releaser.SetReleaseCallback(() => this.ReleaseLockCallback(lockId));
if (forceCallerOwnership)
{
return(releaser);
}
// TODO: Implement Isolation Level strategy.
if (this.isolationLevel == IsolationLevelEnum.ReadCommitted)
{
// If this is a read lock return to caller.
// If write transaction is the owner.
if (lockType == LockTypeEnum.Shared)
{
return(releaser);
}
else if (lockType == LockTypeEnum.Exclusive)
{
this.myLocks.Add(releaser);
return(new Releaser());
}
else
{
throw new InvalidProgramException();
}
}
else
{
throw new InvalidProgramException();
}
}
/// <summary>
/// Obtains an exclusive lock according to the specified <see cref="LockToken" />,
/// then executes the specified <see cref="Action" /> before releasing the lock.
/// </summary>
/// <param name="token">The token dictating the scope and behavior of execution.</param>
/// <param name="action">The action to execute.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="token" /> is null.
/// <para>or</para>
/// <paramref name="action" /> is null.
/// </exception>
/// <exception cref="AcquireLockTimeoutException">The lock could not be obtained within the acquisition timeout specified by <paramref name="token" />.</exception>
/// <exception cref="HoldLockTimeoutException"><paramref name="action" /> did not complete within the hold timeout specified by <paramref name="token" />.</exception>
public void Run(LockToken token, Action action)
{
if (token == null)
{
throw new ArgumentNullException(nameof(token));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
LockTicket lockTicket = _lockManager.AcquireLock(token.Key, token.AcquireTimeout, 1, _requestName);
try
{
RunAction(token, action);
}
finally
{
_lockManager.ReleaseLock(lockTicket);
}
}
public ActionResult <SampleDTO> Get(int id)
{
using (_lockManager.AcquireLock("temp", TimeSpan.FromSeconds(30)))
{
Console.WriteLine("111");
//Thread.Sleep(15 * 1000);
}
var sample = new Sample()
{
Value = 11
};
//this._eventPublisher.Publish(sample);
//_logger.LogWarning("{@sample}", sample);
_cacheManager.SetAsync <Sample>("sample", sample, 60);
return(_mapper.Map <Sample, SampleDTO>(_cacheManager.GetAsync("sample", () => Task.FromResult(new Sample())).Result));
}