public static boolean equivalent(final HttpResponse r1, final HttpResponse r2) { return equivalent(r1.getVersion(), r2.getVersion()) && r1.getCode() == r2.getCode() && LangUtils.equals(r1.getReasonPhrase(), r2.getReasonPhrase()) && isEndToEndHeaderSubset(r1, r2); }
private void ensure200ForOPTIONSRequestWithNoBodyHasContentLengthZero(final HttpRequest request, final HttpResponse response) { if (!request.getMethod().equalsIgnoreCase(HeaderConstants.OPTIONS_METHOD)) { return; } if (response.getCode() != HttpStatus.SC_OK) { return; } if (response.getFirstHeader(HttpHeaders.CONTENT_LENGTH) == null) { response.addHeader(HttpHeaders.CONTENT_LENGTH, "0"); } }
/** * Determines if the given response is generated from a stale cache entry. * @param httpResponse the response to be checked * @return whether the response is stale or not */ boolean isStale(final HttpResponse httpResponse) { for (final Iterator<Header> it = httpResponse.headerIterator(HeaderConstants.WARNING); it.hasNext(); ) { /* * warn-codes * 110 = Response is stale * 111 = Revalidation failed */ final Header warning = it.next(); final String warningValue = warning.getValue(); if (warningValue.startsWith("110") || warningValue.startsWith("111")) { return true; } } return false; }
private void ensure304DoesNotContainExtraEntityHeaders(final HttpResponse response) { final String[] disallowedEntityHeaders = { HeaderConstants.ALLOW, HttpHeaders.CONTENT_ENCODING, "Content-Language", HttpHeaders.CONTENT_LENGTH, "Content-MD5", "Content-Range", HttpHeaders.CONTENT_TYPE, HeaderConstants.LAST_MODIFIED }; if (response.getCode() == HttpStatus.SC_NOT_MODIFIED) { for(final String hdr : disallowedEntityHeaders) { response.removeHeaders(hdr); } } }
private void addMissingContentLengthHeader(final HttpResponse response, final byte[] body) { if (transferEncodingIsPresent(response)) { return; } final Header contentLength = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); if (contentLength == null) { response.setHeader(HttpHeaders.CONTENT_LENGTH, Integer.toString(body.length)); } }
if (response.getCode() == HttpStatus.SC_NO_CONTENT) { final Header clh = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); if (clh != null) { try { if (response.containsHeader(HttpHeaders.TRANSFER_ENCODING)) { return false; final Header teh = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); if (teh != null) { if (!HeaderElements.CHUNKED_ENCODING.equalsIgnoreCase(teh.getValue())) { final String method = request != null ? request.getMethod() : null; if (MessageSupport.canResponseHaveBody(method, response) && response.countHeaders(HttpHeaders.CONTENT_LENGTH) != 1) { return false; Iterator<Header> headerIterator = response.headerIterator(HttpHeaders.CONNECTION); if (!headerIterator.hasNext()) { headerIterator = response.headerIterator("Proxy-Connection");
/** * Creates a cache entry for the given request, origin response message and response content. */ public HttpCacheEntry createtCacheEntry( final HttpRequest request, final HttpResponse originResponse, final ByteArrayBuffer content, final Date requestSent, final Date responseReceived) throws ResourceIOException { return new HttpCacheEntry( requestSent, responseReceived, originResponse.getCode(), originResponse.getHeaders(), content != null ? resourceFactory.generate(request.getRequestUri(), content.array(), 0, content.length()) : null); }
private void identityIsNotUsedInContentEncoding(final HttpResponse response) { final Header[] hdrs = response.getHeaders(HttpHeaders.CONTENT_ENCODING); if (hdrs == null || hdrs.length == 0) { return; return; response.removeHeaders(HttpHeaders.CONTENT_ENCODING); for (final Header h : newHeaders) { response.addHeader(h);
@Override public void consumeResponse( final HttpResponse response, final EntityDetails entityDetails, final HttpContext context, final FutureCallback<Void> resultCallback) throws HttpException, IOException { status = response.getCode(); resultCallbackRef.set(resultCallback); stats.setVersion(response.getVersion()); final Header serverHeader = response.getFirstHeader(HttpHeaders.SERVER); if (serverHeader != null) { stats.setServerName(serverHeader.getValue()); } if (config.getVerbosity() >= 2) { System.out.println(response.getCode()); } if (entityDetails != null) { if (config.getVerbosity() >= 6) { if (entityDetails.getContentType() != null) { final ContentType contentType = ContentType.parseLenient(entityDetails.getContentType()); charset = contentType.getCharset(); } } } else { streamEnd(null); } }
@Test public void testIsGetWithAnyCacheControlCacheable() { response.addHeader("Cache-Control", "max=10"); Assert.assertTrue(policy.isResponseCacheable("GET", response)); response = new BasicHttpResponse(HttpStatus.SC_OK, ""); response.setHeader("Date", DateUtils.formatDate(new Date())); response.addHeader("Cache-Control", "no-transform"); response.setHeader("Content-Length", "0"); Assert.assertTrue(policy.isResponseCacheable("GET", response)); }
if (responseCommitted.compareAndSet(false, true)) { final ProtocolVersion transportVersion = response.getVersion(); if (transportVersion != null && transportVersion.greaterEquals(HttpVersion.HTTP_2)) { throw new UnsupportedHttpVersionException(transportVersion); final int status = response.getCode(); if (status < HttpStatus.SC_SUCCESS) { throw new HttpException("Invalid response: " + status);
private void ensurePartialContentIsNotSentToAClientThatDidNotRequestIt(final HttpRequest request, final HttpResponse response) throws IOException { if (request.getFirstHeader(HeaderConstants.RANGE) != null || response.getCode() != HttpStatus.SC_PARTIAL_CONTENT) { return; } throw new ClientProtocolException(UNEXPECTED_PARTIAL_CONTENT); }
@Override public void onResponseHead(final HttpConnection connection, final HttpResponse response) { if (config.getVerbosity() >= 3) { System.out.println("<< " + response.getCode() + " " + response.getReasonPhrase()); final Header[] headers = response.getHeaders(); for (final Header header : headers) { System.out.println("<< " + header.toString()); } System.out.println(); } }
public static SimpleHttpResponse copy(final HttpResponse original) { Args.notNull(original, "HTTP response"); final SimpleHttpResponse copy = new SimpleHttpResponse(original.getCode()); copy.setVersion(original.getVersion()); for (final Iterator<Header> it = original.headerIterator(); it.hasNext(); ) { copy.addHeader(it.next()); } return copy; }
/** * For 304 Not modified responses, adds a "Last-Modified" header with the * value of the "If-Modified-Since" header passed in the request. This * header is required to be able to reuse match the cache entry for * subsequent requests but as defined in http specifications it is not * included in 304 responses by backend servers. This header will not be * included in the resulting response. */ void storeRequestIfModifiedSinceFor304Response(final HttpRequest request, final HttpResponse backendResponse) { if (backendResponse.getCode() == HttpStatus.SC_NOT_MODIFIED) { final Header h = request.getFirstHeader("If-Modified-Since"); if (h != null) { backendResponse.addHeader("Last-Modified", h.getValue()); } } }
final int status = response.getCode(); if (CACHEABLE_STATUS_CODES.contains(status)) { final Header contentLength = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); if (contentLength != null) { final long contentLengthValue = Long.parseLong(contentLength.getValue()); if (response.countHeaders(HeaderConstants.AGE) > 1) { log.debug("Multiple Age headers"); return false; if (response.countHeaders(HeaderConstants.EXPIRES) > 1) { log.debug("Multiple Expires headers"); return false; if (response.countHeaders(HttpHeaders.DATE) > 1) { log.debug("Multiple Date headers"); return false;
private void ensure206ContainsDateHeader(final HttpResponse response) { if (response.getFirstHeader(HttpHeaders.DATE) == null) { response.addHeader(HttpHeaders.DATE, DateUtils.formatDate(new Date())); } }
@Test public void testSetResponseStatus() { HttpResponse response = new BasicHttpResponse(200, "OK"); Assert.assertNotNull(response.getCode()); Assert.assertEquals(200, response.getCode()); response = new BasicHttpResponse(HttpStatus.SC_BAD_REQUEST, "Bad Request"); Assert.assertEquals(HttpStatus.SC_BAD_REQUEST, response.getCode()); response = new BasicHttpResponse(HttpStatus.SC_INTERNAL_SERVER_ERROR, "whatever"); Assert.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response.getCode()); Assert.assertEquals("whatever", response.getReasonPhrase()); response = new BasicHttpResponse(HttpStatus.SC_OK, "OK"); try { response.setCode(-23); Assert.fail("IllegalArgumentException should have been thrown"); } catch (final IllegalArgumentException ex) { // expected } }