Branch for implementing distributed gb-issues

1 files changed, 455 insertions, 0 deletions

diff --git a/src/com/gitblit/utils/IssueUtils.java b/src/com/gitblit/utils/IssueUtils.java
new file mode 100644
index 00000000..82170703
--- /dev/null
+++ b/src/com/gitblit/utils/IssueUtils.java
@@ -0,0 +1,455 @@
+/*

+ * 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.utils;

+

+import java.io.IOException;

+import java.text.MessageFormat;

+import java.util.ArrayList;

+import java.util.Arrays;

+import java.util.Collections;

+import java.util.Date;

+import java.util.HashMap;

+import java.util.List;

+import java.util.Map;

+

+import org.eclipse.jgit.JGitText;

+import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;

+import org.eclipse.jgit.api.errors.JGitInternalException;

+import org.eclipse.jgit.dircache.DirCache;

+import org.eclipse.jgit.dircache.DirCacheBuilder;

+import org.eclipse.jgit.dircache.DirCacheEntry;

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

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

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

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

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

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

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

+import org.eclipse.jgit.lib.RefUpdate.Result;

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

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

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

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

+import org.eclipse.jgit.treewalk.CanonicalTreeParser;

+import org.eclipse.jgit.treewalk.TreeWalk;

+

+import com.gitblit.models.IssueModel;

+import com.gitblit.models.IssueModel.Attachment;

+import com.gitblit.models.IssueModel.Change;

+import com.gitblit.models.IssueModel.Field;

+import com.gitblit.models.PathModel;

+import com.gitblit.models.RefModel;

+import com.gitblit.utils.JsonUtils.ExcludeField;

+import com.google.gson.Gson;

+

+/**

+ * Utility class for reading Gitblit issues.

+ * 

+ * @author James Moger

+ * 

+ */

