| // Copyright 2012 Google Inc. All Rights Reserved. | |
| // | |
| // 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.google.gitiles; | |
| import static com.google.common.base.Preconditions.checkNotNull; | |
| import com.google.common.base.Strings; | |
| import com.google.common.collect.Iterables; | |
| import com.google.common.collect.ListMultimap; | |
| import com.google.common.collect.Lists; | |
| import com.google.common.collect.Maps; | |
| import com.google.common.collect.Sets; | |
| import com.google.common.primitives.Longs; | |
| import com.google.gitiles.CommitData.Field; | |
| import com.google.gitiles.DateFormatter.Format; | |
| import com.google.gitiles.GitilesRequestFailureException.FailureReason; | |
| import com.google.gson.reflect.TypeToken; | |
| import java.io.IOException; | |
| import java.io.OutputStream; | |
| import java.io.Writer; | |
| import java.util.ArrayList; | |
| import java.util.Collection; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Optional; | |
| import java.util.Set; | |
| import javax.annotation.Nullable; | |
| import javax.servlet.http.HttpServletRequest; | |
| import javax.servlet.http.HttpServletResponse; | |
| import org.eclipse.jgit.diff.DiffConfig; | |
| import org.eclipse.jgit.errors.IncorrectObjectTypeException; | |
| import org.eclipse.jgit.errors.MissingObjectException; | |
| import org.eclipse.jgit.http.server.ServletUtils; | |
| import org.eclipse.jgit.lib.AbbreviatedObjectId; | |
| import org.eclipse.jgit.lib.Constants; | |
| import org.eclipse.jgit.lib.ObjectId; | |
| import org.eclipse.jgit.lib.ObjectReader; | |
| import org.eclipse.jgit.lib.Ref; | |
| import org.eclipse.jgit.lib.Repository; | |
| import org.eclipse.jgit.revwalk.FollowFilter; | |
| import org.eclipse.jgit.revwalk.RevCommit; | |
| import org.eclipse.jgit.revwalk.RevObject; | |
| import org.eclipse.jgit.revwalk.RevSort; | |
| import org.eclipse.jgit.revwalk.RevTag; | |
| import org.eclipse.jgit.revwalk.RevWalk; | |
| import org.eclipse.jgit.revwalk.filter.AndRevFilter; | |
| import org.eclipse.jgit.revwalk.filter.MessageRevFilter; | |
| import org.eclipse.jgit.revwalk.filter.RevFilter; | |
| import org.eclipse.jgit.treewalk.filter.ChangedPathTreeFilter; | |
| import org.eclipse.jgit.util.StringUtils; | |
| /** Serves an HTML page with a shortlog for commits and paths. */ | |
| public class LogServlet extends BaseServlet { | |
| private static final long serialVersionUID = 1L; | |
| static final String LIMIT_PARAM = "n"; | |
| static final String START_PARAM = "s"; | |
| private static final String FOLLOW_PARAM = "follow"; | |
| private static final String NAME_STATUS_PARAM = "name-status"; | |
| private static final String PRETTY_PARAM = "pretty"; | |
| private static final String TOPO_ORDER_PARAM = "topo-order"; | |
| private static final String REVERSE_PARAM = "reverse"; | |
| private static final String FIRST_PARENT_PARAM = "first-parent"; | |
| private static final String GREP_PARAM = "grep"; | |
| private static final int DEFAULT_LIMIT = 100; | |
| private static final int MAX_LIMIT = 10000; | |
| private final Linkifier linkifier; | |
| public LogServlet(GitilesAccess.Factory accessFactory, Renderer renderer, Linkifier linkifier) { | |
| super(renderer, accessFactory); | |
| this.linkifier = checkNotNull(linkifier, "linkifier"); | |
| } | |
| @Override | |
| protected void doGetHtml(HttpServletRequest req, HttpServletResponse res) throws IOException { | |
| Repository repo = ServletUtils.getRepository(req); | |
| GitilesView view = getView(req, repo); | |
| Paginator paginator = null; | |
| try { | |
| GitilesAccess access = getAccess(req); | |
| paginator = newPaginator(repo, view, access); | |
| if (paginator == null) { | |
| throw new GitilesRequestFailureException(FailureReason.OBJECT_NOT_FOUND); | |
| } | |
| DateFormatter df = new DateFormatter(access, Format.DEFAULT); | |
| // Allow the user to select a logView variant with the "pretty" param. | |
| String pretty = Iterables.getFirst(view.getParameters().get(PRETTY_PARAM), "default"); | |
| Map<String, Object> data = Maps.newHashMapWithExpectedSize(2); | |
| if (!view.getRevision().nameIsId()) { | |
| List<Map<String, Object>> tags = Lists.newArrayListWithExpectedSize(1); | |
| for (RevObject o : RevisionServlet.listObjects(paginator.getWalk(), view.getRevision())) { | |
| if (o instanceof RevTag) { | |
| tags.add(new TagSoyData(linkifier, req).toSoyData(paginator.getWalk(), (RevTag) o, df)); | |
| } | |
| } | |
| if (!tags.isEmpty()) { | |
| data.put("tags", tags); | |
| } | |
| } | |
| String title = "Log - "; | |
| if (!Revision.isNull(view.getOldRevision())) { | |
| title += view.getRevisionRange(); | |
| } else { | |
| title += view.getRevision().getName(); | |
| } | |
| data.put("title", title); | |
| try (OutputStream out = | |
| startRenderStreamingHtml( | |
| req, res, "com.google.gitiles.templates.LogDetail.logDetail", data)) { | |
| Writer w = newWriter(out, res); | |
| new LogSoyData(req, access, pretty) | |
| .renderStreaming(paginator, null, renderer, w, df, LogSoyData.FooterBehavior.NEXT); | |
| w.flush(); | |
| } | |
| } finally { | |
| if (paginator != null) { | |
| paginator.getWalk().close(); | |
| } | |
| } | |
| } | |
| @Override | |
| protected void doGetJson(HttpServletRequest req, HttpServletResponse res) throws IOException { | |
| Repository repo = ServletUtils.getRepository(req); | |
| GitilesView view = getView(req, repo); | |
| Set<Field> fs = Sets.newEnumSet(CommitJsonData.DEFAULT_FIELDS, Field.class); | |
| String nameStatus = Iterables.getFirst(view.getParameters().get(NAME_STATUS_PARAM), null); | |
| if ("1".equals(nameStatus) || "".equals(nameStatus)) { | |
| fs.add(Field.DIFF_TREE); | |
| } | |
| Paginator paginator = null; | |
| try { | |
| GitilesAccess access = getAccess(req); | |
| paginator = newPaginator(repo, view, access); | |
| if (paginator == null) { | |
| throw new GitilesRequestFailureException(FailureReason.OBJECT_NOT_FOUND); | |
| } | |
| DateFormatter df = new DateFormatter(access, Format.DEFAULT); | |
| CommitJsonData.Log result = new CommitJsonData.Log(); | |
| List<CommitJsonData.Commit> entries = Lists.newArrayListWithCapacity(paginator.getLimit()); | |
| for (RevCommit c : paginator) { | |
| RevWalk walk = paginator.getWalk(); | |
| if (!walk.isRetainBody()) { | |
| walk.parseBody(c); | |
| } | |
| entries.add(new CommitJsonData().toJsonData(req, paginator.getWalk(), c, fs, df)); | |
| } | |
| result.log = entries; | |
| if (paginator.getPreviousStart() != null) { | |
| result.previous = paginator.getPreviousStart().name(); | |
| } | |
| if (paginator.getNextStart() != null) { | |
| result.next = paginator.getNextStart().name(); | |
| } | |
| renderJson(req, res, result, new TypeToken<CommitJsonData.Log>() {}.getType()); | |
| } finally { | |
| if (paginator != null) { | |
| paginator.getWalk().close(); | |
| } | |
| } | |
| } | |
| private static @Nullable GitilesView getView(HttpServletRequest req, Repository repo) | |
| throws IOException { | |
| GitilesView view = ViewFilter.getView(req); | |
| if (!Revision.isNull(view.getRevision())) { | |
| return view; | |
| } | |
| Ref headRef = repo.exactRef(Constants.HEAD); | |
| if (headRef == null) { | |
| return null; | |
| } | |
| ObjectId id = headRef.getObjectId(); | |
| if (id == null) { | |
| return null; | |
| } | |
| try (RevWalk walk = new RevWalk(repo)) { | |
| return GitilesView.log() | |
| .copyFrom(view) | |
| .setRevision(Revision.peel(Constants.HEAD, walk.parseAny(id), walk)) | |
| .build(); | |
| } | |
| } | |
| private static class InvalidStartValueException extends IllegalArgumentException { | |
| private static final long serialVersionUID = 1L; | |
| InvalidStartValueException() { | |
| super(); | |
| } | |
| } | |
| private static Optional<ObjectId> getStart( | |
| ListMultimap<String, String> params, ObjectReader reader) | |
| throws IOException, InvalidStartValueException { | |
| List<String> values = params.get(START_PARAM); | |
| switch (values.size()) { | |
| case 0: | |
| return Optional.empty(); | |
| case 1: | |
| String id = values.get(0); | |
| if (!AbbreviatedObjectId.isId(id)) { | |
| throw new InvalidStartValueException(); | |
| } | |
| Collection<ObjectId> ids = reader.resolve(AbbreviatedObjectId.fromString(id)); | |
| if (ids.size() != 1) { | |
| throw new InvalidStartValueException(); | |
| } | |
| return Optional.of(Iterables.getOnlyElement(ids)); | |
| default: | |
| throw new InvalidStartValueException(); | |
| } | |
| } | |
| private static @Nullable RevWalk newWalk(Repository repo, GitilesView view, GitilesAccess access) | |
| throws MissingObjectException, IOException { | |
| RevWalk walk = new RevWalk(repo); | |
| if (isTrue(view, FIRST_PARENT_PARAM)) { | |
| walk.setFirstParent(true); | |
| } | |
| if (isTrue(view, TOPO_ORDER_PARAM)) { | |
| walk.sort(RevSort.TOPO_KEEP_BRANCH_TOGETHER, true); | |
| } | |
| if (isTrue(view, REVERSE_PARAM)) { | |
| walk.sort(RevSort.REVERSE, true); | |
| } | |
| try { | |
| walk.markStart(walk.parseCommit(view.getRevision().getId())); | |
| if (!Revision.isNull(view.getOldRevision())) { | |
| walk.markUninteresting(walk.parseCommit(view.getOldRevision().getId())); | |
| } | |
| } catch (IncorrectObjectTypeException iote) { | |
| return null; | |
| } | |
| setTreeFilter(walk, view, access); | |
| setRevFilter(walk, view); | |
| walk.setRetainBody(false); | |
| return walk; | |
| } | |
| private static void setRevFilter(RevWalk walk, GitilesView view) { | |
| List<RevFilter> filters = new ArrayList<>(4); | |
| if (isTrue(view, "no-merges")) { | |
| filters.add(RevFilter.NO_MERGES); | |
| } | |
| String author = Iterables.getFirst(view.getParameters().get("author"), null); | |
| if (author != null) { | |
| filters.add(IdentRevFilter.author(author)); | |
| } | |
| String committer = Iterables.getFirst(view.getParameters().get("committer"), null); | |
| if (committer != null) { | |
| filters.add(IdentRevFilter.committer(committer)); | |
| } | |
| String grep = Iterables.getFirst(view.getParameters().get(GREP_PARAM), null); | |
| if (!Strings.isNullOrEmpty(grep)) { | |
| filters.add(MessageRevFilter.create(grep)); | |
| } | |
| if (filters.size() > 1) { | |
| walk.setRevFilter(AndRevFilter.create(filters)); | |
| } else if (filters.size() == 1) { | |
| walk.setRevFilter(filters.get(0)); | |
| } | |
| } | |
| private static void setTreeFilter(RevWalk walk, GitilesView view, GitilesAccess access) | |
| throws IOException { | |
| if (Strings.isNullOrEmpty(view.getPathPart())) { | |
| return; | |
| } | |
| walk.setRewriteParents(false); | |
| String path = view.getPathPart(); | |
| List<String> followParams = view.getParameters().get(FOLLOW_PARAM); | |
| boolean follow = | |
| !followParams.isEmpty() | |
| ? isTrue(followParams.get(0)) | |
| : access.getConfig().getBoolean("log", null, "follow", true); | |
| if (follow) { | |
| walk.setTreeFilter(FollowFilter.create(path, access.getConfig().get(DiffConfig.KEY))); | |
| } else { | |
| walk.setTreeFilter(ChangedPathTreeFilter.create(path)); | |
| } | |
| } | |
| private static boolean isTrue(GitilesView view, String param) { | |
| return isTrue(Iterables.getFirst(view.getParameters().get(param), null)); | |
| } | |
| private static boolean isTrue(String v) { | |
| if (v == null) { | |
| return false; | |
| } else if (v.isEmpty()) { | |
| return true; | |
| } | |
| return Boolean.TRUE.equals(StringUtils.toBooleanOrNull(v)); | |
| } | |
| private static @Nullable Paginator newPaginator( | |
| Repository repo, GitilesView view, GitilesAccess access) throws IOException { | |
| if (view == null) { | |
| return null; | |
| } | |
| try (RevWalk walk = newWalk(repo, view, access)) { | |
| if (walk == null) { | |
| return null; | |
| } | |
| try { | |
| Optional<ObjectId> start = getStart(view.getParameters(), walk.getObjectReader()); | |
| return new Paginator(walk, getLimit(view), start.orElse(null)); | |
| } catch (InvalidStartValueException e) { | |
| return null; | |
| } | |
| } | |
| } | |
| private static int getLimit(GitilesView view) { | |
| List<String> values = view.getParameters().get(LIMIT_PARAM); | |
| if (values.isEmpty()) { | |
| return DEFAULT_LIMIT; | |
| } | |
| Long limit = Longs.tryParse(values.get(0)); | |
| if (limit == null) { | |
| return DEFAULT_LIMIT; | |
| } | |
| return (int) Math.min(limit, MAX_LIMIT); | |
| } | |
| } |