Example usage for org.eclipse.jgit.lib RefUpdate setExpectedOldObjectId

List of usage examples for org.eclipse.jgit.lib RefUpdate setExpectedOldObjectId

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.lib.*
  5. RefUpdate
  6. setExpectedOldObjectId

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib RefUpdate setExpectedOldObjectId.

Prototype

public void setExpectedOldObjectId(AnyObjectId id)

Source Link

Document

Set the expected value of the ref after the lock is taken, but before update occurs.

Usage

From source file:com.google.gerrit.server.change.CherryPickChange.java

License:Apache License

private Change createNewChange(Repository git, RevWalk revWalk, Change.Key changeKey, Project.NameKey project,
        Ref destRef, CodeReviewCommit cherryPickCommit, RefControl refControl, IdentifiedUser identifiedUser,
        String topic) throws OrmException, InvalidChangeOperationException, IOException {
    Change change = new Change(changeKey, new Change.Id(db.get().nextChangeId()), identifiedUser.getAccountId(),
            new Branch.NameKey(project, destRef.getName()), TimeUtil.nowTs());
    change.setTopic(topic);// ww  w .j  a  v a 2 s. c o  m
    ChangeInserter ins = changeInserterFactory.create(refControl.getProjectControl(), change, cherryPickCommit);
    PatchSet newPatchSet = ins.getPatchSet();

    CommitValidators commitValidators = commitValidatorsFactory.create(refControl, new NoSshInfo(), git);
    CommitReceivedEvent commitReceivedEvent = new CommitReceivedEvent(
            new ReceiveCommand(ObjectId.zeroId(), cherryPickCommit.getId(), newPatchSet.getRefName()),
            refControl.getProjectControl().getProject(), refControl.getRefName(), cherryPickCommit,
            identifiedUser);

    try {
        commitValidators.validateForGerritCommits(commitReceivedEvent);
    } catch (CommitValidationException e) {
        throw new InvalidChangeOperationException(e.getMessage());
    }

    final RefUpdate ru = git.updateRef(newPatchSet.getRefName());
    ru.setExpectedOldObjectId(ObjectId.zeroId());
    ru.setNewObjectId(cherryPickCommit);
    ru.disableRefLog();
    if (ru.update(revWalk) != RefUpdate.Result.NEW) {
        throw new IOException(String.format("Failed to create ref %s in %s: %s", newPatchSet.getRefName(),
                change.getDest().getParentKey().get(), ru.getResult()));
    }

    ins.insert();

    return change;
}

From source file:com.google.gerrit.server.change.CreateChange.java

License:Apache License

private static void updateRef(Repository git, RevWalk rw, RevCommit c, Change change, PatchSet newPatchSet)
        throws IOException {
    RefUpdate ru = git.updateRef(newPatchSet.getRefName());
    ru.setExpectedOldObjectId(ObjectId.zeroId());
    ru.setNewObjectId(c);/* ww w.jav  a 2  s  .co m*/
    ru.disableRefLog();
    if (ru.update(rw) != RefUpdate.Result.NEW) {
        throw new IOException(String.format("Failed to create ref %s in %s: %s", newPatchSet.getRefName(),
                change.getDest().getParentKey().get(), ru.getResult()));
    }
}

From source file:com.google.gerrit.server.change.PatchSetInserter.java

License:Apache License

