SONAR-6680 RuleRepository now load all rules at first call

RuleRepository now implements a stonger contract (which is documented)
method hasKey(RuleKey) is replaced by method findByKey(RuleKey) which returns an Optional (saves using two methods in a row when Rule exists)
methods getById(int) and findById(int) added to be able to replace Views' specific RuleRepository with the one from the Compute Engine

server/sonar-server/src/main/java/org/sonar/server/computation/container/ReportComputeEngineContainerPopulator.java

@@ -48,7 +48,6 @@
 import org.sonar.server.computation.issue.LoadComponentUuidsHavingOpenIssuesVisitor;
 import org.sonar.server.computation.issue.NewDebtAggregator;
 import org.sonar.server.computation.issue.NewDebtCalculator;
-import org.sonar.server.computation.issue.RuleCacheLoader;
 import org.sonar.server.computation.issue.RuleRepositoryImpl;
 import org.sonar.server.computation.issue.RuleTagsCopier;
 import org.sonar.server.computation.issue.ScmAccountToUser;
@@ -140,7 +139,6 @@ private static List componentClasses() {
       ScmInfoRepositoryImpl.class,
 
       // issues
-      RuleCacheLoader.class,
       RuleRepositoryImpl.class,
       ScmAccountToUserLoader.class,
       ScmAccountToUser.class,

server/sonar-server/src/main/java/org/sonar/server/computation/issue/RuleRepository.java

@@ -19,11 +19,29 @@
  */
 package org.sonar.server.computation.issue;
 
+import com.google.common.base.Optional;
 import org.sonar.api.rule.RuleKey;
 
+/**
+ * Repository of every rule in DB (including manual rules) whichever their status.
+ */
 public interface RuleRepository {
 
+  /**
+   * @throws NullPointerException if {@code key} is {@code null}
+   * @throws IllegalArgumentException when there is no Rule for the specified RuleKey in the repository
+   */
   Rule getByKey(RuleKey key);
 
-  boolean hasKey(RuleKey key);
+  /**
+   * @throws IllegalArgumentException when there is no Rule for the specified RuleKey in the repository
+   */
+  Rule getById(int id);
+
+  /**
+   * @throws NullPointerException if {@code key} is {@code null}
+   */
+  Optional<Rule> findByKey(RuleKey key);
+
+  Optional<Rule> findById(int id);
 }

server/sonar-server/src/main/java/org/sonar/server/computation/issue/RuleRepositoryImpl.java

@@ -19,24 +19,92 @@
  */
 package org.sonar.server.computation.issue;
 
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableMap;
+import java.util.Map;
+import javax.annotation.CheckForNull;
 import org.sonar.api.rule.RuleKey;
-import org.sonar.server.util.cache.MemoryCache;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+import org.sonar.db.rule.RuleDto;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
 
 public class RuleRepositoryImpl implements RuleRepository {
 
-  private final MemoryCache<RuleKey, Rule> cache;
+  @CheckForNull
+  private Map<RuleKey, Rule> rulesByKey;
+  @CheckForNull
+  private Map<Integer, Rule> rulesById;
+
+  private final DbClient dbClient;
 
-  public RuleRepositoryImpl(RuleCacheLoader cacheLoader) {
-    this.cache = new MemoryCache<>(cacheLoader);
+  public RuleRepositoryImpl(DbClient dbClient) {
+    this.dbClient = dbClient;
   }
 
   @Override
   public Rule getByKey(RuleKey key) {
-    return cache.get(key);
+    verifyKeyArgument(key);
+
+    ensureInitialized();
+
+    Rule rule = rulesByKey.get(key);
+    checkArgument(rule != null, "Can not find rule for key %s. This rule does not exist in DB", key);
+    return rule;
   }
 
   @Override
-  public boolean hasKey(RuleKey key) {
-    return cache.getNullable(key) != null;
+  public Optional<Rule> findByKey(RuleKey key) {
+    verifyKeyArgument(key);
+
+    ensureInitialized();
+
+    return Optional.fromNullable(rulesByKey.get(key));
   }
+
+  @Override
+  public Rule getById(int id) {
+    ensureInitialized();
+
+    Rule rule = rulesById.get(id);
+    checkArgument(rule != null, "Can not find rule for id %s. This rule does not exist in DB", id);
+    return rule;
+  }
+
+  @Override
+  public Optional<Rule> findById(int id) {
+    ensureInitialized();
+
+    return Optional.fromNullable(rulesById.get(id));
+  }
+
+  private static void verifyKeyArgument(RuleKey key) {
+    requireNonNull(key, "RuleKey can not be null");
+  }
+
+  private void ensureInitialized() {
+    if (rulesByKey == null) {
+      DbSession dbSession = dbClient.openSession(false);
+      try {
+        loadRulesFromDb(dbSession);
+      } finally {
+        dbClient.closeSession(dbSession);
+      }
+    }
+  }
+
+  private void loadRulesFromDb(DbSession dbSession) {
+    ImmutableMap.Builder<RuleKey, Rule> rulesByKeyBuilder = ImmutableMap.builder();
+    ImmutableMap.Builder<Integer, Rule> rulesByIdBuilder = ImmutableMap.builder();
+    for (RuleDto ruleDto : dbClient.ruleDao().selectAll(dbSession)) {
+      Rule rule = new RuleImpl(ruleDto);
+      rulesByKeyBuilder.put(ruleDto.getKey(), rule);
+      rulesByIdBuilder.put(ruleDto.getId(), rule);
+    }
+    this.rulesByKey = rulesByKeyBuilder.build();
+    this.rulesById = rulesByIdBuilder.build();
+  }
+
 }

server/sonar-server/src/main/java/org/sonar/server/computation/step/LoadQualityProfilesStep.java

@@ -19,6 +19,7 @@
  */
 package org.sonar.server.computation.step;
 
+import com.google.common.base.Optional;
 import com.google.common.base.Predicate;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -66,11 +67,8 @@ public void execute() {
   private class IsValid implements Predicate<ActiveRule> {
     @Override
     public boolean apply(@Nonnull ActiveRule input) {
-      if (ruleRepository.hasKey(input.getRuleKey())) {
-        Rule rule = ruleRepository.getByKey(input.getRuleKey());
-        return rule.getStatus() != RuleStatus.REMOVED;
-      }
-      return false;
+      Optional<Rule> rule = ruleRepository.findByKey(input.getRuleKey());
+      return rule.isPresent() && rule.get().getStatus() != RuleStatus.REMOVED;
     }
   }
 

server/sonar-server/src/test/java/org/sonar/server/computation/issue/DumbRule.java

@@ -39,6 +39,7 @@ public class DumbRule implements Rule {
 
   public DumbRule(RuleKey key) {
     this.key = key;
+    this.id = key.hashCode();
   }
 
   @Override