throw new SonarException("Fail to load extensions from plugin " + pluginMetadata.getKey(), e);
}
}
+ invokeExtensionProviders(pico);
}
boolean shouldRegisterCoverageExtension(String pluginKey) {
*/
package org.sonar.core.plugin;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
import com.google.common.collect.Maps;
import org.picocontainer.Characteristics;
import org.picocontainer.MutablePicoContainer;
-import org.picocontainer.injectors.ProviderAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.*;
import org.sonar.api.platform.PluginRepository;
import java.util.Collection;
+import java.util.List;
import java.util.Map;
/**
private static final Logger LOG = LoggerFactory.getLogger(AbstractPluginRepository.class);
- private Map<String, Plugin> pluginByKey = Maps.newHashMap();
+ private BiMap<String, Plugin> pluginByKey = HashBiMap.create();
private Map<Object, Plugin> pluginByExtension = Maps.newIdentityHashMap();
protected void registerPlugin(MutablePicoContainer container, Plugin plugin, String pluginKey) {
}
}
+ /**
+ * Must be executed by implementations when all plugins are registered.
+ */
+ protected void invokeExtensionProviders(MutablePicoContainer container) {
+ List<ExtensionProvider> providers = container.getComponents(ExtensionProvider.class);
+ for (ExtensionProvider provider : providers) {
+ Plugin plugin = getPluginForExtension(provider);
+ Object obj = provider.provide();
+ if (obj instanceof Iterable) {
+ for (Object elt : (Iterable) obj) {
+ registerExtension(container, plugin, getPluginKey(plugin), elt);
+ }
+ } else {
+ registerExtension(container, plugin, getPluginKey(plugin), obj);
+ }
+ }
+ }
+
private void registerExtension(MutablePicoContainer container, Plugin plugin, String pluginKey, Object extension) {
if (shouldRegisterExtension(pluginKey, extension)) {
LOG.debug("Register the extension: {}", extension);
container.as(Characteristics.CACHE).addComponent(getExtensionKey(extension), extension);
pluginByExtension.put(extension, plugin);
- }
- if (isExtensionProvider(extension)) {
- LOG.debug("Register the extension provider: {}", extension);
- container.as(Characteristics.CACHE).addAdapter(new ExtensionProviderAdapter(extension));
+
}
}
return pluginByKey.get(key);
}
+ public String getPluginKey(Plugin plugin) {
+ return pluginByKey.inverse().get(plugin);
+ }
+
/**
* Returns the list of properties of a plugin
*/
}
protected static boolean isExtensionProvider(Object extension) {
- boolean is = false;
- if (isType(extension, ExtensionProvider.class)) {
- if (extension instanceof ExtensionProvider) {
- is = true;
- } else {
- LOG.error("The following ExtensionProvider must be registered in Plugin.getExtensions() as an instance but not a class: " + extension);
- }
- }
- return is;
+ return isType(extension, ExtensionProvider.class);
}
protected static Object getExtensionKey(Object component) {
}
return component.getClass().getCanonicalName() + "-" + component.toString();
}
-
- public static class ExtensionProviderAdapter extends ProviderAdapter {
- public ExtensionProviderAdapter(Object provider) {
- super(provider);
- }
- }
}
import org.sonar.api.utils.IocContainer;
import java.util.Arrays;
+import java.util.Collection;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.notNullValue;
}
@Test
- public void extensionProviderIsAnObjectButNotAClass() {
- assertThat(AbstractPluginRepository.isExtensionProvider(BProvider.class), is(false));
- assertThat(AbstractPluginRepository.isExtensionProvider(new BProvider()), is(true));
+ public void shouldBeExtensionProvider() {
+ assertThat(AbstractPluginRepository.isExtensionProvider(BProvider.class), is(true));
+ assertThat(AbstractPluginRepository.isExtensionProvider(new BProvider(new A())), is(true));
}
@Test
};
Plugin plugin = mock(Plugin.class);
- BProvider bProvider = new BProvider();
- when(plugin.getExtensions()).thenReturn(Arrays.asList(A.class, bProvider, C.class, D.class));
+ when(plugin.getExtensions()).thenReturn(Arrays.asList(A.class, BProvider.class, B.class, C.class, D.class));
repository.registerPlugin(pico, plugin, "foo");
+ repository.invokeExtensionProviders(pico);
pico.start();
assertThat(pico.getComponent(A.class), is(A.class));
assertThat(pico.getComponent(C.class), is(C.class));
assertThat(pico.getComponent(D.class), is(D.class));
- assertThat(pico.getComponent(C.class).getBees().length, is(2));
- assertThat(pico.getComponent(D.class).getBees().length, is(2));
- assertThat(bProvider.calls, is(1)); // do not create B instances two times (C and D dependencies)
-
- // Picocontainer question: why components created by providers are not registered in the container ?
- //assertThat(pico.getComponents(B.class).size(), is(2)); // created by the ExtensionProvider
+ assertThat(pico.getComponent(C.class).getBees().length, is(3));// 1 in plugin.getExtensions() + 2 created by BProvider
+ assertThat(pico.getComponent(D.class).getBees().length, is(3));
+ assertThat(pico.getComponent(BProvider.class).calls, is(1)); // do not create B instances two times (C and D dependencies)
+ assertThat(pico.getComponents(B.class).size(), is(3));
}
public static class FakeServerExtension implements ServerExtension {
}
}
+
public static class C implements ServerExtension {
private B[] bees;
}
}
- public static class BProvider extends ExtensionProvider {
+ public static class BProvider extends ExtensionProvider implements ServerExtension {
private int calls = 0;
- public B[] provide(A a) {
+ private A a;
+
+ public BProvider(A a) {
+ this.a = a;
+ }
+
+ public Collection<B> provide() {
calls++;
- return new B[]{new B(a), new B(a)};
+ return Arrays.asList(new B(a), new B(a));
}
}
*/
package org.sonar.api;
-import org.picocontainer.injectors.Provider;
-
/**
* Factory of extensions. It allows to dynamically create extensions depending upon runtime context. A use-case is
* to create one rule repository by language.
*
- * <p>Constraints are :
+ * <p>Notes :
* <ul>
- * <li>the factory is declared in Plugin.getExtensions() as an instance but not as a class</li>
- * <li>the factory must have a public method named "provide()"</li>
- * <li>the method provide() must return an object or an array of objects. Collections and classes are excluded.</li>
- * <li>the methode provide() can accept parameters. These parameters are IoC dependencies.
+ * <li>the provider is declared in Plugin.getExtensions()</li>
+ * <li>the provider must also implement ServerExtension and/or BatchExtension</li>
+ * <li>the provider can accept dependencies (parameters) in its constructors.</li>
+ * <li>the method provide() is automatically executed once by sonar</li>
+ * <li>the method provide() must return an object or an Iterable of objects. <strong>Arrays are excluded</strong>.</li>
* </ul>
* </p>
*
* <p>Example:
* <pre>
- * public class RuleRepositoryProvider extends ExtensionProvider {
- * public RuleRepository[] provide(Language[] languages) {
- * RuleRepository[] result = new RuleRepository[languages.length];
- * for(int index=0; index < languages.length ; index++) {
- * Language language = languages[index];
- * result[index] = new RuleRepository(...);
+ * public class RuleRepositoryProvider extends ExtensionProvider implements ServerExtension {
+ * private Language[] languages;
+ *
+ * public RuleRepositoryProvider(Language[] languages) {
+ * this.languages = languages;
+ * }
+ *
+ * public List<RuleRepository> provide() {
+ * List<RuleRepository> result = new ArrayList<RuleRepository>();
+ * for(Language language: languages) {
+ * result.add(new RuleRepository(..., language, ...));
* }
* return result;
* }
* }
* </pre>
* </p>
- *
+ *
* @since 2.3
*/
-public abstract class ExtensionProvider implements Extension, Provider {
+public abstract class ExtensionProvider implements Extension {
+ public abstract Object provide();
}
Plugin getPlugin(String key);
+ /**
+ * @deprecated since 2.3
+ */
@Deprecated
Plugin getPluginForExtension(Object extension);
throw new SonarException("Please check the plugin manifest. The main plugin class does not exist: " + jpaPlugin.getPluginClass(), e);
}
}
+ invokeExtensionProviders(pico);
}
@Override
projects / sonarqube.git / commitdiff