private LogSessionIsLocked ( string key ) : void | ||
key | string | |
return | void |
/// <summary> /// Reads a stored session /// </summary> /// <param name="Key">Session Key</param> /// <param name="Reader">Method to call to complete read</param> /// <param name="StateObject">State object</param> /// <param name="isExporting">Indicates if the session is to be exported</param> /// <returns>Result of read action</returns> private SessionActionResult Read(string Key, SessionReadHandler Reader, object StateObject, bool isExporting) { if (Key == null) { throw new ArgumentNullException("Key"); } bool tryAgain; bool sessionIslocked = false; Diags.ResetDeadLockCounter(); //Reset Dead lock counter do { tryAgain = false; AcquireReadLock(); ISessionObject entry; try { dict.TryGetValue(Key, out entry); } finally { ReleaseReadLock(); } if (entry == null) { //Session not found Diags.LogSessionNotFound(Key); return(SessionActionResult.NotFound); } else { //Session Found if (entry.CompareExchangeIsInUse(true, false) == false) { //The InUse flag has been set and now this thread has exclusive access to this session object try { //Set IsExporting flag for this entry if item is to be exported if (isExporting) { entry.IsExporting = true; } //Call Reader Delegate if (Reader != null) { Reader(entry, StateObject); } if (isExporting) { Diags.LogSessionExporting(Key, entry); } else { Diags.LogSessionRead(Key, entry); } sessionIslocked = entry.IsLocked; } finally { if (!isExporting) //Remove inUse property if not exporting { entry.CompareExchangeIsInUse(false, true); } } } else { //Nope, it's still there so check if it's been exported and try again if (entry.IsExporting) { //This session is already been exported so leave Diags.ResetDeadLockCounter(); return(SessionActionResult.Exporting); } Thread.Sleep(1); //pause for 1 ms tryAgain = true; } Diags.DetectDeadLock(Key, DeadLockIterationCount); //Signal a deadlock after 2000 iterations } } while (tryAgain); Diags.ResetDeadLockCounter(); //Signal deadlock was freed if (sessionIslocked && !isExporting) { Diags.LogSessionIsLocked(Key); return(SessionActionResult.Locked); } else { return(SessionActionResult.OK); } }
/// <summary> /// Updates or inserts a session in the dictionary /// </summary> /// <param name="Key">Session Key</param> /// <param name="Session">Session object</param> /// <param name="InsertOnly">Indicates that session should only be inserted if it does not already exist</param> /// <param name="UpdateIfNotFound">Indicates whether session should be updated if the session was not found. If set to flase, this gives the caller a chance to query the network before trying again </param> /// <param name="LockedSessionInfo">Locked session information if session is locked</param> /// <returns>Result of Action</returns> private SessionActionResult UpSert(string Key, ISessionObject Session, bool InsertOnly, bool UpdateIfNotFound, out SessionResponseInfo LockedSessionInfo) { // Look for the session using a reader lock. // If session is not found, switch to a writer lock and insert item. // If session is found: // Perform an atomic compare exchange on the variable 'InUse' // If session is in Use, try Upsert again from the start. // If session is not in Use, Perform UpSert and reset InUse // Also update Sorted session list if (Key == null) { throw new ArgumentNullException("Key"); } if (Session == null) { throw new ArgumentNullException("Session"); } LockedSessionInfo = null; bool tryAgain; Diags.ResetDeadLockCounter(); do { tryAgain = false; AcquireReadLock(); ISessionObject entry; try { dict.TryGetValue(Key, out entry); } finally { ReleaseReadLock(); } if (entry == null) { if (!UpdateIfNotFound) { return(SessionActionResult.NotFound); } //Session not found -- insert brand new session object AcquireWriteLock(); try { //Check again to be sure now that the write-lock has been obtained dict.TryGetValue(Key, out entry); if (entry != null) { //ooops -- another thread inserted a seesion with this key while this thread was trying to obtain the write-lock //so try again tryAgain = true; continue; } Session.LockCookie = 1; //For some reason Lockcookie starts counting from 2 -- so set it to 1 now so that it increments to 2 when sought dict[Key] = Session; expiryList.Add(DateTime.UtcNow.Add(new TimeSpan(0, Session.TimeOut, 0)), Key, Key); Diags.LogNewSession(Key, Session); } finally { ReleaseWriteLock(); } } else { //Session Found if (InsertOnly) { Diags.LogSessionAlreadyExists(Key); return(SessionActionResult.AlreadyExists); //Do not perform an update if InsertOnly is requested } //There is no need to acquire a write lock here since the dictionary is not been modified. //Only the dictionary entry itself is been updated and such updates are guaranteed to be atomic //if the atomic InUse property is set. if (entry.CompareExchangeIsInUse(true, false) == false) { //the InUse flag is set, so this code section has exclusive access to this session object try { if (entry.IsLocked) { if (!entry.UnLock(Session.LockCookie)) { //Lockcookie did not match LockedSessionInfo = (SessionResponseInfo)entry.CreateResponseInfo(); Diags.LogSessionIsLocked(Key); return(SessionActionResult.Locked); } } Session.LockCookie = entry.LockCookie; //Overwrite the incoming session's lock-cookie with the internal one's so as not to let external input change the lockcookie Session.ExtraFlags = -1; //disable extra flags since an update is being performed entry.CopyFrom(Session); //Copy all information from Session to entry expiryList.Add(DateTime.UtcNow.Add(new TimeSpan(0, Session.TimeOut, 0)), Key, Key); //reset expiry timeout Diags.LogUpdatedSession(Key, Session); } finally { entry.CompareExchangeIsInUse(false, true); } } else { //Is this entry being exported? if (entry.IsExporting) { //This session is already been exported so leave Diags.ResetDeadLockCounter(); return(SessionActionResult.Exporting); } //Another thread is using this session and will be done soon so try again Thread.Sleep(1); //pause for 1 ms tryAgain = true; } } Diags.DetectDeadLock(Key, DeadLockIterationCount); //Signal a deadlock after 2000 iterations } while (tryAgain); Diags.ResetDeadLockCounter(); //Signal deadlock was freed return(SessionActionResult.OK); }
/// <summary> /// Removes a session from the dictionary /// </summary> /// <param name="Key">Session Key</param> /// <param name="LockCookie">Lock Cookie</param> /// <param name="IsExpiring">Indicates that the item is being removed because it's expiring</param> /// <param name="ExpiryDate">The Item expiry date (for comparison)</param> /// <param name="LockedSessionInfo">Locked session information if session is locked</param> /// <returns>Result of Action</returns> private SessionActionResult Remove(string Key, uint LockCookie, bool IsExpiring, DateTime ExpiryDate, out SessionResponseInfo LockedSessionInfo) { if (Key == null) { throw new ArgumentNullException("Key"); } LockedSessionInfo = null; bool tryAgain; Diags.ResetDeadLockCounter(); do { tryAgain = false; AcquireReadLock(); ISessionObject entry; try { dict.TryGetValue(Key, out entry); } finally { ReleaseReadLock(); } if (entry == null) { //Session not found Diags.LogSessionNotFound(Key); return(SessionActionResult.NotFound); } else { //Session Found if (entry.CompareExchangeIsInUse(true, false) == false) { try { //The InUse flag is set and so this code section has exclusive access to this session object AcquireWriteLock(); try { //Check again to be sure, now that the write-lock has been obtained ISessionObject oldEntry = entry; if (!dict.TryGetValue(Key, out entry)) { //ooops -- another thread deleted the session from the dictionary while this thread //was either trying to do the compareExchange (or if buggy, while obtaining the write-lock) //so try again oldEntry.CompareExchangeIsInUse(false, true); //unlock the previously locked item tryAgain = true; continue; } if (IsExpiring) { DateTime timeStamp; if (expiryList.TryGetTimeStamp(Key, out timeStamp)) { if (timeStamp != ExpiryDate) { //The expiration date on this session was updated, so leave return(SessionActionResult.OK); } } } if (!IsExpiring && entry.IsLocked) //Locked items DO expire. if not expiring, LockCookie has to match session's { if (!entry.UnLock(LockCookie)) { //Lockcookie did not match LockedSessionInfo = (SessionResponseInfo)entry.CreateResponseInfo(); Diags.LogSessionIsLocked(Key); return(SessionActionResult.Locked); } } if (dict.Remove(Key)) { expiryList.Remove(Key); if (IsExpiring) { Diags.LogSessionExpired(Key); } else { Diags.LogSessionDeleted(Key); } } else { //This should never happen Diags.Fail("ASSERTION Failed -- Session dictionary was unable to remove key\r\n"); } } finally { ReleaseWriteLock(); } } finally { if (entry != null) { entry.CompareExchangeIsInUse(false, true); } } } else { //Is this entry being exported? if (entry.IsExporting) { //This session is already been exported so leave Diags.ResetDeadLockCounter(); return(SessionActionResult.Exporting); } //Another thread is using this session and will be done soon so try again Thread.Sleep(1); //pause for 1 ms tryAgain = true; } Diags.DetectDeadLock(Key, DeadLockIterationCount); //Signal a deadlock after 2000 iterations } } while (tryAgain); Diags.ResetDeadLockCounter(); //Signal deadlock was freed return(SessionActionResult.OK); }