C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx.Client.Shared/PluginHost.cs

/*  ----------------------------------------------------------------------------
 *  Microsoft Corporation
 *  ----------------------------------------------------------------------------
 *  Microsoft Project Server mpFx (mpFx)
 *  ----------------------------------------------------------------------------
 *  Author: Colby Africa
 *  ----------------------------------------------------------------------------
 *  License: http://code.msdn.microsoft.com/mpFx/Project/License.aspx
 *  ----------------------------------------------------------------------------
 */

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Windows.Forms;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Shared.Forms;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Shared.Properties;

namespace Mcs.Epm.MicrosoftProject.mpFx.Client.Shared
{
    public class PluginHost : IDisposable
    {
        #region Instance Data

        private readonly string _StartupPath;
        private bool _Disposed;
        private readonly List<string> _ExclusionList = new List<string>(Settings.Default.ExclusionList.Split(','));

        #endregion

        #region Public Events

        public event OnStatusChangedEventHandler OnStatusChanged;

        #endregion

        #region Public Properties

        public ProjectServer ProjectServer { get; private set; }
        public Form Parent { get; private set; }
        public ToolStrip ToolStrip { get; private set; }
        public Dictionary<Guid, IMpFxClientPlugin> Plugins { get; private set; }
        public PluginGallery Gallery { get; private set; }
        #endregion

        #region Constructors

        public PluginHost(ProjectServer projectServer, Form parent, ToolStrip toolStrip, string startupPath)
        {
            Tools.ValidateObjectParam(projectServer,
                                      string.Format(CultureInfo.CurrentCulture,
                                                    Resources.InvalidArgument,
                                                    "projectServer"));

            Tools.ValidateObjectParam(parent,
                                      string.Format(CultureInfo.CurrentCulture,
                                                    Resources.InvalidArgument,
                                                    "parent"));

            Tools.ValidateObjectParam(toolStrip,
                                      string.Format(CultureInfo.CurrentCulture,
                                                    Resources.InvalidArgument,
                                                    "toolStrip"));


            Tools.ValidateDirectoryParam(startupPath,
                                         string.Format(CultureInfo.CurrentCulture,
                                                       Resources.DirectoryNotFound,
                                                       "startupPath"));
            ProjectServer = projectServer;
            Parent = parent;
            ToolStrip = toolStrip;

            _StartupPath = startupPath;
            _StartupPath = Path.Combine(_StartupPath, Settings.Default.PluginSubDirectory);

            if (!Directory.Exists(_StartupPath))
            {
                Directory.CreateDirectory(_StartupPath);
            }

            Plugins = new Dictionary<Guid, IMpFxClientPlugin>();            

            Gallery = new PluginGallery(this);

            _Disposed = false;
        }

        #endregion

        #region Public Methods

        public void Load()
        {            
            Tools.ValidateDirectoryParam(_StartupPath,
                                         string.Format(CultureInfo.CurrentCulture,
                                                       Resources.DirectoryNotFound,
                                                       _StartupPath));

            string[] directories = Directory.GetDirectories(_StartupPath);

            if (directories.Length == 0)
            {
                throw new MpFxException(Resources.PluginsNotPresent);
            }

            CreateUserInterFace();

            AppDomain testDomain = AppDomain.CreateDomain(Resources.AppTitle);

            IInterfaceInspector interfaceInspector = InterfaceInspector.Get(testDomain, Resources.Inspector);

            foreach (string directory in directories)
            {
                if (File.Exists(Path.Combine(directory, "delete")))   // Plugin marked for deletion
                {
                    Tools.DeleteDirectory(directory, true);
                    continue;
                }

                string[] files = Directory.GetFiles(directory, "*.dll");

                foreach (string file in files)
                {
                    IMpFxClientPlugin plugin = LoadPlugin(interfaceInspector, file, true);
                    if (plugin != null)
                    {
                        break;
                    }
                }
            }
        }

        public void LoadPlugin(Guid guid)
        {
            if (!Plugins.ContainsKey(guid))
            {
                throw new ArgumentException(Tools.Format(Resources.InvalidPlugin, guid));
            }

            IMpFxClientPlugin plugin = Plugins[guid];

            if (plugin != null)
            {
                plugin.OnLoad(ProjectServer, Parent, ToolStrip);
            }
        }

