Changeset 2750 for trunk/sources/HeuristicLab.PluginInfrastructure

Timestamp:

02/04/10 12:20:43 (15 years ago)

Author:

gkronber

Message:

Prepared plugin infrastructure to work with versioned plugins and dependencies and added versioning to part of HL.GP plugins. #864 (Plugins should have an a version)

Location:

trunk/sources/HeuristicLab.PluginInfrastructure

Files:

• Attributes/AssemblyBuildDateAttribute.cs (modified) (1 diff)
• Attributes/PluginAttribute.cs (modified) (1 diff)
• Attributes/PluginDependencyAttribute.cs (modified) (1 diff)
• InvalidPluginException.cs (modified) (1 diff)
• Manager/PluginValidator.cs (modified) (6 diffs)

trunk/sources/HeuristicLab.PluginInfrastructure/Attributes/AssemblyBuildDateAttribute.cs

@@ -45 +45 @@
     /// <exception cref="FormatException">Thrown when the time stamp could not be parsed as build date.</exception>
     /// <param name="buildDate">The build date of the assembly.</param>
+    [Obsolete]
     public AssemblyBuildDateAttribute(string buildDate)
       : base() {

trunk/sources/HeuristicLab.PluginInfrastructure/Attributes/PluginAttribute.cs

@@ -47 +47 @@
     }
 
+    private Version version;
+    /// <summary>
+    /// Gets the version of the plugin.
+    /// </summary>
+    public Version Version {
+      get { return version; }
+    }
+
+    [Obsolete]
+    public PluginAttribute(string name) : this(name, "0.0.0.0") { }
+
     /// <summary>
     /// Initializes a new instance of <see cref="PluginAttribute"/>.
     /// <param name="name">Name of the plugin</param>
+    /// <param name="version">Version of the plugin</param>
     /// </summary>
-    public PluginAttribute(string name)
-      : this(name, string.Empty) {
+    public PluginAttribute(string name, string version)
+      : this(name, string.Empty, version) {
     }
 
     /// <summary>
     /// Initializes a new instance of <see cref="PluginAttribute"/>.
+    /// </summary>
     /// <param name="name">Name of the plugin</param>
     /// <param name="description">Description of the plugin</param>
-    /// </summary>
-    public PluginAttribute(string name, string description) {
+    /// <param name="version">Version of the plugin</param>
+    public PluginAttribute(string name, string description, string version) {
       if (string.IsNullOrEmpty(name)) throw new ArgumentException("Plugin name is null or empty.");
       if (description == null) throw new ArgumentNullException("description");
+      if (string.IsNullOrEmpty(version)) new ArgumentException("Version string is null or empty.");
       this.name = name;
       this.description = description;
+      this.version = new Version(version); // throws format exception if the version string can't be parsed
     }
   }

trunk/sources/HeuristicLab.PluginInfrastructure/Attributes/PluginDependencyAttribute.cs

@@ -39 +39 @@
     }
 
+    private Version version;
+    /// <summary>
+    /// Gets the version of the plugin dependency.
+    /// </summary>
+    public Version Version {
+      get { return version; }
+    }
+
     /// <summary>
     /// Initializes a new instance of <see cref="PluginDependencyAttribute"/>.
     /// <param name="dependency">The name of the plugin that is needed to load a plugin.</param>
     /// </summary>
-    public PluginDependencyAttribute(string dependency) {
-      if (string.IsNullOrEmpty(dependency)) throw new ArgumentException("Dependency is null or empty.", "dependency");
+    [Obsolete]
+    public PluginDependencyAttribute(string dependency)
+      : this(dependency, "0.0.0.0") {
+    }
+
+    public PluginDependencyAttribute(string dependency, string version) {
+      if (string.IsNullOrEmpty(dependency)) throw new ArgumentException("Dependency name is null or empty.", "dependency");
+      if (string.IsNullOrEmpty(version)) throw new ArgumentException("Dependency version is null or empty.", "version");
       this.dependency = dependency;
+      this.version = new Version(version); // throws format exception if the version string can't be parsed
     }
   }

