Codebase list async-http-client / 4ed3005
New upstream version 2.5.0 Emmanuel Bourg 5 years ago
26 changed file(s) with 281 addition(s) and 81 deletion(s). Raw diff Collapse all Expand all
+4
-2
README.md less more
262262 or
263263
264264 ```java
265 Request propFindRequest = new RequestBuilder("PROPFIND").setUrl("http://host:port).build();
266 Response response = c.executeRequest(propFindRequest, new AsyncHandler(){...}).get();
265 Request propFindRequest = new RequestBuilder("PROPFIND").setUrl("http://host:port").build();
266 Response response = c.executeRequest(propFindRequest, new AsyncHandler() {
267 // ...
268 }).get();
267269 ```
268270
269271 ## More
+1
-1
client/pom.xml less more
11 <parent>
22 <groupId>org.asynchttpclient</groupId>
33 <artifactId>async-http-client-project</artifactId>
4 <version>2.4.9</version>
4 <version>2.5.0</version>
55 </parent>
66 <modelVersion>4.0.0</modelVersion>
77 <artifactId>async-http-client</artifactId>
+3
-0
client/src/main/java/org/asynchttpclient/AsyncHttpClientConfig.java less more
2727 import org.asynchttpclient.filter.ResponseFilter;
2828 import org.asynchttpclient.netty.EagerResponseBodyPart;
2929 import org.asynchttpclient.netty.LazyResponseBodyPart;
30 import org.asynchttpclient.netty.channel.ConnectionSemaphoreFactory;
3031 import org.asynchttpclient.proxy.ProxyServer;
3132 import org.asynchttpclient.proxy.ProxyServerSelector;
3233
291292 ResponseBodyPartFactory getResponseBodyPartFactory();
292293
293294 ChannelPool getChannelPool();
295
296 ConnectionSemaphoreFactory getConnectionSemaphoreFactory();
294297
295298 Timer getNettyTimer();
296299
+17
-0
client/src/main/java/org/asynchttpclient/DefaultAsyncHttpClientConfig.java less more
2929 import org.asynchttpclient.filter.IOExceptionFilter;
3030 import org.asynchttpclient.filter.RequestFilter;
3131 import org.asynchttpclient.filter.ResponseFilter;
32 import org.asynchttpclient.netty.channel.ConnectionSemaphoreFactory;
3233 import org.asynchttpclient.proxy.ProxyServer;
3334 import org.asynchttpclient.proxy.ProxyServerSelector;
3435 import org.asynchttpclient.util.ProxyUtils;
8384 private final int maxConnections;
8485 private final int maxConnectionsPerHost;
8586 private final ChannelPool channelPool;
87 private final ConnectionSemaphoreFactory connectionSemaphoreFactory;
8688 private final KeepAliveStrategy keepAliveStrategy;
8789
8890 // ssl
161163 int maxConnections,
162164 int maxConnectionsPerHost,
163165 ChannelPool channelPool,
166 ConnectionSemaphoreFactory connectionSemaphoreFactory,
164167 KeepAliveStrategy keepAliveStrategy,
165168
166169 // ssl
247250 this.maxConnections = maxConnections;
248251 this.maxConnectionsPerHost = maxConnectionsPerHost;
249252 this.channelPool = channelPool;
253 this.connectionSemaphoreFactory = connectionSemaphoreFactory;
250254 this.keepAliveStrategy = keepAliveStrategy;
251255
252256 // ssl
443447 @Override
444448 public ChannelPool getChannelPool() {
445449 return channelPool;
450 }
451
452 @Override
453 public ConnectionSemaphoreFactory getConnectionSemaphoreFactory() {
454 return connectionSemaphoreFactory;
446455 }
447456
448457 @Override
687696 private int maxConnections = defaultMaxConnections();
688697 private int maxConnectionsPerHost = defaultMaxConnectionsPerHost();
689698 private ChannelPool channelPool;
699 private ConnectionSemaphoreFactory connectionSemaphoreFactory;
690700 private KeepAliveStrategy keepAliveStrategy = new DefaultKeepAliveStrategy();
691701
692702 // ssl
767777 maxConnections = config.getMaxConnections();
768778 maxConnectionsPerHost = config.getMaxConnectionsPerHost();
769779 channelPool = config.getChannelPool();
780 connectionSemaphoreFactory = config.getConnectionSemaphoreFactory();
770781 keepAliveStrategy = config.getKeepAliveStrategy();
771782
772783 // ssl
980991
981992 public Builder setChannelPool(ChannelPool channelPool) {
982993 this.channelPool = channelPool;
994 return this;
995 }
996
997 public Builder setConnectionSemaphoreFactory(ConnectionSemaphoreFactory connectionSemaphoreFactory) {
998 this.connectionSemaphoreFactory = connectionSemaphoreFactory;
983999 return this;
9841000 }
9851001
12321248 maxConnections,
12331249 maxConnectionsPerHost,
12341250 channelPool,
1251 connectionSemaphoreFactory,
12351252 keepAliveStrategy,
12361253 useOpenSsl,
12371254 useInsecureTrustManager,
+8
-2
client/src/main/java/org/asynchttpclient/netty/channel/ChannelManager.java less more
333333 return sslHandler;
334334 }
335335
336 public void updatePipelineForHttpTunneling(ChannelPipeline pipeline, Uri requestUri) {
336 public Future<Channel> updatePipelineForHttpTunneling(ChannelPipeline pipeline, Uri requestUri) {
337
338 Future<Channel> whenHanshaked = null;
339
337340 if (pipeline.get(HTTP_CLIENT_CODEC) != null)
338341 pipeline.remove(HTTP_CLIENT_CODEC);
339342
340343 if (requestUri.isSecured()) {
341344 if (!isSslHandlerConfigured(pipeline)) {
342 pipeline.addBefore(AHC_HTTP_HANDLER, SSL_HANDLER, createSslHandler(requestUri.getHost(), requestUri.getExplicitPort()));
345 SslHandler sslHandler = createSslHandler(requestUri.getHost(), requestUri.getExplicitPort());
346 whenHanshaked = sslHandler.handshakeFuture();
347 pipeline.addBefore(AHC_HTTP_HANDLER, SSL_HANDLER, sslHandler);
343348 }
344349 pipeline.addAfter(SSL_HANDLER, HTTP_CLIENT_CODEC, newHttpClientCodec());
345350
351356 pipeline.addAfter(AHC_HTTP_HANDLER, AHC_WS_HANDLER, wsHandler);
352357 pipeline.remove(AHC_HTTP_HANDLER);
353358 }
359 return whenHanshaked;
354360 }
355361
356362 public SslHandler addSslHandler(ChannelPipeline pipeline, Uri uri, String virtualHost, boolean hasSocksProxyHandler) {
+5
-59
client/src/main/java/org/asynchttpclient/netty/channel/ConnectionSemaphore.java less more
00 /*
1 * Copyright (c) 2017 AsyncHttpClient Project. All rights reserved.
1 * Copyright (c) 2018 AsyncHttpClient Project. All rights reserved.
22 *
33 * This program is licensed to you under the Apache License Version 2.0,
44 * and you may not use this file except in compliance with the Apache License Version 2.0.
1212 */
1313 package org.asynchttpclient.netty.channel;
1414
15 import org.asynchttpclient.AsyncHttpClientConfig;
16 import org.asynchttpclient.exception.TooManyConnectionsException;
17 import org.asynchttpclient.exception.TooManyConnectionsPerHostException;
18
1915 import java.io.IOException;
20 import java.util.concurrent.ConcurrentHashMap;
21
22 import static org.asynchttpclient.util.ThrowableUtil.unknownStackTrace;
2316
2417 /**
25 * Max connections and max-per-host connections limiter.
26 *
27 * @author Stepan Koltsov
18 * Connections limiter.
2819 */
29 public class ConnectionSemaphore {
20 public interface ConnectionSemaphore {
3021
31 private final NonBlockingSemaphoreLike freeChannels;
32 private final int maxConnectionsPerHost;
33 private final ConcurrentHashMap<Object, NonBlockingSemaphore> freeChannelsPerHost = new ConcurrentHashMap<>();
34 private final IOException tooManyConnections;
35 private final IOException tooManyConnectionsPerHost;
22 void acquireChannelLock(Object partitionKey) throws IOException;
3623
37 private ConnectionSemaphore(AsyncHttpClientConfig config) {
38 tooManyConnections = unknownStackTrace(new TooManyConnectionsException(config.getMaxConnections()), ConnectionSemaphore.class, "acquireChannelLock");
39 tooManyConnectionsPerHost = unknownStackTrace(new TooManyConnectionsPerHostException(config.getMaxConnectionsPerHost()), ConnectionSemaphore.class, "acquireChannelLock");
40 int maxTotalConnections = config.getMaxConnections();
41 maxConnectionsPerHost = config.getMaxConnectionsPerHost();
24 void releaseChannelLock(Object partitionKey);
4225
43 freeChannels = maxTotalConnections > 0 ?
44 new NonBlockingSemaphore(config.getMaxConnections()) :
45 NonBlockingSemaphoreInfinite.INSTANCE;
46 }
47
48 public static ConnectionSemaphore newConnectionSemaphore(AsyncHttpClientConfig config) {
49 return config.getMaxConnections() > 0 || config.getMaxConnectionsPerHost() > 0 ? new ConnectionSemaphore(config) : null;
50 }
51
52 private boolean tryAcquireGlobal() {
53 return freeChannels.tryAcquire();
54 }
55
56 private NonBlockingSemaphoreLike getFreeConnectionsForHost(Object partitionKey) {
57 return maxConnectionsPerHost > 0 ?
58 freeChannelsPerHost.computeIfAbsent(partitionKey, pk -> new NonBlockingSemaphore(maxConnectionsPerHost)) :
59 NonBlockingSemaphoreInfinite.INSTANCE;
60 }
61
62 private boolean tryAcquirePerHost(Object partitionKey) {
63 return getFreeConnectionsForHost(partitionKey).tryAcquire();
64 }
65
66 public void acquireChannelLock(Object partitionKey) throws IOException {
67 if (!tryAcquireGlobal())
68 throw tooManyConnections;
69 if (!tryAcquirePerHost(partitionKey)) {
70 freeChannels.release();
71
72 throw tooManyConnectionsPerHost;
73 }
74 }
75
76 public void releaseChannelLock(Object partitionKey) {
77 freeChannels.release();
78 getFreeConnectionsForHost(partitionKey).release();
79 }
8026 }
+22
-0
client/src/main/java/org/asynchttpclient/netty/channel/ConnectionSemaphoreFactory.java less more
0 /*
1 * Copyright (c) 2018 AsyncHttpClient Project. All rights reserved.
2 *
3 * This program is licensed to you under the Apache License Version 2.0,
4 * and you may not use this file except in compliance with the Apache License Version 2.0.
5 * You may obtain a copy of the Apache License Version 2.0 at
6 * http://www.apache.org/licenses/LICENSE-2.0.
7 *
8 * Unless required by applicable law or agreed to in writing,
9 * software distributed under the Apache License Version 2.0 is distributed on an
10 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
12 */
13 package org.asynchttpclient.netty.channel;
14
15 import org.asynchttpclient.AsyncHttpClientConfig;
16
17 public interface ConnectionSemaphoreFactory {
18
19 ConnectionSemaphore newConnectionSemaphore(AsyncHttpClientConfig config);
20
21 }
+30
-0
client/src/main/java/org/asynchttpclient/netty/channel/DefaultConnectionSemaphoreFactory.java less more
0 /*
1 * Copyright (c) 2018 AsyncHttpClient Project. All rights reserved.
2 *
3 * This program is licensed to you under the Apache License Version 2.0,
4 * and you may not use this file except in compliance with the Apache License Version 2.0.
5 * You may obtain a copy of the Apache License Version 2.0 at
6 * http://www.apache.org/licenses/LICENSE-2.0.
7 *
8 * Unless required by applicable law or agreed to in writing,
9 * software distributed under the Apache License Version 2.0 is distributed on an
10 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
12 */
13 package org.asynchttpclient.netty.channel;
14
15 import org.asynchttpclient.AsyncHttpClientConfig;
16
17 public class DefaultConnectionSemaphoreFactory implements ConnectionSemaphoreFactory {
18
19 public ConnectionSemaphore newConnectionSemaphore(AsyncHttpClientConfig config) {
20 ConnectionSemaphore semaphore = new NoopConnectionSemaphore();
21 if (config.getMaxConnections() > 0) {
22 semaphore = new MaxConnectionSemaphore(config.getMaxConnections());
23 }
24 if (config.getMaxConnectionsPerHost() > 0) {
25 semaphore = new PerHostConnectionSemaphore(config.getMaxConnectionsPerHost(), semaphore);
26 }
27 return semaphore;
28 }
29 }
+47
-0
client/src/main/java/org/asynchttpclient/netty/channel/MaxConnectionSemaphore.java less more
0 /*
1 * Copyright (c) 2018 AsyncHttpClient Project. All rights reserved.
2 *
3 * This program is licensed to you under the Apache License Version 2.0,
4 * and you may not use this file except in compliance with the Apache License Version 2.0.
5 * You may obtain a copy of the Apache License Version 2.0 at
6 * http://www.apache.org/licenses/LICENSE-2.0.
7 *
8 * Unless required by applicable law or agreed to in writing,
9 * software distributed under the Apache License Version 2.0 is distributed on an
10 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
12 */
13 package org.asynchttpclient.netty.channel;
14
15 import org.asynchttpclient.exception.TooManyConnectionsException;
16
17 import java.io.IOException;
18
19 import static org.asynchttpclient.util.ThrowableUtil.unknownStackTrace;
20
21 /**
22 * Max connections limiter.
23 *
24 * @author Stepan Koltsov
25 */
26 public class MaxConnectionSemaphore implements ConnectionSemaphore {
27
28 private final NonBlockingSemaphoreLike freeChannels;
29 private final IOException tooManyConnections;
30
31 MaxConnectionSemaphore(int maxConnections) {
32 tooManyConnections = unknownStackTrace(new TooManyConnectionsException(maxConnections), MaxConnectionSemaphore.class, "acquireChannelLock");
33 freeChannels = maxConnections > 0 ? new NonBlockingSemaphore(maxConnections) : NonBlockingSemaphoreInfinite.INSTANCE;
34 }
35
36 @Override
37 public void acquireChannelLock(Object partitionKey) throws IOException {
38 if (!freeChannels.tryAcquire())
39 throw tooManyConnections;
40 }
41
42 @Override
43 public void releaseChannelLock(Object partitionKey) {
44 freeChannels.release();
45 }
46 }
+30
-0
client/src/main/java/org/asynchttpclient/netty/channel/NoopConnectionSemaphore.java less more
0 /*
1 * Copyright (c) 2018 AsyncHttpClient Project. All rights reserved.
2 *
3 * This program is licensed to you under the Apache License Version 2.0,
4 * and you may not use this file except in compliance with the Apache License Version 2.0.
5 * You may obtain a copy of the Apache License Version 2.0 at
6 * http://www.apache.org/licenses/LICENSE-2.0.
7 *
8 * Unless required by applicable law or agreed to in writing,
9 * software distributed under the Apache License Version 2.0 is distributed on an
10 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
12 */
13 package org.asynchttpclient.netty.channel;
14
15 import java.io.IOException;
16
17 /**
18 * No-op implementation of {@link ConnectionSemaphore}.
19 */
20 public class NoopConnectionSemaphore implements ConnectionSemaphore {
21
22 @Override
23 public void acquireChannelLock(Object partitionKey) throws IOException {
24 }
25
26 @Override
27 public void releaseChannelLock(Object partitionKey) {
28 }
29 }
+61
-0
client/src/main/java/org/asynchttpclient/netty/channel/PerHostConnectionSemaphore.java less more
0 /*
1 * Copyright (c) 2018 AsyncHttpClient Project. All rights reserved.
2 *
3 * This program is licensed to you under the Apache License Version 2.0,
4 * and you may not use this file except in compliance with the Apache License Version 2.0.
5 * You may obtain a copy of the Apache License Version 2.0 at
6 * http://www.apache.org/licenses/LICENSE-2.0.
7 *
8 * Unless required by applicable law or agreed to in writing,
9 * software distributed under the Apache License Version 2.0 is distributed on an
10 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
12 */
13 package org.asynchttpclient.netty.channel;
14
15 import org.asynchttpclient.exception.TooManyConnectionsPerHostException;
16
17 import java.io.IOException;
18 import java.util.concurrent.ConcurrentHashMap;
19
20 import static org.asynchttpclient.util.ThrowableUtil.unknownStackTrace;
21
22 /**
23 * Max per-host connections limiter.
24 */
25 public class PerHostConnectionSemaphore implements ConnectionSemaphore {
26
27 private final ConnectionSemaphore globalSemaphore;
28
29 private final ConcurrentHashMap<Object, NonBlockingSemaphore> freeChannelsPerHost = new ConcurrentHashMap<>();
30 private final int maxConnectionsPerHost;
31 private final IOException tooManyConnectionsPerHost;
32
33 PerHostConnectionSemaphore(int maxConnectionsPerHost, ConnectionSemaphore globalSemaphore) {
34 this.globalSemaphore = globalSemaphore;
35 tooManyConnectionsPerHost = unknownStackTrace(new TooManyConnectionsPerHostException(maxConnectionsPerHost), PerHostConnectionSemaphore.class, "acquireChannelLock");
36 this.maxConnectionsPerHost = maxConnectionsPerHost;
37 }
38
39 @Override
40 public void acquireChannelLock(Object partitionKey) throws IOException {
41 globalSemaphore.acquireChannelLock(partitionKey);
42
43 if (!getFreeConnectionsForHost(partitionKey).tryAcquire()) {
44 globalSemaphore.releaseChannelLock(partitionKey);
45 throw tooManyConnectionsPerHost;
46 }
47 }
48
49 @Override
50 public void releaseChannelLock(Object partitionKey) {
51 globalSemaphore.releaseChannelLock(partitionKey);
52 getFreeConnectionsForHost(partitionKey).release();
53 }
54
55 private NonBlockingSemaphoreLike getFreeConnectionsForHost(Object partitionKey) {
56 return maxConnectionsPerHost > 0 ?
57 freeChannelsPerHost.computeIfAbsent(partitionKey, pk -> new NonBlockingSemaphore(maxConnectionsPerHost)) :
58 NonBlockingSemaphoreInfinite.INSTANCE;
59 }
60 }
+9
-2
client/src/main/java/org/asynchttpclient/netty/handler/intercept/ConnectSuccessInterceptor.java less more
1313 package org.asynchttpclient.netty.handler.intercept;
1414
1515 import io.netty.channel.Channel;
16 import io.netty.util.concurrent.Future;
1617 import org.asynchttpclient.Request;
1718 import org.asynchttpclient.RequestBuilder;
1819 import org.asynchttpclient.netty.NettyResponseFuture;
4647 Uri requestUri = request.getUri();
4748 LOGGER.debug("Connecting to proxy {} for scheme {}", proxyServer, requestUri.getScheme());
4849
49 channelManager.updatePipelineForHttpTunneling(channel.pipeline(), requestUri);
50 Future<Channel> whenHandshaked = channelManager.updatePipelineForHttpTunneling(channel.pipeline(), requestUri);
51
5052 future.setReuseChannel(true);
5153 future.setConnectAllowed(false);
52 requestSender.drainChannelAndExecuteNextRequest(channel, future, new RequestBuilder(future.getTargetRequest()).build());
54 Request targetRequest = new RequestBuilder(future.getTargetRequest()).build();
55 if (whenHandshaked == null) {
56 requestSender.drainChannelAndExecuteNextRequest(channel, future, targetRequest);
57 } else {
58 requestSender.drainChannelAndExecuteNextRequest(channel, future, targetRequest, whenHandshaked);
59 }
5360
5461 return true;
5562 }
+26
-3
client/src/main/java/org/asynchttpclient/netty/request/NettyRequestSender.java less more
7474 AsyncHttpClientState clientState) {
7575 this.config = config;
7676 this.channelManager = channelManager;
77 this.connectionSemaphore = ConnectionSemaphore.newConnectionSemaphore(config);
77 this.connectionSemaphore = config.getConnectionSemaphoreFactory() == null
78 ? new DefaultConnectionSemaphoreFactory().newConnectionSemaphore(config)
79 : config.getConnectionSemaphoreFactory().newConnectionSemaphore(config);
7880 this.nettyTimer = nettyTimer;
7981 this.clientState = clientState;
8082 requestFactory = new NettyRequestFactory(config);
459461
460462 public void abort(Channel channel, NettyResponseFuture<?> future, Throwable t) {
461463
462 if (channel != null) {
464 if (channel != null && channel.isActive()) {
463465 channelManager.closeChannel(channel);
464466 }
465467
603605 return clientState.isClosed();
604606 }
605607
606 public void drainChannelAndExecuteNextRequest(final Channel channel, final NettyResponseFuture<?> future,
608 public void drainChannelAndExecuteNextRequest(final Channel channel,
609 final NettyResponseFuture<?> future,
607610 Request nextRequest) {
608611 Channels.setAttribute(channel, new OnLastHttpContentCallback(future) {
609612 @Override
612615 }
613616 });
614617 }
618
619 public void drainChannelAndExecuteNextRequest(final Channel channel,
620 final NettyResponseFuture<?> future,
621 Request nextRequest,
622 Future<Channel> whenHandshaked) {
623 Channels.setAttribute(channel, new OnLastHttpContentCallback(future) {
624 @Override
625 public void call() {
626 whenHandshaked.addListener(f -> {
627 if (f.isSuccess()) {
628 sendNextRequest(nextRequest, future);
629 } else {
630 future.abort(f.cause());
631 }
632 }
633 );
634 }
635 });
636 }
637
615638 }
+1
-1
example/pom.xml less more
11 <parent>
22 <groupId>org.asynchttpclient</groupId>
33 <artifactId>async-http-client-project</artifactId>
4 <version>2.4.9</version>
4 <version>2.5.0</version>
55 </parent>
66 <modelVersion>4.0.0</modelVersion>
77 <artifactId>async-http-client-example</artifactId>
+1
-1
extras/guava/pom.xml less more
11 <parent>
22 <groupId>org.asynchttpclient</groupId>
33 <artifactId>async-http-client-extras-parent</artifactId>
4 <version>2.4.9</version>
4 <version>2.5.0</version>
55 </parent>
66 <modelVersion>4.0.0</modelVersion>
77 <artifactId>async-http-client-extras-guava</artifactId>
+1
-1
extras/jdeferred/pom.xml less more
1717 <parent>
1818 <artifactId>async-http-client-extras-parent</artifactId>
1919 <groupId>org.asynchttpclient</groupId>
20 <version>2.4.9</version>
20 <version>2.5.0</version>
2121 </parent>
2222 <artifactId>async-http-client-extras-jdeferred</artifactId>
2323 <name>Asynchronous Http Client JDeferred Extras</name>
+1
-1
extras/pom.xml less more
11 <parent>
22 <groupId>org.asynchttpclient</groupId>
33 <artifactId>async-http-client-project</artifactId>
4 <version>2.4.9</version>
4 <version>2.5.0</version>
55 </parent>
66 <modelVersion>4.0.0</modelVersion>
77 <artifactId>async-http-client-extras-parent</artifactId>
+1
-1
extras/registry/pom.xml less more
11 <parent>
22 <groupId>org.asynchttpclient</groupId>
33 <artifactId>async-http-client-extras-parent</artifactId>
4 <version>2.4.9</version>
4 <version>2.5.0</version>
55 </parent>
66 <modelVersion>4.0.0</modelVersion>
77 <artifactId>async-http-client-extras-registry</artifactId>
+1
-1
extras/retrofit2/pom.xml less more
33 <parent>
44 <artifactId>async-http-client-extras-parent</artifactId>
55 <groupId>org.asynchttpclient</groupId>
6 <version>2.4.9</version>
6 <version>2.5.0</version>
77 </parent>
88
99 <artifactId>async-http-client-extras-retrofit2</artifactId>
+1
-1
extras/rxjava/pom.xml less more
22 <parent>
33 <artifactId>async-http-client-extras-parent</artifactId>
44 <groupId>org.asynchttpclient</groupId>
5 <version>2.4.9</version>
5 <version>2.5.0</version>
66 </parent>
77 <artifactId>async-http-client-extras-rxjava</artifactId>
88 <name>Asynchronous Http Client RxJava Extras</name>
+1
-1
extras/rxjava2/pom.xml less more
22 <parent>
33 <artifactId>async-http-client-extras-parent</artifactId>
44 <groupId>org.asynchttpclient</groupId>
5 <version>2.4.9</version>
5 <version>2.5.0</version>
66 </parent>
77 <artifactId>async-http-client-extras-rxjava2</artifactId>
88 <name>Asynchronous Http Client RxJava2 Extras</name>
+1
-1
extras/simple/pom.xml less more
22 <parent>
33 <artifactId>async-http-client-extras-parent</artifactId>
44 <groupId>org.asynchttpclient</groupId>
5 <version>2.4.9</version>
5 <version>2.5.0</version>
66 </parent>
77 <artifactId>async-http-client-extras-simple</artifactId>
88 <name>Asynchronous Http Simple Client</name>
+1
-1
extras/typesafeconfig/pom.xml less more
33 <parent>
44 <artifactId>async-http-client-extras-parent</artifactId>
55 <groupId>org.asynchttpclient</groupId>
6 <version>2.4.9</version>
6 <version>2.5.0</version>
77 </parent>
88
99 <artifactId>async-http-client-extras-typesafe-config</artifactId>
+6
-0
extras/typesafeconfig/src/main/java/org/asynchttpclient/extras/typesafeconfig/AsyncHttpClientTypesafeConfig.java less more
3030 import org.asynchttpclient.filter.IOExceptionFilter;
3131 import org.asynchttpclient.filter.RequestFilter;
3232 import org.asynchttpclient.filter.ResponseFilter;
33 import org.asynchttpclient.netty.channel.ConnectionSemaphoreFactory;
3334 import org.asynchttpclient.proxy.ProxyServerSelector;
3435
3536 import java.util.*;
323324 }
324325
325326 @Override
327 public ConnectionSemaphoreFactory getConnectionSemaphoreFactory() {
328 return null;
329 }
330
331 @Override
326332 public Timer getNettyTimer() {
327333 return null;
328334 }
+1
-1
netty-utils/pom.xml less more
11 <parent>
22 <groupId>org.asynchttpclient</groupId>
33 <artifactId>async-http-client-project</artifactId>
4 <version>2.4.9</version>
4 <version>2.5.0</version>
55 </parent>
66 <modelVersion>4.0.0</modelVersion>
77 <artifactId>async-http-client-netty-utils</artifactId>
+1
-1
pom.xml less more
88 <groupId>org.asynchttpclient</groupId>
99 <artifactId>async-http-client-project</artifactId>
1010 <name>Asynchronous Http Client Project</name>
11 <version>2.4.9</version>
11 <version>2.5.0</version>
1212 <packaging>pom</packaging>
1313 <description>
1414 The Async Http Client (AHC) library's purpose is to allow Java