private boolean hasRequestContextTimeout(RequestContext requestContext) { Object requestTimeout = requestContext.getLocalAttr(R2Constants.REQUEST_TIMEOUT); return (requestTimeout instanceof Number) && (((Number)requestTimeout).intValue() > 0); }
public void setLocalAttr(final String name, final String value) { this.requestContext.putLocalAttr(name, value); }
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((_request == null) ? 0 : _request.hashCode()); result = prime * result + ((_requestContext == null) ? 0 : _requestContext.hashCode()); return result; }
Boolean decompressionOff = (Boolean) requestContext.getLocalAttr(R2Constants.RESPONSE_DECOMPRESSION_OFF); if (decompressionOff == null || !decompressionOff) 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);
@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 = "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)); }
NextFilter<StreamRequest, StreamResponse> nextFilter) Boolean decompressionOff = (Boolean) requestContext.getLocalAttr(R2Constants.RESPONSE_DECOMPRESSION_OFF); if (decompressionOff == null || !decompressionOff) 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);
private <T> RequestContext createRequestContext(Request<T> request) { RequestContext requestContext = new RequestContext(); requestContext.putLocalAttr("method", request.getMethod()); return requestContext; }
public MockResourceContext() { this.requestHeaders = new HashMap<>(); this.requestContext = new RequestContext(); }
public int getResponseCompressionThreshold(MessageHeaders message) throws CompressionException { String responseCompressionThreshold = message.getHeader(HttpConstants.HEADER_RESPONSE_COMPRESSION_THRESHOLD); // If Response-Compression-Threshold header is present, use that value. If not, use the value in _defaultResponseCompressionConfig. if (responseCompressionThreshold != null) { try { return Integer.parseInt(responseCompressionThreshold); } catch (NumberFormatException e) { throw new CompressionException(CompressionConstants.INVALID_THRESHOLD + responseCompressionThreshold); } } return _defaultResponseCompressionConfig.getCompressionThreshold(); } }
@Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; RestRequestBatchKey other = (RestRequestBatchKey) obj; if (_request == null) { if (other._request != null) return false; } else if (!_request.equals(other._request)) return false; if (_requestContext == null) { if (other._requestContext != null) return false; } else if (!_requestContext.equals(other._requestContext)) return false; return true; }
private <T> RequestContext createRequestContext(Request<T> request) { RequestContext requestContext = new RequestContext(); requestContext.putLocalAttr("method", request.getMethod()); return requestContext; }
public static String getRealClientIpAddr(final ResourceContext context) { // If some upstream device added an X-Forwarded-For header // use it for the client ip // This will support scenarios where load balancers or gateways // front the Azkaban web server and a changing Ip address invalidates // the session final Map<String, String> headers = context.getRequestHeaders(); final WebUtils utils = new WebUtils(); return utils.getRealClientIpAddr(headers, (String) context.getRawRequestContext().getLocalAttr("REMOTE_ADDR")); } }
/** * Creates new ParSeqRestClient with default configuration. * * @deprecated Please use {@link ParSeqRestliClientBuilder} to create instances. */ @Deprecated public ParSeqRestClient(final Client client) { ArgumentUtil.requireNotNull(client, "client"); _client = client; _requestConfigProvider = RequestConfigProvider.build(new ParSeqRestliClientConfigBuilder().build(), () -> Optional.empty()); _requestContextProvider = request -> new RequestContext(); _d2RequestTimeoutEnabled = false; }
if (taskNeedTimeout) { requestContext.putLocalAttr(R2Constants.REQUEST_TIMEOUT, timeout.getValue().intValue()); requestContext.putLocalAttr(R2Constants.REQUEST_TIMEOUT_IGNORE_IF_HIGHER_THAN_DEFAULT, true);
@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); }
private void verifyRequestContextTimeout(Request<?> request, int timeout, Boolean ignoreIfHigher) { assertTrue(_capturingRestClient.getCapturedRequestContexts().containsKey(request)); RequestContext context = _capturingRestClient.getCapturedRequestContexts().get(request); Number contextTimeout = (Number)context.getLocalAttr(R2Constants.REQUEST_TIMEOUT); assertNotNull(contextTimeout); assertEquals(contextTimeout.intValue(), timeout); if (ignoreIfHigher == null) { assertNull(context.getLocalAttr(R2Constants.REQUEST_TIMEOUT_IGNORE_IF_HIGHER_THAN_DEFAULT)); } else { assertEquals(context.getLocalAttr(R2Constants.REQUEST_TIMEOUT_IGNORE_IF_HIGHER_THAN_DEFAULT), ignoreIfHigher); } } }
/** * Creates new ParSeqRestClient with default configuration. * * @deprecated Please use {@link ParSeqRestliClientBuilder} to create instances. */ @Deprecated public ParSeqRestClient(final RestClient client) { ArgumentUtil.requireNotNull(client, "client"); _client = client; _requestConfigProvider = RequestConfigProvider.build(new ParSeqRestliClientConfigBuilder().build(), () -> Optional.empty()); _requestContextProvider = request -> new RequestContext(); _d2RequestTimeoutEnabled = false; }
@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); }
private void verifyRequestContext(Request<?> request) { assertTrue(_capturingRestClient.getCapturedRequestContexts().containsKey(request)); assertNotNull(_capturingRestClient.getCapturedRequestContexts().get(request).getLocalAttr("method")); assertEquals(_capturingRestClient.getCapturedRequestContexts().get(request).getLocalAttr("method"), request.getMethod()); }