private static void recycleRequestResponsePackets(
final Connection c, final HttpResponsePacket response) {
if (!Utils.isSpdyConnection(c)) {
HttpRequestPacket request = response.getRequest();
request.setExpectContent(false);
response.recycle();
request.recycle();
}
}
private boolean sendAsGrizzlyRequest(
final RequestInfoHolder requestInfoHolder, final FilterChainContext ctx) throws IOException {
HttpTxContext httpTxContext = requestInfoHolder.getHttpTxContext();
if (httpTxContext == null) {
httpTxContext = HttpTxContext.create(requestInfoHolder);
}
if (checkProxyAuthFailure(ctx, httpTxContext)) {
return true;
}
final Request request = httpTxContext.getRequest();
final URI uri = request.isUseRawUrl() ? request.getRawURI() : request.getURI();
boolean secure = Utils.isSecure(uri);
// If the request is secure, check to see if an error occurred during
// the handshake. We have to do this here, as the error would occur
// out of the scope of a HttpTxContext so there would be
// no good way to communicate the problem to the caller.
if (secure && checkHandshakeError(ctx, httpTxContext)) {
return true;
}
if (isUpgradeRequest(httpTxContext.getHandler())
&& isWSRequest(httpTxContext.getRequestUrl())) {
httpTxContext.setWSRequest(true);
convertToUpgradeRequest(httpTxContext);
}
HttpRequestPacket requestPacket = requestCache.poll();
if (requestPacket == null) {
requestPacket = new HttpRequestPacketImpl();
}
requestPacket.setMethod(request.getMethod());
requestPacket.setProtocol(Protocol.HTTP_1_1);
// Special handling for CONNECT.
if (Method.CONNECT.matchesMethod(request.getMethod())) {
final int port = uri.getPort();
requestPacket.setRequestURI(uri.getHost() + ':' + (port == -1 ? 443 : port));
} else {
requestPacket.setRequestURI(uri.getPath());
}
if (Utils.requestHasEntityBody(request)) {
final long contentLength = request.getContentLength();
if (contentLength >= 0) {
requestPacket.setContentLengthLong(contentLength);
requestPacket.setChunked(false);
} else {
requestPacket.setChunked(true);
}
}
if (httpTxContext.isWSRequest()) {
try {
final URI wsURI = new URI(httpTxContext.getWsRequestURI());
httpTxContext.setProtocolHandler(Version.RFC6455.createHandler(true));
httpTxContext.setHandshake(httpTxContext.getProtocolHandler().createHandShake(wsURI));
requestPacket =
(HttpRequestPacket) httpTxContext.getHandshake().composeHeaders().getHttpHeader();
} catch (URISyntaxException e) {
throw new IllegalArgumentException("Invalid WS URI: " + httpTxContext.getWsRequestURI());
}
}
requestPacket.setSecure(secure);
addQueryString(request, requestPacket);
addHostHeader(request, uri, requestPacket);
addGeneralHeaders(request, requestPacket);
addCookies(request, requestPacket);
initTransferCompletionHandler(request, httpTxContext.getHandler());
final HttpRequestPacket requestPacketLocal = requestPacket;
FilterChainContext sendingCtx = ctx;
if (secure) {
// Check to see if the ProtocolNegotiator has given
// us a different FilterChain to use. If so, we need
// use a different FilterChainContext when invoking sendRequest().
sendingCtx = checkAndHandleFilterChainUpdate(ctx, sendingCtx);
}
final Connection c = ctx.getConnection();
if (!Utils.isSpdyConnection(c)) {
HttpContext.newInstance(ctx, c, c, c);
} else {
SpdySession session = SpdySession.get(c);
final Lock lock = session.getNewClientStreamLock();
try {
lock.lock();
SpdyStream stream =
session.openStream(
requestPacketLocal,
session.getNextLocalStreamId(),
0,
0,
0,
false,
!requestPacketLocal.isExpectContent());
HttpContext.newInstance(ctx, stream, stream, stream);
} finally {
lock.unlock();
}
}
HttpTxContext.set(ctx, httpTxContext);
return sendRequest(sendingCtx, request, requestPacketLocal);
}