Use String instead of MethodDescriptor in ServerCallHandler.
Using MethodDescriptor before was abusive, but the alternative was not
clear.
The new gRPC protocol causes things to become more obvious. Headers,
method name, and timeout were the interesting things on the
MethodDescriptor. In the new protocol, headers are no longer going to be
treated differently from context. We are fine with passing the method
name. So that leaves just timeout, which we really will need more
methods for on the ServerCall object anyway.
-------------
Created by MOE: http://code.google.com/p/moe-java
MOE_MIGRATED_REVID=74889759
diff --git a/core/src/main/java/com/google/net/stubby/ServerCallHandler.java b/core/src/main/java/com/google/net/stubby/ServerCallHandler.java
index 065a7b9..ad4229c 100644
--- a/core/src/main/java/com/google/net/stubby/ServerCallHandler.java
+++ b/core/src/main/java/com/google/net/stubby/ServerCallHandler.java
@@ -16,10 +16,9 @@
* Implementations must not throw an exception if they started processing that may use {@code
* call} on another thread.
*
- * @param method metadata concerning the call
+ * @param fullMethodName full method name of call
* @param call object for responding
* @return listener for processing incoming messages for {@code call}
*/
- ServerCall.Listener<ReqT> startCall(MethodDescriptor<ReqT, RespT> method,
- ServerCall<RespT> call);
+ ServerCall.Listener<ReqT> startCall(String fullMethodName, ServerCall<RespT> call);
}
diff --git a/core/src/main/java/com/google/net/stubby/ServerInterceptor.java b/core/src/main/java/com/google/net/stubby/ServerInterceptor.java
index 5dade5e..a1709e9 100644
--- a/core/src/main/java/com/google/net/stubby/ServerInterceptor.java
+++ b/core/src/main/java/com/google/net/stubby/ServerInterceptor.java
@@ -15,11 +15,11 @@
* Implementations must not throw an exception if they started processing that may use {@code
* call} on another thread.
*
- * @param method metadata concerning the call
+ * @param method full method name of the call
* @param call object for responding
* @param next next processor in the interceptor chain
* @return listener for processing incoming messages for {@code call}
*/
- <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(MethodDescriptor<ReqT, RespT> method,
- ServerCall<RespT> call, ServerCallHandler<ReqT, RespT> next);
+ <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(String method, ServerCall<RespT> call,
+ ServerCallHandler<ReqT, RespT> next);
}
diff --git a/core/src/main/java/com/google/net/stubby/ServerInterceptors.java b/core/src/main/java/com/google/net/stubby/ServerInterceptors.java
index 8afc5d4..318da03 100644
--- a/core/src/main/java/com/google/net/stubby/ServerInterceptors.java
+++ b/core/src/main/java/com/google/net/stubby/ServerInterceptors.java
@@ -58,8 +58,7 @@
}
@Override
- public ServerCall.Listener<ReqT> startCall(MethodDescriptor<ReqT, RespT> method,
- ServerCall<RespT> call) {
+ public ServerCall.Listener<ReqT> startCall(String method, ServerCall<RespT> call) {
return ProcessInterceptorsCallHandler.create(interceptors.iterator(), callHandler)
.startCall(method, call);
}
@@ -82,8 +81,7 @@
}
@Override
- public ServerCall.Listener<ReqT> startCall(MethodDescriptor<ReqT, RespT> method,
- ServerCall<RespT> call) {
+ public ServerCall.Listener<ReqT> startCall(String method, ServerCall<RespT> call) {
if (interceptors != null && interceptors.hasNext()) {
return interceptors.next().interceptCall(method, call, this);
} else {
diff --git a/core/src/main/java/com/google/net/stubby/newtransport/ServerTransportListener.java b/core/src/main/java/com/google/net/stubby/newtransport/ServerTransportListener.java
index 7952067..7453968 100644
--- a/core/src/main/java/com/google/net/stubby/newtransport/ServerTransportListener.java
+++ b/core/src/main/java/com/google/net/stubby/newtransport/ServerTransportListener.java
@@ -11,8 +11,8 @@
* Called when a new stream was created by the remote client.
*
* @param stream the newly created stream.
- * @param method the method being called on the server.
+ * @param method the full method name being called on the server.
* @return a listener for events on the new stream.
*/
- StreamListener streamCreated(ServerStream stream, MethodDescriptor<?, ?> method);
+ StreamListener streamCreated(ServerStream stream, String method);
}
diff --git a/core/src/main/java/com/google/net/stubby/newtransport/netty/NettyServerHandler.java b/core/src/main/java/com/google/net/stubby/newtransport/netty/NettyServerHandler.java
index 3609b24..e857a6c 100644
--- a/core/src/main/java/com/google/net/stubby/newtransport/netty/NettyServerHandler.java
+++ b/core/src/main/java/com/google/net/stubby/newtransport/netty/NettyServerHandler.java
@@ -5,7 +5,6 @@
import static com.google.net.stubby.newtransport.HttpUtil.HTTP_METHOD;
import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableMap;
import com.google.net.stubby.MethodDescriptor;
import com.google.net.stubby.Status;
import com.google.net.stubby.newtransport.ServerTransportListener;
@@ -32,13 +31,10 @@
import io.netty.util.ReferenceCountUtil;
import java.util.List;
-import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
-import javax.inject.Provider;
-
/**
* Server-side Netty handler for GRPC processing. All event handlers are executed entirely within
* the context of the Netty Channel thread.
@@ -86,7 +82,7 @@
// The Http2Stream object was put by AbstractHttp2ConnectionHandler before calling this method.
Http2Stream http2Stream = connection().requireStream(streamId);
http2Stream.data(stream);
- MethodDescriptor<?, ?> method = createMethod(streamId, headers);
+ String method = determineMethod(streamId, headers);
StreamListener listener = transportListener.streamCreated(stream, method);
stream.setListener(listener);
} catch (Http2Exception e) {
@@ -188,7 +184,7 @@
}
}
- private MethodDescriptor<?, ?> createMethod(int streamId, Http2Headers headers)
+ private String determineMethod(int streamId, Http2Headers headers)
throws Http2StreamException {
if (!HTTP_METHOD.equals(headers.method())) {
throw new Http2StreamException(streamId, Http2Error.REFUSED_STREAM,
@@ -204,24 +200,7 @@
throw new Http2StreamException(streamId, Http2Error.REFUSED_STREAM,
String.format("Malformatted path: %s", headers.path()));
}
- // TODO(user): pass the real timeout
- MethodDescriptor<?, ?> method = MethodDescriptor.create(
- MethodDescriptor.Type.UNKNOWN, methodName, 1, TimeUnit.SECONDS, null, null);
- ImmutableMap.Builder<String, Provider<String>> grpcHeaders =
- new ImmutableMap.Builder<String, Provider<String>>();
- for (Map.Entry<String, String> header : headers) {
- if (!header.getKey().startsWith(":")) {
- final String value = header.getValue();
- // headers starting with ":" are reserved for HTTP/2 built-in headers
- grpcHeaders.put(header.getKey(), new Provider<String>() {
- @Override
- public String get() {
- return value;
- }
- });
- }
- }
- return method.withHeaders(grpcHeaders.build());
+ return methodName;
}
/**
diff --git a/core/src/main/java/com/google/net/stubby/newtransport/netty/Utils.java b/core/src/main/java/com/google/net/stubby/newtransport/netty/Utils.java
index a06e056..9119460 100644
--- a/core/src/main/java/com/google/net/stubby/newtransport/netty/Utils.java
+++ b/core/src/main/java/com/google/net/stubby/newtransport/netty/Utils.java
@@ -1,9 +1,15 @@
package com.google.net.stubby.newtransport.netty;
+import com.google.common.collect.ImmutableMap;
+
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
+import io.netty.handler.codec.http2.Http2Headers;
import java.nio.ByteBuffer;
+import java.util.Map;
+
+import javax.inject.Provider;
/**
* Common utility methods.
@@ -19,6 +25,24 @@
return buf;
}
+ public static ImmutableMap<String, Provider<String>> convertHeaders(Http2Headers headers) {
+ ImmutableMap.Builder<String, Provider<String>> grpcHeaders =
+ new ImmutableMap.Builder<String, Provider<String>>();
+ for (Map.Entry<String, String> header : headers) {
+ if (!header.getKey().startsWith(":")) {
+ final String value = header.getValue();
+ // headers starting with ":" are reserved for HTTP/2 built-in headers
+ grpcHeaders.put(header.getKey(), new Provider<String>() {
+ @Override
+ public String get() {
+ return value;
+ }
+ });
+ }
+ }
+ return grpcHeaders.build();
+ }
+
private Utils() {
// Prevents instantiation
}
diff --git a/core/src/test/java/com/google/net/stubby/ServerInterceptorsTest.java b/core/src/test/java/com/google/net/stubby/ServerInterceptorsTest.java
index f805af6..78d9f3d 100644
--- a/core/src/test/java/com/google/net/stubby/ServerInterceptorsTest.java
+++ b/core/src/test/java/com/google/net/stubby/ServerInterceptorsTest.java
@@ -38,7 +38,7 @@
private ServerCallHandler<String, Integer> handler
= (ServerCallHandler<String, Integer>) mock(ServerCallHandler.class);
@Mock private ServerCall.Listener<String> listener;
- @Mock private MethodDescriptor<String, Integer> methodDescriptor;
+ private String methodName = "/someRandom.Name";
@Mock private ServerCall<Integer> call;
private ServerServiceDefinition serviceDefinition = ServerServiceDefinition.builder("basic")
.addMethod("flow", requestMarshaller, responseMarshaller, handler).build();
@@ -46,8 +46,7 @@
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- Mockito.when(handler.startCall(
- Mockito.<MethodDescriptor<String, Integer>>any(), Mockito.<ServerCall<Integer>>any()))
+ Mockito.when(handler.startCall(Mockito.<String>any(), Mockito.<ServerCall<Integer>>any()))
.thenReturn(listener);
}
@@ -56,7 +55,6 @@
verifyZeroInteractions(requestMarshaller);
verifyZeroInteractions(responseMarshaller);
verifyZeroInteractions(listener);
- verifyZeroInteractions(methodDescriptor);
}
@Test(expected = NullPointerException.class)
@@ -86,16 +84,16 @@
ServerServiceDefinition intercepted
= ServerInterceptors.intercept(serviceDefinition, Arrays.asList(interceptor));
assertSame(listener,
- getSoleMethod(intercepted).getServerCallHandler().startCall(methodDescriptor, call));
- verify(interceptor).interceptCall(same(methodDescriptor), same(call), anyCallHandler());
- verify(handler).startCall(methodDescriptor, call);
+ getSoleMethod(intercepted).getServerCallHandler().startCall(methodName, call));
+ verify(interceptor).interceptCall(same(methodName), same(call), anyCallHandler());
+ verify(handler).startCall(methodName, call);
verifyNoMoreInteractions(interceptor, handler);
assertSame(listener,
- getSoleMethod(intercepted).getServerCallHandler().startCall(methodDescriptor, call));
+ getSoleMethod(intercepted).getServerCallHandler().startCall(methodName, call));
verify(interceptor, times(2))
- .interceptCall(same(methodDescriptor), same(call), anyCallHandler());
- verify(handler, times(2)).startCall(methodDescriptor, call);
+ .interceptCall(same(methodName), same(call), anyCallHandler());
+ verify(handler, times(2)).startCall(methodName, call);
verifyNoMoreInteractions(interceptor, handler);
}
@@ -108,13 +106,13 @@
.addMethod("flow2", requestMarshaller, responseMarshaller, handler2).build();
ServerServiceDefinition intercepted = ServerInterceptors.intercept(
serviceDefinition, Arrays.<ServerInterceptor>asList(new NoopInterceptor()));
- getMethod(intercepted, "flow").getServerCallHandler().startCall(methodDescriptor, call);
- verify(handler).startCall(methodDescriptor, call);
+ getMethod(intercepted, "flow").getServerCallHandler().startCall(methodName, call);
+ verify(handler).startCall(methodName, call);
verifyNoMoreInteractions(handler);
verifyZeroInteractions(handler2);
- getMethod(intercepted, "flow2").getServerCallHandler().startCall(methodDescriptor, call);
- verify(handler2).startCall(methodDescriptor, call);
+ getMethod(intercepted, "flow2").getServerCallHandler().startCall(methodName, call);
+ verify(handler2).startCall(methodName, call);
verifyNoMoreInteractions(handler);
verifyNoMoreInteractions(handler2);
}
@@ -124,26 +122,23 @@
final List<String> order = new ArrayList<String>();
handler = new ServerCallHandler<String, Integer>() {
@Override
- public ServerCall.Listener<String> startCall(MethodDescriptor<String, Integer> method,
- ServerCall<Integer> call) {
+ public ServerCall.Listener<String> startCall(String method, ServerCall<Integer> call) {
order.add("handler");
return listener;
}
};
ServerInterceptor interceptor1 = new ServerInterceptor() {
@Override
- public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
- MethodDescriptor<ReqT, RespT> method, ServerCall<RespT> call,
- ServerCallHandler<ReqT, RespT> next) {
+ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(String method,
+ ServerCall<RespT> call, ServerCallHandler<ReqT, RespT> next) {
order.add("i1");
return next.startCall(method, call);
}
};
ServerInterceptor interceptor2 = new ServerInterceptor() {
@Override
- public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
- MethodDescriptor<ReqT, RespT> method, ServerCall<RespT> call,
- ServerCallHandler<ReqT, RespT> next) {
+ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(String method,
+ ServerCall<RespT> call, ServerCallHandler<ReqT, RespT> next) {
order.add("i2");
return next.startCall(method, call);
}
@@ -153,30 +148,26 @@
ServerServiceDefinition intercepted = ServerInterceptors.intercept(
serviceDefinition, Arrays.asList(interceptor1, interceptor2));
assertSame(listener,
- getSoleMethod(intercepted).getServerCallHandler().startCall(methodDescriptor, call));
+ getSoleMethod(intercepted).getServerCallHandler().startCall(methodName, call));
assertEquals(Arrays.asList("i1", "i2", "handler"), order);
}
@Test
public void argumentsPassed() {
- @SuppressWarnings("unchecked")
- final MethodDescriptor<String, Integer> method2 = mock(MethodDescriptor.class);
+ final String method2 = "/someOtherRandom.Method";
@SuppressWarnings("unchecked")
final ServerCall<Integer> call2 = mock(ServerCall.class);
@SuppressWarnings("unchecked")
final ServerCall.Listener<String> listener2 = mock(ServerCall.Listener.class);
ServerInterceptor interceptor = new ServerInterceptor() {
@Override
- public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
- MethodDescriptor<ReqT, RespT> method, ServerCall<RespT> call,
- ServerCallHandler<ReqT, RespT> next) {
- assertSame(method, methodDescriptor);
+ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(String method,
+ ServerCall<RespT> call, ServerCallHandler<ReqT, RespT> next) {
+ assertSame(method, methodName);
assertSame(call, ServerInterceptorsTest.this.call);
@SuppressWarnings("unchecked")
- MethodDescriptor<ReqT, RespT> method2Typed = (MethodDescriptor<ReqT, RespT>) method2;
- @SuppressWarnings("unchecked")
ServerCall<RespT> call2Typed = (ServerCall<RespT>) call2;
- assertSame(listener, next.startCall(method2Typed, call2Typed));
+ assertSame(listener, next.startCall(method2, call2Typed));
@SuppressWarnings("unchecked")
ServerCall.Listener<ReqT> listener2Typed = (ServerCall.Listener<ReqT>) listener2;
return listener2Typed;
@@ -185,7 +176,7 @@
ServerServiceDefinition intercepted = ServerInterceptors.intercept(
serviceDefinition, Arrays.asList(interceptor));
assertSame(listener2,
- getSoleMethod(intercepted).getServerCallHandler().startCall(methodDescriptor, call));
+ getSoleMethod(intercepted).getServerCallHandler().startCall(methodName, call));
verify(handler).startCall(method2, call2);
}
@@ -210,9 +201,8 @@
private static class NoopInterceptor implements ServerInterceptor {
@Override
- public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
- MethodDescriptor<ReqT, RespT> method, ServerCall<RespT> call,
- ServerCallHandler<ReqT, RespT> next) {
+ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(String method,
+ ServerCall<RespT> call, ServerCallHandler<ReqT, RespT> next) {
return next.startCall(method, call);
}
}
diff --git a/core/src/test/java/com/google/net/stubby/newtransport/netty/NettyServerHandlerTest.java b/core/src/test/java/com/google/net/stubby/newtransport/netty/NettyServerHandlerTest.java
index 91371d4..1aa20dc 100644
--- a/core/src/test/java/com/google/net/stubby/newtransport/netty/NettyServerHandlerTest.java
+++ b/core/src/test/java/com/google/net/stubby/newtransport/netty/NettyServerHandlerTest.java
@@ -12,7 +12,6 @@
import static org.mockito.Mockito.when;
import com.google.common.io.ByteStreams;
-import com.google.net.stubby.MethodDescriptor;
import com.google.net.stubby.Status;
import com.google.net.stubby.newtransport.Framer;
import com.google.net.stubby.newtransport.HttpUtil;
@@ -74,7 +73,7 @@
public void setup() throws Exception {
MockitoAnnotations.initMocks(this);
- when(transportListener.streamCreated(any(ServerStream.class), any(MethodDescriptor.class)))
+ when(transportListener.streamCreated(any(ServerStream.class), any(String.class)))
.thenReturn(streamListener);
handler = newHandler(transportListener);
frameWriter = new DefaultHttp2FrameWriter();
@@ -169,7 +168,7 @@
ArgumentCaptor<NettyServerStream> streamCaptor =
ArgumentCaptor.forClass(NettyServerStream.class);
@SuppressWarnings("rawtypes")
- ArgumentCaptor<MethodDescriptor> methodCaptor = ArgumentCaptor.forClass(MethodDescriptor.class);
+ ArgumentCaptor<String> methodCaptor = ArgumentCaptor.forClass(String.class);
verify(transportListener).streamCreated(streamCaptor.capture(), methodCaptor.capture());
stream = streamCaptor.getValue();
}