Reorganized to Apache Standard Directory Layout & integrated Moxie

This is a massive commit which reorganizes the entire project structure
(although it is still monolithic), removes the Build classes, and
switches to Moxie, a smarter Ant build tookit based on the original
Gitblit Build classes.

The Ant build script will likely require additional fine-tuning, but
this is big step forward.

1 files changed, 405 insertions, 0 deletions

diff --git a/src/main/java/com/gitblit/GitServlet.java b/src/main/java/com/gitblit/GitServlet.java
new file mode 100644
index 00000000..77be963f
--- /dev/null
+++ b/src/main/java/com/gitblit/GitServlet.java
@@ -0,0 +1,405 @@
+/*

+ * Copyright 2011 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 groovy.lang.Binding;

+import groovy.util.GroovyScriptEngine;

+

+import java.io.File;

+import java.io.IOException;

+import java.text.MessageFormat;

+import java.util.Collection;

+import java.util.Enumeration;

+import java.util.LinkedHashSet;

+import java.util.List;

+import java.util.Map;

+import java.util.Set;

+

+import javax.servlet.ServletConfig;

+import javax.servlet.ServletContext;

+import javax.servlet.ServletException;

+import javax.servlet.http.HttpServletRequest;

+

+import org.eclipse.jgit.http.server.resolver.DefaultReceivePackFactory;

+import org.eclipse.jgit.http.server.resolver.DefaultUploadPackFactory;

+import org.eclipse.jgit.lib.PersonIdent;

+import org.eclipse.jgit.lib.Ref;

+import org.eclipse.jgit.lib.Repository;

+import org.eclipse.jgit.revwalk.RevCommit;

+import org.eclipse.jgit.transport.PostReceiveHook;

+import org.eclipse.jgit.transport.PreReceiveHook;

+import org.eclipse.jgit.transport.ReceiveCommand;

+import org.eclipse.jgit.transport.ReceiveCommand.Result;

+import org.eclipse.jgit.transport.ReceivePack;

+import org.eclipse.jgit.transport.RefFilter;

+import org.eclipse.jgit.transport.UploadPack;

+import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;

+import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;

+import org.slf4j.Logger;

+import org.slf4j.LoggerFactory;

+

+import com.gitblit.Constants.AccessRestrictionType;

+import com.gitblit.models.RepositoryModel;

+import com.gitblit.models.UserModel;

+import com.gitblit.utils.ClientLogger;

+import com.gitblit.utils.HttpUtils;

+import com.gitblit.utils.IssueUtils;

+import com.gitblit.utils.JGitUtils;

+import com.gitblit.utils.PushLogUtils;

+import com.gitblit.utils.StringUtils;

+

+/**

+ * The GitServlet exists to force configuration of the JGit GitServlet based on

+ * the Gitblit settings from either gitblit.properties or from context

+ * parameters in the web.xml file.

+ * 

+ * It also implements and registers the Groovy hook mechanism.

+ * 

+ * Access to this servlet is protected by the GitFilter.

+ * 

+ * @author James Moger

+ * 

+ */

