Examples with UpdateException com.google.gerrit.server.update.UpdateException used on opensource projects

Example 21 with UpdateException

use of com.google.gerrit.server.update.UpdateException in project gerrit by GerritCodeReview.

the class ReceiveCommits method autoCloseChanges.

private void autoCloseChanges(ReceiveCommand cmd, Task progress) {
    try (TraceTimer traceTimer = newTimer("autoCloseChanges")) {
        logger.atFine().log("Starting auto-closing of changes");
        String refName = cmd.getRefName();
        Set<Change.Id> ids = new HashSet<>();
        // handleRegularCommands
        try {
            retryHelper.changeUpdate("autoCloseChanges", updateFactory -> {
                try (BatchUpdate bu = updateFactory.create(projectState.getNameKey(), user, TimeUtil.now());
                    ObjectInserter ins = repo.newObjectInserter();
                    ObjectReader reader = ins.newReader();
                    RevWalk rw = new RevWalk(reader)) {
                    if (ObjectId.zeroId().equals(cmd.getOldId())) {
                        // potentially expensive computation that loop over all commits.
                        return null;
                    }
                    bu.setRepository(repo, rw, ins);
                    // TODO(dborowitz): Teach BatchUpdate to ignore missing changes.
                    RevCommit newTip = rw.parseCommit(cmd.getNewId());
                    BranchNameKey branch = BranchNameKey.create(project.getNameKey(), refName);
                    rw.reset();
                    rw.sort(RevSort.REVERSE);
                    rw.markStart(newTip);
                    rw.markUninteresting(rw.parseCommit(cmd.getOldId()));
                    Map<Change.Key, ChangeNotes> byKey = null;
                    List<ReplaceRequest> replaceAndClose = new ArrayList<>();
                    int existingPatchSets = 0;
                    int newPatchSets = 0;
                    SubmissionId submissionId = null;
                    COMMIT: for (RevCommit c; (c = rw.next()) != null; ) {
                        rw.parseBody(c);
                        // refs pointing to this commit.
                        for (PatchSet.Id psId : receivePackRefCache.patchSetIdsFromObjectId(c.copy())) {
                            Optional<ChangeNotes> notes = getChangeNotes(psId.changeId());
                            if (notes.isPresent() && notes.get().getChange().getDest().equals(branch)) {
                                if (submissionId == null) {
                                    submissionId = new SubmissionId(notes.get().getChange());
                                }
                                existingPatchSets++;
                                bu.addOp(notes.get().getChangeId(), setPrivateOpFactory.create(false, null));
                                bu.addOp(psId.changeId(), mergedByPushOpFactory.create(requestScopePropagator, psId, submissionId, refName, newTip.getId().getName()));
                                continue COMMIT;
                            }
                        }
                        for (String changeId : ChangeUtil.getChangeIdsFromFooter(c, urlFormatter.get())) {
                            if (byKey == null) {
                                byKey = retryHelper.changeIndexQuery("queryOpenChangesByKeyByBranch", q -> openChangesByKeyByBranch(q, branch)).call();
                            }
                            ChangeNotes onto = byKey.get(Change.key(changeId.trim()));
                            if (onto != null) {
                                newPatchSets++;
                                // Hold onto this until we're done with the walk, as the call to
                                // req.validate below calls isMergedInto which resets the walk.
                                ReplaceRequest req = new ReplaceRequest(onto.getChangeId(), c, cmd, false);
                                req.notes = onto;
                                replaceAndClose.add(req);
                                continue COMMIT;
                            }
                        }
                    }
                    for (ReplaceRequest req : replaceAndClose) {
                        Change.Id id = req.notes.getChangeId();
                        if (!req.validateNewPatchSetForAutoClose()) {
                            logger.atFine().log("Not closing %s because validation failed", id);
                            continue;
                        }
                        if (submissionId == null) {
                            submissionId = new SubmissionId(req.notes.getChange());
                        }
                        req.addOps(bu, null);
                        bu.addOp(id, setPrivateOpFactory.create(false, null));
                        bu.addOp(id, mergedByPushOpFactory.create(requestScopePropagator, req.psId, submissionId, refName, newTip.getId().getName()).setPatchSetProvider(req.replaceOp::getPatchSet));
                        bu.addOp(id, new ChangeProgressOp(progress));
                        ids.add(id);
                    }
                    logger.atFine().log("Auto-closing %d changes with existing patch sets and %d with new patch" + " sets", existingPatchSets, newPatchSets);
                    bu.execute();
                } catch (IOException | StorageException | PermissionBackendException e) {
                    throw new StorageException("Failed to auto-close changes", e);
                }
                // If we are here, we didn't throw UpdateException. Record the result.
                // The ordering is indeterminate due to the HashSet; unfortunately, Change.Id
                // doesn't
                // fit into TreeSet.
                ids.stream().forEach(id -> result.addChange(ReceiveCommitsResult.ChangeStatus.AUTOCLOSED, id));
                return null;
            }).defaultTimeoutMultiplier(5).call();
        } catch (RestApiException e) {
            logger.atSevere().withCause(e).log("Can't insert patchset");
        } catch (UpdateException e) {
            logger.atSevere().withCause(e).log("Failed to auto-close changes");
        } finally {
            logger.atFine().log("Done auto-closing changes");
        }
    }
}