trunk/sources/HeuristicLab.PluginInfrastructure/InvalidPluginException.cs

@@ -31 +31 @@
   [Serializable]
   public sealed class InvalidPluginException : Exception {
+    /// <summary>
+    /// Initializes a new InvalidPluginException
+    /// </summary>
     public InvalidPluginException() : base() { }
+    /// <summary>
+    /// Initializes a new InvalidPluginException with an error message.
+    /// </summary>
+    /// <param name="message">The exception message</param>
     public InvalidPluginException(string message) : base(message) { }
-    public InvalidPluginException(string message, Exception exception) : base(message, exception) { }
+    /// <summary>
+    /// Initializes a new InvalidPluginException with an error message and an inner exception.
+    /// </summary>
+    /// <param name="message">The exception message.</param>
+    /// <param name="innerException">The original exception.</param>
+    public InvalidPluginException(string message, Exception innerException) : base(message, innerException) { }
+    /// <summary>
+    /// Constructor for serialization.
+    /// </summary>
+    /// <param name="info">The serialization info.</param>
+    /// <param name="contex">The serialization context.</param>
     private InvalidPluginException(SerializationInfo info, StreamingContext contex) : base(info, contex) { }
   }

trunk/sources/HeuristicLab.PluginInfrastructure/Manager/PluginValidator.cs

