githubFork/gitblit.git - Solinfo Gitblit

			@@ -37,12 +37,14 @@
			import java.util.Map.Entry;
			import java.util.Set;
			import java.util.TimeZone;
			import java.util.TreeMap;
			import java.util.TreeSet;
			import java.util.concurrent.ConcurrentHashMap;
			import java.util.concurrent.Executors;
			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 +58,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;
			@@ -77,6 +80,7 @@
			import com.gitblit.models.FederationProposal;
			import com.gitblit.models.FederationSet;
			import com.gitblit.models.Metric;
			import com.gitblit.models.ProjectModel;
			import com.gitblit.models.RepositoryModel;
			import com.gitblit.models.SearchResult;
			import com.gitblit.models.ServerSettings;
			@@ -86,6 +90,8 @@
			import com.gitblit.models.UserModel;
			import com.gitblit.utils.ArrayUtils;
			import com.gitblit.utils.ByteFormat;
			import com.gitblit.utils.ContainerUtils;
			import com.gitblit.utils.DeepCopier;
			import com.gitblit.utils.FederationUtils;
			import com.gitblit.utils.JGitUtils;
			import com.gitblit.utils.JsonUtils;
			@@ -125,6 +131,12 @@
			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 Map<String, ProjectModel> projectCache = new ConcurrentHashMap<String, ProjectModel>();

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

			private RepositoryResolver<Void> repositoryResolver;

			@@ -145,6 +157,8 @@
			private LuceneExecutor luceneExecutor;

			private TimeZone timezone;

			private FileBasedConfig projectConfigs;

			public GitBlit() {
			if (gitblit == null) {
			@@ -723,15 +737,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;
			}

			/**
			@@ -741,11 +820,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),
			settings.getStrings(Keys.git.searchExclusions));
			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;
			}

			/**
			@@ -804,6 +920,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) {
			@@ -823,9 +940,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;
			}

			@@ -860,6 +983,203 @@
			* @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);
			}


			/**
			* Returns the map of project config. This map is cached and reloaded if
			* the underlying projects.conf file changes.
			*
			* @return project config map
			*/
			private Map<String, ProjectModel> getProjectConfigs() {
			if (projectConfigs.isOutdated()) {

			try {
			projectConfigs.load();
			} catch (Exception e) {
			}

			// project configs
			String rootName = GitBlit.getString(Keys.web.repositoryRootGroupName, "main");
			ProjectModel rootProject = new ProjectModel(rootName, true);

			Map<String, ProjectModel> configs = new HashMap<String, ProjectModel>();
			// cache the root project under its alias and an empty path
			configs.put("", rootProject);
			configs.put(rootProject.name.toLowerCase(), rootProject);

			for (String name : projectConfigs.getSubsections("project")) {
			ProjectModel project;
			if (name.equalsIgnoreCase(rootName)) {
			project = rootProject;
			} else {
			project = new ProjectModel(name);
			}
			project.title = projectConfigs.getString("project", name, "title");
			project.description = projectConfigs.getString("project", name, "description");
			// TODO add more interesting metadata
			// project manager?
			// commit message regex?
			// RW+
			// RW
			// R
			configs.put(name.toLowerCase(), project);
			}
			projectCache.clear();
			projectCache.putAll(configs);
			}
			return projectCache;
			}

			/**
			* Returns a list of project models for the user.
			*
			* @param user
			* @return list of projects that are accessible to the user
			*/
			public List<ProjectModel> getProjectModels(UserModel user) {
			Map<String, ProjectModel> configs = getProjectConfigs();

			// per-user project lists, this accounts for security and visibility
			Map<String, ProjectModel> map = new TreeMap<String, ProjectModel>();
			// root project
			map.put("", configs.get(""));

			for (RepositoryModel model : getRepositoryModels(user)) {
			String rootPath = StringUtils.getRootPath(model.name).toLowerCase();
			if (!map.containsKey(rootPath)) {
			ProjectModel project;
			if (configs.containsKey(rootPath)) {
			// clone the project model because it's repository list will
			// be tailored for the requesting user
			project = DeepCopier.copy(configs.get(rootPath));
			} else {
			project = new ProjectModel(rootPath);
			}
			map.put(rootPath, project);
			}
			map.get(rootPath).addRepository(model);
			}

			// sort projects, root project first
			List<ProjectModel> projects = new ArrayList<ProjectModel>(map.values());
			Collections.sort(projects);
			projects.remove(map.get(""));
			projects.add(0, map.get(""));
			return projects;
			}

			/**
			* Returns the project model for the specified user.
			*
			* @param name
			* @param user
			* @return a project model, or null if it does not exist
			*/
			public ProjectModel getProjectModel(String name, UserModel user) {
			for (ProjectModel project : getProjectModels(user)) {
			if (project.name.equalsIgnoreCase(name)) {
			return project;
			}
			}
			return null;
			}

			/**
			* Returns a project model for the Gitblit/system user.
			*
			* @param name a project name
			* @return a project model or null if the project does not exist
			*/
			public ProjectModel getProjectModel(String name) {
			Map<String, ProjectModel> configs = getProjectConfigs();
			ProjectModel project = configs.get(name.toLowerCase());
			if (project == null) {
			return null;
			}
			// clone the object
			project = DeepCopier.copy(project);
			String folder = name.toLowerCase() + "/";
			for (String repository : getRepositoryList()) {
			if (repository.toLowerCase().startsWith(folder)) {
			project.addRepository(repository);
			}
			}
			return project;
			}

			/**
			* 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;
			@@ -869,7 +1189,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", "");
			@@ -909,6 +1230,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;
			}

			/**
			@@ -1086,7 +1427,7 @@
			}

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

			// load repository
			@@ -1114,15 +1455,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.
			*
			@@ -1132,7 +1478,7 @@
			* 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);
			@@ -1210,16 +1556,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);
			}
			@@ -1938,6 +2286,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());
			@@ -1953,6 +2310,11 @@
			loginService = new GitblitUserService();
			}
			setUserService(loginService);

			// load and cache the project metadata
			projectConfigs = new FileBasedConfig(getFileOrFolder(Keys.web.projectsFile, "projects.conf"), FS.detect());
			getProjectConfigs();

			mailExecutor = new MailExecutor(settings);
			if (mailExecutor.isReady()) {
			logger.info("Mail executor is scheduled to process the message queue every 2 minutes.");
			@@ -1988,6 +2350,8 @@
			} catch (IllegalArgumentException e) {
			logger.error("Failed to configure JGit parameters!", e);
			}

			ContainerUtils.CVE_2007_0450.test();
			}

			private void logTimezone(String type, TimeZone zone) {