| /* |
| * Copyright (c) 2015, 2017, 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 8087112 |
| * @modules jdk.incubator.httpclient |
| * java.logging |
| * jdk.httpserver |
| * @library /lib/testlibrary/ / |
| * @build jdk.testlibrary.SimpleSSLContext ProxyServer |
| * @compile ../../../com/sun/net/httpserver/LogFilter.java |
| * @compile ../../../com/sun/net/httpserver/EchoHandler.java |
| * @compile ../../../com/sun/net/httpserver/FileServerHandler.java |
| * @run main/othervm -Djdk.httpclient.HttpClient.log=errors,trace SmokeTest |
| */ |
| |
| import com.sun.net.httpserver.Headers; |
| import com.sun.net.httpserver.HttpContext; |
| import com.sun.net.httpserver.HttpExchange; |
| import com.sun.net.httpserver.HttpHandler; |
| import com.sun.net.httpserver.HttpServer; |
| import com.sun.net.httpserver.HttpsConfigurator; |
| import com.sun.net.httpserver.HttpsParameters; |
| import com.sun.net.httpserver.HttpsServer; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import java.net.InetSocketAddress; |
| import java.net.PasswordAuthentication; |
| import java.net.ProxySelector; |
| import java.net.ServerSocket; |
| import java.net.Socket; |
| import java.net.URI; |
| import jdk.incubator.http.HttpClient; |
| import jdk.incubator.http.HttpRequest; |
| import jdk.incubator.http.HttpResponse; |
| import java.nio.file.StandardOpenOption; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.BufferedInputStream; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.UncheckedIOException; |
| import java.util.concurrent.BlockingQueue; |
| import java.util.concurrent.CompletableFuture; |
| import java.util.concurrent.CompletionException; |
| import java.util.concurrent.CyclicBarrier; |
| import java.util.concurrent.Executors; |
| import java.util.concurrent.ExecutorService; |
| import java.util.concurrent.LinkedBlockingQueue; |
| import java.util.concurrent.TimeUnit; |
| import javax.net.ssl.SSLContext; |
| import javax.net.ssl.SSLParameters; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.HashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Random; |
| import jdk.testlibrary.SimpleSSLContext; |
| import static jdk.incubator.http.HttpRequest.BodyProcessor.fromFile; |
| import static jdk.incubator.http.HttpRequest.BodyProcessor.fromInputStream; |
| import static jdk.incubator.http.HttpRequest.BodyProcessor.fromString; |
| import static jdk.incubator.http.HttpResponse.*; |
| import static jdk.incubator.http.HttpResponse.BodyHandler.asFile; |
| import static jdk.incubator.http.HttpResponse.BodyHandler.asString; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.logging.ConsoleHandler; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| /** |
| * * Basic smoke test for Http/1.1 client |
| * - basic request response |
| * - request body POST |
| * - response body GET |
| * - redirect |
| * - chunked request/response |
| * - SSL |
| * - proxies |
| * - 100 continue |
| * - check keep alive appears to be working |
| * - cancel of long request |
| * |
| * Uses a FileServerHandler serving a couple of known files |
| * in docs directory. |
| */ |
| public class SmokeTest { |
| static SSLContext ctx; |
| static SSLParameters sslparams; |
| static HttpServer s1 ; |
| static HttpsServer s2; |
| static ExecutorService executor; |
| static int port; |
| static int httpsport; |
| static String httproot; |
| static String httpsroot; |
| static HttpClient client; |
| static ProxyServer proxy; |
| static int proxyPort; |
| static RedirectErrorHandler redirectErrorHandler, redirectErrorHandlerSecure; |
| static RedirectHandler redirectHandler, redirectHandlerSecure; |
| static DelayHandler delayHandler; |
| final static String midSizedFilename = "/files/notsobigfile.txt"; |
| final static String smallFilename = "/files/smallfile.txt"; |
| static Path midSizedFile; |
| static Path smallFile; |
| static String fileroot; |
| |
| static String getFileContent(String path) throws IOException { |
| FileInputStream fis = new FileInputStream(path); |
| byte[] buf = new byte[2000]; |
| StringBuilder sb = new StringBuilder(); |
| int n; |
| while ((n=fis.read(buf)) != -1) { |
| sb.append(new String(buf, 0, n, "US-ASCII")); |
| } |
| fis.close(); |
| return sb.toString(); |
| } |
| |
| static void cmpFileContent(Path path1, Path path2) throws IOException { |
| InputStream fis1 = new BufferedInputStream(new FileInputStream(path1.toFile())); |
| InputStream fis2 = new BufferedInputStream(new FileInputStream(path2.toFile())); |
| |
| int n1, n2; |
| while ((n1=fis1.read()) != -1) { |
| n2 = fis2.read(); |
| if (n1 != n2) |
| throw new IOException("Content not the same"); |
| } |
| fis1.close(); |
| fis2.close(); |
| } |
| |
| public static void main(String[] args) throws Exception { |
| initServer(); |
| fileroot = System.getProperty ("test.src", ".")+ "/docs"; |
| midSizedFile = Paths.get(fileroot + midSizedFilename); |
| smallFile = Paths.get(fileroot + smallFilename); |
| ExecutorService e = Executors.newCachedThreadPool(); |
| System.out.println(e); |
| client = HttpClient.newBuilder() |
| .sslContext(ctx) |
| .executor(e) |
| .version(HttpClient.Version.HTTP_1_1) |
| .sslParameters(sslparams) |
| .followRedirects(HttpClient.Redirect.ALWAYS) |
| .build(); |
| |
| try { |
| |
| test1(httproot + "files/foo.txt", true); |
| test1(httproot + "files/foo.txt", false); |
| test1(httpsroot + "files/foo.txt", true); |
| test1(httpsroot + "files/foo.txt", false); |
| |
| test2(httproot + "echo/foo", "This is a short test"); |
| test2(httpsroot + "echo/foo", "This is a short test"); |
| |
| test2a(httproot + "echo/foo"); |
| test2a(httpsroot + "echo/foo"); |
| |
| test3(httproot + "redirect/foo.txt"); |
| test3(httpsroot + "redirect/foo.txt"); |
| |
| test4(httproot + "files/foo.txt"); |
| |
| test4(httpsroot + "files/foo.txt"); |
| |
| test5(httproot + "echo/foo", true); |
| |
| test5(httpsroot + "echo/foo", true); |
| test5(httproot + "echo/foo", false); |
| |
| test5(httpsroot + "echo/foo", false); |
| |
| test6(httproot + "echo/foo", true); |
| test6(httpsroot + "echo/foo", true); |
| test6(httproot + "echo/foo", false); |
| test6(httpsroot + "echo/foo", false); |
| |
| test7(httproot + "keepalive/foo"); |
| /* |
| test10(httproot + "redirecterror/foo.txt"); |
| |
| test10(httpsroot + "redirecterror/foo.txt"); |
| |
| test11(httproot + "echo/foo"); |
| test11(httpsroot + "echo/foo"); |
| */ |
| //test12(httproot + "delay/foo", delayHandler); |
| |
| } finally { |
| s1.stop(0); |
| s2.stop(0); |
| proxy.close(); |
| e.shutdownNow(); |
| executor.shutdownNow(); |
| } |
| } |
| |
| static class Auth extends java.net.Authenticator { |
| volatile int count = 0; |
| @Override |
| protected PasswordAuthentication getPasswordAuthentication() { |
| if (count++ == 0) { |
| return new PasswordAuthentication("user", "passwd".toCharArray()); |
| } else { |
| return new PasswordAuthentication("user", "goober".toCharArray()); |
| } |
| } |
| int count() { |
| return count; |
| } |
| } |
| |
| // Basic test |
| static void test1(String target, boolean fixedLen) throws Exception { |
| System.out.print("test1: " + target); |
| URI uri = new URI(target); |
| |
| HttpRequest.Builder builder = HttpRequest.newBuilder().uri(uri).GET(); |
| |
| if (fixedLen) { |
| builder.header("XFixed", "yes"); |
| } |
| |
| HttpRequest request = builder.build(); |
| |
| HttpResponse<String> response = client.send(request, asString()); |
| |
| String body = response.body(); |
| if (!body.equals("This is foo.txt\r\n")) { |
| throw new RuntimeException(); |
| } |
| |
| // repeat async |
| HttpResponse<String> response1 = client.sendAsync(request, asString()) |
| .join(); |
| |
| String body1 = response1.body(); |
| if (!body1.equals("This is foo.txt\r\n")) { |
| throw new RuntimeException(); |
| } |
| System.out.println(" OK"); |
| } |
| |
| // POST use echo to check reply |
| static void test2(String s, String body) throws Exception { |
| System.out.print("test2: " + s); |
| URI uri = new URI(s); |
| |
| HttpRequest request = HttpRequest.newBuilder(uri) |
| .POST(fromString(body)) |
| .build(); |
| |
| HttpResponse<String> response = client.send(request, asString()); |
| |
| if (response.statusCode() != 200) { |
| throw new RuntimeException( |
| "Expected 200, got [ " + response.statusCode() + " ]"); |
| } |
| String reply = response.body(); |
| if (!reply.equals(body)) { |
| throw new RuntimeException( |
| "Body mismatch: expected [" + body + "], got [" + reply + "]"); |
| } |
| System.out.println(" OK"); |
| } |
| |
| // POST use echo to check reply |
| static void test2a(String s) throws Exception { |
| System.out.print("test2a: " + s); |
| URI uri = new URI(s); |
| Path p = Util.getTempFile(128 * 1024); |
| //Path p = Util.getTempFile(1 * 1024); |
| |
| HttpRequest request = HttpRequest.newBuilder(uri) |
| .POST(fromFile(p)) |
| .build(); |
| |
| Path resp = Util.getTempFile(1); // will be overwritten |
| |
| HttpResponse<Path> response = |
| client.send(request, |
| BodyHandler.asFile(resp, |
| StandardOpenOption.TRUNCATE_EXISTING, |
| StandardOpenOption.WRITE)); |
| |
| if (response.statusCode() != 200) { |
| throw new RuntimeException( |
| "Expected 200, got [ " + response.statusCode() + " ]"); |
| } |
| Path reply = response.body(); |
| //System.out.println("Reply stored in " + reply.toString()); |
| cmpFileContent(reply, p); |
| System.out.println(" OK"); |
| } |
| |
| // Redirect |
| static void test3(String s) throws Exception { |
| System.out.print("test3: " + s); |
| URI uri = new URI(s); |
| RedirectHandler handler = uri.getScheme().equals("https") |
| ? redirectHandlerSecure : redirectHandler; |
| |
| HttpRequest request = HttpRequest.newBuilder() |
| .uri(uri) |
| .GET() |
| .build(); |
| |
| HttpResponse<Path> response = client.send(request, |
| asFile(Paths.get("redir1.txt"))); |
| |
| if (response.statusCode() != 200) { |
| throw new RuntimeException( |
| "Expected 200, got [ " + response.statusCode() + " ]"); |
| } else { |
| response.body(); |
| } |
| |
| Path downloaded = Paths.get("redir1.txt"); |
| if (Files.size(downloaded) != Files.size(midSizedFile)) { |
| throw new RuntimeException("Size mismatch"); |
| } |
| |
| System.out.printf(" (count: %d) ", handler.count()); |
| // repeat with async api |
| |
| handler.reset(); |
| |
| request = HttpRequest.newBuilder(uri).build(); |
| |
| response = client.sendAsync(request, asFile(Paths.get("redir2.txt"))).join(); |
| |
| if (response.statusCode() != 200) { |
| throw new RuntimeException( |
| "Expected 200, got [ " + response.statusCode() + " ]"); |
| } else { |
| response.body(); |
| } |
| |
| downloaded = Paths.get("redir2.txt"); |
| if (Files.size(downloaded) != Files.size(midSizedFile)) { |
| throw new RuntimeException("Size mismatch 2"); |
| } |
| System.out.printf(" (count: %d) ", handler.count()); |
| System.out.println(" OK"); |
| } |
| |
| // Proxies |
| static void test4(String s) throws Exception { |
| System.out.print("test4: " + s); |
| URI uri = new URI(s); |
| InetSocketAddress proxyAddr = new InetSocketAddress("127.0.0.1", proxyPort); |
| String filename = fileroot + uri.getPath(); |
| |
| ExecutorService e = Executors.newCachedThreadPool(); |
| |
| HttpClient cl = HttpClient.newBuilder() |
| .executor(e) |
| .proxy(ProxySelector.of(proxyAddr)) |
| .sslContext(ctx) |
| .sslParameters(sslparams) |
| .build(); |
| |
| HttpRequest request = HttpRequest.newBuilder(uri).GET().build(); |
| |
| CompletableFuture<String> fut = client.sendAsync(request, asString()) |
| .thenApply((response) -> response.body()); |
| |
| String body = fut.get(5, TimeUnit.HOURS); |
| |
| String fc = getFileContent(filename); |
| |
| if (!body.equals(fc)) { |
| throw new RuntimeException( |
| "Body mismatch: expected [" + body + "], got [" + fc + "]"); |
| } |
| e.shutdownNow(); |
| System.out.println(" OK"); |
| } |
| |
| // 100 Continue: use echo target |
| static void test5(String target, boolean fixedLen) throws Exception { |
| System.out.print("test5: " + target); |
| URI uri = new URI(target); |
| String requestBody = generateString(12 * 1024 + 13); |
| |
| HttpRequest.Builder builder = HttpRequest.newBuilder(uri) |
| .expectContinue(true) |
| .POST(fromString(requestBody)); |
| |
| if (fixedLen) { |
| builder.header("XFixed", "yes"); |
| } |
| |
| HttpRequest request = builder.build(); |
| |
| HttpResponse<String> response = client.send(request, asString()); |
| |
| String body = response.body(); |
| |
| if (!body.equals(requestBody)) { |
| throw new RuntimeException( |
| "Body mismatch: expected [" + body + "], got [" + body + "]"); |
| } |
| System.out.println(" OK"); |
| } |
| |
| // use echo |
| static void test6(String target, boolean fixedLen) throws Exception { |
| System.out.print("test6: " + target); |
| URI uri = new URI(target); |
| String requestBody = generateString(12 * 1024 + 3); |
| |
| HttpRequest.Builder builder = HttpRequest.newBuilder(uri).GET(); |
| |
| if (fixedLen) { |
| builder.header("XFixed", "yes"); |
| } |
| |
| HttpRequest request = builder.build(); |
| |
| HttpResponse<String> response = client.send(request, asString()); |
| |
| if (response.statusCode() != 200) { |
| throw new RuntimeException( |
| "Expected 200, got [ " + response.statusCode() + " ]"); |
| } |
| |
| String responseBody = response.body(); |
| |
| if (responseBody.equals(requestBody)) { |
| throw new RuntimeException( |
| "Body mismatch: expected [" + requestBody + "], got [" + responseBody + "]"); |
| } |
| System.out.println(" OK"); |
| } |
| |
| @SuppressWarnings("rawtypes") |
| static void test7(String target) throws Exception { |
| System.out.print("test7: " + target); |
| Path requestBody = Util.getTempFile(128 * 1024); |
| // First test |
| URI uri = new URI(target); |
| HttpRequest request = HttpRequest.newBuilder().uri(uri).GET().build(); |
| |
| for (int i=0; i<4; i++) { |
| HttpResponse<String> r = client.send(request, asString()); |
| String body = r.body(); |
| if (!body.equals("OK")) { |
| throw new RuntimeException("Expected OK, got: " + body); |
| } |
| } |
| |
| // Second test: 4 x parallel |
| request = HttpRequest.newBuilder().uri(uri).POST(fromFile(requestBody)).build(); |
| List<CompletableFuture<String>> futures = new LinkedList<>(); |
| for (int i=0; i<4; i++) { |
| futures.add(client.sendAsync(request, asString()) |
| .thenApply((response) -> { |
| if (response.statusCode() == 200) |
| return response.body(); |
| else |
| return "ERROR"; |
| })); |
| } |
| // all sent? |
| CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])) |
| .join(); |
| |
| for (CompletableFuture<String> future : futures) { |
| String body = future.get(); |
| if (!body.equals("OK")) { |
| throw new RuntimeException("Expected OK, got: " + body); |
| } |
| } |
| |
| // Third test: Multiple of 4 parallel requests |
| request = HttpRequest.newBuilder(uri).GET().build(); |
| BlockingQueue<String> q = new LinkedBlockingQueue<>(); |
| for (int i=0; i<4; i++) { |
| client.sendAsync(request, asString()) |
| .thenApply((HttpResponse<String> resp) -> { |
| String body = resp.body(); |
| putQ(q, body); |
| return body; |
| }); |
| } |
| // we've sent four requests. Now, just send another request |
| // as each response is received. The idea is to ensure that |
| // only four sockets ever get used. |
| |
| for (int i=0; i<100; i++) { |
| // block until response received |
| String body = takeQ(q); |
| if (!body.equals("OK")) { |
| throw new RuntimeException(body); |
| } |
| client.sendAsync(request, asString()) |
| .thenApply((resp) -> { |
| if (resp.statusCode() == 200) |
| putQ(q, resp.body()); |
| else |
| putQ(q, "ERROR"); |
| return null; |
| }); |
| } |
| // should be four left |
| for (int i=0; i<4; i++) { |
| takeQ(q); |
| } |
| System.out.println(" OK"); |
| } |
| |
| static String takeQ(BlockingQueue<String> q) { |
| String r = null; |
| try { |
| r = q.take(); |
| } catch (InterruptedException e) {} |
| |
| return r; |
| } |
| |
| static void putQ(BlockingQueue<String> q, String o) { |
| try { |
| q.put(o); |
| } catch (InterruptedException e) { |
| // can't happen |
| } |
| } |
| |
| static FileInputStream newStream() { |
| try { |
| return new FileInputStream(smallFile.toFile()); |
| } catch (FileNotFoundException e) { |
| throw new UncheckedIOException(e); |
| } |
| } |
| // Chunked output stream |
| static void test11(String target) throws Exception { |
| System.out.print("test11: " + target); |
| URI uri = new URI(target); |
| |
| HttpRequest request = HttpRequest.newBuilder(uri) |
| .POST(fromInputStream(SmokeTest::newStream)) |
| .build(); |
| |
| Path download = Paths.get("test11.txt"); |
| |
| HttpResponse<Path> response = client.send(request, asFile(download)); |
| |
| if (response.statusCode() != 200) { |
| throw new RuntimeException("Wrong response code"); |
| } |
| |
| download.toFile().delete(); |
| response.body(); |
| |
| if (Files.size(download) != Files.size(smallFile)) { |
| System.out.println("Original size: " + Files.size(smallFile)); |
| System.out.println("Downloaded size: " + Files.size(download)); |
| throw new RuntimeException("Size mismatch"); |
| } |
| System.out.println(" OK"); |
| } |
| |
| static void delay(int seconds) { |
| try { |
| Thread.sleep(seconds * 1000); |
| } catch (InterruptedException e) { |
| } |
| } |
| |
| // Redirect loop: return an error after a certain number of redirects |
| static void test10(String s) throws Exception { |
| System.out.print("test10: " + s); |
| URI uri = new URI(s); |
| RedirectErrorHandler handler = uri.getScheme().equals("https") |
| ? redirectErrorHandlerSecure : redirectErrorHandler; |
| |
| HttpRequest request = HttpRequest.newBuilder(uri).GET().build(); |
| CompletableFuture<HttpResponse<String>> cf = |
| client.sendAsync(request, asString()); |
| |
| try { |
| HttpResponse<String> response = cf.join(); |
| throw new RuntimeException("Exepected Completion Exception"); |
| } catch (CompletionException e) { |
| //System.out.println(e); |
| } |
| |
| System.out.printf(" (Calls %d) ", handler.count()); |
| System.out.println(" OK"); |
| } |
| |
| static final int NUM = 50; |
| |
| static Random random = new Random(); |
| static final String alphabet = "ABCDEFGHIJKLMNOPQRST"; |
| |
| static char randomChar() { |
| return alphabet.charAt(random.nextInt(alphabet.length())); |
| } |
| |
| static String generateString(int length) { |
| StringBuilder sb = new StringBuilder(length); |
| for (int i=0; i<length; i++) { |
| sb.append(randomChar()); |
| } |
| return sb.toString(); |
| } |
| |
| static void initServer() throws Exception { |
| |
| Logger logger = Logger.getLogger("com.sun.net.httpserver"); |
| ConsoleHandler ch = new ConsoleHandler(); |
| logger.setLevel(Level.SEVERE); |
| ch.setLevel(Level.SEVERE); |
| logger.addHandler(ch); |
| |
| String root = System.getProperty ("test.src")+ "/docs"; |
| InetSocketAddress addr = new InetSocketAddress (0); |
| s1 = HttpServer.create (addr, 0); |
| if (s1 instanceof HttpsServer) { |
| throw new RuntimeException ("should not be httpsserver"); |
| } |
| s2 = HttpsServer.create (addr, 0); |
| HttpHandler h = new FileServerHandler(root); |
| |
| HttpContext c1 = s1.createContext("/files", h); |
| HttpContext c2 = s2.createContext("/files", h); |
| HttpContext c3 = s1.createContext("/echo", new EchoHandler()); |
| redirectHandler = new RedirectHandler("/redirect"); |
| redirectHandlerSecure = new RedirectHandler("/redirect"); |
| HttpContext c4 = s1.createContext("/redirect", redirectHandler); |
| HttpContext c41 = s2.createContext("/redirect", redirectHandlerSecure); |
| HttpContext c5 = s2.createContext("/echo", new EchoHandler()); |
| HttpContext c6 = s1.createContext("/keepalive", new KeepAliveHandler()); |
| redirectErrorHandler = new RedirectErrorHandler("/redirecterror"); |
| redirectErrorHandlerSecure = new RedirectErrorHandler("/redirecterror"); |
| HttpContext c7 = s1.createContext("/redirecterror", redirectErrorHandler); |
| HttpContext c71 = s2.createContext("/redirecterror", redirectErrorHandlerSecure); |
| delayHandler = new DelayHandler(); |
| HttpContext c8 = s1.createContext("/delay", delayHandler); |
| HttpContext c81 = s2.createContext("/delay", delayHandler); |
| |
| executor = Executors.newCachedThreadPool(); |
| s1.setExecutor(executor); |
| s2.setExecutor(executor); |
| ctx = new SimpleSSLContext().get(); |
| sslparams = ctx.getSupportedSSLParameters(); |
| s2.setHttpsConfigurator(new Configurator(ctx)); |
| s1.start(); |
| s2.start(); |
| |
| port = s1.getAddress().getPort(); |
| System.out.println("HTTP server port = " + port); |
| httpsport = s2.getAddress().getPort(); |
| System.out.println("HTTPS server port = " + httpsport); |
| httproot = "http://127.0.0.1:" + port + "/"; |
| httpsroot = "https://127.0.0.1:" + httpsport + "/"; |
| |
| proxy = new ProxyServer(0, false); |
| proxyPort = proxy.getPort(); |
| System.out.println("Proxy port = " + proxyPort); |
| } |
| } |
| |
| class Configurator extends HttpsConfigurator { |
| public Configurator(SSLContext ctx) { |
| super(ctx); |
| } |
| |
| public void configure (HttpsParameters params) { |
| params.setSSLParameters (getSSLContext().getSupportedSSLParameters()); |
| } |
| } |
| |
| class UploadServer extends Thread { |
| int statusCode; |
| ServerSocket ss; |
| int port; |
| int size; |
| Object lock; |
| boolean failed = false; |
| |
| UploadServer(int size) throws IOException { |
| this.statusCode = statusCode; |
| this.size = size; |
| ss = new ServerSocket(0); |
| port = ss.getLocalPort(); |
| lock = new Object(); |
| } |
| |
| int port() { |
| return port; |
| } |
| |
| int size() { |
| return size; |
| } |
| |
| // wait a sec before calling this |
| boolean failed() { |
| synchronized(lock) { |
| return failed; |
| } |
| } |
| |
| @Override |
| public void run () { |
| int nbytes = 0; |
| Socket s = null; |
| |
| synchronized(lock) { |
| try { |
| s = ss.accept(); |
| |
| InputStream is = s.getInputStream(); |
| OutputStream os = s.getOutputStream(); |
| os.write("HTTP/1.1 201 OK\r\nContent-length: 0\r\n\r\n".getBytes()); |
| int n; |
| byte[] buf = new byte[8000]; |
| while ((n=is.read(buf)) != -1) { |
| nbytes += n; |
| } |
| } catch (IOException e) { |
| System.out.println ("read " + nbytes); |
| System.out.println ("size " + size); |
| failed = nbytes >= size; |
| } finally { |
| try { |
| ss.close(); |
| if (s != null) |
| s.close(); |
| } catch (IOException e) {} |
| } |
| } |
| } |
| } |
| |
| class RedirectHandler implements HttpHandler { |
| String root; |
| volatile int count = 0; |
| |
| RedirectHandler(String root) { |
| this.root = root; |
| } |
| |
| @Override |
| public synchronized void handle(HttpExchange t) |
| throws IOException |
| { |
| byte[] buf = new byte[2048]; |
| try (InputStream is = t.getRequestBody()) { |
| while (is.read(buf) != -1) ; |
| } |
| |
| Headers responseHeaders = t.getResponseHeaders(); |
| |
| if (count++ < 1) { |
| responseHeaders.add("Location", root + "/foo/" + count); |
| } else { |
| responseHeaders.add("Location", SmokeTest.midSizedFilename); |
| } |
| t.sendResponseHeaders(301, -1); |
| t.close(); |
| } |
| |
| int count() { |
| return count; |
| } |
| |
| void reset() { |
| count = 0; |
| } |
| } |
| |
| class RedirectErrorHandler implements HttpHandler { |
| String root; |
| volatile int count = 1; |
| |
| RedirectErrorHandler(String root) { |
| this.root = root; |
| } |
| |
| synchronized int count() { |
| return count; |
| } |
| |
| synchronized void increment() { |
| count++; |
| } |
| |
| @Override |
| public synchronized void handle (HttpExchange t) |
| throws IOException |
| { |
| byte[] buf = new byte[2048]; |
| try (InputStream is = t.getRequestBody()) { |
| while (is.read(buf) != -1) ; |
| } |
| |
| Headers map = t.getResponseHeaders(); |
| String redirect = root + "/foo/" + Integer.toString(count); |
| increment(); |
| map.add("Location", redirect); |
| t.sendResponseHeaders(301, -1); |
| t.close(); |
| } |
| } |
| |
| class Util { |
| static byte[] readAll(InputStream is) throws IOException { |
| byte[] buf = new byte[1024]; |
| byte[] result = new byte[0]; |
| |
| while (true) { |
| int n = is.read(buf); |
| if (n > 0) { |
| byte[] b1 = new byte[result.length + n]; |
| System.arraycopy(result, 0, b1, 0, result.length); |
| System.arraycopy(buf, 0, b1, result.length, n); |
| result = b1; |
| } else if (n == -1) { |
| return result; |
| } |
| } |
| } |
| |
| static Path getTempFile(int size) throws IOException { |
| File f = File.createTempFile("test", "txt"); |
| f.deleteOnExit(); |
| byte[] buf = new byte[2048]; |
| for (int i=0; i<buf.length; i++) |
| buf[i] = (byte)i; |
| |
| FileOutputStream fos = new FileOutputStream(f); |
| while (size > 0) { |
| int amount = Math.min(size, buf.length); |
| fos.write(buf, 0, amount); |
| size -= amount; |
| } |
| fos.close(); |
| return f.toPath(); |
| } |
| } |
| |
| class DelayHandler implements HttpHandler { |
| |
| CyclicBarrier bar1 = new CyclicBarrier(2); |
| CyclicBarrier bar2 = new CyclicBarrier(2); |
| CyclicBarrier bar3 = new CyclicBarrier(2); |
| |
| CyclicBarrier barrier1() { |
| return bar1; |
| } |
| |
| CyclicBarrier barrier2() { |
| return bar2; |
| } |
| |
| @Override |
| public synchronized void handle(HttpExchange he) throws IOException { |
| byte[] buf = Util.readAll(he.getRequestBody()); |
| try { |
| bar1.await(); |
| bar2.await(); |
| } catch (Exception e) {} |
| he.sendResponseHeaders(200, -1); // will probably fail |
| he.close(); |
| } |
| |
| } |
| |
| // check for simple hardcoded sequence and use remote address |
| // to check. |
| // First 4 requests executed in sequence (should use same connection/address) |
| // Next 4 requests parallel (should use different addresses) |
| // Then send 4 requests in parallel x 100 times (same four addresses used all time) |
| |
| class KeepAliveHandler implements HttpHandler { |
| AtomicInteger counter = new AtomicInteger(0); |
| AtomicInteger nparallel = new AtomicInteger(0); |
| |
| HashSet<Integer> portSet = new HashSet<>(); |
| |
| int[] ports = new int[8]; |
| |
| void sleep(int n) { |
| try { |
| Thread.sleep(n); |
| } catch (InterruptedException e) {} |
| } |
| |
| synchronized void setPort(int index, int value) { |
| ports[index] = value; |
| } |
| |
| synchronized int getPort(int index) { |
| return ports[index]; |
| } |
| |
| synchronized void getPorts(int[] dest, int from) { |
| dest[0] = ports[from+0]; |
| dest[1] = ports[from+1]; |
| dest[2] = ports[from+2]; |
| dest[3] = ports[from+3]; |
| } |
| |
| static CountDownLatch latch = new CountDownLatch(4); |
| |
| @Override |
| public void handle (HttpExchange t) |
| throws IOException |
| { |
| int np = nparallel.incrementAndGet(); |
| int remotePort = t.getRemoteAddress().getPort(); |
| String result = "OK"; |
| int[] lports = new int[4]; |
| |
| int n = counter.getAndIncrement(); |
| |
| /// First test |
| if (n < 4) { |
| setPort(n, remotePort); |
| } |
| if (n == 3) { |
| getPorts(lports, 0); |
| // check all values in ports[] are the same |
| if (lports[0] != lports[1] || lports[2] != lports[3] |
| || lports[0] != lports[2]) { |
| result = "Error " + Integer.toString(n); |
| System.out.println(result); |
| } |
| } |
| // Second test |
| if (n >=4 && n < 8) { |
| // delay so that this connection doesn't get reused |
| // before all 4 requests sent |
| setPort(n, remotePort); |
| latch.countDown(); |
| try {latch.await();} catch (InterruptedException e) {} |
| } |
| if (n == 7) { |
| getPorts(lports, 4); |
| // should be all different |
| if (lports[0] == lports[1] || lports[2] == lports[3] |
| || lports[0] == lports[2]) { |
| result = "Error " + Integer.toString(n); |
| System.out.println(result); |
| } |
| // setup for third test |
| for (int i=0; i<4; i++) { |
| portSet.add(lports[i]); |
| } |
| System.out.printf("Ports: %d, %d, %d, %d\n", lports[0], lports[1], lports[2], lports[3]); |
| } |
| // Third test |
| if (n > 7) { |
| if (np > 4) { |
| System.err.println("XXX np = " + np); |
| } |
| // just check that port is one of the ones in portSet |
| if (!portSet.contains(remotePort)) { |
| System.out.println ("UNEXPECTED REMOTE PORT " + remotePort); |
| result = "Error " + Integer.toString(n); |
| System.out.println(result); |
| } |
| } |
| byte[] buf = new byte[2048]; |
| |
| try (InputStream is = t.getRequestBody()) { |
| while (is.read(buf) != -1) ; |
| } |
| t.sendResponseHeaders(200, result.length()); |
| OutputStream o = t.getResponseBody(); |
| o.write(result.getBytes("US-ASCII")); |
| t.close(); |
| nparallel.getAndDecrement(); |
| } |
| } |
