diff options
author | Matt A. Tobin <mattatobin@localhost.localdomain> | 2018-02-02 04:16:08 -0500 |
---|---|---|
committer | Matt A. Tobin <mattatobin@localhost.localdomain> | 2018-02-02 04:16:08 -0500 |
commit | 5f8de423f190bbb79a62f804151bc24824fa32d8 (patch) | |
tree | 10027f336435511475e392454359edea8e25895d /mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/BasicHttpClientConnectionManager.java | |
parent | 49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff) | |
download | UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip |
Add m-esr52 at 52.6.0
Diffstat (limited to 'mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/BasicHttpClientConnectionManager.java')
-rw-r--r-- | mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/BasicHttpClientConnectionManager.java | 370 |
1 files changed, 370 insertions, 0 deletions
diff --git a/mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/BasicHttpClientConnectionManager.java b/mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/BasicHttpClientConnectionManager.java new file mode 100644 index 000000000..1049a4151 --- /dev/null +++ b/mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/BasicHttpClientConnectionManager.java @@ -0,0 +1,370 @@ +/* + * ==================================================================== + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + * <http://www.apache.org/>. + * + */ + +package ch.boye.httpclientandroidlib.impl.conn; + +import java.io.Closeable; +import java.io.IOException; +import java.net.InetSocketAddress; +import java.util.Date; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; + +import ch.boye.httpclientandroidlib.androidextra.HttpClientAndroidLog; +/* LogFactory removed by HttpClient for Android script. */ +import ch.boye.httpclientandroidlib.HttpClientConnection; +import ch.boye.httpclientandroidlib.HttpHost; +import ch.boye.httpclientandroidlib.annotation.GuardedBy; +import ch.boye.httpclientandroidlib.annotation.ThreadSafe; +import ch.boye.httpclientandroidlib.config.ConnectionConfig; +import ch.boye.httpclientandroidlib.config.Lookup; +import ch.boye.httpclientandroidlib.config.Registry; +import ch.boye.httpclientandroidlib.config.RegistryBuilder; +import ch.boye.httpclientandroidlib.config.SocketConfig; +import ch.boye.httpclientandroidlib.conn.ConnectionRequest; +import ch.boye.httpclientandroidlib.conn.DnsResolver; +import ch.boye.httpclientandroidlib.conn.HttpClientConnectionManager; +import ch.boye.httpclientandroidlib.conn.HttpConnectionFactory; +import ch.boye.httpclientandroidlib.conn.SchemePortResolver; +import ch.boye.httpclientandroidlib.conn.ManagedHttpClientConnection; +import ch.boye.httpclientandroidlib.conn.routing.HttpRoute; +import ch.boye.httpclientandroidlib.conn.socket.ConnectionSocketFactory; +import ch.boye.httpclientandroidlib.conn.socket.PlainConnectionSocketFactory; +import ch.boye.httpclientandroidlib.conn.ssl.SSLConnectionSocketFactory; +import ch.boye.httpclientandroidlib.protocol.HttpContext; +import ch.boye.httpclientandroidlib.util.Args; +import ch.boye.httpclientandroidlib.util.Asserts; +import ch.boye.httpclientandroidlib.util.LangUtils; + +/** + * A connection manager for a single connection. This connection manager maintains only one active + * connection. Even though this class is fully thread-safe it ought to be used by one execution + * thread only, as only one thread a time can lease the connection at a time. + * <p/> + * This connection manager will make an effort to reuse the connection for subsequent requests + * with the same {@link HttpRoute route}. It will, however, close the existing connection and + * open it for the given route, if the route of the persistent connection does not match that + * of the connection request. If the connection has been already been allocated + * {@link IllegalStateException} is thrown. + * <p/> + * This connection manager implementation should be used inside an EJB container instead of + * {@link PoolingHttpClientConnectionManager}. + * + * @since 4.3 + */ +@ThreadSafe +public class BasicHttpClientConnectionManager implements HttpClientConnectionManager, Closeable { + + public HttpClientAndroidLog log = new HttpClientAndroidLog(getClass()); + + private final HttpClientConnectionOperator connectionOperator; + private final HttpConnectionFactory<HttpRoute, ManagedHttpClientConnection> connFactory; + + @GuardedBy("this") + private ManagedHttpClientConnection conn; + + @GuardedBy("this") + private HttpRoute route; + + @GuardedBy("this") + private Object state; + + @GuardedBy("this") + private long updated; + + @GuardedBy("this") + private long expiry; + + @GuardedBy("this") + private boolean leased; + + @GuardedBy("this") + private SocketConfig socketConfig; + + @GuardedBy("this") + private ConnectionConfig connConfig; + + private final AtomicBoolean isShutdown; + + private static Registry<ConnectionSocketFactory> getDefaultRegistry() { + return RegistryBuilder.<ConnectionSocketFactory>create() + .register("http", PlainConnectionSocketFactory.getSocketFactory()) + .register("https", SSLConnectionSocketFactory.getSocketFactory()) + .build(); + } + + public BasicHttpClientConnectionManager( + final Lookup<ConnectionSocketFactory> socketFactoryRegistry, + final HttpConnectionFactory<HttpRoute, ManagedHttpClientConnection> connFactory, + final SchemePortResolver schemePortResolver, + final DnsResolver dnsResolver) { + super(); + this.connectionOperator = new HttpClientConnectionOperator( + socketFactoryRegistry, schemePortResolver, dnsResolver); + this.connFactory = connFactory != null ? connFactory : ManagedHttpClientConnectionFactory.INSTANCE; + this.expiry = Long.MAX_VALUE; + this.socketConfig = SocketConfig.DEFAULT; + this.connConfig = ConnectionConfig.DEFAULT; + this.isShutdown = new AtomicBoolean(false); + } + + public BasicHttpClientConnectionManager( + final Lookup<ConnectionSocketFactory> socketFactoryRegistry, + final HttpConnectionFactory<HttpRoute, ManagedHttpClientConnection> connFactory) { + this(socketFactoryRegistry, connFactory, null, null); + } + + public BasicHttpClientConnectionManager( + final Lookup<ConnectionSocketFactory> socketFactoryRegistry) { + this(socketFactoryRegistry, null, null, null); + } + + public BasicHttpClientConnectionManager() { + this(getDefaultRegistry(), null, null, null); + } + + @Override + protected void finalize() throws Throwable { + try { + shutdown(); + } finally { // Make sure we call overridden method even if shutdown barfs + super.finalize(); + } + } + + public void close() { + shutdown(); + } + + HttpRoute getRoute() { + return route; + } + + Object getState() { + return state; + } + + public synchronized SocketConfig getSocketConfig() { + return socketConfig; + } + + public synchronized void setSocketConfig(final SocketConfig socketConfig) { + this.socketConfig = socketConfig != null ? socketConfig : SocketConfig.DEFAULT; + } + + public synchronized ConnectionConfig getConnectionConfig() { + return connConfig; + } + + public synchronized void setConnectionConfig(final ConnectionConfig connConfig) { + this.connConfig = connConfig != null ? connConfig : ConnectionConfig.DEFAULT; + } + + public final ConnectionRequest requestConnection( + final HttpRoute route, + final Object state) { + Args.notNull(route, "Route"); + return new ConnectionRequest() { + + public boolean cancel() { + // Nothing to abort, since requests are immediate. + return false; + } + + public HttpClientConnection get(final long timeout, final TimeUnit tunit) { + return BasicHttpClientConnectionManager.this.getConnection( + route, state); + } + + }; + } + + private void closeConnection() { + if (this.conn != null) { + this.log.debug("Closing connection"); + try { + this.conn.close(); + } catch (final IOException iox) { + if (this.log.isDebugEnabled()) { + this.log.debug("I/O exception closing connection", iox); + } + } + this.conn = null; + } + } + + private void shutdownConnection() { + if (this.conn != null) { + this.log.debug("Shutting down connection"); + try { + this.conn.shutdown(); + } catch (final IOException iox) { + if (this.log.isDebugEnabled()) { + this.log.debug("I/O exception shutting down connection", iox); + } + } + this.conn = null; + } + } + + private void checkExpiry() { + if (this.conn != null && System.currentTimeMillis() >= this.expiry) { + if (this.log.isDebugEnabled()) { + this.log.debug("Connection expired @ " + new Date(this.expiry)); + } + closeConnection(); + } + } + + synchronized HttpClientConnection getConnection(final HttpRoute route, final Object state) { + Asserts.check(!this.isShutdown.get(), "Connection manager has been shut down"); + if (this.log.isDebugEnabled()) { + this.log.debug("Get connection for route " + route); + } + Asserts.check(!this.leased, "Connection is still allocated"); + if (!LangUtils.equals(this.route, route) || !LangUtils.equals(this.state, state)) { + closeConnection(); + } + this.route = route; + this.state = state; + checkExpiry(); + if (this.conn == null) { + this.conn = this.connFactory.create(route, this.connConfig); + } + this.leased = true; + return this.conn; + } + + public synchronized void releaseConnection( + final HttpClientConnection conn, + final Object state, + final long keepalive, final TimeUnit tunit) { + Args.notNull(conn, "Connection"); + Asserts.check(conn == this.conn, "Connection not obtained from this manager"); + if (this.log.isDebugEnabled()) { + this.log.debug("Releasing connection " + conn); + } + if (this.isShutdown.get()) { + return; + } + try { + this.updated = System.currentTimeMillis(); + if (!this.conn.isOpen()) { + this.conn = null; + this.route = null; + this.conn = null; + this.expiry = Long.MAX_VALUE; + } else { + this.state = state; + if (this.log.isDebugEnabled()) { + final String s; + if (keepalive > 0) { + s = "for " + keepalive + " " + tunit; + } else { + s = "indefinitely"; + } + this.log.debug("Connection can be kept alive " + s); + } + if (keepalive > 0) { + this.expiry = this.updated + tunit.toMillis(keepalive); + } else { + this.expiry = Long.MAX_VALUE; + } + } + } finally { + this.leased = false; + } + } + + public void connect( + final HttpClientConnection conn, + final HttpRoute route, + final int connectTimeout, + final HttpContext context) throws IOException { + Args.notNull(conn, "Connection"); + Args.notNull(route, "HTTP route"); + Asserts.check(conn == this.conn, "Connection not obtained from this manager"); + final HttpHost host; + if (route.getProxyHost() != null) { + host = route.getProxyHost(); + } else { + host = route.getTargetHost(); + } + final InetSocketAddress localAddress = route.getLocalSocketAddress(); + this.connectionOperator.connect(this.conn, host, localAddress, + connectTimeout, this.socketConfig, context); + } + + public void upgrade( + final HttpClientConnection conn, + final HttpRoute route, + final HttpContext context) throws IOException { + Args.notNull(conn, "Connection"); + Args.notNull(route, "HTTP route"); + Asserts.check(conn == this.conn, "Connection not obtained from this manager"); + this.connectionOperator.upgrade(this.conn, route.getTargetHost(), context); + } + + public void routeComplete( + final HttpClientConnection conn, + final HttpRoute route, + final HttpContext context) throws IOException { + } + + public synchronized void closeExpiredConnections() { + if (this.isShutdown.get()) { + return; + } + if (!this.leased) { + checkExpiry(); + } + } + + public synchronized void closeIdleConnections(final long idletime, final TimeUnit tunit) { + Args.notNull(tunit, "Time unit"); + if (this.isShutdown.get()) { + return; + } + if (!this.leased) { + long time = tunit.toMillis(idletime); + if (time < 0) { + time = 0; + } + final long deadline = System.currentTimeMillis() - time; + if (this.updated <= deadline) { + closeConnection(); + } + } + } + + public synchronized void shutdown() { + if (this.isShutdown.compareAndSet(false, true)) { + shutdownConnection(); + } + } + +} |