Example 22 with UpdateException

use of com.google.gerrit.server.update.UpdateException in project gerrit by GerritCodeReview.

the class ReceiveCommits method insertChangesAndPatchSets.

private void insertChangesAndPatchSets(ImmutableList<CreateRequest> newChanges, Task replaceProgress) {
    try (TraceTimer traceTimer = newTimer("insertChangesAndPatchSets", Metadata.builder().resourceCount(newChanges.size()))) {
        ReceiveCommand magicBranchCmd = magicBranch != null ? magicBranch.cmd : null;
        if (magicBranchCmd != null && magicBranchCmd.getResult() != NOT_ATTEMPTED) {
            logger.atWarning().log("Skipping change updates on %s because ref update failed: %s %s", project.getName(), magicBranchCmd.getResult(), Strings.nullToEmpty(magicBranchCmd.getMessage()));
            return;
        }
        try (BatchUpdate bu = batchUpdateFactory.create(project.getNameKey(), user.materializedCopy(), TimeUtil.now());
            ObjectInserter ins = repo.newObjectInserter();
            ObjectReader reader = ins.newReader();
            RevWalk rw = new RevWalk(reader)) {
            bu.setRepository(repo, rw, ins);
            bu.setRefLogMessage("push");
            if (magicBranch != null) {
                bu.setNotify(magicBranch.getNotifyForNewChange());
            }
            logger.atFine().log("Adding %d replace requests", newChanges.size());
            for (ReplaceRequest replace : replaceByChange.values()) {
                replace.addOps(bu, replaceProgress);
                if (magicBranch != null) {
                    bu.setNotifyHandling(replace.ontoChange, magicBranch.getNotifyHandling(replace.notes));
                    if (magicBranch.shouldPublishComments()) {
                        bu.addOp(replace.notes.getChangeId(), publishCommentsOp.create(replace.psId, project.getNameKey()));
                        Optional<ChangeNotes> changeNotes = getChangeNotes(replace.notes.getChangeId());
                        if (!changeNotes.isPresent()) {
                            // If not present, no need to update attention set here since this is a new change.
                            continue;
                        }
                        List<HumanComment> drafts = commentsUtil.draftByChangeAuthor(changeNotes.get(), user.getAccountId());
                        if (drafts.isEmpty()) {
                            // If no comments, attention set shouldn't update since the user didn't reply.
                            continue;
                        }
                        replyAttentionSetUpdates.processAutomaticAttentionSetRulesOnReply(bu, changeNotes.get(), isReadyForReview(changeNotes.get()), user, drafts);
                    }
                }
            }
            logger.atFine().log("Adding %d create requests", newChanges.size());
            for (CreateRequest create : newChanges) {
                create.addOps(bu);
            }
            logger.atFine().log("Adding %d group update requests", newChanges.size());
            updateGroups.forEach(r -> r.addOps(bu));
            logger.atFine().log("Executing batch");
            try {
                bu.execute();
            } catch (UpdateException e) {
                throw asRestApiException(e);
            }
            replaceByChange.values().stream().forEach(req -> result.addChange(ReceiveCommitsResult.ChangeStatus.REPLACED, req.ontoChange));
            newChanges.stream().forEach(req -> result.addChange(ReceiveCommitsResult.ChangeStatus.CREATED, req.changeId));
            if (magicBranchCmd != null) {
                magicBranchCmd.setResult(OK);
            }
            for (ReplaceRequest replace : replaceByChange.values()) {
                String rejectMessage = replace.getRejectMessage();
                if (rejectMessage == null) {
                    if (replace.inputCommand.getResult() == NOT_ATTEMPTED) {
                        // Not necessarily the magic branch, so need to set OK on the original value.
                        replace.inputCommand.setResult(OK);
                    }
                } else {
                    logger.atFine().log("Rejecting due to message from ReplaceOp");
                    reject(replace.inputCommand, rejectMessage);
                }
            }
        } catch (ResourceConflictException e) {
            addError(e.getMessage());
            reject(magicBranchCmd, "conflict");
        } catch (BadRequestException | UnprocessableEntityException | AuthException e) {
            logger.atFine().withCause(e).log("Rejecting due to client error");
            reject(magicBranchCmd, e.getMessage());
        } catch (RestApiException | IOException e) {
            throw new StorageException("Can't insert change/patch set for " + project.getName(), e);
        }
        if (magicBranch != null && magicBranch.submit) {
            try {
                submit(newChanges, replaceByChange.values());
            } catch (ResourceConflictException e) {
                addError(e.getMessage());
                reject(magicBranchCmd, "conflict");
            } catch (RestApiException | StorageException | UpdateException | IOException | ConfigInvalidException | PermissionBackendException e) {
                logger.atSevere().withCause(e).log("Error submitting changes to %s", project.getName());
                reject(magicBranchCmd, "error during submit");
            }
        }
    }
}

