kenix / http-grpc-spring-web

http-grpc transcoder with spring-web

http-grpc-spring-web

A simplistic spring-web component that automatically configures spring-mvc controllers that transcodes HTTP requests, invokes corresponding gRPC service method and transcodes the reply back to HTTP response, with little configuration. Inspired by envoy HTTP to gRPC transcoder.

Usage

Show me how: refer to the module example with its tests.

Dependency

Maven:

<dependency>
  <groupId>io.github.kenix</groupId>
  <artifactId>http-grpc-spring-web</artifactId>
  <version>0.1.0-rc.4</version>
</dependency>

Gradle:

dependencies {
  implementation 'io.github.kenix:http-grpc-spring-web:0.1.0-rc.4'
}

Plumbing

After implementing a gRPC service, provide following beans:

HttpGrpcMapper responsible for discovering gRPC services and registering transcoder controllers

GrpcServerDescriptor used by HttpGrpcMapper to discover gRPC services. Currently, only support single server. If necessary, can easily support multiple servers.

• List<FileDescriptor> is mandatory in order to find all message types of gRPC requests. TODO: either injection or enabling ProtoReflectionService

• one of following alternatives:

  1. List<ServerMethodDefinition> transcoded call is made directly

  2. gRPC server port and one of following:

     1. a gRPC global server interceptor ServerMethodDefinitionInterceptor and enabling gRPC HealthService Invoked the first time (service health check) it will collect all ServerMethodDefinitions, after that only forward calls. This enables direct transcoded calls.
     2. nothing else, transcoded call will not be direct, but routed internally using an embedded gRPC client. This has performance impact.

Integration

• distributed tracing: out of the box with spring-cloud-starter-sleuth, see also module client

TODO

Refer to open issues.

http-grpc-spring-web's Issues

fulfill sona publish requirements - pom version range

Should use mathematical version range instead of +

support http rule '/v1/{name=messages/*}'

Most probably via SimpleUrlHandlerMapping, for http.proto:

// Example:
//
//     service Messaging {
//       rpc GetMessage(GetMessageRequest) returns (Message) {
//         option (google.api.http) = {
//             get: "/v1/{name=messages/*}"
//         };
//       }
//     }
//     message GetMessageRequest {
//       string name = 1; // Mapped to URL path.
//     }
//     message Message {
//       string text = 1; // The resource content.
//     }
//
// This enables an HTTP REST to gRPC mapping as below:
//
// HTTP | gRPC
// -----|-----
// `GET /v1/messages/123456`  | `GetMessage(name: "messages/123456")`

integrate metrics

Optionally via micrometer e.g. when it's available.

do initial commit

Extract experiment codes into auto-configuration java-library and make it available.

check integration with spring-security

Most probably via HTTP headers and gRPC Metadata (headers).

integrate distributed tracing

Most probably via HTTP headers and gRPC Metadata (headers)

handle DELETE correctly

Regarding HTTP response status

support more reasonable HTTP status

Depending on

1. gRPC method name
2. additional annotation?

support server streaming via SSE

Probably via spring-web async for SSE