jdk/test/java/net/httpclient/ShortRequestBody.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2015, 2016, 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.
  */

 import java.io.*;
 import jdk.incubator.http.HttpClient;
 import jdk.incubator.http.HttpResponse;
 import jdk.incubator.http.HttpRequest;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.URI;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.ByteBuffer;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Flow;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.TimeUnit;
 import static java.lang.System.out;
 import static java.nio.charset.StandardCharsets.US_ASCII;
 import static jdk.incubator.http.HttpResponse.BodyHandler.discard;
 import static java.nio.charset.StandardCharsets.UTF_8;

 /**
  * @test
  * @bug 8151441
  * @summary Request body of incorrect (larger or smaller) sizes than that
  *          reported by the body processor
  * @run main/othervm ShortRequestBody
  */

 public class ShortRequestBody {

     static final Path testSrc = Paths.get(System.getProperty("test.src", "."));
     static volatile HttpClient staticDefaultClient;

     static HttpClient defaultClient() {
         if (staticDefaultClient == null) {
             synchronized (ShortRequestBody.class) {
                 staticDefaultClient = HttpClient.newHttpClient();
             }
         }
         return staticDefaultClient;
     }

     // Some body types ( sources ) for testing.
     static final String STRING_BODY = "Hello world";
     static final byte[] BYTE_ARRAY_BODY = new byte[] {
         (byte)0xCA, (byte)0xFE, (byte)0xBA, (byte)0xBE };
     static final Path FILE_BODY = testSrc.resolve("docs").resolve("files").resolve("foo.txt");

     // Body lengths and offsets ( amount to be wrong by ), to make coordination
     // between client and server easier.
     static final int[] BODY_LENGTHS = new int[] { STRING_BODY.length(),
                                                   BYTE_ARRAY_BODY.length,
                                                   fileSize(FILE_BODY) };
     static final int[] BODY_OFFSETS = new int[] { 0, +1, -1, +2, -2, +3, -3 };

     // A delegating body processor. Subtypes will have a concrete body type.
     static abstract class AbstractDelegateRequestBody
             implements HttpRequest.BodyProcessor {

         final HttpRequest.BodyProcessor delegate;
         final long contentLength;

         AbstractDelegateRequestBody(HttpRequest.BodyProcessor delegate,
                                     long contentLength) {
             this.delegate = delegate;
             this.contentLength = contentLength;
         }

         @Override
         public void subscribe(Flow.Subscriber<? super ByteBuffer> subscriber) {
             delegate.subscribe(subscriber);
         }

         @Override
         public long contentLength() { return contentLength; /* may be wrong! */ }
     }

     // Request body processors that may generate a different number of actual
     // bytes to that of what is reported through their {@code contentLength}.

     static class StringRequestBody extends AbstractDelegateRequestBody {
         StringRequestBody(String body, int additionalLength) {
             super(HttpRequest.BodyProcessor.fromString(body),
                   body.getBytes(UTF_8).length + additionalLength);
         }
     }

     static class ByteArrayRequestBody extends AbstractDelegateRequestBody {
         ByteArrayRequestBody(byte[] body, int additionalLength) {
             super(HttpRequest.BodyProcessor.fromByteArray(body),
                   body.length + additionalLength);
         }
     }

     static class FileRequestBody extends AbstractDelegateRequestBody {
         FileRequestBody(Path path, int additionalLength) throws IOException {
             super(HttpRequest.BodyProcessor.fromFile(path),
                   Files.size(path) + additionalLength);
         }
     }

     // ---

     public static void main(String[] args) throws Exception {
         try (Server server = new Server()) {
             URI uri = new URI("http://127.0.0.1:" + server.getPort() + "/");

             // sanity
             success(uri, new StringRequestBody(STRING_BODY, 0));
             success(uri, new ByteArrayRequestBody(BYTE_ARRAY_BODY, 0));
             success(uri, new FileRequestBody(FILE_BODY, 0));

             for (int i=1; i< BODY_OFFSETS.length; i++) {
                 failureBlocking(uri, new StringRequestBody(STRING_BODY, BODY_OFFSETS[i]));
                 failureBlocking(uri, new ByteArrayRequestBody(BYTE_ARRAY_BODY, BODY_OFFSETS[i]));
                 failureBlocking(uri, new FileRequestBody(FILE_BODY, BODY_OFFSETS[i]));

                 failureNonBlocking(uri, new StringRequestBody(STRING_BODY, BODY_OFFSETS[i]));
                 failureNonBlocking(uri, new ByteArrayRequestBody(BYTE_ARRAY_BODY, BODY_OFFSETS[i]));
                 failureNonBlocking(uri, new FileRequestBody(FILE_BODY, BODY_OFFSETS[i]));
             }
         } finally {
             Executor def = defaultClient().executor();
             if (def instanceof ExecutorService) {
                ((ExecutorService)def).shutdownNow();
             }
         }
     }

     static void success(URI uri, HttpRequest.BodyProcessor processor)
         throws Exception
     {
         CompletableFuture<HttpResponse<Void>> cf;
         HttpRequest request = HttpRequest.newBuilder(uri)
                                          .POST(processor)
                                          .build();
         cf = defaultClient().sendAsync(request, discard(null));

         HttpResponse<Void> resp = cf.get(30, TimeUnit.SECONDS);
         out.println("Response code: " + resp.statusCode());
         check(resp.statusCode() == 200, "Expected 200, got ", resp.statusCode());
     }

     static void failureNonBlocking(URI uri, HttpRequest.BodyProcessor processor)
         throws Exception
     {
         CompletableFuture<HttpResponse<Void>> cf;
         HttpRequest request = HttpRequest.newBuilder(uri)
                                          .POST(processor)
                                          .build();
         cf = defaultClient().sendAsync(request, discard(null));

         try {
             HttpResponse<Void> r = cf.get(30, TimeUnit.SECONDS);
             throw new RuntimeException("Unexpected response: " + r.statusCode());
         } catch (TimeoutException x) {
             throw new RuntimeException("Unexpected timeout", x);
         } catch (ExecutionException expected) {
             out.println("Caught expected: " + expected);
             check(expected.getCause() instanceof IOException,
                   "Expected cause IOException, but got: ", expected.getCause());
         }
     }

     static void failureBlocking(URI uri, HttpRequest.BodyProcessor processor)
         throws Exception
     {
         HttpRequest request = HttpRequest.newBuilder(uri)
                                          .POST(processor)
                                          .build();
         try {
             HttpResponse<Void> r = defaultClient().send(request, discard(null));
             throw new RuntimeException("Unexpected response: " + r.statusCode());
         } catch (IOException expected) {
             out.println("Caught expected: " + expected);
         }
     }

     static class Server extends Thread implements AutoCloseable {

         static String RESPONSE = "HTTP/1.1 200 OK\r\n" +
                                  "Connection: close\r\n"+
                                  "Content-length: 0\r\n\r\n";

         private final ServerSocket ss;
         private volatile boolean closed;

         Server() throws IOException {
             super("Test-Server");
             ss = new ServerSocket(0); this.start();
         }

         int getPort() { return ss.getLocalPort(); }

         @Override
         public void run() {
             int count = 0;
             int offset = 0;

             while (!closed) {
                 try (Socket s = ss.accept()) {
                     InputStream is = s.getInputStream();
                     readRequestHeaders(is);
                     byte[] ba = new byte[1024];

                     int length = BODY_LENGTHS[count % 3];
                     length += BODY_OFFSETS[offset];

                     is.readNBytes(ba, 0, length);

                     OutputStream os = s.getOutputStream();
                     os.write(RESPONSE.getBytes(US_ASCII));
                     count++;
                     if (count % 6 == 0) // 6 is the number of failure requests per offset
                         offset++;
                 } catch (IOException e) {
                     if (!closed)
                         System.out.println("Unexpected" + e);
                 }
             }
         }

         @Override
         public void close() {
             if (closed)
                 return;
             closed = true;
             try {
                 ss.close();
             } catch (IOException e) {
                 throw new UncheckedIOException("Unexpected", e);
             }
         }
     }

     static final byte[] requestEnd = new byte[] {'\r', '\n', '\r', '\n' };

     // Read until the end of a HTTP request headers
     static void readRequestHeaders(InputStream is) throws IOException {
         int requestEndCount = 0, r;
         while ((r = is.read()) != -1) {
             if (r == requestEnd[requestEndCount]) {
                 requestEndCount++;
                 if (requestEndCount == 4) {
                     break;
                 }
             } else {
                 requestEndCount = 0;
             }
         }
     }

     static int fileSize(Path p) {
         try { return (int) Files.size(p); }
         catch (IOException x) { throw new UncheckedIOException(x); }
     }

     static boolean check(boolean cond, Object... failedArgs) {
         if (cond)
             return true;
         // We are going to fail...
         StringBuilder sb = new StringBuilder();
         for (Object o : failedArgs)
                 sb.append(o);
         throw new RuntimeException(sb.toString());
     }
 }
	/*
	* Copyright (c) 2015, 2016, 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.
	*/

	import java.io.*;
	import jdk.incubator.http.HttpClient;
	import jdk.incubator.http.HttpResponse;
	import jdk.incubator.http.HttpRequest;
	import java.net.ServerSocket;
	import java.net.Socket;
	import java.net.URI;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.nio.ByteBuffer;
	import java.util.concurrent.CompletableFuture;
	import java.util.concurrent.Executor;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.Flow;
	import java.util.concurrent.TimeoutException;
	import java.util.concurrent.TimeUnit;
	import static java.lang.System.out;
	import static java.nio.charset.StandardCharsets.US_ASCII;
	import static jdk.incubator.http.HttpResponse.BodyHandler.discard;
	import static java.nio.charset.StandardCharsets.UTF_8;

	/**
	* @test
	* @bug 8151441
	* @summary Request body of incorrect (larger or smaller) sizes than that
	* reported by the body processor
	* @run main/othervm ShortRequestBody
	*/

	public class ShortRequestBody {

	static final Path testSrc = Paths.get(System.getProperty("test.src", "."));
	static volatile HttpClient staticDefaultClient;

	static HttpClient defaultClient() {
	if (staticDefaultClient == null) {
	synchronized (ShortRequestBody.class) {
	staticDefaultClient = HttpClient.newHttpClient();
	}
	}
	return staticDefaultClient;
	}

	// Some body types ( sources ) for testing.
	static final String STRING_BODY = "Hello world";
	static final byte[] BYTE_ARRAY_BODY = new byte[] {
	(byte)0xCA, (byte)0xFE, (byte)0xBA, (byte)0xBE };
	static final Path FILE_BODY = testSrc.resolve("docs").resolve("files").resolve("foo.txt");

	// Body lengths and offsets ( amount to be wrong by ), to make coordination
	// between client and server easier.
	static final int[] BODY_LENGTHS = new int[] { STRING_BODY.length(),
	BYTE_ARRAY_BODY.length,
	fileSize(FILE_BODY) };
	static final int[] BODY_OFFSETS = new int[] { 0, +1, -1, +2, -2, +3, -3 };

	// A delegating body processor. Subtypes will have a concrete body type.
	static abstract class AbstractDelegateRequestBody
	implements HttpRequest.BodyProcessor {

	final HttpRequest.BodyProcessor delegate;
	final long contentLength;

	AbstractDelegateRequestBody(HttpRequest.BodyProcessor delegate,
	long contentLength) {
	this.delegate = delegate;
	this.contentLength = contentLength;
	}

	@Override
	public void subscribe(Flow.Subscriber<? super ByteBuffer> subscriber) {
	delegate.subscribe(subscriber);
	}

	@Override
	public long contentLength() { return contentLength; /* may be wrong! */ }
	}

	// Request body processors that may generate a different number of actual
	// bytes to that of what is reported through their {@code contentLength}.

	static class StringRequestBody extends AbstractDelegateRequestBody {
	StringRequestBody(String body, int additionalLength) {
	super(HttpRequest.BodyProcessor.fromString(body),
	body.getBytes(UTF_8).length + additionalLength);
	}
	}

	static class ByteArrayRequestBody extends AbstractDelegateRequestBody {
	ByteArrayRequestBody(byte[] body, int additionalLength) {
	super(HttpRequest.BodyProcessor.fromByteArray(body),
	body.length + additionalLength);
	}
	}

	static class FileRequestBody extends AbstractDelegateRequestBody {
	FileRequestBody(Path path, int additionalLength) throws IOException {
	super(HttpRequest.BodyProcessor.fromFile(path),
	Files.size(path) + additionalLength);
	}
	}

	// ---

	public static void main(String[] args) throws Exception {
	try (Server server = new Server()) {
	URI uri = new URI("http://127.0.0.1:" + server.getPort() + "/");

	// sanity
	success(uri, new StringRequestBody(STRING_BODY, 0));
	success(uri, new ByteArrayRequestBody(BYTE_ARRAY_BODY, 0));
	success(uri, new FileRequestBody(FILE_BODY, 0));

	for (int i=1; i< BODY_OFFSETS.length; i++) {
	failureBlocking(uri, new StringRequestBody(STRING_BODY, BODY_OFFSETS[i]));
	failureBlocking(uri, new ByteArrayRequestBody(BYTE_ARRAY_BODY, BODY_OFFSETS[i]));
	failureBlocking(uri, new FileRequestBody(FILE_BODY, BODY_OFFSETS[i]));

	failureNonBlocking(uri, new StringRequestBody(STRING_BODY, BODY_OFFSETS[i]));
	failureNonBlocking(uri, new ByteArrayRequestBody(BYTE_ARRAY_BODY, BODY_OFFSETS[i]));
	failureNonBlocking(uri, new FileRequestBody(FILE_BODY, BODY_OFFSETS[i]));
	}
	} finally {
	Executor def = defaultClient().executor();
	if (def instanceof ExecutorService) {
	((ExecutorService)def).shutdownNow();
	}
	}
	}

	static void success(URI uri, HttpRequest.BodyProcessor processor)
	throws Exception
	{
	CompletableFuture<HttpResponse<Void>> cf;
	HttpRequest request = HttpRequest.newBuilder(uri)
	.POST(processor)
	.build();
	cf = defaultClient().sendAsync(request, discard(null));

	HttpResponse<Void> resp = cf.get(30, TimeUnit.SECONDS);
	out.println("Response code: " + resp.statusCode());
	check(resp.statusCode() == 200, "Expected 200, got ", resp.statusCode());
	}

	static void failureNonBlocking(URI uri, HttpRequest.BodyProcessor processor)
	throws Exception
	{
	CompletableFuture<HttpResponse<Void>> cf;
	HttpRequest request = HttpRequest.newBuilder(uri)
	.POST(processor)
	.build();
	cf = defaultClient().sendAsync(request, discard(null));

	try {
	HttpResponse<Void> r = cf.get(30, TimeUnit.SECONDS);
	throw new RuntimeException("Unexpected response: " + r.statusCode());
	} catch (TimeoutException x) {
	throw new RuntimeException("Unexpected timeout", x);
	} catch (ExecutionException expected) {
	out.println("Caught expected: " + expected);
	check(expected.getCause() instanceof IOException,
	"Expected cause IOException, but got: ", expected.getCause());
	}
	}

	static void failureBlocking(URI uri, HttpRequest.BodyProcessor processor)
	throws Exception
	{
	HttpRequest request = HttpRequest.newBuilder(uri)
	.POST(processor)
	.build();
	try {
	HttpResponse<Void> r = defaultClient().send(request, discard(null));
	throw new RuntimeException("Unexpected response: " + r.statusCode());
	} catch (IOException expected) {
	out.println("Caught expected: " + expected);
	}
	}

	static class Server extends Thread implements AutoCloseable {

	static String RESPONSE = "HTTP/1.1 200 OK\r\n" +
	"Connection: close\r\n"+
	"Content-length: 0\r\n\r\n";

	private final ServerSocket ss;
	private volatile boolean closed;

	Server() throws IOException {
	super("Test-Server");
	ss = new ServerSocket(0); this.start();
	}

	int getPort() { return ss.getLocalPort(); }

	@Override
	public void run() {
	int count = 0;
	int offset = 0;

	while (!closed) {
	try (Socket s = ss.accept()) {
	InputStream is = s.getInputStream();
	readRequestHeaders(is);
	byte[] ba = new byte[1024];

	int length = BODY_LENGTHS[count % 3];
	length += BODY_OFFSETS[offset];

	is.readNBytes(ba, 0, length);

	OutputStream os = s.getOutputStream();
	os.write(RESPONSE.getBytes(US_ASCII));
	count++;
	if (count % 6 == 0) // 6 is the number of failure requests per offset
	offset++;
	} catch (IOException e) {
	if (!closed)
	System.out.println("Unexpected" + e);
	}
	}
	}

	@Override
	public void close() {
	if (closed)
	return;
	closed = true;
	try {
	ss.close();
	} catch (IOException e) {
	throw new UncheckedIOException("Unexpected", e);
	}
	}
	}

	static final byte[] requestEnd = new byte[] {'\r', '\n', '\r', '\n' };

	// Read until the end of a HTTP request headers
	static void readRequestHeaders(InputStream is) throws IOException {
	int requestEndCount = 0, r;
	while ((r = is.read()) != -1) {
	if (r == requestEnd[requestEndCount]) {
	requestEndCount++;
	if (requestEndCount == 4) {
	break;
	}
	} else {
	requestEndCount = 0;
	}
	}
	}

	static int fileSize(Path p) {
	try { return (int) Files.size(p); }
	catch (IOException x) { throw new UncheckedIOException(x); }
	}

	static boolean check(boolean cond, Object... failedArgs) {
	if (cond)
	return true;
	// We are going to fail...
	StringBuilder sb = new StringBuilder();
	for (Object o : failedArgs)
	sb.append(o);
	throw new RuntimeException(sb.toString());
	}
	}