From 86bea9e0016b2890db8ba83049dd4e89653a0a5e Mon Sep 17 00:00:00 2001
From: James Moger <james.moger@gitblit.com>
Date: Fri, 16 Mar 2012 17:29:39 -0400
Subject: [PATCH] Ensure that the welcome message is interpreted as UTF-8 (issue 74)

---
 src/com/gitblit/GitBlit.java |  518 +++++++++++++++++++++++++++++++++++++++++++++++++-------
 1 files changed, 447 insertions(+), 71 deletions(-)

diff --git a/src/com/gitblit/GitBlit.java b/src/com/gitblit/GitBlit.java
index 60a96e6..272630c 100644
--- a/src/com/gitblit/GitBlit.java
+++ b/src/com/gitblit/GitBlit.java
@@ -23,13 +23,20 @@
 import java.io.InputStreamReader;
 import java.lang.reflect.Field;
 import java.text.MessageFormat;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.Date;
 import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Set;
+import java.util.TimeZone;
+import java.util.TreeSet;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
@@ -66,10 +73,13 @@
 import com.gitblit.models.FederationSet;
 import com.gitblit.models.Metric;
 import com.gitblit.models.RepositoryModel;
+import com.gitblit.models.SearchResult;
 import com.gitblit.models.ServerSettings;
 import com.gitblit.models.ServerStatus;
 import com.gitblit.models.SettingModel;
+import com.gitblit.models.TeamModel;
 import com.gitblit.models.UserModel;
+import com.gitblit.utils.ArrayUtils;
 import com.gitblit.utils.ByteFormat;
 import com.gitblit.utils.FederationUtils;
 import com.gitblit.utils.JGitUtils;
@@ -77,6 +87,7 @@
 import com.gitblit.utils.MetricUtils;
 import com.gitblit.utils.ObjectCache;
 import com.gitblit.utils.StringUtils;
