{
+ private TestServiceBlockingStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected TestServiceBlockingStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new TestServiceBlockingStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * One empty request followed by one empty response.
+ *
+ */
+ public io.grpc.testing.integration.EmptyProtos.Empty emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+ return blockingUnaryCall(
+ getChannel(), getEmptyCallMethod(), getCallOptions(), request);
+ }
+
+ /**
+ *
+ * One request followed by one response.
+ *
+ */
+ public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) {
+ return blockingUnaryCall(
+ getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+ }
+
+ /**
+ *
+ * One request followed by one response. Response has cache control
+ * headers set such that a caching HTTP proxy (such as GFE) can
+ * satisfy subsequent requests.
+ *
+ */
+ public io.grpc.testing.integration.Messages.SimpleResponse cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) {
+ return blockingUnaryCall(
+ getChannel(), getCacheableUnaryCallMethod(), getCallOptions(), request);
+ }
+
+ /**
+ *
+ * One request followed by a sequence of responses (streamed download).
+ * The server returns the payload with client desired type and sizes.
+ *
+ */
+ public java.util.Iterator streamingOutputCall(
+ io.grpc.testing.integration.Messages.StreamingOutputCallRequest request) {
+ return blockingServerStreamingCall(
+ getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+ }
+
+ /**
+ *
+ * The test server will not implement this method. It will be used
+ * to test the behavior when clients call unimplemented methods.
+ *
+ */
+ public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+ return blockingUnaryCall(
+ getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+ }
+ }
+
+ /**
+ *
+ * A simple service to test the various types of RPCs and experiment with
+ * performance with various types of payload.
+ *
+ */
+ public static final class TestServiceFutureStub extends io.grpc.stub.AbstractFutureStub {
+ private TestServiceFutureStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected TestServiceFutureStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new TestServiceFutureStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * One empty request followed by one empty response.
+ *
+ */
+ public com.google.common.util.concurrent.ListenableFuture emptyCall(
+ io.grpc.testing.integration.EmptyProtos.Empty request) {
+ return futureUnaryCall(
+ getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request);
+ }
+
+ /**
+ *
+ * One request followed by one response.
+ *
+ */
+ public com.google.common.util.concurrent.ListenableFuture unaryCall(
+ io.grpc.testing.integration.Messages.SimpleRequest request) {
+ return futureUnaryCall(
+ getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request);
+ }
+
+ /**
+ *
+ * One request followed by one response. Response has cache control
+ * headers set such that a caching HTTP proxy (such as GFE) can
+ * satisfy subsequent requests.
+ *
+ */
+ public com.google.common.util.concurrent.ListenableFuture cacheableUnaryCall(
+ io.grpc.testing.integration.Messages.SimpleRequest request) {
+ return futureUnaryCall(
+ getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request);
+ }
+
+ /**
+ *
+ * The test server will not implement this method. It will be used
+ * to test the behavior when clients call unimplemented methods.
+ *
+ */
+ public com.google.common.util.concurrent.ListenableFuture unimplementedCall(
+ io.grpc.testing.integration.EmptyProtos.Empty request) {
+ return futureUnaryCall(
+ getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request);
+ }
+ }
+
+ private static final int METHODID_EMPTY_CALL = 0;
+ private static final int METHODID_UNARY_CALL = 1;
+ private static final int METHODID_CACHEABLE_UNARY_CALL = 2;
+ private static final int METHODID_STREAMING_OUTPUT_CALL = 3;
+ private static final int METHODID_UNIMPLEMENTED_CALL = 4;
+ private static final int METHODID_STREAMING_INPUT_CALL = 5;
+ private static final int METHODID_FULL_DUPLEX_CALL = 6;
+ private static final int METHODID_HALF_DUPLEX_CALL = 7;
+
+ private static final class MethodHandlers implements
+ io.grpc.stub.ServerCalls.UnaryMethod,
+ io.grpc.stub.ServerCalls.ServerStreamingMethod,
+ io.grpc.stub.ServerCalls.ClientStreamingMethod,
+ io.grpc.stub.ServerCalls.BidiStreamingMethod {
+ private final TestServiceImplBase serviceImpl;
+ private final int methodId;
+
+ MethodHandlers(TestServiceImplBase serviceImpl, int methodId) {
+ this.serviceImpl = serviceImpl;
+ this.methodId = methodId;
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
+ switch (methodId) {
+ case METHODID_EMPTY_CALL:
+ serviceImpl.emptyCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+ (io.grpc.stub.StreamObserver) responseObserver);
+ break;
+ case METHODID_UNARY_CALL:
+ serviceImpl.unaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request,
+ (io.grpc.stub.StreamObserver) responseObserver);
+ break;
+ case METHODID_CACHEABLE_UNARY_CALL:
+ serviceImpl.cacheableUnaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request,
+ (io.grpc.stub.StreamObserver) responseObserver);
+ break;
+ case METHODID_STREAMING_OUTPUT_CALL:
+ serviceImpl.streamingOutputCall((io.grpc.testing.integration.Messages.StreamingOutputCallRequest) request,
+ (io.grpc.stub.StreamObserver) responseObserver);
+ break;
+ case METHODID_UNIMPLEMENTED_CALL:
+ serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+ (io.grpc.stub.StreamObserver) responseObserver);
+ break;
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public io.grpc.stub.StreamObserver invoke(
+ io.grpc.stub.StreamObserver responseObserver) {
+ switch (methodId) {
+ case METHODID_STREAMING_INPUT_CALL:
+ return (io.grpc.stub.StreamObserver) serviceImpl.streamingInputCall(
+ (io.grpc.stub.StreamObserver) responseObserver);
+ case METHODID_FULL_DUPLEX_CALL:
+ return (io.grpc.stub.StreamObserver) serviceImpl.fullDuplexCall(
+ (io.grpc.stub.StreamObserver) responseObserver);
+ case METHODID_HALF_DUPLEX_CALL:
+ return (io.grpc.stub.StreamObserver) serviceImpl.halfDuplexCall(
+ (io.grpc.stub.StreamObserver) responseObserver);
+ default:
+ throw new AssertionError();
+ }
+ }
+ }
+
+ private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+ io.grpc.ServiceDescriptor result = serviceDescriptor;
+ if (result == null) {
+ synchronized (TestServiceGrpc.class) {
+ result = serviceDescriptor;
+ if (result == null) {
+ serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+ .addMethod(getEmptyCallMethod())
+ .addMethod(getUnaryCallMethod())
+ .addMethod(getCacheableUnaryCallMethod())
+ .addMethod(getStreamingOutputCallMethod())
+ .addMethod(getStreamingInputCallMethod())
+ .addMethod(getFullDuplexCallMethod())
+ .addMethod(getHalfDuplexCallMethod())
+ .addMethod(getUnimplementedCallMethod())
+ .build();
+ }
+ }
+ }
+ return result;
+ }
+}
diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
new file mode 100644
index 0000000000..7bc4e1c5cf
--- /dev/null
+++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
@@ -0,0 +1,283 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncUnaryCall;
+import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
+import static io.grpc.stub.ClientCalls.blockingUnaryCall;
+import static io.grpc.stub.ClientCalls.futureUnaryCall;
+import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncUnaryCall;
+import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
+
+/**
+ *
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ *
+ */
+@javax.annotation.Generated(
+ value = "by gRPC proto compiler",
+ comments = "Source: grpc/testing/test.proto")
+public final class UnimplementedServiceGrpc {
+
+ private UnimplementedServiceGrpc() {}
+
+ public static final String SERVICE_NAME = "grpc.testing.UnimplementedService";
+
+ // Static method descriptors that strictly reflect the proto.
+ private static volatile io.grpc.MethodDescriptor getUnimplementedCallMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall",
+ requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+ responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+ public static io.grpc.MethodDescriptor getUnimplementedCallMethod() {
+ io.grpc.MethodDescriptor getUnimplementedCallMethod;
+ if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) {
+ synchronized (UnimplementedServiceGrpc.class) {
+ if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) {
+ UnimplementedServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod =
+ io.grpc.MethodDescriptor.newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+ io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+ io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+ .build();
+ }
+ }
+ }
+ return getUnimplementedCallMethod;
+ }
+
+ /**
+ * Creates a new async stub that supports all call types for the service
+ */
+ public static UnimplementedServiceStub newStub(io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public UnimplementedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new UnimplementedServiceStub(channel, callOptions);
+ }
+ };
+ return UnimplementedServiceStub.newStub(factory, channel);
+ }
+
+ /**
+ * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+ */
+ public static UnimplementedServiceBlockingStub newBlockingStub(
+ io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public UnimplementedServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new UnimplementedServiceBlockingStub(channel, callOptions);
+ }
+ };
+ return UnimplementedServiceBlockingStub.newStub(factory, channel);
+ }
+
+ /**
+ * Creates a new ListenableFuture-style stub that supports unary calls on the service
+ */
+ public static UnimplementedServiceFutureStub newFutureStub(
+ io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public UnimplementedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new UnimplementedServiceFutureStub(channel, callOptions);
+ }
+ };
+ return UnimplementedServiceFutureStub.newStub(factory, channel);
+ }
+
+ /**
+ *
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ *
+ */
+ public static abstract class UnimplementedServiceImplBase implements io.grpc.BindableService {
+
+ /**
+ *
+ * A call that no server should implement
+ *
+ */
+ public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+ io.grpc.stub.StreamObserver responseObserver) {
+ asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver);
+ }
+
+ @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+ return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+ .addMethod(
+ getUnimplementedCallMethod(),
+ asyncUnaryCall(
+ new MethodHandlers<
+ io.grpc.testing.integration.EmptyProtos.Empty,
+ io.grpc.testing.integration.EmptyProtos.Empty>(
+ this, METHODID_UNIMPLEMENTED_CALL)))
+ .build();
+ }
+ }
+
+ /**
+ *
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ *
+ */
+ public static final class UnimplementedServiceStub extends io.grpc.stub.AbstractAsyncStub {
+ private UnimplementedServiceStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected UnimplementedServiceStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new UnimplementedServiceStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * A call that no server should implement
+ *
+ */
+ public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+ io.grpc.stub.StreamObserver responseObserver) {
+ asyncUnaryCall(
+ getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver);
+ }
+ }
+
+ /**
+ *
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ *
+ */
+ public static final class UnimplementedServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub {
+ private UnimplementedServiceBlockingStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected UnimplementedServiceBlockingStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new UnimplementedServiceBlockingStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * A call that no server should implement
+ *
+ */
+ public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+ return blockingUnaryCall(
+ getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+ }
+ }
+
+ /**
+ *
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ *
+ */
+ public static final class UnimplementedServiceFutureStub extends io.grpc.stub.AbstractFutureStub {
+ private UnimplementedServiceFutureStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected UnimplementedServiceFutureStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new UnimplementedServiceFutureStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * A call that no server should implement
+ *
+ */
+ public com.google.common.util.concurrent.ListenableFuture unimplementedCall(
+ io.grpc.testing.integration.EmptyProtos.Empty request) {
+ return futureUnaryCall(
+ getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request);
+ }
+ }
+
+ private static final int METHODID_UNIMPLEMENTED_CALL = 0;
+
+ private static final class MethodHandlers implements
+ io.grpc.stub.ServerCalls.UnaryMethod,
+ io.grpc.stub.ServerCalls.ServerStreamingMethod,
+ io.grpc.stub.ServerCalls.ClientStreamingMethod,
+ io.grpc.stub.ServerCalls.BidiStreamingMethod {
+ private final UnimplementedServiceImplBase serviceImpl;
+ private final int methodId;
+
+ MethodHandlers(UnimplementedServiceImplBase serviceImpl, int methodId) {
+ this.serviceImpl = serviceImpl;
+ this.methodId = methodId;
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
+ switch (methodId) {
+ case METHODID_UNIMPLEMENTED_CALL:
+ serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+ (io.grpc.stub.StreamObserver) responseObserver);
+ break;
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public io.grpc.stub.StreamObserver invoke(
+ io.grpc.stub.StreamObserver responseObserver) {
+ switch (methodId) {
+ default:
+ throw new AssertionError();
+ }
+ }
+ }
+
+ private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+ io.grpc.ServiceDescriptor result = serviceDescriptor;
+ if (result == null) {
+ synchronized (UnimplementedServiceGrpc.class) {
+ result = serviceDescriptor;
+ if (result == null) {
+ serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+ .addMethod(getUnimplementedCallMethod())
+ .build();
+ }
+ }
+ }
+ return result;
+ }
+}
diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java
new file mode 100644
index 0000000000..26ac2a72df
--- /dev/null
+++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java
@@ -0,0 +1,278 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncUnaryCall;
+import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
+import static io.grpc.stub.ClientCalls.blockingUnaryCall;
+import static io.grpc.stub.ClientCalls.futureUnaryCall;
+import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncUnaryCall;
+import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
+
+/**
+ *
+ * A service used to obtain stats for verifying LB behavior.
+ *
+ */
+@javax.annotation.Generated(
+ value = "by gRPC proto compiler",
+ comments = "Source: grpc/testing/test.proto")
+public final class LoadBalancerStatsServiceGrpc {
+
+ private LoadBalancerStatsServiceGrpc() {}
+
+ public static final String SERVICE_NAME = "grpc.testing.LoadBalancerStatsService";
+
+ // Static method descriptors that strictly reflect the proto.
+ private static volatile io.grpc.MethodDescriptor getGetClientStatsMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "GetClientStats",
+ requestType = io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.class,
+ responseType = io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+ public static io.grpc.MethodDescriptor getGetClientStatsMethod() {
+ io.grpc.MethodDescriptor getGetClientStatsMethod;
+ if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) {
+ synchronized (LoadBalancerStatsServiceGrpc.class) {
+ if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) {
+ LoadBalancerStatsServiceGrpc.getGetClientStatsMethod = getGetClientStatsMethod =
+ io.grpc.MethodDescriptor.newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClientStats"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+ io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+ io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.getDefaultInstance()))
+ .build();
+ }
+ }
+ }
+ return getGetClientStatsMethod;
+ }
+
+ /**
+ * Creates a new async stub that supports all call types for the service
+ */
+ public static LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new LoadBalancerStatsServiceStub(channel, callOptions);
+ }
+ };
+ return LoadBalancerStatsServiceStub.newStub(factory, channel);
+ }
+
+ /**
+ * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+ */
+ public static LoadBalancerStatsServiceBlockingStub newBlockingStub(
+ io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public LoadBalancerStatsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new LoadBalancerStatsServiceBlockingStub(channel, callOptions);
+ }
+ };
+ return LoadBalancerStatsServiceBlockingStub.newStub(factory, channel);
+ }
+
+ /**
+ * Creates a new ListenableFuture-style stub that supports unary calls on the service
+ */
+ public static LoadBalancerStatsServiceFutureStub newFutureStub(
+ io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public LoadBalancerStatsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new LoadBalancerStatsServiceFutureStub(channel, callOptions);
+ }
+ };
+ return LoadBalancerStatsServiceFutureStub.newStub(factory, channel);
+ }
+
+ /**
+ *
+ * A service used to obtain stats for verifying LB behavior.
+ *
+ */
+ public static abstract class LoadBalancerStatsServiceImplBase implements io.grpc.BindableService {
+
+ /**
+ *
+ * Gets the backend distribution for RPCs sent by a test client.
+ *
+ */
+ public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+ io.grpc.stub.StreamObserver responseObserver) {
+ asyncUnimplementedUnaryCall(getGetClientStatsMethod(), responseObserver);
+ }
+
+ @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+ return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+ .addMethod(
+ getGetClientStatsMethod(),
+ asyncUnaryCall(
+ new MethodHandlers<
+ io.grpc.testing.integration.Messages.LoadBalancerStatsRequest,
+ io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>(
+ this, METHODID_GET_CLIENT_STATS)))
+ .build();
+ }
+ }
+
+ /**
+ *
+ * A service used to obtain stats for verifying LB behavior.
+ *
+ */
+ public static final class LoadBalancerStatsServiceStub extends io.grpc.stub.AbstractAsyncStub {
+ private LoadBalancerStatsServiceStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected LoadBalancerStatsServiceStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new LoadBalancerStatsServiceStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * Gets the backend distribution for RPCs sent by a test client.
+ *
+ */
+ public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+ io.grpc.stub.StreamObserver responseObserver) {
+ asyncUnaryCall(
+ getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request, responseObserver);
+ }
+ }
+
+ /**
+ *
+ * A service used to obtain stats for verifying LB behavior.
+ *
+ */
+ public static final class LoadBalancerStatsServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub {
+ private LoadBalancerStatsServiceBlockingStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected LoadBalancerStatsServiceBlockingStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new LoadBalancerStatsServiceBlockingStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * Gets the backend distribution for RPCs sent by a test client.
+ *
+ */
+ public io.grpc.testing.integration.Messages.LoadBalancerStatsResponse getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) {
+ return blockingUnaryCall(
+ getChannel(), getGetClientStatsMethod(), getCallOptions(), request);
+ }
+ }
+
+ /**
+ *
+ * A service used to obtain stats for verifying LB behavior.
+ *
+ */
+ public static final class LoadBalancerStatsServiceFutureStub extends io.grpc.stub.AbstractFutureStub {
+ private LoadBalancerStatsServiceFutureStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected LoadBalancerStatsServiceFutureStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new LoadBalancerStatsServiceFutureStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * Gets the backend distribution for RPCs sent by a test client.
+ *
+ */
+ public com.google.common.util.concurrent.ListenableFuture getClientStats(
+ io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) {
+ return futureUnaryCall(
+ getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request);
+ }
+ }
+
+ private static final int METHODID_GET_CLIENT_STATS = 0;
+
+ private static final class MethodHandlers implements
+ io.grpc.stub.ServerCalls.UnaryMethod,
+ io.grpc.stub.ServerCalls.ServerStreamingMethod,
+ io.grpc.stub.ServerCalls.ClientStreamingMethod,
+ io.grpc.stub.ServerCalls.BidiStreamingMethod {
+ private final LoadBalancerStatsServiceImplBase serviceImpl;
+ private final int methodId;
+
+ MethodHandlers(LoadBalancerStatsServiceImplBase serviceImpl, int methodId) {
+ this.serviceImpl = serviceImpl;
+ this.methodId = methodId;
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
+ switch (methodId) {
+ case METHODID_GET_CLIENT_STATS:
+ serviceImpl.getClientStats((io.grpc.testing.integration.Messages.LoadBalancerStatsRequest) request,
+ (io.grpc.stub.StreamObserver) responseObserver);
+ break;
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public io.grpc.stub.StreamObserver invoke(
+ io.grpc.stub.StreamObserver responseObserver) {
+ switch (methodId) {
+ default:
+ throw new AssertionError();
+ }
+ }
+ }
+
+ private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+ io.grpc.ServiceDescriptor result = serviceDescriptor;
+ if (result == null) {
+ synchronized (LoadBalancerStatsServiceGrpc.class) {
+ result = serviceDescriptor;
+ if (result == null) {
+ serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+ .addMethod(getGetClientStatsMethod())
+ .build();
+ }
+ }
+ }
+ return result;
+ }
+}
diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
new file mode 100644
index 0000000000..470c3bcee0
--- /dev/null
+++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
@@ -0,0 +1,341 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncUnaryCall;
+import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
+import static io.grpc.stub.ClientCalls.blockingUnaryCall;
+import static io.grpc.stub.ClientCalls.futureUnaryCall;
+import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncUnaryCall;
+import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
+
+/**
+ */
+@javax.annotation.Generated(
+ value = "by gRPC proto compiler",
+ comments = "Source: grpc/testing/metrics.proto")
+public final class MetricsServiceGrpc {
+
+ private MetricsServiceGrpc() {}
+
+ public static final String SERVICE_NAME = "grpc.testing.MetricsService";
+
+ // Static method descriptors that strictly reflect the proto.
+ private static volatile io.grpc.MethodDescriptor getGetAllGaugesMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "GetAllGauges",
+ requestType = io.grpc.testing.integration.Metrics.EmptyMessage.class,
+ responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+ public static io.grpc.MethodDescriptor getGetAllGaugesMethod() {
+ io.grpc.MethodDescriptor getGetAllGaugesMethod;
+ if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) {
+ synchronized (MetricsServiceGrpc.class) {
+ if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) {
+ MetricsServiceGrpc.getGetAllGaugesMethod = getGetAllGaugesMethod =
+ io.grpc.MethodDescriptor.newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAllGauges"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+ io.grpc.testing.integration.Metrics.EmptyMessage.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+ io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()))
+ .build();
+ }
+ }
+ }
+ return getGetAllGaugesMethod;
+ }
+
+ private static volatile io.grpc.MethodDescriptor getGetGaugeMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "GetGauge",
+ requestType = io.grpc.testing.integration.Metrics.GaugeRequest.class,
+ responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+ public static io.grpc.MethodDescriptor getGetGaugeMethod() {
+ io.grpc.MethodDescriptor getGetGaugeMethod;
+ if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) {
+ synchronized (MetricsServiceGrpc.class) {
+ if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) {
+ MetricsServiceGrpc.getGetGaugeMethod = getGetGaugeMethod =
+ io.grpc.MethodDescriptor.newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetGauge"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+ io.grpc.testing.integration.Metrics.GaugeRequest.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+ io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()))
+ .build();
+ }
+ }
+ }
+ return getGetGaugeMethod;
+ }
+
+ /**
+ * Creates a new async stub that supports all call types for the service
+ */
+ public static MetricsServiceStub newStub(io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public MetricsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new MetricsServiceStub(channel, callOptions);
+ }
+ };
+ return MetricsServiceStub.newStub(factory, channel);
+ }
+
+ /**
+ * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+ */
+ public static MetricsServiceBlockingStub newBlockingStub(
+ io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public MetricsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new MetricsServiceBlockingStub(channel, callOptions);
+ }
+ };
+ return MetricsServiceBlockingStub.newStub(factory, channel);
+ }
+
+ /**
+ * Creates a new ListenableFuture-style stub that supports unary calls on the service
+ */
+ public static MetricsServiceFutureStub newFutureStub(
+ io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public MetricsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new MetricsServiceFutureStub(channel, callOptions);
+ }
+ };
+ return MetricsServiceFutureStub.newStub(factory, channel);
+ }
+
+ /**
+ */
+ public static abstract class MetricsServiceImplBase implements io.grpc.BindableService {
+
+ /**
+ *
+ * Returns the values of all the gauges that are currently being maintained by
+ * the service
+ *
+ */
+ public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+ io.grpc.stub.StreamObserver responseObserver) {
+ asyncUnimplementedUnaryCall(getGetAllGaugesMethod(), responseObserver);
+ }
+
+ /**
+ *
+ * Returns the value of one gauge
+ *
+ */
+ public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+ io.grpc.stub.StreamObserver responseObserver) {
+ asyncUnimplementedUnaryCall(getGetGaugeMethod(), responseObserver);
+ }
+
+ @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+ return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+ .addMethod(
+ getGetAllGaugesMethod(),
+ asyncServerStreamingCall(
+ new MethodHandlers<
+ io.grpc.testing.integration.Metrics.EmptyMessage,
+ io.grpc.testing.integration.Metrics.GaugeResponse>(
+ this, METHODID_GET_ALL_GAUGES)))
+ .addMethod(
+ getGetGaugeMethod(),
+ asyncUnaryCall(
+ new MethodHandlers<
+ io.grpc.testing.integration.Metrics.GaugeRequest,
+ io.grpc.testing.integration.Metrics.GaugeResponse>(
+ this, METHODID_GET_GAUGE)))
+ .build();
+ }
+ }
+
+ /**
+ */
+ public static final class MetricsServiceStub extends io.grpc.stub.AbstractAsyncStub {
+ private MetricsServiceStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected MetricsServiceStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new MetricsServiceStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * Returns the values of all the gauges that are currently being maintained by
+ * the service
+ *
+ */
+ public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+ io.grpc.stub.StreamObserver responseObserver) {
+ asyncServerStreamingCall(
+ getChannel().newCall(getGetAllGaugesMethod(), getCallOptions()), request, responseObserver);
+ }
+
+ /**
+ *
+ * Returns the value of one gauge
+ *
+ */
+ public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+ io.grpc.stub.StreamObserver responseObserver) {
+ asyncUnaryCall(
+ getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request, responseObserver);
+ }
+ }
+
+ /**
+ */
+ public static final class MetricsServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub {
+ private MetricsServiceBlockingStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected MetricsServiceBlockingStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new MetricsServiceBlockingStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * Returns the values of all the gauges that are currently being maintained by
+ * the service
+ *
+ */
+ public java.util.Iterator getAllGauges(
+ io.grpc.testing.integration.Metrics.EmptyMessage request) {
+ return blockingServerStreamingCall(
+ getChannel(), getGetAllGaugesMethod(), getCallOptions(), request);
+ }
+
+ /**
+ *
+ * Returns the value of one gauge
+ *
+ */
+ public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request) {
+ return blockingUnaryCall(
+ getChannel(), getGetGaugeMethod(), getCallOptions(), request);
+ }
+ }
+
+ /**
+ */
+ public static final class MetricsServiceFutureStub extends io.grpc.stub.AbstractFutureStub {
+ private MetricsServiceFutureStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected MetricsServiceFutureStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new MetricsServiceFutureStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * Returns the value of one gauge
+ *
+ */
+ public com.google.common.util.concurrent.ListenableFuture getGauge(
+ io.grpc.testing.integration.Metrics.GaugeRequest request) {
+ return futureUnaryCall(
+ getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request);
+ }
+ }
+
+ private static final int METHODID_GET_ALL_GAUGES = 0;
+ private static final int METHODID_GET_GAUGE = 1;
+
+ private static final class MethodHandlers implements
+ io.grpc.stub.ServerCalls.UnaryMethod,
+ io.grpc.stub.ServerCalls.ServerStreamingMethod,
+ io.grpc.stub.ServerCalls.ClientStreamingMethod