+ * This adapter tracks the checkpoints for reusable communication states, + * as indicated by {@link #markReusable markReusable} and queried by + * {@link #isMarkedReusable isMarkedReusable}. + * All send and receive operations will automatically clear the mark. + *
+ * Connection release calls are delegated to the connection manager,
+ * if there is one. {@link #abortConnection abortConnection} will
+ * clear the reusability mark first. The connection manager is
+ * expected to tolerate multiple calls to the release method.
+ *
+ * @since 4.0
+ */
+public abstract class AbstractClientConnAdapter
+ implements ManagedClientConnection, HttpContext {
+
+ /**
+ * The connection manager, if any.
+ * This attribute MUST NOT be final, so the adapter can be detached
+ * from the connection manager without keeping a hard reference there.
+ */
+ private volatile ClientConnectionManager connManager;
+
+ /** The wrapped connection. */
+ private volatile OperatedClientConnection wrappedConnection;
+
+ /** The reusability marker. */
+ private volatile boolean markedReusable;
+
+ /** True if the connection has been shut down or released. */
+ private volatile boolean released;
+
+ /** The duration this is valid for while idle (in ms). */
+ private volatile long duration;
+
+ /**
+ * Creates a new connection adapter.
+ * The adapter is initially not
+ * {@link #isMarkedReusable marked} as reusable.
+ *
+ * @param mgr the connection manager, or null
+ * @param conn the connection to wrap, or null
+ */
+ protected AbstractClientConnAdapter(ClientConnectionManager mgr,
+ OperatedClientConnection conn) {
+ super();
+ connManager = mgr;
+ wrappedConnection = conn;
+ markedReusable = false;
+ released = false;
+ duration = Long.MAX_VALUE;
+ }
+
+ /**
+ * Detaches this adapter from the wrapped connection.
+ * This adapter becomes useless.
+ */
+ protected synchronized void detach() {
+ wrappedConnection = null;
+ connManager = null; // base class attribute
+ duration = Long.MAX_VALUE;
+ }
+
+ protected OperatedClientConnection getWrappedConnection() {
+ return wrappedConnection;
+ }
+
+ protected ClientConnectionManager getManager() {
+ return connManager;
+ }
+
+ /**
+ * @deprecated use {@link #assertValid(OperatedClientConnection)}
+ */
+ @Deprecated
+ protected final void assertNotAborted() throws InterruptedIOException {
+ if (isReleased()) {
+ throw new InterruptedIOException("Connection has been shut down");
+ }
+ }
+
+ /**
+ * @since 4.1
+ * @return value of released flag
+ */
+ protected boolean isReleased() {
+ return released;
+ }
+
+ /**
+ * Asserts that there is a valid wrapped connection to delegate to.
+ *
+ * @throws ConnectionShutdownException if there is no wrapped connection
+ * or connection has been aborted
+ */
+ protected final void assertValid(
+ final OperatedClientConnection wrappedConn) throws ConnectionShutdownException {
+ if (isReleased() || wrappedConn == null) {
+ throw new ConnectionShutdownException();
+ }
+ }
+
+ public boolean isOpen() {
+ OperatedClientConnection conn = getWrappedConnection();
+ if (conn == null)
+ return false;
+
+ return conn.isOpen();
+ }
+
+ public boolean isStale() {
+ if (isReleased())
+ return true;
+ OperatedClientConnection conn = getWrappedConnection();
+ if (conn == null)
+ return true;
+
+ return conn.isStale();
+ }
+
+ public void setSocketTimeout(int timeout) {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ conn.setSocketTimeout(timeout);
+ }
+
+ public int getSocketTimeout() {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ return conn.getSocketTimeout();
+ }
+
+ public HttpConnectionMetrics getMetrics() {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ return conn.getMetrics();
+ }
+
+ public void flush() throws IOException {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ conn.flush();
+ }
+
+ public boolean isResponseAvailable(int timeout) throws IOException {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ return conn.isResponseAvailable(timeout);
+ }
+
+ public void receiveResponseEntity(HttpResponse response)
+ throws HttpException, IOException {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ unmarkReusable();
+ conn.receiveResponseEntity(response);
+ }
+
+ public HttpResponse receiveResponseHeader()
+ throws HttpException, IOException {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ unmarkReusable();
+ return conn.receiveResponseHeader();
+ }
+
+ public void sendRequestEntity(HttpEntityEnclosingRequest request)
+ throws HttpException, IOException {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ unmarkReusable();
+ conn.sendRequestEntity(request);
+ }
+
+ public void sendRequestHeader(HttpRequest request)
+ throws HttpException, IOException {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ unmarkReusable();
+ conn.sendRequestHeader(request);
+ }
+
+ public InetAddress getLocalAddress() {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ return conn.getLocalAddress();
+ }
+
+ public int getLocalPort() {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ return conn.getLocalPort();
+ }
+
+ public InetAddress getRemoteAddress() {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ return conn.getRemoteAddress();
+ }
+
+ public int getRemotePort() {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ return conn.getRemotePort();
+ }
+
+ public boolean isSecure() {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ return conn.isSecure();
+ }
+
+ public SSLSession getSSLSession() {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ if (!isOpen())
+ return null;
+
+ SSLSession result = null;
+ Socket sock = conn.getSocket();
+ if (sock instanceof SSLSocket) {
+ result = ((SSLSocket)sock).getSession();
+ }
+ return result;
+ }
+
+ public void markReusable() {
+ markedReusable = true;
+ }
+
+ public void unmarkReusable() {
+ markedReusable = false;
+ }
+
+ public boolean isMarkedReusable() {
+ return markedReusable;
+ }
+
+ public void setIdleDuration(long duration, TimeUnit unit) {
+ if(duration > 0) {
+ this.duration = unit.toMillis(duration);
+ } else {
+ this.duration = -1;
+ }
+ }
+
+ public synchronized void releaseConnection() {
+ if (released) {
+ return;
+ }
+ released = true;
+ if (connManager != null) {
+ connManager.releaseConnection(this, duration, TimeUnit.MILLISECONDS);
+ }
+ }
+
+ public synchronized void abortConnection() {
+ if (released) {
+ return;
+ }
+ released = true;
+ unmarkReusable();
+ try {
+ shutdown();
+ } catch (IOException ignore) {
+ }
+ if (connManager != null) {
+ connManager.releaseConnection(this, duration, TimeUnit.MILLISECONDS);
+ }
+ }
+
+ public synchronized Object getAttribute(final String id) {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ if (conn instanceof HttpContext) {
+ return ((HttpContext) conn).getAttribute(id);
+ } else {
+ return null;
+ }
+ }
+
+ public synchronized Object removeAttribute(final String id) {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ if (conn instanceof HttpContext) {
+ return ((HttpContext) conn).removeAttribute(id);
+ } else {
+ return null;
+ }
+ }
+
+ public synchronized void setAttribute(final String id, final Object obj) {
+ OperatedClientConnection conn = getWrappedConnection();
+ assertValid(conn);
+ if (conn instanceof HttpContext) {
+ ((HttpContext) conn).setAttribute(id, obj);
+ }
+ }
+
+}