import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
private String formatChangeUrl(String url, Input input) {
  StringBuilder m =
      new StringBuilder()
          .append("  ")
          .append(ChangeUtil.formatChangeUrl(url, input.change()))
          .append(" ")
          .append(ChangeUtil.cropSubject(input.subject()));
  if (input.isEdit()) {
    m.append(" [EDIT]");
  }
  if (input.isPrivate()) {
    m.append(" [PRIVATE]");
  }
  if (input.isWorkInProgress()) {
    m.append(" [WIP]");
  }
  return m.toString();
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
public boolean updateChange(ChangeContext ctx) throws OrmException, ResourceConflictException {
  change = ctx.getChange();
  PatchSet.Id psId = change.currentPatchSetId();
  ChangeUpdate update = ctx.getUpdate(psId);
  if (!change.getStatus().isOpen()) {
    throw new ResourceConflictException("change is " + ChangeUtil.status(change));
  }
  patchSet = psUtil.get(ctx.getDb(), ctx.getNotes(), psId);
  change.setStatus(Change.Status.ABANDONED);
  change.setLastUpdatedOn(ctx.getWhen());

  update.setStatus(change.getStatus());
  message = newMessage(ctx);
  cmUtil.addChangeMessage(ctx.getDb(), update, message);
  return true;
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
public boolean updateChange(ChangeContext ctx) throws OrmException, ResourceConflictException {
  change = ctx.getChange();
  if (change == null || change.getStatus() != Status.ABANDONED) {
    throw new ResourceConflictException("change is " + ChangeUtil.status(change));
  }
  PatchSet.Id psId = change.currentPatchSetId();
  ChangeUpdate update = ctx.getUpdate(psId);
  patchSet = psUtil.get(ctx.getDb(), ctx.getNotes(), psId);
  change.setStatus(Status.NEW);
  change.setLastUpdatedOn(ctx.getWhen());
  update.setStatus(change.getStatus());

  message = newMessage(ctx);
  cmUtil.addChangeMessage(ctx.getDb(), update, message);
  return true;
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
private Change.Id insertPatchSet(
    BatchUpdate bu,
    Repository git,
    ChangeNotes destNotes,
    CodeReviewCommit cherryPickCommit,
    CherryPickInput input)
    throws IOException, OrmException, BadRequestException, ConfigInvalidException {
  Change destChange = destNotes.getChange();
  PatchSet.Id psId = ChangeUtil.nextPatchSetId(git, destChange.currentPatchSetId());
  PatchSetInserter inserter = patchSetInserterFactory.create(destNotes, psId, cherryPickCommit);
  inserter
      .setMessage("Uploaded patch set " + inserter.getPatchSetId().get() + ".")
      .setNotify(input.notify)
      .setAccountsToNotify(notifyUtil.resolveAccounts(input.notifyDetails));
  bu.addOp(destChange.getId(), inserter);
  return destChange.getId();
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
public boolean updateChange(ChangeContext ctx) throws OrmException {
  change = ctx.getChange();
  PatchSet.Id psId = ctx.getChange().currentPatchSetId();
  String msg = "Removed reviewer " + reviewer;
  changeMessage =
      new ChangeMessage(
          new ChangeMessage.Key(change.getId(), ChangeUtil.messageUuid()),
          ctx.getAccountId(),
          ctx.getWhen(),
          psId);
  changeMessage.setMessage(msg);

  ctx.getUpdate(psId).setChangeMessage(msg);
  ctx.getUpdate(psId).removeReviewerByEmail(reviewer);
  return true;
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
protected Response<String> applyImpl(
    BatchUpdate.Factory updateFactory, ChangeResource req, TopicInput input)
    throws UpdateException, RestApiException, PermissionBackendException {
  req.permissions().check(ChangePermission.EDIT_TOPIC_NAME);

  if (input != null
      && input.topic != null
      && input.topic.length() > ChangeUtil.TOPIC_MAX_LENGTH) {
    throw new BadRequestException(
        String.format("topic length exceeds the limit (%s)", ChangeUtil.TOPIC_MAX_LENGTH));
  }

  Op op = new Op(input != null ? input : new TopicInput());
  try (BatchUpdate u =
      updateFactory.create(
          dbProvider.get(), req.getChange().getProject(), req.getUser(), TimeUtil.nowTs())) {
    u.addOp(req.getId(), op);
    u.execute();
  }
  return Strings.isNullOrEmpty(op.newTopicName) ? Response.none() : Response.ok(op.newTopicName);
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
public ChangeInfo applyImpl(
    BatchUpdate.Factory updateFactory, ChangeResource rsrc, RevertInput input)
    throws IOException, OrmException, RestApiException, UpdateException, NoSuchChangeException,
        PermissionBackendException, NoSuchProjectException {
  Change change = rsrc.getChange();
  if (change.getStatus() != Change.Status.MERGED) {
    throw new ResourceConflictException("change is " + ChangeUtil.status(change));
  }

  contributorAgreements.check(rsrc.getProject(), rsrc.getUser());
  permissionBackend.user(rsrc.getUser()).ref(change.getDest()).check(CREATE_CHANGE);

  Change.Id revertId =
      revert(updateFactory, rsrc.getNotes(), rsrc.getUser(), Strings.emptyToNull(input.message));
  return json.noOptions().format(rsrc.getProject(), revertId);
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
protected Response<?> applyImpl(
    BatchUpdate.Factory updateFactory, ChangeResource rsrc, Input input)
    throws RestApiException, UpdateException {
  Change change = rsrc.getChange();
  if (!rsrc.isUserOwner()) {
    throw new AuthException("not allowed to set work in progress");
  }

  if (change.getStatus() != Status.NEW) {
    throw new ResourceConflictException("change is " + ChangeUtil.status(change));
  }

  if (change.isWorkInProgress()) {
    throw new ResourceConflictException("change is already work in progress");
  }

  try (BatchUpdate bu =
      updateFactory.create(db.get(), rsrc.getProject(), rsrc.getUser(), TimeUtil.nowTs())) {
    bu.addOp(rsrc.getChange().getId(), opFactory.create(true, input));
    bu.execute();
    return Response.ok("");
  }
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
protected Response<?> applyImpl(
    BatchUpdate.Factory updateFactory, ChangeResource rsrc, Input input)
    throws RestApiException, UpdateException {
  Change change = rsrc.getChange();
  if (!rsrc.isUserOwner()) {
    throw new AuthException("not allowed to set ready for review");
  }

  if (change.getStatus() != Status.NEW) {
    throw new ResourceConflictException("change is " + ChangeUtil.status(change));
  }

  if (!change.isWorkInProgress()) {
    throw new ResourceConflictException("change is not work in progress");
  }

  try (BatchUpdate bu =
      updateFactory.create(db.get(), rsrc.getProject(), rsrc.getUser(), TimeUtil.nowTs())) {
    bu.addOp(rsrc.getChange().getId(), opFactory.create(false, input));
    bu.execute();
    return Response.ok("");
  }
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
private ChangeMessage insertMessage(
    Change.Id id, PatchSet.Id psId, Account.Id author, Timestamp ts, String message)
    throws Exception {
  ChangeMessage msg =
      new ChangeMessage(new ChangeMessage.Key(id, ChangeUtil.messageUuid()), author, ts, psId);
  msg.setMessage(message);
  db.changeMessages().insert(Collections.singleton(msg));

  Change c = db.changes().get(id);
  if (ts.compareTo(c.getLastUpdatedOn()) > 0) {
    c.setLastUpdatedOn(ts);
    db.changes().update(Collections.singleton(c));
  }

  return msg;
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
private void insertPatchSet(
    BatchUpdate bu,
    Repository git,
    Change change,
    RevCommit cherryPickCommit,
    ChangeControl changeControl,
    String pullRequestMessage)
    throws IOException, UpdateException, RestApiException {
  try (RevWalk revWalk = new RevWalk(git)) {
    PatchSet.Id psId = ChangeUtil.nextPatchSetId(git, change.currentPatchSetId());

    PatchSetInserter patchSetInserter =
        patchSetInserterFactory.create(changeControl, psId, cherryPickCommit);
    patchSetInserter.setMessage(pullRequestMessage);
    patchSetInserter.setValidate(false);

    bu.addOp(change.getId(), patchSetInserter);
    bu.execute();
  }
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
private void newPatchSet() throws IOException, OrmException {
  RevCommit newCommit = rp.getRevWalk().parseCommit(newCommitId);
  psId =
      ChangeUtil.nextPatchSetIdFromAllRefsMap(allRefs(), notes.getChange().currentPatchSetId());
  info = patchSetInfoFactory.get(rp.getRevWalk(), newCommit, psId);
  cmd = new ReceiveCommand(ObjectId.zeroId(), newCommitId, psId.toRefName());
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
private static boolean createdOnIsMonotonic(
    Map<?, PatchSet> patchSets, Set<PatchSet.Id> limitToIds) {
  List<PatchSet> orderedById =
      patchSets
          .values()
          .stream()
          .filter(ps -> limitToIds.contains(ps.getId()))
          .sorted(ChangeUtil.PS_ID_ORDER)
          .collect(toList());
  return Ordering.natural().onResultOf(PatchSet::getCreatedOn).isOrdered(orderedById);
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
protected ChangeInfo applyImpl(
    BatchUpdate.Factory updateFactory, RevisionResource rsrc, RebaseInput input)
    throws EmailException, OrmException, UpdateException, RestApiException, IOException,
        NoSuchChangeException, PermissionBackendException {
  rsrc.permissions().database(dbProvider).check(ChangePermission.REBASE);

  Change change = rsrc.getChange();
  try (Repository repo = repoManager.openRepository(change.getProject());
      ObjectInserter oi = repo.newObjectInserter();
      ObjectReader reader = oi.newReader();
      RevWalk rw = new RevWalk(reader);
      BatchUpdate bu =
          updateFactory.create(
              dbProvider.get(), change.getProject(), rsrc.getUser(), TimeUtil.nowTs())) {
    if (!change.getStatus().isOpen()) {
      throw new ResourceConflictException("change is " + ChangeUtil.status(change));
    } else if (!hasOneParent(rw, rsrc.getPatchSet())) {
      throw new ResourceConflictException(
          "cannot rebase merge commits or commit with no ancestor");
    }
    bu.setRepository(repo, rw, oi);
    bu.addOp(
        change.getId(),
        rebaseFactory
            .create(rsrc.getNotes(), rsrc.getPatchSet(), findBaseRev(repo, rw, rsrc, input))
            .setForceContentMerge(true)
            .setFireRevisionCreated(true));
    bu.execute();
  }
  return json.create(OPTIONS).format(change.getProject(), change.getId());
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
protected ChangeInfo applyImpl(
    BatchUpdate.Factory updateFactory, ChangeResource rsrc, MoveInput input)
    throws RestApiException, OrmException, UpdateException, PermissionBackendException {
  Change change = rsrc.getChange();
  Project.NameKey project = rsrc.getProject();
  IdentifiedUser caller = rsrc.getUser().asIdentifiedUser();
  input.destinationBranch = RefNames.fullName(input.destinationBranch);

  if (change.getStatus().isClosed()) {
    throw new ResourceConflictException("Change is " + ChangeUtil.status(change));
  }

  Branch.NameKey newDest = new Branch.NameKey(project, input.destinationBranch);
  if (change.getDest().equals(newDest)) {
    throw new ResourceConflictException("Change is already destined for the specified branch");
  }

  // Move requires abandoning this change, and creating a new change.
  try {
    rsrc.permissions().database(dbProvider).check(ABANDON);
    permissionBackend.user(caller).database(dbProvider).ref(newDest).check(CREATE_CHANGE);
  } catch (AuthException denied) {
    throw new AuthException("move not permitted", denied);
  }

  try (BatchUpdate u =
      updateFactory.create(dbProvider.get(), project, caller, TimeUtil.nowTs())) {
    u.addOp(change.getId(), new Op(input));
    u.execute();
  }
  return json.noOptions().format(project, rsrc.getId());
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
public BinaryResult apply(RevisionResource rsrc)
    throws OrmException, RestApiException, UpdateException, IOException, ConfigInvalidException,
        PermissionBackendException {
  if (Strings.isNullOrEmpty(format)) {
    throw new BadRequestException("format is not specified");
  }
  ArchiveFormat f = allowedFormats.extensions.get("." + format);
  if (f == null && format.equals("tgz")) {
    // Always allow tgz, even when the allowedFormats doesn't contain it.
    // Then we allow at least one format even if the list of allowed
    // formats is empty.
    f = ArchiveFormat.TGZ;
  }
  if (f == null) {
    throw new BadRequestException("unknown archive format");
  }

  Change change = rsrc.getChange();
  if (!change.getStatus().isOpen()) {
    throw new PreconditionFailedException("change is " + ChangeUtil.status(change));
  }
  if (!rsrc.getUser().isIdentifiedUser()) {
    throw new MethodNotAllowedException("Anonymous users cannot submit");
  }

  return getBundles(rsrc, f);
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
/**
 * Promote change edit to patch set, by squashing the edit into its parent.
 *
 * @param updateFactory factory for creating updates.
 * @param notes the {@code ChangeNotes} of the change to which the change edit belongs
 * @param user the current user
 * @param edit change edit to publish
 * @param notify Notify handling that defines to whom email notifications should be sent after the
 *     change edit is published.
 * @param accountsToNotify Accounts that should be notified after the change edit is published.
 * @throws IOException
 * @throws OrmException
 * @throws UpdateException
 * @throws RestApiException
 */
public void publish(
    BatchUpdate.Factory updateFactory,
    ChangeNotes notes,
    CurrentUser user,
    final ChangeEdit edit,
    NotifyHandling notify,
    ListMultimap<RecipientType, Account.Id> accountsToNotify)
    throws IOException, OrmException, RestApiException, UpdateException {
  Change change = edit.getChange();
  try (Repository repo = gitManager.openRepository(change.getProject());
      ObjectInserter oi = repo.newObjectInserter();
      ObjectReader reader = oi.newReader();
      RevWalk rw = new RevWalk(reader)) {
    PatchSet basePatchSet = edit.getBasePatchSet();
    if (!basePatchSet.getId().equals(change.currentPatchSetId())) {
      throw new ResourceConflictException("only edit for current patch set can be published");
    }

    RevCommit squashed = squashEdit(rw, oi, edit.getEditCommit(), basePatchSet);
    PatchSet.Id psId = ChangeUtil.nextPatchSetId(repo, change.currentPatchSetId());
    PatchSetInserter inserter =
        patchSetInserterFactory
            .create(notes, psId, squashed)
            .setNotify(notify)
            .setAccountsToNotify(accountsToNotify);

    StringBuilder message =
        new StringBuilder("Patch Set ").append(inserter.getPatchSetId().get()).append(": ");

    // Previously checked that the base patch set is the current patch set.
    ObjectId prior = ObjectId.fromString(basePatchSet.getRevision().get());
    ChangeKind kind =
        changeKindCache.getChangeKind(change.getProject(), rw, repo.getConfig(), prior, squashed);
    if (kind == ChangeKind.NO_CODE_CHANGE) {
      message.append("Commit message was updated.");
      inserter.setDescription("Edit commit message");
    } else {
      message
          .append("Published edit on patch set ")
          .append(basePatchSet.getPatchSetId())
          .append(".");
    }

    try (BatchUpdate bu =
        updateFactory.create(db.get(), change.getProject(), user, TimeUtil.nowTs())) {
      bu.setRepository(repo, rw, oi);
      bu.addOp(change.getId(), inserter.setMessage(message.toString()));
      bu.addOp(
          change.getId(),
          new BatchUpdateOp() {
            @Override
            public void updateRepo(RepoContext ctx) throws Exception {
              ctx.addRefUpdate(edit.getEditCommit().copy(), ObjectId.zeroId(), edit.getRefName());
            }
          });
      bu.execute();
    }
  }
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
public String changeClosed(ChangeReportFormatter.Input input) {
  return String.format(
      "change %s closed", ChangeUtil.formatChangeUrl(canonicalWebUrl, input.change()));
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
protected void updateRepoImpl(RepoContext ctx)
    throws IntegrationException, IOException, OrmException {
  // If there is only one parent, a cherry-pick can be done by taking the
  // delta relative to that one parent and redoing that on the current merge
  // tip.
  args.rw.parseBody(toMerge);
  psId =
      ChangeUtil.nextPatchSetIdFromChangeRefsMap(
          ctx.getRepoView().getRefs(getId().toRefPrefix()),
          toMerge.change().currentPatchSetId());
  RevCommit mergeTip = args.mergeTip.getCurrentTip();
  args.rw.parseBody(mergeTip);
  String cherryPickCmtMsg = args.mergeUtil.createCommitMessageOnSubmit(toMerge, mergeTip);

  PersonIdent committer =
      args.caller.newCommitterIdent(ctx.getWhen(), args.serverIdent.getTimeZone());
  try {
    newCommit =
        args.mergeUtil.createCherryPickFromCommit(
            ctx.getInserter(),
            ctx.getRepoView().getConfig(),
            args.mergeTip.getCurrentTip(),
            toMerge,
            committer,
            cherryPickCmtMsg,
            args.rw,
            0,
            false);
  } catch (MergeConflictException mce) {
    // Keep going in the case of a single merge failure; the goal is to
    // cherry-pick as many commits as possible.
    toMerge.setStatusCode(CommitMergeStatus.PATH_CONFLICT);
    return;
  } catch (MergeIdenticalTreeException mie) {
    toMerge.setStatusCode(SKIPPED_IDENTICAL_TREE);
    return;
  }
  // Initial copy doesn't have new patch set ID since change hasn't been
  // updated yet.
  newCommit = amendGitlink(newCommit);
  newCommit.copyFrom(toMerge);
  newCommit.setPatchsetId(psId);
  newCommit.setStatusCode(CommitMergeStatus.CLEAN_PICK);
  args.mergeTip.moveTipTo(newCommit, newCommit);
  args.commitStatus.put(newCommit);

  ctx.addRefUpdate(ObjectId.zeroId(), newCommit, psId.toRefName());
  patchSetInfo = args.patchSetInfoFactory.get(ctx.getRevWalk(), newCommit, psId);
}
 

import com.google.gerrit.server.ChangeUtil; //导入依赖的package包/类
@Override
public MergeableInfo apply(RevisionResource resource)
    throws AuthException, ResourceConflictException, BadRequestException, OrmException,
        IOException {
  Change change = resource.getChange();
  PatchSet ps = resource.getPatchSet();
  MergeableInfo result = new MergeableInfo();

  if (!change.getStatus().isOpen()) {
    throw new ResourceConflictException("change is " + ChangeUtil.status(change));
  } else if (!ps.getId().equals(change.currentPatchSetId())) {
    // Only the current revision is mergeable. Others always fail.
    return result;
  }

  ChangeData cd = changeDataFactory.create(db.get(), resource.getNotes());
  result.submitType = getSubmitType(resource.getUser(), cd, ps);

  try (Repository git = gitManager.openRepository(change.getProject())) {
    ObjectId commit = toId(ps);
    Ref ref = git.getRefDatabase().exactRef(change.getDest().get());
    ProjectState projectState = projectCache.get(change.getProject());
    String strategy = mergeUtilFactory.create(projectState).mergeStrategyName();
    result.strategy = strategy;
    result.mergeable = isMergable(git, change, commit, ref, result.submitType, strategy);

    if (otherBranches) {
      result.mergeableInto = new ArrayList<>();
      BranchOrderSection branchOrder = projectState.getBranchOrderSection();
      if (branchOrder != null) {
        int prefixLen = Constants.R_HEADS.length();
        String[] names = branchOrder.getMoreStable(ref.getName());
        Map<String, Ref> refs = git.getRefDatabase().exactRef(names);
        for (String n : names) {
          Ref other = refs.get(n);
          if (other == null) {
            continue;
          }
          if (cache.get(commit, other, SubmitType.CHERRY_PICK, strategy, change.getDest(), git)) {
            result.mergeableInto.add(other.getName().substring(prefixLen));
          }
        }
      }
    }
  }
  return result;
}