| New file |
| | |
|---|
| | | /*
|
|---|
| | | * Copyright 2012 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;
|
|---|
| | |
|
|---|
| | | import java.lang.reflect.Field;
|
|---|
| | | import java.text.MessageFormat;
|
|---|
| | | import java.util.Calendar;
|
|---|
| | | import java.util.Date;
|
|---|
| | | import java.util.Map;
|
|---|
| | | import java.util.Properties;
|
|---|
| | | import java.util.concurrent.ConcurrentHashMap;
|
|---|
| | | import java.util.concurrent.atomic.AtomicBoolean;
|
|---|
| | | import java.util.concurrent.atomic.AtomicInteger;
|
|---|
| | |
|
|---|
| | | import org.eclipse.jgit.api.GarbageCollectCommand;
|
|---|
| | | import org.eclipse.jgit.api.Git;
|
|---|
| | | import org.eclipse.jgit.lib.Repository;
|
|---|
| | | import org.slf4j.Logger;
|
|---|
| | | import org.slf4j.LoggerFactory;
|
|---|
| | |
|
|---|
| | | import com.gitblit.models.RepositoryModel;
|
|---|
| | | import com.gitblit.utils.FileUtils;
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * The GC executor handles periodic garbage collection in repositories.
|
|---|
| | | * |
|---|
| | | * @author James Moger
|
|---|
| | | * |
|---|
| | | */
|
|---|
| | | public class GCExecutor implements Runnable {
|
|---|
| | |
|
|---|
| | | public static enum GCStatus {
|
|---|
| | | READY, COLLECTING;
|
|---|
| | | |
|---|
| | | public boolean exceeds(GCStatus s) {
|
|---|
| | | return ordinal() > s.ordinal();
|
|---|
| | | }
|
|---|
| | | }
|
|---|
| | | private final Logger logger = LoggerFactory.getLogger(GCExecutor.class);
|
|---|
| | |
|
|---|
| | | private final IStoredSettings settings;
|
|---|
| | | |
|---|
| | | private AtomicBoolean running = new AtomicBoolean(false);
|
|---|
| | | |
|---|
| | | private AtomicBoolean forceClose = new AtomicBoolean(false);
|
|---|
| | | |
|---|
| | | private final Map<String, GCStatus> gcCache = new ConcurrentHashMap<String, GCStatus>();
|
|---|
| | |
|
|---|
| | | public GCExecutor(IStoredSettings settings) {
|
|---|
| | | this.settings = settings;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Indicates if the GC executor is ready to process repositories.
|
|---|
| | | * |
|---|
| | | * @return true if the GC executor is ready to process repositories
|
|---|
| | | */
|
|---|
| | | public boolean isReady() {
|
|---|
| | | return settings.getBoolean(Keys.git.enableGarbageCollection, false);
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | public boolean isRunning() {
|
|---|
| | | return running.get();
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | public boolean lock(String repositoryName) {
|
|---|
| | | return setGCStatus(repositoryName, GCStatus.COLLECTING);
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Tries to set a GCStatus for the specified repository.
|
|---|
| | | * |
|---|
| | | * @param repositoryName
|
|---|
| | | * @return true if the status has been set
|
|---|
| | | */
|
|---|
| | | private boolean setGCStatus(String repositoryName, GCStatus status) {
|
|---|
| | | String key = repositoryName.toLowerCase();
|
|---|
| | | if (gcCache.containsKey(key)) {
|
|---|
| | | if (gcCache.get(key).exceeds(GCStatus.READY)) {
|
|---|
| | | // already collecting or blocked
|
|---|
| | | return false;
|
|---|
| | | }
|
|---|
| | | }
|
|---|
| | | gcCache.put(key, status);
|
|---|
| | | return true;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Returns true if Gitblit is actively collecting garbage in this repository.
|
|---|
| | | * |
|---|
| | | * @param repositoryName
|
|---|
| | | * @return true if actively collecting garbage
|
|---|
| | | */
|
|---|
| | | public boolean isCollectingGarbage(String repositoryName) {
|
|---|
| | | String key = repositoryName.toLowerCase();
|
|---|
| | | return gcCache.containsKey(key) && GCStatus.COLLECTING.equals(gcCache.get(key));
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Resets the GC status to ready.
|
|---|
| | | * |
|---|
| | | * @param repositoryName
|
|---|
| | | */
|
|---|
| | | public void releaseLock(String repositoryName) {
|
|---|
| | | gcCache.put(repositoryName.toLowerCase(), GCStatus.READY);
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | public void close() {
|
|---|
| | | forceClose.set(true);
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | @Override
|
|---|
| | | public void run() {
|
|---|
| | | if (!isReady()) {
|
|---|
| | | return;
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | running.set(true); |
|---|
| | | Date now = new Date();
|
|---|
| | |
|
|---|
| | | for (String repositoryName : GitBlit.self().getRepositoryList()) {
|
|---|
| | | if (forceClose.get()) {
|
|---|
| | | break;
|
|---|
| | | }
|
|---|
| | | if (isCollectingGarbage(repositoryName)) {
|
|---|
| | | logger.warn(MessageFormat.format("Already collecting garbage from {0}?!?", repositoryName));
|
|---|
| | | continue;
|
|---|
| | | }
|
|---|
| | | boolean garbageCollected = false;
|
|---|
| | | RepositoryModel model = null;
|
|---|
| | | Repository repository = null;
|
|---|
| | | try {
|
|---|
| | | model = GitBlit.self().getRepositoryModel(repositoryName);
|
|---|
| | | repository = GitBlit.self().getRepository(repositoryName);
|
|---|
| | | if (repository == null) {
|
|---|
| | | logger.warn(MessageFormat.format("GCExecutor is missing repository {0}?!?", repositoryName));
|
|---|
| | | continue;
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | if (!isRepositoryIdle(repository)) {
|
|---|
| | | logger.debug(MessageFormat.format("GCExecutor is skipping {0} because it is not idle", repositoryName));
|
|---|
| | | continue;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | // By setting the GCStatus to COLLECTING we are
|
|---|
| | | // disabling *all* access to this repository from Gitblit.
|
|---|
| | | // Think of this as a clutch in a manual transmission vehicle.
|
|---|
| | | if (!setGCStatus(repositoryName, GCStatus.COLLECTING)) {
|
|---|
| | | logger.warn(MessageFormat.format("Can not acquire GC lock for {0}, skipping", repositoryName));
|
|---|
| | | continue;
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | logger.debug(MessageFormat.format("GCExecutor locked idle repository {0}", repositoryName));
|
|---|
| | | |
|---|
| | | Git git = new Git(repository);
|
|---|
| | | GarbageCollectCommand gc = git.gc();
|
|---|
| | | Properties stats = gc.getStatistics();
|
|---|
| | | |
|---|
| | | // determine if this is a scheduled GC
|
|---|
| | | Calendar cal = Calendar.getInstance();
|
|---|
| | | cal.setTime(model.lastGC);
|
|---|
| | | 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, model.gcPeriod);
|
|---|
| | | Date gcDate = cal.getTime();
|
|---|
| | | boolean shouldCollectGarbage = now.after(gcDate);
|
|---|
| | |
|
|---|
| | | // determine if filesize triggered GC
|
|---|
| | | long gcThreshold = FileUtils.convertSizeToLong(model.gcThreshold, 500*1024L);
|
|---|
| | | long sizeOfLooseObjects = (Long) stats.get("sizeOfLooseObjects");
|
|---|
| | | boolean hasEnoughGarbage = sizeOfLooseObjects >= gcThreshold;
|
|---|
| | |
|
|---|
| | | // if we satisfy one of the requirements, GC
|
|---|
| | | boolean hasGarbage = sizeOfLooseObjects > 0;
|
|---|
| | | if (hasGarbage && (hasEnoughGarbage || shouldCollectGarbage)) {
|
|---|
| | | long looseKB = sizeOfLooseObjects/1024L;
|
|---|
| | | logger.info(MessageFormat.format("Collecting {1} KB of loose objects from {0}", repositoryName, looseKB));
|
|---|
| | | |
|---|
| | | // do the deed
|
|---|
| | | gc.call();
|
|---|
| | | |
|---|
| | | garbageCollected = true;
|
|---|
| | | }
|
|---|
| | | } catch (Exception e) {
|
|---|
| | | logger.error("Error collecting garbage in " + repositoryName, e);
|
|---|
| | | } finally {
|
|---|
| | | // cleanup
|
|---|
| | | if (repository != null) {
|
|---|
| | | if (garbageCollected) {
|
|---|
| | | // update the last GC date
|
|---|
| | | model.lastGC = new Date();
|
|---|
| | | GitBlit.self().updateConfiguration(repository, model);
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | repository.close();
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | // reset the GC lock |
|---|
| | | releaseLock(repositoryName);
|
|---|
| | | logger.debug(MessageFormat.format("GCExecutor released GC lock for {0}", repositoryName));
|
|---|
| | | }
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | running.set(false);
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | private boolean isRepositoryIdle(Repository repository) {
|
|---|
| | | try {
|
|---|
| | | // Read the use count.
|
|---|
| | | // An idle use count is 2:
|
|---|
| | | // +1 for being in the cache
|
|---|
| | | // +1 for the repository parameter in this method
|
|---|
| | | Field useCnt = Repository.class.getDeclaredField("useCnt");
|
|---|
| | | useCnt.setAccessible(true);
|
|---|
| | | int useCount = ((AtomicInteger) useCnt.get(repository)).get();
|
|---|
| | | return useCount == 2;
|
|---|
| | | } catch (Exception e) {
|
|---|
| | | logger.warn(MessageFormat
|
|---|
| | | .format("Failed to reflectively determine use count for repository {0}",
|
|---|
| | | repository.getDirectory().getPath()), e);
|
|---|
| | | }
|
|---|
| | | return false;
|
|---|
| | | }
|
|---|
| | | }
|
|---|
