Merge branch 'stable-3.2'
* stable-3.2:
Set version to 3.2.3 for release
Change-Id: Idaf7c2ed5a601b6d091268147057b79899a4801a
diff --git a/Jenkinsfile b/Jenkinsfile
index a090baf..deb1d46 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -19,7 +19,7 @@
stage('build') {
steps {
gerritReview labels: [Verified: 0], message: "Build started: ${env.BUILD_URL}"
- sh 'mvn test'
+ sh "bash -c '. set-java.sh 11 && mvn test'"
}
}
}
diff --git a/pom.xml b/pom.xml
index 9ad8148..c67aee8 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
<groupId>com.gerritforge</groupId>
<artifactId>global-refdb</artifactId>
- <version>3.2.3</version>
+ <version>3.3.0-rc1</version>
<packaging>jar</packaging>
<name>global-refdb</name>
@@ -38,7 +38,7 @@
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
- <gerrit.version>3.2.3</gerrit.version>
+ <gerrit.version>3.3.0-rc1</gerrit.version>
</properties>
<dependencies>
@@ -75,8 +75,8 @@
<artifactId>maven-compiler-plugin</artifactId>
<version>3.6.1</version>
<configuration>
- <source>1.8</source>
- <target>1.8</target>
+ <source>11</source>
+ <target>11</target>
</configuration>
</plugin>
<plugin>
@@ -95,7 +95,7 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
- <version>3.1.1</version>
+ <version>3.2.0</version>
<executions>
<execution>
<id>attach-javadocs</id>
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/BatchRefUpdateValidator.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/BatchRefUpdateValidator.java
new file mode 100644
index 0000000..0961b3c
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/BatchRefUpdateValidator.java
@@ -0,0 +1,178 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.OutOfSyncException;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedRefEnforcement;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedRefEnforcement.EnforcePolicy;
+import com.google.common.flogger.FluentLogger;
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.eclipse.jgit.lib.BatchRefUpdate;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.ObjectIdRef;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.transport.ReceiveCommand;
+
+public class BatchRefUpdateValidator extends RefUpdateValidator {
+ private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+
+ public static interface Factory {
+ BatchRefUpdateValidator create(String projectName, RefDatabase refDb);
+ }
+
+ public interface BatchValidationWrapper {
+ void apply(BatchRefUpdate batchRefUpdate, NoParameterVoidFunction arg) throws IOException;
+ }
+
+ @Inject
+ public BatchRefUpdateValidator(
+ SharedRefDatabaseWrapper sharedRefDb,
+ ValidationMetrics validationMetrics,
+ SharedRefEnforcement refEnforcement,
+ LockWrapper.Factory lockWrapperFactory,
+ ProjectsFilter projectsFilter,
+ @Assisted String projectName,
+ @Assisted RefDatabase refDb) {
+ super(
+ sharedRefDb,
+ validationMetrics,
+ refEnforcement,
+ lockWrapperFactory,
+ projectsFilter,
+ projectName,
+ refDb);
+ }
+
+ public void executeBatchUpdateWithValidation(
+ BatchRefUpdate batchRefUpdate, NoParameterVoidFunction batchRefUpdateFunction)
+ throws IOException {
+ if (refEnforcement.getPolicy(projectName) == EnforcePolicy.IGNORED
+ || !isGlobalProject(projectName)) {
+ batchRefUpdateFunction.invoke();
+ return;
+ }
+
+ try {
+ doExecuteBatchUpdate(batchRefUpdate, batchRefUpdateFunction);
+ } catch (IOException e) {
+ logger.atWarning().withCause(e).log(
+ "Failed to execute Batch Update on project %s", projectName);
+ if (refEnforcement.getPolicy(projectName) == EnforcePolicy.REQUIRED) {
+ throw e;
+ }
+ }
+ }
+
+ private void doExecuteBatchUpdate(
+ BatchRefUpdate batchRefUpdate, NoParameterVoidFunction delegateUpdate) throws IOException {
+
+ List<ReceiveCommand> commands = batchRefUpdate.getCommands();
+ if (commands.isEmpty()) {
+ return;
+ }
+
+ List<RefPair> refsToUpdate = getRefsPairs(commands).collect(Collectors.toList());
+ List<RefPair> refsFailures =
+ refsToUpdate.stream().filter(RefPair::hasFailed).collect(Collectors.toList());
+ if (!refsFailures.isEmpty()) {
+ String allFailuresMessage =
+ refsFailures.stream()
+ .map(refPair -> String.format("Failed to fetch ref %s", refPair.compareRef.getName()))
+ .collect(Collectors.joining(", "));
+ Exception firstFailureException = refsFailures.get(0).exception;
+
+ logger.atSevere().withCause(firstFailureException).log(allFailuresMessage);
+ throw new IOException(allFailuresMessage, firstFailureException);
+ }
+
+ try (CloseableSet<AutoCloseable> locks = new CloseableSet<>()) {
+ refsToUpdate = compareAndGetLatestLocalRefs(refsToUpdate, locks);
+ delegateUpdate.invoke();
+ updateSharedRefDb(batchRefUpdate.getCommands().stream(), refsToUpdate);
+ } catch (OutOfSyncException e) {
+ List<ReceiveCommand> receiveCommands = batchRefUpdate.getCommands();
+ logger.atWarning().withCause(e).log(
+ String.format(
+ "Batch ref-update failing because node is out of sync with the shared ref-db. Set all commands Result to LOCK_FAILURE [%d]",
+ receiveCommands.size()));
+ receiveCommands.forEach((command) -> command.setResult(ReceiveCommand.Result.LOCK_FAILURE));
+ }
+ }
+
+ private void updateSharedRefDb(Stream<ReceiveCommand> commandStream, List<RefPair> refsToUpdate)
+ throws IOException {
+ if (commandStream
+ .filter(cmd -> cmd.getResult() != ReceiveCommand.Result.OK)
+ .findFirst()
+ .isPresent()) {
+ return;
+ }
+
+ for (RefPair refPair : refsToUpdate) {
+ updateSharedDbOrThrowExceptionFor(refPair);
+ }
+ }
+
+ private Stream<RefPair> getRefsPairs(List<ReceiveCommand> receivedCommands) {
+ return receivedCommands.stream().map(this::getRefPairForCommand);
+ }
+
+ private RefPair getRefPairForCommand(ReceiveCommand command) {
+ try {
+ switch (command.getType()) {
+ case CREATE:
+ return new RefPair(nullRef(command.getRefName()), getNewRef(command));
+
+ case UPDATE:
+ case UPDATE_NONFASTFORWARD:
+ return new RefPair(getCurrentRef(command.getRefName()), getNewRef(command));
+
+ case DELETE:
+ return new RefPair(getCurrentRef(command.getRefName()), ObjectId.zeroId());
+
+ default:
+ return new RefPair(
+ command.getRef(),
+ new IllegalArgumentException("Unsupported command type " + command.getType()));
+ }
+ } catch (IOException e) {
+ return new RefPair(command.getRef(), e);
+ }
+ }
+
+ private ObjectId getNewRef(ReceiveCommand command) {
+ return command.getNewId();
+ }
+
+ private List<RefPair> compareAndGetLatestLocalRefs(
+ List<RefPair> refsToUpdate, CloseableSet<AutoCloseable> locks) throws IOException {
+ List<RefPair> latestRefsToUpdate = new ArrayList<>();
+ for (RefPair refPair : refsToUpdate) {
+ latestRefsToUpdate.add(compareAndGetLatestLocalRef(refPair, locks));
+ }
+ return latestRefsToUpdate;
+ }
+
+ private static final Ref nullRef(String refName) {
+ return new ObjectIdRef.Unpeeled(Ref.Storage.NETWORK, refName, ObjectId.zeroId());
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/LibModule.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/LibModule.java
new file mode 100644
index 0000000..49b20d8
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/LibModule.java
@@ -0,0 +1,37 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.gerritforge.gerrit.globalrefdb.GlobalRefDatabase;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.NoopSharedRefDatabase;
+import com.google.gerrit.extensions.registration.DynamicItem;
+import com.google.gerrit.lifecycle.LifecycleModule;
+import com.google.inject.Scopes;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LibModule extends LifecycleModule {
+ private static final Logger log = LoggerFactory.getLogger(LibModule.class);
+
+ @Override
+ protected void configure() {
+ DynamicItem.itemOf(binder(), GlobalRefDatabase.class);
+ DynamicItem.bind(binder(), GlobalRefDatabase.class)
+ .to(NoopSharedRefDatabase.class)
+ .in(Scopes.SINGLETON);
+
+ log.info("Shared ref-db engine: none");
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/LibModuleLogFile.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/LibModuleLogFile.java
new file mode 100644
index 0000000..075bcc9
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/LibModuleLogFile.java
@@ -0,0 +1,32 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.google.gerrit.server.util.SystemLog;
+import org.apache.log4j.AsyncAppender;
+import org.apache.log4j.Layout;
+import org.apache.log4j.LogManager;
+import org.apache.log4j.Logger;
+
+public abstract class LibModuleLogFile {
+
+ public LibModuleLogFile(SystemLog systemLog, String logName, Layout layout) {
+ AsyncAppender asyncAppender = systemLog.createAsyncAppender(logName, layout, true, true);
+ Logger logger = LogManager.getLogger(logName);
+ logger.removeAppender(logName);
+ logger.addAppender(asyncAppender);
+ logger.setAdditivity(false);
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/LockWrapper.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/LockWrapper.java
new file mode 100644
index 0000000..18d75a3
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/LockWrapper.java
@@ -0,0 +1,50 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+
+public class LockWrapper implements AutoCloseable {
+ public interface Factory {
+ LockWrapper create(
+ @Assisted("project") String project,
+ @Assisted("refName") String refName,
+ @Assisted AutoCloseable lock);
+ }
+
+ private final String project;
+ private final String refName;
+ private final AutoCloseable lock;
+ private final SharedRefLogger sharedRefLogger;
+
+ @Inject
+ public LockWrapper(
+ SharedRefLogger sharedRefLogger,
+ @Assisted("project") String project,
+ @Assisted("refName") String refName,
+ @Assisted AutoCloseable lock) {
+ this.lock = lock;
+ this.sharedRefLogger = sharedRefLogger;
+ this.project = project;
+ this.refName = refName;
+ }
+
+ @Override
+ public void close() throws Exception {
+ lock.close();
+ sharedRefLogger.logLockRelease(project, refName);
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/Log4jSharedRefLogger.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/Log4jSharedRefLogger.java
new file mode 100644
index 0000000..5653ee2
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/Log4jSharedRefLogger.java
@@ -0,0 +1,141 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
+import static org.eclipse.jgit.lib.Constants.OBJ_COMMIT;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.flogger.FluentLogger;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.extensions.common.GitPerson;
+import com.google.gerrit.json.OutputFormat;
+import com.google.gerrit.server.CommonConverters;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.gerrit.server.util.SystemLog;
+import com.google.gson.Gson;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.io.IOException;
+import org.apache.log4j.PatternLayout;
+import org.eclipse.jgit.errors.IncorrectObjectTypeException;
+import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Singleton
+public class Log4jSharedRefLogger extends LibModuleLogFile implements SharedRefLogger {
+ private static final String LOG_NAME = "sharedref_log";
+ private Logger sharedRefDBLog;
+ private final GitRepositoryManager gitRepositoryManager;
+ private static final Gson gson = OutputFormat.JSON_COMPACT.newGson();
+
+ private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+
+ @Inject
+ public Log4jSharedRefLogger(SystemLog systemLog, GitRepositoryManager gitRepositoryManager) {
+ super(systemLog, LOG_NAME, new PatternLayout("[%d{ISO8601}] [%t] %-5p : %m%n"));
+ this.gitRepositoryManager = gitRepositoryManager;
+ sharedRefDBLog = LoggerFactory.getLogger(LOG_NAME);
+ }
+
+ @Override
+ public void logRefUpdate(String project, Ref currRef, ObjectId newRefValue) {
+ if (!ObjectId.zeroId().equals(newRefValue)) {
+ try (Repository repository = gitRepositoryManager.openRepository(Project.nameKey(project));
+ RevWalk walk = new RevWalk(repository)) {
+ GitPerson committer = null;
+ String commitMessage = null;
+ if (newRefValue != null) {
+ int objectType = walk.parseAny(newRefValue).getType();
+ switch (objectType) {
+ case OBJ_COMMIT:
+ RevCommit commit = walk.parseCommit(newRefValue);
+ committer = CommonConverters.toGitPerson(commit.getCommitterIdent());
+ commitMessage = commit.getShortMessage();
+ break;
+ case OBJ_BLOB:
+ break;
+ default:
+ throw new IncorrectObjectTypeException(newRefValue, Constants.typeString(objectType));
+ }
+ }
+ sharedRefDBLog.info(
+ gson.toJson(
+ new SharedRefLogEntry.UpdateRef(
+ project,
+ currRef.getName(),
+ currRef.getObjectId().getName(),
+ newRefValue == null ? ObjectId.zeroId().name() : newRefValue.getName(),
+ committer,
+ commitMessage)));
+ } catch (IOException e) {
+ logger.atSevere().withCause(e).log(
+ "Cannot log sharedRefDB interaction for ref %s on project %s",
+ currRef.getName(), project);
+ }
+ } else {
+ sharedRefDBLog.info(
+ gson.toJson(
+ new SharedRefLogEntry.DeleteRef(
+ project, currRef.getName(), currRef.getObjectId().getName())));
+ }
+ }
+
+ @Override
+ public <T> void logRefUpdate(String project, String refName, T currRef, T newRefValue) {
+ if (newRefValue != null) {
+ sharedRefDBLog.info(
+ gson.toJson(
+ new SharedRefLogEntry.UpdateRef(
+ project, refName, safeToString(currRef), safeToString(newRefValue), null, null)));
+ } else {
+ sharedRefDBLog.info(
+ gson.toJson(new SharedRefLogEntry.DeleteRef(project, refName, safeToString(currRef))));
+ }
+ }
+
+ @Override
+ public void logProjectDelete(String project) {
+ sharedRefDBLog.info(gson.toJson(new SharedRefLogEntry.DeleteProject(project)));
+ }
+
+ @Override
+ public void logLockAcquisition(String project, String refName) {
+ sharedRefDBLog.info(gson.toJson(new SharedRefLogEntry.LockAcquire(project, refName)));
+ }
+
+ @Override
+ public void logLockRelease(String project, String refName) {
+ sharedRefDBLog.info(gson.toJson(new SharedRefLogEntry.LockRelease(project, refName)));
+ }
+
+ @VisibleForTesting
+ public void setLogger(Logger logger) {
+ this.sharedRefDBLog = logger;
+ }
+
+ private <T> String safeToString(T currRef) {
+ if (currRef == null) {
+ return "<null>";
+ }
+ return currRef.toString();
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectDeletedSharedDbCleanup.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectDeletedSharedDbCleanup.java
new file mode 100644
index 0000000..ec72bcc
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectDeletedSharedDbCleanup.java
@@ -0,0 +1,53 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.gerritforge.gerrit.globalrefdb.GlobalRefDbSystemError;
+import com.google.common.flogger.FluentLogger;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.extensions.events.ProjectDeletedListener;
+import com.google.inject.Inject;
+
+public class ProjectDeletedSharedDbCleanup implements ProjectDeletedListener {
+ private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+
+ private final SharedRefDatabaseWrapper sharedDb;
+
+ private final ValidationMetrics validationMetrics;
+
+ @Inject
+ public ProjectDeletedSharedDbCleanup(
+ SharedRefDatabaseWrapper sharedDb, ValidationMetrics validationMetrics) {
+ this.sharedDb = sharedDb;
+ this.validationMetrics = validationMetrics;
+ }
+
+ @Override
+ public void onProjectDeleted(Event event) {
+ String projectName = event.getProjectName();
+ logger.atInfo().log(
+ "Deleting project '%s'. Will perform a cleanup in Shared-Ref database.", projectName);
+
+ try {
+ sharedDb.remove(Project.nameKey(projectName));
+ } catch (GlobalRefDbSystemError e) {
+ validationMetrics.incrementSplitBrain();
+ logger.atSevere().withCause(e).log(
+ "Project '%s' deleted from GIT but it was not able to cleanup"
+ + " from Shared-Ref database",
+ projectName);
+ }
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectsFilter.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectsFilter.java
new file mode 100644
index 0000000..3121df4
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectsFilter.java
@@ -0,0 +1,112 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.google.common.base.Strings;
+import com.google.common.collect.Sets;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.entities.Project.NameKey;
+import com.google.gerrit.server.events.Event;
+import com.google.gerrit.server.events.ProjectEvent;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import java.util.Set;
+
+// import com.google.gerrit.entities.AccessSection;
+
+@Singleton
+public class ProjectsFilter {
+ public enum PatternType {
+ REGEX,
+ WILDCARD,
+ EXACT_MATCH;
+
+ public static PatternType getPatternType(String pattern) {
+ // TODO: Use AccessSection
+ if (pattern.startsWith("^")) {
+ // if (pattern.startsWith(AccessSection.REGEX_PREFIX)) {
+ return REGEX;
+ } else if (pattern.endsWith("*")) {
+ return WILDCARD;
+ } else {
+ return EXACT_MATCH;
+ }
+ }
+ }
+
+ private Set<NameKey> globalProjects = Sets.newConcurrentHashSet();
+ private Set<NameKey> localProjects = Sets.newConcurrentHashSet();
+ private final List<String> projectPatterns;
+
+ @Inject
+ public ProjectsFilter(SharedRefDbConfiguration cfg) {
+ projectPatterns = cfg.projects().getPatterns();
+ }
+
+ public boolean matches(Event event) {
+ if (event == null) {
+ throw new IllegalArgumentException("Event object cannot be null");
+ }
+ if (event instanceof ProjectEvent) {
+ return matches(((ProjectEvent) event).getProjectNameKey());
+ }
+ return false;
+ }
+
+ public boolean matches(String projectName) {
+ return matches(NameKey.parse(projectName));
+ }
+
+ public boolean matches(Project.NameKey name) {
+ if (name == null || Strings.isNullOrEmpty(name.get())) {
+ throw new IllegalArgumentException(
+ String.format("Project name cannot be null or empty, but was %s", name));
+ }
+ if (projectPatterns.isEmpty() || globalProjects.contains(name)) {
+ return true;
+ }
+
+ if (localProjects.contains(name)) {
+ return false;
+ }
+
+ String projectName = name.get();
+
+ for (String pattern : projectPatterns) {
+ if (matchesPattern(projectName, pattern)) {
+ globalProjects.add(name);
+ return true;
+ }
+ }
+ localProjects.add(name);
+ return false;
+ }
+
+ private boolean matchesPattern(String projectName, String pattern) {
+ boolean match = false;
+ switch (PatternType.getPatternType(pattern)) {
+ case REGEX:
+ match = projectName.matches(pattern);
+ break;
+ case WILDCARD:
+ match = projectName.startsWith(pattern.substring(0, pattern.length() - 1));
+ break;
+ case EXACT_MATCH:
+ match = projectName.equals(pattern);
+ }
+ return match;
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/RefPair.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/RefPair.java
new file mode 100644
index 0000000..7156a7e
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/RefPair.java
@@ -0,0 +1,47 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+
+public class RefPair {
+ public final Ref compareRef;
+ public final ObjectId putValue;
+ public final Exception exception;
+
+ RefPair(Ref oldRef, ObjectId newRefValue) {
+ if (oldRef == null) {
+ throw new IllegalArgumentException("Required not-null ref in RefPair");
+ }
+ this.compareRef = oldRef;
+ this.putValue = newRefValue;
+ this.exception = null;
+ }
+
+ RefPair(Ref newRef, Exception e) {
+ this.compareRef = newRef;
+ this.exception = e;
+ this.putValue = ObjectId.zeroId();
+ }
+
+ public String getName() {
+ return compareRef.getName();
+ }
+
+ public boolean hasFailed() {
+ return exception != null;
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/RefUpdateValidator.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/RefUpdateValidator.java
new file mode 100644
index 0000000..123e382
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/RefUpdateValidator.java
@@ -0,0 +1,295 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.gerritforge.gerrit.globalrefdb.GlobalRefDbSystemError;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.OutOfSyncException;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedDbSplitBrainException;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedLockException;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedRefEnforcement;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedRefEnforcement.EnforcePolicy;
+import com.google.common.base.MoreObjects;
+import com.google.common.flogger.FluentLogger;
+import com.google.gerrit.entities.Project;
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.io.IOException;
+import java.util.HashMap;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.ObjectIdRef;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RefUpdate;
+
+public class RefUpdateValidator {
+ private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+
+ public static final String SHARED_REF_DB_VERSIONING_REF = "refs/global-refdb/version";
+
+ protected final SharedRefDatabaseWrapper sharedRefDb;
+ protected final ValidationMetrics validationMetrics;
+
+ protected final String projectName;
+ private final LockWrapper.Factory lockWrapperFactory;
+ protected final RefDatabase refDb;
+ protected final SharedRefEnforcement refEnforcement;
+ protected final ProjectsFilter projectsFilter;
+
+ public static interface Factory {
+ RefUpdateValidator create(String projectName, RefDatabase refDb);
+ }
+
+ public interface ExceptionThrowingSupplier<T, E extends Exception> {
+ T create() throws E;
+ }
+
+ public interface RefValidationWrapper {
+ RefUpdate.Result apply(NoParameterFunction<RefUpdate.Result> arg, RefUpdate refUpdate)
+ throws IOException;
+ }
+
+ public interface NoParameterFunction<T> {
+ T invoke() throws IOException;
+ }
+
+ public interface NoParameterVoidFunction {
+ void invoke() throws IOException;
+ }
+
+ @Inject
+ public RefUpdateValidator(
+ SharedRefDatabaseWrapper sharedRefDb,
+ ValidationMetrics validationMetrics,
+ SharedRefEnforcement refEnforcement,
+ LockWrapper.Factory lockWrapperFactory,
+ ProjectsFilter projectsFilter,
+ @Assisted String projectName,
+ @Assisted RefDatabase refDb) {
+ this.sharedRefDb = sharedRefDb;
+ this.validationMetrics = validationMetrics;
+ this.lockWrapperFactory = lockWrapperFactory;
+ this.refDb = refDb;
+ this.projectName = projectName;
+ this.refEnforcement = refEnforcement;
+ this.projectsFilter = projectsFilter;
+ }
+
+ public RefUpdate.Result executeRefUpdate(
+ RefUpdate refUpdate, NoParameterFunction<RefUpdate.Result> refUpdateFunction)
+ throws IOException {
+ if (isProjectVersionUpdate(refUpdate.getName())
+ || !isGlobalProject(projectName)
+ || refEnforcement.getPolicy(projectName) == EnforcePolicy.IGNORED) {
+ return refUpdateFunction.invoke();
+ }
+
+ try {
+ return doExecuteRefUpdate(refUpdate, refUpdateFunction);
+ } catch (SharedDbSplitBrainException e) {
+ validationMetrics.incrementSplitBrain();
+
+ logger.atWarning().withCause(e).log(
+ "Unable to execute ref-update on project=%s ref=%s",
+ projectName, refUpdate.getRef().getName());
+ if (refEnforcement.getPolicy(projectName) == EnforcePolicy.REQUIRED) {
+ throw e;
+ }
+ }
+ return null;
+ }
+
+ private Boolean isProjectVersionUpdate(String refName) {
+ Boolean isProjectVersionUpdate = refName.equals(SHARED_REF_DB_VERSIONING_REF);
+ logger.atFine().log("Is project version update? " + isProjectVersionUpdate);
+ return isProjectVersionUpdate;
+ }
+
+ private <T extends Throwable> void softFailBasedOnEnforcement(T e, EnforcePolicy policy)
+ throws T {
+ logger.atWarning().withCause(e).log(
+ String.format(
+ "Failure while running with policy enforcement %s. Error message: %s",
+ policy, e.getMessage()));
+ if (policy == EnforcePolicy.REQUIRED) {
+ throw e;
+ }
+ }
+
+ protected Boolean isGlobalProject(String projectName) {
+ Boolean isGlobalProject = projectsFilter.matches(projectName);
+ logger.atFine().log("Is global project? " + isGlobalProject);
+ return isGlobalProject;
+ }
+
+ protected RefUpdate.Result doExecuteRefUpdate(
+ RefUpdate refUpdate, NoParameterFunction<RefUpdate.Result> refUpdateFunction)
+ throws IOException {
+ try (CloseableSet<AutoCloseable> locks = new CloseableSet<>()) {
+ RefPair refPairForUpdate = newRefPairFrom(refUpdate);
+ compareAndGetLatestLocalRef(refPairForUpdate, locks);
+ RefUpdate.Result result = refUpdateFunction.invoke();
+ if (isSuccessful(result)) {
+ updateSharedDbOrThrowExceptionFor(refPairForUpdate);
+ }
+ return result;
+ } catch (OutOfSyncException e) {
+ logger.atWarning().withCause(e).log(
+ String.format("Local node is out of sync with ref-db: %s", e.getMessage()));
+
+ return RefUpdate.Result.LOCK_FAILURE;
+ }
+ }
+
+ protected void updateSharedDbOrThrowExceptionFor(RefPair refPair) throws IOException {
+ // We are not checking refs that should be ignored
+ final EnforcePolicy refEnforcementPolicy =
+ refEnforcement.getPolicy(projectName, refPair.getName());
+ if (refEnforcementPolicy == EnforcePolicy.IGNORED) return;
+
+ String errorMessage =
+ String.format(
+ "Not able to persist the data in Zookeeper for project '%s' and ref '%s',"
+ + "the cluster is now in Split Brain since the commit has been "
+ + "persisted locally but not in SharedRef the value %s",
+ projectName, refPair.getName(), refPair.putValue);
+ boolean succeeded;
+ try {
+ succeeded =
+ sharedRefDb.compareAndPut(
+ Project.nameKey(projectName), refPair.compareRef, refPair.putValue);
+ } catch (GlobalRefDbSystemError e) {
+ logger.atWarning().withCause(e).log(
+ "Not able to persist the data in Zookeeper for project '{}' and ref '{}', message: {}",
+ projectName,
+ refPair.getName(),
+ e.getMessage());
+ throw new SharedDbSplitBrainException(errorMessage, e);
+ }
+
+ if (!succeeded) {
+ throw new SharedDbSplitBrainException(errorMessage);
+ }
+ }
+
+ protected RefPair compareAndGetLatestLocalRef(RefPair refPair, CloseableSet<AutoCloseable> locks)
+ throws SharedLockException, OutOfSyncException, IOException {
+ String refName = refPair.getName();
+ EnforcePolicy refEnforcementPolicy = refEnforcement.getPolicy(projectName, refName);
+ if (refEnforcementPolicy == EnforcePolicy.IGNORED) {
+ return refPair;
+ }
+
+ locks.addResourceIfNotExist(
+ String.format("%s-%s", projectName, refName),
+ () ->
+ lockWrapperFactory.create(
+ projectName, refName, sharedRefDb.lockRef(Project.nameKey(projectName), refName)));
+
+ RefPair latestRefPair = getLatestLocalRef(refPair);
+ if (sharedRefDb.isUpToDate(Project.nameKey(projectName), latestRefPair.compareRef)) {
+ return latestRefPair;
+ }
+
+ if (isNullRef(latestRefPair.compareRef)
+ || sharedRefDb.exists(Project.nameKey(projectName), refName)) {
+ validationMetrics.incrementSplitBrainPrevention();
+
+ softFailBasedOnEnforcement(
+ new OutOfSyncException(projectName, latestRefPair.compareRef), refEnforcementPolicy);
+ }
+
+ return latestRefPair;
+ }
+
+ private boolean isNullRef(Ref ref) {
+ return ref.getObjectId().equals(ObjectId.zeroId());
+ }
+
+ private RefPair getLatestLocalRef(RefPair refPair) throws IOException {
+ Ref latestRef = refDb.exactRef(refPair.getName());
+ return new RefPair(
+ latestRef == null ? nullRef(refPair.getName()) : latestRef, refPair.putValue);
+ }
+
+ private Ref nullRef(String name) {
+ return new ObjectIdRef.Unpeeled(Ref.Storage.NETWORK, name, ObjectId.zeroId());
+ }
+
+ protected boolean isSuccessful(RefUpdate.Result result) {
+ switch (result) {
+ case NEW:
+ case FORCED:
+ case FAST_FORWARD:
+ case NO_CHANGE:
+ case RENAMED:
+ return true;
+
+ case REJECTED_OTHER_REASON:
+ case REJECTED_MISSING_OBJECT:
+ case REJECTED_CURRENT_BRANCH:
+ case NOT_ATTEMPTED:
+ case LOCK_FAILURE:
+ case IO_FAILURE:
+ case REJECTED:
+ default:
+ return false;
+ }
+ }
+
+ protected RefPair newRefPairFrom(RefUpdate refUpdate) throws IOException {
+ return new RefPair(getCurrentRef(refUpdate.getName()), refUpdate.getNewObjectId());
+ }
+
+ protected Ref getCurrentRef(String refName) throws IOException {
+ return MoreObjects.firstNonNull(refDb.findRef(refName), nullRef(refName));
+ }
+
+ public static class CloseableSet<T extends AutoCloseable> implements AutoCloseable {
+ private final HashMap<String, AutoCloseable> elements;
+
+ public CloseableSet() {
+ this(new HashMap<>());
+ }
+
+ public CloseableSet(HashMap<String, AutoCloseable> elements) {
+ this.elements = elements;
+ }
+
+ public void addResourceIfNotExist(
+ String key, ExceptionThrowingSupplier<T, SharedLockException> resourceFactory)
+ throws SharedLockException {
+ if (!elements.containsKey(key)) {
+ elements.put(key, resourceFactory.create());
+ }
+ }
+
+ @Override
+ public void close() {
+ elements.values().stream()
+ .forEach(
+ closeable -> {
+ try {
+ closeable.close();
+ } catch (Exception closingException) {
+ logger.atSevere().withCause(closingException).log(
+ "Exception trying to release resource %s, "
+ + "the locked resources won't be accessible in all cluster unless"
+ + " the lock is removed from ZK manually",
+ closeable);
+ }
+ });
+ }
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDatabaseWrapper.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDatabaseWrapper.java
new file mode 100644
index 0000000..d9c8051
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDatabaseWrapper.java
@@ -0,0 +1,102 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.gerritforge.gerrit.globalrefdb.GlobalRefDatabase;
+import com.gerritforge.gerrit.globalrefdb.GlobalRefDbLockException;
+import com.gerritforge.gerrit.globalrefdb.GlobalRefDbSystemError;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.NoopSharedRefDatabase;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.extensions.registration.DynamicItem;
+import com.google.inject.Inject;
+import java.util.Optional;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+
+public class SharedRefDatabaseWrapper implements GlobalRefDatabase {
+ private static final GlobalRefDatabase NOOP_REFDB = new NoopSharedRefDatabase();
+
+ @Inject(optional = true)
+ private DynamicItem<GlobalRefDatabase> sharedRefDbDynamicItem;
+
+ private final SharedRefLogger sharedRefLogger;
+
+ @Inject
+ public SharedRefDatabaseWrapper(SharedRefLogger sharedRefLogger) {
+ this.sharedRefLogger = sharedRefLogger;
+ }
+
+ @VisibleForTesting
+ public SharedRefDatabaseWrapper(
+ DynamicItem<GlobalRefDatabase> sharedRefDbDynamicItem, SharedRefLogger sharedRefLogger) {
+ this.sharedRefLogger = sharedRefLogger;
+ this.sharedRefDbDynamicItem = sharedRefDbDynamicItem;
+ }
+
+ @Override
+ public boolean isUpToDate(Project.NameKey project, Ref ref) throws GlobalRefDbLockException {
+ return sharedRefDb().isUpToDate(project, ref);
+ }
+
+ @Override
+ public boolean compareAndPut(Project.NameKey project, Ref currRef, ObjectId newRefValue)
+ throws GlobalRefDbSystemError {
+ boolean succeeded = sharedRefDb().compareAndPut(project, currRef, newRefValue);
+ if (succeeded) {
+ sharedRefLogger.logRefUpdate(project.get(), currRef, newRefValue);
+ }
+ return succeeded;
+ }
+
+ @Override
+ public <T> boolean compareAndPut(Project.NameKey project, String refName, T currValue, T newValue)
+ throws GlobalRefDbSystemError {
+ boolean succeeded = sharedRefDb().compareAndPut(project, refName, currValue, newValue);
+ if (succeeded) {
+ sharedRefLogger.logRefUpdate(project.get(), refName, currValue, newValue);
+ }
+ return succeeded;
+ }
+
+ @Override
+ public AutoCloseable lockRef(Project.NameKey project, String refName)
+ throws GlobalRefDbLockException {
+ AutoCloseable locker = sharedRefDb().lockRef(project, refName);
+ sharedRefLogger.logLockAcquisition(project.get(), refName);
+ return locker;
+ }
+
+ @Override
+ public boolean exists(Project.NameKey project, String refName) {
+ return sharedRefDb().exists(project, refName);
+ }
+
+ @Override
+ public void remove(Project.NameKey project) throws GlobalRefDbSystemError {
+ sharedRefDb().remove(project);
+ sharedRefLogger.logProjectDelete(project.get());
+ }
+
+ @Override
+ public <T> Optional<T> get(Project.NameKey nameKey, String s, Class<T> clazz)
+ throws GlobalRefDbSystemError {
+ return sharedRefDb().get(nameKey, s, clazz);
+ }
+
+ private GlobalRefDatabase sharedRefDb() {
+ return Optional.ofNullable(sharedRefDbDynamicItem).map(di -> di.get()).orElse(NOOP_REFDB);
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbBatchRefUpdate.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbBatchRefUpdate.java
new file mode 100644
index 0000000..5d23c32
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbBatchRefUpdate.java
@@ -0,0 +1,185 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.List;
+import org.eclipse.jgit.lib.BatchRefUpdate;
+import org.eclipse.jgit.lib.PersonIdent;
+import org.eclipse.jgit.lib.ProgressMonitor;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.transport.PushCertificate;
+import org.eclipse.jgit.transport.ReceiveCommand;
+import org.eclipse.jgit.util.time.ProposedTimestamp;
+
+public class SharedRefDbBatchRefUpdate extends BatchRefUpdate {
+
+ private final BatchRefUpdate batchRefUpdate;
+ private final String project;
+ private final BatchRefUpdateValidator.Factory batchRefValidatorFactory;
+ private final RefDatabase refDb;
+
+ public static interface Factory {
+ SharedRefDbBatchRefUpdate create(String project, RefDatabase refDb);
+ }
+
+ @Inject
+ public SharedRefDbBatchRefUpdate(
+ BatchRefUpdateValidator.Factory batchRefValidatorFactory,
+ @Assisted String project,
+ @Assisted RefDatabase refDb) {
+ super(refDb);
+ this.refDb = refDb;
+ this.project = project;
+ this.batchRefUpdate = refDb.newBatchUpdate();
+ this.batchRefValidatorFactory = batchRefValidatorFactory;
+ }
+
+ @Override
+ public int hashCode() {
+ return batchRefUpdate.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return batchRefUpdate.equals(obj);
+ }
+
+ @Override
+ public boolean isAllowNonFastForwards() {
+ return batchRefUpdate.isAllowNonFastForwards();
+ }
+
+ @Override
+ public BatchRefUpdate setAllowNonFastForwards(boolean allow) {
+ return batchRefUpdate.setAllowNonFastForwards(allow);
+ }
+
+ @Override
+ public PersonIdent getRefLogIdent() {
+ return batchRefUpdate.getRefLogIdent();
+ }
+
+ @Override
+ public BatchRefUpdate setRefLogIdent(PersonIdent pi) {
+ return batchRefUpdate.setRefLogIdent(pi);
+ }
+
+ @Override
+ public String getRefLogMessage() {
+ return batchRefUpdate.getRefLogMessage();
+ }
+
+ @Override
+ public boolean isRefLogIncludingResult() {
+ return batchRefUpdate.isRefLogIncludingResult();
+ }
+
+ @Override
+ public BatchRefUpdate setRefLogMessage(String msg, boolean appendStatus) {
+ return batchRefUpdate.setRefLogMessage(msg, appendStatus);
+ }
+
+ @Override
+ public BatchRefUpdate disableRefLog() {
+ return batchRefUpdate.disableRefLog();
+ }
+
+ @Override
+ public BatchRefUpdate setForceRefLog(boolean force) {
+ return batchRefUpdate.setForceRefLog(force);
+ }
+
+ @Override
+ public boolean isRefLogDisabled() {
+ return batchRefUpdate.isRefLogDisabled();
+ }
+
+ @Override
+ public BatchRefUpdate setAtomic(boolean atomic) {
+ return batchRefUpdate.setAtomic(atomic);
+ }
+
+ @Override
+ public boolean isAtomic() {
+ return batchRefUpdate.isAtomic();
+ }
+
+ @Override
+ public void setPushCertificate(PushCertificate cert) {
+ batchRefUpdate.setPushCertificate(cert);
+ }
+
+ @Override
+ public List<ReceiveCommand> getCommands() {
+ return batchRefUpdate.getCommands();
+ }
+
+ @Override
+ public BatchRefUpdate addCommand(ReceiveCommand cmd) {
+ return batchRefUpdate.addCommand(cmd);
+ }
+
+ @Override
+ public BatchRefUpdate addCommand(ReceiveCommand... cmd) {
+ return batchRefUpdate.addCommand(cmd);
+ }
+
+ @Override
+ public BatchRefUpdate addCommand(Collection<ReceiveCommand> cmd) {
+ return batchRefUpdate.addCommand(cmd);
+ }
+
+ @Override
+ public List<String> getPushOptions() {
+ return batchRefUpdate.getPushOptions();
+ }
+
+ @Override
+ public List<ProposedTimestamp> getProposedTimestamps() {
+ return batchRefUpdate.getProposedTimestamps();
+ }
+
+ @Override
+ public BatchRefUpdate addProposedTimestamp(ProposedTimestamp ts) {
+ return batchRefUpdate.addProposedTimestamp(ts);
+ }
+
+ @Override
+ public void execute(RevWalk walk, ProgressMonitor monitor, List<String> options)
+ throws IOException {
+ batchRefValidatorFactory
+ .create(project, refDb)
+ .executeBatchUpdateWithValidation(
+ batchRefUpdate, () -> batchRefUpdate.execute(walk, monitor, options));
+ }
+
+ @Override
+ public void execute(RevWalk walk, ProgressMonitor monitor) throws IOException {
+ batchRefValidatorFactory
+ .create(project, refDb)
+ .executeBatchUpdateWithValidation(
+ batchRefUpdate, () -> batchRefUpdate.execute(walk, monitor));
+ }
+
+ @Override
+ public String toString() {
+ return batchRefUpdate.toString();
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbConfiguration.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbConfiguration.java
new file mode 100644
index 0000000..3708f74
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbConfiguration.java
@@ -0,0 +1,127 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import static com.google.common.base.Suppliers.memoize;
+import static com.google.common.base.Suppliers.ofInstance;
+
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedRefEnforcement.EnforcePolicy;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.MultimapBuilder;
+import java.io.IOException;
+import java.util.List;
+import org.eclipse.jgit.errors.ConfigInvalidException;
+import org.eclipse.jgit.lib.Config;
+import org.eclipse.jgit.storage.file.FileBasedConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SharedRefDbConfiguration {
+ private static final Logger log = LoggerFactory.getLogger(SharedRefDbConfiguration.class);
+
+ private final Supplier<Projects> projects;
+ private final Supplier<SharedRefDatabase> sharedRefDb;
+
+ public SharedRefDbConfiguration(Config config) {
+ Supplier<Config> lazyCfg = lazyLoad(config);
+ projects = memoize(() -> new Projects(lazyCfg));
+ sharedRefDb = memoize(() -> new SharedRefDatabase(lazyCfg));
+ }
+
+ public SharedRefDatabase getSharedRefDb() {
+ return sharedRefDb.get();
+ }
+
+ public Projects projects() {
+ return projects.get();
+ }
+
+ private Supplier<Config> lazyLoad(Config config) {
+ if (config instanceof FileBasedConfig) {
+ return memoize(
+ () -> {
+ FileBasedConfig fileConfig = (FileBasedConfig) config;
+ String fileConfigFileName = fileConfig.getFile().getPath();
+ try {
+ log.info("Loading configuration from {}", fileConfigFileName);
+ fileConfig.load();
+ } catch (IOException | ConfigInvalidException e) {
+ log.error("Unable to load configuration from " + fileConfigFileName, e);
+ }
+ return fileConfig;
+ });
+ }
+ return ofInstance(config);
+ }
+
+ public static class SharedRefDatabase {
+ public static final String SECTION = "ref-database";
+ public static final String ENABLE_KEY = "enabled";
+ public static final String SUBSECTION_ENFORCEMENT_RULES = "enforcementRules";
+
+ private final boolean enabled;
+ private final Multimap<EnforcePolicy, String> enforcementRules;
+
+ private SharedRefDatabase(Supplier<Config> cfg) {
+ enabled = getBoolean(cfg, SECTION, null, ENABLE_KEY, false);
+
+ enforcementRules = MultimapBuilder.hashKeys().arrayListValues().build();
+ for (EnforcePolicy policy : EnforcePolicy.values()) {
+ enforcementRules.putAll(
+ policy, getList(cfg, SECTION, SUBSECTION_ENFORCEMENT_RULES, policy.name()));
+ }
+ }
+
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ public Multimap<EnforcePolicy, String> getEnforcementRules() {
+ return enforcementRules;
+ }
+
+ private List<String> getList(
+ Supplier<Config> cfg, String section, String subsection, String name) {
+ return ImmutableList.copyOf(cfg.get().getStringList(section, subsection, name));
+ }
+ }
+
+ public static class Projects {
+ public static final String SECTION = "projects";
+ public static final String PATTERN_KEY = "pattern";
+ public List<String> patterns;
+
+ public Projects(Supplier<Config> cfg) {
+ patterns = ImmutableList.copyOf(cfg.get().getStringList(SECTION, null, PATTERN_KEY));
+ }
+
+ public List<String> getPatterns() {
+ return patterns;
+ }
+ }
+
+ static boolean getBoolean(
+ Supplier<Config> cfg, String section, String subsection, String name, boolean defaultValue) {
+ try {
+ return cfg.get().getBoolean(section, subsection, name, defaultValue);
+ } catch (IllegalArgumentException e) {
+ log.error("invalid value for {}; using default value {}", name, defaultValue);
+ log.debug("Failed to retrieve boolean value: {}", e.getMessage(), e);
+ return defaultValue;
+ }
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbGitRepositoryManager.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbGitRepositoryManager.java
new file mode 100644
index 0000000..b533c05
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbGitRepositoryManager.java
@@ -0,0 +1,61 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.gerrit.server.git.LocalDiskRepositoryManager;
+import com.google.gerrit.server.git.RepositoryCaseMismatchException;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.io.IOException;
+import java.util.SortedSet;
+import org.eclipse.jgit.errors.RepositoryNotFoundException;
+import org.eclipse.jgit.lib.Repository;
+
+@Singleton
+public class SharedRefDbGitRepositoryManager implements GitRepositoryManager {
+ private final GitRepositoryManager gitRepositoryManager;
+ private final SharedRefDbRepository.Factory sharedRefDbRepoFactory;
+
+ @Inject
+ public SharedRefDbGitRepositoryManager(
+ SharedRefDbRepository.Factory sharedRefDbRepoFactory,
+ LocalDiskRepositoryManager localDiskRepositoryManager) {
+ this.sharedRefDbRepoFactory = sharedRefDbRepoFactory;
+ this.gitRepositoryManager = localDiskRepositoryManager;
+ }
+
+ @Override
+ public Repository openRepository(Project.NameKey name)
+ throws RepositoryNotFoundException, IOException {
+ return wrap(name, gitRepositoryManager.openRepository(name));
+ }
+
+ @Override
+ public Repository createRepository(Project.NameKey name)
+ throws RepositoryCaseMismatchException, RepositoryNotFoundException, IOException {
+ return wrap(name, gitRepositoryManager.createRepository(name));
+ }
+
+ @Override
+ public SortedSet<Project.NameKey> list() {
+ return gitRepositoryManager.list();
+ }
+
+ private Repository wrap(Project.NameKey projectName, Repository projectRepo) {
+ return sharedRefDbRepoFactory.create(projectName.get(), projectRepo);
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRefDatabase.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRefDatabase.java
new file mode 100644
index 0000000..8597c49
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRefDatabase.java
@@ -0,0 +1,160 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import org.eclipse.jgit.lib.BatchRefUpdate;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RefRename;
+import org.eclipse.jgit.lib.RefUpdate;
+
+public class SharedRefDbRefDatabase extends RefDatabase {
+ private final SharedRefDbRefUpdate.Factory refUpdateFactory;
+ private final SharedRefDbBatchRefUpdate.Factory batchRefUpdateFactory;
+ private final String projectName;
+ private final RefDatabase refDatabase;
+
+ public interface Factory {
+ public SharedRefDbRefDatabase create(String projectName, RefDatabase refDatabase);
+ }
+
+ @Inject
+ public SharedRefDbRefDatabase(
+ SharedRefDbRefUpdate.Factory refUpdateFactory,
+ SharedRefDbBatchRefUpdate.Factory batchRefUpdateFactory,
+ @Assisted String projectName,
+ @Assisted RefDatabase refDatabase) {
+ this.refUpdateFactory = refUpdateFactory;
+ this.batchRefUpdateFactory = batchRefUpdateFactory;
+ this.projectName = projectName;
+ this.refDatabase = refDatabase;
+ }
+
+ @Override
+ public int hashCode() {
+ return refDatabase.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return refDatabase.equals(obj);
+ }
+
+ @Override
+ public void create() throws IOException {
+ refDatabase.create();
+ }
+
+ @Override
+ public void close() {
+ refDatabase.close();
+ }
+
+ @Override
+ public boolean isNameConflicting(String name) throws IOException {
+ return refDatabase.isNameConflicting(name);
+ }
+
+ @Override
+ public Collection<String> getConflictingNames(String name) throws IOException {
+ return refDatabase.getConflictingNames(name);
+ }
+
+ @Override
+ public RefUpdate newUpdate(String name, boolean detach) throws IOException {
+ return wrapRefUpdate(refDatabase.newUpdate(name, detach));
+ }
+
+ @Override
+ public RefRename newRename(String fromName, String toName) throws IOException {
+ return refDatabase.newRename(fromName, toName);
+ }
+
+ @Override
+ public BatchRefUpdate newBatchUpdate() {
+ return batchRefUpdateFactory.create(projectName, refDatabase);
+ }
+
+ @Override
+ public boolean performsAtomicTransactions() {
+ return refDatabase.performsAtomicTransactions();
+ }
+
+ @Override
+ public String toString() {
+ return refDatabase.toString();
+ }
+
+ @Override
+ public Ref exactRef(String name) throws IOException {
+ return refDatabase.exactRef(name);
+ }
+
+ @Override
+ public Map<String, Ref> exactRef(String... refs) throws IOException {
+ return refDatabase.exactRef(refs);
+ }
+
+ @Override
+ public Ref firstExactRef(String... refs) throws IOException {
+ return refDatabase.firstExactRef(refs);
+ }
+
+ @Override
+ public List<Ref> getRefs() throws IOException {
+ return refDatabase.getRefs();
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ public Map<String, Ref> getRefs(String prefix) throws IOException {
+ return refDatabase.getRefs(prefix);
+ }
+
+ @Override
+ public List<Ref> getRefsByPrefix(String prefix) throws IOException {
+ return refDatabase.getRefsByPrefix(prefix);
+ }
+
+ @Override
+ public boolean hasRefs() throws IOException {
+ return refDatabase.hasRefs();
+ }
+
+ @Override
+ public List<Ref> getAdditionalRefs() throws IOException {
+ return refDatabase.getAdditionalRefs();
+ }
+
+ @Override
+ public Ref peel(Ref ref) throws IOException {
+ return refDatabase.peel(ref);
+ }
+
+ @Override
+ public void refresh() {
+ refDatabase.refresh();
+ }
+
+ RefUpdate wrapRefUpdate(RefUpdate refUpdate) {
+ return refUpdateFactory.create(projectName, refUpdate, refDatabase);
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRefUpdate.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRefUpdate.java
new file mode 100644
index 0000000..eb68b14
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRefUpdate.java
@@ -0,0 +1,237 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.io.IOException;
+import org.eclipse.jgit.lib.AnyObjectId;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.PersonIdent;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.transport.PushCertificate;
+
+public class SharedRefDbRefUpdate extends RefUpdate {
+
+ protected final RefUpdate refUpdateBase;
+ private final String projectName;
+ private final RefUpdateValidator.Factory refValidatorFactory;
+ private final RefUpdateValidator refUpdateValidator;
+
+ public interface Factory {
+ SharedRefDbRefUpdate create(String projectName, RefUpdate refUpdate, RefDatabase refDb);
+ }
+
+ @Inject
+ public SharedRefDbRefUpdate(
+ RefUpdateValidator.Factory refValidatorFactory,
+ @Assisted String projectName,
+ @Assisted RefUpdate refUpdate,
+ @Assisted RefDatabase refDb) {
+ super(refUpdate.getRef());
+ refUpdateBase = refUpdate;
+ this.projectName = projectName;
+ this.refValidatorFactory = refValidatorFactory;
+ refUpdateValidator = this.refValidatorFactory.create(this.projectName, refDb);
+ }
+
+ @Override
+ protected RefDatabase getRefDatabase() {
+ return notImplementedException();
+ }
+
+ private <T> T notImplementedException() {
+ throw new IllegalStateException("This method should have never been invoked");
+ }
+
+ @Override
+ protected Repository getRepository() {
+ return notImplementedException();
+ }
+
+ @Override
+ protected boolean tryLock(boolean deref) throws IOException {
+ return notImplementedException();
+ }
+
+ @Override
+ protected void unlock() {
+ notImplementedException();
+ }
+
+ @Override
+ protected Result doUpdate(Result result) throws IOException {
+ return notImplementedException();
+ }
+
+ @Override
+ protected Result doDelete(Result result) throws IOException {
+ return notImplementedException();
+ }
+
+ @Override
+ protected Result doLink(String target) throws IOException {
+ return notImplementedException();
+ }
+
+ @Override
+ public Result update() throws IOException {
+ return refUpdateValidator.executeRefUpdate(refUpdateBase, refUpdateBase::update);
+ }
+
+ @Override
+ public Result update(RevWalk rev) throws IOException {
+ return refUpdateValidator.executeRefUpdate(refUpdateBase, () -> refUpdateBase.update(rev));
+ }
+
+ @Override
+ public Result delete() throws IOException {
+ return refUpdateValidator.executeRefUpdate(refUpdateBase, refUpdateBase::delete);
+ }
+
+ @Override
+ public Result delete(RevWalk walk) throws IOException {
+ return refUpdateValidator.executeRefUpdate(refUpdateBase, () -> refUpdateBase.delete(walk));
+ }
+
+ @Override
+ public int hashCode() {
+ return refUpdateBase.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return refUpdateBase.equals(obj);
+ }
+
+ @Override
+ public String toString() {
+ return refUpdateBase.toString();
+ }
+
+ @Override
+ public String getName() {
+ return refUpdateBase.getName();
+ }
+
+ @Override
+ public Ref getRef() {
+ return refUpdateBase.getRef();
+ }
+
+ @Override
+ public ObjectId getNewObjectId() {
+ return refUpdateBase.getNewObjectId();
+ }
+
+ @Override
+ public void setDetachingSymbolicRef() {
+ refUpdateBase.setDetachingSymbolicRef();
+ }
+
+ @Override
+ public boolean isDetachingSymbolicRef() {
+ return refUpdateBase.isDetachingSymbolicRef();
+ }
+
+ @Override
+ public void setNewObjectId(AnyObjectId id) {
+ refUpdateBase.setNewObjectId(id);
+ }
+
+ @Override
+ public ObjectId getExpectedOldObjectId() {
+ return refUpdateBase.getExpectedOldObjectId();
+ }
+
+ @Override
+ public void setExpectedOldObjectId(AnyObjectId id) {
+ refUpdateBase.setExpectedOldObjectId(id);
+ }
+
+ @Override
+ public boolean isForceUpdate() {
+ return refUpdateBase.isForceUpdate();
+ }
+
+ @Override
+ public void setForceUpdate(boolean b) {
+ refUpdateBase.setForceUpdate(b);
+ }
+
+ @Override
+ public PersonIdent getRefLogIdent() {
+ return refUpdateBase.getRefLogIdent();
+ }
+
+ @Override
+ public void setRefLogIdent(PersonIdent pi) {
+ refUpdateBase.setRefLogIdent(pi);
+ }
+
+ @Override
+ public String getRefLogMessage() {
+ return refUpdateBase.getRefLogMessage();
+ }
+
+ @Override
+ public void setRefLogMessage(String msg, boolean appendStatus) {
+ refUpdateBase.setRefLogMessage(msg, appendStatus);
+ }
+
+ @Override
+ public void disableRefLog() {
+ refUpdateBase.disableRefLog();
+ }
+
+ @Override
+ public void setForceRefLog(boolean force) {
+ refUpdateBase.setForceRefLog(force);
+ }
+
+ @Override
+ public ObjectId getOldObjectId() {
+ return refUpdateBase.getOldObjectId();
+ }
+
+ @Override
+ public void setPushCertificate(PushCertificate cert) {
+ refUpdateBase.setPushCertificate(cert);
+ }
+
+ @Override
+ public Result getResult() {
+ return refUpdateBase.getResult();
+ }
+
+ @Override
+ public Result forceUpdate() throws IOException {
+ return refUpdateValidator.executeRefUpdate(refUpdateBase, refUpdateBase::forceUpdate);
+ }
+
+ @Override
+ public Result link(String target) throws IOException {
+ return refUpdateBase.link(target);
+ }
+
+ @Override
+ public void setCheckConflicting(boolean check) {
+ refUpdateBase.setCheckConflicting(check);
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRepository.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRepository.java
new file mode 100644
index 0000000..cdb65da
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRepository.java
@@ -0,0 +1,56 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.google.gerrit.server.git.DelegateRepository;
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.io.IOException;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.Repository;
+
+public class SharedRefDbRepository extends DelegateRepository {
+
+ private final SharedRefDbRefDatabase sharedRefDatabase;
+
+ public interface Factory {
+ public SharedRefDbRepository create(String projectName, Repository repository);
+ }
+
+ @Inject
+ public SharedRefDbRepository(
+ SharedRefDbRefDatabase.Factory refDbFactory,
+ @Assisted String projectName,
+ @Assisted Repository repository) {
+ super(repository);
+ this.sharedRefDatabase = refDbFactory.create(projectName, repository.getRefDatabase());
+ }
+
+ @Override
+ public RefDatabase getRefDatabase() {
+ return sharedRefDatabase;
+ }
+
+ @Override
+ public RefUpdate updateRef(String ref) throws IOException {
+ return sharedRefDatabase.wrapRefUpdate(delegate.updateRef(ref));
+ }
+
+ @Override
+ public RefUpdate updateRef(String ref, boolean detach) throws IOException {
+ return sharedRefDatabase.wrapRefUpdate(delegate.updateRef(ref, detach));
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefLogEntry.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefLogEntry.java
new file mode 100644
index 0000000..d580057
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefLogEntry.java
@@ -0,0 +1,100 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.google.gerrit.common.Nullable;
+import com.google.gerrit.extensions.common.GitPerson;
+
+public class SharedRefLogEntry {
+
+ public enum Type {
+ UPDATE_REF,
+ DELETE_REF,
+ DELETE_PROJECT,
+ LOCK_ACQUIRE,
+ LOCK_RELEASE
+ }
+
+ public String projectName;
+ public Type type;
+
+ public static class UpdateRef extends SharedRefLogEntry {
+
+ public String refName;
+ public String oldId;
+ public String newId;
+ public GitPerson committer;
+ public String comment;
+
+ UpdateRef(
+ String projectName,
+ String refName,
+ String oldId,
+ String newId,
+ @Nullable GitPerson committer,
+ @Nullable String comment) {
+ this.type = Type.UPDATE_REF;
+ this.projectName = projectName;
+ this.refName = refName;
+ this.oldId = oldId;
+ this.newId = newId;
+ this.committer = committer;
+ this.comment = comment;
+ }
+ }
+
+ public static class DeleteProject extends SharedRefLogEntry {
+
+ DeleteProject(String projectName) {
+ this.type = Type.DELETE_PROJECT;
+ this.projectName = projectName;
+ }
+ }
+
+ public static class DeleteRef extends SharedRefLogEntry {
+
+ public String refName;
+ public String oldId;
+
+ DeleteRef(String projectName, String refName, String oldId) {
+ this.type = Type.DELETE_REF;
+ this.projectName = projectName;
+ this.refName = refName;
+ this.oldId = oldId;
+ }
+ }
+
+ public static class LockAcquire extends SharedRefLogEntry {
+
+ public String refName;
+
+ LockAcquire(String projectName, String refName) {
+ this.type = Type.LOCK_ACQUIRE;
+ this.projectName = projectName;
+ this.refName = refName;
+ }
+ }
+
+ public static class LockRelease extends SharedRefLogEntry {
+
+ public String refName;
+
+ LockRelease(String projectName, String refName) {
+ this.type = Type.LOCK_RELEASE;
+ this.projectName = projectName;
+ this.refName = refName;
+ }
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefLogger.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefLogger.java
new file mode 100644
index 0000000..faef27b
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefLogger.java
@@ -0,0 +1,31 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+
+public interface SharedRefLogger {
+
+ void logRefUpdate(String project, Ref currRef, ObjectId newRefValue);
+
+ <T> void logRefUpdate(String project, String refName, T currRef, T newRefValue);
+
+ void logProjectDelete(String project);
+
+ void logLockAcquisition(String project, String refName);
+
+ void logLockRelease(String project, String refName);
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/ValidationMetrics.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/ValidationMetrics.java
new file mode 100644
index 0000000..678091b
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/ValidationMetrics.java
@@ -0,0 +1,72 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.google.gerrit.metrics.Counter1;
+import com.google.gerrit.metrics.Description;
+import com.google.gerrit.metrics.Field;
+import com.google.gerrit.metrics.MetricMaker;
+import com.google.gerrit.server.logging.PluginMetadata;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+
+@Singleton
+public class ValidationMetrics {
+ private static final String GIT_UPDATE_SPLIT_BRAIN_PREVENTED = "git_update_split_brain_prevented";
+ private static final String GIT_UPDATE_SPLIT_BRAIN = "git_update_split_brain";
+
+ private final Counter1<String> splitBrainPreventionCounter;
+ private final Counter1<String> splitBrainCounter;
+
+ @Inject
+ public ValidationMetrics(MetricMaker metricMaker) {
+ this.splitBrainPreventionCounter =
+ metricMaker.newCounter(
+ "global-refdb/validation/git_update_split_brain_prevented",
+ rateDescription("errors", "Rate of REST API error responses"),
+ stringField(
+ GIT_UPDATE_SPLIT_BRAIN_PREVENTED,
+ "Ref-update operations, split-brain detected and prevented"));
+
+ this.splitBrainCounter =
+ metricMaker.newCounter(
+ "global-refdb/validation/git_update_split_brain",
+ rateDescription("errors", "Rate of REST API error responses"),
+ stringField(
+ GIT_UPDATE_SPLIT_BRAIN,
+ "Ref-update operation left node in a split-brain scenario"));
+ }
+
+ public void incrementSplitBrainPrevention() {
+ splitBrainPreventionCounter.increment(GIT_UPDATE_SPLIT_BRAIN_PREVENTED);
+ }
+
+ public void incrementSplitBrain() {
+ splitBrainCounter.increment(GIT_UPDATE_SPLIT_BRAIN);
+ }
+
+ public Field<String> stringField(String metadataKey, String description) {
+ return Field.ofString(
+ metadataKey,
+ (metadataBuilder, fieldValue) ->
+ metadataBuilder.addPluginMetadata(PluginMetadata.create(metadataKey, fieldValue)))
+ .description(description)
+ .build();
+ }
+
+ public Description rateDescription(String unit, String description) {
+ return new Description(description).setRate().setUnit(unit);
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/CustomSharedRefEnforcementByProject.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/CustomSharedRefEnforcementByProject.java
new file mode 100644
index 0000000..b1eca36
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/CustomSharedRefEnforcementByProject.java
@@ -0,0 +1,103 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import static com.google.common.base.Suppliers.memoize;
+
+import com.gerritforge.gerrit.globalrefdb.validation.SharedRefDbConfiguration;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Splitter;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableMap;
+import com.google.inject.Inject;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+public class CustomSharedRefEnforcementByProject implements SharedRefEnforcement {
+ private static final String ALL = ".*";
+
+ private final Supplier<Map<String, Map<String, EnforcePolicy>>> predefEnforcements;
+
+ @Inject
+ public CustomSharedRefEnforcementByProject(SharedRefDbConfiguration config) {
+ this.predefEnforcements = memoize(() -> parseDryRunEnforcementsToMap(config));
+ }
+
+ private static Map<String, Map<String, EnforcePolicy>> parseDryRunEnforcementsToMap(
+ SharedRefDbConfiguration config) {
+ Map<String, Map<String, EnforcePolicy>> enforcementMap = new HashMap<>();
+
+ for (Map.Entry<EnforcePolicy, String> enforcementEntry :
+ config.getSharedRefDb().getEnforcementRules().entries()) {
+ parseEnforcementEntry(enforcementMap, enforcementEntry);
+ }
+
+ return enforcementMap;
+ }
+
+ private static void parseEnforcementEntry(
+ Map<String, Map<String, EnforcePolicy>> enforcementMap,
+ Map.Entry<EnforcePolicy, String> enforcementEntry) {
+ Iterator<String> projectAndRef = Splitter.on(':').split(enforcementEntry.getValue()).iterator();
+ EnforcePolicy enforcementPolicy = enforcementEntry.getKey();
+
+ if (projectAndRef.hasNext()) {
+ String projectName = emptyToAll(projectAndRef.next());
+ String refName = emptyToAll(projectAndRef.hasNext() ? projectAndRef.next() : ALL);
+
+ Map<String, EnforcePolicy> existingOrDefaultRef =
+ enforcementMap.getOrDefault(projectName, new HashMap<>());
+
+ existingOrDefaultRef.put(refName, enforcementPolicy);
+
+ enforcementMap.put(projectName, existingOrDefaultRef);
+ }
+ }
+
+ private static String emptyToAll(String value) {
+ return value.trim().isEmpty() ? ALL : value;
+ }
+
+ @Override
+ public EnforcePolicy getPolicy(String projectName, String refName) {
+ if (isRefToBeIgnoredBySharedRefDb(refName)) {
+ return EnforcePolicy.IGNORED;
+ }
+
+ return getRefEnforcePolicy(projectName, refName);
+ }
+
+ private EnforcePolicy getRefEnforcePolicy(String projectName, String refName) {
+ Map<String, EnforcePolicy> orDefault =
+ predefEnforcements
+ .get()
+ .getOrDefault(
+ projectName, predefEnforcements.get().getOrDefault(ALL, ImmutableMap.of()));
+
+ return MoreObjects.firstNonNull(
+ orDefault.getOrDefault(refName, orDefault.get(ALL)), EnforcePolicy.REQUIRED);
+ }
+
+ @Override
+ public EnforcePolicy getPolicy(String projectName) {
+ Map<String, EnforcePolicy> policiesForProject =
+ predefEnforcements
+ .get()
+ .getOrDefault(
+ projectName, predefEnforcements.get().getOrDefault(ALL, ImmutableMap.of()));
+ return policiesForProject.getOrDefault(ALL, EnforcePolicy.REQUIRED);
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/DefaultSharedRefEnforcement.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/DefaultSharedRefEnforcement.java
new file mode 100644
index 0000000..9c2ef35
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/DefaultSharedRefEnforcement.java
@@ -0,0 +1,28 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+public class DefaultSharedRefEnforcement implements SharedRefEnforcement {
+
+ @Override
+ public EnforcePolicy getPolicy(String projectName, String refName) {
+ return isRefToBeIgnoredBySharedRefDb(refName) ? EnforcePolicy.IGNORED : EnforcePolicy.REQUIRED;
+ }
+
+ @Override
+ public EnforcePolicy getPolicy(String projectName) {
+ return EnforcePolicy.REQUIRED;
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/NoopSharedRefDatabase.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/NoopSharedRefDatabase.java
new file mode 100644
index 0000000..4810c64
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/NoopSharedRefDatabase.java
@@ -0,0 +1,63 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import com.gerritforge.gerrit.globalrefdb.GlobalRefDatabase;
+import com.gerritforge.gerrit.globalrefdb.GlobalRefDbLockException;
+import com.gerritforge.gerrit.globalrefdb.GlobalRefDbSystemError;
+import com.google.gerrit.entities.Project;
+import java.util.Optional;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+
+public class NoopSharedRefDatabase implements GlobalRefDatabase {
+
+ @Override
+ public boolean isUpToDate(Project.NameKey project, Ref ref) throws GlobalRefDbLockException {
+ return true;
+ }
+
+ @Override
+ public boolean compareAndPut(Project.NameKey project, Ref currRef, ObjectId newRefValue)
+ throws GlobalRefDbSystemError {
+ return true;
+ }
+
+ @Override
+ public <T> boolean compareAndPut(Project.NameKey project, String refName, T currValue, T newValue)
+ throws GlobalRefDbSystemError {
+ return false;
+ }
+
+ @Override
+ public AutoCloseable lockRef(Project.NameKey project, String refName)
+ throws GlobalRefDbLockException {
+ return () -> {};
+ }
+
+ @Override
+ public boolean exists(Project.NameKey project, String refName) {
+ return false;
+ }
+
+ @Override
+ public void remove(Project.NameKey project) throws GlobalRefDbSystemError {}
+
+ @Override
+ public <T> Optional<T> get(Project.NameKey project, String refName, Class<T> clazz)
+ throws GlobalRefDbSystemError {
+ return Optional.empty();
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/OutOfSyncException.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/OutOfSyncException.java
new file mode 100644
index 0000000..c8dc304
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/OutOfSyncException.java
@@ -0,0 +1,34 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import java.io.IOException;
+import org.eclipse.jgit.lib.Ref;
+
+/** Local project/ref is out of sync with the shared refdb */
+public class OutOfSyncException extends IOException {
+ private static final long serialVersionUID = 1L;
+
+ public OutOfSyncException(String project, Ref localRef) {
+ super(
+ localRef == null
+ ? String.format(
+ "Local ref doesn't exists locally for project %s but exists in the shared ref-db",
+ project)
+ : String.format(
+ "Local ref %s (ObjectId=%s) on project %s is out of sync with the shared ref-db",
+ localRef.getName(), localRef.getObjectId().getName(), project));
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/SharedDbSplitBrainException.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/SharedDbSplitBrainException.java
new file mode 100644
index 0000000..aece4cb
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/SharedDbSplitBrainException.java
@@ -0,0 +1,29 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import java.io.IOException;
+
+public class SharedDbSplitBrainException extends IOException {
+ private static final long serialVersionUID = 1L;
+
+ public SharedDbSplitBrainException(String message) {
+ super(message);
+ }
+
+ public SharedDbSplitBrainException(String message, Throwable cause) {
+ super(message, cause);
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/SharedLockException.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/SharedLockException.java
new file mode 100644
index 0000000..69c3f33
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/SharedLockException.java
@@ -0,0 +1,26 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import java.io.IOException;
+
+/** Unable to lock a project/ref resource. */
+public class SharedLockException extends IOException {
+ private static final long serialVersionUID = 1L;
+
+ public SharedLockException(String project, String refName, Exception cause) {
+ super(String.format("Unable to lock project %s on ref %s", project, refName), cause);
+ }
+}
diff --git a/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/SharedRefEnforcement.java b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/SharedRefEnforcement.java
new file mode 100644
index 0000000..d2c1ed6
--- /dev/null
+++ b/src/main/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/SharedRefEnforcement.java
@@ -0,0 +1,53 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+/** Type of enforcement to implement between the local and shared RefDb. */
+public interface SharedRefEnforcement {
+ public enum EnforcePolicy {
+ IGNORED,
+ REQUIRED;
+ }
+
+ /**
+ * Get the enforcement policy for a project/refName.
+ *
+ * @param projectName project to be enforced
+ * @param refName ref name to be enforced
+ * @return the {@link EnforcePolicy} value
+ */
+ public EnforcePolicy getPolicy(String projectName, String refName);
+
+ /**
+ * Get the enforcement policy for a project
+ *
+ * @param projectName
+ * @return the {@link EnforcePolicy} value
+ */
+ public EnforcePolicy getPolicy(String projectName);
+
+ /**
+ * Check if a refName should be ignored by shared Ref-Db
+ *
+ * @param refName
+ * @return true if ref should be ignored; false otherwise
+ */
+ default boolean isRefToBeIgnoredBySharedRefDb(String refName) {
+ return refName == null
+ || refName.startsWith("refs/draft-comments")
+ || (refName.startsWith("refs/changes") && !refName.endsWith("/meta"))
+ || refName.startsWith("refs/cache-automerge");
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/BatchRefUpdateValidatorTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/BatchRefUpdateValidatorTest.java
new file mode 100644
index 0000000..e1c8478
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/BatchRefUpdateValidatorTest.java
@@ -0,0 +1,194 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.eclipse.jgit.transport.ReceiveCommand.Type.UPDATE;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.DefaultSharedRefEnforcement;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.RefFixture;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedRefEnforcement;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.metrics.DisabledMetricMaker;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.eclipse.jgit.internal.storage.file.RefDirectory;
+import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase;
+import org.eclipse.jgit.junit.TestRepository;
+import org.eclipse.jgit.lib.BatchRefUpdate;
+import org.eclipse.jgit.lib.NullProgressMonitor;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.transport.ReceiveCommand;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class BatchRefUpdateValidatorTest extends LocalDiskRepositoryTestCase implements RefFixture {
+ @Rule public TestName nameRule = new TestName();
+
+ private Repository diskRepo;
+ private TestRepository<Repository> repo;
+ private RefDirectory refdir;
+ private RevCommit A;
+ private RevCommit B;
+
+ @Mock SharedRefDatabaseWrapper sharedRefDatabase;
+
+ @Mock SharedRefEnforcement tmpRefEnforcement;
+ @Mock ProjectsFilter projectsFilter;
+
+ @Before
+ public void setup() throws Exception {
+ super.setUp();
+ when(projectsFilter.matches(anyString())).thenReturn(true);
+ gitRepoSetup();
+ }
+
+ private void gitRepoSetup() throws Exception {
+ diskRepo = createBareRepository();
+ refdir = (RefDirectory) diskRepo.getRefDatabase();
+ repo = new TestRepository<>(diskRepo);
+ A = repo.commit().create();
+ B = repo.commit(repo.getRevWalk().parseCommit(A));
+ }
+
+ @Test
+ public void immutableChangeShouldNotBeWrittenIntoZk() throws Exception {
+ String AN_IMMUTABLE_REF = "refs/changes/01/1/1";
+
+ List<ReceiveCommand> cmds = Arrays.asList(new ReceiveCommand(A, B, AN_IMMUTABLE_REF, UPDATE));
+
+ BatchRefUpdate batchRefUpdate = newBatchUpdate(cmds);
+ BatchRefUpdateValidator BatchRefUpdateValidator = newDefaultValidator(A_TEST_PROJECT_NAME);
+
+ BatchRefUpdateValidator.executeBatchUpdateWithValidation(
+ batchRefUpdate, () -> execute(batchRefUpdate));
+
+ verify(sharedRefDatabase, never())
+ .compareAndPut(any(Project.NameKey.class), any(Ref.class), any(ObjectId.class));
+ }
+
+ @Test
+ public void compareAndPutShouldAlwaysIngoreAlwaysDraftCommentsEvenOutOfOrder() throws Exception {
+ String DRAFT_COMMENT = "refs/draft-comments/56/450756/1013728";
+ List<ReceiveCommand> cmds = Arrays.asList(new ReceiveCommand(A, B, DRAFT_COMMENT, UPDATE));
+
+ BatchRefUpdate batchRefUpdate = newBatchUpdate(cmds);
+ BatchRefUpdateValidator BatchRefUpdateValidator = newDefaultValidator(A_TEST_PROJECT_NAME);
+
+ BatchRefUpdateValidator.executeBatchUpdateWithValidation(
+ batchRefUpdate, () -> execute(batchRefUpdate));
+
+ verify(sharedRefDatabase, never())
+ .compareAndPut(A_TEST_PROJECT_NAME_KEY, newRef(DRAFT_COMMENT, A.getId()), B.getId());
+ }
+
+ @Test
+ public void validationShouldFailWhenLocalRefDbIsOutOfSync() throws Exception {
+ String AN_OUT_OF_SYNC_REF = "refs/changes/01/1/1";
+ BatchRefUpdate batchRefUpdate =
+ newBatchUpdate(
+ Collections.singletonList(new ReceiveCommand(A, B, AN_OUT_OF_SYNC_REF, UPDATE)));
+ BatchRefUpdateValidator batchRefUpdateValidator =
+ getRefValidatorForEnforcement(A_TEST_PROJECT_NAME, tmpRefEnforcement);
+
+ doReturn(SharedRefEnforcement.EnforcePolicy.REQUIRED)
+ .when(batchRefUpdateValidator.refEnforcement)
+ .getPolicy(A_TEST_PROJECT_NAME, AN_OUT_OF_SYNC_REF);
+ lenient()
+ .doReturn(false)
+ .when(sharedRefDatabase)
+ .isUpToDate(A_TEST_PROJECT_NAME_KEY, newRef(AN_OUT_OF_SYNC_REF, AN_OBJECT_ID_1));
+
+ batchRefUpdateValidator.executeBatchUpdateWithValidation(
+ batchRefUpdate, () -> execute(batchRefUpdate));
+
+ final List<ReceiveCommand> commands = batchRefUpdate.getCommands();
+ assertThat(commands.size()).isEqualTo(1);
+ commands.forEach(
+ (command) -> assertThat(command.getResult()).isEqualTo(ReceiveCommand.Result.LOCK_FAILURE));
+ }
+
+ @Test
+ public void shouldNotUpdateSharedRefDbWhenProjectIsLocal() throws Exception {
+ when(projectsFilter.matches(anyString())).thenReturn(true);
+
+ String AN_OUT_OF_SYNC_REF = "refs/changes/01/1/1";
+ BatchRefUpdate batchRefUpdate =
+ newBatchUpdate(
+ Collections.singletonList(new ReceiveCommand(A, B, AN_OUT_OF_SYNC_REF, UPDATE)));
+ BatchRefUpdateValidator batchRefUpdateValidator =
+ getRefValidatorForEnforcement(A_TEST_PROJECT_NAME, tmpRefEnforcement);
+
+ batchRefUpdateValidator.executeBatchUpdateWithValidation(
+ batchRefUpdate, () -> execute(batchRefUpdate));
+
+ verify(sharedRefDatabase, never())
+ .compareAndPut(any(Project.NameKey.class), any(Ref.class), any(ObjectId.class));
+ }
+
+ private BatchRefUpdateValidator newDefaultValidator(String projectName) {
+ return getRefValidatorForEnforcement(projectName, new DefaultSharedRefEnforcement());
+ }
+
+ private BatchRefUpdateValidator getRefValidatorForEnforcement(
+ String projectName, SharedRefEnforcement sharedRefEnforcement) {
+ return new BatchRefUpdateValidator(
+ sharedRefDatabase,
+ new ValidationMetrics(new DisabledMetricMaker()),
+ sharedRefEnforcement,
+ new DummyLockWrapper(),
+ projectsFilter,
+ projectName,
+ diskRepo.getRefDatabase());
+ }
+
+ private Void execute(BatchRefUpdate u) throws IOException {
+ try (RevWalk rw = new RevWalk(diskRepo)) {
+ u.execute(rw, NullProgressMonitor.INSTANCE);
+ }
+ return null;
+ }
+
+ private BatchRefUpdate newBatchUpdate(List<ReceiveCommand> cmds) {
+ BatchRefUpdate u = refdir.newBatchUpdate();
+ u.addCommand(cmds);
+ return u;
+ }
+
+ @Override
+ public String testBranch() {
+ return "branch_" + nameRule.getMethodName();
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/DisabledSharedRefLogger.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/DisabledSharedRefLogger.java
new file mode 100644
index 0000000..f9a1e57
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/DisabledSharedRefLogger.java
@@ -0,0 +1,38 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+import org.junit.Ignore;
+
+@Ignore
+public class DisabledSharedRefLogger implements SharedRefLogger {
+
+ @Override
+ public void logRefUpdate(String project, Ref currRef, ObjectId newRefValue) {}
+
+ @Override
+ public void logProjectDelete(String project) {}
+
+ @Override
+ public void logLockAcquisition(String project, String refName) {}
+
+ @Override
+ public void logLockRelease(String project, String refName) {}
+
+ @Override
+ public <T> void logRefUpdate(String project, String refName, T currRef, T newRefValue) {}
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/DummyLockWrapper.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/DummyLockWrapper.java
new file mode 100644
index 0000000..84d6912
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/DummyLockWrapper.java
@@ -0,0 +1,26 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import org.junit.Ignore;
+
+@Ignore
+public class DummyLockWrapper implements LockWrapper.Factory {
+
+ @Override
+ public LockWrapper create(String project, String refName, AutoCloseable lock) {
+ return new LockWrapper(new DisabledSharedRefLogger(), project, refName, lock);
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/Log4jSharedRefLoggerTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/Log4jSharedRefLoggerTest.java
new file mode 100644
index 0000000..2c89091
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/Log4jSharedRefLoggerTest.java
@@ -0,0 +1,165 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.gerrit.acceptance.AbstractDaemonTest;
+import com.google.gerrit.acceptance.PushOneCommit;
+import com.google.gerrit.entities.RefNames;
+import com.google.gerrit.json.OutputFormat;
+import com.google.gerrit.server.config.SitePaths;
+import com.google.gerrit.server.notedb.Sequences;
+import com.google.gerrit.server.util.SystemLog;
+import com.google.gson.Gson;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.apache.log4j.LogManager;
+import org.apache.log4j.PatternLayout;
+import org.apache.log4j.WriterAppender;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Log4jSharedRefLoggerTest extends AbstractDaemonTest {
+
+ private static final Gson gson = OutputFormat.JSON_COMPACT.newGson();
+ private StringWriter logWriter;
+ private Log4jSharedRefLogger log4jSharedRefLogger;
+
+ @Before
+ public void setUp() throws IOException {
+ this.logWriter = new StringWriter();
+ this.log4jSharedRefLogger = newLog4jSharedRefLogger();
+ }
+
+ @Test
+ public void shouldLogProjectDeletion() {
+ log4jSharedRefLogger.logProjectDelete(project.get());
+
+ SharedRefLogEntry.DeleteProject gotLogEntry =
+ gson.fromJson(logWriter.toString(), SharedRefLogEntry.DeleteProject.class);
+
+ assertThat(gotLogEntry.type).isEqualTo(SharedRefLogEntry.Type.DELETE_PROJECT);
+ assertThat(gotLogEntry.projectName).isEqualTo(project.get());
+ }
+
+ @Test
+ public void shouldLogUpdateRef() throws Exception {
+ final String refName = "refs/remotes/origin/master";
+ Ref currRef = repo().exactRef(refName);
+ PushOneCommit.Result result = pushTo(refName);
+ ObjectId newRefValue = result.getCommit().toObjectId();
+
+ log4jSharedRefLogger.logRefUpdate(project.get(), currRef, newRefValue);
+
+ SharedRefLogEntry.UpdateRef gotLogEntry =
+ gson.fromJson(logWriter.toString(), SharedRefLogEntry.UpdateRef.class);
+
+ assertThat(gotLogEntry.type).isEqualTo(SharedRefLogEntry.Type.UPDATE_REF);
+ assertThat(gotLogEntry.projectName).isEqualTo(project.get());
+ assertThat(gotLogEntry.refName).isEqualTo(refName);
+ assertThat(gotLogEntry.oldId).isEqualTo(currRef.getObjectId().getName());
+ assertThat(gotLogEntry.newId).isEqualTo(newRefValue.getName());
+ assertThat(gotLogEntry.comment).isNotNull();
+ assertThat(gotLogEntry.committer).isNotNull();
+ }
+
+ @Test
+ public void shouldLogDeleteRef() throws Exception {
+ final String refName = "refs/remotes/origin/master";
+ Ref currRef = repo().exactRef(refName);
+
+ log4jSharedRefLogger.logRefUpdate(project.get(), currRef, ObjectId.zeroId());
+
+ SharedRefLogEntry.DeleteRef gotLogEntry =
+ gson.fromJson(logWriter.toString(), SharedRefLogEntry.DeleteRef.class);
+
+ assertThat(gotLogEntry.type).isEqualTo(SharedRefLogEntry.Type.DELETE_REF);
+ assertThat(gotLogEntry.projectName).isEqualTo(project.get());
+ assertThat(gotLogEntry.refName).isEqualTo(refName);
+ assertThat(gotLogEntry.oldId).isEqualTo(currRef.getObjectId().getName());
+ }
+
+ @Test
+ public void shouldLogBlobRefs() throws Exception {
+ Repository allUsersRepo = repoManager.openRepository(allUsers);
+ String blobRefName = RefNames.REFS_SEQUENCES + Sequences.NAME_ACCOUNTS;
+ Ref currRef = allUsersRepo.exactRef(blobRefName);
+ log4jSharedRefLogger.logRefUpdate(allUsers.get(), currRef, currRef.getObjectId());
+
+ SharedRefLogEntry.UpdateRef gotLogEntry =
+ gson.fromJson(logWriter.toString(), SharedRefLogEntry.UpdateRef.class);
+
+ assertThat(gotLogEntry.type).isEqualTo(SharedRefLogEntry.Type.UPDATE_REF);
+ assertThat(gotLogEntry.projectName).isEqualTo(allUsers.get());
+ assertThat(gotLogEntry.refName).isEqualTo(blobRefName);
+ assertThat(gotLogEntry.oldId).isEqualTo(currRef.getObjectId().getName());
+ assertThat(gotLogEntry.newId).isEqualTo(currRef.getObjectId().getName());
+ assertThat(gotLogEntry.comment).isNull();
+ assertThat(gotLogEntry.committer).isNull();
+ }
+
+ @Test
+ public void shouldLogLockAcquisition() {
+ String refName = "refs/foo/bar";
+ log4jSharedRefLogger.logLockAcquisition(project.get(), refName);
+
+ SharedRefLogEntry.LockAcquire gotLogEntry =
+ gson.fromJson(logWriter.toString(), SharedRefLogEntry.LockAcquire.class);
+
+ assertThat(gotLogEntry.type).isEqualTo(SharedRefLogEntry.Type.LOCK_ACQUIRE);
+ assertThat(gotLogEntry.projectName).isEqualTo(project.get());
+ assertThat(gotLogEntry.refName).isEqualTo(refName);
+ }
+
+ @Test
+ public void shouldLogLockRelease() {
+ String refName = "refs/foo/bar";
+ log4jSharedRefLogger.logLockRelease(project.get(), refName);
+
+ SharedRefLogEntry.LockAcquire gotLogEntry =
+ gson.fromJson(logWriter.toString(), SharedRefLogEntry.LockAcquire.class);
+
+ assertThat(gotLogEntry.type).isEqualTo(SharedRefLogEntry.Type.LOCK_RELEASE);
+ assertThat(gotLogEntry.projectName).isEqualTo(project.get());
+ assertThat(gotLogEntry.refName).isEqualTo(refName);
+ }
+
+ private Log4jSharedRefLogger newLog4jSharedRefLogger() throws IOException {
+ final Log4jSharedRefLogger log4jSharedRefLogger =
+ new Log4jSharedRefLogger(new SystemLog(new SitePaths(newPath()), baseConfig), repoManager);
+ log4jSharedRefLogger.setLogger(logWriterLogger());
+ return log4jSharedRefLogger;
+ }
+
+ private Logger logWriterLogger() {
+ org.apache.log4j.Logger logger = LogManager.getLogger("logWriterLogger");
+ logger.addAppender(new WriterAppender(new PatternLayout("%m"), logWriter));
+ return LoggerFactory.getLogger("logWriterLogger");
+ }
+
+ private static Path newPath() throws IOException {
+ Path tmp = Files.createTempFile("gerrit_test_", "_site");
+ Files.deleteIfExists(tmp);
+ return tmp;
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectDeletedSharedDbCleanupTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectDeletedSharedDbCleanupTest.java
new file mode 100644
index 0000000..cf383bf
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectDeletedSharedDbCleanupTest.java
@@ -0,0 +1,58 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.RefFixture;
+import com.google.gerrit.extensions.api.changes.NotifyHandling;
+import com.google.gerrit.extensions.events.ProjectDeletedListener;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ProjectDeletedSharedDbCleanupTest implements RefFixture {
+ @Rule public TestName nameRule = new TestName();
+
+ @Mock ValidationMetrics mockValidationMetrics;
+ @Mock SharedRefDatabaseWrapper sharedRefDatabase;
+
+ @Test
+ public void aDeleteProjectEventShouldCleanupProjectFromZk() throws Exception {
+ String projectName = A_TEST_PROJECT_NAME;
+ ProjectDeletedSharedDbCleanup projectDeletedSharedDbCleanup =
+ new ProjectDeletedSharedDbCleanup(sharedRefDatabase, mockValidationMetrics);
+
+ ProjectDeletedListener.Event event =
+ new ProjectDeletedListener.Event() {
+ @Override
+ public String getProjectName() {
+ return projectName;
+ }
+
+ @Override
+ public NotifyHandling getNotify() {
+ return NotifyHandling.NONE;
+ }
+ };
+
+ projectDeletedSharedDbCleanup.onProjectDeleted(event);
+
+ Mockito.verify(sharedRefDatabase, Mockito.times(1)).remove(A_TEST_PROJECT_NAME_KEY);
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectsFilterTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectsFilterTest.java
new file mode 100644
index 0000000..a8da17e
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/ProjectsFilterTest.java
@@ -0,0 +1,180 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.gerritforge.gerrit.globalrefdb.validation.SharedRefDbConfiguration.Projects;
+import com.google.common.collect.Lists;
+import com.google.gerrit.entities.Project.NameKey;
+import com.google.gerrit.server.events.Event;
+import com.google.gerrit.server.events.ProjectEvent;
+import com.google.gerrit.server.events.RefUpdatedEvent;
+import com.google.gerrit.testing.GerritJUnit;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ProjectsFilterTest {
+
+ @Mock private SharedRefDbConfiguration configuration;
+ @Mock private Projects projects;
+
+ private ProjectsFilter objectUnderTest;
+
+ @Test
+ public void shouldMatchByExactProjectName() {
+ when(projects.getPatterns()).thenReturn(Lists.newArrayList("test_project"));
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project"))).isTrue();
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project2"))).isFalse();
+ }
+
+ @Test
+ public void shouldMatchByWildcard() {
+ when(projects.getPatterns()).thenReturn(Lists.newArrayList("test_project*"));
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project"))).isTrue();
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project2"))).isTrue();
+ assertThat(objectUnderTest.matches(NameKey.parse("2test_project"))).isFalse();
+ }
+
+ @Test
+ public void shouldMatchByRegex() {
+ when(projects.getPatterns()).thenReturn(Lists.newArrayList("^test_(project|project2)"));
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project"))).isTrue();
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project2"))).isTrue();
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project3"))).isFalse();
+ }
+
+ @Test
+ public void shouldExcludeByRegex() {
+ when(projects.getPatterns()).thenReturn(Lists.newArrayList("^(?:(?!test_project3).)*$"));
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project"))).isTrue();
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project2"))).isTrue();
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project3"))).isFalse();
+ }
+
+ @Test
+ public void shouldExcludeByMultipleProjectsRegexPattern() {
+ when(projects.getPatterns())
+ .thenReturn(Lists.newArrayList("^(?:(?!(test_project3|test_project4)).)*$"));
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project"))).isTrue();
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project2"))).isTrue();
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project3"))).isFalse();
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project4"))).isFalse();
+ }
+
+ @Test
+ public void shouldMatchWhenNoPatternProvided() {
+ when(projects.getPatterns()).thenReturn(Collections.emptyList());
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ assertThat(objectUnderTest.matches(NameKey.parse("test_project"))).isTrue();
+ }
+
+ @Test
+ public void shouldMatchProjectEvent() {
+ ProjectEvent event = mock(ProjectEvent.class);
+ when(event.getProjectNameKey()).thenReturn(NameKey.parse("test_project"));
+ when(projects.getPatterns()).thenReturn(Lists.newArrayList("test_project"));
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ assertThat(objectUnderTest.matches(event)).isTrue();
+ }
+
+ @Test
+ public void shouldMatchRefUpdatedEvent() {
+ RefUpdatedEvent event = mock(RefUpdatedEvent.class);
+ when(event.getProjectNameKey()).thenReturn(NameKey.parse("test_project"));
+ when(projects.getPatterns()).thenReturn(Lists.newArrayList("test_project"));
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ assertThat(objectUnderTest.matches(event)).isTrue();
+ }
+
+ @Test
+ public void shouldExcludedNonProjectEvents() {
+ Event event = mock(Event.class);
+ when(projects.getPatterns()).thenReturn(Lists.newArrayList("test_project)"));
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ assertThat(objectUnderTest.matches(event)).isFalse();
+ }
+
+ @Test
+ public void shouldThrowExceptionWhenProjecNameIsNull() {
+ when(projects.getPatterns()).thenReturn(Collections.emptyList());
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ GerritJUnit.assertThrows(
+ IllegalArgumentException.class, () -> objectUnderTest.matches((NameKey) null));
+ }
+
+ @Test
+ public void shouldThrowExceptionWhenProjecNameIsEmpty() {
+ when(projects.getPatterns()).thenReturn(Collections.emptyList());
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ GerritJUnit.assertThrows(
+ IllegalArgumentException.class, () -> objectUnderTest.matches(NameKey.parse("")));
+ }
+
+ @Test
+ public void shouldThrowExceptionWhenEventIsNull() {
+ when(projects.getPatterns()).thenReturn(Collections.emptyList());
+ when(configuration.projects()).thenReturn(projects);
+
+ objectUnderTest = new ProjectsFilter(configuration);
+
+ GerritJUnit.assertThrows(
+ IllegalArgumentException.class, () -> objectUnderTest.matches((Event) null));
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/RefUpdateValidatorTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/RefUpdateValidatorTest.java
new file mode 100644
index 0000000..2c7431f
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/RefUpdateValidatorTest.java
@@ -0,0 +1,218 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.DefaultSharedRefEnforcement;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.RefFixture;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedDbSplitBrainException;
+import com.google.gerrit.entities.Project;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.RefUpdate.Result;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RefUpdateValidatorTest implements RefFixture {
+ private static final DefaultSharedRefEnforcement defaultRefEnforcement =
+ new DefaultSharedRefEnforcement();
+
+ @Mock SharedRefDatabaseWrapper sharedRefDb;
+
+ @Mock SharedRefLogger sharedRefLogger;
+
+ @Mock RefDatabase localRefDb;
+
+ @Mock ValidationMetrics validationMetrics;
+
+ @Mock RefUpdate refUpdate;
+
+ @Mock ProjectsFilter projectsFilter;
+
+ String refName;
+ Ref oldUpdateRef;
+ Ref newUpdateRef;
+ Ref localRef;
+
+ RefUpdateValidator refUpdateValidator;
+
+ @Before
+ public void setupMocks() throws Exception {
+ refName = aBranchRef();
+ oldUpdateRef = newRef(refName, AN_OBJECT_ID_1);
+ newUpdateRef = newRef(refName, AN_OBJECT_ID_2);
+ localRef = newRef(refName, AN_OBJECT_ID_3);
+
+ doReturn(localRef).when(localRefDb).findRef(refName);
+ doReturn(localRef).when(localRefDb).exactRef(refName);
+ doReturn(oldUpdateRef).when(refUpdate).getRef();
+ doReturn(newUpdateRef.getObjectId()).when(refUpdate).getNewObjectId();
+ doReturn(refName).when(refUpdate).getName();
+ lenient().doReturn(oldUpdateRef.getObjectId()).when(refUpdate).getOldObjectId();
+
+ doReturn(true).when(projectsFilter).matches(anyString());
+
+ refUpdateValidator = newRefUpdateValidator(sharedRefDb);
+ }
+
+ @Test
+ public void validationShouldSucceedWhenSharedRefDbIsNoop() throws Exception {
+ SharedRefDatabaseWrapper noopSharedRefDbWrapper = new SharedRefDatabaseWrapper(sharedRefLogger);
+
+ Result result =
+ newRefUpdateValidator(noopSharedRefDbWrapper).executeRefUpdate(refUpdate, () -> Result.NEW);
+ assertThat(result).isEqualTo(Result.NEW);
+ }
+
+ @Test
+ public void validationShouldSucceedWhenLocalRefDbIsUpToDate() throws Exception {
+ lenient()
+ .doReturn(false)
+ .when(sharedRefDb)
+ .isUpToDate(any(Project.NameKey.class), any(Ref.class));
+ doReturn(true).when(sharedRefDb).isUpToDate(A_TEST_PROJECT_NAME_KEY, localRef);
+ lenient()
+ .doReturn(false)
+ .when(sharedRefDb)
+ .compareAndPut(any(Project.NameKey.class), any(Ref.class), any(ObjectId.class));
+ doReturn(true)
+ .when(sharedRefDb)
+ .compareAndPut(A_TEST_PROJECT_NAME_KEY, localRef, newUpdateRef.getObjectId());
+
+ Result result = refUpdateValidator.executeRefUpdate(refUpdate, () -> Result.NEW);
+
+ assertThat(result).isEqualTo(Result.NEW);
+ }
+
+ @Test
+ public void sharedRefDbShouldBeUpdatedWithRefDeleted() throws Exception {
+ doReturn(ObjectId.zeroId()).when(refUpdate).getNewObjectId();
+ doReturn(true).when(sharedRefDb).isUpToDate(any(Project.NameKey.class), any(Ref.class));
+ lenient()
+ .doReturn(false)
+ .when(sharedRefDb)
+ .compareAndPut(any(Project.NameKey.class), any(Ref.class), any(ObjectId.class));
+ doReturn(true)
+ .when(sharedRefDb)
+ .compareAndPut(A_TEST_PROJECT_NAME_KEY, localRef, ObjectId.zeroId());
+ doReturn(localRef).doReturn(null).when(localRefDb).findRef(refName);
+
+ Result result = refUpdateValidator.executeRefUpdate(refUpdate, () -> Result.FORCED);
+
+ assertThat(result).isEqualTo(Result.FORCED);
+ }
+
+ @Test
+ public void sharedRefDbShouldBeUpdatedWithNewRefCreated() throws Exception {
+ Ref localNullRef = nullRef(refName);
+
+ doReturn(true).when(sharedRefDb).isUpToDate(any(Project.NameKey.class), any(Ref.class));
+ lenient()
+ .doReturn(false)
+ .when(sharedRefDb)
+ .compareAndPut(any(Project.NameKey.class), any(Ref.class), any(ObjectId.class));
+ doReturn(true)
+ .when(sharedRefDb)
+ .compareAndPut(A_TEST_PROJECT_NAME_KEY, localNullRef, newUpdateRef.getObjectId());
+ doReturn(localNullRef).doReturn(newUpdateRef).when(localRefDb).findRef(refName);
+
+ Result result = refUpdateValidator.executeRefUpdate(refUpdate, () -> Result.NEW);
+
+ assertThat(result).isEqualTo(Result.NEW);
+ }
+
+ @Test
+ public void validationShouldFailWhenLocalRefDbIsOutOfSync() throws Exception {
+ lenient()
+ .doReturn(true)
+ .when(sharedRefDb)
+ .isUpToDate(any(Project.NameKey.class), any(Ref.class));
+ doReturn(true).when(sharedRefDb).exists(A_TEST_PROJECT_NAME_KEY, refName);
+ doReturn(false).when(sharedRefDb).isUpToDate(A_TEST_PROJECT_NAME_KEY, localRef);
+
+ Result result = refUpdateValidator.executeRefUpdate(refUpdate, () -> Result.NEW);
+
+ assertThat(result).isEqualTo(Result.LOCK_FAILURE);
+ }
+
+ @Test(expected = SharedDbSplitBrainException.class)
+ public void shouldTrowSplitBrainWhenLocalRefDbIsUpToDateButFinalCompareAndPutIsFailing()
+ throws Exception {
+ lenient()
+ .doReturn(false)
+ .when(sharedRefDb)
+ .isUpToDate(any(Project.NameKey.class), any(Ref.class));
+ doReturn(true).when(sharedRefDb).isUpToDate(A_TEST_PROJECT_NAME_KEY, localRef);
+ lenient()
+ .doReturn(true)
+ .when(sharedRefDb)
+ .compareAndPut(any(Project.NameKey.class), any(Ref.class), any(ObjectId.class));
+ doReturn(false)
+ .when(sharedRefDb)
+ .compareAndPut(A_TEST_PROJECT_NAME_KEY, localRef, newUpdateRef.getObjectId());
+
+ refUpdateValidator.executeRefUpdate(refUpdate, () -> Result.NEW);
+ }
+
+ @Test
+ public void shouldNotUpdateSharedRefDbWhenFinalCompareAndPutIsFailing() throws Exception {
+ lenient()
+ .doReturn(false)
+ .when(sharedRefDb)
+ .isUpToDate(any(Project.NameKey.class), any(Ref.class));
+ doReturn(true).when(sharedRefDb).isUpToDate(A_TEST_PROJECT_NAME_KEY, localRef);
+
+ Result result = refUpdateValidator.executeRefUpdate(refUpdate, () -> Result.LOCK_FAILURE);
+
+ verify(sharedRefDb, never())
+ .compareAndPut(any(Project.NameKey.class), any(Ref.class), any(ObjectId.class));
+ assertThat(result).isEqualTo(Result.LOCK_FAILURE);
+ }
+
+ @Test
+ public void shouldNotUpdateSharedRefDbWhenProjectIsLocal() throws Exception {
+ when(projectsFilter.matches(anyString())).thenReturn(false);
+
+ refUpdateValidator.executeRefUpdate(refUpdate, () -> Result.NEW);
+
+ verify(sharedRefDb, never())
+ .compareAndPut(any(Project.NameKey.class), any(Ref.class), any(ObjectId.class));
+ }
+
+ private RefUpdateValidator newRefUpdateValidator(SharedRefDatabaseWrapper refDbWrapper) {
+ return new RefUpdateValidator(
+ refDbWrapper,
+ validationMetrics,
+ defaultRefEnforcement,
+ new DummyLockWrapper(),
+ projectsFilter,
+ A_TEST_PROJECT_NAME,
+ localRefDb);
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbBatchRefUpdateTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbBatchRefUpdateTest.java
new file mode 100644
index 0000000..e52cc5f
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbBatchRefUpdateTest.java
@@ -0,0 +1,211 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import static java.util.Arrays.asList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.DefaultSharedRefEnforcement;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.RefFixture;
+import java.io.IOException;
+import java.util.Collections;
+import org.eclipse.jgit.lib.BatchRefUpdate;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.ObjectIdRef;
+import org.eclipse.jgit.lib.ProgressMonitor;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.transport.ReceiveCommand;
+import org.eclipse.jgit.transport.ReceiveCommand.Result;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SharedRefDbBatchRefUpdateTest implements RefFixture {
+
+ @Mock SharedRefDatabaseWrapper sharedRefDb;
+ @Mock BatchRefUpdate batchRefUpdate;
+ @Mock BatchRefUpdateValidator batchRefUpdateValidator;
+ @Mock RefDatabase refDatabase;
+ @Mock RevWalk revWalk;
+ @Mock ProgressMonitor progressMonitor;
+ @Mock ValidationMetrics validationMetrics;
+ @Mock ProjectsFilter projectsFilter;
+
+ private final Ref oldRef =
+ new ObjectIdRef.Unpeeled(Ref.Storage.NETWORK, A_TEST_REF_NAME, AN_OBJECT_ID_1);
+ private final Ref newRef =
+ new ObjectIdRef.Unpeeled(Ref.Storage.NETWORK, A_TEST_REF_NAME, AN_OBJECT_ID_2);
+ ReceiveCommand receiveCommandBeforeExecution =
+ createReceiveCommand(
+ oldRef.getObjectId(), newRef.getObjectId(), oldRef.getName(), Result.NOT_ATTEMPTED);
+
+ ReceiveCommand successReceiveCommandAfterExecution =
+ createReceiveCommand(oldRef.getObjectId(), newRef.getObjectId(), oldRef.getName(), Result.OK);
+
+ ReceiveCommand rejectReceiveCommandAfterExecution =
+ createReceiveCommand(
+ oldRef.getObjectId(),
+ newRef.getObjectId(),
+ oldRef.getName(),
+ Result.REJECTED_NONFASTFORWARD);
+
+ private ReceiveCommand createReceiveCommand(
+ ObjectId oldRefObjectId, ObjectId newRefObjectId, String refName, Result result) {
+ ReceiveCommand receiveCommand = new ReceiveCommand(oldRefObjectId, newRefObjectId, refName);
+ receiveCommand.setResult(result);
+ return receiveCommand;
+ }
+
+ private SharedRefDbBatchRefUpdate sharedRefDbRefUpdate;
+
+ @Rule public TestName nameRule = new TestName();
+
+ @Override
+ public String testBranch() {
+ return "branch_" + nameRule.getMethodName();
+ }
+
+ @Before
+ public void setup() {
+ when(projectsFilter.matches(anyString())).thenReturn(true);
+ }
+
+ @SuppressWarnings("deprecation")
+ private void setMockRequiredReturnValues() throws IOException {
+
+ doReturn(batchRefUpdate).when(refDatabase).newBatchUpdate();
+
+ when(batchRefUpdate.getCommands())
+ .thenReturn(asList(receiveCommandBeforeExecution))
+ .thenReturn(asList(successReceiveCommandAfterExecution));
+
+ doReturn(oldRef).when(refDatabase).getRef(A_TEST_REF_NAME);
+ doReturn(oldRef).when(refDatabase).exactRef(A_TEST_REF_NAME);
+
+ sharedRefDbRefUpdate = getSharedRefDbBatchRefUpdateWithDefaultPolicyEnforcement();
+
+ verifyZeroInteractions(validationMetrics);
+ }
+
+ @Test
+ public void executeAndDelegateSuccessfullyWithNoExceptions() throws Exception {
+ setMockRequiredReturnValues();
+
+ // When compareAndPut against sharedDb succeeds
+ doReturn(true).when(sharedRefDb).isUpToDate(A_TEST_PROJECT_NAME_KEY, oldRef);
+ doReturn(true)
+ .when(sharedRefDb)
+ .compareAndPut(eq(A_TEST_PROJECT_NAME_KEY), refEquals(oldRef), eq(newRef.getObjectId()));
+ sharedRefDbRefUpdate.execute(revWalk, progressMonitor, Collections.emptyList());
+ verify(sharedRefDb)
+ .compareAndPut(eq(A_TEST_PROJECT_NAME_KEY), refEquals(oldRef), eq(newRef.getObjectId()));
+ }
+
+ private Ref refEquals(Ref oldRef) {
+ return argThat(new RefMatcher(oldRef));
+ }
+
+ @Test(expected = IOException.class)
+ public void executeAndFailsWithExceptions() throws IOException {
+ sharedRefDbRefUpdate = getSharedRefDbBatchRefUpdateWithMockedValidator();
+ doThrow(new IOException("IO Test Exception"))
+ .when(batchRefUpdateValidator)
+ .executeBatchUpdateWithValidation(any(), any());
+
+ sharedRefDbRefUpdate.execute(revWalk, progressMonitor, Collections.emptyList());
+ }
+
+ @Test
+ public void executeSuccessfullyWithNoExceptionsWhenOutOfSync() throws IOException {
+ setMockRequiredReturnValues();
+ doReturn(true).when(sharedRefDb).exists(A_TEST_PROJECT_NAME_KEY, A_TEST_REF_NAME);
+ doReturn(false).when(sharedRefDb).isUpToDate(A_TEST_PROJECT_NAME_KEY, oldRef);
+
+ sharedRefDbRefUpdate.execute(revWalk, progressMonitor, Collections.emptyList());
+
+ verify(validationMetrics).incrementSplitBrainPrevention();
+ }
+
+ @Test
+ public void executeSuccessfullyWithNoExceptionsWhenEmptyList() throws IOException {
+ doReturn(batchRefUpdate).when(refDatabase).newBatchUpdate();
+ doReturn(Collections.emptyList()).when(batchRefUpdate).getCommands();
+
+ sharedRefDbRefUpdate = getSharedRefDbBatchRefUpdateWithDefaultPolicyEnforcement();
+
+ sharedRefDbRefUpdate.execute(revWalk, progressMonitor, Collections.emptyList());
+ }
+
+ private SharedRefDbBatchRefUpdate getSharedRefDbBatchRefUpdateWithDefaultPolicyEnforcement() {
+ BatchRefUpdateValidator.Factory batchRefValidatorFactory =
+ new BatchRefUpdateValidator.Factory() {
+ @Override
+ public BatchRefUpdateValidator create(String projectName, RefDatabase refDb) {
+ return new BatchRefUpdateValidator(
+ sharedRefDb,
+ validationMetrics,
+ new DefaultSharedRefEnforcement(),
+ new DummyLockWrapper(),
+ projectsFilter,
+ projectName,
+ refDb);
+ }
+ };
+ return new SharedRefDbBatchRefUpdate(
+ batchRefValidatorFactory, A_TEST_PROJECT_NAME, refDatabase);
+ }
+
+ private SharedRefDbBatchRefUpdate getSharedRefDbBatchRefUpdateWithMockedValidator() {
+ BatchRefUpdateValidator.Factory batchRefValidatorFactory =
+ new BatchRefUpdateValidator.Factory() {
+ @Override
+ public BatchRefUpdateValidator create(String projectName, RefDatabase refDb) {
+ return batchRefUpdateValidator;
+ }
+ };
+ return new SharedRefDbBatchRefUpdate(
+ batchRefValidatorFactory, A_TEST_PROJECT_NAME, refDatabase);
+ }
+
+ protected static class RefMatcher implements ArgumentMatcher<Ref> {
+ private Ref left;
+
+ public RefMatcher(Ref ref) {
+ this.left = ref;
+ }
+
+ @Override
+ public boolean matches(Ref right) {
+ return left.getName().equals(right.getName())
+ && left.getObjectId().equals(right.getObjectId());
+ }
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbGitRepositoryManagerTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbGitRepositoryManagerTest.java
new file mode 100644
index 0000000..b2b8ad6
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbGitRepositoryManagerTest.java
@@ -0,0 +1,82 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.RefFixture;
+import com.google.gerrit.server.git.LocalDiskRepositoryManager;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SharedRefDbGitRepositoryManagerTest implements RefFixture {
+
+ @Mock LocalDiskRepositoryManager localDiskRepositoryManagerMock;
+
+ @Mock SharedRefDbRepository.Factory sharedRefDbRepositoryFactoryMock;
+
+ @Mock Repository repositoryMock;
+
+ @Mock SharedRefDbRepository sharedRefDbRepositoryMock;
+
+ SharedRefDbGitRepositoryManager msRepoMgr;
+
+ @Override
+ public String testBranch() {
+ return "foo";
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ doReturn(sharedRefDbRepositoryMock)
+ .when(sharedRefDbRepositoryFactoryMock)
+ .create(A_TEST_PROJECT_NAME, repositoryMock);
+ msRepoMgr =
+ new SharedRefDbGitRepositoryManager(
+ sharedRefDbRepositoryFactoryMock, localDiskRepositoryManagerMock);
+ }
+
+ @Test
+ public void openRepositoryShouldCreateSharedRefDbRepositoryWrapper() throws Exception {
+ doReturn(repositoryMock)
+ .when(localDiskRepositoryManagerMock)
+ .openRepository(A_TEST_PROJECT_NAME_KEY);
+
+ msRepoMgr.openRepository(A_TEST_PROJECT_NAME_KEY);
+
+ verifyThatSharedRefDbRepositoryWrapperHasBeenCreated();
+ }
+
+ @Test
+ public void createRepositoryShouldCreateSharedRefDbRepositoryWrapper() throws Exception {
+ doReturn(repositoryMock)
+ .when(localDiskRepositoryManagerMock)
+ .createRepository(A_TEST_PROJECT_NAME_KEY);
+
+ msRepoMgr.createRepository(A_TEST_PROJECT_NAME_KEY);
+
+ verifyThatSharedRefDbRepositoryWrapperHasBeenCreated();
+ }
+
+ private void verifyThatSharedRefDbRepositoryWrapperHasBeenCreated() {
+ verify(sharedRefDbRepositoryFactoryMock).create(A_TEST_PROJECT_NAME, repositoryMock);
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRefDatabaseTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRefDatabaseTest.java
new file mode 100644
index 0000000..352b136
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRefDatabaseTest.java
@@ -0,0 +1,59 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.RefFixture;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SharedRefDbRefDatabaseTest implements RefFixture {
+
+ @Rule public TestName nameRule = new TestName();
+
+ @Mock SharedRefDbRefUpdate.Factory refUpdateFactoryMock;
+ @Mock SharedRefDbBatchRefUpdate.Factory refBatchUpdateFactoryMock;
+
+ @Mock RefDatabase refDatabaseMock;
+
+ @Mock RefUpdate refUpdateMock;
+
+ @Override
+ public String testBranch() {
+ return "branch_" + nameRule.getMethodName();
+ }
+
+ @Test
+ public void newUpdateShouldCreateSharedRefDbRefUpdate() throws Exception {
+ String refName = aBranchRef();
+ SharedRefDbRefDatabase sharedRefDbRefDb =
+ new SharedRefDbRefDatabase(
+ refUpdateFactoryMock, refBatchUpdateFactoryMock, A_TEST_PROJECT_NAME, refDatabaseMock);
+ doReturn(refUpdateMock).when(refDatabaseMock).newUpdate(refName, false);
+
+ sharedRefDbRefDb.newUpdate(refName, false);
+
+ verify(refUpdateFactoryMock).create(A_TEST_PROJECT_NAME, refUpdateMock, refDatabaseMock);
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRepositoryTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRepositoryTest.java
new file mode 100644
index 0000000..5bb4fb4
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/SharedRefDbRepositoryTest.java
@@ -0,0 +1,97 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.RefFixture;
+import java.io.IOException;
+import org.eclipse.jgit.lib.ObjectDatabase;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RefUpdate.Result;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SharedRefDbRepositoryTest implements RefFixture {
+
+ @Mock SharedRefDbRefDatabase.Factory sharedRefDbRefDbFactory;
+ @Mock SharedRefDbRefDatabase sharedRefDb;
+ @Mock RefDatabase genericRefDb;
+ @Mock ObjectDatabase objectDatabase;
+
+ @Mock SharedRefDbRefUpdate sharedRefDbRefUpdate;
+
+ @Mock Repository repository;
+
+ private final String PROJECT_NAME = "ProjectName";
+ private final String REFS_HEADS_MASTER = "refs/heads/master";
+
+ @Override
+ public String testBranch() {
+ return null;
+ }
+
+ private void setMockitoCommon() {
+ doReturn(true).when(repository).isBare();
+ doReturn(genericRefDb).when(repository).getRefDatabase();
+ doReturn(objectDatabase).when(repository).getObjectDatabase();
+ doReturn(sharedRefDb).when(sharedRefDbRefDbFactory).create(PROJECT_NAME, genericRefDb);
+ }
+
+ @Test
+ public void shouldInvokeSharedRefDbRefDbFactoryCreate() {
+ setMockitoCommon();
+ try (SharedRefDbRepository sharedRefDbRepository =
+ new SharedRefDbRepository(sharedRefDbRefDbFactory, PROJECT_NAME, repository)) {
+
+ sharedRefDbRepository.getRefDatabase();
+ verify(sharedRefDbRefDbFactory).create(PROJECT_NAME, genericRefDb);
+ }
+ }
+
+ @Test
+ public void shouldInvokeNewUpdateInSharedRefDbRefDatabase() throws IOException {
+ setMockitoCommon();
+ try (SharedRefDbRepository sharedRefDbRepository =
+ new SharedRefDbRepository(sharedRefDbRefDbFactory, PROJECT_NAME, repository)) {
+ sharedRefDbRepository.getRefDatabase().newUpdate(REFS_HEADS_MASTER, false);
+
+ verify(sharedRefDb).newUpdate(REFS_HEADS_MASTER, false);
+ }
+ }
+
+ @Test
+ public void shouldInvokeUpdateInSharedRefDbRefUpdate() throws IOException {
+ setMockitoCommon();
+ doReturn(Result.NEW).when(sharedRefDbRefUpdate).update();
+ doReturn(sharedRefDbRefUpdate).when(sharedRefDb).newUpdate(REFS_HEADS_MASTER, false);
+
+ try (SharedRefDbRepository sharedRefDbRepository =
+ new SharedRefDbRepository(sharedRefDbRefDbFactory, PROJECT_NAME, repository)) {
+
+ Result updateResult =
+ sharedRefDbRepository.getRefDatabase().newUpdate(REFS_HEADS_MASTER, false).update();
+
+ verify(sharedRefDbRefUpdate).update();
+ assertThat(updateResult).isEqualTo(Result.NEW);
+ }
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/CustomSharedRefEnforcementByProjectTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/CustomSharedRefEnforcementByProjectTest.java
new file mode 100644
index 0000000..4cf6800
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/CustomSharedRefEnforcementByProjectTest.java
@@ -0,0 +1,150 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.gerritforge.gerrit.globalrefdb.validation.SharedRefDbConfiguration;
+import com.gerritforge.gerrit.globalrefdb.validation.SharedRefDbConfiguration.SharedRefDatabase;
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedRefEnforcement.EnforcePolicy;
+import java.util.Arrays;
+import org.eclipse.jgit.lib.Config;
+import org.eclipse.jgit.lib.Ref;
+import org.junit.Before;
+import org.junit.Test;
+
+public class CustomSharedRefEnforcementByProjectTest implements RefFixture {
+
+ SharedRefEnforcement refEnforcement;
+
+ @Before
+ public void setUp() {
+ Config sharedRefDbConfig = new Config();
+ sharedRefDbConfig.setStringList(
+ SharedRefDatabase.SECTION,
+ SharedRefDatabase.SUBSECTION_ENFORCEMENT_RULES,
+ EnforcePolicy.IGNORED.name(),
+ Arrays.asList(
+ "ProjectOne",
+ "ProjectTwo:refs/heads/master/test",
+ "ProjectTwo:refs/heads/master/test2"));
+
+ refEnforcement = newCustomRefEnforcement(sharedRefDbConfig);
+ }
+
+ @Test
+ public void projectOneShouldReturnDesiredForAllRefs() {
+ Ref aRef = newRef("refs/heads/master/2", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy("ProjectOne", aRef.getName()))
+ .isEqualTo(EnforcePolicy.IGNORED);
+ }
+
+ @Test
+ public void projectOneEnforcementShouldAlwaysPrevail() {
+ Ref aRef = newRef("refs/heads/master/test", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy("ProjectOne", aRef.getName()))
+ .isEqualTo(EnforcePolicy.IGNORED);
+ }
+
+ @Test
+ public void aNonListedProjectShouldRequireRefForMasterTest() {
+ Ref aRef = newRef("refs/heads/master/test", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy("NonListedProject", aRef.getName()))
+ .isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Test
+ public void projectTwoSpecificRefShouldReturnIgnoredPolicy() {
+ Ref refOne = newRef("refs/heads/master/test", AN_OBJECT_ID_1);
+ Ref refTwo = newRef("refs/heads/master/test2", AN_OBJECT_ID_1);
+
+ assertThat(refEnforcement.getPolicy("ProjectTwo", refOne.getName()))
+ .isEqualTo(EnforcePolicy.IGNORED);
+ assertThat(refEnforcement.getPolicy("ProjectTwo", refTwo.getName()))
+ .isEqualTo(EnforcePolicy.IGNORED);
+ }
+
+ @Test
+ public void aNonListedProjectShouldReturnRequired() {
+ Ref refOne = newRef("refs/heads/master/newChange", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy("NonListedProject", refOne.getName()))
+ .isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Test
+ public void aNonListedRefInProjectShouldReturnRequired() {
+ Ref refOne = newRef("refs/heads/master/test3", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy("ProjectTwo", refOne.getName()))
+ .isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Test
+ public void aNonListedProjectAndRefShouldReturnRequired() {
+ Ref refOne = newRef("refs/heads/master/test3", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy("NonListedProject", refOne.getName()))
+ .isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Test
+ public void getProjectPolicyForProjectOneShouldReturnIgnored() {
+ assertThat(refEnforcement.getPolicy("ProjectOne")).isEqualTo(EnforcePolicy.IGNORED);
+ }
+
+ @Test
+ public void getProjectPolicyForProjectTwoShouldReturnRequired() {
+ assertThat(refEnforcement.getPolicy("ProjectTwo")).isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Test
+ public void getProjectPolicyForNonListedProjectShouldReturnRequired() {
+ assertThat(refEnforcement.getPolicy("NonListedProject")).isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Test
+ public void getProjectPolicyForNonListedProjectWhenSingleProject() {
+ SharedRefEnforcement customEnforcement =
+ newCustomRefEnforcementWithValue(EnforcePolicy.IGNORED, ":refs/heads/master");
+
+ assertThat(customEnforcement.getPolicy("NonListedProject")).isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Test
+ public void getANonListedProjectWhenOnlyOneProjectIsListedShouldReturnRequired() {
+ SharedRefEnforcement customEnforcement =
+ newCustomRefEnforcementWithValue(EnforcePolicy.IGNORED, "AProject:");
+ assertThat(customEnforcement.getPolicy("NonListedProject", "refs/heads/master"))
+ .isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ private SharedRefEnforcement newCustomRefEnforcementWithValue(
+ EnforcePolicy policy, String... projectAndRefs) {
+ Config sharedRefDbConfiguration = new Config();
+ sharedRefDbConfiguration.setStringList(
+ SharedRefDatabase.SECTION,
+ SharedRefDatabase.SUBSECTION_ENFORCEMENT_RULES,
+ policy.name(),
+ Arrays.asList(projectAndRefs));
+ return newCustomRefEnforcement(sharedRefDbConfiguration);
+ }
+
+ private SharedRefEnforcement newCustomRefEnforcement(Config sharedRefDbConfig) {
+ return new CustomSharedRefEnforcementByProject(new SharedRefDbConfiguration(sharedRefDbConfig));
+ }
+
+ @Override
+ public String testBranch() {
+ return "fooBranch";
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/DefaultSharedRefEnforcementTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/DefaultSharedRefEnforcementTest.java
new file mode 100644
index 0000000..a9f0cb2
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/DefaultSharedRefEnforcementTest.java
@@ -0,0 +1,80 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.gerritforge.gerrit.globalrefdb.validation.dfsrefdb.SharedRefEnforcement.EnforcePolicy;
+import org.eclipse.jgit.lib.Ref;
+import org.junit.Test;
+
+public class DefaultSharedRefEnforcementTest implements RefFixture {
+
+ SharedRefEnforcement refEnforcement = new DefaultSharedRefEnforcement();
+
+ @Test
+ public void anImmutableChangeShouldBeIgnored() {
+ Ref immutableChangeRef = newRef(A_REF_NAME_OF_A_PATCHSET, AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy(A_TEST_PROJECT_NAME, immutableChangeRef.getName()))
+ .isEqualTo(EnforcePolicy.IGNORED);
+ }
+
+ @Test
+ public void aChangeMetaShouldNotBeIgnored() {
+ Ref immutableChangeRef = newRef("refs/changes/01/1/meta", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy(A_TEST_PROJECT_NAME, immutableChangeRef.getName()))
+ .isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Test
+ public void aCacheAutomergeShouldBeIgnored() {
+ Ref immutableChangeRef = newRef("refs/cache-automerge/01/1/1000000", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy(A_TEST_PROJECT_NAME, immutableChangeRef.getName()))
+ .isEqualTo(EnforcePolicy.IGNORED);
+ }
+
+ @Test
+ public void aDraftCommentsShouldBeIgnored() {
+ Ref immutableChangeRef = newRef("refs/draft-comments/01/1/1000000", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy(A_TEST_PROJECT_NAME, immutableChangeRef.getName()))
+ .isEqualTo(EnforcePolicy.IGNORED);
+ }
+
+ @Test
+ public void regularRefHeadsMasterShouldNotBeIgnored() {
+ Ref immutableChangeRef = newRef("refs/heads/master", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy(A_TEST_PROJECT_NAME, immutableChangeRef.getName()))
+ .isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Test
+ public void regularCommitShouldNotBeIgnored() {
+ Ref immutableChangeRef = newRef("refs/heads/stable-2.16", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy(A_TEST_PROJECT_NAME, immutableChangeRef.getName()))
+ .isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Test
+ public void allUsersExternalIdsRefShouldBeRequired() {
+ Ref refOne = newRef("refs/meta/external-ids", AN_OBJECT_ID_1);
+ assertThat(refEnforcement.getPolicy("All-Users", refOne.getName()))
+ .isEqualTo(EnforcePolicy.REQUIRED);
+ }
+
+ @Override
+ public String testBranch() {
+ return "fooBranch";
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/NoopSharedRefDatabaseTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/NoopSharedRefDatabaseTest.java
new file mode 100644
index 0000000..bc1435c
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/NoopSharedRefDatabaseTest.java
@@ -0,0 +1,42 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.eclipse.jgit.lib.Ref;
+import org.junit.Test;
+
+public class NoopSharedRefDatabaseTest implements RefFixture {
+
+ private Ref sampleRef = newRef(A_TEST_REF_NAME, AN_OBJECT_ID_1);
+ private NoopSharedRefDatabase objectUnderTest = new NoopSharedRefDatabase();
+
+ @Test
+ public void isUpToDateShouldAlwaysReturnTrue() {
+ assertThat(objectUnderTest.isUpToDate(A_TEST_PROJECT_NAME_KEY, sampleRef)).isTrue();
+ }
+
+ @Test
+ public void compareAndPutShouldAlwaysReturnTrue() {
+ assertThat(objectUnderTest.compareAndPut(A_TEST_PROJECT_NAME_KEY, sampleRef, AN_OBJECT_ID_2))
+ .isTrue();
+ }
+
+ @Test
+ public void existsShouldAlwaysReturnFalse() {
+ assertThat(objectUnderTest.exists(A_TEST_PROJECT_NAME_KEY, A_TEST_REF_NAME)).isFalse();
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/RefFixture.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/RefFixture.java
new file mode 100644
index 0000000..fa6a825
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/RefFixture.java
@@ -0,0 +1,54 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.entities.RefNames;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.ObjectIdRef;
+import org.eclipse.jgit.lib.Ref;
+import org.junit.Ignore;
+
+@Ignore
+public interface RefFixture {
+
+ static final String ALLOWED_CHARS = "abcdefghilmnopqrstuvz";
+ static final String ALLOWED_DIGITS = "1234567890";
+ static final String ALLOWED_NAME_CHARS =
+ ALLOWED_CHARS + ALLOWED_CHARS.toUpperCase() + ALLOWED_DIGITS;
+ static final String A_TEST_PROJECT_NAME = "A_TEST_PROJECT_NAME";
+ static final Project.NameKey A_TEST_PROJECT_NAME_KEY = Project.nameKey(A_TEST_PROJECT_NAME);
+ static final ObjectId AN_OBJECT_ID_1 = new ObjectId(1, 2, 3, 4, 5);
+ static final ObjectId AN_OBJECT_ID_2 = new ObjectId(1, 2, 3, 4, 6);
+ static final ObjectId AN_OBJECT_ID_3 = new ObjectId(1, 2, 3, 4, 7);
+ static final String A_TEST_REF_NAME = "refs/heads/master";
+ static final String A_REF_NAME_OF_A_PATCHSET = "refs/changes/01/1/1";
+
+ default String aBranchRef() {
+ return RefNames.REFS_HEADS + testBranch();
+ }
+
+ default String testBranch() {
+ return "aTestBranch";
+ }
+
+ default Ref newRef(String refName, ObjectId objectId) {
+ return new ObjectIdRef.Unpeeled(Ref.Storage.NETWORK, refName, objectId);
+ }
+
+ default Ref nullRef(String refName) {
+ return newRef(refName, ObjectId.zeroId());
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/RefSharedDatabaseTest.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/RefSharedDatabaseTest.java
new file mode 100644
index 0000000..2d3d8b8
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/RefSharedDatabaseTest.java
@@ -0,0 +1,47 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.ObjectIdRef;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Ref.Storage;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestName;
+
+public class RefSharedDatabaseTest implements RefFixture {
+ @Rule public TestName nameRule = new TestName();
+
+ @Override
+ public String testBranch() {
+ return "branch_" + nameRule.getMethodName();
+ }
+
+ @Test
+ public void shouldCreateANewRef() {
+
+ ObjectId objectId = AN_OBJECT_ID_1;
+ String refName = aBranchRef();
+
+ Ref aNewRef = new ObjectIdRef.Unpeeled(Storage.NETWORK, refName, objectId);
+
+ assertThat(aNewRef.getName()).isEqualTo(refName);
+ assertThat(aNewRef.getObjectId()).isEqualTo(objectId);
+ assertThat(aNewRef.getStorage()).isEqualTo(Storage.NETWORK);
+ }
+}
diff --git a/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/RefUpdateStub.java b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/RefUpdateStub.java
new file mode 100644
index 0000000..e78ba6d
--- /dev/null
+++ b/src/test/java/com/gerritforge/gerrit/globalrefdb/validation/dfsrefdb/RefUpdateStub.java
@@ -0,0 +1,114 @@
+// Copyright (C) 2020 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.gerritforge.gerrit.globalrefdb.validation.dfsrefdb;
+
+import java.io.IOException;
+import org.apache.commons.lang.NotImplementedException;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.junit.Ignore;
+
+@Ignore
+public class RefUpdateStub extends RefUpdate {
+
+ public static RefUpdate forSuccessfulCreate(Ref newRef) {
+ return new RefUpdateStub(Result.NEW, null, newRef, newRef.getObjectId());
+ }
+
+ public static RefUpdate forSuccessfulUpdate(Ref oldRef, ObjectId newObjectId) {
+ return new RefUpdateStub(Result.FAST_FORWARD, null, oldRef, newObjectId);
+ }
+
+ public static RefUpdate forSuccessfulDelete(Ref oldRef) {
+ return new RefUpdateStub(null, Result.FORCED, oldRef, ObjectId.zeroId());
+ }
+
+ private final Result updateResult;
+ private final Result deleteResult;
+
+ public RefUpdateStub(Result updateResult, Result deleteResult, Ref oldRef, ObjectId newObjectId) {
+ super(oldRef);
+ this.setNewObjectId(newObjectId);
+ this.updateResult = updateResult;
+ this.deleteResult = deleteResult;
+ }
+
+ @Override
+ protected RefDatabase getRefDatabase() {
+ throw new NotImplementedException("Method not implemented yet, not assumed you needed it!!");
+ }
+
+ @Override
+ protected Repository getRepository() {
+ throw new NotImplementedException("Method not implemented yet, not assumed you needed it!!");
+ }
+
+ @Override
+ protected boolean tryLock(boolean deref) throws IOException {
+ throw new NotImplementedException("Method not implemented yet, not assumed you needed it!!");
+ }
+
+ @Override
+ protected void unlock() {
+ throw new NotImplementedException("Method not implemented yet, not assumed you needed it!!");
+ }
+
+ @Override
+ protected Result doUpdate(Result desiredResult) throws IOException {
+ throw new NotImplementedException("Method not implemented, shouldn't be called!!");
+ }
+
+ @Override
+ protected Result doDelete(Result desiredResult) throws IOException {
+ throw new NotImplementedException("Method not implemented, shouldn't be called!!");
+ }
+
+ @Override
+ protected Result doLink(String target) throws IOException {
+ throw new NotImplementedException("Method not implemented yet, not assumed you needed it!!");
+ }
+
+ @Override
+ public Result update() throws IOException {
+ if (updateResult != null) return updateResult;
+
+ throw new NotImplementedException("Not assumed you needed to stub this call!!");
+ }
+
+ @Override
+ public Result update(RevWalk walk) throws IOException {
+ if (updateResult != null) return updateResult;
+
+ throw new NotImplementedException("Not assumed you needed to stub this call!!");
+ }
+
+ @Override
+ public Result delete() throws IOException {
+ if (deleteResult != null) return deleteResult;
+
+ throw new NotImplementedException("Not assumed you needed to stub this call!!");
+ }
+
+ @Override
+ public Result delete(RevWalk walk) throws IOException {
+ if (deleteResult != null) return deleteResult;
+
+ throw new NotImplementedException("Not assumed you needed to stub this call!!");
+ }
+}
