private static HttpSessionState CreateSessionState(string key, object state)
{
string id = key.Substring(CACHEKEYPREFIXLENGTH);
ISessionStateItemCollection sessionItems =
(ISessionStateItemCollection)ExpressionEvaluator.GetValue(state, "_sessionItems");
HttpStaticObjectsCollection staticObjects =
(HttpStaticObjectsCollection)ExpressionEvaluator.GetValue(state, "_staticObjects");
int timeout = (int)ExpressionEvaluator.GetValue(state, "_timeout");
TypeRegistry.RegisterType("SessionStateModule", typeof(SessionStateModule));
HttpCookieMode cookieMode =
(HttpCookieMode)ExpressionEvaluator.GetValue(null, "SessionStateModule.s_configCookieless");
SessionStateMode stateMode =
(SessionStateMode)ExpressionEvaluator.GetValue(null, "SessionStateModule.s_configMode");
HttpSessionStateContainer container = new HttpSessionStateContainer(
id
, sessionItems
, staticObjects
, timeout
, false
, cookieMode
, stateMode
, true
);
return((HttpSessionState)Activator.CreateInstance(
typeof(HttpSessionState)
, BindingFlags.Instance | BindingFlags.NonPublic
, null
, new object[] { container }
, CultureInfo.InvariantCulture
));
}
public HttpSessionStateContainer(string id, ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout, bool newSession, HttpCookieMode cookieMode, SessionStateMode mode, bool isReadonly) : this(null, id, sessionItems, staticObjects, timeout, newSession, cookieMode, mode, isReadonly)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
}
public bool TryCheckWriteLockAndGetData(bool isLocking, out object lockId, out ISessionStateItemCollection data, out int sessionTimeout)
{
object rowDataFromRedis = null;
string[] keyArgs = new string[] { Keys.LockKey, Keys.DataKey, Keys.InternalKey };
object[] valueArgs = new object[] { };
rowDataFromRedis = redisConnection.Eval(readLockAndGetDataScript, keyArgs, valueArgs);
bool ret = false;
data = null;
if (isLocking)
{
lockId = redisConnection.GetLockId(rowDataFromRedis);
}
else
{
lockId = "";
}
sessionTimeout = redisConnection.GetSessionTimeout(rowDataFromRedis);
if (lockId.ToString().Equals(""))
{
// If lockId = "" means no lock exists and we got data from store.
lockId = null;
ret = true;
data = redisConnection.GetSessionData(rowDataFromRedis);
}
return(ret);
}
public void TestSessionAttributeRemoval()
{
bool locked;
TimeSpan lockAge;
object lockId;
SessionStateActions actions;
SessionStateStoreData data =
m_store.GetItemExclusive(null, SESSION_ID, out locked, out lockAge, out lockId, out actions);
Assert.IsTrue(locked);
Assert.IsTrue(lockAge >= TimeSpan.Zero);
Assert.IsNotNull(lockId);
Assert.AreEqual(SessionStateActions.None, actions);
ISessionStateItemCollection session = data.Items;
AssertSessionDefaults(session);
session.Remove("INT");
session.Remove("BLOB");
m_store.SetAndReleaseItemExclusive(null, SESSION_ID, data, lockId, false);
data = m_store.GetItem(null, SESSION_ID, out locked, out lockAge, out lockId, out actions);
Assert.IsFalse(locked);
Assert.AreEqual(TimeSpan.Zero, lockAge);
Assert.IsNull(lockId);
Assert.AreEqual(SessionStateActions.None, actions);
session = data.Items;
Assert.IsNull(session["int"]);
Assert.IsNull(session["blob"]);
}
// This needs to be done because there is no other way to get information on the
// exact session item that failed to deserialize.
private static ISessionStateItemCollection ValidateItems(ISessionStateItemCollection items)
{
var failedItems = new List <Tuple <int, string> >();
for (var i = 0; i < items.Count; i++)
{
try
{
var item = items[i];
}
catch (SerializationException e)
{
items[i] = null;
failedItems.Add(Tuple.Create(i, e.Message));
}
}
if (failedItems.Any())
{
throw new SerializationException(string.Format("Session item '{0}' type cannot not be marshaled. Only primitive types " +
"(Boolean, Byte, System.DateTime/Date, Double, System.Int16/Integer, " +
"System.Int32/Long, System.Float/Single, String) can be marshaled between " +
"Classic ASP and ASP.NET. {1}", items.Keys[failedItems.First().Item1], failedItems.First().Item2));
}
return(items);
}
public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
{
LogUtils.WriteInfo("------------------ SetAndReleaseItemExclusive 1 ------------------");
ISessionStateItemCollection sessionItems = null;
HttpStaticObjectsCollection staticObjects = null;
if (item.Items.Count > 0)
{
sessionItems = item.Items;
}
if (!item.StaticObjects.NeverAccessed)
{
staticObjects = item.StaticObjects;
}
LogUtils.WriteInfo(context);
LogUtils.WriteInfo(id);
LogUtils.WriteInfo(item);
LogUtils.WriteInfo(lockId);
LogUtils.WriteInfo(newItem);
LogUtils.WriteInfo(staticObjects);
LogUtils.WriteInfo(sessionItems);
MqdSessionState state2 = new MqdSessionState(sessionItems, staticObjects, item.Timeout);
LogUtils.WriteInfo(state2);
RedisUtils.SetString(id, state2.ToJson(), item.Timeout);
LogUtils.WriteInfo("------------------ SetAndReleaseItemExclusive 2 ------------------\r\n");
}
public void GetItem_RecordLocked()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
bool locked;
TimeSpan lockAge;
object lockId = null;
SessionStateActions actions;
object mockLockId = 0;
ISessionStateItemCollection sessionData = null;
int sessionTimeout;
var mockCache = A.Fake <ICacheConnection>();
A.CallTo(() => mockCache.TryCheckWriteLockAndGetData(out mockLockId, out sessionData, out sessionTimeout)).Returns(false);
A.CallTo(() => mockCache.GetLockAge(A <object> .Ignored)).Returns(TimeSpan.Zero);
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
SessionStateStoreData sessionStateStoreData = sessionStateStore.GetItem(null, id, out locked, out lockAge, out lockId, out actions);
A.CallTo(() => mockCache.TryCheckWriteLockAndGetData(out mockLockId, out sessionData, out sessionTimeout)).MustHaveHappened();
A.CallTo(() => mockCache.GetLockAge(A <object> .Ignored)).MustHaveHappened();
Assert.Equal(null, sessionStateStoreData);
Assert.Equal(true, locked);
}
public void TestExternalAttributeMultipleWrites()
{
CheckCacheIsReady();
bool locked;
TimeSpan lockAge;
object lockId;
SessionStateActions actions;
SessionStateStoreData data =
m_store.GetItemExclusive(null, SESSION_ID, out locked, out lockAge, out lockId, out actions);
ISessionStateItemCollection session = data.Items;
session["blob"] = CreateBlob(1);
session["test"] = "test";
session["test"] = CreateBlob(1024);
session["test"] = "test";
session["test2"] = CreateBlob(1024);
session["test2"] = "test2";
m_store.SetAndReleaseItemExclusive(null, SESSION_ID, data, lockId, false);
Assert.AreEqual(0, m_extAttrCache.Count);
}
private bool TryUpdateAndReleaseLockPrepare(object lockId, ISessionStateItemCollection data, int sessionTimeout, out string[] keyArgs, out object[] valueArgs)
{
keyArgs = null;
valueArgs = null;
if (data != null)
{
List <object> list = new List <object>();
ChangeTrackingSessionStateItemCollection sessionItems = (ChangeTrackingSessionStateItemCollection)data;
int noOfItemsRemoved = redisUtility.AppendRemoveItemsInList(sessionItems, list);
int noOfItemsUpdated = redisUtility.AppendUpdatedOrNewItemsInList(sessionItems, list);
keyArgs = new string[] { Keys.LockKey, Keys.DataKey, Keys.InternalKey };
valueArgs = new object[list.Count + 8]; // this +8 is for first wight values in ARGV that we will add now
valueArgs[0] = (lockId == null) ? "" : lockId;
valueArgs[1] = sessionTimeout;
valueArgs[2] = noOfItemsRemoved;
valueArgs[3] = 9; // In Lua index starts from 1 so first item deleted will be 9th.
valueArgs[4] = noOfItemsRemoved + 8; // index for last removed item
valueArgs[5] = noOfItemsUpdated;
valueArgs[6] = noOfItemsRemoved + 9; // first item updated will be next to last item removed
valueArgs[7] = list.Count + 8; // index for last item in list in LUA
// if nothing is changed in session then also execute update script to update session timeout
if (list.Count != 0)
{
list.CopyTo(valueArgs, 8);
}
return(true);
}
return(false);
}
public async Task GetItem_RecordLocked()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
bool locked;
TimeSpan lockAge;
object lockId = null;
SessionStateActions actions;
object mockLockId = 0;
ISessionStateItemCollection sessionData = null;
int sessionTimeout;
var mockCache = A.Fake <ICacheConnection>();
A.CallTo(() => mockCache.TryCheckWriteLockAndGetData(out mockLockId, out sessionData, out sessionTimeout)).Returns(false);
A.CallTo(() => mockCache.GetLockAge(A <object> .Ignored)).Returns(TimeSpan.Zero);
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
SessionStateStoreData sessionStateStoreData;
GetItemResult data = await sessionStateStore.GetItemAsync(null, id, CancellationToken.None);
sessionStateStoreData = data.Item;
locked = data.Locked;
lockAge = data.LockAge;
lockId = data.LockId;
actions = data.Actions;
A.CallTo(() => mockCache.TryCheckWriteLockAndGetData(out mockLockId, out sessionData, out sessionTimeout)).MustHaveHappened();
A.CallTo(() => mockCache.GetLockAge(A <object> .Ignored)).MustHaveHappened();
Assert.Null(sessionStateStoreData);
Assert.True(locked);
}
internal void InitStateStoreItem(bool addToContext)
{
this.ChangeImpersonation(this._rqContext, false);
try
{
if (this._rqItem == null)
{
this._rqItem = this._store.CreateNewStoreData(this._rqContext, s_timeout);
}
this._rqSessionItems = this._rqItem.Items;
if (this._rqSessionItems == null)
{
throw new HttpException(System.Web.SR.GetString("Null_value_for_SessionStateItemCollection"));
}
this._rqStaticObjects = this._rqItem.StaticObjects;
this._rqSessionItems.Dirty = false;
this._rqSessionState = new HttpSessionStateContainer(this, this._rqId, this._rqSessionItems, this._rqStaticObjects, this._rqItem.Timeout, this._rqIsNewSession, s_configCookieless, s_configMode, this._rqReadonly);
if (addToContext)
{
SessionStateUtility.AddHttpSessionStateToContext(this._rqContext, this._rqSessionState);
}
}
finally
{
this.RestoreImpersonation();
}
}
public void CreateSession()
{
// create new session with a zero timeout in order for the default
// store timeout specified in CreateSessionStore to take effect
SessionStateStoreData data = m_store.CreateNewStoreData(null, 0);
ISessionStateItemCollection session = data.Items;
session["int"] = 1;
session["string"] = "test string";
session["date"] = DateTime.Today;
session["bool"] = false;
session["blob"] = BLOB;
session["person"] = PERSON;
m_store.SetAndReleaseItemExclusive(null, SESSION_ID, data, null, true);
m_store.ResetItemTimeout(null, SESSION_ID);
SplitSessionModelManager modelManager = (SplitSessionModelManager)m_store.ModelManager;
Assert.AreEqual(modelManager.SessionCache.CacheName, SESSION_CACHE_NAME_TEST);
Assert.AreEqual(1, m_sessionCache.Count);
Assert.AreEqual(1, m_extAttrCache.Count);
m_sessionOnEndCalled = false;
}
public HttpSessionStateContainer(string id, ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout, bool newSession, HttpCookieMode cookieMode, SessionStateMode mode, bool isReadonly) : this(null, id, sessionItems, staticObjects, timeout, newSession, cookieMode, mode, isReadonly)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
}
public ISessionStateItemCollection GetSessionData(object rowDataFromRedis)
{
RedisResult rowDataAsRedisResult = (RedisResult)rowDataFromRedis;
RedisResult[] lockScriptReturnValueArray = (RedisResult[])rowDataAsRedisResult;
Debug.Assert(lockScriptReturnValueArray != null);
ISessionStateItemCollection sessionData = null;
if (lockScriptReturnValueArray.Length > 1 && lockScriptReturnValueArray[1] != null)
{
RedisResult[] data = (RedisResult[])lockScriptReturnValueArray[1];
// LUA script returns data as object array so keys and values are store one after another
// This list has to be even because it contains pair of <key, value> as {key, value, key, value}
if (data != null && data.Length != 0 && data.Length % 2 == 0)
{
sessionData = new ChangeTrackingSessionStateItemCollection();
// In every cycle of loop we are getting one pair of key value and putting it into session items
// thats why increment is by 2 because we want to move to next pair
for (int i = 0; (i + 1) < data.Length; i += 2)
{
string key = (string)data[i];
object val = redisUtility.GetObjectFromBytes((byte[])data[i + 1]);
if (key != null)
{
sessionData[key] = val;
}
}
}
}
return(sessionData);
}
private void InitStateStoreItem(bool addToContext)
{
Debug.Assert(_rqId != null, "_rqId != null");
if (_rqItem == null)
{
_rqItem = _store.CreateNewStoreData(_rqContext, s_timeout);
}
_rqSessionItems = _rqItem.Items;
if (_rqSessionItems == null)
{
throw new HttpException(string.Format(SR.Null_value_for_SessionStateItemCollection));
}
// No check for null because we allow our custom provider to return a null StaticObjects.
_rqStaticObjects = _rqItem.StaticObjects;
_rqSessionItems.Dirty = false;
_rqSessionState = new HttpSessionStateContainer(
_rqId,
_rqSessionItems,
_rqStaticObjects,
_rqItem.Timeout,
_rqIsNewSession,
ConfigCookieless,
s_configMode,
_rqReadonly);
if (addToContext)
{
SessionStateUtility.AddHttpSessionStateToContext(_rqContext.ApplicationInstance.Context, _rqSessionState);
}
}
public SessionStateStoreData(ISessionStateItemCollection sessionItems,
HttpStaticObjectsCollection staticObjects,
int timeout)
{
this.sessionItems = sessionItems;
this.staticObjects = staticObjects;
this.timeout = timeout;
}
internal static SessionStateStoreData CreateLegitStoreData(HttpContext context, ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout)
{
if (sessionItems == null)
sessionItems = new SessionStateItemCollection();
if (staticObjects == null && context != null)
staticObjects = SessionStateUtility.GetSessionStaticObjects(context);
return new SessionStateStoreData(sessionItems, staticObjects, timeout);
}
public SessionStateStoreData(ISessionStateItemCollection items,
HttpStaticObjectsCollection objects,
int timeout)
{
sessionItems = items;
staticObjects = objects;
this.timeout = timeout;
}
public static ISessionStateItemCollection AddItems(this ISessionStateItemCollection items, IDictionary <string, object> newItems)
{
foreach (var newItem in newItems)
{
items[newItem.Key] = newItem.Value;
}
return(items);
}
public SessionStateStoreData (ISessionStateItemCollection items,
HttpStaticObjectsCollection objects,
int timeout)
{
sessionItems = items;
staticObjects = objects;
this.timeout = timeout;
}
public void TryUpdateAndReleaseLock(object lockId, ISessionStateItemCollection data, int sessionTimeout)
{
string[] keyArgs;
object[] valueArgs;
if (TryUpdateAndReleaseLockPrepare(lockId, data, sessionTimeout, out keyArgs, out valueArgs))
{
redisConnection.Eval(removeAndUpdateSessionDataScript, keyArgs, valueArgs);
}
}
private void SetVersion(ISessionStateItemCollection sessionData)
{
if (sessionData == null)
{
return;
}
versionCheckInterceptor.SetVersion(sessionData);
}
public byte[] Serialize(ISessionStateItemCollection items)
{
using (var ms = new MemoryStream())
{
var writer = new BinaryWriter(ms);
((SessionStateItemCollection)items).Serialize(writer);
return(ms.ToArray());
}
}
private void AssertStateItems(IDictionary expected, ISessionStateItemCollection actual)
{
Assert.AreEqual(expected.Count, actual.Count);
foreach (var kvp in expected.Cast <DictionaryEntry>())
{
var name = (string)kvp.Key;
Assert.AreEqual(kvp.Value, actual[name]);
}
}
public void Set(ISessionStateItemCollection data, int sessionTimeout)
{
string[] keyArgs;
object[] valueArgs;
if (SetPrepare(data, sessionTimeout, out keyArgs, out valueArgs))
{
redisConnection.Eval(setScript, keyArgs, valueArgs);
}
}
/* In certain situations the 'item' parameter passed to SetAndReleaseItemExclusive
* may be null. The issue was reported in bug #333898, but the reporter cannot
* provide a test case that triggers the issue. Added work around the problem
* in the way that should have the least impact on the rest of the code. If 'item'
* is null, then the new session item is created without the items and staticItems
* collections - they will be initialized to defaults when retrieving the session
* item. This is not a correct fix, but since there is no test case this is the best
* what can be done right now.
*/
public override void SetAndReleaseItemExclusive(HttpContext context,
string id,
SessionStateStoreData item,
object lockId,
bool newItem)
{
EnsureGoodId(id, true);
string CacheId = CachePrefix + id;
Cache cache = HttpRuntime.InternalCache;
InProcSessionItem inProcItem = cache [CacheId] as InProcSessionItem;
ISessionStateItemCollection itemItems = null;
int itemTimeout = 20;
HttpStaticObjectsCollection itemStaticItems = null;
if (item != null)
{
itemItems = item.Items;
itemTimeout = item.Timeout;
itemStaticItems = item.StaticObjects;
}
if (newItem || inProcItem == null)
{
inProcItem = new InProcSessionItem();
inProcItem.timeout = itemTimeout;
inProcItem.expiresAt = DateTime.UtcNow.AddMinutes(itemTimeout);
if (lockId.GetType() == typeof(Int32))
{
inProcItem.lockId = (Int32)lockId;
}
}
else
{
if (lockId == null || lockId.GetType() != typeof(Int32) || inProcItem.lockId != (Int32)lockId)
{
return;
}
inProcItem.resettingTimeout = true;
cache.Remove(CacheId);
}
try {
inProcItem.rwlock.AcquireWriterLock(lockAcquireTimeout);
inProcItem.locked = false;
inProcItem.items = itemItems;
inProcItem.staticItems = itemStaticItems;
InsertSessionItem(inProcItem, itemTimeout, CacheId);
} catch {
throw;
} finally {
if (inProcItem.rwlock.IsWriterLockHeld)
{
inProcItem.rwlock.ReleaseWriterLock();
}
}
}
internal void Copy(ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout, bool locked, DateTime utcLockDate, int lockCookie, int flags)
{
this._sessionItems = sessionItems;
this._staticObjects = staticObjects;
this._timeout = timeout;
this._locked = locked;
this._utcLockDate = utcLockDate;
this._lockCookie = lockCookie;
this._flags = flags;
}
internal void Copy(ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout, bool locked, DateTime utcLockDate, int lockCookie, int flags)
{
this._sessionItems = sessionItems;
this._staticObjects = staticObjects;
this._timeout = timeout;
this._locked = locked;
this._utcLockDate = utcLockDate;
this._lockCookie = lockCookie;
this._flags = flags;
}
public override async Task SetAndReleaseItemExclusiveAsync(HttpContextBase context, string id, SessionStateStoreData item, object lockId, bool newItem, CancellationToken cancellationToken)
{
try
{
if (LastException == null)
{
GetAccessToStore(id);
// If it is new record
if (newItem)
{
ISessionStateItemCollection sessionItems = null;
if (item != null && item.Items != null)
{
sessionItems = item.Items;
}
else
{
sessionItems = new ChangeTrackingSessionStateItemCollection(redisUtility);
}
if (sessionItems["SessionStateActions"] != null)
{
sessionItems.Remove("SessionStateActions");
}
// Converting timout from min to sec
cache.Set(sessionItems, (item.Timeout * FROM_MIN_TO_SEC));
LogUtility.LogInfo("SetAndReleaseItemExclusive => Session Id: {0}, Session provider object: {1} => created new item in session.", id, this.GetHashCode());
} // If update if lock matches
else
{
if (item != null && item.Items != null)
{
if (item.Items["SessionStateActions"] != null)
{
item.Items.Remove("SessionStateActions");
}
// Converting timout from min to sec
cache.TryUpdateAndReleaseLock(lockId, item.Items, (item.Timeout * FROM_MIN_TO_SEC));
LogUtility.LogInfo("SetAndReleaseItemExclusive => Session Id: {0}, Session provider object: {1} => updated item in session, Lock ID: {2}.", id, this.GetHashCode(), lockId);
}
}
}
}
catch (Exception e)
{
LogUtility.LogError("SetAndReleaseItemExclusive => {0}", e.ToString());
LastException = e;
if (configuration.ThrowOnError)
{
throw;
}
}
await Task.FromResult(0);
}
internal InProcSessionState(
ISessionStateItemCollection sessionItems,
HttpStaticObjectsCollection staticObjects,
int timeout,
bool locked,
DateTime utcLockDate,
int lockCookie,
int flags)
{
Copy(sessionItems, staticObjects, timeout, locked, utcLockDate, lockCookie, flags);
}
public void Dispose ()
{
if (rwlock != null) {
rwlock.Dispose ();
rwlock = null;
}
staticItems = null;
if (items != null)
items.Clear ();
items = null;
}
internal static SessionStateStoreData CreateLegitStoreData(HttpContext context, ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout)
{
if (sessionItems == null)
{
sessionItems = new SessionStateItemCollection();
}
if ((staticObjects == null) && (context != null))
{
staticObjects = GetSessionStaticObjects(context);
}
return new SessionStateStoreData(sessionItems, staticObjects, timeout);
}
internal HttpSessionStateContainer(SessionStateModule stateModule, string id, ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout, bool newSession, HttpCookieMode cookieMode, SessionStateMode mode, bool isReadonly)
{
this._stateModule = stateModule;
this._id = id;
this._sessionItems = sessionItems;
this._staticObjects = staticObjects;
this._timeout = timeout;
this._newSession = newSession;
this._cookieMode = cookieMode;
this._mode = mode;
this._isReadonly = isReadonly;
}
internal HttpSessionStateContainer(SessionStateModule stateModule, string id, ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout, bool newSession, HttpCookieMode cookieMode, SessionStateMode mode, bool isReadonly)
{
this._stateModule = stateModule;
this._id = id;
this._sessionItems = sessionItems;
this._staticObjects = staticObjects;
this._timeout = timeout;
this._newSession = newSession;
this._cookieMode = cookieMode;
this._mode = mode;
this._isReadonly = isReadonly;
}
/// <summary>
/// Updates the session-item information in the session-state data store with values from the current request, and clears the lock on the data.
/// </summary>
/// <param name="context">The <see cref="T:System.Web.HttpContext"/> for the current request.</param><param name="id">The session identifier for the current request.</param><param name="item">The <see cref="T:System.Web.SessionState.SessionStateStoreData"/> object that contains the current session values to be stored.</param><param name="lockId">The lock identifier for the current request. </param><param name="newItem">true to identify the session item as a new item; false to identify the session item as an existing item.</param>
public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
{
ISessionStateItemCollection sessionItems = null;
if (item.Items.Count > 0)
{
sessionItems = item.Items;
}
var database = GetConnection().GetDatabase();
RedisSessionStateStore.Create(database, id, item.Timeout).Set(sessionItems);
}
public SessionItemEx(SessionItem data)
{
items = data.Items;
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
data.StaticObjects.Serialize(writer);
staticObjects = stream.ToArray();
}
}
}
internal InProcSessionItem ()
{
this.locked = false;
this.cookieless = false;
this.items = null;
this.staticItems = null;
this.lockedTime = DateTime.MinValue;
this.expiresAt = DateTime.MinValue;
this.rwlock = new ReaderWriterLockSlim ();
this.lockId = Int32.MinValue;
this.timeout = 0;
this.resettingTimeout = false;
}
internal InProcSessionItem()
{
this.locked = false;
this.cookieless = false;
this.items = null;
this.staticItems = null;
this.lockedTime = DateTime.MinValue;
this.expiresAt = DateTime.MinValue;
this.rwlock = new ReaderWriterLockSlim();
this.lockId = Int32.MinValue;
this.timeout = 0;
this.resettingTimeout = false;
}
public MySessionState(string id,
ISessionStateItemCollection sessionItems,
HttpStaticObjectsCollection staticObjects,
int timeout,
bool newSession,
HttpCookieMode cookieMode,
SessionStateMode mode,
bool isReadonly)
{
pId = id;
pSessionItems = sessionItems;
pStaticObjects = staticObjects;
pTimeout = timeout;
pNewSession = newSession;
pCookieMode = cookieMode;
pMode = mode;
pIsReadonly = isReadonly;
}
internal HttpSessionStateContainer(
SessionStateModule stateModule,
string id,
ISessionStateItemCollection sessionItems,
HttpStaticObjectsCollection staticObjects,
int timeout,
bool newSession,
HttpCookieMode cookieMode,
SessionStateMode mode,
bool isReadonly) {
_stateModule = stateModule;
_id = id; // If null, it means we're delaying session id reading
_sessionItems = sessionItems;
_staticObjects = staticObjects;
_timeout = timeout;
_newSession = newSession;
_cookieMode = cookieMode;
_mode = mode;
_isReadonly = isReadonly;
}
public HttpSessionStateContainer (string id,
ISessionStateItemCollection sessionItems,
HttpStaticObjectsCollection staticObjects,
int timeout,
bool newSession,
HttpCookieMode cookieMode,
SessionStateMode mode,
bool isReadonly)
{
if (id == null)
throw new ArgumentNullException ("id");
this.sessionItems = sessionItems;
this.id = id;
this.staticObjects = staticObjects;
this.timeout = timeout;
this.newSession = newSession;
this.cookieMode = cookieMode;
this.mode = mode;
this.isReadOnly = isReadonly;
this.isCookieless = cookieMode == HttpCookieMode.UseUri;
}
// This needs to be done because there is no other way to get information on the
// exact session item that failed to deserialize.
private static ISessionStateItemCollection ValidateItems(ISessionStateItemCollection items)
{
var failedItems = new List<Tuple<int, string>>();
for (var i = 0; i < items.Count; i++)
{
try
{
var item = items[i];
}
catch (SerializationException e)
{
items[i] = null;
failedItems.Add(Tuple.Create(i, e.Message));
}
}
if (failedItems.Any())
throw new SerializationException(string.Format("Session item '{0}' type cannot not be marshaled. Only primitive types " +
"(Boolean, Byte, System.DateTime/Date, Double, System.Int16/Integer, " +
"System.Int32/Long, System.Float/Single, String) can be marshaled between " +
"Classic ASP and ASP.NET. {1}", items.Keys[failedItems.First().Item1], failedItems.First().Item2));
return items;
}
private void LogSessionObjects(ISessionStateItemCollection sessionCollection, string sessionID, string url, string username) {
if (this._logSessionObjects && this._logger != null) {
this._logger.LogSessionObjects(sessionCollection, sessionID, url, username);
}
}
public void Set(ISessionStateItemCollection data, int sessionTimeout)
{
string[] keyArgs;
object[] valueArgs;
if (SetPrepare(data, sessionTimeout, out keyArgs, out valueArgs))
{
redisConnection.Eval(setScript, keyArgs, valueArgs);
}
}
public bool TryCheckWriteLockAndGetData(out object lockId, out ISessionStateItemCollection data, out int sessionTimeout)
{
object rowDataFromRedis = null;
string[] keyArgs = new string[] { Keys.LockKey, Keys.DataKey, Keys.InternalKey };
object[] valueArgs = new object[] { };
rowDataFromRedis = redisConnection.Eval(readLockAndGetDataScript, keyArgs, valueArgs);
bool ret = false;
data = null;
lockId = redisConnection.GetLockId(rowDataFromRedis);
sessionTimeout = redisConnection.GetSessionTimeout(rowDataFromRedis);
if (lockId.ToString().Equals(""))
{
// If lockId = "" means no lock exists and we got data from store.
lockId = null;
ret = true;
data = redisConnection.GetSessionData(rowDataFromRedis);
}
return ret;
}
public SessionStateStoreData (ISessionStateItemCollection sessionItems, System.Web.HttpStaticObjectsCollection staticObjects, int timeout)
{
}
public bool TryTakeWriteLockAndGetData(DateTime lockTime, int lockTimeout, out object lockId, out ISessionStateItemCollection data, out int sessionTimeout)
{
string expectedLockId = lockTime.Ticks.ToString();
object rowDataFromRedis = null;
string[] keyArgs = new string[] { Keys.LockKey, Keys.DataKey, Keys.InternalKey };
object[] valueArgs = new object[] { expectedLockId, lockTimeout };
rowDataFromRedis = redisConnection.Eval(writeLockAndGetDataScript, keyArgs, valueArgs);
bool ret = false;
data = null;
lockId = redisConnection.GetLockId(rowDataFromRedis);
sessionTimeout = redisConnection.GetSessionTimeout(rowDataFromRedis);
bool isLocked = redisConnection.IsLocked(rowDataFromRedis);
if (!isLocked && lockId.ToString().Equals(expectedLockId))
{
ret = true;
data = redisConnection.GetSessionData(rowDataFromRedis);
}
return ret;
}
private bool SetPrepare(ISessionStateItemCollection data, int sessionTimeout, out string[] keyArgs, out object[] valueArgs)
{
keyArgs = null;
valueArgs = null;
if (data != null && data.Count > 0)
{
ChangeTrackingSessionStateItemCollection sessionItems = (ChangeTrackingSessionStateItemCollection)data;
List<object> list = redisUtility.GetNewItemsAsList(sessionItems);
if (list.Count > 0)
{
keyArgs = new string[] { Keys.DataKey, Keys.InternalKey };
valueArgs = new object[list.Count + 2]; // this +2 is for first 2 values in ARGV that we will add now
valueArgs[0] = list.Count + 2;
valueArgs[1] = sessionTimeout;
list.CopyTo(valueArgs, 2);
return true;
}
}
return false;
}
private void AssertStateItems(IDictionary expected, ISessionStateItemCollection actual)
{
Assert.Equal(expected.Count, actual.Count);
foreach (var kvp in expected.Cast<DictionaryEntry>())
{
var name = (string)kvp.Key;
Assert.Equal(kvp.Value, actual[name]);
}
}
private byte[] Serialize(ISessionStateItemCollection data)
{
byte[] bytes;
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
var collection = data as SessionStateItemCollection;
if (collection != null)
collection.Serialize(writer);
writer.Close();
bytes = stream.ToArray();
}
bytes = redisConfig.CompressionEnabled ? Gzip.Compress(bytes) : bytes;
return bytes;
}
internal void InitStateStoreItem(bool addToContext) {
Debug.Assert(_rqId != null || s_allowInProcOptimization, "_rqId != null || s_allowInProcOptimization");
ChangeImpersonation(_rqContext, false);
try {
if (_rqItem == null) {
Debug.Trace("InitStateStoreItem", "Creating new session state");
_rqItem = _store.CreateNewStoreData(_rqContext, s_timeout);
}
_rqSessionItems = _rqItem.Items;
if (_rqSessionItems == null) {
throw new HttpException(SR.GetString(SR.Null_value_for_SessionStateItemCollection));
}
// No check for null because we allow our custom provider to return a null StaticObjects.
_rqStaticObjects = _rqItem.StaticObjects;
_rqSessionItems.Dirty = false;
_rqSessionState = new HttpSessionStateContainer(
this,
_rqId, // could be null if we're using InProc optimization
_rqSessionItems,
_rqStaticObjects,
_rqItem.Timeout,
_rqIsNewSession,
s_configCookieless,
s_configMode,
_rqReadonly);
if (addToContext) {
SessionStateUtility.AddHttpSessionStateToContext(_rqContext, _rqSessionState);
}
}
finally {
RestoreImpersonation();
}
}
public SessionStateStoreData(ISessionStateItemCollection sessionItems,
HttpStaticObjectsCollection staticObjects,
int timeout) {
_sessionItems = sessionItems;
_staticObjects = staticObjects;
_timeout = timeout;
}
internal InProcSessionState(ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout, bool locked, DateTime utcLockDate, int lockCookie, int flags)
{
this.Copy(sessionItems, staticObjects, timeout, locked, utcLockDate, lockCookie, flags);
}
private bool TryUpdateIfLockIdMatchPrepare(object lockId, ISessionStateItemCollection data, int sessionTimeout, out string[] keyArgs, out object[] valueArgs)
{
keyArgs = null;
valueArgs = null;
if (data != null)
{
List<object> list = new List<object>();
ChangeTrackingSessionStateItemCollection sessionItems = (ChangeTrackingSessionStateItemCollection)data;
int noOfItemsRemoved = redisUtility.AppendRemoveItemsInList(sessionItems, list);
int noOfItemsUpdated = redisUtility.AppendUpdatedOrNewItemsInList(sessionItems, list);
keyArgs = new string[] { Keys.LockKey, Keys.DataKey, Keys.InternalKey };
valueArgs = new object[list.Count + 8]; // this +8 is for first wight values in ARGV that we will add now
valueArgs[0] = lockId;
valueArgs[1] = sessionTimeout;
valueArgs[2] = noOfItemsRemoved;
valueArgs[3] = 9; // In Lua index starts from 1 so first item deleted will be 9th.
valueArgs[4] = noOfItemsRemoved + 8; // index for last removed item
valueArgs[5] = noOfItemsUpdated;
valueArgs[6] = noOfItemsRemoved + 9; // first item updated will be next to last item removed
valueArgs[7] = list.Count + 8; // index for last item in list in LUA
// if nothing is changed in session then also execute update script to update session timeout
if (list.Count != 0)
{
list.CopyTo(valueArgs, 8);
}
return true;
}
return false;
}
internal RedisSessionState(ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout)
{
this.Copy(sessionItems, staticObjects, timeout);
}
public FakeHttpSessionState(ISessionStateItemCollection items, string sessID)
{
this.Items = items;
this.sessionID = sessID;
}
internal void Copy(ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout)
{
this._sessionItems = sessionItems;
this._staticObjects = staticObjects;
this._timeout = timeout;
}
public void Set(ISessionStateItemCollection sessionStateItemCollection)
{
_database.KeyDelete(HashKey);
if (sessionStateItemCollection == null)
return;
foreach (string key in sessionStateItemCollection.Keys)
{
var item = sessionStateItemCollection[key];
_database.HashSet(HashKey, key, item == null ? null : JsonConvert.SerializeObject(new DataItem(item)));
}
UpdateExpire();
}
void ResetPerRequestFields() {
Debug.Assert(_rqIctx == null, "_rqIctx == null");
Debug.Assert(_rqChangeImpersonationRefCount == 0, "_rqChangeImpersonationRefCount == 0");
_rqSessionState = null;
_rqId = null;
_rqSessionItems = null;
_rqStaticObjects = null;
_rqIsNewSession = false;
_rqSessionStateNotFound = true;
_rqReadonly = false;
_rqItem = null;
_rqContext = null;
_rqAr = null;
_rqLockId = null;
_rqInCallback = 0;
_rqLastPollCompleted = DateTime.MinValue;
_rqExecutionTimeout = TimeSpan.Zero;
_rqAddedCookie = false;
_rqIdNew = false;
_rqActionFlags = 0;
_rqIctx = null;
_rqChangeImpersonationRefCount = 0;
_rqTimerThreadImpersonationIctx = null;
_rqSupportSessionIdReissue = false;
}
public void TryUpdateAndReleaseLockIfLockIdMatch(object lockId, ISessionStateItemCollection data, int sessionTimeout)
{
string[] keyArgs;
object[] valueArgs;
if (TryUpdateIfLockIdMatchPrepare(lockId, data, sessionTimeout, out keyArgs, out valueArgs))
{
redisConnection.Eval(removeAndUpdateIfLockMatchScript, keyArgs, valueArgs);
}
}