        public void UnloadPlugin(Guid guid)
        {
            if (!Plugins.ContainsKey(guid))
            {
                throw new ArgumentException(Tools.Format(Resources.InvalidPlugin, guid));
            }

            IMpFxClientPlugin plugin = Plugins[guid];

            if (plugin != null && plugin.IsLoaded)
            {
                plugin.OnUnload();
            }
        }

        public IMpFxClientPlugin LoadPlugin(IInterfaceInspector interfaceInspector, string file, bool addToCollection)
        {
            IMpFxClientPlugin plugin = null;

            try
            {
                string typeName;

                if (interfaceInspector.TryGetTypeNameByFileAndInterface(file, Resources.PluginInterface, out typeName))
                {
                    Assembly pluginAssembly = Assembly.LoadFile(file);

                    Type pluginType = pluginAssembly.GetType(typeName);

                    if (pluginType != null)
                    {
                        plugin = Activator.CreateInstance(pluginType) as IMpFxClientPlugin;

                        if (plugin != null)
                        {
                            plugin.Implementation = file;

                            if (addToCollection)
                            {
                                Plugins.Add(plugin.Guid, plugin);

                                plugin.OnStatusChanged += plugin_OnStatusChanged;

                                DoOnStatusChanged(new OnStatusChangedArgs(Tools.Format(Resources.LoadingPlugin,
                                                                                       plugin.Name,
                                                                                       plugin.Version,
                                                                                       plugin.Author)));

                                plugin.OnLoad(ProjectServer, Parent, ToolStrip);
                            }

                            return plugin;
                        }
                    }
                }
            }
            catch (Exception)
            {
                if (plugin != null)
                {
                    plugin.Dispose();
                }

                throw;
            }

            return null;
        }

        public void RemovePlugin(Guid guid)
        {
            if (!Plugins.ContainsKey(guid))
            {
                throw new KeyNotFoundException("guid");
            }

            string implementation = Plugins[guid].Implementation;

            implementation = Path.GetDirectoryName(implementation);

            if (!Directory.Exists(implementation))
            {
                throw new DirectoryNotFoundException(implementation);
            }

            implementation = Path.Combine(implementation, "delete");

            File.Create(implementation).Dispose();
        }

        public string AddPluginToLocalGallery(PluginDescriptor pluginDescriptor, string file)
        {
            Assembly sourceAssembly = Assembly.LoadFile(file);
            List<string> referencedAssembliesPaths = GetDependencies(sourceAssembly);
            string targetPath = pluginDescriptor.Name.Replace(" ", "");
            targetPath = Path.Combine(_StartupPath, targetPath);

            if (Directory.Exists(targetPath))
            {
                throw new IOException(string.Format("Target directory exists: ' {0}'.  Please remove the directory and try again", targetPath));
            }

            Directory.CreateDirectory(targetPath);

            foreach (string referencedAssemblyPath in referencedAssembliesPaths)
            {
                File.Copy(referencedAssemblyPath, Path.Combine(targetPath, Path.GetFileName(referencedAssemblyPath)));
            }

            string[] files = Directory.GetFiles(Path.GetDirectoryName(file));

            string pluginFilePath = Path.Combine(targetPath, Path.GetFileName(file));

            foreach (string otherfile in files)
            {
                if (!referencedAssembliesPaths.Contains(otherfile) && !otherfile.Equals(file, StringComparison.CurrentCultureIgnoreCase))
                {
                    string otherTargetPath = Path.Combine(targetPath, Path.GetFileName(otherfile));
                    File.Copy(otherfile, otherTargetPath);
                }
            }

            File.Copy(file, pluginFilePath);

            Tools.CopyFiles(Path.GetDirectoryName(file), targetPath, "*.config", false);
            Tools.CopyFiles(Path.GetDirectoryName(file), targetPath, "*.pdb", false);

            return pluginFilePath;
        }

