Java tutorial
// Copyright (C) 2014 The Android Open Source Project // // 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.gerrit.server; import static com.google.common.base.MoreObjects.firstNonNull; import static com.google.common.base.Preconditions.checkArgument; import static java.util.stream.Collectors.toList; import com.google.common.collect.ComparisonChain; import com.google.common.collect.FluentIterable; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; import com.google.common.collect.Lists; import com.google.common.collect.Ordering; import com.google.gerrit.common.Nullable; import com.google.gerrit.extensions.client.Side; import com.google.gerrit.extensions.common.CommentInfo; import com.google.gerrit.extensions.restapi.UnprocessableEntityException; import com.google.gerrit.reviewdb.client.Account; import com.google.gerrit.reviewdb.client.Change; import com.google.gerrit.reviewdb.client.Comment; import com.google.gerrit.reviewdb.client.Patch; import com.google.gerrit.reviewdb.client.PatchLineComment; import com.google.gerrit.reviewdb.client.PatchLineComment.Status; import com.google.gerrit.reviewdb.client.PatchSet; import com.google.gerrit.reviewdb.client.RefNames; import com.google.gerrit.reviewdb.client.RobotComment; import com.google.gerrit.reviewdb.server.ReviewDb; import com.google.gerrit.server.config.AllUsersName; import com.google.gerrit.server.config.GerritServerId; import com.google.gerrit.server.git.GitRepositoryManager; import com.google.gerrit.server.notedb.ChangeNotes; import com.google.gerrit.server.notedb.ChangeUpdate; import com.google.gerrit.server.notedb.NotesMigration; import com.google.gerrit.server.patch.PatchListCache; import com.google.gerrit.server.patch.PatchListNotAvailableException; import com.google.gerrit.server.update.ChangeContext; import com.google.gwtorm.server.OrmException; import com.google.gwtorm.server.ResultSet; import com.google.inject.Inject; import com.google.inject.Singleton; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.function.Predicate; import java.util.stream.StreamSupport; import org.eclipse.jgit.lib.BatchRefUpdate; import org.eclipse.jgit.lib.NullProgressMonitor; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.revwalk.RevWalk; import org.eclipse.jgit.transport.ReceiveCommand; /** * Utility functions to manipulate Comments. * * <p>These methods either query for and update Comments in the NoteDb or ReviewDb, depending on the * state of the NotesMigration. */ @Singleton public class CommentsUtil { public static final Ordering<Comment> COMMENT_ORDER = new Ordering<Comment>() { @Override public int compare(Comment c1, Comment c2) { return ComparisonChain.start().compare(c1.key.filename, c2.key.filename) .compare(c1.key.patchSetId, c2.key.patchSetId).compare(c1.side, c2.side) .compare(c1.lineNbr, c2.lineNbr).compare(c1.writtenOn, c2.writtenOn).result(); } }; public static final Ordering<CommentInfo> COMMENT_INFO_ORDER = new Ordering<CommentInfo>() { @Override public int compare(CommentInfo a, CommentInfo b) { return ComparisonChain.start().compare(a.path, b.path, NULLS_FIRST) .compare(a.patchSet, b.patchSet, NULLS_FIRST).compare(side(a), side(b)) .compare(a.line, b.line, NULLS_FIRST).compare(a.inReplyTo, b.inReplyTo, NULLS_FIRST) .compare(a.message, b.message).compare(a.id, b.id).result(); } private int side(CommentInfo c) { return firstNonNull(c.side, Side.REVISION).ordinal(); } }; public static PatchSet.Id getCommentPsId(Change.Id changeId, Comment comment) { return new PatchSet.Id(changeId, comment.key.patchSetId); } public static String extractMessageId(@Nullable String tag) { if (tag == null || !tag.startsWith("mailMessageId=")) { return null; } return tag.substring("mailMessageId=".length()); } private static final Ordering<Comparable<?>> NULLS_FIRST = Ordering.natural().nullsFirst(); private final GitRepositoryManager repoManager; private final AllUsersName allUsers; private final NotesMigration migration; private final String serverId; @Inject CommentsUtil(GitRepositoryManager repoManager, AllUsersName allUsers, NotesMigration migration, @GerritServerId String serverId) { this.repoManager = repoManager; this.allUsers = allUsers; this.migration = migration; this.serverId = serverId; } public Comment newComment(ChangeContext ctx, String path, PatchSet.Id psId, short side, String message, @Nullable Boolean unresolved, @Nullable String parentUuid) throws OrmException, UnprocessableEntityException { if (unresolved == null) { if (parentUuid == null) { // Default to false if comment is not descended from another. unresolved = false; } else { // Inherit unresolved value from inReplyTo comment if not specified. Comment.Key key = new Comment.Key(parentUuid, path, psId.patchSetId); Optional<Comment> parent = get(ctx.getDb(), ctx.getNotes(), key); if (!parent.isPresent()) { throw new UnprocessableEntityException("Invalid parentUuid supplied for comment"); } unresolved = parent.get().unresolved; } } Comment c = new Comment(new Comment.Key(ChangeUtil.messageUuid(), path, psId.get()), ctx.getUser().getAccountId(), ctx.getWhen(), side, message, serverId, unresolved); c.parentUuid = parentUuid; ctx.getUser().updateRealAccountId(c::setRealAuthor); return c; } public RobotComment newRobotComment(ChangeContext ctx, String path, PatchSet.Id psId, short side, String message, String robotId, String robotRunId) { RobotComment c = new RobotComment(new Comment.Key(ChangeUtil.messageUuid(), path, psId.get()), ctx.getUser().getAccountId(), ctx.getWhen(), side, message, serverId, robotId, robotRunId); ctx.getUser().updateRealAccountId(c::setRealAuthor); return c; } public Optional<Comment> get(ReviewDb db, ChangeNotes notes, Comment.Key key) throws OrmException { if (!migration.readChanges()) { return Optional.ofNullable(db.patchComments().get(PatchLineComment.Key.from(notes.getChangeId(), key))) .map(plc -> plc.asComment(serverId)); } Predicate<Comment> p = c -> key.equals(c.key); Optional<Comment> c = publishedByChange(db, notes).stream().filter(p).findFirst(); if (c.isPresent()) { return c; } return draftByChange(db, notes).stream().filter(p).findFirst(); } public List<Comment> publishedByChange(ReviewDb db, ChangeNotes notes) throws OrmException { if (!migration.readChanges()) { return sort(byCommentStatus(db.patchComments().byChange(notes.getChangeId()), Status.PUBLISHED)); } notes.load(); return sort(Lists.newArrayList(notes.getComments().values())); } public List<RobotComment> robotCommentsByChange(ChangeNotes notes) throws OrmException { if (!migration.readChanges()) { return ImmutableList.of(); } notes.load(); return sort(Lists.newArrayList(notes.getRobotComments().values())); } public List<Comment> draftByChange(ReviewDb db, ChangeNotes notes) throws OrmException { if (!migration.readChanges()) { return sort(byCommentStatus(db.patchComments().byChange(notes.getChangeId()), Status.DRAFT)); } List<Comment> comments = new ArrayList<>(); for (Ref ref : getDraftRefs(notes.getChangeId())) { Account.Id account = Account.Id.fromRefSuffix(ref.getName()); if (account != null) { comments.addAll(draftByChangeAuthor(db, notes, account)); } } return sort(comments); } private List<Comment> byCommentStatus(ResultSet<PatchLineComment> comments, final PatchLineComment.Status status) { return toComments(serverId, Lists.newArrayList(Iterables.filter(comments, c -> c.getStatus() == status))); } public List<Comment> byPatchSet(ReviewDb db, ChangeNotes notes, PatchSet.Id psId) throws OrmException { if (!migration.readChanges()) { return sort(toComments(serverId, db.patchComments().byPatchSet(psId).toList())); } List<Comment> comments = new ArrayList<>(); comments.addAll(publishedByPatchSet(db, notes, psId)); for (Ref ref : getDraftRefs(notes.getChangeId())) { Account.Id account = Account.Id.fromRefSuffix(ref.getName()); if (account != null) { comments.addAll(draftByPatchSetAuthor(db, psId, account, notes)); } } return sort(comments); } public List<Comment> publishedByChangeFile(ReviewDb db, ChangeNotes notes, Change.Id changeId, String file) throws OrmException { if (!migration.readChanges()) { return sort(toComments(serverId, db.patchComments().publishedByChangeFile(changeId, file).toList())); } return commentsOnFile(notes.load().getComments().values(), file); } public List<Comment> publishedByPatchSet(ReviewDb db, ChangeNotes notes, PatchSet.Id psId) throws OrmException { if (!migration.readChanges()) { return removeCommentsOnAncestorOfCommitMessage( sort(toComments(serverId, db.patchComments().publishedByPatchSet(psId).toList()))); } return removeCommentsOnAncestorOfCommitMessage( commentsOnPatchSet(notes.load().getComments().values(), psId)); } public List<RobotComment> robotCommentsByPatchSet(ChangeNotes notes, PatchSet.Id psId) throws OrmException { if (!migration.readChanges()) { return ImmutableList.of(); } return commentsOnPatchSet(notes.load().getRobotComments().values(), psId); } /** * For the commit message the A side in a diff view is always empty when a comparison against an * ancestor is done, so there can't be any comments on this ancestor. However earlier we showed * the auto-merge commit message on side A when for a merge commit a comparison against the * auto-merge was done. From that time there may still be comments on the auto-merge commit * message and those we want to filter out. */ private List<Comment> removeCommentsOnAncestorOfCommitMessage(List<Comment> list) { return list.stream().filter(c -> c.side != 0 || !Patch.COMMIT_MSG.equals(c.key.filename)).collect(toList()); } public List<Comment> draftByPatchSetAuthor(ReviewDb db, PatchSet.Id psId, Account.Id author, ChangeNotes notes) throws OrmException { if (!migration.readChanges()) { return sort(toComments(serverId, db.patchComments().draftByPatchSetAuthor(psId, author).toList())); } return commentsOnPatchSet(notes.load().getDraftComments(author).values(), psId); } public List<Comment> draftByChangeFileAuthor(ReviewDb db, ChangeNotes notes, String file, Account.Id author) throws OrmException { if (!migration.readChanges()) { return sort(toComments(serverId, db.patchComments().draftByChangeFileAuthor(notes.getChangeId(), file, author).toList())); } return commentsOnFile(notes.load().getDraftComments(author).values(), file); } public List<Comment> draftByChangeAuthor(ReviewDb db, ChangeNotes notes, Account.Id author) throws OrmException { if (!migration.readChanges()) { return StreamSupport.stream(db.patchComments().draftByAuthor(author).spliterator(), false) .filter(c -> c.getPatchSetId().getParentKey().equals(notes.getChangeId())) .map(plc -> plc.asComment(serverId)).sorted(COMMENT_ORDER).collect(toList()); } List<Comment> comments = new ArrayList<>(); comments.addAll(notes.getDraftComments(author).values()); return sort(comments); } @Deprecated // To be used only by HasDraftByLegacyPredicate. public List<Change.Id> changesWithDraftsByAuthor(ReviewDb db, Account.Id author) throws OrmException { if (!migration.readChanges()) { return FluentIterable.from(db.patchComments().draftByAuthor(author)) .transform(plc -> plc.getPatchSetId().getParentKey()).toList(); } List<Change.Id> changes = new ArrayList<>(); try (Repository repo = repoManager.openRepository(allUsers)) { for (String refName : repo.getRefDatabase().getRefs(RefNames.REFS_DRAFT_COMMENTS).keySet()) { Account.Id accountId = Account.Id.fromRefSuffix(refName); Change.Id changeId = Change.Id.fromRefPart(refName); if (accountId == null || changeId == null) { continue; } changes.add(changeId); } } catch (IOException e) { throw new OrmException(e); } return changes; } public void putComments(ReviewDb db, ChangeUpdate update, PatchLineComment.Status status, Iterable<Comment> comments) throws OrmException { for (Comment c : comments) { update.putComment(status, c); } db.patchComments().upsert(toPatchLineComments(update.getId(), status, comments)); } public void putRobotComments(ChangeUpdate update, Iterable<RobotComment> comments) { for (RobotComment c : comments) { update.putRobotComment(c); } } public void deleteComments(ReviewDb db, ChangeUpdate update, Iterable<Comment> comments) throws OrmException { for (Comment c : comments) { update.deleteComment(c); } db.patchComments().delete(toPatchLineComments(update.getId(), PatchLineComment.Status.DRAFT, comments)); } public void deleteAllDraftsFromAllUsers(Change.Id changeId) throws IOException { try (Repository repo = repoManager.openRepository(allUsers); RevWalk rw = new RevWalk(repo)) { BatchRefUpdate bru = repo.getRefDatabase().newBatchUpdate(); for (Ref ref : getDraftRefs(repo, changeId)) { bru.addCommand(new ReceiveCommand(ref.getObjectId(), ObjectId.zeroId(), ref.getName())); } bru.setRefLogMessage("Delete drafts from NoteDb", false); bru.execute(rw, NullProgressMonitor.INSTANCE); for (ReceiveCommand cmd : bru.getCommands()) { if (cmd.getResult() != ReceiveCommand.Result.OK) { throw new IOException(String.format("Failed to delete draft comment ref %s at %s: %s (%s)", cmd.getRefName(), cmd.getOldId(), cmd.getResult(), cmd.getMessage())); } } } } private static List<Comment> commentsOnFile(Collection<Comment> allComments, String file) { List<Comment> result = new ArrayList<>(allComments.size()); for (Comment c : allComments) { String currentFilename = c.key.filename; if (currentFilename.equals(file)) { result.add(c); } } return sort(result); } private static <T extends Comment> List<T> commentsOnPatchSet(Collection<T> allComments, PatchSet.Id psId) { List<T> result = new ArrayList<>(allComments.size()); for (T c : allComments) { if (c.key.patchSetId == psId.get()) { result.add(c); } } return sort(result); } public static void setCommentRevId(Comment c, PatchListCache cache, Change change, PatchSet ps) throws OrmException { checkArgument(c.key.patchSetId == ps.getId().get(), "cannot set RevId for patch set %s on comment %s", ps.getId(), c); if (c.revId == null) { try { if (Side.fromShort(c.side) == Side.PARENT) { if (c.side < 0) { c.revId = ObjectId.toString(cache.getOldId(change, ps, -c.side)); } else { c.revId = ObjectId.toString(cache.getOldId(change, ps, null)); } } else { c.revId = ps.getRevision().get(); } } catch (PatchListNotAvailableException e) { throw new OrmException(e); } } } /** * Get NoteDb draft refs for a change. * * <p>Works if NoteDb is not enabled, but the results are not meaningful. * * <p>This is just a simple ref scan, so the results may potentially include refs for zombie draft * comments. A zombie draft is one which has been published but the write to delete the draft ref * from All-Users failed. * * @param changeId change ID. * @return raw refs from All-Users repo. */ public Collection<Ref> getDraftRefs(Change.Id changeId) throws OrmException { try (Repository repo = repoManager.openRepository(allUsers)) { return getDraftRefs(repo, changeId); } catch (IOException e) { throw new OrmException(e); } } private Collection<Ref> getDraftRefs(Repository repo, Change.Id changeId) throws IOException { return repo.getRefDatabase().getRefs(RefNames.refsDraftCommentsPrefix(changeId)).values(); } private static <T extends Comment> List<T> sort(List<T> comments) { Collections.sort(comments, COMMENT_ORDER); return comments; } public static Iterable<PatchLineComment> toPatchLineComments(Change.Id changeId, PatchLineComment.Status status, Iterable<Comment> comments) { return FluentIterable.from(comments).transform(c -> PatchLineComment.from(changeId, status, c)); } public static List<Comment> toComments(final String serverId, Iterable<PatchLineComment> comments) { return COMMENT_ORDER.sortedCopy(FluentIterable.from(comments).transform(plc -> plc.asComment(serverId))); } }