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.

1030 lines
37 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 <grpc/support/port_platform.h>
#include "test/cpp/util/grpc_tool.h"
#include <cstdio>
#include <fstream>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <thread>
#include "absl/flags/flag.h"
#include "absl/memory/memory.h"
#include <grpc/grpc.h>
#include <grpcpp/channel.h>
#include <grpcpp/create_channel.h>
#include <grpcpp/grpcpp.h>
#include <grpcpp/security/credentials.h>
#include <grpcpp/support/string_ref.h>
#include "test/cpp/util/cli_call.h"
#include "test/cpp/util/proto_file_parser.h"
#include "test/cpp/util/proto_reflection_descriptor_database.h"
8 years ago
#include "test/cpp/util/service_describer.h"
#if GPR_WINDOWS
#include <io.h>
#else
#include <unistd.h>
#endif
ABSL_FLAG(bool, l, false, "Use a long listing format");
ABSL_FLAG(bool, remotedb, true,
"Use server types to parse and format messages");
ABSL_FLAG(std::string, metadata, "",
"Metadata to send to server, in the form of key1:val1:key2:val2");
ABSL_FLAG(std::string, proto_path, ".",
"Path to look for the proto file. "
"Multiple paths can be separated by " GRPC_CLI_PATH_SEPARATOR);
ABSL_FLAG(std::string, protofiles, "", "Name of the proto file.");
ABSL_FLAG(bool, binary_input, false, "Input in binary format");
ABSL_FLAG(bool, binary_output, false, "Output in binary format");
ABSL_FLAG(std::string, default_service_config, "",
"Default service config to use on the channel, if non-empty. Note "
"that this will be ignored if the name resolver returns a service "
"config.");
ABSL_FLAG(bool, display_peer_address, false,
"Log the peer socket address of the connection that each RPC is made "
"on to stderr.");
ABSL_FLAG(bool, json_input, false, "Input in json format");
ABSL_FLAG(bool, json_output, false, "Output in json format");
ABSL_FLAG(std::string, infile, "", "Input file (default is stdin)");
ABSL_FLAG(bool, batch, false,
"Input contains multiple requests. Please do not use this to send "
"more than a few RPCs. gRPC CLI has very different performance "
"characteristics compared with normal RPC calls which make it "
"unsuitable for loadtesting or significant production traffic.");
// TODO(Capstan): Consider using absl::Duration
ABSL_FLAG(double, timeout, -1,
"Specify timeout in seconds, used to set the deadline for all "
"RPCs. The default value of -1 means no deadline has been set.");
ABSL_FLAG(
int, max_recv_msg_size, 0,
"Specify the max receive message size in bytes for all RPCs. -1 indicates "
"unlimited. The default value of 0 means to use the gRPC default.");
8 years ago
namespace grpc {
namespace testing {
namespace {
class GrpcTool {
public:
explicit GrpcTool();
virtual ~GrpcTool() {}
8 years ago
bool Help(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback);
8 years ago
bool CallMethod(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback);
bool ListServices(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback);
bool PrintType(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback);
// TODO(zyc): implement the following methods
// bool ListServices(int argc, const char** argv, GrpcToolOutputCallback
// callback);
// bool PrintTypeId(int argc, const char** argv, GrpcToolOutputCallback
// callback);
bool ParseMessage(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback);
bool ToText(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback);
bool ToJson(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback);
bool ToBinary(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback);
void SetPrintCommandMode(int exit_status) {
print_command_usage_ = true;
usage_exit_status_ = exit_status;
}
private:
void CommandUsage(const std::string& usage) const;
bool print_command_usage_;
int usage_exit_status_;
const std::string cred_usage_;
};
template <typename T>
8 years ago
std::function<bool(GrpcTool*, int, const char**, const CliCredentials&,
GrpcToolOutputCallback)>
BindWith5Args(T&& func) {
return std::bind(std::forward<T>(func), std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3,
std::placeholders::_4, std::placeholders::_5);
}
template <typename T>
size_t ArraySize(T& a) {
return ((sizeof(a) / sizeof(*(a))) /
static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))));
}
void ParseMetadataFlag(
std::multimap<std::string, std::string>* client_metadata) {
if (absl::GetFlag(FLAGS_metadata).empty()) {
return;
}
std::vector<std::string> fields;
const char delim = ':';
const char escape = '\\';
size_t cur = -1;
std::stringstream ss;
while (++cur < absl::GetFlag(FLAGS_metadata).length()) {
switch (absl::GetFlag(FLAGS_metadata).at(cur)) {
case escape:
if (cur < absl::GetFlag(FLAGS_metadata).length() - 1) {
char c = absl::GetFlag(FLAGS_metadata).at(++cur);
if (c == delim || c == escape) {
ss << c;
continue;
}
}
fprintf(stderr, "Failed to parse metadata flag.\n");
exit(1);
case delim:
fields.push_back(ss.str());
ss.str("");
ss.clear();
break;
default:
ss << absl::GetFlag(FLAGS_metadata).at(cur);
}
}
fields.push_back(ss.str());
if (fields.size() % 2) {
fprintf(stderr, "Failed to parse metadata flag.\n");
exit(1);
}
for (size_t i = 0; i < fields.size(); i += 2) {
client_metadata->insert(
std::pair<std::string, std::string>(fields[i], fields[i + 1]));
}
}
template <typename T>
void PrintMetadata(const T& m, const std::string& message) {
if (m.empty()) {
return;
}
fprintf(stderr, "%s\n", message.c_str());
std::string pair;
for (typename T::const_iterator iter = m.begin(); iter != m.end(); ++iter) {
pair.clear();
pair.append(iter->first.data(), iter->first.size());
pair.append(" : ");
pair.append(iter->second.data(), iter->second.size());
fprintf(stderr, "%s\n", pair.c_str());
}
}
void ReadResponse(CliCall* call, const std::string& method_name,
const GrpcToolOutputCallback& callback,
ProtoFileParser* parser, gpr_mu* parser_mu, bool print_mode) {
std::string serialized_response_proto;
std::multimap<grpc::string_ref, grpc::string_ref> server_initial_metadata;
for (bool receive_initial_metadata = true; call->ReadAndMaybeNotifyWrite(
&serialized_response_proto,
receive_initial_metadata ? &server_initial_metadata : nullptr);
receive_initial_metadata = false) {
fprintf(stderr, "got response.\n");
if (!absl::GetFlag(FLAGS_binary_output)) {
gpr_mu_lock(parser_mu);
serialized_response_proto = parser->GetFormattedStringFromMethod(
method_name, serialized_response_proto, false /* is_request */,
absl::GetFlag(FLAGS_json_output));
if (parser->HasError() && print_mode) {
fprintf(stderr, "Failed to parse response.\n");
}
gpr_mu_unlock(parser_mu);
}
if (receive_initial_metadata) {
PrintMetadata(server_initial_metadata,
"Received initial metadata from server:");
}
if (!callback(serialized_response_proto) && print_mode) {
fprintf(stderr, "Failed to output response.\n");
}
}
}
std::shared_ptr<grpc::Channel> CreateCliChannel(
const std::string& server_address, const CliCredentials& cred,
const grpc::ChannelArguments& extra_args) {
grpc::ChannelArguments args(extra_args);
if (!cred.GetSslTargetNameOverride().empty()) {
args.SetSslTargetNameOverride(cred.GetSslTargetNameOverride());
}
if (!absl::GetFlag(FLAGS_default_service_config).empty()) {
args.SetString(GRPC_ARG_SERVICE_CONFIG,
absl::GetFlag(FLAGS_default_service_config));
}
// See |GRPC_ARG_MAX_METADATA_SIZE| in |grpc_types.h|.
// Set to large enough size (10M) that should work for most use cases.
args.SetInt(GRPC_ARG_MAX_METADATA_SIZE, 10 * 1024 * 1024);
return grpc::CreateCustomChannel(server_address, cred.GetCredentials(), args);
}
struct Command {
const char* command;
8 years ago
std::function<bool(GrpcTool*, int, const char**, const CliCredentials&,
GrpcToolOutputCallback)>
function;
int min_args;
int max_args;
};
const Command ops[] = {
{"help", BindWith5Args(&GrpcTool::Help), 0, INT_MAX},
8 years ago
{"ls", BindWith5Args(&GrpcTool::ListServices), 1, 3},
{"list", BindWith5Args(&GrpcTool::ListServices), 1, 3},
{"call", BindWith5Args(&GrpcTool::CallMethod), 2, 3},
8 years ago
{"type", BindWith5Args(&GrpcTool::PrintType), 2, 2},
{"parse", BindWith5Args(&GrpcTool::ParseMessage), 2, 3},
{"totext", BindWith5Args(&GrpcTool::ToText), 2, 3},
{"tobinary", BindWith5Args(&GrpcTool::ToBinary), 2, 3},
{"tojson", BindWith5Args(&GrpcTool::ToJson), 2, 3},
};
void Usage(const std::string& msg) {
fprintf(
stderr,
"%s\n"
8 years ago
" grpc_cli ls ... ; List services\n"
" grpc_cli call ... ; Call method\n"
8 years ago
" grpc_cli type ... ; Print type\n"
" grpc_cli parse ... ; Parse message\n"
" grpc_cli totext ... ; Convert binary message to text\n"
" grpc_cli tojson ... ; Convert binary message to json\n"
" grpc_cli tobinary ... ; Convert text message to binary\n"
" grpc_cli help ... ; Print this message, or per-command usage\n"
"\n",
msg.c_str());
exit(1);
}
const Command* FindCommand(const std::string& name) {
for (int i = 0; i < static_cast<int>(ArraySize(ops)); i++) {
if (name == ops[i].command) {
return &ops[i];
}
}
return nullptr;
}
} // namespace
8 years ago
int GrpcToolMainLib(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback) {
if (argc < 2) {
Usage("No command specified");
}
std::string command = argv[1];
argc -= 2;
argv += 2;
const Command* cmd = FindCommand(command);
if (cmd != nullptr) {
GrpcTool grpc_tool;
if (argc < cmd->min_args || argc > cmd->max_args) {
// Force the command to print its usage message
fprintf(stderr, "\nWrong number of arguments for %s\n", command.c_str());
grpc_tool.SetPrintCommandMode(1);
7 years ago
return cmd->function(&grpc_tool, -1, nullptr, cred, callback);
}
const bool ok = cmd->function(&grpc_tool, argc, argv, cred, callback);
return ok ? 0 : 1;
} else {
Usage("Invalid command '" + command + "'");
}
return 1;
}
GrpcTool::GrpcTool() : print_command_usage_(false), usage_exit_status_(0) {}
void GrpcTool::CommandUsage(const std::string& usage) const {
if (print_command_usage_) {
fprintf(stderr, "\n%s%s\n", usage.c_str(),
(usage.empty() || usage[usage.size() - 1] != '\n') ? "\n" : "");
exit(usage_exit_status_);
}
}
8 years ago
bool GrpcTool::Help(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback) {
CommandUsage(
"Print help\n"
" grpc_cli help [subcommand]\n");
if (argc == 0) {
Usage("");
} else {
const Command* cmd = FindCommand(argv[0]);
if (cmd == nullptr) {
Usage("Unknown command '" + std::string(argv[0]) + "'");
}
SetPrintCommandMode(0);
7 years ago
cmd->function(this, -1, nullptr, cred, callback);
}
return true;
}
8 years ago
bool GrpcTool::ListServices(int argc, const char** argv,
const CliCredentials& cred,
const GrpcToolOutputCallback& callback) {
8 years ago
CommandUsage(
"List services\n"
" grpc_cli ls <address> [<service>[/<method>]]\n"
" <address> ; host:port\n"
" <service> ; Exported service name\n"
" <method> ; Method name\n"
" --l ; Use a long listing format\n"
" --outfile ; Output filename (defaults to stdout)\n" +
cred.GetCredentialUsage());
std::string server_address(argv[0]);
8 years ago
std::shared_ptr<grpc::Channel> channel =
CreateCliChannel(server_address, cred, grpc::ChannelArguments());
8 years ago
grpc::ProtoReflectionDescriptorDatabase desc_db(channel);
grpc::protobuf::DescriptorPool desc_pool(&desc_db);
8 years ago
std::vector<std::string> service_list;
8 years ago
if (!desc_db.GetServices(&service_list)) {
fprintf(stderr, "Received an error when querying services endpoint.\n");
8 years ago
return false;
}
// If no service is specified, dump the list of services.
std::string output;
8 years ago
if (argc < 2) {
// List all services, if --l is passed, then include full description,
// otherwise include a summarized list only.
if (absl::GetFlag(FLAGS_l)) {
8 years ago
output = DescribeServiceList(service_list, desc_pool);
} else {
for (auto it = service_list.begin(); it != service_list.end(); it++) {
auto const& service = *it;
8 years ago
output.append(service);
output.append("\n");
}
}
} else {
std::string service_name;
std::string method_name;
8 years ago
std::stringstream ss(argv[1]);
// Remove leading slashes.
while (ss.peek() == '/') {
ss.get();
}
// Parse service and method names. Support the following patterns:
// Service
// Service Method
// Service.Method
// Service/Method
if (argc == 3) {
std::getline(ss, service_name, '/');
method_name = argv[2];
} else {
if (std::getline(ss, service_name, '/')) {
std::getline(ss, method_name);
}
}
const grpc::protobuf::ServiceDescriptor* service =
8 years ago
desc_pool.FindServiceByName(service_name);
if (service != nullptr) {
if (method_name.empty()) {
output = absl::GetFlag(FLAGS_l) ? DescribeService(service)
: SummarizeService(service);
8 years ago
} else {
method_name.insert(0, 1, '.');
method_name.insert(0, service_name);
const grpc::protobuf::MethodDescriptor* method =
8 years ago
desc_pool.FindMethodByName(method_name);
if (method != nullptr) {
output = absl::GetFlag(FLAGS_l) ? DescribeMethod(method)
: SummarizeMethod(method);
8 years ago
} else {
fprintf(stderr, "Method %s not found in service %s.\n",
method_name.c_str(), service_name.c_str());
return false;
}
}
} else {
if (!method_name.empty()) {
fprintf(stderr, "Service %s not found.\n", service_name.c_str());
return false;
} else {
const grpc::protobuf::MethodDescriptor* method =
8 years ago
desc_pool.FindMethodByName(service_name);
if (method != nullptr) {
output = absl::GetFlag(FLAGS_l) ? DescribeMethod(method)
: SummarizeMethod(method);
8 years ago
} else {
fprintf(stderr, "Service or method %s not found.\n",
service_name.c_str());
return false;
}
}
}
}
return callback(output);
}
bool GrpcTool::PrintType(int /*argc*/, const char** argv,
const CliCredentials& cred,
const GrpcToolOutputCallback& callback) {
8 years ago
CommandUsage(
"Print type\n"
" grpc_cli type <address> <type>\n"
" <address> ; host:port\n"
" <type> ; Protocol buffer type name\n" +
cred.GetCredentialUsage());
std::string server_address(argv[0]);
8 years ago
std::shared_ptr<grpc::Channel> channel =
CreateCliChannel(server_address, cred, grpc::ChannelArguments());
8 years ago
grpc::ProtoReflectionDescriptorDatabase desc_db(channel);
grpc::protobuf::DescriptorPool desc_pool(&desc_db);
std::string output;
8 years ago
const grpc::protobuf::Descriptor* descriptor =
desc_pool.FindMessageTypeByName(argv[1]);
if (descriptor != nullptr) {
output = descriptor->DebugString();
} else {
fprintf(stderr, "Type %s not found.\n", argv[1]);
return false;
}
return callback(output);
}
bool GrpcTool::CallMethod(int argc, const char** argv,
8 years ago
const CliCredentials& cred,
const GrpcToolOutputCallback& callback) {
CommandUsage(
"Call method\n"
" grpc_cli call <address> <service>[.<method>] <request>\n"
" <address> ; host:port\n"
" <service> ; Exported service name\n"
" <method> ; Method name\n"
" <request> ; Text protobuffer (overrides infile)\n"
8 years ago
" --protofiles ; Comma separated proto files used as a"
" fallback when parsing request/response\n"
" --proto_path ; The search paths of proto files"
" (" GRPC_CLI_PATH_SEPARATOR
" separated), valid only when --protofiles is given\n"
" --noremotedb ; Don't attempt to use reflection service"
" at all\n"
" --metadata ; The metadata to be sent to the server\n"
" --infile ; Input filename (defaults to stdin)\n"
" --outfile ; Output filename (defaults to stdout)\n"
" --binary_input ; Input in binary format\n"
" --binary_output ; Output in binary format\n"
" --json_input ; Input in json format\n"
" --json_output ; Output in json format\n"
" --max_recv_msg_size ; Specify max receive message size in "
"bytes. -1 indicates unlimited. The default value of 0 means to use the "
"gRPC default.\n"
" --timeout ; Specify timeout (in seconds), used to "
"set the deadline for RPCs. The default value of -1 means no "
"deadline has been set.\n" +
cred.GetCredentialUsage());
std::stringstream output_ss;
std::string request_text;
std::string server_address(argv[0]);
std::string method_name(argv[1]);
std::string formatted_method_name;
std::unique_ptr<ProtoFileParser> parser;
std::string serialized_request_proto;
CliArgs cli_args;
cli_args.timeout = absl::GetFlag(FLAGS_timeout);
bool print_mode = false;
grpc::ChannelArguments args;
if (absl::GetFlag(FLAGS_max_recv_msg_size) != 0) {
args.SetMaxReceiveMessageSize(absl::GetFlag(FLAGS_max_recv_msg_size));
}
std::shared_ptr<grpc::Channel> channel =
CreateCliChannel(server_address, cred, args);
if (!absl::GetFlag(FLAGS_binary_input) ||
!absl::GetFlag(FLAGS_binary_output)) {
parser = std::make_unique<grpc::testing::ProtoFileParser>(
absl::GetFlag(FLAGS_remotedb) ? channel : nullptr,
absl::GetFlag(FLAGS_proto_path), absl::GetFlag(FLAGS_protofiles));
if (parser->HasError()) {
fprintf(
stderr,
"Failed to find remote reflection service and local proto files.\n");
return false;
}
}
if (absl::GetFlag(FLAGS_binary_input)) {
formatted_method_name = method_name;
} else {
formatted_method_name = parser->GetFormattedMethodName(method_name);
if (parser->HasError()) {
fprintf(stderr, "Failed to find method %s in proto files.\n",
method_name.c_str());
}
}
if (argc == 3) {
request_text = argv[2];
}
if (parser != nullptr &&
parser->IsStreaming(method_name, true /* is_request */)) {
std::istream* input_stream;
std::ifstream input_file;
if (absl::GetFlag(FLAGS_batch)) {
fprintf(stderr, "Batch mode for streaming RPC is not supported.\n");
return false;
}
std::multimap<std::string, std::string> client_metadata;
ParseMetadataFlag(&client_metadata);
PrintMetadata(client_metadata, "Sending client initial metadata:");
CliCall call(channel, formatted_method_name, client_metadata, cli_args);
if (absl::GetFlag(FLAGS_display_peer_address)) {
fprintf(stderr, "New call for method_name:%s has peer address:|%s|\n",
formatted_method_name.c_str(), call.peer().c_str());
}
if (absl::GetFlag(FLAGS_infile).empty()) {
if (isatty(fileno(stdin))) {
print_mode = true;
fprintf(stderr, "reading streaming request message from stdin...\n");
}
input_stream = &std::cin;
} else {
input_file.open(absl::GetFlag(FLAGS_infile),
std::ios::in | std::ios::binary);
if (!input_file) {
fprintf(stderr, "Failed to open infile %s.\n",
absl::GetFlag(FLAGS_infile).c_str());
return false;
}
input_stream = &input_file;
}
gpr_mu parser_mu;
gpr_mu_init(&parser_mu);
std::thread read_thread(ReadResponse, &call, method_name, callback,
parser.get(), &parser_mu, print_mode);
std::stringstream request_ss;
std::string line;
while (!request_text.empty() ||
(!input_stream->eof() && getline(*input_stream, line))) {
if (!request_text.empty()) {
if (absl::GetFlag(FLAGS_binary_input)) {
serialized_request_proto = request_text;
request_text.clear();
} else {
gpr_mu_lock(&parser_mu);
serialized_request_proto = parser->GetSerializedProtoFromMethod(
method_name, request_text, true /* is_request */,
absl::GetFlag(FLAGS_json_input));
request_text.clear();
if (parser->HasError()) {
if (print_mode) {
fprintf(stderr, "Failed to parse request.\n");
}
gpr_mu_unlock(&parser_mu);
continue;
}
gpr_mu_unlock(&parser_mu);
}
call.WriteAndWait(serialized_request_proto);
if (print_mode) {
fprintf(stderr, "Request sent.\n");
}
} else {
if (line.length() == 0) {
request_text = request_ss.str();
request_ss.str(std::string());
request_ss.clear();
} else {
request_ss << line << ' ';
}
}
}
if (input_file.is_open()) {
input_file.close();
}
call.WritesDoneAndWait();
read_thread.join();
gpr_mu_destroy(&parser_mu);
std::multimap<grpc::string_ref, grpc::string_ref> server_trailing_metadata;
Status status = call.Finish(&server_trailing_metadata);
PrintMetadata(server_trailing_metadata,
"Received trailing metadata from server:");
if (status.ok()) {
fprintf(stderr, "Stream RPC succeeded with OK status\n");
return true;
} else {
fprintf(stderr, "Rpc failed with status code %d, error message: %s\n",
status.error_code(), status.error_message().c_str());
return false;
}
} else { // parser->IsStreaming(method_name, true /* is_request */)
if (absl::GetFlag(FLAGS_batch)) {
if (parser != nullptr &&
parser->IsStreaming(method_name, false /* is_request */)) {
fprintf(stderr, "Batch mode for streaming RPC is not supported.\n");
return false;
}
std::istream* input_stream;
std::ifstream input_file;
if (absl::GetFlag(FLAGS_infile).empty()) {
if (isatty(fileno(stdin))) {
print_mode = true;
fprintf(stderr, "reading request messages from stdin...\n");
}
input_stream = &std::cin;
} else {
input_file.open(absl::GetFlag(FLAGS_infile),
std::ios::in | std::ios::binary);
input_stream = &input_file;
}
std::multimap<std::string, std::string> client_metadata;
ParseMetadataFlag(&client_metadata);
if (print_mode) {
PrintMetadata(client_metadata, "Sending client initial metadata:");
}
std::stringstream request_ss;
std::string line;
while (!request_text.empty() ||
(!input_stream->eof() && getline(*input_stream, line))) {
if (!request_text.empty()) {
if (absl::GetFlag(FLAGS_binary_input)) {
serialized_request_proto = request_text;
request_text.clear();
} else {
serialized_request_proto = parser->GetSerializedProtoFromMethod(
method_name, request_text, true /* is_request */,
absl::GetFlag(FLAGS_json_input));
request_text.clear();
if (parser->HasError()) {
if (print_mode) {
fprintf(stderr, "Failed to parse request.\n");
}
continue;
}
}
std::string serialized_response_proto;
std::multimap<grpc::string_ref, grpc::string_ref>
server_initial_metadata, server_trailing_metadata;
CliCall call(channel, formatted_method_name, client_metadata,
cli_args);
if (absl::GetFlag(FLAGS_display_peer_address)) {
fprintf(stderr,
"New call for method_name:%s has peer address:|%s|\n",
formatted_method_name.c_str(), call.peer().c_str());
}
call.Write(serialized_request_proto);
call.WritesDone();
if (!call.Read(&serialized_response_proto,
&server_initial_metadata)) {
fprintf(stderr, "Failed to read response.\n");
}
Status status = call.Finish(&server_trailing_metadata);
if (status.ok()) {
if (print_mode) {
fprintf(stderr, "Rpc succeeded with OK status.\n");
PrintMetadata(server_initial_metadata,
"Received initial metadata from server:");
PrintMetadata(server_trailing_metadata,
"Received trailing metadata from server:");
}
if (absl::GetFlag(FLAGS_binary_output)) {
if (!callback(serialized_response_proto)) {
break;
}
} else {
std::string response_text = parser->GetFormattedStringFromMethod(
method_name, serialized_response_proto,
false /* is_request */, absl::GetFlag(FLAGS_json_output));
if (parser->HasError() && print_mode) {
fprintf(stderr, "Failed to parse response.\n");
} else {
if (!callback(response_text)) {
break;
}
}
}
} else {
if (print_mode) {
fprintf(stderr,
"Rpc failed with status code %d, error message: %s\n",
status.error_code(), status.error_message().c_str());
}
}
} else {
if (line.length() == 0) {
request_text = request_ss.str();
request_ss.str(std::string());
request_ss.clear();
} else {
request_ss << line << ' ';
}
}
}
if (input_file.is_open()) {
input_file.close();
}
return true;
}
if (argc == 3) {
if (!absl::GetFlag(FLAGS_infile).empty()) {
fprintf(stderr, "warning: request given in argv, ignoring --infile\n");
}
} else {
std::stringstream input_stream;
if (absl::GetFlag(FLAGS_infile).empty()) {
if (isatty(fileno(stdin))) {
fprintf(stderr, "reading request message from stdin...\n");
}
input_stream << std::cin.rdbuf();
} else {
std::ifstream input_file(absl::GetFlag(FLAGS_infile),
std::ios::in | std::ios::binary);
input_stream << input_file.rdbuf();
input_file.close();
}
request_text = input_stream.str();
}
if (absl::GetFlag(FLAGS_binary_input)) {
serialized_request_proto = request_text;
} else {
serialized_request_proto = parser->GetSerializedProtoFromMethod(
method_name, request_text, true /* is_request */,
absl::GetFlag(FLAGS_json_input));
if (parser->HasError()) {
fprintf(stderr, "Failed to parse request.\n");
return false;
}
}
fprintf(stderr, "connecting to %s\n", server_address.c_str());
std::string serialized_response_proto;
std::multimap<std::string, std::string> client_metadata;
std::multimap<grpc::string_ref, grpc::string_ref> server_initial_metadata,
server_trailing_metadata;
ParseMetadataFlag(&client_metadata);
PrintMetadata(client_metadata, "Sending client initial metadata:");
CliCall call(channel, formatted_method_name, client_metadata, cli_args);
if (absl::GetFlag(FLAGS_display_peer_address)) {
fprintf(stderr, "New call for method_name:%s has peer address:|%s|\n",
formatted_method_name.c_str(), call.peer().c_str());
}
call.Write(serialized_request_proto);
call.WritesDone();
for (bool receive_initial_metadata = true; call.Read(
&serialized_response_proto,
receive_initial_metadata ? &server_initial_metadata : nullptr);
receive_initial_metadata = false) {
if (!absl::GetFlag(FLAGS_binary_output)) {
serialized_response_proto = parser->GetFormattedStringFromMethod(
method_name, serialized_response_proto, false /* is_request */,
absl::GetFlag(FLAGS_json_output));
if (parser->HasError()) {
fprintf(stderr, "Failed to parse response.\n");
return false;
}
}
if (receive_initial_metadata) {
PrintMetadata(server_initial_metadata,
"Received initial metadata from server:");
}
if (!callback(serialized_response_proto)) {
return false;
}
}
Status status = call.Finish(&server_trailing_metadata);
PrintMetadata(server_trailing_metadata,
"Received trailing metadata from server:");
if (status.ok()) {
fprintf(stderr, "Rpc succeeded with OK status\n");
return true;
} else {
fprintf(stderr, "Rpc failed with status code %d, error message: %s\n",
status.error_code(), status.error_message().c_str());
return false;
}
}
GPR_UNREACHABLE_CODE(return false);
}
bool GrpcTool::ParseMessage(int argc, const char** argv,
const CliCredentials& cred,
const GrpcToolOutputCallback& callback) {
CommandUsage(
"Parse message\n"
" grpc_cli parse <address> <type> [<message>]\n"
" <address> ; host:port\n"
" <type> ; Protocol buffer type name\n"
" <message> ; Text protobuffer (overrides --infile)\n"
" --protofiles ; Comma separated proto files used as a"
" fallback when parsing request/response\n"
" --proto_path ; The search paths of proto files"
" (" GRPC_CLI_PATH_SEPARATOR
" separated), valid only when --protofiles is given\n"
" --noremotedb ; Don't attempt to use reflection service"
" at all\n"
" --infile ; Input filename (defaults to stdin)\n"
" --outfile ; Output filename (defaults to stdout)\n"
" --binary_input ; Input in binary format\n"
" --binary_output ; Output in binary format\n"
" --json_input ; Input in json format\n"
" --json_output ; Output in json format\n" +
cred.GetCredentialUsage());
std::stringstream output_ss;
std::string message_text;
std::string server_address(argv[0]);
std::string type_name(argv[1]);
std::unique_ptr<grpc::testing::ProtoFileParser> parser;
std::string serialized_request_proto;
if (argc == 3) {
message_text = argv[2];
if (!absl::GetFlag(FLAGS_infile).empty()) {
fprintf(stderr, "warning: message given in argv, ignoring --infile.\n");
}
} else {
std::stringstream input_stream;
if (absl::GetFlag(FLAGS_infile).empty()) {
if (isatty(fileno(stdin))) {
fprintf(stderr, "reading request message from stdin...\n");
}
input_stream << std::cin.rdbuf();
} else {
std::ifstream input_file(absl::GetFlag(FLAGS_infile),
std::ios::in | std::ios::binary);
input_stream << input_file.rdbuf();
input_file.close();
}
message_text = input_stream.str();
}
if (!absl::GetFlag(FLAGS_binary_input) ||
!absl::GetFlag(FLAGS_binary_output)) {
std::shared_ptr<grpc::Channel> channel =
CreateCliChannel(server_address, cred, grpc::ChannelArguments());
parser = std::make_unique<grpc::testing::ProtoFileParser>(
absl::GetFlag(FLAGS_remotedb) ? channel : nullptr,
absl::GetFlag(FLAGS_proto_path), absl::GetFlag(FLAGS_protofiles));
if (parser->HasError()) {
fprintf(
stderr,
"Failed to find remote reflection service and local proto files.\n");
return false;
}
}
if (absl::GetFlag(FLAGS_binary_input)) {
serialized_request_proto = message_text;
} else {
serialized_request_proto = parser->GetSerializedProtoFromMessageType(
type_name, message_text, absl::GetFlag(FLAGS_json_input));
if (parser->HasError()) {
fprintf(stderr, "Failed to serialize the message.\n");
return false;
}
}
if (absl::GetFlag(FLAGS_binary_output)) {
output_ss << serialized_request_proto;
} else {
std::string output_text;
output_text = parser->GetFormattedStringFromMessageType(
type_name, serialized_request_proto, absl::GetFlag(FLAGS_json_output));
if (parser->HasError()) {
fprintf(stderr, "Failed to deserialize the message.\n");
return false;
}
output_ss << output_text << std::endl;
}
return callback(output_ss.str());
}
bool GrpcTool::ToText(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback) {
CommandUsage(
"Convert binary message to text\n"
" grpc_cli totext <protofiles> <type>\n"
" <protofiles> ; Comma separated list of proto files\n"
" <type> ; Protocol buffer type name\n"
" --proto_path ; The search paths of proto files"
" (" GRPC_CLI_PATH_SEPARATOR
" separated)\n"
" --infile ; Input filename (defaults to stdin)\n"
" --outfile ; Output filename (defaults to stdout)\n");
absl::SetFlag(&FLAGS_protofiles, argv[0]);
absl::SetFlag(&FLAGS_remotedb, false);
absl::SetFlag(&FLAGS_binary_input, true);
absl::SetFlag(&FLAGS_binary_output, false);
return ParseMessage(argc, argv, cred, callback);
}
bool GrpcTool::ToJson(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback) {
CommandUsage(
"Convert binary message to json\n"
" grpc_cli tojson <protofiles> <type>\n"
" <protofiles> ; Comma separated list of proto files\n"
" <type> ; Protocol buffer type name\n"
" --proto_path ; The search paths of proto files"
" (" GRPC_CLI_PATH_SEPARATOR
" separated)\n"
" --infile ; Input filename (defaults to stdin)\n"
" --outfile ; Output filename (defaults to stdout)\n");
absl::SetFlag(&FLAGS_protofiles, argv[0]);
absl::SetFlag(&FLAGS_remotedb, false);
absl::SetFlag(&FLAGS_binary_input, true);
absl::SetFlag(&FLAGS_binary_output, false);
absl::SetFlag(&FLAGS_json_output, true);
return ParseMessage(argc, argv, cred, callback);
}
bool GrpcTool::ToBinary(int argc, const char** argv, const CliCredentials& cred,
const GrpcToolOutputCallback& callback) {
CommandUsage(
"Convert text message to binary\n"
" grpc_cli tobinary <protofiles> <type> [<message>]\n"
" <protofiles> ; Comma separated list of proto files\n"
" <type> ; Protocol buffer type name\n"
" --proto_path ; The search paths of proto files"
" (" GRPC_CLI_PATH_SEPARATOR
" separated)\n"
" --infile ; Input filename (defaults to stdin)\n"
" --outfile ; Output filename (defaults to stdout)\n");
absl::SetFlag(&FLAGS_protofiles, argv[0]);
absl::SetFlag(&FLAGS_remotedb, false);
absl::SetFlag(&FLAGS_binary_input, false);
absl::SetFlag(&FLAGS_binary_output, true);
return ParseMessage(argc, argv, cred, callback);
}
} // namespace testing
} // namespace grpc