org.restheart.plugins.PluginsScanner Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of restheart Show documentation
Show all versions of restheart Show documentation
RESTHeart Core - Core services for RESTHeart
/*-
* ========================LICENSE_START=================================
* restheart-core
* %%
* Copyright (C) 2014 - 2024 SoftInstigate
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see }
*/
public class PluginsScanner {
private static final String REGISTER_PLUGIN_CLASS_NAME = RegisterPlugin.class.getName();
private static final String INITIALIZER_CLASS_NAME = Initializer.class.getName();
private static final String AUTHMECHANISM_CLASS_NAME = AuthMechanism.class.getName();
private static final String AUTHORIZER_CLASS_NAME = Authorizer.class.getName();
private static final String TOKEN_MANAGER_CLASS_NAME = TokenManager.class.getName();
private static final String AUTHENTICATOR_CLASS_NAME = Authenticator.class.getName();
private static final String INTERCEPTOR_CLASS_NAME = Interceptor.class.getName();
private static final String SERVICE_CLASS_NAME = Service.class.getName();
private static final String PROVIDER_CLASS_NAME = Provider.class.getName();
private static final ArrayList INITIALIZERS = new ArrayList<>();
private static final ArrayList AUTH_MECHANISMS = new ArrayList<>();
private static final ArrayList AUTHORIZERS = new ArrayList<>();
private static final ArrayList TOKEN_MANAGERS = new ArrayList<>();
private static final ArrayList AUTHENTICATORS = new ArrayList<>();
private static final ArrayList INTERCEPTORS = new ArrayList<>();
private static final ArrayList SERVICES = new ArrayList<>();
private static final ArrayList PROVIDERS = new ArrayList<>();
// ClassGraph.scan() at class initialization time to support native image
// generation with GraalVM
// see https://github.com/SoftInstigate/classgraph-on-graalvm
static {
ClassGraph classGraph;
RuntimeClassGraph rtcg = null;
if (ImageInfo.inImageBuildtimeCode()) {
// initizialize PluginsClassloader with the URL of restheart.jar uber jar
// during build time the class this class is loaded by
var jarPath = PluginsScanner.class.getProtectionDomain().getCodeSource().getLocation().getPath();
try {
var jarFile = new File(jarPath);
var jarURL = jarFile.toURI().toURL();
URL[] urls = { jarURL };
PluginsClassloader.init(urls);
} catch(MalformedURLException mue) {
System.err.println("Error initilizing PluginsClassloader on restheart uber jar " + jarPath + ". Exception: " + mue.getMessage());
}
classGraph = new ClassGraph()
.disableDirScanning() // added for GraalVM
.disableNestedJarScanning() // added for GraalVM
.disableRuntimeInvisibleAnnotations() // added for GraalVM
.overrideClassLoaders(PluginsClassloader.getInstance()) // added for GraalVM. Mandatory, otherwise build fails
.ignoreParentClassLoaders()
.enableAnnotationInfo().enableMethodInfo().enableFieldInfo().ignoreFieldVisibility().initializeLoadedClasses();
} else {
rtcg = new RuntimeClassGraph();
classGraph = rtcg.get();
// apply plugins-scanning-verbose configuration option
classGraph = classGraph.verbose(Bootstrapper.getConfiguration().coreModule().pluginsScanningVerbose());
// apply plugins-packages configuration option
var pluginsPackages = Bootstrapper.getConfiguration().coreModule().pluginsPackages();
if (!Bootstrapper.getConfiguration().coreModule().pluginsPackages().isEmpty()) {
classGraph = classGraph.acceptPackages(pluginsPackages.toArray(String[]::new));
}
rtcg.logStartScan();
}
try (var scanResult = classGraph.scan(Runtime.getRuntime().availableProcessors())) {
INITIALIZERS.addAll(collectPlugins(scanResult, INITIALIZER_CLASS_NAME));
AUTH_MECHANISMS.addAll(collectPlugins(scanResult, AUTHMECHANISM_CLASS_NAME));
AUTHORIZERS.addAll(collectPlugins(scanResult, AUTHORIZER_CLASS_NAME));
TOKEN_MANAGERS.addAll(collectPlugins(scanResult, TOKEN_MANAGER_CLASS_NAME));
AUTHENTICATORS.addAll(collectPlugins(scanResult, AUTHENTICATOR_CLASS_NAME));
INTERCEPTORS.addAll(collectPlugins(scanResult, INTERCEPTOR_CLASS_NAME));
SERVICES.addAll(collectPlugins(scanResult, SERVICE_CLASS_NAME));
PROVIDERS.addAll(collectProviders(scanResult));
}
if (rtcg != null) {
rtcg.logEndScan();
}
}
public static List allPluginsClassNames() {
var ret = new ArrayList();
INITIALIZERS.stream().map(p -> p.clazz()).forEachOrdered(ret::add);
AUTH_MECHANISMS.stream().map(p -> p.clazz()).forEachOrdered(ret::add);
AUTHORIZERS.stream().map(p -> p.clazz()).forEachOrdered(ret::add);
TOKEN_MANAGERS.stream().map(p -> p.clazz()).forEachOrdered(ret::add);
AUTHENTICATORS.stream().map(p -> p.clazz()).forEachOrdered(ret::add);
INTERCEPTORS.stream().map(p -> p.clazz()).forEachOrdered(ret::add);
SERVICES.stream().map(p -> p.clazz()).forEachOrdered(ret::add);
PROVIDERS.stream().map(p -> p.clazz()).forEachOrdered(ret::add);
return ret;
}
static final List providers() {
return PROVIDERS;
}
static final List initializers() {
return INITIALIZERS;
}
static final List authMechanisms() {
return AUTH_MECHANISMS;
}
static final List authorizers() {
return AUTHORIZERS;
}
static final List tokenManagers() {
return TOKEN_MANAGERS;
}
static final List authenticators() {
return AUTHENTICATORS;
}
static final List interceptors() {
return INTERCEPTORS;
}
static final List services() {
return SERVICES;
}
/**
* @param type the class of the plugin , e.g. Initializer.class
*/
private static List collectPlugins(ScanResult scanResult, String className) {
var ret = new ArrayList();
var registeredPlugins = scanResult.getClassesWithAnnotation(REGISTER_PLUGIN_CLASS_NAME);
if (registeredPlugins == null || registeredPlugins.isEmpty()) {
return ret;
}
ClassInfoList listOfType;
if (className.equals(AUTHENTICATOR_CLASS_NAME)) {
var tms = scanResult.getClassesImplementing(TOKEN_MANAGER_CLASS_NAME);
listOfType = scanResult.getClassesImplementing(className).exclude(tms);
} else {
listOfType = scanResult.getClassesImplementing(className);
}
var plugins = registeredPlugins.intersect(listOfType);
return plugins.stream().map(c -> descriptor(c)).collect(Collectors.toList());
}
/**
*
*/
private static List collectProviders(ScanResult scanResult) {
var ret = new ArrayList();
var providers = scanResult.getClassesImplementing(PROVIDER_CLASS_NAME);
if (providers == null || providers.isEmpty()) {
return ret;
}
return providers.stream().map(c -> descriptor(c)).collect(Collectors.toList());
}
private static PluginDescriptor descriptor(ClassInfo pluginClassInfo) {
var clazz = pluginClassInfo.getName();
var name = pluginClassInfo.getAnnotationInfo(REGISTER_PLUGIN_CLASS_NAME).getParameterValues().stream()
.filter(p -> "name".equals(p.getName())).map(p -> p.getValue()).findAny().get().toString();
return new PluginDescriptor(name, clazz, isEnabled(name, pluginClassInfo), collectInjections(pluginClassInfo));
}
private static ArrayList collectInjections(ClassInfo pluginClassInfo) {
var ret = new ArrayList();
ret.addAll(collectFieldInjections(pluginClassInfo, Inject.class));
ret.addAll(collectMethodInjections(pluginClassInfo, OnInit.class));
return ret;
}
/**
* NOTE:returns true at build time, to force native compilation of
* all plugins
*
* @param name
* @param pluginClassInfo
* @return true if the plugin is enabled, taking into account enabledByDefault and its configuration
*/
private static boolean isEnabled(String name, ClassInfo pluginClassInfo) {
if (ImageInfo.inImageBuildtimeCode()) {
return true;
} else {
var isEnabledByDefault = (boolean) pluginClassInfo.getAnnotationInfo(REGISTER_PLUGIN_CLASS_NAME).getParameterValues().stream()
.filter(p -> "enabledByDefault".equals(p.getName())).map(p -> p.getValue()).findAny().get();
Map confArgs = Bootstrapper.getConfiguration().getOrDefault(name, null);
return PluginRecord.isEnabled(isEnabledByDefault, confArgs);
}
}
private static ArrayList collectMethodInjections(ClassInfo pluginClassInfo, Class clazz) {
var ret = new ArrayList();
var mil = pluginClassInfo.getDeclaredMethodInfo();
for (var mi : mil) {
if (mi.hasAnnotation(clazz.getName())) {
ArrayList> annotationParams = new ArrayList<>();
for (var p : mi.getAnnotationInfo(clazz.getName()).getParameterValues()) {
var value = p.getValue();
if (value instanceof AnnotationEnumValue annotationEnumValue) {
removeRefToScanResult(annotationEnumValue);
}
annotationParams.add(new AbstractMap.SimpleEntry<>(p.getName(), value));
}
var methodParams = new ArrayList();
Arrays.stream(mi.getParameterInfo()).forEachOrdered(pi -> methodParams.add(pi.getTypeDescriptor().toString()));
ret.add(new MethodInjectionDescriptor(mi.getName(), clazz, annotationParams, methodParams, mi.hashCode()));
}
}
return ret;
}
private static ArrayList collectFieldInjections(ClassInfo pluginClassInfo, Class clazz) {
var ret = new ArrayList();
var fil = pluginClassInfo.getDeclaredFieldInfo();
for (var fi : fil) {
if (fi.hasAnnotation(clazz.getName())) {
var annotationParams = new ArrayList>();
for (var p : fi.getAnnotationInfo(clazz.getName()).getParameterValues()) {
var value = p.getValue();
if (value instanceof AnnotationEnumValue annotationEnumValue) {
removeRefToScanResult(annotationEnumValue);
}
annotationParams.add(new AbstractMap.SimpleEntry<>(p.getName(), value));
}
try {
var fieldClass = PluginsClassloader.getInstance().loadClass(fi.getTypeDescriptor().toString());
ret.add(new FieldInjectionDescriptor(fi.getName(), fieldClass, annotationParams, fi.hashCode()));
} catch(ClassNotFoundException cnfe) {
// should not happen
throw new RuntimeException(cnfe);
}
}
}
return ret;
}
/**
* this removes the reference to scanResult in the annotation info
* otherwise the huge object won't be garbage collected
*
* @param obj
*/
private static void removeRefToScanResult(AnnotationEnumValue obj) {
try {
var f = AnnotationEnumValue.class.getSuperclass().getDeclaredField("scanResult");
f.setAccessible(true);
f.set(obj, null);
} catch (IllegalAccessException | IllegalArgumentException | NoSuchFieldException | SecurityException ex) {
// nothing to do
}
}
static class RuntimeClassGraph {
private static final Logger LOGGER = LoggerFactory.getLogger(PluginsScanner.class);
private final ClassGraph classGraph;
URL[] jars = null;
public RuntimeClassGraph() {
var pdir = getPluginsDirectory();
this.jars = findPluginsJars(pdir);
if (!PluginsClassloader.isInitialized()) {
PluginsClassloader.init(jars);
}
this.classGraph = new ClassGraph().disableModuleScanning().disableDirScanning()
.disableNestedJarScanning().disableRuntimeInvisibleAnnotations()
.addClassLoader(PluginsClassloader.getInstance()).addClassLoader(ClassLoader.getSystemClassLoader())
.enableAnnotationInfo().enableMethodInfo().enableFieldInfo().ignoreFieldVisibility().initializeLoadedClasses();
}
private long starScanTime = 0;
private long endScanTime = 0;
public void logStartScan() {
LOGGER.info("Scanning jars for plugins started");
this.starScanTime = System.currentTimeMillis();
}
public void logEndScan() {
this.endScanTime = System.currentTimeMillis();
LOGGER.info("Scanning jars for plugins completed in {} msec", endScanTime-starScanTime);
}
public ClassGraph get() {
return this.classGraph;
}
private Path getPluginsDirectory() {
var pluginsDir = Bootstrapper.getConfiguration().coreModule().pluginsDirectory();
if (pluginsDir == null) {
return null;
}
if (pluginsDir.startsWith("/")) {
return Paths.get(pluginsDir);
} else {
// this is to allow specifying the plugins directory path
// relative to the jar (also working when running from classes)
var location = PluginsFactory.class.getProtectionDomain().getCodeSource().getLocation();
try {
var decodedLocation = URLDecoder.decode(location.getPath(), StandardCharsets.UTF_8.toString());
var locationFile = new File(decodedLocation);
pluginsDir = locationFile.getParent() + File.separator + pluginsDir;
return FileSystems.getDefault().getPath(pluginsDir);
} catch(UnsupportedEncodingException uee) {
Assert.assertShouldNeverHappen();
throw new RuntimeException(uee);
}
}
}
private URL[] findPluginsJars(Path pluginsDirectory) {
return _findPluginsJars(pluginsDirectory, 0);
}
private URL[] _findPluginsJars(Path dir, int depth) {
var pluginsPackages = Bootstrapper.getConfiguration().coreModule().pluginsPackages();
if (!pluginsPackages.isEmpty()) {
LOGGER.info("Limiting the scanning of plugins to packages {}", pluginsPackages);
}
if (dir == null) {
return new URL[0];
} else {
try {
checkPluginDirectory(dir);
} catch(IllegalStateException ise) {
return new URL[0];
}
}
var urls = new ArrayList();
try (var ds = Files.newDirectoryStream(dir, "*.jar")) {
for (Path path : ds) {
var jar = path.toUri().toURL();
if (!Files.isReadable(path)) {
LOGGER.error("Plugin jar {} is not readable", jar);
throw new IllegalStateException("Plugin jar " + jar + " is not readable");
}
urls.add(jar);
LOGGER.info("Found plugin jar {}", URLDecoder.decode(jar.getPath(), StandardCharsets.UTF_8.toString()));
}
} catch (IOException ex) {
LOGGER.error("Cannot read jars in plugins directory {}", Bootstrapper.getConfiguration().coreModule().pluginsDirectory(), ex.getMessage());
}
// Scans the plugins directory up to two levels deep
if (depth < 2) {
try (var ds = Files.newDirectoryStream(dir, (Filter) (Path entry) -> Files.isDirectory(entry))) {
for (Path subdir : ds) {
if (Files.isReadable(subdir)) {
var subjars = _findPluginsJars(subdir, depth + 1);
if (subjars != null && subjars.length > 0) {
Arrays.stream(subjars).forEach(jar -> urls.add(jar));
}
} else {
LOGGER.warn("Subdirectory {} of plugins directory {} is not readable", subdir, Bootstrapper.getConfiguration().coreModule().pluginsDirectory());
}
}
} catch (IOException ex) {
LOGGER.error("Cannot read jars in plugins subdirectory", ex.getMessage());
}
}
return urls.toArray(URL[]::new);
}
private void checkPluginDirectory(Path pluginsDirectory) {
if (!Files.exists(pluginsDirectory)) {
LOGGER.warn("Plugin directory {} does not exist", pluginsDirectory);
throw new IllegalStateException("Plugins directory " + pluginsDirectory + " does not exist");
}
if (!Files.isReadable(pluginsDirectory)) {
LOGGER.warn("Plugin directory {} is not readable", pluginsDirectory);
throw new IllegalStateException("Plugins directory " + pluginsDirectory + " is not readable");
}
}
}
}
record PluginDescriptor(String name, String clazz, boolean enabled, ArrayList injections) {}
interface InjectionDescriptor {}
record MethodInjectionDescriptor(String method, Class clazz, ArrayList> annotationParams, ArrayList methodParams, int methodHash) implements InjectionDescriptor {}
record FieldInjectionDescriptor(String field, Class clazz, ArrayList> annotationParams, int fieldHash) implements InjectionDescriptor {}