String requestContentEncoding = req.getHeader(HttpConstants.CONTENT_ENCODING); byte[] decompressedContent = encoding.getCompressor().inflate(req.getEntity().asInputStream()); Map<String, String> headers = new HashMap<String, String>(req.getHeaders()); headers.remove(HttpConstants.CONTENT_ENCODING); headers.put(HttpConstants.CONTENT_LENGTH, Integer.toString(decompressedContent.length)); req = req.builder().setEntity(decompressedContent).setHeaders(headers).build(); String responseAcceptedEncodings = req.getHeader(HttpConstants.ACCEPT_ENCODING); if (responseAcceptedEncodings == null)
@Override public String toString() { RestRequest request = getRawRequest(); StringBuilder outBuffer = new StringBuilder(); String endl = "\n"; outBuffer.append("R2Request Info").append(endl); outBuffer.append("type: RestRequest").append(endl); outBuffer.append("uri: ").append(request.getURI().toString()).append(endl); outBuffer.append("headers: "); request.getHeaders().forEach((k, v) -> outBuffer.append("[").append(k).append(":").append(v).append("] ") ); outBuffer.append(endl); ByteString entity = request.getEntity(); if (entity != null) { outBuffer.append("body: ").append(entity.asString(Charset.defaultCharset())).append(endl); } return outBuffer.toString(); } }
public static void assertEqual(RestRequestBuilder actual, RestRequestBuilder expect) throws IOException { // Check entity ByteString actualEntity = actual.getEntity(); ByteString expectedEntity = expect.getEntity(); if (actualEntity == null) { Assert.assertTrue(expectedEntity == null); } else { Assert.assertEquals(actualEntity.length(), expectedEntity.length()); Assert.assertEquals(actualEntity.asString(StandardCharsets.UTF_8),expectedEntity.asString(StandardCharsets.UTF_8)); } // Check request RestRequest actualRequest = actual.build(); RestRequest expectedRequest = expect.build(); Assert.assertEquals(actualRequest.getMethod(), expectedRequest.getMethod()); Assert.assertEquals(actualRequest.getURI().toString(), expectedRequest.getURI().toString()); Map<String, String> actualHeaders = actualRequest.getHeaders(); Map<String, String> expectedHeaders = expectedRequest.getHeaders(); Assert.assertEquals(actualHeaders.size(), expectedHeaders.size()); for (String key: actualHeaders.keySet()) { Assert.assertEquals(actualHeaders.get(key), expectedHeaders.get(key)); } } }
@Override public void onRequest(RestRequest restRequest, RequestContext requestContext, Map<String, String> wireAttrs) { String header = restRequest.getHeader(_headerName); Assert.assertEquals(header, _expectedValue); if (_entityLength > 0) { Assert.assertEquals(restRequest.getEntity().length(), _entityLength); } }
/** * Adapts a RestRequest to Netty's HttpRequest * @param request R2 rest request * @return Adapted HttpRequest. */ public static HttpRequest toNettyRequest(RestRequest request) throws Exception { HttpMethod nettyMethod = HttpMethod.valueOf(request.getMethod()); URL url = new URL(request.getURI().toString()); String path = url.getFile(); // RFC 2616, section 5.1.2: // Note that the absolute path cannot be empty; if none is present in the original URI, // it MUST be given as "/" (the server root). if (path.isEmpty()) { path = "/"; } ByteBuf content = Unpooled.wrappedBuffer(request.getEntity().asByteBuffer()); HttpRequest nettyRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, nettyMethod, path, content); nettyRequest.headers().set(HttpConstants.CONTENT_LENGTH, request.getEntity().length()); for (Map.Entry<String, String> entry : request.getHeaders().entrySet()) { nettyRequest.headers().set(entry.getKey(), entry.getValue()); } nettyRequest.headers().set(HttpHeaderNames.HOST, url.getAuthority()); nettyRequest.headers().set(HttpConstants.REQUEST_COOKIE_HEADER_NAME, request.getCookies()); return nettyRequest; }
@Override public void sendAsyncRequestImpl(RestRequest request, Callback<RestResponse> callback) throws IOException { log.debug ("Request URI : {} ", request.getURI()); client.restRequest(request, new com.linkedin.common.callback.Callback<RestResponse>() { @Override public void onError(Throwable e) { callback.onFailure(e); } @Override public void onSuccess(RestResponse result) { callback.onSuccess(result); } }); }
public RestRequestBuilder(RestRequest request) { super(request); _entity = request.getEntity(); }
@Override protected void fillHttpOutputData(Schema schema, GenericRecord outputRecord, RestRequest restRequest, ResponseStatus status) throws IOException { R2ResponseStatus r2ResponseStatus = (R2ResponseStatus) status; HttpRequestResponseRecord record = new HttpRequestResponseRecord(); record.setRequestUrl(restRequest.getURI().toASCIIString()); record.setMethod(restRequest.getMethod()); record.setStatusCode(r2ResponseStatus.getStatusCode()); record.setContentType(r2ResponseStatus.getContentType()); record.setBody(r2ResponseStatus.getContent() == null? null: r2ResponseStatus.getContent().asByteBuffer()); outputRecord.put("HttpRequestResponse", record); }
URI uri = request.getURI(); ByteString entity = request.getEntity(); if (entity == null || entity.length() == 0) MimeMultipart multi = createMultiPartEntity(entity, request.getHeader(HEADER_CONTENT_TYPE), uri.getRawQuery()); requestBuilder.setHeader(HEADER_CONTENT_TYPE, multi.getContentType()); ByteArrayOutputStream os = new ByteArrayOutputStream();
if (_helper.shouldCompressRequest(req.getEntity().length(), (CompressionOption) requestContext.getLocalAttr(R2Constants.REQUEST_COMPRESSION_OVERRIDE) )) byte[] compressed = compressor.deflate(req.getEntity().asInputStream()); if (compressed.length < req.getEntity().length()) req = req.builder().setEntity(compressed).setHeader(HttpConstants.CONTENT_ENCODING, compressor.getContentEncodingName()).build();
private static void inheritHeaders(IndividualRequest individualRequest, RestRequest envelopeRequest) { Map<String, String> envelopeHeaders = HeaderUtil.removeHeaders(envelopeRequest.getHeaders(), HeaderUtil.NONINHERITABLE_REQUEST_HEADERS); if (envelopeHeaders.size() > 0) { individualRequest.setHeaders(new StringMap(HeaderUtil.mergeHeaders(envelopeHeaders, individualRequest.getHeaders()))); } } }
@Override public String getContentType() { return request.getHeader(HEADER_CONTENT_TYPE); }
private void writeReqLine(OutputStream out, Request req) throws IOException { if (req instanceof RestRequest) { write(out, ((RestRequest)req).getMethod()); } else { write(out, POST); } write(out, SP); write(out, req.getURI().toASCIIString()); write(out, SP); write(out, HTTP_1_1); write(out, CRLF); }
/** * Builds HTTP headers related to response compression and creates a RestRequest with those headers added. * * @param responseCompressionOverride compression force on/off override from the request context. * @param req current request. * @return request with response compression headers. */ public RestRequest addResponseCompressionHeaders(CompressionOption responseCompressionOverride, RestRequest req) { RestRequestBuilder builder = req.builder(); if (responseCompressionOverride == null) { builder.addHeaderValue(HttpConstants.ACCEPT_ENCODING, _acceptEncodingHeader); if (_responseCompressionConfig != null) { builder.addHeaderValue(HttpConstants.HEADER_RESPONSE_COMPRESSION_THRESHOLD, Integer.toString(_responseCompressionConfig.getCompressionThreshold())); } } else if (responseCompressionOverride == CompressionOption.FORCE_ON) { builder.addHeaderValue(HttpConstants.ACCEPT_ENCODING, _acceptEncodingHeader) .addHeaderValue(HttpConstants.HEADER_RESPONSE_COMPRESSION_THRESHOLD, Integer.toString(0)); } return builder.build(); }
private static RestRequest createSyntheticRequest(RestRequest envelopeRequest, IndividualRequest individualRequest) throws MimeTypeParseException, IOException { URI uri = URI.create(individualRequest.getRelativeUrl()); ByteString entity = getBodyAsByteString(individualRequest); return new RestRequestBuilder(uri) .setMethod(individualRequest.getMethod()) .setHeaders(individualRequest.getHeaders()) .setCookies(envelopeRequest.getCookies()) .setEntity(entity) .build(); }
@Override protected void encode(ChannelHandlerContext ctx, RestRequest request, List<Object> out) throws Exception { HttpMethod nettyMethod = HttpMethod.valueOf(request.getMethod()); URL url = new URL(request.getURI().toString()); String path = url.getFile(); // RFC 2616, section 5.1.2: // Note that the absolute path cannot be empty; if none is present in the original URI, // it MUST be given as "/" (the server root). if (path.isEmpty()) { path = "/"; } ByteString entity = request.getEntity(); ByteBuf content = Unpooled.wrappedBuffer(entity.asByteBuffer()); FullHttpRequest nettyRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, nettyMethod, path, content); for (Map.Entry<String, String> e : request.getHeaders().entrySet()) { nettyRequest.headers().set(e.getKey(), e.getValue()); } nettyRequest.headers().set(HttpHeaderNames.HOST, url.getAuthority()); nettyRequest.headers().set(HttpConstants.REQUEST_COOKIE_HEADER_NAME, request.getCookies()); nettyRequest.headers().set(HttpHeaderNames.CONTENT_LENGTH, entity.length()); out.add(nettyRequest); } }
@Override public void sendAsyncRequestImpl(RestRequest request, Callback<RestResponse> callback) throws IOException { log.debug ("Request URI : {} ", request.getURI()); client.restRequest(request, new com.linkedin.common.callback.Callback<RestResponse>() { @Override public void onError(Throwable e) { callback.onFailure(e); } @Override public void onSuccess(RestResponse result) { callback.onSuccess(result); } }); }
@Override public InputStream getInputStream() throws IOException { return request.getEntity().asInputStream(); }
@Override public void onRestRequest(RestRequest req, RequestContext requestContext, Map<String, String> wireAttrs, NextFilter<RestRequest, RestResponse> nextFilter) { trace("onRestRequest", req, wireAttrs, requestContext); requestContext.putLocalAttr(REQUEST_URI, req.getURI()); requestContext.putLocalAttr(REQUEST_METHOD, req.getMethod()); nextFilter.onRequest(req, requestContext, wireAttrs); }