Merge branch 'stable-2.15'

* stable-2.15:
  Make zip generation (more) reproducible
  Make _bower_archive rule deterministic
  Remove duplication between both index modules
  Add more debug logging to account creation
  Delete index after each test in elasticsearch tests
  AccountManager: Reduce logs to debug level
  AccountManager: Use Logger's built-in string formatting
  Documentation: clarify what happens if you override a label in a child.
  Prolog cookbook: fix several examples.

Change-Id: I53dd1ec43c6fc019bfac76a9606fdca97eb5e6f0

Documentation/prolog-cookbook.txt

@@ -901,7 +901,10 @@ add_category_min_score(In, Category, Min,  P) :-
     findall(X, gerrit:commit_label(label(Category,X),R),Z),
     sum_list(Z, Sum),
     Sum >= Min, !,
-    P = [label(Category,ok(R)) | In].
+    gerrit:commit_label(label(Category, V), U),
+    V >= 1,
+    !,
+    P = [label(Category,ok(U)) | In].
 
 add_category_min_score(In, Category,Min,P) :-
     P = [label(Category,need(Min)) | In].

java/com/google/gerrit/elasticsearch/ElasticIndexModule.java

@@ -14,28 +14,15 @@
 
 package com.google.gerrit.elasticsearch;
 
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.gerrit.index.IndexConfig;
-import com.google.gerrit.index.Schema;
 import com.google.gerrit.index.project.ProjectIndex;
-import com.google.gerrit.lifecycle.LifecycleModule;
-import com.google.gerrit.server.config.GerritServerConfig;
-import com.google.gerrit.server.index.IndexModule;
-import com.google.gerrit.server.index.OnlineUpgrader;
-import com.google.gerrit.server.index.SingleVersionModule;
+import com.google.gerrit.server.index.AbstractIndexModule;
 import com.google.gerrit.server.index.VersionManager;
 import com.google.gerrit.server.index.account.AccountIndex;
 import com.google.gerrit.server.index.change.ChangeIndex;
 import com.google.gerrit.server.index.group.GroupIndex;
-import com.google.inject.AbstractModule;
-import com.google.inject.Provides;
-import com.google.inject.Singleton;
-import com.google.inject.assistedinject.FactoryModuleBuilder;
 import java.util.Map;
-import org.eclipse.jgit.lib.Config;
 
