mirror of https://github.com/grpc/grpc.git
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.
959 lines
33 KiB
959 lines
33 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 "test/cpp/util/grpc_tool.h" |
|
|
|
#include <cstdio> |
|
#include <fstream> |
|
#include <iostream> |
|
#include <memory> |
|
#include <sstream> |
|
#include <string> |
|
#include <thread> |
|
|
|
#include <gflags/gflags.h> |
|
#include <grpc/grpc.h> |
|
#include <grpc/support/port_platform.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" |
|
#include "test/cpp/util/service_describer.h" |
|
|
|
#if GPR_WINDOWS |
|
#include <io.h> |
|
#else |
|
#include <unistd.h> |
|
#endif |
|
|
|
namespace grpc { |
|
namespace testing { |
|
|
|
DEFINE_bool(l, false, "Use a long listing format"); |
|
DEFINE_bool(remotedb, true, "Use server types to parse and format messages"); |
|
DEFINE_string(metadata, "", |
|
"Metadata to send to server, in the form of key1:val1:key2:val2"); |
|
DEFINE_string(proto_path, ".", "Path to look for the proto file."); |
|
DEFINE_string(protofiles, "", "Name of the proto file."); |
|
DEFINE_bool(binary_input, false, "Input in binary format"); |
|
DEFINE_bool(binary_output, false, "Output in binary format"); |
|
DEFINE_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."); |
|
DEFINE_bool(json_input, false, "Input in json format"); |
|
DEFINE_bool(json_output, false, "Output in json format"); |
|
DEFINE_string(infile, "", "Input file (default is stdin)"); |
|
DEFINE_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."); |
|
|
|
namespace { |
|
|
|
class GrpcTool { |
|
public: |
|
explicit GrpcTool(); |
|
virtual ~GrpcTool() {} |
|
|
|
bool Help(int argc, const char** argv, const CliCredentials& cred, |
|
GrpcToolOutputCallback callback); |
|
bool CallMethod(int argc, const char** argv, const CliCredentials& cred, |
|
GrpcToolOutputCallback callback); |
|
bool ListServices(int argc, const char** argv, const CliCredentials& cred, |
|
GrpcToolOutputCallback callback); |
|
bool PrintType(int argc, const char** argv, const CliCredentials& cred, |
|
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, |
|
GrpcToolOutputCallback callback); |
|
bool ToText(int argc, const char** argv, const CliCredentials& cred, |
|
GrpcToolOutputCallback callback); |
|
bool ToJson(int argc, const char** argv, const CliCredentials& cred, |
|
GrpcToolOutputCallback callback); |
|
bool ToBinary(int argc, const char** argv, const CliCredentials& cred, |
|
GrpcToolOutputCallback callback); |
|
|
|
void SetPrintCommandMode(int exit_status) { |
|
print_command_usage_ = true; |
|
usage_exit_status_ = exit_status; |
|
} |
|
|
|
private: |
|
void CommandUsage(const grpc::string& usage) const; |
|
bool print_command_usage_; |
|
int usage_exit_status_; |
|
const grpc::string cred_usage_; |
|
}; |
|
|
|
template <typename T> |
|
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<grpc::string, grpc::string>* client_metadata) { |
|
if (FLAGS_metadata.empty()) { |
|
return; |
|
} |
|
std::vector<grpc::string> fields; |
|
const char delim = ':'; |
|
const char escape = '\\'; |
|
size_t cur = -1; |
|
std::stringstream ss; |
|
while (++cur < FLAGS_metadata.length()) { |
|
switch (FLAGS_metadata.at(cur)) { |
|
case escape: |
|
if (cur < FLAGS_metadata.length() - 1) { |
|
char c = 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 << 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<grpc::string, grpc::string>(fields[i], fields[i + 1])); |
|
} |
|
} |
|
|
|
template <typename T> |
|
void PrintMetadata(const T& m, const grpc::string& message) { |
|
if (m.empty()) { |
|
return; |
|
} |
|
fprintf(stderr, "%s\n", message.c_str()); |
|
grpc::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 grpc::string& method_name, |
|
GrpcToolOutputCallback callback, ProtoFileParser* parser, |
|
gpr_mu* parser_mu, bool print_mode) { |
|
grpc::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 (!FLAGS_binary_output) { |
|
gpr_mu_lock(parser_mu); |
|
serialized_response_proto = parser->GetFormattedStringFromMethod( |
|
method_name, serialized_response_proto, false /* is_request */, |
|
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 grpc::string& server_address, const CliCredentials& cred) { |
|
grpc::ChannelArguments args; |
|
if (!cred.GetSslTargetNameOverride().empty()) { |
|
args.SetSslTargetNameOverride(cred.GetSslTargetNameOverride()); |
|
} |
|
if (!FLAGS_default_service_config.empty()) { |
|
args.SetString(GRPC_ARG_SERVICE_CONFIG, |
|
FLAGS_default_service_config.c_str()); |
|
} |
|
return ::grpc::CreateCustomChannel(server_address, cred.GetCredentials(), |
|
args); |
|
} |
|
|
|
struct Command { |
|
const char* command; |
|
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}, |
|
{"ls", BindWith5Args(&GrpcTool::ListServices), 1, 3}, |
|
{"list", BindWith5Args(&GrpcTool::ListServices), 1, 3}, |
|
{"call", BindWith5Args(&GrpcTool::CallMethod), 2, 3}, |
|
{"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 grpc::string& msg) { |
|
fprintf( |
|
stderr, |
|
"%s\n" |
|
" grpc_cli ls ... ; List services\n" |
|
" grpc_cli call ... ; Call method\n" |
|
" 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 grpc::string& name) { |
|
for (int i = 0; i < (int)ArraySize(ops); i++) { |
|
if (name == ops[i].command) { |
|
return &ops[i]; |
|
} |
|
} |
|
return nullptr; |
|
} |
|
} // namespace |
|
|
|
int GrpcToolMainLib(int argc, const char** argv, const CliCredentials& cred, |
|
GrpcToolOutputCallback callback) { |
|
if (argc < 2) { |
|
Usage("No command specified"); |
|
} |
|
|
|
grpc::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); |
|
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 '" + grpc::string(command.c_str()) + "'"); |
|
} |
|
return 1; |
|
} |
|
|
|
GrpcTool::GrpcTool() : print_command_usage_(false), usage_exit_status_(0) {} |
|
|
|
void GrpcTool::CommandUsage(const grpc::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_); |
|
} |
|
} |
|
|
|
bool GrpcTool::Help(int argc, const char** argv, const CliCredentials& cred, |
|
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 '" + grpc::string(argv[0]) + "'"); |
|
} |
|
SetPrintCommandMode(0); |
|
cmd->function(this, -1, nullptr, cred, callback); |
|
} |
|
return true; |
|
} |
|
|
|
bool GrpcTool::ListServices(int argc, const char** argv, |
|
const CliCredentials& cred, |
|
GrpcToolOutputCallback callback) { |
|
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()); |
|
|
|
grpc::string server_address(argv[0]); |
|
std::shared_ptr<grpc::Channel> channel = |
|
CreateCliChannel(server_address, cred); |
|
grpc::ProtoReflectionDescriptorDatabase desc_db(channel); |
|
grpc::protobuf::DescriptorPool desc_pool(&desc_db); |
|
|
|
std::vector<grpc::string> service_list; |
|
if (!desc_db.GetServices(&service_list)) { |
|
fprintf(stderr, "Received an error when querying services endpoint.\n"); |
|
return false; |
|
} |
|
|
|
// If no service is specified, dump the list of services. |
|
grpc::string output; |
|
if (argc < 2) { |
|
// List all services, if --l is passed, then include full description, |
|
// otherwise include a summarized list only. |
|
if (FLAGS_l) { |
|
output = DescribeServiceList(service_list, desc_pool); |
|
} else { |
|
for (auto it = service_list.begin(); it != service_list.end(); it++) { |
|
auto const& service = *it; |
|
output.append(service); |
|
output.append("\n"); |
|
} |
|
} |
|
} else { |
|
grpc::string service_name; |
|
grpc::string method_name; |
|
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 = |
|
desc_pool.FindServiceByName(service_name); |
|
if (service != nullptr) { |
|
if (method_name.empty()) { |
|
output = FLAGS_l ? DescribeService(service) : SummarizeService(service); |
|
} else { |
|
method_name.insert(0, 1, '.'); |
|
method_name.insert(0, service_name); |
|
const grpc::protobuf::MethodDescriptor* method = |
|
desc_pool.FindMethodByName(method_name); |
|
if (method != nullptr) { |
|
output = FLAGS_l ? DescribeMethod(method) : SummarizeMethod(method); |
|
} 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 = |
|
desc_pool.FindMethodByName(service_name); |
|
if (method != nullptr) { |
|
output = FLAGS_l ? DescribeMethod(method) : SummarizeMethod(method); |
|
} 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, |
|
GrpcToolOutputCallback callback) { |
|
CommandUsage( |
|
"Print type\n" |
|
" grpc_cli type <address> <type>\n" |
|
" <address> ; host:port\n" |
|
" <type> ; Protocol buffer type name\n" + |
|
cred.GetCredentialUsage()); |
|
|
|
grpc::string server_address(argv[0]); |
|
std::shared_ptr<grpc::Channel> channel = |
|
CreateCliChannel(server_address, cred); |
|
grpc::ProtoReflectionDescriptorDatabase desc_db(channel); |
|
grpc::protobuf::DescriptorPool desc_pool(&desc_db); |
|
|
|
grpc::string output; |
|
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, |
|
const CliCredentials& cred, |
|
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" |
|
" --protofiles ; Comma separated proto files used as a" |
|
" fallback when parsing request/response\n" |
|
" --proto_path ; The search path of proto files, 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" + |
|
cred.GetCredentialUsage()); |
|
|
|
std::stringstream output_ss; |
|
grpc::string request_text; |
|
grpc::string server_address(argv[0]); |
|
grpc::string method_name(argv[1]); |
|
grpc::string formatted_method_name; |
|
std::unique_ptr<ProtoFileParser> parser; |
|
grpc::string serialized_request_proto; |
|
bool print_mode = false; |
|
|
|
std::shared_ptr<grpc::Channel> channel = |
|
CreateCliChannel(server_address, cred); |
|
|
|
if (!FLAGS_binary_input || !FLAGS_binary_output) { |
|
parser.reset( |
|
new grpc::testing::ProtoFileParser(FLAGS_remotedb ? channel : nullptr, |
|
FLAGS_proto_path, FLAGS_protofiles)); |
|
if (parser->HasError()) { |
|
fprintf( |
|
stderr, |
|
"Failed to find remote reflection service and local proto files.\n"); |
|
return false; |
|
} |
|
} |
|
|
|
if (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->IsStreaming(method_name, true /* is_request */)) { |
|
std::istream* input_stream; |
|
std::ifstream input_file; |
|
|
|
if (FLAGS_batch) { |
|
fprintf(stderr, "Batch mode for streaming RPC is not supported.\n"); |
|
return false; |
|
} |
|
|
|
std::multimap<grpc::string, grpc::string> client_metadata; |
|
ParseMetadataFlag(&client_metadata); |
|
PrintMetadata(client_metadata, "Sending client initial metadata:"); |
|
|
|
CliCall call(channel, formatted_method_name, client_metadata); |
|
|
|
if (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(FLAGS_infile, std::ios::in | std::ios::binary); |
|
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; |
|
grpc::string line; |
|
while (!request_text.empty() || |
|
(!input_stream->eof() && getline(*input_stream, line))) { |
|
if (!request_text.empty()) { |
|
if (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 */, |
|
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(grpc::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 (FLAGS_batch) { |
|
if (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 (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(FLAGS_infile, std::ios::in | std::ios::binary); |
|
input_stream = &input_file; |
|
} |
|
|
|
std::multimap<grpc::string, grpc::string> client_metadata; |
|
ParseMetadataFlag(&client_metadata); |
|
if (print_mode) { |
|
PrintMetadata(client_metadata, "Sending client initial metadata:"); |
|
} |
|
|
|
std::stringstream request_ss; |
|
grpc::string line; |
|
while (!request_text.empty() || |
|
(!input_stream->eof() && getline(*input_stream, line))) { |
|
if (!request_text.empty()) { |
|
if (FLAGS_binary_input) { |
|
serialized_request_proto = request_text; |
|
request_text.clear(); |
|
} else { |
|
serialized_request_proto = parser->GetSerializedProtoFromMethod( |
|
method_name, request_text, true /* is_request */, |
|
FLAGS_json_input); |
|
request_text.clear(); |
|
if (parser->HasError()) { |
|
if (print_mode) { |
|
fprintf(stderr, "Failed to parse request.\n"); |
|
} |
|
continue; |
|
} |
|
} |
|
|
|
grpc::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); |
|
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 (FLAGS_binary_output) { |
|
if (!callback(serialized_response_proto)) { |
|
break; |
|
} |
|
} else { |
|
grpc::string response_text = parser->GetFormattedStringFromMethod( |
|
method_name, serialized_response_proto, |
|
false /* is_request */, 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(grpc::string()); |
|
request_ss.clear(); |
|
} else { |
|
request_ss << line << ' '; |
|
} |
|
} |
|
} |
|
|
|
if (input_file.is_open()) { |
|
input_file.close(); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
if (argc == 3) { |
|
if (!FLAGS_infile.empty()) { |
|
fprintf(stderr, "warning: request given in argv, ignoring --infile\n"); |
|
} |
|
} else { |
|
std::stringstream input_stream; |
|
if (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(FLAGS_infile, std::ios::in | std::ios::binary); |
|
input_stream << input_file.rdbuf(); |
|
input_file.close(); |
|
} |
|
request_text = input_stream.str(); |
|
} |
|
|
|
if (FLAGS_binary_input) { |
|
serialized_request_proto = request_text; |
|
} else { |
|
serialized_request_proto = parser->GetSerializedProtoFromMethod( |
|
method_name, request_text, true /* is_request */, 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()); |
|
|
|
grpc::string serialized_response_proto; |
|
std::multimap<grpc::string, grpc::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); |
|
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 (!FLAGS_binary_output) { |
|
serialized_response_proto = parser->GetFormattedStringFromMethod( |
|
method_name, serialized_response_proto, false /* is_request */, |
|
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, |
|
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 path of proto files, 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; |
|
grpc::string message_text; |
|
grpc::string server_address(argv[0]); |
|
grpc::string type_name(argv[1]); |
|
std::unique_ptr<grpc::testing::ProtoFileParser> parser; |
|
grpc::string serialized_request_proto; |
|
|
|
if (argc == 3) { |
|
message_text = argv[2]; |
|
if (!FLAGS_infile.empty()) { |
|
fprintf(stderr, "warning: message given in argv, ignoring --infile.\n"); |
|
} |
|
} else { |
|
std::stringstream input_stream; |
|
if (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(FLAGS_infile, std::ios::in | std::ios::binary); |
|
input_stream << input_file.rdbuf(); |
|
input_file.close(); |
|
} |
|
message_text = input_stream.str(); |
|
} |
|
|
|
if (!FLAGS_binary_input || !FLAGS_binary_output) { |
|
std::shared_ptr<grpc::Channel> channel = |
|
CreateCliChannel(server_address, cred); |
|
parser.reset( |
|
new grpc::testing::ProtoFileParser(FLAGS_remotedb ? channel : nullptr, |
|
FLAGS_proto_path, FLAGS_protofiles)); |
|
if (parser->HasError()) { |
|
fprintf( |
|
stderr, |
|
"Failed to find remote reflection service and local proto files.\n"); |
|
return false; |
|
} |
|
} |
|
|
|
if (FLAGS_binary_input) { |
|
serialized_request_proto = message_text; |
|
} else { |
|
serialized_request_proto = parser->GetSerializedProtoFromMessageType( |
|
type_name, message_text, FLAGS_json_input); |
|
if (parser->HasError()) { |
|
fprintf(stderr, "Failed to serialize the message.\n"); |
|
return false; |
|
} |
|
} |
|
|
|
if (FLAGS_binary_output) { |
|
output_ss << serialized_request_proto; |
|
} else { |
|
grpc::string output_text; |
|
output_text = parser->GetFormattedStringFromMessageType( |
|
type_name, serialized_request_proto, 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, |
|
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 path of proto files\n" |
|
" --infile ; Input filename (defaults to stdin)\n" |
|
" --outfile ; Output filename (defaults to stdout)\n"); |
|
|
|
FLAGS_protofiles = argv[0]; |
|
FLAGS_remotedb = false; |
|
FLAGS_binary_input = true; |
|
FLAGS_binary_output = false; |
|
return ParseMessage(argc, argv, cred, callback); |
|
} |
|
|
|
bool GrpcTool::ToJson(int argc, const char** argv, const CliCredentials& cred, |
|
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 path of proto files\n" |
|
" --infile ; Input filename (defaults to stdin)\n" |
|
" --outfile ; Output filename (defaults to stdout)\n"); |
|
|
|
FLAGS_protofiles = argv[0]; |
|
FLAGS_remotedb = false; |
|
FLAGS_binary_input = true; |
|
FLAGS_binary_output = false; |
|
FLAGS_json_output = true; |
|
return ParseMessage(argc, argv, cred, callback); |
|
} |
|
|
|
bool GrpcTool::ToBinary(int argc, const char** argv, const CliCredentials& cred, |
|
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 path of proto files\n" |
|
" --infile ; Input filename (defaults to stdin)\n" |
|
" --outfile ; Output filename (defaults to stdout)\n"); |
|
|
|
FLAGS_protofiles = argv[0]; |
|
FLAGS_remotedb = false; |
|
FLAGS_binary_input = false; |
|
FLAGS_binary_output = true; |
|
return ParseMessage(argc, argv, cred, callback); |
|
} |
|
|
|
} // namespace testing |
|
} // namespace grpc
|
|
|