@Override protected PluginRepository createPluginRepository() { return new CompoundPluginRepository() .add(new DefaultPluginRepository(getPluginsRoot(), isDevelopment())) .add(new JarPluginRepository(getPluginsRoot())); }
@Override protected PluginLoader createPluginLoader() { return new CompoundPluginLoader() .add(new DefaultPluginLoader(this, pluginClasspath)) .add(new JarPluginLoader(this)); }
@Override protected PluginDescriptorFinder createPluginDescriptorFinder() { return new CompoundPluginDescriptorFinder() .add(new PropertiesPluginDescriptorFinder()) .add(new ManifestPluginDescriptorFinder()); }
@Override protected void initialize() { pluginClasspath = createPluginClasspath(); super.initialize(); if (isDevelopment()) { addPluginStateListener(new LoggingPluginStateListener()); } log.info("PF4J version {} in '{}' mode", getVersion(), getRuntimeMode()); }
private ExtensionWrapper createExtensionWrapper(Class<?> extensionClass) { int ordinal = 0; if (extensionClass.isAnnotationPresent(Extension.class)) { ordinal = extensionClass.getAnnotation(Extension.class).ordinal(); } ExtensionDescriptor descriptor = new ExtensionDescriptor(ordinal, extensionClass); return new ExtensionWrapper<>(descriptor, pluginManager.getExtensionFactory()); }
public DevelopmentPluginClasspath() { addClassesDirectories(MAVEN.getClassesDirectories()); addClassesDirectories(GRADLE.getClassesDirectories()); addClassesDirectories(KOTLIN.getClassesDirectories()); addLibDirectories(MAVEN.getLibDirectories()); addLibDirectories(GRADLE.getLibDirectories()); addLibDirectories(KOTLIN.getLibDirectories()); }
/** * Shortcut */ public String getPluginId() { return getDescriptor().getPluginId(); }
/** * The plugin label is used in logging and it's a string in format {@code pluginId@pluginVersion}. */ protected String getPluginLabel(PluginDescriptor pluginDescriptor) { return pluginDescriptor.getPluginId() + "@" + pluginDescriptor.getVersion(); }
/** * By default if {@link DefaultPluginManager#isDevelopment()} returns true * than a {@link DevelopmentPluginClasspath} is returned * else this method returns {@link DefaultPluginClasspath}. */ protected PluginClasspath createPluginClasspath() { return isDevelopment() ? new DevelopmentPluginClasspath() : new DefaultPluginClasspath(); }
@Override public String toString() { return "PluginStateEvent [plugin=" + plugin.getPluginId() + ", newState=" + getPluginState() + ", oldState=" + oldState + ']'; }
@Override public ClassLoader loadPlugin(Path pluginPath, PluginDescriptor pluginDescriptor) { PluginClassLoader pluginClassLoader = createPluginClassLoader(pluginPath, pluginDescriptor); loadClasses(pluginPath, pluginClassLoader); loadJars(pluginPath, pluginClassLoader); return pluginClassLoader; }
public DefaultExtensionFinder(PluginManager pluginManager) { this.pluginManager = pluginManager; add(new LegacyExtensionFinder(pluginManager)); // add(new ServiceProviderExtensionFinder(pluginManager)); }
@Override protected ExtensionFinder createExtensionFinder() { DefaultExtensionFinder extensionFinder = new DefaultExtensionFinder(this); addPluginStateListener(extensionFinder); return extensionFinder; }
public DefaultPluginClasspath() { super(); addClassesDirectories("classes"); addLibDirectories("lib"); }
@Override public PluginDescriptor find(Path pluginPath) throws PluginException { Properties properties = readProperties(pluginPath); return createPluginDescriptor(properties); }
@Override public PluginDescriptor find(Path pluginPath) throws PluginException { Manifest manifest = readManifest(pluginPath); return createPluginDescriptor(manifest); }
@Override public boolean deletePluginPath(Path pluginPath) { for (PluginRepository repository : repositories) { if (repository.deletePluginPath(pluginPath)) { return true; } } return false; }
/** * Constructs {@code AbstractPluginManager} with the given plugins root. * * @param pluginsRoot the root to search for plugins */ public AbstractPluginManager(Path pluginsRoot) { this.pluginsRoot = pluginsRoot; initialize(); }
@Override public void pluginStateChanged(PluginStateEvent event) { for (ExtensionFinder finder : finders) { if (finder instanceof PluginStateListener) { ((PluginStateListener) finder).pluginStateChanged(event); } } }
/** * Check if an existing version of dependency is compatible with the required version (from plugin descriptor). * * @param requiredVersion * @param existingVersion * @return */ protected boolean checkDependencyVersion(String requiredVersion, String existingVersion) { return versionManager.checkVersionConstraint(existingVersion, requiredVersion); }