Changeset 2488 for branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager

Timestamp:

11/12/09 17:45:45 (15 years ago)

Author:

gkronber

Message:

Worked on plugin infrastructure refactoring. (Fully functional revision). #799

Location:

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager

Files:

• ApplicationDescription.cs (modified) (2 diffs)
• ApplicationManager.cs (modified) (1 diff)
• HeuristicLab.PluginInfrastructure.Manager.csproj (modified) (1 diff)
• Loader.cs (modified) (12 diffs)
• PluginDescription.cs (modified) (5 diffs)
• PluginManager.cs (modified) (5 diffs)
• Runner.cs (modified) (3 diffs)

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/ApplicationDescription.cs

@@ -29 +29 @@
   /// </summary>
   [Serializable]
-  public class ApplicationDescription {
+  public class ApplicationDescription : IApplicationDescription {
     private string name;
 
@@ -67 +67 @@
     }
 
-    private string pluginAssembly;
+    private string declaringAssemblyName;
     /// <summary>
     /// Gets or sets the name of the assembly that contains the IApplication type.
     /// </summary>
-    public string PluginAssembly {
-      get { return pluginAssembly; }
-      set { pluginAssembly = value; }
+    public string DeclaringAssemblyName {
+      get { return declaringAssemblyName; }
+      set { declaringAssemblyName = value; }
     }
 
-    private string pluginType;
+    private string declaringTypeName;
     /// <summary>
     /// Gets or sets the name of the type that implements the interface IApplication.
     /// </summary>
-    public string PluginType {
-      get { return pluginType; }
-      set { pluginType = value; }
+    public string DeclaringTypeName {
+      get { return declaringTypeName; }
+      set { declaringTypeName = value; }
     }
   }

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/ApplicationManager.cs

@@ -27 +27 @@
 using System.Security.Permissions;
 using System.Security;
+using System.Linq;
 
 namespace HeuristicLab.PluginInfrastructure.Manager {
 
-  public class ApplicationManager {
+  public class ApplicationManager : MarshalByRefObject, IApplicationManager {
+    private List<IPluginDescription> plugins;
     /// <summary>
-    /// Event handler for actions in the application manager.
+    /// Gets all plugins.
     /// </summary>
-    public event PluginManagerActionEventHandler Action;
-
-    // singleton pattern
-    public ApplicationManager() {
-      applications = new List<ApplicationDescription>();
+    public IEnumerable<IPluginDescription> Plugins {
+      get { return plugins; }
     }
 
-    private ApplicationManager singleton = new ApplicationManager();
-    public ApplicationManager Manager {
-      get { return singleton; }
+    private List<IApplicationDescription> applications;
+    /// <summary>
+    /// Gets all installed applications.
+    /// </summary>
+    public IEnumerable<IApplicationDescription> Applications {
+      get { return applications; }
+    }
+
+    public ApplicationManager() : base() { }
+
+    internal void PrepareApplicationDomain(IEnumerable<IApplicationDescription> apps, IEnumerable<IPluginDescription> plugins) {
+      this.plugins = new List<IPluginDescription>(plugins);
+      this.applications = new List<IApplicationDescription>(apps);
+      PluginInfrastructure.ApplicationManager.RegisterApplicationManager(this);
+      LoadPlugins(plugins);
+    }
+
+    private void LoadPlugins(IEnumerable<IPluginDescription> plugins) {
+      // load all loadable plugins (all dependencies available) into the execution context
+      foreach (var desc in PluginDescriptionIterator.IterateInDependencyOrder(plugins.Where(x => x.PluginState != PluginState.Disabled))) {
+        foreach (var plugin in GetInstances<IPlugin>(desc)) {
+          plugin.OnLoad();
+        }
+        desc.Load();
+      }
+    }
+
+    internal void Run(IApplicationDescription appInfo) {
+      IApplication runnablePlugin = (IApplication)Activator.CreateInstance(appInfo.DeclaringAssemblyName, appInfo.DeclaringTypeName).Unwrap();
+      try {
+        runnablePlugin.Run();
+      }
+      catch (Exception e) {
+        throw new Exception(String.Format(
+          "Unexpected exception caught: \"{0}\"\r\n" +
+          "Type: {1}\r\n" +
+          "Plugin {2}:\r\n{3}",
+          e.Message,
+          e.GetType().FullName,
+          appInfo.Name,
+          e.ToString()));
+      }
+    }
+
+    /// <summary>
+    /// Creates an instance of all types that are subtypes or the same type of the specified type and declared in <paramref name="plugin"/>
+    /// </summary>
+    /// <typeparam name="T">Most general type.</typeparam>
+    /// <returns>Enumerable of the created instances.</returns>
+    public IEnumerable<T> GetInstances<T>(IPluginDescription plugin) where T : class {
+      return from t in GetTypes(typeof(T), plugin)
+             where !t.IsAbstract && !t.IsInterface && !t.HasElementType
+             select (T)Activator.CreateInstance(t);
+    }
+    /// <summary>
+    /// Creates an instance of all types that are subtypes or the same type of the specified type
+    /// </summary>
+    /// <typeparam name="T">Most general type.</typeparam>
+    /// <returns>Enumerable of the created instances.</returns>
+    public IEnumerable<T> GetInstances<T>() where T : class {
+      return from i in GetInstances(typeof(T))
+             select (T)i;
+    }
+
+    /// <summary>
+    /// Creates an instance of all types that are subtypes or the same type of the specified type
+    /// </summary>
+    /// <typeparam name="type">Most general type.</typeparam>
+    /// <returns>Enumerable of the created instances.</returns>
+    public IEnumerable<object> GetInstances(Type type) {
+      return from t in GetTypes(type)
+             where !t.IsAbstract && !t.IsInterface && !t.HasElementType
+             select Activator.CreateInstance(t);
+    }
+
+    /// <summary>
+    /// Finds all types that are subtypes or equal to the specified type.
+    /// </summary>
+    /// <param name="type">Most general type for which to find matching types.</param>
+    /// <returns>Enumerable of the discovered types.</returns>
+    public IEnumerable<Type> GetTypes(Type type) {
+      return from asm in AppDomain.CurrentDomain.GetAssemblies()
+             from t in GetTypes(type, asm)
+             select t;
+    }
+
+    /// <summary>
+    /// Finds all types that are subtypes or equal to the specified type if they are part of the given
+    /// <paramref name="plugin"/>.
+    /// </summary>
+    /// <param name="type">Most general type for which to find matching types.</param>
+    /// <param name="plugin">The plugin the subtypes must be part of.</param>
+    /// <returns>Enumerable of the discovered types.</returns>
+    public IEnumerable<Type> GetTypes(Type type, IPluginDescription pluginDescription) {
+      return from asm in AppDomain.CurrentDomain.GetAssemblies()
+             where pluginDescription.Assemblies.Contains(asm.Location)
+             from t in GetTypes(type, asm)
+             select t;
+    }
+
+    /// <summary>
+    /// Gets types that are assignable (same of subtype) to the specified type only from the given assembly.
+    /// </summary>
+    /// <param name="type">Most general type we want to find.</param>
+    /// <param name="assembly">Assembly that should be searched for types.</param>
+    /// <returns>Enumerable of the discovered types.</returns>
+    private IEnumerable<Type> GetTypes(Type type, Assembly assembly) {
+      return from t in assembly.GetTypes()
+             where type.IsAssignableFrom(t)
+             select t;
     }
 
 
-    private void NotifyListeners(string action, string text) {
-      if (Action != null) {
-        Action(this, new PluginManagerActionEventArgs(text, action));
-      }
+    // infinite lease time
+    /// <summary>
+    /// Initializes the life time service with infinite lease time.
+    /// </summary>
+    /// <returns><c>null</c>.</returns>
+    public override object InitializeLifetimeService() {
+      return null;
     }
   }
 }
+

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/HeuristicLab.PluginInfrastructure.Manager.csproj

@@ -49 +49 @@
   <ItemGroup>
     <Compile Include="ApplicationDescription.cs" />
-    <Compile Include="PluginDescriptionIterator.cs" />
+    <Compile Include="ApplicationManager.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Loader.cs" />
-    <Compile Include="PluginState.cs" />
     <Compile Include="PluginDescription.cs" />
     <Compile Include="PluginManager.cs" />
     <Compile Include="PluginManagerActionEventArgs.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Runner.cs" />
   </ItemGroup>
   <ItemGroup>

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/Loader.cs

@@ -55 +55 @@
       this.plugins = new List<PluginDescription>();
       this.pluginDependencies = new Dictionary<PluginDescription, List<string>>();
+
+      AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += ReflectionOnlyAssemblyResolveEventHandler;
+    }
+
+    private Assembly ReflectionOnlyAssemblyResolveEventHandler(object sender, ResolveEventArgs args) {
+      //try {
+      return Assembly.ReflectionOnlyLoad(args.Name);
+      //}
+      //catch (FileLoadException ex) {
+      //  return null;
+      //}
     }
 
@@ -70 +81 @@
     /// </summary>
     internal void Init() {
-      //AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += delegate(object sender, ResolveEventArgs args) {
-      //  try {
-      //    return Assembly.ReflectionOnlyLoad(args.Name);
-      //  }
-      //  catch (FileLoadException ex) {
-      //    return null;
-      //  }
-      //};
       pluginDependencies.Clear();
 
@@ -91 +94 @@
       CheckPluginDependencies(pluginDescriptions);
 
+      // mark all plugins as enabled that were not disabled in CheckPluginFiles or CheckPluginDependencies
+      foreach (var desc in pluginDescriptions)
+        if (desc.PluginState != PluginState.Disabled)
+          desc.Enable();
+
       // test full loading (in contrast to reflection only loading) of plugins
       // disables plugins that are not loaded correctly
@@ -100 +108 @@
 
     private void DiscoverApplications() {
-      DiscoveryService service = new DiscoveryService();
-      IApplication[] apps = service.GetInstances<IApplication>();
       applications = new List<ApplicationDescription>();
 
-      foreach (IApplication application in apps) {
+      foreach (IApplication application in GetApplications()) {
         ApplicationDescription info = new ApplicationDescription();
         info.Name = application.Name;
@@ -110 +116 @@
         info.Description = application.Description;
         info.AutoRestart = application.RestartOnErrors;
-        info.PluginAssembly = application.GetType().Assembly.GetName().Name;
-        info.PluginType = application.GetType().Namespace + "." + application.GetType().Name;
+        info.DeclaringAssemblyName = application.GetType().Assembly.GetName().Name;
+        info.DeclaringTypeName = application.GetType().Namespace + "." + application.GetType().Name;
 
         applications.Add(info);
       }
+    }
+
+    private IEnumerable<IApplication> GetApplications() {
+      return from asm in AppDomain.CurrentDomain.GetAssemblies()
+             from t in asm.GetTypes()
+             where typeof(IApplication).IsAssignableFrom(t) &&
+               !t.IsAbstract && !t.IsInterface && !t.HasElementType
+             select (IApplication)Activator.CreateInstance(t);
     }
 
@@ -198 +212 @@
       // iterate through all custom attributes and search for attributed that we are interested in 
       foreach (CustomAttributeData attributeData in attributes) {
-        if (IsAttributeDataForType(attributeData, typeof(PluginDescriptionAttribute))) {
+        if (IsAttributeDataForType(attributeData, typeof(PluginAttribute))) {
           pluginName = (string)attributeData.ConstructorArguments[0].Value;
         } else if (IsAttributeDataForType(attributeData, typeof(PluginDependencyAttribute))) {
@@ -222 +236 @@
         info.AddAssemblies(pluginAssemblies);
         info.AddFiles(pluginFiles);
-        info.PluginState = PluginState.Undefined;
 
         this.pluginDependencies[info] = pluginDependencies;
@@ -246 +259 @@
           } else {
             // no plugin description that matches the dependency name is available => plugin is disabled
-            desc.PluginState = PluginState.Disabled;
+            desc.Disable();
             break; // stop processing more dependencies
           }
@@ -257 +270 @@
         if (IsAnyDependencyDisabled(pluginDescription)) {
           // PluginDescription.Message = "Disabled: missing plugin dependency.";
-          pluginDescription.PluginState = PluginState.Disabled;
+          pluginDescription.Disable();
         }
       }
@@ -273 +286 @@
     private void LoadPlugins(IEnumerable<PluginDescription> pluginDescriptions) {
       // load all loadable plugins (all dependencies available) into the execution context
-      foreach (PluginDescription desc in PluginDescriptionIterator.IterateInDependencyOrder(pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled))) {
+      foreach (var desc in PluginDescriptionIterator.IterateInDependencyOrder(pluginDescriptions
+                                                                                .Cast<IPluginDescription>()
+                                                                                .Where(x => x.PluginState != PluginState.Disabled))) {
         List<Type> types = new List<Type>();
         foreach (string assembly in desc.Assemblies) {
@@ -288 +303 @@
             IPlugin plugin = (IPlugin)Activator.CreateInstance(pluginType);
             plugin.OnLoad();
+            desc.Load();
             PluginAction(this, new PluginManagerActionEventArgs(plugin.Name, PluginManagerAction.PluginLoaded));
           }
@@ -335 +351 @@
         if (!CheckPluginFiles(desc)) {
           //plugin.Message = "Disabled: missing plugin file.";
-          desc.PluginState = PluginState.Disabled;
+          desc.Disable();
         }
       }

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/PluginDescription.cs

@@ -30 +30 @@
   /// </summary>
   [Serializable]
-  public class PluginDescription {
+  public class PluginDescription : IPluginDescription {
     private string name;
     /// <summary>
@@ -62 +62 @@
     public PluginState PluginState {
       get { return pluginState; }
-      set { pluginState = value; }
+    }
+
+    private int nTimesLoaded;
+    public void Disable() {
+      if (pluginState != PluginState.Undefined)
+        throw new InvalidOperationException("Can't disabled a plugin in state " + pluginState);
+      pluginState = PluginState.Disabled;
+    }
+
+    public void Enable() {
+      if (pluginState != PluginState.Undefined)
+        throw new InvalidOperationException("Can't enabled a plugin in state " + pluginState);
+      pluginState = PluginState.Enabled;
+    }
+
+    public void Load() {
+      if (!(pluginState == PluginState.Enabled || pluginState == PluginState.Loaded))
+        throw new InvalidOperationException("Can't loaded a plugin in state " + pluginState);
+      pluginState = PluginState.Loaded;
+      nTimesLoaded++;
+    }
+
+    public void Unload() {
+      if (pluginState != PluginState.Loaded)
+        throw new InvalidOperationException("Can't unload a plugin in state " + pluginState);
+      nTimesLoaded--;
+      if (nTimesLoaded == 0) pluginState = PluginState.Enabled;
     }
 
@@ -78 +104 @@
     }
 
-    private List<PluginDescription> dependencies = new List<PluginDescription>();
+    private List<IPluginDescription> dependencies = new List<IPluginDescription>();
     /// <summary>
     /// Gets all dependencies of the plugin.
     /// </summary>
-    public IEnumerable<PluginDescription> Dependencies {
+    public IEnumerable<IPluginDescription> Dependencies {
       get { return dependencies; }
     }
@@ -104 +130 @@
     }
 
+    public PluginDescription() {
+      nTimesLoaded = 0;
+      pluginState = PluginState.Undefined;
+    }
+
+
     //private string message;
     ///// <summary>
@@ -121 +153 @@
     }
 
-    // equals and hashcode have to be implemented because we want to compare PluginDescriptions from 
-    // different AppDomains and serialization destroys reference equality
-    /// <summary>
-    /// Checks whether the given object is equal to the current plugin.
-    /// </summary>
-    /// <param name="obj">The object to compare.</param>
-    /// <returns><c>true</c> if it is equal, <c>false</c> otherwise.</returns>
-    public override bool Equals(object obj) {
-      if (!(obj is PluginDescription))
-        return false;
-      PluginDescription other = (PluginDescription)obj;
+    //// equals and hashcode have to be implemented because we want to compare PluginDescriptions from 
+    //// different AppDomains and serialization destroys reference equality
+    ///// <summary>
+    ///// Checks whether the given object is equal to the current plugin.
+    ///// </summary>
+    ///// <param name="obj">The object to compare.</param>
+    ///// <returns><c>true</c> if it is equal, <c>false</c> otherwise.</returns>
+    //public override bool Equals(object obj) {
+    //  if (!(obj is PluginDescription))
+    //    return false;
+    //  PluginDescription other = (PluginDescription)obj;
 
-      return other.Name == this.Name && other.Version == this.Version;
-    }
-    /// <summary>
-    /// Gets the hash code of the current plugin.
-    /// </summary>
-    /// <returns>The hash code of the plugin.</returns>
-    public override int GetHashCode() {
-      if (version != null) {
-        return name.GetHashCode() + version.GetHashCode();
-      } else return name.GetHashCode();
-    }
+    //  return other.Name == this.Name && other.Version == this.Version;
+    //}
+    ///// <summary>
+    ///// Gets the hash code of the current plugin.
+    ///// </summary>
+    ///// <returns>The hash code of the plugin.</returns>
+    //public override int GetHashCode() {
+    //  if (version != null) {
+    //    return name.GetHashCode() + version.GetHashCode();
+    //  } else return name.GetHashCode();
+    //}
   }
 }

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/PluginManager.cs

@@ -27 +27 @@
 using System.Security.Permissions;
 using System.Security;
+using System.Linq;
 
 namespace HeuristicLab.PluginInfrastructure.Manager {
@@ -81 +82 @@
 
     private List<PluginDescription> plugins;
-    public IEnumerable<PluginDescription> Plugins {
-      get { return plugins; }
-    }
+    //public IEnumerable<PluginDescription> Plugins {
+    //  get { return plugins; }
+    //}
 
     private List<ApplicationDescription> applications;
@@ -109 +110 @@
       plugins = new List<PluginDescription>(remoteLoader.Plugins);
       applications = new List<ApplicationDescription>(remoteLoader.Applications);
-      throw new NotImplementedException();
+
+      // discard the AppDomain that was used for plugin discovery
+      UnloadAppDomain(pluginDomain);
+    }
+
+    private void UnloadAppDomain(AppDomain appDomain) {
+      AppDomain.Unload(appDomain);
+
+      // set all loaded plugins back to enabled
+      foreach (var pluginDescription in plugins)
+        pluginDescription.Unload();
     }
 
@@ -130 +141 @@
     public void Run(ApplicationDescription appInfo) {
       // create a separate AppDomain for the application
-      // activate a PluginRunner instance in the application
+      // initialize the static ApplicationManager in the AppDomain
       // and remotely tell it to start the application
 
@@ -139 +150 @@
         setup.PrivateBinPath = pluginDir;
         applicationDomain = AppDomain.CreateDomain(appInfo.Name, null, setup);
-        Runner remoteRunner = (Runner)applicationDomain.CreateInstanceAndUnwrap(typeof(Runner).Assembly.GetName().Name, typeof(Runner).FullName);
-        remoteRunner.PluginAction += delegate(object sender, PluginManagerActionEventArgs args) { if (Action != null) Action(this, args); };
-        remoteRunner.LoadPlugins(Plugins);
+        ApplicationManager applicationManager =
+          (ApplicationManager)applicationDomain.CreateInstanceAndUnwrap("HeuristicLab.PluginInfraStructure.Manager", "HeuristicLab.PluginInfrastructure.Manager.ApplicationManager");
+        //applicationManager.PluginAction += delegate(object sender, PluginManagerActionEventArgs args) { if (Action != null) Action(this, args); };
+        applicationManager.PrepareApplicationDomain(
+          new List<IApplicationDescription>(applications.Cast<IApplicationDescription>()),
+          new List<IPluginDescription>(plugins.Cast<IPluginDescription>()));
         NotifyListeners(PluginManagerAction.Initialized, "All plugins");
-        remoteRunner.Run(appInfo);
+        applicationManager.Run(appInfo);
       }
       finally {

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/Runner.cs

@@ -44 +44 @@
     }
 
-    public void LoadPlugins(IEnumerable<PluginDescription> pluginDescriptions) {
+    public void LoadPlugins(IEnumerable<IPluginDescription> pluginDescriptions) {
       //FileIOPermission fileperm = new FileIOPermission(FileIOPermissionAccess.AllAccess, @"C:\Program Files\HeuristicLab 3.0\plugins\");
       //fileperm.Assert();
 
       // load all loadable plugins (all dependencies available) into the execution context
-      foreach (PluginDescription desc in PluginDescriptionIterator.IterateInDependencyOrder(pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled))) {
+      foreach (var desc in PluginDescriptionIterator.IterateInDependencyOrder(pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled))) {
         List<Type> types = new List<Type>();
         foreach (string assembly in desc.Assemblies) {
@@ -64 +64 @@
             IPlugin plugin = (IPlugin)Activator.CreateInstance(pluginType);
             plugin.OnLoad();
+            desc.Load();
             PluginAction(this, new PluginManagerActionEventArgs(plugin.Name, PluginManagerAction.PluginLoaded));
           }
@@ -88 +89 @@
 
     public void Run(ApplicationDescription appInfo) {
-      IApplication runnablePlugin = (IApplication)Activator.CreateInstance(appInfo.PluginAssembly, appInfo.PluginType).Unwrap();
+      IApplication runnablePlugin = (IApplication)Activator.CreateInstance(appInfo.DeclaringAssemblyName, appInfo.DeclaringTypeName).Unwrap();
       try {
         runnablePlugin.Run();