/** * @param compressor Compressor associated with this encoding enum */ EncodingType(Compressor compressor) { this.compressor = compressor; httpName = compressor.getContentEncodingName(); }
/** * @return if this encoding has a compressor. Generally, speaking, this is false * for ANY (*). */ public boolean hasCompressor() { return getCompressor() != null; } }
public ServerCompressionFilter(String acceptedFilters, CompressionConfig responseCompressionConfig) { this(AcceptEncoding.parseAcceptEncoding(acceptedFilters), responseCompressionConfig); }
@Test(dataProvider = "headersData") public void testResponseCompressionRules(String acceptEncoding, int compressionThreshold, EncodingType expectedContentEncoding) throws CompressionException, URISyntaxException { ServerCompressionFilter serverCompressionFilter = new ServerCompressionFilter(ACCEPT_COMPRESSIONS); RequestContext context = new RequestContext(); context.putLocalAttr(HttpConstants.ACCEPT_ENCODING, acceptEncoding); context.putLocalAttr(HttpConstants.HEADER_RESPONSE_COMPRESSION_THRESHOLD, compressionThreshold); int originalLength = 100; byte[] entity = new byte[originalLength]; Arrays.fill(entity, (byte) 'A'); int compressedLength = (expectedContentEncoding == null) ? originalLength : expectedContentEncoding.getCompressor().deflate(new ByteArrayInputStream(entity)).length; String expectedContentEncodingName = (expectedContentEncoding == null) ? null : expectedContentEncoding.getHttpName(); RestResponse restResponse = new RestResponseBuilder().setEntity(entity).build(); serverCompressionFilter.onRestResponse(restResponse, context, Collections.<String, String>emptyMap(), new HeaderCaptureFilter(HttpConstants.CONTENT_ENCODING, expectedContentEncodingName, compressedLength)); } }
@Test(dataProvider = "requestCompressionData") public void testRequestCompressionRules(CompressionConfig requestCompressionConfig, CompressionOption requestCompressionOverride, boolean headerShouldBePresent) throws CompressionException, URISyntaxException { ClientCompressionFilter clientCompressionFilter = new ClientCompressionFilter(EncodingType.SNAPPY.getHttpName(), requestCompressionConfig, ACCEPT_COMPRESSIONS, new CompressionConfig(Integer.MAX_VALUE), Collections.<String>emptyList()); // The entity should be compressible for this test. int original = 100; byte[] entity = new byte[original]; Arrays.fill(entity, (byte)'A'); RestRequest restRequest = new RestRequestBuilder(new URI(URI)).setMethod(RestMethod.POST).setEntity(entity).build(); int compressed = EncodingType.SNAPPY.getCompressor().deflate(new ByteArrayInputStream(entity)).length; RequestContext context = new RequestContext(); context.putLocalAttr(R2Constants.REQUEST_COMPRESSION_OVERRIDE, requestCompressionOverride); int entityLength = headerShouldBePresent ? compressed : original; String expectedContentEncoding = headerShouldBePresent ? EncodingType.SNAPPY.getHttpName() : null; clientCompressionFilter.onRestRequest(restRequest, context, Collections.<String, String>emptyMap(), new HeaderCaptureFilter(HttpConstants.CONTENT_ENCODING, expectedContentEncoding, entityLength)); }
else if (requestContentEncoding.equals(EncodingType.ANY)) + requestContentEncoding.getHttpName()); _acceptEncodingHeader = buildAcceptEncodingHeader(acceptedEncodings); _responseCompressionConfig = responseCompressionConfig; _helper = new ClientCompressionHelper(requestCompressionConfig, responseCompressionOperations);
/** * Same as previous constructor, but with comma delimited strings for requestContentEncoding and acceptedEncodings. */ public ClientCompressionFilter(String requestContentEncoding, CompressionConfig requestCompressionConfig, String acceptedEncodings, CompressionConfig responseCompressionConfig, List<String> responseCompressionOperations) { this(requestContentEncoding.trim().isEmpty() ? EncodingType.IDENTITY : EncodingType.get(requestContentEncoding.trim().toLowerCase()), requestCompressionConfig, AcceptEncoding.parseAcceptEncoding(acceptedEncodings), responseCompressionConfig, responseCompressionOperations); }
@Override public byte[] inflate(InputStream data) throws CompressionException { try { byte[] temp = IOUtils.toByteArray(data); return Snappy.uncompress(temp, 0, temp.length); } catch (IOException e) { throw new CompressionException(CompressionConstants.DECODING_ERROR + getContentEncodingName(), e); } }
@Override public byte[] inflate(InputStream data) throws CompressionException { ByteArrayOutputStream out = new ByteArrayOutputStream(); try (SnappyFramedInputStream snappy = new SnappyFramedInputStream(data, true)) { IOUtils.copy(snappy, out); } catch (IOException e) { throw new CompressionException(CompressionConstants.DECODING_ERROR + getContentEncodingName(), e); } return out.toByteArray(); }
@Override public byte[] inflate(InputStream data) throws CompressionException { ByteArrayOutputStream out; GZIPInputStream gzip = null; try { out = new ByteArrayOutputStream(); gzip = new GZIPInputStream(data); IOUtils.copy(gzip, out); } catch (IOException e) { throw new CompressionException(CompressionConstants.DECODING_ERROR + getContentEncodingName(), e); } finally { if (gzip != null) { IOUtils.closeQuietly(gzip); } } return out.toByteArray(); }
@Override public byte[] inflate(InputStream data) throws CompressionException { ByteArrayOutputStream out = new ByteArrayOutputStream(); BZip2CompressorInputStream bzip2 = null; try { bzip2 = new BZip2CompressorInputStream(data); IOUtils.copy(bzip2, out); } catch (IOException e) { throw new CompressionException(CompressionConstants.DECODING_ERROR + getContentEncodingName(), e); } finally { if (bzip2 != null) { IOUtils.closeQuietly(bzip2); } } return out.toByteArray(); }
/** * Takes a comma delimited string of content-encoding values and parses them, * returning an array of parsed EncodingType in the order of * the parsed string. Throws IllegalArgumentException * if something not supported or not recognized shows up. * @param acceptCompression */ public static EncodingType[] parseAcceptEncoding(String acceptCompression) { if(acceptCompression.trim().isEmpty()) { return new EncodingType[0]; } String[] entries = acceptCompression.toLowerCase().split(CompressionConstants.ENCODING_DELIMITER); EncodingType[] types = new EncodingType[entries.length]; for(int i = 0; i < entries.length; i++) { types[i] = EncodingType.get(entries[i].trim()); } return types; }
@Test(dataProvider = "contentEncodingGeneratorDataProvider") public void testEncodingGeneration(EncodingType[] encoding, String acceptEncoding) { Assert.assertEquals(ClientCompressionFilter.buildAcceptEncodingHeader(encoding), acceptEncoding); } }
@Override public int compareTo(AcceptEncoding target) { return new Float(target.getQuality()).compareTo(getQuality()); } }
public ClientCompressionHelper(CompressionConfig requestCompressionConfig, List<String> responseCompressionOperations) { _requestCompressionConfig = requestCompressionConfig; buildResponseCompressionMethodsAndFamiliesSet(responseCompressionOperations); _compressAllResponses = _responseCompressionMethods.contains(COMPRESS_ALL_RESPONSES_INDICATOR); }
/** * Returns true if the client might want a compressed response from the server. * @param operation */ public boolean shouldCompressResponseForOperation(String operation) { if (_compressAllResponses) { return true; } else if (operation == null) { return false; } else { return _responseCompressionMethods.contains(operation) || isMemberOfCompressionFamily(operation); } }
/** Instantiates a compression filter * that supports the compression methods in the given set in argument. * @param supportedEncoding */ public ServerStreamCompressionFilter(StreamEncodingType[] supportedEncoding, Executor executor, int compressThreshold) { _supportedEncoding = new HashSet<StreamEncodingType>(Arrays.asList(supportedEncoding)); _supportedEncoding.add(StreamEncodingType.IDENTITY); _supportedEncoding.add(StreamEncodingType.ANY); _executor = executor; _serverCompressionHelper = new ServerCompressionHelper(compressThreshold); }
@Override public byte[] deflate(InputStream data) throws CompressionException { try { byte[] temp = IOUtils.toByteArray(data); return Snappy.compress(temp); } catch (IOException e) { throw new CompressionException(CompressionConstants.DECODING_ERROR + getContentEncodingName(), e); } } }
@Override public byte[] deflate(InputStream data) throws CompressionException { ByteArrayOutputStream out = new ByteArrayOutputStream(); try (SnappyFramedOutputStream snappy = new SnappyFramedOutputStream(out)) { IOUtils.copy(data, snappy); } catch (IOException e) { throw new CompressionException(CompressionConstants.DECODING_ERROR + getContentEncodingName(), e); } return out.toByteArray(); }
@Override public byte[] deflate(InputStream data) throws CompressionException { ByteArrayOutputStream out; GZIPOutputStream gzip = null; try { out = new ByteArrayOutputStream(); gzip = new GZIPOutputStream(out); IOUtils.copy(data, gzip); } catch (IOException e) { throw new CompressionException(CompressionConstants.DECODING_ERROR + getContentEncodingName(), e); } finally { if (gzip != null) { IOUtils.closeQuietly(gzip); } } return out.toByteArray(); }