Examples with MethodNotAllowedException com.google.gerrit.extensions.restapi.MethodNotAllowedException used on opensource projects

Example 46 with MethodNotAllowedException

use of com.google.gerrit.extensions.restapi.MethodNotAllowedException in project gerrit by GerritCodeReview.

the class RevisionIT method deleteVoteOnNonCurrentPatchSet.

@Test
public void deleteVoteOnNonCurrentPatchSet() throws Exception {
    // patch set 1
    PushOneCommit.Result r = createChange();
    gApi.changes().id(r.getChangeId()).revision(r.getCommit().name()).review(ReviewInput.approve());
    // patch set 2
    amendChange(r.getChangeId());
    // code-review
    requestScopeOperations.setApiUser(user.id());
    recommend(r.getChangeId());
    // check if it's blocked to delete a vote on a non-current patch set.
    requestScopeOperations.setApiUser(admin.id());
    MethodNotAllowedException thrown = assertThrows(MethodNotAllowedException.class, () -> gApi.changes().id(r.getChangeId()).revision(r.getCommit().getName()).reviewer(user.id().toString()).deleteVote(LabelId.CODE_REVIEW));
    assertThat(thrown).hasMessageThat().contains("Cannot access on non-current patch set");
}

Example 47 with MethodNotAllowedException

use of com.google.gerrit.extensions.restapi.MethodNotAllowedException in project gerrit by GerritCodeReview.

the class RestApiServlet method parseRawInput.

private Object parseRawInput(HttpServletRequest req, Type type) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, MethodNotAllowedException {
    Object obj = createInstance(type);
    for (Field f : obj.getClass().getDeclaredFields()) {
        if (f.getType() == RawInput.class) {
            f.setAccessible(true);
            f.set(obj, RawInputUtil.create(req));
            return obj;
        }
    }
    throw new MethodNotAllowedException("raw input not supported");
}

Example 48 with MethodNotAllowedException

use of com.google.gerrit.extensions.restapi.MethodNotAllowedException in project gerrit by GerritCodeReview.

the class RestApiServlet method service.

