Java tutorial
/* * Copyright 2013 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.Collection; import java.util.Collections; import java.util.Date; import java.util.List; import java.util.Set; import java.util.TreeSet; 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.internal.JGitText; 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.RevWalk; import org.eclipse.jgit.transport.ReceiveCommand; import org.eclipse.jgit.treewalk.CanonicalTreeParser; import org.eclipse.jgit.treewalk.TreeWalk; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.gitblit.models.PathModel.PathChangeModel; import com.gitblit.models.PushLogEntry; import com.gitblit.models.RefModel; import com.gitblit.models.UserModel; /** * Utility class for maintaining a pushlog within a git repository on an * orphan branch. * * @author James Moger * */ public class PushLogUtils { public static final String GB_PUSHES = "refs/gitblit/pushes"; static final Logger LOGGER = LoggerFactory.getLogger(PushLogUtils.class); /** * Log an error message and exception. * * @param t * @param repository * if repository is not null it MUST be the {0} parameter in the * pattern. * @param pattern * @param objects */ private static void error(Throwable t, Repository repository, String pattern, Object... objects) { List<Object> parameters = new ArrayList<Object>(); if (objects != null && objects.length > 0) { for (Object o : objects) { parameters.add(o); } } if (repository != null) { parameters.add(0, repository.getDirectory().getAbsolutePath()); } LOGGER.error(MessageFormat.format(pattern, parameters.toArray()), t); } /** * Returns a RefModel for the gb-pushes branch in the repository. If the * branch can not be found, null is returned. * * @param repository * @return a refmodel for the gb-pushes branch or null */ public static RefModel getPushLogBranch(Repository repository) { List<RefModel> refs = JGitUtils.getRefs(repository, com.gitblit.Constants.R_GITBLIT); for (RefModel ref : refs) { if (ref.reference.getName().equals(GB_PUSHES)) { return ref; } } return null; } /** * Updates a push log. * * @param user * @param repository * @param commands * @return true, if the update was successful */ public static boolean updatePushLog(UserModel user, Repository repository, Collection<ReceiveCommand> commands) { RefModel pushlogBranch = getPushLogBranch(repository); if (pushlogBranch == null) { JGitUtils.createOrphanBranch(repository, GB_PUSHES, null); } boolean success = false; String message = "push"; try { ObjectId headId = repository.resolve(GB_PUSHES + "^{commit}"); ObjectInserter odi = repository.newObjectInserter(); try { // Create the in-memory index of the push log entry DirCache index = createIndex(repository, headId, commands); ObjectId indexTreeId = index.writeTree(odi); PersonIdent ident = new PersonIdent(user.getDisplayName(), user.emailAddress == null ? user.username : user.emailAddress); // Create a commit object CommitBuilder commit = new CommitBuilder(); commit.setAuthor(ident); commit.setCommitter(ident); commit.setEncoding(Constants.CHARACTER_ENCODING); commit.setMessage(message); 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_PUSHES); 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_PUSHES, commitId.toString(), rc)); } } finally { revWalk.release(); } } finally { odi.release(); } } catch (Throwable t) { error(t, repository, "Failed to commit pushlog entry to {0}"); } return success; } /** * Creates an in-memory index of the push log entry. * * @param repo * @param headId * @param commands * @return an in-memory index * @throws IOException */ private static DirCache createIndex(Repository repo, ObjectId headId, Collection<ReceiveCommand> commands) throws IOException { DirCache inCoreIndex = DirCache.newInCore(); DirCacheBuilder dcBuilder = inCoreIndex.builder(); ObjectInserter inserter = repo.newObjectInserter(); long now = System.currentTimeMillis(); Set<String> ignorePaths = new TreeSet<String>(); try { // add receive commands to the temporary index for (ReceiveCommand command : commands) { // use the ref names as the path names String path = command.getRefName(); ignorePaths.add(path); StringBuilder change = new StringBuilder(); change.append(command.getType().name()).append(' '); switch (command.getType()) { case CREATE: change.append(ObjectId.zeroId().getName()); change.append(' '); change.append(command.getNewId().getName()); break; case UPDATE: case UPDATE_NONFASTFORWARD: change.append(command.getOldId().getName()); change.append(' '); change.append(command.getNewId().getName()); break; case DELETE: change = null; break; } if (change == null) { // ref deleted continue; } String content = change.toString(); // create an index entry for this attachment final DirCacheEntry dcEntry = new DirCacheEntry(path); dcEntry.setLength(content.length()); dcEntry.setLastModified(now); dcEntry.setFileMode(FileMode.REGULAR_FILE); // insert object dcEntry.setObjectId(inserter.insert(Constants.OBJ_BLOB, content.getBytes("UTF-8"))); // 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 (!ignorePaths.contains(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; } public static List<PushLogEntry> getPushLog(String repositoryName, Repository repository) { return getPushLog(repositoryName, repository, null, -1); } public static List<PushLogEntry> getPushLog(String repositoryName, Repository repository, int maxCount) { return getPushLog(repositoryName, repository, null, maxCount); } public static List<PushLogEntry> getPushLog(String repositoryName, Repository repository, Date minimumDate) { return getPushLog(repositoryName, repository, minimumDate, -1); } public static List<PushLogEntry> getPushLog(String repositoryName, Repository repository, Date minimumDate, int maxCount) { List<PushLogEntry> list = new ArrayList<PushLogEntry>(); RefModel ref = getPushLogBranch(repository); if (ref == null) { return list; } List<RevCommit> pushes; if (minimumDate == null) { pushes = JGitUtils.getRevLog(repository, GB_PUSHES, 0, maxCount); } else { pushes = JGitUtils.getRevLog(repository, GB_PUSHES, minimumDate); } for (RevCommit push : pushes) { if (push.getAuthorIdent().getName().equalsIgnoreCase("gitblit")) { // skip gitblit/internal commits continue; } Date date = push.getAuthorIdent().getWhen(); UserModel user = new UserModel(push.getAuthorIdent().getEmailAddress()); user.displayName = push.getAuthorIdent().getName(); PushLogEntry log = new PushLogEntry(repositoryName, date, user); list.add(log); List<PathChangeModel> changedRefs = JGitUtils.getFilesInCommit(repository, push); for (PathChangeModel change : changedRefs) { switch (change.changeType) { case DELETE: log.updateRef(change.path, ReceiveCommand.Type.DELETE); break; case ADD: log.updateRef(change.path, ReceiveCommand.Type.CREATE); default: String content = JGitUtils.getStringContent(repository, push.getTree(), change.path); String[] fields = content.split(" "); log.updateRef(change.path, ReceiveCommand.Type.valueOf(fields[0])); String oldId = fields[1]; String newId = fields[2]; List<RevCommit> pushedCommits = JGitUtils.getRevLog(repository, oldId, newId); for (RevCommit pushedCommit : pushedCommits) { log.addCommit(change.path, pushedCommit); } } } } Collections.sort(list); return list; } }