gerrit-server/src/main/java/com/google/gerrit/server/notedb/ChangeDraftUpdate.java

// 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.notedb;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
import static com.google.gerrit.server.notedb.CommentsInNotesUtil.getCommentPsId;

import com.google.common.collect.Lists;
import com.google.common.collect.Table;
import com.google.gerrit.reviewdb.client.Account;
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.Project;
import com.google.gerrit.reviewdb.client.RefNames;
import com.google.gerrit.reviewdb.client.RevId;
import com.google.gerrit.server.GerritPersonIdent;
import com.google.gerrit.server.IdentifiedUser;
import com.google.gerrit.server.config.AllUsersName;
import com.google.gerrit.server.config.AnonymousCowardName;
import com.google.gerrit.server.git.GitRepositoryManager;
import com.google.gerrit.server.git.MetaDataUpdate;
import com.google.gerrit.server.project.ChangeControl;
import com.google.gwtorm.server.OrmException;
import com.google.inject.assistedinject.Assisted;
import com.google.inject.assistedinject.AssistedInject;

import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.lib.CommitBuilder;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.notes.NoteMap;
import org.eclipse.jgit.revwalk.RevCommit;

import java.io.IOException;
import java.util.Date;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * A single delta to apply atomically to a change.
 * <p>
 * This delta contains only draft comments on a single patch set of a change by
 * a single author. This delta will become a single commit in the All-Users
 * repository.
 * <p>
 * This class is not thread safe.
 */
public class ChangeDraftUpdate extends AbstractChangeUpdate {
  public interface Factory {
    ChangeDraftUpdate create(ChangeControl ctl, Date when);
  }

  private final AllUsersName draftsProject;
  private final Account.Id accountId;
  private final CommentsInNotesUtil commentsUtil;
  private final ChangeNotes changeNotes;
  private final DraftCommentNotes draftNotes;

  private List<PatchLineComment> upsertComments;
  private List<PatchLineComment> deleteComments;

  @AssistedInject
  private ChangeDraftUpdate(
      @GerritPersonIdent PersonIdent serverIdent,
      @AnonymousCowardName String anonymousCowardName,
      GitRepositoryManager repoManager,
      NotesMigration migration,
      MetaDataUpdate.User updateFactory,
      DraftCommentNotes.Factory draftNotesFactory,
      AllUsersName allUsers,
      CommentsInNotesUtil commentsUtil,
      @Assisted ChangeControl ctl,
      @Assisted Date when) throws OrmException {
    super(migration, repoManager, updateFactory, ctl, serverIdent,
        anonymousCowardName, when);
    this.draftsProject = allUsers;
    this.commentsUtil = commentsUtil;
    checkState(ctl.getCurrentUser().isIdentifiedUser(),
        "Current user must be identified");
    IdentifiedUser user = (IdentifiedUser) ctl.getCurrentUser();
    this.accountId = user.getAccountId();
    this.changeNotes = getChangeNotes().load();
    this.draftNotes = draftNotesFactory.create(ctl.getChange().getId(),
        user.getAccountId());

    this.upsertComments = Lists.newArrayList();
    this.deleteComments = Lists.newArrayList();
  }

  public void insertComment(PatchLineComment c) throws OrmException {
    verifyComment(c);
    checkArgument(c.getStatus() == Status.DRAFT,
        "Cannot insert a published comment into a ChangeDraftUpdate");
    if (migration.readChanges()) {
      checkArgument(!changeNotes.containsComment(c),
          "A comment already exists with the same key,"
          + " so the following comment cannot be inserted: %s", c);
    }
    upsertComments.add(c);
  }

  public void upsertComment(PatchLineComment c) {
    verifyComment(c);
    checkArgument(c.getStatus() == Status.DRAFT,
        "Cannot upsert a published comment into a ChangeDraftUpdate");
    upsertComments.add(c);
  }

  public void updateComment(PatchLineComment c) throws OrmException {
    verifyComment(c);
    checkArgument(c.getStatus() == Status.DRAFT,
        "Cannot update a published comment into a ChangeDraftUpdate");
    // Here, we check to see if this comment existed previously as a draft.
    // However, this could cause a race condition if there is a delete and an
    // update operation happening concurrently (or two deletes) and they both
    // believe that the comment exists. If a delete happens first, then
    // the update will fail. However, this is an acceptable risk since the
    // caller wanted the comment deleted anyways, so the end result will be the
    // same either way.
    if (migration.readChanges()) {
      checkArgument(draftNotes.load().containsComment(c),
          "Cannot update this comment because it didn't exist previously");
    }
    upsertComments.add(c);
  }

  public void deleteComment(PatchLineComment c) throws OrmException {
    verifyComment(c);
    // See the comment above about potential race condition.
    if (migration.readChanges()) {
      checkArgument(draftNotes.load().containsComment(c),
          "Cannot delete this comment because it didn't previously exist as a"
          + " draft");
    }
    if (migration.writeChanges()) {
      if (draftNotes.load().containsComment(c)) {
        deleteComments.add(c);
      }
    }
  }

