diff --git a/src/share/classes/sun/net/www/http/HttpClient.java b/src/share/classes/sun/net/www/http/HttpClient.java index 24bcd4b5eca9635e345dc38d0a62f26e25775a0d..c1996ff735c42a5d534c620565150f652ea2ad38 100644 --- a/src/share/classes/sun/net/www/http/HttpClient.java +++ b/src/share/classes/sun/net/www/http/HttpClient.java @@ -55,6 +55,9 @@ public class HttpClient extends NetworkClient { // Http data we send with the headers PosterOutputStream poster = null; + // true if we are in streaming mode (fixed length or chunked) + boolean streaming; + // if we've had one io error boolean failedOnce = false; @@ -275,6 +278,10 @@ public class HttpClient extends NetworkClient { ret.cachedHttpClient = true; assert ret.inCache; ret.inCache = false; + PlatformLogger logger = HttpURLConnection.getHttpLogger(); + if (logger.isLoggable(PlatformLogger.FINEST)) { + logger.finest("KeepAlive stream retrieved from the cache, " + ret); + } } } else { // We cannot return this connection to the cache as it's @@ -545,6 +552,13 @@ public class HttpClient extends NetworkClient { serverOutput.flush(); } + public void writeRequests(MessageHeader head, + PosterOutputStream pos, + boolean streaming) throws IOException { + this.streaming = streaming; + writeRequests(head, pos); + } + /** Parse the first line of the HTTP request. It usually looks something like: "HTTP/1.0 comment\r\n". */ @@ -577,11 +591,11 @@ public class HttpClient extends NetworkClient { closeServer(); cachedHttpClient = false; if (!failedOnce && requests != null) { - if (httpuc.getRequestMethod().equals("POST") && !retryPostProp) { + failedOnce = true; + if (httpuc.getRequestMethod().equals("POST") && (!retryPostProp || streaming)) { // do not retry the request } else { // try once more - failedOnce = true; openServer(); if (needsTunneling()) { httpuc.doTunneling(); @@ -684,10 +698,10 @@ public class HttpClient extends NetworkClient { } } else if (nread != 8) { if (!failedOnce && requests != null) { - if (httpuc.getRequestMethod().equals("POST") && !retryPostProp) { + failedOnce = true; + if (httpuc.getRequestMethod().equals("POST") && (!retryPostProp || streaming)) { // do not retry the request } else { - failedOnce = true; closeServer(); cachedHttpClient = false; openServer(); diff --git a/src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java b/src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java index e888abe26e8526b016bf083c02972bbd27b7de9f..a9caf59495356444f2c0c2c5405cb17b3590bcaa 100644 --- a/src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java +++ b/src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java @@ -494,7 +494,7 @@ public class HttpURLConnection extends java.net.HttpURLConnection { if (logger.isLoggable(PlatformLogger.FINE)) { logger.fine(requests.toString()); } - http.writeRequests(requests, poster); + http.writeRequests(requests, poster, streaming()); if (ps.checkError()) { String proxyHost = http.getProxyHostUsed(); int proxyPort = http.getProxyPortUsed(); diff --git a/test/sun/net/www/http/HttpClient/StreamingRetry.java b/test/sun/net/www/http/HttpClient/StreamingRetry.java new file mode 100644 index 0000000000000000000000000000000000000000..03c5b503e8a23546ac09e9f408de45991b8c943b --- /dev/null +++ b/test/sun/net/www/http/HttpClient/StreamingRetry.java @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 6672144 + * @summary HttpURLConnection.getInputStream sends POST request after failed chunked send + */ + +import java.net.HttpURLConnection; +import java.net.ServerSocket; +import java.net.URL; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +public class StreamingRetry implements Runnable { + static final int ACCEPT_TIMEOUT = 20 * 1000; // 20 seconds + ServerSocket ss; + + public static void main(String[] args) throws IOException { + (new StreamingRetry()).instanceMain(); + } + + void instanceMain() throws IOException { + test(); + if (failed > 0) throw new RuntimeException("Some tests failed"); + } + + void test() throws IOException { + ss = new ServerSocket(0); + ss.setSoTimeout(ACCEPT_TIMEOUT); + int port = ss.getLocalPort(); + + (new Thread(this)).start(); + + try { + URL url = new URL("http://localhost:" + port + "/"); + HttpURLConnection uc = (HttpURLConnection) url.openConnection(); + uc.setDoOutput(true); + uc.setChunkedStreamingMode(4096); + OutputStream os = uc.getOutputStream(); + os.write("Hello there".getBytes()); + + InputStream is = uc.getInputStream(); + is.close(); + } catch (IOException expected) { + //expected.printStackTrace(); + } finally { + ss.close(); + } + } + + // Server + public void run() { + try { + (ss.accept()).close(); + (ss.accept()).close(); + ss.close(); + fail("The server shouldn't accept a second connection"); + } catch (IOException e) { + //OK, the clien will close the server socket if successfull + } + } + + volatile int failed = 0; + void fail() {failed++; Thread.dumpStack();} + void fail(String msg) {System.err.println(msg); fail();} +}