blob: b940ccc8478f95c3537c36e5fbbff3882a39ee96 [file] [log] [blame]
// Copyright (C) 2008 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.gerrit.server.project;
import static com.google.gerrit.server.project.ProjectCache.illegalState;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.stream.Collectors.toSet;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Sets;
import com.google.common.collect.Streams;
import com.google.common.flogger.FluentLogger;
import com.google.common.hash.Hashing;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.gerrit.common.Nullable;
import com.google.gerrit.entities.AccountGroup;
import com.google.gerrit.entities.CachedProjectConfig;
import com.google.gerrit.entities.Project;
import com.google.gerrit.entities.RefNames;
import com.google.gerrit.exceptions.StorageException;
import com.google.gerrit.index.project.ProjectIndexer;
import com.google.gerrit.lifecycle.LifecycleModule;
import com.google.gerrit.metrics.Counter2;
import com.google.gerrit.metrics.Description;
import com.google.gerrit.metrics.Description.Units;
import com.google.gerrit.metrics.Field;
import com.google.gerrit.metrics.MetricMaker;
import com.google.gerrit.metrics.Timer0;
import com.google.gerrit.proto.Protos;
import com.google.gerrit.server.CacheRefreshExecutor;
import com.google.gerrit.server.cache.CacheModule;
import com.google.gerrit.server.cache.proto.Cache;
import com.google.gerrit.server.cache.serialize.CacheSerializer;
import com.google.gerrit.server.cache.serialize.ObjectIdConverter;
import com.google.gerrit.server.cache.serialize.ProtobufSerializer;
import com.google.gerrit.server.cache.serialize.entities.CachedProjectConfigSerializer;
import com.google.gerrit.server.config.AllProjectsConfigProvider;
import com.google.gerrit.server.config.AllProjectsName;
import com.google.gerrit.server.config.AllUsersName;
import com.google.gerrit.server.config.GerritServerConfig;
import com.google.gerrit.server.git.GitRepositoryManager;
import com.google.gerrit.server.logging.Metadata;
import com.google.gerrit.server.logging.TraceContext;
import com.google.gerrit.server.logging.TraceContext.TraceTimer;
import com.google.inject.Inject;
import com.google.inject.Module;
import com.google.inject.Provider;
import com.google.inject.Singleton;
import com.google.inject.TypeLiteral;
import com.google.inject.name.Named;
import com.google.protobuf.ByteString;
import java.io.IOException;
import java.time.Duration;
import java.util.Arrays;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.StoredConfig;
/**
* Cache of project information, including access rights.
*
* <p>The data of a project is the project's project.config in refs/meta/config parsed out as an
* immutable value. It's keyed purely by the refs/meta/config SHA-1. We also cache the same value
* keyed by name. The latter mapping can become outdated, so data must be evicted explicitly.
*/
@Singleton
public class ProjectCacheImpl implements ProjectCache {
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
public static final String CACHE_NAME = "projects";
public static final String PERSISTED_CACHE_NAME = "persisted_projects";
public static final String CACHE_LIST = "project_list";
public static Module module() {
return new CacheModule() {
@Override
protected void configure() {
// We split the project cache into two parts for performance reasons:
// 1) An in-memory part that has only the project name as key.
// 2) A persisted part that has the name and revision as key.
//
// When loading dashboards or returning change query results we potentially
// need to access hundreds of projects because each change could originate in
// a different project and, through inheritance, require us to check even more
// projects when evaluating permissions. It's not feasible to read the revision
// of refs/meta/config from each of these repos as that would require opening
// them all and reading their ref list or table.
// At the same time, we want the persisted cache to be immutable and we want it
// to be impossible that a value for a given key is out of date. We therefore
// require a revision in the key. That is in line with the rest of the caches in
// Gerrit.
//
// Splitting the cache into two chunks internally in this class allows us to retain
// the existing performance guarantees of not requiring reads for the repo for values
// cached in-memory but also to persist the cache which leads to a much improved
// cold-start behavior and in-memory miss latency.
cache(
CACHE_NAME,
Project.NameKey.class,
new TypeLiteral<Optional<CachedProjectConfig>>() {})
.loader(InMemoryLoader.class)
.refreshAfterWrite(Duration.ofMinutes(15))
.expireAfterWrite(Duration.ofHours(1));
persist(PERSISTED_CACHE_NAME, Cache.ProjectCacheKeyProto.class, CachedProjectConfig.class)
.loader(PersistedLoader.class)
.keySerializer(new ProtobufSerializer<>(Cache.ProjectCacheKeyProto.parser()))
.valueSerializer(PersistedProjectConfigSerializer.INSTANCE)
.diskLimit(1 << 30) // 1 GiB
.version(4)
.maximumWeight(0);
cache(CACHE_LIST, ListKey.class, new TypeLiteral<ImmutableSortedSet<Project.NameKey>>() {})
.maximumWeight(1)
.loader(Lister.class);
bind(ProjectCacheImpl.class);
bind(ProjectCache.class).to(ProjectCacheImpl.class);
install(
new LifecycleModule() {
@Override
protected void configure() {
listener().to(ProjectCacheWarmer.class);
}
});
install(
new LifecycleModule() {
@Override
protected void configure() {
listener().to(PeriodicProjectListCacheWarmer.LifeCycle.class);
}
});
}
};
}
private final Config config;
private final AllProjectsName allProjectsName;
private final AllUsersName allUsersName;
private final LoadingCache<Project.NameKey, Optional<CachedProjectConfig>> inMemoryProjectCache;
private final LoadingCache<ListKey, ImmutableSortedSet<Project.NameKey>> list;
private final Lock listLock;
private final Provider<ProjectIndexer> indexer;
private final Timer0 guessRelevantGroupsLatency;
private final ProjectState.Factory projectStateFactory;
@Inject
ProjectCacheImpl(
@GerritServerConfig Config config,
AllProjectsName allProjectsName,
AllUsersName allUsersName,
@Named(CACHE_NAME)
LoadingCache<Project.NameKey, Optional<CachedProjectConfig>> inMemoryProjectCache,
@Named(CACHE_LIST) LoadingCache<ListKey, ImmutableSortedSet<Project.NameKey>> list,
Provider<ProjectIndexer> indexer,
MetricMaker metricMaker,
ProjectState.Factory projectStateFactory) {
this.config = config;
this.allProjectsName = allProjectsName;
this.allUsersName = allUsersName;
this.inMemoryProjectCache = inMemoryProjectCache;
this.list = list;
this.listLock = new ReentrantLock(true /* fair */);
this.indexer = indexer;
this.projectStateFactory = projectStateFactory;
this.guessRelevantGroupsLatency =
metricMaker.newTimer(
"group/guess_relevant_groups_latency",
new Description("Latency for guessing relevant groups")
.setCumulative()
.setUnit(Units.NANOSECONDS));
}
@Override
public ProjectState getAllProjects() {
return get(allProjectsName).orElseThrow(illegalState(allProjectsName));
}
@Override
public ProjectState getAllUsers() {
return get(allUsersName).orElseThrow(illegalState(allUsersName));
}
@Override
public Optional<ProjectState> get(@Nullable Project.NameKey projectName) {
if (projectName == null) {
return Optional.empty();
}
try {
return inMemoryProjectCache.get(projectName).map(projectStateFactory::create);
} catch (ExecutionException e) {
throw new StorageException(
String.format("project state of project %s not available", projectName.get()), e);
}
}
@Override
public void evict(Project.NameKey p) {
if (p != null) {
logger.atFine().log("Evict project '%s'", p.get());
inMemoryProjectCache.invalidate(p);
}
}
@Override
public void evictAndReindex(Project p) {
evictAndReindex(p.getNameKey());
}
@Override
public void evictAndReindex(Project.NameKey p) {
evict(p);
indexer.get().index(p);
}
@Override
public void remove(Project p) {
remove(p.getNameKey());
}
@Override
public void remove(Project.NameKey name) {
listLock.lock();
try {
list.put(
ListKey.ALL,
ImmutableSortedSet.copyOf(Sets.difference(list.get(ListKey.ALL), ImmutableSet.of(name))));
} catch (ExecutionException e) {
logger.atWarning().withCause(e).log("Cannot list available projects");
} finally {
listLock.unlock();
}
evictAndReindex(name);
}
@Override
public void onCreateProject(Project.NameKey newProjectName) throws IOException {
listLock.lock();
try {
list.put(
ListKey.ALL,
ImmutableSortedSet.copyOf(
Sets.union(list.get(ListKey.ALL), ImmutableSet.of(newProjectName))));
} catch (ExecutionException e) {
logger.atWarning().withCause(e).log("Cannot list available projects");
} finally {
listLock.unlock();
}
evictAndReindex(newProjectName);
}
@Override
public ImmutableSortedSet<Project.NameKey> all() {
try {
return list.get(ListKey.ALL);
} catch (ExecutionException e) {
logger.atWarning().withCause(e).log("Cannot list available projects");
return ImmutableSortedSet.of();
}
}
@Override
public void refreshProjectList() {
list.refresh(ListKey.ALL);
}
@Override
public Set<AccountGroup.UUID> guessRelevantGroupUUIDs() {
try (Timer0.Context ignored = guessRelevantGroupsLatency.start()) {
Set<AccountGroup.UUID> relevantGroupUuids =
Streams.concat(
Arrays.stream(
config.getStringList("groups", /* subsection= */ null, "relevantGroup"))
.map(AccountGroup::uuid),
all().stream()
.map(n -> inMemoryProjectCache.getIfPresent(n))
.filter(Objects::nonNull)
.filter(Optional::isPresent)
.flatMap(p -> p.get().getAllGroupUUIDs().stream())
// getAllGroupUUIDs shouldn't really return null UUIDs, but harden
// against them just in case there is a bug or corner case.
.filter(id -> id != null && id.get() != null))
.collect(toSet());
logger.atFine().log("relevant group UUIDs: %s", relevantGroupUuids);
return relevantGroupUuids;
}
}
@Override
public ImmutableSortedSet<Project.NameKey> byName(String pfx) {
Project.NameKey start = Project.nameKey(pfx);
Project.NameKey end = Project.nameKey(pfx + Character.MAX_VALUE);
try {
// Right endpoint is exclusive, but U+FFFF is a non-character so no project ends with it.
return list.get(ListKey.ALL).subSet(start, end);
} catch (ExecutionException e) {
logger.atWarning().withCause(e).log("Cannot look up projects for prefix %s", pfx);
return ImmutableSortedSet.of();
}
}
/**
* Returns a {@code MurMur128} hash of the contents of {@code etc/All-Projects-project.config}.
*/
public static byte[] allProjectsFileProjectConfigHash(Optional<StoredConfig> allProjectsConfig) {
// Hash the contents of All-Projects-project.config
// This is a way for administrators to orchestrate project.config changes across many Gerrit
// instances.
// When this file changes, we need to make sure we disregard persistently cached project
// state.
if (!allProjectsConfig.isPresent()) {
// If the project.config file is not present, this is equal to an empty config file:
return Hashing.murmur3_128().hashString("", UTF_8).asBytes();
}
try {
allProjectsConfig.get().load();
} catch (IOException | ConfigInvalidException e) {
throw new IllegalStateException(e);
}
return Hashing.murmur3_128().hashString(allProjectsConfig.get().toText(), UTF_8).asBytes();
}
@Singleton
static class InMemoryLoader extends CacheLoader<Project.NameKey, Optional<CachedProjectConfig>> {
private final LoadingCache<Cache.ProjectCacheKeyProto, CachedProjectConfig> persistedCache;
private final GitRepositoryManager repoManager;
private final ListeningExecutorService cacheRefreshExecutor;
private final Counter2<String, Boolean> refreshCounter;
private final AllProjectsName allProjectsName;
private final AllProjectsConfigProvider allProjectsConfigProvider;
@Inject
InMemoryLoader(
@Named(PERSISTED_CACHE_NAME)
LoadingCache<Cache.ProjectCacheKeyProto, CachedProjectConfig> persistedCache,
GitRepositoryManager repoManager,
@CacheRefreshExecutor ListeningExecutorService cacheRefreshExecutor,
MetricMaker metricMaker,
AllProjectsName allProjectsName,
AllProjectsConfigProvider allProjectsConfigProvider) {
this.persistedCache = persistedCache;
this.repoManager = repoManager;
this.cacheRefreshExecutor = cacheRefreshExecutor;
refreshCounter =
metricMaker.newCounter(
"caches/refresh_count",
new Description(
"The number of refreshes per cache with an indicator if a reload was"
+ " necessary.")
.setRate(),
Field.ofString("cache", Metadata.Builder::className)
.description("The name of the cache.")
.build(),
Field.ofBoolean("outdated", Metadata.Builder::outdated)
.description("Whether the cache entry was outdated on reload.")
.build());
this.allProjectsName = allProjectsName;
this.allProjectsConfigProvider = allProjectsConfigProvider;
}
@Override
public Optional<CachedProjectConfig> load(Project.NameKey key)
throws IOException, ExecutionException {
try {
try (TraceTimer ignored =
TraceContext.newTimer(
"Loading project from serialized cache",
Metadata.builder().projectName(key.get()).build());
Repository git = repoManager.openRepository(key)) {
Cache.ProjectCacheKeyProto.Builder keyProto =
Cache.ProjectCacheKeyProto.newBuilder().setProject(key.get());
Ref configRef = git.exactRef(RefNames.REFS_CONFIG);
if (key.get().equals(allProjectsName.get())) {
Optional<StoredConfig> allProjectsConfig =
allProjectsConfigProvider.get(allProjectsName);
byte[] fileHash = allProjectsFileProjectConfigHash(allProjectsConfig);
keyProto.setGlobalConfigRevision(ByteString.copyFrom(fileHash));
}
if (configRef != null) {
keyProto.setRevision(ObjectIdConverter.create().toByteString(configRef.getObjectId()));
}
return Optional.of(persistedCache.get(keyProto.build()));
}
} catch (RepositoryNotFoundException e) {
return Optional.empty();
}
}
@Override
public ListenableFuture<Optional<CachedProjectConfig>> reload(
Project.NameKey key, Optional<CachedProjectConfig> oldState) throws Exception {
try (TraceTimer ignored =
TraceContext.newTimer(
"Reload project", Metadata.builder().projectName(key.get()).build())) {
try (Repository git = repoManager.openRepository(key)) {
Ref configRef = git.exactRef(RefNames.REFS_CONFIG);
if (oldState.isPresent()) {
if (configRef != null
&& configRef.getObjectId().equals(oldState.get().getRevision().get())) {
// Old and new state are equivalent
refreshCounter.increment(CACHE_NAME, false);
return Futures.immediateFuture(oldState);
}
} else {
if (configRef == null) {
// Repository is still missing
refreshCounter.increment(CACHE_NAME, false);
return Futures.immediateFuture(Optional.empty());
}
}
}
// Repository is not thread safe, so we have to open it on the thread that does the loading.
// Just invoke the loader on the other thread.
refreshCounter.increment(CACHE_NAME, true);
return cacheRefreshExecutor.submit(() -> load(key));
}
}
}
@Singleton
static class PersistedLoader
extends CacheLoader<Cache.ProjectCacheKeyProto, CachedProjectConfig> {
private final GitRepositoryManager repoManager;
private final ProjectConfig.Factory projectConfigFactory;
@Inject
PersistedLoader(GitRepositoryManager repoManager, ProjectConfig.Factory projectConfigFactory) {
this.repoManager = repoManager;
this.projectConfigFactory = projectConfigFactory;
}
@Override
public CachedProjectConfig load(Cache.ProjectCacheKeyProto key) throws Exception {
Project.NameKey nameKey = Project.nameKey(key.getProject());
ObjectId revision =
key.getRevision().isEmpty()
? null
: ObjectIdConverter.create().fromByteString(key.getRevision());
try (TraceTimer ignored =
TraceContext.newTimer(
"Loading project from repo", Metadata.builder().projectName(nameKey.get()).build())) {
try (Repository git = repoManager.openRepository(nameKey)) {
ProjectConfig cfg = projectConfigFactory.create(nameKey);
cfg.load(git, revision);
return cfg.getCacheable();
}
}
}
}
private enum PersistedProjectConfigSerializer implements CacheSerializer<CachedProjectConfig> {
INSTANCE;
@Override
public byte[] serialize(CachedProjectConfig value) {
return Protos.toByteArray(CachedProjectConfigSerializer.serialize(value));
}
@Override
public CachedProjectConfig deserialize(byte[] in) {
return CachedProjectConfigSerializer.deserialize(
Protos.parseUnchecked(Cache.CachedProjectConfigProto.parser(), in));
}
}
static class ListKey {
static final ListKey ALL = new ListKey();
private ListKey() {}
}
static class Lister extends CacheLoader<ListKey, ImmutableSortedSet<Project.NameKey>> {
private final GitRepositoryManager mgr;
@Inject
Lister(GitRepositoryManager mgr) {
this.mgr = mgr;
}
@Override
public ImmutableSortedSet<Project.NameKey> load(ListKey key) throws Exception {
try (TraceTimer timer = TraceContext.newTimer("Loading project list")) {
return ImmutableSortedSet.copyOf(mgr.list());
}
}
}
@VisibleForTesting
public void evictAllByName() {
inMemoryProjectCache.invalidateAll();
}
@VisibleForTesting
public long sizeAllByName() {
return inMemoryProjectCache.size();
}
}