/** * 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 StreamRequest addResponseCompressionHeaders(CompressionOption responseCompressionOverride, StreamRequest req) { StreamRequestBuilder 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(req.getEntityStream()); } }
@Override public void onSuccess(EntityStream[] result) { if (result.length == 1) { StreamRequest uncompressedRequest = request.builder().build(result[0]); nextFilter.onRequest(uncompressedRequest, requestContext, wireAttrs); } else { StreamRequestBuilder builder = request.builder(); EntityStream compressedStream = compressor.deflate(EntityStreams.newEntityStream(new CompositeWriter(result))); Map<String, String> headers = stripHeaders(builder.getHeaders(), HttpConstants.CONTENT_LENGTH); StreamRequest compressedRequest = builder.setHeaders(headers) .setHeader(HttpConstants.CONTENT_ENCODING, compressor.getContentEncodingName()) .build(compressedStream); nextFilter.onRequest(compressedRequest, requestContext, wireAttrs); } } });
@Override public void onSuccess(EntityStream[] results) { if (results.length == 1) // entity stream is less than threshold { StreamResponse response = res.builder().build(results[0]); nextFilter.onResponse(response, requestContext, wireAttrs); } else { EntityStream compressedStream = compressor.deflate(EntityStreams.newEntityStream(new CompositeWriter(results))); StreamResponseBuilder builder = res.builder(); // remove original content-length header if presents. if (builder.getHeader(HttpConstants.CONTENT_LENGTH) != null) { Map<String, String> headers = stripHeaders(builder.getHeaders(), HttpConstants.CONTENT_LENGTH); builder.setHeaders(headers); } StreamResponse response = builder.addHeaderValue(HttpConstants.CONTENT_ENCODING, compressor.getContentEncodingName()) .build(compressedStream); nextFilter.onResponse(response, requestContext, wireAttrs); } } });
String requestContentEncoding = req.getHeader(HttpConstants.CONTENT_ENCODING); if (requestContentEncoding != null) EntityStream uncompressedStream = compressor.inflate(req.getEntityStream()); Map<String, String> headers = stripHeaders(req.getHeaders(), HttpConstants.CONTENT_ENCODING, HttpConstants.CONTENT_LENGTH); req = req.builder().setHeaders(headers).build(uncompressedStream); String responseCompression = req.getHeader(HttpConstants.ACCEPT_ENCODING); if (responseCompression == null) StreamResponse streamResponse = new StreamResponseBuilder().setStatus(HttpConstants.UNSUPPORTED_MEDIA_TYPE).build(EntityStreams.emptyStream()); nextFilter.onError(new StreamException(streamResponse, ex), requestContext, wireAttrs);
StreamResponse response = se.getResponse(); String compressionHeader = response.getHeader(HttpConstants.CONTENT_ENCODING); EntityStream uncompressedStream = compressor.inflate(response.getEntityStream()); StreamResponseBuilder builder = response.builder(); Map<String, String> headers = stripHeaders(builder.getHeaders(), HttpConstants.CONTENT_ENCODING, HttpConstants.CONTENT_LENGTH); response = builder.setHeaders(headers).build(uncompressedStream); ex = new StreamException(response);
response = new StreamResponseBuilder().setStatus(HttpConstants.NOT_ACCEPTABLE).build(EntityStreams.emptyStream()); res.getEntityStream().setReader(reader); return;
Arrays.fill(entity, (byte)'A'); StreamRequest streamRequest = new StreamRequestBuilder(new URI(URI)) .setMethod(RestMethod.POST) .build(EntityStreams.newEntityStream(new ByteStringWriter(ByteString.copy(entity)))); FullEntityReader reader = new FullEntityReader(callback); captureFilter.getEntityStream().setReader(reader);
String compressionHeader = res.getHeader(HttpConstants.CONTENT_ENCODING); EntityStream uncompressedStream = compressor.inflate(res.getEntityStream()); StreamResponseBuilder builder = res.builder(); Map<String, String> headers = stripHeaders(builder.getHeaders(), HttpConstants.CONTENT_ENCODING, HttpConstants.CONTENT_LENGTH); res = builder.setHeaders(headers).build(uncompressedStream);
Arrays.fill(entity, (byte)'A'); StreamRequest streamRequest = new StreamRequestBuilder(new URI(URI)) .setMethod(RestMethod.POST) .build(EntityStreams.newEntityStream(new ByteStringWriter(ByteString.copy(entity))));
public static StreamRequest toStreamRequest(StreamRequest request, Map<String, String> headers) { return request.builder() .unsafeSetHeaders(headers) .build(request.getEntityStream()); }
@Test(dataProvider = "operationsData") public void testCompressionOperations(String compressionConfig, String[] operations, boolean headerShouldBePresent) throws URISyntaxException { StreamRequest streamRequest = new StreamRequestBuilder(new URI(URI)).build(EntityStreams.emptyStream()); ClientStreamCompressionFilter clientCompressionFilter = new ClientStreamCompressionFilter(StreamEncodingType.IDENTITY.getHttpName(), new CompressionConfig(Integer.MAX_VALUE), ACCEPT_COMPRESSIONS, new CompressionConfig(Integer.MAX_VALUE), Arrays.asList(compressionConfig.split(",")), Executors.newCachedThreadPool() ); for (String operation: operations) { RequestContext context = new RequestContext(); context.putLocalAttr(R2Constants.OPERATION, operation); clientCompressionFilter.onStreamRequest(streamRequest, context, Collections.<String, String>emptyMap(), new HeaderCaptureFilter(HttpConstants.ACCEPT_ENCODING, headerShouldBePresent)); } }
@Override public void onRequest(StreamRequest streamRequest, RequestContext requestContext, Map<String, String> wireAttrs) { String header = streamRequest.getHeader(_headerName); if (_shouldBePresent) { Assert.assertNotNull(header); } else { Assert.assertNull(header); } if (_entityLength > 0) { _entityStream = streamRequest.getEntityStream(); } }
req.getEntityStream().setReader(reader); return;
@Override public StreamRequest build(EntityStream entityStream) { return new StreamRequestImpl(entityStream, getHeaders(), getCookies(), getURI(), getMethod()); }
@Override public StreamResponse build(EntityStream entityStream) { return new StreamResponseImpl(entityStream, getHeaders(), getCookies(), getStatus()); }
@Override public StreamResponseBuilder builder() { return new StreamResponseBuilder(this); }
@Override public StreamResponse buildCanonical(EntityStream entityStream) { return new StreamResponseImpl(entityStream, getCanonicalHeaders(), getCanonicalCookies(), getStatus()); } }
@Override public StreamRequestBuilder builder() { return new StreamRequestBuilder(this); }
@Override public String toString() { return "StreamRequest[headers=" + getHeaders() + ",cookies=" + getCookies() + ",uri=" + getURI() + ",method=" + getMethod() + "]"; } }
@Override public String toString() { return "StreamResponse[headers=" + getHeaders() + ",cookies=" + getCookies() + ",status=" + getStatus() + "]"; } }