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 <grpc/grpc.h>
20 #include <grpcpp/support/config.h>
21 #include <gtest/gtest.h>
22
23 #include "absl/log/check.h"
24 #include "google/protobuf/duration.upb.h"
25 #include "src/core/lib/address_utils/sockaddr_utils.h"
26 #include "src/core/lib/iomgr/sockaddr.h"
27 #include "src/core/load_balancing/grpclb/load_balancer_api.h"
28 #include "src/proto/grpc/lb/v1/load_balancer.pb.h" // C++ version
29 #include "test/core/test_util/test_config.h"
30 #include "upb/mem/arena.hpp"
31
32 namespace grpc {
33 namespace {
34
35 using grpc::lb::v1::LoadBalanceRequest;
36 using grpc::lb::v1::LoadBalanceResponse;
37
38 class GrpclbTest : public ::testing::Test {
39 protected:
SetUpTestSuite()40 static void SetUpTestSuite() { grpc_init(); }
41
TearDownTestSuite()42 static void TearDownTestSuite() { grpc_shutdown(); }
43 };
44
Ip4ToPackedString(const char * ip_str)45 std::string Ip4ToPackedString(const char* ip_str) {
46 struct in_addr ip4;
47 CHECK_EQ(inet_pton(AF_INET, ip_str, &ip4), 1);
48 return std::string(reinterpret_cast<const char*>(&ip4), sizeof(ip4));
49 }
50
PackedStringToIp(const grpc_core::GrpcLbServer & server)51 std::string PackedStringToIp(const grpc_core::GrpcLbServer& server) {
52 char ip_str[46] = {0};
53 int af = -1;
54 if (server.ip_size == 4) {
55 af = AF_INET;
56 } else if (server.ip_size == 16) {
57 af = AF_INET6;
58 } else {
59 abort();
60 }
61 CHECK_NE(inet_ntop(af, (void*)server.ip_addr, ip_str, 46), nullptr);
62 return ip_str;
63 }
64
TEST_F(GrpclbTest,CreateRequest)65 TEST_F(GrpclbTest, CreateRequest) {
66 const std::string service_name = "AServiceName";
67 LoadBalanceRequest request;
68 upb::Arena arena;
69 grpc_slice slice =
70 grpc_core::GrpcLbRequestCreate(service_name.c_str(), arena.ptr());
71 const int num_bytes_written = GRPC_SLICE_LENGTH(slice);
72 EXPECT_GT(num_bytes_written, 0);
73 request.ParseFromArray(GRPC_SLICE_START_PTR(slice), num_bytes_written);
74 EXPECT_EQ(request.initial_request().name(), service_name);
75 grpc_slice_unref(slice);
76 }
77
TEST_F(GrpclbTest,ParseInitialResponse)78 TEST_F(GrpclbTest, ParseInitialResponse) {
79 // Construct response to parse.
80 LoadBalanceResponse response;
81 auto* initial_response = response.mutable_initial_response();
82 auto* client_stats_report_interval =
83 initial_response->mutable_client_stats_report_interval();
84 client_stats_report_interval->set_seconds(123);
85 client_stats_report_interval->set_nanos(456000000);
86 const std::string encoded_response = response.SerializeAsString();
87 grpc_slice encoded_slice =
88 grpc_slice_from_copied_string(encoded_response.c_str());
89 // Test parsing.
90 grpc_core::GrpcLbResponse resp;
91 upb::Arena arena;
92 ASSERT_TRUE(
93 grpc_core::GrpcLbResponseParse(encoded_slice, arena.ptr(), &resp));
94 grpc_slice_unref(encoded_slice);
95 EXPECT_EQ(resp.type, resp.INITIAL);
96 EXPECT_EQ(resp.client_stats_report_interval,
97 grpc_core::Duration::Milliseconds(123456));
98 EXPECT_EQ(resp.serverlist.size(), 0);
99 }
100
TEST_F(GrpclbTest,ParseResponseServerList)101 TEST_F(GrpclbTest, ParseResponseServerList) {
102 // Construct response to parse.
103 LoadBalanceResponse response;
104 auto* serverlist = response.mutable_server_list();
105 auto* server = serverlist->add_servers();
106 server->set_ip_address(Ip4ToPackedString("127.0.0.1"));
107 server->set_port(12345);
108 server->set_load_balance_token("rate_limting");
109 server->set_drop(true);
110 server = response.mutable_server_list()->add_servers();
111 server->set_ip_address(Ip4ToPackedString("10.0.0.1"));
112 server->set_port(54321);
113 server->set_load_balance_token("load_balancing");
114 server->set_drop(true);
115 const std::string encoded_response = response.SerializeAsString();
116 const grpc_slice encoded_slice = grpc_slice_from_copied_buffer(
117 encoded_response.data(), encoded_response.size());
118 // Test parsing.
119 grpc_core::GrpcLbResponse resp;
120 upb::Arena arena;
121 ASSERT_TRUE(
122 grpc_core::GrpcLbResponseParse(encoded_slice, arena.ptr(), &resp));
123 grpc_slice_unref(encoded_slice);
124 EXPECT_EQ(resp.type, resp.SERVERLIST);
125 EXPECT_EQ(resp.serverlist.size(), 2);
126 EXPECT_EQ(PackedStringToIp(resp.serverlist[0]), "127.0.0.1");
127 EXPECT_EQ(resp.serverlist[0].port, 12345);
128 EXPECT_STREQ(resp.serverlist[0].load_balance_token, "rate_limting");
129 EXPECT_TRUE(resp.serverlist[0].drop);
130 EXPECT_EQ(PackedStringToIp(resp.serverlist[1]), "10.0.0.1");
131 EXPECT_EQ(resp.serverlist[1].port, 54321);
132 EXPECT_STREQ(resp.serverlist[1].load_balance_token, "load_balancing");
133 EXPECT_TRUE(resp.serverlist[1].drop);
134 }
135
136 } // namespace
137 } // namespace grpc
138
main(int argc,char ** argv)139 int main(int argc, char** argv) {
140 grpc::testing::TestEnvironment env(&argc, argv);
141 ::testing::InitGoogleTest(&argc, argv);
142 int ret = RUN_ALL_TESTS();
143 return ret;
144 }
145