Review

Exception on HttpConnection.writeRequest() leaves the connection open.

Introduce close() calls in respective catch blocks.

• missing/call

org/apache/commons/httpclient/HttpMethodDirector.java

executeWithRetry(HttpMethod)

class HttpMethodDirector {
    /**
     * Executes a method with the current hostConfiguration.
     *
     * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 
     * can be recovered from.
     * @throws HttpException  if a protocol exception occurs. Usually protocol exceptions 
     * cannot be recovered from.
     */
    private void executeWithRetry(final HttpMethod method) 
        throws IOException, HttpException {
        
        /** How many times did this transparently handle a recoverable exception? */
        int recoverableExceptionCount = 0;
        int execCount = 0;
        // TODO: how do we get requestSent?
        boolean requestSent = false;
        
        // loop until the method is successfully processed, the retryHandler 
        // returns false or a non-recoverable exception is thrown
        while (true) {
            execCount++;
            requestSent = false;
            if (LOG.isTraceEnabled()) {
                LOG.trace("Attempt number " + execCount + " to process request");
            }
            if (!this.conn.isOpen()) {
                // this connection must be opened before it can be used
                // This has nothing to do with opening a secure tunnel
                try {
                    this.conn.open();
                    if (this.conn.isProxied() && this.conn.isSecure() 
                    && !(method instanceof ConnectMethod)) {
                        // we need to create a secure tunnel before we can execute the real method
                        if (!executeConnect()) {
                            // abort, the connect method failed
                            return;
                        }
                    }
                } catch (IOException e) {
                    releaseConnection = true;
                    throw e;
                } catch (RuntimeException e) {
                    releaseConnection = true;
                    throw e;
                }
            }
            try {
                method.execute(state, this.conn);
                break;
            } catch (HttpRecoverableException httpre) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Closing the connection.");
                }
                this.conn.close();
                LOG.info("Recoverable exception caught when processing request");
                // update the recoverable exception count.
                recoverableExceptionCount++;
                
                // test if this method should be retried                
                MethodRetryHandler handler = method.getMethodRetryHandler();
                if (handler == null) {
                    handler = new DefaultMethodRetryHandler();
                }
                if (!handler.retryMethod(
                        method, 
                        this.conn, 
                        httpre, 
                        execCount, 
                        requestSent)
                ) {
                    LOG.warn(
                        "Recoverable exception caught but MethodRetryHandler.retryMethod() "
                        + "returned false, rethrowing exception"
                    );
                    // this connection can no longer be used, it has been closed
                    releaseConnection = true;
                    throw httpre;
                }
            }
        }
        
    }
}

class CloseConnection {
  void pattern(HttpConnection conn, HttpMethod method, HttpState state) throws IOException, HttpException {
    try {
        while (true) {
            if (!conn.isOpen()) {
                conn.open();
                if (conn.isProxied() && conn.isSecure() && !(method instanceof ConnectMethod)) {
                    // initialize connect method...
                }
            }
            try {
                method.execute(state, conn);
                break;
            } catch (HttpRecoverableException httpre) {
                conn.close();
            }
        }
    } catch (IOException e) {
        if (conn.isOpen()) {
            conn.close();
        }
        throw e;
    } catch (RuntimeException e) {
        if (conn.isOpen()) {
            conn.close();
        }
        throw e;
    }
  }
}