jdk-sandbox: comparison test/jdk/java/net/httpclient/http2/server/Http2TestServerConnection.java

equal deleted inserted replaced

-:e4022357f852
+:57f17e890a40
 import java.net.Socket;
 import java.net.URI;
 import java.net.InetAddress;
 import javax.net.ssl.*;
 import java.net.URISyntaxException;
+import java.net.http.HttpHeaders;
 import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.function.Consumer;
-import jdk.internal.net.http.common.HttpHeadersImpl;
+import jdk.internal.net.http.common.HttpHeadersBuilder;
 import jdk.internal.net.http.frame.*;
 import jdk.internal.net.http.hpack.Decoder;
 import jdk.internal.net.http.hpack.DecodingCallback;
 import jdk.internal.net.http.hpack.Encoder;
 import sun.net.www.http.ChunkedInputStream;
 outputQ.put(wup);
 wup = new WindowUpdateFrame(0 , len);
 outputQ.put(wup);
 }
-HttpHeadersImpl decodeHeaders(List<HeaderFrame> frames) throws IOException {
+HttpHeaders decodeHeaders(List<HeaderFrame> frames) throws IOException {
-HttpHeadersImpl headers = createNewResponseHeaders();
+HttpHeadersBuilder headersBuilder = createNewHeadersBuilder();
 DecodingCallback cb = (name, value) -> {
-headers.addHeader(name.toString(), value.toString());
+headersBuilder.addHeader(name.toString(), value.toString());
 };
 for (HeaderFrame frame : frames) {
 List<ByteBuffer> buffers = frame.getHeaderBlock();
 for (ByteBuffer buffer : buffers) {
 hpackIn.decode(buffer, false, cb);
 }
 }
 hpackIn.decode(EMPTY_BUFFER, true, cb);
-return headers;
+return headersBuilder.build();
 }
 String getRequestLine(String request) {
 int eol = request.indexOf(CRLF);
 return request.substring(0, eol);
 throw new RuntimeException("Malformed request");
 }
 return request.substring(start,end);
 }
