/// <summary> /// Persists the user token blob to the Http session. /// </summary> private void PersistUserTokenCache() { string cacheKey = GetSignedInUsersUniqueId(); if (string.IsNullOrWhiteSpace(cacheKey)) { return; } s_sessionLock.EnterWriteLock(); try { Debug.WriteLine($"INFO: Serializing session {_httpContext.Session.Id}, cacheId {cacheKey}"); // Reflect changes in the persistent store byte[] blob = _userTokenCache.SerializeMsalV3(); _httpContext.Session.Set(cacheKey, blob); _httpContext.Session.CommitAsync().Wait(); } finally { s_sessionLock.ExitWriteLock(); } }
/// <summary> /// Raised AFTER MSAL added the new token in its in-memory copy of the cache. /// This notification is called every time MSAL accessed the cache, not just when a write took place: /// If MSAL's current operation resulted in a cache change, the property TokenCacheNotificationArgs.HasStateChanged will be set to true. /// If that is the case, we call the TokenCache.Serialize() to get a binary blob representing the latest cache content – and persist it. /// </summary> /// <param name="args">Contains parameters used by the MSAL call accessing the cache.</param> private void UserTokenCacheAfterAccessNotification(TokenCacheNotificationArgs args) { SetSignedInUserFromNotificationArgs(args); // if state changed, i.e. new token obtained if (args.HasStateChanged && !string.IsNullOrWhiteSpace(GetSignedInUsersUniqueId())) { if (_inMemoryCache == null) { _inMemoryCache = new UserTokenCache { WebUserUniqueId = GetSignedInUsersUniqueId() }; } _inMemoryCache.CacheBits = _dataProtector.Protect(_userTokenCache.SerializeMsalV3()); _inMemoryCache.LastWrite = DateTime.Now; try { // Update the DB and the lastwrite _tokenCacheDb.Entry(_inMemoryCache).State = _inMemoryCache.UserTokenCacheId == 0 ? EntityState.Added : EntityState.Modified; _tokenCacheDb.SaveChanges(); } catch (DbUpdateConcurrencyException) { // Record already updated on a different thread, so just read the updated record ReadCacheForSignedInUser(); } } }
public void Persist() { SessionLock.EnterWriteLock(); // Reflect changes in the persistent store httpContext.Session.Set(CacheId, cache.SerializeMsalV3()); SessionLock.ExitWriteLock(); }
public void Persist() { SessionLock.EnterWriteLock(); // Reflect changes in the persistent store staticCache[CacheId] = cache.SerializeMsalV3(); SessionLock.ExitWriteLock(); }
/// <summary> /// Persists the user token blob to the memoryCache. /// </summary> private void PersistUserTokenCache() { string cacheKey = GetMsalAccountId(); if (string.IsNullOrWhiteSpace(cacheKey)) { return; } // Ideally, methods that load and persist should be thread safe.MemoryCache.Get() is thread safe. memoryCache.Set(GetMsalAccountId(), UserTokenCache.SerializeMsalV3(), cacheDuration); }
/// <summary> /// Persists the application token's to session cache. /// </summary> private void PersistAppTokenCache() { s_sessionLock.EnterWriteLock(); try { Debug.WriteLine($"INFO: Serializing session {_httpContext.Session.Id}, cacheId {_appCacheId}"); // Reflect changes in the persistent store byte[] blob = _apptokenCache.SerializeMsalV3(); _httpContext.Session.Set(_appCacheId, blob); _httpContext.Session.CommitAsync().Wait(); } finally { s_sessionLock.ExitWriteLock(); } }
public void Persist() { SessionLock.EnterWriteLock(); try { Debug.WriteLine($"INFO: Serializing session {session.Id}, cacheId {CacheId}"); // Reflect changes in the persistent store byte[] blob = cache.SerializeMsalV3(); session.Set(CacheId, blob); session.CommitAsync().Wait(); } finally { SessionLock.ExitWriteLock(); } }
/// <summary> /// Persists the application's token to the cache. /// </summary> private void PersistAppTokenCache() { // Ideally, methods that load and persist should be thread safe.MemoryCache.Get() is thread safe. // Reflect changes in the persistence store memoryCache.Set(AppCacheId, AppTokenCache.SerializeMsalV3(), cacheDuration); }
public void Persist() { // Reflect changes in the persistent store byte[] blob = cache.SerializeMsalV3(); memoryCache.Set(CacheId, blob); }
private void Persist() { sessionLock.EnterReadLock(); httpContext.Session[cacheId] = tokenCache.SerializeMsalV3(); sessionLock.ExitReadLock(); }
private void Persist(string key, ITokenCache tokenCache) { _cache.Set(key, tokenCache.SerializeMsalV3(), DateTimeOffset.Now.AddHours(12)); }
/// <summary> /// Persists the user token blob to the memoryCache. /// </summary> private void PersistUserTokenCache() { // Ideally, methods that load and persist should be thread safe.MemoryCache.Get() is thread safe. _memoryCache.Set(GetMsalAccountId(), _userTokenCache.SerializeMsalV3(), _cacheOptions.AbsoluteExpiration); }