private void commitPromise( final HttpRequest promise, final AsyncPushProducer pushProducer) throws HttpException, IOException { httpProcessor.process(promise, null, context); final List<Header> promiseHeaders = DefaultH2RequestConverter.INSTANCE.convert(promise); outputChannel.push(promiseHeaders, pushProducer); connMetrics.incrementRequestCount(); }
@Override public AsyncDataConsumer handleResponse( final HttpResponse response, final EntityDetails entityDetails) throws HttpException, IOException { clientContext.setAttribute(HttpCoreContext.HTTP_RESPONSE, response); httpProcessor.process(response, entityDetails, clientContext); if (request.getMethod().equalsIgnoreCase(StandardMethods.TRACE.name())) { // Do not perform authentication for TRACE request return asyncExecCallback.handleResponse(response, entityDetails); } if (needAuthentication(targetAuthExchange, proxyAuthExchange, route, request, response, clientContext)) { challenged.set(true); return null; } challenged.set(false); return asyncExecCallback.handleResponse(response, entityDetails); }
private void commitPromise( final HttpRequest promise, final AsyncPushProducer pushProducer) throws HttpException, IOException { context.setProtocolVersion(HttpVersion.HTTP_2); context.setAttribute(HttpCoreContext.HTTP_REQUEST, promise); httpProcessor.process(promise, null, context); final List<Header> headers = DefaultH2RequestConverter.INSTANCE.convert(promise); outputChannel.push(headers, pushProducer); connMetrics.incrementRequestCount(); }
private void commitResponse( final HttpResponse response, final EntityDetails responseEntityDetails) throws HttpException, IOException { if (responseCommitted.compareAndSet(false, true)) { context.setProtocolVersion(HttpVersion.HTTP_2); context.setAttribute(HttpCoreContext.HTTP_RESPONSE, response); httpProcessor.process(response, responseEntityDetails, context); final List<Header> headers = DefaultH2ResponseConverter.INSTANCE.convert(response); outputChannel.submit(headers, responseEntityDetails == null); connMetrics.incrementResponseCount(); if (responseEntityDetails == null) { responseState = MessageState.COMPLETE; } else { responseState = MessageState.BODY; pushProducer.produce(outputChannel); } } }
/** * Pre-process the given request using the given protocol processor and * initiates the process of request execution. * * @param request the request to prepare * @param processor the processor to use * @param context the context for sending the request * * @throws IOException in case of an I/O error. * @throws HttpException in case of HTTP protocol violation or a processing * problem. */ public void preProcess( final ClassicHttpRequest request, final HttpProcessor processor, final HttpContext context) throws HttpException, IOException { Args.notNull(request, "HTTP request"); Args.notNull(processor, "HTTP processor"); Args.notNull(context, "HTTP context"); context.setAttribute(HttpCoreContext.HTTP_REQUEST, request); processor.process(request, request.getEntity(), context); }
/** * Pre-process the given request using the given protocol processor and * initiates the process of request execution. * * @param request the request to prepare * @param processor the processor to use * @param context the context for sending the request * * @throws IOException in case of an I/O error. * @throws HttpException in case of HTTP protocol violation or a processing * problem. */ public void preProcess( final ClassicHttpRequest request, final HttpProcessor processor, final HttpContext context) throws HttpException, IOException { Args.notNull(request, "HTTP request"); Args.notNull(processor, "HTTP processor"); Args.notNull(context, "HTTP context"); context.setAttribute(HttpCoreContext.HTTP_REQUEST, request); processor.process(request, request.getEntity(), context); }
private void commitRequest(final HttpRequest request, final EntityDetails entityDetails) throws HttpException, IOException { if (requestCommitted.compareAndSet(false, true)) { context.setProtocolVersion(HttpVersion.HTTP_2); context.setAttribute(HttpCoreContext.HTTP_REQUEST, request); httpProcessor.process(request, entityDetails, context); final List<Header> headers = DefaultH2RequestConverter.INSTANCE.convert(request); outputChannel.submit(headers, entityDetails == null); connMetrics.incrementRequestCount(); if (entityDetails == null) { requestState = MessageState.COMPLETE; } else { final Header h = request.getFirstHeader(HttpHeaders.EXPECT); final boolean expectContinue = h != null && "100-continue".equalsIgnoreCase(h.getValue()); if (expectContinue) { requestState = MessageState.ACK; } else { requestState = MessageState.BODY; exchangeHandler.produce(dataChannel); } } } else { throw new H2ConnectionException(H2Error.INTERNAL_ERROR, "Request already committed"); } }
@Test public void testResponseToHead() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("HEAD", "/"); Mockito.when(conn.receiveRequestHeader()).thenReturn(request); Mockito.when(responseFactory.newHttpResponse(200)).thenReturn(response); Mockito.when(handlerResolver.resolve(request, context)).thenReturn(requestHandler); Mockito.when(connReuseStrategy.keepAlive(request, response, context)).thenReturn(Boolean.TRUE); httpservice.handleRequest(conn, context); Assert.assertSame(request, context.getRequest()); Mockito.verify(httprocessor).process(response, response.getEntity(), context); Mockito.verify(requestHandler).handle(request, response, context); Mockito.verify(conn).sendResponseHeader(response); Mockito.verify(conn, Mockito.never()).sendResponseEntity(ArgumentMatchers.<ClassicHttpResponse>any()); Mockito.verify(conn).flush(); Mockito.verify(conn, Mockito.never()).close(); Mockito.verify(response).close(); }
@Override public AsyncDataConsumer handleResponse( final HttpResponse response, final EntityDetails entityDetails) throws HttpException, IOException { clientContext.setAttribute(HttpCoreContext.HTTP_RESPONSE, response); proxyHttpProcessor.process(response, entityDetails, clientContext); final int status = response.getCode(); if (status < HttpStatus.SC_SUCCESS) { throw new HttpException("Unexpected response to CONNECT request: " + new StatusLine(response)); } if (needAuthentication(proxyAuthExchange, proxy, response, clientContext)) { state.challenged = true; return null; } state.challenged = false; if (status >= HttpStatus.SC_REDIRECTION) { state.tunnelRefused = true; return asyncExecCallback.handleResponse(response, entityDetails); } return null; }
private void commitResponse( final HttpResponse response, final EntityDetails responseEntityDetails) throws HttpException, IOException { if (responseCommitted.compareAndSet(false, true)) { final int status = response.getCode(); if (status < HttpStatus.SC_SUCCESS) { throw new HttpException("Invalid response: " + status); } context.setAttribute(HttpCoreContext.HTTP_RESPONSE, response); httpProcessor.process(response, responseEntityDetails, context); final List<Header> responseHeaders = DefaultH2ResponseConverter.INSTANCE.convert(response); Asserts.notNull(receivedRequest, "Received request"); final String method = receivedRequest.getMethod(); final boolean endStream = responseEntityDetails == null || method.equalsIgnoreCase("HEAD"); outputChannel.submit(responseHeaders, endStream); connMetrics.incrementResponseCount(); if (responseEntityDetails == null) { responseState = MessageState.COMPLETE; } else { responseState = MessageState.BODY; exchangeHandler.produce(outputChannel); } } else { throw new H2ConnectionException(H2Error.INTERNAL_ERROR, "Response already committed"); } }
@Test public void testExecutionHead() throws Exception { final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class); final HttpClientConnection conn = Mockito.mock(HttpClientConnection.class); final HttpRequestExecutor executor = new HttpRequestExecutor(); final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("HEAD", "/"); executor.preProcess(request, httprocessor, context); Mockito.verify(httprocessor).process(request, request.getEntity(), context); Mockito.when(conn.receiveResponseHeader()).thenReturn( new BasicClassicHttpResponse(200, "OK")); final ClassicHttpResponse response = executor.execute(request, conn, context); Mockito.verify(conn).sendRequestHeader(request); Mockito.verify(conn).flush(); Mockito.verify(conn).receiveResponseHeader(); Mockito.verify(conn, Mockito.never()).receiveResponseEntity(response); executor.postProcess(response, httprocessor, context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); }
@Test public void testExecutionNoResponseBody() throws Exception { final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class); final HttpClientConnection conn = Mockito.mock(HttpClientConnection.class); final HttpRequestExecutor executor = new HttpRequestExecutor(); final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("GET", "/"); executor.preProcess(request, httprocessor, context); Mockito.verify(httprocessor).process(request, request.getEntity(), context); Mockito.when(conn.receiveResponseHeader()).thenReturn( new BasicClassicHttpResponse(204, "OK")); final ClassicHttpResponse response = executor.execute(request, conn, context); Mockito.verify(conn).sendRequestHeader(request); Mockito.verify(conn).flush(); Mockito.verify(conn).receiveResponseHeader(); Mockito.verify(conn, Mockito.never()).receiveResponseEntity(response); executor.postProcess(response, httprocessor, context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); }
@Test public void testNoContentResponse() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("GET", "/"); Mockito.when(conn.receiveRequestHeader()).thenReturn(request); Mockito.when(responseFactory.newHttpResponse(200)).thenReturn(response); Mockito.when(handlerResolver.resolve(request, context)).thenReturn(new HttpRequestHandler() { @Override public void handle( final ClassicHttpRequest request, final ClassicHttpResponse response, final HttpContext context) throws HttpException, IOException { response.setCode(HttpStatus.SC_NO_CONTENT); } }); Mockito.when(connReuseStrategy.keepAlive(request, response, context)).thenReturn(Boolean.TRUE); httpservice.handleRequest(conn, context); Assert.assertSame(request, context.getRequest()); Mockito.verify(httprocessor).process(response, response.getEntity(), context); Mockito.verify(conn).sendResponseHeader(response); Mockito.verify(conn, Mockito.never()).sendResponseEntity(ArgumentMatchers.<ClassicHttpResponse>any()); Mockito.verify(conn).flush(); Mockito.verify(conn, Mockito.never()).close(); Mockito.verify(response).close(); }
@Test public void testConnectionKeepAlive() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("GET", "/"); Mockito.when(conn.receiveRequestHeader()).thenReturn(request); Mockito.when(responseFactory.newHttpResponse(200)).thenReturn(response); Mockito.when(handlerResolver.resolve(request, context)).thenReturn(requestHandler); Mockito.when(connReuseStrategy.keepAlive(request, response, context)).thenReturn(Boolean.TRUE); httpservice.handleRequest(conn, context); Assert.assertEquals(HttpStatus.SC_OK, response.getCode()); Assert.assertSame(request, context.getRequest()); Assert.assertSame(response, context.getResponse()); Mockito.verify(httprocessor).process(request, request.getEntity(), context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); Mockito.verify(conn).sendResponseHeader(response); Mockito.verify(conn).sendResponseEntity(response); Mockito.verify(conn).flush(); Mockito.verify(conn, Mockito.never()).close(); Mockito.verify(response).close(); }
@Test public void testExecutionEntityEnclosingRequest() throws Exception { final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class); final HttpClientConnection conn = Mockito.mock(HttpClientConnection.class); final HttpRequestExecutor executor = new HttpRequestExecutor(); final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("POST", "/"); final HttpEntity entity = Mockito.mock(HttpEntity.class); request.setEntity(entity); executor.preProcess(request, httprocessor, context); Mockito.verify(httprocessor).process(request, request.getEntity(), context); Mockito.when(conn.receiveResponseHeader()).thenReturn( new BasicClassicHttpResponse(200, "OK")); final ClassicHttpResponse response = executor.execute(request, conn, context); Mockito.verify(conn).sendRequestHeader(request); Mockito.verify(conn).sendRequestEntity(request); Mockito.verify(conn).flush(); Mockito.verify(conn).receiveResponseHeader(); Mockito.verify(conn).receiveResponseEntity(response); executor.postProcess(response, httprocessor, context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); }
@Test public void testBasicExecution() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("GET", "/"); Mockito.when(conn.receiveRequestHeader()).thenReturn(request); Mockito.when(responseFactory.newHttpResponse(200)).thenReturn(response); Mockito.when(connReuseStrategy.keepAlive(request, response, context)).thenReturn(Boolean.FALSE); httpservice.handleRequest(conn, context); Assert.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, response.getCode()); Assert.assertSame(request, context.getRequest()); Assert.assertSame(response, context.getResponse()); Mockito.verify(httprocessor).process(request, request.getEntity(), context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); Mockito.verify(conn).sendResponseHeader(response); Mockito.verify(conn).sendResponseEntity(response); Mockito.verify(conn).flush(); Mockito.verify(conn).close(); Mockito.verify(response).close(); }
@Test public void testMethodNotSupported() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("whatever", "/"); Mockito.when(conn.receiveRequestHeader()).thenReturn(request); Mockito.when(responseFactory.newHttpResponse(200)).thenReturn(response); Mockito.when(handlerResolver.resolve(request, context)).thenReturn(requestHandler); Mockito.doThrow(new MethodNotSupportedException("whatever")).when( requestHandler).handle(request, response, context); httpservice.handleRequest(conn, context); final ArgumentCaptor<ClassicHttpResponse> responseCaptor = ArgumentCaptor.forClass(ClassicHttpResponse.class); Mockito.verify(conn).sendResponseHeader(responseCaptor.capture()); final ClassicHttpResponse error = responseCaptor.getValue(); Assert.assertNotNull(error); Assert.assertSame(request, context.getRequest()); Assert.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, error.getCode()); Mockito.verify(httprocessor).process(error, error.getEntity(), context); Mockito.verify(conn).sendResponseHeader(error); Mockito.verify(conn).sendResponseEntity(error); Mockito.verify(conn).close(); }
@Test public void testUnsupportedHttpVersionException() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("whatever", "/"); Mockito.when(conn.receiveRequestHeader()).thenReturn(request); Mockito.when(responseFactory.newHttpResponse(200)).thenReturn(response); Mockito.when(handlerResolver.resolve(request, context)).thenReturn(requestHandler); Mockito.doThrow(new UnsupportedHttpVersionException()).when( requestHandler).handle(request, response, context); httpservice.handleRequest(conn, context); final ArgumentCaptor<ClassicHttpResponse> responseCaptor = ArgumentCaptor.forClass(ClassicHttpResponse.class); Mockito.verify(conn).sendResponseHeader(responseCaptor.capture()); final ClassicHttpResponse error = responseCaptor.getValue(); Assert.assertNotNull(error); Assert.assertSame(request, context.getRequest()); Assert.assertEquals(HttpStatus.SC_HTTP_VERSION_NOT_SUPPORTED, error.getCode()); Mockito.verify(httprocessor).process(error, error.getEntity(), context); Mockito.verify(conn).sendResponseHeader(error); Mockito.verify(conn).sendResponseEntity(error); Mockito.verify(conn).close(); }
@Test public void testProtocolException() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("whatever", "/"); Mockito.when(conn.receiveRequestHeader()).thenReturn(request); Mockito.when(responseFactory.newHttpResponse(200)).thenReturn(response); Mockito.when(handlerResolver.resolve(request, context)).thenReturn(requestHandler); Mockito.doThrow(new ProtocolException("oh, this world is wrong")).when( requestHandler).handle(request, response, context); httpservice.handleRequest(conn, context); final ArgumentCaptor<ClassicHttpResponse> responseCaptor = ArgumentCaptor.forClass(ClassicHttpResponse.class); Mockito.verify(conn).sendResponseHeader(responseCaptor.capture()); final ClassicHttpResponse error = responseCaptor.getValue(); Assert.assertNotNull(error); Assert.assertSame(request, context.getRequest()); Assert.assertEquals(HttpStatus.SC_BAD_REQUEST, error.getCode()); Mockito.verify(httprocessor).process(error, error.getEntity(), context); Mockito.verify(conn).sendResponseHeader(error); Mockito.verify(conn).sendResponseEntity(error); Mockito.verify(conn).close(); }