Handle cache unreliability #99

JunTaoLuo · JunTaoLuo · commit db918af1e3eb · 2016-05-18T12:07:43.000-07:00
diff --git a/src/Microsoft.AspNetCore.Session/DistributedSession.cs b/src/Microsoft.AspNetCore.Session/DistributedSession.cs
@@ -75,7 +75,7 @@ public string Id
         {
             get
             {
-                Load(); // TODO: Silent failure
+                Load();
                 if (_sessionId == null)
                 {
                     _sessionId = new Guid(IdBytes).ToString();
@@ -88,7 +88,7 @@ private byte[] IdBytes
         {
             get
             {
-                Load(); // TODO: Silent failure
+                Load();
                 if (_sessionIdBytes == null)
                 {
                     _sessionIdBytes = new byte[IdByteCount];
@@ -102,14 +102,14 @@ public IEnumerable<string> Keys
         {
             get
             {
-                Load(); // TODO: Silent failure
+                Load();
                 return _store.Keys.Select(key => key.KeyString);
             }
         }
 
         public bool TryGetValue(string key, out byte[] value)
         {
-            Load(); // TODO: Silent failure
+            Load();
             return _store.TryGetValue(new EncodedKey(key), out value);
         }
 
@@ -155,7 +155,17 @@ private void Load()
         {
             if (!_loaded)
             {
-                var data = _cache.Get(_sessionKey);
+                byte[] data = null;
+                try
+                {
+                    data = _cache.Get(_sessionKey);
+                }
+                catch (Exception exception)
+                {
+                    _logger.SessionCacheReadException(_sessionKey, exception);
+                    return;
+                }
+
                 if (data != null)
                 {
                     Deserialize(new MemoryStream(data));
@@ -174,7 +184,17 @@ public async Task LoadAsync()
         {
             if (!_loaded)
             {
-                var data = await _cache.GetAsync(_sessionKey);
+                byte[] data = null;
+                try
+                {
+                    data = await _cache.GetAsync(_sessionKey);
+                }
+                catch (Exception exception)
+                {
+                    _logger.SessionCacheReadException(_sessionKey, exception);
+                    return;
+                }
+
                 if (data != null)
                 {
                     Deserialize(new MemoryStream(data));
@@ -191,28 +211,50 @@ public async Task CommitAsync()
         {
             if (_isModified)
             {
-                var data = await _cache.GetAsync(_sessionKey);
-                if (_logger.IsEnabled(LogLevel.Information) && data == null)
+                byte[] data = null;
+                try
+                {
+                    data = await _cache.GetAsync(_sessionKey);
+                }
+                catch (Exception exception)
+                {
+                    _logger.SessionCacheReadException(_sessionKey, exception);
+                    return;
+                }
+
+                if (data == null)
                 {
                     _logger.SessionStarted(_sessionKey, Id);
                 }
                 _isModified = false;
 
                 var stream = new MemoryStream();
                 Serialize(stream);
-                await _cache.SetAsync(
-                    _sessionKey,
-                    stream.ToArray(),
-                    new DistributedCacheEntryOptions().SetSlidingExpiration(_idleTimeout));
 
-                if (_logger.IsEnabled(LogLevel.Debug))
+                try
                 {
-                    _logger.SessionStored(_sessionKey, Id, _store.Count);
+                    await _cache.SetAsync(
+                        _sessionKey,
+                        stream.ToArray(),
+                        new DistributedCacheEntryOptions().SetSlidingExpiration(_idleTimeout));
                 }
+                catch (Exception exception)
+                {
+                    _logger.SessionCacheWriteException(_sessionKey, Id, exception);
+                    return;
+                }
+                _logger.SessionStored(_sessionKey, Id, _store.Count);
             }
             else
             {
-                await _cache.RefreshAsync(_sessionKey);
+                try
+                {
+                    await _cache.RefreshAsync(_sessionKey);
+                }
+                catch (Exception exception)
+                {
+                    _logger.SessionCacheRefreshException(_sessionKey, exception);
+                }
             }
         }
 
diff --git a/src/Microsoft.AspNetCore.Session/LoggingExtensions.cs b/src/Microsoft.AspNetCore.Session/LoggingExtensions.cs
@@ -12,6 +12,9 @@ internal static class LoggingExtensions
         private static Action<ILogger, string, string, Exception> _sessionStarted;
         private static Action<ILogger, string, string, int, Exception> _sessionLoaded;
         private static Action<ILogger, string, string, int, Exception> _sessionStored;
+        private static Action<ILogger, string, Exception> _sessionCacheReadException;
+        private static Action<ILogger, string, string, Exception> _sessionCacheWriteException;
+        private static Action<ILogger, string, Exception> _sessionCacheRefreshException;
 
         static LoggingExtensions()
         {
@@ -22,7 +25,7 @@ static LoggingExtensions()
             _accessingExpiredSession = LoggerMessage.Define<string>(
                 eventId: 2,
                 logLevel: LogLevel.Warning,
-                formatString: "Accessing expired session; Key:{sessionKey}");
+                formatString: "Accessing expired session, Key:{sessionKey}");
             _sessionStarted = LoggerMessage.Define<string, string>(
                 eventId: 3,
                 logLevel: LogLevel.Information,
@@ -35,6 +38,18 @@ static LoggingExtensions()
                 eventId: 5,
                 logLevel: LogLevel.Debug,
                 formatString: "Session stored; Key:{sessionKey}, Id:{sessionId}, Count:{count}");
+            _sessionCacheReadException = LoggerMessage.Define<string>(
+                eventId: 6,
+                logLevel: LogLevel.Error,
+                formatString: "Session read exceptionm, Key:{sessionKey}, Exception:{exception}");
+            _sessionCacheWriteException = LoggerMessage.Define<string, string>(
+                eventId: 7,
+                logLevel: LogLevel.Error,
+                formatString: "Session write exception, Key:{sessionKey}, Id:{sessionId}, Exception:{exception}");
+            _sessionCacheRefreshException = LoggerMessage.Define<string>(
+                eventId: 8,
+                logLevel: LogLevel.Error,
+                formatString: "Session refresh exception, Key:{sessionKey}, Exception:{exception}");
         }
 
         public static void ErrorClosingTheSession(this ILogger logger, Exception exception)
@@ -61,5 +76,20 @@ public static void SessionStored(this ILogger logger, string sessionKey, string
         {
             _sessionStored(logger, sessionKey, sessionId, count, null);
         }
+
+        public static void SessionCacheReadException(this ILogger logger, string sessionKey, Exception exception)
+        {
+            _sessionCacheReadException(logger, sessionKey, exception);
+        }
+
+        public static void SessionCacheWriteException(this ILogger logger, string sessionKey, string sessionId, Exception exception)
+        {
+            _sessionCacheWriteException(logger, sessionKey, sessionId, exception);
+        }
+
+        public static void SessionCacheRefreshException(this ILogger logger, string sessionKey, Exception exception)
+        {
+            _sessionCacheRefreshException(logger, sessionKey, exception);
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public string Id`
`75`	`75`	`{`
`76`	`76`	`get`
`77`	`77`	`{`
`78`		`- Load(); // TODO: Silent failure`
	`78`	`+ Load();`
`79`	`79`	`if (_sessionId == null)`
`80`	`80`	`{`
`81`	`81`	`_sessionId = new Guid(IdBytes).ToString();`
`@@ -88,7 +88,7 @@ private byte[] IdBytes`
`88`	`88`	`{`
`89`	`89`	`get`
`90`	`90`	`{`
`91`		`- Load(); // TODO: Silent failure`
	`91`	`+ Load();`
`92`	`92`	`if (_sessionIdBytes == null)`
`93`	`93`	`{`
`94`	`94`	`_sessionIdBytes = new byte[IdByteCount];`
`@@ -102,14 +102,14 @@ public IEnumerable<string> Keys`
`102`	`102`	`{`
`103`	`103`	`get`
`104`	`104`	`{`
`105`		`- Load(); // TODO: Silent failure`
	`105`	`+ Load();`
`106`	`106`	`return _store.Keys.Select(key => key.KeyString);`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`public bool TryGetValue(string key, out byte[] value)`
`111`	`111`	`{`
`112`		`- Load(); // TODO: Silent failure`
	`112`	`+ Load();`
`113`	`113`	`return _store.TryGetValue(new EncodedKey(key), out value);`
`114`	`114`	`}`
`115`	`115`
`@@ -155,7 +155,17 @@ private void Load()`
`155`	`155`	`{`
`156`	`156`	`if (!_loaded)`
`157`	`157`	`{`
`158`		`- var data = _cache.Get(_sessionKey);`
	`158`	`+ byte[] data = null;`
	`159`	`+ try`
	`160`	`+ {`
	`161`	`+ data = _cache.Get(_sessionKey);`
	`162`	`+ }`
	`163`	`+ catch (Exception exception)`
	`164`	`+ {`
	`165`	`+ _logger.SessionCacheReadException(_sessionKey, exception);`
	`166`	`+ return;`
	`167`	`+ }`
	`168`	`+`
`159`	`169`	`if (data != null)`
`160`	`170`	`{`
`161`	`171`	`Deserialize(new MemoryStream(data));`
`@@ -174,7 +184,17 @@ public async Task LoadAsync()`
`174`	`184`	`{`
`175`	`185`	`if (!_loaded)`
`176`	`186`	`{`
`177`		`- var data = await _cache.GetAsync(_sessionKey);`
	`187`	`+ byte[] data = null;`
	`188`	`+ try`
	`189`	`+ {`
	`190`	`+ data = await _cache.GetAsync(_sessionKey);`
	`191`	`+ }`
	`192`	`+ catch (Exception exception)`
	`193`	`+ {`
	`194`	`+ _logger.SessionCacheReadException(_sessionKey, exception);`
	`195`	`+ return;`
	`196`	`+ }`
	`197`	`+`
`178`	`198`	`if (data != null)`
`179`	`199`	`{`
`180`	`200`	`Deserialize(new MemoryStream(data));`
`@@ -191,28 +211,50 @@ public async Task CommitAsync()`
`191`	`211`	`{`
`192`	`212`	`if (_isModified)`
`193`	`213`	`{`
`194`		`- var data = await _cache.GetAsync(_sessionKey);`
`195`		`- if (_logger.IsEnabled(LogLevel.Information) && data == null)`
	`214`	`+ byte[] data = null;`
	`215`	`+ try`
	`216`	`+ {`
	`217`	`+ data = await _cache.GetAsync(_sessionKey);`
	`218`	`+ }`
	`219`	`+ catch (Exception exception)`
	`220`	`+ {`
	`221`	`+ _logger.SessionCacheReadException(_sessionKey, exception);`
	`222`	`+ return;`
	`223`	`+ }`
	`224`	`+`
	`225`	`+ if (data == null)`
`196`	`226`	`{`
`197`	`227`	`_logger.SessionStarted(_sessionKey, Id);`
`198`	`228`	`}`
`199`	`229`	`_isModified = false;`
`200`	`230`
`201`	`231`	`var stream = new MemoryStream();`
`202`	`232`	`Serialize(stream);`
`203`		`- await _cache.SetAsync(`
`204`		`- _sessionKey,`
`205`		`- stream.ToArray(),`
`206`		`- new DistributedCacheEntryOptions().SetSlidingExpiration(_idleTimeout));`
`207`	`233`
`208`		`- if (_logger.IsEnabled(LogLevel.Debug))`
	`234`	`+ try`
`209`	`235`	`{`
`210`		`- _logger.SessionStored(_sessionKey, Id, _store.Count);`
	`236`	`+ await _cache.SetAsync(`
	`237`	`+ _sessionKey,`
	`238`	`+ stream.ToArray(),`
	`239`	`+ new DistributedCacheEntryOptions().SetSlidingExpiration(_idleTimeout));`
`211`	`240`	`}`
	`241`	`+ catch (Exception exception)`
	`242`	`+ {`
	`243`	`+ _logger.SessionCacheWriteException(_sessionKey, Id, exception);`
	`244`	`+ return;`
	`245`	`+ }`
	`246`	`+ _logger.SessionStored(_sessionKey, Id, _store.Count);`
`212`	`247`	`}`
`213`	`248`	`else`
`214`	`249`	`{`
`215`		`- await _cache.RefreshAsync(_sessionKey);`
	`250`	`+ try`
	`251`	`+ {`
	`252`	`+ await _cache.RefreshAsync(_sessionKey);`
	`253`	`+ }`
	`254`	`+ catch (Exception exception)`
	`255`	`+ {`
	`256`	`+ _logger.SessionCacheRefreshException(_sessionKey, exception);`
	`257`	`+ }`
`216`	`258`	`}`
`217`	`259`	`}`
`218`	`260`