Example 23 with UpdateException

use of com.google.gerrit.server.update.UpdateException in project gerrit by GerritCodeReview.

the class ReceiveCommits method handleRegularCommands.

private void handleRegularCommands(List<ReceiveCommand> cmds, MultiProgressMonitor progress) throws PermissionBackendException, IOException, NoSuchProjectException {
    try (TraceTimer traceTimer = newTimer("handleRegularCommands", Metadata.builder().resourceCount(cmds.size()))) {
        result.magicPush(false);
        for (ReceiveCommand cmd : cmds) {
            parseRegularCommand(cmd);
        }
        Map<BranchNameKey, ReceiveCommand> branches;
        try (BatchUpdate bu = batchUpdateFactory.create(project.getNameKey(), user.materializedCopy(), TimeUtil.now());
            ObjectInserter ins = repo.newObjectInserter();
            ObjectReader reader = ins.newReader();
            RevWalk rw = new RevWalk(reader);
            MergeOpRepoManager orm = ormProvider.get()) {
            bu.setRepository(repo, rw, ins);
            bu.setRefLogMessage("push");
            int added = 0;
            for (ReceiveCommand cmd : cmds) {
                if (cmd.getResult() == NOT_ATTEMPTED) {
                    bu.addRepoOnlyOp(new UpdateOneRefOp(cmd));
                    added++;
                }
            }
            logger.atFine().log("Added %d additional ref updates", added);
            SubmissionExecutor submissionExecutor = new SubmissionExecutor(false, superprojectUpdateSubmissionListeners);
            submissionExecutor.execute(ImmutableList.of(bu));
            orm.setContext(TimeUtil.now(), user, NotifyResolver.Result.none());
            submissionExecutor.afterExecutions(orm);
            branches = bu.getSuccessfullyUpdatedBranches(false);
        } catch (UpdateException | RestApiException e) {
            throw new StorageException(e);
        }
        // This could be moved into a SubmissionListener
        branches.values().stream().filter(c -> isHead(c) || isConfig(c)).forEach(c -> {
            // BatchUpdate because they involve kicking off an additional BatchUpdate.
            switch(c.getType()) {
                case CREATE:
                case UPDATE:
                case UPDATE_NONFASTFORWARD:
                    Task closeProgress = progress.beginSubTask("closed", UNKNOWN);
                    autoCloseChanges(c, closeProgress);
                    closeProgress.end();
                    break;
                case DELETE:
                    break;
            }
        });
    }
}

Example 24 with UpdateException

use of com.google.gerrit.server.update.UpdateException in project gerrit by GerritCodeReview.

the class PostReview method apply.

