githubFork/gitblit.git - Solinfo Gitblit

			@@ -43,6 +43,7 @@
			import java.util.concurrent.ScheduledExecutorService;
			import java.util.concurrent.TimeUnit;
			import java.util.concurrent.atomic.AtomicInteger;
			import java.util.concurrent.atomic.AtomicReference;

			import javax.mail.Message;
			import javax.mail.MessagingException;
			@@ -56,6 +57,7 @@
			import org.eclipse.jgit.lib.Repository;
			import org.eclipse.jgit.lib.RepositoryCache.FileKey;
			import org.eclipse.jgit.lib.StoredConfig;
			import org.eclipse.jgit.storage.file.FileBasedConfig;
			import org.eclipse.jgit.storage.file.WindowCache;
			import org.eclipse.jgit.storage.file.WindowCacheConfig;
			import org.eclipse.jgit.transport.ServiceMayNotContinueException;
			@@ -69,6 +71,7 @@
			import org.slf4j.LoggerFactory;

			import com.gitblit.Constants.AccessRestrictionType;
			import com.gitblit.Constants.AuthorizationControl;
			import com.gitblit.Constants.FederationRequest;
			import com.gitblit.Constants.FederationStrategy;
			import com.gitblit.Constants.FederationToken;
			@@ -85,6 +88,7 @@
			import com.gitblit.models.UserModel;
			import com.gitblit.utils.ArrayUtils;
			import com.gitblit.utils.ByteFormat;
			import com.gitblit.utils.DeepCopier;
			import com.gitblit.utils.FederationUtils;
			import com.gitblit.utils.JGitUtils;
			import com.gitblit.utils.JsonUtils;
			@@ -124,6 +128,10 @@
			private final ObjectCache<Long> repositorySizeCache = new ObjectCache<Long>();

			private final ObjectCache<List<Metric>> repositoryMetricsCache = new ObjectCache<List<Metric>>();

			private final Map<String, RepositoryModel> repositoryListCache = new ConcurrentHashMap<String, RepositoryModel>();

			private final AtomicReference<String> repositoryListSettingsChecksum = new AtomicReference<String>("");

			private RepositoryResolver<Void> repositoryResolver;

			@@ -722,15 +730,80 @@
			public boolean deleteTeam(String teamname) {
			return userService.deleteTeam(teamname);
			}

			/**
			* Adds the repository to the list of cached repositories if Gitblit is
			* configured to cache the repository list.
			*
			* @param name
			*/
			private void addToCachedRepositoryList(String name, RepositoryModel model) {
			if (settings.getBoolean(Keys.git.cacheRepositoryList, true)) {
			repositoryListCache.put(name, model);
			}
			}

			/**
			* Removes the repository from the list of cached repositories.
			*
			* @param name
			*/
			private void removeFromCachedRepositoryList(String name) {
			if (StringUtils.isEmpty(name)) {
			return;
			}
			repositoryListCache.remove(name);
			}

			/**
			* Clears all the cached data for the specified repository.
			* Clears all the cached metadata for the specified repository.
			*
			* @param repositoryName
			*/
			public void clearRepositoryCache(String repositoryName) {
			private void clearRepositoryMetadataCache(String repositoryName) {
			repositorySizeCache.remove(repositoryName);
			repositoryMetricsCache.remove(repositoryName);
			}

			/**
			* Resets the repository list cache.
			*
			*/
			public void resetRepositoryListCache() {
			logger.info("Repository cache manually reset");
			repositoryListCache.clear();
			}

			/**
			* Calculate the checksum of settings that affect the repository list cache.
			* @return a checksum
			*/
			private String getRepositoryListSettingsChecksum() {
			StringBuilder ns = new StringBuilder();
			ns.append(settings.getString(Keys.git.cacheRepositoryList, "")).append('\n');
			ns.append(settings.getString(Keys.git.onlyAccessBareRepositories, "")).append('\n');
			ns.append(settings.getString(Keys.git.searchRepositoriesSubfolders, "")).append('\n');
			ns.append(settings.getString(Keys.git.searchRecursionDepth, "")).append('\n');
			ns.append(settings.getString(Keys.git.searchExclusions, "")).append('\n');
			String checksum = StringUtils.getSHA1(ns.toString());
			return checksum;
			}

			/**
			* Compare the last repository list setting checksum to the current checksum.
			* If different then clear the cache so that it may be rebuilt.
			*
			* @return true if the cached repository list is valid since the last check
			*/
			private boolean isValidRepositoryList() {
			String newChecksum = getRepositoryListSettingsChecksum();
			boolean valid = newChecksum.equals(repositoryListSettingsChecksum.get());
			repositoryListSettingsChecksum.set(newChecksum);
			if (!valid && settings.getBoolean(Keys.git.cacheRepositoryList, true)) {
			logger.info("Repository list settings have changed. Clearing repository list cache.");
			repositoryListCache.clear();
			}
			return valid;
			}

			/**
			@@ -740,10 +813,48 @@
			* @return list of all repositories
			*/
			public List<String> getRepositoryList() {
			return JGitUtils.getRepositoryList(repositoriesFolder,
			settings.getBoolean(Keys.git.onlyAccessBareRepositories, false),
			settings.getBoolean(Keys.git.searchRepositoriesSubfolders, true),
			settings.getInteger(Keys.git.searchRecursionDepth, -1));
			if (repositoryListCache.size() == 0 \|\| !isValidRepositoryList()) {
			// we are not caching OR we have not yet cached OR the cached list is invalid
			long startTime = System.currentTimeMillis();
			List<String> repositories = JGitUtils.getRepositoryList(repositoriesFolder,
			settings.getBoolean(Keys.git.onlyAccessBareRepositories, false),
			settings.getBoolean(Keys.git.searchRepositoriesSubfolders, true),
			settings.getInteger(Keys.git.searchRecursionDepth, -1),
			settings.getStrings(Keys.git.searchExclusions));

			if (!settings.getBoolean(Keys.git.cacheRepositoryList, true)) {
			// we are not caching
			StringUtils.sortRepositorynames(repositories);
			return repositories;
			} else {
			// we are caching this list
			String msg = "{0} repositories identified in {1} msecs";

			// optionally (re)calculate repository sizes
			if (getBoolean(Keys.web.showRepositorySizes, true)) {
			msg = "{0} repositories identified with calculated folder sizes in {1} msecs";
			for (String repository : repositories) {
			RepositoryModel model = getRepositoryModel(repository);
			if (!model.skipSizeCalculation) {
			calculateSize(model);
			}
			}
			} else {
			// update cache
			for (String repository : repositories) {
			getRepositoryModel(repository);
			}
			}

			long duration = System.currentTimeMillis() - startTime;
			logger.info(MessageFormat.format(msg, repositoryListCache.size(), duration));
			}
			}

			// return sorted copy of cached list
			List<String> list = new ArrayList<String>(repositoryListCache.keySet());
			StringUtils.sortRepositorynames(list);
			return list;
			}

			/**
			@@ -802,6 +913,7 @@
			* @return list of repository models accessible to user
			*/
			public List<RepositoryModel> getRepositoryModels(UserModel user) {
			long methodStart = System.currentTimeMillis();
			List<String> list = getRepositoryList();
			List<RepositoryModel> repositories = new ArrayList<RepositoryModel>();
			for (String repo : list) {
			@@ -821,9 +933,15 @@
			}
			}
			long duration = System.currentTimeMillis() - startTime;
			logger.info(MessageFormat.format("{0} repository sizes calculated in {1} msecs",
			if (duration > 250) {
			// only log calcualtion time if > 250 msecs
			logger.info(MessageFormat.format("{0} repository sizes calculated in {1} msecs",
			repoCount, duration));
			}
			}
			long duration = System.currentTimeMillis() - methodStart;
			logger.info(MessageFormat.format("{0} repository models loaded for {1} in {2} msecs",
			repositories.size(), user == null ? "anonymous" : user.username, duration));
			return repositories;
			}

			@@ -858,6 +976,79 @@
			* @return repository model or null
			*/
			public RepositoryModel getRepositoryModel(String repositoryName) {
			if (!repositoryListCache.containsKey(repositoryName)) {
			RepositoryModel model = loadRepositoryModel(repositoryName);
			if (model == null) {
			return null;
			}
			addToCachedRepositoryList(repositoryName, model);
			return model;
			}

			// cached model
			RepositoryModel model = repositoryListCache.get(repositoryName);

			// check for updates
			Repository r = getRepository(repositoryName);
			if (r == null) {
			// repository is missing
			removeFromCachedRepositoryList(repositoryName);
			logger.error(MessageFormat.format("Repository \"{0}\" is missing! Removing from cache.", repositoryName));
			return null;
			}

			FileBasedConfig config = (FileBasedConfig) getRepositoryConfig(r);
			if (config.isOutdated()) {
			// reload model
			logger.info(MessageFormat.format("Config for \"{0}\" has changed. Reloading model and updating cache.", repositoryName));
			model = loadRepositoryModel(repositoryName);
			removeFromCachedRepositoryList(repositoryName);
			addToCachedRepositoryList(repositoryName, model);
			} else {
			// update a few repository parameters
			if (!model.hasCommits) {
			// update hasCommits, assume a repository only gains commits :)
			model.hasCommits = JGitUtils.hasCommits(r);
			}

			model.lastChange = JGitUtils.getLastChange(r);
			}
			r.close();

			// return a copy of the cached model
			return DeepCopier.copy(model);
			}

			/**
			* Workaround JGit. I need to access the raw config object directly in order
			* to see if the config is dirty so that I can reload a repository model.
			* If I use the stock JGit method to get the config it already reloads the
			* config. If the config changes are made within Gitblit this is fine as
			* the returned config will still be flagged as dirty. BUT... if the config
			* is manipulated outside Gitblit then it fails to recognize this as dirty.
			*
			* @param r
			* @return a config
			*/
			private StoredConfig getRepositoryConfig(Repository r) {
			try {
			Field f = r.getClass().getDeclaredField("repoConfig");
			f.setAccessible(true);
			StoredConfig config = (StoredConfig) f.get(r);
			return config;
			} catch (Exception e) {
			logger.error("Failed to retrieve \"repoConfig\" via reflection", e);
			}
			return r.getConfig();
			}

			/**
			* Create a repository model from the configuration and repository data.
			*
			* @param repositoryName
			* @return a repositoryModel or null if the repository does not exist
			*/
			private RepositoryModel loadRepositoryModel(String repositoryName) {
			Repository r = getRepository(repositoryName);
			if (r == null) {
			return null;
			@@ -867,7 +1058,8 @@
			model.hasCommits = JGitUtils.hasCommits(r);
			model.lastChange = JGitUtils.getLastChange(r);
			model.isBare = r.isBare();
			StoredConfig config = JGitUtils.readConfig(r);

			StoredConfig config = r.getConfig();
			if (config != null) {
			model.description = getConfig(config, "description", "");
			model.owner = getConfig(config, "owner", "");
			@@ -875,6 +1067,8 @@
			model.useDocs = getConfig(config, "useDocs", false);
			model.accessRestriction = AccessRestrictionType.fromName(getConfig(config,
			"accessRestriction", settings.getString(Keys.git.defaultAccessRestriction, null)));
			model.authorizationControl = AuthorizationControl.fromName(getConfig(config,
			"authorizationControl", settings.getString(Keys.git.defaultAuthorizationControl, null)));
			model.showRemoteBranches = getConfig(config, "showRemoteBranches", false);
			model.isFrozen = getConfig(config, "isFrozen", false);
			model.showReadme = getConfig(config, "showReadme", false);
			@@ -905,6 +1099,26 @@
			model.availableRefs = JGitUtils.getAvailableHeadTargets(r);
			r.close();
			return model;
			}

			/**
			* Determines if this server has the requested repository.
			*
			* @param name
			* @return true if the repository exists
			*/
			public boolean hasRepository(String repositoryName) {
			if (settings.getBoolean(Keys.git.cacheRepositoryList, true)) {
			// if we are caching use the cache to determine availability
			// otherwise we end up adding a phantom repository to the cache
			return repositoryListCache.containsKey(repositoryName);
			}
			Repository r = getRepository(repositoryName, false);
			if (r == null) {
			return false;
			}
			r.close();
			return true;
			}

			/**
			@@ -1082,7 +1296,7 @@
			}

			// clear the cache
			clearRepositoryCache(repositoryName);
			clearRepositoryMetadataCache(repositoryName);
			}

			// load repository
			@@ -1110,15 +1324,20 @@
			repository.name, currentRef, repository.HEAD));
			if (JGitUtils.setHEADtoRef(r, repository.HEAD)) {
			// clear the cache
			clearRepositoryCache(repository.name);
			clearRepositoryMetadataCache(repository.name);
			}
			}

			// close the repository object
			r.close();
			}

			// update repository cache
			removeFromCachedRepositoryList(repositoryName);
			// model will actually be replaced on next load because config is stale
			addToCachedRepositoryList(repository.name, repository);
			}


			/**
			* Updates the Gitblit configuration for the specified repository.
			*
			@@ -1128,12 +1347,13 @@
			* the Gitblit repository model
			*/
			public void updateConfiguration(Repository r, RepositoryModel repository) {
			StoredConfig config = JGitUtils.readConfig(r);
			StoredConfig config = r.getConfig();
			config.setString(Constants.CONFIG_GITBLIT, null, "description", repository.description);
			config.setString(Constants.CONFIG_GITBLIT, null, "owner", repository.owner);
			config.setBoolean(Constants.CONFIG_GITBLIT, null, "useTickets", repository.useTickets);
			config.setBoolean(Constants.CONFIG_GITBLIT, null, "useDocs", repository.useDocs);
			config.setString(Constants.CONFIG_GITBLIT, null, "accessRestriction", repository.accessRestriction.name());
			config.setString(Constants.CONFIG_GITBLIT, null, "authorizationControl", repository.authorizationControl.name());
			config.setBoolean(Constants.CONFIG_GITBLIT, null, "showRemoteBranches", repository.showRemoteBranches);
			config.setBoolean(Constants.CONFIG_GITBLIT, null, "isFrozen", repository.isFrozen);
			config.setBoolean(Constants.CONFIG_GITBLIT, null, "showReadme", repository.showReadme);
			@@ -1205,16 +1425,18 @@
			public boolean deleteRepository(String repositoryName) {
			try {
			closeRepository(repositoryName);
			// clear the repository cache
			clearRepositoryMetadataCache(repositoryName);
			removeFromCachedRepositoryList(repositoryName);

			File folder = new File(repositoriesFolder, repositoryName);
			if (folder.exists() && folder.isDirectory()) {
			FileUtils.delete(folder, FileUtils.RECURSIVE \| FileUtils.RETRY);
			if (userService.deleteRepositoryRole(repositoryName)) {
			logger.info(MessageFormat.format("Repository \"{0}\" deleted", repositoryName));
			return true;
			}
			}

			// clear the repository cache
			clearRepositoryCache(repositoryName);
			} catch (Throwable t) {
			logger.error(MessageFormat.format("Failed to delete repository {0}", repositoryName), t);
			}
			@@ -1933,6 +2155,15 @@
			repositoriesFolder = getRepositoriesFolder();
			logger.info("Git repositories folder " + repositoriesFolder.getAbsolutePath());
			repositoryResolver = new FileResolver<Void>(repositoriesFolder, true);

			// calculate repository list settings checksum for future config changes
			repositoryListSettingsChecksum.set(getRepositoryListSettingsChecksum());

			// build initial repository list
			if (settings.getBoolean(Keys.git.cacheRepositoryList, true)) {
			logger.info("Identifying available repositories...");
			getRepositoryList();
			}

			logTimezone("JVM", TimeZone.getDefault());
			logTimezone(Constants.NAME, getTimezone());