private void fireOnHeaderReceived(HttpHeaders headers) { for (TransferListener l : listeners) { try { l.onResponseHeadersReceived(headers); } catch (Throwable t) { l.onThrowable(t); } } }
@Override public Response onCompleted(Response response) throws Exception { fireOnEnd(); return response; }
private void fireOnBytesSent(long amount, long current, long total) { for (TransferListener l : listeners) { try { l.onBytesSent(amount, current, total); } catch (Throwable t) { l.onThrowable(t); } } }
public AsyncHandler.State onContentWriteProgress(long amount, long current, long total) { return delegate.onContentWriteProgress(amount, current, total); } }
public AsyncHandler.State onHeadersWritten() { return delegate.onHeadersWritten(); }
public AsyncHandler.State onContentWritten() { return delegate.onContentWritten(); }
@Test(expectedExceptions = IOException.class) public void testConnectionRefused() throws IOException, InterruptedException { int newPortWithoutAnyoneListening = findFreePort(); try (AsyncHttpClient client = asyncHttpClient(getAsyncHttpClientConfig())) { BoundRequestBuilder r = client.prepareGet("http://localhost:" + newPortWithoutAnyoneListening + "/testConnectionRefused"); CountingOutputStream cos = new CountingOutputStream(); BodyDeferringAsyncHandler bdah = new BodyDeferringAsyncHandler(cos); r.execute(bdah); bdah.getResponse(); } }
private void fireOnBytesReceived(byte[] b) { for (TransferListener l : listeners) { try { l.onBytesReceived(b); } catch (Throwable t) { l.onThrowable(t); } } }
private void fireOnHeadersSent(HttpHeaders headers) { for (TransferListener l : listeners) { try { l.onRequestHeadersSent(headers); } catch (Throwable t) { l.onThrowable(t); } } }
private void fireOnEnd() { for (TransferListener l : listeners) { try { l.onRequestResponseCompleted(); } catch (Throwable t) { l.onThrowable(t); } } }
/** * Delegates to {@link BodyDeferringAsyncHandler#getResponse()}. Will * blocks as long as headers arrives only. Might return * <code>null</code>. See * {@link BodyDeferringAsyncHandler#getResponse()} method for details. * * @return a {@link Response} * @throws InterruptedException if the latch is interrupted * @throws IOException if the handler completed with an exception */ public Response getAsapResponse() throws InterruptedException, IOException { return bdah.getResponse(); }
@Override public State onTrailingHeadersReceived(HttpHeaders headers) throws Exception { fireOnHeaderReceived(headers); return super.onHeadersReceived(headers); }
@Override public State onHeadersWritten() { if (headers != null) { fireOnHeadersSent(headers); } return State.CONTINUE; }
@Override public State onContentWriteProgress(long amount, long current, long total) { fireOnBytesSent(amount, current, total); return State.CONTINUE; }
@Override public void onThrowable(Throwable t) { fireOnThrowable(t); }
private void fireOnThrowable(Throwable t) { for (TransferListener l : listeners) { try { l.onThrowable(t); } catch (Throwable t2) { logger.warn("onThrowable", t2); } } } }
@Override public State onBodyPartReceived(final HttpResponseBodyPart content) throws Exception { State s = State.CONTINUE; if (accumulateResponseBytes) { s = super.onBodyPartReceived(content); } fireOnBytesReceived(content.getBodyPartBytes()); return s; }
public AbstractHandler configureHandler() throws Exception { return new SlowAndBigHandler(); }
@Override public void operationProgressed(ChannelProgressiveFuture f, long progress, long total) { future.touch(); if (progressAsyncHandler != null && !notifyHeaders) { long lastLastProgress = lastProgress; lastProgress = progress; if (total < 0) { total = expectedTotal; } if (progress != lastLastProgress) { progressAsyncHandler.onContentWriteProgress(progress - lastLastProgress, progress, total); } } } }
@Override public State onHeadersReceived(final HttpHeaders headers) throws Exception { fireOnHeaderReceived(headers); return super.onHeadersReceived(headers); }