The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#) https://grpc.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

978 lines
35 KiB

//
//
// Copyright 2016 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//
#include <memory>
#include <thread>
#include <gtest/gtest.h>
#include "absl/log/check.h"
#include <grpc/grpc.h>
#include <grpcpp/channel.h>
#include <grpcpp/client_context.h>
#include <grpcpp/create_channel.h>
#include <grpcpp/generic/async_generic_service.h>
#include <grpcpp/server.h>
#include <grpcpp/server_builder.h>
#include <grpcpp/server_context.h>
#include "src/core/lib/gprpp/env.h"
#include "src/core/lib/iomgr/iomgr.h"
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/test_util/port.h"
#include "test/core/test_util/test_config.h"
#include "test/cpp/end2end/test_service_impl.h"
#include "test/cpp/util/byte_buffer_proto_helper.h"
namespace grpc {
namespace testing {
namespace {
void* tag(int i) { return reinterpret_cast<void*>(i); }
bool VerifyReturnSuccess(CompletionQueue* cq, int i) {
void* got_tag;
bool ok;
EXPECT_TRUE(cq->Next(&got_tag, &ok));
EXPECT_EQ(tag(i), got_tag);
return ok;
}
void Verify(CompletionQueue* cq, int i, bool expect_ok) {
EXPECT_EQ(expect_ok, VerifyReturnSuccess(cq, i));
}
// Handlers to handle async request at a server. To be run in a separate thread.
template <class Service>
void HandleEcho(Service* service, ServerCompletionQueue* cq, bool dup_service) {
ServerContext srv_ctx;
grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx);
EchoRequest recv_request;
EchoResponse send_response;
service->RequestEcho(&srv_ctx, &recv_request, &response_writer, cq, cq,
tag(1));
Verify(cq, 1, true);
send_response.set_message(recv_request.message());
if (dup_service) {
send_response.mutable_message()->append("_dup");
}
response_writer.Finish(send_response, Status::OK, tag(2));
Verify(cq, 2, true);
}
// Handlers to handle raw request at a server. To be run in a
// separate thread. Note that this is the same as the async version, except
// that the req/resp are ByteBuffers
template <class Service>
void HandleRawEcho(Service* service, ServerCompletionQueue* cq,
bool /*dup_service*/) {
ServerContext srv_ctx;
GenericServerAsyncResponseWriter response_writer(&srv_ctx);
ByteBuffer recv_buffer;
service->RequestEcho(&srv_ctx, &recv_buffer, &response_writer, cq, cq,
tag(1));
Verify(cq, 1, true);
EchoRequest recv_request;
EXPECT_TRUE(ParseFromByteBuffer(&recv_buffer, &recv_request));
EchoResponse send_response;
send_response.set_message(recv_request.message());
auto send_buffer = SerializeToByteBuffer(&send_response);
response_writer.Finish(*send_buffer, Status::OK, tag(2));
Verify(cq, 2, true);
}
template <class Service>
void HandleClientStreaming(Service* service, ServerCompletionQueue* cq) {
ServerContext srv_ctx;
EchoRequest recv_request;
EchoResponse send_response;
ServerAsyncReader<EchoResponse, EchoRequest> srv_stream(&srv_ctx);
service->RequestRequestStream(&srv_ctx, &srv_stream, cq, cq, tag(1));
Verify(cq, 1, true);
int i = 1;
do {
i++;
send_response.mutable_message()->append(recv_request.message());
srv_stream.Read(&recv_request, tag(i));
} while (VerifyReturnSuccess(cq, i));
srv_stream.Finish(send_response, Status::OK, tag(100));
Verify(cq, 100, true);
}
template <class Service>
void HandleRawClientStreaming(Service* service, ServerCompletionQueue* cq) {
ServerContext srv_ctx;
ByteBuffer recv_buffer;
EchoRequest recv_request;
EchoResponse send_response;
GenericServerAsyncReader srv_stream(&srv_ctx);
service->RequestRequestStream(&srv_ctx, &srv_stream, cq, cq, tag(1));
Verify(cq, 1, true);
int i = 1;
while (true) {
i++;
srv_stream.Read(&recv_buffer, tag(i));
if (!VerifyReturnSuccess(cq, i)) {
break;
}
EXPECT_TRUE(ParseFromByteBuffer(&recv_buffer, &recv_request));
send_response.mutable_message()->append(recv_request.message());
}
auto send_buffer = SerializeToByteBuffer(&send_response);
srv_stream.Finish(*send_buffer, Status::OK, tag(100));
Verify(cq, 100, true);
}
template <class Service>
void HandleServerStreaming(Service* service, ServerCompletionQueue* cq) {
ServerContext srv_ctx;
EchoRequest recv_request;
EchoResponse send_response;
ServerAsyncWriter<EchoResponse> srv_stream(&srv_ctx);
service->RequestResponseStream(&srv_ctx, &recv_request, &srv_stream, cq, cq,
tag(1));
Verify(cq, 1, true);
send_response.set_message(recv_request.message() + "0");
srv_stream.Write(send_response, tag(2));
Verify(cq, 2, true);
send_response.set_message(recv_request.message() + "1");
srv_stream.Write(send_response, tag(3));
Verify(cq, 3, true);
send_response.set_message(recv_request.message() + "2");
srv_stream.Write(send_response, tag(4));
Verify(cq, 4, true);
srv_stream.Finish(Status::OK, tag(5));
Verify(cq, 5, true);
}
void HandleGenericEcho(GenericServerAsyncReaderWriter* stream,
CompletionQueue* cq) {
ByteBuffer recv_buffer;
stream->Read(&recv_buffer, tag(2));
Verify(cq, 2, true);
EchoRequest recv_request;
EXPECT_TRUE(ParseFromByteBuffer(&recv_buffer, &recv_request));
EchoResponse send_response;
send_response.set_message(recv_request.message());
auto send_buffer = SerializeToByteBuffer(&send_response);
stream->Write(*send_buffer, tag(3));
Verify(cq, 3, true);
stream->Finish(Status::OK, tag(4));
Verify(cq, 4, true);
}
void HandleGenericRequestStream(GenericServerAsyncReaderWriter* stream,
CompletionQueue* cq) {
ByteBuffer recv_buffer;
EchoRequest recv_request;
EchoResponse send_response;
int i = 1;
while (true) {
i++;
stream->Read(&recv_buffer, tag(i));
if (!VerifyReturnSuccess(cq, i)) {
break;
}
EXPECT_TRUE(ParseFromByteBuffer(&recv_buffer, &recv_request));
send_response.mutable_message()->append(recv_request.message());
}
auto send_buffer = SerializeToByteBuffer(&send_response);
stream->Write(*send_buffer, tag(99));
Verify(cq, 99, true);
stream->Finish(Status::OK, tag(100));
Verify(cq, 100, true);
}
// Request and handle one generic call.
void HandleGenericCall(AsyncGenericService* service,
ServerCompletionQueue* cq) {
GenericServerContext srv_ctx;
GenericServerAsyncReaderWriter stream(&srv_ctx);
service->RequestCall(&srv_ctx, &stream, cq, cq, tag(1));
Verify(cq, 1, true);
if (srv_ctx.method() == "/grpc.testing.EchoTestService/Echo") {
HandleGenericEcho(&stream, cq);
} else if (srv_ctx.method() ==
"/grpc.testing.EchoTestService/RequestStream") {
HandleGenericRequestStream(&stream, cq);
} else { // other methods not handled yet.
gpr_log(GPR_ERROR, "method: %s", srv_ctx.method().c_str());
CHECK(0);
}
}
class TestServiceImplDupPkg
: public grpc::testing::duplicate::EchoTestService::Service {
public:
Status Echo(ServerContext* /*context*/, const EchoRequest* request,
EchoResponse* response) override {
response->set_message(request->message() + "_dup");
return Status::OK;
}
};
class HybridEnd2endTest : public ::testing::TestWithParam<bool> {
protected:
HybridEnd2endTest() {}
static void SetUpTestSuite() {
#if TARGET_OS_IPHONE
// Workaround Apple CFStream bug
grpc_core::SetEnv("grpc_cfstream", "0");
#endif
}
void SetUp() override {
inproc_ = (::testing::UnitTest::GetInstance()
->current_test_info()
->value_param() != nullptr)
? GetParam()
: false;
}
bool SetUpServer(grpc::Service* service1, grpc::Service* service2,
AsyncGenericService* generic_service,
CallbackGenericService* callback_generic_service,
int max_message_size = 0) {
int port = grpc_pick_unused_port_or_die();
server_address_ << "localhost:" << port;
// Setup server
ServerBuilder builder;
builder.AddListeningPort(server_address_.str(),
grpc::InsecureServerCredentials());
// Always add a sync unimplemented service: we rely on having at least one
// synchronous method to get a listening cq
builder.RegisterService(&unimplemented_service_);
builder.RegisterService(service1);
if (service2) {
builder.RegisterService(service2);
}
if (generic_service) {
builder.RegisterAsyncGenericService(generic_service);
}
if (callback_generic_service) {
builder.RegisterCallbackGenericService(callback_generic_service);
}
if (max_message_size != 0) {
builder.SetMaxMessageSize(max_message_size);
}
// Create a separate cq for each potential handler.
for (int i = 0; i < 5; i++) {
cqs_.push_back(builder.AddCompletionQueue(false));
}
server_ = builder.BuildAndStart();
// If there is a generic callback service, this setup is only successful if
// we have an iomgr that can run in the background or are inprocess
return !callback_generic_service || grpc_iomgr_run_in_background() ||
inproc_;
}
void TearDown() override {
if (server_) {
server_->Shutdown();
}
void* ignored_tag;
bool ignored_ok;
for (auto it = cqs_.begin(); it != cqs_.end(); ++it) {
(*it)->Shutdown();
while ((*it)->Next(&ignored_tag, &ignored_ok)) {
}
}
}
void ResetStub() {
std::shared_ptr<Channel> channel =
inproc_ ? server_->InProcessChannel(ChannelArguments())
: grpc::CreateChannel(server_address_.str(),
InsecureChannelCredentials());
stub_ = grpc::testing::EchoTestService::NewStub(channel);
}
// Test all rpc methods.
void TestAllMethods() {
SendEcho();
SendSimpleClientStreaming();
SendSimpleServerStreaming();
SendBidiStreaming();
}
void SendEcho() {
EchoRequest send_request;
EchoResponse recv_response;
ClientContext cli_ctx;
cli_ctx.set_wait_for_ready(true);
send_request.set_message("Hello");
Status recv_status = stub_->Echo(&cli_ctx, send_request, &recv_response);
EXPECT_EQ(send_request.message(), recv_response.message());
EXPECT_TRUE(recv_status.ok());
}
void SendEchoToDupService() {
std::shared_ptr<Channel> channel = grpc::CreateChannel(
server_address_.str(), InsecureChannelCredentials());
auto stub = grpc::testing::duplicate::EchoTestService::NewStub(channel);
EchoRequest send_request;
EchoResponse recv_response;
ClientContext cli_ctx;
cli_ctx.set_wait_for_ready(true);
send_request.set_message("Hello");
Status recv_status = stub->Echo(&cli_ctx, send_request, &recv_response);
EXPECT_EQ(send_request.message() + "_dup", recv_response.message());
EXPECT_TRUE(recv_status.ok());
}
void SendSimpleClientStreaming() {
EchoRequest send_request;
EchoResponse recv_response;
std::string expected_message;
ClientContext cli_ctx;
cli_ctx.set_wait_for_ready(true);
send_request.set_message("Hello");
auto stream = stub_->RequestStream(&cli_ctx, &recv_response);
for (int i = 0; i < 5; i++) {
EXPECT_TRUE(stream->Write(send_request));
expected_message.append(send_request.message());
}
stream->WritesDone();
Status recv_status = stream->Finish();
EXPECT_EQ(expected_message, recv_response.message());
EXPECT_TRUE(recv_status.ok());
}
void SendSimpleServerStreaming() {
EchoRequest request;
EchoResponse response;
ClientContext context;
context.set_wait_for_ready(true);
request.set_message("hello");
auto stream = stub_->ResponseStream(&context, request);
EXPECT_TRUE(stream->Read(&response));
EXPECT_EQ(response.message(), request.message() + "0");
EXPECT_TRUE(stream->Read(&response));
EXPECT_EQ(response.message(), request.message() + "1");
EXPECT_TRUE(stream->Read(&response));
EXPECT_EQ(response.message(), request.message() + "2");
EXPECT_FALSE(stream->Read(&response));
Status s = stream->Finish();
EXPECT_TRUE(s.ok());
}
void SendSimpleServerStreamingToDupService() {
std::shared_ptr<Channel> channel = grpc::CreateChannel(
server_address_.str(), InsecureChannelCredentials());
auto stub = grpc::testing::duplicate::EchoTestService::NewStub(channel);
EchoRequest request;
EchoResponse response;
ClientContext context;
context.set_wait_for_ready(true);
request.set_message("hello");
auto stream = stub->ResponseStream(&context, request);
EXPECT_TRUE(stream->Read(&response));
EXPECT_EQ(response.message(), request.message() + "0_dup");
EXPECT_TRUE(stream->Read(&response));
EXPECT_EQ(response.message(), request.message() + "1_dup");
EXPECT_TRUE(stream->Read(&response));
EXPECT_EQ(response.message(), request.message() + "2_dup");
EXPECT_FALSE(stream->Read(&response));
Status s = stream->Finish();
EXPECT_TRUE(s.ok());
}
void SendBidiStreaming() {
EchoRequest request;
EchoResponse response;
ClientContext context;
context.set_wait_for_ready(true);
std::string msg("hello");
auto stream = stub_->BidiStream(&context);
request.set_message(msg + "0");
EXPECT_TRUE(stream->Write(request));
EXPECT_TRUE(stream->Read(&response));
EXPECT_EQ(response.message(), request.message());
request.set_message(msg + "1");
EXPECT_TRUE(stream->Write(request));
EXPECT_TRUE(stream->Read(&response));
EXPECT_EQ(response.message(), request.message());
request.set_message(msg + "2");
EXPECT_TRUE(stream->Write(request));
EXPECT_TRUE(stream->Read(&response));
EXPECT_EQ(response.message(), request.message());
stream->WritesDone();
EXPECT_FALSE(stream->Read(&response));
EXPECT_FALSE(stream->Read(&response));
Status s = stream->Finish();
EXPECT_TRUE(s.ok());
}
grpc::testing::UnimplementedEchoService::Service unimplemented_service_;
std::vector<std::unique_ptr<ServerCompletionQueue>> cqs_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<Server> server_;
std::ostringstream server_address_;
bool inproc_;
};
TEST_F(HybridEnd2endTest, AsyncEcho) {
typedef EchoTestService::WithAsyncMethod_Echo<TestServiceImpl> SType;
SType service;
SetUpServer(&service, nullptr, nullptr, nullptr);
ResetStub();
std::thread echo_handler_thread(HandleEcho<SType>, &service, cqs_[0].get(),
false);
TestAllMethods();
echo_handler_thread.join();
}
TEST_F(HybridEnd2endTest, RawEcho) {
typedef EchoTestService::WithRawMethod_Echo<TestServiceImpl> SType;
SType service;
SetUpServer(&service, nullptr, nullptr, nullptr);
ResetStub();
std::thread echo_handler_thread(HandleRawEcho<SType>, &service, cqs_[0].get(),
false);
TestAllMethods();
echo_handler_thread.join();
}
TEST_F(HybridEnd2endTest, RawRequestStream) {
typedef EchoTestService::WithRawMethod_RequestStream<TestServiceImpl> SType;
SType service;
SetUpServer(&service, nullptr, nullptr, nullptr);
ResetStub();
std::thread request_stream_handler_thread(HandleRawClientStreaming<SType>,
&service, cqs_[0].get());
TestAllMethods();
request_stream_handler_thread.join();
}
TEST_F(HybridEnd2endTest, AsyncEchoRawRequestStream) {
typedef EchoTestService::WithRawMethod_RequestStream<
EchoTestService::WithAsyncMethod_Echo<TestServiceImpl>>
SType;
SType service;
SetUpServer(&service, nullptr, nullptr, nullptr);
ResetStub();
std::thread echo_handler_thread(HandleEcho<SType>, &service, cqs_[0].get(),
false);
std::thread request_stream_handler_thread(HandleRawClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
request_stream_handler_thread.join();
echo_handler_thread.join();
}
TEST_F(HybridEnd2endTest, GenericEchoRawRequestStream) {
typedef EchoTestService::WithRawMethod_RequestStream<
EchoTestService::WithGenericMethod_Echo<TestServiceImpl>>
SType;
SType service;
AsyncGenericService generic_service;
SetUpServer(&service, nullptr, &generic_service, nullptr);
ResetStub();
std::thread generic_handler_thread(HandleGenericCall, &generic_service,
cqs_[0].get());
std::thread request_stream_handler_thread(HandleRawClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
generic_handler_thread.join();
request_stream_handler_thread.join();
}
TEST_F(HybridEnd2endTest, AsyncEchoRequestStream) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_Echo<TestServiceImpl>>
SType;
SType service;
SetUpServer(&service, nullptr, nullptr, nullptr);
ResetStub();
std::thread echo_handler_thread(HandleEcho<SType>, &service, cqs_[0].get(),
false);
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
echo_handler_thread.join();
request_stream_handler_thread.join();
}
TEST_F(HybridEnd2endTest, AsyncRequestStreamResponseStream) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>
SType;
SType service;
SetUpServer(&service, nullptr, nullptr, nullptr);
ResetStub();
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
&service, cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
response_stream_handler_thread.join();
request_stream_handler_thread.join();
}
// Add a second service with one sync method.
TEST_F(HybridEnd2endTest, AsyncRequestStreamResponseStreamSyncDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>
SType;
SType service;
TestServiceImplDupPkg dup_service;
SetUpServer(&service, &dup_service, nullptr, nullptr);
ResetStub();
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
&service, cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
SendEchoToDupService();
response_stream_handler_thread.join();
request_stream_handler_thread.join();
}
// Add a second service with one sync streamed unary method.
class StreamedUnaryDupPkg
: public duplicate::EchoTestService::WithStreamedUnaryMethod_Echo<
TestServiceImplDupPkg> {
public:
Status StreamedEcho(
ServerContext* /*context*/,
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req;
EchoResponse resp;
uint32_t next_msg_sz;
stream->NextMessageSize(&next_msg_sz);
gpr_log(GPR_INFO, "Streamed Unary Next Message Size is %u", next_msg_sz);
CHECK(stream->Read(&req));
resp.set_message(req.message() + "_dup");
CHECK(stream->Write(resp));
return Status::OK;
}
};
TEST_F(HybridEnd2endTest,
AsyncRequestStreamResponseStreamSyncStreamedUnaryDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>
SType;
SType service;
StreamedUnaryDupPkg dup_service;
SetUpServer(&service, &dup_service, nullptr, nullptr, 8192);
ResetStub();
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
&service, cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
SendEchoToDupService();
response_stream_handler_thread.join();
request_stream_handler_thread.join();
}
// Add a second service that is fully Streamed Unary
class FullyStreamedUnaryDupPkg
: public duplicate::EchoTestService::StreamedUnaryService {
public:
Status StreamedEcho(
ServerContext* /*context*/,
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req;
EchoResponse resp;
uint32_t next_msg_sz;
stream->NextMessageSize(&next_msg_sz);
gpr_log(GPR_INFO, "Streamed Unary Next Message Size is %u", next_msg_sz);
CHECK(stream->Read(&req));
resp.set_message(req.message() + "_dup");
CHECK(stream->Write(resp));
return Status::OK;
}
};
TEST_F(HybridEnd2endTest,
AsyncRequestStreamResponseStreamSyncFullyStreamedUnaryDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>
SType;
SType service;
FullyStreamedUnaryDupPkg dup_service;
SetUpServer(&service, &dup_service, nullptr, nullptr, 8192);
ResetStub();
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
&service, cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
SendEchoToDupService();
response_stream_handler_thread.join();
request_stream_handler_thread.join();
}
// Add a second service with one sync split server streaming method.
class SplitResponseStreamDupPkg
: public duplicate::EchoTestService::
WithSplitStreamingMethod_ResponseStream<TestServiceImplDupPkg> {
public:
Status StreamedResponseStream(
ServerContext* /*context*/,
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req;
EchoResponse resp;
uint32_t next_msg_sz;
stream->NextMessageSize(&next_msg_sz);
gpr_log(GPR_INFO, "Split Streamed Next Message Size is %u", next_msg_sz);
CHECK(stream->Read(&req));
for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
resp.set_message(req.message() + std::to_string(i) + "_dup");
CHECK(stream->Write(resp));
}
return Status::OK;
}
};
TEST_F(HybridEnd2endTest,
AsyncRequestStreamResponseStreamSyncSplitStreamedDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>
SType;
SType service;
SplitResponseStreamDupPkg dup_service;
SetUpServer(&service, &dup_service, nullptr, nullptr, 8192);
ResetStub();
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
&service, cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
SendSimpleServerStreamingToDupService();
response_stream_handler_thread.join();
request_stream_handler_thread.join();
}
// Add a second service that is fully split server streamed
class FullySplitStreamedDupPkg
: public duplicate::EchoTestService::SplitStreamedService {
public:
Status StreamedResponseStream(
ServerContext* /*context*/,
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req;
EchoResponse resp;
uint32_t next_msg_sz;
stream->NextMessageSize(&next_msg_sz);
gpr_log(GPR_INFO, "Split Streamed Next Message Size is %u", next_msg_sz);
CHECK(stream->Read(&req));
for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
resp.set_message(req.message() + std::to_string(i) + "_dup");
CHECK(stream->Write(resp));
}
return Status::OK;
}
};
TEST_F(HybridEnd2endTest,
asyncRequestStreamResponseStreamFullySplitStreamedDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>
SType;
SType service;
FullySplitStreamedDupPkg dup_service;
SetUpServer(&service, &dup_service, nullptr, nullptr, 8192);
ResetStub();
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
&service, cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
SendSimpleServerStreamingToDupService();
response_stream_handler_thread.join();
request_stream_handler_thread.join();
}
// Add a second service that is fully server streamed
class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService {
public:
Status StreamedEcho(
ServerContext* /*context*/,
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req;
EchoResponse resp;
uint32_t next_msg_sz;
stream->NextMessageSize(&next_msg_sz);
gpr_log(GPR_INFO, "Streamed Unary Next Message Size is %u", next_msg_sz);
CHECK(stream->Read(&req));
resp.set_message(req.message() + "_dup");
CHECK(stream->Write(resp));
return Status::OK;
}
Status StreamedResponseStream(
ServerContext* /*context*/,
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override {
EchoRequest req;
EchoResponse resp;
uint32_t next_msg_sz;
stream->NextMessageSize(&next_msg_sz);
gpr_log(GPR_INFO, "Split Streamed Next Message Size is %u", next_msg_sz);
CHECK(stream->Read(&req));
for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
resp.set_message(req.message() + std::to_string(i) + "_dup");
CHECK(stream->Write(resp));
}
return Status::OK;
}
};
TEST_F(HybridEnd2endTest,
AsyncRequestStreamResponseStreamFullyStreamedDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>
SType;
SType service;
FullyStreamedDupPkg dup_service;
SetUpServer(&service, &dup_service, nullptr, nullptr, 8192);
ResetStub();
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
&service, cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
SendEchoToDupService();
SendSimpleServerStreamingToDupService();
response_stream_handler_thread.join();
request_stream_handler_thread.join();
}
// Add a second service with one async method.
TEST_F(HybridEnd2endTest, AsyncRequestStreamResponseStreamAsyncDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>
SType;
SType service;
duplicate::EchoTestService::AsyncService dup_service;
SetUpServer(&service, &dup_service, nullptr, nullptr);
ResetStub();
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
&service, cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
std::thread echo_handler_thread(
HandleEcho<duplicate::EchoTestService::AsyncService>, &dup_service,
cqs_[2].get(), true);
TestAllMethods();
SendEchoToDupService();
response_stream_handler_thread.join();
request_stream_handler_thread.join();
echo_handler_thread.join();
}
TEST_F(HybridEnd2endTest, GenericEcho) {
EchoTestService::WithGenericMethod_Echo<TestServiceImpl> service;
AsyncGenericService generic_service;
SetUpServer(&service, nullptr, &generic_service, nullptr);
ResetStub();
std::thread generic_handler_thread(HandleGenericCall, &generic_service,
cqs_[0].get());
TestAllMethods();
generic_handler_thread.join();
}
TEST_P(HybridEnd2endTest, CallbackGenericEcho) {
EchoTestService::WithGenericMethod_Echo<TestServiceImpl> service;
class GenericEchoService : public CallbackGenericService {
private:
ServerGenericBidiReactor* CreateReactor(
GenericCallbackServerContext* context) override {
EXPECT_EQ(context->method(), "/grpc.testing.EchoTestService/Echo");
gpr_log(GPR_DEBUG, "Constructor of generic service %d",
static_cast<int>(context->deadline().time_since_epoch().count()));
class Reactor : public ServerGenericBidiReactor {
public:
Reactor() { StartRead(&request_); }
private:
void OnDone() override { delete this; }
void OnReadDone(bool ok) override {
if (!ok) {
EXPECT_EQ(reads_complete_, 1);
} else {
EXPECT_EQ(reads_complete_++, 0);
response_ = request_;
StartWrite(&response_);
StartRead(&request_);
}
}
void OnWriteDone(bool ok) override {
Finish(ok ? Status::OK
: Status(StatusCode::UNKNOWN, "Unexpected failure"));
}
ByteBuffer request_;
ByteBuffer response_;
std::atomic_int reads_complete_{0};
};
return new Reactor;
}
} generic_service;
if (!SetUpServer(&service, nullptr, nullptr, &generic_service)) {
return;
}
ResetStub();
TestAllMethods();
}
TEST_F(HybridEnd2endTest, GenericEchoAsyncRequestStream) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithGenericMethod_Echo<TestServiceImpl>>
SType;
SType service;
AsyncGenericService generic_service;
SetUpServer(&service, nullptr, &generic_service, nullptr);
ResetStub();
std::thread generic_handler_thread(HandleGenericCall, &generic_service,
cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
generic_handler_thread.join();
request_stream_handler_thread.join();
}
// Add a second service with one sync method.
TEST_F(HybridEnd2endTest, GenericEchoAsyncRequestStreamSyncDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithGenericMethod_Echo<TestServiceImpl>>
SType;
SType service;
AsyncGenericService generic_service;
TestServiceImplDupPkg dup_service;
SetUpServer(&service, &dup_service, &generic_service, nullptr);
ResetStub();
std::thread generic_handler_thread(HandleGenericCall, &generic_service,
cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
TestAllMethods();
SendEchoToDupService();
generic_handler_thread.join();
request_stream_handler_thread.join();
}
// Add a second service with one async method.
TEST_F(HybridEnd2endTest, GenericEchoAsyncRequestStreamAsyncDupService) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithGenericMethod_Echo<TestServiceImpl>>
SType;
SType service;
AsyncGenericService generic_service;
duplicate::EchoTestService::AsyncService dup_service;
SetUpServer(&service, &dup_service, &generic_service, nullptr);
ResetStub();
std::thread generic_handler_thread(HandleGenericCall, &generic_service,
cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
std::thread echo_handler_thread(
HandleEcho<duplicate::EchoTestService::AsyncService>, &dup_service,
cqs_[2].get(), true);
TestAllMethods();
SendEchoToDupService();
generic_handler_thread.join();
request_stream_handler_thread.join();
echo_handler_thread.join();
}
TEST_F(HybridEnd2endTest, GenericEchoAsyncRequestStreamResponseStream) {
typedef EchoTestService::WithAsyncMethod_RequestStream<
EchoTestService::WithGenericMethod_Echo<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>>
SType;
SType service;
AsyncGenericService generic_service;
SetUpServer(&service, nullptr, &generic_service, nullptr);
ResetStub();
std::thread generic_handler_thread(HandleGenericCall, &generic_service,
cqs_[0].get());
std::thread request_stream_handler_thread(HandleClientStreaming<SType>,
&service, cqs_[1].get());
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
&service, cqs_[2].get());
TestAllMethods();
generic_handler_thread.join();
request_stream_handler_thread.join();
response_stream_handler_thread.join();
}
TEST_F(HybridEnd2endTest, GenericEchoRequestStreamAsyncResponseStream) {
typedef EchoTestService::WithGenericMethod_RequestStream<
EchoTestService::WithGenericMethod_Echo<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>>
SType;
SType service;
AsyncGenericService generic_service;
SetUpServer(&service, nullptr, &generic_service, nullptr);
ResetStub();
std::thread generic_handler_thread(HandleGenericCall, &generic_service,
cqs_[0].get());
std::thread generic_handler_thread2(HandleGenericCall, &generic_service,
cqs_[1].get());
std::thread response_stream_handler_thread(HandleServerStreaming<SType>,
&service, cqs_[2].get());
TestAllMethods();
generic_handler_thread.join();
generic_handler_thread2.join();
response_stream_handler_thread.join();
}
// If WithGenericMethod is called and no generic service is registered, the
// server will fail to build.
TEST_F(HybridEnd2endTest, GenericMethodWithoutGenericService) {
EchoTestService::WithGenericMethod_RequestStream<
EchoTestService::WithGenericMethod_Echo<
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>>
service;
SetUpServer(&service, nullptr, nullptr, nullptr);
EXPECT_EQ(nullptr, server_.get());
}
INSTANTIATE_TEST_SUITE_P(HybridEnd2endTest, HybridEnd2endTest,
::testing::Bool());
} // namespace
} // namespace testing
} // namespace grpc
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}