public Change insert()
        throws InvalidChangeOperationException, OrmException, IOException, NoSuchChangeException {
    init();//  w  w w.java 2  s  .com
    validate();

    Change c = ctl.getChange();
    Change updatedChange;
    RefUpdate ru = git.updateRef(patchSet.getRefName());
    ru.setExpectedOldObjectId(ObjectId.zeroId());
    ru.setNewObjectId(commit);
    ru.disableRefLog();
    if (ru.update(revWalk) != RefUpdate.Result.NEW) {
        throw new IOException(String.format("Failed to create ref %s in %s: %s", patchSet.getRefName(),
                c.getDest().getParentKey().get(), ru.getResult()));
    }
    gitRefUpdated.fire(c.getProject(), ru);

    final PatchSet.Id currentPatchSetId = c.currentPatchSetId();

    ChangeUpdate update = updateFactory.create(ctl, patchSet.getCreatedOn());

    db.changes().beginTransaction(c.getId());
    try {
        updatedChange = db.changes().get(c.getId());
        if (!updatedChange.getStatus().isOpen() && !allowClosed) {
            throw new InvalidChangeOperationException(String.format("Change %s is closed", c.getId()));
        }

        ChangeUtil.insertAncestors(db, patchSet.getId(), commit);
        if (groups != null) {
            patchSet.setGroups(groups);
        } else {
            patchSet.setGroups(GroupCollector.getCurrentGroups(db, c));
        }
        db.patchSets().insert(Collections.singleton(patchSet));

        SetMultimap<ReviewerState, Account.Id> oldReviewers = sendMail
                ? approvalsUtil.getReviewers(db, ctl.getNotes())
                : null;

        updatedChange = db.changes().atomicUpdate(c.getId(), new AtomicUpdate<Change>() {
            @Override
            public Change update(Change change) {
                if (change.getStatus().isClosed() && !allowClosed) {
                    return null;
                }
                if (!change.currentPatchSetId().equals(currentPatchSetId)) {
                    return null;
                }
                if (change.getStatus() != Change.Status.DRAFT && !allowClosed) {
                    change.setStatus(Change.Status.NEW);
                }
                change.setCurrentPatchSet(patchSetInfoFactory.get(commit, patchSet.getId()));
                ChangeUtil.updated(change);
                return change;
            }
        });
        if (updatedChange == null) {
            throw new ChangeModifiedException(String.format("Change %s was modified", c.getId()));
        }

        if (messageIsForChange()) {
            cmUtil.addChangeMessage(db, update, changeMessage);
        }

        approvalCopier.copy(db, ctl, patchSet);
        db.commit();
        if (messageIsForChange()) {
            update.commit();
        }

        if (!messageIsForChange()) {
            commitMessageNotForChange(updatedChange);
        }

        if (sendMail) {
            try {
                PatchSetInfo info = patchSetInfoFactory.get(commit, patchSet.getId());
                ReplacePatchSetSender cm = replacePatchSetFactory.create(c.getId());
                cm.setFrom(user.getAccountId());
                cm.setPatchSet(patchSet, info);
                cm.setChangeMessage(changeMessage);
                cm.addReviewers(oldReviewers.get(ReviewerState.REVIEWER));
                cm.addExtraCC(oldReviewers.get(ReviewerState.CC));
                cm.send();
            } catch (Exception err) {
                log.error("Cannot send email for new patch set on change " + updatedChange.getId(), err);
            }
        }

    } finally {
        db.rollback();
    }
    indexer.index(db, updatedChange);
    if (runHooks) {
        hooks.doPatchsetCreatedHook(updatedChange, patchSet, db);
    }
    return updatedChange;
}

From source file:com.google.gerrit.server.ChangeUtil.java

License:Apache License

public Change.Id revert(ChangeControl ctl, PatchSet.Id patchSetId, String message, PersonIdent myIdent,
        SshInfo sshInfo) throws NoSuchChangeException, OrmException, MissingObjectException,
        IncorrectObjectTypeException, IOException, InvalidChangeOperationException {
    Change.Id changeId = patchSetId.getParentKey();
    PatchSet patch = db.get().patchSets().get(patchSetId);
    if (patch == null) {
        throw new NoSuchChangeException(changeId);
    }/*from w w w . j a va2 s  . c om*/
    Change changeToRevert = db.get().changes().get(changeId);

    Project.NameKey project = ctl.getChange().getProject();
    try (Repository git = gitManager.openRepository(project); RevWalk revWalk = new RevWalk(git)) {
        RevCommit commitToRevert = revWalk.parseCommit(ObjectId.fromString(patch.getRevision().get()));

        PersonIdent authorIdent = user().newCommitterIdent(myIdent.getWhen(), myIdent.getTimeZone());

        RevCommit parentToCommitToRevert = commitToRevert.getParent(0);
        revWalk.parseHeaders(parentToCommitToRevert);

        CommitBuilder revertCommitBuilder = new CommitBuilder();
        revertCommitBuilder.addParentId(commitToRevert);
        revertCommitBuilder.setTreeId(parentToCommitToRevert.getTree());
        revertCommitBuilder.setAuthor(authorIdent);
        revertCommitBuilder.setCommitter(authorIdent);

        if (message == null) {
            message = MessageFormat.format(ChangeMessages.get().revertChangeDefaultMessage,
                    changeToRevert.getSubject(), patch.getRevision().get());
        }

        ObjectId computedChangeId = ChangeIdUtil.computeChangeId(parentToCommitToRevert.getTree(),
                commitToRevert, authorIdent, myIdent, message);
        revertCommitBuilder.setMessage(ChangeIdUtil.insertId(message, computedChangeId, true));

        RevCommit revertCommit;
        try (ObjectInserter oi = git.newObjectInserter()) {
            ObjectId id = oi.insert(revertCommitBuilder);
            oi.flush();
            revertCommit = revWalk.parseCommit(id);
        }

        RefControl refControl = ctl.getRefControl();
        Change change = new Change(new Change.Key("I" + computedChangeId.name()),
                new Change.Id(db.get().nextChangeId()), user().getAccountId(), changeToRevert.getDest(),
                TimeUtil.nowTs());
        change.setTopic(changeToRevert.getTopic());
        ChangeInserter ins = changeInserterFactory.create(refControl.getProjectControl(), change, revertCommit);
        PatchSet ps = ins.getPatchSet();

        String ref = refControl.getRefName();
        String cmdRef = MagicBranch.NEW_PUBLISH_CHANGE + ref.substring(ref.lastIndexOf('/') + 1);
        CommitReceivedEvent commitReceivedEvent = new CommitReceivedEvent(
                new ReceiveCommand(ObjectId.zeroId(), revertCommit.getId(), cmdRef),
                refControl.getProjectControl().getProject(), refControl.getRefName(), revertCommit, user());

        try {
            commitValidatorsFactory.create(refControl, sshInfo, git)
                    .validateForGerritCommits(commitReceivedEvent);
        } catch (CommitValidationException e) {
            throw new InvalidChangeOperationException(e.getMessage());
        }

        RefUpdate ru = git.updateRef(ps.getRefName());
        ru.setExpectedOldObjectId(ObjectId.zeroId());
        ru.setNewObjectId(revertCommit);
        ru.disableRefLog();
        if (ru.update(revWalk) != RefUpdate.Result.NEW) {
            throw new IOException(String.format("Failed to create ref %s in %s: %s", ps.getRefName(),
                    change.getDest().getParentKey().get(), ru.getResult()));
        }

        ChangeMessage cmsg = new ChangeMessage(new ChangeMessage.Key(changeId, messageUUID(db.get())),
                user().getAccountId(), TimeUtil.nowTs(), patchSetId);
        StringBuilder msgBuf = new StringBuilder();
        msgBuf.append("Patch Set ").append(patchSetId.get()).append(": Reverted");
        msgBuf.append("\n\n");
        msgBuf.append("This patchset was reverted in change: ").append(change.getKey().get());
        cmsg.setMessage(msgBuf.toString());

        ins.setMessage(cmsg).insert();

        try {
            RevertedSender cm = revertedSenderFactory.create(change.getId());
            cm.setFrom(user().getAccountId());
            cm.setChangeMessage(cmsg);
            cm.send();
        } catch (Exception err) {
            log.error("Cannot send email for revert change " + change.getId(), err);
        }

        return change.getId();
    } catch (RepositoryNotFoundException e) {
        throw new NoSuchChangeException(changeId, e);
    }
}

