private SessionStateStoreData Deserialize(HttpContext context, Byte[] serializedItems, int timeout) { var ms = new MemoryStream(serializedItems); var sessionItems = new SessionStateItemCollection(); if (ms.Length > 0) { var reader = new BinaryReader(ms); sessionItems = SessionStateItemCollection.Deserialize(reader); } return(new SessionStateStoreData(sessionItems, SessionStateUtility.GetSessionStaticObjects(context), timeout)); }
private SessionStateStoreData Deserialize(HttpContext context, string serializedItems, int timeout) { SessionStateItemCollection sessionItems; using (MemoryStream memory = new MemoryStream(Convert.FromBase64String(serializedItems))) { using (BinaryReader reader = new BinaryReader(memory)) { sessionItems = SessionStateItemCollection.Deserialize(reader); } } return(new SessionStateStoreData(sessionItems, SessionStateUtility.GetSessionStaticObjects(context), timeout)); }
internal static SessionStateStoreData CreateSessionStoreData(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)); }
private string Serialize(SessionStateItemCollection items) { MemoryStream ms = new MemoryStream(); using (BinaryWriter writer = new BinaryWriter(ms)) { if (items != null) { items.Serialize(writer); } } return(Convert.ToBase64String(ms.ToArray())); }
private static SessionStateStoreData Deserialize(HttpContextBase context, Stream stream) { int timeout; SessionStateItemCollection sessionItems; bool hasItems; bool hasStaticObjects; HttpStaticObjectsCollection staticObjects; byte eof; Debug.Assert(context != null); try { BinaryReader reader = new BinaryReader(stream); timeout = reader.ReadInt32(); hasItems = reader.ReadBoolean(); hasStaticObjects = reader.ReadBoolean(); if (hasItems) { sessionItems = SessionStateItemCollection.Deserialize(reader); } else { sessionItems = new SessionStateItemCollection(); } if (hasStaticObjects) { staticObjects = HttpStaticObjectsCollection.Deserialize(reader); } else { staticObjects = GetSessionStaticObjects(context.ApplicationInstance.Context); } eof = reader.ReadByte(); if (eof != 0xff) { throw new HttpException(String.Format(CultureInfo.CurrentCulture, Resource1.Invalid_session_state)); } } catch (EndOfStreamException) { throw new HttpException(String.Format(CultureInfo.CurrentCulture, Resource1.Invalid_session_state)); } return(new SessionStateStoreData(sessionItems, staticObjects, timeout)); }
private SessionStateStoreData Deserialize(HttpContext context, string serializedItems, int timeout) { MemoryStream ms = new MemoryStream(Convert.FromBase64String(serializedItems)); SessionStateItemCollection sessionItems = new SessionStateItemCollection(); if (ms.Length > 0) { BinaryReader reader = new BinaryReader(ms); sessionItems = SessionStateItemCollection.Deserialize(reader); } return(new SessionStateStoreData(sessionItems, SessionStateUtility.GetSessionStaticObjects(context), timeout)); }
public FakeHttpContext(string relativeUrl, string method, IPrincipal principal, NameValueCollection formParams, NameValueCollection queryStringParams, HttpCookieCollection cookies, SessionStateItemCollection sessionItems) { _relativeUrl = relativeUrl; _method = method; _principal = principal; _formParams = formParams; _queryStringParams = queryStringParams; _cookies = cookies; _sessionItems = sessionItems; _items = new Dictionary <object, object>(); }
public string Serialize(SessionStateItemCollection items) { MemoryStream ms = new MemoryStream(); BinaryWriter writer = new BinaryWriter(ms); if ((items != null)) { items.Serialize(writer); } writer.Close(); return(Convert.ToBase64String(ms.ToArray())); }
public static byte[] Serialize(SessionStateItemCollection items) { MemoryStream ms = new MemoryStream(); BinaryWriter writer = new BinaryWriter(ms); if (items != null) { items.Serialize(writer); } writer.Close(); return(ms.ToArray()); }
protected override SessionStateDocument PreExistingSessionState() { var items = new SessionStateItemCollection(); items["Name"] = "Roger Ramjet"; return(new SessionStateDocument(SessionId, ApplicationName) { Locked = true, LockId = LockId, SessionItems = Subject.Serialize(items), Expiry = DateTime.UtcNow.AddMinutes(1) }); }
public FakeControllerContext ( HttpContext context, ControllerBase controller, string userName, string[] roles, NameValueCollection formParams, NameValueCollection queryStringParams, HttpCookieCollection cookies, SessionStateItemCollection sessionItems, RequestData data = null ) : base(new FakeHttpContext(context, new FakePrincipal(new FakeIdentity(userName), roles), formParams, queryStringParams, cookies, sessionItems, data, null), new RouteData(), controller) { }
private string Serialize(SessionStateItemCollection items) { using (MemoryStream ms = new MemoryStream()) { using (BinaryWriter writer = new BinaryWriter(ms)) { if (items != null) { items.Serialize(writer); } } var encryptedData = MachineKey.Protect(ms.ToArray(), "Session Data"); return(Convert.ToBase64String(encryptedData)); } }
private SessionStateItemCollection DeserializeSessionItems(byte[] serializedItems) { SessionStateItemCollection sessionItems = new SessionStateItemCollection(); if (serializedItems != null) { MemoryStream ms = new MemoryStream(serializedItems); if (ms.Length > 0) { BinaryReader reader = new BinaryReader(ms); sessionItems = SessionStateItemCollection.Deserialize(reader); } } return(sessionItems); }
public FakeControllerContext ( IController controller, string userName, string[] roles, NameValueCollection formParams, NameValueCollection queryStringParams, HttpCookieCollection cookies, SessionStateItemCollection sessionItems ) : base( new FakeHttpContext(new FakePrincipal(new FakeIdentity(userName), roles), formParams, queryStringParams, cookies, sessionItems), new RouteData(), (ControllerBase)controller) { }
/// <summary> /// 反序列为集合 /// </summary> /// <param name="binary">数据</param> /// <returns></returns> public static SessionStateItemCollection Deserialize(byte[] binary) { if (binary == null || binary.Length == 0) { return(new SessionStateItemCollection()); } using (var ms = new MemoryStream(binary)) { using (var reader = new BinaryReader(ms)) { return(SessionStateItemCollection.Deserialize(reader)); } } }
public SessionStateStoreData Deserialize(HttpContext context, BsonArray bsonSerializedItems, int timeout) { var sessionItems = new SessionStateItemCollection(); foreach (var bsonValue in bsonSerializedItems.Values) { var document = bsonValue as BsonDocument; foreach (var name in document.Names) { sessionItems[name] = document[name]; } } return(new SessionStateStoreData(sessionItems, SessionStateUtility.GetSessionStaticObjects(context), timeout)); }
private void CreateSessionData(int AppId, DateTime timeCreated) { MySqlCommand cmd = new MySqlCommand(); strSessionID = System.Guid.NewGuid().ToString(); //DateTime now = DateTime.Now; //DateTime lastHour = now.Subtract(new TimeSpan(1, 0, 0)); SessionStateItemCollection collection = new SessionStateItemCollection(); collection["FirstName"] = "Some"; collection["LastName"] = "Name"; byte[] items = Serialize(collection); string sql = @"INSERT INTO my_aspnet_sessions VALUES ( @sessionId, @appId, @created, @expires, @lockdate, @lockid, @timeout, @locked, @items, @flags)"; cmd = new MySqlCommand(sql, Connection); cmd.Parameters.AddWithValue("@sessionId", strSessionID); cmd.Parameters.AddWithValue("@appId", AppId); cmd.Parameters.AddWithValue("@created", timeCreated); cmd.Parameters.AddWithValue("@expires", timeCreated); cmd.Parameters.AddWithValue("@lockdate", timeCreated); cmd.Parameters.AddWithValue("@lockid", 1); cmd.Parameters.AddWithValue("@timeout", 1); cmd.Parameters.AddWithValue("@locked", 0); cmd.Parameters.AddWithValue("@items", items); cmd.Parameters.AddWithValue("@flags", 0); cmd.ExecuteNonQuery(); //create new row on sessioncleanup table cmd.CommandText = "INSERT IGNORE INTO my_aspnet_sessioncleanup SET" + " ApplicationId = @ApplicationId, " + " LastRun = NOW(), " + " IntervalMinutes = 10"; cmd.Parameters.Clear(); cmd.Parameters.AddWithValue("@ApplicationId", AppId); cmd.ExecuteNonQuery(); // set our last run table to 1 hour ago cmd.CommandText = "UPDATE my_aspnet_sessioncleanup SET LastRun=@lastHour WHERE ApplicationId = @ApplicationId"; cmd.Parameters.Clear(); cmd.Parameters.AddWithValue("@lastHour", DateTime.Now.Subtract(new TimeSpan(1, 0, 0))); cmd.Parameters.AddWithValue("@ApplicationId", AppId); cmd.ExecuteNonQuery(); }
/// <summary> /// Loads a session state item from the bucket. This function is publicly accessible /// so that you have direct access to session data from another application if necesssary. /// We use this so our front end code can determine if an employee is logged into our back /// end application to give them special permissions, without the session data being actually common /// between the two applications. /// </summary> /// <param name="headerPrefix">Prefix for the header data</param> /// <param name="dataPrefix">Prefix for the real data</param> /// <param name="bucket">Couchbase bucket to load from</param> /// <param name="id">Session ID</param> /// <param name="metaOnly">True to load only meta data</param> /// <returns>Session store item read, null on failure</returns> public static SessionStateItem Load( string headerPrefix, string dataPrefix, IBucket bucket, string id, bool metaOnly) { // Read the header value from Couchbase var header = bucket.Get <byte[]>(_headerPrefix + id); if (header.Status == ResponseStatus.KeyNotFound) { return(null); } // Deserialize the header values SessionStateItem entry; using (var ms = new MemoryStream(header.Value)) { entry = LoadHeader(ms); } entry.HeadCas = header.Cas; // Bail early if we are only loading the meta data if (metaOnly) { return(entry); } // Read the data for the item from Couchbase var data = bucket.Get <byte[]>(_dataPrefix + id); if (data.Value == null) { return(null); } entry.DataCas = data.Cas; // Deserialize the data using (var ms = new MemoryStream(data.Value)) { using (var br = new BinaryReader(ms)) { entry.Data = SessionStateItemCollection.Deserialize(br); } } // Return the session entry return(entry); }
private string Serialize(SessionStateItemCollection items) { //using (var ms = new MemoryStream() ) //{ // using (var br = new BinaryWriter(ms)) // { // if (items!=null) // { // items.Serialize(br); // } // return Convert.ToBase64String(ms.ToArray()); // } //} return("AAAsdfasfasdfasdfasdfasdfasdfasdfasdfaaaaaaaaaaaaffffffasdfsdafklldksjfldksjfsdhofhosdfhosdfusdaofasBBB"); }
protected static HttpSessionState CreateSession() { HttpSessionState sessionState; string id = Guid.NewGuid().ToString(); HttpStaticObjectsCollection staticObjects = new HttpStaticObjectsCollection(); int timeout = 20; bool newSession = true; SessionStateMode mode = SessionStateMode.InProc; bool isReadOnly = false; SessionStateItemCollection sessionItems = new SessionStateItemCollection(); HttpSessionStateContainer httpSessionStateContainer = new HttpSessionStateContainer( id, sessionItems, staticObjects, timeout, newSession, HttpCookieMode.UseUri, mode, isReadOnly); sessionState = (HttpSessionState)PrivateInvoke.CreateInstanceNonPublicCtor(typeof(HttpSessionState), httpSessionStateContainer); return(sessionState); }
/// <summary> /// Serialize is called by the SetAndReleaseItemExclusive method to /// convert the SessionStateItemCollection into a Base64 String private Byte[] Serialize(SessionStateItemCollection items) { Byte[] buffer = new Byte[] { }; using (MemoryStream ms = new MemoryStream()) { BinaryWriter writer = new BinaryWriter(ms); if (items != null) { items.Serialize(writer); } writer.Close(); buffer = ms.ToArray(); } return(buffer); //return Convert.ToBase64String(ms.ToArray()); }
public void SettingsSuccess() { ModelMapCreator mapCreator = new ModelMapCreator(); mapCreator.CreateMap(); Mock <IAchievementService> mockAchievementService = new Mock <IAchievementService>(); MockFacebookContextSettings facebookContextSettings = new MockFacebookContextSettings("AppId", 1234567890, "AccessToken123", "http://apps.facebook.com/canvasPage", "SignedRequest"); Mock <IUserService> mockUserService = new Mock <IUserService>(); User originalUser = new User { AutoUpdate = true, FacebookUserId = facebookContextSettings.UserId, PublishDescription = true, SteamUserId = "NullReference" }; mockUserService.Setup(service => service.GetUser(facebookContextSettings.UserId)) .Returns(() => originalUser).Verifiable(); SessionStateItemCollection sessionItems = new SessionStateItemCollection(); AchievementController controller = new AchievementController(mockAchievementService.Object, mockUserService.Object, facebookContextSettings); FakeControllerContext context = new FakeControllerContext(controller, sessionItems); controller.ControllerContext = context; controller.UserSettings = originalUser; SettingsViewModel model = new SettingsViewModel { AutoUpdate = true, PublishDescription = true, SteamUserId = originalUser.SteamUserId }; JsonResult result = controller.SaveSettings(model); Assert.That((string)result.Data == "Success"); mockUserService.Verify(); }
public static MqdSessionState FromJson(string json) { if (string.IsNullOrEmpty(json)) { return(null); } try { SessionStateItem item = JsonConvert.DeserializeObject <SessionStateItem>(json); SessionStateItemCollection collections = new SessionStateItemCollection(); SessionStateItemValue objectValue = null; JsonSerializer serializer = new JsonSerializer(); StringReader sr = null; JsonTextReader tReader = null; foreach (KeyValuePair <string, SessionStateItemValue> kvp in item.Dict) { objectValue = kvp.Value as SessionStateItemValue; if (objectValue.Value == null) { collections[kvp.Key] = null; } else { if (!IsValueType(objectValue.Type)) { sr = new StringReader(objectValue.Value.ToString()); tReader = new JsonTextReader(sr); collections[kvp.Key] = serializer.Deserialize(tReader, objectValue.Type); } else { collections[kvp.Key] = objectValue.Value; } } } return(new MqdSessionState(collections, null, item.Timeout)); } catch { return(null); } }
public FakeHttpContext(Uri url, string appRelativeUrl, string httpMethod, IPrincipal principal, NameValueCollection formParams, NameValueCollection queryStringParams, HttpCookieCollection cookies, SessionStateItemCollection sessionItems ) { _url = url; _appRelativeUrl = appRelativeUrl; _httpMethod = httpMethod; _principal = principal; _formParams = formParams; _queryStringParams = queryStringParams; _cookies = cookies; _sessionItems = sessionItems; if (principal != null) _isAuthenticated = principal.Identity.IsAuthenticated; _httpRequest = new FakeHttpRequest(_url, _appRelativeUrl, _httpMethod, _isAuthenticated, _formParams, _queryStringParams, _cookies, InputStream); _httpResponse = new FakeHttpResponse(); }
/// <summary> /// 序列化为二进制数据 /// </summary> /// <param name="items">选项</param> /// <returns></returns> public static byte[] Serialize(SessionStateItemCollection items) { if (items == null) { return(null); } using (var ms = new MemoryStream()) { using (var writer = new BinaryWriter(ms)) { items.Serialize(writer); writer.Close(); return(ms.ToArray()); } } }
private void DeleteTimedOutSessionsWithCallback() { using (MySqlConnection con = new MySqlConnection(connectionString)) { con.Open(); MySqlCommand cmd = new MySqlCommand("SELECT SessionID, SessionItems FROM my_aspnet_sessions WHERE Expires < NOW() AND ApplicationId = @ApplicationId", con); cmd.Parameters.AddWithValue("@ApplicationId", ApplicationId); using (MySqlDataReader reader = cmd.ExecuteReader()) { while (reader.Read()) { string sid = reader.GetString(0); object items = reader.GetValue(1); byte[] rawSessionItems = (items is DBNull) ? null : (byte[])items; SessionStateItemCollection sessionItems = this.DeserializeSessionItems(rawSessionItems); SessionStateStoreData ssd = new SessionStateStoreData(sessionItems, new HttpStaticObjectsCollection(), 0); try { if (this.expireCallback != null) { this.expireCallback.Invoke(sid, ssd); } using (MySqlConnection con2 = new MySqlConnection(connectionString)) { MySqlCommand cmd2 = new MySqlCommand("DELETE FROM my_aspnet_sessions" + " WHERE SessionId = @SessionId" + " AND ApplicationId = @ApplicationId", con2); cmd2.Parameters.AddWithValue("@SessionId", sid); cmd2.Parameters.AddWithValue("@ApplicationId", ApplicationId); con2.Open(); cmd2.ExecuteNonQuery(); } } catch (Exception e) { Trace.Write("Got exception in Delete Timed Out Sessions With Callback " + e); throw; } } } } }
public void Construct_ShouldSetSessionStateItemCollectionInternal() { //--------------- Arrange ------------------- var items = new SessionStateItemCollection(); var key = GetRandomString(5); var value = GetRandomString(); items[key] = value; //--------------- Assume ---------------- //--------------- Act ---------------------- var sut = Create(items); //--------------- Assert ----------------------- Expect(sut[key]).To.Equal(value); }
private static SessionStateStoreData Deserialize(HttpContext context, Stream stream) { int timeout; bool hasItems; bool hasStaticObjects; SessionStateItemCollection sessionItems; HttpStaticObjectsCollection staticObjects; try { BinaryReader reader = new BinaryReader(stream); timeout = reader.ReadInt32(); hasItems = reader.ReadBoolean(); hasStaticObjects = reader.ReadBoolean(); if (hasItems) { sessionItems = SessionStateItemCollection.Deserialize(reader); } else { sessionItems = new SessionStateItemCollection(); } if (hasStaticObjects) { staticObjects = HttpStaticObjectsCollection.Deserialize(reader); } else { staticObjects = SessionStateUtility.GetSessionStaticObjects(context); } if (reader.ReadByte() != EndOfStream) { throw new HttpException(Resources.Invalid_session_state); } } catch (EndOfStreamException) { throw new HttpException(Resources.Invalid_session_state); } return(new SessionStateStoreData(sessionItems, staticObjects, timeout)); }
private string Serialize(SessionStateItemCollection items) { using (var stream = new MemoryStream()) { using (var writer = new BinaryWriter(stream)) { if (items != null) { items.Serialize(writer); } writer.Flush(); writer.Close(); return(Convert.ToBase64String(stream.ToArray())); } } }
/// <summary> /// Convert a SessionStateItemCollection into a Base64 string /// </summary> private static string Serialize(SessionStateItemCollection items) { if (items == null || items.Count < 1) { return(string.Empty); } using (MemoryStream mStream = new MemoryStream()) { using (BinaryWriter bWriter = new BinaryWriter(mStream)) { items.Serialize(bWriter); bWriter.Close(); } return(Convert.ToBase64String(mStream.ToArray())); } }
} // End of the Serialize method /// <summary> /// Deserialize session items /// </summary> private SessionStateStoreData Deserialize(HttpContext context, string serializedItems, int timeout) { // Create variables SessionStateItemCollection sessionItems = new SessionStateItemCollection(); MemoryStream stream = null; BinaryReader reader = null; try { // Create the stream stream = new MemoryStream(Convert.FromBase64String(serializedItems)); // Deserialize the stream if(stream.Length > 0) { reader = new BinaryReader(stream); sessionItems = SessionStateItemCollection.Deserialize(reader); } } catch(Exception e) { // We do not want to throw an exception string exMessage = e.Message; } finally { // Close the reader if it is different from null if(reader != null) { reader.Close(); } } // Return the data return new SessionStateStoreData(sessionItems, SessionStateUtility.GetSessionStaticObjects(context), timeout); } // End of the Deserialize method
} // End of the GetSessionStoreItem method #endregion #region Serialization /// <summary> /// Serialize session items /// </summary> private string Serialize(SessionStateItemCollection items) { // Create the string to return string sessionItems = ""; // Create variables MemoryStream stream = null; BinaryWriter writer = null; try { // Create the binary writer stream = new MemoryStream(); writer = new BinaryWriter(stream); // Serialize session items if (items != null) items.Serialize(writer); // Get the serialized string sessionItems = Convert.ToBase64String(stream.ToArray()); } catch(Exception e) { // We do not want to throw an exception string exMessage = e.Message; } finally { // Close the binary writer if(writer != null) { writer.Close(); } } // Return the string return sessionItems; } // End of the Serialize method
///<summary> /// Deserialize is called by the GetSessionStoreItem method to /// convert the byte array stored in the blob field to a /// SessionStateItemCollection. /// </summary> private SessionStateStoreData Deserialize(HttpContext context, byte[] serializedItems, int timeout) { SessionStateItemCollection sessionItems = new SessionStateItemCollection(); if (serializedItems != null) { MemoryStream ms = new MemoryStream(serializedItems); if (ms.Length > 0) { BinaryReader reader = new BinaryReader(ms); sessionItems = SessionStateItemCollection.Deserialize(reader); } } return new SessionStateStoreData(sessionItems, SessionStateUtility.GetSessionStaticObjects(context), timeout); }
/// <summary> /// Converts the session's content into a byte array so we can store it in Memcached. /// </summary> /// <param name="items">The session's items that should be stored in Memcached.</param> /// <returns>A byte array that can be saved in Memcached.</returns> private static byte[] Serialize(SessionStateItemCollection items) { MemoryStream ms = new MemoryStream(); BinaryWriter writer = new BinaryWriter(ms); if (items != null) items.Serialize(writer); writer.Close(); return ms.ToArray(); }