private void dispose() { if (this.consumed) { return; } try { final HttpEntity entity = this.response.getEntity(); final InputStream content = entity.getContent(); if (content != null) { content.close(); } } catch (final Exception ignore) { } finally { this.consumed = true; } }
public void saveContent(final File file) throws IOException { assertNotConsumed(); final int status = response.getCode(); if (status >= HttpStatus.SC_REDIRECTION) { throw new HttpResponseException(status, response.getReasonPhrase()); } try (FileOutputStream out = new FileOutputStream(file)) { final HttpEntity entity = this.response.getEntity(); if (entity != null) { entity.writeTo(out); } } finally { this.consumed = true; } }
log.debug("Caching backend response"); final ByteArrayBuffer buf; final HttpEntity entity = backendResponse.getEntity(); if (entity != null) { buf = new ByteArrayBuffer(1024);
public static boolean semanticallyTransparent( final ClassicHttpResponse r1, final ClassicHttpResponse r2) throws Exception { final boolean entitiesEquivalent = equivalent(r1.getEntity(), r2.getEntity()); if (!entitiesEquivalent) { return false; } final boolean statusLinesEquivalent = LangUtils.equals(r1.getReasonPhrase(), r2.getReasonPhrase()) && r1.getCode() == r2.getCode(); if (!statusLinesEquivalent) { return false; } return isEndToEndHeaderSubset(r1, r2); }
@Test public void testResponseToAHEADRequestMustNotHaveABody() throws Exception { request = new BasicClassicHttpRequest("HEAD", "/"); EasyMock.expect( mockExecChain.proceed( EasyMock.isA(ClassicHttpRequest.class), EasyMock.isA(ExecChain.Scope.class))).andReturn(originResponse); replayMocks(); final ClassicHttpResponse result = execute(request); verifyMocks(); Assert.assertTrue(result.getEntity() == null || result.getEntity().getContentLength() == 0); }
public HttpResponse returnResponse() throws IOException { assertNotConsumed(); try { final HttpEntity entity = this.response.getEntity(); if (entity != null) { final ByteArrayEntity byteArrayEntity = new ByteArrayEntity( EntityUtils.toByteArray(entity)); final ContentType contentType = EntityUtils.getContentTypeOrDefault(entity); byteArrayEntity.setContentType(contentType.toString()); this.response.setEntity(byteArrayEntity); } return this.response; } finally { this.consumed = true; } }
public void testCachedEntityBodyIsUsedForResponseAfter304Validation() throws Exception { final ClassicHttpRequest req1 = new BasicClassicHttpRequest("GET", "/"); final ClassicHttpResponse resp1 = HttpTestUtils.make200Response(); resp1.setHeader("Cache-Control","max-age=3600"); resp1.setHeader("ETag","\"etag\""); final ClassicHttpRequest req2 = new BasicClassicHttpRequest("GET", "/"); req2.setHeader("Cache-Control","max-age=0, max-stale=0"); final ClassicHttpResponse resp2 = new BasicClassicHttpResponse(HttpStatus.SC_NOT_MODIFIED, "Not Modified"); backendExpectsAnyRequestAndReturn(resp1); backendExpectsAnyRequestAndReturn(resp2); replayMocks(); execute(req1); final ClassicHttpResponse result = execute(req2); verifyMocks(); final InputStream i1 = resp1.getEntity().getContent(); final InputStream i2 = result.getEntity().getContent(); int b1, b2; while((b1 = i1.read()) != -1) { b2 = i2.read(); Assert.assertEquals(b1, b2); } b2 = i2.read(); Assert.assertEquals(-1, b2); i1.close(); i2.close(); }
if (resultEtagHeader == null) { log.warn("304 response did not contain ETag"); EntityUtils.consume(backendResponse.getEntity()); backendResponse.close(); return callBackend(target, request, scope, chain); if (matchingVariant == null) { log.debug("304 response did not contain ETag matching one sent in If-None-Match"); EntityUtils.consume(backendResponse.getEntity()); backendResponse.close(); return callBackend(target, request, scope, chain); EntityUtils.consume(backendResponse.getEntity()); backendResponse.close(); final ClassicHttpRequest unconditional = conditionalRequestBuilder.buildUnconditionalRequest(request);
@Test public void testNoEntityForIfNoneMatchRequestNotYetInCache() throws Exception { final Date now = new Date(); final Date tenSecondsAgo = new Date(now.getTime() - 10 * 1000L); impl = createCachingExecChain(new BasicHttpCache(), CacheConfig.DEFAULT); final ClassicHttpRequest req1 = new HttpGet("http://foo.example.com/"); req1.addHeader("If-None-Match", "\"etag\""); final ClassicHttpResponse resp1 = HttpTestUtils.make304Response(); resp1.setHeader("Content-Length", "128"); resp1.setHeader("ETag", "\"etag\""); resp1.setHeader("Date", DateUtils.formatDate(tenSecondsAgo)); resp1.setHeader("Cache-Control", "public, max-age=5"); backendExpectsAnyRequestAndReturn(resp1); replayMocks(); final ClassicHttpResponse result = execute(req1); verifyMocks(); assertEquals(HttpStatus.SC_NOT_MODIFIED, result.getCode()); assertNull("The 304 response messages MUST NOT contain a message-body", result.getEntity()); }
@Test public void test206ResponseGeneratedFromCacheMustHaveABodyThatMatchesContentLengthHeaderIfPresent() throws Exception { final ClassicHttpRequest req1 = new BasicClassicHttpRequest("GET", "/"); final ClassicHttpResponse resp1 = HttpTestUtils.make200Response(); resp1.setHeader("ETag", "\"etag\""); resp1.setHeader("Cache-Control", "max-age=3600"); final ClassicHttpRequest req2 = new BasicClassicHttpRequest("GET", "/"); req2.setHeader("Range", "bytes=0-50"); backendExpectsAnyRequestAndReturn(resp1).times(1, 2); replayMocks(); execute(req1); final ClassicHttpResponse result = execute(req2); verifyMocks(); if (HttpStatus.SC_PARTIAL_CONTENT == result.getCode()) { final Header h = result.getFirstHeader("Content-Length"); if (h != null) { final int contentLength = Integer.parseInt(h.getValue()); int bytesRead = 0; final InputStream i = result.getEntity().getContent(); while ((i.read()) != -1) { bytesRead++; } i.close(); Assert.assertEquals(contentLength, bytesRead); } } }
final InputStream i = result.getEntity().getContent(); int b; boolean found1 = false;
unauthorized.addHeader(HttpHeaders.WWW_AUTHENTICATE, "Basic realm=\"" + realm + "\""); customizeUnauthorizedResponse(unauthorized); if (unauthorized.getEntity() == null) { unauthorized.setEntity(new StringEntity("Unauthorized"));
final InputStream i = result.getEntity().getContent(); int b; boolean found1 = false;
try { final ClassicHttpResponse result1 = execute(req1); EntityUtils.toString(result1.getEntity()); Assert.fail("We should have had a SocketTimeoutException"); } catch (final SocketTimeoutException e) {
@Test public void testResponseContentStatusNoContent() throws Exception { final HttpContext context = new BasicHttpContext(null); final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); response.setCode(HttpStatus.SC_NO_CONTENT); final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); Assert.assertNull(header); }
@Test public void testResponseConnControlEntityContentLength() throws Exception { final HttpContext context = new BasicHttpContext(null); final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); final StringEntity entity = new StringEntity("whatever"); response.setEntity(entity); final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); Assert.assertNull(header); }
@Test public void testResponseConnControlEntityChunked() throws Exception { final HttpContext context = new BasicHttpContext(null); final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); final BasicHttpEntity entity = new BasicHttpEntity(); entity.setChunked(true); response.setEntity(entity); final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); Assert.assertNull(header); }
@Test public void testResponseServerNotGenerated() throws Exception { final HttpContext context = new BasicHttpContext(null); final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); response.addHeader(new BasicHeader(HttpHeaders.SERVER, "whatever")); final ResponseServer interceptor = new ResponseServer("some server"); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.SERVER); Assert.assertNotNull(h1); Assert.assertEquals("whatever", h1.getValue()); }