1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 package org.apache.hc.client5.http.impl.nio;
29
30 import org.apache.hc.client5.http.DnsResolver;
31 import org.apache.hc.client5.http.HttpRoute;
32 import org.apache.hc.client5.http.SchemePortResolver;
33 import org.apache.hc.client5.http.config.ConnectionConfig;
34 import org.apache.hc.client5.http.config.TlsConfig;
35 import org.apache.hc.client5.http.nio.AsyncClientConnectionOperator;
36 import org.apache.hc.client5.http.ssl.ConscryptClientTlsStrategy;
37 import org.apache.hc.client5.http.ssl.DefaultClientTlsStrategy;
38 import org.apache.hc.core5.annotation.Internal;
39 import org.apache.hc.core5.function.Resolver;
40 import org.apache.hc.core5.http.HttpHost;
41 import org.apache.hc.core5.http.URIScheme;
42 import org.apache.hc.core5.http.config.RegistryBuilder;
43 import org.apache.hc.core5.http.nio.ssl.TlsStrategy;
44 import org.apache.hc.core5.pool.PoolConcurrencyPolicy;
45 import org.apache.hc.core5.pool.PoolReusePolicy;
46 import org.apache.hc.core5.util.ReflectionUtils;
47 import org.apache.hc.core5.util.TimeValue;
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75 public class PoolingAsyncClientConnectionManagerBuilder {
76
77 private TlsStrategy tlsStrategy;
78 private SchemePortResolver schemePortResolver;
79 private DnsResolver dnsResolver;
80 private PoolConcurrencyPolicy poolConcurrencyPolicy;
81 private PoolReusePolicy poolReusePolicy;
82
83 private boolean systemProperties;
84
85 private int maxConnTotal;
86 private int maxConnPerRoute;
87
88 private Resolver<HttpRoute, ConnectionConfig> connectionConfigResolver;
89 private Resolver<HttpHost, TlsConfig> tlsConfigResolver;
90
91 public static PoolingAsyncClientConnectionManagerBuilder create() {
92 return new PoolingAsyncClientConnectionManagerBuilder();
93 }
94
95 @Internal
96 protected PoolingAsyncClientConnectionManagerBuilder() {
97 super();
98 }
99
100
101
102
103 public final PoolingAsyncClientConnectionManagerBuilder setTlsStrategy(
104 final TlsStrategy tlsStrategy) {
105 this.tlsStrategy = tlsStrategy;
106 return this;
107 }
108
109
110
111
112 public final PoolingAsyncClientConnectionManagerBuilder setDnsResolver(final DnsResolver dnsResolver) {
113 this.dnsResolver = dnsResolver;
114 return this;
115 }
116
117
118
119
120 public final PoolingAsyncClientConnectionManagerBuilder setSchemePortResolver(final SchemePortResolver schemePortResolver) {
121 this.schemePortResolver = schemePortResolver;
122 return this;
123 }
124
125
126
127
128 public final PoolingAsyncClientConnectionManagerBuilder setPoolConcurrencyPolicy(final PoolConcurrencyPolicy poolConcurrencyPolicy) {
129 this.poolConcurrencyPolicy = poolConcurrencyPolicy;
130 return this;
131 }
132
133
134
135
136 public final PoolingAsyncClientConnectionManagerBuilder setConnPoolPolicy(final PoolReusePolicy poolReusePolicy) {
137 this.poolReusePolicy = poolReusePolicy;
138 return this;
139 }
140
141
142
143
144 public final PoolingAsyncClientConnectionManagerBuilder setMaxConnTotal(final int maxConnTotal) {
145 this.maxConnTotal = maxConnTotal;
146 return this;
147 }
148
149
150
151
152 public final PoolingAsyncClientConnectionManagerBuilder setMaxConnPerRoute(final int maxConnPerRoute) {
153 this.maxConnPerRoute = maxConnPerRoute;
154 return this;
155 }
156
157
158
159
160
161
162 public final PoolingAsyncClientConnectionManagerBuilder setDefaultConnectionConfig(final ConnectionConfig config) {
163 this.connectionConfigResolver = (route) -> config;
164 return this;
165 }
166
167
168
169
170
171
172 public final PoolingAsyncClientConnectionManagerBuilder setConnectionConfigResolver(
173 final Resolver<HttpRoute, ConnectionConfig> connectionConfigResolver) {
174 this.connectionConfigResolver = connectionConfigResolver;
175 return this;
176 }
177
178
179
180
181
182
183 public final PoolingAsyncClientConnectionManagerBuilder setDefaultTlsConfig(final TlsConfig config) {
184 this.tlsConfigResolver = (host) -> config;
185 return this;
186 }
187
188
189
190
191
192
193 public final PoolingAsyncClientConnectionManagerBuilder setTlsConfigResolver(
194 final Resolver<HttpHost, TlsConfig> tlsConfigResolver) {
195 this.tlsConfigResolver = tlsConfigResolver;
196 return this;
197 }
198
199
200
201
202
203
204 @Deprecated
205 public final PoolingAsyncClientConnectionManagerBuilder setConnectionTimeToLive(final TimeValue timeToLive) {
206 setDefaultConnectionConfig(ConnectionConfig.custom()
207 .setTimeToLive(timeToLive)
208 .build());
209 return this;
210 }
211
212
213
214
215
216
217
218 @Deprecated
219 public final PoolingAsyncClientConnectionManagerBuilder setValidateAfterInactivity(final TimeValue validateAfterInactivity) {
220 setDefaultConnectionConfig(ConnectionConfig.custom()
221 .setValidateAfterInactivity(validateAfterInactivity)
222 .build());
223 return this;
224 }
225
226
227
228
229
230 public final PoolingAsyncClientConnectionManagerBuilder useSystemProperties() {
231 this.systemProperties = true;
232 return this;
233 }
234
235 @Internal
236 protected AsyncClientConnectionOperator createConnectionOperator(
237 final TlsStrategy tlsStrategy,
238 final SchemePortResolver schemePortResolver,
239 final DnsResolver dnsResolver) {
240 return new DefaultAsyncClientConnectionOperator(
241 RegistryBuilder.<TlsStrategy>create()
242 .register(URIScheme.HTTPS.getId(), tlsStrategy)
243 .build(),
244 schemePortResolver,
245 dnsResolver);
246 }
247
248 public PoolingAsyncClientConnectionManager build() {
249 final TlsStrategy tlsStrategyCopy;
250 if (tlsStrategy != null) {
251 tlsStrategyCopy = tlsStrategy;
252 } else {
253 if (ReflectionUtils.determineJRELevel() <= 8 && ConscryptClientTlsStrategy.isSupported()) {
254 if (systemProperties) {
255 tlsStrategyCopy = ConscryptClientTlsStrategy.getSystemDefault();
256 } else {
257 tlsStrategyCopy = ConscryptClientTlsStrategy.getDefault();
258 }
259 } else {
260 if (systemProperties) {
261 tlsStrategyCopy = DefaultClientTlsStrategy.createSystemDefault();
262 } else {
263 tlsStrategyCopy = DefaultClientTlsStrategy.createDefault();
264 }
265 }
266 }
267 final PoolingAsyncClientConnectionManager poolingmgr = new PoolingAsyncClientConnectionManager(
268 createConnectionOperator(tlsStrategyCopy, schemePortResolver, dnsResolver),
269 poolConcurrencyPolicy,
270 poolReusePolicy,
271 null);
272 poolingmgr.setConnectionConfigResolver(connectionConfigResolver);
273 poolingmgr.setTlsConfigResolver(tlsConfigResolver);
274 if (maxConnTotal > 0) {
275 poolingmgr.setMaxTotal(maxConnTotal);
276 }
277 if (maxConnPerRoute > 0) {
278 poolingmgr.setDefaultMaxPerRoute(maxConnPerRoute);
279 }
280 return poolingmgr;
281 }
282
283 }