public Response<ReviewResult> apply(RevisionResource revision, ReviewInput input, Instant ts) throws RestApiException, UpdateException, IOException, PermissionBackendException, ConfigInvalidException, PatchListNotAvailableException {
    // Respect timestamp, but truncate at change created-on time.
    ts = Ordering.natural().max(ts, revision.getChange().getCreatedOn());
    if (revision.getEdit().isPresent()) {
        throw new ResourceConflictException("cannot post review on edit");
    }
    ProjectState projectState = projectCache.get(revision.getProject()).orElseThrow(illegalState(revision.getProject()));
    LabelTypes labelTypes = projectState.getLabelTypes(revision.getNotes());
    logger.atFine().log("strict label checking is %s", (strictLabels ? "enabled" : "disabled"));
    metrics.draftHandling.increment(input.drafts == null ? "N/A" : input.drafts.name());
    input.drafts = firstNonNull(input.drafts, DraftHandling.KEEP);
    logger.atFine().log("draft handling = %s", input.drafts);
    if (input.onBehalfOf != null) {
        revision = onBehalfOf(revision, labelTypes, input);
    }
    if (input.labels != null) {
        checkLabels(revision, labelTypes, input.labels);
    }
    if (input.comments != null) {
        input.comments = cleanUpComments(input.comments);
        checkComments(revision, input.comments);
    }
    if (input.draftIdsToPublish != null) {
        checkDraftIds(revision, input.draftIdsToPublish, input.drafts);
    }
    if (input.robotComments != null) {
        input.robotComments = cleanUpComments(input.robotComments);
        checkRobotComments(revision, input.robotComments);
    }
    if (input.notify == null) {
        input.notify = defaultNotify(revision.getChange(), input);
    }
    logger.atFine().log("notify handling = %s", input.notify);
    Map<String, ReviewerResult> reviewerJsonResults = null;
    List<ReviewerModification> reviewerResults = Lists.newArrayList();
    boolean hasError = false;
    boolean confirm = false;
    if (input.reviewers != null) {
        reviewerJsonResults = Maps.newHashMap();
        for (ReviewerInput reviewerInput : input.reviewers) {
            ReviewerModification result = reviewerModifier.prepare(revision.getNotes(), revision.getUser(), reviewerInput, true);
            reviewerJsonResults.put(reviewerInput.reviewer, result.result);
            if (result.result.error != null) {
                logger.atFine().log("Adding %s as reviewer failed: %s", reviewerInput.reviewer, result.result.error);
                hasError = true;
                continue;
            }
            if (result.result.confirm != null) {
                logger.atFine().log("Adding %s as reviewer requires confirmation", reviewerInput.reviewer);
                confirm = true;
                continue;
            }
            logger.atFine().log("Adding %s as reviewer was prepared", reviewerInput.reviewer);
            reviewerResults.add(result);
        }
    }
    ReviewResult output = new ReviewResult();
    output.reviewers = reviewerJsonResults;
    if (hasError || confirm) {
        output.error = ERROR_ADDING_REVIEWER;
        return Response.withStatusCode(SC_BAD_REQUEST, output);
    }
    output.labels = input.labels;
    try (BatchUpdate bu = updateFactory.create(revision.getChange().getProject(), revision.getUser(), ts)) {
        Account account = revision.getUser().asIdentifiedUser().getAccount();
        boolean ccOrReviewer = false;
        if (input.labels != null && !input.labels.isEmpty()) {
            ccOrReviewer = input.labels.values().stream().anyMatch(v -> v != 0);
            if (ccOrReviewer) {
                logger.atFine().log("calling user is cc/reviewer on the change due to voting on a label");
            }
        }
        if (!ccOrReviewer) {
            // Check if user was already CCed or reviewing prior to this review.
            ReviewerSet currentReviewers = approvalsUtil.getReviewers(revision.getChangeResource().getNotes());
            ccOrReviewer = currentReviewers.all().contains(account.id());
            if (ccOrReviewer) {
                logger.atFine().log("calling user is already cc/reviewer on the change");
            }
        }
        // Apply reviewer changes first. Revision emails should be sent to the
        // updated set of reviewers. Also keep track of whether the user added
        // themselves as a reviewer or to the CC list.
        logger.atFine().log("adding reviewer additions");
        for (ReviewerModification reviewerResult : reviewerResults) {
            // Send a single batch email below.
            reviewerResult.op.suppressEmail();
            // Send events below, if possible as batch.
            reviewerResult.op.suppressEvent();
            bu.addOp(revision.getChange().getId(), reviewerResult.op);
            if (!ccOrReviewer && reviewerResult.reviewers.contains(account)) {
                logger.atFine().log("calling user is explicitly added as reviewer or CC");
                ccOrReviewer = true;
            }
        }
        if (!ccOrReviewer) {
            // User posting this review isn't currently in the reviewer or CC list,
            // isn't being explicitly added, and isn't voting on any label.
            // Automatically CC them on this change so they receive replies.
            logger.atFine().log("CCing calling user");
            ReviewerModification selfAddition = reviewerModifier.ccCurrentUser(revision.getUser(), revision);
            selfAddition.op.suppressEmail();
            selfAddition.op.suppressEvent();
            bu.addOp(revision.getChange().getId(), selfAddition.op);
        }
        // Add WorkInProgressOp if requested.
        if ((input.ready || input.workInProgress) && didWorkInProgressChange(revision.getChange().isWorkInProgress(), input)) {
            if (input.ready && input.workInProgress) {
                output.error = ERROR_WIP_READY_MUTUALLY_EXCLUSIVE;
                return Response.withStatusCode(SC_BAD_REQUEST, output);
            }
            revision.getChangeResource().permissions().check(ChangePermission.TOGGLE_WORK_IN_PROGRESS_STATE);
            if (input.ready) {
                output.ready = true;
            }
            logger.atFine().log("setting work-in-progress to %s", input.workInProgress);
            WorkInProgressOp wipOp = workInProgressOpFactory.create(input.workInProgress, new WorkInProgressOp.Input());
            wipOp.suppressEmail();
            bu.addOp(revision.getChange().getId(), wipOp);
        }
        // Add the review op.
        logger.atFine().log("posting review");
        bu.addOp(revision.getChange().getId(), new Op(projectState, revision.getPatchSet().id(), input));
        // Notify based on ReviewInput, ignoring the notify settings from any ReviewerInputs.
        NotifyResolver.Result notify = notifyResolver.resolve(input.notify, input.notifyDetails);
        bu.setNotify(notify);
        // Adjust the attention set based on the input
        replyAttentionSetUpdates.updateAttentionSet(bu, revision.getNotes(), input, revision.getUser());
        bu.execute();
        // Re-read change to take into account results of the update.
        ChangeData cd = changeDataFactory.create(revision.getProject(), revision.getChange().getId());
        for (ReviewerModification reviewerResult : reviewerResults) {
            reviewerResult.gatherResults(cd);
        }
        // Sending emails and events from ReviewersOps was suppressed so we can send a single batch
        // email/event here.
        batchEmailReviewers(revision.getUser(), revision.getChange(), reviewerResults, notify);
        batchReviewerEvents(revision.getUser(), cd, revision.getPatchSet(), reviewerResults, ts);
    }
    return Response.ok(output);
}

