HttpResponse response = doSendRequest(request, conn, context); if (response == null) { response = doReceiveResponse(request, conn, context); conn.close(); throw ex; } catch (HttpException ex) { conn.close(); throw ex; } catch (RuntimeException ex) { conn.close(); throw ex;
context.setAttribute(ExecutionContext.HTTP_REQ_SENT, Boolean.FALSE); conn.sendRequestHeader(request); if (request instanceof HttpEntityEnclosingRequest) { request.getRequestLine().getProtocolVersion(); if (((HttpEntityEnclosingRequest) request).expectContinue() && !ver.lessEquals(HttpVersion.HTTP_1_0)) { conn.flush(); int tms = request.getParams().getIntParameter( CoreProtocolPNames.WAIT_FOR_CONTINUE, 2000); if (conn.isResponseAvailable(tms)) { response = conn.receiveResponseHeader(); if (canResponseHaveBody(request, response)) { conn.receiveResponseEntity(response); conn.sendRequestEntity((HttpEntityEnclosingRequest) request); conn.flush(); context.setAttribute(ExecutionContext.HTTP_REQ_SENT, Boolean.TRUE); return response;
response = conn.receiveResponseHeader(); if (canResponseHaveBody(request, response)) { conn.receiveResponseEntity(response); statuscode = response.getStatusLine().getStatusCode();
final HttpRequest connect = new BasicHttpRequest("CONNECT", authority, request.getProtocolVersion()); this.requestExecutor.preProcess(connect, this.proxyHttpProcessor, context); if (!managedConn.isOpen()) { this.connManager.connect( managedConn, route, connect.removeHeaders(AUTH.PROXY_AUTH_RESP); this.authenticator.generateAuthResponse(connect, proxyAuthState, context); response = this.requestExecutor.execute(connect, managedConn, context); this.log.debug("Connection kept alive"); final HttpEntity entity = response.getEntity(); EntityUtils.consume(entity); } else { managedConn.close(); final int status = response.getStatusLine().getStatusCode(); managedConn.close(); throw new TunnelRefusedException("CONNECT refused by proxy: " + response.getStatusLine(), response);
if (managedConn.isOpen()) { if (Log.isLoggable(TAG, Log.DEBUG)) { Log.d(TAG, "Stale connection check"); if (managedConn.isStale()) { if (Log.isLoggable(TAG, Log.DEBUG)) { Log.d(TAG, "Stale connection detected"); managedConn.close(); if (!managedConn.isOpen()) { if (Log.isLoggable(TAG, Log.DEBUG)) { Log.d(TAG, "Opening connection " + route); managedConn.setSocketTimeout(timeout); response = requestExecutor.execute(request, managedConn, context); targetAuthState, proxyAuthState, route, response, context)) { final HttpEntity entity = response.getEntity(); if (connHolder.isReusable()) { EntityUtilsHC4.consume(entity); } else { managedConn.close(); if (proxyAuthState.getState() == AuthProtocolState.SUCCESS && proxyAuthState.getAuthScheme() != null
final HttpClientContext context, final HttpExecutionAware execAware) throws IOException, HttpException { Args.notNull(route, "HTTP route"); Args.notNull(request, "HTTP request"); Args.notNull(context, "HTTP context"); final ConnectionRequest connRequest = connManager.requestConnection(route, null); if (execAware != null) { if (execAware.isAborted()) { if (!managedConn.isOpen()) { final int timeout = config.getConnectTimeout(); this.connManager.connect( managedConn, route, timeout > 0 ? timeout : 0, context); this.connManager.routeComplete(managedConn, route, context); managedConn.setSocketTimeout(timeout); final HttpResponse response = requestExecutor.execute(request, managedConn, context); httpProcessor.process(response, context); final HttpEntity entity = response.getEntity(); if (entity == null || !entity.isStreaming()) {
conn.receiveResponseEntity(response); propagateHeaders(httpPacket, response.getAllHeaders()); } catch (IOException e) { LOG.error("IOException when decoding HTTP response", e); try { HttpRequest request = parser.parse(); propagateHeaders(httpPacket, request.getAllHeaders()); } catch (IOException e) { LOG.error("IOException when decoding HTTP request", e);
private static void closeConnection(final HttpClientConnection conn) { try { conn.close(); } catch (final IOException ignore) { } }
private void releaseConnection(final boolean reusable) { if (this.released.compareAndSet(false, true)) { synchronized (this.managedConn) { if (reusable) { this.manager.releaseConnection(this.managedConn, this.state, this.validDuration, this.tunit); } else { try { this.managedConn.close(); log.debug("Connection discarded"); } catch (final IOException ex) { if (this.log.isDebugEnabled()) { this.log.debug(ex.getMessage(), ex); } } finally { this.manager.releaseConnection( this.managedConn, null, 0, TimeUnit.MILLISECONDS); } } } } }
/** * {@inheritDoc} */ @Override public synchronized void sendRequest(HttpRequest request, boolean wantResponse) throws IOException { if (!(request instanceof org.apache.http.HttpRequest)) { throw new IllegalArgumentException("request must be an instance of org.apache.http.HttpRequest"); } try { if (!wantResponse) { request.setHeader(HEADER_KEY_PRAGMA, PRAGMA_VALUE_NO_RESPONSE); } logger.log(OpLevel.TRACE, "Sending to {0}: {1}", uri, request); org.apache.http.HttpRequest httpRequest = (org.apache.http.HttpRequest) request; connection.sendRequestHeader(httpRequest); if (httpRequest instanceof HttpEntityEnclosingRequest && request.hasContent()) { connection.sendRequestEntity((HttpEntityEnclosingRequest) httpRequest); } connection.flush(); } catch (HttpException he) { throw new IOException(he.getMessage(), he); } }
/** * {@inheritDoc} */ @Override public boolean isConnected() { return (connection != null && connection.isOpen()); }
/** * {@inheritDoc} */ @Override public synchronized HttpResponse getResponse() throws IOException { try { HttpResponseImpl resp = new HttpResponseImpl(connection.receiveResponseHeader()); String contentLenStr = resp.getHeader(HttpHeaders.CONTENT_LENGTH); String contentType = resp.getHeader(HttpHeaders.CONTENT_TYPE); int contentLen = (StringUtils.isEmpty(contentLenStr) ? 0 : Integer.parseInt(contentLenStr)); if (contentLen > 0 || !StringUtils.isEmpty(contentType)) { connection.receiveResponseEntity(resp); } return resp; } catch (Throwable ex) { throw new IOException(ex.getMessage(), ex); } }
@Override public boolean isStale() { final HttpClientConnection conn = getConnection(); if (conn != null) { return conn.isStale(); } else { return true; } }
@Override public HttpClientConnection get( final long timeout, final TimeUnit tunit) throws InterruptedException, ExecutionException, ConnectionPoolTimeoutException { final HttpClientConnection conn = leaseConnection(future, timeout, tunit); if (conn.isOpen()) { final HttpHost host; if (route.getProxyHost() != null) { host = route.getProxyHost(); } else { host = route.getTargetHost(); } final SocketConfig socketConfig = resolveSocketConfig(host); conn.setSocketTimeout(socketConfig.getSoTimeout()); } return conn; }
final HttpRequest connect = new BasicHttpRequest("CONNECT", authority, request.getProtocolVersion()); this.requestExecutor.preProcess(connect, this.proxyHttpProcessor, context); if (!managedConn.isOpen()) { this.connManager.connect( managedConn, route, connect.removeHeaders(AUTH.PROXY_AUTH_RESP); this.authenticator.generateAuthResponse(connect, proxyAuthState, context); response = this.requestExecutor.execute(connect, managedConn, context); this.log.debug("Connection kept alive"); final HttpEntity entity = response.getEntity(); EntityUtils.consume(entity); } else { managedConn.close(); final int status = response.getStatusLine().getStatusCode(); managedConn.close(); throw new TunnelRefusedException("CONNECT refused by proxy: " + response.getStatusLine(), response);
final HttpClientConnection conn, final HttpContext context) throws HttpException, IOException { Args.notNull(request, "HTTP request"); Args.notNull(conn, "Client connection"); Args.notNull(context, "HTTP context"); HttpResponse response = null; int statusCode = 0; response = conn.receiveResponseHeader(); if (canResponseHaveBody(request, response)) { conn.receiveResponseEntity(response); statusCode = response.getStatusLine().getStatusCode();
if (managedConn.isOpen()) { this.log.debug("Stale connection check"); if (managedConn.isStale()) { this.log.debug("Stale connection detected"); managedConn.close(); if (!managedConn.isOpen()) { this.log.debug("Opening connection " + route); try { managedConn.setSocketTimeout(timeout); response = requestExecutor.execute(request, managedConn, context); targetAuthState, proxyAuthState, route, response, context)) { final HttpEntity entity = response.getEntity(); if (connHolder.isReusable()) { EntityUtils.consume(entity); } else { managedConn.close(); if (proxyAuthState.getState() == AuthProtocolState.SUCCESS && proxyAuthState.getAuthScheme() != null if (!original.containsHeader(AUTH.WWW_AUTH_RESP)) { request.removeHeaders(AUTH.WWW_AUTH_RESP);
final HttpClientContext context, final HttpExecutionAware execAware) throws IOException, HttpException { Args.notNull(route, "HTTP route"); Args.notNull(request, "HTTP request"); Args.notNull(context, "HTTP context"); final ConnectionRequest connRequest = connManager.requestConnection(route, null); if (execAware != null) { if (execAware.isAborted()) { if (!managedConn.isOpen()) { final int timeout = config.getConnectTimeout(); this.connManager.connect( managedConn, route, timeout > 0 ? timeout : 0, context); this.connManager.routeComplete(managedConn, route, context); managedConn.setSocketTimeout(timeout); final HttpResponse response = requestExecutor.execute(request, managedConn, context); httpProcessor.process(response, context); final HttpEntity entity = response.getEntity(); if (entity == null || !entity.isStreaming()) {
private static void closeConnection(final HttpClientConnection conn) { try { conn.close(); } catch (final IOException ignore) { } }
private void releaseConnection(final boolean reusable) { if (this.released.compareAndSet(false, true)) { synchronized (this.managedConn) { if (reusable) { this.manager.releaseConnection(this.managedConn, this.state, this.validDuration, this.tunit); } else { try { this.managedConn.close(); log.debug("Connection discarded"); } catch (final IOException ex) { if (this.log.isDebugEnabled()) { this.log.debug(ex.getMessage(), ex); } } finally { this.manager.releaseConnection( this.managedConn, null, 0, TimeUnit.MILLISECONDS); } } } } }