+import com.gitblit.utils.TimeUtils;
 
 /**
  * GitBlit is the servlet context listener singleton that acts as the core for
@@ -97,7 +108,7 @@
 public class GitBlit implements ServletContextListener {
 
 	private static GitBlit gitblit;
-
+	
 	private final Logger logger = LoggerFactory.getLogger(GitBlit.class);
 
 	private final ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(5);
@@ -117,8 +128,6 @@
 
 	private File repositoriesFolder;
 
-	private boolean exportAll = true;
-
 	private IUserService userService;
 
 	private IStoredSettings settings;
@@ -128,6 +137,10 @@
 	private ServerStatus serverStatus;
 
 	private MailExecutor mailExecutor;
+	
+	private LuceneExecutor luceneExecutor;
+	
+	private TimeZone timezone;
 
 	public GitBlit() {
 		if (gitblit == null) {
@@ -156,6 +169,24 @@
 	public static boolean isGO() {
 		return self().settings instanceof FileSettings;
 	}
+	
+	/**
+	 * Returns the preferred timezone for the Gitblit instance.
+	 * 
+	 * @return a timezone
+	 */
+	public static TimeZone getTimezone() {
+		if (self().timezone == null) {
+			String tzid = getString("web.timezone", null);
+			if (StringUtils.isEmpty(tzid)) {
+				self().timezone = TimeZone.getDefault();
+				return self().timezone;
+			}
+			self().timezone = TimeZone.getTimeZone(tzid);
+		}
+		return self().timezone;
+	}
+	
 
 	/**
 	 * Returns the boolean value for the specified key. If the key does not
@@ -292,6 +323,16 @@
 	 */
 	public static File getProposalsFolder() {
 		return getFileOrFolder(Keys.federation.proposalsFolder, "proposals");
+	}
+
+	/**
+	 * Returns the path of the Groovy folder. This method checks to see if
+	 * Gitblit is running on a cloud service and may return an adjusted path.
+	 * 
+	 * @return the Groovy scripts folder path
+	 */
+	public static File getGroovyScriptsFolder() {
+		return getFileOrFolder(Keys.groovy.scriptsFolder, "groovy");
 	}
 
 	/**
@@ -434,8 +475,18 @@
 	 */
 	public List<String> getAllUsernames() {
 		List<String> names = new ArrayList<String>(userService.getAllUsernames());
-		Collections.sort(names);
 		return names;
+	}
+
+	/**
+	 * Returns the list of all users available to the login service.
+	 * 
+	 * @see IUserService.getAllUsernames()
+	 * @return list of all usernames
+	 */
+	public List<UserModel> getAllUsers() {
+		List<UserModel> users = userService.getAllUsers();
+		return users;
 	}
 
 	/**
@@ -511,6 +562,95 @@
 	}
 
 	/**
+	 * Returns the list of available teams that a user or repository may be
+	 * assigned to.
+	 * 
+	 * @return the list of teams
+	 */
+	public List<String> getAllTeamnames() {
+		List<String> teams = new ArrayList<String>(userService.getAllTeamNames());
+		return teams;
+	}
+
+	/**
+	 * Returns the list of available teams that a user or repository may be
+	 * assigned to.
+	 * 
+	 * @return the list of teams
+	 */
+	public List<TeamModel> getAllTeams() {
+		List<TeamModel> teams = userService.getAllTeams();
+		return teams;
+	}
+
+	/**
+	 * Returns the TeamModel object for the specified name.
+	 * 
+	 * @param teamname
+	 * @return a TeamModel object or null
+	 */
+	public TeamModel getTeamModel(String teamname) {
+		return userService.getTeamModel(teamname);
+	}
+
+	/**
+	 * Returns the list of all teams who are allowed to bypass the access
+	 * restriction placed on the specified repository.
+	 * 
+	 * @see IUserService.getTeamnamesForRepositoryRole(String)
+	 * @param repository
+	 * @return list of all teamnames that can bypass the access restriction
+	 */
+	public List<String> getRepositoryTeams(RepositoryModel repository) {
+		return userService.getTeamnamesForRepositoryRole(repository.name);
+	}
+
+	/**
+	 * Sets the list of all uses who are allowed to bypass the access
+	 * restriction placed on the specified repository.
+	 * 
+	 * @see IUserService.setTeamnamesForRepositoryRole(String, List<String>)
+	 * @param repository
+	 * @param teamnames
+	 * @return true if successful
+	 */
+	public boolean setRepositoryTeams(RepositoryModel repository, List<String> repositoryTeams) {
+		return userService.setTeamnamesForRepositoryRole(repository.name, repositoryTeams);
+	}
+
+	/**
+	 * Updates the TeamModel object for the specified name.
+	 * 
+	 * @param teamname
+	 * @param team
+	 * @param isCreate
+	 */
+	public void updateTeamModel(String teamname, TeamModel team, boolean isCreate)
+			throws GitBlitException {
+		if (!teamname.equalsIgnoreCase(team.name)) {
+			if (userService.getTeamModel(team.name) != null) {
+				throw new GitBlitException(MessageFormat.format(
+						"Failed to rename ''{0}'' because ''{1}'' already exists.", teamname,
+						team.name));
+			}
+		}
+		if (!userService.updateTeamModel(teamname, team)) {
+			throw new GitBlitException(isCreate ? "Failed to add team!" : "Failed to update team!");
+		}
+	}
+
+	/**
+	 * Delete the team object with the specified teamname
+	 * 
+	 * @see IUserService.deleteTeam(String)
+	 * @param teamname
+	 * @return true if successful
+	 */
+	public boolean deleteTeam(String teamname) {
+		return userService.deleteTeam(teamname);
+	}
+
+	/**
 	 * Clears all the cached data for the specified repository.
 	 * 
 	 * @param repositoryName
@@ -527,7 +667,8 @@
 	 * @return list of all repositories
 	 */
 	public List<String> getRepositoryList() {
-		return JGitUtils.getRepositoryList(repositoriesFolder, exportAll,
+		return JGitUtils.getRepositoryList(repositoriesFolder, 
+				settings.getBoolean(Keys.git.onlyAccessBareRepositories, false),
 				settings.getBoolean(Keys.git.searchRepositoriesSubfolders, true));
 	}
 
@@ -538,21 +679,38 @@
 	 * @return repository or null
 	 */
 	public Repository getRepository(String repositoryName) {
+		return getRepository(repositoryName, true);
+	}
+
+	/**
+	 * Returns the JGit repository for the specified name.
+	 * 
+	 * @param repositoryName
+	 * @param logError
+	 * @return repository or null
+	 */
+	public Repository getRepository(String repositoryName, boolean logError) {
 		Repository r = null;
 		try {
 			r = repositoryResolver.open(null, repositoryName);
 		} catch (RepositoryNotFoundException e) {
 			r = null;
-			logger.error("GitBlit.getRepository(String) failed to find "
-					+ new File(repositoriesFolder, repositoryName).getAbsolutePath());
+			if (logError) {
+				logger.error("GitBlit.getRepository(String) failed to find "
+						+ new File(repositoriesFolder, repositoryName).getAbsolutePath());
+			}
 		} catch (ServiceNotAuthorizedException e) {
 			r = null;
-			logger.error("GitBlit.getRepository(String) failed to find "
-					+ new File(repositoriesFolder, repositoryName).getAbsolutePath(), e);
+			if (logError) {
+				logger.error("GitBlit.getRepository(String) failed to find "
+						+ new File(repositoriesFolder, repositoryName).getAbsolutePath(), e);
+			}
 		} catch (ServiceNotEnabledException e) {
 			r = null;
-			logger.error("GitBlit.getRepository(String) failed to find "
-					+ new File(repositoriesFolder, repositoryName).getAbsolutePath(), e);
+			if (logError) {
+				logger.error("GitBlit.getRepository(String) failed to find "
+						+ new File(repositoriesFolder, repositoryName).getAbsolutePath(), e);
+			}
 		}
 		return r;
 	}
@@ -627,7 +785,8 @@
 		RepositoryModel model = new RepositoryModel();
 		model.name = repositoryName;
 		model.hasCommits = JGitUtils.hasCommits(r);
-		model.lastChange = JGitUtils.getLastChange(r, null);
+		model.lastChange = JGitUtils.getLastChange(r);
+		model.isBare = r.isBare();
 		StoredConfig config = JGitUtils.readConfig(r);
 		if (config != null) {
 			model.description = getConfig(config, "description", "");
@@ -647,7 +806,17 @@
 					"gitblit", null, "federationSets")));
 			model.isFederated = getConfig(config, "isFederated", false);
 			model.origin = config.getString("remote", "origin", "url");
