public void start(final HttpProcessor httpProcessor) { if (requesterRef.get() == null) { final HttpRequestExecutor requestExecutor = new HttpRequestExecutor( HttpRequestExecutor.DEFAULT_WAIT_FOR_CONTINUE, DefaultConnectionReuseStrategy.INSTANCE, LoggingHttp1StreamListener.INSTANCE); final StrictConnPool<HttpHost, HttpClientConnection> connPool = new StrictConnPool<>( 20, 50, TimeValue.NEG_ONE_MILLISECONDS, PoolReusePolicy.LIFO, LoggingConnPoolListener.INSTANCE); final HttpRequester requester = new HttpRequester( requestExecutor, httpProcessor != null ? httpProcessor : HttpProcessors.client(), connPool, socketConfig, new DefaultBHttpClientConnectionFactory(H1Config.DEFAULT, CharCodingConfig.DEFAULT), sslContext != null ? sslContext.getSocketFactory() : null, DefaultAddressResolver.INSTANCE); requesterRef.compareAndSet(null, requester); } else { throw new IllegalStateException("Requester has already been started"); } }
public void start(final HttpProcessor httpProcessor) { if (requesterRef.get() == null) { final HttpRequestExecutor requestExecutor = new HttpRequestExecutor( HttpRequestExecutor.DEFAULT_WAIT_FOR_CONTINUE, DefaultConnectionReuseStrategy.INSTANCE, LoggingHttp1StreamListener.INSTANCE); final StrictConnPool<HttpHost, HttpClientConnection> connPool = new StrictConnPool<>( 20, 50, TimeValue.NEG_ONE_MILLISECONDS, PoolReusePolicy.LIFO, LoggingConnPoolListener.INSTANCE); final HttpRequester requester = new HttpRequester( requestExecutor, httpProcessor != null ? httpProcessor : HttpProcessors.client(), connPool, socketConfig, new DefaultBHttpClientConnectionFactory(H1Config.DEFAULT, CharCodingConfig.DEFAULT), sslContext != null ? sslContext.getSocketFactory() : null, DefaultAddressResolver.INSTANCE); requesterRef.compareAndSet(null, requester); } else { throw new IllegalStateException("Requester has already been started"); } }
@Test public void testExecutionIOException() throws Exception { final HttpClientConnection conn = Mockito.mock(HttpClientConnection.class); final HttpRequestExecutor executor = new HttpRequestExecutor(); final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("GET", "/"); Mockito.doThrow(new IOException("Oopsie")).when(conn).sendRequestHeader(request); try { executor.execute(request, conn, context); Assert.fail("IOException should have been thrown"); } catch (final IOException ex) { Mockito.verify(conn).close(); } }
@Test public void testExecutionRuntimeException() throws Exception { final HttpClientConnection conn = Mockito.mock(HttpClientConnection.class); final HttpRequestExecutor executor = new HttpRequestExecutor(); final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("GET", "/"); Mockito.doThrow(new RuntimeException("Oopsie")).when(conn).receiveResponseHeader(); try { executor.execute(request, conn, context); Assert.fail("IOException should have been thrown"); } catch (final RuntimeException ex) { Mockito.verify(conn).close(); } }
MinimalHttpClient(final HttpClientConnectionManager connManager) { super(); this.connManager = Args.notNull(connManager, "HTTP connection manager"); this.reuseStrategy = DefaultConnectionReuseStrategy.INSTANCE; this.schemePortResolver = DefaultSchemePortResolver.INSTANCE; this.requestExecutor = new HttpRequestExecutor(this.reuseStrategy); this.httpProcessor = new DefaultHttpProcessor( new RequestContent(), new RequestTargetHost(), new RequestClientConnControl(), new RequestUserAgent(VersionInfo.getSoftwareInfo( "Apache-HttpClient", "org.apache.hc.client5", getClass()))); }
@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); }
public HttpRequester create() { final HttpRequestExecutor requestExecutor = new HttpRequestExecutor( HttpRequestExecutor.DEFAULT_WAIT_FOR_CONTINUE, connReuseStrategy != null ? connReuseStrategy : DefaultConnectionReuseStrategy.INSTANCE,
public HttpRequester create() { final HttpRequestExecutor requestExecutor = new HttpRequestExecutor( HttpRequestExecutor.DEFAULT_WAIT_FOR_CONTINUE, connReuseStrategy != null ? connReuseStrategy : DefaultConnectionReuseStrategy.INSTANCE,
@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 testExecutionEntityEnclosingRequestWithExpectContinueFailure() 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", "/"); request.addHeader(HttpHeaders.EXPECT, HeaderElements.CONTINUE); 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(402, "OK")); Mockito.when(conn.isDataAvailable(ArgumentMatchers.anyInt())).thenReturn(Boolean.TRUE); final ClassicHttpResponse response = executor.execute(request, conn, context); Mockito.verify(conn).sendRequestHeader(request); Mockito.verify(conn, Mockito.never()).sendRequestEntity(request); Mockito.verify(conn).terminateRequest(request); Mockito.verify(conn, Mockito.times(2)).flush(); Mockito.verify(conn).isDataAvailable(3000); Mockito.verify(conn).receiveResponseHeader(); Mockito.verify(conn).receiveResponseEntity(response); executor.postProcess(response, httprocessor, context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); }
final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class); try { final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.execute(null, conn, context); Assert.fail("IllegalArgumentException expected"); final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.execute(request, null, context); Assert.fail("IllegalArgumentException expected"); final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.execute(request, conn, null); Assert.fail("IllegalArgumentException expected"); final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.preProcess(null, httprocessor, context); Assert.fail("IllegalArgumentException expected"); final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.preProcess(request, null, context); Assert.fail("IllegalArgumentException expected"); final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.preProcess(request, httprocessor, null); Assert.fail("IllegalArgumentException expected"); final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.postProcess(null, httprocessor, context); Assert.fail("IllegalArgumentException expected");
@Test public void testExecutionEntityEnclosingRequestWithExpectContinueNoResponse() 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", "/"); request.addHeader(HttpHeaders.EXPECT, HeaderElements.CONTINUE); 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")); Mockito.when(conn.isDataAvailable(ArgumentMatchers.anyInt())).thenReturn(Boolean.FALSE); final ClassicHttpResponse response = executor.execute(request, conn, context); Mockito.verify(conn).sendRequestHeader(request); Mockito.verify(conn).sendRequestEntity(request); Mockito.verify(conn, Mockito.times(2)).flush(); Mockito.verify(conn).isDataAvailable(3000); 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 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 testExecutionEntityEnclosingRequestWithExpectContinueSuccess() 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", "/"); request.addHeader(HttpHeaders.EXPECT, HeaderElements.CONTINUE); 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(100, "Continue"), new BasicClassicHttpResponse(200, "OK")); Mockito.when(conn.isDataAvailable(ArgumentMatchers.anyInt())).thenReturn(Boolean.TRUE); final ClassicHttpResponse response = executor.execute(request, conn, context); Mockito.verify(conn).sendRequestHeader(request); Mockito.verify(conn).sendRequestEntity(request); Mockito.verify(conn, Mockito.times(2)).flush(); Mockito.verify(conn).isDataAvailable(3000); Mockito.verify(conn, Mockito.times(2)).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 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(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).receiveResponseEntity(response); executor.postProcess(response, httprocessor, context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); Assert.assertSame(request, context.getRequest()); Assert.assertSame(response, context.getResponse()); }
final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class); final HttpClientConnection conn = Mockito.mock(HttpClientConnection.class); final HttpRequestExecutor executor = new HttpRequestExecutor();
final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class); final HttpClientConnection conn = Mockito.mock(HttpClientConnection.class); final HttpRequestExecutor executor = new HttpRequestExecutor();
/** * @since 5.0 */ public ProxyClient( final HttpConnectionFactory<ManagedHttpClientConnection> connFactory, final H1Config h1Config, final CharCodingConfig charCodingConfig, final RequestConfig requestConfig) { super(); this.connFactory = connFactory != null ? connFactory : new ManagedHttpClientConnectionFactory(h1Config, charCodingConfig, null, null); this.requestConfig = requestConfig != null ? requestConfig : RequestConfig.DEFAULT; this.httpProcessor = new DefaultHttpProcessor( new RequestTargetHost(), new RequestClientConnControl(), new RequestUserAgent()); this.requestExec = new HttpRequestExecutor(); this.proxyAuthStrategy = new DefaultAuthenticationStrategy(); this.authenticator = new HttpAuthenticator(); this.proxyAuthExchange = new AuthExchange(); this.authSchemeRegistry = RegistryBuilder.<AuthSchemeProvider>create() .register(AuthSchemes.BASIC.ident, new BasicSchemeFactory()) .register(AuthSchemes.DIGEST.ident, new DigestSchemeFactory()) .register(AuthSchemes.NTLM.ident, new NTLMSchemeFactory()) .register(AuthSchemes.SPNEGO.ident, new SPNegoSchemeFactory(KerberosConfig.DEFAULT, SystemDefaultDnsResolver.INSTANCE)) .register(AuthSchemes.KERBEROS.ident, new KerberosSchemeFactory(KerberosConfig.DEFAULT, SystemDefaultDnsResolver.INSTANCE)) .build(); this.reuseStrategy = new DefaultConnectionReuseStrategy(); }
requestExecCopy = new HttpRequestExecutor();