package edu.umd.cs.findbugs;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLConnection;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;
import java.util.jar.Attributes;
import java.util.jar.JarInputStream;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
import javax.annotation.WillClose;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import edu.umd.cs.findbugs.ba.AnalysisContext;
import edu.umd.cs.findbugs.charsets.UTF8;
import edu.umd.cs.findbugs.classfile.IAnalysisEngineRegistrar;
import edu.umd.cs.findbugs.cloud.Cloud;
import edu.umd.cs.findbugs.cloud.CloudFactory;
import edu.umd.cs.findbugs.cloud.CloudPlugin;
import edu.umd.cs.findbugs.cloud.CloudPluginBuilder;
import edu.umd.cs.findbugs.cloud.username.NameLookup;
import edu.umd.cs.findbugs.internalAnnotations.DottedClassName;
import edu.umd.cs.findbugs.io.IO;
import edu.umd.cs.findbugs.plan.ByInterfaceDetectorFactorySelector;
import edu.umd.cs.findbugs.plan.DetectorFactorySelector;
import edu.umd.cs.findbugs.plan.DetectorOrderingConstraint;
import edu.umd.cs.findbugs.plan.ReportingDetectorFactorySelector;
import edu.umd.cs.findbugs.plan.SingleDetectorFactorySelector;
import edu.umd.cs.findbugs.plugins.DuplicatePluginIdError;
import edu.umd.cs.findbugs.plugins.DuplicatePluginIdException;
import edu.umd.cs.findbugs.updates.UpdateChecker;
import edu.umd.cs.findbugs.util.ClassName;
import edu.umd.cs.findbugs.util.JavaWebStart;
import edu.umd.cs.findbugs.util.Util;
import edu.umd.cs.findbugs.xml.XMLUtil;
public class PluginLoader {
private static final String XPATH_PLUGIN_SHORT_DESCRIPTION = "/MessageCollection/Plugin/ShortDescription";
private static final String XPATH_PLUGIN_WEBSITE = "/FindbugsPlugin/@website";
private static final String XPATH_PLUGIN_PROVIDER = "/FindbugsPlugin/@provider";
private static final String XPATH_PLUGIN_PLUGINID = "/FindbugsPlugin/@pluginid";
private static final boolean DEBUG = SystemProperties.getBoolean("findbugs.debug.PluginLoader");
static boolean lazyInitialization = false;
static LinkedList<PluginLoader> partiallyInitialized = new LinkedList<PluginLoader>();
private static int nextUnknownId;
private ClassLoader classLoader;
private final ClassLoader classLoaderForResources;
private final Plugin plugin;
private final boolean corePlugin;
boolean initialPlugin;
boolean cannotDisable;
private boolean optionalPlugin;
private final URL loadedFrom;
private final String jarName;
private final URI loadedFromUri;
String parentId;
static HashSet<String> loadedPluginIds = new HashSet<String>();
static {
if (DEBUG) {
System.out.println("Debugging plugin loading. FindBugs version "
+ Version.getReleaseWithDateIfDev());
}
loadInitialPlugins();
}
@Deprecated
public PluginLoader(URL url) throws PluginException {
this(url, toUri(url), null, false, true);
}
@Deprecated
public PluginLoader(URL url, ClassLoader parent) throws PluginException {
this(url, toUri(url), parent, false, true);
}
public boolean hasParent() {
return parentId != null && parentId.length() > 0;
}
private PluginLoader(@Nonnull URL url, URI uri, ClassLoader parent, boolean isInitial, boolean optional) throws PluginException {
URL[] loaderURLs = createClassloaderUrls(url);
classLoaderForResources = new URLClassLoader(loaderURLs);
loadedFrom = url;
loadedFromUri = uri;
jarName = getJarName(url);
corePlugin = false;
initialPlugin = isInitial;
optionalPlugin = optional;
plugin = init();
if (!hasParent()) {
classLoader = new URLClassLoader(loaderURLs, parent);
} else {
if (parent != PluginLoader.class.getClassLoader()) {
throw new IllegalArgumentException("Can't specify parentid " + parentId + " and provide a seperate class loader");
}
Plugin parentPlugin = Plugin.getByPluginId(parentId);
if (parentPlugin != null) {
parent = parentPlugin.getClassLoader();
classLoader = new URLClassLoader(loaderURLs, parent);
}
}
if (classLoader == null) {
if (!lazyInitialization) {
throw new IllegalStateException("Can't find parent plugin " + parentId);
}
partiallyInitialized.add(this);
} else {
loadPluginComponents();
Plugin.putPlugin(loadedFromUri, plugin);
}
}
private static void finishLazyInitialization() {
if (!lazyInitialization) {
throw new IllegalStateException("Not in lazy initialization mode");
}
while (!partiallyInitialized.isEmpty()) {
boolean changed = false;
LinkedList<String> unresolved = new LinkedList<String>();
Set<String> needed = new TreeSet<String>();
for (Iterator<PluginLoader> i = partiallyInitialized.iterator(); i.hasNext();) {
PluginLoader pluginLoader = i.next();
String pluginId = pluginLoader.getPlugin().getPluginId();
assert pluginLoader.hasParent();
String parentid = pluginLoader.parentId;
Plugin parent = Plugin.getByPluginId(parentid);
if (parent != null) {
i.remove();
try {
URL[] loaderURLs = PluginLoader.createClassloaderUrls(pluginLoader.loadedFrom);
pluginLoader.classLoader = new URLClassLoader(loaderURLs, parent.getClassLoader());
pluginLoader.loadPluginComponents();
Plugin.putPlugin(pluginLoader.loadedFromUri, pluginLoader.plugin);
} catch (PluginException e) {
throw new RuntimeException("Unable to load plugin " + pluginId, e);
}
changed = true;
} else {
unresolved.add(pluginId);
needed.add(parentid);
}
}
if (!changed) {
String msg = "Unable to load parent plugins " + needed + " in order to load " + unresolved;
System.err.println(msg);
AnalysisContext.logError(msg);
msg = "Available plugins are " + Plugin.getAllPluginIds();
System.err.println(msg);
AnalysisContext.logError(msg);
for (Iterator<PluginLoader> i = partiallyInitialized.iterator(); i.hasNext();) {
Plugin.removePlugin(i.next().loadedFromUri);
}
partiallyInitialized.clear();
}
}
lazyInitialization = false;
}
private static @Nonnull URL[] createClassloaderUrls(@Nonnull URL url) throws PluginException {
List<URL> urls = new ArrayList<URL>();
urls.add(url);
Manifest mf = null;
File f = new File(url.getPath());
if(!f.isDirectory()) {
JarInputStream jis = null;
try {
jis = new JarInputStream(url.openStream());
mf = jis.getManifest();
} catch (IOException ioe) {
throw new PluginException("Failed loading manifest for plugin jar: " + url, ioe);
} finally {
IO.close(jis);
}
} else {
File manifest = guessManifest(f);
if(manifest != null){
FileInputStream is = null;
try {
is = new FileInputStream(manifest);
mf = new Manifest(is);
} catch (IOException e) {
throw new PluginException("Failed loading manifest for plugin jar: " + url, e);
} finally {
IO.close(is);
}
}
}
if(mf != null){
try {
addClassPathFromManifest(url, urls, mf);
} catch (MalformedURLException e) {
throw new PluginException("Failed loading manifest for plugin jar: " + url, e);
}
}
return urls.toArray(new URL[urls.size()]);
}
private static void addClassPathFromManifest(@Nonnull URL url, @Nonnull List<URL> urls,
@Nonnull Manifest mf) throws MalformedURLException {
Attributes atts = mf.getMainAttributes();
if (atts == null) {
return;
}
String classPath = atts.getValue(Attributes.Name.CLASS_PATH);
if (classPath != null) {
String jarRoot = url.toString();
jarRoot = jarRoot.substring(0, jarRoot.lastIndexOf('/') + 1);
String[] jars = classPath.split(",");
for (String jar : jars) {
jar = jarRoot + jar.trim();
urls.add(new URL(jar));
}
}
}
@CheckForNull
private static File guessManifest(@Nonnull File parent) {
File file = new File(parent, "MANIFEST.MF");
if(!file.isFile()){
file = new File(parent, "META-INF/MANIFEST.MF");
}
if(!file.isFile()){
file = new File(parent, "../META-INF/MANIFEST.MF");
}
if(file.isFile()){
return file;
}
return null;
}
@Deprecated
public PluginLoader() throws PluginException {
classLoader = getClass().getClassLoader();
classLoaderForResources = classLoader;
corePlugin = true;
initialPlugin = true;
optionalPlugin = false;
loadedFrom = computeCoreUrl();
try {
loadedFromUri = loadedFrom.toURI();
} catch (URISyntaxException e) {
throw new IllegalArgumentException("Failed to parse uri: " + loadedFrom);
}
jarName = getJarName(loadedFrom);
plugin = init();
loadPluginComponents();
Plugin.putPlugin(null, plugin);
}
@Deprecated
public PluginLoader(boolean fake, URL url) throws PluginException {
classLoader = getClass().getClassLoader();
classLoaderForResources = classLoader;
corePlugin = false;
initialPlugin = true;
optionalPlugin = false;
loadedFrom = url;
try {
loadedFromUri = loadedFrom.toURI();
} catch (URISyntaxException e) {
throw new IllegalArgumentException("Failed to parse uri: " + loadedFrom);
}
jarName = getJarName(loadedFrom);
plugin = null;
}
private static URL computeCoreUrl() {
URL from;
String findBugsClassFile = ClassName.toSlashedClassName(FindBugs.class) + ".class";
URL me = FindBugs.class.getClassLoader().getResource(findBugsClassFile);
if (DEBUG) {
System.out.println("FindBugs.class loaded from " + me);
}
if(me == null) {
throw new IllegalStateException("Failed to load " + findBugsClassFile);
}
try {
String u = me.toString();
if (u.startsWith("jar:") && u.endsWith("!/" + findBugsClassFile)) {
u = u.substring(4, u.indexOf("!/"));
from = new URL(u);
} else if (u.endsWith(findBugsClassFile)) {
u = u.substring(0, u.indexOf(findBugsClassFile));
from = new URL(u);
} else {
throw new IllegalArgumentException("Unknown url shema: " + u);
}
} catch (MalformedURLException e) {
throw new IllegalArgumentException("Failed to parse url: " + me);
}
if (DEBUG) {
System.out.println("Core class files loaded from " + from);
}
return from;
}
public URL getURL() {
return loadedFrom;
}
public URI getURI() {
return loadedFromUri;
}
private static URI toUri(URL url) throws PluginException {
try {
return url.toURI();
} catch (URISyntaxException e) {
throw new PluginException("Bad uri: " + url, e);
}
}
private static String getJarName(URL url) {
String location = url.getPath();
int i = location.lastIndexOf('/');
location = location.substring(i + 1);
return location;
}
public ClassLoader getClassLoader() {
if (classLoader == null) {
throw new IllegalStateException("Plugin not completely initialized; classloader not set yet");
}
return classLoader;
}
public Plugin loadPlugin() throws PluginException {
return getPlugin();
}
public Plugin getPlugin() {
if (plugin == null) {
throw new AssertionError("plugin not already loaded");
}
return plugin;
}
private static URL resourceFromPlugin(URL u, String args) throws MalformedURLException {
String path = u.getPath();
if (path.endsWith(".zip") || path.endsWith(".jar")) {
return new URL("jar:" + u.toString() + "!/" + args);
} else if (path.endsWith("/")) {
return new URL(u.toString() + args);
} else {
return new URL(u.toString() + "/" + args);
}
}
public URL getResource(String name) {
if (isCorePlugin()) {
URL url = getCoreResource(name);
if (url != null && IO.verifyURL(url)) {
return url;
}
}
if (loadedFrom != null) {
try {
URL url = resourceFromPlugin(loadedFrom, name);
if (DEBUG) {
System.out.println("Trying to load " + name + " from " + url);
}
if (IO.verifyURL(url)) {
return url;
}
} catch (MalformedURLException e) {
assert true;
}
}
if (classLoaderForResources instanceof URLClassLoader) {
URLClassLoader urlClassLoader = (URLClassLoader) classLoaderForResources;
if (DEBUG) {
System.out.println("Trying to load " + name + " using URLClassLoader.findResource");
System.out.println(" from urls: " + Arrays.asList(urlClassLoader.getURLs()));
}
URL url = urlClassLoader.findResource(name);
if (url == null) {
url = urlClassLoader.findResource("/" + name);
}
if (IO.verifyURL(url)) {
return url;
}
}
if (DEBUG) {
System.out.println("Trying to load " + name + " using ClassLoader.getResource");
}
URL url = classLoaderForResources.getResource(name);
if (url == null) {
url = classLoaderForResources.getResource("/" + name);
}
if (IO.verifyURL(url)) {
return url;
}
return null;
}
static @CheckForNull
URL getCoreResource(String name) {
URL u = loadFromFindBugsPluginDir(name);
if (u != null) {
return u;
}
u = loadFromFindBugsEtcDir(name);
if (u != null) {
return u;
}
u = PluginLoader.class.getResource(name);
if (u != null) {
return u;
}
u = PluginLoader.class.getResource("/"+name);
return u;
}
public static @CheckForNull
URL loadFromFindBugsEtcDir(String name) {
String findBugsHome = DetectorFactoryCollection.getFindBugsHome();
if (findBugsHome != null) {
File f = new File(new File(new File(findBugsHome), "etc"), name);
if (f.canRead()) {
try {
return f.toURL();
} catch (MalformedURLException e) {
assert true;
}
}
}
return null;
}
public static @CheckForNull
URL loadFromFindBugsPluginDir(String name) {
String findBugsHome = DetectorFactoryCollection.getFindBugsHome();
if (findBugsHome != null) {
File f = new File(new File(new File(findBugsHome), "plugin"), name);
if (f.canRead()) {
try {
return f.toURI().toURL();
} catch (MalformedURLException e) {
assert true;
}
}
}
return null;
}
private static <T> Class<? extends T> getClass(ClassLoader loader, @DottedClassName String className, Class<T> type) throws PluginException {
try {
return loader.loadClass(className).asSubclass(type);
} catch (ClassNotFoundException e) {
throw new PluginException("Unable to load " + className, e);
} catch (ClassCastException e) {
throw new PluginException("Cannot cast " + className + " to " + type.getName(), e);
}
}
private Plugin init() throws PluginException {
if (DEBUG) {
System.out.println("Loading plugin from " + loadedFrom);
}
Document pluginDescriptor = getPluginDescriptor();
List<Document> messageCollectionList = getMessageDocuments();
Plugin constructedPlugin = constructMinimalPlugin(pluginDescriptor, messageCollectionList);
if (DEBUG) {
System.out.println("Loaded " + constructedPlugin.getPluginId() + " from " + loadedFrom);
}
return constructedPlugin;
}
private void loadPluginComponents()
throws PluginException {
Document pluginDescriptor = getPluginDescriptor();
List<Document> messageCollectionList = getMessageDocuments();
List<Node> cloudNodeList = XMLUtil.selectNodes(pluginDescriptor, "/FindbugsPlugin/Cloud");
for (Node cloudNode : cloudNodeList) {
String cloudClassname = cloudNode.valueOf("@cloudClass");
String cloudId = cloudNode.valueOf("@id");
String usernameClassname = cloudNode.valueOf("@usernameClass");
boolean onlineStorage = Boolean.valueOf(cloudNode.valueOf("@onlineStorage"));
String propertiesLocation = cloudNode.valueOf("@properties");
boolean disabled = Boolean.valueOf(cloudNode.valueOf("@disabled")) && !cloudId.equals(CloudFactory.DEFAULT_CLOUD);
if (disabled) {
continue;
}
boolean hidden = Boolean.valueOf(cloudNode.valueOf("@hidden")) && !cloudId.equals(CloudFactory.DEFAULT_CLOUD);
Class<? extends Cloud> cloudClass = getClass(classLoader, cloudClassname, Cloud.class);
Class<? extends NameLookup> usernameClass = getClass(classLoader, usernameClassname, NameLookup.class);
Node cloudMessageNode = findMessageNode(messageCollectionList, "/MessageCollection/Cloud[@id='" + cloudId + "']",
"Missing Cloud description for cloud " + cloudId);
String description = getChildText(cloudMessageNode, "Description").trim();
String details = getChildText(cloudMessageNode, "Details").trim();
PropertyBundle properties = new PropertyBundle();
if (propertiesLocation != null && propertiesLocation.length() > 0) {
URL properiesURL = classLoader.getResource(propertiesLocation);
if (properiesURL == null) {
continue;
}
properties.loadPropertiesFromURL(properiesURL);
}
List<Node> propertyNodes = XMLUtil.selectNodes(cloudNode, "Property");
for (Node node : propertyNodes) {
String key = node.valueOf("@key");
String value = node.getText().trim();
properties.setProperty(key, value);
}
CloudPlugin cloudPlugin = new CloudPluginBuilder().setFindbugsPluginId(plugin.getPluginId()).setCloudid(cloudId).setClassLoader(classLoader)
.setCloudClass(cloudClass).setUsernameClass(usernameClass).setHidden(hidden).setProperties(properties)
.setDescription(description).setDetails(details).setOnlineStorage(onlineStorage).createCloudPlugin();
plugin.addCloudPlugin(cloudPlugin);
}
try {
List<Node> componentNodeList = XMLUtil.selectNodes(pluginDescriptor, "/FindbugsPlugin/PluginComponent");
for (Node componentNode : componentNodeList) {
@DottedClassName String componentKindname = componentNode.valueOf("@componentKind");
if (componentKindname == null) {
throw new PluginException("Missing @componentKind for " + plugin.getPluginId()
+ " loaded from " + loadedFrom);
}
@DottedClassName String componentClassname = componentNode.valueOf("@componentClass");
if (componentClassname == null) {
throw new PluginException("Missing @componentClassname for " + plugin.getPluginId()
+ " loaded from " + loadedFrom);
}
String componentId = componentNode.valueOf("@id");
if (componentId == null) {
throw new PluginException("Missing @id for " + plugin.getPluginId()
+ " loaded from " + loadedFrom);
}
try {
String propertiesLocation = componentNode.valueOf("@properties");
boolean disabled = Boolean.valueOf(componentNode.valueOf("@disabled"));
Node filterMessageNode = findMessageNode(messageCollectionList,
"/MessageCollection/PluginComponent[@id='" + componentId + "']",
"Missing Cloud description for PluginComponent " + componentId);
String description = getChildText(filterMessageNode, "Description").trim();
String details = getChildText(filterMessageNode, "Details").trim();
PropertyBundle properties = new PropertyBundle();
if (propertiesLocation != null && propertiesLocation.length() > 0) {
URL properiesURL = classLoaderForResources.getResource(propertiesLocation);
if (properiesURL == null) {
AnalysisContext.logError("Could not load properties for " + plugin.getPluginId() + " component " + componentId
+ " from " + propertiesLocation);
continue;
}
properties.loadPropertiesFromURL(properiesURL);
}
List<Node> propertyNodes = XMLUtil.selectNodes(componentNode, "Property");
for (Node node : propertyNodes) {
String key = node.valueOf("@key");
String value = node.getText();
properties.setProperty(key, value);
}
Class<?> componentKind = classLoader.loadClass(componentKindname);
loadComponentPlugin(plugin, componentKind, componentClassname, componentId, disabled, description, details,
properties);
} catch (RuntimeException e) {
AnalysisContext.logError("Unable to load ComponentPlugin " + componentId +
" : " + componentClassname + " implementing " + componentKindname, e);
}
}
if (!FindBugs.isNoMains()) {
List<Node> findBugsMainList = XMLUtil.selectNodes(pluginDescriptor, "/FindbugsPlugin/FindBugsMain");
for (Node main : findBugsMainList) {
String className = main.valueOf("@class");
if (className == null) {
throw new PluginException("Missing @class for FindBugsMain in plugin" + plugin.getPluginId()
+ " loaded from " + loadedFrom);
}
String cmd = main.valueOf("@cmd");
if (cmd == null) {
throw new PluginException("Missing @cmd for for FindBugsMain in plugin " + plugin.getPluginId()
+ " loaded from " + loadedFrom);
}
String kind = main.valueOf("@kind");
boolean analysis = Boolean.valueOf(main.valueOf("@analysis"));
Element mainMessageNode = (Element) findMessageNode(messageCollectionList,
"/MessageCollection/FindBugsMain[@cmd='" + cmd
+"']/Description",
"Missing FindBugsMain description for cmd " + cmd);
String description = mainMessageNode.getTextTrim();
try {
Class<?> mainClass = classLoader.loadClass(className);
plugin.addFindBugsMain(mainClass, cmd, description, kind, analysis);
} catch (Exception e) {
String msg = "Unable to load FindBugsMain " + cmd +
" : " + className + " in plugin " + plugin.getPluginId()
+ " loaded from " + loadedFrom;
PluginException e2 = new PluginException(msg, e);
AnalysisContext.logError(msg, e2);
}
}
}
List<Node> detectorNodeList = XMLUtil.selectNodes(pluginDescriptor, "/FindbugsPlugin/Detector");
int detectorCount = 0;
for (Node detectorNode : detectorNodeList) {
String className = detectorNode.valueOf("@class");
String speed = detectorNode.valueOf("@speed");
String disabled = detectorNode.valueOf("@disabled");
String reports = detectorNode.valueOf("@reports");
String requireJRE = detectorNode.valueOf("@requirejre");
String hidden = detectorNode.valueOf("@hidden");
if (speed == null || speed.length() == 0) {
speed = "fast";
}
Class<?> detectorClass = null;
if (!FindBugs.isNoAnalysis()) {
detectorClass = classLoader.loadClass(className);
if (!Detector.class.isAssignableFrom(detectorClass) && !Detector2.class.isAssignableFrom(detectorClass)) {
throw new PluginException("Class " + className + " does not implement Detector or Detector2");
}
}
DetectorFactory factory = new DetectorFactory(plugin, className, detectorClass, !"true".equals(disabled), speed,
reports, requireJRE);
if (Boolean.valueOf(hidden).booleanValue()) {
factory.setHidden(true);
}
factory.setPositionSpecifiedInPluginDescriptor(detectorCount++);
plugin.addDetectorFactory(factory);
Node node = findMessageNode(messageCollectionList, "/MessageCollection/Detector[@class='" + className
+ "']/Details", "Missing Detector description for detector " + className);
Element details = (Element) node;
String detailHTML = details.getText();
StringBuilder buf = new StringBuilder();
buf.append("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n");
buf.append("<HTML><HEAD><TITLE>Detector Description</TITLE></HEAD><BODY>\n");
buf.append(detailHTML);
buf.append("</BODY></HTML>\n");
factory.setDetailHTML(buf.toString());
}
} catch (ClassNotFoundException e) {
throw new PluginException("Could not instantiate detector class: " + e, e);
}
Node orderingConstraintsNode = pluginDescriptor.selectSingleNode("/FindbugsPlugin/OrderingConstraints");
if (orderingConstraintsNode != null) {
List<Element> elements = XMLUtil.selectNodes(orderingConstraintsNode, "./SplitPass|./WithinPass");
for (Element constraintElement : elements) {
DetectorFactorySelector earlierSelector = getConstraintSelector(constraintElement, plugin, "Earlier");
DetectorFactorySelector laterSelector = getConstraintSelector(constraintElement, plugin, "Later");
DetectorOrderingConstraint constraint = new DetectorOrderingConstraint(earlierSelector, laterSelector);
constraint.setSingleSource(earlierSelector instanceof SingleDetectorFactorySelector);
if ("SplitPass".equals(constraintElement.getName())) {
plugin.addInterPassOrderingConstraint(constraint);
} else {
plugin.addIntraPassOrderingConstraint(constraint);
}
}
}
List<Node> categoryNodeListGlobal = XMLUtil.selectNodes(pluginDescriptor, "/FindbugsPlugin/BugCategory");
for(Node categoryNode : categoryNodeListGlobal) {
String key = categoryNode.valueOf("@category");
if ("".equals(key)) {
throw new PluginException("BugCategory element with missing category attribute");
}
BugCategory bc = plugin.addOrCreateBugCategory(key);
boolean hidden = Boolean.valueOf(categoryNode.valueOf("@hidden"));
if (hidden) {
bc.setHidden(hidden);
}
}
for (Document messageCollection : messageCollectionList) {
List<Node> categoryNodeList = XMLUtil.selectNodes(messageCollection, "/MessageCollection/BugCategory");
if (DEBUG) {
System.out.println("found " + categoryNodeList.size() + " categories in " + plugin.getPluginId());
}
for (Node categoryNode : categoryNodeList) {
String key = categoryNode.valueOf("@category");
if ("".equals(key)) {
throw new PluginException("BugCategory element with missing category attribute");
}
BugCategory bc = plugin.addOrCreateBugCategory(key);
String shortDesc = getChildText(categoryNode, "Description");
bc.setShortDescription(shortDesc);
try {
String abbrev = getChildText(categoryNode, "Abbreviation");
if (bc.getAbbrev() == null) {
bc.setAbbrev(abbrev);
if (DEBUG) {
System.out.println("category " + key + " abbrev -> " + abbrev);
}
} else if (DEBUG) {
System.out.println("rejected abbrev '" + abbrev + "' for category " + key + ": " + bc.getAbbrev());
}
} catch (PluginException pe) {
if (DEBUG)
{
System.out.println("missing Abbreviation for category " + key + "/" + shortDesc);
}
}
try {
String details = getChildText(categoryNode, "Details");
if (bc.getDetailText() == null) {
bc.setDetailText(details);
if (DEBUG) {
System.out.println("category " + key + " details -> " + details);
}
} else if (DEBUG) {
System.out.println("rejected details [" + details + "] for category " + key + ": [" + bc.getDetailText()
+ ']');
}
} catch (PluginException pe) {
}
}
}
List<Node> bugPatternNodeList = XMLUtil.selectNodes(pluginDescriptor, "/FindbugsPlugin/BugPattern");
for (Node bugPatternNode : bugPatternNodeList) {
String type = bugPatternNode.valueOf("@type");
String abbrev = bugPatternNode.valueOf("@abbrev");
String category = bugPatternNode.valueOf("@category");
boolean experimental = Boolean.parseBoolean(bugPatternNode.valueOf("@experimental"));
String query = "/MessageCollection/BugPattern[@type='" + type + "']";
Node messageNode = findMessageNode(messageCollectionList, query, "messages.xml missing BugPattern element for type "
+ type);
Node bugsUrlNode = messageNode.getDocument().selectSingleNode("/MessageCollection/Plugin/"+(experimental?"AllBugsUrl":"BugsUrl"));
String bugsUrl = bugsUrlNode == null ? null : bugsUrlNode.getText();
String shortDesc = getChildText(messageNode, "ShortDescription");
String longDesc = getChildText(messageNode, "LongDescription");
String detailText = getChildText(messageNode, "Details");
int cweid = 0;
try {
String cweString = bugPatternNode.valueOf("@cweid");
if (cweString.length() > 0) {
cweid = Integer.parseInt(cweString);
}
} catch (RuntimeException e) {
assert true;
}
BugPattern bugPattern = new BugPattern(type, abbrev, category, experimental, shortDesc, longDesc, detailText, bugsUrl, cweid);
try {
String deprecatedStr = bugPatternNode.valueOf("@deprecated");
boolean deprecated = deprecatedStr.length() > 0 && Boolean.valueOf(deprecatedStr).booleanValue();
if (deprecated) {
bugPattern.setDeprecated(deprecated);
}
} catch (RuntimeException e) {
assert true;
}
plugin.addBugPattern(bugPattern);
}
Set<String> definedBugCodes = new HashSet<String>();
for (Document messageCollection : messageCollectionList) {
List<Node> bugCodeNodeList = XMLUtil.selectNodes(messageCollection, "/MessageCollection/BugCode");
for (Node bugCodeNode : bugCodeNodeList) {
String abbrev = bugCodeNode.valueOf("@abbrev");
if ("".equals(abbrev)) {
throw new PluginException("BugCode element with missing abbrev attribute");
}
if (definedBugCodes.contains(abbrev)) {
continue;
}
String description = bugCodeNode.getText();
String query = "/FindbugsPlugin/BugCode[@abbrev='" + abbrev + "']";
Node fbNode = pluginDescriptor.selectSingleNode(query);
int cweid = 0;
if (fbNode != null) {
try {
cweid = Integer.parseInt(fbNode.valueOf("@cweid"));
} catch (RuntimeException e) {
assert true;
}
}
BugCode bugCode = new BugCode(abbrev, description, cweid);
plugin.addBugCode(bugCode);
definedBugCodes.add(abbrev);
}
}
Node node = pluginDescriptor.selectSingleNode("/FindbugsPlugin/EngineRegistrar");
if (node != null) {
String engineClassName = node.valueOf("@class");
if (engineClassName == null) {
throw new PluginException("EngineRegistrar element with missing class attribute");
}
try {
Class<?> engineRegistrarClass = classLoader.loadClass(engineClassName);
if (!IAnalysisEngineRegistrar.class.isAssignableFrom(engineRegistrarClass)) {
throw new PluginException(engineRegistrarClass + " does not implement IAnalysisEngineRegistrar");
}
plugin.setEngineRegistrarClass(engineRegistrarClass
.<IAnalysisEngineRegistrar> asSubclass(IAnalysisEngineRegistrar.class));
} catch (ClassNotFoundException e) {
throw new PluginException("Could not instantiate analysis engine registrar class: " + e, e);
}
}
try {
URL bugRankURL = getResource(BugRanker.FILENAME);
if (bugRankURL == null) {
if (DEBUG) {
System.out.println("No " + BugRanker.FILENAME + " for plugin " + plugin.getPluginId());
}
}
BugRanker ranker = new BugRanker(bugRankURL);
plugin.setBugRanker(ranker);
} catch (IOException e) {
throw new PluginException("Couldn't parse \"" + BugRanker.FILENAME + "\"", e);
}
}
private Plugin constructMinimalPlugin(Document pluginDescriptor, List<Document> messageCollectionList)
throws DuplicatePluginIdError {
String pluginId = pluginDescriptor.valueOf(XPATH_PLUGIN_PLUGINID);
if ("".equals(pluginId)) {
synchronized (PluginLoader.class) {
pluginId = "plugin" + nextUnknownId++;
}
}
cannotDisable = Boolean.parseBoolean(pluginDescriptor.valueOf("/FindbugsPlugin/@cannotDisable"));
String de = pluginDescriptor.valueOf("/FindbugsPlugin/@defaultenabled");
if (de != null && "false".equals(de.toLowerCase().trim())) {
optionalPlugin = true;
}
if (optionalPlugin) {
cannotDisable = false;
}
if (!loadedPluginIds.add(pluginId)) {
Plugin existingPlugin = Plugin.getByPluginId(pluginId);
URL u = existingPlugin == null ? null : existingPlugin.getPluginLoader().getURL();
if (cannotDisable && initialPlugin) {
throw new DuplicatePluginIdError(pluginId, loadedFrom, u);
} else {
throw new DuplicatePluginIdException(pluginId, loadedFrom, u);
}
}
parentId = pluginDescriptor.valueOf("/FindbugsPlugin/@parentid");
String version = pluginDescriptor.valueOf("/FindbugsPlugin/@version");
String releaseDate = pluginDescriptor.valueOf("/FindbugsPlugin/@releaseDate");
if ((releaseDate == null || releaseDate.length() == 0) && isCorePlugin()) {
releaseDate = Version.CORE_PLUGIN_RELEASE_DATE;
}
Date parsedDate = parseDate(releaseDate);
Plugin constructedPlugin = new Plugin(pluginId, version, parsedDate, this, !optionalPlugin, cannotDisable);
String provider = pluginDescriptor.valueOf(XPATH_PLUGIN_PROVIDER).trim();
if (!"".equals(provider)) {
constructedPlugin.setProvider(provider);
}
String website = pluginDescriptor.valueOf(XPATH_PLUGIN_WEBSITE).trim();
if (!"".equals(website)) {
try {
constructedPlugin.setWebsite(website);
} catch (URISyntaxException e1) {
AnalysisContext.logError("Plugin " + constructedPlugin.getPluginId() + " has invalid website: " + website, e1);
}
}
String updateUrl = pluginDescriptor.valueOf("/FindbugsPlugin/@update-url").trim();
if (!"".equals(updateUrl)) {
try {
constructedPlugin.setUpdateUrl(updateUrl);
} catch (URISyntaxException e1) {
AnalysisContext.logError("Plugin " + constructedPlugin.getPluginId() + " has invalid update check URL: " + website, e1);
}
}
Node pluginShortDesc = null;
try {
pluginShortDesc = findMessageNode(messageCollectionList, XPATH_PLUGIN_SHORT_DESCRIPTION,
"no plugin description");
} catch (PluginException e) {
}
if (pluginShortDesc != null) {
constructedPlugin.setShortDescription(pluginShortDesc.getText().trim());
}
Node detailedDescription = null;
try {
detailedDescription = findMessageNode(messageCollectionList, "/MessageCollection/Plugin/Details",
"no plugin description");
} catch (PluginException e) {
}
if (detailedDescription != null) {
constructedPlugin.setDetailedDescription(detailedDescription.getText().trim());
}
List<Node> globalOptionNodes = XMLUtil.selectNodes(pluginDescriptor, "/FindbugsPlugin/GlobalOptions/Property");
for(Node optionNode : globalOptionNodes) {
String key = optionNode.valueOf("@key");
String value = optionNode.getText().trim();
constructedPlugin.setMyGlobalOption(key, value);
}
return constructedPlugin;
}
public Document getPluginDescriptor() throws PluginException, PluginDoesntContainMetadataException {
Document pluginDescriptor;
String name = "findbugs.xml";
URL findbugsXML_URL = getResource(name);
if (findbugsXML_URL == null) {
throw new PluginException("Couldn't find \"" + name + "\" in plugin " + this);
}
if (DEBUG) {
System.out.println("PluginLoader found " + name + " at: " + findbugsXML_URL);
}
if (jarName != null && !findbugsXML_URL.toString().contains(jarName)
&& !(corePlugin && findbugsXML_URL.toString().endsWith("etc/findbugs.xml"))) {
String classloaderName = classLoader.getClass().getName();
if (classLoader instanceof URLClassLoader) {
classloaderName += Arrays.asList(((URLClassLoader) classLoader).getURLs());
}
throw new PluginDoesntContainMetadataException((corePlugin ? "Core plugin" : "Plugin ") + jarName
+ " doesn't contain findbugs.xml; got " + findbugsXML_URL + " from " + classloaderName);
}
SAXReader reader = new SAXReader();
Reader r = null;
try {
r = UTF8.bufferedReader(findbugsXML_URL.openStream());
pluginDescriptor = reader.read(r);
} catch (DocumentException e) {
throw new PluginException("Couldn't parse \"" + findbugsXML_URL + "\" using " + reader.getClass().getName(), e);
} catch (IOException e) {
throw new PluginException("Couldn't open \"" + findbugsXML_URL + "\"", e);
} finally {
IO.close(r);
}
return pluginDescriptor;
}
private static List<String> getPotentialMessageFiles() {
Locale locale = Locale.getDefault();
String language = locale.getLanguage();
String country = locale.getCountry();
List<String> potential = new ArrayList<String>(3);
if (country != null) {
potential.add("messages_" + language + "_" + country + ".xml");
}
potential.add("messages_" + language + ".xml");
potential.add("messages.xml");
return potential;
}
private List<Document> getMessageDocuments() throws PluginException {
ArrayList<Document> messageCollectionList = new ArrayList<Document>();
PluginException caught = null;
for (String m : getPotentialMessageFiles()) {
try {
addCollection(messageCollectionList, m);
} catch (PluginException e) {
caught = e;
AnalysisContext.logError(
"Error loading localized message file:" + m, e);
}
}
if (messageCollectionList.isEmpty()) {
if (caught != null) {
throw caught;
}
throw new PluginException("No message.xml files found");
}
return messageCollectionList;
}
private <T> void loadComponentPlugin(Plugin plugin,
Class<T> componentKind, @DottedClassName String componentClassname, String filterId,
boolean disabled, String description, String details, PropertyBundle properties) throws PluginException {
Class<? extends T> componentClass = null;
if (!FindBugs.isNoAnalysis() || componentKind == edu.umd.cs.findbugs.bugReporter.BugReporterDecorator.class) {
componentClass = getClass(classLoader, componentClassname, componentKind);
}
ComponentPlugin<T> componentPlugin = new ComponentPlugin<T>(plugin, filterId, classLoader, componentClass,
properties, !disabled, description, details);
plugin.addComponentPlugin(componentKind, componentPlugin);
}
private static Date parseDate(String releaseDate) {
if (releaseDate == null || releaseDate.length() == 0) {
return null;
}
try {
SimpleDateFormat releaseDateFormat = new SimpleDateFormat(UpdateChecker.PLUGIN_RELEASE_DATE_FMT, Locale.ENGLISH);
Date result = releaseDateFormat.parse(releaseDate);
return result;
} catch (ParseException e) {
AnalysisContext.logError("unable to parse date " + releaseDate, e);
return null;
}
}
private static DetectorFactorySelector getConstraintSelector(Element constraintElement, Plugin plugin,
String singleDetectorElementName) throws PluginException {
Node node = constraintElement.selectSingleNode("./" + singleDetectorElementName);
if (node != null) {
String detectorClass = node.valueOf("@class");
return new SingleDetectorFactorySelector(plugin, detectorClass);
}
node = constraintElement.selectSingleNode("./" + singleDetectorElementName + "Category");
if (node != null) {
boolean spanPlugins = Boolean.valueOf(node.valueOf("@spanplugins")).booleanValue();
String categoryName = node.valueOf("@name");
if (!"".equals(categoryName)) {
if ("reporting".equals(categoryName)) {
return new ReportingDetectorFactorySelector(spanPlugins ? null : plugin);
} else if ("training".equals(categoryName)) {
return new ByInterfaceDetectorFactorySelector(spanPlugins ? null : plugin, TrainingDetector.class);
} else if ("interprocedural".equals(categoryName)) {
return new ByInterfaceDetectorFactorySelector(spanPlugins ? null : plugin,
InterproceduralFirstPassDetector.class);
} else {
throw new PluginException("Invalid category name " + categoryName + " in constraint selector node");
}
}
}
node = constraintElement.selectSingleNode("./" + singleDetectorElementName + "Subtypes");
if (node != null) {
boolean spanPlugins = Boolean.valueOf(node.valueOf("@spanplugins")).booleanValue();
String superName = node.valueOf("@super");
if (!"".equals(superName)) {
try {
Class<?> superClass = Class.forName(superName);
return new ByInterfaceDetectorFactorySelector(spanPlugins ? null : plugin, superClass);
} catch (ClassNotFoundException e) {
throw new PluginException("Unknown class " + superName + " in constraint selector node");
}
}
}
throw new PluginException("Invalid constraint selector node");
}
private void addCollection(List<Document> messageCollectionList, String filename) throws PluginException {
URL messageURL = getResource(filename);
if (messageURL != null) {
SAXReader reader = new SAXReader();
try {
Reader stream = UTF8.bufferedReader(messageURL.openStream());
Document messageCollection;
try {
messageCollection = reader.read(stream);
} finally {
stream.close();
}
messageCollectionList.add(messageCollection);
} catch (IOException | DocumentException e) {
throw new PluginException("Couldn't parse \"" + messageURL + "\"", e);
}
}
}
private static Node findMessageNode(List<Document> messageCollectionList, String xpath, String missingMsg)
throws PluginException {
for (Document document : messageCollectionList) {
Node node = document.selectSingleNode(xpath);
if (node != null) {
return node;
}
}
throw new PluginException(missingMsg);
}
private static String findMessageText(List<Document> messageCollectionList, String xpath, String missingMsg) {
for (Document document : messageCollectionList) {
Node node = document.selectSingleNode(xpath);
if (node != null) {
return node.getText().trim();
}
}
return missingMsg;
}
private static String getChildText(Node node, String childName) throws PluginException {
Node child = node.selectSingleNode(childName);
if (child == null) {
throw new PluginException("Could not find child \"" + childName + "\" for node");
}
return child.getText();
}
public static PluginLoader getPluginLoader(URL url, ClassLoader parent, boolean isInitial, boolean optional) throws PluginException {
URI uri = toUri(url);
Plugin plugin = Plugin.getPlugin(uri);
if (plugin != null) {
PluginLoader loader = plugin.getPluginLoader();
assert loader.getClassLoader().getParent().equals(parent);
return loader;
}
return new PluginLoader(url, uri, parent, isInitial, optional);
}
@Nonnull
public static synchronized PluginLoader getCorePluginLoader() {
Plugin plugin = Plugin.getPlugin(null);
if (plugin != null) {
return plugin.getPluginLoader();
}
throw new IllegalStateException("Core plugin not loaded yet!");
}
public boolean isCorePlugin() {
return corePlugin;
}
static void installStandardPlugins() {
String homeDir = DetectorFactoryCollection.getFindBugsHome();
if (homeDir == null) {
return;
}
File home = new File(homeDir);
loadPlugins(home);
}
private static void loadPlugins(File home) {
if (home.canRead() && home.isDirectory()) {
loadPluginsInDir(new File(home, "plugin"), false);
loadPluginsInDir(new File(home, "optionalPlugin"), true);
}
}
static void installUserInstalledPlugins() {
String homeDir = System.getProperty("user.home");
if (homeDir == null) {
return;
}
File homeFindBugs = new File(new File(homeDir), ".findbugs");
loadPlugins(homeFindBugs);
}
private static void loadPluginsInDir(File pluginDir, boolean optional) {
File[] contentList = pluginDir.listFiles();
if (contentList == null) {
return;
}
for (File file : contentList) {
if (file.getName().endsWith(".jar")) {
try {
URL url = file.toURI().toURL();
if (IO.verifyURL(url)) {
loadInitialPlugin(url, true, optional);
if (FindBugs.DEBUG) {
System.out.println("Found plugin: " + file.toString());
}
}
} catch (MalformedURLException e) {
}
}
}
}
static synchronized void loadInitialPlugins() {
lazyInitialization = true;
loadCorePlugin();
if (JavaWebStart.isRunningViaJavaWebstart()) {
installWebStartPlugins();
} else {
installStandardPlugins();
installUserInstalledPlugins();
}
Set<Entry<Object, Object>> entrySet = SystemProperties.getAllProperties().entrySet();
for (Map.Entry<?, ?> e : entrySet) {
if (e.getKey() instanceof String && e.getValue() instanceof String
&& ((String) e.getKey()).startsWith("findbugs.plugin.")) {
try {
String value = (String) e.getValue();
if (value.startsWith("file:") && !value.endsWith(".jar") && !value.endsWith("/")) {
value += "/";
}
URL url = JavaWebStart.resolveRelativeToJnlpCodebase(value);
System.out.println("Loading " + e.getKey() + " from " + url);
loadInitialPlugin(url, true, false);
} catch (MalformedURLException e1) {
AnalysisContext.logError(String.format("Bad URL for plugin: %s=%s", e.getKey(), e.getValue()), e1);
}
}
}
if (Plugin.getAllPlugins().size() > 1 && JavaWebStart.isRunningViaJavaWebstart()) {
try {
System.setSecurityManager(null);
} catch (Throwable e) {
assert true;
}
}
finishLazyInitialization();
}
private static void loadCorePlugin() {
try {
Plugin plugin = Plugin.getPlugin(null);
if (plugin != null) {
throw new IllegalStateException("Already loaded");
}
PluginLoader pluginLoader = new PluginLoader();
plugin = pluginLoader.getPlugin();
Plugin.putPlugin(null, plugin);
} catch (PluginException e1) {
throw new IllegalStateException("Unable to load core plugin", e1);
}
}
private static void loadInitialPlugin(URL u, boolean initial, boolean optional) {
try {
getPluginLoader(u, PluginLoader.class.getClassLoader(), initial, optional);
} catch (DuplicatePluginIdException ignored) {
assert true;
}catch (PluginException e) {
AnalysisContext.logError("Unable to load plugin from " + u, e);
if (DEBUG) {
e.printStackTrace();
}
}
}
static void installWebStartPlugins() {
URL pluginListProperties = getCoreResource("pluginlist.properties");
BufferedReader in = null;
if (pluginListProperties != null) {
try {
DetectorFactoryCollection.jawsDebugMessage(pluginListProperties.toString());
URL base = getUrlBase(pluginListProperties);
in = UTF8.bufferedReader(pluginListProperties.openStream());
while (true) {
String plugin = in.readLine();
if (plugin == null) {
break;
}
URL url = new URL(base, plugin);
try {
URLConnection connection = url.openConnection();
String contentType = connection.getContentType();
DetectorFactoryCollection.jawsDebugMessage("contentType : " + contentType);
if (connection instanceof HttpURLConnection) {
((HttpURLConnection) connection).disconnect();
}
loadInitialPlugin(url, true, false);
} catch (IOException e) {
DetectorFactoryCollection.jawsDebugMessage("error loading " + url + " : " + e.getMessage());
}
}
} catch (IOException e) {
DetectorFactoryCollection.jawsDebugMessage("error : " + e.getMessage());
} finally {
Util.closeSilently(in);
}
}
}
private static URL getUrlBase(URL pluginListProperties) throws MalformedURLException {
String urlname = pluginListProperties.toString();
URL base = pluginListProperties;
int pos = urlname.indexOf("!/");
if (pos >= 0 && urlname.startsWith("jar:")) {
urlname = urlname.substring(4, pos);
base = new URL(urlname);
}
return base;
}
@Override
public String toString() {
if (plugin == null) {
return String.format("PluginLoader(%s)", loadedFrom);
}
return String.format("PluginLoader(%s, %s)", plugin.getPluginId(), loadedFrom);
}
static public class Summary {
public final String id;
public final String description;
public final String provider;
public final String webbsite;
public Summary(String id, String description, String provider, String website) {
super();
this.id = id;
this.description = description;
this.provider = provider;
this.webbsite = website;
}
}
public static Summary validate(File file) throws IllegalArgumentException {
String path = file.getPath();
if (!file.getName().endsWith(".jar")) {
String message = "File " + path + " is not a .jar file";
throw new IllegalArgumentException(message);
}
if (!file.isFile() || !file.canRead()) {
String message = "File " + path
+ " is not a file or is not readable";
throw new IllegalArgumentException(message);
}
if (file.length() == 0) {
String message = "File " + path + " is empty";
throw new IllegalArgumentException(message);
}
ZipFile zip = null;
try {
zip = new ZipFile(file);
ZipEntry findbugsXML = zip.getEntry("findbugs.xml");
if (findbugsXML == null) {
throw new IllegalArgumentException(
"plugin doesn't contain a findbugs.xml file");
}
ZipEntry messagesXML = zip.getEntry("messages.xml");
if (messagesXML == null) {
throw new IllegalArgumentException(
"plugin doesn't contain a messages.xml file");
}
Document pluginDocument = parseDocument(zip.getInputStream(findbugsXML));
String pluginId = pluginDocument.valueOf(XPATH_PLUGIN_PLUGINID).trim();
String provider = pluginDocument.valueOf(XPATH_PLUGIN_PROVIDER).trim();
String website = pluginDocument.valueOf(XPATH_PLUGIN_WEBSITE).trim();
List<Document> msgDocuments = new ArrayList<Document>(3);
for (String msgFile : getPotentialMessageFiles()) {
ZipEntry msgEntry = zip.getEntry(msgFile);
if (msgEntry == null) {
continue;
}
Document msgDocument = parseDocument(zip.getInputStream(msgEntry));
msgDocuments.add(msgDocument);
}
String shortDesc = findMessageText(msgDocuments,
XPATH_PLUGIN_SHORT_DESCRIPTION, "");
return new Summary(pluginId, shortDesc, provider, website);
} catch (DocumentException e) {
throw new IllegalArgumentException(e);
} catch (IOException e) {
throw new IllegalArgumentException(e);
} finally {
Util.closeSilently(zip);
}
}
private static Document parseDocument(@WillClose InputStream in) throws DocumentException {
Reader r = UTF8.bufferedReader(in);
try {
SAXReader reader = new SAXReader();
Document d = reader.read(r);
return d;
} finally {
Util.closeSilently(r);
}
}
}
PluginLoader
XPATH_PLUGIN_SHORT_DESCRIPTION: String
lazyInitialization: boolean
