View Javadoc

1   package com.atlassian.plugin;
2   
3   import com.atlassian.plugin.loaders.SinglePluginLoader;
4   import com.atlassian.plugin.util.ClassLoaderUtils;
5   import org.apache.commons.logging.Log;
6   import org.apache.commons.logging.LogFactory;
7   
8   import java.util.*;
9   
10  public class DefaultModuleDescriptorFactory implements ModuleDescriptorFactory
11  {
12      private static Log log = LogFactory.getLog(DefaultModuleDescriptorFactory.class);
13  
14      private Map<String,Class<? extends ModuleDescriptor>> moduleDescriptorClasses;
15      private List<String> permittedModuleKeys = Collections.emptyList();
16  
17      public DefaultModuleDescriptorFactory()
18      {
19          this.moduleDescriptorClasses = new HashMap<String, Class<? extends ModuleDescriptor>>();
20      }
21  
22      public Class<? extends ModuleDescriptor> getModuleDescriptorClass(String type)
23      {
24          return moduleDescriptorClasses.get(type);
25      }
26  
27      public ModuleDescriptor getModuleDescriptor(String type) throws PluginParseException, IllegalAccessException, InstantiationException, ClassNotFoundException
28      {
29          if (shouldSkipModuleOfType(type))
30              return null;
31  
32          Class moduleDescriptorClazz = getModuleDescriptorClass(type);
33  
34          if (moduleDescriptorClazz == null)
35              throw new PluginParseException("Cannot find ModuleDescriptor class for plugin of type '" + type + "'.");
36  
37          return (ModuleDescriptor) moduleDescriptorClazz.newInstance();
38      }
39  
40      protected boolean shouldSkipModuleOfType(String type)
41      {
42          return permittedModuleKeys != null && !permittedModuleKeys.isEmpty() && !permittedModuleKeys.contains(type);
43      }
44  
45      public void setModuleDescriptors(Map<String, String> moduleDescriptorClassNames)
46      {
47          for (Iterator<Map.Entry<String,String>> it = moduleDescriptorClassNames.entrySet().iterator(); it.hasNext();)
48          {
49              Map.Entry<String,String> entry = it.next();
50              Class<? extends ModuleDescriptor> descriptorClass = getClassFromEntry(entry);
51              if (descriptorClass != null)
52                  addModuleDescriptor(entry.getKey(), descriptorClass);
53          }
54      }
55  
56      private Class<? extends ModuleDescriptor> getClassFromEntry(Map.Entry<String,String> entry)
57      {
58          if (shouldSkipModuleOfType(entry.getKey()))
59              return null;
60  
61          Class<? extends ModuleDescriptor> descriptorClass = null;
62          try
63          {
64              descriptorClass = (Class<? extends ModuleDescriptor>) ClassLoaderUtils.loadClass(entry.getValue(), getClass());
65  
66              if (!ModuleDescriptor.class.isAssignableFrom(descriptorClass))
67              {
68                  log.error("Configured plugin module descriptor class " + entry.getValue() + " does not inherit from ModuleDescriptor");
69                  descriptorClass = null;
70              }
71          }
72          catch (ClassNotFoundException e)
73          {
74              log.error("Unable to add configured plugin module descriptor " + entry.getKey() + ". Class not found: " + entry.getValue());
75          }
76  
77          return descriptorClass;
78      }
79  
80      public boolean hasModuleDescriptor(String type)
81      {
82          return moduleDescriptorClasses.containsKey(type);
83      }
84  
85      public void addModuleDescriptor(String type, Class<? extends ModuleDescriptor> moduleDescriptorClass)
86      {
87          moduleDescriptorClasses.put(type, moduleDescriptorClass);
88      }
89  
90      public void removeModuleDescriptorForType(String type)
91      {
92          moduleDescriptorClasses.remove(type);
93      }
94  
95      protected Map<String, Class<? extends ModuleDescriptor>> getDescriptorClassesMap()
96      {
97          return moduleDescriptorClasses;
98      }
99  
100     /**
101      * Sets the list of module keys that will be loaded. If this list is empty, then the factory will
102      * permit all recognised module types to load. This allows you to run the plugin system in a 'restricted mode'
103      *
104      * @param permittedModuleKeys List of (String) keys
105      */
106     public void setPermittedModuleKeys(List<String> permittedModuleKeys)
107     {
108         if (permittedModuleKeys == null)
109             permittedModuleKeys = Collections.emptyList();
110 
111         this.permittedModuleKeys = permittedModuleKeys;
112     }
113 }