restore ISerializer ability, "safely"

src/OutputCacheProvider/RedisOutputCacheConnectionWrapper.cs

@@ -3,6 +3,7 @@
 // Licensed under the MIT License. See License.txt in the project root for license information.
 //
 
+using StackExchange.Redis;
 using System;
 using System.IO;
 using System.Web.Caching;
@@ -15,9 +16,9 @@ internal class RedisOutputCacheConnectionWrapper : IOutputCacheConnection
         private static object lockForSharedConnection = new object();
 
         internal IRedisClientConnection redisConnection;
-        private ProviderConfiguration configuration;
+        private OutputCacheProviderConfiguration configuration;
 
-        public RedisOutputCacheConnectionWrapper(ProviderConfiguration configuration)
+        public RedisOutputCacheConnectionWrapper(OutputCacheProviderConfiguration configuration)
         {
             this.configuration = configuration;
 
@@ -119,5 +120,11 @@ private object DeserializeOutputCacheEntry(byte[] serializedOutputCacheEntry)
                 return null;
             }
         }
+
+        public byte[] GetOutputCacheDataFromResult(object rowDataFromRedis)
+        {
+            RedisResult rowDataAsRedisResult = (RedisResult)rowDataFromRedis;
+            return (byte[])rowDataAsRedisResult;
+        }
     }
 }

src/OutputCacheProvider/RedisOutputCacheProvider.cs