+public class GitServlet extends org.eclipse.jgit.http.server.GitServlet {

+

+	private static final long serialVersionUID = 1L;

+

+	private GroovyScriptEngine gse;

+

+	private File groovyDir;

+

+	@Override

+	public void init(ServletConfig config) throws ServletException {

+		groovyDir = GitBlit.getGroovyScriptsFolder();

+		try {

+			// set Grape root

+			File grapeRoot = GitBlit.getFileOrFolder(Keys.groovy.grapeFolder, "${baseFolder}/groovy/grape").getAbsoluteFile();

+			grapeRoot.mkdirs();

+			System.setProperty("grape.root", grapeRoot.getAbsolutePath());

+			

+			gse = new GroovyScriptEngine(groovyDir.getAbsolutePath());			

+		} catch (IOException e) {

+			throw new ServletException("Failed to instantiate Groovy Script Engine!", e);

+		}

+

+		// set the Gitblit receive hook

+		setReceivePackFactory(new DefaultReceivePackFactory() {

+			@Override

+			public ReceivePack create(HttpServletRequest req, Repository db)

+					throws ServiceNotEnabledException, ServiceNotAuthorizedException {

+				

+				// determine repository name from request

+				String repositoryName = req.getPathInfo().substring(1);

+				repositoryName = GitFilter.getRepositoryName(repositoryName);

+				

+				GitblitReceiveHook hook = new GitblitReceiveHook();

+				hook.repositoryName = repositoryName;

+				hook.gitblitUrl = HttpUtils.getGitblitURL(req);

+

+				ReceivePack rp = super.create(req, db);

+				rp.setPreReceiveHook(hook);

+				rp.setPostReceiveHook(hook);

+

+				// determine pushing user

+				PersonIdent person = rp.getRefLogIdent();

+				UserModel user = GitBlit.self().getUserModel(person.getName());

+				if (user == null) {

+					// anonymous push, create a temporary usermodel

+					user = new UserModel(person.getName());

+				}

+				

+				// enforce advanced ref permissions

+				RepositoryModel repository = GitBlit.self().getRepositoryModel(repositoryName);

+				rp.setAllowCreates(user.canCreateRef(repository));

+				rp.setAllowDeletes(user.canDeleteRef(repository));

+				rp.setAllowNonFastForwards(user.canRewindRef(repository));

+				

+				if (repository.isFrozen) {

+					throw new ServiceNotEnabledException();

+				}

+				

+				return rp;

+			}

+		});

+		

+		// override the default upload pack to exclude gitblit refs

+		setUploadPackFactory(new DefaultUploadPackFactory() {

+			@Override

+			public UploadPack create(final HttpServletRequest req, final Repository db)

+					throws ServiceNotEnabledException, ServiceNotAuthorizedException {

+				UploadPack up = super.create(req, db);

+				RefFilter refFilter = new RefFilter() {

+					@Override

+					public Map<String, Ref> filter(Map<String, Ref> refs) {

+						// admin accounts can access all refs 

+						UserModel user = GitBlit.self().authenticate(req);

+						if (user == null) {

+							user = UserModel.ANONYMOUS;

+						}

+						if (user.canAdmin()) {

+							return refs;

+						}

+

+						// normal users can not clone gitblit refs

+						refs.remove(IssueUtils.GB_ISSUES);

+						refs.remove(PushLogUtils.GB_PUSHES);

+						return refs;

+					}

+				};

+				up.setRefFilter(refFilter);

+				return up;

+			}

+		});

+		super.init(new GitblitServletConfig(config));

+	}

+

+	/**

+	 * Transitional wrapper class to configure the JGit 1.2 GitFilter. This

+	 * GitServlet will probably be replaced by a GitFilter so that Gitblit can

+	 * serve Git repositories on the root URL and not a /git sub-url.

+	 * 

+	 * @author James Moger

+	 * 

+	 */

+	private class GitblitServletConfig implements ServletConfig {

+		final ServletConfig config;

+

+		GitblitServletConfig(ServletConfig config) {

+			this.config = config;

+		}

+

+		@Override

+		public String getServletName() {

+			return config.getServletName();

+		}

+

+		@Override

+		public ServletContext getServletContext() {

+			return config.getServletContext();

+		}

+

+		@Override

+		public String getInitParameter(String name) {

+			if (name.equals("base-path")) {

+				return GitBlit.getRepositoriesFolder().getAbsolutePath();

+			} else if (name.equals("export-all")) {

+				return "1";

+			}

+			return config.getInitParameter(name);

+		}

+

+		@Override

+		public Enumeration<String> getInitParameterNames() {

+			return config.getInitParameterNames();

+		}

+	}

+

+	/**

+	 * The Gitblit receive hook allows for special processing on push events.

+	 * That might include rejecting writes to specific branches or executing a

+	 * script.

+	 * 

+	 * @author James Moger

+	 * 

+	 */

+	private class GitblitReceiveHook implements PreReceiveHook, PostReceiveHook {

+

+		protected final Logger logger = LoggerFactory.getLogger(GitblitReceiveHook.class);

+

+		protected String repositoryName;

+		

+		protected String gitblitUrl;

+

+		/**

+		 * Instrumentation point where the incoming push event has been parsed,

+		 * validated, objects created BUT refs have not been updated. You might

+		 * use this to enforce a branch-write permissions model.

+		 */

+		@Override

+		public void onPreReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {

+			RepositoryModel repository = GitBlit.self().getRepositoryModel(repositoryName);

+			UserModel user = getUserModel(rp);

+			

+			if (repository.accessRestriction.atLeast(AccessRestrictionType.PUSH) && repository.verifyCommitter) {

+				if (StringUtils.isEmpty(user.emailAddress)) {

+					// emit warning if user does not have an email address 

+					logger.warn(MessageFormat.format("Consider setting an email address for {0} ({1}) to improve committer verification.", user.getDisplayName(), user.username));

+				}

+				

+				// Optionally enforce that the committer of the left parent chain

+				// match the account being used to push the commits.

+				// 

+				// This requires all merge commits are executed with the "--no-ff"

+				// option to force a merge commit even if fast-forward is possible.

+				// This ensures that the chain of left parents has the commit

+				// identity of the merging user.

+				for (ReceiveCommand cmd : commands) {

+					try {

+						List<RevCommit> commits = JGitUtils.getRevLog(rp.getRepository(), cmd.getOldId().name(), cmd.getNewId().name());

+						for (RevCommit commit : commits) {

+							PersonIdent committer = commit.getCommitterIdent();

+							if (!user.is(committer.getName(), committer.getEmailAddress())) {

+								String reason;

+								if (StringUtils.isEmpty(user.emailAddress)) {

+									// account does not have en email address

+									reason = MessageFormat.format("{0} by {1} <{2}> was not committed by {3} ({4})", commit.getId().name(), committer.getName(), StringUtils.isEmpty(committer.getEmailAddress()) ? "?":committer.getEmailAddress(), user.getDisplayName(), user.username);

+								} else {

+									// account has an email address

+									reason = MessageFormat.format("{0} by {1} <{2}> was not committed by {3} ({4}) <{5}>", commit.getId().name(), committer.getName(), StringUtils.isEmpty(committer.getEmailAddress()) ? "?":committer.getEmailAddress(), user.getDisplayName(), user.username, user.emailAddress);

+								}

+								cmd.setResult(Result.REJECTED_OTHER_REASON, reason);

+								break;

+							}

+						}

+					} catch (Exception e) {

+						logger.error("Failed to verify commits were made by pushing user", e);

+					}

+				}

+			}

+			

+			Set<String> scripts = new LinkedHashSet<String>();

+			scripts.addAll(GitBlit.self().getPreReceiveScriptsInherited(repository));

+			scripts.addAll(repository.preReceiveScripts);

+			runGroovy(repository, user, commands, rp, scripts);

+			for (ReceiveCommand cmd : commands) {

+				if (!Result.NOT_ATTEMPTED.equals(cmd.getResult())) {

+					logger.warn(MessageFormat.format("{0} {1} because \"{2}\"", cmd.getNewId()

+							.getName(), cmd.getResult(), cmd.getMessage()));

+				}

+			}

+		}

+

+		/**

+		 * Instrumentation point where the incoming push has been applied to the

+		 * repository. This is the point where we would trigger a Jenkins build

+		 * or send an email.

+		 */

+		@Override

+		public void onPostReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {

+			if (commands.size() == 0) {

+				logger.info("skipping post-receive hooks, no refs created, updated, or removed");

+				return;

+			}

+

+			UserModel user = getUserModel(rp);

+			RepositoryModel repository = GitBlit.self().getRepositoryModel(repositoryName);

+

+			// log ref changes

+			for (ReceiveCommand cmd : commands) {

+				if (Result.OK.equals(cmd.getResult())) {

+					// add some logging for important ref changes

+					switch (cmd.getType()) {

+					case DELETE:

+						logger.info(MessageFormat.format("{0} DELETED {1} in {2} ({3})", user.username, cmd.getRefName(), repository.name, cmd.getOldId().name()));

+						break;

+					case CREATE:

+						logger.info(MessageFormat.format("{0} CREATED {1} in {2}", user.username, cmd.getRefName(), repository.name));

+						break;

+					case UPDATE_NONFASTFORWARD:

+						logger.info(MessageFormat.format("{0} UPDATED NON-FAST-FORWARD {1} in {2} (from {3} to {4})", user.username, cmd.getRefName(), repository.name, cmd.getOldId().name(), cmd.getNewId().name()));

+						break;

+					default:

+						break;

+					}

+				}

+			}

+

+			// update push log

+			try {

+				PushLogUtils.updatePushLog(user, rp.getRepository(), commands);

+				logger.info(MessageFormat.format("{0} push log updated", repository.name));

+			} catch (Exception e) {

+				logger.error(MessageFormat.format("Failed to update {0} pushlog", repository.name), e);

+			}

+			

+			// run Groovy hook scripts 

+			Set<String> scripts = new LinkedHashSet<String>();

+			scripts.addAll(GitBlit.self().getPostReceiveScriptsInherited(repository));

+			scripts.addAll(repository.postReceiveScripts);

+			runGroovy(repository, user, commands, rp, scripts);

+		}

+

+		/**

+		 * Returns the UserModel for the user pushing the changes.

+		 * 

+		 * @param rp

+		 * @return a UserModel

+		 */

+		protected UserModel getUserModel(ReceivePack rp) {

+			PersonIdent person = rp.getRefLogIdent();

+			UserModel user = GitBlit.self().getUserModel(person.getName());

+			if (user == null) {

+				// anonymous push, create a temporary usermodel

+				user = new UserModel(person.getName());

+				user.isAuthenticated = false;

+			}

+			return user;

+		}

+

+		/**

+		 * Runs the specified Groovy hook scripts.

+		 * 

+		 * @param repository

+		 * @param user

+		 * @param commands

+		 * @param scripts

+		 */

+		protected void runGroovy(RepositoryModel repository, UserModel user,

+				Collection<ReceiveCommand> commands, ReceivePack rp, Set<String> scripts) {

+			if (scripts == null || scripts.size() == 0) {

+				// no Groovy scripts to execute

+				return;

+			}

+

+			Binding binding = new Binding();

+			binding.setVariable("gitblit", GitBlit.self());

+			binding.setVariable("repository", repository);

+			binding.setVariable("receivePack", rp);

+			binding.setVariable("user", user);

+			binding.setVariable("commands", commands);

+			binding.setVariable("url", gitblitUrl);

+			binding.setVariable("logger", logger);

+			binding.setVariable("clientLogger", new ClientLogger(rp));

+			for (String script : scripts) {

+				if (StringUtils.isEmpty(script)) {

+					continue;

+				}

+				// allow script to be specified without .groovy extension

+				// this is easier to read in the settings

+				File file = new File(groovyDir, script);

+				if (!file.exists() && !script.toLowerCase().endsWith(".groovy")) {

+					file = new File(groovyDir, script + ".groovy");

+					if (file.exists()) {

+						script = file.getName();

+					}

+				}

+				try {

+					Object result = gse.run(script, binding);

+					if (result instanceof Boolean) {

+						if (!((Boolean) result)) {

+							logger.error(MessageFormat.format(

+									"Groovy script {0} has failed!  Hook scripts aborted.", script));

+							break;

+						}

+					}

+				} catch (Exception e) {

+					logger.error(

+							MessageFormat.format("Failed to execute Groovy script {0}", script), e);

+				}

+			}

+		}

+	}

+}