@Override
protected final void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
    final long startNanos = System.nanoTime();
    long auditStartTs = TimeUtil.nowMs();
    res.setHeader("Content-Disposition", "attachment");
    res.setHeader("X-Content-Type-Options", "nosniff");
    int statusCode = SC_OK;
    long responseBytes = -1;
    Optional<Exception> cause = Optional.empty();
    Response<?> response = null;
    QueryParams qp = null;
    Object inputRequestBody = null;
    RestResource rsrc = TopLevelResource.INSTANCE;
    ViewData viewData = null;
    try (TraceContext traceContext = enableTracing(req, res)) {
        String requestUri = requestUri(req);
        try (PerThreadCache ignored = PerThreadCache.create()) {
            List<IdString> path = splitPath(req);
            RequestInfo requestInfo = createRequestInfo(traceContext, requestUri, path);
            globals.requestListeners.runEach(l -> l.onRequest(requestInfo));
            // TraceIT#performanceLoggingForRestCall()).
            try (RequestStateContext requestStateContext = RequestStateContext.open().addRequestStateProvider(globals.deadlineCheckerFactory.create(requestInfo, req.getHeader(X_GERRIT_DEADLINE)));
                PerformanceLogContext performanceLogContext = new PerformanceLogContext(globals.config, globals.performanceLoggers)) {
                traceRequestData(req);
                if (isCorsPreflight(req)) {
                    doCorsPreflight(req, res);
                    return;
                }
                qp = ParameterParser.getQueryParams(req);
                checkCors(req, res, qp.hasXdOverride());
                if (qp.hasXdOverride()) {
                    req = applyXdOverrides(req, qp);
                }
                checkUserSession(req);
                RestCollection<RestResource, RestResource> rc = members.get();
                globals.permissionBackend.currentUser().checkAny(GlobalPermission.fromAnnotation(rc.getClass()));
                viewData = new ViewData(null, null);
                if (path.isEmpty()) {
                    globals.quotaChecker.enforce(req);
                    if (rc instanceof NeedsParams) {
                        ((NeedsParams) rc).setParams(qp.params());
                    }
                    if (isRead(req)) {
                        viewData = new ViewData(null, rc.list());
                    } else if (isPost(req)) {
                        RestView<RestResource> restCollectionView = rc.views().get(PluginName.GERRIT, "POST_ON_COLLECTION./");
                        if (restCollectionView != null) {
                            viewData = new ViewData(null, restCollectionView);
                        } else {
                            throw methodNotAllowed(req);
                        }
                    } else {
                        // DELETE on root collections is not supported
                        throw methodNotAllowed(req);
                    }
                } else {
                    IdString id = path.remove(0);
                    try {
                        rsrc = parseResourceWithRetry(req, traceContext, viewData.pluginName, rc, rsrc, id);
                        globals.quotaChecker.enforce(rsrc, req);
                        if (path.isEmpty()) {
                            checkPreconditions(req);
                        }
                    } catch (ResourceNotFoundException e) {
                        if (!path.isEmpty()) {
                            throw e;
                        }
                        globals.quotaChecker.enforce(req);
                        if (isPost(req) || isPut(req)) {
                            RestView<RestResource> createView = rc.views().get(PluginName.GERRIT, "CREATE./");
                            if (createView != null) {
                                viewData = new ViewData(null, createView);
                                path.add(id);
                            } else {
                                throw e;
                            }
                        } else if (isDelete(req)) {
                            RestView<RestResource> deleteView = rc.views().get(PluginName.GERRIT, "DELETE_MISSING./");
                            if (deleteView != null) {
                                viewData = new ViewData(null, deleteView);
                                path.add(id);
                            } else {
                                throw e;
                            }
                        } else {
                            throw e;
                        }
                    }
                    if (viewData.view == null) {
                        viewData = view(rc, req.getMethod(), path);
                    }
                }
                checkRequiresCapability(viewData);
                while (viewData.view instanceof RestCollection<?, ?>) {
                    @SuppressWarnings("unchecked") RestCollection<RestResource, RestResource> c = (RestCollection<RestResource, RestResource>) viewData.view;
                    if (path.isEmpty()) {
                        if (isRead(req)) {
                            viewData = new ViewData(null, c.list());
                        } else if (isPost(req)) {
                            // TODO: Here and on other collection methods: There is a bug that binds child views
                            // with pluginName="gerrit" instead of the real plugin name. This has never worked
                            // correctly and should be fixed where the binding gets created (DynamicMapProvider)
                            // and here.
                            RestView<RestResource> restCollectionView = c.views().get(PluginName.GERRIT, "POST_ON_COLLECTION./");
                            if (restCollectionView != null) {
                                viewData = new ViewData(null, restCollectionView);
                            } else {
                                throw methodNotAllowed(req);
                            }
                        } else if (isDelete(req)) {
                            RestView<RestResource> restCollectionView = c.views().get(PluginName.GERRIT, "DELETE_ON_COLLECTION./");
                            if (restCollectionView != null) {
                                viewData = new ViewData(null, restCollectionView);
                            } else {
                                throw methodNotAllowed(req);
                            }
                        } else {
                            throw methodNotAllowed(req);
                        }
                        break;
                    }
                    IdString id = path.remove(0);
                    try {
                        rsrc = parseResourceWithRetry(req, traceContext, viewData.pluginName, c, rsrc, id);
                        checkPreconditions(req);
                        viewData = new ViewData(null, null);
                    } catch (ResourceNotFoundException e) {
                        if (!path.isEmpty()) {
                            throw e;
                        }
                        if (isPost(req) || isPut(req)) {
                            RestView<RestResource> createView = c.views().get(PluginName.GERRIT, "CREATE./");
                            if (createView != null) {
                                viewData = new ViewData(viewData.pluginName, createView);
                                path.add(id);
                            } else {
                                throw e;
                            }
                        } else if (isDelete(req)) {
                            RestView<RestResource> deleteView = c.views().get(PluginName.GERRIT, "DELETE_MISSING./");
                            if (deleteView != null) {
                                viewData = new ViewData(viewData.pluginName, deleteView);
                                path.add(id);
                            } else {
                                throw e;
                            }
                        } else {
                            throw e;
                        }
                    }
                    if (viewData.view == null) {
                        viewData = view(c, req.getMethod(), path);
                    }
                    checkRequiresCapability(viewData);
                }
                if (notModified(req, traceContext, viewData, rsrc)) {
                    logger.atFinest().log("REST call succeeded: %d", SC_NOT_MODIFIED);
                    res.sendError(SC_NOT_MODIFIED);
                    return;
                }
                try (DynamicOptions pluginOptions = new DynamicOptions(globals.injector, globals.dynamicBeans)) {
                    if (!globals.paramParser.get().parse(viewData.view, pluginOptions, qp.params(), req, res)) {
                        return;
                    }
                    if (viewData.view instanceof RestReadView<?> && isRead(req)) {
                        response = invokeRestReadViewWithRetry(req, traceContext, viewData, (RestReadView<RestResource>) viewData.view, rsrc);
                    } else if (viewData.view instanceof RestModifyView<?, ?>) {
                        @SuppressWarnings("unchecked") RestModifyView<RestResource, Object> m = (RestModifyView<RestResource, Object>) viewData.view;
                        Type type = inputType(m);
                        inputRequestBody = parseRequest(req, type);
                        response = invokeRestModifyViewWithRetry(req, traceContext, viewData, m, rsrc, inputRequestBody);
                        if (inputRequestBody instanceof RawInput) {
                            try (InputStream is = req.getInputStream()) {
                                ServletUtils.consumeRequestBody(is);
                            }
                        }
                    } else if (viewData.view instanceof RestCollectionCreateView<?, ?, ?>) {
                        @SuppressWarnings("unchecked") RestCollectionCreateView<RestResource, RestResource, Object> m = (RestCollectionCreateView<RestResource, RestResource, Object>) viewData.view;
                        Type type = inputType(m);
                        inputRequestBody = parseRequest(req, type);
                        response = invokeRestCollectionCreateViewWithRetry(req, traceContext, viewData, m, rsrc, path.get(0), inputRequestBody);
                        if (inputRequestBody instanceof RawInput) {
                            try (InputStream is = req.getInputStream()) {
                                ServletUtils.consumeRequestBody(is);
                            }
                        }
                    } else if (viewData.view instanceof RestCollectionDeleteMissingView<?, ?, ?>) {
                        @SuppressWarnings("unchecked") RestCollectionDeleteMissingView<RestResource, RestResource, Object> m = (RestCollectionDeleteMissingView<RestResource, RestResource, Object>) viewData.view;
                        Type type = inputType(m);
                        inputRequestBody = parseRequest(req, type);
                        response = invokeRestCollectionDeleteMissingViewWithRetry(req, traceContext, viewData, m, rsrc, path.get(0), inputRequestBody);
                        if (inputRequestBody instanceof RawInput) {
                            try (InputStream is = req.getInputStream()) {
                                ServletUtils.consumeRequestBody(is);
                            }
                        }
                    } else if (viewData.view instanceof RestCollectionModifyView<?, ?, ?>) {
                        @SuppressWarnings("unchecked") RestCollectionModifyView<RestResource, RestResource, Object> m = (RestCollectionModifyView<RestResource, RestResource, Object>) viewData.view;
                        Type type = inputType(m);
                        inputRequestBody = parseRequest(req, type);
                        response = invokeRestCollectionModifyViewWithRetry(req, traceContext, viewData, m, rsrc, inputRequestBody);
                        if (inputRequestBody instanceof RawInput) {
                            try (InputStream is = req.getInputStream()) {
                                ServletUtils.consumeRequestBody(is);
                            }
                        }
                    } else {
                        throw new ResourceNotFoundException();
                    }
                    String isUpdatedRefEnabled = req.getHeader(X_GERRIT_UPDATED_REF_ENABLED);
                    if (!Strings.isNullOrEmpty(isUpdatedRefEnabled) && Boolean.valueOf(isUpdatedRefEnabled)) {
                        setXGerritUpdatedRefResponseHeaders(req, res);
                    }
                    if (response instanceof Response.Redirect) {
                        CacheHeaders.setNotCacheable(res);
                        String location = ((Response.Redirect) response).location();
                        res.sendRedirect(location);
                        logger.atFinest().log("REST call redirected to: %s", location);
                        return;
                    } else if (response instanceof Response.Accepted) {
                        CacheHeaders.setNotCacheable(res);
                        res.setStatus(response.statusCode());
                        res.setHeader(HttpHeaders.LOCATION, ((Response.Accepted) response).location());
                        logger.atFinest().log("REST call succeeded: %d", response.statusCode());
                        return;
                    }
                    statusCode = response.statusCode();
                    configureCaching(req, res, traceContext, rsrc, viewData, response.caching());
                    res.setStatus(statusCode);
                    logger.atFinest().log("REST call succeeded: %d", statusCode);
                }
                if (response != Response.none()) {
                    Object value = Response.unwrap(response);
                    if (value instanceof BinaryResult) {
                        responseBytes = replyBinaryResult(req, res, (BinaryResult) value);
                    } else {
                        responseBytes = replyJson(req, res, false, qp.config(), value);
                    }
                }
            }
        } catch (MalformedJsonException | JsonParseException e) {
            cause = Optional.of(e);
            logger.atFine().withCause(e).log("REST call failed on JSON parsing");
            responseBytes = replyError(req, res, statusCode = SC_BAD_REQUEST, "Invalid " + JSON_TYPE + " in request", e);
        } catch (BadRequestException e) {
            cause = Optional.of(e);
            responseBytes = replyError(req, res, statusCode = SC_BAD_REQUEST, messageOr(e, "Bad Request"), e.caching(), e);
        } catch (AuthException e) {
            cause = Optional.of(e);
            responseBytes = replyError(req, res, statusCode = SC_FORBIDDEN, messageOr(e, "Forbidden"), e.caching(), e);
        } catch (AmbiguousViewException e) {
            cause = Optional.of(e);
            responseBytes = replyError(req, res, statusCode = SC_NOT_FOUND, messageOr(e, "Ambiguous"), e);
        } catch (ResourceNotFoundException e) {
            cause = Optional.of(e);
            responseBytes = replyError(req, res, statusCode = SC_NOT_FOUND, messageOr(e, "Not Found"), e.caching(), e);
        } catch (MethodNotAllowedException e) {
            cause = Optional.of(e);
            responseBytes = replyError(req, res, statusCode = SC_METHOD_NOT_ALLOWED, messageOr(e, "Method Not Allowed"), e.caching(), e);
        } catch (ResourceConflictException e) {
            cause = Optional.of(e);
            responseBytes = replyError(req, res, statusCode = SC_CONFLICT, messageOr(e, "Conflict"), e.caching(), e);
        } catch (PreconditionFailedException e) {
            cause = Optional.of(e);
            responseBytes = replyError(req, res, statusCode = SC_PRECONDITION_FAILED, messageOr(e, "Precondition Failed"), e.caching(), e);
        } catch (UnprocessableEntityException e) {
            cause = Optional.of(e);
            responseBytes = replyError(req, res, statusCode = SC_UNPROCESSABLE_ENTITY, messageOr(e, "Unprocessable Entity"), e.caching(), e);
        } catch (NotImplementedException e) {
            cause = Optional.of(e);
            logger.atSevere().withCause(e).log("Error in %s %s", req.getMethod(), uriForLogging(req));
            responseBytes = replyError(req, res, statusCode = SC_NOT_IMPLEMENTED, messageOr(e, "Not Implemented"), e);
        } catch (QuotaException e) {
            cause = Optional.of(e);
            responseBytes = replyError(req, res, statusCode = SC_TOO_MANY_REQUESTS, messageOr(e, "Quota limit reached"), e.caching(), e);
        } catch (InvalidDeadlineException e) {
            cause = Optional.of(e);
            responseBytes = replyError(req, res, statusCode = SC_BAD_REQUEST, messageOr(e, "Bad Request"), e);
        } catch (Exception e) {
            cause = Optional.of(e);
            Optional<RequestCancelledException> requestCancelledException = RequestCancelledException.getFromCausalChain(e);
            if (requestCancelledException.isPresent()) {
                RequestStateProvider.Reason cancellationReason = requestCancelledException.get().getCancellationReason();
                globals.cancellationMetrics.countCancelledRequest(RequestInfo.RequestType.REST, requestUri, cancellationReason);
                statusCode = getCancellationStatusCode(cancellationReason);
                responseBytes = replyError(req, res, statusCode, getCancellationMessage(requestCancelledException.get()), e);
            } else {
                statusCode = SC_INTERNAL_SERVER_ERROR;
                Optional<ExceptionHook.Status> status = getStatus(e);
                statusCode = status.map(ExceptionHook.Status::statusCode).orElse(SC_INTERNAL_SERVER_ERROR);
                if (res.isCommitted()) {
                    responseBytes = 0;
                    if (statusCode == SC_INTERNAL_SERVER_ERROR) {
                        logger.atSevere().withCause(e).log("Error in %s %s, response already committed", req.getMethod(), uriForLogging(req));
                    } else {
                        logger.atWarning().log("Response for %s %s already committed, wanted to set status %d", req.getMethod(), uriForLogging(req), statusCode);
                    }
                } else {
                    res.reset();
                    TraceContext.getTraceId().ifPresent(traceId -> res.addHeader(X_GERRIT_TRACE, traceId));
                    if (status.isPresent()) {
                        responseBytes = reply(req, res, e, status.get(), getUserMessages(e));
                    } else {
                        responseBytes = replyInternalServerError(req, res, e, getUserMessages(e));
                    }
                }
            }
        } finally {
            String metric = getViewName(viewData);
            String formattedCause = cause.map(globals.retryHelper::formatCause).orElse("_none");
            globals.metrics.count.increment(metric);
            if (statusCode >= SC_BAD_REQUEST) {
                globals.metrics.errorCount.increment(metric, statusCode, formattedCause);
            }
            if (responseBytes != -1) {
                globals.metrics.responseBytes.record(metric, responseBytes);
            }
            globals.metrics.serverLatency.record(metric, System.nanoTime() - startNanos, TimeUnit.NANOSECONDS);
            globals.auditService.dispatch(new ExtendedHttpAuditEvent(globals.webSession.get().getSessionId(), globals.currentUser.get(), req, auditStartTs, qp != null ? qp.params() : ImmutableListMultimap.of(), inputRequestBody, statusCode, response, rsrc, viewData == null ? null : viewData.view));
        }
    }
}

