Initial libraty creation
The problem is with DynamicItem - it doesn't get updated with the Gerrit
cache reference. It seems that it doesn't work across db and sys injector.
Change-Id: I05cf4766e4b74b380c9fbf7c6e25553dfa76d5d3
diff --git a/BUILD b/BUILD
new file mode 100644
index 0000000..f8f49ad
--- /dev/null
+++ b/BUILD
@@ -0,0 +1,44 @@
+load("//tools/bzl:junit.bzl", "junit_tests")
+load("//javatests/com/google/gerrit/acceptance:tests.bzl", "acceptance_tests")
+load(
+ "//tools/bzl:plugin.bzl",
+ "PLUGIN_DEPS",
+ "PLUGIN_DEPS_NEVERLINK",
+ "PLUGIN_TEST_DEPS",
+ "gerrit_plugin",
+)
+
+gerrit_plugin(
+ name = "gerrit-cached-refdb",
+ srcs = glob(["src/main/java/**/*.java"]),
+ manifest_entries = [
+ "Gerrit-PluginName: gerrit-cached-refdb",
+ "Implementation-Title: gerrit-cached-refdb plugin",
+ "Implementation-URL: TODO",
+ ],
+ resources = glob(["src/main/resources/**/*"]),
+ deps = [],
+)
+
+junit_tests(
+ name = "gerrit-cached-refdb_tests",
+ srcs = glob(["src/test/java/**/*Test.java"]),
+ resources = glob(["src/test/resources/**/*"]),
+ tags = [
+ "local",
+ "gerrit-cached-refdb",
+ ],
+ deps = PLUGIN_DEPS + PLUGIN_TEST_DEPS + [
+ ":gerrit-cached-refdb__plugin",
+ ],
+)
+
+acceptance_tests(
+ srcs = glob(["src/test/java/**/*IT.java"]),
+ group = "jgit_cache",
+ labels = ["server"],
+ vm_args = ["-Xmx2G"],
+ deps = [
+ ":gerrit-cached-refdb__plugin",
+ ],
+)
\ No newline at end of file
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/BatchRefUpdateWithCacheUpdate.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/BatchRefUpdateWithCacheUpdate.java
new file mode 100644
index 0000000..360dfa1
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/BatchRefUpdateWithCacheUpdate.java
@@ -0,0 +1,184 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+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.Repository;
+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;
+
+class BatchRefUpdateWithCacheUpdate extends BatchRefUpdate {
+ interface Factory {
+ BatchRefUpdateWithCacheUpdate create(Repository repo, BatchRefUpdate delegate);
+ }
+
+ private final Repository repo;
+ private final RefByNameCacheWrapper refsCache;
+ private final BatchRefUpdate delegate;
+
+ @Inject
+ BatchRefUpdateWithCacheUpdate(
+ RefByNameCacheWrapper refsCache,
+ @Assisted Repository repo,
+ @Assisted BatchRefUpdate delegate) {
+ super(repo.getRefDatabase());
+ this.refsCache = refsCache;
+ this.repo = repo;
+ this.delegate = delegate;
+ }
+
+ @Override
+ public boolean isAllowNonFastForwards() {
+ return delegate.isAllowNonFastForwards();
+ }
+
+ @Override
+ public BatchRefUpdate setAllowNonFastForwards(boolean allow) {
+ delegate.setAllowNonFastForwards(allow);
+ return this;
+ }
+
+ @Override
+ public PersonIdent getRefLogIdent() {
+ return delegate.getRefLogIdent();
+ }
+
+ @Override
+ public BatchRefUpdate setRefLogIdent(PersonIdent pi) {
+ delegate.setRefLogIdent(pi);
+ return this;
+ }
+
+ @Override
+ public String getRefLogMessage() {
+ return delegate.getRefLogMessage();
+ }
+
+ @Override
+ public boolean isRefLogIncludingResult() {
+ return delegate.isRefLogIncludingResult();
+ }
+
+ @Override
+ public BatchRefUpdate setRefLogMessage(String msg, boolean appendStatus) {
+ delegate.setRefLogMessage(msg, appendStatus);
+ return this;
+ }
+
+ @Override
+ public BatchRefUpdate disableRefLog() {
+ delegate.disableRefLog();
+ return this;
+ }
+
+ @Override
+ public BatchRefUpdate setForceRefLog(boolean force) {
+ delegate.setForceRefLog(force);
+ return this;
+ }
+
+ @Override
+ public boolean isRefLogDisabled() {
+ return delegate.isRefLogDisabled();
+ }
+
+ @Override
+ public BatchRefUpdate setAtomic(boolean atomic) {
+ delegate.setAtomic(atomic);
+ return this;
+ }
+
+ @Override
+ public boolean isAtomic() {
+ return delegate.isAtomic();
+ }
+
+ @Override
+ public void setPushCertificate(PushCertificate cert) {
+ delegate.setPushCertificate(cert);
+ }
+
+ @Override
+ public List<ReceiveCommand> getCommands() {
+ return delegate.getCommands();
+ }
+
+ @Override
+ public BatchRefUpdate addCommand(ReceiveCommand cmd) {
+ delegate.addCommand(cmd);
+ return this;
+ }
+
+ @Override
+ public BatchRefUpdate addCommand(ReceiveCommand... cmd) {
+ delegate.addCommand(cmd);
+ return this;
+ }
+
+ @Override
+ public BatchRefUpdate addCommand(Collection<ReceiveCommand> cmd) {
+ delegate.addCommand(cmd);
+ return this;
+ }
+
+ @Override
+ public List<String> getPushOptions() {
+ return delegate.getPushOptions();
+ }
+
+ @Override
+ public List<ProposedTimestamp> getProposedTimestamps() {
+ return delegate.getProposedTimestamps();
+ }
+
+ @Override
+ public BatchRefUpdate addProposedTimestamp(ProposedTimestamp ts) {
+ delegate.addProposedTimestamp(ts);
+ return this;
+ }
+
+ @Override
+ public void execute(RevWalk walk, ProgressMonitor monitor, List<String> options)
+ throws IOException {
+ delegate.execute(walk, monitor, options);
+ evictCache();
+ }
+
+ @Override
+ public void execute(RevWalk walk, ProgressMonitor monitor) throws IOException {
+ delegate.execute(walk, monitor);
+ evictCache();
+ }
+
+ private void evictCache() {
+ delegate
+ .getCommands()
+ .forEach(
+ cmd -> {
+ if (cmd.getResult() == ReceiveCommand.Result.OK) {
+ refsCache.evict(repo.getIdentifier(), cmd.getRefName());
+ }
+ });
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/CachedRefDatabase.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/CachedRefDatabase.java
new file mode 100644
index 0000000..79a619c
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/CachedRefDatabase.java
@@ -0,0 +1,174 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+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 java.util.Optional;
+import java.util.Set;
+import org.eclipse.jgit.lib.BatchRefUpdate;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RefRename;
+import org.eclipse.jgit.lib.RefUpdate;
+
+class CachedRefDatabase extends RefDatabase {
+ interface Factory {
+ CachedRefDatabase create(CachedRefRepository repo);
+ }
+
+ private final RefByNameCacheWrapper refsCache;
+ private final BatchRefUpdateWithCacheUpdate.Factory batchUpdateFactory;
+ private final RefUpdateWithCacheUpdate.Factory updateFactory;
+ private final RefRenameWithCacheUpdate.Factory renameFactory;
+ private final RefDatabase delegate;
+ private final CachedRefRepository repo;
+
+ @Inject
+ CachedRefDatabase(
+ RefByNameCacheWrapper refsCache,
+ BatchRefUpdateWithCacheUpdate.Factory batchUpdateFactory,
+ RefUpdateWithCacheUpdate.Factory updateFactory,
+ RefRenameWithCacheUpdate.Factory renameFactory,
+ @Assisted CachedRefRepository repo) {
+ this.refsCache = refsCache;
+ this.batchUpdateFactory = batchUpdateFactory;
+ this.updateFactory = updateFactory;
+ this.renameFactory = renameFactory;
+ this.delegate = repo.getDelegate().getRefDatabase();
+ this.repo = repo;
+ }
+
+ @Override
+ public void create() throws IOException {
+ delegate.create();
+ }
+
+ @Override
+ public void close() {
+ delegate.close();
+ }
+
+ @Override
+ public boolean isNameConflicting(String name) throws IOException {
+ return delegate.isNameConflicting(name);
+ }
+
+ @Override
+ public RefUpdate newUpdate(String name, boolean detach) throws IOException {
+ return updateFactory.create(this, repo, delegate.newUpdate(name, detach));
+ }
+
+ @Override
+ public RefRename newRename(String fromName, String toName) throws IOException {
+ return renameFactory.create(
+ repo,
+ delegate.newRename(fromName, toName),
+ newUpdate(fromName, false),
+ newUpdate(toName, false));
+ }
+
+ @Override
+ public Ref exactRef(String name) throws IOException {
+ return refsCache.computeIfAbsent(
+ repo.getIdentifier(), name, () -> Optional.ofNullable(delegate.exactRef(name)));
+ }
+
+ @Deprecated
+ @Override
+ public Map<String, Ref> getRefs(String prefix) throws IOException {
+ return delegate.getRefs(prefix);
+ }
+
+ @Override
+ public List<Ref> getAdditionalRefs() throws IOException {
+ return delegate.getAdditionalRefs();
+ }
+
+ @Override
+ public Ref peel(Ref ref) throws IOException {
+ return delegate.peel(ref);
+ }
+
+ @Override
+ public boolean hasVersioning() {
+ return delegate.hasVersioning();
+ }
+
+ @Override
+ public Collection<String> getConflictingNames(String name) throws IOException {
+ return delegate.getConflictingNames(name);
+ }
+
+ @Override
+ public BatchRefUpdate newBatchUpdate() {
+ return batchUpdateFactory.create(repo, delegate.newBatchUpdate());
+ }
+
+ @Override
+ public boolean performsAtomicTransactions() {
+ return delegate.performsAtomicTransactions();
+ }
+
+ @Override
+ public Map<String, Ref> exactRef(String... refs) throws IOException {
+ return delegate.exactRef(refs);
+ }
+
+ @Override
+ public Ref firstExactRef(String... refs) throws IOException {
+ return delegate.firstExactRef(refs);
+ }
+
+ @Override
+ public List<Ref> getRefs() throws IOException {
+ return delegate.getRefs();
+ }
+
+ @Override
+ public List<Ref> getRefsByPrefix(String prefix) throws IOException {
+ return delegate.getRefsByPrefix(prefix);
+ }
+
+ @Override
+ public List<Ref> getRefsByPrefix(String... prefixes) throws IOException {
+ return delegate.getRefsByPrefix(prefixes);
+ }
+
+ @Override
+ public Set<Ref> getTipsWithSha1(ObjectId id) throws IOException {
+ return delegate.getTipsWithSha1(id);
+ }
+
+ @Override
+ public boolean hasFastTipsWithSha1() throws IOException {
+ return delegate.hasFastTipsWithSha1();
+ }
+
+ @Override
+ public boolean hasRefs() throws IOException {
+ return delegate.hasRefs();
+ }
+
+ @Override
+ public void refresh() {
+ delegate.refresh();
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/CachedRefRepository.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/CachedRefRepository.java
new file mode 100644
index 0000000..e7960e3
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/CachedRefRepository.java
@@ -0,0 +1,350 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.eclipse.jgit.dircache.DirCache;
+import org.eclipse.jgit.errors.AmbiguousObjectException;
+import org.eclipse.jgit.errors.CorruptObjectException;
+import org.eclipse.jgit.errors.IncorrectObjectTypeException;
+import org.eclipse.jgit.errors.MissingObjectException;
+import org.eclipse.jgit.errors.NoWorkTreeException;
+import org.eclipse.jgit.errors.RevisionSyntaxException;
+import org.eclipse.jgit.events.ListenerList;
+import org.eclipse.jgit.events.RepositoryEvent;
+import org.eclipse.jgit.lib.AnyObjectId;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.ObjectInserter;
+import org.eclipse.jgit.lib.ObjectLoader;
+import org.eclipse.jgit.lib.ObjectReader;
+import org.eclipse.jgit.lib.ProgressMonitor;
+import org.eclipse.jgit.lib.RebaseTodoLine;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.RefRename;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.lib.RepositoryState;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.util.FS;
+
+class CachedRefRepository extends DelegateRepository {
+ interface Factory {
+ CachedRefRepository create(Repository repo);
+ }
+
+ private final CachedRefDatabase refDb;
+ private final RefUpdateWithCacheUpdate.Factory updateFactory;
+ private final RefRenameWithCacheUpdate.Factory renameFactory;
+
+ @Inject
+ CachedRefRepository(
+ CachedRefDatabase.Factory refDbFactory,
+ RefUpdateWithCacheUpdate.Factory updateFactory,
+ RefRenameWithCacheUpdate.Factory renameFactory,
+ @Assisted Repository repo) {
+ super(repo);
+ this.updateFactory = updateFactory;
+ this.renameFactory = renameFactory;
+ this.refDb = refDbFactory.create(this);
+ }
+
+ @Override
+ public RefDatabase getRefDatabase() {
+ return refDb;
+ }
+
+ @Override
+ public ListenerList getListenerList() {
+ return getDelegate().getListenerList();
+ }
+
+ @Override
+ public void fireEvent(RepositoryEvent<?> event) {
+ getDelegate().fireEvent(event);
+ }
+
+ @Override
+ public File getDirectory() {
+ return getDelegate().getDirectory();
+ }
+
+ @Override
+ public ObjectInserter newObjectInserter() {
+ return getDelegate().newObjectInserter();
+ }
+
+ @Override
+ public ObjectReader newObjectReader() {
+ return getDelegate().newObjectReader();
+ }
+
+ @Override
+ public FS getFS() {
+ return getDelegate().getFS();
+ }
+
+ @Deprecated
+ @Override
+ public boolean hasObject(AnyObjectId objectId) {
+ return getDelegate().hasObject(objectId);
+ }
+
+ @Override
+ public ObjectLoader open(AnyObjectId objectId) throws MissingObjectException, IOException {
+ return getDelegate().open(objectId);
+ }
+
+ @Override
+ public ObjectLoader open(AnyObjectId objectId, int typeHint)
+ throws MissingObjectException, IncorrectObjectTypeException, IOException {
+ return getDelegate().open(objectId, typeHint);
+ }
+
+ @Override
+ public RefUpdate updateRef(String ref) throws IOException {
+ return updateFactory.create(refDb, this, getDelegate().updateRef(ref));
+ }
+
+ @Override
+ public RefUpdate updateRef(String ref, boolean detach) throws IOException {
+ return updateFactory.create(refDb, this, getDelegate().updateRef(ref, detach));
+ }
+
+ @Override
+ public RefRename renameRef(String fromRef, String toRef) throws IOException {
+ return renameFactory.create(
+ this, getDelegate().renameRef(fromRef, toRef), updateRef(fromRef), updateRef(toRef));
+ }
+
+ @Override
+ public ObjectId resolve(String revstr)
+ throws AmbiguousObjectException, IncorrectObjectTypeException, RevisionSyntaxException,
+ IOException {
+ return getDelegate().resolve(revstr);
+ }
+
+ @Override
+ public String simplify(String revstr) throws AmbiguousObjectException, IOException {
+ return getDelegate().simplify(revstr);
+ }
+
+ @Override
+ public void incrementOpen() {
+ getDelegate().incrementOpen();
+ }
+
+ @Override
+ public void close() {
+ getDelegate().close();
+ }
+
+ @Override
+ public String getFullBranch() throws IOException {
+ return getDelegate().getFullBranch();
+ }
+
+ @Override
+ public String getBranch() throws IOException {
+ return getDelegate().getBranch();
+ }
+
+ @Override
+ public Set<ObjectId> getAdditionalHaves() {
+ return getDelegate().getAdditionalHaves();
+ }
+
+ @Deprecated
+ @Override
+ public Map<String, Ref> getAllRefs() {
+ return getDelegate().getAllRefs();
+ }
+
+ @Deprecated
+ @Override
+ public Map<String, Ref> getTags() {
+ return getDelegate().getTags();
+ }
+
+ @Deprecated
+ @Override
+ public Ref peel(Ref ref) {
+ return getDelegate().peel(ref);
+ }
+
+ @Override
+ public Map<AnyObjectId, Set<Ref>> getAllRefsByPeeledObjectId() {
+ return getDelegate().getAllRefsByPeeledObjectId();
+ }
+
+ @Override
+ public File getIndexFile() throws NoWorkTreeException {
+ return getDelegate().getIndexFile();
+ }
+
+ @Override
+ public RevCommit parseCommit(AnyObjectId id)
+ throws IncorrectObjectTypeException, IOException, MissingObjectException {
+ return getDelegate().parseCommit(id);
+ }
+
+ @Override
+ public DirCache readDirCache() throws NoWorkTreeException, CorruptObjectException, IOException {
+ return getDelegate().readDirCache();
+ }
+
+ @Override
+ public DirCache lockDirCache() throws NoWorkTreeException, CorruptObjectException, IOException {
+ return getDelegate().lockDirCache();
+ }
+
+ @Override
+ public RepositoryState getRepositoryState() {
+ return getDelegate().getRepositoryState();
+ }
+
+ @Override
+ public boolean isBare() {
+ return getDelegate().isBare();
+ }
+
+ @Override
+ public File getWorkTree() throws NoWorkTreeException {
+ return getDelegate().getWorkTree();
+ }
+
+ @Override
+ public String shortenRemoteBranchName(String refName) {
+ return getDelegate().shortenRemoteBranchName(refName);
+ }
+
+ @Override
+ public String getRemoteName(String refName) {
+ return getDelegate().getRemoteName(refName);
+ }
+
+ @Override
+ public String getGitwebDescription() throws IOException {
+ return getDelegate().getGitwebDescription();
+ }
+
+ @Override
+ public void setGitwebDescription(String description) throws IOException {
+ getDelegate().setGitwebDescription(description);
+ }
+
+ @Override
+ public String readMergeCommitMsg() throws IOException, NoWorkTreeException {
+ return getDelegate().readMergeCommitMsg();
+ }
+
+ @Override
+ public void writeMergeCommitMsg(String msg) throws IOException {
+ getDelegate().writeMergeCommitMsg(msg);
+ }
+
+ @Override
+ public String readCommitEditMsg() throws IOException, NoWorkTreeException {
+ return getDelegate().readCommitEditMsg();
+ }
+
+ @Override
+ public void writeCommitEditMsg(String msg) throws IOException {
+ getDelegate().writeCommitEditMsg(msg);
+ }
+
+ @Override
+ public List<ObjectId> readMergeHeads() throws IOException, NoWorkTreeException {
+ return getDelegate().readMergeHeads();
+ }
+
+ @Override
+ public void writeMergeHeads(List<? extends ObjectId> heads) throws IOException {
+ getDelegate().writeMergeHeads(heads);
+ }
+
+ @Override
+ public ObjectId readCherryPickHead() throws IOException, NoWorkTreeException {
+ return getDelegate().readCherryPickHead();
+ }
+
+ @Override
+ public ObjectId readRevertHead() throws IOException, NoWorkTreeException {
+ return getDelegate().readRevertHead();
+ }
+
+ @Override
+ public void writeCherryPickHead(ObjectId head) throws IOException {
+ getDelegate().writeCherryPickHead(head);
+ }
+
+ @Override
+ public void writeRevertHead(ObjectId head) throws IOException {
+ getDelegate().writeRevertHead(head);
+ }
+
+ @Override
+ public void writeOrigHead(ObjectId head) throws IOException {
+ getDelegate().writeOrigHead(head);
+ }
+
+ @Override
+ public ObjectId readOrigHead() throws IOException, NoWorkTreeException {
+ return getDelegate().readOrigHead();
+ }
+
+ @Override
+ public String readSquashCommitMsg() throws IOException {
+ return getDelegate().readSquashCommitMsg();
+ }
+
+ @Override
+ public void writeSquashCommitMsg(String msg) throws IOException {
+ getDelegate().writeSquashCommitMsg(msg);
+ }
+
+ @Override
+ public List<RebaseTodoLine> readRebaseTodo(String path, boolean includeComments)
+ throws IOException {
+ return getDelegate().readRebaseTodo(path, includeComments);
+ }
+
+ @Override
+ public void writeRebaseTodoFile(String path, List<RebaseTodoLine> steps, boolean append)
+ throws IOException {
+ getDelegate().writeRebaseTodoFile(path, steps, append);
+ }
+
+ @Override
+ public Set<String> getRemoteNames() {
+ return getDelegate().getRemoteNames();
+ }
+
+ @Override
+ public void autoGC(ProgressMonitor monitor) {
+ getDelegate().autoGC(monitor);
+ }
+
+ @Override
+ public void create() throws IOException {
+ getDelegate().create();
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/CachedRefsModule.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/CachedRefsModule.java
new file mode 100644
index 0000000..9d6eb2d
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/CachedRefsModule.java
@@ -0,0 +1,23 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import com.google.gerrit.extensions.config.FactoryModule;
+
+public class CachedRefsModule extends FactoryModule {
+ @Override
+ protected void configure() {
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/DelegateRepository.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/DelegateRepository.java
new file mode 100644
index 0000000..1323398
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/DelegateRepository.java
@@ -0,0 +1,97 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import java.io.IOException;
+import org.eclipse.jgit.attributes.AttributesNodeProvider;
+import org.eclipse.jgit.lib.BaseRepositoryBuilder;
+import org.eclipse.jgit.lib.ObjectDatabase;
+import org.eclipse.jgit.lib.RefDatabase;
+import org.eclipse.jgit.lib.ReflogReader;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.lib.StoredConfig;
+
+/**
+ * For the time being copied from com.google.gerrit.server.git.DelegateRepository as it is package
+ * protected in 'stable-3.2'. It can be dropped when change gets merged up to.
+ */
+class DelegateRepository extends Repository {
+
+ private final Repository delegate;
+
+ DelegateRepository(Repository delegate) {
+ super(toBuilder(delegate));
+ this.delegate = delegate;
+ }
+
+ @Override
+ public void create(boolean bare) throws IOException {
+ delegate.create(bare);
+ }
+
+ @Override
+ public String getIdentifier() {
+ return delegate.getIdentifier();
+ }
+
+ @Override
+ public ObjectDatabase getObjectDatabase() {
+ return delegate.getObjectDatabase();
+ }
+
+ @Override
+ public RefDatabase getRefDatabase() {
+ return delegate.getRefDatabase();
+ }
+
+ @Override
+ public StoredConfig getConfig() {
+ return delegate.getConfig();
+ }
+
+ @Override
+ public AttributesNodeProvider createAttributesNodeProvider() {
+ return delegate.createAttributesNodeProvider();
+ }
+
+ @Override
+ public void scanForRepoChanges() throws IOException {
+ delegate.scanForRepoChanges();
+ }
+
+ @Override
+ public void notifyIndexChanged(boolean internal) {
+ delegate.notifyIndexChanged(internal);
+ }
+
+ @Override
+ public ReflogReader getReflogReader(String refName) throws IOException {
+ return delegate.getReflogReader(refName);
+ }
+
+ public Repository getDelegate() {
+ return delegate;
+ }
+
+ @SuppressWarnings("rawtypes")
+ private static BaseRepositoryBuilder toBuilder(Repository repo) {
+ if (!repo.isBare()) {
+ throw new IllegalArgumentException(
+ "non-bare repository is not supported: " + repo.getIdentifier());
+ }
+
+ return new BaseRepositoryBuilder<>().setFS(repo.getFS()).setGitDir(repo.getDirectory());
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/GerritCachedGitRepositoryManager.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/GerritCachedGitRepositoryManager.java
new file mode 100644
index 0000000..4eb0cf1
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/GerritCachedGitRepositoryManager.java
@@ -0,0 +1,52 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.gerrit.server.git.LocalDiskRepositoryManager;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.io.IOException;
+import java.util.SortedSet;
+import org.eclipse.jgit.lib.Repository;
+
+@Singleton
+class GerritCachedGitRepositoryManager implements GitRepositoryManager {
+ private final LocalDiskRepositoryManager repoManager;
+ private final CachedRefRepository.Factory repoWrapperFactory;
+
+ @Inject
+ GerritCachedGitRepositoryManager(
+ LocalDiskRepositoryManager repoManager, CachedRefRepository.Factory repoWrapperFactory) {
+ this.repoManager = repoManager;
+ this.repoWrapperFactory = repoWrapperFactory;
+ }
+
+ @Override
+ public Repository openRepository(Project.NameKey name) throws IOException {
+ return repoWrapperFactory.create(repoManager.openRepository(name));
+ }
+
+ @Override
+ public Repository createRepository(Project.NameKey name) throws IOException {
+ return repoWrapperFactory.create(repoManager.createRepository(name));
+ }
+
+ @Override
+ public SortedSet<Project.NameKey> list() {
+ return repoManager.list();
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/LibDbModule.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/LibDbModule.java
new file mode 100644
index 0000000..5787abe
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/LibDbModule.java
@@ -0,0 +1,38 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import com.google.common.flogger.FluentLogger;
+import com.google.gerrit.extensions.config.FactoryModule;
+import com.google.gerrit.extensions.registration.DynamicItem;
+import com.google.gerrit.server.git.GitRepositoryManager;
+
+public class LibDbModule extends FactoryModule {
+ private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+
+ @Override
+ protected void configure() {
+ DynamicItem.itemOf(binder(), RefByNameCache.class);
+
+ factory(RefUpdateWithCacheUpdate.Factory.class);
+ factory(RefRenameWithCacheUpdate.Factory.class);
+ factory(BatchRefUpdateWithCacheUpdate.Factory.class);
+ factory(CachedRefDatabase.Factory.class);
+ factory(CachedRefRepository.Factory.class);
+
+ bind(GitRepositoryManager.class).to(GerritCachedGitRepositoryManager.class);
+ logger.atInfo().log("DB library loaded");
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/LibSysModule.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/LibSysModule.java
new file mode 100644
index 0000000..e6dab8f
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/LibSysModule.java
@@ -0,0 +1,32 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import static com.google.inject.Scopes.SINGLETON;
+
+import com.google.common.flogger.FluentLogger;
+import com.google.gerrit.extensions.registration.DynamicItem;
+import com.google.inject.AbstractModule;
+
+public class LibSysModule extends AbstractModule {
+ private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+
+ @Override
+ protected void configure() {
+ install(RefByNameGerritCache.module());
+ DynamicItem.bind(binder(), RefByNameCache.class).to(RefByNameGerritCache.class).in(SINGLETON);
+ logger.atInfo().log("Sys library loaded");
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/NoOpRefByNameCache.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/NoOpRefByNameCache.java
new file mode 100644
index 0000000..44b6abb
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/NoOpRefByNameCache.java
@@ -0,0 +1,41 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import com.google.common.flogger.FluentLogger;
+import java.util.Optional;
+import java.util.concurrent.Callable;
+import org.eclipse.jgit.lib.Ref;
+
+class NoOpRefByNameCache implements RefByNameCache {
+ private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+
+ @Override
+ public Ref computeIfAbsent(
+ String identifier, String ref, Callable<? extends Optional<Ref>> loader) {
+ try {
+ return loader.call().orElse(null);
+ } catch (Exception e) {
+ logger.atSevere().withCause(e).log(
+ "Repository '%s', getting ref '%s' failed", identifier, ref);
+ }
+ return null;
+ }
+
+ @Override
+ public void evict(String identifier, String ref) {
+ // do nothing as there is no cache to be evicted
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefByNameCache.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefByNameCache.java
new file mode 100644
index 0000000..69fabfc
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefByNameCache.java
@@ -0,0 +1,25 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import java.util.Optional;
+import java.util.concurrent.Callable;
+import org.eclipse.jgit.lib.Ref;
+
+interface RefByNameCache {
+ Ref computeIfAbsent(String identifier, String ref, Callable<? extends Optional<Ref>> loader);
+
+ void evict(String identifier, String ref);
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefByNameCacheWrapper.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefByNameCacheWrapper.java
new file mode 100644
index 0000000..c9744ad
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefByNameCacheWrapper.java
@@ -0,0 +1,45 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.gerrit.extensions.registration.DynamicItem;
+import com.google.inject.Inject;
+import java.util.Optional;
+import java.util.concurrent.Callable;
+import org.eclipse.jgit.lib.Ref;
+
+class RefByNameCacheWrapper implements RefByNameCache {
+ private static final RefByNameCache NOOP_CACHE = new NoOpRefByNameCache();
+
+ @Inject(optional = true)
+ private DynamicItem<RefByNameCache> refByNameCache;
+
+ @Override
+ public Ref computeIfAbsent(
+ String identifier, String ref, Callable<? extends Optional<Ref>> loader) {
+ return cache().computeIfAbsent(identifier, ref, loader);
+ }
+
+ @Override
+ public void evict(String identifier, String ref) {
+ cache().evict(identifier, ref);
+ }
+
+ @VisibleForTesting
+ RefByNameCache cache() {
+ return Optional.ofNullable(refByNameCache).map(DynamicItem::get).orElse(NOOP_CACHE);
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefByNameGerritCache.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefByNameGerritCache.java
new file mode 100644
index 0000000..e9fc2b7
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefByNameGerritCache.java
@@ -0,0 +1,70 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import com.google.common.cache.Cache;
+import com.google.common.flogger.FluentLogger;
+import com.google.gerrit.server.cache.CacheModule;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import com.google.inject.TypeLiteral;
+import com.google.inject.name.Named;
+import java.util.Optional;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import org.eclipse.jgit.lib.Ref;
+
+@Singleton
+class RefByNameGerritCache implements RefByNameCache {
+ private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+ private static final String REF_BY_NAME = "ref_by_name";
+
+ static com.google.inject.Module module() {
+ return new CacheModule() {
+ @Override
+ protected void configure() {
+ cache(REF_BY_NAME, String.class, new TypeLiteral<Optional<Ref>>() {});
+ }
+ };
+ }
+
+ private final Cache<String, Optional<Ref>> refByName;
+
+ @Inject
+ RefByNameGerritCache(@Named(REF_BY_NAME) Cache<String, Optional<Ref>> refByName) {
+ this.refByName = refByName;
+ }
+
+ @Override
+ public Ref computeIfAbsent(
+ String identifier, String ref, Callable<? extends Optional<Ref>> loader) {
+ String uniqueRefName = getUniqueName(identifier, ref);
+ try {
+ return refByName.get(uniqueRefName, loader).orElse(null);
+ } catch (ExecutionException e) {
+ logger.atWarning().withCause(e).log("Getting ref for [%s] failed.", uniqueRefName);
+ return null;
+ }
+ }
+
+ @Override
+ public void evict(String identifier, String ref) {
+ refByName.invalidate(getUniqueName(identifier, ref));
+ }
+
+ private static String getUniqueName(String identifier, String ref) {
+ return String.format("%s$%s", identifier, ref);
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefRenameWithCacheUpdate.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefRenameWithCacheUpdate.java
new file mode 100644
index 0000000..68de4ca
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefRenameWithCacheUpdate.java
@@ -0,0 +1,107 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.io.IOException;
+import java.util.EnumSet;
+import org.eclipse.jgit.lib.PersonIdent;
+import org.eclipse.jgit.lib.RefRename;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.RefUpdate.Result;
+import org.eclipse.jgit.lib.Repository;
+
+class RefRenameWithCacheUpdate extends RefRename {
+ interface Factory {
+ RefRenameWithCacheUpdate create(
+ Repository repo,
+ RefRename delegate,
+ @Assisted("src") RefUpdate src,
+ @Assisted("dst") RefUpdate dst);
+ }
+
+ private static final String NOT_SUPPORTED_MSG = "Should never be called";
+ private static final EnumSet<Result> SUCCESSFUL_RENAMES =
+ EnumSet.of(Result.NEW, Result.FORCED, Result.FAST_FORWARD, Result.RENAMED);
+
+ private final RefByNameCacheWrapper refsCache;
+ private final Repository repo;
+ private final RefRename delegate;
+ private final RefUpdate src;
+
+ @Inject
+ RefRenameWithCacheUpdate(
+ RefByNameCacheWrapper refsCache,
+ @Assisted Repository repo,
+ @Assisted RefRename delegate,
+ @Assisted("src") RefUpdate src,
+ @Assisted("dst") RefUpdate dst) {
+ super(src, dst);
+ this.refsCache = refsCache;
+ this.repo = repo;
+ this.delegate = delegate;
+ this.src = src;
+ }
+
+ @Override
+ public PersonIdent getRefLogIdent() {
+ return delegate.getRefLogIdent();
+ }
+
+ @Override
+ public void setRefLogIdent(PersonIdent pi) {
+ delegate.setRefLogIdent(pi);
+ }
+
+ @Override
+ public String getRefLogMessage() {
+ return delegate.getRefLogMessage();
+ }
+
+ @Override
+ public void setRefLogMessage(String msg) {
+ // Method is called from the super constructor and delegate is not available yet therefore
+ // 'null' has to be checked. It doesn't matter as wrapped instance is properly constructed and
+ // its ref log message is used.
+ if (delegate != null) {
+ delegate.setRefLogMessage(msg);
+ }
+ }
+
+ @Override
+ public void disableRefLog() {
+ delegate.disableRefLog();
+ }
+
+ @Override
+ public Result getResult() {
+ return delegate.getResult();
+ }
+
+ @Override
+ public Result rename() throws IOException {
+ Result r = delegate.rename();
+ if (SUCCESSFUL_RENAMES.contains(r)) {
+ refsCache.evict(repo.getIdentifier(), src.getName());
+ }
+ return r;
+ }
+
+ @Override
+ protected Result doRename() throws IOException {
+ throw new UnsupportedOperationException(NOT_SUPPORTED_MSG);
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefUpdateWithCacheUpdate.java b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefUpdateWithCacheUpdate.java
new file mode 100644
index 0000000..a4bee39
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/RefUpdateWithCacheUpdate.java
@@ -0,0 +1,215 @@
+package com.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+import java.io.IOException;
+import java.util.EnumSet;
+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;
+
+class RefUpdateWithCacheUpdate extends RefUpdate {
+ interface Factory {
+ RefUpdateWithCacheUpdate create(RefDatabase refDb, Repository repo, RefUpdate delegate);
+ }
+
+ private static final String NOT_SUPPORTED_MSG = "Should never be called";
+ private static final EnumSet<Result> SUCCESSFUL_UPDATES =
+ EnumSet.of(Result.NEW, Result.FORCED, Result.FAST_FORWARD, Result.RENAMED);
+
+ private final RefByNameCacheWrapper refsCache;
+ private final RefDatabase refDb;
+ private final Repository repo;
+ private final RefUpdate delegate;
+
+ @Inject
+ RefUpdateWithCacheUpdate(
+ RefByNameCacheWrapper refsCache,
+ @Assisted RefDatabase refDb,
+ @Assisted Repository repo,
+ @Assisted RefUpdate delegate) {
+ super(delegate.getRef());
+ this.refsCache = refsCache;
+ this.refDb = refDb;
+ this.repo = repo;
+ this.delegate = delegate;
+ }
+
+ @Override
+ public String getName() {
+ return delegate.getName();
+ }
+
+ @Override
+ public Ref getRef() {
+ return delegate.getRef();
+ }
+
+ @Override
+ public ObjectId getNewObjectId() {
+ return delegate.getNewObjectId();
+ }
+
+ @Override
+ public void setDetachingSymbolicRef() {
+ delegate.setDetachingSymbolicRef();
+ }
+
+ @Override
+ public boolean isDetachingSymbolicRef() {
+ return delegate.isDetachingSymbolicRef();
+ }
+
+ @Override
+ public void setNewObjectId(AnyObjectId id) {
+ delegate.setNewObjectId(id);
+ }
+
+ @Override
+ public ObjectId getExpectedOldObjectId() {
+ return delegate.getExpectedOldObjectId();
+ }
+
+ @Override
+ public void setExpectedOldObjectId(AnyObjectId id) {
+ delegate.setExpectedOldObjectId(id);
+ }
+
+ @Override
+ public boolean isForceUpdate() {
+ return delegate.isForceUpdate();
+ }
+
+ @Override
+ public void setForceUpdate(boolean b) {
+ delegate.setForceUpdate(b);
+ }
+
+ @Override
+ public PersonIdent getRefLogIdent() {
+ return delegate.getRefLogIdent();
+ }
+
+ @Override
+ public void setRefLogIdent(PersonIdent pi) {
+ delegate.setRefLogIdent(pi);
+ }
+
+ @Override
+ public String getRefLogMessage() {
+ return delegate.getRefLogMessage();
+ }
+
+ @Override
+ public void setRefLogMessage(String msg, boolean appendStatus) {
+ delegate.setRefLogMessage(msg, appendStatus);
+ }
+
+ @Override
+ public void disableRefLog() {
+ delegate.disableRefLog();
+ }
+
+ @Override
+ public void setForceRefLog(boolean force) {
+ delegate.setForceRefLog(force);
+ }
+
+ @Override
+ public ObjectId getOldObjectId() {
+ return delegate.getOldObjectId();
+ }
+
+ @Override
+ public void setPushCertificate(PushCertificate cert) {
+ delegate.setPushCertificate(cert);
+ }
+
+ @Override
+ public Result getResult() {
+ return delegate.getResult();
+ }
+
+ @Override
+ public Result forceUpdate() throws IOException {
+ return evictCache(delegate.forceUpdate());
+ }
+
+ @Override
+ public Result update() throws IOException {
+ return evictCache(delegate.update());
+ }
+
+ @Override
+ public Result update(RevWalk walk) throws IOException {
+ return evictCache(delegate.update(walk));
+ }
+
+ @Override
+ public Result delete() throws IOException {
+ return evictCache(delegate.delete());
+ }
+
+ @Override
+ public Result delete(RevWalk walk) throws IOException {
+ return evictCache(delegate.delete(walk));
+ }
+
+ @Override
+ public Result link(String target) throws IOException {
+ return evictCache(delegate.link(target));
+ }
+
+ @Override
+ public void setCheckConflicting(boolean check) {
+ delegate.setCheckConflicting(check);
+ }
+
+ @Override
+ protected RefDatabase getRefDatabase() {
+ return refDb;
+ }
+
+ @Override
+ protected Repository getRepository() {
+ return repo;
+ }
+
+ @Override
+ protected boolean tryLock(boolean deref) throws IOException {
+ throw new UnsupportedOperationException(NOT_SUPPORTED_MSG);
+ }
+
+ @Override
+ protected void unlock() {
+ throw new UnsupportedOperationException(NOT_SUPPORTED_MSG);
+ }
+
+ @Override
+ protected Result doUpdate(Result desiredResult) throws IOException {
+ throw new UnsupportedOperationException(NOT_SUPPORTED_MSG);
+ }
+
+ @Override
+ protected Result doDelete(Result desiredResult) throws IOException {
+ throw new UnsupportedOperationException(NOT_SUPPORTED_MSG);
+ }
+
+ @Override
+ protected Result doLink(String target) throws IOException {
+ throw new UnsupportedOperationException(NOT_SUPPORTED_MSG);
+ }
+
+ private Result evictCache(Result r) {
+ if (SUCCESSFUL_UPDATES.contains(r)) {
+ refsCache.evict(repo.getIdentifier(), getName());
+ }
+ return r;
+ }
+}
diff --git a/src/test/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/GerritCachedRefDbIT.java b/src/test/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/GerritCachedRefDbIT.java
new file mode 100644
index 0000000..bf2ca31
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/gerritcachedrefdb/GerritCachedRefDbIT.java
@@ -0,0 +1,45 @@
+// Copyright (C) 2021 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.googlesource.gerrit.plugins.gerritcachedrefdb;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.gerrit.acceptance.AbstractDaemonTest;
+import com.google.gerrit.acceptance.NoHttpd;
+import com.google.gerrit.acceptance.UseLocalDisk;
+import com.google.gerrit.acceptance.config.GerritConfig;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.inject.Inject;
+import org.junit.Test;
+
+@UseLocalDisk
+@NoHttpd
+public class GerritCachedRefDbIT extends AbstractDaemonTest {
+ @Inject private GitRepositoryManager gitRepoManager;
+
+ @Inject private RefByNameCacheWrapper refByNameCacheWrapper;
+
+ @Test
+ @GerritConfig(
+ name = "gerrit.installDbModule",
+ value = "com.googlesource.gerrit.plugins.gerritcachedrefdb.LibDbModule")
+ @GerritConfig(
+ name = "gerrit.installModule",
+ value = "com.googlesource.gerrit.plugins.gerritcachedrefdb.LibSysModule")
+ public void shouldBeAbleToInstallGerritCachedGitRepoManager() {
+ assertThat(gitRepoManager).isInstanceOf(GerritCachedGitRepositoryManager.class);
+ assertThat(refByNameCacheWrapper.cache()).isInstanceOf(RefByNameGerritCache.class);
+ }
+}
