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

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

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

Introduction

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

Prototype

public Result getResult()

Source Link

Document

Get the status of this update.

Usage

From source file:com.gitblit.git.PatchsetReceivePack.java

License:Apache License

private void updateReflog(RefUpdate ru) {
    if (ru == null) {
        return;/*from  www.j a  v  a2 s  .co  m*/
    }

    ReceiveCommand.Type type = null;
    switch (ru.getResult()) {
    case NEW:
        type = Type.CREATE;
        break;
    case FAST_FORWARD:
        type = Type.UPDATE;
        break;
    case FORCED:
        type = Type.UPDATE_NONFASTFORWARD;
        break;
    default:
        LOGGER.error(
                MessageFormat.format("unexpected ref update type {0} for {1}", ru.getResult(), ru.getName()));
        return;
    }
    ReceiveCommand cmd = new ReceiveCommand(ru.getOldObjectId(), ru.getNewObjectId(), ru.getName(), type);
    RefLogUtils.updateRefLog(user, getRepository(), Arrays.asList(cmd));
}

From source file:com.google.gerrit.httpd.rpc.project.ListBranchesTest.java

License:Apache License

private void set(String branch, ObjectId id) throws IOException {
    final RefUpdate u = realDb.updateRef(R_HEADS + branch);
    u.setForceUpdate(true);//from  w  w w  .  j a  v a  2s .c  o  m
    u.setNewObjectId(id);
    switch (u.update()) {
    case NEW:
    case FAST_FORWARD:
    case FORCED:
        break;
    default:
        fail("unexpected update failure " + branch + " " + u.getResult());
    }
}

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);//from w w  w  .  j a v  a 2s.c  om
    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);//from ww  w. j a  va  2  s. c  o  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();/*from   w  w  w.j ava  2 s. c o  m*/
    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);
    }// w w  w  . j a  v a2  s .c o m
    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.ChangeUtil.java

License:Apache License

public void deleteOnlyDraftPatchSet(PatchSet patch, Change change)
        throws NoSuchChangeException, OrmException, IOException {
    PatchSet.Id patchSetId = patch.getId();
    if (!patch.isDraft()) {
        throw new NoSuchChangeException(patchSetId.getParentKey());
    }/*from  ww  w .  j a va 2  s  .c om*/

    try (Repository repo = gitManager.openRepository(change.getProject())) {
        RefUpdate update = repo.updateRef(patch.getRefName());
        update.setForceUpdate(true);
        update.disableRefLog();
        switch (update.delete()) {
        case NEW:
        case FAST_FORWARD:
        case FORCED:
        case NO_CHANGE:
            // Successful deletion.
            break;
        default:
            throw new IOException("Failed to delete ref " + patch.getRefName() + " in " + repo.getDirectory()
                    + ": " + update.getResult());
        }
        gitRefUpdated.fire(change.getProject(), update, ReceiveCommand.Type.DELETE);
    }

    deleteOnlyDraftPatchSetPreserveRef(this.db.get(), patch);
}

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);/*from   ww w  .j  a  v a 2  s  .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.MergeOp.java

License:Apache License

private RefUpdate updateBranch(Branch.NameKey destBranch) throws MergeException {
    RefUpdate branchUpdate = getPendingRefUpdate(destBranch);
    CodeReviewCommit branchTip = getBranchTip(destBranch);

    MergeTip mergeTip = mergeTips.get(destBranch);

    CodeReviewCommit currentTip = mergeTip != null ? mergeTip.getCurrentTip() : null;
    if (Objects.equals(branchTip, currentTip)) {
        if (currentTip != null) {
            logDebug("Branch already at merge tip {}, no update to perform", currentTip.name());
        } else {/*from   w  w w  . jav a 2  s  . co m*/
            logDebug("Both branch and merge tip are nonexistent, no update");
        }
        return null;
    } else if (currentTip == null) {
        logDebug("No merge tip, no update to perform");
        return null;
    }

    if (RefNames.REFS_CONFIG.equals(branchUpdate.getName())) {
        logDebug("Loading new configuration from {}", RefNames.REFS_CONFIG);
        try {
            ProjectConfig cfg = new ProjectConfig(destProject.getProject().getNameKey());
            cfg.load(repo, currentTip);
        } catch (Exception e) {
            throw new MergeException("Submit would store invalid" + " project configuration "
                    + currentTip.name() + " for " + destProject.getProject().getName(), e);
        }
    }

    branchUpdate.setRefLogIdent(refLogIdent);
    branchUpdate.setForceUpdate(false);
    branchUpdate.setNewObjectId(currentTip);
    branchUpdate.setRefLogMessage("merged", true);
    try {
        RefUpdate.Result result = branchUpdate.update(rw);
        logDebug("Update of {}: {}..{} returned status {}", branchUpdate.getName(),
                branchUpdate.getOldObjectId(), branchUpdate.getNewObjectId(), result);
        switch (result) {
        case NEW:
        case FAST_FORWARD:
            if (branchUpdate.getResult() == RefUpdate.Result.FAST_FORWARD) {
                tagCache.updateFastForward(destBranch.getParentKey(), branchUpdate.getName(),
                        branchUpdate.getOldObjectId(), currentTip);
            }

            if (RefNames.REFS_CONFIG.equals(branchUpdate.getName())) {
                Project p = destProject.getProject();
                projectCache.evict(p);
                destProject = projectCache.get(p.getNameKey());
                repoManager.setProjectDescription(p.getNameKey(), p.getDescription());
            }

            return branchUpdate;

        case LOCK_FAILURE:
            throw new MergeException("Failed to lock " + branchUpdate.getName());
        default:
            throw new IOException(branchUpdate.getResult().name() + '\n' + branchUpdate);
        }
    } catch (IOException e) {
        throw new MergeException("Cannot update " + branchUpdate.getName(), e);
    }
}

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

