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 package org.apache.http.impl.conn.tsccm;
28
29 import java.io.IOException;
30 import java.util.concurrent.TimeUnit;
31
32 import org.apache.commons.logging.Log;
33 import org.apache.commons.logging.LogFactory;
34 import org.apache.http.annotation.Contract;
35 import org.apache.http.annotation.ThreadingBehavior;
36 import org.apache.http.conn.ClientConnectionManager;
37 import org.apache.http.conn.ClientConnectionOperator;
38 import org.apache.http.conn.ClientConnectionRequest;
39 import org.apache.http.conn.ConnectionPoolTimeoutException;
40 import org.apache.http.conn.ManagedClientConnection;
41 import org.apache.http.conn.params.ConnPerRouteBean;
42 import org.apache.http.conn.routing.HttpRoute;
43 import org.apache.http.conn.scheme.SchemeRegistry;
44 import org.apache.http.impl.conn.DefaultClientConnectionOperator;
45 import org.apache.http.impl.conn.SchemeRegistryFactory;
46 import org.apache.http.params.HttpParams;
47 import org.apache.http.util.Args;
48 import org.apache.http.util.Asserts;
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70 @Contract(threading = ThreadingBehavior.SAFE_CONDITIONAL)
71 @Deprecated
72 public class ThreadSafeClientConnManager implements ClientConnectionManager {
73
74 private final Log log;
75
76
77 protected final SchemeRegistry schemeRegistry;
78
79 protected final AbstractConnPool connectionPool;
80
81
82 protected final ConnPoolByRoute pool;
83
84
85 protected final ClientConnectionOperator connOperator;
86
87 protected final ConnPerRouteBean connPerRoute;
88
89
90
91
92
93
94 public ThreadSafeClientConnManager(final SchemeRegistry schreg) {
95 this(schreg, -1, TimeUnit.MILLISECONDS);
96 }
97
98
99
100
101 public ThreadSafeClientConnManager() {
102 this(SchemeRegistryFactory.createDefault());
103 }
104
105
106
107
108
109
110
111
112
113
114 public ThreadSafeClientConnManager(final SchemeRegistry schreg,
115 final long connTTL, final TimeUnit connTTLTimeUnit) {
116 this(schreg, connTTL, connTTLTimeUnit, new ConnPerRouteBean());
117 }
118
119
120
121
122
123
124
125
126
127
128
129
130
131 public ThreadSafeClientConnManager(final SchemeRegistry schreg,
132 final long connTTL, final TimeUnit connTTLTimeUnit, final ConnPerRouteBean connPerRoute) {
133 super();
134 Args.notNull(schreg, "Scheme registry");
135 this.log = LogFactory.getLog(getClass());
136 this.schemeRegistry = schreg;
137 this.connPerRoute = connPerRoute;
138 this.connOperator = createConnectionOperator(schreg);
139 this.pool = createConnectionPool(connTTL, connTTLTimeUnit) ;
140 this.connectionPool = this.pool;
141 }
142
143
144
145
146
147
148
149
150
151 @Deprecated
152 public ThreadSafeClientConnManager(final HttpParams params,
153 final SchemeRegistry schreg) {
154 Args.notNull(schreg, "Scheme registry");
155 this.log = LogFactory.getLog(getClass());
156 this.schemeRegistry = schreg;
157 this.connPerRoute = new ConnPerRouteBean();
158 this.connOperator = createConnectionOperator(schreg);
159 this.pool = (ConnPoolByRoute) createConnectionPool(params) ;
160 this.connectionPool = this.pool;
161 }
162
163 @Override
164 protected void finalize() throws Throwable {
165 try {
166 shutdown();
167 } finally {
168 super.finalize();
169 }
170 }
171
172
173
174
175
176
177
178
179 @Deprecated
180 protected AbstractConnPool createConnectionPool(final HttpParams params) {
181 return new ConnPoolByRoute(connOperator, params);
182 }
183
184
185
186
187
188
189
190
191 protected ConnPoolByRoute createConnectionPool(final long connTTL, final TimeUnit connTTLTimeUnit) {
192 return new ConnPoolByRoute(connOperator, connPerRoute, 20, connTTL, connTTLTimeUnit);
193 }
194
195
196
197
198
199
200
201
202
203
204
205
206
207 protected ClientConnectionOperator
208 createConnectionOperator(final SchemeRegistry schreg) {
209
210 return new DefaultClientConnectionOperator(schreg);
211 }
212
213 @Override
214 public SchemeRegistry getSchemeRegistry() {
215 return this.schemeRegistry;
216 }
217
218 @Override
219 public ClientConnectionRequest requestConnection(
220 final HttpRoute route,
221 final Object state) {
222
223 final PoolEntryRequest poolRequest = pool.requestPoolEntry(
224 route, state);
225
226 return new ClientConnectionRequest() {
227
228 @Override
229 public void abortRequest() {
230 poolRequest.abortRequest();
231 }
232
233 @Override
234 public ManagedClientConnection getConnection(
235 final long timeout, final TimeUnit timeUnit) throws InterruptedException,
236 ConnectionPoolTimeoutException {
237 Args.notNull(route, "Route");
238
239 if (log.isDebugEnabled()) {
240 log.debug("Get connection: " + route + ", timeout = " + timeout);
241 }
242
243 final BasicPoolEntry entry = poolRequest.getPoolEntry(timeout, timeUnit);
244 return new BasicPooledConnAdapter(ThreadSafeClientConnManager.this, entry);
245 }
246
247 };
248
249 }
250
251 @Override
252 public void releaseConnection(final ManagedClientConnection conn, final long validDuration, final TimeUnit timeUnit) {
253 Args.check(conn instanceof BasicPooledConnAdapter, "Connection class mismatch, " +
254 "connection not obtained from this manager");
255 final BasicPooledConnAdapter./../org/apache/http/impl/conn/tsccm/BasicPooledConnAdapter.html#BasicPooledConnAdapter">BasicPooledConnAdapter hca = (BasicPooledConnAdapter) conn;
256 if (hca.getPoolEntry() != null) {
257 Asserts.check(hca.getManager() == this, "Connection not obtained from this manager");
258 }
259 synchronized (hca) {
260 final BasicPoolEntry./../../../org/apache/http/impl/conn/tsccm/BasicPoolEntry.html#BasicPoolEntry">BasicPoolEntry entry = (BasicPoolEntry) hca.getPoolEntry();
261 if (entry == null) {
262 return;
263 }
264 try {
265
266 if (hca.isOpen() && !hca.isMarkedReusable()) {
267
268
269
270
271
272
273
274
275 hca.shutdown();
276 }
277 } catch (final IOException iox) {
278 if (log.isDebugEnabled()) {
279 log.debug("Exception shutting down released connection.",
280 iox);
281 }
282 } finally {
283 final boolean reusable = hca.isMarkedReusable();
284 if (log.isDebugEnabled()) {
285 if (reusable) {
286 log.debug("Released connection is reusable.");
287 } else {
288 log.debug("Released connection is not reusable.");
289 }
290 }
291 hca.detach();
292 pool.freeEntry(entry, reusable, validDuration, timeUnit);
293 }
294 }
295 }
296
297 @Override
298 public void shutdown() {
299 log.debug("Shutting down");
300 pool.shutdown();
301 }
302
303
304
305
306
307
308
309
310
311
312
313 public int getConnectionsInPool(final HttpRoute route) {
314 return pool.getConnectionsInPool(route);
315 }
316
317
318
319
320
321
322
323
324
325 public int getConnectionsInPool() {
326 return pool.getConnectionsInPool();
327 }
328
329 @Override
330 public void closeIdleConnections(final long idleTimeout, final TimeUnit timeUnit) {
331 if (log.isDebugEnabled()) {
332 log.debug("Closing connections idle longer than " + idleTimeout + " " + timeUnit);
333 }
334 pool.closeIdleConnections(idleTimeout, timeUnit);
335 }
336
337 @Override
338 public void closeExpiredConnections() {
339 log.debug("Closing expired connections");
340 pool.closeExpiredConnections();
341 }
342
343
344
345
346 public int getMaxTotal() {
347 return pool.getMaxTotalConnections();
348 }
349
350
351
352
353 public void setMaxTotal(final int max) {
354 pool.setMaxTotalConnections(max);
355 }
356
357
358
359
360 public int getDefaultMaxPerRoute() {
361 return connPerRoute.getDefaultMaxPerRoute();
362 }
363
364
365
366
367 public void setDefaultMaxPerRoute(final int max) {
368 connPerRoute.setDefaultMaxPerRoute(max);
369 }
370
371
372
373
374 public int getMaxForRoute(final HttpRoute route) {
375 return connPerRoute.getMaxForRoute(route);
376 }
377
378
379
380
381 public void setMaxForRoute(final HttpRoute route, final int max) {
382 connPerRoute.setMaxForRoute(route, max);
383 }
384
385 }
386