chore(implementation)!: use Jetty-12 core without servlets

Port the invoker to upgrade to Eclipse Jetty-12 version 12.  Specifically using the new core APIs of Eclipse Jetty-12 that allow the overhead of a Servlet container to be avoided.   Several optimizations are included, including the optimization that small writes can be buffered in such a way to avoid chunked responses when possible.

BREAKING CHANGE: use Java 17 or above, as required by Eclipse Jetty-12.

Author: gregw

invoker/core/src/main/java/com/google/cloud/functions/invoker/http/HttpResponseImpl.java

@@ -116,9 +116,7 @@ public synchronized BufferedWriter getWriter() throws IOException {
    */
   public void close(Callback callback) {
     try {
-      if (writer != null) {
-        writer.flush();
-      }
+      // The writer has been constructed to do no buffering, so it does not need to be flushed
       if (contentSinkOutputStream != null) {
         // Do an asynchronous close, so large buffered content may be written without blocking
         contentSinkOutputStream.close(callback);

invoker/core/src/test/java/com/google/cloud/functions/invoker/IntegrationTest.java

@@ -167,6 +167,8 @@ abstract static class TestCase {
 
     abstract int expectedResponseCode();
 
+    abstract Optional<Map<String, String>> expectedResponseHeaders();
+
     abstract Optional<String> expectedResponseText();
 
     abstract Optional<JsonObject> expectedJson();
@@ -186,6 +188,7 @@ static Builder builder() {
           .setUrl("/")
           .setRequestText("")
           .setExpectedResponseCode(HttpStatus.OK_200)
+          .setExpectedResponseHeaders(ImmutableMap.of())
           .setExpectedResponseText("")
           .setHttpContentType("text/plain")
           .setHttpHeaders(ImmutableMap.of());
@@ -204,6 +207,8 @@ Builder setRequestText(String text) {
 
       abstract Builder setExpectedResponseCode(int x);
 
+      abstract Builder setExpectedResponseHeaders(Map<String, String> x);
+
       abstract Builder setExpectedResponseText(String x);
 
       abstract Builder setExpectedResponseText(Optional<String> x);
@@ -249,11 +254,44 @@ public void helloWorld() throws Exception {
     testHttpFunction(
         fullTarget("HelloWorld"),
         ImmutableList.of(
-            TestCase.builder().setExpectedResponseText("hello\n").build(),
+            TestCase.builder()
+                .setExpectedResponseText("hello\n")
+                .setHttpHeaders(ImmutableMap.of(
+                    "Content-Length", "*"))
+                .build(),
             FAVICON_TEST_CASE,
             ROBOTS_TXT_TEST_CASE));
   }
 
+  @Test
+  public void bufferedWrites() throws Exception {
+    // This test checks that writes are buffered and are written
+    // in an efficient way with known content-length if possible.
+    testHttpFunction(
+        fullTarget("BufferedWrites"),
+        ImmutableList.of(
+            TestCase.builder()
+                .setUrl("/target?writes=2")
+                .setExpectedResponseText("write 0\nwrite 1\n")
+                .setExpectedResponseHeaders(ImmutableMap.of(
+                    "x-write-0", "true",
+                    "x-write-1", "true",
+                    "x-written", "true",
+                    "Content-Length", "16"
+                ))
+                .build(),
+            TestCase.builder()
+                .setUrl("/target?writes=2&flush=true")
+                .setExpectedResponseText("write 0\nwrite 1\n")
+                .setExpectedResponseHeaders(ImmutableMap.of(
+                    "x-write-0", "true",
+                    "x-write-1", "true",
+                    "x-written", "-",
+                    "Transfer-Encoding", "chunked"))
+                .build()
+        ));
+  }
+
   @Test
   public void exceptionHttp() throws Exception {
     String exceptionExpectedOutput =
@@ -696,6 +734,17 @@ private void testFunction(
             .withMessage("Response to %s is %s %s", uri, response.getStatus(), response.getReason())
             .that(response.getStatus())
             .isEqualTo(testCase.expectedResponseCode());
+        testCase.expectedResponseHeaders().ifPresent(map -> {
+          for (Map.Entry<String, String> entry : map.entrySet()) {
+            if ("*".equals(entry.getValue())) {
+              expect.that(response.getHeaders().getFieldNamesCollection()).contains(entry.getKey());
+            } else if ("-".equals(entry.getValue())) {
+              expect.that(response.getHeaders().getFieldNamesCollection()).doesNotContain(entry.getKey());
+            } else {
+              expect.that(response.getHeaders().getValuesList(entry.getKey())).contains(entry.getValue());
+            }
+          }
+        });
         testCase
             .expectedResponseText()
             .ifPresent(text -> expect.that(response.getContentAsString()).isEqualTo(text));

invoker/core/src/test/java/com/google/cloud/functions/invoker/testfunctions/BufferedWrites.java

@@ -0,0 +1,27 @@
+package com.google.cloud.functions.invoker.testfunctions;
+
+import com.google.cloud.functions.HttpFunction;
+import com.google.cloud.functions.HttpRequest;
+import com.google.cloud.functions.HttpResponse;
+import java.io.BufferedWriter;
+import java.util.List;
+import java.util.Map;
+
+public class BufferedWrites implements HttpFunction {
+  @Override
+  public void service(HttpRequest request, HttpResponse response) throws Exception {
+    Map<String, List<String>> queryParameters = request.getQueryParameters();
+    int writes = Integer.parseInt(request.getFirstQueryParameter("writes").orElse("0"));
+    boolean flush = Boolean.parseBoolean(request.getFirstQueryParameter("flush").orElse("false"));
+
+    BufferedWriter writer = response.getWriter();
+    for (int i = 0; i < writes; i++) {
+      response.appendHeader("x-write-" + i, "true");
+      writer.write("write " + i + "\n");
+    }
+    if (flush) {
+      writer.flush();
+    }
+    response.appendHeader("x-written", "true");
+  }
+}