private void InstanciateDummySharedObject()
{
AsyncDummySharedObjectId = SharedObjectId.FromString("AsyncDummySharedObjectId");
AsyncDummySharedObject = new DummySharedObject
{
DummyObjectName = "AsyncDummySharedObjectName",
DummyObjectValue = "AsyncDummySharedObjectValue"
};
DummySharedObjectId = SharedObjectId.FromString("DummySharedObjectId");
DummySharedObject = new DummySharedObject
{
DummyObjectName = "DummySharedObjectName",
DummyObjectValue = "DummySharedObjectValue"
};
}
private static RedisKey KeyOf(SharedObjectId sharedObjectId)
{
var key = (RedisKey)sharedObjectId.Value;
return key;
}
public async Task<object> ReadAsync(Type objectType, SharedObjectId sharedObjectId)
{
CheckObjectIsNotLockedBySomeoneElse(sharedObjectId);
var key = KeyOf(sharedObjectId);
var valueWithExpire = await Db.StringGetWithExpiryAsync(key);
if (IsObjectExpired(valueWithExpire))
return null;
var sharedObject = await DeserializeAsync(valueWithExpire.Value, objectType);
return sharedObject;
}
public async Task InsertAsync(SharedObjectId sharedObjectId, object sharedObject, TimeSpan objectLifespan = default(TimeSpan))
{
CheckObjectIsNotLockedBySomeoneElse(sharedObjectId);
var key = KeyOf(sharedObjectId);
var value = await SerializeAsync(sharedObject);
var timeout = objectLifespan != default(TimeSpan) ? objectLifespan : DefaultObjectLifeSpan;
var success = await Db.StringSetAsync(key, value, timeout, When.NotExists);
if (!success) throw new InvalidOperationException(String.Format("Could not insert object {0}", sharedObjectId));
}
public async Task UpdateAsync(SharedObjectId sharedObjectId, object sharedObject, TimeSpan objectTimeout = default(TimeSpan))
{
CheckObjectIsNotLockedBySomeoneElse(sharedObjectId);
var key = KeyOf(sharedObjectId);
var value = await SerializeAsync(sharedObject);
var timeout = objectTimeout;
if (timeout == default(TimeSpan))
{
var currentValueWithExpiry = Db.StringGetWithExpiry(key);
if (currentValueWithExpiry.Expiry != null)
timeout = currentValueWithExpiry.Expiry.Value;
}
var success = await Db.StringSetAsync(key, value, timeout, When.Exists);
if (!success) throw new InvalidOperationException(String.Format("Could not update object {0}", sharedObjectId));
}
public async Task RemoveAsync(SharedObjectId sharedObjectId)
{
CheckObjectIsNotLockedBySomeoneElse(sharedObjectId);
var key = KeyOf(sharedObjectId);
var success = await Db.KeyDeleteAsync(key);
if (!success) throw new InvalidOperationException(String.Format("Could not remove object {0}", sharedObjectId));
}
public object Read(Type objectType, SharedObjectId sharedObjectId)
{
CheckObjectIsNotLockedBySomeoneElse(sharedObjectId);
var key = KeyOf(sharedObjectId);
var valueWithExpire = Db.StringGetWithExpiry(key);
if (IsObjectExpired(valueWithExpire))
return null;
var sharedObject = Deserialize(valueWithExpire.Value, objectType);
return sharedObject;
}
private static FileBasedKey LockKeyFor(SharedObjectId sharedObjectId)
{
var key = (FileBasedKey)("LockFor" + sharedObjectId.Value);
return key;
}
public void Unlock(SharedObjectId sharedObjectId)
{
CheckObjectIsLocked(sharedObjectId);
CheckObjectIsNotLockedBySomeoneElse(sharedObjectId);
var lockKey = LockKeyFor(sharedObjectId);
var lockValue = LockValueFor(sharedObjectId);
// Remove the key representing the lock
Db.KeyDelete(lockKey);
Log.Info("Lock with key {0} and value {1} for shared object of id {2} RELEASED",
lockKey, lockValue, sharedObjectId);
}
public void Lock(SharedObjectId sharedObjectId, TimeSpan acquireTimeout, TimeSpan lockDuration = default(TimeSpan))
{
var lockKey = LockKeyFor(sharedObjectId);
var lockValue = LockValueFor(sharedObjectId);
var lockAcquired = false;
var sw = new Stopwatch();
sw.Start();
acquireTimeout = acquireTimeout != default(TimeSpan) ? acquireTimeout : DefaultAcquireLockTimeout;
lockDuration = lockDuration != default(TimeSpan) ? lockDuration : DefaultLockDuration;
while (!lockAcquired && sw.Elapsed < acquireTimeout)
{
// Returns true only if the string was set. It means, if there is no previous value with this key
lockAcquired = Db.StringSet(lockKey, lockValue, lockDuration, When.NotExists);
Thread.Sleep(10);
lockAcquired = lockAcquired && lockValue == Db.StringGet(lockKey);
}
sw.Stop();
if (lockAcquired)
{
Log.Info("Lock with key {0} and value {1} for shared object of id {2} and duration {3} ACQUIRED!",
lockKey, lockValue, sharedObjectId, lockDuration);
}
else
{
Log.Error("Lock with key {0} and value {1} for shared object of id {2} and duration {3} COULD NOT BE ACQUIRED!",
lockKey, lockValue, sharedObjectId, lockDuration);
throw new CouldNotAcquireLockException(sharedObjectId);
}
}
private RedisValue LockValueFor(SharedObjectId sharedObjectId)
{
return Serialize(sharedObjectId + "@" + RedisSharedMemoryId);
}
private void CheckObjectIsNotLockedBySomeoneElse(SharedObjectId sharedObjectId)
{
var lockKey = LockKeyFor(sharedObjectId);
var expectedLockValue = LockValueFor(sharedObjectId);
var lockValue = Db.StringGet(lockKey);
var isLockedBySomeoneElse = !lockValue.IsNull && lockValue != expectedLockValue;
if (isLockedBySomeoneElse)
throw new AccessLockedException(sharedObjectId);
}
private void CheckObjectIsLocked(SharedObjectId sharedObjectId)
{
var isLocked = IsLocked(sharedObjectId);
if (!isLocked)
throw new AccessShouldBeLockedException(sharedObjectId);
}
private FileBasedValue LockValueFor(SharedObjectId sharedObjectId)
{
return Serialize(sharedObjectId + "@" + FileBasedSharedMemoryId);
}
private static RedisKey LockKeyFor(SharedObjectId sharedObjectId)
{
var key = (RedisKey)("LockFor" + sharedObjectId.Value);
return key;
}
public bool IsLocked(SharedObjectId sharedObjectId)
{
var lockKey = LockKeyFor(sharedObjectId);
LockValueFor(sharedObjectId);
var lockValue = Db.StringGet(lockKey);
return !lockValue.IsNull;
}
private static FileBasedKey KeyOf(SharedObjectId sharedObjectId)
{
var key = (FileBasedKey)sharedObjectId.Value;
return key;
}
