package org.sonar.server.plugins;
import org.apache.commons.io.FileUtils;
-import org.sonar.api.ServerComponent;
+import org.sonar.api.ServerSide;
import org.sonar.api.utils.ZipUtils;
-import org.sonar.core.platform.PluginInfo;
-import org.sonar.core.platform.PluginExploder;
import org.sonar.core.platform.ExplodedPlugin;
+import org.sonar.core.platform.PluginExploder;
+import org.sonar.core.platform.PluginInfo;
import org.sonar.server.platform.DefaultServerFileSystem;
import java.io.File;
import static org.apache.commons.io.FileUtils.cleanDirectory;
import static org.apache.commons.io.FileUtils.forceMkdir;
-public class ServerPluginExploder extends PluginExploder implements ServerComponent {
+@ServerSide
+public class ServerPluginExploder extends PluginExploder {
private final DefaultServerFileSystem fs;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import org.sonar.updatecenter.common.Version;
import static com.google.common.collect.Iterables.transform;
import static com.google.common.collect.Lists.newArrayList;
}
for (PluginInfo.RequiredPlugin requiredPlugin : plugin.getRequiredPlugins()) {
- PluginInfo available = allPluginsByKeys.get(requiredPlugin.getKey());
- if (available == null) {
+ PluginInfo installedRequirement = allPluginsByKeys.get(requiredPlugin.getKey());
+ if (installedRequirement == null) {
// it requires a plugin that is not installed
LOG.warn("Plugin {} [{}] is ignored because the required plugin [{}] is not installed", plugin.getName(), plugin.getKey(), requiredPlugin.getKey());
return false;
}
- if (requiredPlugin.getMinimalVersion().compareToIgnoreQualifier(available.getVersion()) > 0) {
+ Version installedRequirementVersion = installedRequirement.getVersion();
+ if (installedRequirementVersion != null && requiredPlugin.getMinimalVersion().compareToIgnoreQualifier(installedRequirementVersion) > 0) {
// it requires a more recent version
LOG.warn("Plugin {} [{}] is ignored because the version {} of required plugin [{}] is not supported", plugin.getName(), plugin.getKey(),
requiredPlugin.getKey(), requiredPlugin.getMinimalVersion());
activity.setAction(type.name());
activity.setData("key", getKey().toString());
activity.setData("ruleKey", getKey().ruleKey().toString());
- activity.setData("profileKey", getKey().qProfile().toString());
+ activity.setData("profileKey", getKey().qProfile());
for (Map.Entry<String, String> param : parameters.entrySet()) {
if (!param.getKey().isEmpty()) {
private String writeActiveRule(ActiveRule activeRule, JsonWriter json) {
json
.beginObject()
- .prop("qProfile", activeRule.key().qProfile().toString())
+ .prop("qProfile", activeRule.key().qProfile())
.prop("inherit", activeRule.inheritance().toString())
.prop("severity", activeRule.severity());
ActiveRuleKey parentKey = activeRule.parentKey();
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.CharUtils;
-import org.sonar.api.ServerComponent;
+import org.sonar.api.ServerSide;
import org.sonar.core.platform.PluginInfo;
import org.sonar.core.platform.PluginRepository;
import org.sonar.core.plugins.RemotePlugin;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
-public final class GeneratePluginIndex implements ServerComponent {
+@ServerSide
+public final class GeneratePluginIndex {
private DefaultServerFileSystem fileSystem;
private PluginRepository repository;
package org.sonar.batch.bootstrap;
import org.apache.commons.io.FileUtils;
-import org.sonar.api.BatchComponent;
+import org.sonar.api.BatchSide;
import org.sonar.api.utils.ZipUtils;
import org.sonar.core.platform.ExplodedPlugin;
import org.sonar.core.platform.PluginExploder;
import java.io.FileOutputStream;
import java.io.IOException;
-public class BatchPluginExploder extends PluginExploder implements BatchComponent {
+@BatchSide
+public class BatchPluginExploder extends PluginExploder {
private final FileCache fileCache;
import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import org.apache.commons.lang.StringUtils;
-import org.sonar.api.BatchComponent;
+import org.sonar.api.BatchSide;
import org.sonar.api.CoreProperties;
import org.sonar.api.config.Settings;
import org.sonar.api.utils.log.Logger;
/**
* Filters the plugins to be enabled during analysis
*/
-public class BatchPluginPredicate implements Predicate<String>, BatchComponent {
+@BatchSide
+public class BatchPluginPredicate implements Predicate<String>{
private static final Logger LOG = Loggers.get(BatchPluginPredicate.class);
*/
package org.sonar.batch.bootstrap;
-import org.sonar.api.BatchComponent;
+import org.sonar.api.BatchSide;
import org.sonar.api.Plugin;
import org.sonar.core.platform.PluginInfo;
import java.util.Map;
-public interface PluginInstaller extends BatchComponent {
+@BatchSide
+public interface PluginInstaller {
/**
* Gets the list of plugins installed on server and downloads them if not
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Strings;
import org.apache.commons.lang.SystemUtils;
-import org.sonar.api.BatchComponent;
import org.sonar.api.Plugin;
-import org.sonar.api.ServerComponent;
import org.sonar.api.utils.log.Loggers;
import org.sonar.classloader.ClassloaderBuilder;
+import org.sonar.classloader.Mask;
import java.io.Closeable;
import java.io.File;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
-import org.sonar.classloader.Mask;
import static java.util.Arrays.asList;
import static org.sonar.classloader.ClassloaderBuilder.LoadingOrder.PARENT_FIRST;
} catch (UnsupportedClassVersionError e) {
throw new IllegalStateException(String.format("The plugin [%s] does not support Java %s",
pluginKey, SystemUtils.JAVA_VERSION_TRIMMED), e);
- } catch (ClassNotFoundException|IllegalAccessException|InstantiationException e) {
+ } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
throw new IllegalStateException(String.format(
"Fail to instantiate class [%s] of plugin [%s]", mainClass, pluginKey), e);
}
*/
@Override
public String toString() {
- return String.format("%s:%s", qualityProfileKey.toString(), ruleKey.toString());
+ return String.format("%s:%s", qualityProfileKey, ruleKey.toString());
}
}
if (this == o) {
return true;
}
- if (!(o instanceof Language)) {
+ if (o == null || !(o instanceof Language)) {
return false;
}
-
- Language language = (Language) o;
- return !(key != null ? !key.equals(language.getKey()) : language.getKey() != null);
+ Language that = (Language) o;
+ return key.equals(that.getKey());
}
@Override
public int hashCode() {
- return key != null ? key.hashCode() : 0;
+ return key.hashCode();
}
@Override
import org.junit.rules.ExpectedException;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
public class AbstractLanguageTest {
public ExpectedException thrown = ExpectedException.none();
@Test
- public void a_language_should_equal_itself() {
- assertEquals(new Language1(), new Language1());
- }
+ public void test_equals_and_hashcode() {
+ final Language1 lang1 = new Language1();
+ assertThat(lang1.equals(lang1)).isTrue();
+ assertThat(lang1.equals(new Language2())).isFalse();
+ assertThat(lang1.equals(new Language1Too())).isTrue();
+ assertThat(lang1.equals("not a language")).isFalse();
+ assertThat(lang1.equals(null)).isFalse();
- @Test
- public void should_be_equal_to_another_language_implementation_having_same_key() {
- assertThat(new Language1()).isEqualTo(new Language2());
+ // not an AbstractLanguage but a Language
+ assertThat(lang1.equals(new Language() {
+ @Override
+ public String getKey() {
+ return lang1.getKey();
+ }
+
+ @Override
+ public String getName() {
+ return lang1.getName();
+ }
+
+ @Override
+ public String[] getFileSuffixes() {
+ return lang1.getFileSuffixes();
+ }
+ })).isTrue();
+
+ assertThat(lang1.hashCode()).isEqualTo(lang1.hashCode());
+ assertThat(lang1.hashCode()).isEqualTo(new Language1Too().hashCode());
}
@Test
static class Language1 extends AbstractLanguage {
public Language1() {
- super("language_key");
+ super("lang1");
+ }
+
+ public String[] getFileSuffixes() {
+ return new String[0];
+ }
+ }
+
+ static class Language1Too extends AbstractLanguage {
+ public Language1Too() {
+ super("lang1");
}
public String[] getFileSuffixes() {
static class Language2 extends AbstractLanguage {
public Language2() {
- super("language_key");
+ super("lang2");
}
public String[] getFileSuffixes() {
return new String[0];
}
}
-
}