  /**
   * Deletes a PatchLineComment from the list of drafts only if it existed
   * previously as a draft. If it wasn't a draft previously, this is a no-op.
   */
  public void deleteCommentIfPresent(PatchLineComment c) throws OrmException {
    if (draftNotes.load().containsComment(c)) {
      verifyComment(c);
      deleteComments.add(c);
    }
  }

  private void verifyComment(PatchLineComment comment) {
    checkState(psId != null,
        "setPatchSetId must be called first");
    checkArgument(getCommentPsId(comment).equals(psId),
        "Comment on %s does not match configured patch set %s",
        getCommentPsId(comment), psId);
    if (migration.writeChanges()) {
      checkArgument(comment.getRevId() != null);
    }
    checkArgument(comment.getAuthor().equals(accountId),
        "The author for the following comment does not match the author of"
        + " this ChangeDraftUpdate (%s): %s", accountId, comment);
  }

  /** @return the tree id for the updated tree */
  private ObjectId storeCommentsInNotes(AtomicBoolean removedAllComments)
      throws OrmException, IOException {
    if (isEmpty()) {
      return null;
    }

    NoteMap noteMap = draftNotes.load().getNoteMap();
    if (noteMap == null) {
      noteMap = NoteMap.newEmptyMap();
    }

    Table<PatchSet.Id, String, PatchLineComment> baseDrafts =
        draftNotes.getDraftBaseComments();
    Table<PatchSet.Id, String, PatchLineComment> psDrafts =
        draftNotes.getDraftPsComments();

    boolean draftsEmpty = baseDrafts.isEmpty() && psDrafts.isEmpty();

    // There is no need to rewrite the note for one of the sides of the patch
    // set if all of the modifications were made to the comments of one side,
    // so we set these flags to potentially save that extra work.
    boolean baseSideChanged = false;
    boolean revisionSideChanged = false;

    // We must define these RevIds so that if this update deletes all
    // remaining comments on a given side, then we can remove that note.
    // However, if this update doesn't delete any comments, it is okay for these
    // to be null because they won't be used.
    RevId baseRevId = null;
    RevId psRevId = null;

    for (PatchLineComment c : deleteComments) {
      if (c.getSide() == (short) 0) {
        baseSideChanged = true;
        baseRevId = c.getRevId();
        baseDrafts.remove(psId, c.getKey().get());
      } else {
        revisionSideChanged = true;
        psRevId = c.getRevId();
        psDrafts.remove(psId, c.getKey().get());
      }
    }

    for (PatchLineComment c : upsertComments) {
      if (c.getSide() == (short) 0) {
        baseSideChanged = true;
        baseDrafts.put(psId, c.getKey().get(), c);
      } else {
        revisionSideChanged = true;
        psDrafts.put(psId, c.getKey().get(), c);
      }
    }

    List<PatchLineComment> newBaseDrafts =
        Lists.newArrayList(baseDrafts.row(psId).values());
    List<PatchLineComment> newPsDrafts =
        Lists.newArrayList(psDrafts.row(psId).values());

    updateNoteMap(baseSideChanged, noteMap, newBaseDrafts,
        baseRevId);
    updateNoteMap(revisionSideChanged, noteMap, newPsDrafts,
        psRevId);

    removedAllComments.set(
        baseDrafts.isEmpty() && psDrafts.isEmpty() && !draftsEmpty);

    return noteMap.writeTree(inserter);
  }

  private void updateNoteMap(boolean changed, NoteMap noteMap,
      List<PatchLineComment> comments, RevId commitId)
      throws IOException {
    if (changed) {
      if (comments.isEmpty()) {
        commentsUtil.removeNote(noteMap, commitId);
      } else {
        commentsUtil.writeCommentsToNoteMap(noteMap, comments, inserter);
      }
    }
  }

  public RevCommit commit() throws IOException {
    BatchMetaDataUpdate batch = openUpdate();
    try {
      writeCommit(batch);
      return batch.commit();
    } catch (OrmException e) {
      throw new IOException(e);
    } finally {
      batch.close();
    }
  }

  @Override
  public void writeCommit(BatchMetaDataUpdate batch)
      throws OrmException, IOException {
    CommitBuilder builder = new CommitBuilder();
    if (migration.writeChanges()) {
      AtomicBoolean removedAllComments = new AtomicBoolean();
      ObjectId treeId = storeCommentsInNotes(removedAllComments);
      if (treeId != null) {
        if (removedAllComments.get()) {
          batch.removeRef(getRefName());
        } else {
          builder.setTreeId(treeId);
          batch.write(builder);
        }
      }
    }
  }

  @Override
  protected Project.NameKey getProjectName() {
    return draftsProject;
  }

  @Override
  protected String getRefName() {
    return RefNames.refsDraftComments(accountId, getChange().getId());
  }

  @Override
  protected boolean onSave(CommitBuilder commit) throws IOException,
      ConfigInvalidException {
    if (isEmpty()) {
      return false;
    }
    commit.setAuthor(newIdent(getUser().getAccount(), when));
    commit.setCommitter(new PersonIdent(serverIdent, when));
    commit.setMessage(String.format("Comment on patch set %d", psId.get()));
    return true;
  }

  private boolean isEmpty() {
    return deleteComments.isEmpty()
        && upsertComments.isEmpty();
  }
}