/*
|
* 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);
|
}
|
}
|
