Refine search
private void respondError(RestRequest request, RestChannel channel, String error, RestStatus status) { try { XContentBuilder builder = RestXContentBuilder.restContentBuilder(request); builder.startObject(); builder.field("success", false); builder.field("error", error); builder.endObject(); channel.sendResponse(new BytesRestResponse(status, builder)); } catch (IOException e) { errorResponse(request, channel, e); } }
@Override public XContentBuilder newBuilder() throws IOException { return delegate.newBuilder(); }
@Override public RestResponse buildResponse(GetIndexResponse getIndexResponse, XContentBuilder builder) throws Exception { GetIndexRequest.Feature[] features = getIndexRequest.features(); String[] indices = getIndexResponse.indices(); builder.startObject(); for (String index : indices) { builder.startObject(index); for (GetIndexRequest.Feature feature : features) { switch (feature) { case ALIASES: writeAliases(getIndexResponse.aliases().get(index), builder, channel.request()); break; case MAPPINGS: writeMappings(getIndexResponse.mappings().get(index), builder, channel.request()); break; case SETTINGS: writeSettings(getIndexResponse.settings().get(index), builder, channel.request()); break; default: throw new IllegalStateException("feature [" + feature + "] is not valid"); } } builder.endObject(); } builder.endObject(); return new BytesRestResponse(RestStatus.OK, builder); } private void writeAliases(List<AliasMetaData> aliases, XContentBuilder builder, ToXContent.Params params) throws IOException {
static BytesRestResponse createSimpleErrorResponse(RestChannel channel, RestStatus status, String errorMessage) throws IOException { return new BytesRestResponse(status, channel.newErrorBuilder().startObject() .field("error", errorMessage) .field("status", status.getStatus()) .endObject()); }
/** * Handle a requests with no candidate handlers (return a 400 Bad Request * error). */ private void handleBadRequest(RestRequest request, RestChannel channel) throws IOException { try (XContentBuilder builder = channel.newErrorBuilder()) { builder.startObject(); { builder.field("error", "no handler found for uri [" + request.uri() + "] and method [" + request.method() + "]"); } builder.endObject(); channel.sendResponse(new BytesRestResponse(BAD_REQUEST, builder)); } }
private void badRequest(RestChannel channel, String message) { try { XContentBuilder builder = channel.newErrorBuilder(); channel.sendResponse(new BytesRestResponse(BAD_REQUEST, builder.startObject().field("error", message).endObject())); } catch (IOException e) { logger.warn("Failed to send response", e); } }
private static XContentBuilder build(RestChannel channel, RestStatus status, Exception e) throws IOException { ToXContent.Params params = channel.request(); if (params.paramAsBoolean("error_trace", !REST_EXCEPTION_SKIP_STACK_TRACE_DEFAULT)) { params = new ToXContent.DelegatingMapParams(singletonMap(REST_EXCEPTION_SKIP_STACK_TRACE, "false"), params); } else if (e != null) { Supplier<?> messageSupplier = () -> new ParameterizedMessage("path: {}, params: {}", channel.request().rawPath(), channel.request().params()); if (status.getStatus() < 500) { SUPPRESSED_ERROR_LOGGER.debug(messageSupplier, e); } else { SUPPRESSED_ERROR_LOGGER.warn(messageSupplier, e); } } XContentBuilder builder = channel.newErrorBuilder().startObject(); ElasticsearchException.generateFailureXContent(builder, params, e, channel.detailedErrorsEnabled()); builder.field(STATUS, status.getStatus()); builder.endObject(); return builder; }
/** * Checks the request parameters against enabled settings for error trace support * @return true if the request does not have any parameters that conflict with system settings */ boolean checkRequestParameters(final RestRequest request, final RestChannel channel) { // error_trace cannot be used when we disable detailed errors if (channel.detailedErrorsEnabled() == false && request.paramAsBoolean("error_trace", false)) { try { XContentBuilder builder = channel.newErrorBuilder(); builder.startObject().field("error","error traces in responses are disabled.").endObject().string(); RestResponse response = new BytesRestResponse(BAD_REQUEST, builder); response.addHeader("Content-Type", "application/json"); channel.sendResponse(response); } catch (IOException e) { logger.warn("Failed to send response", e); } return false; } return true; }
public static RestResponse buildXContentBuilder(Table table, RestChannel channel) throws Exception { RestRequest request = channel.request(); XContentBuilder builder = channel.newBuilder(); List<DisplayHeader> displayHeaders = buildDisplayHeaders(table, request); builder.startArray(); List<Integer> rowOrder = getRowOrder(table, request); for (Integer row : rowOrder) { builder.startObject(); for (DisplayHeader header : displayHeaders) { builder.field(header.display, renderValue(request, table.getAsMap().get(header.name).get(row).value)); } builder.endObject(); } builder.endArray(); return new BytesRestResponse(RestStatus.OK, builder); }
/** */ private void onFailure(RestRequest request, RestChannel channel, Exception e) throws Exception{ try{ channel.sendResponse(new BytesRestResponse(channel, e)); } catch (IOException ioe){ logger.error("Sending failure response fails !", e); channel.sendResponse(new BytesRestResponse(RestStatus.INTERNAL_SERVER_ERROR)); } } }
private void errorResponse(RestRequest request, RestChannel channel, Throwable e) { try { channel.sendResponse(new XContentThrowableRestResponse(request, e)); logger.error("errorResponse", e); } catch (IOException ioEx) { logger.error("Failed to send failure response", ioEx); } }
@Override protected RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) { try (XContentParser parser = request.contentOrSourceParamParser()) { parser.mapStrings().forEach((k, v) -> request.params().putIfAbsent(k, v)); } catch (IOException e) { LOGGER.warn("Please use json format params, like: {\"sql\":\"SELECT * FROM test\"}"); String sql = request.param("sql"); if (request.path().endsWith("/_explain")) { final String jsonExplanation = queryAction.explain().explain(); return channel -> channel.sendResponse(new BytesRestResponse(RestStatus.OK, XContentType.JSON.mediaType(), jsonExplanation)); } else { Map<String, String> params = request.params();
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { boolean helpWanted = request.paramAsBoolean("help", false); if (helpWanted) { return channel -> { Table table = getTableWithHeader(request); int[] width = buildHelpWidths(table, request); BytesStream bytesOutput = Streams.flushOnCloseStream(channel.bytesOutput()); UTF8StreamWriter out = new UTF8StreamWriter().setOutput(bytesOutput); for (Table.Cell cell : table.getHeaders()) { // need to do left-align always, so create new cells pad(new Table.Cell(cell.value), width[0], request, out); out.append(" | "); pad(new Table.Cell(cell.attr.containsKey("alias") ? cell.attr.get("alias") : ""), width[1], request, out); out.append(" | "); pad(new Table.Cell(cell.attr.containsKey("desc") ? cell.attr.get("desc") : "not available"), width[2], request, out); out.append("\n"); } out.close(); channel.sendResponse(new BytesRestResponse(RestStatus.OK, BytesRestResponse.TEXT_CONTENT_TYPE, bytesOutput.bytes())); }; } else { return doCatRequest(request, client); } }
public static RestResponse buildTextPlainResponse(Table table, RestChannel channel) throws IOException { RestRequest request = channel.request(); boolean verbose = request.paramAsBoolean("v", false); BytesStream bytesOut = Streams.flushOnCloseStream(channel.bytesOutput()); UTF8StreamWriter out = new UTF8StreamWriter().setOutput(bytesOut); int lastHeader = headers.size() - 1; return new BytesRestResponse(RestStatus.OK, BytesRestResponse.TEXT_CONTENT_TYPE, bytesOut.bytes());
private void list(RestRequest request, RestChannel channel, Client esClient) { try { Map<String, Object> rivers = getRivers(request.paramAsInt("page", 1), request.paramAsInt("count", 10), esClient); XContentBuilder builder = RestXContentBuilder.restContentBuilder(request); builder.value(rivers); channel.sendResponse(new BytesRestResponse(RestStatus.OK, builder)); } catch (Throwable e) { errorResponse(request, channel, e); } }
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { final GetRequest getRequest = new GetRequest(request.param("index"), request.param("type"), request.param("id")); getRequest.refresh(request.paramAsBoolean("refresh", getRequest.refresh())); getRequest.routing(request.param("routing")); getRequest.parent(request.param("parent")); getRequest.preference(request.param("preference")); getRequest.realtime(request.paramAsBoolean("realtime", getRequest.realtime())); getRequest.fetchSourceContext(FetchSourceContext.parseFromRestRequest(request)); return channel -> { if (getRequest.fetchSourceContext() != null && !getRequest.fetchSourceContext().fetchSource()) { final ActionRequestValidationException validationError = new ActionRequestValidationException(); validationError.addValidationError("fetching source can not be disabled"); channel.sendResponse(new BytesRestResponse(channel, validationError)); } else { client.get(getRequest, new RestGetSourceResponseListener(channel, request)); } }; }
public void sendErrorResponse(RestRequest request, RestChannel channel, Throwable e) { try { channel.sendResponse(new BytesRestResponse(channel, e)); } catch (Throwable e1) { logger.error("failed to send failure response for uri [" + request.uri() + "]", e1); } }
final int contentLength = request.hasContent() ? request.content().length() : 0; requestHandled = true; } else if (contentLength > 0 && mHandler.map(h -> h.supportsContentStream()).orElse(false) && request.getXContentType() != XContentType.JSON && request.getXContentType() != XContentType.SMILE) { channel.sendResponse(BytesRestResponse.createSimpleErrorResponse(channel, RestStatus.NOT_ACCEPTABLE, "Content-Type [" + request.getXContentType() + "] does not support stream parsing. Use JSON or SMILE instead")); requestHandled = true; } catch (Exception e) { responseChannel.sendResponse(new BytesRestResponse(responseChannel, e));
public void sendResponse(RestChannel channel){ try { String json = ElasticUtils.hitsAsStringResult(results,metaResults); BytesRestResponse bytesRestResponse = new BytesRestResponse(RestStatus.OK, json); channel.sendResponse(bytesRestResponse); } catch (IOException e) { e.printStackTrace(); } }
@Override public boolean reRequestAuthentication(final RestChannel channel, AuthCredentials creds) { final BytesRestResponse wwwAuthenticateResponse = new BytesRestResponse(RestStatus.UNAUTHORIZED, "Unauthorized"); wwwAuthenticateResponse.addHeader("WWW-Authenticate", "Basic realm=\"Search Guard\""); channel.sendResponse(wwwAuthenticateResponse); return true; }