//******************************************************************************************************//  Adapter.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://  ----------------------------------------------------------------------------------------------------//  09/23/2010 - Pinal C. Patel//       Generated original version of source code.//  11/19/2010 - Pinal C. Patel//       Removed the persistence of Enabled property to the config file.//  11/24/2010 - Pinal C. Patel//       Modified Name property to use SettingsCategory instead of Type name.//  12/07/2010 - Pinal C. Patel//       Updated PersistSettings property to default to false instead of true.//  03/08/2011 - Pinal C. Patel//       Added StatusUpdate and Disposed events.//       Added Type and File properties to support serialized adapter instances.//       Added attributes to fields and properties to enable serialization of derived type instances.//  04/05/2011 - Pinal C. Patel//       Changed properties Type to TypeName and File to HostFile to avoid naming conflict.//       Modified Name property to use the file name (no extension) from HostFile property if available.//  04/08/2011 - Pinal C. Patel//       Added ExecutionException event.//       Renamed StatusUpdate event to StatusMessage.//  05/11/2011 - Pinal C. Patel//       Modified OnStatusUpdate() method to allow for parameterized arguments.//  09/21/2011 - J. Ritchie Carroll//       Added Mono implementation exception regions.//  01/18/2012 - Pinal C. Patel//       Added DataContract attribute to prevent serialization of events when serializing using //       DataContractSerializer//  12/13/2012 - Starlynn Danyelle Gilliam//       Modified Header.////****************************************************************************************************** using System;using System.ComponentModel;using System.Configuration;using System.Runtime.Serialization;using System.Text;using System.Xml.Serialization;using GSF.IO; namespace GSF.Adapters{    /// <summary>    /// Represents an adapter that could execute in isolation in a separate <see cref="AppDomain"/>.    /// </summary>    /// <seealso cref="IAdapter"/>    /// <seealso cref="AdapterLoader{T}"/>    [Serializable, DataContract(Namespace = "")]    public class Adapter : MarshalByRefObject, IAdapter    {        #region [ Members ]         // Fields        [NonSerialized]        private DateTime m_created;        [NonSerialized]        private string m_hostFile;        [NonSerialized]        private bool m_persistSettings;        [NonSerialized]        private string m_settingsCategory;        [NonSerialized]        private bool m_enabled;        [NonSerialized]        private bool m_disposed;        [NonSerialized]        private bool m_initialized;         // Events         /// <summary>        /// Occurs when the <see cref="Adapter"/> wants to provide a status update.        /// </summary>        /// <remarks>        /// <see cref="EventArgs{T1,T2}.Argument1"/> is the <see cref="UpdateType"/>.<br/>        /// <see cref="EventArgs{T1,T2}.Argument2"/> is the update message.        /// </remarks>        public event EventHandler<EventArgs<UpdateType, string>> StatusUpdate;         /// <summary>        /// Occurs when the <see cref="IAdapter"/> encounters an <see cref="Exception"/> during execution.        /// </summary>        /// <remarks>        /// <see cref="EventArgs{T1,T2}.Argument1"/> is the text that describes the activity that was being performed by the <see cref="IAdapter"/>.<br/>        /// <see cref="EventArgs{T1,T2}.Argument2"/> is the encountered <see cref="Exception"/>.        /// </remarks>        public event EventHandler<EventArgs<string, Exception>> ExecutionException;         /// <summary>        /// Occurs when <see cref="Adapter"/> is disposed.        /// </summary>        public event EventHandler Disposed;         #endregion         #region [ Constructors ]         /// <summary>        /// Initializes a new instance of the <see cref="Adapter"/>.        /// </summary>        public Adapter()        {            m_created = DateTime.UtcNow;            m_settingsCategory = this.GetType().Name;        }         /// <summary>        /// Releases the unmanaged resources before the <see cref="Adapter"/> is reclaimed by <see cref="GC"/>.        /// </summary>        ~Adapter()        {            Dispose(false);        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets or sets the text representation of the <see cref="Adapter"/>'s <see cref="TypeName"/>.        /// </summary>        /// <remarks>        /// This can be used for looking up the <see cref="TypeName"/> of the <see cref="Adapter"/> when deserializing it using <see cref="XmlSerializer"/>.        /// </remarks>        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]        public virtual string TypeName        {            get            {                Type type = this.GetType();                return string.Format("{0}, {1}", type.FullName, type.Assembly.GetName().Name);            }            set            {                // Ignore            }        }         /// <summary>        /// Gets or sets the path to the file where the <see cref="Adapter"/> is housed.        /// </summary>        /// <remarks>        /// This can be used to update the <see cref="Adapter"/> when changes are made to the file where it is housed.        /// </remarks>        [XmlIgnore, Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]        public virtual string HostFile        {            get            {                return m_hostFile;            }            set            {                m_hostFile = value;            }        }         /// <summary>        /// Gets or sets a boolean value that indicates whether the <see cref="Adapter"/> is currently enabled.        /// </summary>        [XmlIgnore]        public virtual bool Enabled        {            get            {                return m_enabled;            }            set            {                m_enabled = value;            }        }         /// <summary>        /// Gets a flag that indicates whether the object has been disposed.        /// </summary>        [XmlIgnore]        public bool IsDisposed        {            get            {                return m_disposed;            }        }         /// <summary>        /// Gets or sets a boolean value that indicates whether <see cref="Adapter"/> settings are to be saved to the config file.        /// </summary>        [XmlIgnore]        public virtual bool PersistSettings        {            get            {                return m_persistSettings;            }            set            {                m_persistSettings = value;            }        }         /// <summary>        /// Gets or sets the category under which <see cref="Adapter"/> settings are to be saved to the config file if the <see cref="PersistSettings"/> property is set to true.        /// </summary>        /// <exception cref="ArgumentNullException">The value being assigned is a null or empty string.</exception>        [XmlIgnore]        public virtual string SettingsCategory        {            get            {                return m_settingsCategory;            }            set            {                if (string.IsNullOrEmpty(value))                    throw new ArgumentNullException(nameof(value));                 m_settingsCategory = value;            }        }         /// <summary>        /// Gets the memory utilization of the <see cref="Adapter"/> in bytes if executing in a separate <see cref="AppDomain"/>, otherwise <see cref="Double.NaN"/>.        /// </summary>        /// <remarks>        /// <para>        /// <see cref="MemoryUsage"/> gets updated only after a full blocking collection by <see cref="GC"/> (e.g. <see cref="GC.Collect()"/>).        /// </para>        /// <para>        /// This method always returns <c><see cref="Double.NaN"/></c> under Mono deployments.        /// </para>        /// </remarks>        public double MemoryUsage        {            get            {#if !MONO                if (!Domain.IsDefaultAppDomain() && AppDomain.MonitoringIsEnabled)                    // Both app domain isolation and app domain resource monitoring is enabled.                    return Domain.MonitoringSurvivedMemorySize;#endif                return double.NaN;            }        }         /// <summary>        /// Gets the % processor utilization of the <see cref="Adapter"/> if executing in a separate <see cref="AppDomain"/> otherwise <see cref="Double.NaN"/>.        /// </summary>        /// <remarks>        /// This method always returns <c><see cref="Double.NaN"/></c> under Mono deployments.        /// </remarks>        public double ProcessorUsage        {            get            {#if !MONO                if (!Domain.IsDefaultAppDomain() && AppDomain.MonitoringIsEnabled)                    // Both app domain isolation and app domain resource monitoring is enabled.                    return Domain.MonitoringTotalProcessorTime.TotalSeconds / Ticks.ToSeconds(DateTime.UtcNow.Ticks - m_created.Ticks) / Environment.ProcessorCount * 100;#endif                return double.NaN;            }        }         /// <summary>        /// Gets the unique identifier of the <see cref="Adapter"/>.        /// </summary>        public virtual string Name        {            get            {                if (string.IsNullOrEmpty(m_hostFile))                    return m_settingsCategory;                 return FilePath.GetFileNameWithoutExtension(m_hostFile);            }        }         /// <summary>        /// Gets the descriptive status of the <see cref="Adapter"/>.        /// </summary>        public virtual string Status        {            get            {                StringBuilder status = new StringBuilder();                status.Append("            Adapter domain: ");                status.Append(Domain.FriendlyName);                status.AppendLine();                status.Append("             Adapter state: ");                status.Append(Enabled ? "Enabled" : "Disabled");                status.AppendLine();                status.Append("              Memory usage: ");                status.Append(double.IsNaN(MemoryUsage) ? "Not tracked" : MemoryUsage.ToString("0 bytes"));                status.AppendLine();                status.Append("           Processor usage: ");                status.Append(double.IsNaN(ProcessorUsage) ? "Not tracked" : ProcessorUsage.ToString("0'%'"));                status.AppendLine();                 return status.ToString();            }        }         /// <summary>        /// Gets the <see cref="AppDomain"/> in which the <see cref="Adapter"/> is executing.        /// </summary>        public virtual AppDomain Domain        {            get            {                return AppDomain.CurrentDomain;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Releases all the resources used by the <see cref="Adapter"/>.        /// </summary>        public void Dispose()        {            Dispose(true);            GC.SuppressFinalize(this);        }         /// <summary>        /// Initializes the <see cref="Adapter"/>.        /// </summary>        public virtual void Initialize()        {            if (!m_initialized)            {                LoadSettings();         // Load settings from the config file.                m_initialized = true;   // Initialize only once.            }        }         /// <summary>        /// Saves <see cref="Adapter"/> settings to the config file if the <see cref="PersistSettings"/> property is set to true.        /// </summary>        /// <exception cref="ConfigurationErrorsException"><see cref="SettingsCategory"/> has a value of null or empty string.</exception>        public virtual void SaveSettings()        {            if (m_persistSettings)            {                // Ensure that settings category is specified.                if (string.IsNullOrEmpty(m_settingsCategory))                    throw new ConfigurationErrorsException("SettingsCategory property has not been set.");            }        }         /// <summary>        /// Loads saved <see cref="Adapter"/> settings from the config file if the <see cref="PersistSettings"/> property is set to true.        /// </summary>        /// <exception cref="ConfigurationErrorsException"><see cref="SettingsCategory"/> has a value of null or empty string.</exception>        public virtual void LoadSettings()        {            if (m_persistSettings)            {                // Ensure that settings category is specified.                if (string.IsNullOrEmpty(m_settingsCategory))                    throw new ConfigurationErrorsException("SettingsCategory property has not been set.");            }        }         /// <summary>        /// Releases the unmanaged resources used by the <see cref="Adapter"/> and optionally releases the managed resources.        /// </summary>        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>        protected virtual void Dispose(bool disposing)        {            if (!m_disposed)            {                try                {                    // This will be done regardless of whether the object is finalized or disposed.				                    if (disposing)                    {                        // This will be done only when the object is disposed by calling Dispose().                        SaveSettings();                    }                }                finally                {                    m_disposed = true;  // Prevent duplicate dispose.                    OnDisposed();       // Raise dispose event.                }            }        }         /// <summary>        /// Raises the <see cref="StatusUpdate"/> event.        /// </summary>        /// <param name="updateType"><see cref="UpdateType"/> to send to <see cref="StatusUpdate"/> event.</param>        /// <param name="updateMessage">Update message to send to <see cref="StatusUpdate"/> event.</param>        /// <param name="args">Arguments to be used when formatting the <paramref name="updateMessage"/>.</param>        protected virtual void OnStatusUpdate(UpdateType updateType, string updateMessage, params object[] args)        {            if ((object)StatusUpdate != null)                StatusUpdate(this, new EventArgs<UpdateType, string>(updateType, string.Format(updateMessage, args)));        }         /// <summary>        /// Raises the <see cref="ExecutionException"/> event.        /// </summary>        /// <param name="activityDescription">Activity description to send to <see cref="ExecutionException"/> event.</param>        /// <param name="encounteredException">Encountered <see cref="Exception"/> to send to <see cref="ExecutionException"/> event.</param>        protected virtual void OnExecutionException(string activityDescription, Exception encounteredException)        {            if ((object)ExecutionException != null)                ExecutionException(this, new EventArgs<string, Exception>(activityDescription, encounteredException));        }         /// <summary>        /// Raises the <see cref="Disposed"/> event.        /// </summary>        protected virtual void OnDisposed()        {            if ((object)Disposed != null)                Disposed(this, EventArgs.Empty);        }         #endregion    }}