public void setLocalAttr(final String name, final String value) { this.requestContext.putLocalAttr(name, value); }
private <T> RequestContext createRequestContext(Request<T> request) { RequestContext requestContext = new RequestContext(); requestContext.putLocalAttr("method", request.getMethod()); return requestContext; }
private <T> RequestContext createRequestContext(Request<T> request) { RequestContext requestContext = new RequestContext(); requestContext.putLocalAttr("method", request.getMethod()); return requestContext; }
if (taskNeedTimeout) { requestContext.putLocalAttr(R2Constants.REQUEST_TIMEOUT, timeout.getValue().intValue()); requestContext.putLocalAttr(R2Constants.REQUEST_TIMEOUT_IGNORE_IF_HIGHER_THAN_DEFAULT, true);
@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)); } }
requestContext.putLocalAttr(HttpConstants.ACCEPT_ENCODING, responseAcceptedEncodings); requestContext.putLocalAttr(HttpConstants.HEADER_RESPONSE_COMPRESSION_THRESHOLD, _serverCompressionHelper.getResponseCompressionThreshold(req));
@Test(dataProvider = "responseCompressionData") public void testResponseCompressionRules(CompressionConfig responseCompressionConfig, CompressionOption responseCompressionOverride, String expectedAcceptEncoding, String expectedCompressionThreshold, String operation) throws CompressionException, URISyntaxException { ClientCompressionFilter clientCompressionFilter = new ClientCompressionFilter(EncodingType.SNAPPY.getHttpName(), new CompressionConfig(Integer.MAX_VALUE), ACCEPT_COMPRESSIONS, responseCompressionConfig, Arrays.asList(ClientCompressionHelper.COMPRESS_ALL_RESPONSES_INDICATOR)); RestRequest restRequest = new RestRequestBuilder(new URI(URI)).build(); RequestContext context = new RequestContext(); if (operation != null) { context.putLocalAttr(R2Constants.OPERATION, operation); } context.putLocalAttr(R2Constants.RESPONSE_COMPRESSION_OVERRIDE, responseCompressionOverride); clientCompressionFilter.onRestRequest(restRequest, context, Collections.<String, String>emptyMap(), new HeaderCaptureFilter(HttpConstants.ACCEPT_ENCODING, expectedAcceptEncoding)); clientCompressionFilter.onRestRequest(restRequest, context, Collections.<String, String>emptyMap(), new HeaderCaptureFilter(HttpConstants.HEADER_RESPONSE_COMPRESSION_THRESHOLD, expectedCompressionThreshold)); }
@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)); } }
if (operation != null) context.putLocalAttr(R2Constants.OPERATION, operation); context.putLocalAttr(R2Constants.REQUEST_COMPRESSION_OVERRIDE, requestCompressionOverride); int entityLength = headerShouldBePresent ? compressed : original;
@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)); }
requestContext.putLocalAttr(HttpConstants.HEADER_RESPONSE_COMPRESSION_THRESHOLD, _serverCompressionHelper.getResponseCompressionThreshold(req)); requestContext.putLocalAttr(HttpConstants.ACCEPT_ENCODING, responseCompression); nextFilter.onRequest(req, requestContext, wireAttrs);
if (operation != null) context.putLocalAttr(R2Constants.OPERATION, operation); context.putLocalAttr(R2Constants.REQUEST_COMPRESSION_OVERRIDE, requestCompressionOverride); int entityLength = headerShouldBePresent ? compressed : original;
@Test public void testLongerTimeoutFromContext() { setInboundRequestContext(new InboundRequestContextBuilder() .setName("withD2Timeout") .build()); GetRequest<Greeting> request = new GreetingsBuilders().get().id(1L).build(); RequestContext context = new RequestContext(); context.putLocalAttr(R2Constants.REQUEST_TIMEOUT, 12000); Task<?> task = _parseqClient.createTask(request, context); runAndWait(getTestClassName() + ".testTimeoutRequest", task); assertFalse(hasTask("withTimeout", task.getTrace())); verifyRequestContextTimeout(request, 12000, null); }
@Test public void testTighterTimeoutFromContext() { setInboundRequestContext(new InboundRequestContextBuilder() .setName("withD2Timeout") .build()); GetRequest<Greeting> request = new GreetingsBuilders().get().id(1L).build(); RequestContext context = new RequestContext(); context.putLocalAttr(R2Constants.REQUEST_TIMEOUT, 4000); Task<?> task = _parseqClient.createTask(request, context); runAndWait(getTestClassName() + ".testTimeoutRequest", task); assertFalse(hasTask("withTimeout", task.getTrace())); verifyRequestContextTimeout(request, 4000, null); }
/** * Inserts a hint in RequestContext instructing D2 to bypass normal hashing behavior * and instead route to the specified target service. This is different than * setRequestContextTargetHost because it sets the service context path as well as the host. * @param context RequestContext for the request which will be made * @param targetService target service's URI to be used as a hint in the RequestContext */ public static void setRequestContextTargetService(RequestContext context, URI targetService) { context.putLocalAttr(TARGET_SERVICE_KEY_NAME, targetService); }
/** * Register a {@link TransportCallback} to be invoked for success/error responses. * * @param callback the callback to be invoked on response or error. * @param context the {@link RequestContext} to store the callback. * @param <T> the Response message subtype for the {@link TransportCallback}. */ public static <T> void registerCallback(TransportCallback<T> callback, RequestContext context) { context.putLocalAttr(CALLBACK_ATTR, callback); }
/** * Forces the client compression filter to not decompress responses. * @param requestContext request context to be modified. */ public static void turnOffResponseDecompression(RequestContext requestContext) { requestContext.putLocalAttr(R2Constants.RESPONSE_DECOMPRESSION_OFF, true); } }
private void updateRequestContext(RequestContext requestContext) { SslSessionValidator sslSessionValidator = getValidator(); if (sslSessionValidator != null) { requestContext.putLocalAttr(R2Constants.REQUESTED_SSL_SESSION_VALIDATOR, sslSessionValidator); } }
@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); }
@Override public void onStreamRequest(StreamRequest req, RequestContext requestContext, Map<String, String> wireAttrs, NextFilter<StreamRequest, StreamResponse> nextFilter) { trace("onStreamRequest", req, wireAttrs, requestContext); requestContext.putLocalAttr(REQUEST_URI, req.getURI()); requestContext.putLocalAttr(REQUEST_METHOD, req.getMethod()); nextFilter.onRequest(req, requestContext, wireAttrs); }