1 /*

     2  * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /*

    25  * @test

    26  * @bug 8087112 8178699

    27  * @modules jdk.incubator.httpclient

    28  *          java.logging

    29  *          jdk.httpserver

    30  * @library /lib/testlibrary/ /

    31  * @build jdk.testlibrary.SimpleSSLContext ProxyServer

    32  * @compile ../../../com/sun/net/httpserver/LogFilter.java

    33  * @compile ../../../com/sun/net/httpserver/EchoHandler.java

    34  * @compile ../../../com/sun/net/httpserver/FileServerHandler.java

    35  * @run main/othervm -Djdk.httpclient.HttpClient.log=errors,trace SmokeTest

    36  */

    37 

    38 import com.sun.net.httpserver.Headers;

    39 import com.sun.net.httpserver.HttpContext;

    40 import com.sun.net.httpserver.HttpExchange;

    41 import com.sun.net.httpserver.HttpHandler;

    42 import com.sun.net.httpserver.HttpServer;

    43 import com.sun.net.httpserver.HttpsConfigurator;

    44 import com.sun.net.httpserver.HttpsParameters;

    45 import com.sun.net.httpserver.HttpsServer;

    46 import java.util.concurrent.atomic.AtomicInteger;

    47 import java.net.InetSocketAddress;

    48 import java.net.PasswordAuthentication;

    49 import java.net.ProxySelector;

    50 import java.net.ServerSocket;

    51 import java.net.Socket;

    52 import java.net.URI;

    53 import jdk.incubator.http.HttpClient;

    54 import jdk.incubator.http.HttpRequest;

    55 import jdk.incubator.http.HttpResponse;

    56 import java.nio.file.StandardOpenOption;

    57 import java.io.File;

    58 import java.io.FileInputStream;

    59 import java.io.FileOutputStream;

    60 import java.io.FileNotFoundException;

    61 import java.io.IOException;

    62 import java.io.BufferedInputStream;

    63 import java.io.InputStream;

    64 import java.io.OutputStream;

    65 import java.io.UncheckedIOException;

    66 import java.util.concurrent.BlockingQueue;

    67 import java.util.concurrent.CompletableFuture;

    68 import java.util.concurrent.CompletionException;

    69 import java.util.concurrent.CyclicBarrier;

    70 import java.util.concurrent.Executors;

    71 import java.util.concurrent.ExecutorService;

    72 import java.util.concurrent.LinkedBlockingQueue;

    73 import java.util.concurrent.TimeUnit;

    74 import javax.net.ssl.SSLContext;

    75 import javax.net.ssl.SSLParameters;

    76 import java.nio.file.Files;

    77 import java.nio.file.Path;

    78 import java.nio.file.Paths;

    79 import java.util.HashSet;

    80 import java.util.LinkedList;

    81 import java.util.List;

    82 import java.util.Random;

    83 import jdk.testlibrary.SimpleSSLContext;

    84 import static jdk.incubator.http.HttpRequest.BodyProcessor.fromFile;

    85 import static jdk.incubator.http.HttpRequest.BodyProcessor.fromInputStream;

    86 import static jdk.incubator.http.HttpRequest.BodyProcessor.fromString;

    87 import static jdk.incubator.http.HttpResponse.*;

    88 import static jdk.incubator.http.HttpResponse.BodyHandler.asFile;

    89 import static jdk.incubator.http.HttpResponse.BodyHandler.asString;

    90 import java.util.concurrent.CountDownLatch;

    91 import java.util.logging.ConsoleHandler;

    92 import java.util.logging.Level;

    93 import java.util.logging.Logger;

    94 

    95 /**

    96  * * Basic smoke test for Http/1.1 client

    97  * - basic request response

    98  * - request body POST

    99  * - response body GET

   100  * - redirect

   101  * - chunked request/response

   102  * - SSL

   103  * - proxies

   104  * - 100 continue

   105  * - check keep alive appears to be working

   106  * - cancel of long request

   107  *

   108  * Uses a FileServerHandler serving a couple of known files

   109  * in docs directory.

   110  */

   111 public class SmokeTest {

   112     static SSLContext ctx;

   113     static SSLParameters sslparams;

   114     static HttpServer s1 ;

   115     static HttpsServer s2;

   116     static ExecutorService executor;

   117     static int port;

   118     static int httpsport;

   119     static String httproot;

   120     static String httpsroot;

   121     static HttpClient client;

   122     static ProxyServer proxy;

   123     static int proxyPort;

   124     static RedirectErrorHandler redirectErrorHandler, redirectErrorHandlerSecure;

   125     static RedirectHandler redirectHandler, redirectHandlerSecure;

   126     static DelayHandler delayHandler;

   127     final static String midSizedFilename = "/files/notsobigfile.txt";

   128     final static String smallFilename = "/files/smallfile.txt";

   129     static Path midSizedFile;

   130     static Path smallFile;

   131     static String fileroot;

   132 

   133     static String getFileContent(String path) throws IOException {

   134         FileInputStream fis = new FileInputStream(path);

   135         byte[] buf = new byte[2000];

   136         StringBuilder sb = new StringBuilder();

   137         int n;

   138         while ((n=fis.read(buf)) != -1) {

   139             sb.append(new String(buf, 0, n, "US-ASCII"));

   140         }

   141         fis.close();

   142         return sb.toString();

   143     }

   144 

   145     static void cmpFileContent(Path path1, Path path2) throws IOException {

   146         InputStream fis1 = new BufferedInputStream(new FileInputStream(path1.toFile()));

   147         InputStream fis2 = new BufferedInputStream(new FileInputStream(path2.toFile()));

   148 

   149         int n1, n2;

   150         while ((n1=fis1.read()) != -1) {

   151             n2 = fis2.read();

   152             if (n1 != n2)

   153                 throw new IOException("Content not the same");

   154         }

   155         fis1.close();

   156         fis2.close();

   157     }

   158 

   159     public static void main(String[] args) throws Exception {

   160         initServer();

   161         fileroot = System.getProperty ("test.src", ".")+ "/docs";

   162         midSizedFile = Paths.get(fileroot + midSizedFilename);

   163         smallFile = Paths.get(fileroot + smallFilename);

   164         ExecutorService e = Executors.newCachedThreadPool();

   165         System.out.println(e);

   166         client = HttpClient.newBuilder()

   167                            .sslContext(ctx)

   168                            .executor(e)

   169                            .version(HttpClient.Version.HTTP_1_1)

   170                            .sslParameters(sslparams)

   171                            .followRedirects(HttpClient.Redirect.ALWAYS)

   172                            .build();

   173 

   174         try {

   175 

   176             test1(httproot + "files/foo.txt", true);

   177             test1(httproot + "files/foo.txt", false);

   178             test1(httpsroot + "files/foo.txt", true);

   179             test1(httpsroot + "files/foo.txt", false);

   180 

   181             test2(httproot + "echo/foo", "This is a short test");

   182             test2(httpsroot + "echo/foo", "This is a short test");

   183 

   184             test2a(httproot + "echo/foo");

   185             test2a(httpsroot + "echo/foo");

   186 

   187             test3(httproot + "redirect/foo.txt");

   188             test3(httpsroot + "redirect/foo.txt");

   189 

   190             test4(httproot + "files/foo.txt");

   191 

   192             test4(httpsroot + "files/foo.txt");

   193 

   194             test5(httproot + "echo/foo", true);

   195 

   196             test5(httpsroot + "echo/foo", true);

   197             test5(httproot + "echo/foo", false);

   198 

   199             test5(httpsroot + "echo/foo", false);

   200 

   201             test6(httproot + "echo/foo", true);

   202             test6(httpsroot + "echo/foo", true);

   203             test6(httproot + "echo/foo", false);

   204             test6(httpsroot + "echo/foo", false);

   205 

   206             test7(httproot + "keepalive/foo");

   207 /*

   208             test10(httproot + "redirecterror/foo.txt");

   209 

   210             test10(httpsroot + "redirecterror/foo.txt");

   211 

   212             test11(httproot + "echo/foo");

   213             test11(httpsroot + "echo/foo");

   214 */

   215             //test12(httproot + "delay/foo", delayHandler);

   216 

   217         } finally {

   218             s1.stop(0);

   219             s2.stop(0);

   220             proxy.close();

   221             e.shutdownNow();

   222             executor.shutdownNow();

   223         }

   224     }

   225 

   226     static class Auth extends java.net.Authenticator {

   227         volatile int count = 0;

   228         @Override

   229         protected PasswordAuthentication getPasswordAuthentication() {

   230             if (count++ == 0) {

   231                 return new PasswordAuthentication("user", "passwd".toCharArray());

   232             } else {

   233                 return new PasswordAuthentication("user", "goober".toCharArray());

   234             }

   235         }

   236         int count() {

   237             return count;

   238         }

   239     }

   240 

   241     // Basic test

   242     static void test1(String target, boolean fixedLen) throws Exception {

   243         System.out.print("test1: " + target);

   244         URI uri = new URI(target);

   245 

   246         HttpRequest.Builder builder = HttpRequest.newBuilder().uri(uri).GET();

   247 

   248         if (fixedLen) {

   249             builder.header("XFixed", "yes");

   250         }

   251 

   252         HttpRequest request = builder.build();

   253 

   254         HttpResponse<String> response = client.send(request, asString());

   255 

   256         String body = response.body();

   257         if (!body.equals("This is foo.txt\r\n")) {

   258             throw new RuntimeException();

   259         }

   260 

   261         // repeat async

   262         HttpResponse<String> response1 = client.sendAsync(request, asString())

   263                                                .join();

   264 

   265         String body1 = response1.body();

   266         if (!body1.equals("This is foo.txt\r\n")) {

   267             throw new RuntimeException();

   268         }

   269         System.out.println(" OK");

   270     }

   271 

   272     // POST use echo to check reply

   273     static void test2(String s, String body) throws Exception {

   274         System.out.print("test2: " + s);

   275         URI uri = new URI(s);

   276 

   277         HttpRequest request = HttpRequest.newBuilder(uri)

   278                                          .POST(fromString(body))

   279                                          .build();

   280 

   281         HttpResponse<String> response = client.send(request, asString());

   282 

   283         if (response.statusCode() != 200) {

   284             throw new RuntimeException(

   285                 "Expected 200, got [ " + response.statusCode() + " ]");

   286         }

   287         String reply = response.body();

   288         if (!reply.equals(body)) {

   289             throw new RuntimeException(

   290                 "Body mismatch: expected [" + body + "], got [" + reply + "]");

   291         }

   292         System.out.println(" OK");

   293     }

   294 

   295     // POST use echo to check reply

   296     static void test2a(String s) throws Exception {

   297         System.out.print("test2a: " + s);

   298         URI uri = new URI(s);

   299         Path p = Util.getTempFile(128 * 1024);

   300         //Path p = Util.getTempFile(1 * 1024);

   301 

   302         HttpRequest request = HttpRequest.newBuilder(uri)

   303                                          .POST(fromFile(p))

   304                                          .build();

   305 

   306         Path resp = Util.getTempFile(1); // will be overwritten

   307 

   308         HttpResponse<Path> response =

   309                 client.send(request,

   310                             BodyHandler.asFile(resp,

   311                                                StandardOpenOption.TRUNCATE_EXISTING,

   312                                                StandardOpenOption.WRITE));

   313 

   314         if (response.statusCode() != 200) {

   315             throw new RuntimeException(

   316                 "Expected 200, got [ " + response.statusCode() + " ]");

   317         }

   318         Path reply = response.body();

   319         //System.out.println("Reply stored in " + reply.toString());

   320         cmpFileContent(reply, p);

   321         System.out.println(" OK");

   322     }

   323 

   324     // Redirect

   325     static void test3(String s) throws Exception {

   326         System.out.print("test3: " + s);

   327         URI uri = new URI(s);

   328         RedirectHandler handler = uri.getScheme().equals("https")

   329                 ? redirectHandlerSecure : redirectHandler;

   330 

   331         HttpRequest request = HttpRequest.newBuilder()

   332                                          .uri(uri)

   333                                          .GET()

   334                                          .build();

   335 

   336         HttpResponse<Path> response = client.send(request,

   337                                                   asFile(Paths.get("redir1.txt")));

   338 

   339         if (response.statusCode() != 200) {

   340             throw new RuntimeException(

   341                 "Expected 200, got [ " + response.statusCode() + " ]");

   342         } else {

   343             response.body();

   344         }

   345 

   346         Path downloaded = Paths.get("redir1.txt");

   347         if (Files.size(downloaded) != Files.size(midSizedFile)) {

   348             throw new RuntimeException("Size mismatch");

   349         }

   350 

   351         System.out.printf(" (count: %d) ", handler.count());

   352         // repeat with async api

   353 

   354         handler.reset();

   355 

   356         request = HttpRequest.newBuilder(uri).build();

   357 

   358         response = client.sendAsync(request, asFile(Paths.get("redir2.txt"))).join();

   359 

   360         if (response.statusCode() != 200) {

   361             throw new RuntimeException(

   362                     "Expected 200, got [ " + response.statusCode() + " ]");

   363         } else {

   364             response.body();

   365         }

   366 

   367         downloaded = Paths.get("redir2.txt");

   368         if (Files.size(downloaded) != Files.size(midSizedFile)) {

   369             throw new RuntimeException("Size mismatch 2");

   370         }

   371         System.out.printf(" (count: %d) ", handler.count());

   372         System.out.println(" OK");

   373     }

   374 

   375     // Proxies

   376     static void test4(String s) throws Exception {

   377         System.out.print("test4: " + s);

   378         URI uri = new URI(s);

   379         InetSocketAddress proxyAddr = new InetSocketAddress("127.0.0.1", proxyPort);

   380         String filename = fileroot + uri.getPath();

   381 

   382         ExecutorService e = Executors.newCachedThreadPool();

   383 

   384         HttpClient cl = HttpClient.newBuilder()

   385                                   .executor(e)

   386                                   .proxy(ProxySelector.of(proxyAddr))

   387                                   .sslContext(ctx)

   388                                   .sslParameters(sslparams)

   389                                   .build();

   390 

   391         HttpRequest request = HttpRequest.newBuilder(uri).GET().build();

   392 

   393         CompletableFuture<String> fut = client.sendAsync(request, asString())

   394                 .thenApply((response) -> response.body());

   395 

   396         String body = fut.get(5, TimeUnit.HOURS);

   397 

   398         String fc = getFileContent(filename);

   399 

   400         if (!body.equals(fc)) {

   401             throw new RuntimeException(

   402                     "Body mismatch: expected [" + body + "], got [" + fc + "]");

   403         }

   404         e.shutdownNow();

   405         System.out.println(" OK");

   406     }

   407 

   408     // 100 Continue: use echo target

   409     static void test5(String target, boolean fixedLen) throws Exception {

   410         System.out.print("test5: " + target);

   411         URI uri = new URI(target);

   412         String requestBody = generateString(12 * 1024 + 13);

   413 

   414         HttpRequest.Builder builder = HttpRequest.newBuilder(uri)

   415                                             .expectContinue(true)

   416                                             .POST(fromString(requestBody));

   417 

   418         if (fixedLen) {

   419             builder.header("XFixed", "yes");

   420         }

   421 

   422         HttpRequest request = builder.build();

   423 

   424         HttpResponse<String> response = client.send(request, asString());

   425 

   426         String body = response.body();

   427 

   428         if (!body.equals(requestBody)) {

   429             throw new RuntimeException(

   430                     "Body mismatch: expected [" + body + "], got [" + body + "]");

   431         }

   432         System.out.println(" OK");

   433     }

   434 

   435     // use echo

   436     static void test6(String target, boolean fixedLen) throws Exception {

   437         System.out.print("test6: " + target);

   438         URI uri = new URI(target);

   439         String requestBody = generateString(12 * 1024 + 3);

   440 

   441         HttpRequest.Builder builder = HttpRequest.newBuilder(uri).GET();

   442 

   443         if (fixedLen) {

   444             builder.header("XFixed", "yes");

   445         }

   446 

   447         HttpRequest request = builder.build();

   448 

   449         HttpResponse<String> response = client.send(request, asString());

   450 

   451         if (response.statusCode() != 200) {

   452             throw new RuntimeException(

   453                     "Expected 200, got [ " + response.statusCode() + " ]");

   454         }

   455 

   456         String responseBody = response.body();

   457 

   458         if (responseBody.equals(requestBody)) {

   459             throw new RuntimeException(

   460                     "Body mismatch: expected [" + requestBody + "], got [" + responseBody + "]");

   461         }

   462         System.out.println(" OK");

   463     }

   464 

   465     @SuppressWarnings("rawtypes")

   466     static void test7(String target) throws Exception {

   467         System.out.print("test7: " + target);

   468         Path requestBody = Util.getTempFile(128 * 1024);

   469         // First test

   470         URI uri = new URI(target);

   471         HttpRequest request = HttpRequest.newBuilder().uri(uri).GET().build();

   472 

   473         for (int i=0; i<4; i++) {

   474             HttpResponse<String> r = client.send(request, asString());

   475             String body = r.body();

   476             if (!body.equals("OK")) {

   477                 throw new RuntimeException("Expected OK, got: " + body);

   478             }

   479         }

   480 

   481         // Second test: 4 x parallel

   482         request = HttpRequest.newBuilder().uri(uri).POST(fromFile(requestBody)).build();

   483         List<CompletableFuture<String>> futures = new LinkedList<>();

   484         for (int i=0; i<4; i++) {

   485             futures.add(client.sendAsync(request, asString())

   486                               .thenApply((response) -> {

   487                                   if (response.statusCode() == 200)

   488                                       return response.body();

   489                                   else

   490                                       return "ERROR";

   491                               }));

   492         }

   493         // all sent?

   494         CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))

   495                          .join();

   496 

   497         for (CompletableFuture<String> future : futures) {

   498             String body = future.get();

   499             if (!body.equals("OK")) {

   500                 throw new RuntimeException("Expected OK, got: " + body);

   501             }

   502         }

   503 

   504         // Third test: Multiple of 4 parallel requests

   505         request = HttpRequest.newBuilder(uri).GET().build();

   506         BlockingQueue<String> q = new LinkedBlockingQueue<>();

   507         for (int i=0; i<4; i++) {

   508             client.sendAsync(request, asString())

   509                   .thenApply((HttpResponse<String> resp) -> {

   510                       String body = resp.body();

   511                       putQ(q, body);

   512                       return body;

   513                   });

   514         }

   515         // we've sent four requests. Now, just send another request

   516         // as each response is received. The idea is to ensure that

   517         // only four sockets ever get used.

   518 

   519         for (int i=0; i<100; i++) {

   520             // block until response received

   521             String body = takeQ(q);

   522             if (!body.equals("OK")) {

   523                 throw new RuntimeException(body);

   524             }

   525             client.sendAsync(request, asString())

   526                   .thenApply((resp) -> {

   527                       if (resp.statusCode() == 200)

   528                           putQ(q, resp.body());

   529                       else

   530                           putQ(q, "ERROR");

   531                       return null;

   532                   });

   533         }

   534         // should be four left

   535         for (int i=0; i<4; i++) {

   536             takeQ(q);

   537         }

   538         System.out.println(" OK");

   539     }

   540 

   541     static String takeQ(BlockingQueue<String> q) {

   542         String r = null;

   543         try {

   544             r = q.take();

   545         } catch (InterruptedException e) {}

   546 

   547         return r;

   548     }

   549 

   550     static void putQ(BlockingQueue<String> q, String o) {

   551         try {

   552             q.put(o);

   553         } catch (InterruptedException e) {

   554             // can't happen

   555         }

   556     }

   557 

   558     static FileInputStream newStream() {

   559         try {

   560             return new FileInputStream(smallFile.toFile());

   561         } catch (FileNotFoundException e) {

   562             throw new UncheckedIOException(e);

   563         }

   564     }

   565     // Chunked output stream

   566     static void test11(String target) throws Exception {

   567         System.out.print("test11: " + target);

   568         URI uri = new URI(target);

   569 

   570         HttpRequest request = HttpRequest.newBuilder(uri)

   571                                          .POST(fromInputStream(SmokeTest::newStream))

   572                                          .build();

   573 

   574         Path download = Paths.get("test11.txt");

   575 

   576         HttpResponse<Path> response = client.send(request, asFile(download));

   577 

   578         if (response.statusCode() != 200) {

   579             throw new RuntimeException("Wrong response code");

   580         }

   581 

   582         download.toFile().delete();

   583         response.body();

   584 

   585         if (Files.size(download) != Files.size(smallFile)) {

   586             System.out.println("Original size: " + Files.size(smallFile));

   587             System.out.println("Downloaded size: " + Files.size(download));

   588             throw new RuntimeException("Size mismatch");

   589         }

   590         System.out.println(" OK");

   591     }

   592 

   593     static void delay(int seconds) {

   594         try {

   595             Thread.sleep(seconds * 1000);

   596         } catch (InterruptedException e) {

   597         }

   598     }

   599 

   600     // Redirect loop: return an error after a certain number of redirects

   601     static void test10(String s) throws Exception {

   602         System.out.print("test10: " + s);

   603         URI uri = new URI(s);

   604         RedirectErrorHandler handler = uri.getScheme().equals("https")

   605                 ? redirectErrorHandlerSecure : redirectErrorHandler;

   606 

   607         HttpRequest request = HttpRequest.newBuilder(uri).GET().build();

   608         CompletableFuture<HttpResponse<String>> cf =

   609                 client.sendAsync(request, asString());

   610 

   611         try {

   612             HttpResponse<String> response = cf.join();

   613             throw new RuntimeException("Exepected Completion Exception");

   614         } catch (CompletionException e) {

   615             //System.out.println(e);

   616         }

   617 

   618         System.out.printf(" (Calls %d) ", handler.count());

   619         System.out.println(" OK");

   620     }

   621 

   622     static final int NUM = 50;

   623 

   624     static Random random = new Random();

   625     static final String alphabet = "ABCDEFGHIJKLMNOPQRST";

   626 

   627     static char randomChar() {

   628         return alphabet.charAt(random.nextInt(alphabet.length()));

   629     }

   630 

   631     static String generateString(int length) {

   632         StringBuilder sb = new StringBuilder(length);

   633         for (int i=0; i<length; i++) {

   634             sb.append(randomChar());

   635         }

   636         return sb.toString();

   637     }

   638 

   639     static void initServer() throws Exception {

   640 

   641         Logger logger = Logger.getLogger("com.sun.net.httpserver");

   642         ConsoleHandler ch = new ConsoleHandler();

   643         logger.setLevel(Level.SEVERE);

   644         ch.setLevel(Level.SEVERE);

   645         logger.addHandler(ch);

   646 

   647         String root = System.getProperty ("test.src")+ "/docs";

   648         InetSocketAddress addr = new InetSocketAddress (0);

   649         s1 = HttpServer.create (addr, 0);

   650         if (s1 instanceof HttpsServer) {

   651             throw new RuntimeException ("should not be httpsserver");

   652         }

   653         s2 = HttpsServer.create (addr, 0);

   654         HttpHandler h = new FileServerHandler(root);

   655 

   656         HttpContext c1 = s1.createContext("/files", h);

   657         HttpContext c2 = s2.createContext("/files", h);

   658         HttpContext c3 = s1.createContext("/echo", new EchoHandler());

   659         redirectHandler = new RedirectHandler("/redirect");

   660         redirectHandlerSecure = new RedirectHandler("/redirect");

   661         HttpContext c4 = s1.createContext("/redirect", redirectHandler);

   662         HttpContext c41 = s2.createContext("/redirect", redirectHandlerSecure);

   663         HttpContext c5 = s2.createContext("/echo", new EchoHandler());

   664         HttpContext c6 = s1.createContext("/keepalive", new KeepAliveHandler());

   665         redirectErrorHandler = new RedirectErrorHandler("/redirecterror");

   666         redirectErrorHandlerSecure = new RedirectErrorHandler("/redirecterror");

   667         HttpContext c7 = s1.createContext("/redirecterror", redirectErrorHandler);

   668         HttpContext c71 = s2.createContext("/redirecterror", redirectErrorHandlerSecure);

   669         delayHandler = new DelayHandler();

   670         HttpContext c8 = s1.createContext("/delay", delayHandler);

   671         HttpContext c81 = s2.createContext("/delay", delayHandler);

   672 

   673         executor = Executors.newCachedThreadPool();

   674         s1.setExecutor(executor);

   675         s2.setExecutor(executor);

   676         ctx = new SimpleSSLContext().get();

   677         sslparams = ctx.getSupportedSSLParameters();

   678         s2.setHttpsConfigurator(new Configurator(ctx));

   679         s1.start();

   680         s2.start();

   681 

   682         port = s1.getAddress().getPort();

   683         System.out.println("HTTP server port = " + port);

   684         httpsport = s2.getAddress().getPort();

   685         System.out.println("HTTPS server port = " + httpsport);

   686         httproot = "http://127.0.0.1:" + port + "/";

   687         httpsroot = "https://127.0.0.1:" + httpsport + "/";

   688 

   689         proxy = new ProxyServer(0, false);

   690         proxyPort = proxy.getPort();

   691         System.out.println("Proxy port = " + proxyPort);

   692     }

   693 }

   694 

   695 class Configurator extends HttpsConfigurator {

   696     public Configurator(SSLContext ctx) {

   697         super(ctx);

   698     }

   699 

   700     public void configure (HttpsParameters params) {

   701         params.setSSLParameters (getSSLContext().getSupportedSSLParameters());

   702     }

   703 }

   704 

   705 class UploadServer extends Thread {

   706     int statusCode;

   707     ServerSocket ss;

   708     int port;

   709     int size;

   710     Object lock;

   711     boolean failed = false;

   712 

   713     UploadServer(int size) throws IOException {

   714         this.statusCode = statusCode;

   715         this.size = size;

   716         ss = new ServerSocket(0);

   717         port = ss.getLocalPort();

   718         lock = new Object();

   719     }

   720 

   721     int port() {

   722           return port;

   723     }

   724 

   725     int size() {

   726           return size;

   727     }

   728 

   729     // wait a sec before calling this

   730     boolean failed() {

   731         synchronized(lock) {

   732             return failed;

   733         }

   734     }

   735 

   736     @Override

   737     public void run () {

   738         int nbytes = 0;

   739         Socket s = null;

   740 

   741         synchronized(lock) {

   742             try {

   743                 s = ss.accept();

   744 

   745                 InputStream is = s.getInputStream();

   746                 OutputStream os = s.getOutputStream();

   747                 os.write("HTTP/1.1 201 OK\r\nContent-length: 0\r\n\r\n".getBytes());

   748                 int n;

   749                 byte[] buf = new byte[8000];

   750                 while ((n=is.read(buf)) != -1) {

   751                     nbytes += n;

   752                 }

   753             } catch (IOException e) {

   754                 System.out.println ("read " + nbytes);

   755                 System.out.println ("size " + size);

   756                 failed = nbytes >= size;

   757             } finally {

   758                 try {

   759                     ss.close();

   760                     if (s != null)

   761                         s.close();

   762                 } catch (IOException e) {}

   763             }

   764         }

   765     }

   766 }

   767 

   768 class RedirectHandler implements HttpHandler {

   769     String root;

   770     volatile int count = 0;

   771 

   772     RedirectHandler(String root) {

   773         this.root = root;

   774     }

   775 

   776     @Override

   777     public synchronized void handle(HttpExchange t)

   778         throws IOException

   779     {

   780         byte[] buf = new byte[2048];

   781         try (InputStream is = t.getRequestBody()) {

   782             while (is.read(buf) != -1) ;

   783         }

   784 

   785         Headers responseHeaders = t.getResponseHeaders();

   786 

   787         if (count++ < 1) {

   788             responseHeaders.add("Location", root + "/foo/" + count);

   789         } else {

   790             responseHeaders.add("Location", SmokeTest.midSizedFilename);

   791         }

   792         t.sendResponseHeaders(301, -1);

   793         t.close();

   794     }

   795 

   796     int count() {

   797         return count;

   798     }

   799 

   800     void reset() {

   801         count = 0;

   802     }

   803 }

   804 

   805 class RedirectErrorHandler implements HttpHandler {

   806     String root;

   807     volatile int count = 1;

   808 

   809     RedirectErrorHandler(String root) {

   810         this.root = root;

   811     }

   812 

   813     synchronized int count() {

   814         return count;

   815     }

   816 

   817     synchronized void increment() {

   818         count++;

   819     }

   820 

   821     @Override

   822     public synchronized void handle (HttpExchange t)

   823         throws IOException

   824     {

   825         byte[] buf = new byte[2048];

   826         try (InputStream is = t.getRequestBody()) {

   827             while (is.read(buf) != -1) ;

   828         }

   829 

   830         Headers map = t.getResponseHeaders();

   831         String redirect = root + "/foo/" + Integer.toString(count);

   832         increment();

   833         map.add("Location", redirect);

   834         t.sendResponseHeaders(301, -1);

   835         t.close();

   836     }

   837 }

   838 

   839 class Util {

   840     static byte[] readAll(InputStream is) throws IOException {

   841         byte[] buf = new byte[1024];

   842         byte[] result = new byte[0];

   843 

   844         while (true) {

   845             int n = is.read(buf);

   846             if (n > 0) {

   847                 byte[] b1 = new byte[result.length + n];

   848                 System.arraycopy(result, 0, b1, 0, result.length);

   849                 System.arraycopy(buf, 0, b1, result.length, n);

   850                 result = b1;

   851             } else if (n == -1) {

   852                 return result;

   853             }

   854         }

   855     }

   856 

   857     static Path getTempFile(int size) throws IOException {

   858         File f = File.createTempFile("test", "txt");

   859         f.deleteOnExit();

   860         byte[] buf = new byte[2048];

   861         for (int i=0; i<buf.length; i++)

   862             buf[i] = (byte)i;

   863 

   864         FileOutputStream fos = new FileOutputStream(f);

   865         while (size > 0) {

   866             int amount = Math.min(size, buf.length);

   867             fos.write(buf, 0, amount);

   868             size -= amount;

   869         }

   870         fos.close();

   871         return f.toPath();

   872     }

   873 }

   874 

   875 class DelayHandler implements HttpHandler {

   876 

   877     CyclicBarrier bar1 = new CyclicBarrier(2);

   878     CyclicBarrier bar2 = new CyclicBarrier(2);

   879     CyclicBarrier bar3 = new CyclicBarrier(2);

   880 

   881     CyclicBarrier barrier1() {

   882         return bar1;

   883     }

   884 

   885     CyclicBarrier barrier2() {

   886         return bar2;

   887     }

   888 

   889     @Override

   890     public synchronized void handle(HttpExchange he) throws IOException {

   891         byte[] buf = Util.readAll(he.getRequestBody());

   892         try {

   893             bar1.await();

   894             bar2.await();

   895         } catch (Exception e) {}

   896         he.sendResponseHeaders(200, -1); // will probably fail

   897         he.close();

   898     }

   899 

   900 }

   901 

   902 // check for simple hardcoded sequence and use remote address

   903 // to check.

   904 // First 4 requests executed in sequence (should use same connection/address)

   905 // Next 4 requests parallel (should use different addresses)

   906 // Then send 4 requests in parallel x 100 times (same four addresses used all time)

   907 

   908 class KeepAliveHandler implements HttpHandler {

   909     AtomicInteger counter = new AtomicInteger(0);

   910     AtomicInteger nparallel = new AtomicInteger(0);

   911 

   912     HashSet<Integer> portSet = new HashSet<>();

   913 

   914     int[] ports = new int[8];

   915 

   916     void sleep(int n) {

   917         try {

   918             Thread.sleep(n);

   919         } catch (InterruptedException e) {}

   920     }

   921 

   922     synchronized void setPort(int index, int value) {

   923         ports[index] = value;

   924     }

   925 

   926     synchronized int getPort(int index) {

   927         return ports[index];

   928     }

   929 

   930     synchronized void getPorts(int[] dest, int from) {

   931         dest[0] = ports[from+0];

   932         dest[1] = ports[from+1];

   933         dest[2] = ports[from+2];

   934         dest[3] = ports[from+3];

   935     }

   936 

   937     static CountDownLatch latch = new CountDownLatch(4);

   938 

   939     @Override

   940     public void handle (HttpExchange t)

   941         throws IOException

   942     {

   943         int np = nparallel.incrementAndGet();

   944         int remotePort = t.getRemoteAddress().getPort();

   945         String result = "OK";

   946         int[] lports = new int[4];

   947 

   948         int n = counter.getAndIncrement();

   949 

   950         /// First test

   951         if (n < 4) {

   952             setPort(n, remotePort);

   953         }

   954         if (n == 3) {

   955             getPorts(lports, 0);

   956             // check all values in ports[] are the same

   957             if (lports[0] != lports[1] || lports[2] != lports[3]

   958                     || lports[0] != lports[2]) {

   959                 result = "Error " + Integer.toString(n);

   960                 System.out.println(result);

   961             }

   962         }

   963         // Second test

   964         if (n >=4 && n < 8) {

   965             // delay so that this connection doesn't get reused

   966             // before all 4 requests sent

   967             setPort(n, remotePort);

   968             latch.countDown();

   969             try {latch.await();} catch (InterruptedException e) {}

   970         }

   971         if (n == 7) {

   972             getPorts(lports, 4);

   973             // should be all different

   974             if (lports[0] == lports[1] || lports[2] == lports[3]

   975                     || lports[0] == lports[2]) {

   976                 result = "Error " + Integer.toString(n);

   977                 System.out.println(result);

   978             }

   979             // setup for third test

   980             for (int i=0; i<4; i++) {

   981                 portSet.add(lports[i]);

   982             }

   983             System.out.printf("Ports: %d, %d, %d, %d\n", lports[0], lports[1], lports[2], lports[3]);

   984         }

   985         // Third test

   986         if (n > 7) {

   987             if (np > 4) {

   988                 System.err.println("XXX np = " + np);

   989             }

   990             // just check that port is one of the ones in portSet

   991             if (!portSet.contains(remotePort)) {

   992                 System.out.println ("UNEXPECTED REMOTE PORT " + remotePort);

   993                 result = "Error " + Integer.toString(n);

   994                 System.out.println(result);

   995             }

   996         }

   997         byte[] buf = new byte[2048];

   998 

   999         try (InputStream is = t.getRequestBody()) {

  1000             while (is.read(buf) != -1) ;

  1001         }

  1002         t.sendResponseHeaders(200, result.length());

  1003         OutputStream o = t.getResponseBody();

  1004         o.write(result.getBytes("US-ASCII"));

  1005         t.close();

  1006         nparallel.getAndDecrement();

  1007     }

  1008 }