From source file:com.google.gerrit.server.edit.ChangeEditModifier.java

License:Apache License

private RefUpdate.Result update(Repository repo, IdentifiedUser me, String refName, RevWalk rw,
        ObjectId oldObjectId, ObjectId newEdit) throws IOException {
    RefUpdate ru = repo.updateRef(refName);
    ru.setExpectedOldObjectId(oldObjectId);
    ru.setNewObjectId(newEdit);// w ww . j  a  v a  2  s. c o  m
    ru.setRefLogIdent(getRefLogIdent(me));
    ru.setRefLogMessage("inline edit (amend)", false);
    ru.setForceUpdate(true);
    RefUpdate.Result res = ru.update(rw);
    if (res != RefUpdate.Result.NEW && res != RefUpdate.Result.FORCED) {
        throw new IOException("update failed: " + ru);
    }
    return res;
}

From source file:com.google.gerrit.server.edit.ChangeEditUtil.java

License:Apache License

private static void deleteRef(Repository repo, ChangeEdit edit) throws IOException {
    String refName = edit.getRefName();
    RefUpdate ru = repo.updateRef(refName, true);
    ru.setExpectedOldObjectId(edit.getRef().getObjectId());
    ru.setForceUpdate(true);/*from  w w  w  .  j av  a2  s. com*/
    RefUpdate.Result result = ru.delete();
    switch (result) {
    case FORCED:
    case NEW:
    case NO_CHANGE:
        break;
    default:
        throw new IOException(String.format("Failed to delete ref %s: %s", refName, result));
    }
}

From source file:com.google.gerrit.server.git.CherryPick.java

License:Apache License

