package ro.fortsoft.pf4j.demo;\r
\r
import java.util.List;\r
+import java.util.Set;\r
\r
import org.apache.commons.lang.StringUtils;\r
\r
import ro.fortsoft.pf4j.DefaultPluginManager;\r
import ro.fortsoft.pf4j.PluginManager;\r
+import ro.fortsoft.pf4j.PluginWrapper;\r
import ro.fortsoft.pf4j.demo.api.Greeting;\r
\r
/**\r
public class Boot {\r
\r
public static void main(String[] args) {\r
- // print logo\r
- printLogo();\r
+ // print logo\r
+ printLogo();\r
\r
- // create the plugin manager\r
+ // create the plugin manager\r
final PluginManager pluginManager = new DefaultPluginManager();\r
\r
// load the plugins\r
pluginManager.loadPlugins();\r
\r
// enable a disabled plugin\r
- pluginManager.enablePlugin("welcome-plugin");\r
+// pluginManager.enablePlugin("welcome-plugin");\r
\r
// start (active/resolved) the plugins\r
pluginManager.startPlugins();\r
\r
// retrieves the extensions for Greeting extension point\r
List<Greeting> greetings = pluginManager.getExtensions(Greeting.class);\r
- System.out.println(String.format("### Found %d extensions for the extension point '%s'", greetings.size(), Greeting.class.getName()));\r
+ System.out.println(String.format("Found %d extensions for extension point '%s'", greetings.size(), Greeting.class.getName()));\r
for (Greeting greeting : greetings) {\r
- System.out.println(">>> " + greeting.getGreeting());\r
+ System.out.println(">>> " + greeting.getGreeting());\r
+ }\r
+\r
+ // print extensions for each started plugin\r
+ List<PluginWrapper> startedPlugins = pluginManager.getStartedPlugins();\r
+ for (PluginWrapper plugin : startedPlugins) {\r
+ String pluginId = plugin.getDescriptor().getPluginId();\r
+ System.out.println(String.format("Extensions added by plugin '%s':", pluginId));\r
+ Set<String> extensionClassNames = pluginManager.getExtensionClassNames(pluginId);\r
+ for (String extension : extensionClassNames) {\r
+ System.out.println(" " + extension);\r
+ }\r
}\r
\r
// stop the plugins\r
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;
private static final Logger log = LoggerFactory.getLogger(DefaultExtensionFinder.class);
- private ClassLoader classLoader;
+ private PluginManager pluginManager;
private ExtensionFactory extensionFactory;
- private volatile Set<String> entries;
+ private volatile Map<String, Set<String>> 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 <T> List<ExtensionWrapper<T>> find(Class<T> type) {
log.debug("Checking extension point '{}'", type.getName());
if (!isExtensionPoint(type)) {
}
log.debug("Finding extensions for extension point '{}'", type.getName());
- List<ExtensionWrapper<T>> result = new ArrayList<ExtensionWrapper<T>>();
- 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<T>(type.cast(instance), extension.ordinal()));
+ List<ExtensionWrapper<T>> result = new ArrayList<ExtensionWrapper<T>>();
+ for (Map.Entry<String, Set<String>> entry : entries.entrySet()) {
+ String pluginId = entry.getKey();
+ Set<String> 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<T>(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()) {
return result;
}
- /**
+ @Override
+ public Set<String> 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.
*/
};
}
- private Set<String> readIndexFiles() {
- log.debug("Reading extensions index files");
- Set<String> entries = new HashSet<String>();
+ private Map<String, Set<String>> readIndexFiles() {
+ // checking cache
+ if (entries != null) {
+ return entries;
+ }
- try {
- Enumeration<URL> 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<String, Set<String>>();
+
+ List<PluginWrapper> startedPlugins = pluginManager.getStartedPlugins();
+ for (PluginWrapper plugin : startedPlugins) {
+ String pluginId = plugin.getDescriptor().getPluginId();
+ log.debug("Reading extensions index file for plugin '{}'", pluginId);
+ Set<String> entriesPerPlugin = new HashSet<String>();
+
+ 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);
*/
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.
private List<String> enabledPlugins;
private List<String> 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.
// 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;
}
@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);
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()) {
Iterator<PluginWrapper> 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);
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();
}
public boolean unloadPlugin(String pluginId) {
try {
PluginState state = stopPlugin(pluginId);
- if (!PluginState.STOPPED.equals(state)) {
+ if (PluginState.STOPPED != state) {
return false;
}
// 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
@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;
@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
return extensions;
}
+ @Override
+ public Set<String> getExtensionClassNames(String pluginId) {
+ return extensionFinder.findClassNames(pluginId);
+ }
+
@Override
public RuntimeMode getRuntimeMode() {
if (runtimeMode == null) {
* Add the possibility to override the ExtensionFinder.
*/
protected ExtensionFinder createExtensionFinder() {
- return new DefaultExtensionFinder(compoundClassLoader);
+ return new DefaultExtensionFinder(this);
}
/**
resolvedPlugins = new ArrayList<PluginWrapper>();
startedPlugins = new ArrayList<PluginWrapper>();
disabledPlugins = new ArrayList<String>();
- compoundClassLoader = new CompoundClassLoader();
pluginClasspath = createPluginClasspath();
pluginDescriptorFinder = createPluginDescriptorFinder();
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();
resolvedPlugins = dependencyResolver.getSortedPlugins();
for (PluginWrapper pluginWrapper : resolvedPlugins) {
unresolvedPlugins.remove(pluginWrapper);
- compoundClassLoader.addLoader(pluginWrapper.getPluginClassLoader());
log.info("Plugin '{}' resolved", pluginWrapper.getDescriptor().getPluginId());
}
}
package ro.fortsoft.pf4j;
import java.util.List;
+import java.util.Set;
/**
* @author Decebal Suiu
*/
public interface ExtensionFinder {
- public <T> List<ExtensionWrapper<T>> find(Class<T> type);
+ /**
+ * Retrieves a list with all extensions found for an extension point.
+ */
+ public <T> List<ExtensionWrapper<T>> find(Class<T> type);
- public void reset();
+ /**
+ * Retrieves a list with all extension class names found for a plugin.
+ */
+ public Set<String> findClassNames(String pluginId);
+
+ public void reset();
}
import java.io.File;
import java.util.List;
+import java.util.Set;
/**
* Provides the functionality for plugin management such as load,
public <T> List<T> getExtensions(Class<T> type);
- /**
+ public Set<String> getExtensionClassNames(String pluginId);
+
+ /**
* The runtime mode. Must currently be either DEVELOPMENT or DEPLOYMENT.
*/
public RuntimeMode getRuntimeMode();
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;
/*
* 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.
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.
*/
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;
}
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;
}
void setPluginState(PluginState pluginState) {
this.pluginState = pluginState;
}
-
+
void setRuntimeMode(RuntimeMode runtimeMode) {
this.runtimeMode = runtimeMode;
}
--- /dev/null
+/*
+ * 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<PluginWrapper> startedPlugins = pluginManager.getStartedPlugins();
+ for (PluginWrapper plugin: startedPlugins) {
+ if (pluginId.equals(plugin.getPluginId())) {
+ return PluginState.STARTED == plugin.getPluginState();
+ }
+ }
+
+ return false;
+ }
+
+}
projects / pf4j.git / commitdiff