1 /*
   2  * Copyright (c) 2002, 2018, 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 4636628
  27  * @summary HttpURLConnection duplicates HTTP GET requests when used with multiple threads
  28 */
  29 
  30 /*
  31  * This tests keep-alive behavior using chunkedinputstreams
  32  * It checks that keep-alive connections are used and also
  33  * that requests are not being repeated (due to errors)
  34  *
  35  * It also checks that the keepalive connections are closed eventually
  36  * because the test will not terminate if the connections
  37  * are not closed by the keep-alive timer.
  38  */
  39 
  40 import java.net.*;
  41 import java.io.*;
  42 import java.time.Duration;
  43 import java.util.Queue;
  44 import java.util.concurrent.ConcurrentLinkedQueue;
  45 
  46 public class MultiThreadTest extends Thread {
  47 
  48     /*
  49      * Is debugging enabled - start with -d to enable.
  50      */
  51     static boolean debug = true; // disable debug once stability proven
  52 
  53     static Object threadlock = new Object ();
  54     static int threadCounter = 0;
  55 
  56     static Object getLock() { return threadlock; }
  57 
  58     static void debug(String msg) {
  59         if (debug)
  60             System.out.println(msg);
  61     }
  62 
  63     static int reqnum = 0;
  64 
  65     void doRequest(String uri) throws Exception {
  66         URL url = new URL(uri + "?foo="+reqnum);
  67         reqnum ++;
  68         HttpURLConnection http = (HttpURLConnection)url.openConnection();
  69 
  70         InputStream in = http.getInputStream();
  71         byte b[] = new byte[100];
  72         int total = 0;
  73         int n;
  74         do {
  75             n = in.read(b);
  76             if (n > 0) total += n;
  77         } while (n > 0);
  78         debug ("client: read " + total + " bytes");
  79         in.close();
  80         http.disconnect();
  81     }
  82 
  83     String uri;
  84     byte[] b;
  85     int requests;
  86 
  87     MultiThreadTest(int port, int requests) throws Exception {
  88         uri = "http://localhost:" +
  89                      port + "/foo.html";
  90 
  91         b = new byte [256];
  92         this.requests = requests;
  93 
  94         synchronized (threadlock) {
  95             threadCounter ++;
  96         }
  97     }
  98 
  99     public void run () {
 100         long start = System.nanoTime();
 101 
 102         try {
 103             for (int i=0; i<requests; i++) {
 104                 doRequest (uri);
 105             }
 106         } catch (Exception e) {
 107             throw new RuntimeException (e.getMessage());
 108         } finally {
 109             synchronized (threadlock) {
 110                 threadCounter --;
 111                 if (threadCounter == 0) {
 112                     threadlock.notifyAll();
 113                 }
 114             }
 115         }
 116         debug("client: end - " + Duration.ofNanos(System.nanoTime() - start));
 117     }
 118 
 119     static int threads=5;
 120 
 121     public static void main(String args[]) throws Exception {
 122         long start = System.nanoTime();
 123 
 124         int x = 0, arg_len = args.length;
 125         int requests = 20;
 126 
 127         if (arg_len > 0 && args[0].equals("-d")) {
 128             debug = true;
 129             x = 1;
 130             arg_len --;
 131         }
 132         if (arg_len > 0) {
 133             threads = Integer.parseInt (args[x]);
 134             requests = Integer.parseInt (args[x+1]);
 135         }
 136 
 137         /* start the server */
 138         ServerSocket ss = new ServerSocket(0);
 139         Server svr = new Server(ss);
 140         svr.start();
 141 
 142         Object lock = MultiThreadTest.getLock();
 143         synchronized (lock) {
 144             for (int i=0; i<threads; i++) {
 145                 MultiThreadTest t = new MultiThreadTest(ss.getLocalPort(), requests);
 146                 t.start ();
 147             }
 148             try {
 149                 lock.wait();
 150             } catch (InterruptedException e) {}
 151         }
 152 
 153         // shutdown server - we're done.
 154         svr.shutdown();
 155 
 156         int cnt = svr.connectionCount();
 157         MultiThreadTest.debug("Connections = " + cnt);
 158         int reqs = Worker.getRequests ();
 159         MultiThreadTest.debug("Requests = " + reqs);
 160         System.out.println ("Connection count = " + cnt + " Request count = " + reqs);
 161         if (cnt > threads) { // could be less
 162             throw new RuntimeException ("Expected "+threads + " connections: used " +cnt);
 163         }
 164         if  (reqs != threads*requests) {
 165             throw new RuntimeException ("Expected "+ threads*requests+ " requests: got " +reqs);
 166         }
 167         for (Thread worker : svr.workers()) {
 168             worker.join(60_000);
 169         }
 170 
 171         debug("main thread end - " + Duration.ofNanos(System.nanoTime() - start));
 172     }
 173 }
 174 
 175     /*
 176      * Server thread to accept connection and create worker threads
 177      * to service each connection.
 178      */
 179     class Server extends Thread {
 180         ServerSocket ss;
 181         int connectionCount;
 182         boolean shutdown = false;
 183         private Queue<Worker> workers = new ConcurrentLinkedQueue<>();
 184 
 185         Server(ServerSocket ss) {
 186             this.ss = ss;
 187         }
 188 
 189         public Queue<Worker> workers() {
 190             return workers;
 191         }
 192 
 193         public synchronized int connectionCount() {
 194             return connectionCount;
 195         }
 196 
 197         public synchronized void shutdown() {
 198             shutdown = true;
 199         }
 200 
 201         public void run() {
 202             try {
 203                 ss.setSoTimeout(2000);
 204 
 205                 for (;;) {
 206                     Socket s;
 207                     try {
 208                         MultiThreadTest.debug("server: calling accept.");
 209                         s = ss.accept();
 210                         MultiThreadTest.debug("server: return accept.");
 211                     } catch (SocketTimeoutException te) {
 212                         MultiThreadTest.debug("server: STE");
 213                         synchronized (this) {
 214                             if (shutdown) {
 215                                 MultiThreadTest.debug("server: Shuting down.");
 216                                 return;
 217                             }
 218                         }
 219                         continue;
 220                     }
 221 
 222                     int id;
 223                     Worker w;
 224                     synchronized (this) {
 225                         id = connectionCount++;
 226                         w = new Worker(s, id);
 227                         workers.add(w);
 228                     }
 229                     w.start();
 230                     MultiThreadTest.debug("server: Started worker " + id);
 231                 }
 232 
 233             } catch (Exception e) {
 234                 e.printStackTrace();
 235             } finally {
 236                 try {
 237                     ss.close();
 238                 } catch (Exception e) { }
 239             }
 240         }
 241     }
 242 
 243     /*
 244      * Worker thread to service single connection - can service
 245      * multiple http requests on same connection.
 246      */
 247     class Worker extends Thread {
 248         Socket s;
 249         int id;
 250 
 251         Worker(Socket s, int id) {
 252             this.s = s;
 253             this.id = id;
 254         }
 255 
 256         static int requests = 0;
 257         static Object rlock = new Object();
 258 
 259         public static int getRequests () {
 260             synchronized (rlock) {
 261                 return requests;
 262             }
 263         }
 264         public static void incRequests () {
 265             synchronized (rlock) {
 266                 requests++;
 267             }
 268         }
 269 
 270         int readUntil (InputStream in, char[] seq) throws IOException {
 271             int i=0, count=0;
 272             while (true) {
 273                 int c = in.read();
 274                 if (c == -1)
 275                     return -1;
 276                 count++;
 277                 if (c == seq[i]) {
 278                     i++;
 279                     if (i == seq.length)
 280                         return count;
 281                     continue;
 282                 } else {
 283                     i = 0;
 284                 }
 285             }
 286         }
 287 
 288         public void run() {
 289             long start = System.nanoTime();
 290 
 291             try {
 292                 int max = 400;
 293                 byte b[] = new byte[1000];
 294                 InputStream in = new BufferedInputStream (s.getInputStream());
 295                 // response to client
 296                 PrintStream out = new PrintStream(
 297                                     new BufferedOutputStream(
 298                                                 s.getOutputStream() ));
 299 
 300                 for (;;) {
 301 
 302                     // read entire request from client
 303                     int n=0;
 304 
 305                     n = readUntil (in, new char[] {'\r','\n', '\r','\n'});
 306 
 307                     if (n <= 0) {
 308                         MultiThreadTest.debug("worker: " + id + ": Shutdown");
 309                         s.close();
 310                         return;
 311                     }
 312 
 313                     MultiThreadTest.debug("worker " + id +
 314                         ": Read request from client " +
 315                         "(" + n + " bytes).");
 316 
 317                     incRequests();
 318                     out.print("HTTP/1.1 200 OK\r\n");
 319                     out.print("Transfer-Encoding: chunked\r\n");
 320                     out.print("Content-Type: text/html\r\n");
 321                     out.print("Connection: Keep-Alive\r\n");
 322                     out.print ("Keep-Alive: timeout=15, max="+max+"\r\n");
 323                     out.print("\r\n");
 324                     out.print ("6\r\nHello \r\n");
 325                     out.print ("5\r\nWorld\r\n");
 326                     out.print ("0\r\n\r\n");
 327                     out.flush();
 328 
 329                     if (--max == 0) {
 330                         s.close();
 331                         return;
 332                     }
 333                 }
 334 
 335             } catch (Exception e) {
 336                 e.printStackTrace();
 337             } finally {
 338                 try {
 339                     s.close();
 340                 } catch (Exception e) { }
 341                 MultiThreadTest.debug("worker: " + id  + " end - " +
 342                             Duration.ofNanos(System.nanoTime() - start));
 343             }
 344         }
 345     }