Quellcode-Bibliothek MaxStreams.java

/*
 * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR published the Free Software Foundation.
 *
 * 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
 * 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
  accompaniedthis )
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write
 * Inc., 51 Franklin St, Fifth Floor, Boston           ..jdk.net.httpframe
 *
 contact ,500OracleParkway RedwoodShores CA 94065 USA
 * or visit www.oracle.com if you need additional information or* build jdk..lib.net.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 * questionsjavautil..CountDownLatch
 */

/*
 * java..http.HttpRequest
 * @ 8196389
  summaryShould HttpClient supportSETTINGS_MAX_CONCURRENT_STREAMSthe server
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 
 *          .net/.internalnet.http.ommon
 *          java.net.http/jdk.
 *          java.net.http/jdk.internal.net.http.hpack
           .logging
 *          jdk.httpserver
 * @library /test/java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 25
*@ jdktest..netSimpleSSLContext
 * @run                }java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 */

import java.io testAsString( ) Exception
import javaio.InputStreamjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
import java.        .setLatchlatch
mport.net;
import javaListCompletableFuture<>>responses  LinkedList>)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ..List
import java.util.LinkedList;
import java.util.Properties;
import java.GET
import java.util.concurrent..build(;
import java.util.concurrent.CompletionException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Semaphore
import javax.net.ssl.SSLContext warmup")
import java.nethttp.HttpClient
import java.net.http.HttpRequest;
importif(warmup()! 200| !warmup.().equals(RESPONSE)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
import javanet..HttpResponse.BodyHandler;
import java.SystemerrprintlnSending request "  i);
importresponsesaddclientsendAsync(,BodyHandlersofString))java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
import .testngannotations.fterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
try
import .errprintln(" for firstexception";
import static org.testng.Assert.assertEquals;
import orgtestng.assertFalse
import static org.testng         catch(Exception )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

latch(;

        
 https2TestServer
    final Http2FixedHandler ..(Waiting second;
java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 19
 ;
    String..("xpected 2 " )
    volatile latch
    ExecutorService exec;
    finalSemaphore = ()

    // we send an initial warm up request, then MAX_STREAMS+1 requestsHttpResponse<String cf responses) 
    // in parallel. The last of them should hit the limit.
    // Then we wait for all the responses and send a further request
    // which should succeed. The server should see (and respond to)
    /MAX_STREAMS+2requests per  run.

    static finalthrownewRuntimeException();
    staticfinal String RESPONSE =Hello"java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

    @DataProvider(name = "Systemerr.(t));
     Object[]() 
        return new Object[            }
    http2FixedURI
                              ()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
{}java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                {https2FixedURI}
        };
    }System.(" "java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38


    @Test(dataProvider = "uris", timeOut=20000)
    void testAsString          ExecutorsnewCachedThreadPool
        System.err.println("Semaphore acquire");
        canStartTestRun  InetSocketAddress(.()0;
        latch = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        handler(;
        HttpClient client = HttpClient.newBuilderhttp2TestServer = Http2TestServer"", false,0, ,10,, null;
> responses new<>);

        HttpRequest request = HttpRequest        http2FixedURI =http//" + http2TestServer.serverAuthority()+ "/http2/fixed";
ent.)
                                                 .(handler//
                                          ( Exception
        // send warmup to ensure we only have one Http2Connection
        System.err.println("Sending warmup request");
        HttpResponse<String> warmup = client.send(request, BodyHandlers.ofString());
        if (warmup.statusCode() != 200 |          counter new();
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        for}
            System.err.println(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            responses        
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        // wait until we get local exception before allow server to proceed
         {
            System.err.printlnOutputStream  getResponseBody) 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          ( ee{
            System.err                ifc >0& c=MAX_STREAMS
        }

        latchcountDown);

        // check the first MAX_STREAMS requests succeedederr(" "java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        try {
ception)
            CompletableFuture.allOf(}
            System.err.println("Did not get Expected exception 2
         catch(xception) 
            System.}finally {
                // client issues MAX_STREAMS + 3 requests in total
        // but server should only see MAX_STREAMS + 2 in total. One is rejected by client
        int failures= 0;
        for (CompletableFuture<HttpResponse c= MAX_STREAMS 1 {
           <>r =null
            try {
                count++;
                r                     canStartTestRun.elease;
                if (r}
                    throw new RuntimeException();
            } catch (Throwable t) {
                failures++;
                System.err.printf("Failure %d at count %d\n", failures, count);
                System.err.println(t);
                t.printStackTrace();
            }
        }
        if (failures != 1) {
            String msg = "Expected 1 failure. Got " + failures;
            throw new RuntimeException(msg);
        }

        System.err.println("Sending last request");
        // make sure it succeeds now as number of streams == 0 now
        HttpResponse<String> warmdown = client.send(request, BodyHandlers.ofString());
        if (warmdown.statusCode() != 200 || !warmdown.body().equals(RESPONSE))
            throw new RuntimeException();
        System.err.println("Test OK");
    }

    @BeforeTest
    public void setup() throws Exception {
        ctx = (new SimpleSSLContext()).get();
        exec = Executors.newCachedThreadPool();

        InetSocketAddress sa = new InetSocketAddress(InetAddress.getLoopbackAddress(), 0);

        Properties props = new Properties();
        props.setProperty("http2server.settings.max_concurrent_streams", Integer.toString(MAX_STREAMS));
        http2TestServer = new Http2TestServer("localhost", false, 0, exec, 10, props, null);
        http2TestServer.addHandler(handler, "/http2/fixed");
        http2FixedURI = "http://" + http2TestServer.serverAuthority()+ "/http2/fixed";
        http2TestServer.start();

        https2TestServer = new Http2TestServer("localhost", true, 0, exec, 10, props, ctx);
        https2TestServer.addHandler(handler, "/https2/fixed");
        https2FixedURI = "https://" + https2TestServer.serverAuthority()+ "/https2/fixed";
        https2TestServer.start();
    }

    @AfterTest
    public void teardown() throws Exception {
        System.err.println("Stopping test server now");
        http2TestServer.stop();
    }

    class Http2FixedHandler implements Http2Handler {
        final AtomicInteger counter = new AtomicInteger(0);
        volatile CountDownLatch latch;

        synchronized void setLatch(CountDownLatch latch) {
            this.latch = latch;
        }

        synchronized CountDownLatch getLatch() {
            return latch;
        }

        @Override
        public void handle(Http2TestExchange t) throws IOException {
            int c = -1;
            try (InputStream is = t.getRequestBody();
                 OutputStream os = t.getResponseBody()) {

                is.readAllBytes();
                c = counter.getAndIncrement();
                if (c > 0 && c <= MAX_STREAMS) {
                    // Wait for latch.
                    try {
                        // don't send any replies until all requests are sent
                        System.err.println("Latch await");
                        getLatch().await();
                        System.err.println("Latch resume");
                    } catch (InterruptedException ee) {}
                }
                t.sendResponseHeaders(200, RESPONSE.length());
                os.write(RESPONSE.getBytes());
            } finally {
                // client issues MAX_STREAMS + 3 requests in total
                // but server should only see MAX_STREAMS + 2 in total. One is rejected by client
                // counter c captured before increment so final value is MAX_STREAMS + 1
                if (c == MAX_STREAMS + 1) {
                    System.err.println("Semaphore release");
                    counter.set(0);
                    canStartTestRun.release();
                }
            }
        }
    }
}