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.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 ConcurrentHashMap<Key, Repository> cacheMap;
- private final Lock[] openLocks;
- private ScheduledFuture<?> cleanupTask;
- private volatile long expireAfter;
- 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 (scheduler) {
- 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;
- }
- }
- }