grpc
/
grpc-java
mirror of https://github.com/grpc/grpc-java.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add javadoc to grpc codegen based on proto docs 

Fixes #1612
This commit is contained in:
nmittler 2016-04-15 12:52:00 -07:00
parent 00f8f349b2
commit 7e8b504e3f
15 changed files with 954 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/BenchmarkServiceGrpc.java
View File

@ -15,6 +15,8 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: services.proto")
@ -44,25 +46,48 @@ public class BenchmarkServiceGrpc {
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Messages.SimpleRequest.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Messages.SimpleResponse.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static BenchmarkServiceStub newStub(io.grpc.Channel channel) {
return new BenchmarkServiceStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static BenchmarkServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new BenchmarkServiceBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static BenchmarkServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
return new BenchmarkServiceFutureStub(channel);
}
/**
*/
public static interface BenchmarkService {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public void unaryCall(io.grpc.benchmarks.proto.Messages.SimpleRequest request,
io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver);
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleRequest> streamingCall(
io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver);
}
@ -87,13 +112,29 @@ public class BenchmarkServiceGrpc {
}
}
/**
*/
public static interface BenchmarkServiceBlockingClient {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public io.grpc.benchmarks.proto.Messages.SimpleResponse unaryCall(io.grpc.benchmarks.proto.Messages.SimpleRequest request);
}
/**
*/
public static interface BenchmarkServiceFutureClient {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.benchmarks.proto.Messages.SimpleResponse> unaryCall(
io.grpc.benchmarks.proto.Messages.SimpleRequest request);
}

67
benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/WorkerServiceGrpc.java
View File