@@ -12,7 +12,7 @@ namespace Microsoft.Web.Redis
 
     public class RedisOutputCacheProvider : OutputCacheProviderAsync
     {
-        internal static ProviderConfiguration configuration;
+        internal static OutputCacheProviderConfiguration configuration;
         internal static object configurationCreationLock = new object();
         internal IOutputCacheConnection cache;
 
@@ -42,7 +42,7 @@ public override void Initialize(string name, System.Collections.Specialized.Name
                 {
                     if (configuration == null)
                     {
-                        configuration = ProviderConfiguration.ProviderConfigurationForOutputCache(config);
+                        configuration = new OutputCacheProviderConfiguration(config);
                     }
                 }
             }

src/OutputCacheProvider/RedisOutputCacheProviderConfiguration.cs

@@ -0,0 +1,43 @@
+//
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+//
+
+using System;
+using System.Collections.Specialized;
+using static Microsoft.Web.Redis.ProviderConfigurationExtension;
+
+namespace Microsoft.Web.Redis
+{
+    internal class OutputCacheProviderConfiguration : IProviderConfiguration
+    {
+        public TimeSpan RequestTimeout { get; set; }
+        public TimeSpan SessionTimeout { get; set; }
+        public int Port { get; set; }
+        public string Host { get; set; }
+        public string AccessKey { get; set; }
+        public TimeSpan RetryTimeout { get; set; }
+        public bool ThrowOnError { get; set; }
+        public bool UseSsl { get; set; }
+        public int DatabaseId { get; set; }
+        public string ApplicationName { get; set; }
+        public int ConnectionTimeoutInMilliSec { get; set; }
+        public int OperationTimeoutInMilliSec { get; set; }
+        public string ConnectionString { get; set; }
+
+        internal OutputCacheProviderConfiguration(NameValueCollection config)
+        {
+            GetIProviderConfiguration(config, this);
+
+            // No retry login for output cache provider
+            RetryTimeout = TimeSpan.Zero;
+
+            // Session state specific attribute which are not applicable to output cache
+            ThrowOnError = true;
+            RequestTimeout = TimeSpan.Zero;
+            SessionTimeout = TimeSpan.Zero;
+
+            LogUtility.LogInfo($"Host: {Host}, Port: {Port}, UseSsl: {UseSsl}, DatabaseId: {DatabaseId}, ApplicationName: {ApplicationName}");
+        }
+    }
+}

src/RedisSessionStateProvider/DefaultSessionStateSerializer.cs

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+//
+
+using System.IO;
+using System.Web.SessionState;
+
+namespace Microsoft.Web.RedisSessionStateProvider
+{
+    /// <summary>
+    /// Provides methods to serialize and deserialize session state data using binary serialization.
+    /// This is the default implementation of the ISessionDataSerializer class.
+    /// The implementation uses the serialization and deserialization methods provided by the SessionStateItemCollection class. 
+    /// </summary>
+    internal class DefaultSessionStateSerializer : ISessionStateSerializer
+    {
+        /// <summary>
+        /// Deserializes the session state data.
+        /// </summary>
+        /// <param name="data">The serialized session state data as a byte array.</param>
+        /// <returns>The deserialized session state data.</returns>
+        public SessionStateItemCollection Deserialize(byte[] data)
+        {
+            MemoryStream ms = new MemoryStream(data);
+            BinaryReader reader = new BinaryReader(ms);
+            return SessionStateItemCollection.Deserialize(reader);
+        }
+
+        /// <summary>
+        /// Serializes the session state data.
+        /// </summary>
+        /// <param name="data">The session state data to serialize.</param>
+        /// <returns>The serialized session state data as a byte array.</returns>
+        public byte[] Serialize(SessionStateItemCollection data)
+        {
+            MemoryStream ms = new MemoryStream();
+            BinaryWriter writer = new BinaryWriter(ms);
+            data.Serialize(writer);
+            writer.Close();
+            return ms.ToArray();
+        }
+    }
+}

src/RedisSessionStateProvider/ICacheConnection.cs → src/RedisSessionStateProvider/ISessionStateConnection.cs

@@ -8,7 +8,7 @@
 
 namespace Microsoft.Web.Redis
 {
-    internal interface ICacheConnection
+    internal interface ISessionStateConnection
     {
         KeyGenerator Keys { get; set; }
         void Set(ISessionStateItemCollection data, int sessionTimeout);

src/RedisSessionStateProvider/ISessionStateSerializer.cs

@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+//
+
+using System.Web.SessionState;
+
+/// <summary>
+/// Provides methods to serialize and deserialize session state data.
+/// </summary>
+public interface ISessionStateSerializer
+{
+    /// <summary>
+    /// Serializes the session state data.
+    /// </summary>
+    /// <param name="data">The session state data to serialize.</param>
+    /// <returns>The serialized session state data as a byte array.</returns>
+    byte[] Serialize(SessionStateItemCollection data);
+
+    /// <summary>
+    /// Deserializes the session state data.
+    /// </summary>
+    /// <param name="data">The serialized session state data as a byte array.</param>
+    /// <returns>The deserialized session state data.</returns>
+    SessionStateItemCollection Deserialize(byte[] data);
+}

src/RedisSessionStateProvider/KeyGenerator.cs

@@ -3,8 +3,6 @@
 // Licensed under the MIT License. See License.txt in the project root for license information.
 //
 
-using System;
-
 namespace Microsoft.Web.Redis
 {
     internal class KeyGenerator
@@ -14,24 +12,24 @@ internal class KeyGenerator
         public string LockKey { get; private set; }
         public string InternalKey { get; private set; }
 
-        private void GenerateKeys(string id, string app)
+        private void GenerateKeys(string id, string app, string serializationSuffix)
         {
             this.id = id;
-            DataKey = $"{{{app}_{id}}}_SessionStateItemCollection";
+            DataKey = $"{{{app}_{id}}}_SessionStateItemCollection{serializationSuffix}";
             LockKey = $"{{{app}_{id}}}_WriteLock";
             InternalKey = $"{{{app}_{id}}}_SessionTimeout";
         }
 
-        public KeyGenerator(string sessionId, string applicationName)
+        public KeyGenerator(string sessionId, string applicationName, string serializationSuffix)
         {
-            GenerateKeys(sessionId, applicationName);
+            GenerateKeys(sessionId, applicationName, serializationSuffix);
         }
 
-        public void RegenerateKeyStringIfIdModified(string sessionId, string applicationName)
+        public void RegenerateKeyStringIfIdModified(string sessionId, string applicationName, string serializationSuffix)
         {
             if (!sessionId.Equals(this.id))
             {
-                GenerateKeys(sessionId, applicationName);
+                GenerateKeys(sessionId, applicationName, serializationSuffix);
             }
         }
     }

src/RedisSessionStateProvider/RedisConnectionWrapper.cs → src/RedisSessionStateProvider/RedisSessionStateConnectionWrapper.cs

@@ -3,27 +3,28 @@
 // Licensed under the MIT License. See License.txt in the project root for license information.
 //
 
+using StackExchange.Redis;
 using System;
 using System.Collections.Generic;
-using System.IO;
+using System.Diagnostics;
 using System.Web.SessionState;
 
 namespace Microsoft.Web.Redis
 {
-    internal class RedisConnectionWrapper : ICacheConnection
+    internal class RedisSessionStateConnectionWrapper : ISessionStateConnection
     {
         internal static RedisSharedConnection sharedConnection;
         private static object lockForSharedConnection = new object();
 
         public KeyGenerator Keys { set; get; }
 
         internal IRedisClientConnection redisConnection;
-        private ProviderConfiguration configuration;
+        private SessionStateProviderConfiguration configuration;
 
-        public RedisConnectionWrapper(ProviderConfiguration configuration, string id)
+        public RedisSessionStateConnectionWrapper(SessionStateProviderConfiguration configuration, string id)
         {
             this.configuration = configuration;
-            Keys = new KeyGenerator(id, configuration.ApplicationName);
+            Keys = new KeyGenerator(id, configuration.ApplicationName, configuration.SerializationSuffixForKeys);
 
             // only single object of RedisSharedConnection will be created and then reused
             if (sharedConnection == null)
@@ -127,11 +128,8 @@ internal byte[] SerializeSessionStateItemCollection(ISessionStateItemCollection
             {
                 return null;
             }
-            MemoryStream ms = new MemoryStream();
-            BinaryWriter writer = new BinaryWriter(ms);
-            ((SessionStateItemCollection)sessionStateItemCollection).Serialize(writer);
-            writer.Close();
-            return ms.ToArray();
+
+            return configuration.SessionStateSerializer.Serialize((SessionStateItemCollection)sessionStateItemCollection);
         }
 
         public void Set(ISessionStateItemCollection data, int sessionTimeout)
@@ -149,10 +147,10 @@ public void Set(ISessionStateItemCollection data, int sessionTimeout)
         /*-------Start of Lock set operation-----------------------------------------------------------------------------------------------------------------------------------------------*/
 
         // KEYS = { write-lock-id, data-id, internal-id }
-        // ARGV = { write-lock-value-that-we-want-to-set, request-timout }
+        // ARGV = { write-lock-value-that-we-want-to-set, request-timeout }
         // lockValue = 1) (Initially) write lock value that we want to set (ARGV[1]) if we get lock successfully this will return as retArray[1]
         //             2) If another write lock exists than its lock value from cache
-        // retArray = {lockValue , session data if lock was taken successfully, session timeout value if exists, wheather lock was taken or not}
+        // retArray = {lockValue , session data if lock was taken successfully, session timeout value if exists, whether lock was taken or not}
         private static readonly string writeLockAndGetDataScript = (@"
                 local retArray = {}
                 local lockValue = ARGV[1]
@@ -199,7 +197,7 @@ public bool TryTakeWriteLockAndGetData(DateTime lockTime, int lockTimeout, out o
             if (!isLocked && lockId.ToString().Equals(expectedLockId))
             {
                 ret = true;
-                data = redisConnection.GetSessionData(rowDataFromRedis);
+                data = GetSessionData(rowDataFromRedis);
             }
             return ret;
         }
@@ -247,7 +245,7 @@ public bool TryCheckWriteLockAndGetData(out object lockId, out ISessionStateItem
                 // If lockId = "" means no lock exists and we got data from store.
                 lockId = null;
                 ret = true;
-                data = redisConnection.GetSessionData(rowDataFromRedis);
+                data = GetSessionData(rowDataFromRedis);
             }
             return ret;
         }
@@ -371,5 +369,44 @@ public void TryUpdateAndReleaseLock(object lockId, ISessionStateItemCollection d
         }
 
         /*-------End of TryUpdateIfLockIdMatch operation-----------------------------------------------------------------------------------------------------------------------------------------------*/
+
+        internal SessionStateItemCollection DeserializeSessionStateItemCollection(RedisResult serializedSessionStateItemCollection)
+        {
+            try
+            {
+                var bytes = (byte[])serializedSessionStateItemCollection;
+                if (bytes is null)
+                {
+                    return null;
+                }
+                return configuration.SessionStateSerializer.Deserialize(bytes);
+
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        public virtual ISessionStateItemCollection GetSessionData(object rowDataFromRedis)
+        {
+
+            RedisResult rowDataAsRedisResult = (RedisResult)rowDataFromRedis;
+            RedisResult[] lockScriptReturnValueArray = (RedisResult[])rowDataAsRedisResult;
+            Debug.Assert(lockScriptReturnValueArray != null);
+
+            SessionStateItemCollection sessionData = null;
+            if (lockScriptReturnValueArray.Length > 1 && lockScriptReturnValueArray[1] != null)
+            {
+                RedisResult data = lockScriptReturnValueArray[1];
+                var serializedSessionStateItemCollection = data;
+
+                if (serializedSessionStateItemCollection != null)
+                {
+                    sessionData = DeserializeSessionStateItemCollection(serializedSessionStateItemCollection);
+                }
+            }
+            return sessionData;
+        }
     }
 }