Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Refactored based on code review

Browse Source
pull/16766/head
Feso 6 years ago
parent d74162f83a
commit 29c131f790
3 changed files with 107 additions and 175 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 79
      test/cpp/util/grpc_tool.cc
  2. 139
      test/cpp/util/proto_file_parser.cc
  3. 64
      test/cpp/util/proto_file_parser.h

79
test/cpp/util/grpc_tool.cc
Unescape View File

@ -193,8 +193,9 @@ void ReadResponse(CliCall* call, const grpc::string& method_name,
fprintf(stderr, "got response.\n"); fprintf(stderr, "got response.\n");
if (!FLAGS_binary_output) { if (!FLAGS_binary_output) {
gpr_mu_lock(parser_mu); gpr_mu_lock(parser_mu);
serialized_response_proto = parser->GetTextFormatFromMethod( serialized_response_proto = parser->GetFormattedStringFromMethod(
method_name, serialized_response_proto, false /* is_request */); method_name, serialized_response_proto, false /* is_request */,
FLAGS_json_output);
if (parser->HasError() && print_mode) { if (parser->HasError() && print_mode) {
fprintf(stderr, "Failed to parse response.\n"); fprintf(stderr, "Failed to parse response.\n");
} }
@ -555,12 +556,9 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
request_text.clear(); request_text.clear();
} else { } else {
gpr_mu_lock(&parser_mu); gpr_mu_lock(&parser_mu);
serialized_request_proto = serialized_request_proto = parser->GetSerializedProtoFromMethod(
FLAGS_json_input ? method_name, request_text, true /* is_request */,
parser->GetSerializedProtoFromMethodJsonFormat( FLAGS_json_input);
method_name, request_text, true /* is_request */) :
parser->GetSerializedProtoFromMethodTextFormat(
method_name, request_text, true /* is_request */);
request_text.clear(); request_text.clear();
if (parser->HasError()) { if (parser->HasError()) {
if (print_mode) { if (print_mode) {
@ -643,12 +641,9 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
serialized_request_proto = request_text; serialized_request_proto = request_text;
request_text.clear(); request_text.clear();
} else { } else {
serialized_request_proto = serialized_request_proto = parser->GetSerializedProtoFromMethod(
FLAGS_json_input ? method_name, request_text, true /* is_request */,
parser->GetSerializedProtoFromMethodJsonFormat( FLAGS_json_input);
method_name, request_text, true /* is_request */) :
parser->GetSerializedProtoFromMethodTextFormat(
method_name, request_text, true /* is_request */);
request_text.clear(); request_text.clear();
if (parser->HasError()) { if (parser->HasError()) {
if (print_mode) { if (print_mode) {
@ -684,14 +679,10 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
break; break;
} }
} else { } else {
grpc::string response_text = grpc::string response_text = parser->GetFormattedStringFromMethod(method_name,
FLAGS_json_output ?
parser->GetJsonFormatFromMethod(method_name,
serialized_response_proto, serialized_response_proto,
false /* is_request */) : false /* is_request */,
parser->GetTextFormatFromMethod(method_name, FLAGS_json_output);
serialized_response_proto,
false /* is_request */);
if (parser->HasError() && print_mode) { if (parser->HasError() && print_mode) {
fprintf(stderr, "Failed to parse response.\n"); fprintf(stderr, "Failed to parse response.\n");
@ -748,12 +739,8 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
if (FLAGS_binary_input) { if (FLAGS_binary_input) {
serialized_request_proto = request_text; serialized_request_proto = request_text;
} else { } else {
serialized_request_proto = serialized_request_proto = parser->GetSerializedProtoFromMethod(
FLAGS_json_input ? method_name, request_text, true /* is_request */, FLAGS_json_input);
parser->GetSerializedProtoFromMethodJsonFormat(
method_name, request_text, true /* is_request */) :
parser->GetSerializedProtoFromMethodTextFormat(
method_name, request_text, true /* is_request */);
if (parser->HasError()) { if (parser->HasError()) {
fprintf(stderr, "Failed to parse request.\n"); fprintf(stderr, "Failed to parse request.\n");
return false; return false;
@ -776,18 +763,14 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
&serialized_response_proto, &serialized_response_proto,
receive_initial_metadata ? &server_initial_metadata : nullptr); receive_initial_metadata ? &server_initial_metadata : nullptr);
receive_initial_metadata = false) { receive_initial_metadata = false) {
if (FLAGS_json_output) { if (!FLAGS_binary_output) {
serialized_response_proto = parser->GetJsonFormatFromMethod( serialized_response_proto = parser->GetFormattedStringFromMethod(
method_name, serialized_response_proto, false /* is_request */); method_name, serialized_response_proto, false /* is_request */,
} else if (!FLAGS_binary_output) { FLAGS_json_output);
serialized_response_proto = parser->GetTextFormatFromMethod( if (parser->HasError()) {
method_name, serialized_response_proto, false /* is_request */); fprintf(stderr, "Failed to parse response.\n");
} return false;
if (FLAGS_json_output || !FLAGS_binary_output) { }
if (parser->HasError()) {
fprintf(stderr, "Failed to parse response.\n");
return false;
}
} }
if (receive_initial_metadata) { if (receive_initial_metadata) {
@ -878,12 +861,8 @@ bool GrpcTool::ParseMessage(int argc, const char** argv,
if (FLAGS_binary_input) { if (FLAGS_binary_input) {
serialized_request_proto = message_text; serialized_request_proto = message_text;
} else { } else {
serialized_request_proto = serialized_request_proto = parser->GetSerializedProtoFromMessageType(
FLAGS_json_input ? type_name, message_text, FLAGS_json_input);
parser->GetSerializedProtoFromMessageTypeJsonFormat(type_name,
message_text) :
parser->GetSerializedProtoFromMessageTypeTextFormat(type_name,
message_text);
if (parser->HasError()) { if (parser->HasError()) {
fprintf(stderr, "Failed to serialize the message.\n"); fprintf(stderr, "Failed to serialize the message.\n");
return false; return false;
@ -894,14 +873,8 @@ bool GrpcTool::ParseMessage(int argc, const char** argv,
output_ss << serialized_request_proto; output_ss << serialized_request_proto;
} else { } else {
grpc::string output_text; grpc::string output_text;
if (FLAGS_json_output) { output_text = parser->GetFormattedStringFromMessageType(
output_text = parser->GetJsonFormatFromMessageType( type_name, serialized_request_proto, FLAGS_json_output);
type_name, serialized_request_proto);
} else {
output_text = parser->GetTextFormatFromMessageType(
type_name, serialized_request_proto);
}
if (parser->HasError()) { if (parser->HasError()) {
fprintf(stderr, "Failed to deserialize the message.\n"); fprintf(stderr, "Failed to deserialize the message.\n");
return false; return false;

139
test/cpp/util/proto_file_parser.cc
Unescape View File

@ -216,55 +216,33 @@ bool ProtoFileParser::IsStreaming(const grpc::string& method, bool is_request) {
: method_desc->server_streaming(); : method_desc->server_streaming();
} }
grpc::string ProtoFileParser::GetSerializedProtoFromMethodTextFormat( grpc::string ProtoFileParser::GetSerializedProtoFromMethod(
const grpc::string& method, const grpc::string& text_format_proto, const grpc::string& method, const grpc::string& formatted_proto,
bool is_request) { bool is_request, bool is_json_format) {
has_error_ = false; has_error_ = false;
grpc::string message_type_name = GetMessageTypeFromMethod(method, is_request); grpc::string message_type_name = GetMessageTypeFromMethod(method, is_request);
if (has_error_) { if (has_error_) {
return ""; return "";
} }
return GetSerializedProtoFromMessageTypeTextFormat(message_type_name, return GetSerializedProtoFromMessageType(message_type_name, formatted_proto,
text_format_proto); is_json_format);
} }
grpc::string ProtoFileParser::GetSerializedProtoFromMethodJsonFormat( grpc::string ProtoFileParser::GetFormattedStringFromMethod(
const grpc::string& method, const grpc::string& json_format_proto,
bool is_request) {
has_error_ = false;
grpc::string message_type_name = GetMessageTypeFromMethod(method, is_request);
if (has_error_) {
return "";
}
return GetSerializedProtoFromMessageTypeJsonFormat(message_type_name,
json_format_proto);
}
grpc::string ProtoFileParser::GetTextFormatFromMethod(
const grpc::string& method, const grpc::string& serialized_proto,
bool is_request) {
has_error_ = false;
grpc::string message_type_name = GetMessageTypeFromMethod(method, is_request);
if (has_error_) {
return "";
}
return GetTextFormatFromMessageType(message_type_name, serialized_proto);
}
grpc::string ProtoFileParser::GetJsonFormatFromMethod(
const grpc::string& method, const grpc::string& serialized_proto, const grpc::string& method, const grpc::string& serialized_proto,
bool is_request) { bool is_request, bool is_json_format) {
has_error_ = false; has_error_ = false;
grpc::string message_type_name = GetMessageTypeFromMethod(method, is_request); grpc::string message_type_name = GetMessageTypeFromMethod(method, is_request);
if (has_error_) { if (has_error_) {
return ""; return "";
} }
return GetJsonFormatFromMessageType(message_type_name, serialized_proto); return GetFormattedStringFromMessageType(message_type_name, serialized_proto, is_json_format);
} }
grpc::string ProtoFileParser::GetSerializedProtoFromMessageTypeTextFormat( grpc::string ProtoFileParser::GetSerializedProtoFromMessageType(
const grpc::string& message_type_name, const grpc::string& message_type_name,
const grpc::string& text_format_proto) { const grpc::string& formatted_proto,
bool is_json_format) {
has_error_ = false; has_error_ = false;
grpc::string serialized; grpc::string serialized;
const protobuf::Descriptor* desc = const protobuf::Descriptor* desc =
@ -275,38 +253,24 @@ grpc::string ProtoFileParser::GetSerializedProtoFromMessageTypeTextFormat(
} }
std::unique_ptr<grpc::protobuf::Message> msg( std::unique_ptr<grpc::protobuf::Message> msg(
dynamic_factory_->GetPrototype(desc)->New()); dynamic_factory_->GetPrototype(desc)->New());
bool ok = protobuf::TextFormat::ParseFromString(text_format_proto, msg.get());
if (!ok) {
LogError("Failed to parse text format to proto.");
return "";
}
ok = msg->SerializeToString(&serialized);
if (!ok) {
LogError("Failed to serialize proto.");
return "";
}
return serialized;
}
grpc::string ProtoFileParser::GetSerializedProtoFromMessageTypeJsonFormat( bool ok;
const grpc::string& message_type_name, if (is_json_format) {
const grpc::string& json_format_proto) { ok = grpc::protobuf::json::JsonStringToMessage(formatted_proto, msg.get())
has_error_ = false; .ok();
grpc::string serialized; if (!ok) {
const protobuf::Descriptor* desc = LogError("Failed to convert json format to proto.");
desc_pool_->FindMessageTypeByName(message_type_name); return "";
if (!desc) { }
LogError("Message type not found"); } else {
return ""; ok = protobuf::TextFormat::ParseFromString(formatted_proto, msg.get());
if (!ok) {
LogError("Failed to convert text format to proto.");
return "";
}
} }
std::unique_ptr<grpc::protobuf::Message> msg(
dynamic_factory_->GetPrototype(desc)->New());
if (!grpc::protobuf::json::JsonStringToMessage(json_format_proto, msg.get()).ok()) { ok = msg->SerializeToString(&serialized);
LogError("Failed to parse json format to proto.");
return "";
}
bool ok = msg->SerializeToString(&serialized);
if (!ok) { if (!ok) {
LogError("Failed to serialize proto."); LogError("Failed to serialize proto.");
return ""; return "";
@ -314,9 +278,10 @@ grpc::string ProtoFileParser::GetSerializedProtoFromMessageTypeJsonFormat(
return serialized; return serialized;
} }
grpc::string ProtoFileParser::GetTextFormatFromMessageType( grpc::string ProtoFileParser::GetFormattedStringFromMessageType(
const grpc::string& message_type_name, const grpc::string& message_type_name,
const grpc::string& serialized_proto) { const grpc::string& serialized_proto,
bool is_json_format) {
has_error_ = false; has_error_ = false;
const protobuf::Descriptor* desc = const protobuf::Descriptor* desc =
desc_pool_->FindMessageTypeByName(message_type_name); desc_pool_->FindMessageTypeByName(message_type_name);
@ -330,38 +295,24 @@ grpc::string ProtoFileParser::GetTextFormatFromMessageType(
LogError("Failed to deserialize proto."); LogError("Failed to deserialize proto.");
return ""; return "";
} }
grpc::string text_format; grpc::string formatted_string;
if (!protobuf::TextFormat::PrintToString(*msg.get(), &text_format)) {
LogError("Failed to print proto message to text format");
return "";
}
return text_format;
}
grpc::string ProtoFileParser::GetJsonFormatFromMessageType( if (is_json_format) {
const grpc::string& message_type_name, grpc::protobuf::json::JsonPrintOptions jsonPrintOptions;
const grpc::string& serialized_proto) { jsonPrintOptions.add_whitespace = true;
has_error_ = false; if (!grpc::protobuf::json::MessageToJsonString(*msg.get(),
const protobuf::Descriptor* desc = &formatted_string,
desc_pool_->FindMessageTypeByName(message_type_name); jsonPrintOptions).ok()) {
if (!desc) { LogError("Failed to print proto message to json format");
LogError("Message type not found"); return "";
return ""; }
} } else {
std::unique_ptr<grpc::protobuf::Message> msg( if (!protobuf::TextFormat::PrintToString(*msg.get(), &formatted_string)) {
dynamic_factory_->GetPrototype(desc)->New()); LogError("Failed to print proto message to text format");
if (!msg->ParseFromString(serialized_proto)) { return "";
LogError("Failed to deserialize proto."); }
return "";
}
grpc::string json_format;
grpc::protobuf::json::JsonPrintOptions jsonPrintOptions;
jsonPrintOptions.add_whitespace = true;
if (!grpc::protobuf::json::MessageToJsonString(*msg.get(), &json_format, jsonPrintOptions).ok()) {
LogError("Failed to print proto message to json format");
return "";
} }
return json_format; return formatted_string;
} }
void ProtoFileParser::LogError(const grpc::string& error_msg) { void ProtoFileParser::LogError(const grpc::string& error_msg) {

64
test/cpp/util/proto_file_parser.h
Unescape View File

@ -53,37 +53,45 @@ class ProtoFileParser {
// used as the argument of Stub::Call() // used as the argument of Stub::Call()
grpc::string GetFormattedMethodName(const grpc::string& method); grpc::string GetFormattedMethodName(const grpc::string& method);
grpc::string GetSerializedProtoFromMethodTextFormat( /// Converts a text or json string to its binary proto representation for the
const grpc::string& method, const grpc::string& text_format_proto, /// given method's input or return type.
bool is_request); /// \param method the name of the method (does not need to be fully qualified name)
/// \param formatted_proto the text- or json-formatted proto string
grpc::string GetSerializedProtoFromMethodJsonFormat( /// \param is_request if \c true the resolved type is that of the input parameter of
const grpc::string& method, const grpc::string& json_format_proto, /// the method, otherwise it is the output type
bool is_request); /// \param is_json_format if \c true the \c formatted_proto is treated as a
/// json-formatted proto, otherwise it is treated as a text-formatted proto
grpc::string GetTextFormatFromMethod(const grpc::string& method, /// \return the serialised binary proto represenation of \c formatted_proto
const grpc::string& serialized_proto, grpc::string GetSerializedProtoFromMethod(
bool is_request); const grpc::string& method, const grpc::string& formatted_proto,
bool is_request, bool is_json_format);
grpc::string GetJsonFormatFromMethod(const grpc::string& method,
const grpc::string& serialized_proto, /// Converts a text or json string to its proto representation for the given
bool is_request); /// message type.
/// \param formatted_proto the text- or json-formatted proto string
grpc::string GetSerializedProtoFromMessageTypeTextFormat( /// \return the serialised binary proto represenation of \c formatted_proto
grpc::string GetSerializedProtoFromMessageType(
const grpc::string& message_type_name, const grpc::string& message_type_name,
const grpc::string& text_format_proto); const grpc::string& formatted_proto,
bool is_json_format);
grpc::string GetSerializedProtoFromMessageTypeJsonFormat(
const grpc::string& message_type_name, /// Converts a binary proto string to its text or json string representation
const grpc::string& json_format_proto); /// for the given method's input or return type.
/// \param method the name of the method (does not need to be a fully qualified name)
grpc::string GetTextFormatFromMessageType( /// \param the serialised binary proto representation of type \c message_type_name
const grpc::string& message_type_name, /// \return the text- or json-formatted proto string of \c serialized_proto
const grpc::string& serialized_proto); grpc::string GetFormattedStringFromMethod(const grpc::string& method,
const grpc::string& serialized_proto,
bool is_request, bool is_json_format);
grpc::string GetJsonFormatFromMessageType( /// Converts a binary proto string to its text or json string representation
/// for the given message type.
/// \param the serialised binary proto representation of type \c message_type_name
/// \return the text- or json-formatted proto string of \c serialized_proto
grpc::string GetFormattedStringFromMessageType(
const grpc::string& message_type_name, const grpc::string& message_type_name,
const grpc::string& serialized_proto); const grpc::string& serialized_proto,
bool is_json_format);
bool IsStreaming(const grpc::string& method, bool is_request); bool IsStreaming(const grpc::string& method, bool is_request);

Write Preview
Loading…
Cancel
Save