//******************************************************************************************************//  HubClientOperationsBase.cs - Gbtc////  Copyright © 2016, 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://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://  ----------------------------------------------------------------------------------------------------//  08/16/2016 - J. Ritchie Carroll//       Generated original version of source code.////****************************************************************************************************** using System;using System.Collections.Concurrent;using Microsoft.AspNet.SignalR.Hubs; namespace GSF.Web.Hubs{    /// <summary>    /// Represents a base class for SignalR hub operations that need to track session based clients.    /// </summary>    /// <typeparam name="T">Type of <see cref="IHubClient"/> for hub operations.</typeparam>    public abstract class HubClientOperationsBase<T> where T : class, IHubClient, new()    {        #region [ Members ]         // Fields        private readonly IHub m_hub;        private readonly Action<string, UpdateType> m_logStatusMessageFunction;        private readonly Action<Exception> m_logExceptionFunction;        private T m_hubClient;         #endregion         #region [ Constructors ]         /// <summary>        /// Creates a new <see cref="HubClientOperationsBase{T}"/> instance.        /// </summary>        /// <param name="hub"></param>        /// <param name="logStatusMessageFunction">Delegate to use to log status messages, if any.</param>        /// <param name="logExceptionFunction">Delegate to use to log exceptions, if any.</param>        protected HubClientOperationsBase(IHub hub, Action<string, UpdateType> logStatusMessageFunction = null, Action<Exception> logExceptionFunction = null)        {            m_hub = hub;            m_logStatusMessageFunction = logStatusMessageFunction;            m_logExceptionFunction = logExceptionFunction;        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets instance of hub client for current SignalR session.        /// </summary>        protected T HubClient        {            get            {                if ((object)m_hubClient != null)                    return m_hubClient;                 // Attempt to get connection ID from active hub context                string connectionID = m_hub?.Context?.ConnectionId;                 if (string.IsNullOrEmpty(connectionID))                {                    // If no connection ID was available, check to see if base hub is a record operations hub,                    // if so, see if there is an assigned connection ID to use, such as may be the case if the                    // hub instance is being used outside of a SignalR context, like an IHostedHttpHandler                    IRecordOperationsHub recordOperationsHub = m_hub as IRecordOperationsHub;                     connectionID = recordOperationsHub?.ConnectionID;                     if (string.IsNullOrEmpty(connectionID))                        return null;                }                 m_hubClient = s_hubClients.GetOrAdd(connectionID, id => new T                {                    HubInstance = m_hub,                    ConnectionID = connectionID,                    LogStatusMessageFunction = m_logStatusMessageFunction,                    LogExceptionFunction = m_logExceptionFunction                });                 return m_hubClient;            }        }         /// <summary>        /// Disposes any associated <see cref="IHubClient"/> when SignalR session is disconnected.        /// </summary>        /// <remarks>        /// This method should be called within implementing SignalR hub when stop is called.        /// </remarks>        public virtual void EndSession()        {            EndSession(m_hub?.Context?.ConnectionId);        }         #endregion         #region [ Static ]         // Static Fields         // References to session based IHubClient implementations - since a SignalR session can persist through        // any number of hub instances, this dictionary is used to track IHubClient instances        private static readonly ConcurrentDictionary<string, T> s_hubClients;         // Static Constructor        static HubClientOperationsBase()        {            s_hubClients = new ConcurrentDictionary<string, T>(StringComparer.OrdinalIgnoreCase);        }         // Static Methods         /// <summary>        /// Disposes any associated <see cref="IHubClient"/> when SignalR session is disconnected.        /// </summary>        /// <param name="connectionID">SignalR connection ID.</param>        /// <remarks>        /// This method should be called within implementing SignalR hub when stop is called.        /// </remarks>        public static void EndSession(string connectionID)        {            T client;             // Dispose of hub client when SignalR session is disconnected            if (!string.IsNullOrEmpty(connectionID) && s_hubClients.TryRemove(connectionID, out client))                client?.Dispose();        }         #endregion    }}