+			model.preReceiveScripts = new ArrayList<String>(Arrays.asList(config.getStringList(
+					"gitblit", null, "preReceiveScript")));
+			model.postReceiveScripts = new ArrayList<String>(Arrays.asList(config.getStringList(
+					"gitblit", null, "postReceiveScript")));
+			model.mailingLists = new ArrayList<String>(Arrays.asList(config.getStringList(
+					"gitblit", null, "mailingList")));
+			model.indexedBranches = new ArrayList<String>(Arrays.asList(config.getStringList(
+					"gitblit", null, "indexBranch")));
 		}
+		model.HEAD = JGitUtils.getHEADRef(r);
+		model.availableRefs = JGitUtils.getAvailableHeadTargets(r);
 		r.close();
 		return model;
 	}
@@ -704,6 +873,9 @@
 				repository.close();
 			}
 		}
+		
+		// close any open index writer/searcher in the Lucene executor
+		luceneExecutor.close(repositoryName);
 	}
 
 	/**
@@ -720,7 +892,7 @@
 		if (repositoryMetricsCache.hasCurrent(model.name, model.lastChange)) {
 			return new ArrayList<Metric>(repositoryMetricsCache.getObject(model.name));
 		}
-		List<Metric> metrics = MetricUtils.getDateMetrics(repository, null, true, null);
+		List<Metric> metrics = MetricUtils.getDateMetrics(repository, null, true, null, getTimezone());
 		repositoryMetricsCache.updateObject(model.name, model.lastChange, metrics);
 		return new ArrayList<Metric>(metrics);
 	}
@@ -785,6 +957,12 @@
 			// create repository
 			logger.info("create repository " + repository.name);
 			r = JGitUtils.createRepository(repositoriesFolder, repository.name);
+			
+			// automatically index master branch if Lucene integration is enabled
+			if (luceneExecutor.isReady()) {
+				repository.indexedBranches = new ArrayList<String>();
+				repository.indexedBranches.add("refs/heads/master");
+			}
 		} else {
 			// rename repository
 			if (!repositoryName.equalsIgnoreCase(repository.name)) {
@@ -805,6 +983,11 @@
 							MessageFormat
 									.format("Can not rename repository ''{0}'' to ''{1}'' because ''{1}'' already exists.",
 											repositoryName, repository.name));
+				}
+				File parentFile = destFolder.getParentFile();
+				if (!parentFile.exists() && !parentFile.mkdirs()) {
+					throw new GitBlitException(MessageFormat.format(
+							"Failed to create folder ''{0}''", parentFile.getAbsolutePath()));
 				}
 				if (!folder.renameTo(destFolder)) {
 					throw new GitBlitException(MessageFormat.format(
@@ -838,6 +1021,18 @@
 		// update settings
 		if (r != null) {
 			updateConfiguration(r, repository);
+			// only update symbolic head if it changes
+			String currentRef = JGitUtils.getHEADRef(r);
+			if (!StringUtils.isEmpty(repository.HEAD) && !repository.HEAD.equals(currentRef)) {
+				logger.info(MessageFormat.format("Relinking {0} HEAD from {1} to {2}", 
+						repository.name, currentRef, repository.HEAD));
+				if (JGitUtils.setHEADtoRef(r, repository.HEAD)) {
+					// clear the cache
+					clearRepositoryCache(repository.name);
+				}
+			}
+
+			// close the repository object
 			r.close();
 		}
 	}
@@ -866,6 +1061,19 @@
 		config.setString("gitblit", null, "federationStrategy",
 				repository.federationStrategy.name());
 		config.setBoolean("gitblit", null, "isFederated", repository.isFederated);
+		if (!ArrayUtils.isEmpty(repository.preReceiveScripts)) {
+			config.setStringList("gitblit", null, "preReceiveScript", repository.preReceiveScripts);
+		}
+		if (!ArrayUtils.isEmpty(repository.postReceiveScripts)) {
+			config.setStringList("gitblit", null, "postReceiveScript",
+					repository.postReceiveScripts);
+		}
+		if (!ArrayUtils.isEmpty(repository.mailingLists)) {
+			config.setStringList("gitblit", null, "mailingList", repository.mailingLists);
+		}
+		if (!ArrayUtils.isEmpty(repository.indexedBranches)) {
+			config.setStringList("gitblit", null, "indexBranch", repository.indexedBranches);
+		}
 		try {
 			config.save();
 		} catch (IOException e) {
@@ -1115,8 +1323,10 @@
 		case PULL_REPOSITORIES:
 			return token.equals(all) || token.equals(unr) || token.equals(jur);
 		case PULL_USERS:
+		case PULL_TEAMS:
 			return token.equals(all) || token.equals(unr);
 		case PULL_SETTINGS:
+		case PULL_SCRIPTS:
 			return token.equals(all);
 		}
 		return false;
@@ -1329,14 +1539,183 @@
 	}
 
 	/**
+	 * Returns the list of all Groovy push hook scripts. Script files must have
+	 * .groovy extension
+	 * 
+	 * @return list of available hook scripts
+	 */
+	public List<String> getAllScripts() {
+		File groovyFolder = getGroovyScriptsFolder();
+		File[] files = groovyFolder.listFiles(new FileFilter() {
+			@Override
+			public boolean accept(File pathname) {
+				return pathname.isFile() && pathname.getName().endsWith(".groovy");
+			}
+		});
+		List<String> scripts = new ArrayList<String>();
+		if (files != null) {
+			for (File file : files) {
+				String script = file.getName().substring(0, file.getName().lastIndexOf('.'));
+				scripts.add(script);
+			}
+		}
+		return scripts;
+	}
+
+	/**
+	 * Returns the list of pre-receive scripts the repository inherited from the
+	 * global settings and team affiliations.
+	 * 
+	 * @param repository
+	 *            if null only the globally specified scripts are returned
+	 * @return a list of scripts
+	 */
+	public List<String> getPreReceiveScriptsInherited(RepositoryModel repository) {
+		Set<String> scripts = new LinkedHashSet<String>();
+		// Globals
+		for (String script : getStrings(Keys.groovy.preReceiveScripts)) {
+			if (script.endsWith(".groovy")) {
+				scripts.add(script.substring(0, script.lastIndexOf('.')));
+			} else {
+				scripts.add(script);
+			}
+		}
+
+		// Team Scripts
+		if (repository != null) {
+			for (String teamname : userService.getTeamnamesForRepositoryRole(repository.name)) {
+				TeamModel team = userService.getTeamModel(teamname);
+				scripts.addAll(team.preReceiveScripts);
+			}
+		}
+		return new ArrayList<String>(scripts);
+	}
+
+	/**
+	 * Returns the list of all available Groovy pre-receive push hook scripts
+	 * that are not already inherited by the repository. Script files must have
+	 * .groovy extension
+	 * 
+	 * @param repository
+	 *            optional parameter
+	 * @return list of available hook scripts
+	 */
+	public List<String> getPreReceiveScriptsUnused(RepositoryModel repository) {
+		Set<String> inherited = new TreeSet<String>(getPreReceiveScriptsInherited(repository));
+
+		// create list of available scripts by excluding inherited scripts
+		List<String> scripts = new ArrayList<String>();
+		for (String script : getAllScripts()) {
+			if (!inherited.contains(script)) {
+				scripts.add(script);
+			}
+		}
+		return scripts;
+	}
+
+	/**
+	 * Returns the list of post-receive scripts the repository inherited from
+	 * the global settings and team affiliations.
+	 * 
+	 * @param repository
+	 *            if null only the globally specified scripts are returned
+	 * @return a list of scripts
+	 */
+	public List<String> getPostReceiveScriptsInherited(RepositoryModel repository) {
+		Set<String> scripts = new LinkedHashSet<String>();
+		// Global Scripts
+		for (String script : getStrings(Keys.groovy.postReceiveScripts)) {
+			if (script.endsWith(".groovy")) {
+				scripts.add(script.substring(0, script.lastIndexOf('.')));
+			} else {
+				scripts.add(script);
+			}
+		}
+		// Team Scripts
+		if (repository != null) {
+			for (String teamname : userService.getTeamnamesForRepositoryRole(repository.name)) {
+				TeamModel team = userService.getTeamModel(teamname);
+				scripts.addAll(team.postReceiveScripts);
+			}
+		}
+		return new ArrayList<String>(scripts);
+	}
+
+	/**
+	 * Returns the list of unused Groovy post-receive push hook scripts that are
+	 * not already inherited by the repository. Script files must have .groovy
+	 * extension
+	 * 
+	 * @param repository
+	 *            optional parameter
+	 * @return list of available hook scripts
+	 */
+	public List<String> getPostReceiveScriptsUnused(RepositoryModel repository) {
+		Set<String> inherited = new TreeSet<String>(getPostReceiveScriptsInherited(repository));
+
+		// create list of available scripts by excluding inherited scripts
+		List<String> scripts = new ArrayList<String>();
+		for (String script : getAllScripts()) {
+			if (!inherited.contains(script)) {
+				scripts.add(script);
+			}
+		}
+		return scripts;
+	}
+	
+	/**
+	 * Search the specified repositories using the Lucene query.
+	 * 
+	 * @param query
+	 * @param maximumHits
+	 * @param repositories
+	 * @return
+	 */
+	public List<SearchResult> search(String query, int maximumHits, List<String> repositories) {
+		List<SearchResult> srs = luceneExecutor.search(query, maximumHits, repositories);
+		return srs;
+	}
+
+	/**
 	 * Notify the administrators by email.
 	 * 
 	 * @param subject
 	 * @param message
 	 */