-public class ElasticIndexModule extends AbstractModule {
+public class ElasticIndexModule extends AbstractIndexModule {
   public static ElasticIndexModule singleVersionWithExplicitVersions(
       Map<String, Integer> versions, int threads, boolean slave) {
     return new ElasticIndexModule(versions, threads, false, slave);
@@ -49,74 +36,33 @@ public class ElasticIndexModule extends AbstractModule {
     return new ElasticIndexModule(null, 0, false, slave);
   }
 
-  private final Map<String, Integer> singleVersions;
-  private final int threads;
-  private final boolean onlineUpgrade;
-  private final boolean slave;
-
   private ElasticIndexModule(
       Map<String, Integer> singleVersions, int threads, boolean onlineUpgrade, boolean slave) {
-    if (singleVersions != null) {
-      checkArgument(!onlineUpgrade, "online upgrade is incompatible with single version map");
-    }
-    this.singleVersions = singleVersions;
-    this.threads = threads;
-    this.onlineUpgrade = onlineUpgrade;
-    this.slave = slave;
+    super(singleVersions, threads, onlineUpgrade, slave);
   }
 
   @Override
-  protected void configure() {
-    if (slave) {
-      bind(AccountIndex.Factory.class).toInstance(ElasticIndexModule::createDummyIndexFactory);
-      bind(ChangeIndex.Factory.class).toInstance(ElasticIndexModule::createDummyIndexFactory);
-      bind(ProjectIndex.Factory.class).toInstance(ElasticIndexModule::createDummyIndexFactory);
-    } else {
-      install(
-          new FactoryModuleBuilder()
-              .implement(AccountIndex.class, ElasticAccountIndex.class)
-              .build(AccountIndex.Factory.class));
-      install(
-          new FactoryModuleBuilder()
-              .implement(ChangeIndex.class, ElasticChangeIndex.class)
-              .build(ChangeIndex.Factory.class));
-      install(
-          new FactoryModuleBuilder()
-              .implement(ProjectIndex.class, ElasticProjectIndex.class)
-              .build(ProjectIndex.Factory.class));
-    }
-    install(
-        new FactoryModuleBuilder()
-            .implement(GroupIndex.class, ElasticGroupIndex.class)
-            .build(GroupIndex.Factory.class));
-
-    install(new IndexModule(threads, slave));
-    if (singleVersions == null) {
-      install(new MultiVersionModule());
-    } else {
-      install(new SingleVersionModule(singleVersions));
-    }
+  protected Class<? extends AccountIndex> getAccountIndex() {
+    return ElasticAccountIndex.class;
   }
 
-  @SuppressWarnings("unused")
-  private static <T> T createDummyIndexFactory(Schema<?> schema) {
-    throw new UnsupportedOperationException();
+  @Override
+  protected Class<? extends ChangeIndex> getChangeIndex() {
+    return ElasticChangeIndex.class;
   }
 
-  @Provides
-  @Singleton
-  IndexConfig getIndexConfig(@GerritServerConfig Config cfg) {
-    return IndexConfig.fromConfig(cfg).separateChangeSubIndexes(true).build();
+  @Override
+  protected Class<? extends GroupIndex> getGroupIndex() {
+    return ElasticGroupIndex.class;
   }
 
-  private class MultiVersionModule extends LifecycleModule {
-    @Override
-    public void configure() {
-      bind(VersionManager.class).to(ElasticVersionManager.class);
-      listener().to(ElasticVersionManager.class);
-      if (onlineUpgrade) {
-        listener().to(OnlineUpgrader.class);
-      }
-    }
+  @Override
+  protected Class<? extends ProjectIndex> getProjectIndex() {
+    return ElasticProjectIndex.class;
+  }
+
+  @Override
+  protected Class<? extends VersionManager> getVersionManager() {
+    return ElasticVersionManager.class;
   }
 }

java/com/google/gerrit/lucene/LuceneIndexModule.java

@@ -14,30 +14,20 @@
 
 package com.google.gerrit.lucene;
 
-import static com.google.common.base.Preconditions.checkArgument;
-
 import com.google.common.collect.ImmutableMap;
 import com.google.gerrit.index.IndexConfig;
-import com.google.gerrit.index.Schema;
 import com.google.gerrit.index.project.ProjectIndex;
-import com.google.gerrit.lifecycle.LifecycleModule;
 import com.google.gerrit.server.config.GerritServerConfig;
-import com.google.gerrit.server.index.IndexModule;
-import com.google.gerrit.server.index.OnlineUpgrader;
-import com.google.gerrit.server.index.SingleVersionModule;
+import com.google.gerrit.server.index.AbstractIndexModule;
 import com.google.gerrit.server.index.VersionManager;
 import com.google.gerrit.server.index.account.AccountIndex;
 import com.google.gerrit.server.index.change.ChangeIndex;
 import com.google.gerrit.server.index.group.GroupIndex;
-import com.google.inject.AbstractModule;
-import com.google.inject.Provides;
-import com.google.inject.Singleton;
-import com.google.inject.assistedinject.FactoryModuleBuilder;
 import java.util.Map;
 import org.apache.lucene.search.BooleanQuery;
 import org.eclipse.jgit.lib.Config;
 
-public class LuceneIndexModule extends AbstractModule {
+public class LuceneIndexModule extends AbstractIndexModule {
   public static LuceneIndexModule singleVersionAllLatest(int threads, boolean slave) {
     return new LuceneIndexModule(ImmutableMap.of(), threads, false, slave);
   }
@@ -59,76 +49,40 @@ public class LuceneIndexModule extends AbstractModule {
     return cfg.getBoolean("index", "lucene", "testInmemory", false);
   }
 
-  private final Map<String, Integer> singleVersions;
-  private final int threads;
-  private final boolean onlineUpgrade;
-  private final boolean slave;
-
   private LuceneIndexModule(
       Map<String, Integer> singleVersions, int threads, boolean onlineUpgrade, boolean slave) {
-    if (singleVersions != null) {
-      checkArgument(!onlineUpgrade, "online upgrade is incompatible with single version map");
-    }
-    this.singleVersions = singleVersions;
-    this.threads = threads;
-    this.onlineUpgrade = onlineUpgrade;
-    this.slave = slave;
+    super(singleVersions, threads, onlineUpgrade, slave);
   }
 
   @Override
-  protected void configure() {
-    if (slave) {
-      bind(AccountIndex.Factory.class).toInstance(LuceneIndexModule::createDummyIndexFactory);
-      bind(ChangeIndex.Factory.class).toInstance(LuceneIndexModule::createDummyIndexFactory);
-      bind(ProjectIndex.Factory.class).toInstance(LuceneIndexModule::createDummyIndexFactory);
-    } else {
-      install(
-          new FactoryModuleBuilder()
-              .implement(AccountIndex.class, LuceneAccountIndex.class)
-              .build(AccountIndex.Factory.class));
-      install(
-          new FactoryModuleBuilder()
-              .implement(ChangeIndex.class, LuceneChangeIndex.class)
-              .build(ChangeIndex.Factory.class));
-      install(
-          new FactoryModuleBuilder()
-              .implement(ProjectIndex.class, LuceneProjectIndex.class)
-              .build(ProjectIndex.Factory.class));
-    }
-    install(
-        new FactoryModuleBuilder()
-            .implement(GroupIndex.class, LuceneGroupIndex.class)
-            .build(GroupIndex.Factory.class));
-
-    install(new IndexModule(threads, slave));
-    if (singleVersions == null) {
-      install(new MultiVersionModule());
-    } else {
-      install(new SingleVersionModule(singleVersions));
-    }
+  protected Class<? extends AccountIndex> getAccountIndex() {
+    return LuceneAccountIndex.class;
   }
 
-  @SuppressWarnings("unused")
-  private static <T> T createDummyIndexFactory(Schema<?> schema) {
-    throw new UnsupportedOperationException();
+  @Override
+  protected Class<? extends ChangeIndex> getChangeIndex() {
+    return LuceneChangeIndex.class;
   }
 
-  @Provides
-  @Singleton
-  IndexConfig getIndexConfig(@GerritServerConfig Config cfg) {
+  @Override
+  protected Class<? extends GroupIndex> getGroupIndex() {
+    return LuceneGroupIndex.class;
+  }
+
+  @Override
+  protected Class<? extends ProjectIndex> getProjectIndex() {
+    return LuceneProjectIndex.class;
+  }
+
+  @Override
+  protected Class<? extends VersionManager> getVersionManager() {
+    return LuceneVersionManager.class;
+  }
+
+  @Override
+  protected IndexConfig getIndexConfig(@GerritServerConfig Config cfg) {
     BooleanQuery.setMaxClauseCount(
         cfg.getInt("index", "maxTerms", BooleanQuery.getMaxClauseCount()));
-    return IndexConfig.fromConfig(cfg).separateChangeSubIndexes(true).build();
-  }
-
-  private class MultiVersionModule extends LifecycleModule {
-    @Override
-    public void configure() {
-      bind(VersionManager.class).to(LuceneVersionManager.class);
-      listener().to(LuceneVersionManager.class);
-      if (onlineUpgrade) {
-        listener().to(OnlineUpgrader.class);
-      }
-    }
+    return super.getIndexConfig(cfg);
   }
 }

java/com/google/gerrit/server/account/AccountManager.java

@@ -151,7 +151,7 @@ public class AccountManager {
           }
         }
         // New account, automatically create and return.
-        log.info("External ID not found. Attempting to create new account.");
+        log.debug("External ID not found. Attempting to create new account.");
         return create(who);
       }
 
@@ -159,9 +159,9 @@ public class AccountManager {
       Optional<AccountState> accountState = byIdCache.get(extId.accountId());
       if (!accountState.isPresent()) {
         log.error(
-            String.format(
-                "Authentication with external ID %s failed. Account %s doesn't exist.",
-                extId.key().get(), extId.accountId().get()));
+            "Authentication with external ID {} failed. Account {} doesn't exist.",
+            extId.key().get(),
+            extId.accountId().get());
         throw new AccountException("Authentication error, account not found");
       }
 
@@ -285,9 +285,11 @@ public class AccountManager {
   private AuthResult create(AuthRequest who)
       throws OrmException, AccountException, IOException, ConfigInvalidException {
     Account.Id newId = new Account.Id(sequences.nextAccountId());
+    log.debug("Assigning new Id {} to account", newId);
 
     ExternalId extId =
         ExternalId.createWithEmail(who.getExternalIdKey(), newId, who.getEmailAddress());
+    log.debug("Created external Id: {}", extId);
     checkEmailNotUsed(extId);
     ExternalId userNameExtId =
         who.getUserName().isPresent() ? createUsername(newId, who.getUserName().get()) : null;
@@ -412,7 +414,7 @@ public class AccountManager {
   public AuthResult link(Account.Id to, AuthRequest who)
       throws AccountException, OrmException, IOException, ConfigInvalidException {
     Optional<ExternalId> optionalExtId = externalIds.get(who.getExternalIdKey());
-    log.info("Link another authentication identity to an existing account");
+    log.debug("Link another authentication identity to an existing account");
     if (optionalExtId.isPresent()) {
       ExternalId extId = optionalExtId.get();
       if (!extId.accountId().equals(to)) {
@@ -421,7 +423,7 @@ public class AccountManager {
       }
       update(who, extId);
     } else {
-      log.info("Linking new external ID to the existing account");
+      log.debug("Linking new external ID to the existing account");
       ExternalId newExtId =
           ExternalId.createWithEmail(who.getExternalIdKey(), to, who.getEmailAddress());
       checkEmailNotUsed(newExtId);

java/com/google/gerrit/server/index/AbstractIndexModule.java

@@ -0,0 +1,121 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.server.index;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.gerrit.index.IndexConfig;
+import com.google.gerrit.index.Schema;
+import com.google.gerrit.index.project.ProjectIndex;
+import com.google.gerrit.lifecycle.LifecycleModule;
+import com.google.gerrit.server.config.GerritServerConfig;
+import com.google.gerrit.server.index.account.AccountIndex;
+import com.google.gerrit.server.index.change.ChangeIndex;
+import com.google.gerrit.server.index.group.GroupIndex;
+import com.google.inject.AbstractModule;
+import com.google.inject.Provides;
+import com.google.inject.Singleton;
+import com.google.inject.assistedinject.FactoryModuleBuilder;
+import java.util.Map;
+import org.eclipse.jgit.lib.Config;
+
+public abstract class AbstractIndexModule extends AbstractModule {
+
+  private final int threads;
+  private final Map<String, Integer> singleVersions;
+  private final boolean onlineUpgrade;
+  private final boolean slave;
+
+  protected AbstractIndexModule(
+      Map<String, Integer> singleVersions, int threads, boolean onlineUpgrade, boolean slave) {
+    if (singleVersions != null) {
+      checkArgument(!onlineUpgrade, "online upgrade is incompatible with single version map");
+    }
+    this.singleVersions = singleVersions;
+    this.threads = threads;
+    this.onlineUpgrade = onlineUpgrade;
+    this.slave = slave;
+  }
+
+  @Override
+  protected void configure() {
+    if (slave) {
+      bind(AccountIndex.Factory.class).toInstance(AbstractIndexModule::createDummyIndexFactory);
+      bind(ChangeIndex.Factory.class).toInstance(AbstractIndexModule::createDummyIndexFactory);
+      bind(ProjectIndex.Factory.class).toInstance(AbstractIndexModule::createDummyIndexFactory);
+    } else {
+      install(
+          new FactoryModuleBuilder()
+              .implement(AccountIndex.class, getAccountIndex())
+              .build(AccountIndex.Factory.class));
+      install(
+          new FactoryModuleBuilder()
+              .implement(ChangeIndex.class, getChangeIndex())
+              .build(ChangeIndex.Factory.class));
+      install(
+          new FactoryModuleBuilder()
+              .implement(ProjectIndex.class, getProjectIndex())
+              .build(ProjectIndex.Factory.class));
+    }
+    install(
+        new FactoryModuleBuilder()
+            .implement(GroupIndex.class, getGroupIndex())
+            .build(GroupIndex.Factory.class));
+
+    install(new IndexModule(threads, slave));
+    if (singleVersions == null) {
+      install(new MultiVersionModule());
+    } else {
+      install(new SingleVersionModule(singleVersions));
+    }
+  }
+
+  @SuppressWarnings("unused")
+  private static <T> T createDummyIndexFactory(Schema<?> schema) {
+    throw new UnsupportedOperationException();
+  }
+
+  protected abstract Class<? extends AccountIndex> getAccountIndex();
+
+  protected abstract Class<? extends ChangeIndex> getChangeIndex();
+
+  protected abstract Class<? extends GroupIndex> getGroupIndex();
+
+  protected abstract Class<? extends ProjectIndex> getProjectIndex();
+
+  protected abstract Class<? extends VersionManager> getVersionManager();
+
+  @Provides
+  @Singleton
+  IndexConfig provideIndexConfig(@GerritServerConfig Config cfg) {
+    return getIndexConfig(cfg);
+  }
+
+  protected IndexConfig getIndexConfig(@GerritServerConfig Config cfg) {
+    return IndexConfig.fromConfig(cfg).separateChangeSubIndexes(true).build();
+  }
+
+  private class MultiVersionModule extends LifecycleModule {
+    @Override
+    public void configure() {
+      Class<? extends VersionManager> versionManagerClass = getVersionManager();
+      bind(VersionManager.class).to(versionManagerClass);
+      listener().to(versionManagerClass);
+      if (onlineUpgrade) {
+        listener().to(OnlineUpgrader.class);
+      }
+    }
+  }
+}