void ICompactSerializable.Deserialize(CompactReader reader)
{
_lockId=reader.ReadObject();
_lockDate = reader.ReadDateTime();
_lockExpiration = reader.ReadObject() as LockExpiration;
_lockManager = reader.ReadObject() as LockManager;
}
void ICompactSerializable.Deserialize(CompactReader reader)
{
_lockId = reader.ReadObject();
_lockDate = reader.ReadDateTime();
_lockExpiration = reader.ReadObject() as LockExpiration;
_lockManager = reader.ReadObject() as LockManager;
}
public LockExpiration DeepClone(PoolManager poolManager)
{
var clonedLockExpiration = new LockExpiration();
clonedLockExpiration._lastTimeStamp = _lastTimeStamp;
clonedLockExpiration._lockTTL = _lockTTL;
clonedLockExpiration._ttl = _ttl;
return(clonedLockExpiration);
}
public override LockOptions Lock(object key, LockExpiration lockExpiration, ref object lockId, ref DateTime lockDate, OperationContext operationContext)
{
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("RepCache.Lock", "");
if (Cluster.Servers.Count > 1)
{
Clustered_Lock(key, lockExpiration, ref lockId, ref lockDate, operationContext);
return new LockOptions(lockId, lockDate);
}
else
{
return Local_Lock(key, lockExpiration, lockId, lockDate, operationContext);
}
}
/// <summary>
/// Retrieve the object from the local cache only.
/// </summary>
/// <param name="key">key of the entry.</param>
/// <returns>cache entry.</returns>
private CacheEntry Local_Get(object key, ref object lockId, ref DateTime lockDate, LockExpiration lockExpiration, LockAccessType access, OperationContext operationContext)
{
CacheEntry retVal = null;
if (_internalCache != null)
retVal = _internalCache.Get(key, ref lockId, ref lockDate, lockExpiration, access, operationContext);
return retVal;
}
public override LockOptions Lock(object key, LockExpiration lockExpiration, ref object lockId, ref DateTime lockDate, OperationContext operationContext)
{
return Internal.Lock(key, lockExpiration, ref lockId, ref lockDate, operationContext);
}
public void CopyLock(object lockId, DateTime lockDate, LockExpiration lockExpiration)
{
lock (this)
{
if(lockId != null)
this.Flag.SetBit(BitSetConstants.LockedItem);
else
this.Flag.UnsetBit(BitSetConstants.LockedItem);
this.LockId = lockId;
this.LockDate = lockDate;
this.LockExpiration = lockExpiration;
}
}
/// <summary>
/// Retrieve the object from the cache. A string key is passed as parameter.
/// </summary>
/// <param name="key">key of the entry.</param>
/// <param name="lockId"></param>
/// <param name="lockDate"></param>
/// <param name="lockExpiration"></param>
/// <param name="accessType"></param>
/// <param name="operationContext"></param>
/// <returns>cache entry.</returns>
public sealed override CacheEntry Get(object key, ref object lockId, ref DateTime lockDate, LockExpiration lockExpiration, LockAccessType accessType, OperationContext operationContext)
{
return Get(key, true, ref lockId, ref lockDate, lockExpiration, accessType, operationContext);
}
public override LockOptions Lock(object key, LockExpiration lockExpiration, ref object lockId, ref DateTime lockDate, OperationContext operationContext)
{
LockOptions lockInfo = new LockOptions();
CacheEntry e = GetInternal(key, false, operationContext);
if (e != null)
{
e.Lock(lockExpiration, ref lockId, ref lockDate);
lockInfo.LockDate = lockDate;
lockInfo.LockId = lockId;
return lockInfo;
}
else
{
lockInfo.LockId = lockId = null;
return lockInfo;
}
}
private LockOptions Local_Lock(object key, LockExpiration lockExpiration, object lockId, DateTime lockDate, OperationContext operationContext)
{
if (_internalCache != null)
return _internalCache.Lock(key, lockExpiration, ref lockId, ref lockDate, operationContext);
return null;
}
/// <summary>
/// Retrieve the object from the cluster.
/// </summary>
/// <param name="key">key of the entry.</param>
/// <param name="excludeSelf">Set false to do a complete cluster lookup.</param>
/// <returns>cache entry.</returns>
protected CacheEntry Clustered_Get(Address address, object key, ref object lockId, ref DateTime lockDate, LockExpiration lockExpiration, LockAccessType access, OperationContext operationContext)
{
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustCacheBase.Get", "");
CacheEntry retVal = null;
try
{
Function func = new Function((int)OpCodes.Get, new object[] { key, lockId, lockDate, access, lockExpiration, operationContext });
object result = Cluster.SendMessage(address, func, GetFirstResponse);
if (result == null)
{
return retVal;
}
object[] objArr = (object[])((OperationResponse)result).SerializablePayload;
retVal = objArr[0] as CacheEntry;
if (retVal != null)
{
retVal.Value = ((OperationResponse)result).UserPayload;
}
lockId = objArr[1];
lockDate = (DateTime)objArr[2];
}
catch (Runtime.Exceptions.TimeoutException te)
{
throw;
}
catch (Runtime.Exceptions.SuspectedException se)
{
throw;
}
catch (CacheException e)
{
throw;
}
catch (Exception e)
{
throw new GeneralFailureException(e.Message, e);
}
return retVal;
}
/// <summary>
/// Retrieve the object from the cache. A string key is passed as parameter.
/// </summary>
/// <param name="key">key of the entry.</param>
/// <param name="lockId"></param>
/// <param name="lockDate"></param>
/// <param name="lockExpiration"></param>
/// <param name="accessType"></param>
/// <param name="operationContext"></param>
/// <returns>cache entry.</returns>
public virtual CacheEntry Get(object key, ref object lockId, ref DateTime lockDate, LockExpiration lockExpiration, LockAccessType accessType, OperationContext operationContext)
{
lockId = null;
lockDate = DateTime.Now;
return null;
}
public virtual LockOptions Lock(object key, LockExpiration lockExpiration, ref object lockId, ref DateTime lockDate, OperationContext operationContext)
{
lockId = null;
lockDate = DateTime.Now;
return null;
}
public virtual CacheEntry Get(object key, bool isUserOperation, ref object lockId, ref DateTime lockDate, LockExpiration lockExpiration, LockAccessType accessType, OperationContext operationContext)
{
return null;
}
internal virtual void UpdateLockInfo(object key, object lockId, DateTime lockDate, LockExpiration lockExpiration, OperationContext operationContext)
{
}
public CompressedValueEntry Get(object key, BitSet flagMap,ref object lockId, ref DateTime lockDate, TimeSpan lockTimeout, LockAccessType accessType, OperationContext operationContext)
{
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("Cache.GetGrp", "");
// Cache has possibly expired so do default.
if (!IsRunning) return null;
CompressedValueEntry result = new CompressedValueEntry();
CacheEntry e = null;
try
{
_context.PerfStatsColl.MsecPerGetBeginSample();
_context.PerfStatsColl.IncrementGetPerSecStats();
_context.PerfStatsColl.IncrementHitsRatioPerSecBaseStats();
HPTimeStats getTime = new HPTimeStats();
getTime.BeginSample();
LockExpiration lockExpiration = null;
if (accessType == LockAccessType.ACQUIRE)
{
lockId = GetLockId(key);
lockDate = DateTime.UtcNow;
if (!TimeSpan.Equals(lockTimeout, TimeSpan.Zero))
{
lockExpiration = new LockExpiration(lockTimeout);
}
}
object generatedLockId = lockId;
e = _context.CacheImpl.Get(key, ref lockId, ref lockDate, lockExpiration, accessType, operationContext);
if (e == null && accessType == LockAccessType.ACQUIRE)
{
if (lockId == null || generatedLockId.Equals(lockId))
{
lockId = null;
lockDate = new DateTime();
}
}
if (flagMap != null)
{
if (e != null)
{
/// increment the counter for hits/sec
_context.PerfStatsColl.MsecPerGetEndSample();
result.Value = e.Value;
result.Flag = e.Flag;
}
}
_context.PerfStatsColl.MsecPerGetEndSample();
getTime.EndSample();
/// update the counter for hits/sec or misses/sec
if (result.Value != null)
{
_context.PerfStatsColl.IncrementHitsRatioPerSecStats();
_context.PerfStatsColl.IncrementHitsPerSecStats();
}
else
{
_context.PerfStatsColl.IncrementMissPerSecStats();
}
if (result.Value is CallbackEntry)
result.Value = ((CallbackEntry)result.Value).Value;
}
catch (OperationFailedException inner)
{
if (inner.IsTracable) _context.NCacheLog.Error("Cache.Get()", "Get operation failed. Error : " + inner.ToString());
throw;
}
catch (Exception inner)
{
_context.NCacheLog.Error("Cache.Get()", "Get operation failed. Error : " + inner.ToString());
throw new OperationFailedException("Get operation failed. Error :" + inner.Message, inner);
}
return result;
}
public bool Lock(object key, TimeSpan lockTimeout, out object lockId, out DateTime lockDate, OperationContext operationContext)
{
lockId = null;
lockDate = DateTime.UtcNow;
LockExpiration lockExpiration = null;
if (!TimeSpan.Equals(lockTimeout, TimeSpan.Zero))
{
lockExpiration = new LockExpiration(lockTimeout);
}
if (IsRunning)
{
object generatedLockId = lockId = GetLockId(key);
LockOptions lockInfo = _context.CacheImpl.Lock(key, lockExpiration, ref lockId, ref lockDate, operationContext);
if (lockInfo != null)
{
lockId = lockInfo.LockId;
lockDate = lockInfo.LockDate;
if (generatedLockId.Equals(lockInfo.LockId))
return true;
return false;
}
else
{
lockId = null;
return false;
}
}
return false;
}
/// <summary>
/// Get the CacheEntry stored in the cache.
/// </summary>
/// <param name="key">The key used as reference to find the desired object</param>
/// <param name="lockId"></param>
/// <param name="lockDate"></param>
/// <param name="lockTimeout"></param>
/// <param name="accessType"></param>
/// <param name="operationContext"></param>
/// <returns>Returns a CacheEntry</returns>
public object GetCacheEntry(object key, ref object lockId, ref DateTime lockDate, TimeSpan lockTimeout, LockAccessType accessType, OperationContext operationContext)
{
if (key == null) throw new ArgumentNullException("key");
if (!key.GetType().IsSerializable)
throw new ArgumentException("key is not serializable");
// Cache has possibly expired so do default.
if (!IsRunning) return null;
try
{
_context.PerfStatsColl.MsecPerGetBeginSample();
_context.PerfStatsColl.IncrementGetPerSecStats();
CacheEntry entry = null;
LockExpiration lockExpiration = null;
//if lockId will be empty if item is not already lock provided by user
if ((lockId != null && lockId.ToString() == "") || lockId == null)
{
if (accessType == LockAccessType.ACQUIRE)
{
lockId = GetLockId(key);
lockDate = DateTime.Now;
if (!TimeSpan.Equals(lockTimeout, TimeSpan.Zero))
{
lockExpiration = new LockExpiration(lockTimeout);
}
}
}
object generatedLockId = lockId;
// if only key is provided by user
if ((accessType == LockAccessType.IGNORE_LOCK || accessType == LockAccessType.DONT_ACQUIRE))
{
entry = _context.CacheImpl.Get(key, operationContext);
}
//if key and locking information is provided by user
else
{
entry = _context.CacheImpl.Get(key, ref lockId, ref lockDate, lockExpiration, accessType, operationContext);
}
if (entry == null && accessType == LockAccessType.ACQUIRE)
{
if (lockId == null || generatedLockId.Equals(lockId))
{
lockId = null;
lockDate = new DateTime();
}
}
_context.PerfStatsColl.MsecPerGetEndSample();
if (entry != null)
{
_context.PerfStatsColl.IncrementHitsPerSecStats();
}
else
{
_context.PerfStatsColl.IncrementMissPerSecStats();
}
return entry;
}
catch (OperationFailedException inner)
{
if (inner.IsTracable) _context.NCacheLog.Error("Cache.Get()", inner.ToString());
throw;
}
catch (Exception inner)
{
_context.NCacheLog.Error("Cache.Get()", inner.ToString());
throw new OperationFailedException("Get operation failed. Error : " + inner.Message, inner);
}
}
protected LockOptions Clustered_Lock(Address address, object key, LockExpiration lockExpiration, ref object lockId, ref DateTime lockDate, OperationContext operationContext)
{
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("ClustCacheBase.Lock", "");
LockOptions retVal = null;
try
{
Function func = new Function((int)OpCodes.LockKey, new object[] { key, lockId, lockDate, lockExpiration, operationContext });
object result = Cluster.SendMessage(address, func, GroupRequest.GET_FIRST);
if (result == null)
{
return retVal;
}
retVal = result as LockOptions;
if (retVal != null)
{
lockId = retVal.LockId;
lockDate = retVal.LockDate;
}
}
catch (Runtime.Exceptions.TimeoutException te)
{
throw;
}
catch (Runtime.Exceptions.SuspectedException se)
{
throw;
}
catch (CacheException e)
{
throw;
}
catch (Exception e)
{
throw new GeneralFailureException(e.Message, e);
}
return retVal;
}
/// <summary>
/// Retrieve the object from the cache. A string key is passed as parameter.
/// </summary>
/// <param name="key">key of the entry.</param>
/// <param name="lockId"></param>
/// <param name="lockDate"></param>
/// <param name="lockExpiration"></param>
/// <param name="access"></param>
/// <param name="operationContext"></param>
/// <returns>cache entry.</returns>
public override CacheEntry Get(object key, ref object lockId, ref DateTime lockDate,
LockExpiration lockExpiration, LockAccessType access, OperationContext operationContext)
{
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("PrtCache.Get", "");
/// Wait until the object enters the running status
_statusLatch.WaitForAny(NodeStatus.Running);
if (_internalCache == null) throw new InvalidOperationException();
Address address = null;
CacheEntry e = null;
bool suspectedErrorOccured = false;
while (true)
{
address = GetNextNode(key as string);
if (address == null)
{
NCacheLog.Error("PartitionedServerCache.Get()", "specified key does not map to any node. return.");
return null;
}
try
{
if (address.CompareTo(Cluster.LocalAddress) == 0)
{
e = Local_Get(key, ref lockId, ref lockDate, lockExpiration, access, operationContext);
}
else
{
e = Clustered_Get(address, key, ref lockId, ref lockDate, lockExpiration, access,
operationContext);
}
if (e == null)
{
_stats.BumpMissCount();
}
else
{
_stats.BumpHitCount();
}
break;
}
catch (Runtime.Exceptions.SuspectedException se)
{
suspectedErrorOccured = true;
//we redo the operation
if (NCacheLog.IsInfoEnabled)
NCacheLog.Info("PartitionedServerCache.Get",
address + " left while Get. Error: " + se.ToString());
continue;
}
catch (Runtime.Exceptions.TimeoutException te)
{
if (NCacheLog.IsInfoEnabled)
NCacheLog.Info("PartitionedServerCache.Get",
address + " operation timed out. Error: " + te.ToString());
if (suspectedErrorOccured)
{
suspectedErrorOccured = false;
continue;
}
else
{
throw new GeneralFailureException(te.Message, te);
}
}
catch (Alachisoft.NCache.Caching.Exceptions.StateTransferException se)
{
_distributionMgr.Wait(key);
}
}
return e;
}
protected bool Clustered_Lock(object key, LockExpiration lockExpiration, ref object lockId, ref DateTime lockDate, OperationContext operationContext)
{
try
{
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("RepCacheBase.Lock", "enter");
Function func = new Function((int)OpCodes.LockKey, new object[] { key, lockId, lockDate, lockExpiration, operationContext }, false);
RspList results = Cluster.BroadcastToMultiple(Cluster.Servers,
func,
GroupRequest.GET_ALL);
try
{
ClusterHelper.ValidateResponses(results, typeof(LockOptions), Name);
}
catch (LockingException le)
{
//release the lock preemptively...
Clustered_UnLock(key, null, true, operationContext);
return false;
}
return ClusterHelper.FindAtomicLockStatusReplicated(results, ref lockId, ref lockDate);
}
catch (CacheException e)
{
throw;
}
catch (Exception e)
{
throw new GeneralFailureException(e.Message, e);
}
finally
{
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("RepCacheBase.Lock", "exit");
}
}
public override LockOptions Lock(object key, LockExpiration lockExpiration, ref object lockId,
ref DateTime lockDate, OperationContext operationContext)
{
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("PartCache.lock", "lock_id :" + lockId);
/// Wait until the object enters the running status
_statusLatch.WaitForAny(NodeStatus.Running);
if (_internalCache == null) throw new InvalidOperationException();
LockOptions lockInfo = null;
Address address = null;
bool suspectedErrorOccured = false;
while (true)
{
address = GetNextNode(key as string);
if (address == null)
{
NCacheLog.Error("PartitionedServerCache.lock()", "specified key does not map to any node. return.");
return null;
}
try
{
if (address.CompareTo(Cluster.LocalAddress) == 0)
{
lockInfo = Local_Lock(key, lockExpiration, ref lockId, ref lockDate, operationContext);
}
else
{
lockInfo = Clustered_Lock(address, key, lockExpiration, ref lockId, ref lockDate,
operationContext);
}
return lockInfo;
}
catch (Runtime.Exceptions.SuspectedException se)
{
suspectedErrorOccured = true;
//we redo the operation
if (NCacheLog.IsInfoEnabled)
NCacheLog.Info("PartitionedServerCache.lock",
address + " left while trying to lock the key. Error: " + se.ToString());
continue;
}
catch (Runtime.Exceptions.TimeoutException te)
{
if (NCacheLog.IsInfoEnabled)
NCacheLog.Info("PartitionedServerCache.lock",
address + " operation timed out. Error: " + te.ToString());
if (suspectedErrorOccured)
{
suspectedErrorOccured = false;
continue;
}
else
{
throw new GeneralFailureException(te.Message, te);
}
}
catch (Alachisoft.NCache.Caching.Exceptions.StateTransferException se)
{
_distributionMgr.Wait(key);
}
}
return lockInfo;
}
internal override void UpdateLockInfo(object key, object lockId, DateTime lockDate, LockExpiration lockExpiration, OperationContext operationContext)
{
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("CacheSyncWrp.UpdLock", "enter");
Sync.AcquireWriterLock(Timeout.Infinite);
try
{
Internal.UpdateLockInfo(key, lockId, lockDate, lockExpiration, operationContext);
}
finally
{
Sync.ReleaseWriterLock();
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("CacheSyncWrp.UpdLock", "exit");
}
}
/// <summary>
/// Retrieve the object from the cache. A string key is passed as parameter.
/// </summary>
/// <param name="key">key of the entry.</param>
/// <param name="lockId"></param>
/// <param name="lockDate"></param>
/// <param name="lockExpiration"></param>
/// <param name="access"></param>
/// <param name="operationContext"></param>
/// <returns>cache entry.</returns>
public override CacheEntry Get(object key, ref object lockId, ref DateTime lockDate, LockExpiration lockExpiration, LockAccessType access, OperationContext operationContext)
{
CacheEntry entry = null;
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("CacheSyncWrp.Get_2", "enter");
Sync.AcquireReaderLock(Timeout.Infinite);
try
{
entry = Internal.Get(key, ref lockId, ref lockDate, lockExpiration, access, operationContext);
if (access == LockAccessType.ACQUIRE && entry != null && _context.CacheImpl.RequiresReplication)
{
string uniqueKey = System.Guid.NewGuid().ToString() + key;
#if !CLIENT
_context.CacheImpl.EnqueueForReplication(null, (int)ClusterCacheBase.OpCodes.UpdateLockInfo, new object[] { true, key, lockId, lockDate, lockExpiration, operationContext });
#endif
}
}
finally
{
Sync.ReleaseReaderLock();
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("CacheSyncWrp.Get_2", "exit");
}
return entry;
}
internal override void UpdateLockInfo(object key, object lockId, DateTime lockDate, LockExpiration lockExpiration, OperationContext operationContext)
{
CacheEntry entry = GetInternal(key, false, operationContext);
if (entry != null)
{
entry.CopyLock(lockId, lockDate, lockExpiration);
}
}
public override LockOptions Lock(object key, LockExpiration lockExpiration, ref object lockId, ref DateTime lockDate, OperationContext operationContext)
{
LockOptions lockInfo = null;
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("CacheSyncWrp.Lock", "enter");
Sync.AcquireWriterLock(Timeout.Infinite);
try
{
lockInfo = Internal.Lock(key, lockExpiration, ref lockId, ref lockDate, operationContext);
if (_context.CacheImpl.RequiresReplication)
{
string uniqueKey = System.Guid.NewGuid().ToString() + key;
#if !CLIENT
_context.CacheImpl.EnqueueForReplication(null, (int)ClusterCacheBase.OpCodes.UpdateLockInfo, new object[] { true, key, lockId, lockDate, lockExpiration, operationContext });
#endif
}
}
finally
{
Sync.ReleaseWriterLock();
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("CacheSyncWrp.Lock", "exit");
}
return lockInfo;
}
/// <summary>
/// Retrieve the object from the cache. A string key is passed as parameter.
/// </summary>
/// <param name="key">key of the entry.</param>
/// <param name="isUserOperation"></param>
/// <param name="lockId"></param>
/// <param name="lockDate"></param>
/// <param name="lockExpiration"></param>
/// <param name="accessType"></param>
/// <param name="operationContext"></param>
/// <returns>cache entry.</returns>
public sealed override CacheEntry Get(object key, bool isUserOperation, ref object lockId, ref DateTime lockDate, LockExpiration lockExpiration, LockAccessType accessType, OperationContext operationContext)
{
CacheEntry e = GetInternal(key, isUserOperation, operationContext);
if (accessType != LockAccessType.IGNORE_LOCK)
{
if (e != null)
{
if (accessType == LockAccessType.DONT_ACQUIRE)
{
bool success = e.CompareLock(lockId);
if (success)
{
//explicitly set the lockdate incase of compare lock.
//compare lock does not set the lockdate.
lockDate = e.LockDate;
}
else
{
success = !e.IsLocked(ref lockId, ref lockDate);
}
if (!success) { e = null; }
}
else if (accessType == LockAccessType.ACQUIRE && !e.Lock(lockExpiration, ref lockId, ref lockDate))//internally sets the out parameters
{
e = null;
}
}
else
{
lockId = null;
}
}
ExpirationHint exh = (e == null ? null : e.ExpirationHint);
if (exh != null)
{
if (exh.CheckExpired(_context))
{
// If cache forward is set we skip the expiration.
if (!exh.NeedsReSync)
{
ItemRemoveReason reason = ItemRemoveReason.Expired;
Remove(key, reason, true, null, LockAccessType.IGNORE_LOCK, operationContext);
e = null;
}
}
if (exh.IsVariant && isUserOperation)
{
try
{
_context.ExpiryMgr.ResetVariant(exh);
}
catch (Exception ex)
{
RemoveInternal(key, ItemRemoveReason.Removed, false, operationContext);
throw ex;
}
}
}
_stats.UpdateCount(this.Count);
if (e != null)
_stats.BumpHitCount();
else
_stats.BumpMissCount();
return e;
}
/// <summary>
/// Retrieve the object from the cache. A string key is passed as parameter.
/// </summary>
/// <param name="key">key of the entry.</param>
/// <returns>cache entry.</returns>
public override CacheEntry Get(object key, ref object lockId, ref DateTime lockDate, LockExpiration lockExpiration, LockAccessType access, OperationContext operationContext)
{
if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("RepCache.Get", "");
/// Wait until the object enters any running status
_statusLatch.WaitForAny(NodeStatus.Initializing | NodeStatus.Running);
if (_internalCache == null) throw new InvalidOperationException();
CacheEntry e = null;
if (access == LockAccessType.ACQUIRE || access == LockAccessType.DONT_ACQUIRE)
{
if (Cluster.Servers.Count > 1)
{
e = Local_Get(key, false, operationContext);
if (e != null)
{
if (access == LockAccessType.DONT_ACQUIRE)
{
if (e.IsItemLocked() && !e.CompareLock(lockId))
{
lockId = e.LockId;
lockDate = e.LockDate;
e = null;
}
else
{
lockDate = e.LockDate; //compare lock does not set the lockdate internally.
}
}
else if (!e.IsLocked(ref lockId, ref lockDate))
{
if (Clustered_Lock(key, lockExpiration, ref lockId, ref lockDate, operationContext))
{
e = Local_Get(key, ref lockId, ref lockDate, lockExpiration, LockAccessType.IGNORE_LOCK, operationContext);
}
}
else
{
//dont send the entry back if it is locked.
e = null;
}
}
else if (_statusLatch.IsAnyBitsSet(NodeStatus.Initializing))
{
if (access == LockAccessType.ACQUIRE)
{
if (Clustered_Lock(key, lockExpiration, ref lockId, ref lockDate, operationContext))
{
e = Clustered_Get(key, ref lockId, ref lockDate, access, operationContext);
}
}
else
{
e = Clustered_Get(key, ref lockId, ref lockDate, access, operationContext);
}
}
}
else
{
e = Local_Get(key, ref lockId, ref lockDate, lockExpiration, access, operationContext);
}
}
else
{
e = Local_Get(key, operationContext);
if (e == null && _statusLatch.IsAnyBitsSet(NodeStatus.Initializing))
{
e = Clustered_Get(key, ref lockId, ref lockDate, LockAccessType.IGNORE_LOCK, operationContext);
}
}
if (e == null)
{
_stats.BumpMissCount();
}
else
{
_stats.BumpHitCount();
// update the indexes on other nodes in the cluster
if ((e.ExpirationHint != null && e.ExpirationHint.IsVariant) /*|| (e.EvictionHint !=null && e.EvictionHint.IsVariant)*/ )
{
UpdateIndices(key, true, operationContext);
Local_Get(key, operationContext); //to update the index locally.
}
}
return e;
}
public bool Lock(LockExpiration lockExpiration, ref object lockId, ref DateTime lockDate)
{
lock (this)
{
if (!this.IsLocked(ref lockId, ref lockDate))
{
this.Flag.SetBit(BitSetConstants.LockedItem);
this.LockId = lockId;
this.LockDate = lockDate;
this.LockExpiration = lockExpiration;
if (this.LockExpiration != null) this.LockExpiration.Set();
return true;
}
else
{
lockId = this.LockId;
lockDate = this.LockDate;
}
return false;
}
}
/// <summary>
/// Retrieve the object from the cache. A string key is passed as parameter.
/// </summary>
/// <param name="key">key of the entry.</param>
/// <param name="lockId"></param>
/// <param name="lockDate"></param>
/// <param name="lockExpiration"></param>
/// <param name="accessType"></param>
/// <param name="operationContext"></param>
/// <returns>cache entry.</returns>
public override CacheEntry Get(object key, ref object lockId, ref DateTime lockDate, LockExpiration lockExpiration, LockAccessType accessType, OperationContext operationContext)
{
CacheEntry entry = Internal.Get(key, ref lockId, ref lockDate, lockExpiration, accessType, operationContext);
if (entry != null && KeepDeflattedValues)
{
entry.KeepDeflattedValue(_context.SerializationContext);
}
return entry;
}
