From 0cf3fc42ff8d3a71ba10bb599a5ec64885c86681 Mon Sep 17 00:00:00 2001 From: Decebal Suiu Date: Tue, 8 Apr 2014 19:00:28 +0300 Subject: [PATCH] added support for PluginManager.getExtensionClassNames(String pluginId) and simplify enable/disable plugin --- .../main/java/ro/fortsoft/pf4j/demo/Boot.java | 25 +++- .../fortsoft/pf4j/DefaultExtensionFinder.java | 129 ++++++++++-------- .../fortsoft/pf4j/DefaultPluginManager.java | 129 ++++++++++-------- .../ro/fortsoft/pf4j/ExtensionFinder.java | 13 +- .../java/ro/fortsoft/pf4j/PluginManager.java | 5 +- .../java/ro/fortsoft/pf4j/PluginState.java | 5 +- .../java/ro/fortsoft/pf4j/PluginWrapper.java | 33 +++-- .../ro/fortsoft/pf4j/util/PluginUtils.java | 37 +++++ 8 files changed, 239 insertions(+), 137 deletions(-) create mode 100644 pf4j/src/main/java/ro/fortsoft/pf4j/util/PluginUtils.java diff --git a/demo/app/src/main/java/ro/fortsoft/pf4j/demo/Boot.java b/demo/app/src/main/java/ro/fortsoft/pf4j/demo/Boot.java index 548ef4f..453e2c2 100644 --- a/demo/app/src/main/java/ro/fortsoft/pf4j/demo/Boot.java +++ b/demo/app/src/main/java/ro/fortsoft/pf4j/demo/Boot.java @@ -13,11 +13,13 @@ package ro.fortsoft.pf4j.demo; import java.util.List; +import java.util.Set; import org.apache.commons.lang.StringUtils; import ro.fortsoft.pf4j.DefaultPluginManager; import ro.fortsoft.pf4j.PluginManager; +import ro.fortsoft.pf4j.PluginWrapper; import ro.fortsoft.pf4j.demo.api.Greeting; /** @@ -28,26 +30,37 @@ import ro.fortsoft.pf4j.demo.api.Greeting; public class Boot { public static void main(String[] args) { - // print logo - printLogo(); + // print logo + printLogo(); - // create the plugin manager + // create the plugin manager final PluginManager pluginManager = new DefaultPluginManager(); // load the plugins pluginManager.loadPlugins(); // enable a disabled plugin - pluginManager.enablePlugin("welcome-plugin"); +// pluginManager.enablePlugin("welcome-plugin"); // start (active/resolved) the plugins pluginManager.startPlugins(); // retrieves the extensions for Greeting extension point List greetings = pluginManager.getExtensions(Greeting.class); - System.out.println(String.format("### Found %d extensions for the extension point '%s'", greetings.size(), Greeting.class.getName())); + System.out.println(String.format("Found %d extensions for extension point '%s'", greetings.size(), Greeting.class.getName())); for (Greeting greeting : greetings) { - System.out.println(">>> " + greeting.getGreeting()); + System.out.println(">>> " + greeting.getGreeting()); + } + + // print extensions for each started plugin + List startedPlugins = pluginManager.getStartedPlugins(); + for (PluginWrapper plugin : startedPlugins) { + String pluginId = plugin.getDescriptor().getPluginId(); + System.out.println(String.format("Extensions added by plugin '%s':", pluginId)); + Set extensionClassNames = pluginManager.getExtensionClassNames(pluginId); + for (String extension : extensionClassNames) { + System.out.println(" " + extension); + } } // stop the plugins diff --git a/pf4j/src/main/java/ro/fortsoft/pf4j/DefaultExtensionFinder.java b/pf4j/src/main/java/ro/fortsoft/pf4j/DefaultExtensionFinder.java index 99f7eca..c31f5d3 100644 --- a/pf4j/src/main/java/ro/fortsoft/pf4j/DefaultExtensionFinder.java +++ b/pf4j/src/main/java/ro/fortsoft/pf4j/DefaultExtensionFinder.java @@ -16,12 +16,7 @@ import java.io.IOException; import java.io.InputStreamReader; import java.io.Reader; import java.net.URL; -import java.util.ArrayList; -import java.util.Collections; -import java.util.Enumeration; -import java.util.HashSet; -import java.util.List; -import java.util.Set; +import java.util.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -37,21 +32,16 @@ public class DefaultExtensionFinder implements ExtensionFinder { private static final Logger log = LoggerFactory.getLogger(DefaultExtensionFinder.class); - private ClassLoader classLoader; + private PluginManager pluginManager; private ExtensionFactory extensionFactory; - private volatile Set entries; + private volatile Map> entries; // cache by pluginId - public DefaultExtensionFinder(ClassLoader classLoader) { - this.classLoader = classLoader; + public DefaultExtensionFinder(PluginManager pluginManager) { + this.pluginManager = pluginManager; this.extensionFactory = createExtensionFactory(); } - @Override - public void reset() { - entries = null; - } - - @Override + @Override public List> find(Class type) { log.debug("Checking extension point '{}'", type.getName()); if (!isExtensionPoint(type)) { @@ -61,28 +51,31 @@ public class DefaultExtensionFinder implements ExtensionFinder { } log.debug("Finding extensions for extension point '{}'", type.getName()); - List> result = new ArrayList>(); - if (entries == null) { - entries = readIndexFiles(); - } + readIndexFiles(); - for (String entry : entries) { - try { - Class extensionType = classLoader.loadClass(entry); - log.debug("Checking extension type '{}'", extensionType.getName()); - if (type.isAssignableFrom(extensionType)) { - Object instance = extensionFactory.create(extensionType); - if (instance != null) { - Extension extension = extensionType.getAnnotation(Extension.class); - log.debug("Added extension '{}' with ordinal {}", extensionType.getName(), extension.ordinal()); - result.add(new ExtensionWrapper(type.cast(instance), extension.ordinal())); + List> result = new ArrayList>(); + for (Map.Entry> entry : entries.entrySet()) { + String pluginId = entry.getKey(); + Set extensionClassNames = entry.getValue(); + + for (String className : extensionClassNames) { + try { + Class extensionType = pluginManager.getPluginClassLoader(pluginId).loadClass(className); + log.debug("Checking extension type '{}'", extensionType.getName()); + if (type.isAssignableFrom(extensionType)) { + Object instance = extensionFactory.create(extensionType); + if (instance != null) { + Extension extension = extensionType.getAnnotation(Extension.class); + log.debug("Added extension '{}' with ordinal {}", extensionType.getName(), extension.ordinal()); + result.add(new ExtensionWrapper(type.cast(instance), extension.ordinal())); + } + } else { + log.warn("'{}' is not an extension for extension point '{}'", extensionType.getName(), type.getName()); } - } else { - log.warn("'{}' is not an extension for extension point '{}'", extensionType.getName(), type.getName()); - } - } catch (ClassNotFoundException e) { - log.error(e.getMessage(), e); - } + } catch (ClassNotFoundException e) { + log.error(e.getMessage(), e); + } + } } if (entries.isEmpty()) { @@ -97,7 +90,18 @@ public class DefaultExtensionFinder implements ExtensionFinder { return result; } - /** + @Override + public Set findClassNames(String pluginId) { + return entries.get(pluginId); + } + + @Override + public void reset() { + // clear cache + entries = null; + } + + /** * Add the possibility to override the ExtensionFactory. * The default implementation uses Class.newInstance() method. */ @@ -122,28 +126,43 @@ public class DefaultExtensionFinder implements ExtensionFinder { }; } - private Set readIndexFiles() { - log.debug("Reading extensions index files"); - Set entries = new HashSet(); + private Map> readIndexFiles() { + // checking cache + if (entries != null) { + return entries; + } - try { - Enumeration indexFiles = classLoader.getResources(ExtensionsIndexer.EXTENSIONS_RESOURCE); - while (indexFiles.hasMoreElements()) { - Reader reader = new InputStreamReader(indexFiles.nextElement().openStream(), "UTF-8"); - ExtensionsIndexer.readIndex(reader, entries); - } - } catch (IOException e) { - log.error(e.getMessage(), e); - } + entries = new HashMap>(); + + List startedPlugins = pluginManager.getStartedPlugins(); + for (PluginWrapper plugin : startedPlugins) { + String pluginId = plugin.getDescriptor().getPluginId(); + log.debug("Reading extensions index file for plugin '{}'", pluginId); + Set entriesPerPlugin = new HashSet(); + + try { + URL url = plugin.getPluginClassLoader().getResource(ExtensionsIndexer.EXTENSIONS_RESOURCE); + log.debug("Read '{}'", url.getFile()); + Reader reader = new InputStreamReader(url.openStream(), "UTF-8"); + ExtensionsIndexer.readIndex(reader, entriesPerPlugin); + + if (entriesPerPlugin.isEmpty()) { + log.debug("No extensions found"); + } else { + log.debug("Found possible {} extensions:", entriesPerPlugin.size()); + for (String entry : entriesPerPlugin) { + log.debug(" " + entry); + } + } - if (entries.isEmpty()) { - log.debug("No extensions found"); - } else { - log.debug("Found possible {} extensions", entries.size()); + entries.put(pluginId, entriesPerPlugin); + } catch (IOException e) { + log.error(e.getMessage(), e); + } } - return entries; - } + return entries; + } private boolean isExtensionPoint(Class type) { return ExtensionPoint.class.isAssignableFrom(type); diff --git a/pf4j/src/main/java/ro/fortsoft/pf4j/DefaultPluginManager.java b/pf4j/src/main/java/ro/fortsoft/pf4j/DefaultPluginManager.java index e9d46a5..c9b63b2 100644 --- a/pf4j/src/main/java/ro/fortsoft/pf4j/DefaultPluginManager.java +++ b/pf4j/src/main/java/ro/fortsoft/pf4j/DefaultPluginManager.java @@ -12,27 +12,14 @@ */ package ro.fortsoft.pf4j; -import java.io.File; -import java.io.FileFilter; -import java.io.IOException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; - import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import ro.fortsoft.pf4j.util.*; -import ro.fortsoft.pf4j.util.AndFileFilter; -import ro.fortsoft.pf4j.util.CompoundClassLoader; -import ro.fortsoft.pf4j.util.DirectoryFileFilter; -import ro.fortsoft.pf4j.util.FileUtils; -import ro.fortsoft.pf4j.util.HiddenFilter; -import ro.fortsoft.pf4j.util.NotFileFilter; -import ro.fortsoft.pf4j.util.Unzip; -import ro.fortsoft.pf4j.util.ZipFileFilter; +import java.io.File; +import java.io.FileFilter; +import java.io.IOException; +import java.util.*; /** * Default implementation of the PluginManager interface. @@ -90,11 +77,6 @@ public class DefaultPluginManager implements PluginManager { private List enabledPlugins; private List disabledPlugins; - /** - * A compound class loader of resolved plugins. - */ - protected CompoundClassLoader compoundClassLoader; - /** * Cache value for the runtime mode. No need to re-read it because it wont change at * runtime. @@ -179,12 +161,12 @@ public class DefaultPluginManager implements PluginManager { // TODO uninstalled plugin dependencies? unresolvedPlugins.remove(pluginWrapper); resolvedPlugins.add(pluginWrapper); - compoundClassLoader.addLoader(pluginWrapper.getPluginClassLoader()); extensionFinder.reset(); return pluginWrapper.getDescriptor().getPluginId(); } catch (PluginException e) { log.error(e.getMessage(), e); } + return null; } @@ -194,9 +176,10 @@ public class DefaultPluginManager implements PluginManager { @Override public void startPlugins() { for (PluginWrapper pluginWrapper : resolvedPlugins) { - PluginDescriptor pluginDescriptor = pluginWrapper.getDescriptor(); - if (!isPluginDisabled(pluginDescriptor.getPluginId())) { + PluginState pluginState = pluginWrapper.getPluginState(); + if ((PluginState.DISABLED != pluginState) && (PluginState.STARTED != pluginState)) { try { + PluginDescriptor pluginDescriptor = pluginWrapper.getDescriptor(); log.info("Start plugin '{}:{}'", pluginDescriptor.getPluginId(), pluginDescriptor.getVersion()); pluginWrapper.getPlugin().start(); pluginWrapper.setPluginState(PluginState.STARTED); @@ -219,15 +202,16 @@ public class DefaultPluginManager implements PluginManager { PluginWrapper pluginWrapper = plugins.get(pluginId); PluginDescriptor pluginDescriptor = pluginWrapper.getDescriptor(); - if (pluginWrapper.getPluginState().equals(PluginState.STARTED)) { + if (PluginState.STARTED == pluginWrapper.getPluginState()) { log.debug("Already started plugin '{}:{}'", pluginDescriptor.getPluginId(), pluginDescriptor.getVersion()); return PluginState.STARTED; } - // test for disabled plugin - if (isPluginDisabled(pluginDescriptor.getPluginId())) { - // do nothing - return pluginWrapper.getPluginState(); + if (PluginState.DISABLED == pluginWrapper.getPluginState()) { + // automatically enable plugin on manual plugin start + if (!enablePlugin(pluginId)) { + return pluginWrapper.getPluginState(); + } } for (PluginDependency dependency : pluginDescriptor.getDependencies()) { @@ -256,9 +240,9 @@ public class DefaultPluginManager implements PluginManager { Iterator itr = startedPlugins.iterator(); while (itr.hasNext()) { PluginWrapper pluginWrapper = itr.next(); - PluginDescriptor pluginDescriptor = pluginWrapper.getDescriptor(); - if (!isPluginDisabled(pluginDescriptor.getPluginId())) { + if (PluginState.STARTED == pluginWrapper.getPluginState()) { try { + PluginDescriptor pluginDescriptor = pluginWrapper.getDescriptor(); log.info("Stop plugin '{}:{}'", pluginDescriptor.getPluginId(), pluginDescriptor.getVersion()); pluginWrapper.getPlugin().stop(); pluginWrapper.setPluginState(PluginState.STOPPED); @@ -281,13 +265,13 @@ public class DefaultPluginManager implements PluginManager { PluginWrapper pluginWrapper = plugins.get(pluginId); PluginDescriptor pluginDescriptor = pluginWrapper.getDescriptor(); - if (pluginWrapper.getPluginState().equals(PluginState.STOPPED)) { + if (PluginState.STOPPED == pluginWrapper.getPluginState()) { log.debug("Already stopped plugin '{}:{}'", pluginDescriptor.getPluginId(), pluginDescriptor.getVersion()); return PluginState.STOPPED; } // test for disabled plugin - if (isPluginDisabled(pluginDescriptor.getPluginId())) { + if (PluginState.DISABLED == pluginWrapper.getPluginState()) { // do nothing return pluginWrapper.getPluginState(); } @@ -369,7 +353,7 @@ public class DefaultPluginManager implements PluginManager { public boolean unloadPlugin(String pluginId) { try { PluginState state = stopPlugin(pluginId); - if (!PluginState.STOPPED.equals(state)) { + if (PluginState.STOPPED != state) { return false; } @@ -391,13 +375,13 @@ public class DefaultPluginManager implements PluginManager { // remove the classloader if (pluginClassLoaders.containsKey(pluginId)) { PluginClassLoader classLoader = pluginClassLoaders.remove(pluginId); - compoundClassLoader.removeLoader(classLoader); try { classLoader.close(); } catch (IOException e) { log.error(e.getMessage(), e); } } + return true; } catch (IllegalArgumentException e) { // ignore not found exceptions because this method is recursive @@ -408,18 +392,34 @@ public class DefaultPluginManager implements PluginManager { @Override public boolean disablePlugin(String pluginId) { - if (plugins.containsKey(pluginId)) { - log.debug("Unloading plugin {}", pluginId); - unloadPlugin(pluginId); + if (!plugins.containsKey(pluginId)) { + throw new IllegalArgumentException(String.format("Unknown pluginId %s", pluginId)); } - if (disabledPlugins.add(pluginId)) { - try { - FileUtils.writeLines(disabledPlugins, new File(pluginsDirectory, "disabled.txt")); - return true; - } catch (IOException e) { - log.error("Failed to disable plugin {}", pluginId, e); + + PluginWrapper pluginWrapper = plugins.get(pluginId); + PluginDescriptor pluginDescriptor = pluginWrapper.getDescriptor(); + + if (PluginState.DISABLED == getPlugin(pluginId).getPluginState()) { + log.debug("Already disabled plugin '{}:{}'", pluginDescriptor.getPluginId(), pluginDescriptor.getVersion()); + return true; + } + + if (PluginState.STOPPED == stopPlugin(pluginId)) { + getPlugin(pluginId).setPluginState(PluginState.DISABLED); + extensionFinder.reset(); + + if (disabledPlugins.add(pluginId)) { + try { + FileUtils.writeLines(disabledPlugins, new File(pluginsDirectory, "disabled.txt")); + } catch (IOException e) { + log.error("Failed to disable plugin {}", pluginId, e); + return false; + } } + log.info("Disabled plugin '{}:{}'", pluginDescriptor.getPluginId(), pluginDescriptor.getVersion()); + + return true; } return false; @@ -427,19 +427,33 @@ public class DefaultPluginManager implements PluginManager { @Override public boolean enablePlugin(String pluginId) { - if (!disabledPlugins.remove(pluginId)) { - log.debug("Plugin {} was not disabled", pluginId); + if (!plugins.containsKey(pluginId)) { + throw new IllegalArgumentException(String.format("Unknown pluginId %s", pluginId)); + } + + PluginWrapper pluginWrapper = plugins.get(pluginId); + PluginDescriptor pluginDescriptor = pluginWrapper.getDescriptor(); + + if (PluginState.DISABLED != getPlugin(pluginId).getPluginState()) { + log.debug("Plugin plugin '{}:{}' is not disabled", pluginDescriptor.getPluginId(), pluginDescriptor.getVersion()); return true; } try { - FileUtils.writeLines(disabledPlugins, new File(pluginsDirectory, "disabled.txt")); - return true; + if (disabledPlugins.remove(pluginId)) { + FileUtils.writeLines(disabledPlugins, new File(pluginsDirectory, "disabled.txt")); + } } catch (IOException e) { log.error("Failed to enable plugin {}", pluginId, e); + return false; } - return false; + getPlugin(pluginId).setPluginState(PluginState.CREATED); + extensionFinder.reset(); + + log.info("Enabled plugin '{}:{}'", pluginDescriptor.getPluginId(), pluginDescriptor.getVersion()); + + return true; } @Override @@ -506,6 +520,11 @@ public class DefaultPluginManager implements PluginManager { return extensions; } + @Override + public Set getExtensionClassNames(String pluginId) { + return extensionFinder.findClassNames(pluginId); + } + @Override public RuntimeMode getRuntimeMode() { if (runtimeMode == null) { @@ -552,7 +571,7 @@ public class DefaultPluginManager implements PluginManager { * Add the possibility to override the ExtensionFinder. */ protected ExtensionFinder createExtensionFinder() { - return new DefaultExtensionFinder(compoundClassLoader); + return new DefaultExtensionFinder(this); } /** @@ -612,7 +631,6 @@ public class DefaultPluginManager implements PluginManager { resolvedPlugins = new ArrayList(); startedPlugins = new ArrayList(); disabledPlugins = new ArrayList(); - compoundClassLoader = new CompoundClassLoader(); pluginClasspath = createPluginClasspath(); pluginDescriptorFinder = createPluginDescriptorFinder(); @@ -660,13 +678,13 @@ public class DefaultPluginManager implements PluginManager { log.debug("Creating wrapper for plugin '{}'", pluginPath); PluginWrapper pluginWrapper = new PluginWrapper(pluginDescriptor, pluginPath, pluginLoader.getPluginClassLoader()); pluginWrapper.setRuntimeMode(getRuntimeMode()); - /* + // test for disabled plugin if (isPluginDisabled(pluginDescriptor.getPluginId())) { log.info("Plugin '{}' is disabled", pluginPath); pluginWrapper.setPluginState(PluginState.DISABLED); } - */ + log.debug("Created wrapper '{}' for plugin '{}'", pluginWrapper, pluginPath); String pluginId = pluginDescriptor.getPluginId(); @@ -717,7 +735,6 @@ public class DefaultPluginManager implements PluginManager { resolvedPlugins = dependencyResolver.getSortedPlugins(); for (PluginWrapper pluginWrapper : resolvedPlugins) { unresolvedPlugins.remove(pluginWrapper); - compoundClassLoader.addLoader(pluginWrapper.getPluginClassLoader()); log.info("Plugin '{}' resolved", pluginWrapper.getDescriptor().getPluginId()); } } diff --git a/pf4j/src/main/java/ro/fortsoft/pf4j/ExtensionFinder.java b/pf4j/src/main/java/ro/fortsoft/pf4j/ExtensionFinder.java index 7e22a4a..c518566 100644 --- a/pf4j/src/main/java/ro/fortsoft/pf4j/ExtensionFinder.java +++ b/pf4j/src/main/java/ro/fortsoft/pf4j/ExtensionFinder.java @@ -13,14 +13,23 @@ package ro.fortsoft.pf4j; import java.util.List; +import java.util.Set; /** * @author Decebal Suiu */ public interface ExtensionFinder { - public List> find(Class type); + /** + * Retrieves a list with all extensions found for an extension point. + */ + public List> find(Class type); - public void reset(); + /** + * Retrieves a list with all extension class names found for a plugin. + */ + public Set findClassNames(String pluginId); + + public void reset(); } diff --git a/pf4j/src/main/java/ro/fortsoft/pf4j/PluginManager.java b/pf4j/src/main/java/ro/fortsoft/pf4j/PluginManager.java index 4173c2b..36defe5 100644 --- a/pf4j/src/main/java/ro/fortsoft/pf4j/PluginManager.java +++ b/pf4j/src/main/java/ro/fortsoft/pf4j/PluginManager.java @@ -14,6 +14,7 @@ package ro.fortsoft.pf4j; import java.io.File; import java.util.List; +import java.util.Set; /** * Provides the functionality for plugin management such as load, @@ -123,7 +124,9 @@ public interface PluginManager { public List getExtensions(Class type); - /** + public Set getExtensionClassNames(String pluginId); + + /** * The runtime mode. Must currently be either DEVELOPMENT or DEPLOYMENT. */ public RuntimeMode getRuntimeMode(); diff --git a/pf4j/src/main/java/ro/fortsoft/pf4j/PluginState.java b/pf4j/src/main/java/ro/fortsoft/pf4j/PluginState.java index 06d7815..207e436 100644 --- a/pf4j/src/main/java/ro/fortsoft/pf4j/PluginState.java +++ b/pf4j/src/main/java/ro/fortsoft/pf4j/PluginState.java @@ -18,12 +18,9 @@ package ro.fortsoft.pf4j; public class PluginState { public static final PluginState CREATED = new PluginState("CREATED"); -// public static final PluginState INITIALIZED = new PluginState("INITIALIZED"); -// public static final PluginState DISABLED = new PluginState("DISABLED"); + public static final PluginState DISABLED = new PluginState("DISABLED"); public static final PluginState STARTED = new PluginState("STARTED"); public static final PluginState STOPPED = new PluginState("STOPPED"); -// public static final PluginState DESTROYED = new PluginState("DESTROYED"); -// public static final PluginState FAILED = new PluginState("FAILED"); private String status; diff --git a/pf4j/src/main/java/ro/fortsoft/pf4j/PluginWrapper.java b/pf4j/src/main/java/ro/fortsoft/pf4j/PluginWrapper.java index d307cf0..b2ab37d 100644 --- a/pf4j/src/main/java/ro/fortsoft/pf4j/PluginWrapper.java +++ b/pf4j/src/main/java/ro/fortsoft/pf4j/PluginWrapper.java @@ -1,11 +1,11 @@ /* * Copyright 2012 Decebal Suiu - * + * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this work except in compliance with * the License. You may obtain a copy of the License in the LICENSE file, or at: - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. @@ -28,22 +28,22 @@ public class PluginWrapper { Plugin plugin; PluginState pluginState; RuntimeMode runtimeMode; - + public PluginWrapper(PluginDescriptor descriptor, String pluginPath, PluginClassLoader pluginClassLoader) { this.descriptor = descriptor; this.pluginPath = pluginPath; this.pluginClassLoader = pluginClassLoader; - + // TODO try { plugin = createPluginInstance(); } catch (Exception e) { e.printStackTrace(); } - + pluginState = PluginState.CREATED; } - + /** * Returns the plugin descriptor. */ @@ -79,12 +79,19 @@ public class PluginWrapper { return runtimeMode; } + /** + * Shortcut + */ + public String getPluginId() { + return getDescriptor().getPluginId(); + } + @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + descriptor.getPluginId().hashCode(); - + return result; } @@ -93,20 +100,20 @@ public class PluginWrapper { if (this == obj) { return true; } - + if (obj == null) { return false; } - + if (getClass() != obj.getClass()) { return false; } - + PluginWrapper other = (PluginWrapper) obj; if (!descriptor.getPluginId().equals(other.descriptor.getPluginId())) { return false; } - + return true; } @@ -119,7 +126,7 @@ public class PluginWrapper { void setPluginState(PluginState pluginState) { this.pluginState = pluginState; } - + void setRuntimeMode(RuntimeMode runtimeMode) { this.runtimeMode = runtimeMode; } diff --git a/pf4j/src/main/java/ro/fortsoft/pf4j/util/PluginUtils.java b/pf4j/src/main/java/ro/fortsoft/pf4j/util/PluginUtils.java new file mode 100644 index 0000000..bfe6287 --- /dev/null +++ b/pf4j/src/main/java/ro/fortsoft/pf4j/util/PluginUtils.java @@ -0,0 +1,37 @@ +/* + * Copyright 2014 Decebal Suiu + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this work except in compliance with + * the License. You may obtain a copy of the License in the LICENSE file, or at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ +package ro.fortsoft.pf4j.util; + +import ro.fortsoft.pf4j.PluginManager; +import ro.fortsoft.pf4j.PluginState; +import ro.fortsoft.pf4j.PluginWrapper; + +import java.util.List; + +/** + * @author Decebal Suiu + */ +public class PluginUtils { + + public static boolean isPluginStarted(PluginManager pluginManager, String pluginId) { + List startedPlugins = pluginManager.getStartedPlugins(); + for (PluginWrapper plugin: startedPlugins) { + if (pluginId.equals(plugin.getPluginId())) { + return PluginState.STARTED == plugin.getPluginState(); + } + } + + return false; + } + +}