Example 49 with MethodNotAllowedException

use of com.google.gerrit.extensions.restapi.MethodNotAllowedException in project gerrit by GerritCodeReview.

the class RestApiServlet method parseRequest.

private Object parseRequest(HttpServletRequest req, Type type) throws IOException, BadRequestException, SecurityException, IllegalArgumentException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, MethodNotAllowedException {
    // 400). Consume the request body for all but raw input request types here.
    if (isType(JSON_TYPE, req.getContentType())) {
        try (BufferedReader br = req.getReader();
            JsonReader json = new JsonReader(br)) {
            try {
                json.setLenient(true);
                JsonToken first;
                try {
                    first = json.peek();
                } catch (EOFException e) {
                    throw new BadRequestException("Expected JSON object", e);
                }
                if (first == JsonToken.STRING) {
                    return parseString(json.nextString(), type);
                }
                return OutputFormat.JSON.newGson().fromJson(json, type);
            } finally {
                try {
                    // Reader.close won't consume the rest of the input. Explicitly consume the request
                    // body.
                    br.skip(Long.MAX_VALUE);
                } catch (Exception e) {
                // ignore, e.g. trying to consume the rest of the input may fail if the request was
                // cancelled
                }
            }
        }
    }
    String method = req.getMethod();
    if (("PUT".equals(method) || "POST".equals(method)) && acceptsRawInput(type)) {
        return parseRawInput(req, type);
    }
    if (isDelete(req) && hasNoBody(req)) {
        return null;
    }
    if (hasNoBody(req)) {
        return createInstance(type);
    }
    if (isType(PLAIN_TEXT, req.getContentType())) {
        try (BufferedReader br = req.getReader()) {
            char[] tmp = new char[256];
            StringBuilder sb = new StringBuilder();
            int n;
            while (0 < (n = br.read(tmp))) {
                sb.append(tmp, 0, n);
            }
            return parseString(sb.toString(), type);
        }
    }
    if (isPost(req) && isType(FORM_TYPE, req.getContentType())) {
        return OutputFormat.JSON.newGson().fromJson(ParameterParser.formToJson(req), type);
    }
    throw new BadRequestException("Expected Content-Type: " + JSON_TYPE);
}