+public class IssueUtils {

+

+	public static final String GB_ISSUES = "refs/heads/gb-issues";

+

+	/**

+	 * Returns a RefModel for the gb-issues branch in the repository. If the

+	 * branch can not be found, null is returned.

+	 * 

+	 * @param repository

+	 * @return a refmodel for the gb-issues branch or null

+	 */

+	public static RefModel getIssuesBranch(Repository repository) {

+		return JGitUtils.getBranch(repository, "gb-issues");

+	}

+

+	/**

+	 * Returns all the issues in the repository.

+	 * 

+	 * @param repository

+	 * @param filter

+	 *            optional issue filter to only return matching results

+	 * @return a list of issues

+	 */

+	public static List<IssueModel> getIssues(Repository repository, IssueFilter filter) {

+		List<IssueModel> list = new ArrayList<IssueModel>();

+		RefModel issuesBranch = getIssuesBranch(repository);

+		if (issuesBranch == null) {

+			return list;

+		}

+		List<PathModel> paths = JGitUtils

+				.getDocuments(repository, Arrays.asList("json"), GB_ISSUES);

+		RevTree tree = JGitUtils.getCommit(repository, GB_ISSUES).getTree();

+		for (PathModel path : paths) {

+			String json = JGitUtils.getStringContent(repository, tree, path.path);

+			IssueModel issue = JsonUtils.fromJsonString(json, IssueModel.class);

+			if (filter == null) {

+				list.add(issue);

+			} else {

+				if (filter.accept(issue)) {

+					list.add(issue);

+				}

+			}

+		}

+		Collections.sort(list);

+		return list;

+	}

+

+	/**

+	 * Retrieves the specified issue from the repository with complete changes

+	 * history.

+	 * 

+	 * @param repository

+	 * @param issueId

+	 * @return an issue, if it exists, otherwise null

+	 */

+	public static IssueModel getIssue(Repository repository, String issueId) {

+		RefModel issuesBranch = getIssuesBranch(repository);

+		if (issuesBranch == null) {

+			return null;

+		}

+

+		if (StringUtils.isEmpty(issueId)) {

+			return null;

+		}

+

+		// deserialize the issue model object

+		IssueModel issue = null;

+		String issuePath = getIssuePath(issueId);

+		RevTree tree = JGitUtils.getCommit(repository, GB_ISSUES).getTree();

+		String json = JGitUtils.getStringContent(repository, tree, issuePath + "/issue.json");

+		issue = JsonUtils.fromJsonString(json, IssueModel.class);

+		return issue;

+	}

+

+	/**

+	 * Retrieves the specified attachment from an issue.

+	 * 

+	 * @param repository

+	 * @param issueId

+	 * @param filename

+	 * @return an attachment, if found, null otherwise

+	 */

+	public static Attachment getIssueAttachment(Repository repository, String issueId,

+			String filename) {

+		RefModel issuesBranch = getIssuesBranch(repository);

+		if (issuesBranch == null) {

+			return null;

+		}

+

+		if (StringUtils.isEmpty(issueId)) {

+			return null;

+		}

+

+		// deserialize the issue model so that we have the attachment metadata

+		String issuePath = getIssuePath(issueId);

+		RevTree tree = JGitUtils.getCommit(repository, GB_ISSUES).getTree();

+		String json = JGitUtils.getStringContent(repository, tree, issuePath + "/issue.json");

+		IssueModel issue = JsonUtils.fromJsonString(json, IssueModel.class);

+		Attachment attachment = issue.getAttachment(filename);

+

+		// attachment not found

+		if (attachment == null) {

+			return null;

+		}

+

+		// retrieve the attachment content

+		byte[] content = JGitUtils.getByteContent(repository, tree, issuePath + "/" + filename);

+		attachment.content = content;

+		attachment.size = content.length;

+		return attachment;

+	}

+

+	/**

+	 * Stores an issue in the gb-issues branch of the repository. The branch is

+	 * automatically created if it does not already exist.

+	 * 

+	 * @param repository

+	 * @param change

+	 * @return true if successful

+	 */

+	public static IssueModel createIssue(Repository repository, Change change) {

+		RefModel issuesBranch = getIssuesBranch(repository);

+		if (issuesBranch == null) {

+			JGitUtils.createOrphanBranch(repository, "gb-issues", null);

+		}

+		change.created = new Date();

+

+		IssueModel issue = new IssueModel();

+		issue.created = change.created;

+		issue.summary = change.getString(Field.Summary);

+		issue.description = change.getString(Field.Description);

+		issue.reporter = change.getString(Field.Reporter);

+

+		if (StringUtils.isEmpty(issue.summary)) {

+			throw new RuntimeException("Must specify an issue summary!");

+		}

+		if (StringUtils.isEmpty(change.getString(Field.Description))) {

+			throw new RuntimeException("Must specify an issue description!");

+		}

+		if (StringUtils.isEmpty(change.getString(Field.Reporter))) {

+			throw new RuntimeException("Must specify an issue reporter!");

+		}

+

+		issue.id = StringUtils.getSHA1(issue.created.toString() + issue.reporter + issue.summary

+				+ issue.description);

+

+		String message = createChangelog('+', issue.id, change);

+		boolean success = commit(repository, issue, change, message);

+		if (success) {

+			return issue;

+		}

+		return null;

+	}

+

+	/**

+	 * Updates an issue in the gb-issues branch of the repository.

+	 * 

+	 * @param repository

+	 * @param issue

+	 * @param change

+	 * @return true if successful

+	 */

+	public static boolean updateIssue(Repository repository, String issueId, Change change) {

+		boolean success = false;

+		RefModel issuesBranch = getIssuesBranch(repository);

+

+		if (issuesBranch == null) {

+			throw new RuntimeException("gb-issues branch does not exist!");

+		}

+

+		if (change == null) {

+			throw new RuntimeException("change can not be null!");

+		}

+

+		if (StringUtils.isEmpty(change.author)) {

+			throw new RuntimeException("must specify change.author!");

+		}

+

+		IssueModel issue = getIssue(repository, issueId);

+		change.created = new Date();

+

+		String message = createChangelog('=', issueId, change);

+		success = commit(repository, issue, change, message);

+		return success;

+	}

+

+	private static String createChangelog(char type, String issueId, Change change) {

+		return type + " " + issueId + "\n\n" + toJson(change);

+	}

+

+	/**

+	 * 

+	 * @param repository

+	 * @param issue

+	 * @param change

+	 * @param changelog

+	 * @return

+	 */

+	private static boolean commit(Repository repository, IssueModel issue, Change change,

+			String changelog) {

+		boolean success = false;

+		String issuePath = getIssuePath(issue.id);

+		try {

+			issue.addChange(change);

+

+			// serialize the issue as json

+			String json = toJson(issue);

+

+			// cache the issue "files" in a map

+			Map<String, CommitFile> files = new HashMap<String, CommitFile>();

+			CommitFile issueFile = new CommitFile(issuePath + "/issue.json", change.created);

+			issueFile.content = json.getBytes(Constants.CHARACTER_ENCODING);

+			files.put(issueFile.path, issueFile);

+

+			if (change.hasAttachments()) {

+				for (Attachment attachment : change.attachments) {

+					if (!ArrayUtils.isEmpty(attachment.content)) {

+						CommitFile file = new CommitFile(issuePath + "/" + attachment.name,

+								change.created);

+						file.content = attachment.content;

+						files.put(file.path, file);

+					}

+				}

+			}

+

+			ObjectId headId = repository.resolve(GB_ISSUES + "^{commit}");

+

+			ObjectInserter odi = repository.newObjectInserter();

+			try {

+				// Create the in-memory index of the new/updated issue.

+				DirCache index = createIndex(repository, headId, files);

+				ObjectId indexTreeId = index.writeTree(odi);

+

+				// Create a commit object

+				PersonIdent author = new PersonIdent(issue.reporter, issue.reporter + "@gitblit");

+				CommitBuilder commit = new CommitBuilder();

+				commit.setAuthor(author);

+				commit.setCommitter(author);

+				commit.setEncoding(Constants.CHARACTER_ENCODING);

+				commit.setMessage(changelog);

+				commit.setParentId(headId);

+				commit.setTreeId(indexTreeId);

+

+				// Insert the commit into the repository

+				ObjectId commitId = odi.insert(commit);

+				odi.flush();

+

+				RevWalk revWalk = new RevWalk(repository);

+				try {

+					RevCommit revCommit = revWalk.parseCommit(commitId);

+					RefUpdate ru = repository.updateRef(GB_ISSUES);

+					ru.setNewObjectId(commitId);

+					ru.setExpectedOldObjectId(headId);

+					ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);

+					Result rc = ru.forceUpdate();

+					switch (rc) {

+					case NEW:

+					case FORCED:

+					case FAST_FORWARD:

+						success = true;

+						break;

+					case REJECTED:

+					case LOCK_FAILURE:

+						throw new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD,

+								ru.getRef(), rc);

+					default:

+						throw new JGitInternalException(MessageFormat.format(

+								JGitText.get().updatingRefFailed, GB_ISSUES, commitId.toString(),

+								rc));

+					}

+				} finally {

+					revWalk.release();

+				}

+			} finally {

+				odi.release();

+			}

+		} catch (Throwable t) {

+			t.printStackTrace();

+		}

