/*
* Copyright (C) 2009, Google Inc.
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
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.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 Repository} instances. */
public class RepositoryCache {
private static final RepositoryCache cache = new RepositoryCache();
private final static Logger LOG = LoggerFactory
.getLogger(RepositoryCache.class);
/**
* Open an existing repository, reusing a cached instance if possible.
* <p>
* When done with the repository, the caller must call
* {@link Repository#close()} to decrement the repository's usage counter.
*
* @param location
* where the local repository is. Typically a {@link FileKey}.
* @return the repository instance requested; caller must close when done.
* @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.
*/
public static Repository open(final 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 Repository#close()} to decrement the repository's usage counter.
*
* @param location
* where the local repository is. Typically a {@link 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 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(final Key location, final 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 FileKey} for the
* repository's {@link 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(final 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 final 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 RepositoryCache#close(Repository)} to remove and close the
* repository.
*
* @param db
* repository to unregister.
* @since 4.3
*/
public static void unregister(final 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 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);
}
/**
* @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(new Runnable() {
@Override
public void run() {
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(final Key location, final Repository db) {
Repository oldDb = cacheMap.put(location, db);
if (oldDb != null)
oldDb.close();
}
private Repository unregisterRepository(final 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(final Key location) {
synchronized (lockFor(location)) {
Repository oldDb = unregisterRepository(location);
if (oldDb != null) {
oldDb.doClose();
}
}
}
private Collection<Key> getKeys() {
return new ArrayList<Key>(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(final 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(final 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(final 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(final File directory, FS fs) {
path = canonical(directory);
this.fs = fs;
}
private static File canonical(final 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(final 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(final 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(final File dir, FS fs) {
return fs.resolve(dir, "objects").exists() //$NON-NLS-1$
&& fs.resolve(dir, "refs").exists() //$NON-NLS-1$
&& isValidHead(new File(dir, Constants.HEAD));
}
private static boolean isValidHead(final File head) {
final String ref = readFirstLine(head);
return ref != null
&& (ref.startsWith("ref: refs/") || ObjectId.isId(ref)); //$NON-NLS-1$
}
private static String readFirstLine(final 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(final 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;
}
}
}