Server code for the interoperability tests of the grpc-web repo.

https://github.com/grpc/grpc-web/blob/a639b4cf2611de2b68883571787083b73cf61f5e/doc/interop-test-descriptions.md

All tests pass using manual verification

Signed-off-by: Thomas Segismont <tsegismont@gmail.com>

Author: tsegismont

vertx-grpc-server/src/test/java/io/vertx/grpc/server/web/interop/Interceptor.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2011-2024 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+ * which is available at https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+ */
+
+package io.vertx.grpc.server.web.interop;
+
+import io.grpc.*;
+import io.grpc.Metadata.Key;
+
+import java.util.Collections;
+import java.util.Set;
+
+import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
+import static io.grpc.Metadata.BINARY_BYTE_MARSHALLER;
+
+class Interceptor implements ServerInterceptor {
+
+  private static final Key<String> ECHO_INITIAL_KEY = Key.of("x-grpc-test-echo-initial", ASCII_STRING_MARSHALLER);
+  private static final Set<Key<?>> HEADERS_KEY_SET = Collections.singleton(ECHO_INITIAL_KEY);
+  private static final Key<byte[]> ECHO_TRAILING_KEY = Key.of("x-grpc-test-echo-trailing-bin", BINARY_BYTE_MARSHALLER);
+  private static final Set<Key<?>> TRAILERS_KEY_SET = Collections.singleton(ECHO_TRAILING_KEY);
+
+  @Override
+  public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata metadata, ServerCallHandler<ReqT, RespT> next) {
+    return next.startCall(new ForwardingServerCall.SimpleForwardingServerCall<ReqT, RespT>(call) {
+
+      @Override
+      public void sendHeaders(Metadata headers) {
+        headers.merge(metadata, HEADERS_KEY_SET);
+        super.sendHeaders(headers);
+      }
+
+      @Override
+      public void close(Status status, Metadata trailers) {
+        trailers.merge(metadata, TRAILERS_KEY_SET);
+        super.close(status, trailers);
+      }
+    }, metadata);
+  }
+}

vertx-grpc-server/src/test/java/io/vertx/grpc/server/web/interop/InteropServer.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2011-2024 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+ * which is available at https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+ */
+
+package io.vertx.grpc.server.web.interop;
+
+import io.grpc.ServerInterceptors;
+import io.grpc.ServerServiceDefinition;
+import io.vertx.core.AbstractVerticle;
+import io.vertx.core.Promise;
+import io.vertx.core.Vertx;
+import io.vertx.grpc.server.GrpcServer;
+import io.vertx.grpc.server.GrpcServerOptions;
+import io.vertx.grpc.server.GrpcServiceBridge;
+
+/**
+ * A gRPC-Web server for grpc-web interop tests.
+ */
+public class InteropServer extends AbstractVerticle {
+
+  public static void main(String[] args) {
+    Vertx vertx = Vertx.vertx();
+    vertx.deployVerticle(new InteropServer())
+      .onFailure(Throwable::printStackTrace)
+      .onSuccess(v -> System.out.println("Deployed InteropServer"));
+  }
+
+  @Override
+  public void start(Promise<Void> startPromise) {
+    GrpcServer grpcServer = GrpcServer.server(vertx, new GrpcServerOptions().setGrpcWebEnabled(true));
+
+    ServerServiceDefinition serviceDefinition = ServerInterceptors.intercept(new TestServiceImpl(vertx), new Interceptor());
+    GrpcServiceBridge.bridge(serviceDefinition).bind(grpcServer);
+
+    vertx.createHttpServer()
+      .requestHandler(grpcServer)
+      .listen(8080)
+      .<Void>mapEmpty()
+      .onComplete(startPromise);
+  }
+}

vertx-grpc-server/src/test/java/io/vertx/grpc/server/web/interop/TestServiceImpl.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2011-2024 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+ * which is available at https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+ */
+
+package io.vertx.grpc.server.web.interop;
+
+import com.google.protobuf.ByteString;
+import grpc.testing.EmptyOuterClass;
+import grpc.testing.Messages;
+import grpc.testing.TestServiceGrpc;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.stub.StreamObserver;
+import io.vertx.core.Future;
+import io.vertx.core.Promise;
+import io.vertx.core.Vertx;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.concurrent.TimeUnit.MICROSECONDS;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+class TestServiceImpl extends TestServiceGrpc.TestServiceImplBase {
+
+  private final Vertx vertx;
+
+  TestServiceImpl(Vertx vertx) {
+    this.vertx = vertx;
+  }
+
+  @Override
+  public void emptyCall(EmptyOuterClass.Empty request, StreamObserver<EmptyOuterClass.Empty> responseObserver) {
+    responseObserver.onNext(EmptyOuterClass.Empty.newBuilder().build());
+    responseObserver.onCompleted();
+  }
+
+  @Override
+  public void unaryCall(Messages.SimpleRequest request, StreamObserver<Messages.SimpleResponse> responseObserver) {
+    if (request.hasResponseStatus()) {
+      Messages.EchoStatus echoStatus = request.getResponseStatus();
+      Status status = Status.fromCodeValue(echoStatus.getCode())
+        .withDescription(echoStatus.getMessage());
+      responseObserver.onError(new StatusException(status));
+      return;
+    }
+    Messages.Payload payload = Messages.Payload.newBuilder()
+      .setTypeValue(request.getResponseTypeValue())
+      .setBody(ByteString.copyFrom(new byte[request.getResponseSize()]))
+      .build();
+    Messages.SimpleResponse response = Messages.SimpleResponse.newBuilder()
+      .setPayload(payload)
+      .build();
+    responseObserver.onNext(response);
+    responseObserver.onCompleted();
+  }
+
+  @Override
+  public void streamingOutputCall(Messages.StreamingOutputCallRequest request, StreamObserver<Messages.StreamingOutputCallResponse> responseObserver) {
+    List<Future<Void>> futures = new ArrayList<>(request.getResponseParametersCount());
+    long delay = 0;
+    for (Messages.ResponseParameters parameters : request.getResponseParametersList()) {
+      delay += Math.max(1, MILLISECONDS.convert(parameters.getIntervalUs(), MICROSECONDS));
+      Promise<Void> promise = Promise.promise();
+      vertx.setTimer(delay, l -> {
+        Messages.Payload payload = Messages.Payload.newBuilder()
+          .setType(request.getResponseType())
+          .setBody(ByteString.copyFrom(new byte[parameters.getSize()]))
+          .build();
+        Messages.StreamingOutputCallResponse response = Messages.StreamingOutputCallResponse.newBuilder()
+          .setPayload(payload)
+          .build();
+        responseObserver.onNext(response);
+        promise.complete();
+      });
+      futures.add(promise.future());
+    }
+    Future.join(futures).onComplete(v -> responseObserver.onCompleted());
+  }
+}