Add m-esr52 at 52.6.0

1 files changed, 276 insertions, 0 deletions

diff --git a/mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/BasicClientConnectionManager.java b/mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/BasicClientConnectionManager.java
new file mode 100644
index 000000000..176e28150
--- /dev/null
+++ b/mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/conn/BasicClientConnectionManager.java
@@ -0,0 +1,276 @@
+/*
+ * ====================================================================
+ * 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.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+
+import ch.boye.httpclientandroidlib.androidextra.HttpClientAndroidLog;
+/* LogFactory removed by HttpClient for Android script. */
+import ch.boye.httpclientandroidlib.HttpClientConnection;
+import ch.boye.httpclientandroidlib.annotation.GuardedBy;
+import ch.boye.httpclientandroidlib.annotation.ThreadSafe;
+import ch.boye.httpclientandroidlib.conn.ClientConnectionManager;
+import ch.boye.httpclientandroidlib.conn.ClientConnectionOperator;
+import ch.boye.httpclientandroidlib.conn.ClientConnectionRequest;
+import ch.boye.httpclientandroidlib.conn.ManagedClientConnection;
+import ch.boye.httpclientandroidlib.conn.OperatedClientConnection;
+import ch.boye.httpclientandroidlib.conn.routing.HttpRoute;
+import ch.boye.httpclientandroidlib.conn.scheme.SchemeRegistry;
+import ch.boye.httpclientandroidlib.util.Args;
+import ch.boye.httpclientandroidlib.util.Asserts;
+
+/**
+ * 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 PoolingClientConnectionManager}.
+ *
+ * @since 4.2
+ *
+ * @deprecated (4.3) use {@link BasicHttpClientConnectionManager}.
+ */
+@ThreadSafe
+@Deprecated
+public class BasicClientConnectionManager implements ClientConnectionManager {
+
+    public HttpClientAndroidLog log = new HttpClientAndroidLog(getClass());
+
+    private static final AtomicLong COUNTER = new AtomicLong();
+
+    /** The message to be logged on multiple allocation. */
+    public final static String MISUSE_MESSAGE =
+    "Invalid use of BasicClientConnManager: connection still allocated.\n" +
+    "Make sure to release the connection before allocating another one.";
+
+    /** The schemes supported by this connection manager. */
+    private final SchemeRegistry schemeRegistry;
+
+    /** The operator for opening and updating connections. */
+    private final ClientConnectionOperator connOperator;
+
+    /** The one and only entry in this pool. */
+    @GuardedBy("this")
+    private HttpPoolEntry poolEntry;
+
+    /** The currently issued managed connection, if any. */
+    @GuardedBy("this")
+    private ManagedClientConnectionImpl conn;
+
+    /** Indicates whether this connection manager is shut down. */
+    @GuardedBy("this")
+    private volatile boolean shutdown;
+
+    /**
+     * Creates a new simple connection manager.
+     *
+     * @param schreg    the scheme registry
+     */
+    public BasicClientConnectionManager(final SchemeRegistry schreg) {
+        Args.notNull(schreg, "Scheme registry");
+        this.schemeRegistry = schreg;
+        this.connOperator = createConnectionOperator(schreg);
+    }
+
+    public BasicClientConnectionManager() {
+        this(SchemeRegistryFactory.createDefault());
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            shutdown();
+        } finally { // Make sure we call overridden method even if shutdown barfs
+            super.finalize();
+        }
+    }
+
+    public SchemeRegistry getSchemeRegistry() {
+        return this.schemeRegistry;
+    }
+
+    protected ClientConnectionOperator createConnectionOperator(final SchemeRegistry schreg) {
+        return new DefaultClientConnectionOperator(schreg);
+    }
+
+    public final ClientConnectionRequest requestConnection(
+            final HttpRoute route,
+            final Object state) {
+
+        return new ClientConnectionRequest() {
+
+            public void abortRequest() {
+                // Nothing to abort, since requests are immediate.
+            }
+
+            public ManagedClientConnection getConnection(
+                    final long timeout, final TimeUnit tunit) {
+                return BasicClientConnectionManager.this.getConnection(
+                        route, state);
+            }
+
+        };
+    }
+
+    private void assertNotShutdown() {
+        Asserts.check(!this.shutdown, "Connection manager has been shut down");
+    }
+
+    ManagedClientConnection getConnection(final HttpRoute route, final Object state) {
+        Args.notNull(route, "Route");
+        synchronized (this) {
+            assertNotShutdown();
+            if (this.log.isDebugEnabled()) {
+                this.log.debug("Get connection for route " + route);
+            }
+            Asserts.check(this.conn == null, MISUSE_MESSAGE);
+            if (this.poolEntry != null && !this.poolEntry.getPlannedRoute().equals(route)) {
+                this.poolEntry.close();
+                this.poolEntry = null;
+            }
+            if (this.poolEntry == null) {
+                final String id = Long.toString(COUNTER.getAndIncrement());
+                final OperatedClientConnection conn = this.connOperator.createConnection();
+                this.poolEntry = new HttpPoolEntry(this.log, id, route, conn, 0, TimeUnit.MILLISECONDS);
+            }
+            final long now = System.currentTimeMillis();
+            if (this.poolEntry.isExpired(now)) {
+                this.poolEntry.close();
+                this.poolEntry.getTracker().reset();
+            }
+            this.conn = new ManagedClientConnectionImpl(this, this.connOperator, this.poolEntry);
+            return this.conn;
+        }
+    }
+
+    private void shutdownConnection(final HttpClientConnection conn) {
+        try {
+            conn.shutdown();
+        } catch (final IOException iox) {
+            if (this.log.isDebugEnabled()) {
+                this.log.debug("I/O exception shutting down connection", iox);
+            }
+        }
+    }
+
+    public void releaseConnection(final ManagedClientConnection conn, final long keepalive, final TimeUnit tunit) {
+        Args.check(conn instanceof ManagedClientConnectionImpl, "Connection class mismatch, " +
+            "connection not obtained from this manager");
+        final ManagedClientConnectionImpl managedConn = (ManagedClientConnectionImpl) conn;
+        synchronized (managedConn) {
+            if (this.log.isDebugEnabled()) {
+                this.log.debug("Releasing connection " + conn);
+            }
+            if (managedConn.getPoolEntry() == null) {
+                return; // already released
+            }
+            final ClientConnectionManager manager = managedConn.getManager();
+            Asserts.check(manager == this, "Connection not obtained from this manager");
+            synchronized (this) {
+                if (this.shutdown) {
+                    shutdownConnection(managedConn);
+                    return;
+                }
+                try {
+                    if (managedConn.isOpen() && !managedConn.isMarkedReusable()) {
+                        shutdownConnection(managedConn);
+                    }
+                    if (managedConn.isMarkedReusable()) {
+                        this.poolEntry.updateExpiry(keepalive, tunit != null ? tunit : TimeUnit.MILLISECONDS);
+                        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);
+                        }
+                    }
+                } finally {
+                    managedConn.detach();
+                    this.conn = null;
+                    if (this.poolEntry.isClosed()) {
+                        this.poolEntry = null;
+                    }
+                }
+            }
+        }
+    }
+
+    public void closeExpiredConnections() {
+        synchronized (this) {
+            assertNotShutdown();
+            final long now = System.currentTimeMillis();
+            if (this.poolEntry != null && this.poolEntry.isExpired(now)) {
+                this.poolEntry.close();
+                this.poolEntry.getTracker().reset();
+            }
+        }
+    }
+
+    public void closeIdleConnections(final long idletime, final TimeUnit tunit) {
+        Args.notNull(tunit, "Time unit");
+        synchronized (this) {
+            assertNotShutdown();
+            long time = tunit.toMillis(idletime);
+            if (time < 0) {
+                time = 0;
+            }
+            final long deadline = System.currentTimeMillis() - time;
+            if (this.poolEntry != null && this.poolEntry.getUpdated() <= deadline) {
+                this.poolEntry.close();
+                this.poolEntry.getTracker().reset();
+            }
+        }
+    }
+
+    public void shutdown() {
+        synchronized (this) {
+            this.shutdown = true;
+            try {
+                if (this.poolEntry != null) {
+                    this.poolEntry.close();
+                }
+            } finally {
+                this.poolEntry = null;
+                this.conn = null;
+            }
+        }
+    }
+
+}