View Javadoc
1   /*
2    * ====================================================================
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *   http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing,
14   * software distributed under the License is distributed on an
15   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16   * KIND, either express or implied.  See the License for the
17   * specific language governing permissions and limitations
18   * under the License.
19   * ====================================================================
20   *
21   * This software consists of voluntary contributions made by many
22   * individuals on behalf of the Apache Software Foundation.  For more
23   * information on the Apache Software Foundation, please see
24   * <http://www.apache.org/>.
25   *
26   */
27  
28  package org.apache.http.impl.conn;
29  
30  import java.io.IOException;
31  import java.util.concurrent.TimeUnit;
32  
33  import org.apache.commons.logging.Log;
34  import org.apache.commons.logging.LogFactory;
35  import org.apache.http.annotation.Contract;
36  import org.apache.http.annotation.ThreadingBehavior;
37  import org.apache.http.conn.ClientConnectionManager;
38  import org.apache.http.conn.ClientConnectionOperator;
39  import org.apache.http.conn.ClientConnectionRequest;
40  import org.apache.http.conn.ManagedClientConnection;
41  import org.apache.http.conn.routing.HttpRoute;
42  import org.apache.http.conn.routing.RouteTracker;
43  import org.apache.http.conn.scheme.SchemeRegistry;
44  import org.apache.http.params.HttpParams;
45  import org.apache.http.util.Args;
46  import org.apache.http.util.Asserts;
47  
48  /**
49   * A connection manager for a single connection. This connection manager
50   * maintains only one active connection at a time. Even though this class
51   * is thread-safe it ought to be used by one execution thread only.
52   * <p>
53   * SingleClientConnManager will make an effort to reuse the connection
54   * for subsequent requests with the same {@link HttpRoute route}.
55   * It will, however, close the existing connection and open it
56   * for the given route, if the route of the persistent connection does
57   * not match that of the connection request. If the connection has been
58   * already been allocated {@link IllegalStateException} is thrown.
59   *
60   * @since 4.0
61   *
62   * @deprecated (4.2)  use {@link BasicClientConnectionManager}
63   */
64  @Contract(threading = ThreadingBehavior.SAFE)
65  @Deprecated
66  public class SingleClientConnManager implements ClientConnectionManager {
67  
68      private final Log log = LogFactory.getLog(getClass());
69  
70      /** The message to be logged on multiple allocation. */
71      public final static String MISUSE_MESSAGE =
72      "Invalid use of SingleClientConnManager: connection still allocated.\n" +
73      "Make sure to release the connection before allocating another one.";
74  
75      /** The schemes supported by this connection manager. */
76      protected final SchemeRegistry schemeRegistry;
77  
78      /** The operator for opening and updating connections. */
79      protected final ClientConnectionOperator connOperator;
80  
81      /** Whether the connection should be shut down  on release. */
82      protected final boolean alwaysShutDown;
83  
84      /** The one and only entry in this pool. */
85      protected volatile PoolEntry uniquePoolEntry;
86  
87      /** The currently issued managed connection, if any. */
88      protected volatile ConnAdapter managedConn;
89  
90      /** The time of the last connection release, or -1. */
91      protected volatile long lastReleaseTime;
92  
93      /** The time the last released connection expires and shouldn't be reused. */
94      protected volatile long connectionExpiresTime;
95  
96      /** Indicates whether this connection manager is shut down. */
97      protected volatile boolean isShutDown;
98  
99      /**
100      * Creates a new simple connection manager.
101      *
102      * @param params    the parameters for this manager
103      * @param schreg    the scheme registry
104      *
105      * @deprecated (4.1)  use {@link SingleClientConnManager#SingleClientConnManager(SchemeRegistry)}
106      */
107     @Deprecated
108     public SingleClientConnManager(final HttpParams params,
109                                    final SchemeRegistry schreg) {
110         this(schreg);
111     }
112     /**
113      * Creates a new simple connection manager.
114      *
115      * @param schreg    the scheme registry
116      */
117     public SingleClientConnManager(final SchemeRegistry schreg) {
118         Args.notNull(schreg, "Scheme registry");
119         this.schemeRegistry  = schreg;
120         this.connOperator    = createConnectionOperator(schreg);
121         this.uniquePoolEntry = new PoolEntry();
122         this.managedConn     = null;
123         this.lastReleaseTime = -1L;
124         this.alwaysShutDown  = false; //@@@ from params? as argument?
125         this.isShutDown      = false;
126     }
127 
128     /**
129      * @since 4.1
130      */
131     public SingleClientConnManager() {
132         this(SchemeRegistryFactory.createDefault());
133     }
134 
135     @Override
136     protected void finalize() throws Throwable {
137         try {
138             shutdown();
139         } finally { // Make sure we call overridden method even if shutdown barfs
140             super.finalize();
141         }
142     }
143 
144     @Override
145     public SchemeRegistry getSchemeRegistry() {
146         return this.schemeRegistry;
147     }
148 
149     /**
150      * Hook for creating the connection operator.
151      * It is called by the constructor.
152      * Derived classes can override this method to change the
153      * instantiation of the operator.
154      * The default implementation here instantiates
155      * {@link DefaultClientConnectionOperator DefaultClientConnectionOperator}.
156      *
157      * @param schreg    the scheme registry to use, or {@code null}
158      *
159      * @return  the connection operator to use
160      */
161     protected ClientConnectionOperator
162         createConnectionOperator(final SchemeRegistry schreg) {
163         return new DefaultClientConnectionOperator(schreg);
164     }
165 
166     /**
167      * Asserts that this manager is not shut down.
168      *
169      * @throws IllegalStateException    if this manager is shut down
170      */
171     protected final void assertStillUp() throws IllegalStateException {
172         Asserts.check(!this.isShutDown, "Manager is shut down");
173     }
174 
175     @Override
176     public final ClientConnectionRequest requestConnection(
177             final HttpRoute route,
178             final Object state) {
179 
180         return new ClientConnectionRequest() {
181 
182             @Override
183             public void abortRequest() {
184                 // Nothing to abort, since requests are immediate.
185             }
186 
187             @Override
188             public ManagedClientConnection getConnection(
189                     final long timeout, final TimeUnit tunit) {
190                 return SingleClientConnManager.this.getConnection(
191                         route, state);
192             }
193 
194         };
195     }
196 
197     /**
198      * Obtains a connection.
199      *
200      * @param route     where the connection should point to
201      *
202      * @return  a connection that can be used to communicate
203      *          along the given route
204      */
205     public ManagedClientConnection getConnection(final HttpRoute route, final Object state) {
206         Args.notNull(route, "Route");
207         assertStillUp();
208 
209         if (log.isDebugEnabled()) {
210             log.debug("Get connection for route " + route);
211         }
212 
213         synchronized (this) {
214 
215             Asserts.check(managedConn == null, MISUSE_MESSAGE);
216 
217             // check re-usability of the connection
218             boolean recreate = false;
219             boolean shutdown = false;
220 
221             // Kill the connection if it expired.
222             closeExpiredConnections();
223 
224             if (uniquePoolEntry.connection.isOpen()) {
225                 final RouteTracker tracker = uniquePoolEntry.tracker;
226                 shutdown = (tracker == null || // can happen if method is aborted
227                             !tracker.toRoute().equals(route));
228             } else {
229                 // If the connection is not open, create a new PoolEntry,
230                 // as the connection may have been marked not reusable,
231                 // due to aborts -- and the PoolEntry should not be reused
232                 // either.  There's no harm in recreating an entry if
233                 // the connection is closed.
234                 recreate = true;
235             }
236 
237             if (shutdown) {
238                 recreate = true;
239                 try {
240                     uniquePoolEntry.shutdown();
241                 } catch (final IOException iox) {
242                     log.debug("Problem shutting down connection.", iox);
243                 }
244             }
245 
246             if (recreate) {
247                 uniquePoolEntry = new PoolEntry();
248             }
249 
250             managedConn = new ConnAdapter(uniquePoolEntry, route);
251 
252             return managedConn;
253         }
254     }
255 
256     @Override
257     public void releaseConnection(
258             final ManagedClientConnection conn,
259             final long validDuration, final TimeUnit timeUnit) {
260         Args.check(conn instanceof ConnAdapter, "Connection class mismatch, " +
261             "connection not obtained from this manager");
262         assertStillUp();
263 
264         if (log.isDebugEnabled()) {
265             log.debug("Releasing connection " + conn);
266         }
267 
268         final ConnAdapter sca = (ConnAdapter) conn;
269         synchronized (sca) {
270             if (sca.poolEntry == null)
271              {
272                 return; // already released
273             }
274             final ClientConnectionManager manager = sca.getManager();
275             Asserts.check(manager == this, "Connection not obtained from this manager");
276             try {
277                 // make sure that the response has been read completely
278                 if (sca.isOpen() && (this.alwaysShutDown ||
279                                      !sca.isMarkedReusable())
280                     ) {
281                     if (log.isDebugEnabled()) {
282                         log.debug
283                             ("Released connection open but not reusable.");
284                     }
285 
286                     // make sure this connection will not be re-used
287                     // we might have gotten here because of a shutdown trigger
288                     // shutdown of the adapter also clears the tracked route
289                     sca.shutdown();
290                 }
291             } catch (final IOException iox) {
292                 if (log.isDebugEnabled()) {
293                     log.debug("Exception shutting down released connection.",
294                               iox);
295                 }
296             } finally {
297                 sca.detach();
298                 synchronized (this) {
299                     managedConn = null;
300                     lastReleaseTime = System.currentTimeMillis();
301                     if(validDuration > 0) {
302                         connectionExpiresTime = timeUnit.toMillis(validDuration) + lastReleaseTime;
303                     } else {
304                         connectionExpiresTime = Long.MAX_VALUE;
305                     }
306                 }
307             }
308         }
309     }
310 
311     @Override
312     public void closeExpiredConnections() {
313         final long time = connectionExpiresTime;
314         if (System.currentTimeMillis() >= time) {
315             closeIdleConnections(0, TimeUnit.MILLISECONDS);
316         }
317     }
318 
319     @Override
320     public void closeIdleConnections(final long idletime, final TimeUnit tunit) {
321         assertStillUp();
322 
323         // idletime can be 0 or negative, no problem there
324         Args.notNull(tunit, "Time unit");
325 
326         synchronized (this) {
327             if ((managedConn == null) && uniquePoolEntry.connection.isOpen()) {
328                 final long cutoff =
329                     System.currentTimeMillis() - tunit.toMillis(idletime);
330                 if (lastReleaseTime <= cutoff) {
331                     try {
332                         uniquePoolEntry.close();
333                     } catch (final IOException iox) {
334                         // ignore
335                         log.debug("Problem closing idle connection.", iox);
336                     }
337                 }
338             }
339         }
340     }
341 
342     @Override
343     public void shutdown() {
344         this.isShutDown = true;
345         synchronized (this) {
346             try {
347                 if (uniquePoolEntry != null) {
348                     uniquePoolEntry.shutdown();
349                 }
350             } catch (final IOException iox) {
351                 // ignore
352                 log.debug("Problem while shutting down manager.", iox);
353             } finally {
354                 uniquePoolEntry = null;
355                 managedConn = null;
356             }
357         }
358     }
359 
360     protected void revokeConnection() {
361         final ConnAdapter conn = managedConn;
362         if (conn == null) {
363             return;
364         }
365         conn.detach();
366 
367         synchronized (this) {
368             try {
369                 uniquePoolEntry.shutdown();
370             } catch (final IOException iox) {
371                 // ignore
372                 log.debug("Problem while shutting down connection.", iox);
373             }
374         }
375     }
376 
377     /**
378      * The pool entry for this connection manager.
379      */
380     protected class PoolEntry extends AbstractPoolEntry {
381 
382         /**
383          * Creates a new pool entry.
384          *
385          */
386         protected PoolEntry() {
387             super(SingleClientConnManager.this.connOperator, null);
388         }
389 
390         /**
391          * Closes the connection in this pool entry.
392          */
393         protected void close() throws IOException {
394             shutdownEntry();
395             if (connection.isOpen()) {
396                 connection.close();
397             }
398         }
399 
400         /**
401          * Shuts down the connection in this pool entry.
402          */
403         protected void shutdown() throws IOException {
404             shutdownEntry();
405             if (connection.isOpen()) {
406                 connection.shutdown();
407             }
408         }
409 
410     }
411 
412     /**
413      * The connection adapter used by this manager.
414      */
415     protected class ConnAdapter extends AbstractPooledConnAdapter {
416 
417         /**
418          * Creates a new connection adapter.
419          *
420          * @param entry   the pool entry for the connection being wrapped
421          * @param route   the planned route for this connection
422          */
423         protected ConnAdapter(final PoolEntry entry, final HttpRoute route) {
424             super(SingleClientConnManager.this, entry);
425             markReusable();
426             entry.route = route;
427         }
428 
429     }
430 
431 }