-	public void notifyAdministrators(String subject, String message) {
+	public void sendMailToAdministrators(String subject, String message) {
 		try {
 			Message mail = mailExecutor.createMessageForAdministrators();
+			if (mail != null) {
+				mail.setSubject(subject);
+				mail.setText(message);
+				mailExecutor.queue(mail);
+			}
+		} catch (MessagingException e) {
+			logger.error("Messaging error", e);
+		}
+	}
+
+	/**
+	 * Notify users by email of something.
+	 * 
+	 * @param subject
+	 * @param message
+	 * @param toAddresses
+	 */
+	public void sendMail(String subject, String message, Collection<String> toAddresses) {
+		this.sendMail(subject, message, toAddresses.toArray(new String[0]));
+	}
+
+	/**
+	 * Notify users by email of something.
+	 * 
+	 * @param subject
+	 * @param message
+	 * @param toAddresses
+	 */
+	public void sendMail(String subject, String message, String... toAddresses) {
+		try {
+			Message mail = mailExecutor.createMessage(toAddresses);
 			if (mail != null) {
 				mail.setSubject(subject);
 				mail.setText(message);
@@ -1360,6 +1739,7 @@
 				setting.currentValue = settings.getString(key, "");
 			}
 		}
+		settingsModel.pushScripts = getAllScripts();
 		return settingsModel;
 	}
 
@@ -1435,81 +1815,57 @@
 	 * 
 	 * @param settings
 	 */
-	@SuppressWarnings("deprecation")
 	public void configureContext(IStoredSettings settings, boolean startFederation) {
 		logger.info("Reading configuration from " + settings.toString());
 		this.settings = settings;
 		repositoriesFolder = getRepositoriesFolder();
 		logger.info("Git repositories folder " + repositoriesFolder.getAbsolutePath());
-		repositoryResolver = new FileResolver<Void>(repositoriesFolder, exportAll);
+		repositoryResolver = new FileResolver<Void>(repositoriesFolder, true);
+		
+		logTimezone("JVM", TimeZone.getDefault());
+		logTimezone(Constants.NAME, getTimezone());
+
 		serverStatus = new ServerStatus(isGO());
 		String realm = settings.getString(Keys.realm.userService, "users.properties");
 		IUserService loginService = null;
 		try {
 			// check to see if this "file" is a login service class
 			Class<?> realmClass = Class.forName(realm);
-			if (IUserService.class.isAssignableFrom(realmClass)) {
-				loginService = (IUserService) realmClass.newInstance();
-			}
+			loginService = (IUserService) realmClass.newInstance();
 		} catch (Throwable t) {
-			// not a login service class or class could not be instantiated.
-			// try to use default file login service
-			File realmFile = getFileOrFolder(Keys.realm.userService, "users.conf");
-			if (realmFile.exists()) {
-				// load the existing realm file
-				if (realmFile.getName().toLowerCase().endsWith(".properties")) {
-					// load the v0.5.0 - v0.7.0 properties-based realm file
-					loginService = new FileUserService(realmFile);
-
-					// automatically create a users.conf realm file from the
-					// original users.properties file
-					File usersConfig = new File(realmFile.getParentFile(), "users.conf");
-					if (!usersConfig.exists()) {
-						logger.info(MessageFormat.format("Automatically creating {0} based on {1}",
-								usersConfig.getAbsolutePath(), realmFile.getAbsolutePath()));
-						ConfigUserService configService = new ConfigUserService(usersConfig);
-						for (String username : loginService.getAllUsernames()) {
-							UserModel userModel = loginService.getUserModel(username);
-							configService.updateUserModel(userModel);
-						}
-					}
-					
-					// issue suggestion about switching to users.conf
-					logger.warn("Please consider using \"users.conf\" instead of the deprecated \"users.properties\" file");
-				} else if (realmFile.getName().toLowerCase().endsWith(".conf")) {
-					// load the config-based realm file
-					loginService = new ConfigUserService(realmFile);
-				}
-			} else {
-				// Create a new realm file and add the default admin
-				// account. This is necessary for bootstrapping a dynamic
-				// environment like running on a cloud service.
-				// As of v0.8.0 the default realm file is ConfigUserService.
-				try {
-					realmFile = getFileOrFolder(Keys.realm.userService, "users.conf");
-					realmFile.createNewFile();
-					loginService = new ConfigUserService(realmFile);
-					UserModel admin = new UserModel("admin");
-					admin.password = "admin";
-					admin.canAdmin = true;
-					admin.excludeFromFederation = true;
-					loginService.updateUserModel(admin);
-				} catch (IOException x) {
-					logger.error(
-							MessageFormat.format("COULD NOT CREATE REALM FILE {0}!", realmFile), x);
-				}
-			}
+			loginService = new GitblitUserService();
 		}
 		setUserService(loginService);
 		mailExecutor = new MailExecutor(settings);
 		if (mailExecutor.isReady()) {
+			logger.info("Mail executor is scheduled to process the message queue every 2 minutes.");
 			scheduledExecutor.scheduleAtFixedRate(mailExecutor, 1, 2, TimeUnit.MINUTES);
 		} else {
 			logger.warn("Mail server is not properly configured.  Mail services disabled.");
 		}
+		luceneExecutor = new LuceneExecutor(settings, repositoriesFolder);
+		if (luceneExecutor.isReady()) {
+			String idle = settings.getString(Keys.lucene.frequency, "2 mins");
+			int mins = TimeUtils.convertFrequencyToMinutes(idle);
+			if (mins <= 2) {
+				mins = 2;
+				idle = mins + " mins";
+			}
+			logger.info("Lucene executor is scheduled to process ref changes every " + idle);
+			scheduledExecutor.scheduleAtFixedRate(luceneExecutor, 1, mins, TimeUnit.MINUTES);
+		} else {
+			logger.warn("Lucene integration is disabled.");
+		}
 		if (startFederation) {
 			configureFederation();
-		}
+		}		
+	}
+	
+	private void logTimezone(String type, TimeZone zone) {
+		SimpleDateFormat df = new SimpleDateFormat("z Z");
+		df.setTimeZone(zone);
+		String offset = df.format(new Date());
+		logger.info(type + " timezone is " + zone.getID() + " (" + offset + ")");
 	}
 
 	/**
@@ -1528,18 +1884,37 @@
 			WebXmlSettings webxmlSettings = new WebXmlSettings(context);
 
 			// 0.7.0 web.properties in the deployed war folder
-			File overrideFile = new File(context.getRealPath("/WEB-INF/web.properties"));
-			if (overrideFile.exists()) {
-				webxmlSettings.applyOverrides(overrideFile);
+			String webProps = context.getRealPath("/WEB-INF/web.properties");
+			if (!StringUtils.isEmpty(webProps)) {
+				File overrideFile = new File(webProps);
+				if (overrideFile.exists()) {
+					webxmlSettings.applyOverrides(overrideFile);
+				}
 			}
+			
 
 			// 0.8.0 gitblit.properties file located outside the deployed war
 			// folder lie, for example, on RedHat OpenShift.
-			overrideFile = getFileOrFolder("gitblit.properties");
+			File overrideFile = getFileOrFolder("gitblit.properties");
 			if (!overrideFile.getPath().equals("gitblit.properties")) {
 				webxmlSettings.applyOverrides(overrideFile);
 			}
 			configureContext(webxmlSettings, true);
+
+			// Copy the included scripts to the configured groovy folder
+			File localScripts = getFileOrFolder(Keys.groovy.scriptsFolder, "groovy");
+			if (!localScripts.exists()) {
+				File includedScripts = new File(context.getRealPath("/WEB-INF/groovy"));
+				if (!includedScripts.equals(localScripts)) {
+					try {
+						com.gitblit.utils.FileUtils.copy(localScripts, includedScripts.listFiles());
+					} catch (IOException e) {
+						logger.error(MessageFormat.format(
+								"Failed to copy included Groovy scripts from {0} to {1}",
+								includedScripts, localScripts));
+					}
+				}
+			}
 		}
 
 		serverStatus.servletContainer = servletContext.getServerInfo();
@@ -1553,5 +1928,6 @@
 	public void contextDestroyed(ServletContextEvent contextEvent) {
 		logger.info("Gitblit context destroyed by servlet container.");
 		scheduledExecutor.shutdownNow();
+		luceneExecutor.close();
 	}
 }

--
Gitblit v1.9.1