License:Apache License

private CodeReviewCommit writeCherryPickCommit(CodeReviewCommit mergeTip, CodeReviewCommit n)
        throws IOException, OrmException, NoSuchChangeException, MergeConflictException,
        MergeIdenticalTreeException {/* w ww .  j  a  va2  s  .  c  o m*/

    args.rw.parseBody(n);

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

    PersonIdent committer = args.caller.newCommitterIdent(TimeUtil.nowTs(),
            args.serverIdent.get().getTimeZone());
    CodeReviewCommit newCommit = args.mergeUtil.createCherryPickFromCommit(args.repo, args.inserter, mergeTip,
            n, committer, cherryPickCmtMsg, args.rw);

    PatchSet.Id id = ChangeUtil.nextPatchSetId(args.repo, n.change().currentPatchSetId());
    PatchSet ps = new PatchSet(id);
    ps.setCreatedOn(TimeUtil.nowTs());
    ps.setUploader(args.caller.getAccountId());
    ps.setRevision(new RevId(newCommit.getId().getName()));

    RefUpdate ru;

    args.db.changes().beginTransaction(n.change().getId());
    try {
        insertAncestors(args.db, ps.getId(), newCommit);
        ps.setGroups(GroupCollector.getCurrentGroups(args.db, n.change()));
        args.db.patchSets().insert(Collections.singleton(ps));
        n.change().setCurrentPatchSet(patchSetInfoFactory.get(newCommit, ps.getId()));
        args.db.changes().update(Collections.singletonList(n.change()));

        List<PatchSetApproval> approvals = Lists.newArrayList();
        for (PatchSetApproval a : args.approvalsUtil.byPatchSet(args.db, n.getControl(), n.getPatchsetId())) {
            approvals.add(new PatchSetApproval(ps.getId(), a));
        }
        args.db.patchSetApprovals().insert(approvals);

        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()));
        }

        args.db.commit();
    } finally {
        args.db.rollback();
    }

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

    newCommit.copyFrom(n);
    newCommit.setStatusCode(CommitMergeStatus.CLEAN_PICK);
    newCommit.setControl(args.changeControlFactory.controlFor(n.change(), args.caller));
    newCommits.put(newCommit.getPatchsetId().getParentKey(), newCommit);
    setRefLogIdent();
    return newCommit;
}