Example 25 with UpdateException

use of com.google.gerrit.server.update.UpdateException in project gerrit by GerritCodeReview.

the class RevertSubmission method revertSubmission.

private RevertSubmissionInfo revertSubmission(List<ChangeData> changeData, RevertInput revertInput) throws RestApiException, IOException, UpdateException, ConfigInvalidException, StorageException, PermissionBackendException {
    Multimap<BranchNameKey, ChangeData> changesPerProjectAndBranch = ArrayListMultimap.create();
    changeData.stream().forEach(c -> changesPerProjectAndBranch.put(c.change().getDest(), c));
    cherryPickInput = createCherryPickInput(revertInput);
    Instant timestamp = TimeUtil.now();
    for (BranchNameKey projectAndBranch : changesPerProjectAndBranch.keySet()) {
        cherryPickInput.base = null;
        Project.NameKey project = projectAndBranch.project();
        cherryPickInput.destination = projectAndBranch.branch();
        if (revertInput.workInProgress) {
            cherryPickInput.notify = firstNonNull(cherryPickInput.notify, NotifyHandling.OWNER);
        }
        Collection<ChangeData> changesInProjectAndBranch = changesPerProjectAndBranch.get(projectAndBranch);
        // Sort the changes topologically.
        Iterator<PatchSetData> sortedChangesInProjectAndBranch = sorter.sort(changesInProjectAndBranch).iterator();
        Set<ObjectId> commitIdsInProjectAndBranch = changesInProjectAndBranch.stream().map(c -> c.currentPatchSet().commitId()).collect(Collectors.toSet());
        revertAllChangesInProjectAndBranch(revertInput, project, sortedChangesInProjectAndBranch, commitIdsInProjectAndBranch, timestamp);
    }
    results.sort(Comparator.comparing(c -> c.revertOf));
    RevertSubmissionInfo revertSubmissionInfo = new RevertSubmissionInfo();
    revertSubmissionInfo.revertChanges = results;
    return revertSubmissionInfo;
}