RepositoryCache.java
/*
* Copyright (C) 2009, Google Inc. and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.lib;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.eclipse.jgit.annotations.NonNull;
import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.internal.storage.file.FileRepository;
import org.eclipse.jgit.lib.internal.WorkQueue;
import org.eclipse.jgit.util.FS;
import org.eclipse.jgit.util.IO;
import org.eclipse.jgit.util.RawParseUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Cache of active {@link org.eclipse.jgit.lib.Repository} instances.
*/
public class RepositoryCache {
private static final Logger LOG = LoggerFactory
.getLogger(RepositoryCache.class);
private static final RepositoryCache cache = new RepositoryCache();
/**
* Open an existing repository, reusing a cached instance if possible.
* <p>
* When done with the repository, the caller must call
* {@link org.eclipse.jgit.lib.Repository#close()} to decrement the
* repository's usage counter.
*
* @param location
* where the local repository is. Typically a
* {@link org.eclipse.jgit.lib.RepositoryCache.FileKey}.
* @return the repository instance requested; caller must close when done.
* @throws java.io.IOException
* the repository could not be read (likely its core.version
* property is not supported).
* @throws org.eclipse.jgit.errors.RepositoryNotFoundException
* there is no repository at the given location.
*/
public static Repository open(Key location) throws IOException,
RepositoryNotFoundException {
return open(location, true);
}
/**
* Open a repository, reusing a cached instance if possible.
* <p>
* When done with the repository, the caller must call
* {@link org.eclipse.jgit.lib.Repository#close()} to decrement the
* repository's usage counter.
*
* @param location
* where the local repository is. Typically a
* {@link org.eclipse.jgit.lib.RepositoryCache.FileKey}.
* @param mustExist
* If true, and the repository is not found, throws {@code
* RepositoryNotFoundException}. If false, a repository instance
* is created and registered anyway.
* @return the repository instance requested; caller must close when done.
* @throws java.io.IOException
* the repository could not be read (likely its core.version
* property is not supported).
* @throws RepositoryNotFoundException
* There is no repository at the given location, only thrown if
* {@code mustExist} is true.
*/
public static Repository open(Key location, boolean mustExist)
throws IOException {
return cache.openRepository(location, mustExist);
}
/**
* Register one repository into the cache.
* <p>
* During registration the cache automatically increments the usage counter,
* permitting it to retain the reference. A
* {@link org.eclipse.jgit.lib.RepositoryCache.FileKey} for the repository's
* {@link org.eclipse.jgit.lib.Repository#getDirectory()} is used to index
* the repository in the cache.
* <p>
* If another repository already is registered in the cache at this
* location, the other instance is closed.
*
* @param db
* repository to register.
*/
public static void register(Repository db) {
if (db.getDirectory() != null) {
FileKey key = FileKey.exact(db.getDirectory(), db.getFS());
cache.registerRepository(key, db);
}
}
/**
* Close and remove a repository from the cache.
* <p>
* Removes a repository from the cache, if it is still registered here, and
* close it.
*
* @param db
* repository to unregister.
*/
public static void close(@NonNull Repository db) {
if (db.getDirectory() != null) {
FileKey key = FileKey.exact(db.getDirectory(), db.getFS());
cache.unregisterAndCloseRepository(key);
}
}
/**
* Remove a repository from the cache.
* <p>
* Removes a repository from the cache, if it is still registered here. This
* method will not close the repository, only remove it from the cache. See
* {@link org.eclipse.jgit.lib.RepositoryCache#close(Repository)} to remove
* and close the repository.
*
* @param db
* repository to unregister.
* @since 4.3
*/
public static void unregister(Repository db) {
if (db.getDirectory() != null) {
unregister(FileKey.exact(db.getDirectory(), db.getFS()));
}
}
/**
* Remove a repository from the cache.
* <p>
* Removes a repository from the cache, if it is still registered here. This
* method will not close the repository, only remove it from the cache. See
* {@link org.eclipse.jgit.lib.RepositoryCache#close(Repository)} to remove
* and close the repository.
*
* @param location
* location of the repository to remove.
* @since 4.1
*/
public static void unregister(Key location) {
cache.unregisterRepository(location);
}
/**
* Get the locations of all repositories registered in the cache.
*
* @return the locations of all repositories registered in the cache.
* @since 4.1
*/
public static Collection<Key> getRegisteredKeys() {
return cache.getKeys();
}
static boolean isCached(@NonNull Repository repo) {
File gitDir = repo.getDirectory();
if (gitDir == null) {
return false;
}
FileKey key = new FileKey(gitDir, repo.getFS());
return cache.cacheMap.get(key) == repo;
}
/**
* Unregister all repositories from the cache.
*/
public static void clear() {
cache.clearAll();
}
static void clearExpired() {
cache.clearAllExpired();
}
static void reconfigure(RepositoryCacheConfig repositoryCacheConfig) {
cache.configureEviction(repositoryCacheConfig);
}
private final Map<Key, Repository> cacheMap;
private final Lock[] openLocks;
private ScheduledFuture<?> cleanupTask;
private volatile long expireAfter;
private final Object schedulerLock = new Lock();
private RepositoryCache() {
cacheMap = new ConcurrentHashMap<>();
openLocks = new Lock[4];
for (int i = 0; i < openLocks.length; i++) {
openLocks[i] = new Lock();
}
configureEviction(new RepositoryCacheConfig());
}
private void configureEviction(
RepositoryCacheConfig repositoryCacheConfig) {
expireAfter = repositoryCacheConfig.getExpireAfter();
ScheduledThreadPoolExecutor scheduler = WorkQueue.getExecutor();
synchronized (schedulerLock) {
if (cleanupTask != null) {
cleanupTask.cancel(false);
}
long delay = repositoryCacheConfig.getCleanupDelay();
if (delay == RepositoryCacheConfig.NO_CLEANUP) {
return;
}
cleanupTask = scheduler.scheduleWithFixedDelay(() -> {
try {
cache.clearAllExpired();
} catch (Throwable e) {
LOG.error(e.getMessage(), e);
}
}, delay, delay, TimeUnit.MILLISECONDS);
}
}
private Repository openRepository(final Key location,
final boolean mustExist) throws IOException {
Repository db = cacheMap.get(location);
if (db == null) {
synchronized (lockFor(location)) {
db = cacheMap.get(location);
if (db == null) {
db = location.open(mustExist);
cacheMap.put(location, db);
} else {
db.incrementOpen();
}
}
} else {
db.incrementOpen();
}
return db;
}
private void registerRepository(Key location, Repository db) {
try (Repository oldDb = cacheMap.put(location, db)) {
// oldDb is auto-closed
}
}
private Repository unregisterRepository(Key location) {
return cacheMap.remove(location);
}
private boolean isExpired(Repository db) {
return db != null && db.useCnt.get() <= 0
&& (System.currentTimeMillis() - db.closedAt.get() > expireAfter);
}
private void unregisterAndCloseRepository(Key location) {
synchronized (lockFor(location)) {
Repository oldDb = unregisterRepository(location);
if (oldDb != null) {
oldDb.doClose();
}
}
}
private Collection<Key> getKeys() {
return new ArrayList<>(cacheMap.keySet());
}
private void clearAllExpired() {
for (Repository db : cacheMap.values()) {
if (isExpired(db)) {
RepositoryCache.close(db);
}
}
}
private void clearAll() {
for (Key k : cacheMap.keySet()) {
unregisterAndCloseRepository(k);
}
}
private Lock lockFor(Key location) {
return openLocks[(location.hashCode() >>> 1) % openLocks.length];
}
private static class Lock {
// Used only for its monitor.
}
/**
* Abstract hash key for {@link RepositoryCache} entries.
* <p>
* A Key instance should be lightweight, and implement hashCode() and
* equals() such that two Key instances are equal if they represent the same
* Repository location.
*/
public static interface Key {
/**
* Called by {@link RepositoryCache#open(Key)} if it doesn't exist yet.
* <p>
* If a repository does not exist yet in the cache, the cache will call
* this method to acquire a handle to it.
*
* @param mustExist
* true if the repository must exist in order to be opened;
* false if a new non-existent repository is permitted to be
* created (the caller is responsible for calling create).
* @return the new repository instance.
* @throws IOException
* the repository could not be read (likely its core.version
* property is not supported).
* @throws RepositoryNotFoundException
* There is no repository at the given location, only thrown
* if {@code mustExist} is true.
*/
Repository open(boolean mustExist) throws IOException,
RepositoryNotFoundException;
}
/** Location of a Repository, using the standard java.io.File API. */
public static class FileKey implements Key {
/**
* Obtain a pointer to an exact location on disk.
* <p>
* No guessing is performed, the given location is exactly the GIT_DIR
* directory of the repository.
*
* @param directory
* location where the repository database is.
* @param fs
* the file system abstraction which will be necessary to
* perform certain file system operations.
* @return a key for the given directory.
* @see #lenient(File, FS)
*/
public static FileKey exact(File directory, FS fs) {
return new FileKey(directory, fs);
}
/**
* Obtain a pointer to a location on disk.
* <p>
* The method performs some basic guessing to locate the repository.
* Searched paths are:
* <ol>
* <li>{@code directory} // assume exact match</li>
* <li>{@code directory} + "/.git" // assume working directory</li>
* <li>{@code directory} + ".git" // assume bare</li>
* </ol>
*
* @param directory
* location where the repository database might be.
* @param fs
* the file system abstraction which will be necessary to
* perform certain file system operations.
* @return a key for the given directory.
* @see #exact(File, FS)
*/
public static FileKey lenient(File directory, FS fs) {
final File gitdir = resolve(directory, fs);
return new FileKey(gitdir != null ? gitdir : directory, fs);
}
private final File path;
private final FS fs;
/**
* @param directory
* exact location of the repository.
* @param fs
* the file system abstraction which will be necessary to
* perform certain file system operations.
*/
protected FileKey(File directory, FS fs) {
path = canonical(directory);
this.fs = fs;
}
private static File canonical(File path) {
try {
return path.getCanonicalFile();
} catch (IOException e) {
return path.getAbsoluteFile();
}
}
/** @return location supplied to the constructor. */
public final File getFile() {
return path;
}
@Override
public Repository open(boolean mustExist) throws IOException {
if (mustExist && !isGitRepository(path, fs))
throw new RepositoryNotFoundException(path);
return new FileRepository(path);
}
@Override
public int hashCode() {
return path.hashCode();
}
@Override
public boolean equals(Object o) {
return o instanceof FileKey && path.equals(((FileKey) o).path);
}
@Override
public String toString() {
return path.toString();
}
/**
* Guess if a directory contains a Git repository.
* <p>
* This method guesses by looking for the existence of some key files
* and directories.
*
* @param dir
* the location of the directory to examine.
* @param fs
* the file system abstraction which will be necessary to
* perform certain file system operations.
* @return true if the directory "looks like" a Git repository; false if
* it doesn't look enough like a Git directory to really be a
* Git directory.
*/
public static boolean isGitRepository(File dir, FS fs) {
return fs.resolve(dir, Constants.OBJECTS).exists()
&& fs.resolve(dir, "refs").exists() //$NON-NLS-1$
&& (fs.resolve(dir, Constants.REFTABLE).exists()
|| isValidHead(new File(dir, Constants.HEAD)));
}
private static boolean isValidHead(File head) {
final String ref = readFirstLine(head);
return ref != null
&& (ref.startsWith("ref: refs/") || ObjectId.isId(ref)); //$NON-NLS-1$
}
private static String readFirstLine(File head) {
try {
final byte[] buf = IO.readFully(head, 4096);
int n = buf.length;
if (n == 0)
return null;
if (buf[n - 1] == '\n')
n--;
return RawParseUtils.decode(buf, 0, n);
} catch (IOException e) {
return null;
}
}
/**
* Guess the proper path for a Git repository.
* <p>
* The method performs some basic guessing to locate the repository.
* Searched paths are:
* <ol>
* <li>{@code directory} // assume exact match</li>
* <li>{@code directory} + "/.git" // assume working directory</li>
* <li>{@code directory} + ".git" // assume bare</li>
* </ol>
*
* @param directory
* location to guess from. Several permutations are tried.
* @param fs
* the file system abstraction which will be necessary to
* perform certain file system operations.
* @return the actual directory location if a better match is found;
* null if there is no suitable match.
*/
public static File resolve(File directory, FS fs) {
if (isGitRepository(directory, fs))
return directory;
if (isGitRepository(new File(directory, Constants.DOT_GIT), fs))
return new File(directory, Constants.DOT_GIT);
final String name = directory.getName();
final File parent = directory.getParentFile();
if (isGitRepository(new File(parent, name + Constants.DOT_GIT_EXT), fs))
return new File(parent, name + Constants.DOT_GIT_EXT);
return null;
}
}
}