Example 50 with MethodNotAllowedException

use of com.google.gerrit.extensions.restapi.MethodNotAllowedException in project gerrit by GerritCodeReview.

the class PutAgreement method apply.

@Override
public Response<String> apply(AccountResource resource, AgreementInput input) throws IOException, RestApiException, ConfigInvalidException {
    if (!agreementsEnabled) {
        throw new MethodNotAllowedException("contributor agreements disabled");
    }
    if (!self.get().hasSameAccountId(resource.getUser())) {
        throw new AuthException("not allowed to enter contributor agreement");
    }
    String agreementName = Strings.nullToEmpty(input.name);
    ContributorAgreement ca = projectCache.getAllProjects().getConfig().getContributorAgreements().get(agreementName);
    if (ca == null) {
        throw new UnprocessableEntityException("contributor agreement not found");
    }
    if (ca.getAutoVerify() == null) {
        throw new BadRequestException("cannot enter a non-autoVerify agreement");
    }
    AccountGroup.UUID uuid = ca.getAutoVerify().getUUID();
    if (uuid == null) {
        throw new ResourceConflictException("autoverify group uuid not found");
    }
    AccountState accountState = self.get().state();
    try {
        addMembers.addMembers(uuid, ImmutableSet.of(accountState.account().id()));
    } catch (NoSuchGroupException e) {
        throw new ResourceConflictException("autoverify group not found", e);
    }
    agreementSignup.fire(accountState, agreementName);
    return Response.ok(agreementName);
}