blob: 9d09eeb3012633ecf49f0e240f658a50e18f39e2 [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.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.flogger.FluentLogger;
import com.google.gerrit.common.Nullable;
import com.google.gerrit.entities.AccountGroup;
import com.google.gerrit.entities.Project;
import com.google.gerrit.exceptions.StorageException;
import com.google.gerrit.index.project.ProjectIndexer;
import com.google.gerrit.lifecycle.LifecycleModule;
import com.google.gerrit.metrics.Description;
import com.google.gerrit.metrics.Description.Units;
import com.google.gerrit.metrics.MetricMaker;
import com.google.gerrit.metrics.Timer0;
import com.google.gerrit.server.cache.CacheModule;
import com.google.gerrit.server.config.AllProjectsName;
import com.google.gerrit.server.config.AllUsersName;
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 java.io.IOException;
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.RepositoryNotFoundException;
import org.eclipse.jgit.lib.Repository;
/** Cache of project information, including access rights. */
@Singleton
public class ProjectCacheImpl implements ProjectCache {
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
public static final String CACHE_NAME = "projects";
private static final String CACHE_LIST = "project_list";
public static Module module() {
return new CacheModule() {
@Override
protected void configure() {
cache(CACHE_NAME, String.class, ProjectState.class).loader(Loader.class);
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);
listener().to(ProjectCacheClock.class);
}
});
}
};
}
private final AllProjectsName allProjectsName;
private final AllUsersName allUsersName;
private final LoadingCache<String, ProjectState> byName;
private final LoadingCache<ListKey, ImmutableSortedSet<Project.NameKey>> list;
private final Lock listLock;
private final ProjectCacheClock clock;
private final Provider<ProjectIndexer> indexer;
private final Timer0 guessRelevantGroupsLatency;
@Inject
ProjectCacheImpl(
final AllProjectsName allProjectsName,
final AllUsersName allUsersName,
@Named(CACHE_NAME) LoadingCache<String, ProjectState> byName,
@Named(CACHE_LIST) LoadingCache<ListKey, ImmutableSortedSet<Project.NameKey>> list,
ProjectCacheClock clock,
Provider<ProjectIndexer> indexer,
MetricMaker metricMaker) {
this.allProjectsName = allProjectsName;
this.allUsersName = allUsersName;
this.byName = byName;
this.list = list;
this.listLock = new ReentrantLock(true /* fair */);
this.clock = clock;
this.indexer = indexer;
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 {
ProjectState state = byName.get(projectName.get());
if (state != null && state.needsRefresh(clock.read())) {
byName.invalidate(projectName.get());
state = byName.get(projectName.get());
}
return Optional.of(state);
} catch (Exception e) {
if ((e.getCause() instanceof RepositoryNotFoundException)) {
logger.atFine().log("Cannot find project %s", projectName.get());
return Optional.empty();
}
throw new StorageException(
String.format("project state of project %s not available", projectName.get()), e);
}
}
@Override
public void evict(Project p) {
evict(p.getNameKey());
}
@Override
public void evict(Project.NameKey p) {
if (p != null) {
logger.atFine().log("Evict project '%s'", p.get());
byName.invalidate(p.get());
}
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();
}
evict(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();
}
indexer.get().index(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 Set<AccountGroup.UUID> guessRelevantGroupUUIDs() {
try (Timer0.Context ignored = guessRelevantGroupsLatency.start()) {
return all().stream()
.map(n -> byName.getIfPresent(n.get()))
.filter(Objects::nonNull)
.flatMap(p -> p.getConfig().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());
}
}
@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();
}
}
static class Loader extends CacheLoader<String, ProjectState> {
private final ProjectState.Factory projectStateFactory;
private final GitRepositoryManager mgr;
private final ProjectCacheClock clock;
private final ProjectConfig.Factory projectConfigFactory;
@Inject
Loader(
ProjectState.Factory psf,
GitRepositoryManager g,
ProjectCacheClock clock,
ProjectConfig.Factory projectConfigFactory) {
projectStateFactory = psf;
mgr = g;
this.clock = clock;
this.projectConfigFactory = projectConfigFactory;
}
@Override
public ProjectState load(String projectName) throws Exception {
try (TraceTimer timer =
TraceContext.newTimer(
"Loading project", Metadata.builder().projectName(projectName).build())) {
long now = clock.read();
Project.NameKey key = Project.nameKey(projectName);
try (Repository git = mgr.openRepository(key)) {
ProjectConfig cfg = projectConfigFactory.create(key);
cfg.load(key, git);
ProjectState state = projectStateFactory.create(cfg);
state.initLastCheck(now);
return state;
}
}
}
}
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() {
byName.invalidateAll();
}
@VisibleForTesting
public long sizeAllByName() {
return byName.size();
}
}