private CodeReviewCommit writeCherryPickCommit(final CodeReviewCommit mergeTip, final CodeReviewCommit n)
        throws IOException, OrmException {

    args.rw.parseBody(n);/*ww  w.j a v  a 2s  .c  o m*/

    final PatchSetApproval submitAudit = args.mergeUtil.getSubmitter(n.change.currentPatchSetId());

    PersonIdent cherryPickCommitterIdent = null;
    if (submitAudit != null) {
        cherryPickCommitterIdent = args.identifiedUserFactory.create(submitAudit.getAccountId())
                .newCommitterIdent(submitAudit.getGranted(), args.myIdent.getTimeZone());
    } else {
        cherryPickCommitterIdent = args.myIdent;
    }

    final String cherryPickCmtMsg = args.mergeUtil.createCherryPickCommitMessage(n);

    final CodeReviewCommit newCommit = (CodeReviewCommit) args.mergeUtil.createCherryPickFromCommit(args.repo,
            args.inserter, mergeTip, n, cherryPickCommitterIdent, cherryPickCmtMsg, args.rw);

    if (newCommit == null) {
        return null;
    }

    PatchSet.Id id = ChangeUtil.nextPatchSetId(args.repo, n.change.currentPatchSetId());
    final PatchSet ps = new PatchSet(id);
    ps.setCreatedOn(new Timestamp(System.currentTimeMillis()));
    ps.setUploader(submitAudit.getAccountId());
    ps.setRevision(new RevId(newCommit.getId().getName()));
    insertAncestors(args.db, ps.getId(), newCommit);
    args.db.patchSets().insert(Collections.singleton(ps));

    n.change.setCurrentPatchSet(patchSetInfoFactory.get(newCommit, ps.getId()));
    args.db.changes().update(Collections.singletonList(n.change));

    final List<PatchSetApproval> approvals = Lists.newArrayList();
    for (PatchSetApproval a : args.mergeUtil.getApprovalsForCommit(n)) {
        approvals.add(new PatchSetApproval(ps.getId(), a));
    }
    args.db.patchSetApprovals().insert(approvals);

    final RefUpdate ru = args.repo.updateRef(ps.getRefName());
    ru.setExpectedOldObjectId(ObjectId.zeroId());
    ru.setNewObjectId(newCommit);
    ru.disableRefLog();
    if (ru.update(args.rw) != RefUpdate.Result.NEW) {
        throw new IOException(String.format("Failed to create ref %s in %s: %s", ps.getRefName(),
                n.change.getDest().getParentKey().get(), ru.getResult()));
    }

    gitRefUpdated.fire(n.change.getProject(), ru);

    newCommit.copyFrom(n);
    newCommit.statusCode = CommitMergeStatus.CLEAN_PICK;
    newCommits.put(newCommit.patchsetId.getParentKey(), newCommit);
    setRefLogIdent(submitAudit);
    return newCommit;
}

From source file:com.google.gerrit.server.git.CreateCodeReviewNotes.java

License:Apache License

private RefUpdate createRefUpdate(ObjectId newObjectId, ObjectId expectedOldObjectId) throws IOException {
    RefUpdate refUpdate = db.updateRef(REFS_NOTES_REVIEW);
    refUpdate.setNewObjectId(newObjectId);
    if (expectedOldObjectId == null) {
        refUpdate.setExpectedOldObjectId(ObjectId.zeroId());
    } else {/* w ww.ja va2  s  .  c  o m*/
        refUpdate.setExpectedOldObjectId(expectedOldObjectId);
    }
    return refUpdate;
}

From source file:com.google.gerrit.server.git.MergeOp.java

License:Apache License

private RefUpdate getPendingRefUpdate(Branch.NameKey destBranch) throws MergeException {

    if (pendingRefUpdates.containsKey(destBranch)) {
        logDebug("Access cached open branch {}: {}", destBranch.get(), openBranches.get(destBranch));
        return pendingRefUpdates.get(destBranch);
    }/*from ww w  .  j  ava2s.  c o m*/

    try {
        RefUpdate branchUpdate = repo.updateRef(destBranch.get());
        CodeReviewCommit branchTip;
        if (branchUpdate.getOldObjectId() != null) {
            branchTip = rw.parseCommit(branchUpdate.getOldObjectId());
        } else if (Objects.equals(repo.getFullBranch(), destBranch.get())) {
            branchTip = null;
            branchUpdate.setExpectedOldObjectId(ObjectId.zeroId());
        } else {
            throw new MergeException("The destination branch " + destBranch.get() + " does not exist anymore.");
        }

        logDebug("Opened branch {}: {}", destBranch.get(), branchTip);
        pendingRefUpdates.put(destBranch, branchUpdate);
        openBranches.put(destBranch, branchTip);
        return branchUpdate;
    } catch (IOException e) {
        throw new MergeException("Cannot open branch", e);
    }
}

From source file:com.google.gerrit.server.git.NotesBranchUtil.java

License:Apache License

private RefUpdate createRefUpdate(String notesBranch, ObjectId newObjectId, ObjectId expectedOldObjectId)
        throws IOException {
    RefUpdate refUpdate = db.updateRef(notesBranch);
    refUpdate.setNewObjectId(newObjectId);
    if (expectedOldObjectId == null) {
        refUpdate.setExpectedOldObjectId(ObjectId.zeroId());
    } else {/*  w  w w  . jav  a 2 s. c om*/
        refUpdate.setExpectedOldObjectId(expectedOldObjectId);
    }
    return refUpdate;
}