diff --git a/include/grpc++/ext/reflection.grpc.pb.h b/include/grpc++/ext/reflection.grpc.pb.h
index 18ec2ea1ecc20c3a64f540705e4c3a4f98669f29..822c2e374a80212cc35920ee465029d4ad71c5ef 100644
--- a/include/grpc++/ext/reflection.grpc.pb.h
+++ b/include/grpc++/ext/reflection.grpc.pb.h
@@ -74,10 +74,10 @@
#include <grpc++/impl/codegen/async_stream.h>
#include <grpc++/impl/codegen/async_unary_call.h>
-#include <grpc++/impl/codegen/fc_unary.h>
#include <grpc++/impl/codegen/method_handler_impl.h>
#include <grpc++/impl/codegen/proto_utils.h>
#include <grpc++/impl/codegen/rpc_method.h>
+#include <grpc++/impl/codegen/server_streamed_unary.h>
#include <grpc++/impl/codegen/service_type.h>
#include <grpc++/impl/codegen/status.h>
#include <grpc++/impl/codegen/stub_options.h>
diff --git a/include/grpc++/impl/codegen/completion_queue.h b/include/grpc++/impl/codegen/completion_queue.h
index 95ece77ce5c2207417ef4e7dae997809cad0d05c..ea317a7a79b102f202c736a0ea2e21dfcddeac88 100644
--- a/include/grpc++/impl/codegen/completion_queue.h
+++ b/include/grpc++/impl/codegen/completion_queue.h
@@ -78,8 +78,6 @@ template <class ServiceType, class RequestType, class ResponseType>
class ServerStreamingHandler;
template <class ServiceType, class RequestType, class ResponseType>
class BidiStreamingHandler;
-template <class ServiceType, class RequestType, class ResponseType>
-class FCUnaryMethodHandler;
class UnknownMethodHandler;
class Channel;
@@ -187,10 +185,8 @@ class CompletionQueue : private GrpcLibraryCodegen {
friend class ClientStreamingHandler;
template <class ServiceType, class RequestType, class ResponseType>
friend class ServerStreamingHandler;
- template <class ServiceType, class RequestType, class ResponseType>
- friend class BidiStreamingHandler;
- template <class ServiceType, class RequestType, class ResponseType>
- friend class FCUnaryMethodHandler;
+ template <class Streamer, bool WriteNeeded>
+ friend class TemplatedBidiStreamingHandler;
friend class UnknownMethodHandler;
friend class ::grpc::Server;
friend class ::grpc::ServerContext;
diff --git a/include/grpc++/impl/codegen/method_handler_impl.h b/include/grpc++/impl/codegen/method_handler_impl.h
index 9c3af53b3a33f604182388e9ebd348230335e797..3a671fe830a8c9dc43470c302c2c47a3b64144d9 100644
--- a/include/grpc++/impl/codegen/method_handler_impl.h
+++ b/include/grpc++/impl/codegen/method_handler_impl.h
@@ -35,8 +35,8 @@
#define GRPCXX_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H
#include <grpc++/impl/codegen/core_codegen_interface.h>
-#include <grpc++/impl/codegen/fc_unary.h>
#include <grpc++/impl/codegen/rpc_service_method.h>
+#include <grpc++/impl/codegen/server_streamed_unary.h>
#include <grpc++/impl/codegen/sync_stream.h>
namespace grpc {
@@ -168,20 +168,23 @@ class ServerStreamingHandler : public MethodHandler {
};
// A wrapper class of an application provided bidi-streaming handler.
-template <class ServiceType, class RequestType, class ResponseType>
-class BidiStreamingHandler : public MethodHandler {
+// This also applies to server-streamed implementation of a unary method
+// with the additional requirement that such methods must have done a
+// write for status to be ok
+// Since this is used by more than 1 class, the service is not passed in.
+// Instead, it is expected to be an implicitly-captured argument of func
+// (through bind or something along those lines)
+template <class Streamer, bool WriteNeeded>
+class TemplatedBidiStreamingHandler : public MethodHandler {
public:
- BidiStreamingHandler(
- std::function<Status(ServiceType*, ServerContext*,
- ServerReaderWriter<ResponseType, RequestType>*)>
- func,
- ServiceType* service)
- : func_(func), service_(service) {}
+ TemplatedBidiStreamingHandler(
+ std::function<Status(ServerContext*, Streamer*)>
+ func)
+ : func_(func), write_needed_(WriteNeeded) {}
void RunHandler(const HandlerParameter& param) GRPC_FINAL {
- ServerReaderWriter<ResponseType, RequestType> stream(param.call,
- param.server_context);
- Status status = func_(service_, param.server_context, &stream);
+ Streamer stream(param.call, param.server_context);
+ Status status = func_(param.server_context, &stream);
CallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus> ops;
if (!param.server_context->sent_initial_metadata_) {
@@ -190,6 +193,12 @@ class BidiStreamingHandler : public MethodHandler {
if (param.server_context->compression_level_set()) {
ops.set_compression_level(param.server_context->compression_level());
}
+ if (write_needed_ && status.ok()) {
+ // If we needed a write but never did one, we need to mark the
+ // status as a fail
+ status = Status(IMPROPER_IMPLEMENTATION,
+ "Service did not provide response message");
+ }
}
ops.ServerSendStatus(param.server_context->trailing_metadata_, status);
param.call->PerformOps(&ops);
@@ -197,46 +206,24 @@ class BidiStreamingHandler : public MethodHandler {
}
private:
- std::function<Status(ServiceType*, ServerContext*,
- ServerReaderWriter<ResponseType, RequestType>*)>
- func_;
- ServiceType* service_;
+ std::function<Status(ServerContext*, Streamer*)>
+ func_;
+ const bool write_needed_;
};
-// A wrapper class of an application provided rpc method handler
-// specifically to apply to the flow-controlled implementation of a unary
-// method.
-/// The argument to the constructor should be a member function already
-/// bound to the appropriate service instance. The declaration gets too
-/// complicated
-/// otherwise.
template <class ServiceType, class RequestType, class ResponseType>
-class FCUnaryMethodHandler : public MethodHandler {
+ class BidiStreamingHandler : public TemplatedBidiStreamingHandler<ServerReaderWriter<ResponseType, RequestType>, false> {
public:
- FCUnaryMethodHandler(
- std::function<Status(ServerContext*, FCUnary<RequestType, ResponseType>*)>
- func)
- : func_(func) {}
+ BidiStreamingHandler(std::function<Status(ServiceType*, ServerContext*,
+ ServerReaderWriter<ResponseType,RequestType>*)> func, ServiceType* service): TemplatedBidiStreamingHandler<ServerReaderWriter<ResponseType, RequestType>,false>(std::bind(func, service, std::placeholders::_1, std::placeholders::_2)) {}
+ };
- void RunHandler(const HandlerParameter& param) GRPC_FINAL {
- FCUnary<RequestType, ResponseType> fc_unary(param.call,
- param.server_context);
- Status status = func_(param.server_context, &fc_unary);
- if (!param.server_context->sent_initial_metadata_) {
- // means that the write never happened, which is bad
- } else {
- CallOpSet<CallOpServerSendStatus> ops;
- ops.ServerSendStatus(param.server_context->trailing_metadata_, status);
- param.call->PerformOps(&ops);
- param.call->cq()->Pluck(&ops);
- }
- }
-
- private:
- // Application provided rpc handler function, already bound to its service.
- std::function<Status(ServerContext*, FCUnary<RequestType, ResponseType>*)>
- func_;
-};
+ template <class RequestType, class ResponseType>
+ class StreamedUnaryHandler : public TemplatedBidiStreamingHandler<ServerUnaryStreamer<RequestType, ResponseType>, true> {
+ public:
+ explicit StreamedUnaryHandler(std::function<Status(ServerContext*,
+ ServerUnaryStreamer<RequestType,ResponseType>*)> func): TemplatedBidiStreamingHandler<ServerUnaryStreamer<RequestType, ResponseType>, true>(func) {}
+ };
// Handle unknown method by returning UNIMPLEMENTED error.
class UnknownMethodHandler : public MethodHandler {
diff --git a/include/grpc++/impl/codegen/server_context.h b/include/grpc++/impl/codegen/server_context.h
index aadae893ad36e48aa79095449586b542721b56e4..8e101c3f15b04bb20c76bc53b3922a720b70765f 100644
--- a/include/grpc++/impl/codegen/server_context.h
+++ b/include/grpc++/impl/codegen/server_context.h
@@ -75,8 +75,6 @@ template <class ServiceType, class RequestType, class ResponseType>
class ServerStreamingHandler;
template <class ServiceType, class RequestType, class ResponseType>
class BidiStreamingHandler;
-template <class ServiceType, class RequestType, class ResponseType>
-class FCUnaryMethodHandler;
class UnknownMethodHandler;
class Call;
@@ -192,10 +190,8 @@ class ServerContext {
friend class ClientStreamingHandler;
template <class ServiceType, class RequestType, class ResponseType>
friend class ServerStreamingHandler;
- template <class ServiceType, class RequestType, class ResponseType>
- friend class BidiStreamingHandler;
- template <class ServiceType, class RequestType, class ResponseType>
- friend class FCUnaryMethodHandler;
+ template <class Streamer, bool WriteNeeded>
+ friend class TemplatedBidiStreamingHandler;
friend class UnknownMethodHandler;
friend class ::grpc::ClientContext;
diff --git a/include/grpc++/impl/codegen/fc_unary.h b/include/grpc++/impl/codegen/server_streamed_unary.h
similarity index 86%
rename from include/grpc++/impl/codegen/fc_unary.h
rename to include/grpc++/impl/codegen/server_streamed_unary.h
index a423f1f0b3e40adbca4ad62c29b774f40fb142a5..a23e6020ed22fbeb56fb7d8c2f5658023fa91251 100644
--- a/include/grpc++/impl/codegen/fc_unary.h
+++ b/include/grpc++/impl/codegen/server_streamed_unary.h
@@ -31,8 +31,8 @@
*
*/
-#ifndef GRPCXX_IMPL_CODEGEN_FC_UNARY_H
-#define GRPCXX_IMPL_CODEGEN_FC_UNARY_H
+#ifndef GRPCXX_IMPL_CODEGEN_SERVER_STREAMED_UNARY_H
+#define GRPCXX_IMPL_CODEGEN_SERVER_STREAMED_UNARY_H
#include <grpc++/impl/codegen/call.h>
#include <grpc++/impl/codegen/completion_queue.h>
@@ -47,19 +47,19 @@ namespace grpc {
/// as though it were a single-ping-pong streaming call. The server can use
/// the \a NextMessageSize method to determine an upper-bound on the size of
/// the message.
-/// A key difference relative to streaming: an FCUnary must have exactly 1 Read
-/// and exactly 1 Write, in that order, to function correctly.
-/// Otherwise, the RPC is in error.
+/// A key difference relative to streaming: ServerUnaryStreamer
+/// must have exactly 1 Read and exactly 1 Write, in that order, to function
+/// correctly. Otherwise, the RPC is in error.
template <class RequestType, class ResponseType>
-class FCUnary GRPC_FINAL
+class ServerUnaryStreamer GRPC_FINAL
: public ServerReaderWriterInterface<ResponseType, RequestType> {
public:
- FCUnary(Call* call, ServerContext* ctx)
+ ServerUnaryStreamer(Call* call, ServerContext* ctx)
: ServerReaderWriterInterface<ResponseType, RequestType>(call, ctx),
read_done_(false),
write_done_(false) {}
- ~FCUnary() {}
+ ~ServerUnaryStreamer() {}
bool Read(RequestType* request) GRPC_OVERRIDE {
if (read_done_) {
@@ -87,4 +87,4 @@ class FCUnary GRPC_FINAL
};
} // namespace grpc
-#endif // GRPCXX_IMPL_CODEGEN_FC_UNARY_H
+#endif // GRPCXX_IMPL_CODEGEN_SERVER_STREAMED_UNARY_H
diff --git a/include/grpc++/impl/codegen/service_type.h b/include/grpc++/impl/codegen/service_type.h
index 4af40422a1b6e11343d12aae806fe15d675e338c..9d2a80cbc43a45280d6f0267a2729bdddffa2b2a 100644
--- a/include/grpc++/impl/codegen/service_type.h
+++ b/include/grpc++/impl/codegen/service_type.h
@@ -147,10 +147,11 @@ class Service {
methods_[index].reset();
}
- void MarkMethodFCUnary(int index, MethodHandler* fc_unary_method) {
+ void MarkMethodStreamedUnary(int index,
+ MethodHandler* streamed_unary_method) {
GPR_CODEGEN_ASSERT(methods_[index] && methods_[index]->handler() &&
- "Cannot mark an async or generic method as FCUnary");
- methods_[index]->SetHandler(fc_unary_method);
+ "Cannot mark an async or generic method Streamed Unary");
+ methods_[index]->SetHandler(streamed_unary_method);
// From the server's point of view, streamed unary is a special
// case of BIDI_STREAMING that has 1 read and 1 write, in that order.
diff --git a/include/grpc++/impl/codegen/status_code_enum.h b/include/grpc++/impl/codegen/status_code_enum.h
index 9a90a18e2a53305eab91737d757a605b89f0ad2f..0f18a22c3666f1e9f26cd60017f2fb314b4c4c63 100644
--- a/include/grpc++/impl/codegen/status_code_enum.h
+++ b/include/grpc++/impl/codegen/status_code_enum.h
@@ -143,6 +143,11 @@ enum StatusCode {
/// Unrecoverable data loss or corruption.
DATA_LOSS = 15,
+ // Service was improperly implemented, violated a gRPC API requirement
+ // Not quite the same as unimplemented since it could just be that the API
+ // requirement was violated in this particular circumstance
+ IMPROPER_IMPLEMENTATION = 16,
+
/// Force users to include a default branch:
DO_NOT_USE = -1
};
diff --git a/include/grpc++/support/fc_unary.h b/include/grpc++/support/server_streamed_unary.h
similarity index 88%
rename from include/grpc++/support/fc_unary.h
rename to include/grpc++/support/server_streamed_unary.h
index 7e7dea8feb2c4d14f3ce391606ee39f502ca789b..109dfd4bcabc3ccf228252ee4cb5438d79f14b5b 100644
--- a/include/grpc++/support/fc_unary.h
+++ b/include/grpc++/support/server_streamed_unary.h
@@ -31,9 +31,9 @@
*
*/
-#ifndef GRPCXX_SUPPORT_FC_UNARY_H
-#define GRPCXX_SUPPORT_FC_UNARY_H
+#ifndef GRPCXX_SUPPORT_SERVER_STREAMED_UNARY_H
+#define GRPCXX_SUPPORT_SERVER_STREAMED_UNARY_H
-#include <grpc++/impl/codegen/fc_unary.h>
+#include <grpc++/impl/codegen/server_streamed_unary.h>
-#endif // GRPCXX_SUPPORT_FC_UNARY_H
+#endif // GRPCXX_SUPPORT_SERVER_STREAMED_UNARY_H
diff --git a/src/compiler/cpp_generator.cc b/src/compiler/cpp_generator.cc
index c5d4c2573d900cba531e399934bcc4cf5382f53f..7c70567d12022a97345532b8c7127306375e0c55 100644
--- a/src/compiler/cpp_generator.cc
+++ b/src/compiler/cpp_generator.cc
@@ -130,10 +130,10 @@ grpc::string GetHeaderIncludes(File *file, const Parameters ¶ms) {
static const char *headers_strs[] = {
"grpc++/impl/codegen/async_stream.h",
"grpc++/impl/codegen/async_unary_call.h",
- "grpc++/impl/codegen/fc_unary.h",
"grpc++/impl/codegen/method_handler_impl.h",
"grpc++/impl/codegen/proto_utils.h",
"grpc++/impl/codegen/rpc_method.h",
+ "grpc++/impl/codegen/server_streamed_unary.h",
"grpc++/impl/codegen/service_type.h",
"grpc++/impl/codegen/status.h",
"grpc++/impl/codegen/stub_options.h",
@@ -606,7 +606,7 @@ void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
printer->Print(*vars, "};\n");
}
-void PrintHeaderServerMethodFCUnary(
+void PrintHeaderServerMethodStreamedUnary(
Printer *printer, const Method *method,
std::map<grpc::string, grpc::string> *vars) {
(*vars)["Method"] = method->name();
@@ -615,7 +615,8 @@ void PrintHeaderServerMethodFCUnary(
if (method->NoStreaming()) {
printer->Print(*vars, "template <class BaseClass>\n");
printer->Print(*vars,
- "class WithFCUnaryMethod_$Method$ : public BaseClass {\n");
+ "class WithStreamedUnaryMethod_$Method$ : "
+ "public BaseClass {\n");
printer->Print(
" private:\n"
" void BaseClassMustBeDerivedFromService(const Service *service) "
@@ -623,17 +624,16 @@ void PrintHeaderServerMethodFCUnary(
printer->Print(" public:\n");
printer->Indent();
printer->Print(*vars,
- "WithFCUnaryMethod_$Method$() {\n"
- " ::grpc::Service::MarkMethodFCUnary($Idx$,\n"
- " new ::grpc::FCUnaryMethodHandler<Service, "
- "$Request$, "
- "$Response$>("
- "std::bind(&WithFCUnaryMethod_$Method$<BaseClass>::FC$"
- "Method$, this, std::placeholders::_1, "
- "std::placeholders::_2)));\n"
+ "WithStreamedUnaryMethod_$Method$() {\n"
+ " ::grpc::Service::MarkMethodStreamedUnary($Idx$,\n"
+ " new ::grpc::StreamedUnaryHandler<$Request$, "
+ "$Response$>(std::bind"
+ "(&WithStreamedUnaryMethod_$Method$<BaseClass>::"
+ "Streamed$Method$, this, std::placeholders::_1, "
+ "std::placeholders::_2)));\n"
"}\n");
printer->Print(*vars,
- "~WithFCUnaryMethod_$Method$() GRPC_OVERRIDE {\n"
+ "~WithStreamedUnaryMethod_$Method$() GRPC_OVERRIDE {\n"
" BaseClassMustBeDerivedFromService(this);\n"
"}\n");
printer->Print(
@@ -646,10 +646,11 @@ void PrintHeaderServerMethodFCUnary(
" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
"}\n");
printer->Print(*vars,
- "// replace default version of this method with FCUnary\n"
- "virtual ::grpc::Status FC$Method$("
- "::grpc::ServerContext* context, ::grpc::FCUnary< "
- "$Request$,$Response$>* fc_unary)"
+ "// replace default version of method with streamed unary\n"
+ "virtual ::grpc::Status Streamed$Method$("
+ "::grpc::ServerContext* context, "
+ "::grpc::ServerUnaryStreamer< "
+ "$Request$,$Response$>* server_unary_streamer)"
" = 0;\n");
printer->Outdent();
printer->Print(*vars, "};\n");
@@ -822,17 +823,18 @@ void PrintHeaderService(Printer *printer, const Service *service,
PrintHeaderServerMethodGeneric(printer, service->method(i).get(), vars);
}
- // Server side - FC Unary
+ // Server side - Streamed Unary
for (int i = 0; i < service->method_count(); ++i) {
(*vars)["Idx"] = as_string(i);
- PrintHeaderServerMethodFCUnary(printer, service->method(i).get(), vars);
+ PrintHeaderServerMethodStreamedUnary(printer, service->method(i).get(),
+ vars);
}
printer->Print("typedef ");
for (int i = 0; i < service->method_count(); ++i) {
(*vars)["method_name"] = service->method(i).get()->name();
if (service->method(i)->NoStreaming()) {
- printer->Print(*vars, "WithFCUnaryMethod_$method_name$<");
+ printer->Print(*vars, "WithStreamedUnaryMethod_$method_name$<");
}
}
printer->Print("Service");
@@ -841,7 +843,7 @@ void PrintHeaderService(Printer *printer, const Service *service,
printer->Print(" >");
}
}
- printer->Print(" FCUnaryService;\n");
+ printer->Print(" StreamedUnaryService;\n");
printer->Outdent();
printer->Print("};\n");
@@ -943,9 +945,9 @@ grpc::string GetSourceIncludes(File *file, const Parameters ¶ms) {
"grpc++/impl/codegen/async_unary_call.h",
"grpc++/impl/codegen/channel_interface.h",
"grpc++/impl/codegen/client_unary_call.h",
- "grpc++/impl/codegen/fc_unary.h",
"grpc++/impl/codegen/method_handler_impl.h",
"grpc++/impl/codegen/rpc_service_method.h",
+ "grpc++/impl/codegen/server_streamed_unary.h",
"grpc++/impl/codegen/service_type.h",
"grpc++/impl/codegen/sync_stream.h"};
std::vector<grpc::string> headers(headers_strs, array_end(headers_strs));
diff --git a/src/cpp/ext/reflection.grpc.pb.cc b/src/cpp/ext/reflection.grpc.pb.cc
index f4a0b97d65d1de504499cdaaec872214fc2d1c8d..6603eadc4eee36f4d7d4c6807f9dd117a1b594e5 100644
--- a/src/cpp/ext/reflection.grpc.pb.cc
+++ b/src/cpp/ext/reflection.grpc.pb.cc
@@ -43,9 +43,9 @@
#include <grpc++/impl/codegen/async_unary_call.h>
#include <grpc++/impl/codegen/channel_interface.h>
#include <grpc++/impl/codegen/client_unary_call.h>
-#include <grpc++/impl/codegen/fc_unary.h>
#include <grpc++/impl/codegen/method_handler_impl.h>
#include <grpc++/impl/codegen/rpc_service_method.h>
+#include <grpc++/impl/codegen/server_streamed_unary.h>
#include <grpc++/impl/codegen/service_type.h>
#include <grpc++/impl/codegen/sync_stream.h>
namespace grpc {
diff --git a/test/cpp/end2end/hybrid_end2end_test.cc b/test/cpp/end2end/hybrid_end2end_test.cc
index 1512e99a3c2fd1068bf46568bd49df7265e4833d..eb7125cb040b26da18df532fb9c8d80660830349 100644
--- a/test/cpp/end2end/hybrid_end2end_test.cc
+++ b/test/cpp/end2end/hybrid_end2end_test.cc
@@ -421,31 +421,33 @@ TEST_F(HybridEnd2endTest, AsyncRequestStreamResponseStream_SyncDupService) {
request_stream_handler_thread.join();
}
-// Add a second service with one sync FCUnary method.
-class FCUnaryDupPkg : public duplicate::EchoTestService::WithFCUnaryMethod_Echo<
+// Add a second service with one sync streamed unary method.
+class StreamedUnaryDupPkg : public
+ duplicate::EchoTestService::WithStreamedUnaryMethod_Echo<
TestServiceImplDupPkg> {
public:
- Status FCEcho(ServerContext* context,
- FCUnary<EchoRequest, EchoResponse>* fc_unary) GRPC_OVERRIDE {
+ Status StreamedEcho(ServerContext* context,
+ ServerUnaryStreamer<EchoRequest, EchoResponse>* stream)
+ GRPC_OVERRIDE {
EchoRequest req;
EchoResponse resp;
uint32_t next_msg_sz;
- fc_unary->NextMessageSize(&next_msg_sz);
- gpr_log(GPR_INFO, "FC Unary Next Message Size is %u", next_msg_sz);
- GPR_ASSERT(fc_unary->Read(&req));
+ stream->NextMessageSize(&next_msg_sz);
+ gpr_log(GPR_INFO, "Streamed Unary Next Message Size is %u", next_msg_sz);
+ GPR_ASSERT(stream->Read(&req));
resp.set_message(req.message() + "_dup");
- GPR_ASSERT(fc_unary->Write(resp));
+ GPR_ASSERT(stream->Write(resp));
return Status::OK;
}
};
TEST_F(HybridEnd2endTest,
- AsyncRequestStreamResponseStream_SyncFCUnaryDupService) {
+ AsyncRequestStreamResponseStream_SyncStreamedUnaryDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>
SType;
SType service;
- FCUnaryDupPkg dup_service;
+ StreamedUnaryDupPkg dup_service;
SetUpServer(&service, &dup_service, nullptr, 8192);
ResetStub();
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
@@ -458,30 +460,31 @@ TEST_F(HybridEnd2endTest,
request_stream_handler_thread.join();
}
-// Add a second service that is fully FCUnary
-class FullyFCUnaryDupPkg : public duplicate::EchoTestService::FCUnaryService {
+// Add a second service that is fully Streamed Unary
+class FullyStreamedUnaryDupPkg : public duplicate::EchoTestService::StreamedUnaryService {
public:
- Status FCEcho(ServerContext* context,
- FCUnary<EchoRequest, EchoResponse>* fc_unary) GRPC_OVERRIDE {
+ Status StreamedEcho(ServerContext* context,
+ ServerUnaryStreamer<EchoRequest, EchoResponse>* stream)
+ GRPC_OVERRIDE {
EchoRequest req;
EchoResponse resp;
uint32_t next_msg_sz;
- fc_unary->NextMessageSize(&next_msg_sz);
- gpr_log(GPR_INFO, "FC Unary Next Message Size is %u", next_msg_sz);
- GPR_ASSERT(fc_unary->Read(&req));
+ stream->NextMessageSize(&next_msg_sz);
+ gpr_log(GPR_INFO, "Streamed Unary Next Message Size is %u", next_msg_sz);
+ GPR_ASSERT(stream->Read(&req));
resp.set_message(req.message() + "_dup");
- GPR_ASSERT(fc_unary->Write(resp));
+ GPR_ASSERT(stream->Write(resp));
return Status::OK;
}
};
TEST_F(HybridEnd2endTest,
- AsyncRequestStreamResponseStream_SyncFullyFCUnaryDupService) {
+ AsyncRequestStreamResponseStream_SyncFullyStreamedUnaryDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>
SType;
SType service;
- FullyFCUnaryDupPkg dup_service;
+ FullyStreamedUnaryDupPkg dup_service;
SetUpServer(&service, &dup_service, nullptr, 8192);
ResetStub();
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,