Server closed the stream without sending trailers when using tomcat

[mvazquezrius]

I have tested a modified version of the grpc-server and grpc-tomcat samples, where I change the streamHello implementation to an empty response:

@Override
public void streamHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
	log.info("Hello " + req.getName());
	responseObserver.onCompleted();
}

With the grpc-server, everything works well:

grpcurl -vv -d '{"name":"Hi"}' -plaintext localhost:9090 Simple.StreamHello

Resolved method descriptor:
rpc StreamHello ( .HelloRequest ) returns ( stream .HelloReply );

Request metadata to send:
(empty)

Response headers received:
(empty)

Response trailers received:
content-type: application/grpc
Sent 1 request and received 0 responses
Timing Data: 22.73575ms
  Dial: 12.639834ms
    BlockingDial: 12.606ms
  InvokeRPC: 9.261834ms

But with tomcat the trailers are not sent:

grpcurl -vv -d '{"name":"Hi"}' -plaintext localhost:9090 Simple.StreamHello

Resolved method descriptor:
rpc StreamHello ( .HelloRequest ) returns ( stream .HelloReply );

Request metadata to send:
(empty)

Response headers received:
content-length: 0
content-type: application/grpc
date: Thu, 06 Mar 2025 18:34:11 GMT

Response trailers received:
(empty)
Sent 1 request and received 0 responses
ERROR:
  Code: Internal
  Message: server closed the stream without sending trailers

Related: grpc/grpc-java#10124

[dsyer]

It's a problem in grpc-java for sure. I'm not sure we can do anything until it is fixed there.

[dsyer]

It doesn't look like the gRPC community wants to fix this (Tomcat is not a high enough priority and the problem is actually with the clients). I found that this works:

	@Bean
	@GlobalServerInterceptor
	public ServerInterceptor globalInterceptor() {
		return this::intercept;
	}

	private <ReqT, RespT> ServerCall.Listener<ReqT> intercept(
			ServerCall<ReqT, RespT> call,
			Metadata headers,
			ServerCallHandler<ReqT, RespT> next) {
		StreamHandlerCall<ReqT, RespT> delegate = new StreamHandlerCall<>(call);
		return new StreamHandlerListener<>(delegate, next.startCall(delegate, headers));
	}

	static class StreamHandlerListener<ReqT, RespT> extends SimpleForwardingServerCallListener<ReqT> {

		private StreamHandlerCall<ReqT, RespT> call;

		private StreamHandlerListener(StreamHandlerCall<ReqT, RespT> call, Listener<ReqT> delegate) {
			super(delegate);
			this.call = call;
		}

		@Override
		public void onHalfClose() {
			RuntimeException exception = null;
			try {
				super.onHalfClose();
			} catch (RuntimeException e) {
				exception = e;
			}
			if (call.count == 0 && !call.isCancelled()) {
				Metadata trailers = exception != null ? Status.trailersFromThrowable(exception) : new Metadata();
				if (trailers == null) {
					trailers = new Metadata();
				}
				trailers.put(Metadata.Key.of("empty-stream", Metadata.ASCII_STRING_MARSHALLER), "true");
				call.sendHeaders(trailers);
			}
			if (exception != null) {
				throw exception;
			}
		}
	}

	static class StreamHandlerCall<ReqT, RespT> extends SimpleForwardingServerCall<ReqT, RespT> {

		private int count = 0;

		protected StreamHandlerCall(ServerCall<ReqT, RespT> delegate) {
			super(delegate);
		}

		@Override
		public void sendMessage(RespT message) {
			this.count++;
			super.sendMessage(message);
		}

		@Override
		public void close(Status status, Metadata trailers) {
			if (this.count == 0 && !isCancelled()) {
				trailers.put(Metadata.Key.of("empty-stream", Metadata.ASCII_STRING_MARSHALLER), "true");
				sendHeaders(trailers);
			}
			super.close(status, trailers);
		}

	}

Not sure if we should do that or not yet.