Java tutorial
/* * Copyright 2013 gitblit.com. * * 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.gitblit.utils; import java.text.MessageFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.concurrent.TimeUnit; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.revwalk.RevCommit; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.gitblit.models.RefModel; import com.gitblit.models.RepositoryCommit; /** * Caches repository commits for re-use in the dashboard and activity pages. * * @author James Moger * */ public class CommitCache { private static final CommitCache instance; protected final Logger logger = LoggerFactory.getLogger(getClass()); protected final Map<String, ObjectCache<List<RepositoryCommit>>> cache; protected int cacheDays = -1; public static CommitCache instance() { return instance; } static { instance = new CommitCache(); } protected CommitCache() { cache = new HashMap<>(); } /** * Returns the cutoff date for the cache. Commits after this date are cached. * Commits before this date are not cached. * * @return */ public Date getCutoffDate() { final Calendar cal = Calendar.getInstance(); cal.setTimeInMillis(System.currentTimeMillis()); cal.set(Calendar.HOUR_OF_DAY, 0); cal.set(Calendar.MINUTE, 0); cal.set(Calendar.SECOND, 0); cal.set(Calendar.MILLISECOND, 0); cal.add(Calendar.DATE, -1 * cacheDays); return cal.getTime(); } /** * Sets the number of days to cache. * * @param days */ public synchronized void setCacheDays(int days) { this.cacheDays = days; clear(); } /** * Clears the entire commit cache. * */ public void clear() { synchronized (cache) { cache.clear(); } } /** * Clears the commit cache for a specific repository. * * @param repositoryName */ public void clear(String repositoryName) { String repoKey = repositoryName.toLowerCase(); boolean hadEntries = false; synchronized (cache) { hadEntries = cache.remove(repoKey) != null; } if (hadEntries) { logger.info(MessageFormat.format("{0} commit cache cleared", repositoryName)); } } /** * Clears the commit cache for a specific branch of a specific repository. * * @param repositoryName * @param branch */ public void clear(String repositoryName, String branch) { String repoKey = repositoryName.toLowerCase(); boolean hadEntries = false; synchronized (cache) { ObjectCache<List<RepositoryCommit>> repoCache = cache.get(repoKey); if (repoCache != null) { List<RepositoryCommit> commits = repoCache.remove(branch.toLowerCase()); hadEntries = !ArrayUtils.isEmpty(commits); } } if (hadEntries) { logger.info(MessageFormat.format("{0}:{1} commit cache cleared", repositoryName, branch)); } } /** * Get all commits for the specified repository:branch that are in the cache. * * @param repositoryName * @param repository * @param branch * @return a list of commits */ public List<RepositoryCommit> getCommits(String repositoryName, Repository repository, String branch) { return getCommits(repositoryName, repository, branch, getCutoffDate()); } /** * Get all commits for the specified repository:branch since a specific date. * These commits may be retrieved from the cache if the sinceDate is after * the cacheCutoffDate. * * @param repositoryName * @param repository * @param branch * @param sinceDate * @return a list of commits */ public List<RepositoryCommit> getCommits(String repositoryName, Repository repository, String branch, Date sinceDate) { long start = System.nanoTime(); Date cacheCutoffDate = getCutoffDate(); List<RepositoryCommit> list; if (cacheDays > 0 && (sinceDate.getTime() >= cacheCutoffDate.getTime())) { // request fits within the cache window String repoKey = repositoryName.toLowerCase(); String branchKey = branch.toLowerCase(); RevCommit tip = JGitUtils.getCommit(repository, branch); Date tipDate = JGitUtils.getCommitDate(tip); ObjectCache<List<RepositoryCommit>> repoCache; synchronized (cache) { repoCache = cache.get(repoKey); if (repoCache == null) { repoCache = new ObjectCache<>(); cache.put(repoKey, repoCache); } } synchronized (repoCache) { List<RepositoryCommit> commits; if (!repoCache.hasCurrent(branchKey, tipDate)) { commits = repoCache.getObject(branchKey); if (ArrayUtils.isEmpty(commits)) { // we don't have any cached commits for this branch, reload commits = get(repositoryName, repository, branch, cacheCutoffDate); repoCache.updateObject(branchKey, tipDate, commits); logger.debug(MessageFormat.format( "parsed {0} commits from {1}:{2} since {3,date,yyyy-MM-dd} in {4} msecs", commits.size(), repositoryName, branch, cacheCutoffDate, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start))); } else { // incrementally update cache since the last cached commit ObjectId sinceCommit = commits.get(0).getId(); List<RepositoryCommit> incremental = get(repositoryName, repository, branch, sinceCommit); logger.info(MessageFormat.format( "incrementally added {0} commits to cache for {1}:{2} in {3} msecs", incremental.size(), repositoryName, branch, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start))); incremental.addAll(commits); repoCache.updateObject(branchKey, tipDate, incremental); commits = incremental; } } else { // cache is current commits = repoCache.getObject(branchKey); // evict older commits outside the cache window commits = reduce(commits, cacheCutoffDate); // update cache repoCache.updateObject(branchKey, tipDate, commits); } if (sinceDate.equals(cacheCutoffDate)) { // Mustn't hand out the cached list; that's not thread-safe list = new ArrayList<>(commits); } else { // reduce the commits to those since the specified date list = reduce(commits, sinceDate); } } logger.debug(MessageFormat.format( "retrieved {0} commits from cache of {1}:{2} since {3,date,yyyy-MM-dd} in {4} msecs", list.size(), repositoryName, branch, sinceDate, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start))); } else { // not caching or request outside cache window list = get(repositoryName, repository, branch, sinceDate); logger.debug(MessageFormat.format( "parsed {0} commits from {1}:{2} since {3,date,yyyy-MM-dd} in {4} msecs", list.size(), repositoryName, branch, sinceDate, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start))); } return list; } /** * Returns a list of commits for the specified repository branch. * * @param repositoryName * @param repository * @param branch * @param sinceDate * @return a list of commits */ protected List<RepositoryCommit> get(String repositoryName, Repository repository, String branch, Date sinceDate) { Map<ObjectId, List<RefModel>> allRefs = JGitUtils.getAllRefs(repository, false); List<RevCommit> revLog = JGitUtils.getRevLog(repository, branch, sinceDate); List<RepositoryCommit> commits = new ArrayList<RepositoryCommit>(revLog.size()); for (RevCommit commit : revLog) { RepositoryCommit commitModel = new RepositoryCommit(repositoryName, branch, commit); List<RefModel> commitRefs = allRefs.get(commitModel.getId()); commitModel.setRefs(commitRefs); commits.add(commitModel); } return commits; } /** * Returns a list of commits for the specified repository branch since the specified commit. * * @param repositoryName * @param repository * @param branch * @param sinceCommit * @return a list of commits */ protected List<RepositoryCommit> get(String repositoryName, Repository repository, String branch, ObjectId sinceCommit) { Map<ObjectId, List<RefModel>> allRefs = JGitUtils.getAllRefs(repository, false); List<RevCommit> revLog = JGitUtils.getRevLog(repository, sinceCommit.getName(), branch); List<RepositoryCommit> commits = new ArrayList<RepositoryCommit>(revLog.size()); for (RevCommit commit : revLog) { RepositoryCommit commitModel = new RepositoryCommit(repositoryName, branch, commit); List<RefModel> commitRefs = allRefs.get(commitModel.getId()); commitModel.setRefs(commitRefs); commits.add(commitModel); } return commits; } /** * Reduces the list of commits to those since the specified date. * * @param commits * @param sinceDate * @return a list of commits */ protected List<RepositoryCommit> reduce(List<RepositoryCommit> commits, Date sinceDate) { List<RepositoryCommit> filtered = new ArrayList<RepositoryCommit>(commits.size()); for (RepositoryCommit commit : commits) { if (commit.getCommitDate().compareTo(sinceDate) >= 0) { filtered.add(commit); } } return filtered; } }