1 //
2 //
3 // Copyright 2017 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 <grpc/event_engine/slice_buffer.h>
20 #include <grpc/grpc.h>
21 #include <grpcpp/server.h>
22 #include <grpcpp/server_builder.h>
23 #include <grpcpp/support/config.h>
24 #include <gtest/gtest.h>
25 #include <sys/socket.h>
26
27 #include "src/core/util/notification.h"
28 #include "src/proto/grpc/testing/echo.grpc.pb.h"
29 #include "test/core/event_engine/event_engine_test_utils.h"
30 #include "test/core/test_util/port.h"
31 #include "test/core/test_util/test_config.h"
32
33 namespace grpc {
34 namespace {
35
36 testing::EchoTestService::Service g_service;
37
MakePort()38 std::string MakePort() {
39 std::ostringstream s;
40 int p = grpc_pick_unused_port_or_die();
41 s << "localhost:" << p;
42 return s.str();
43 }
44
GetPort()45 const std::string& GetPort() {
46 static std::string g_port = MakePort();
47 return g_port;
48 }
49
50 class ServerBuilderTest : public ::testing::Test {
51 protected:
SetUpTestSuite()52 static void SetUpTestSuite() { grpc_init(); }
53
TearDownTestSuite()54 static void TearDownTestSuite() { grpc_shutdown(); }
55 };
TEST_F(ServerBuilderTest,NoOp)56 TEST_F(ServerBuilderTest, NoOp) { ServerBuilder b; }
57
TEST_F(ServerBuilderTest,CreateServerNoPorts)58 TEST_F(ServerBuilderTest, CreateServerNoPorts) {
59 ServerBuilder().RegisterService(&g_service).BuildAndStart()->Shutdown();
60 }
61
TEST_F(ServerBuilderTest,CreateServerOnePort)62 TEST_F(ServerBuilderTest, CreateServerOnePort) {
63 ServerBuilder()
64 .RegisterService(&g_service)
65 .AddListeningPort(GetPort(), InsecureServerCredentials())
66 .BuildAndStart()
67 ->Shutdown();
68 }
69
TEST_F(ServerBuilderTest,CreateServerRepeatedPort)70 TEST_F(ServerBuilderTest, CreateServerRepeatedPort) {
71 ServerBuilder()
72 .RegisterService(&g_service)
73 .AddListeningPort(GetPort(), InsecureServerCredentials())
74 .AddListeningPort(GetPort(), InsecureServerCredentials())
75 .BuildAndStart()
76 ->Shutdown();
77 }
78
TEST_F(ServerBuilderTest,CreateServerRepeatedPortWithDisallowedReusePort)79 TEST_F(ServerBuilderTest, CreateServerRepeatedPortWithDisallowedReusePort) {
80 EXPECT_EQ(ServerBuilder()
81 .RegisterService(&g_service)
82 .AddListeningPort(GetPort(), InsecureServerCredentials())
83 .AddListeningPort(GetPort(), InsecureServerCredentials())
84 .AddChannelArgument(GRPC_ARG_ALLOW_REUSEPORT, 0)
85 .BuildAndStart(),
86 nullptr);
87 }
88
TEST_F(ServerBuilderTest,AddPassiveListener)89 TEST_F(ServerBuilderTest, AddPassiveListener) {
90 std::unique_ptr<experimental::PassiveListener> passive_listener;
91 auto server =
92 ServerBuilder()
93 .experimental()
94 .AddPassiveListener(InsecureServerCredentials(), passive_listener)
95 .BuildAndStart();
96 server->Shutdown();
97 }
98
TEST_F(ServerBuilderTest,PassiveListenerAcceptConnectedFd)99 TEST_F(ServerBuilderTest, PassiveListenerAcceptConnectedFd) {
100 std::unique_ptr<experimental::PassiveListener> passive_listener;
101 ServerBuilder builder;
102 auto cq = builder.AddCompletionQueue();
103 // TODO(hork): why is the service necessary? Queue isn't drained otherwise.
104 auto server =
105 builder.RegisterService(&g_service)
106 .experimental()
107 .AddPassiveListener(InsecureServerCredentials(), passive_listener)
108 .BuildAndStart();
109 ASSERT_NE(server.get(), nullptr);
110 #ifdef GPR_SUPPORT_CHANNELS_FROM_FD
111 int fd = socket(AF_INET, SOCK_STREAM, 0);
112 auto accept_status = passive_listener->AcceptConnectedFd(fd);
113 ASSERT_TRUE(accept_status.ok()) << accept_status;
114 #else
115 int fd = -1;
116 auto accept_status = passive_listener->AcceptConnectedFd(fd);
117 ASSERT_FALSE(accept_status.ok()) << accept_status;
118 #endif
119 server->Shutdown();
120 }
121
TEST_F(ServerBuilderTest,PassiveListenerAcceptConnectedEndpoint)122 TEST_F(ServerBuilderTest, PassiveListenerAcceptConnectedEndpoint) {
123 std::unique_ptr<experimental::PassiveListener> passive_listener;
124 auto server =
125 ServerBuilder()
126 .experimental()
127 .AddPassiveListener(InsecureServerCredentials(), passive_listener)
128 .BuildAndStart();
129 grpc_core::Notification endpoint_destroyed;
130 auto success = passive_listener->AcceptConnectedEndpoint(
131 std::make_unique<grpc_event_engine::experimental::ThreadedNoopEndpoint>(
132 &endpoint_destroyed));
133 ASSERT_TRUE(success.ok())
134 << "AcceptConnectedEndpoint failure: " << success.ToString();
135 endpoint_destroyed.WaitForNotification();
136 server->Shutdown();
137 }
138
139 } // namespace
140 } // namespace grpc
141
main(int argc,char ** argv)142 int main(int argc, char** argv) {
143 grpc::testing::TestEnvironment env(&argc, argv);
144 ::testing::InitGoogleTest(&argc, argv);
145 int ret = RUN_ALL_TESTS();
146 return ret;
147 }
148