* Added ExtensionLoader, a generic plugin system with internal, external assembly, and source file plugin loading as well as interface binding

* Switched Simian over to ExtensionLoader

git-svn-id: http://libopenmetaverse.googlecode.com/svn/trunk@2258 52acb1d6-8a22-11de-b505-999d5b087335

ExtensionLoader/ExtensionLoader.cs

@@ -0,0 +1,191 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.CodeDom.Compiler;
+using System.IO;
+
+namespace ExtensionLoader
+{
+    /// <summary>
+    /// Exception thrown when there is a problem with an extension
+    /// </summary>
+    public class ExtensionException : Exception
+    {
+        public ExtensionException(string message)
+            : base(message)
+        {
+        }
+
+        public ExtensionException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+
+    public static class ExtensionLoader<TOwner>
+    {
+        /// <summary>Currently loaded extensions</summary>
+        public static List<IExtension> Extensions;
+        /// <summary></summary>
+        public static CodeDomProvider CSCompiler;
+        /// <summary></summary>
+        public static CompilerParameters CSCompilerParams;
+
+        static ExtensionLoader()
+        {
+            Extensions = new List<IExtension>();
+
+            CSCompiler = CodeDomProvider.CreateProvider("C#");
+
+            CSCompilerParams = new CompilerParameters();
+            CSCompilerParams.GenerateExecutable = false;
+            CSCompilerParams.GenerateInMemory = true;
+            if (System.Diagnostics.Debugger.IsAttached)
+                CSCompilerParams.IncludeDebugInformation = true;
+            else
+                CSCompilerParams.IncludeDebugInformation = false;
+        }
+
+        /// <summary>
+        /// Load extensions within the current assembly, from assembly files in
+        /// a given directory, or from source code files in a given directory
+        /// </summary>
+        /// <param name="assembly">Main assembly to load extensions from</param>
+        /// <param name="path">Directory to load assembly and source code
+        /// extensions from</param>
+        /// <param name="owner">Object that owns the extensions. A reference to
+        /// this is passed to the constructor of each extension</param>
+        /// <param name="referencedAssemblies">List of assemblies the
+        /// extensions need references to</param>
+        /// <param name="assemblySearchPattern">Search pattern for extension
+        /// dlls, for example MyApp.Extension.*.dll</param>
+        /// <param name="sourceSearchPattern">Search pattern for extension
+        /// source code files, for example MyApp.Extension.*.cs</param>
+        /// <param name="assignablesParent">The object containing the 
+        /// assignable interfaces</param>
+        /// <param name="assignableInterfaces">A list of interface types and
+        /// interface references to assign extensions to</param>
+        public static void LoadAllExtensions(Assembly assembly, string path, TOwner owner,
+            List<string> referencedAssemblies, string assemblySearchPattern, string sourceSearchPattern,
+            object assignablesParent, Dictionary<Type, FieldInfo> assignableInterfaces)
+        {
+            // Add referenced assemblies to the C# compiler
+            CSCompilerParams.ReferencedAssemblies.Clear();
+            if (referencedAssemblies != null)
+            {
+                for (int i = 0; i < referencedAssemblies.Count; i++)
+                    CSCompilerParams.ReferencedAssemblies.Add(referencedAssemblies[i]);
+            }
+
+            // Load internal extensions
+            LoadAssemblyExtensions(assembly, owner);
+
+            // Load extensions from external assemblies
+            List<string> extensionNames = ListExtensionAssemblies(path, assemblySearchPattern);
+            foreach (string name in extensionNames)
+                LoadAssemblyExtensions(Assembly.LoadFile(name), owner);
+
+            // Load extensions from external code files
+            extensionNames = ListExtensionSourceFiles(path, sourceSearchPattern);
+            foreach (string name in extensionNames)
+            {
+                CompilerResults results = CSCompiler.CompileAssemblyFromFile(CSCompilerParams, name);
+                if (results.Errors.Count == 0)
+                    LoadAssemblyExtensions(results.CompiledAssembly, owner);
+                else
+                    throw new ExtensionException("Error(s) compiling " + name);
+            }
+
+            if (assignableInterfaces != null)
+            {
+                // Assign extensions to interfaces
+                foreach (KeyValuePair<Type, FieldInfo> kvp in assignableInterfaces)
+                {
+                    Type type = kvp.Key;
+                    FieldInfo assignable = kvp.Value;
+
+                    for (int i = 0; i < Extensions.Count; i++)
+                    {
+                        IExtension extension = Extensions[i];
+
+                        if (extension.GetType().GetInterface(type.Name) != null)
+                            assignable.SetValue(assignablesParent, extension);
+                    }
+                }
+
+                // Check for unassigned interfaces
+                foreach (KeyValuePair<Type, FieldInfo> kvp in assignableInterfaces)
+                {
+                    if (kvp.Value == null)
+                        throw new ExtensionException("Unassigned interface " + kvp.Key.Name);
+                }
+            }
+        }
+
+        public static List<string> ListExtensionAssemblies(string path, string searchPattern)
+        {
+            List<string> plugins = new List<string>();
+            string[] files = Directory.GetFiles(path, searchPattern);
+
+            foreach (string f in files)
+            {
+                try
+                {
+                    Assembly a = Assembly.LoadFrom(f);
+                    System.Type[] types = a.GetTypes();
+                    foreach (System.Type type in types)
+                    {
+                        if (type.GetInterface("IExtension") != null)
+                        {
+                            plugins.Add(f);
+                            break;
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    throw new ExtensionException("Unrecognized extension " + f, e);
+                }
+            }
+
+            return plugins;
+        }
+
+        public static List<string> ListExtensionSourceFiles(string path, string searchPattern)
+        {
+            List<string> plugins = new List<string>();
+            string[] files = Directory.GetFiles(path, searchPattern);
+
+            foreach (string f in files)
+            {
+                if (File.ReadAllText(f).Contains("IExtension"))
+                    plugins.Add(f);
+            }
+
+            return plugins;
+        }
+
+        public static void LoadAssemblyExtensions(Assembly assembly, TOwner owner)
+        {
+            Type[] constructorParams = new Type[] { typeof(TOwner) };
+
+            foreach (Type t in assembly.GetTypes())
+            {
+                try
+                {
+                    if (t.GetInterface("IExtension") != null)
+                    {
+                        ConstructorInfo info = t.GetConstructor(constructorParams);
+                        IExtension extension = (IExtension)info.Invoke(new object[] { owner });
+                        Extensions.Add(extension);
+                    }
+                }
+                catch (Exception e)
+                {
+                    throw new ExtensionException(String.Format(
+                        "Failed to load IExtension {0} from assembly {1}", t.FullName, assembly.FullName), e);
+                }
+            }
+        }
+    }
+}