-void addHeaders(String headers, HttpHeadersImpl hdrs) {
+static void addHeaders(String headersString, HttpHeadersBuilder headersBuilder) {
-String[] hh = headers.split(CRLF);
+String[] hh = headersString.split(CRLF);
 for (String header : hh) {
 int colon = header.indexOf(':');
 if (colon == -1)
 continue;
 String name = header.substring(0, colon);
 String value = header.substring(colon+1);
 while (value.startsWith(" "))
 value = value.substring(1);
-hdrs.addHeader(name, value);
+headersBuilder.addHeader(name, value);
 }
 }
 // First stream (1) comes from a plaintext HTTP/1.1 request
 @SuppressWarnings({"rawtypes","unchecked"})
 void createPrimordialStream(Http1InitialRequest request) throws IOException {
-HttpHeadersImpl headers = createNewResponseHeaders();
+HttpHeadersBuilder headersBuilder = createNewHeadersBuilder();
 String requestLine = getRequestLine(request.headers);
 String[] tokens = requestLine.split(" ");
 if (!tokens[2].equals("HTTP/1.1")) {
 throw new IOException("bad request line");
 }
 String host = getHeader(request.headers, "Host");
 if (host == null) {
 throw new IOException("missing Host");
 }
-headers.setHeader(":method", tokens[0]);
+headersBuilder.setHeader(":method", tokens[0]);
-headers.setHeader(":scheme", "http"); // always in this case
+headersBuilder.setHeader(":scheme", "http"); // always in this case
-headers.setHeader(":authority", host);
+headersBuilder.setHeader(":authority", host);
 String path = uri.getRawPath();
 if (uri.getRawQuery() != null)
 path = path + "?" + uri.getRawQuery();
-headers.setHeader(":path", path);
+headersBuilder.setHeader(":path", path);
 Queue q = new Queue(sentinel);
 byte[] body = getRequestBody(request);
-addHeaders(getHeaders(request.headers), headers);
+addHeaders(getHeaders(request.headers), headersBuilder);
-headers.setHeader("Content-length", Integer.toString(body.length));
+headersBuilder.setHeader("Content-length", Integer.toString(body.length));
+HttpHeaders headers = headersBuilder.build();
 addRequestBodyToQueue(body, q);
 streams.put(1, q);
 exec.submit(() -> {
 handleRequest(headers, q, 1, true /*complete request has been read*/);
 }
 frames.add(frame);
 }
 }
 boolean endStreamReceived = endStream;
-HttpHeadersImpl headers = decodeHeaders(frames);
+HttpHeaders headers = decodeHeaders(frames);
 // Strict to assert Client correctness. Not all servers are as strict,
 // but some are known to be.
 Optional<?> disallowedHeader = headers.firstValue("Upgrade");
 if (disallowedHeader.isPresent()) {
 // runs in own thread. Handles request from start to finish. Incoming frames
 // for this stream/request delivered on Q
 @SuppressWarnings({"rawtypes","unchecked"})
-void handleRequest(HttpHeadersImpl headers,
+void handleRequest(HttpHeaders headers,
 Queue queue,
 int streamid,
 boolean endStreamReceived)
 {
 String method = headers.firstValue(":method").orElse("");
 String scheme = headers.firstValue(":scheme").orElse("");
 //System.out.println("scheme = " + scheme);
 String authority = headers.firstValue(":authority").orElse("");
 //System.out.println("authority = " + authority);
 System.err.printf("TestServer: %s %s\n", method, path);
-HttpHeadersImpl rspheaders = createNewResponseHeaders();
 int winsize = clientSettings.getParameter(
 SettingsFrame.INITIAL_WINDOW_SIZE);
 //System.err.println ("Stream window size = " + winsize);
 final InputStream bis;
 {
 outStreams.put(streamid, bos);
 String us = scheme + "://" + authority + path;
 URI uri = new URI(us);
 boolean pushAllowed = clientSettings.getParameter(SettingsFrame.ENABLE_PUSH) == 1;
+HttpHeadersBuilder rspheadersBuilder = createNewHeadersBuilder();
 Http2TestExchange exchange = exchangeSupplier.get(streamid, method,
-headers, rspheaders, uri, bis, getSSLSession(),
+headers, rspheadersBuilder, uri, bis, getSSLSession(),
 bos, this, pushAllowed);
 // give to user
 Http2Handler handler = server.getHandlerFor(uri.getPath());
 try {
 e.printStackTrace();
 close(-1);
 }
 }
-protected HttpHeadersImpl createNewResponseHeaders() {
+protected HttpHeadersBuilder createNewHeadersBuilder() {
-return new HttpHeadersImpl();
+return new HttpHeadersBuilder();
 }
 private SSLSession getSSLSession() {
 if (! (socket instanceof SSLSocket))
 return null;
 }
 close(ErrorFrame.PROTOCOL_ERROR);
 }
 }
-List<ByteBuffer> encodeHeaders(HttpHeadersImpl headers) {
+/** Encodes an group of headers, without any ordering guarantees. */
+List<ByteBuffer> encodeHeaders(HttpHeaders headers) {
 List<ByteBuffer> buffers = new LinkedList<>();
 ByteBuffer buf = getBuffer();
 boolean encoded;
 for (Map.Entry<String, List<String>> entry : headers.map().entrySet()) {
 buffers.add(buf);
 buf = getBuffer();
 }
 } while (!encoded);
 }
+}
+buf.flip();
+buffers.add(buf);
+return buffers;
+}
+/** Encodes an ordered list of headers. */
+List<ByteBuffer> encodeHeadersOrdered(List<Map.Entry<String,String>> headers) {
+List<ByteBuffer> buffers = new LinkedList<>();
+ByteBuffer buf = getBuffer();
+boolean encoded;
+for (Map.Entry<String, String> entry : headers) {
+String value = entry.getValue();
+String key = entry.getKey().toLowerCase();
+do {
+hpackOut.header(key, value);
+encoded = hpackOut.encode(buf);
+if (!encoded) {
+buf.flip();
+buffers.add(buf);
+buf = getBuffer();
+}
+} while (!encoded);
 }
 buf.flip();
 buffers.add(buf);
 return buffers;
 }
 }
 // returns a minimal response with status 200
 // that is the response to the push promise just sent
 private ResponseHeaders getPushResponse(int streamid) {
-HttpHeadersImpl h = createNewResponseHeaders();
+HttpHeadersBuilder hb = createNewHeadersBuilder();
-h.addHeader(":status", "200");
+hb.addHeader(":status", "200");
-ResponseHeaders oh = new ResponseHeaders(h);
+ResponseHeaders oh = new ResponseHeaders(hb.build());
 oh.streamid(streamid);
 oh.setFlag(HeaderFrame.END_HEADERS);
 return oh;
 }
 // simplified output headers class. really just a type safe container
 // for the hashmap.
 static class ResponseHeaders extends Http2Frame {
-HttpHeadersImpl headers;
+HttpHeaders headers;
-ResponseHeaders(HttpHeadersImpl headers) {
+ResponseHeaders(HttpHeaders headers) {
 super(0, 0);
 this.headers = headers;
 }
 }

branch	http-client-branch
changeset 56619	57f17e890a40
parent 56598	4c502e3991bf
child 56795	03ece2518428