//******************************************************************************************************//  SecurityProviderCache.cs - Gbtc////  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  06/25/2010 - Pinal C. Patel//       Generated original version of source code.//  01/27/2011 - Pinal C. Patel//       Updated SetupPrincipal() to call AppDomain.SetThreadPrincipal() to set the thread principal//       in addition to settings the current thread principal so the thread principal is set correctly //       inside WPF applications.//  12/20/2012 - Starlynn Danyelle Gilliam//       Modified Header.//  04/27/2016 - J. Ritchie Carroll //      Added ValidateCurrentProvider method to simplify CurrentProvider usage patten; code clean-up.////****************************************************************************************************** using System;using System.Collections.Generic;using System.Linq;using System.Security.Principal;using System.Timers;using GSF.Collections;using GSF.Configuration;using GSF.Threading;using Timer = System.Timers.Timer; namespace GSF.Security{    /// <summary>    /// A helper class that manages the caching of <see cref="ISecurityProvider"/>s.    /// </summary>    public static class SecurityProviderCache    {        #region [ Members ]         // Nested Types         /// <summary>        /// A class that facilitates the caching of <see cref="ISecurityProvider"/>.        /// </summary>        private class CacheContext        {            #region [ Members ]             // Fields            private readonly ISecurityProvider m_provider;            private readonly WeakReference<ISecurityProvider> m_weakProvider;            private DateTime m_lastRefreshTime;            private DateTime m_lastAccessTime;             #endregion             #region [ Constructors ]             /// <summary>            /// Initializes a new instance of the <see cref="CacheContext"/> class.            /// </summary>            public CacheContext(ISecurityProvider provider)                : this(provider, null)            {            }             /// <summary>            /// Initializes a new instance of the <see cref="CacheContext"/> class.            /// </summary>            public CacheContext(WeakReference<ISecurityProvider> weakProvider)                : this(null, weakProvider)            {            }             private CacheContext(ISecurityProvider provider, WeakReference<ISecurityProvider> weakProvider)            {                DateTime now = DateTime.UtcNow;                 m_provider = provider;                m_weakProvider = weakProvider;                m_lastRefreshTime = now;                m_lastAccessTime = now;            }             #endregion             #region [ Properties ]             /// <summary>            /// Gets the <see cref="ISecurityProvider"/> managed by this <see cref="CacheContext"/>.            /// </summary>            public ISecurityProvider Provider            {                get                {                    ISecurityProvider provider;                     m_lastAccessTime = DateTime.UtcNow;                     if ((object)m_provider != null)                        return m_provider;                     if ((object)m_weakProvider != null && m_weakProvider.TryGetTarget(out provider))                        return provider;                     return null;                }            }             /// <summary>            /// Gets the <see cref="DateTime"/> of when the <see cref="CacheContext"/> was last refreshed.            /// </summary>            public DateTime LastRefreshTime => m_lastRefreshTime;             /// <summary>            /// Gets the <see cref="DateTime"/> of when the <see cref="CacheContext"/> was last accessed.            /// </summary>            public DateTime LastAccessTime => m_lastAccessTime;             #endregion             #region [ Methods ]             /// <summary>            /// Refreshes the provider managed by this <see cref="CacheContext"/>.            /// </summary>            public bool Refresh()            {                ISecurityProvider provider = Provider;                 if ((object)provider == null)                    return false;                 provider.RefreshData();                provider.Authenticate();                m_lastRefreshTime = DateTime.UtcNow;                 return true;            }             #endregion        }         // Constants         /// <summary>        /// Number of minutes up to which <see cref="ISecurityProvider"/>s are to be cached.        /// </summary>        private const int DefaultUserCacheTimeout = 5;         /// <summary>        /// Number of milliseconds between calls to monitor the cache.        /// </summary>        private const int CacheMonitorTimerInterval = 60000;         #endregion         #region [ Static ]         // Static Fields        private static readonly Dictionary<string, CacheContext> s_cache;        private static readonly List<CacheContext> s_autoRefreshProviders;        private static readonly int s_userCacheTimeout;        private static readonly Action s_cacheMonitorAction;         // Static Constructor        static SecurityProviderCache()        {            // Load settings from the specified category            ConfigurationFile config = ConfigurationFile.Current;            CategorizedSettingsElementCollection settings = config.Settings[SecurityProviderBase.DefaultSettingsCategory];            settings.Add("UserCacheTimeout", DefaultUserCacheTimeout, "Defines the timeout, in whole minutes, for a user's provider cache. Any value less than 1 will cause cache reset every minute.");             s_userCacheTimeout = settings["UserCacheTimeout"].ValueAs(DefaultUserCacheTimeout);             // Initialize static variables            s_cache = new Dictionary<string, CacheContext>();            s_autoRefreshProviders = new List<CacheContext>();             s_cacheMonitorAction = new Action(ManageCachedCredentials);            s_cacheMonitorAction.DelayAndExecute(CacheMonitorTimerInterval);        }         // Static Methods         /// <summary>        /// Creates a new provider from data cached by the <see cref="SecurityProviderCache"/>.        /// </summary>        /// <param name="username">The username of the user for which to create a new provider.</param>        /// <param name="passthroughPrincipal"><see cref="IPrincipal"/> obtained through alternative authentication mechanisms to provide authentication for the <see cref="ISecurityProvider"/>.</param>        /// <param name="autoRefresh">Indicates whether the provider should be automatically refreshed on a timer.</param>        /// <returns>A new provider initialized from cached data.</returns>        public static ISecurityProvider CreateProvider(string username, IPrincipal passthroughPrincipal = null, bool autoRefresh = true)        {            CacheContext cacheContext;             lock (s_cache)            {                cacheContext = s_cache.GetOrAdd(username, name => new CacheContext(SecurityProviderUtility.CreateProvider(username, passthroughPrincipal)));            }             ISecurityProvider provider = SecurityProviderUtility.CreateProvider(cacheContext.Provider.UserData);            provider.PassthroughPrincipal = passthroughPrincipal;             if (autoRefresh)                AutoRefresh(provider);             return provider;        }         /// <summary>        /// Removes any cached information about the user with the given username.        /// </summary>        /// <param name="username">The username of the user to be flushed from the cache.</param>        public static void Flush(string username)        {            lock (s_cache)            {                s_cache.Remove(username);            }        }         /// <summary>        /// Adds the given provider to the collection of providers being automatically refreshed on the user cache timeout interval.        /// </summary>        /// <param name="provider">The security provider to be cached.</param>        public static void AutoRefresh(ISecurityProvider provider)        {            lock (s_autoRefreshProviders)            {                WeakReference<ISecurityProvider> weakProvider = new WeakReference<ISecurityProvider>(provider);                CacheContext cacheContext = new CacheContext(weakProvider);                s_autoRefreshProviders.Add(cacheContext);            }        }         /// <summary>        /// Removes the given provider from the collection of providers being automatically refreshed.        /// </summary>        /// <param name="provider">The provider to be removed.</param>        public static void DisableAutoRefresh(ISecurityProvider provider)        {            lock (s_autoRefreshProviders)            {                s_autoRefreshProviders.RemoveAll(cacheContext => provider.Equals(cacheContext.Provider));            }        }         /// <summary>        /// Forces all cached providers to refresh state.        /// </summary>        public static void RefreshAll()        {            lock (s_cache)            {                s_cache.Clear();            }             List<CacheContext> refreshedContexts = new List<CacheContext>();             lock (s_autoRefreshProviders)            {                for (int i = s_autoRefreshProviders.Count - 1; i >= 0; i--)                {                    CacheContext cacheContext = s_autoRefreshProviders[i];                     if ((object)cacheContext.Provider == null)                    {                        s_autoRefreshProviders[i] = s_autoRefreshProviders[s_autoRefreshProviders.Count - 1];                        s_autoRefreshProviders.RemoveAt(s_autoRefreshProviders.Count - 1);                    }                    else                    {                        refreshedContexts.Add(cacheContext);                    }                }            }             // It's important to avoid calling refresh            // inside the lock for performance reasons            foreach (CacheContext cacheContext in refreshedContexts)                cacheContext.Refresh();        }         private static void ManageCachedCredentials()        {            HashSet<CacheContext> refreshedContexts = new HashSet<CacheContext>();             lock (s_cache)            {                foreach (string username in s_cache.Keys.ToList())                {                    CacheContext cacheContext = s_cache[username];                     if (DateTime.UtcNow.Subtract(cacheContext.LastAccessTime).TotalMinutes > s_userCacheTimeout)                        s_cache.Remove(username);                    else                        refreshedContexts.Add(s_cache[username]);                }            }             lock (s_autoRefreshProviders)            {                for (int i = s_autoRefreshProviders.Count - 1; i >= 0; i--)                {                    CacheContext cacheContext = s_autoRefreshProviders[i];                     if (DateTime.UtcNow.Subtract(cacheContext.LastRefreshTime).TotalMinutes > s_userCacheTimeout)                    {                        if ((object)cacheContext.Provider == null)                        {                            s_autoRefreshProviders[i] = s_autoRefreshProviders[s_autoRefreshProviders.Count - 1];                            s_autoRefreshProviders.RemoveAt(s_autoRefreshProviders.Count - 1);                        }                        else                        {                            refreshedContexts.Add(cacheContext);                        }                    }                }            }             // It's important to avoid calling refresh            // inside the lock for performance reasons            foreach (CacheContext cacheContext in refreshedContexts)                cacheContext.Refresh();             // The refresh could take several minutes so we should            // wait to kick off the timer until after we are finished            s_cacheMonitorAction.DelayAndExecute(CacheMonitorTimerInterval);        }         #endregion    }}