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.

232 lines
8.1 KiB

//
//
// Copyright 2020 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 <sstream>
#include "absl/flags/flag.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_split.h"
#include "absl/synchronization/mutex.h"
#include <grpc/grpc.h>
#include <grpc/support/log.h>
#include <grpc/support/time.h>
#include <grpcpp/ext/admin_services.h>
#include <grpcpp/ext/proto_server_reflection_plugin.h>
#include <grpcpp/health_check_service_interface.h>
#include <grpcpp/server.h>
#include <grpcpp/server_builder.h>
#include <grpcpp/server_context.h>
#include <grpcpp/xds_server_builder.h>
#include "src/core/lib/gpr/string.h"
#include "src/core/lib/gprpp/crash.h"
#include "src/core/lib/iomgr/gethostname.h"
#include "src/core/lib/transport/transport.h"
#include "src/proto/grpc/testing/empty.pb.h"
#include "src/proto/grpc/testing/messages.pb.h"
#include "src/proto/grpc/testing/test.grpc.pb.h"
#include "test/core/util/test_config.h"
#include "test/cpp/end2end/test_health_check_service_impl.h"
#include "test/cpp/util/test_config.h"
ABSL_FLAG(int32_t, port, 8080, "Server port for service.");
ABSL_FLAG(int32_t, maintenance_port, 8081,
"Server port for maintenance if --security is \"secure\".");
ABSL_FLAG(std::string, server_id, "cpp_server",
"Server ID to include in responses.");
ABSL_FLAG(bool, secure_mode, false,
"If true, XdsServerCredentials are used, InsecureServerCredentials "
"otherwise");
using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using grpc::XdsServerBuilder;
using grpc::testing::Empty;
using grpc::testing::HealthCheckServiceImpl;
using grpc::testing::SimpleRequest;
using grpc::testing::SimpleResponse;
using grpc::testing::TestService;
using grpc::testing::XdsUpdateHealthService;
namespace {
constexpr absl::string_view kRpcBehaviorMetadataKey = "rpc-behavior";
constexpr absl::string_view kErrorCodeRpcBehavior = "error-code-";
std::set<std::string> GetRpcBehaviorMetadata(ServerContext* context) {
std::set<std::string> rpc_behaviors;
auto rpc_behavior_metadata =
context->client_metadata().equal_range(grpc::string_ref(
kRpcBehaviorMetadataKey.data(), kRpcBehaviorMetadataKey.length()));
for (auto metadata = rpc_behavior_metadata.first;
metadata != rpc_behavior_metadata.second; ++metadata) {
auto value = metadata->second;
for (auto behavior :
absl::StrSplit(absl::string_view(value.data(), value.length()), ',')) {
rpc_behaviors.emplace(behavior);
}
}
return rpc_behaviors;
}
absl::optional<grpc::Status> GetStatusForRpcBehaviorMetadata(
absl::string_view header_value) {
if (absl::StartsWith(header_value, kErrorCodeRpcBehavior)) {
grpc::StatusCode code;
if (absl::SimpleAtoi(header_value.substr(kErrorCodeRpcBehavior.length()),
&code)) {
std::string message = absl::StrCat(
"Rpc failed as per the rpc-behavior header value: ", header_value);
return Status(code, message);
} else {
std::string message = absl::StrCat(
"Invalid format for rpc-behavior header: ", header_value);
return Status(grpc::StatusCode::INVALID_ARGUMENT, message);
}
} else {
return absl::nullopt;
}
}
} // namespace
class TestServiceImpl : public TestService::Service {
public:
explicit TestServiceImpl(const std::string& hostname) : hostname_(hostname) {}
Status UnaryCall(ServerContext* context, const SimpleRequest* /*request*/,
SimpleResponse* response) override {
response->set_server_id(absl::GetFlag(FLAGS_server_id));
for (const auto& rpc_behavior : GetRpcBehaviorMetadata(context)) {
auto maybe_status = GetStatusForRpcBehaviorMetadata(rpc_behavior);
if (maybe_status.has_value()) {
return *maybe_status;
}
}
response->set_hostname(hostname_);
context->AddInitialMetadata("hostname", hostname_);
return Status::OK;
}
Status EmptyCall(ServerContext* context, const Empty* /*request*/,
Empty* /*response*/) override {
context->AddInitialMetadata("hostname", hostname_);
return Status::OK;
}
private:
std::string hostname_;
};
class XdsUpdateHealthServiceImpl : public XdsUpdateHealthService::Service {
public:
explicit XdsUpdateHealthServiceImpl(
HealthCheckServiceImpl* health_check_service)
: health_check_service_(health_check_service) {}
Status SetServing(ServerContext* /* context */, const Empty* /* request */,
Empty* /* response */) override {
health_check_service_->SetAll(
grpc::health::v1::HealthCheckResponse::SERVING);
return Status::OK;
}
Status SetNotServing(ServerContext* /* context */, const Empty* /* request */,
Empty* /* response */) override {
health_check_service_->SetAll(
grpc::health::v1::HealthCheckResponse::NOT_SERVING);
return Status::OK;
}
private:
HealthCheckServiceImpl* const health_check_service_;
};
void RunServer(bool secure_mode, const int port, const int maintenance_port,
const std::string& hostname) {
std::unique_ptr<Server> xds_enabled_server;
std::unique_ptr<Server> server;
TestServiceImpl service(hostname);
HealthCheckServiceImpl health_check_service;
health_check_service.SetStatus(
"", grpc::health::v1::HealthCheckResponse::SERVING);
health_check_service.SetStatus(
"grpc.testing.TestService",
grpc::health::v1::HealthCheckResponse::SERVING);
health_check_service.SetStatus(
"grpc.testing.XdsUpdateHealthService",
grpc::health::v1::HealthCheckResponse::SERVING);
XdsUpdateHealthServiceImpl update_health_service(&health_check_service);
grpc::reflection::InitProtoReflectionServerBuilderPlugin();
ServerBuilder builder;
if (secure_mode) {
XdsServerBuilder xds_builder;
xds_builder.RegisterService(&service);
xds_builder.AddListeningPort(
absl::StrCat("0.0.0.0:", port),
grpc::XdsServerCredentials(grpc::InsecureServerCredentials()));
xds_enabled_server = xds_builder.BuildAndStart();
gpr_log(GPR_INFO, "Server starting on 0.0.0.0:%d", port);
builder.RegisterService(&health_check_service);
builder.RegisterService(&update_health_service);
grpc::AddAdminServices(&builder);
builder.AddListeningPort(absl::StrCat("0.0.0.0:", maintenance_port),
grpc::InsecureServerCredentials());
server = builder.BuildAndStart();
gpr_log(GPR_INFO, "Maintenance server listening on 0.0.0.0:%d",
maintenance_port);
} else {
builder.RegisterService(&service);
builder.RegisterService(&health_check_service);
builder.RegisterService(&update_health_service);
grpc::AddAdminServices(&builder);
builder.AddListeningPort(absl::StrCat("0.0.0.0:", port),
grpc::InsecureServerCredentials());
server = builder.BuildAndStart();
gpr_log(GPR_INFO, "Server listening on 0.0.0.0:%d", port);
}
server->Wait();
}
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
grpc::testing::InitTest(&argc, &argv, true);
char* hostname = grpc_gethostname();
if (hostname == nullptr) {
std::cout << "Failed to get hostname, terminating" << std::endl;
return 1;
}
int port = absl::GetFlag(FLAGS_port);
if (port == 0) {
std::cout << "Invalid port, terminating" << std::endl;
return 1;
}
int maintenance_port = absl::GetFlag(FLAGS_maintenance_port);
if (maintenance_port == 0) {
std::cout << "Invalid maintenance port, terminating" << std::endl;
return 1;
}
grpc::EnableDefaultHealthCheckService(false);
RunServer(absl::GetFlag(FLAGS_secure_mode), port, maintenance_port, hostname);
return 0;
}