@Override Http2StreamHandler createRemotelyInitiatedStream( final Http2StreamChannel channel, final HttpProcessor httpProcessor, final BasicHttpConnectionMetrics connMetrics, final HandlerFactory<AsyncPushConsumer> pushHandlerFactory) throws IOException { final HttpCoreContext context = HttpCoreContext.create(); context.setAttribute(HttpCoreContext.SSL_SESSION, getSSLSession()); context.setAttribute(HttpCoreContext.CONNECTION_ENDPOINT, getEndpointDetails()); return new ServerHttp2StreamHandler(channel, httpProcessor, connMetrics, exchangeHandlerFactory, context); }
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(); }
@Override void execute(final RequestExecutionCommand executionCommand) throws HttpException, IOException { final AsyncClientExchangeHandler exchangeHandler = executionCommand.getExchangeHandler(); final HttpCoreContext context = HttpCoreContext.adapt(executionCommand.getContext()); context.setAttribute(HttpCoreContext.SSL_SESSION, getSSLSession()); context.setAttribute(HttpCoreContext.CONNECTION_ENDPOINT, getEndpointDetails()); final ClientHttp1StreamHandler handler = new ClientHttp1StreamHandler( outputChannel, httpProcessor, h1Config, connectionReuseStrategy, exchangeHandler, context); pipeline.add(handler); outgoing = handler; if (handler.isOutputReady()) { handler.produceOutput(); } }
HttpClient client = HttpClients.createDefault(); HttpCoreContext localContext = new HttpCoreContext(); HttpResponse response = client.execute(request,localContext); Header[] headers = localContext.getRequest().getAllHeaders(); for (Header header : headers) { System.out.println(header.toString()); }
pushHandlerFactory, context != null ? context : HttpCoreContext.create()); return future;
@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(); }
@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(); }
final BenchmarkWorker[] workers = new BenchmarkWorker[config.getConcurrencyLevel()]; for (int i = 0; i < workers.length; i++) { final HttpCoreContext context = HttpCoreContext.create(); context.setProtocolVersion(version); final BenchmarkWorker worker = new BenchmarkWorker( requester,
response.setHeader(HttpHeaders.CONNECTION, HeaderElements.CLOSE); } else { final HttpCoreContext coreContext = HttpCoreContext.adapt(context); final HttpRequest request = coreContext.getRequest(); boolean closeRequested = false; boolean keepAliveRequested = false;
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"); } }
@Override protected final void handle( final SimpleHttpRequest request, final AsyncServerRequestHandler.ResponseTrigger responseTrigger, final HttpContext context) throws HttpException, IOException { final SimpleHttpResponse response = handle(request, HttpCoreContext.adapt(context)); final SimpleBody body = response.getBody(); final AsyncEntityProducer entityProducer; if (body != null) { if (body.isText()) { entityProducer = new StringAsyncEntityProducer(body.getBodyText(), body.getContentType()); } else { entityProducer = new BasicAsyncEntityProducer(body.getBodyBytes(), body.getContentType()); } } else { entityProducer = null; } responseTrigger.submitResponse(new BasicResponseProducer(response, entityProducer), context); }
public static HttpCoreContext adapt(final HttpContext context) { if (context == null) { return new HttpCoreContext(); } if (context instanceof HttpCoreContext) { return (HttpCoreContext) context; } return new HttpCoreContext(context); }
pushHandlerFactory, context != null ? context : HttpCoreContext.create()); return future;
@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 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(); }
final BenchmarkWorker[] workers = new BenchmarkWorker[config.getConcurrencyLevel()]; for (int i = 0; i < workers.length; i++) { final HttpCoreContext context = HttpCoreContext.create(); context.setProtocolVersion(version); final BenchmarkWorker worker = new BenchmarkWorker( requester,
response.setHeader(HttpHeaders.CONNECTION, HeaderElements.CLOSE); } else { final HttpCoreContext coreContext = HttpCoreContext.adapt(context); final HttpRequest request = coreContext.getRequest(); boolean closeRequested = false; boolean keepAliveRequested = false;
context.setAttribute(HttpCoreContext.HTTP_RESPONSE, response); httpProcessor.process(response, responseEntityDetails, context);
@Override public void run() { try { final BasicHttpContext localContext = new BasicHttpContext(); final HttpCoreContext context = HttpCoreContext.adapt(localContext); while (!Thread.interrupted() && this.conn.isOpen()) { this.httpservice.handleRequest(this.conn, context); localContext.clear(); } this.conn.close(); } catch (final Exception ex) { this.exceptionListener.onError(this.conn, ex); } finally { this.conn.close(CloseMode.IMMEDIATE); } }
public static HttpCoreContext adapt(final HttpContext context) { if (context == null) { return new HttpCoreContext(); } if (context instanceof HttpCoreContext) { return (HttpCoreContext) context; } return new HttpCoreContext(context); }