        /// <summary>
        /// Add dependencies to either the GAC or bin directory
        /// <remarks>
        /// This is messy, but it is what I came up with first.  Here is how it works:
        /// 1.) Get a list of all the referenced assemblies for the source assembly
        /// 2.) Look in the same directory for all files.
        /// 3.) Attempt to load each file as an assembly
        /// 4.) Iterate over the list of referenced assemblies
        /// 5.) Make sure they aren't in the exclusion list (this is important
        ///     so dependencies from Project and SharePoint don't get redeployed
        /// 6.) Determine if the assembly's full name matches that which is
        ///     listed in the reference assemblies
        /// 7.) If so, the file IMPLEMENTS the reference and can be added to the GAC
        ///     or bin directory.
        /// </remarks>
        /// </summary>
        public List<string> GetDependencies(Assembly sourceAssembly)
        {
            AssemblyName[] referencedAssemblies = sourceAssembly.GetReferencedAssemblies();

            string[] files = Directory.GetFiles(Path.GetDirectoryName(sourceAssembly.Location), "*.dll");

            Dictionary<AssemblyName, Assembly> assemblies = new Dictionary<AssemblyName, Assembly>();

            List<string> referencedAssembliesPaths = new List<string>();
            foreach (string file in files)
            {
                try
                {
                    AssemblyName name = AssemblyName.GetAssemblyName(file);

                    assemblies.Add(name, Assembly.LoadFile(file));
                }
                catch (BadImageFormatException) { }
            }

            foreach (AssemblyName assemblyName in referencedAssemblies)
            {
                if (!IsInExclusionList(assemblyName, sourceAssembly))
                {
                    foreach (KeyValuePair<AssemblyName, Assembly> pair in assemblies)
                    {
                        if (pair.Value.FullName == assemblyName.FullName)
                        {
                            Assembly assembly = assemblies[pair.Key];

                            if (assembly.Location != null)
                            {
                                referencedAssembliesPaths.Add(assembly.Location);
                            }
                            break;
                        }
                    }
                }
            }

            return referencedAssembliesPaths;
        }

        #endregion

        #region Private Methods

        private void CreateUserInterFace()
        {
            DoOnStatusChanged(new OnStatusChangedArgs("Creating user interface..."));

            ToolStripDropDownButton toolDropDownButton = Tools.FindToolStripDropDownButtonByText(ToolStrip, "Tools");

            if (toolDropDownButton == null)
            {
                toolDropDownButton = new ToolStripDropDownButton("&Tools");
            }

            ToolStrip.Items.Insert(ToolStrip.Items.Count - 1, toolDropDownButton);

            ToolStripMenuItem pluginsMenuItem = new ToolStripMenuItem("&Plugins");

            pluginsMenuItem.Click += pluginsMenuItem_Click;

            toolDropDownButton.DropDownItems.Add(pluginsMenuItem);

            DoOnStatusChanged(new OnStatusChangedArgs(string.Empty));

        }

        public void DoOnStatusChanged(OnStatusChangedArgs args)
        {
            if (OnStatusChanged != null)
            {
                OnStatusChanged(this, args);
            }
        }

        /// <summary>
        /// Determine whether a given assembly name starts with any
        /// item in the inclusion list.
        /// </summary>
        /// <param name="assemblyName"></param>
        /// <param name="sourceAssembly"></param>
        /// <returns></returns>
        private bool IsInExclusionList(AssemblyName assemblyName, Assembly sourceAssembly)
        {
            string assemblyFullName = assemblyName.FullName;

            if (assemblyFullName.Equals(sourceAssembly.FullName))
            {
                return true;
            }

            foreach (string excludedItem in _ExclusionList)
            {
                if (assemblyFullName.StartsWith(excludedItem, StringComparison.CurrentCultureIgnoreCase))
                {
                    return true;
                }
            }

            return false;
        }

        #endregion

        #region Event Handlers

        void pluginsMenuItem_Click(object sender, EventArgs e)
        {
            using (PluginManagerForm managerForm = new PluginManagerForm(this))
            {
                managerForm.ShowDialog(Parent);
            }
        }

        void plugin_OnStatusChanged(object sender, OnStatusChangedArgs args)
        {
            DoOnStatusChanged(args);
        }

        #endregion

        #region IDisposable members

        ~PluginHost()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing)
        {
            if (!_Disposed)
            {
                if (disposing)
                {
                    CleanUp();
                }

                _Disposed = true;
            }
        }

        private void CleanUp()
        {
            try
            {
                foreach (KeyValuePair<Guid, IMpFxClientPlugin> plugin in Plugins)
                {
                    plugin.Value.OnUnload();
                    plugin.Value.Dispose();
                }

                Gallery.Dispose();

            }
            catch (Exception)
            {/* Swallow */}
        }

        #endregion

    }
}

---