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();
}
