public void Save(ISessionStateContext context, IDictionary<string, object> values)
{
EnsureInitialized(context);
var sessionState = new SessionStateStoreData(new SessionStateItemCollection().AddItems(values), new HttpStaticObjectsCollection(), _timeout);
var data = new SessionStateEncoding().Serialize(sessionState);
_sessionStore.Save(SqlSessionId.Create(context.MetabasePath, context.SessionId), data);
}
public void GetItemExclusive_RecordFound()
{
Utility.SetConfigUtilityToDefault();
string id = "session-id";
bool locked;
TimeSpan lockAge;
object lockId = null;
SessionStateActions actions;
ISessionStateItemCollection sessionStateItemCollection = new ChangeTrackingSessionStateItemCollection();
sessionStateItemCollection["session-key"] = "session-value";
SessionStateStoreData sssd = new SessionStateStoreData(sessionStateItemCollection, null, 15);
ISessionStateItemCollection sessionData = new ChangeTrackingSessionStateItemCollection();
sessionData["session-key"] = "session-value";
ISessionStateItemCollection mockSessionData = null;
object mockLockId = 0;
int mockSessionTimeout;
int sessionTimeout = (int)RedisSessionStateProvider.configuration.SessionTimeout.TotalMinutes;
var mockCache = A.Fake<ICacheConnection>();
A.CallTo(() => mockCache.TryTakeWriteLockAndGetData(A<DateTime>.Ignored, 90, out mockLockId, out mockSessionData, out mockSessionTimeout)).Returns(true).AssignsOutAndRefParameters(0, sessionData, (int)RedisSessionStateProvider.configuration.SessionTimeout.TotalMinutes);
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
sessionStateStore.cache = mockCache;
SessionStateStoreData sessionStateStoreData = sessionStateStore.GetItemExclusive(null, id, out locked, out lockAge, out lockId, out actions);
A.CallTo(() => mockCache.TryTakeWriteLockAndGetData(A<DateTime>.Ignored, 90, out mockLockId, out sessionData, out sessionTimeout)).MustHaveHappened();
Assert.Equal(true, Utility.CompareSessionStateStoreData(sessionStateStoreData, sssd));
Assert.Equal(false, locked);
Assert.Equal(TimeSpan.Zero, lockAge);
Assert.Equal(actions, SessionStateActions.None);
}
public void CreateNewStoreData_WithEmptyStore()
{
Utility.SetConfigUtilityToDefault();
SessionStateStoreData sssd = new SessionStateStoreData(new ChangeTrackingSessionStateItemCollection(), null, 900);
RedisSessionStateProvider sessionStateStore = new RedisSessionStateProvider();
Assert.Equal(true, Utility.CompareSessionStateStoreData(sessionStateStore.CreateNewStoreData(null, 900),sssd));
}
public void SetAndReleaseItem(System.Web.HttpContext context, string id, System.Web.SessionState.SessionStateStoreData item, object lockId, bool newItem)
{
MemcachedSessionDo session;
if (newItem)
{
session = new MemcachedSessionDo()
{
Created = DateTime.Now,
ApplicationName = "",
Locked = false,
LockId = 0,
Flags = (Int32)SessionStateActions.None,
LockDate = DateTime.Now,
SessionItem = Serialize((SessionStateItemCollection)item.Items),
};
client.Store(StoreMode.Set, id, session, DateTime.Now.AddMinutes(sessionStateSection.Timeout.TotalMinutes));
}
else
{
session = client.Get <MemcachedSessionDo>(id);
if (session != null)
{
session.Locked = false;
session.SessionItem = Serialize((SessionStateItemCollection)item.Items);
client.Store(StoreMode.Set, id, session, DateTime.Now.AddMinutes(sessionStateSection.Timeout.TotalMinutes));
}
}
}
internal static bool CompareSessionStateStoreData(SessionStateStoreData obj1, SessionStateStoreData obj2)
{
if ((obj1 == null && obj2 != null) || (obj1 != null && obj2 == null))
{
return false;
}
else if (obj1 != null && obj2 != null)
{
if (obj1.Timeout != obj2.Timeout)
{
return false;
}
System.Collections.Specialized.NameObjectCollectionBase.KeysCollection keys1 = obj1.Items.Keys;
System.Collections.Specialized.NameObjectCollectionBase.KeysCollection keys2 = obj2.Items.Keys;
if ((keys1 != null && keys2 == null) || (keys1 == null && keys2 != null))
{
return false;
}
else if (keys1 != null && keys2 != null)
{
foreach (string key in keys1)
{
if (obj2.Items[key] == null)
{
return false;
}
}
}
}
return true;
}
public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
{
var sessionStore = SessionStore.Instance;
try
{
byte[] serializedItems = Serialize((SessionStateItemCollection)item.Items);
Binary sessionItems = new Binary(serializedItems);
if (newItem)
{
// Delete an existing expired session if it exists.
sessionStore.EvictExpiredSession(id, _applicationName);
// insert new session item.
Session session = new Session(id, this._applicationName, item.Timeout, sessionItems, item.Items.Count, 0);
sessionStore.Insert(session);
}
else
{
sessionStore.UpdateSession(id, item.Timeout, sessionItems, this._applicationName, item.Items.Count, lockId);
}
}
catch (Exception e)
{
if (WriteExceptionsToEventLog)
{
WriteToEventLog(e, "SetAndReleaseItemExclusive");
throw new ProviderException(e.Message, e.InnerException);
}
else
throw e;
}
}
/// <summary>
/// Called when SessionState = ReadOnly
/// </summary>
public override SessionStateStoreData GetItem(HttpContext context, string id, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actions)
{
RedisConnection redisConnection = ConnectionUtils.Connect("10.0.0.3:6379");
{
redisConnection.Open();
var result = redisConnection.Strings.Get(0, id);
byte[] raw = redisConnection.Wait(result);
actions = SessionStateActions.None;
SessionEntity sessionEntity = GetFromBytes(raw);
if (sessionEntity == null || sessionEntity.SessionItems == null )
{
locked = false;
lockId = _lock;
lockAge = TimeSpan.MinValue;
return null;
}
ISessionStateItemCollection sessionItems = new SessionStateItemCollection();
foreach (string key in sessionEntity.SessionItems.Keys)
{
sessionItems[key] = sessionEntity.SessionItems[key];
}
SessionStateStoreData data = new SessionStateStoreData(sessionItems, _staticObjects, context.Session.Timeout);
locked = false;
lockId = _lock;
lockAge = TimeSpan.MinValue;
return data;
}
}
public override SessionStateStoreData CreateNewStoreData(HttpContext context, int timeout)
{
var sessionItems = new SessionStateItemCollection();
string sessionString = JsonConvert.SerializeObject(sessionItems);
cache.PutAsync(context.Session.SessionID, sessionString, TimeSpan.FromMinutes(timeout));
var data = new SessionStateStoreData(sessionItems, null, timeout);
return data;
}
public void SetUp()
{
var configure = new MongoConfigurationBuilder();
configure.ConnectionStringAppSettingKey("mongoserver");
config = configure.BuildConfiguration();
SessionStateItemCollection sessionItemsCollection = new SessionStateItemCollection();
HttpStaticObjectsCollection staticObjectsCollection = new HttpStaticObjectsCollection();
item = new SessionStateStoreData(sessionItemsCollection, staticObjectsCollection, 1);
}
/// <summary>
/// Creates a new System.Web.SessionState.SessionStateStoreData object to be
/// used for the current request.
/// </summary>
/// <param name="context">The current request context</param>
/// <param name="timeout">The session-state System.Web.SessionState.HttpSessionState.Timeout value
/// for the new System.Web.SessionState.SessionStateStoreData.</param>
/// <returns>A new System.Web.SessionState.SessionStateStoreData for the current request.</returns>
public override SessionStateStoreData CreateNewStoreData(HttpContext context, int timeout)
{
SessionStateStoreData data = new SessionStateStoreData(
new SessionStateItemCollection(),
SessionStateUtility.GetSessionStaticObjects(context),
timeout);
return data;
}
public void Should_Encode_Session_Data()
{
var encoding = new SessionStateEncoding();
var sessionState = new SessionStateStoreData(new SessionStateItemCollection(), new HttpStaticObjectsCollection(), 20);
sessionState.Items[Constants.SessionStateKey1] = Constants.SessionStateValue1;
sessionState.Items[Constants.SessionStateKey2] = Constants.SessionStateValue2;
sessionState.Items[Constants.SessionStateKey3] = Constants.SessionStateValue3;
encoding.Serialize(sessionState).SequenceEqual(Constants.SessionStateSerializedBytes).ShouldBeTrue();
}
public RedisASPSessionVariantDictionary Init(RedisASPSessionStateProvider sessionProvider, SessionStateStoreData storeData, string sessionId, int expiry)
{
//PFSession.Log.Debug($"PFRedisVariantDictionary:Init:{hashkey}");
//System.IO.File.AppendAllText(@"C:\\log files\\pfsession.log", $"PFRedisVariantDictionary:Init:{hashkey}");
this.sessionId = sessionId;
this.sessionProvider = sessionProvider;
this.storeData = storeData;
return this;
}
public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
{
ISessionStateItemCollection sessionItems = null;
HttpStaticObjectsCollection staticObjects = null;
if (item.Items.Count > 0)
sessionItems = item.Items;
if (!item.StaticObjects.NeverAccessed)
staticObjects = item.StaticObjects;
RedisSessionState state2 = new RedisSessionState(sessionItems, staticObjects, item.Timeout);
RedisHelper.Set<string>(id, state2.ToJson(), DateTime.Now.AddHours(1));
}
internal void RaiseSessionOnEnd(string id, SessionStateStoreData item)
{
HttpSessionStateContainer container = new HttpSessionStateContainer(id, item.Items, item.StaticObjects, item.Timeout, false, SessionStateModule.s_configCookieless, SessionStateModule.s_configMode, true);
HttpSessionState sessionState = new HttpSessionState(container);
if (HttpRuntime.ShutdownInProgress)
{
this.RaiseOnEnd(sessionState);
}
else
{
SessionOnEndTargetWorkItem item2 = new SessionOnEndTargetWorkItem(this, sessionState);
WorkItem.PostInternal(new WorkItemCallback(item2.RaiseOnEndCallback));
}
}
public byte[] Serialize(SessionStateStoreData sessionState)
{
var hasItems = sessionState.Items != null && sessionState.Items.Count > 0;
var hasStaticObjects = sessionState.StaticObjects != null && !sessionState.StaticObjects.NeverAccessed;
var stream = new MemoryStream();
var writer = new BinaryWriter(stream);
writer.Write(sessionState.Timeout);
writer.Write(hasItems);
writer.Write(hasStaticObjects);
if (hasItems) ((SessionStateItemCollection)sessionState.Items).Serialize(writer);
if (hasStaticObjects) sessionState.StaticObjects.Serialize(writer);
writer.Write(byte.MaxValue);
return stream.ToArray();
}
/// <summary>
/// Deserializes a base 64 string to a SessionStateStoreData object.
/// </summary>
/// <param name="base64String">The base64 string.</param>
/// <param name="context">The context.</param>
/// <param name="timeout">The timeout.</param>
/// <returns></returns>
public static SessionStateStoreData DeserializeToSessionStateStoreData(this string base64String, HttpContext context, int timeout)
{
using (var memoryStream = new MemoryStream(Convert.FromBase64String(base64String)))
{
var sessionItems = new SessionStateItemCollection();
if (memoryStream.Length > 0)
{
using (var reader = new BinaryReader(memoryStream))
{
sessionItems = SessionStateItemCollection.Deserialize(reader);
}
}
var sessionStateStoreData = new SessionStateStoreData(sessionItems, SessionStateUtility.GetSessionStaticObjects(context), timeout);
return sessionStateStoreData;
}
}
public override SessionStateStoreData GetItem(HttpContext context, string id, out bool locked,
out TimeSpan lockAge, out object lockId,
out SessionStateActions actions)
{
// set default out parameters
locked = false;
lockAge = new TimeSpan();
lockId = null;
actions = SessionStateActions.None;
// try to get the session from cache.
string sessionString = cache.GetAsync<string>(id).Result;
if (string.IsNullOrEmpty(sessionString))
return null;
var sessionItems = JsonConvert.DeserializeObject<SessionStateItemCollection>(sessionString);
var data = new SessionStateStoreData(sessionItems, null, 60); // todo: set timeout.
return data;
}
HttpSessionStateContainer CreateContainer(string sessionId, SessionStateStoreData data, bool isNew, bool isReadOnly)
{
if (data == null)
{
return(new HttpSessionStateContainer(
sessionId, null, null, 0, isNew,
config.Cookieless, config.Mode, isReadOnly));
}
return(new HttpSessionStateContainer(
sessionId,
data.Items,
data.StaticObjects,
data.Timeout,
isNew,
config.Cookieless,
config.Mode,
isReadOnly));
}
public override void SetAndReleaseItemExclusive(HttpContext context,
String id,
SessionStateStoreData item,
object lockId,
bool newItem)
{
UnsafeNativeMethods.SessionNDMakeRequestResults results;
byte[] buf;
int length;
int lockCookie;
Debug.Assert(item.Items != null, "item.Items != null");
Debug.Assert(item.StaticObjects != null, "item.StaticObjects != null");
Debug.Trace("OutOfProcSessionStateStore", "Calling Set, id=" + id + " sessionItems=" + item.Items + " timeout=" + item.Timeout);
try {
SessionStateUtility.SerializeStoreData(item, 0, out buf, out length, s_configCompressionEnabled);
}
catch {
if (!newItem)
{
((SessionStateStoreProviderBase)this).ReleaseItemExclusive(context, id, lockId);
}
throw;
}
// Save it to the store
if (lockId == null)
{
lockCookie = 0;
}
else
{
lockCookie = (int)lockId;
}
MakeRequest(UnsafeNativeMethods.StateProtocolVerb.PUT, id,
UnsafeNativeMethods.StateProtocolExclusive.NONE, 0, item.Timeout, lockCookie,
buf, length, s_networkTimeout, out results);
}
internal static void SerializeStoreData(SessionStateStoreData item, int initialStreamSize, out byte[] buf, out int length, bool compressionEnabled)
{
using (MemoryStream stream = new MemoryStream(initialStreamSize))
{
Serialize(item, stream);
if (compressionEnabled)
{
byte[] buffer = stream.GetBuffer();
int count = (int)stream.Length;
stream.SetLength(0L);
using (DeflateStream stream2 = new DeflateStream(stream, CompressionMode.Compress, true))
{
stream2.Write(buffer, 0, count);
}
stream.WriteByte(0xff);
}
buf = stream.GetBuffer();
length = (int)stream.Length;
}
}
void WaitForStoreUnlock(HttpContext context, string sessionId, bool isReadOnly)
{
DateTime dt = DateTime.Now;
while ((DateTime.Now - dt) < executionTimeout)
{
Thread.Sleep(500);
storeData = GetStoreData(context, sessionId, isReadOnly);
if (storeData == null && storeLocked && (storeLockAge > executionTimeout))
{
handler.ReleaseItemExclusive(context, sessionId, storeLockId);
return;
}
else if (storeData != null && !storeLocked)
{
//we have the session
return;
}
}
}
// Remove an item. Note that the item is originally obtained by GetExclusive
// Same note as Set on lockId
public override void RemoveItem(HttpContext context,
String id,
object lockId,
SessionStateStoreData item)
{
Debug.Assert(lockId != null, "lockId != null");
string key = CreateSessionStateCacheKey(id);
CacheInternal cacheInternal = HttpRuntime.CacheInternal;
int lockCookie = (int)lockId;
SessionIDManager.CheckIdLength(id, true /* throwOnFail */);
InProcSessionState state = (InProcSessionState)cacheInternal.Get(key);
/* If the item isn't there, we probably took too long to run. */
if (state == null)
{
return;
}
state._spinLock.AcquireWriterLock();
try {
/* Only remove the item if we are the owner */
if (!state._locked || state._lockCookie != lockCookie)
{
return;
}
/* prevent overwriting when we drop the lock */
state._lockCookie = 0;
}
finally {
state._spinLock.ReleaseWriterLock();
}
cacheInternal.Remove(key);
TraceSessionStats();
}
void GetStoreData(HttpContext context, string sessionId, bool isReadOnly)
{
storeData = (isReadOnly) ?
handler.GetItem(context,
sessionId,
out storeLocked,
out storeLockAge,
out storeLockId,
out storeSessionAction)
:
handler.GetItemExclusive(context,
sessionId,
out storeLocked,
out storeLockAge,
out storeLockId,
out storeSessionAction);
if (storeLockId == null)
{
storeLockId = 0;
}
}
public static byte[] Serialize(SessionStateStoreData sessionData)
{
byte sessionFlag = 0;
MemoryStream stream = null;
byte[] buffer = null;
try
{
stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
if (sessionData.Items != null)
{
sessionFlag = (byte)(sessionFlag | SESSION_ITEMS);
}
if (sessionData.StaticObjects != null && !sessionData.StaticObjects.NeverAccessed)
{
sessionFlag = (byte)(sessionFlag | SESSION_STATIC_ITEMS);
}
writer.Write(sessionFlag);
if ((byte)(sessionFlag & SESSION_ITEMS) == SESSION_ITEMS)
{
((SessionStateItemCollection)sessionData.Items).Serialize(writer);
}
if ((byte)(sessionFlag & SESSION_STATIC_ITEMS) == SESSION_STATIC_ITEMS)
{
sessionData.StaticObjects.Serialize(writer);
}
writer.Write(sessionData.Timeout);
}
finally
{
if (stream != null)
{
buffer = stream.ToArray();
stream.Close();
}
}
return buffer;
}
public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
{
using (var memoryStream = new MemoryStream())
{
using (var binaryWriter = new BinaryWriter(memoryStream))
{
((SessionStateItemCollection)item.Items).Serialize(binaryWriter);
if (newItem)
{
var query = Query.And(Query.EQ("applicationVirtualPath", HostingEnvironment.ApplicationVirtualPath), Query.EQ("id", id));
this.mongoCollection.Remove(query);
var bsonDocument = new BsonDocument
{
{ "applicationVirtualPath", HostingEnvironment.ApplicationVirtualPath },
{ "created", DateTime.Now },
{ "expires", DateTime.Now.AddMinutes(item.Timeout) },
{ "id", id },
{ "lockDate", DateTime.Now },
{ "locked", false },
{ "lockId", 0 },
{ "sessionStateActions", SessionStateActions.None },
{ "sessionStateItems", memoryStream.ToArray() },
{ "sessionStateItemsCount", item.Items.Count },
{ "timeout", item.Timeout }
};
this.mongoCollection.Insert(bsonDocument);
}
else
{
var query = Query.And(Query.EQ("applicationVirtualPath", HostingEnvironment.ApplicationVirtualPath), Query.EQ("id", id), Query.EQ("lockId", lockId.ToString()));
var upate = Update.Set("expires", DateTime.Now.Add(this.sessionStateSection.Timeout)).Set("items", memoryStream.ToArray()).Set("locked", false).Set("sessionStateItemsCount", item.Items.Count);
this.mongoCollection.Update(query, upate);
}
}
}
}
static internal void SerializeStoreData(SessionStateStoreData item, int initialStreamSize, out byte[] buf, out int length, bool compressionEnabled)
{
using (MemoryStream s = new MemoryStream(initialStreamSize)) {
SessionStateUtility.Serialize(item, s);
if (compressionEnabled)
{
byte[] serializedBuffer = s.GetBuffer();
int serializedLength = (int)s.Length;
// truncate the MemoryStream so we can write the compressed data in it
s.SetLength(0);
// compress the serialized bytes
using (DeflateStream zipStream = new DeflateStream(s, CompressionMode.Compress, true)) {
zipStream.Write(serializedBuffer, 0, serializedLength);
}
// if the session state tables have ANSI_PADDING disabled, last )s are trimmed.
// This shouldn't happen, but to be sure, we are padding with an extra byte
s.WriteByte((byte)0xff);
}
buf = s.GetBuffer();
length = (int)s.Length;
}
}
public override void RemoveItem(HttpContext context,
string id,
object lockId,
SessionStateStoreData item)
{
EnsureGoodId(id, true);
string CacheId = CachePrefix + id;
Cache cache = HttpRuntime.InternalCache;
InProcSessionItem inProcItem = cache [CacheId] as InProcSessionItem;
if (inProcItem == null || lockId == null || lockId.GetType() != typeof(Int32) || inProcItem.lockId != (Int32)lockId)
{
return;
}
bool locked = false;
ReaderWriterLockSlim itemLock = null;
try {
itemLock = inProcItem.rwlock;
if (itemLock != null && itemLock.TryEnterWriteLock(lockAcquireTimeout))
{
locked = true;
}
else
{
throw new ApplicationException("Failed to acquire lock after");
}
cache.Remove(CacheId);
} catch {
throw;
} finally {
if (locked)
{
itemLock.ExitWriteLock();
}
}
}
public override void CreateUninitializedItem(HttpContext context, string id, int timeout)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
if (id.Length > SessionIDManager.SessionIDMaxLength)
{
throw new ArgumentException(ProviderResources.Session_id_too_long);
}
id = AppendAppIdHash(id);
using (SessionContext context2 = ModelHelper.CreateSessionContext(this.ConnectionString))
{
if (context2.Sessions.Find(new object[] { id }) == null)
{
Session session = NewSession(id, timeout);
SessionStateStoreData item = new SessionStateStoreData(new SessionStateItemCollection(), SessionStateUtility.GetSessionStaticObjects(context), session.Timeout);
SaveItemToSession(session, item, this.CompressionEnabled);
context2.Sessions.Add(session);
context2.SaveChanges();
}
}
}
internal void RaiseSessionOnEnd(String id, SessionStateStoreData item) {
HttpSessionStateContainer sessionStateContainer = new HttpSessionStateContainer(
id,
item.Items,
item.StaticObjects,
item.Timeout,
false,
SessionStateModule.s_configCookieless,
SessionStateModule.s_configMode,
true);
HttpSessionState sessionState = new HttpSessionState(sessionStateContainer);
if (HttpRuntime.ShutdownInProgress) {
// call directly when shutting down
RaiseOnEnd(sessionState);
}
else {
// post via thread pool
SessionOnEndTargetWorkItem workItem = new SessionOnEndTargetWorkItem(this, sessionState);
WorkItem.PostInternal(new WorkItemCallback(workItem.RaiseOnEndCallback));
}
}
public void NewItemCallsSessionStore()
{
// Arrange & Act
string expectedAppName = "You are everything ... to me";
string appPath = "Application path";
var subject = TestStoreProviderFactory.SetupStoreProvider(appPath, MockHostingProvider);
NameValueCollection keyPairs = new NameValueCollection();
keyPairs.Set("applicationName", expectedAppName);
subject.Initialize("", keyPairs, MockDocumentStore.Object);
SessionStateStoreData sessionData = new SessionStateStoreData(
new SessionStateItemCollection(),
new HttpStaticObjectsCollection(),
20
);
subject.SetAndReleaseItemExclusive(new HttpContext(new SimpleWorkerRequest("", "", "", "", new StringWriter())), "A sessionId", sessionData, new object(), true);
MockDocumentSession.Setup(cmd => cmd.Store(It.IsAny<SessionStateDocument>())).Verifiable();
// Assert
MockDocumentSession.Verify(cmd => cmd.Store(It.IsAny<SessionStateDocument>()), Times.Once());
}
public override void SetAndReleaseItemExclusive(HttpContext context,
string id,
SessionStateStoreData item,
object lockId,
bool newItem)
{
EnsureGoodId(id, true);
byte[] collection_data = null;
byte[] sobjs_data = null;
MemoryStream stream = null;
BinaryWriter writer = null;
try {
SessionStateItemCollection items = item.Items as SessionStateItemCollection;
if (items != null && items.Count > 0)
{
stream = new MemoryStream();
writer = new BinaryWriter(stream);
items.Serialize(writer);
collection_data = stream.GetBuffer();
}
HttpStaticObjectsCollection sobjs = item.StaticObjects;
if (sobjs != null && sobjs.Count > 0)
{
sobjs_data = sobjs.ToByteArray();
}
} catch (Exception ex) {
throw new HttpException("Failed to store session data.", ex);
} finally {
if (writer != null)
{
writer.Close();
}
}
stateServer.SetAndReleaseItemExclusive(id, collection_data, sobjs_data, lockId, item.Timeout, newItem);
}
private void ResetPerRequestFields()
{
this._rqSessionState = null;
this._rqId = null;
this._rqSessionItems = null;
this._rqStaticObjects = null;
this._rqIsNewSession = false;
this._rqSessionStateNotFound = true;
this._rqReadonly = false;
this._rqItem = null;
this._rqContext = null;
this._rqAr = null;
this._rqLockId = null;
this._rqInCallback = 0;
this._rqLastPollCompleted = DateTime.MinValue;
this._rqExecutionTimeout = TimeSpan.Zero;
this._rqAddedCookie = false;
this._rqIdNew = false;
this._rqActionFlags = SessionStateActions.None;
this._rqIctx = null;
this._rqChangeImpersonationRefCount = 0;
this._rqTimerThreadImpersonationIctx = null;
this._rqSupportSessionIdReissue = false;
}
void OnAcquireRequestState(object o, EventArgs args)
{
Trace.WriteLine("SessionStateModule.OnAcquireRequestState (hash " + this.GetHashCode().ToString("x") + ")");
HttpApplication application = (HttpApplication)o;
HttpContext context = application.Context;
if (!(context.Handler is IRequiresSessionState))
{
Trace.WriteLine("Handler (" + context.Handler + ") does not require session state");
return;
}
bool isReadOnly = (context.Handler is IReadOnlySessionState);
bool supportSessionIDReissue;
if (idManager.InitializeRequest(context, false, out supportSessionIDReissue))
{
return; // Redirected, will come back here in a while
}
string sessionId = idManager.GetSessionID(context);
handler.InitializeRequest(context);
storeData = GetStoreData(context, sessionId, isReadOnly);
storeIsNew = false;
if (storeData == null && !storeLocked)
{
storeIsNew = true;
sessionId = idManager.CreateSessionID(context);
Trace.WriteLine("New session ID allocated: " + sessionId);
bool redirected;
bool cookieAdded;
idManager.SaveSessionID(context, sessionId, out redirected, out cookieAdded);
if (redirected)
{
if (supportSessionIDReissue)
{
handler.CreateUninitializedItem(context, sessionId, (int)config.Timeout.TotalMinutes);
}
context.Response.End();
return;
}
else
{
storeData = handler.CreateNewStoreData(context, (int)config.Timeout.TotalMinutes);
}
}
else if (storeData == null && storeLocked)
{
WaitForStoreUnlock(context, sessionId, isReadOnly);
}
else if (storeData != null &&
!storeLocked &&
storeSessionAction == SessionStateActions.InitializeItem &&
IsCookieLess(context, config))
{
storeData = handler.CreateNewStoreData(context, (int)config.Timeout.TotalMinutes);
}
container = CreateContainer(sessionId, storeData, storeIsNew, isReadOnly);
SessionStateUtility.AddHttpSessionStateToContext(app.Context, container);
if (storeIsNew)
{
OnSessionStart();
HttpSessionState hss = app.Session;
if (hss != null)
{
storeData.Timeout = hss.Timeout;
}
}
// Whenever a container is abandoned, we temporarily disable the expire call back.
// So in this case we are quite sure we have a brand new container, so we make sure it works again.
supportsExpiration = handler.SetItemExpireCallback(OnSessionExpired);
}
public override void RemoveItem(HttpContext context, string id, object lockId, SessionStateStoreData item)
{
var query = Query.And(Query.EQ("applicationVirtualPath", HostingEnvironment.ApplicationVirtualPath), Query.EQ("id", id), Query.EQ("lockId", lockId.ToString()));
this.mongoCollection.Remove(query);
}
public override void RemoveItem (HttpContext context,
string id,
object lockId,
SessionStateStoreData item)
{
EnsureGoodId (id, true);
stateServer.Remove (id, lockId);
}
public override void RemoveItem(HttpContext context, string id, object lockId, SessionStateStoreData item)
{
DbProviderFactory factory = ProviderFactory;
DbConnection conn = CreateConnection(factory);
DbCommand cmd = CreateCommand(factory, conn,
"DELETE FROM Sessions WHERE SessionId = @SessionId AND ApplicationName = @ApplicationName AND LockId = @LockId");
DbParameterCollection parameters = cmd.Parameters;
parameters.Add(CreateParameter <string> (factory, "@SessionId", id, 80));
parameters.Add(CreateParameter <string> (factory, "@ApplicationName", ApplicationName, 255));
parameters.Add(CreateParameter <int> (factory, "@LockId", (int)lockId));
try {
conn.Open();
cmd.ExecuteNonQuery();
} catch (Exception ex) {
throw new ProviderException("Error removing item from database.", ex);
} finally {
conn.Close();
}
}
public override void RemoveItem(HttpContext context, string id, object lockId, SessionStateStoreData item)
{
_client.Delete(ApplicationName, id);
}
internal SessionStateStoreData DoGet(HttpContext context,
String id,
UnsafeNativeMethods.StateProtocolExclusive exclusiveAccess,
out bool locked,
out TimeSpan lockAge,
out object lockId,
out SessionStateActions actionFlags)
{
SessionStateStoreData item = null;
UnmanagedMemoryStream stream = null;
int contentLength;
UnsafeNativeMethods.SessionNDMakeRequestResults results;
// Set default return values
locked = false;
lockId = null;
lockAge = TimeSpan.Zero;
actionFlags = 0;
results.content = IntPtr.Zero;
try {
MakeRequest(UnsafeNativeMethods.StateProtocolVerb.GET,
id, exclusiveAccess, 0, 0, 0,
null, 0, s_networkTimeout, out results);
switch (results.httpStatus)
{
case 200:
/* item found, deserialize it */
contentLength = results.contentLength;
if (contentLength > 0)
{
try {
unsafe {
stream = new UnmanagedMemoryStream((byte *)results.content, contentLength);
}
item = SessionStateUtility.DeserializeStoreData(context, stream, s_configCompressionEnabled);
}
finally {
if (stream != null)
{
stream.Close();
}
}
lockId = results.lockCookie;
actionFlags = (SessionStateActions)results.actionFlags;
}
break;
case 423:
/* state locked, return lock information */
if (0 <= results.lockAge)
{
if (results.lockAge < Sec.ONE_YEAR)
{
lockAge = new TimeSpan(0, 0, results.lockAge);
}
else
{
lockAge = TimeSpan.Zero;
}
}
else
{
DateTime now = DateTime.Now;
if (0 < results.lockDate && results.lockDate < now.Ticks)
{
lockAge = now - new DateTime(results.lockDate);
}
else
{
lockAge = TimeSpan.Zero;
}
}
locked = true;
lockId = results.lockCookie;
Debug.Assert((results.actionFlags & (int)SessionStateActions.InitializeItem) == 0,
"(results.actionFlags & (int)SessionStateActions.InitializeItem) == 0; uninitialized item cannot be locked");
break;
}
}
finally {
if (results.content != IntPtr.Zero)
{
UnsafeNativeMethods.SessionNDFreeBody(new HandleRef(this, results.content));
}
}
return(item);
}
public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
{
string key = this.CreateSessionStateCacheKey(id);
bool flag = true;
CacheInternal cacheInternal = HttpRuntime.CacheInternal;
int newLockCookie = NewLockCookie;
ISessionStateItemCollection sessionItems = null;
HttpStaticObjectsCollection staticObjects = null;
SessionIDManager.CheckIdLength(id, true);
if (item.Items.Count > 0)
{
sessionItems = item.Items;
}
if (!item.StaticObjects.NeverAccessed)
{
staticObjects = item.StaticObjects;
}
if (!newItem)
{
InProcSessionState state = (InProcSessionState)cacheInternal.Get(key);
int lockCookie = (int)lockId;
if (state == null)
{
return;
}
state._spinLock.AcquireWriterLock();
try
{
if (!state._locked || (state._lockCookie != lockCookie))
{
return;
}
if (state._timeout == item.Timeout)
{
state.Copy(sessionItems, staticObjects, item.Timeout, false, DateTime.MinValue, lockCookie, state._flags);
flag = false;
}
else
{
state._flags |= 2;
newLockCookie = lockCookie;
state._lockCookie = 0;
}
}
finally
{
state._spinLock.ReleaseWriterLock();
}
}
if (flag)
{
InProcSessionState state2 = new InProcSessionState(sessionItems, staticObjects, item.Timeout, false, DateTime.MinValue, newLockCookie, 0);
try
{
}
finally
{
cacheInternal.UtcInsert(key, state2, null, Cache.NoAbsoluteExpiration, new TimeSpan(0, state2._timeout, 0), CacheItemPriority.NotRemovable, this._callback);
PerfCounters.IncrementCounter(AppPerfCounter.SESSIONS_TOTAL);
PerfCounters.IncrementCounter(AppPerfCounter.SESSIONS_ACTIVE);
}
}
}
public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
{
DbCommand cmd;
DbCommand deleteCmd = null;
string sessItems = Serialize((SessionStateItemCollection)item.Items);
DbProviderFactory factory = ProviderFactory;
string appName = ApplicationName;
DbConnection conn = CreateConnection(factory);
DateTime now = DateTime.Now;
DbParameterCollection parameters;
if (newItem)
{
deleteCmd = CreateCommand(factory, conn, "DELETE FROM Sessions WHERE SessionId = @SessionId AND ApplicationName = @ApplicationName AND Expires < @Expires");
parameters = deleteCmd.Parameters;
parameters.Add(CreateParameter <string> (factory, "@SessionId", id, 80));
parameters.Add(CreateParameter <string> (factory, "@ApplicationName", appName, 255));
parameters.Add(CreateParameter <DateTime> (factory, "@Expires", now));
cmd = CreateCommand(factory, conn, "INSERT INTO Sessions (SessionId, ApplicationName, Created, Expires, LockDate, LockId, Timeout, Locked, SessionItems, Flags) Values (@SessionId, @ApplicationName, @Created, @Expires, @LockDate, @LockId , @Timeout, @Locked, @SessionItems, @Flags)");
parameters = cmd.Parameters;
parameters.Add(CreateParameter <string> (factory, "@SessionId", id, 80));
parameters.Add(CreateParameter <string> (factory, "@ApplicationName", appName, 255));
parameters.Add(CreateParameter <DateTime> (factory, "@Created", now));
parameters.Add(CreateParameter <DateTime> (factory, "@Expires", now.AddMinutes((double)item.Timeout)));
parameters.Add(CreateParameter <DateTime> (factory, "@LockDate", now));
parameters.Add(CreateParameter <int> (factory, "@LockId", 0));
parameters.Add(CreateParameter <int> (factory, "@Timeout", item.Timeout));
parameters.Add(CreateParameter <bool> (factory, "@Locked", false));
parameters.Add(CreateParameter <string> (factory, "@SessionItems", sessItems));
parameters.Add(CreateParameter <int> (factory, "@Flags", 0));
}
else
{
cmd = CreateCommand(factory, conn, "UPDATE Sessions SET Expires = @Expires, SessionItems = @SessionItems, Locked = @Locked WHERE SessionId = @SessionId AND ApplicationName = @ApplicationName AND LockId = @LockId");
parameters = cmd.Parameters;
parameters.Add(CreateParameter <DateTime> (factory, "@Expires", now.AddMinutes((double)item.Timeout)));
parameters.Add(CreateParameter <string> (factory, "@SessionItems", sessItems));
parameters.Add(CreateParameter <bool> (factory, "@Locked", false));
parameters.Add(CreateParameter <string> (factory, "@SessionId", id, 80));
parameters.Add(CreateParameter <string> (factory, "@ApplicationName", appName, 255));
parameters.Add(CreateParameter <int> (factory, "@Lockid", (int)lockId));
}
try
{
conn.Open();
if (deleteCmd != null)
{
deleteCmd.ExecuteNonQuery();
}
cmd.ExecuteNonQuery();
} catch (Exception ex) {
throw new ProviderException("Failure storing session item in database.", ex);
} finally {
conn.Close();
}
}
internal unsafe SessionStateStoreData DoGet(HttpContext context, string id, System.Web.UnsafeNativeMethods.StateProtocolExclusive exclusiveAccess, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actionFlags)
{
SessionStateStoreData data = null;
UnmanagedMemoryStream stream = null;
System.Web.UnsafeNativeMethods.SessionNDMakeRequestResults results;
locked = false;
lockId = null;
lockAge = TimeSpan.Zero;
actionFlags = SessionStateActions.None;
results.content = IntPtr.Zero;
try
{
this.MakeRequest(System.Web.UnsafeNativeMethods.StateProtocolVerb.GET, id, exclusiveAccess, 0, 0, 0, null, 0, s_networkTimeout, out results);
int httpStatus = results.httpStatus;
if (httpStatus != 200)
{
if (httpStatus != 0x1a7)
{
return(data);
}
}
else
{
int contentLength = results.contentLength;
if (contentLength > 0)
{
try
{
stream = new UnmanagedMemoryStream((byte *)results.content, (long)contentLength);
data = SessionStateUtility.DeserializeStoreData(context, stream, s_configCompressionEnabled);
}
finally
{
if (stream != null)
{
stream.Close();
}
}
lockId = results.lockCookie;
actionFlags = (SessionStateActions)results.actionFlags;
}
return(data);
}
if (0 <= results.lockAge)
{
if (results.lockAge < 0x1e13380)
{
lockAge = new TimeSpan(0, 0, results.lockAge);
}
else
{
lockAge = TimeSpan.Zero;
}
}
else
{
DateTime now = DateTime.Now;
if ((0L < results.lockDate) && (results.lockDate < now.Ticks))
{
lockAge = (TimeSpan)(now - new DateTime(results.lockDate));
}
else
{
lockAge = TimeSpan.Zero;
}
}
locked = true;
lockId = results.lockCookie;
}
finally
{
if (results.content != IntPtr.Zero)
{
System.Web.UnsafeNativeMethods.SessionNDFreeBody(new HandleRef(this, results.content));
}
}
return(data);
}
public override void SetAndReleaseItemExclusive(HttpContext context,
String id,
SessionStateStoreData item,
object lockId,
bool newItem)
{
string key = CreateSessionStateCacheKey(id);
bool doInsert = true;
CacheInternal cacheInternal = HttpRuntime.CacheInternal;
int lockCookieForInsert = NewLockCookie;
ISessionStateItemCollection items = null;
HttpStaticObjectsCollection staticObjects = null;
Debug.Assert(item.Items != null, "item.Items != null");
Debug.Assert(item.StaticObjects != null, "item.StaticObjects != null");
Debug.Assert(item.Timeout <= SessionStateModule.MAX_CACHE_BASED_TIMEOUT_MINUTES, "item.Timeout <= SessionStateModule.MAX_CACHE_BASED_TIMEOUT_MINUTES");
SessionIDManager.CheckIdLength(id, true /* throwOnFail */);
if (item.Items.Count > 0)
{
items = item.Items;
}
if (!item.StaticObjects.NeverAccessed)
{
staticObjects = item.StaticObjects;
}
if (!newItem)
{
Debug.Assert(lockId != null, "lockId != null");
InProcSessionState stateCurrent = (InProcSessionState)cacheInternal.Get(key);
int lockCookie = (int)lockId;
/* If the state isn't there, we probably took too long to run. */
if (stateCurrent == null)
{
return;
}
Debug.Trace("SessionStateClientSet", "state is inStorage; key = " + key);
Debug.Assert((stateCurrent._flags & (int)SessionStateItemFlags.Uninitialized) == 0, "Should never set an unitialized item; key = " + key);
stateCurrent._spinLock.AcquireWriterLock();
try {
/* Only set the state if we are the owner */
if (!stateCurrent._locked || stateCurrent._lockCookie != lockCookie)
{
Debug.Trace("SessionStateClientSet", "Leave because we're not the owner; key = " + key);
return;
}
/* We can change the state in place if the timeout hasn't changed */
if (stateCurrent._timeout == item.Timeout)
{
stateCurrent.Copy(
items,
staticObjects,
item.Timeout,
false,
DateTime.MinValue,
lockCookie,
stateCurrent._flags);
// Don't need to insert into the Cache because an in-place copy is good enough.
doInsert = false;
Debug.Trace("SessionStateClientSet", "Changing state inplace; key = " + key);
}
else
{
/* We are going to insert a new item to replace the current one in Cache
* because the expiry time has changed.
*
* Pleas note that an insert will cause the Session_End to be incorrectly raised.
*
* Please note that the item itself should not expire between now and
* where we do UtcInsert below because CacheInternal.Get above have just
* updated its expiry time.
*/
stateCurrent._flags |= (int)SessionStateItemFlags.IgnoreCacheItemRemoved;
/* By setting _lockCookie to 0, we prevent an overwriting by ReleaseExclusive
* when we drop the lock.
* The scenario can happen if another request is polling and trying to prempt
* the lock we have on the item.
*/
lockCookieForInsert = lockCookie;
stateCurrent._lockCookie = 0;
}
}
finally {
stateCurrent._spinLock.ReleaseWriterLock();
}
}
if (doInsert)
{
Debug.Trace("SessionStateClientSet", "Inserting state into Cache; key = " + key);
InProcSessionState state = new InProcSessionState(
items,
staticObjects,
item.Timeout,
false,
DateTime.MinValue,
lockCookieForInsert,
0);
try {
}
finally {
// protected from ThreadAbortEx
cacheInternal.UtcInsert(
key, state, null, Cache.NoAbsoluteExpiration, new TimeSpan(0, state._timeout, 0),
CacheItemPriority.NotRemovable, _callback);
PerfCounters.IncrementCounter(AppPerfCounter.SESSIONS_TOTAL);
PerfCounters.IncrementCounter(AppPerfCounter.SESSIONS_ACTIVE);
TraceSessionStats();
}
}
}
public override void RemoveItem(HttpContext context, string id, object lockId, SessionStateStoreData item)
{
string key = this.CreateSessionStateCacheKey(id);
CacheInternal cacheInternal = HttpRuntime.CacheInternal;
int num = (int)lockId;
SessionIDManager.CheckIdLength(id, true);
InProcSessionState state = (InProcSessionState)cacheInternal.Get(key);
if (state != null)
{
state._spinLock.AcquireWriterLock();
try
{
if (!state._locked || (state._lockCookie != num))
{
return;
}
state._lockCookie = 0;
}
finally
{
state._spinLock.ReleaseWriterLock();
}
cacheInternal.Remove(key);
}
}
void OnSessionExpired(string id, SessionStateStoreData item)
{
SessionStateUtility.RaiseSessionEnd(
CreateContainer(id, item, false, true),
this, EventArgs.Empty);
}
private static string Serialize(SessionStateStoreData sessionStateItems)
{
return JsonConvert.SerializeObject(sessionStateItems);
}
public override void RemoveItem(HttpContext context, string id, object lockId, SessionStateStoreData item)
{
RedisBase.Item_Remove(id);
}
/// <summary>
/// Removes the session record for DynamoDB.
/// </summary>
/// <param name="context"></param>
/// <param name="sessionId"></param>
/// <param name="lockId"></param>
/// <param name="item"></param>
public override void RemoveItem(HttpContext context, string sessionId, object lockId, SessionStateStoreData item)
{
LogInfo("RemoveItem", sessionId, lockId, context);
if (lockId == null)
{
deleteItem(sessionId);
}
else
{
Document doc = this._table.GetItem(GetHashKey(sessionId), CONSISTENT_READ_GET);
if (doc.Contains(ATTRIBUTE_LOCK_ID))
{
string currentLockId = (string)doc[ATTRIBUTE_LOCK_ID];
if (string.Equals(currentLockId, lockId))
{
deleteItem(sessionId);
}
}
}
}
public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
{
if (newItem)
{
var riakSessionItem = new RiakSessionItem
{
SessionStoreItems = Serialize(item)
};
_client.Put(riakSessionItem.ToRiakObject());
}
else
{
var result = _client.Get(ApplicationName, id);
var riakSessionItem = new RiakSessionItem();
if (result.ResultCode != ResultCode.NotFound)
{
riakSessionItem = new RiakSessionItem(result.Value) {Flags = 0};
riakSessionItem.Unlock();
}
else
{
riakSessionItem.SessionId = id;
riakSessionItem.SessionContainer = ApplicationName;
}
riakSessionItem.Created = DateTime.Now;
riakSessionItem.Timeout = item.Timeout;
riakSessionItem.SessionStoreItems = Serialize(item);
_client.Async.Put(riakSessionItem.ToRiakObject(), results => { return; });
}
}
public override void RemoveItem(HttpContext context, string id, object lockId, SessionStateStoreData item)
{
System.Web.UnsafeNativeMethods.SessionNDMakeRequestResults results;
int lockCookie = (int)lockId;
this.MakeRequest(System.Web.UnsafeNativeMethods.StateProtocolVerb.DELETE, id, System.Web.UnsafeNativeMethods.StateProtocolExclusive.NONE, 0, 0, lockCookie, null, 0, s_networkTimeout, out results);
}
public override void SetAndReleaseItemExclusive(HttpContext context,
string id,
SessionStateStoreData item,
object lockId,
bool newItem)
{
if (item == null)
{
return;
}
EnsureGoodId(id, true);
byte[] collection_data = null;
byte[] sobjs_data = null;
MemoryStream stream = null;
BinaryWriter writer = null;
Stream output = null;
GZipStream gzip = null;
try {
SessionStateItemCollection items = item.Items as SessionStateItemCollection;
if (items != null && items.Count > 0)
{
stream = new MemoryStream();
if (config.CompressionEnabled)
{
output = gzip = new GZipStream(stream, CompressionMode.Compress, true);
}
else
{
output = stream;
}
writer = new BinaryWriter(output);
items.Serialize(writer);
if (gzip != null)
{
gzip.Close();
}
writer.Close();
collection_data = stream.ToArray();
}
HttpStaticObjectsCollection sobjs = item.StaticObjects;
if (sobjs != null && sobjs.Count > 0)
{
sobjs_data = sobjs.ToByteArray();
}
} catch (Exception ex) {
throw new HttpException("Failed to store session data.", ex);
} finally {
if (writer != null)
{
writer.Dispose();
}
if (gzip != null)
{
gzip.Dispose();
}
if (stream != null)
{
stream.Dispose();
}
}
stateServer.SetAndReleaseItemExclusive(id, collection_data, sobjs_data, lockId, item.Timeout, newItem);
}
public abstract void RemoveItem(HttpContext context, string id, object lockId, SessionStateStoreData item);
/// <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 HttpContext for the current request.</param>
/// <param name="sessionId">The session identifier for the current request.</param>
/// <param name="item">The 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 sessionId,
SessionStateStoreData item,
object lockId,
bool newItem)
{
LogInfo("SetAndReleaseItemExclusive", sessionId, lockId, newItem, context);
string serialized = serialize(item.Items as SessionStateItemCollection);
Document newValues = new Document();
newValues[ATTRIBUTE_SESSION_ID] = GetHashKey(sessionId);
newValues[ATTRIBUTE_LOCKED] = false;
newValues[ATTRIBUTE_LOCK_ID] = null;
newValues[ATTRIBUTE_LOCK_DATE] = DateTime.Now;
newValues[ATTRIBUTE_EXPIRES] = DateTime.Now.Add(this._timeout);
newValues[ATTRIBUTE_FLAGS] = 0;
newValues[ATTRIBUTE_SESSION_ITEMS] = serialized;
newValues[ATTRIBUTE_RECORD_FORMAT_VERSION] = CURRENT_RECORD_FORMAT_VERSION;
if (newItem)
{
newValues[ATTRIBUTE_CREATE_DATE] = DateTime.Now;
this._table.PutItem(newValues);
}
else
{
Document expected = new Document();
expected[ATTRIBUTE_LOCK_ID] = lockId.ToString();
// Not really any reason the condition should fail unless we get in some sort of weird
// app pool reset mode.
try
{
this._table.UpdateItem(newValues, new UpdateItemOperationConfig() { Expected = expected });
}
catch (ConditionalCheckFailedException) { LogInfo("(SetAndReleaseItemExclusive) Conditional check failed for update.", sessionId, context); }
}
}
public abstract void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem);
public override void SetAndReleaseItemExclusive (HttpContext context,
string id,
SessionStateStoreData item,
object lockId,
bool newItem)
{
EnsureGoodId (id, true);
byte[] collection_data = null;
byte[] sobjs_data = null;
MemoryStream stream = null;
BinaryWriter writer = null;
Stream output = null;
#if NET_4_0
GZipStream gzip = null;
#endif
try {
SessionStateItemCollection items = item.Items as SessionStateItemCollection;
if (items != null && items.Count > 0) {
stream = new MemoryStream ();
#if NET_4_0
if (config.CompressionEnabled)
output = gzip = new GZipStream (stream, CompressionMode.Compress, true);
else
#endif
output = stream;
writer = new BinaryWriter (output);
items.Serialize (writer);
#if NET_4_0
if (gzip != null)
gzip.Close ();
#endif
writer.Close ();
collection_data = stream.ToArray ();
}
HttpStaticObjectsCollection sobjs = item.StaticObjects;
if (sobjs != null && sobjs.Count > 0)
sobjs_data = sobjs.ToByteArray ();
} catch (Exception ex) {
throw new HttpException ("Failed to store session data.", ex);
} finally {
#if NET_4_0
if (writer != null)
writer.Dispose ();
if (gzip != null)
gzip.Dispose ();
#else
if (writer != null)
((IDisposable)writer).Dispose ();
#endif
if (stream != null)
stream.Dispose ();
}
stateServer.SetAndReleaseItemExclusive (id, collection_data, sobjs_data, lockId, item.Timeout, newItem);
}
/* 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);
}
bool locked = false;
ReaderWriterLockSlim itemLock = null;
try {
itemLock = inProcItem.rwlock;
if (itemLock != null && itemLock.TryEnterWriteLock(lockAcquireTimeout))
{
locked = true;
}
else
{
throw new ApplicationException("Failed to acquire lock");
}
if (inProcItem.resettingTimeout)
{
UpdateSessionItemTimeout(itemTimeout, CacheId);
}
else
{
inProcItem.locked = false;
inProcItem.items = itemItems;
inProcItem.staticItems = itemStaticItems;
InsertSessionItem(inProcItem, itemTimeout, CacheId);
}
} catch {
throw;
} finally {
if (locked && itemLock != null)
{
itemLock.ExitWriteLock();
}
}
}
private SessionStateStoreData GetSessionStoreItem(bool lockRecord, HttpContext context, string id, out bool locked,
out TimeSpan lockAge, out object lockId, out SessionStateActions actionFlags)
{
SessionStateStoreData item = null;
lockAge = TimeSpan.Zero;
lockId = null;
locked = false;
actionFlags = 0;
DbProviderFactory factory = ProviderFactory;
DbConnection conn = CreateConnection(factory);
string appName = ApplicationName;
DbCommand cmd = null;
DbDataReader reader = null;
DbParameterCollection parameters;
DateTime expires;
string serializedItems = String.Empty;
bool foundRecord = false;
bool deleteData = false;
int timeout = 0;
DateTime now = DateTime.Now;
try {
conn.Open();
if (lockRecord)
{
cmd = CreateCommand(factory, conn, "UPDATE Sessions SET Locked = @Locked, LockDate = @LockDate WHERE SessionId = @SessionId AND ApplicationName = @ApplicationName AND Expires > @Expires");
parameters = cmd.Parameters;
parameters.Add(CreateParameter <bool> (factory, "@Locked", true));
parameters.Add(CreateParameter <DateTime> (factory, "@LockDate", now));
parameters.Add(CreateParameter <string> (factory, "@SessionId", id, 80));
parameters.Add(CreateParameter <string> (factory, "@ApplicationName", appName, 255));
parameters.Add(CreateParameter <DateTime> (factory, "@Expires", now));
if (cmd.ExecuteNonQuery() == 0)
{
locked = true;
}
else
{
locked = false;
}
}
cmd = CreateCommand(factory, conn, "SELECT Expires, SessionItems, LockId, LockDate, Flags, Timeout FROM Sessions WHERE SessionId = @SessionId AND ApplicationName = @ApplicationName");
parameters = cmd.Parameters;
parameters.Add(CreateParameter <string> (factory, "@SessionId", id, 80));
parameters.Add(CreateParameter <string> (factory, "@ApplicationName", appName, 255));
reader = cmd.ExecuteReader(CommandBehavior.SingleRow);
while (reader.Read())
{
expires = reader.GetDateTime(reader.GetOrdinal("Expires"));
if (expires < now)
{
locked = false;
deleteData = true;
}
else
{
foundRecord = true;
}
serializedItems = reader.GetString(reader.GetOrdinal("SessionItems"));
lockId = reader.GetInt32(reader.GetOrdinal("LockId"));
lockAge = now.Subtract(reader.GetDateTime(reader.GetOrdinal("LockDate")));
actionFlags = (SessionStateActions)reader.GetInt32(reader.GetOrdinal("Flags"));
timeout = reader.GetInt32(reader.GetOrdinal("Timeout"));
}
reader.Close();
if (deleteData)
{
cmd = CreateCommand(factory, conn, "DELETE FROM Sessions WHERE SessionId = @SessionId AND ApplicationName = @ApplicationName");
parameters = cmd.Parameters;
parameters.Add(CreateParameter <string> (factory, "@SessionId", id, 80));
parameters.Add(CreateParameter <string> (factory, "@ApplicationName", appName, 255));
cmd.ExecuteNonQuery();
}
if (!foundRecord)
{
locked = false;
}
if (foundRecord && !locked)
{
lockId = (int)lockId + 1;
cmd = CreateCommand(factory, conn, "UPDATE Sessions SET LockId = @LockId, Flags = 0 WHERE SessionId = @SessionId AND ApplicationName = @ApplicationName");
parameters = cmd.Parameters;
parameters.Add(CreateParameter <int> (factory, "@LockId", (int)lockId));
parameters.Add(CreateParameter <string> (factory, "@SessionId", id, 80));
parameters.Add(CreateParameter <string> (factory, "@ApplicationName", appName, 255));
cmd.ExecuteNonQuery();
if (actionFlags == SessionStateActions.InitializeItem)
{
item = CreateNewStoreData(context, (int)sessionConfig.Timeout.TotalMinutes);
}
else
{
item = Deserialize(context, serializedItems, timeout);
}
}
} catch (Exception ex) {
throw new ProviderException("Unable to retrieve session item from database.", ex);
} finally {
if (reader != null)
{
reader.Close();
}
conn.Close();
}
return(item);
}
public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)
{
System.Web.UnsafeNativeMethods.SessionNDMakeRequestResults results;
byte[] buffer;
int num;
int num2;
try
{
SessionStateUtility.SerializeStoreData(item, 0, out buffer, out num, s_configCompressionEnabled);
}
catch
{
if (!newItem)
{
this.ReleaseItemExclusive(context, id, lockId);
}
throw;
}
if (lockId == null)
{
num2 = 0;
}
else
{
num2 = (int)lockId;
}
this.MakeRequest(System.Web.UnsafeNativeMethods.StateProtocolVerb.PUT, id, System.Web.UnsafeNativeMethods.StateProtocolExclusive.NONE, 0, item.Timeout, num2, buffer, num, s_networkTimeout, out results);
}