/*
* 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.DateFormat;
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.List;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
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.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.RefRename;
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.Constants;
import com.gitblit.models.DailyLogEntry;
import com.gitblit.models.PathModel.PathChangeModel;
import com.gitblit.models.RefLogEntry;
import com.gitblit.models.RefModel;
import com.gitblit.models.RepositoryCommit;
import com.gitblit.models.UserModel;
/**
* Utility class for maintaining a reflog within a git repository on an
* orphan branch.
*
* @author James Moger
*
*/
public class RefLogUtils {
private static final String GB_REFLOG = "refs/meta/gitblit/reflog";
private static final Logger LOGGER = LoggerFactory.getLogger(RefLogUtils.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 true if the repository has a reflog branch.
*
* @param repository
* @return true if the repository has a reflog branch
*/
public static boolean hasRefLogBranch(Repository repository) {
try {
return repository.getRef(GB_REFLOG) != null;
} catch(Exception e) {
LOGGER.error("failed to determine hasRefLogBranch", e);
}
return false;
}
/**
* Returns a RefModel for the reflog branch in the repository. If the
* branch can not be found, null is returned.
*
* @param repository
* @return a refmodel for the reflog branch or null
*/
public static RefModel getRefLogBranch(Repository repository) {
List<RefModel> refs = JGitUtils.getRefs(repository, "refs/");
Ref oldRef = null;
for (RefModel ref : refs) {
if (ref.reference.getName().equals(GB_REFLOG)) {
return ref;
} else if (ref.reference.getName().equals("refs/gitblit/reflog")) {
oldRef = ref.reference;
} else if (ref.reference.getName().equals("refs/gitblit/pushes")) {
oldRef = ref.reference;
}
}
if (oldRef != null) {
// rename old ref to refs/meta/gitblit/reflog
RefRename cmd;
try {
cmd = repository.renameRef(oldRef.getName(), GB_REFLOG);
cmd.setRefLogIdent(new PersonIdent("Gitblit", "gitblit@localhost"));
cmd.setRefLogMessage("renamed " + oldRef.getName() + " => " + GB_REFLOG);
Result res = cmd.rename();
switch (res) {
case RENAMED:
LOGGER.info(repository.getDirectory() + " " + cmd.getRefLogMessage());
return getRefLogBranch(repository);
default:
LOGGER.error("failed to rename " + oldRef.getName() + " => " + GB_REFLOG + " (" + res.name() + ")");
}
} catch (IOException e) {
LOGGER.error("failed to rename reflog", e);
}
}
return null;
}
private static UserModel newUserModelFrom(PersonIdent ident) {
String name = ident.getName();
String username;
String displayname;
if (name.indexOf('/') > -1) {
int slash = name.indexOf('/');
displayname = name.substring(0, slash);
username = name.substring(slash + 1);
} else {
displayname = name;
username = ident.getEmailAddress();
}
UserModel user = new UserModel(username);
user.displayName = displayname;
user.emailAddress = ident.getEmailAddress();
return user;
}
/**
* Logs a ref deletion.
*
* @param user
* @param repository
* @param ref
* @return true, if the update was successful
*/
public static boolean deleteRef(UserModel user, Repository repository, Ref ref) {
try {
if (ref == null) {
return false;
}
RefModel reflogBranch = getRefLogBranch(repository);
if (reflogBranch == null) {
return false;
}
List<RevCommit> log = JGitUtils.getRevLog(repository, reflogBranch.getName(), ref.getName(), 0, 1);
if (log.isEmpty()) {
// this ref is not in the reflog branch
return false;
}
ReceiveCommand cmd = new ReceiveCommand(ref.getObjectId(), ObjectId.zeroId(), ref.getName());
return updateRefLog(user, repository, Arrays.asList(cmd));
} catch (Throwable t) {
error(t, repository, "Failed to commit reflog entry to {0}");
}
return false;
}
/**
* Updates the reflog with the received commands.
*
* @param user
* @param repository
* @param commands
* @return true, if the update was successful
*/
public static boolean updateRefLog(UserModel user, Repository repository,
Collection<ReceiveCommand> commands) {
// only track branches and tags
List<ReceiveCommand> filteredCommands = new ArrayList<ReceiveCommand>();
for (ReceiveCommand cmd : commands) {
if (!cmd.getRefName().startsWith(Constants.R_HEADS)
&& !cmd.getRefName().startsWith(Constants.R_TAGS)) {
continue;
}
filteredCommands.add(cmd);
}
if (filteredCommands.isEmpty()) {
// nothing to log
return true;
}
RefModel reflogBranch = getRefLogBranch(repository);
if (reflogBranch == null) {
JGitUtils.createOrphanBranch(repository, GB_REFLOG, null);
}
boolean success = false;
String message = "push";
try {
ObjectId headId = repository.resolve(GB_REFLOG + "^{commit}");
ObjectInserter odi = repository.newObjectInserter();
try {
// Create the in-memory index of the reflog log entry
DirCache index = createIndex(repository, headId, commands);
ObjectId indexTreeId = index.writeTree(odi);
PersonIdent ident;
if (UserModel.ANONYMOUS.equals(user)) {
// anonymous push
ident = new PersonIdent(user.username + "/" + user.username, user.username);
} else {
// construct real pushing account
ident = new PersonIdent(MessageFormat.format("{0}/{1}", user.getDisplayName(), user.username),
user.emailAddress == null ? user.username : user.emailAddress);
}
// Create a commit object
CommitBuilder commit = new CommitBuilder();
commit.setAuthor(ident);
commit.setCommitter(ident);
commit.setEncoding(Constants.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_REFLOG);
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_REFLOG, commitId.toString(),
rc));
}
} finally {
revWalk.release();
}
} finally {
odi.release();
}
} catch (Throwable t) {
error(t, repository, "Failed to commit reflog entry to {0}");
}
return success;
}
/**
* Creates an in-memory index of the reflog 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(org.eclipse.jgit.lib.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<RefLogEntry> getRefLog(String repositoryName, Repository repository) {
return getRefLog(repositoryName, repository, null, 0, -1);
}
public static List<RefLogEntry> getRefLog(String repositoryName, Repository repository, int maxCount) {
return getRefLog(repositoryName, repository, null, 0, maxCount);
}
public static List<RefLogEntry> getRefLog(String repositoryName, Repository repository, int offset, int maxCount) {
return getRefLog(repositoryName, repository, null, offset, maxCount);
}
public static List<RefLogEntry> getRefLog(String repositoryName, Repository repository, Date minimumDate) {
return getRefLog(repositoryName, repository, minimumDate, 0, -1);
}
/**
* Returns the list of reflog entries as they were recorded by Gitblit.
* Each RefLogEntry may represent multiple ref updates.
*
* @param repositoryName
* @param repository
* @param minimumDate
* @param offset
* @param maxCount
* if < 0, all entries are returned.
* @return a list of reflog entries
*/
public static List<RefLogEntry> getRefLog(String repositoryName, Repository repository,
Date minimumDate, int offset, int maxCount) {
List<RefLogEntry> list = new ArrayList<RefLogEntry>();
RefModel ref = getRefLogBranch(repository);
if (ref == null) {
return list;
}
if (maxCount == 0) {
return list;
}
Map<ObjectId, List<RefModel>> allRefs = JGitUtils.getAllRefs(repository);
List<RevCommit> pushes;
if (minimumDate == null) {
pushes = JGitUtils.getRevLog(repository, GB_REFLOG, offset, maxCount);
} else {
pushes = JGitUtils.getRevLog(repository, GB_REFLOG, minimumDate);
}
for (RevCommit push : pushes) {
if (push.getAuthorIdent().getName().equalsIgnoreCase("gitblit")) {
// skip gitblit/internal commits
continue;
}
UserModel user = newUserModelFrom(push.getAuthorIdent());
Date date = push.getAuthorIdent().getWhen();
RefLogEntry log = new RefLogEntry(repositoryName, date, user);
// only report HEADS and TAGS for now
List<PathChangeModel> changedRefs = new ArrayList<PathChangeModel>();
for (PathChangeModel refChange : JGitUtils.getFilesInCommit(repository, push)) {
if (refChange.path.startsWith(Constants.R_HEADS)
|| refChange.path.startsWith(Constants.R_TAGS)) {
changedRefs.add(refChange);
}
}
if (changedRefs.isEmpty()) {
// skip empty commits
continue;
}
list.add(log);
for (PathChangeModel change : changedRefs) {
switch (change.changeType) {
case DELETE:
log.updateRef(change.path, ReceiveCommand.Type.DELETE);
break;
default:
String content = JGitUtils.getStringContent(repository, push.getTree(), change.path);
String [] fields = content.split(" ");
String oldId = fields[1];
String newId = fields[2];
log.updateRef(change.path, ReceiveCommand.Type.valueOf(fields[0]), oldId, newId);
if (ObjectId.zeroId().getName().equals(newId)) {
// ref deletion
continue;
}
try {
List<RevCommit> pushedCommits = JGitUtils.getRevLog(repository, oldId, newId);
for (RevCommit pushedCommit : pushedCommits) {
RepositoryCommit repoCommit = log.addCommit(change.path, pushedCommit);
if (repoCommit != null) {
repoCommit.setRefs(allRefs.get(pushedCommit.getId()));
}
}
} catch (Exception e) {
}
}
}
}
Collections.sort(list);
return list;
}
/**
* Returns the list of entries organized by ref (e.g. each ref has it's own
* RefLogEntry object).
*
* @param repositoryName
* @param repository
* @param maxCount
* @return a list of reflog entries separated by ref
*/
public static List<RefLogEntry> getLogByRef(String repositoryName, Repository repository, int maxCount) {
return getLogByRef(repositoryName, repository, 0, maxCount);
}
/**
* Returns the list of entries organized by ref (e.g. each ref has it's own
* RefLogEntry object).
*
* @param repositoryName
* @param repository
* @param offset
* @param maxCount
* @return a list of reflog entries separated by ref
*/
public static List<RefLogEntry> getLogByRef(String repositoryName, Repository repository, int offset,
int maxCount) {
// break the reflog into ref entries and then merge them back into a list
Map<String, List<RefLogEntry>> refMap = new HashMap<String, List<RefLogEntry>>();
List<RefLogEntry> refLog = getRefLog(repositoryName, repository, offset, maxCount);
for (RefLogEntry entry : refLog) {
for (String ref : entry.getChangedRefs()) {
if (!refMap.containsKey(ref)) {
refMap.put(ref, new ArrayList<RefLogEntry>());
}
// construct new ref-specific ref change entry
RefLogEntry refChange;
if (entry instanceof DailyLogEntry) {
// simulated reflog from commits grouped by date
refChange = new DailyLogEntry(entry.repository, entry.date);
} else {
// real reflog entry
refChange = new RefLogEntry(entry.repository, entry.date, entry.user);
}
refChange.updateRef(ref, entry.getChangeType(ref), entry.getOldId(ref), entry.getNewId(ref));
refChange.addCommits(entry.getCommits(ref));
refMap.get(ref).add(refChange);
}
}
// merge individual ref changes into master list
List<RefLogEntry> mergedRefLog = new ArrayList<RefLogEntry>();
for (List<RefLogEntry> refPush : refMap.values()) {
mergedRefLog.addAll(refPush);
}
// sort ref log
Collections.sort(mergedRefLog);
return mergedRefLog;
}
/**
* Returns the list of ref changes separated by ref (e.g. each ref has it's own
* RefLogEntry object).
*
* @param repositoryName
* @param repository
* @param minimumDate
* @return a list of ref log entries separated by ref
*/
public static List<RefLogEntry> getLogByRef(String repositoryName, Repository repository, Date minimumDate) {
// break the reflog into refs and then merge them back into a list
Map<String, List<RefLogEntry>> refMap = new HashMap<String, List<RefLogEntry>>();
List<RefLogEntry> entries = getRefLog(repositoryName, repository, minimumDate);
for (RefLogEntry entry : entries) {
for (String ref : entry.getChangedRefs()) {
if (!refMap.containsKey(ref)) {
refMap.put(ref, new ArrayList<RefLogEntry>());
}
// construct new ref-specific log entry
RefLogEntry refPush = new RefLogEntry(entry.repository, entry.date, entry.user);
refPush.updateRef(ref, entry.getChangeType(ref), entry.getOldId(ref), entry.getNewId(ref));
refPush.addCommits(entry.getCommits(ref));
refMap.get(ref).add(refPush);
}
}
// merge individual ref entries into master list
List<RefLogEntry> refLog = new ArrayList<RefLogEntry>();
for (List<RefLogEntry> entry : refMap.values()) {
refLog.addAll(entry);
}
Collections.sort(refLog);
return refLog;
}
/**
* Returns a commit log grouped by day.
*
* @param repositoryName
* @param repository
* @param minimumDate
* @param offset
* @param maxCount
* if < 0, all entries are returned.
* @param the timezone to use when aggregating commits by date
* @return a list of grouped commit log entries
*/
public static List<DailyLogEntry> getDailyLog(String repositoryName, Repository repository,
Date minimumDate, int offset, int maxCount,
TimeZone timezone) {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
df.setTimeZone(timezone);
Map<ObjectId, List<RefModel>> allRefs = JGitUtils.getAllRefs(repository);
Map<String, DailyLogEntry> tags = new HashMap<String, DailyLogEntry>();
Map<String, DailyLogEntry> pulls = new HashMap<String, DailyLogEntry>();
Map<String, DailyLogEntry> dailydigests = new HashMap<String, DailyLogEntry>();
String linearParent = null;
for (RefModel local : JGitUtils.getLocalBranches(repository, true, -1)) {
if (!local.getDate().after(minimumDate)) {
// branch not recently updated
continue;
}
String branch = local.getName();
List<RepositoryCommit> commits = CommitCache.instance().getCommits(repositoryName, repository, branch, minimumDate);
linearParent = null;
for (RepositoryCommit commit : commits) {
if (linearParent != null) {
if (!commit.getName().equals(linearParent)) {
// only follow linear branch commits
continue;
}
}
Date date = commit.getCommitDate();
String dateStr = df.format(date);
if (!dailydigests.containsKey(dateStr)) {
dailydigests.put(dateStr, new DailyLogEntry(repositoryName, date));
}
DailyLogEntry digest = dailydigests.get(dateStr);
if (commit.getParentCount() == 0) {
linearParent = null;
digest.updateRef(branch, ReceiveCommand.Type.CREATE);
} else {
linearParent = commit.getParents()[0].getId().getName();
digest.updateRef(branch, ReceiveCommand.Type.UPDATE, linearParent, commit.getName());
}
RepositoryCommit repoCommit = digest.addCommit(commit);
if (repoCommit != null) {
List<RefModel> matchedRefs = allRefs.get(commit.getId());
repoCommit.setRefs(matchedRefs);
if (!ArrayUtils.isEmpty(matchedRefs)) {
for (RefModel ref : matchedRefs) {
if (ref.getName().startsWith(Constants.R_TAGS)) {
// treat tags as special events in the log
if (!tags.containsKey(dateStr)) {
UserModel tagUser = newUserModelFrom(ref.getAuthorIdent());
Date tagDate = commit.getAuthorIdent().getWhen();
tags.put(dateStr, new DailyLogEntry(repositoryName, tagDate, tagUser));
}
RefLogEntry tagEntry = tags.get(dateStr);
tagEntry.updateRef(ref.getName(), ReceiveCommand.Type.CREATE);
RepositoryCommit rc = repoCommit.clone(ref.getName());
tagEntry.addCommit(rc);
} else if (ref.getName().startsWith(Constants.R_PULL)) {
// treat pull requests as special events in the log
if (!pulls.containsKey(dateStr)) {
UserModel commitUser = newUserModelFrom(ref.getAuthorIdent());
Date commitDate = commit.getAuthorIdent().getWhen();
pulls.put(dateStr, new DailyLogEntry(repositoryName, commitDate, commitUser));
}
RefLogEntry pullEntry = pulls.get(dateStr);
pullEntry.updateRef(ref.getName(), ReceiveCommand.Type.CREATE);
RepositoryCommit rc = repoCommit.clone(ref.getName());
pullEntry.addCommit(rc);
}
}
}
}
}
}
List<DailyLogEntry> list = new ArrayList<DailyLogEntry>(dailydigests.values());
list.addAll(tags.values());
//list.addAll(pulls.values());
Collections.sort(list);
return list;
}
/**
* Returns the list of commits separated by ref (e.g. each ref has it's own
* RefLogEntry object for each day).
*
* @param repositoryName
* @param repository
* @param minimumDate
* @param the timezone to use when aggregating commits by date
* @return a list of push log entries separated by ref and date
*/
public static List<DailyLogEntry> getDailyLogByRef(String repositoryName, Repository repository,
Date minimumDate, TimeZone timezone) {
// break the reflog into ref entries and then merge them back into a list
Map<String, List<DailyLogEntry>> refMap = new HashMap<String, List<DailyLogEntry>>();
List<DailyLogEntry> entries = getDailyLog(repositoryName, repository, minimumDate, 0, -1, timezone);
for (DailyLogEntry entry : entries) {
for (String ref : entry.getChangedRefs()) {
if (!refMap.containsKey(ref)) {
refMap.put(ref, new ArrayList<DailyLogEntry>());
}
// construct new ref-specific log entry
DailyLogEntry refEntry = new DailyLogEntry(entry.repository, entry.date, entry.user);
refEntry.updateRef(ref, entry.getChangeType(ref), entry.getOldId(ref), entry.getNewId(ref));
refEntry.addCommits(entry.getCommits(ref));
refMap.get(ref).add(refEntry);
}
}
// merge individual ref entries into master list
List<DailyLogEntry> refLog = new ArrayList<DailyLogEntry>();
for (List<DailyLogEntry> refEntry : refMap.values()) {
for (DailyLogEntry entry : refEntry) {
if (entry.getCommitCount() > 0) {
refLog.add(entry);
}
}
}
Collections.sort(refLog);
return refLog;
}
}