@Override public Collection<Plugin> getPlugins(final PluginPredicate pluginPredicate) { return pluginAccessor.getPlugins(pluginPredicate); }
@Override public Collection<Plugin> getPlugins() { return pluginAccessor.getPlugins(); }
public Collection<Plugin> getPlugins(final Predicate<Plugin> pluginPredicate) { return delegate.getPlugins(pluginPredicate); }
public Collection<Plugin> getPlugins() { return delegate.getPlugins(); }
private Plugin findPlugin( PluginAccessor pluginAccessor ) { for ( Plugin plugin : pluginAccessor.getPlugins( new PluginPredicate() { public boolean matches( Plugin plugin ) { try { Class<?> loadedClass = plugin.loadClass( DefaultOverrideManager.class.getName(), null ); Class<?> myClass = DefaultOverrideManager.class; return loadedClass == myClass; } catch ( ClassNotFoundException e ) { return false; } } } ) ) { return plugin; } return null; }
public static Plugins getPlugins(final PluginAccessor pluginAccessor, final UriBuilder uriBuilder) { final Iterable<PluginDetails> pluginItemIterable = Iterables.transform(pluginAccessor.getPlugins(), new Function<Plugin, PluginDetails>() { public PluginDetails apply(@Nullable Plugin plugin) { return PluginDetails.getMinimalDetails(uriBuilder, pluginAccessor, plugin); } }); return new Plugins(pluginItemIterable); }
/** * Called when the application has started or has been restored from backup */ public void onStart() { addPluginResourceBundles(pluginAccessor.getPlugins()); }
protected List<Plugin> getDisabledPlugins() { final Collection<Plugin> disabledPlugins = pluginAccessor.getPlugins(new PluginPredicate() { @Override public boolean matches(Plugin plugin) { return plugin != null && !pluginAccessor.isPluginEnabled(plugin.getKey()); } }); if (disabledPlugins == null) { return Collections.emptyList(); } final List<Plugin> disabledPluginsList = new ArrayList<Plugin>(disabledPlugins); Collections.sort(disabledPluginsList, new Comparator<Plugin>() { @Override public int compare(Plugin p1, Plugin p2) { return p1.getName().compareTo(p2.getName()); } }); return Collections.unmodifiableList(disabledPluginsList); }
public List<Plugin> getAllExtensionPlugins() { // todo: cache this? List<Plugin> plugins = new ArrayList<Plugin>(); for (Plugin plugin : pluginAccessor.getPlugins()) { for (ModuleDescriptor moduleDescriptor : plugin.getModuleDescriptors()) { if (moduleDescriptor instanceof DescriptorGenerator) { plugins.add(plugin); break; } } } return plugins; }
@Override public PluginInfos getUserPlugins() { final Collection<Plugin> plugins = pluginAccessor.getPlugins(); final Iterable<Plugin> userPlugins = Iterables.filter(plugins, Predicates.not(new SystemPluginPredicate())); return toPluginInfo("User Plugins", userPlugins); }
/** * Run the healthcheck: get disabled plugin keys, except where we think they are meant to be disabled */ @Override List<String> getItemsFailingCheck() { return pluginAccessor.getPlugins((Predicate<Plugin>) plugin -> !pluginIsSupposedToBeDisabled(plugin) && !pluginAccessor.isPluginEnabled(plugin.getKey())) .stream() .map(Plugin::getKey) .sorted() .collect(toList()); }
/** * Run the healthcheck: get keys of disabled-by-default plugins that are actually enabled */ @Override List<String> getItemsFailingCheck() { return pluginAccessor.getPlugins((Predicate<Plugin>) plugin -> !plugin.isEnabledByDefault() && pluginAccessor.isPluginEnabled(plugin.getKey())) .stream() .map(Plugin::getKey) .sorted() .collect(toList()); } }
Set<Intercom4> getRemoteIntercoms() { if ( _remoteIntercoms == null ) { _remoteIntercoms = new java.util.HashSet<Intercom4>(); Collection<Plugin> plugins = pluginAccessor.getPlugins(); Intercom4 intercom; for ( Plugin plugin : plugins ) { intercom = findRemoteIntercom( plugin ); if ( intercom != null ) { registerIntercom( intercom ); } } } return _remoteIntercoms; }
public Collection<Plugin> getPlugins() { final SortedSet<Plugin> plugins = new TreeSet<>(new PluginComparator()); for(Plugin plugin : pluginAccessor.getPlugins()) { if (!plugins.add(plugin)) { throw new IllegalStateException("Multiple plugins with the same key and version:" + plugin.getKey() + " " + plugin.getPluginsVersion()); } } return Collections.unmodifiableSet(plugins); }
private void addPluginsInformation(SupportInfoBuilder builder) { for (Plugin plugin : pluginAccessor.getPlugins()) { addPluginInformation(builder.addCategory(PLUGINS_PLUGIN), plugin); } }
@Override public PluginInfos getSystemPlugins(boolean includeBuiltInPlugins) { Iterable<Plugin> systemPlugins = Iterables.filter(pluginAccessor.getPlugins(), new SystemPluginPredicate()); if (!includeBuiltInPlugins) { systemPlugins = filterOutTrulyBuiltInPlugins(systemPlugins); } return toPluginInfo("System Plugins", systemPlugins); }
/** * Returns a list containing the system (i.e. non-optional) plugins that are not currently enabled. * * @return an ImmutableList of PluginInfo */ protected ImmutableList<PluginInfo> calculateDisabledSystemPlugins() { PluginAccessor pluginAccessor = ComponentAccessor.getPluginAccessor(); if (pluginAccessor == null) { throw new IllegalStateException("PluginAccessor is null"); } PluginMetadataManager pluginMetadataManager = ComponentAccessor.getComponent(PluginMetadataManager.class); if (pluginMetadataManager == null) { throw new IllegalStateException("PluginMetadataManager is null"); } Collection<Plugin> allPlugins = pluginAccessor.getPlugins(); LOGGER.trace("All plugins: {}", allPlugins); Collection<Plugin> systemPlugins = copyOf(filter(allPlugins, new SystemPluginPredicate(pluginMetadataManager))); LOGGER.trace("System plugins: {}", systemPlugins); Collection<Plugin> disabledSystemPlugins = copyOf(filter(systemPlugins, new PluginNotEnabledPredicate())); LOGGER.trace("Disabled system plugins: {}", disabledSystemPlugins); return copyOf(transform(disabledSystemPlugins, new ExtractPluginInfoFunction())); }
public RefimplI18nResolver(PluginAccessor pluginAccessor, PluginEventManager pluginEventManager, ResourceBundleResolver resolver) { pluginEventManager.register(this); addPluginResourceBundles(pluginAccessor.getPlugins()); this.resolver = assertNotNull(resolver, "resolver"); }
public FishEyeI18nResolver(PluginAccessor pluginAccessor, PluginEventManager pluginEventManager, ResourceBundleResolver resolver) { pluginEventManager.register(this); addPluginResourceBundles(pluginAccessor.getPlugins()); this.resolver = assertNotNull(resolver, "resolver"); }
@Inject public RefimplI18nResolver(final PluginAccessor pluginAccessor, PluginEventManager pluginEventManager, ResourceBundleResolver resolver) { pluginEventManager.register(this); this.resolver = assertNotNull(resolver, "resolver"); locks.write().withLock(() -> addPluginResourceBundles(pluginAccessor.getPlugins())); }