public IEnumerator GetEnumerator()
{
// we are going to return the default enumerator implementation of ConcurrentDictionary, but
// there is one snafu. The keys that have not been read yet are of type
// NotYetDeserializedPlaceholderValue, we need to deserialize them now.
lock (this.enumLock)
{
foreach (KeyValuePair <string, object> itm in this.Items)
{
if (itm.Value is NotYetDeserializedPlaceholderValue)
{
// deserialize the value
this.MemoizedDeserializeGet(itm.Key);
}
}
try
{
return(this.Items.GetEnumerator());
}
catch (Exception exc)
{
if (RedisSessionConfig.SessionExceptionLoggingDel != null)
{
RedisSessionConfig.SessionExceptionLoggingDel(exc);
}
}
}
return(new ConcurrentDictionary <string, object>().GetEnumerator());
}
static void EnsureLocalCacheFreshness(object sender, ElapsedEventArgs e)
{
try
{
List <string> expiredKeys = new List <string>();
DateTime now = DateTime.Now;
foreach (KeyValuePair <string, SessionAndRefCount> val in LocalSharedSessionDictionary.localCache)
{
if (val.Value.LastAccess.AddMilliseconds(cacheItemExpirationAgeMillis) < now ||
val.Value.RequestReferences <= 0)
{
expiredKeys.Add(val.Key);
}
}
foreach (string expKey in expiredKeys)
{
SessionAndRefCount removed;
LocalSharedSessionDictionary.localCache.TryRemove(expKey, out removed);
}
}
catch (Exception sharedDictExc)
{
if (RedisSessionConfig.SessionExceptionLoggingDel != null)
{
RedisSessionConfig.SessionExceptionLoggingDel(sharedDictExc);
}
}
}
/// <summary>
/// Gets a Session from Redis, indicating a non-exclusive lock on the Session. Note that GetItemExclusive
/// calls this method internally, meaning we do not support locks at all retrieving the Session.
/// </summary>
/// <param name="context">The HttpContext of the current request</param>
/// <param name="id">The Session Id, which is the key name in Redis</param>
/// <param name="locked">Whether or not the Session is locked to exclusive access for a single request
/// thread</param>
/// <param name="lockAge">The age of the lock</param>
/// <param name="lockId">The object used to lock the Session</param>
/// <param name="actions">Whether or not to initialize the Session (never)</param>
/// <returns>The Session objects wrapped in a SessionStateStoreData object</returns>
public override SessionStateStoreData GetItem(HttpContext context, string id, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actions)
{
locked = false;
lockAge = new TimeSpan(0);
lockId = null;
actions = SessionStateActions.None;
try
{
string parsedRedisHashId = RedisSessionStateStoreProvider.RedisHashIdFromSessionId(
new HttpContextWrapper(context),
id);
LocalSharedSessionDictionary sharedSessDict = new LocalSharedSessionDictionary();
RedisSessionStateItemCollection items = sharedSessDict.GetSessionForBeginRequest(
parsedRedisHashId,
(redisKey) =>
{
return(RedisSessionStateStoreProvider.GetItemFromRedis(
redisKey,
new HttpContextWrapper(context),
this.SessionTimeout));
});
return(new SessionStateStoreData(
items,
SessionStateUtility.GetSessionStaticObjects(context),
Convert.ToInt32(this.SessionTimeout.TotalMinutes)));
}
catch (Exception e)
{
if (RedisSessionConfig.SessionExceptionLoggingDel != null)
{
RedisSessionConfig.SessionExceptionLoggingDel(e);
}
}
return(this.CreateNewStoreData(context, Convert.ToInt32(this.SessionTimeout.TotalMinutes)));
}
/// <summary>
/// Checks if any items have changed in the Session, and stores the results to Redis
/// </summary>
/// <param name="context">The HttpContext of the current web request</param>
/// <param name="id">The Session Id and Redis key name</param>
/// <param name="item">The Session properties</param>
/// <param name="lockId">The object used to exclusively lock the Session (there shouldn't be one)</param>
/// <param name="newItem">Whether or not the Session was created in this HttpContext</param>
public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
{
try
{
string currentRedisHashId = RedisSessionStateStoreProvider.RedisHashIdFromSessionId(
new HttpContextWrapper(context),
id);
LocalSharedSessionDictionary sharedSessDict = new LocalSharedSessionDictionary();
RedisSessionStateItemCollection redisItems =
sharedSessDict.GetSessionForEndRequest(currentRedisHashId);
// we were unable to pull it from shared cache, meaning either this is the first request or
// something went wrong with the local cache. We still have all the parts needed to write
// to redis, however, by looking at SessionStateStoreData passed in from the Session module
// and the current hash key provided by the id parameter.
if (redisItems == null)
{
redisItems = (RedisSessionStateItemCollection)item.Items;
}
if (redisItems != null)
{
RedisSessionStateStoreProvider.SerializeToRedis(
new HttpContextWrapper(context),
redisItems,
currentRedisHashId,
this.SessionTimeout);
}
}
catch (Exception e)
{
if (RedisSessionConfig.SessionExceptionLoggingDel != null)
{
RedisSessionConfig.SessionExceptionLoggingDel(e);
}
}
}
/// <summary>
/// Gets a hash from Redis and passes it to the constructor of RedisSessionStateItemCollection
/// </summary>
/// <param name="redisKey">The key of the Redis hash</param>
/// <param name="context">The HttpContext of the current web request</param>
/// <returns>An instance of RedisSessionStateItemCollection, may be empty if Redis call fails</returns>
public static RedisSessionStateItemCollection GetItemFromRedis(
string redisKey,
HttpContextBase context,
TimeSpan expirationTimeout)
{
var rConnWrap = RedisSessionStateStoreProvider.RedisConnWrapper();
try
{
var redisData = rConnWrap.HashGetAll(redisKey);
rConnWrap.KeyExpire(redisKey, expirationTimeout);
return(new RedisSessionStateItemCollection(redisData, rConnWrap.ConnectionId));
}
catch (Exception e)
{
if (RedisSessionConfig.SessionExceptionLoggingDel != null)
{
RedisSessionConfig.SessionExceptionLoggingDel(e);
}
}
return(new RedisSessionStateItemCollection());
}
/// <summary>
/// Returns a class that allows iteration over the objects in the Session collection that have changed
/// since being pulled from Redis. Each key is checked for being all of the following: key was
/// accessed, key was not removed or set to null, if the key holds the same object reference as it
/// did when pulled from redis, then the current object at the reference address is serialized and
/// the serialized string is compared with the serialized string that was originally pulled from
/// Redis. The last condition is to ensure Dirty checking is correct, i.e.
/// ((List<string>)Session["a"]).Add("a");
/// does not change what Session["a"] refers to, but it does change the object and we need to write
/// that back to Redis at the end.
/// </summary>
/// <returns>an IEnumerator that allows iteration over the changed elements of the Session.</returns>
public IEnumerable <KeyValuePair <string, string> > GetChangedObjectsEnumerator()
{
List <KeyValuePair <string, string> > changedObjs = new List <KeyValuePair <string, string> >();
lock (enumLock)
{
try
{
// for items that have definitely changed (ints, strings, value types and
// reference types whose refs have changed), add to the resulting list
// and reset their serialized raw data
foreach (KeyValuePair <string, ActionAndValue> changeData in ChangedKeysDict)
{
if (changeData.Value is SetValue)
{
string newSerVal = this.cereal.SerializeOne(changeData.Value.Value);
// now set the SerializedRawData of the key to what we are returning to the
// Session provider, which will write it to Redis so the next thread won't
// think the obj has changed when it tries to write
this.SerializedRawData.AddOrUpdate(
changeData.Key,
(key) =>
{
// ok we added to the initial state, return the new value
changedObjs.Add(
new KeyValuePair <string, string>(
changeData.Key,
newSerVal));
return(newSerVal);
},
(key, oldVal) =>
{
if (oldVal != newSerVal)
{
// ok we reset the initial state, return the new value
changedObjs.Add(
new KeyValuePair <string, string>(
changeData.Key,
newSerVal));
return(newSerVal);
}
return(oldVal);
});
}
if (changeData.Value is DeleteValue)
{
// remove what SerializedRawData thinks is the original Redis state for the key,
// because it will be removed by the Session provider once it reads from the
// enumerator we are returning
string remSerVal;
if (this.SerializedRawData.TryRemove(changeData.Key, out remSerVal))
{
// null means delete to the serializer, perhaps change this in the future
changedObjs.Add(
new KeyValuePair <string, string>(
changeData.Key,
null));
}
}
}
// check each key that was accessed for changes
foreach (KeyValuePair <string, object> itm in this.Items)
{
try
{
// only check keys that are not already in the changedObjs list
bool alreadyAdded = false;
foreach (KeyValuePair <string, string> markedItem in changedObjs)
{
if (markedItem.Key == itm.Key)
{
alreadyAdded = true;
break;
}
}
if (!alreadyAdded && !(itm.Value is NotYetDeserializedPlaceholderValue))
{
string serVal = this.cereal.SerializeOne(itm.Value);
string origSerVal;
if (this.SerializedRawData.TryGetValue(itm.Key, out origSerVal))
{
if (serVal != origSerVal)
{
// object's value has changed, add to output list
changedObjs.Add(
new KeyValuePair <string, string>(
itm.Key,
serVal));
// and reset the original state of it to what it is now
this.SerializedRawData.TryUpdate(
itm.Key,
serVal,
origSerVal);
}
}
}
}
catch (Exception)
{
}
}
}
catch (Exception enumExc)
{
if (RedisSessionConfig.SessionExceptionLoggingDel != null)
{
RedisSessionConfig.SessionExceptionLoggingDel(enumExc);
}
}
}
return(changedObjs);
}