@@ -36 +36 @@
   /// </summary>
   internal sealed class PluginValidator : MarshalByRefObject {
+    // private class to store plugin dependency declarations while reflecting over plugins
+    private class PluginDependency {
+      public string Name { get; private set; }
+      public Version Version { get; private set; }
+
+      public PluginDependency(string name, Version version) {
+        this.Name = name;
+        this.Version = version;
+      }
+    }
+
+
     internal event EventHandler<PluginInfrastructureEventArgs> PluginLoaded;
 
-    private Dictionary<PluginDescription, List<string>> pluginDependencies;
+    private Dictionary<PluginDescription, IEnumerable<PluginDependency>> pluginDependencies;
 
     private List<ApplicationDescription> applications;
@@ -61 +73 @@
 
     internal PluginValidator() {
-      this.pluginDependencies = new Dictionary<PluginDescription, List<string>>();
+      this.pluginDependencies = new Dictionary<PluginDescription, IEnumerable<PluginDependency>>();
 
       // ReflectionOnlyAssemblyResolveEvent must be handled because we load assemblies from the plugin path 
@@ -250 +262 @@
       // get all attributes of that type
       IList<CustomAttributeData> attributes = CustomAttributeData.GetCustomAttributes(pluginType);
-      List<string> pluginDependencies = new List<string>();
+      List<PluginDependency> pluginDependencies = new List<PluginDependency>();
       List<PluginFile> pluginFiles = new List<PluginFile>();
       string pluginName = null;
       string pluginDescription = null;
+      string pluginVersion = "0.0.0.0";
       // iterate through all custom attributes and search for attributed that we are interested in 
       foreach (CustomAttributeData attributeData in attributes) {
         if (IsAttributeDataForType(attributeData, typeof(PluginAttribute))) {
           pluginName = (string)attributeData.ConstructorArguments[0].Value;
-          if (attributeData.ConstructorArguments.Count() == 2) {
-            pluginDescription = (string)attributeData.ConstructorArguments[1].Value;
-          } else pluginDescription = pluginName;
+          if (attributeData.ConstructorArguments.Count() > 1) {
+            pluginVersion = (string)attributeData.ConstructorArguments[1].Value;
+          }
+          if (attributeData.ConstructorArguments.Count() > 2) {
+            pluginDescription = (string)attributeData.ConstructorArguments[2].Value;
+          } else {
+            // no description given => use name as description
+            pluginDescription = pluginName;
+          }
         } else if (IsAttributeDataForType(attributeData, typeof(PluginDependencyAttribute))) {
-          pluginDependencies.Add((string)attributeData.ConstructorArguments[0].Value);
+          string name = (string)attributeData.ConstructorArguments[0].Value;
+          Version version = new Version();
+          // check if version is given for now
+          // later when the constructore of PluginDependencyAttribute with only one argument has been removed
+          // this conditional can be removed as well
+          if (attributeData.ConstructorArguments.Count > 1) {
+            try {
+              version = new Version((string)attributeData.ConstructorArguments[1].Value); // throws FormatException
+            }
+            catch (FormatException ex) {
+              throw new InvalidPluginException("Invalid version format of dependency " + name + " in plugin " + pluginType.ToString(), ex);
+            }
+          }
+          pluginDependencies.Add(new PluginDependency(name, version));
         } else if (IsAttributeDataForType(attributeData, typeof(PluginFileAttribute))) {
           string pluginFileName = (string)attributeData.ConstructorArguments[0].Value;
@@ -270 +302 @@
       }
 
-      var buildDates = from attr in CustomAttributeData.GetCustomAttributes(pluginType.Assembly)
-                       where IsAttributeDataForType(attr, typeof(AssemblyBuildDateAttribute))
-                       select (string)attr.ConstructorArguments[0].Value;
-
       // minimal sanity check of the attribute values
       if (!string.IsNullOrEmpty(pluginName) &&
           pluginFiles.Count > 0 &&                                   // at least on file
-          pluginFiles.Any(f => f.Type == PluginFileType.Assembly) && // at least on assembly
-          buildDates.Count() == 1) {                                 // build date must be declared
+          pluginFiles.Any(f => f.Type == PluginFileType.Assembly)) { // at least on assembly
         // create a temporary PluginDescription that contains the attribute values
         PluginDescription info = new PluginDescription();
         info.Name = pluginName;
         info.Description = pluginDescription;
-        info.Version = pluginType.Assembly.GetName().Version;
-        info.BuildDate = DateTime.Parse(buildDates.Single(), System.Globalization.CultureInfo.InvariantCulture);
+        info.Version = new Version(pluginVersion);
         info.AddFiles(pluginFiles);
 
@@ -303 +329 @@
     private void BuildDependencyTree(IEnumerable<PluginDescription> pluginDescriptions) {
       foreach (var desc in pluginDescriptions) {
-        foreach (string pluginName in pluginDependencies[desc]) {
-          var matchingDescriptions = pluginDescriptions.Where(x => x.Name == pluginName);
+        foreach (var dependency in pluginDependencies[desc]) {
+          var matchingDescriptions = from availablePlugin in pluginDescriptions
+                                     where availablePlugin.Name == dependency.Name
+                                     where IsCompatiblePluginVersion(availablePlugin.Version, dependency.Version)
+                                     select availablePlugin;
           if (matchingDescriptions.Count() > 0) {
             desc.AddDependency(matchingDescriptions.Single());
@@ -313 +342 @@
         }
       }
+    }
+
+    /// <summary>
+    /// Checks if version <paramref name="available"/> is compatible to version <paramref name="requested"/>.
+    /// Note: the compatibility relation is not bijective.
+    /// Compatibility rules:
+    ///  * major and minor number must be the same
+    ///  * build and revision number of <paramref name="available"/> must be larger or equal to <paramref name="requested"/>.
+    /// </summary>
+    /// <param name="available">The available version which should be compared to <paramref name="requested"/>.</param>
+    /// <param name="requested">The requested version that must be matched.</param>
+    /// <returns></returns>
+    private bool IsCompatiblePluginVersion(Version available, Version requested) {
+      // this condition must be removed after all plugins have been updated to declare plugin and dependency versions
+      if (
+        (requested.Major == 0 && requested.Minor == 0) ||
+        (available.Major == 0 && available.Minor == 0)) return true;
+      return
+        available.Major == requested.Major &&
+        available.Minor == requested.Minor &&
+        available.Build >= requested.Build &&
+        available.Revision >= requested.Revision;
     }