| | |
|---|
| | | import java.util.List;
|
|---|
| | | import java.util.Map;
|
|---|
| | | import java.util.Map.Entry;
|
|---|
| | | import java.util.regex.Matcher;
|
|---|
| | | import java.util.regex.Pattern;
|
|---|
| | |
|
|---|
| | | import org.apache.commons.io.filefilter.TrueFileFilter;
|
|---|
| | |
|---|
| | | import org.eclipse.jgit.diff.RawTextComparator;
|
|---|
| | | import org.eclipse.jgit.errors.ConfigInvalidException;
|
|---|
| | | import org.eclipse.jgit.errors.IncorrectObjectTypeException;
|
|---|
| | | import org.eclipse.jgit.errors.LargeObjectException;
|
|---|
| | | import org.eclipse.jgit.errors.MissingObjectException;
|
|---|
| | | import org.eclipse.jgit.errors.StopWalkException;
|
|---|
| | | import org.eclipse.jgit.lib.BlobBasedConfig;
|
|---|
| | |
|---|
| | | import org.eclipse.jgit.lib.RepositoryCache.FileKey;
|
|---|
| | | import org.eclipse.jgit.lib.StoredConfig;
|
|---|
| | | import org.eclipse.jgit.lib.TreeFormatter;
|
|---|
| | | import org.eclipse.jgit.merge.MergeStrategy;
|
|---|
| | | import org.eclipse.jgit.merge.RecursiveMerger;
|
|---|
| | | import org.eclipse.jgit.revwalk.RevBlob;
|
|---|
| | | import org.eclipse.jgit.revwalk.RevCommit;
|
|---|
| | | import org.eclipse.jgit.revwalk.RevObject;
|
|---|
| | |
|---|
| | | import org.slf4j.Logger;
|
|---|
| | | import org.slf4j.LoggerFactory;
|
|---|
| | |
|
|---|
| | | import com.gitblit.GitBlit;
|
|---|
| | | import com.gitblit.GitBlitException;
|
|---|
| | | import com.gitblit.manager.GitblitManager;
|
|---|
| | | import com.gitblit.models.FilestoreModel;
|
|---|
| | | import com.gitblit.models.GitNote;
|
|---|
| | | import com.gitblit.models.PathModel;
|
|---|
| | | import com.gitblit.models.PathModel.PathChangeModel;
|
|---|
| | | import com.gitblit.models.RefModel;
|
|---|
| | | import com.gitblit.models.SubmoduleModel;
|
|---|
| | | import com.gitblit.servlet.FilestoreServlet;
|
|---|
| | | import com.google.common.base.Strings;
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Collection of static methods for retrieving information from a repository.
|
|---|
| | |
|---|
| | | if (commit == null) {
|
|---|
| | | return new Date(0);
|
|---|
| | | }
|
|---|
| | | return commit.getAuthorIdent().getWhen();
|
|---|
| | | if (commit.getAuthorIdent() != null) {
|
|---|
| | | return commit.getAuthorIdent().getWhen();
|
|---|
| | | }
|
|---|
| | | return getCommitDate(commit);
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | |
|---|
| | | try {
|
|---|
| | | // resolve object id
|
|---|
| | | ObjectId branchObject;
|
|---|
| | | if (StringUtils.isEmpty(objectId)) {
|
|---|
| | | if (StringUtils.isEmpty(objectId) || "HEAD".equalsIgnoreCase(objectId)) {
|
|---|
| | | branchObject = getDefaultBranch(repository);
|
|---|
| | | } else {
|
|---|
| | | branchObject = repository.resolve(objectId);
|
|---|
| | |
|---|
| | | }
|
|---|
| | | } finally {
|
|---|
| | | rw.dispose();
|
|---|
| | | tw.release();
|
|---|
| | | tw.close();
|
|---|
| | | }
|
|---|
| | | return content;
|
|---|
| | | }
|
|---|
| | |
|---|
| | | } catch (IOException e) {
|
|---|
| | | error(e, repository, "{0} failed to get files for commit {1}", commit.getName());
|
|---|
| | | } finally {
|
|---|
| | | tw.release();
|
|---|
| | | tw.close();
|
|---|
| | | }
|
|---|
| | | Collections.sort(list);
|
|---|
| | | return list;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Returns the list of files in the specified folder at the specified
|
|---|
| | | * commit. If the repository does not exist or is empty, an empty list is
|
|---|
| | | * returned.
|
|---|
| | | *
|
|---|
| | | * This is modified version that implements path compression feature.
|
|---|
| | | *
|
|---|
| | | * @param repository
|
|---|
| | | * @param path
|
|---|
| | | * if unspecified, root folder is assumed.
|
|---|
| | | * @param commit
|
|---|
| | | * if null, HEAD is assumed.
|
|---|
| | | * @return list of files in specified path
|
|---|
| | | */
|
|---|
| | | public static List<PathModel> getFilesInPath2(Repository repository, String path, RevCommit commit) {
|
|---|
| | |
|
|---|
| | | List<PathModel> list = new ArrayList<PathModel>();
|
|---|
| | | if (!hasCommits(repository)) {
|
|---|
| | | return list;
|
|---|
| | | }
|
|---|
| | | if (commit == null) {
|
|---|
| | | commit = getCommit(repository, null);
|
|---|
| | | }
|
|---|
| | | final TreeWalk tw = new TreeWalk(repository);
|
|---|
| | | try {
|
|---|
| | |
|
|---|
| | | tw.addTree(commit.getTree());
|
|---|
| | | final boolean isPathEmpty = Strings.isNullOrEmpty(path);
|
|---|
| | |
|
|---|
| | | if (!isPathEmpty) {
|
|---|
| | | PathFilter f = PathFilter.create(path);
|
|---|
| | | tw.setFilter(f);
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | tw.setRecursive(true);
|
|---|
| | | List<String> paths = new ArrayList<>();
|
|---|
| | |
|
|---|
| | | while (tw.next()) {
|
|---|
| | | String child = isPathEmpty ? tw.getPathString()
|
|---|
| | | : tw.getPathString().replaceFirst(String.format("%s/", path), "");
|
|---|
| | | paths.add(child);
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | for(String p: PathUtils.compressPaths(paths)) {
|
|---|
| | | String pathString = isPathEmpty ? p : String.format("%s/%s", path, p);
|
|---|
| | | list.add(getPathModel(repository, pathString, path, commit));
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | } catch (IOException e) {
|
|---|
| | | error(e, repository, "{0} failed to get files for commit {1}", commit.getName());
|
|---|
| | | } finally {
|
|---|
| | | tw.close();
|
|---|
| | | }
|
|---|
| | | Collections.sort(list);
|
|---|
| | | return list;
|
|---|
| | |
|---|
| | | tw.setRecursive(true);
|
|---|
| | | tw.addTree(commit.getTree());
|
|---|
| | | while (tw.next()) {
|
|---|
| | | list.add(new PathChangeModel(tw.getPathString(), tw.getPathString(), 0, tw
|
|---|
| | | .getRawMode(0), tw.getObjectId(0).getName(), commit.getId().getName(),
|
|---|
| | | long size = 0;
|
|---|
| | | FilestoreModel filestoreItem = null;
|
|---|
| | | ObjectId objectId = tw.getObjectId(0);
|
|---|
| | | |
|---|
| | | try {
|
|---|
| | | if (!tw.isSubtree() && (tw.getFileMode(0) != FileMode.GITLINK)) {
|
|---|
| | |
|
|---|
| | | size = tw.getObjectReader().getObjectSize(objectId, Constants.OBJ_BLOB);
|
|---|
| | |
|
|---|
| | | if (isPossibleFilestoreItem(size)) {
|
|---|
| | | filestoreItem = getFilestoreItem(tw.getObjectReader().open(objectId));
|
|---|
| | | }
|
|---|
| | | }
|
|---|
| | | } catch (Throwable t) {
|
|---|
| | | error(t, null, "failed to retrieve blob size for " + tw.getPathString());
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | list.add(new PathChangeModel(tw.getPathString(), tw.getPathString(),filestoreItem, size, tw
|
|---|
| | | .getRawMode(0), objectId.getName(), commit.getId().getName(),
|
|---|
| | | ChangeType.ADD));
|
|---|
| | | }
|
|---|
| | | tw.release();
|
|---|
| | | tw.close();
|
|---|
| | | } else {
|
|---|
| | | RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
|
|---|
| | | DiffStatFormatter df = new DiffStatFormatter(commit.getName());
|
|---|
| | | DiffStatFormatter df = new DiffStatFormatter(commit.getName(), repository);
|
|---|
| | | df.setRepository(repository);
|
|---|
| | | df.setDiffComparator(RawTextComparator.DEFAULT);
|
|---|
| | | df.setDetectRenames(true);
|
|---|
| | | List<DiffEntry> diffs = df.scan(parent.getTree(), commit.getTree());
|
|---|
| | | for (DiffEntry diff : diffs) {
|
|---|
| | | // create the path change model
|
|---|
| | | PathChangeModel pcm = PathChangeModel.from(diff, commit.getName());
|
|---|
| | |
|
|---|
| | | if (calculateDiffStat) {
|
|---|
| | | PathChangeModel pcm = PathChangeModel.from(diff, commit.getName(), repository);
|
|---|
| | | |
|---|
| | | if (calculateDiffStat) {
|
|---|
| | | // update file diffstats
|
|---|
| | | df.format(diff);
|
|---|
| | | PathChangeModel pathStat = df.getDiffStat().getPath(pcm.path);
|
|---|
| | |
|---|
| | | RevCommit start = rw.parseCommit(startRange);
|
|---|
| | | RevCommit end = rw.parseCommit(endRange);
|
|---|
| | | list.addAll(getFilesInRange(repository, start, end));
|
|---|
| | | rw.release();
|
|---|
| | | rw.close();
|
|---|
| | | } catch (Throwable t) {
|
|---|
| | | error(t, repository, "{0} failed to determine files in range {1}..{2}!", startCommit, endCommit);
|
|---|
| | | }
|
|---|
| | |
|---|
| | |
|
|---|
| | | List<DiffEntry> diffEntries = df.scan(startCommit.getTree(), endCommit.getTree());
|
|---|
| | | for (DiffEntry diff : diffEntries) {
|
|---|
| | | PathChangeModel pcm = PathChangeModel.from(diff, endCommit.getName());
|
|---|
| | | PathChangeModel pcm = PathChangeModel.from(diff, endCommit.getName(), repository);
|
|---|
| | | list.add(pcm);
|
|---|
| | | }
|
|---|
| | | Collections.sort(list);
|
|---|
| | |
|---|
| | | } catch (IOException e) {
|
|---|
| | | error(e, repository, "{0} failed to get documents for commit {1}", commit.getName());
|
|---|
| | | } finally {
|
|---|
| | | tw.release();
|
|---|
| | | tw.close();
|
|---|
| | | }
|
|---|
| | | Collections.sort(list);
|
|---|
| | | return list;
|
|---|
| | |
|---|
| | | private static PathModel getPathModel(TreeWalk tw, String basePath, RevCommit commit) {
|
|---|
| | | String name;
|
|---|
| | | long size = 0;
|
|---|
| | | |
|---|
| | | if (StringUtils.isEmpty(basePath)) {
|
|---|
| | | name = tw.getPathString();
|
|---|
| | | } else {
|
|---|
| | | name = tw.getPathString().substring(basePath.length() + 1);
|
|---|
| | | }
|
|---|
| | | ObjectId objectId = tw.getObjectId(0);
|
|---|
| | | FilestoreModel filestoreItem = null;
|
|---|
| | | |
|---|
| | | try {
|
|---|
| | | if (!tw.isSubtree() && (tw.getFileMode(0) != FileMode.GITLINK)) {
|
|---|
| | |
|
|---|
| | | size = tw.getObjectReader().getObjectSize(objectId, Constants.OBJ_BLOB);
|
|---|
| | |
|
|---|
| | | if (isPossibleFilestoreItem(size)) {
|
|---|
| | | filestoreItem = getFilestoreItem(tw.getObjectReader().open(objectId));
|
|---|
| | | }
|
|---|
| | | }
|
|---|
| | | } catch (Throwable t) {
|
|---|
| | | error(t, null, "failed to retrieve blob size for " + tw.getPathString());
|
|---|
| | | }
|
|---|
| | | return new PathModel(name, tw.getPathString(), size, tw.getFileMode(0).getBits(),
|
|---|
| | | return new PathModel(name, tw.getPathString(), filestoreItem, size, tw.getFileMode(0).getBits(),
|
|---|
| | | objectId.getName(), commit.getName());
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | public static boolean isPossibleFilestoreItem(long size) {
|
|---|
| | | return ( (size >= com.gitblit.Constants.LEN_FILESTORE_META_MIN) |
|---|
| | | && (size <= com.gitblit.Constants.LEN_FILESTORE_META_MAX));
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | /**
|
|---|
| | | * |
|---|
| | | * @return Representative FilestoreModel if valid, otherwise null
|
|---|
| | | */
|
|---|
| | | public static FilestoreModel getFilestoreItem(ObjectLoader obj){
|
|---|
| | | try {
|
|---|
| | | final byte[] blob = obj.getCachedBytes(com.gitblit.Constants.LEN_FILESTORE_META_MAX);
|
|---|
| | | final String meta = new String(blob, "UTF-8");
|
|---|
| | | |
|---|
| | | return FilestoreModel.fromMetaString(meta);
|
|---|
| | |
|
|---|
| | | } catch (LargeObjectException e) {
|
|---|
| | | //Intentionally failing silent
|
|---|
| | | } catch (Exception e) {
|
|---|
| | | error(e, null, "failed to retrieve filestoreItem " + obj.toString());
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | return null;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Returns a path model by path string
|
|---|
| | | *
|
|---|
| | | * @param repo
|
|---|
| | | * @param path
|
|---|
| | | * @param filter
|
|---|
| | | * @param commit
|
|---|
| | | * @return a path model of the specified object
|
|---|
| | | */
|
|---|
| | | private static PathModel getPathModel(Repository repo, String path, String filter, RevCommit commit)
|
|---|
| | | throws IOException {
|
|---|
| | |
|
|---|
| | | long size = 0;
|
|---|
| | | FilestoreModel filestoreItem = null;
|
|---|
| | | TreeWalk tw = TreeWalk.forPath(repo, path, commit.getTree());
|
|---|
| | | String pathString = path;
|
|---|
| | |
|
|---|
| | | if (!tw.isSubtree() && (tw.getFileMode(0) != FileMode.GITLINK)) {
|
|---|
| | |
|
|---|
| | | pathString = PathUtils.getLastPathComponent(pathString);
|
|---|
| | | |
|---|
| | | size = tw.getObjectReader().getObjectSize(tw.getObjectId(0), Constants.OBJ_BLOB);
|
|---|
| | | |
|---|
| | | if (isPossibleFilestoreItem(size)) {
|
|---|
| | | filestoreItem = getFilestoreItem(tw.getObjectReader().open(tw.getObjectId(0)));
|
|---|
| | | }
|
|---|
| | | } else if (tw.isSubtree()) {
|
|---|
| | |
|
|---|
| | | // do not display dirs that are behind in the path
|
|---|
| | | if (!Strings.isNullOrEmpty(filter)) {
|
|---|
| | | pathString = path.replaceFirst(filter + "/", "");
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | // remove the last slash from path in displayed link
|
|---|
| | | if (pathString != null && pathString.charAt(pathString.length()-1) == '/') {
|
|---|
| | | pathString = pathString.substring(0, pathString.length()-1);
|
|---|
| | | }
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | return new PathModel(pathString, tw.getPathString(), filestoreItem, size, tw.getFileMode(0).getBits(),
|
|---|
| | | tw.getObjectId(0).getName(), commit.getName());
|
|---|
| | |
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Returns a permissions representation of the mode bits.
|
|---|
| | |
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Returns the list of tags in the repository. If repository does not exist
|
|---|
| | | * or is empty, an empty list is returned.
|
|---|
| | | *
|
|---|
| | | * @param repository
|
|---|
| | | * @param fullName
|
|---|
| | | * if true, /refs/tags/yadayadayada is returned. If false,
|
|---|
| | | * yadayadayada is returned.
|
|---|
| | | * @param maxCount
|
|---|
| | | * if < 0, all tags are returned
|
|---|
| | | * @param offset
|
|---|
| | | * if maxCount provided sets the starting point of the records to return
|
|---|
| | | * @return list of tags
|
|---|
| | | */
|
|---|
| | | public static List<RefModel> getTags(Repository repository, boolean fullName, int maxCount, int offset) {
|
|---|
| | | return getRefs(repository, Constants.R_TAGS, fullName, maxCount, offset);
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Returns the list of local branches in the repository. If repository does
|
|---|
| | | * not exist or is empty, an empty list is returned.
|
|---|
| | | *
|
|---|
| | |
|---|
| | | */
|
|---|
| | | private static List<RefModel> getRefs(Repository repository, String refs, boolean fullName,
|
|---|
| | | int maxCount) {
|
|---|
| | | return getRefs(repository, refs, fullName, maxCount, 0);
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Returns a list of references in the repository matching "refs". If the
|
|---|
| | | * repository is null or empty, an empty list is returned.
|
|---|
| | | *
|
|---|
| | | * @param repository
|
|---|
| | | * @param refs
|
|---|
| | | * if unspecified, all refs are returned
|
|---|
| | | * @param fullName
|
|---|
| | | * if true, /refs/something/yadayadayada is returned. If false,
|
|---|
| | | * yadayadayada is returned.
|
|---|
| | | * @param maxCount
|
|---|
| | | * if < 0, all references are returned
|
|---|
| | | * @param offset
|
|---|
| | | * if maxCount provided sets the starting point of the records to return
|
|---|
| | | * @return list of references
|
|---|
| | | */
|
|---|
| | | private static List<RefModel> getRefs(Repository repository, String refs, boolean fullName,
|
|---|
| | | int maxCount, int offset) {
|
|---|
| | | List<RefModel> list = new ArrayList<RefModel>();
|
|---|
| | | if (maxCount == 0) {
|
|---|
| | | return list;
|
|---|
| | |
|---|
| | | Collections.sort(list);
|
|---|
| | | Collections.reverse(list);
|
|---|
| | | if (maxCount > 0 && list.size() > maxCount) {
|
|---|
| | | list = new ArrayList<RefModel>(list.subList(0, maxCount));
|
|---|
| | | if (offset < 0) {
|
|---|
| | | offset = 0;
|
|---|
| | | }
|
|---|
| | | int endIndex = offset + maxCount;
|
|---|
| | | if (endIndex > list.size()) {
|
|---|
| | | endIndex = list.size();
|
|---|
| | | }
|
|---|
| | | list = new ArrayList<RefModel>(list.subList(offset, endIndex));
|
|---|
| | | }
|
|---|
| | | } catch (IOException e) {
|
|---|
| | | error(e, repository, "{0} failed to retrieve {1}", refs);
|
|---|
| | |
|---|
| | | error(t, repository, "{0} can't find {1} in commit {2}", path, commit.name());
|
|---|
| | | } finally {
|
|---|
| | | rw.dispose();
|
|---|
| | | tw.release();
|
|---|
| | | tw.close();
|
|---|
| | | }
|
|---|
| | | return commitId;
|
|---|
| | | }
|
|---|
| | |
|---|
| | | success = false;
|
|---|
| | | }
|
|---|
| | | } finally {
|
|---|
| | | revWalk.release();
|
|---|
| | | revWalk.close();
|
|---|
| | | }
|
|---|
| | | } finally {
|
|---|
| | | odi.release();
|
|---|
| | | odi.close();
|
|---|
| | | }
|
|---|
| | | } catch (Throwable t) {
|
|---|
| | | error(t, repository, "Failed to create orphan branch {1} in repository {0}", branchName);
|
|---|
| | |
|---|
| | | }
|
|---|
| | | return false;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Returns true if the commit identified by commitId is an ancestor or the
|
|---|
| | | * the commit identified by tipId.
|
|---|
| | | *
|
|---|
| | | * @param repository
|
|---|
| | | * @param commitId
|
|---|
| | | * @param tipId
|
|---|
| | | * @return true if there is the commit is an ancestor of the tip
|
|---|
| | | */
|
|---|
| | | public static boolean isMergedInto(Repository repository, String commitId, String tipId) {
|
|---|
| | | try {
|
|---|
| | | return isMergedInto(repository, repository.resolve(commitId), repository.resolve(tipId));
|
|---|
| | | } catch (Exception e) {
|
|---|
| | | LOGGER.error("Failed to determine isMergedInto", e);
|
|---|
| | | }
|
|---|
| | | return false;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Returns true if the commit identified by commitId is an ancestor or the
|
|---|
| | | * the commit identified by tipId.
|
|---|
| | | *
|
|---|
| | | * @param repository
|
|---|
| | | * @param commitId
|
|---|
| | | * @param tipId
|
|---|
| | | * @return true if there is the commit is an ancestor of the tip
|
|---|
| | | */
|
|---|
| | | public static boolean isMergedInto(Repository repository, ObjectId commitId, ObjectId tipCommitId) {
|
|---|
| | | // traverse the revlog looking for a commit chain between the endpoints
|
|---|
| | | RevWalk rw = new RevWalk(repository);
|
|---|
| | | try {
|
|---|
| | | // must re-lookup RevCommits to workaround undocumented RevWalk bug
|
|---|
| | | RevCommit tip = rw.lookupCommit(tipCommitId);
|
|---|
| | | RevCommit commit = rw.lookupCommit(commitId);
|
|---|
| | | return rw.isMergedInto(commit, tip);
|
|---|
| | | } catch (Exception e) {
|
|---|
| | | LOGGER.error("Failed to determine isMergedInto", e);
|
|---|
| | | } finally {
|
|---|
| | | rw.dispose();
|
|---|
| | | }
|
|---|
| | | return false;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Returns the merge base of two commits or null if there is no common
|
|---|
| | | * ancestry.
|
|---|
| | | *
|
|---|
| | | * @param repository
|
|---|
| | | * @param commitIdA
|
|---|
| | | * @param commitIdB
|
|---|
| | | * @return the commit id of the merge base or null if there is no common base
|
|---|
| | | */
|
|---|
| | | public static String getMergeBase(Repository repository, ObjectId commitIdA, ObjectId commitIdB) {
|
|---|
| | | RevWalk rw = new RevWalk(repository);
|
|---|
| | | try {
|
|---|
| | | RevCommit a = rw.lookupCommit(commitIdA);
|
|---|
| | | RevCommit b = rw.lookupCommit(commitIdB);
|
|---|
| | |
|
|---|
| | | rw.setRevFilter(RevFilter.MERGE_BASE);
|
|---|
| | | rw.markStart(a);
|
|---|
| | | rw.markStart(b);
|
|---|
| | | RevCommit mergeBase = rw.next();
|
|---|
| | | if (mergeBase == null) {
|
|---|
| | | return null;
|
|---|
| | | }
|
|---|
| | | return mergeBase.getName();
|
|---|
| | | } catch (Exception e) {
|
|---|
| | | LOGGER.error("Failed to determine merge base", e);
|
|---|
| | | } finally {
|
|---|
| | | rw.dispose();
|
|---|
| | | }
|
|---|
| | | return null;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | public static enum MergeStatus {
|
|---|
| | | MISSING_INTEGRATION_BRANCH, MISSING_SRC_BRANCH, NOT_MERGEABLE, FAILED, ALREADY_MERGED, MERGEABLE, MERGED;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Determines if we can cleanly merge one branch into another. Returns true
|
|---|
| | | * if we can merge without conflict, otherwise returns false.
|
|---|
| | | *
|
|---|
| | | * @param repository
|
|---|
| | | * @param src
|
|---|
| | | * @param toBranch
|
|---|
| | | * @return true if we can merge without conflict
|
|---|
| | | */
|
|---|
| | | public static MergeStatus canMerge(Repository repository, String src, String toBranch) {
|
|---|
| | | RevWalk revWalk = null;
|
|---|
| | | try {
|
|---|
| | | revWalk = new RevWalk(repository);
|
|---|
| | | ObjectId branchId = repository.resolve(toBranch);
|
|---|
| | | if (branchId == null) {
|
|---|
| | | return MergeStatus.MISSING_INTEGRATION_BRANCH;
|
|---|
| | | }
|
|---|
| | | ObjectId srcId = repository.resolve(src);
|
|---|
| | | if (srcId == null) {
|
|---|
| | | return MergeStatus.MISSING_SRC_BRANCH;
|
|---|
| | | }
|
|---|
| | | RevCommit branchTip = revWalk.lookupCommit(branchId);
|
|---|
| | | RevCommit srcTip = revWalk.lookupCommit(srcId);
|
|---|
| | | if (revWalk.isMergedInto(srcTip, branchTip)) {
|
|---|
| | | // already merged
|
|---|
| | | return MergeStatus.ALREADY_MERGED;
|
|---|
| | | } else if (revWalk.isMergedInto(branchTip, srcTip)) {
|
|---|
| | | // fast-forward
|
|---|
| | | return MergeStatus.MERGEABLE;
|
|---|
| | | }
|
|---|
| | | RecursiveMerger merger = (RecursiveMerger) MergeStrategy.RECURSIVE.newMerger(repository, true);
|
|---|
| | | boolean canMerge = merger.merge(branchTip, srcTip);
|
|---|
| | | if (canMerge) {
|
|---|
| | | return MergeStatus.MERGEABLE;
|
|---|
| | | }
|
|---|
| | | } catch (NullPointerException e) {
|
|---|
| | | LOGGER.error("Failed to determine canMerge", e);
|
|---|
| | | } catch (IOException e) {
|
|---|
| | | LOGGER.error("Failed to determine canMerge", e);
|
|---|
| | | } finally {
|
|---|
| | | if (revWalk != null) {
|
|---|
| | | revWalk.close();
|
|---|
| | | }
|
|---|
| | | }
|
|---|
| | | return MergeStatus.NOT_MERGEABLE;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | |
|
|---|
| | | public static class MergeResult {
|
|---|
| | | public final MergeStatus status;
|
|---|
| | | public final String sha;
|
|---|
| | |
|
|---|
| | | MergeResult(MergeStatus status, String sha) {
|
|---|
| | | this.status = status;
|
|---|
| | | this.sha = sha;
|
|---|
| | | }
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | /**
|
|---|
| | | * Tries to merge a commit into a branch. If there are conflicts, the merge
|
|---|
| | | * will fail.
|
|---|
| | | *
|
|---|
| | | * @param repository
|
|---|
| | | * @param src
|
|---|
| | | * @param toBranch
|
|---|
| | | * @param committer
|
|---|
| | | * @param message
|
|---|
| | | * @return the merge result
|
|---|
| | | */
|
|---|
| | | public static MergeResult merge(Repository repository, String src, String toBranch,
|
|---|
| | | PersonIdent committer, String message) {
|
|---|
| | |
|
|---|
| | | if (!toBranch.startsWith(Constants.R_REFS)) {
|
|---|
| | | // branch ref doesn't start with ref, assume this is a branch head
|
|---|
| | | toBranch = Constants.R_HEADS + toBranch;
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | RevWalk revWalk = null;
|
|---|
| | | try {
|
|---|
| | | revWalk = new RevWalk(repository);
|
|---|
| | | RevCommit branchTip = revWalk.lookupCommit(repository.resolve(toBranch));
|
|---|
| | | RevCommit srcTip = revWalk.lookupCommit(repository.resolve(src));
|
|---|
| | | if (revWalk.isMergedInto(srcTip, branchTip)) {
|
|---|
| | | // already merged
|
|---|
| | | return new MergeResult(MergeStatus.ALREADY_MERGED, null);
|
|---|
| | | }
|
|---|
| | | RecursiveMerger merger = (RecursiveMerger) MergeStrategy.RECURSIVE.newMerger(repository, true);
|
|---|
| | | boolean merged = merger.merge(branchTip, srcTip);
|
|---|
| | | if (merged) {
|
|---|
| | | // create a merge commit and a reference to track the merge commit
|
|---|
| | | ObjectId treeId = merger.getResultTreeId();
|
|---|
| | | ObjectInserter odi = repository.newObjectInserter();
|
|---|
| | | try {
|
|---|
| | | // Create a commit object
|
|---|
| | | CommitBuilder commitBuilder = new CommitBuilder();
|
|---|
| | | commitBuilder.setCommitter(committer);
|
|---|
| | | commitBuilder.setAuthor(committer);
|
|---|
| | | commitBuilder.setEncoding(Constants.CHARSET);
|
|---|
| | | if (StringUtils.isEmpty(message)) {
|
|---|
| | | message = MessageFormat.format("merge {0} into {1}", srcTip.getName(), branchTip.getName());
|
|---|
| | | }
|
|---|
| | | commitBuilder.setMessage(message);
|
|---|
| | | commitBuilder.setParentIds(branchTip.getId(), srcTip.getId());
|
|---|
| | | commitBuilder.setTreeId(treeId);
|
|---|
| | |
|
|---|
| | | // Insert the merge commit into the repository
|
|---|
| | | ObjectId mergeCommitId = odi.insert(commitBuilder);
|
|---|
| | | odi.flush();
|
|---|
| | |
|
|---|
| | | // set the merge ref to the merge commit
|
|---|
| | | RevCommit mergeCommit = revWalk.parseCommit(mergeCommitId);
|
|---|
| | | RefUpdate mergeRefUpdate = repository.updateRef(toBranch);
|
|---|
| | | mergeRefUpdate.setNewObjectId(mergeCommitId);
|
|---|
| | | mergeRefUpdate.setRefLogMessage("commit: " + mergeCommit.getShortMessage(), false);
|
|---|
| | | RefUpdate.Result rc = mergeRefUpdate.update();
|
|---|
| | | switch (rc) {
|
|---|
| | | case FAST_FORWARD:
|
|---|
| | | // successful, clean merge
|
|---|
| | | break;
|
|---|
| | | default:
|
|---|
| | | throw new GitBlitException(MessageFormat.format("Unexpected result \"{0}\" when merging commit {1} into {2} in {3}",
|
|---|
| | | rc.name(), srcTip.getName(), branchTip.getName(), repository.getDirectory()));
|
|---|
| | | }
|
|---|
| | |
|
|---|
| | | // return the merge commit id
|
|---|
| | | return new MergeResult(MergeStatus.MERGED, mergeCommitId.getName());
|
|---|
| | | } finally {
|
|---|
| | | odi.close();
|
|---|
| | | }
|
|---|
| | | }
|
|---|
| | | } catch (IOException e) {
|
|---|
| | | LOGGER.error("Failed to merge", e);
|
|---|
| | | } finally {
|
|---|
| | | if (revWalk != null) {
|
|---|
| | | revWalk.close();
|
|---|
| | | }
|
|---|
| | | }
|
|---|
| | | return new MergeResult(MergeStatus.FAILED, null);
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | |
|---|
| | | /**
|
|---|
| | | * Returns the LFS URL for the given oid |
|---|
| | | * Currently assumes that the Gitblit Filestore is used |
|---|
| | | *
|
|---|
| | | * @param baseURL
|
|---|
| | | * @param repository name
|
|---|
| | | * @param oid of lfs item
|
|---|
| | | * @return the lfs item URL
|
|---|
| | | */
|
|---|
| | | public static String getLfsRepositoryUrl(String baseURL, String repositoryName, String oid) {
|
|---|
| | | |
|---|
| | | if (baseURL.length() > 0 && baseURL.charAt(baseURL.length() - 1) == '/') {
|
|---|
| | | baseURL = baseURL.substring(0, baseURL.length() - 1);
|
|---|
| | | }
|
|---|
| | | |
|---|
| | | return baseURL + com.gitblit.Constants.R_PATH |
|---|
| | | + repositoryName + "/" |
|---|
| | | + com.gitblit.Constants.R_LFS |
|---|
| | | + "objects/" + oid;
|
|---|
| | | |
|---|
| | | }
|
|---|
| | | }
|
|---|