+		return success;

+	}

+

+	private static String toJson(Object o) {

+		try {

+			// exclude the attachment content field from json serialization

+			Gson gson = JsonUtils.gson(new ExcludeField(

+					"com.gitblit.models.IssueModel$Attachment.content"));

+			String json = gson.toJson(o);

+			return json;

+		} catch (Throwable t) {

+			throw new RuntimeException(t);

+		}

+	}

+

+	/**

+	 * Returns the issue path. This follows the same scheme as Git's object

+	 * store path where the first two characters of the hash id are the root

+	 * folder with the remaining characters as a subfolder within that folder.

+	 * 

+	 * @param issueId

+	 * @return the root path of the issue content on the gb-issues branch

+	 */

+	private static String getIssuePath(String issueId) {

+		return issueId.substring(0, 2) + "/" + issueId.substring(2);

+	}

+

+	/**

+	 * Creates an in-memory index of the issue change.

+	 * 

+	 * @param repo

+	 * @param headId

+	 * @param files

+	 * @param time

+	 * @return an in-memory index

+	 * @throws IOException

+	 */

+	private static DirCache createIndex(Repository repo, ObjectId headId,

+			Map<String, CommitFile> files) throws IOException {

+

+		DirCache inCoreIndex = DirCache.newInCore();

+		DirCacheBuilder dcBuilder = inCoreIndex.builder();

+		ObjectInserter inserter = repo.newObjectInserter();

+

+		try {

+			// Add the issue files to the temporary index

+			for (CommitFile file : files.values()) {

+				// create an index entry for the file

+				final DirCacheEntry dcEntry = new DirCacheEntry(file.path);

+				dcEntry.setLength(file.content.length);

+				dcEntry.setLastModified(file.time);

+				dcEntry.setFileMode(FileMode.REGULAR_FILE);

+

+				// insert object

+				dcEntry.setObjectId(inserter.insert(Constants.OBJ_BLOB, file.content));

+

+				// add to temporary in-core index

+				dcBuilder.add(dcEntry);

+			}

+

+			// Traverse HEAD to add all other paths

+			TreeWalk treeWalk = new TreeWalk(repo);

+			int hIdx = -1;

+			if (headId != null)

+				hIdx = treeWalk.addTree(new RevWalk(repo).parseTree(headId));

+			treeWalk.setRecursive(true);

+

+			while (treeWalk.next()) {

+				String path = treeWalk.getPathString();

+				CanonicalTreeParser hTree = null;

+				if (hIdx != -1)

+					hTree = treeWalk.getTree(hIdx, CanonicalTreeParser.class);

+				if (!files.containsKey(path)) {

+					// add entries from HEAD for all other paths

+					if (hTree != null) {

+						// create a new DirCacheEntry with data retrieved from

+						// HEAD

+						final DirCacheEntry dcEntry = new DirCacheEntry(path);

+						dcEntry.setObjectId(hTree.getEntryObjectId());

+						dcEntry.setFileMode(hTree.getEntryFileMode());

+

+						// add to temporary in-core index

+						dcBuilder.add(dcEntry);

+					}

+				}

+			}

+

+			// release the treewalk

+			treeWalk.release();

+

+			// finish temporary in-core index used for this commit

+			dcBuilder.finish();

+		} finally {

+			inserter.release();

+		}

+		return inCoreIndex;

+	}

+

+	private static class CommitFile {

+		String path;

+		long time;

+		byte[] content;

+

+		CommitFile(String path, Date date) {

+			this.path = path;

+			this.time = date.getTime();

+		}

+	}

+

+	public static interface IssueFilter {

+		public abstract boolean accept(IssueModel issue);

+	}

+}