1 /*
2 *
3 * Copyright 2016 gRPC authors.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19 #include <thread>
20
21 #include <grpc/grpc.h>
22 #include <grpcpp/channel.h>
23 #include <grpcpp/client_context.h>
24 #include <grpcpp/create_channel.h>
25 #include <grpcpp/impl/server_builder_option.h>
26 #include <grpcpp/impl/server_builder_plugin.h>
27 #include <grpcpp/impl/server_initializer.h>
28 #include <grpcpp/security/credentials.h>
29 #include <grpcpp/security/server_credentials.h>
30 #include <grpcpp/server.h>
31 #include <grpcpp/server_builder.h>
32 #include <grpcpp/server_context.h>
33
34 #include "src/proto/grpc/testing/echo.grpc.pb.h"
35 #include "test/core/util/port.h"
36 #include "test/core/util/test_config.h"
37 #include "test/cpp/end2end/test_service_impl.h"
38
39 #include <gtest/gtest.h>
40
41 #define PLUGIN_NAME "TestServerBuilderPlugin"
42
43 namespace grpc {
44 namespace testing {
45
46 class TestServerBuilderPlugin : public ServerBuilderPlugin {
47 public:
TestServerBuilderPlugin()48 TestServerBuilderPlugin() : service_(new TestServiceImpl()) {
49 init_server_is_called_ = false;
50 finish_is_called_ = false;
51 change_arguments_is_called_ = false;
52 register_service_ = false;
53 }
54
name()55 grpc::string name() override { return PLUGIN_NAME; }
56
InitServer(ServerInitializer * si)57 void InitServer(ServerInitializer* si) override {
58 init_server_is_called_ = true;
59 if (register_service_) {
60 si->RegisterService(service_);
61 }
62 }
63
Finish(ServerInitializer * si)64 void Finish(ServerInitializer* si) override { finish_is_called_ = true; }
65
ChangeArguments(const grpc::string & name,void * value)66 void ChangeArguments(const grpc::string& name, void* value) override {
67 change_arguments_is_called_ = true;
68 }
69
has_async_methods() const70 bool has_async_methods() const override {
71 if (register_service_) {
72 return service_->has_async_methods();
73 }
74 return false;
75 }
76
has_sync_methods() const77 bool has_sync_methods() const override {
78 if (register_service_) {
79 return service_->has_synchronous_methods();
80 }
81 return false;
82 }
83
SetRegisterService()84 void SetRegisterService() { register_service_ = true; }
85
init_server_is_called()86 bool init_server_is_called() { return init_server_is_called_; }
finish_is_called()87 bool finish_is_called() { return finish_is_called_; }
change_arguments_is_called()88 bool change_arguments_is_called() { return change_arguments_is_called_; }
89
90 private:
91 bool init_server_is_called_;
92 bool finish_is_called_;
93 bool change_arguments_is_called_;
94 bool register_service_;
95 std::shared_ptr<TestServiceImpl> service_;
96 };
97
98 class InsertPluginServerBuilderOption : public ServerBuilderOption {
99 public:
InsertPluginServerBuilderOption()100 InsertPluginServerBuilderOption() { register_service_ = false; }
101
UpdateArguments(ChannelArguments * arg)102 void UpdateArguments(ChannelArguments* arg) override {}
103
UpdatePlugins(std::vector<std::unique_ptr<ServerBuilderPlugin>> * plugins)104 void UpdatePlugins(
105 std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override {
106 plugins->clear();
107
108 std::unique_ptr<TestServerBuilderPlugin> plugin(
109 new TestServerBuilderPlugin());
110 if (register_service_) plugin->SetRegisterService();
111 plugins->emplace_back(std::move(plugin));
112 }
113
SetRegisterService()114 void SetRegisterService() { register_service_ = true; }
115
116 private:
117 bool register_service_;
118 };
119
CreateTestServerBuilderPlugin()120 std::unique_ptr<ServerBuilderPlugin> CreateTestServerBuilderPlugin() {
121 return std::unique_ptr<ServerBuilderPlugin>(new TestServerBuilderPlugin());
122 }
123
AddTestServerBuilderPlugin()124 void AddTestServerBuilderPlugin() {
125 static bool already_here = false;
126 if (already_here) return;
127 already_here = true;
128 ::grpc::ServerBuilder::InternalAddPluginFactory(
129 &CreateTestServerBuilderPlugin);
130 }
131
132 // Force AddServerBuilderPlugin() to be called at static initialization time.
133 struct StaticTestPluginInitializer {
StaticTestPluginInitializergrpc::testing::StaticTestPluginInitializer134 StaticTestPluginInitializer() { AddTestServerBuilderPlugin(); }
135 } static_plugin_initializer_test_;
136
137 // When the param boolean is true, the ServerBuilder plugin will be added at the
138 // time of static initialization. When it's false, the ServerBuilder plugin will
139 // be added using ServerBuilder::SetOption().
140 class ServerBuilderPluginTest : public ::testing::TestWithParam<bool> {
141 public:
ServerBuilderPluginTest()142 ServerBuilderPluginTest() {}
143
SetUp()144 void SetUp() override {
145 port_ = grpc_pick_unused_port_or_die();
146 builder_.reset(new ServerBuilder());
147 }
148
InsertPlugin()149 void InsertPlugin() {
150 if (GetParam()) {
151 // Add ServerBuilder plugin in static initialization
152 CheckPresent();
153 } else {
154 // Add ServerBuilder plugin using ServerBuilder::SetOption()
155 builder_->SetOption(std::unique_ptr<ServerBuilderOption>(
156 new InsertPluginServerBuilderOption()));
157 }
158 }
159
InsertPluginWithTestService()160 void InsertPluginWithTestService() {
161 if (GetParam()) {
162 // Add ServerBuilder plugin in static initialization
163 auto plugin = CheckPresent();
164 EXPECT_TRUE(plugin);
165 plugin->SetRegisterService();
166 } else {
167 // Add ServerBuilder plugin using ServerBuilder::SetOption()
168 std::unique_ptr<InsertPluginServerBuilderOption> option(
169 new InsertPluginServerBuilderOption());
170 option->SetRegisterService();
171 builder_->SetOption(std::move(option));
172 }
173 }
174
StartServer()175 void StartServer() {
176 grpc::string server_address = "localhost:" + to_string(port_);
177 builder_->AddListeningPort(server_address, InsecureServerCredentials());
178 // we run some tests without a service, and for those we need to supply a
179 // frequently polled completion queue
180 cq_ = builder_->AddCompletionQueue();
181 cq_thread_ = new std::thread(&ServerBuilderPluginTest::RunCQ, this);
182 server_ = builder_->BuildAndStart();
183 EXPECT_TRUE(CheckPresent());
184 }
185
ResetStub()186 void ResetStub() {
187 string target = "dns:localhost:" + to_string(port_);
188 channel_ = CreateChannel(target, InsecureChannelCredentials());
189 stub_ = grpc::testing::EchoTestService::NewStub(channel_);
190 }
191
TearDown()192 void TearDown() override {
193 auto plugin = CheckPresent();
194 EXPECT_TRUE(plugin);
195 EXPECT_TRUE(plugin->init_server_is_called());
196 EXPECT_TRUE(plugin->finish_is_called());
197 server_->Shutdown();
198 cq_->Shutdown();
199 cq_thread_->join();
200 delete cq_thread_;
201 }
202
to_string(const int number)203 string to_string(const int number) {
204 std::stringstream strs;
205 strs << number;
206 return strs.str();
207 }
208
209 protected:
210 std::shared_ptr<Channel> channel_;
211 std::unique_ptr<ServerBuilder> builder_;
212 std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
213 std::unique_ptr<ServerCompletionQueue> cq_;
214 std::unique_ptr<Server> server_;
215 std::thread* cq_thread_;
216 TestServiceImpl service_;
217 int port_;
218
219 private:
CheckPresent()220 TestServerBuilderPlugin* CheckPresent() {
221 auto it = builder_->plugins_.begin();
222 for (; it != builder_->plugins_.end(); it++) {
223 if ((*it)->name() == PLUGIN_NAME) break;
224 }
225 if (it != builder_->plugins_.end()) {
226 return static_cast<TestServerBuilderPlugin*>(it->get());
227 } else {
228 return nullptr;
229 }
230 }
231
RunCQ()232 void RunCQ() {
233 void* tag;
234 bool ok;
235 while (cq_->Next(&tag, &ok))
236 ;
237 }
238 };
239
TEST_P(ServerBuilderPluginTest,PluginWithoutServiceTest)240 TEST_P(ServerBuilderPluginTest, PluginWithoutServiceTest) {
241 InsertPlugin();
242 StartServer();
243 }
244
TEST_P(ServerBuilderPluginTest,PluginWithServiceTest)245 TEST_P(ServerBuilderPluginTest, PluginWithServiceTest) {
246 InsertPluginWithTestService();
247 StartServer();
248 ResetStub();
249
250 EchoRequest request;
251 EchoResponse response;
252 request.set_message("Hello hello hello hello");
253 ClientContext context;
254 context.set_compression_algorithm(GRPC_COMPRESS_GZIP);
255 Status s = stub_->Echo(&context, request, &response);
256 EXPECT_EQ(response.message(), request.message());
257 EXPECT_TRUE(s.ok());
258 }
259
260 INSTANTIATE_TEST_CASE_P(ServerBuilderPluginTest, ServerBuilderPluginTest,
261 ::testing::Values(false, true));
262
263 } // namespace testing
264 } // namespace grpc
265
main(int argc,char ** argv)266 int main(int argc, char** argv) {
267 grpc_test_init(argc, argv);
268 ::testing::InitGoogleTest(&argc, argv);
269 return RUN_ALL_TESTS();
270 }
271