@ -15,6 +15,8 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: services.proto")
@ -62,31 +64,72 @@ public class WorkerServiceGrpc {
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Control.Void.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Control.Void.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static WorkerServiceStub newStub(io.grpc.Channel channel) {
return new WorkerServiceStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static WorkerServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new WorkerServiceBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static WorkerServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
return new WorkerServiceFutureStub(channel);
}
/**
*/
public static interface WorkerService {
/**
* <pre>
* Start server with specified workload.
* First request sent specifies the ServerConfig followed by ServerStatus
* response. After that, a "Mark" can be sent anytime to request the latest
* stats. Closing the stream will initiate shutdown of the test server
* and once the shutdown has finished, the OK status is sent to terminate
* this RPC.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ServerArgs> runServer(
io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ServerStatus> responseObserver);
/**
* <pre>
* Start client with specified workload.
* First request sent specifies the ClientConfig followed by ClientStatus
* response. After that, a "Mark" can be sent anytime to request the latest
* stats. Closing the stream will initiate shutdown of the test client
* and once the shutdown has finished, the OK status is sent to terminate
* this RPC.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ClientArgs> runClient(
io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ClientStatus> responseObserver);
/**
* <pre>
* Just return the core count - unary call
* </pre>
*/
public void coreCount(io.grpc.benchmarks.proto.Control.CoreRequest request,
io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.CoreResponse> responseObserver);
/**
* <pre>
* Quit this worker
* </pre>
*/
public void quitWorker(io.grpc.benchmarks.proto.Control.Void request,
io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.Void> responseObserver);
}
@ -123,18 +166,42 @@ public class WorkerServiceGrpc {
}
}
/**
*/
public static interface WorkerServiceBlockingClient {
/**
* <pre>
* Just return the core count - unary call
* </pre>
*/
public io.grpc.benchmarks.proto.Control.CoreResponse coreCount(io.grpc.benchmarks.proto.Control.CoreRequest request);
/**
* <pre>
* Quit this worker
* </pre>
*/
public io.grpc.benchmarks.proto.Control.Void quitWorker(io.grpc.benchmarks.proto.Control.Void request);
}
/**
*/
public static interface WorkerServiceFutureClient {
/**
* <pre>
* Just return the core count - unary call
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.benchmarks.proto.Control.CoreResponse> coreCount(
io.grpc.benchmarks.proto.Control.CoreRequest request);
/**
* <pre>
* Quit this worker
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.benchmarks.proto.Control.Void> quitWorker(
io.grpc.benchmarks.proto.Control.Void request);
}

226
compiler/src/java_plugin/cpp/java_generator.cpp
View File

@ -25,6 +25,7 @@ using google::protobuf::ServiceDescriptor;
using google::protobuf::MethodDescriptor;
using google::protobuf::Descriptor;
using google::protobuf::io::Printer;
using google::protobuf::SourceLocation;
using std::to_string;
// Adjust a method name prefix identifier to follow the JavaBean spec:
@ -90,6 +91,208 @@ static inline string MessageFullJavaName(bool nano, const Descriptor* desc) {
return name;
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
template <typename ITR>
static void GrpcSplitStringToIteratorUsing(const string& full,
const char* delim,
ITR& result) {
// Optimize the common case where delim is a single character.
if (delim[0] != '\0' && delim[1] == '\0') {
char c = delim[0];
const char* p = full.data();
const char* end = p + full.size();
while (p != end) {
if (*p == c) {
++p;
} else {
const char* start = p;
while (++p != end && *p != c);
*result++ = string(start, p - start);
}
}
return;
}
string::size_type begin_index, end_index;
begin_index = full.find_first_not_of(delim);
while (begin_index != string::npos) {
end_index = full.find_first_of(delim, begin_index);
if (end_index == string::npos) {
*result++ = full.substr(begin_index);
return;
}
*result++ = full.substr(begin_index, (end_index - begin_index));
begin_index = full.find_first_not_of(delim, end_index);
}
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
static void GrpcSplitStringUsing(const string& full,
const char* delim,
vector<string>* result) {
back_insert_iterator< vector<string> > it(*result);
GrpcSplitStringToIteratorUsing(full, delim, it);
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
static vector<string> GrpcSplit(const string& full, const char* delim) {
vector<string> result;
GrpcSplitStringUsing(full, delim, &result);
return result;
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
static string GrpcEscapeJavadoc(const string& input) {
string result;
result.reserve(input.size() * 2);
char prev = '*';
for (string::size_type i = 0; i < input.size(); i++) {
char c = input[i];
switch (c) {
case '*':
// Avoid "/*".
if (prev == '/') {
result.append("&#42;");
} else {
result.push_back(c);
}
break;
case '/':
// Avoid "*/".
if (prev == '*') {
result.append("&#47;");
} else {
result.push_back(c);
}
break;
case '@':
// '@' starts javadoc tags including the @deprecated tag, which will
// cause a compile-time error if inserted before a declaration that
// does not have a corresponding @Deprecated annotation.
result.append("&#64;");
break;
case '<':
// Avoid interpretation as HTML.
result.append("&lt;");
break;
case '>':
// Avoid interpretation as HTML.
result.append("&gt;");
break;
case '&':
// Avoid interpretation as HTML.
result.append("&amp;");
break;
case '\\':
// Java interprets Unicode escape sequences anywhere!
result.append("&#92;");
break;
default:
result.push_back(c);
break;
}
prev = c;
}
return result;
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
template <typename DescriptorType>
static string GrpcGetCommentsForDescriptor(const DescriptorType* descriptor) {
SourceLocation location;
if (descriptor->GetSourceLocation(&location)) {
return location.leading_comments.empty() ?
location.trailing_comments : location.leading_comments;
}
return string();
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
static vector<string> GrpcGetDocLines(const string& comments) {
if (!comments.empty()) {
// TODO(kenton): Ideally we should parse the comment text as Markdown and
// write it back as HTML, but this requires a Markdown parser. For now
// we just use <pre> to get fixed-width text formatting.
// If the comment itself contains block comment start or end markers,
// HTML-escape them so that they don't accidentally close the doc comment.
string escapedComments = GrpcEscapeJavadoc(comments);
vector<string> lines = GrpcSplit(escapedComments, "\n");
while (!lines.empty() && lines.back().empty()) {
lines.pop_back();
}
return lines;
}
return vector<string>();
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
template <typename DescriptorType>
static vector<string> GrpcGetDocLinesForDescriptor(const DescriptorType* descriptor) {
return GrpcGetDocLines(GrpcGetCommentsForDescriptor(descriptor));
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
static void GrpcWriteDocCommentBody(Printer* printer,
const vector<string>& lines,
bool surroundWithPreTag) {
if (!lines.empty()) {
if (surroundWithPreTag) {
printer->Print(" * <pre>\n");
}
for (int i = 0; i < lines.size(); i++) {
// Most lines should start with a space. Watch out for lines that start
// with a /, since putting that right after the leading asterisk will
// close the comment.
if (!lines[i].empty() && lines[i][0] == '/') {
printer->Print(" * $line$\n", "line", lines[i]);
} else {
printer->Print(" *$line$\n", "line", lines[i]);
}
}
if (surroundWithPreTag) {
printer->Print(" * </pre>\n");
}
}
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
static void GrpcWriteDocComment(Printer* printer, const string& comments) {
printer->Print("/**\n");
vector<string> lines = GrpcGetDocLines(comments);
GrpcWriteDocCommentBody(printer, lines, false);
printer->Print(" */\n");
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
static void GrpcWriteServiceDocComment(Printer* printer,
const ServiceDescriptor* service) {
// Deviating from protobuf to avoid extraneous docs
// (see https://github.com/google/protobuf/issues/1406);
printer->Print("/**\n");
vector<string> lines = GrpcGetDocLinesForDescriptor(service);
GrpcWriteDocCommentBody(printer, lines, true);
printer->Print(" */\n");
}
// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
void GrpcWriteMethodDocComment(Printer* printer,
const MethodDescriptor* method) {
// Deviating from protobuf to avoid extraneous docs
// (see https://github.com/google/protobuf/issues/1406);
printer->Print("/**\n");
vector<string> lines = GrpcGetDocLinesForDescriptor(method);
GrpcWriteDocCommentBody(printer, lines, true);
printer->Print(" */\n");
}
static void PrintMethodFields(
const ServiceDescriptor* service, map<string, string>* vars, Printer* p,
ProtoFlavor flavor) {
@ -293,6 +496,7 @@ static void PrintStub(
(*vars)["interface_name"] = interface_name;
(*vars)["impl_name"] = impl_name;
bool interface = !abstract && !impl;
// Class head
if (abstract) {
p->Print(
@ -300,7 +504,10 @@ static void PrintStub(
"@$ExperimentalApi$\n"
"public static abstract class $abstract_name$ implements $service_name$, "
"$BindableService$ {\n");
} else if (!impl) {
} else if (interface) {
// TODO(nmittler): Replace with WriteServiceDocComment when included in protobuf distribution.
// Print the service-level javadoc when we define the interface.
GrpcWriteServiceDocComment(p, service);
p->Print(
*vars,
"public static interface $interface_name$ {\n");
@ -366,7 +573,10 @@ static void PrintStub(
// Method signature
p->Print("\n");
if (impl || abstract) {
if (interface) {
// TODO(nmittler): Replace with WriteMethodDocComment once included by the protobuf distro.
GrpcWriteMethodDocComment(p, method);
} else {
p->Print(
*vars,
"@$Override$\n");
@ -715,6 +925,8 @@ static void PrintService(const ServiceDescriptor* service,
#else
(*vars)["grpc_version"] = "";
#endif
// TODO(nmittler): Replace with WriteServiceDocComment once included by protobuf distro.
GrpcWriteServiceDocComment(p, service);
p->Print(
*vars,
"@$Generated$(\n"
@ -733,6 +945,8 @@ static void PrintService(const ServiceDescriptor* service,
PrintMethodFields(service, vars, p, flavor);
// TODO(nmittler): Replace with WriteDocComment once included by protobuf distro.
GrpcWriteDocComment(p, " Creates a new async stub that supports all call types for the service");
p->Print(
*vars,
"public static $service_name$Stub newStub($Channel$ channel) {\n");
@ -742,6 +956,10 @@ static void PrintService(const ServiceDescriptor* service,
"return new $service_name$Stub(channel);\n");
p->Outdent();
p->Print("}\n\n");
// TODO(nmittler): Replace with WriteDocComment once included by protobuf distro.
GrpcWriteDocComment(p, " Creates a new blocking-style stub that supports unary and streaming "
"output calls on the service");
p->Print(
*vars,
"public static $service_name$BlockingStub newBlockingStub(\n"
@ -752,6 +970,10 @@ static void PrintService(const ServiceDescriptor* service,
"return new $service_name$BlockingStub(channel);\n");
p->Outdent();
p->Print("}\n\n");
// TODO(nmittler): Replace with WriteDocComment once included by protobuf distro.
GrpcWriteDocComment(p, " Creates a new ListenableFuture-style stub that supports unary and "
"streaming output calls on the service");
p->Print(
*vars,
"public static $service_name$FutureStub newFutureStub(\n"

80
compiler/src/test/golden/TestService.java.txt
View File

@ -15,6 +15,11 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: test.proto")
@ -71,34 +76,81 @@ public class TestServiceGrpc {
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallRequest.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallResponse.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static TestServiceStub newStub(io.grpc.Channel channel) {
return new TestServiceStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static TestServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new TestServiceBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static TestServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
return new TestServiceFutureStub(channel);
}
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
public static interface TestService {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public void unaryCall(io.grpc.testing.integration.Test.SimpleRequest request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.SimpleResponse> responseObserver);
/**
* <pre>
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
* </pre>
*/
public void streamingOutputCall(io.grpc.testing.integration.Test.StreamingOutputCallRequest request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests followed by one response (streamed upload).
* The server returns the aggregated size of client payload as the result.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallRequest> streamingInputCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests with each request served by the server immediately.
* As one request could lead to multiple responses, this interface
* demonstrates the idea of full bidirectionality.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> fullBidiCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests followed by a sequence of responses.
* The server buffers all the client requests and then serves them in order. A
* stream of responses are returned to the client when the server starts with
* first request.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> halfBidiCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver);
}
@ -141,16 +193,44 @@ public class TestServiceGrpc {
}
}
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
public static interface TestServiceBlockingClient {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public io.grpc.testing.integration.Test.SimpleResponse unaryCall(io.grpc.testing.integration.Test.SimpleRequest request);
/**
* <pre>
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
* </pre>
*/
public java.util.Iterator<io.grpc.testing.integration.Test.StreamingOutputCallResponse> streamingOutputCall(
io.grpc.testing.integration.Test.StreamingOutputCallRequest request);
}
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
public static interface TestServiceFutureClient {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Test.SimpleResponse> unaryCall(
io.grpc.testing.integration.Test.SimpleRequest request);
}

1
compiler/src/test/proto/test.proto
View File

@ -23,6 +23,7 @@ message StreamingOutputCallRequest {
message StreamingOutputCallResponse {
}
// Test service that supports all call types.
service TestService {
// One request followed by one response.
// The server returns the client payload as-is.

80
compiler/src/testLite/golden/TestService.java.txt
View File

@ -15,6 +15,11 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: test.proto")
@ -71,34 +76,81 @@ public class TestServiceGrpc {
io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallRequest.getDefaultInstance()),
io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallResponse.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static TestServiceStub newStub(io.grpc.Channel channel) {
return new TestServiceStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static TestServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new TestServiceBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static TestServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
return new TestServiceFutureStub(channel);
}
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
public static interface TestService {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public void unaryCall(io.grpc.testing.integration.Test.SimpleRequest request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.SimpleResponse> responseObserver);
/**
* <pre>
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
* </pre>
*/
public void streamingOutputCall(io.grpc.testing.integration.Test.StreamingOutputCallRequest request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests followed by one response (streamed upload).
* The server returns the aggregated size of client payload as the result.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallRequest> streamingInputCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests with each request served by the server immediately.
* As one request could lead to multiple responses, this interface
* demonstrates the idea of full bidirectionality.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> fullBidiCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests followed by a sequence of responses.
* The server buffers all the client requests and then serves them in order. A
* stream of responses are returned to the client when the server starts with
* first request.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> halfBidiCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver);
}
@ -141,16 +193,44 @@ public class TestServiceGrpc {
}
}
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
public static interface TestServiceBlockingClient {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public io.grpc.testing.integration.Test.SimpleResponse unaryCall(io.grpc.testing.integration.Test.SimpleRequest request);
/**
* <pre>
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
* </pre>
*/
public java.util.Iterator<io.grpc.testing.integration.Test.StreamingOutputCallResponse> streamingOutputCall(
io.grpc.testing.integration.Test.StreamingOutputCallRequest request);
}
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
public static interface TestServiceFutureClient {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Test.SimpleResponse> unaryCall(
io.grpc.testing.integration.Test.SimpleRequest request);
}

1
compiler/src/testLite/proto/test.proto
View File

@ -24,6 +24,7 @@ message StreamingOutputCallRequest {
message StreamingOutputCallResponse {
}
// Test service that supports all call types.
service TestService {
// One request followed by one response.
// The server returns the client payload as-is.

80
compiler/src/testNano/golden/TestService.java.txt
View File

@ -17,6 +17,11 @@ import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
import java.io.IOException;
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: test.proto")
@ -149,34 +154,81 @@ public class TestServiceGrpc {
}
}
/**
* Creates a new async stub that supports all call types for the service
*/
public static TestServiceStub newStub(io.grpc.Channel channel) {
return new TestServiceStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static TestServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new TestServiceBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static TestServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
return new TestServiceFutureStub(channel);
}
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
public static interface TestService {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public void unaryCall(io.grpc.testing.integration.nano.Test.SimpleRequest request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.SimpleResponse> responseObserver);
/**
* <pre>
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
* </pre>
*/
public void streamingOutputCall(io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests followed by one response (streamed upload).
* The server returns the aggregated size of client payload as the result.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingInputCallRequest> streamingInputCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingInputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests with each request served by the server immediately.
* As one request could lead to multiple responses, this interface
* demonstrates the idea of full bidirectionality.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest> fullBidiCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests followed by a sequence of responses.
* The server buffers all the client requests and then serves them in order. A
* stream of responses are returned to the client when the server starts with
* first request.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest> halfBidiCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> responseObserver);
}
@ -219,16 +271,44 @@ public class TestServiceGrpc {
}
}
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
public static interface TestServiceBlockingClient {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public io.grpc.testing.integration.nano.Test.SimpleResponse unaryCall(io.grpc.testing.integration.nano.Test.SimpleRequest request);
/**
* <pre>
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
* </pre>
*/
public java.util.Iterator<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> streamingOutputCall(
io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest request);
}
/**
* <pre>
* Test service that supports all call types.
* </pre>
*/
public static interface TestServiceFutureClient {
/**
* <pre>
* One request followed by one response.
* The server returns the client payload as-is.
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.nano.Test.SimpleResponse> unaryCall(
io.grpc.testing.integration.nano.Test.SimpleRequest request);
}

44
examples/src/generated/main/grpc/io/grpc/examples/helloworld/GreeterGrpc.java
View File

@ -15,6 +15,11 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
* <pre>
* The greeting service definition.
* </pre>
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: helloworld.proto")
@ -35,22 +40,41 @@ public class GreeterGrpc {
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.examples.helloworld.HelloRequest.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.examples.helloworld.HelloReply.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static GreeterStub newStub(io.grpc.Channel channel) {
return new GreeterStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static GreeterBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new GreeterBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static GreeterFutureStub newFutureStub(
io.grpc.Channel channel) {
return new GreeterFutureStub(channel);
}
/**
* <pre>
* The greeting service definition.
* </pre>
*/
public static interface Greeter {
/**
* <pre>
* Sends a greeting
* </pre>
*/
public void sayHello(io.grpc.examples.helloworld.HelloRequest request,
io.grpc.stub.StreamObserver<io.grpc.examples.helloworld.HelloReply> responseObserver);
}
@ -69,13 +93,33 @@ public class GreeterGrpc {
}
}
/**
* <pre>
* The greeting service definition.
* </pre>
*/
public static interface GreeterBlockingClient {
/**
* <pre>
* Sends a greeting
* </pre>
*/
public io.grpc.examples.helloworld.HelloReply sayHello(io.grpc.examples.helloworld.HelloRequest request);
}
/**
* <pre>
* The greeting service definition.
* </pre>
*/
public static interface GreeterFutureClient {
/**
* <pre>
* Sends a greeting
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.examples.helloworld.HelloReply> sayHello(
io.grpc.examples.helloworld.HelloRequest request);
}

85
examples/src/generated/main/grpc/io/grpc/examples/routeguide/RouteGuideGrpc.java
View File

@ -15,6 +15,11 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
* <pre>
* Interface exported by the server.
* </pre>
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: route_guide.proto")
@ -62,31 +67,76 @@ public class RouteGuideGrpc {
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.examples.routeguide.RouteNote.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.examples.routeguide.RouteNote.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static RouteGuideStub newStub(io.grpc.Channel channel) {
return new RouteGuideStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static RouteGuideBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new RouteGuideBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static RouteGuideFutureStub newFutureStub(
io.grpc.Channel channel) {
return new RouteGuideFutureStub(channel);
}
/**
* <pre>
* Interface exported by the server.
* </pre>
*/
public static interface RouteGuide {
/**
* <pre>
* A simple RPC.
* Obtains the feature at a given position.
* A feature with an empty name is returned if there's no feature at the given
* position.
* </pre>
*/
public void getFeature(io.grpc.examples.routeguide.Point request,
io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.Feature> responseObserver);
/**
* <pre>
* A server-to-client streaming RPC.
* Obtains the Features available within the given Rectangle. Results are
* streamed rather than returned at once (e.g. in a response message with a
* repeated field), as the rectangle may cover a large area and contain a
* huge number of features.
* </pre>
*/
public void listFeatures(io.grpc.examples.routeguide.Rectangle request,
io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.Feature> responseObserver);
/**
* <pre>
* A client-to-server streaming RPC.
* Accepts a stream of Points on a route being traversed, returning a
* RouteSummary when traversal is completed.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.Point> recordRoute(
io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.RouteSummary> responseObserver);
/**
* <pre>
* A Bidirectional streaming RPC.
* Accepts a stream of RouteNotes sent while a route is being traversed,
* while receiving other RouteNotes (e.g. from other users).
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.RouteNote> routeChat(
io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.RouteNote> responseObserver);
}
@ -123,16 +173,51 @@ public class RouteGuideGrpc {
}
}
/**
* <pre>
* Interface exported by the server.
* </pre>
*/
public static interface RouteGuideBlockingClient {
/**
* <pre>
* A simple RPC.
* Obtains the feature at a given position.
* A feature with an empty name is returned if there's no feature at the given
* position.
* </pre>
*/
public io.grpc.examples.routeguide.Feature getFeature(io.grpc.examples.routeguide.Point request);
/**
* <pre>
* A server-to-client streaming RPC.
* Obtains the Features available within the given Rectangle. Results are
* streamed rather than returned at once (e.g. in a response message with a
* repeated field), as the rectangle may cover a large area and contain a
* huge number of features.
* </pre>
*/
public java.util.Iterator<io.grpc.examples.routeguide.Feature> listFeatures(
io.grpc.examples.routeguide.Rectangle request);
}
/**
* <pre>
* Interface exported by the server.
* </pre>
*/
public static interface RouteGuideFutureClient {
/**
* <pre>
* A simple RPC.
* Obtains the feature at a given position.
* A feature with an empty name is returned if there's no feature at the given
* position.
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.examples.routeguide.Feature> getFeature(
io.grpc.examples.routeguide.Point request);
}

22
grpclb/src/generated/main/grpc/io/grpc/grpclb/LoadBalancerGrpc.java
View File

@ -15,6 +15,8 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: load_balancer.proto")
@ -35,22 +37,38 @@ public class LoadBalancerGrpc {
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.grpclb.LoadBalanceRequest.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.grpclb.LoadBalanceResponse.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static LoadBalancerStub newStub(io.grpc.Channel channel) {
return new LoadBalancerStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static LoadBalancerBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new LoadBalancerBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static LoadBalancerFutureStub newFutureStub(
io.grpc.Channel channel) {
return new LoadBalancerFutureStub(channel);
}
/**
*/
public static interface LoadBalancer {
/**
* <pre>
* Bidirectional rpc to get a list of servers.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.grpclb.LoadBalanceRequest> balanceLoad(
io.grpc.stub.StreamObserver<io.grpc.grpclb.LoadBalanceResponse> responseObserver);
}
@ -69,9 +87,13 @@ public class LoadBalancerGrpc {
}
}
/**
*/
public static interface LoadBalancerBlockingClient {
}
/**
*/
public static interface LoadBalancerFutureClient {
}

44
interop-testing/src/generated/main/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
View File

@ -15,6 +15,8 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: io/grpc/testing/integration/metrics.proto")
@ -44,25 +46,47 @@ public class MetricsServiceGrpc {
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Metrics.GaugeRequest.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static MetricsServiceStub newStub(io.grpc.Channel channel) {
return new MetricsServiceStub(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) {
return new MetricsServiceBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static MetricsServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
return new MetricsServiceFutureStub(channel);
}
/**
*/
public static interface MetricsService {
/**
* <pre>
* Returns the values of all the gauges that are currently being maintained by
* the service
* </pre>
*/
public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver);
/**
* <pre>
* Returns the value of one gauge
* </pre>
*/
public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver);
}
@ -87,16 +111,36 @@ public class MetricsServiceGrpc {
}
}
/**
*/
public static interface MetricsServiceBlockingClient {
/**
* <pre>
* Returns the values of all the gauges that are currently being maintained by
* the service
* </pre>
*/
public java.util.Iterator<io.grpc.testing.integration.Metrics.GaugeResponse> getAllGauges(
io.grpc.testing.integration.Metrics.EmptyMessage request);
/**
* <pre>
* Returns the value of one gauge
* </pre>
*/
public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request);
}
/**
*/
public static interface MetricsServiceFutureClient {
/**
* <pre>
* Returns the value of one gauge
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Metrics.GaugeResponse> getGauge(
io.grpc.testing.integration.Metrics.GaugeRequest request);
}

41
interop-testing/src/generated/main/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java
View File

@ -15,6 +15,11 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
* <pre>
* A service used to control reconnect server.
* </pre>
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: io/grpc/testing/integration/test.proto")
@ -44,25 +49,43 @@ public class ReconnectServiceGrpc {
io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.ReconnectInfo.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static ReconnectServiceStub newStub(io.grpc.Channel channel) {
return new ReconnectServiceStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static ReconnectServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new ReconnectServiceBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static ReconnectServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
return new ReconnectServiceFutureStub(channel);
}
/**
* <pre>
* A service used to control reconnect server.
* </pre>
*/
public static interface ReconnectService {
/**
*/
public void start(com.google.protobuf.EmptyProtos.Empty request,
io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver);
/**
*/
public void stop(com.google.protobuf.EmptyProtos.Empty request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo> responseObserver);
}
@ -87,18 +110,36 @@ public class ReconnectServiceGrpc {
}
}
/**
* <pre>
* A service used to control reconnect server.
* </pre>
*/
public static interface ReconnectServiceBlockingClient {
/**
*/
public com.google.protobuf.EmptyProtos.Empty start(com.google.protobuf.EmptyProtos.Empty request);
/**
*/
public io.grpc.testing.integration.Messages.ReconnectInfo stop(com.google.protobuf.EmptyProtos.Empty request);
}
/**
* <pre>
* A service used to control reconnect server.
* </pre>
*/
public static interface ReconnectServiceFutureClient {
/**
*/
public com.google.common.util.concurrent.ListenableFuture<com.google.protobuf.EmptyProtos.Empty> start(
com.google.protobuf.EmptyProtos.Empty request);
/**
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.ReconnectInfo> stop(
com.google.protobuf.EmptyProtos.Empty request);
}

96
interop-testing/src/generated/main/grpc/io/grpc/testing/integration/TestServiceGrpc.java
View File

@ -15,6 +15,12 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
* <pre>
* A simple service to test the various types of RPCs and experiment with
* performance with various types of payload.
* </pre>
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: io/grpc/testing/integration/test.proto")
@ -80,37 +86,89 @@ public class TestServiceGrpc {
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static TestServiceStub newStub(io.grpc.Channel channel) {
return new TestServiceStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static TestServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new TestServiceBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static TestServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
return new TestServiceFutureStub(channel);
}
/**
* <pre>
* A simple service to test the various types of RPCs and experiment with
* performance with various types of payload.
* </pre>
*/
public static interface TestService {
/**
* <pre>
* One empty request followed by one empty response.
* </pre>
*/
public void emptyCall(com.google.protobuf.EmptyProtos.Empty request,
io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver);
/**
* <pre>
* One request followed by one response.
* </pre>
*/
public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver);
/**
* <pre>
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
* </pre>
*/
public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests followed by one response (streamed upload).
* The server returns the aggregated size of client payload as the result.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallRequest> streamingInputCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests with each request served by the server immediately.
* As one request could lead to multiple responses, this interface
* demonstrates the idea of full duplexing.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver);
/**
* <pre>
* A sequence of requests followed by a sequence of responses.
* The server buffers all the client requests and then serves them in order. A
* stream of responses are returned to the client when the server starts with
* first request.
* </pre>
*/
public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver);
}
@ -159,21 +217,59 @@ public class TestServiceGrpc {
}
}
/**
* <pre>
* A simple service to test the various types of RPCs and experiment with
* performance with various types of payload.
* </pre>
*/
public static interface TestServiceBlockingClient {
/**
* <pre>
* One empty request followed by one empty response.
* </pre>
*/
public com.google.protobuf.EmptyProtos.Empty emptyCall(com.google.protobuf.EmptyProtos.Empty request);
/**
* <pre>
* One request followed by one response.
* </pre>
*/
public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request);
/**
* <pre>
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
* </pre>
*/
public java.util.Iterator<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> streamingOutputCall(
io.grpc.testing.integration.Messages.StreamingOutputCallRequest request);
}
/**
* <pre>
* A simple service to test the various types of RPCs and experiment with
* performance with various types of payload.
* </pre>
*/
public static interface TestServiceFutureClient {
/**
* <pre>
* One empty request followed by one empty response.
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<com.google.protobuf.EmptyProtos.Empty> emptyCall(
com.google.protobuf.EmptyProtos.Empty request);
/**
* <pre>
* One request followed by one response.
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.SimpleResponse> unaryCall(
io.grpc.testing.integration.Messages.SimpleRequest request);
}

48
interop-testing/src/generated/main/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
View File

@ -15,6 +15,12 @@ import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
/**
* <pre>
* A simple service NOT implemented at servers so clients can test for
* that case.
* </pre>
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 0.14.0-SNAPSHOT)",
comments = "Source: io/grpc/testing/integration/test.proto")
@ -35,22 +41,42 @@ public class UnimplementedServiceGrpc {
io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()),
io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()));
/**
* Creates a new async stub that supports all call types for the service
*/
public static UnimplementedServiceStub newStub(io.grpc.Channel channel) {
return new UnimplementedServiceStub(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) {
return new UnimplementedServiceBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
*/
public static UnimplementedServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
return new UnimplementedServiceFutureStub(channel);
}
/**
* <pre>
* A simple service NOT implemented at servers so clients can test for
* that case.
* </pre>
*/
public static interface UnimplementedService {
/**
* <pre>
* A call that no server should implement
* </pre>
*/
public void unimplementedCall(com.google.protobuf.EmptyProtos.Empty request,
io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver);
}
@ -69,13 +95,35 @@ public class UnimplementedServiceGrpc {
}
}
/**
* <pre>
* A simple service NOT implemented at servers so clients can test for
* that case.
* </pre>
*/
public static interface UnimplementedServiceBlockingClient {
/**
* <pre>
* A call that no server should implement
* </pre>
*/
public com.google.protobuf.EmptyProtos.Empty unimplementedCall(com.google.protobuf.EmptyProtos.Empty request);
}
/**
* <pre>
* A simple service NOT implemented at servers so clients can test for
* that case.
* </pre>
*/
public static interface UnimplementedServiceFutureClient {
/**
* <pre>
* A call that no server should implement
* </pre>
*/
public com.google.common.util.concurrent.ListenableFuture<com.google.protobuf.EmptyProtos.Empty> unimplementedCall(
com.google.protobuf.EmptyProtos.Empty request);
}