/*
|
*
|
* Copyright 2015 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 <algorithm>
|
#include <cassert>
|
#include <cctype>
|
#include <cstring>
|
#include <fstream>
|
#include <iostream>
|
#include <map>
|
#include <memory>
|
#include <ostream>
|
#include <set>
|
#include <sstream>
|
#include <tuple>
|
#include <vector>
|
|
#include "src/compiler/config.h"
|
#include "src/compiler/generator_helpers.h"
|
#include "src/compiler/protobuf_plugin.h"
|
#include "src/compiler/python_generator.h"
|
#include "src/compiler/python_generator_helpers.h"
|
#include "src/compiler/python_private_generator.h"
|
|
using grpc::protobuf::FileDescriptor;
|
using grpc::protobuf::compiler::GeneratorContext;
|
using grpc::protobuf::io::CodedOutputStream;
|
using grpc::protobuf::io::ZeroCopyOutputStream;
|
using std::make_pair;
|
using std::map;
|
using std::pair;
|
using std::replace;
|
using std::set;
|
using std::tuple;
|
using std::vector;
|
|
namespace grpc_python_generator {
|
|
grpc::string generator_file_name;
|
|
namespace {
|
|
typedef map<grpc::string, grpc::string> StringMap;
|
typedef vector<grpc::string> StringVector;
|
typedef tuple<grpc::string, grpc::string> StringPair;
|
typedef set<StringPair> StringPairSet;
|
|
// Provides RAII indentation handling. Use as:
|
// {
|
// IndentScope raii_my_indent_var_name_here(my_py_printer);
|
// // constructor indented my_py_printer
|
// ...
|
// // destructor called at end of scope, un-indenting my_py_printer
|
// }
|
class IndentScope {
|
public:
|
explicit IndentScope(grpc_generator::Printer* printer) : printer_(printer) {
|
printer_->Indent();
|
}
|
|
~IndentScope() { printer_->Outdent(); }
|
|
private:
|
grpc_generator::Printer* printer_;
|
};
|
|
PrivateGenerator::PrivateGenerator(const GeneratorConfiguration& config,
|
const grpc_generator::File* file)
|
: config(config), file(file) {}
|
|
void PrivateGenerator::PrintAllComments(StringVector comments,
|
grpc_generator::Printer* out) {
|
if (comments.empty()) {
|
// Python requires code structures like class and def to have
|
// a body, even if it is just "pass" or a docstring. We need
|
// to ensure not to generate empty bodies. We could do something
|
// smarter and more sophisticated, but at the moment, if there is
|
// no docstring to print, we simply emit "pass" to ensure validity
|
// of the generated code.
|
out->Print("# missing associated documentation comment in .proto file\n");
|
out->Print("pass\n");
|
return;
|
}
|
out->Print("\"\"\"");
|
for (StringVector::iterator it = comments.begin(); it != comments.end();
|
++it) {
|
size_t start_pos = it->find_first_not_of(' ');
|
if (start_pos != grpc::string::npos) {
|
out->PrintRaw(it->c_str() + start_pos);
|
}
|
out->Print("\n");
|
}
|
out->Print("\"\"\"\n");
|
}
|
|
bool PrivateGenerator::PrintBetaServicer(const grpc_generator::Service* service,
|
grpc_generator::Printer* out) {
|
StringMap service_dict;
|
service_dict["Service"] = service->name();
|
out->Print("\n\n");
|
out->Print(service_dict, "class Beta$Service$Servicer(object):\n");
|
{
|
IndentScope raii_class_indent(out);
|
out->Print(
|
"\"\"\"The Beta API is deprecated for 0.15.0 and later.\n"
|
"\nIt is recommended to use the GA API (classes and functions in this\n"
|
"file not marked beta) for all further purposes. This class was "
|
"generated\n"
|
"only to ease transition from grpcio<0.15.0 to "
|
"grpcio>=0.15.0.\"\"\"\n");
|
StringVector service_comments = service->GetAllComments();
|
PrintAllComments(service_comments, out);
|
for (int i = 0; i < service->method_count(); ++i) {
|
auto method = service->method(i);
|
grpc::string arg_name =
|
method->ClientStreaming() ? "request_iterator" : "request";
|
StringMap method_dict;
|
method_dict["Method"] = method->name();
|
method_dict["ArgName"] = arg_name;
|
out->Print(method_dict, "def $Method$(self, $ArgName$, context):\n");
|
{
|
IndentScope raii_method_indent(out);
|
StringVector method_comments = method->GetAllComments();
|
PrintAllComments(method_comments, out);
|
out->Print("context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\n");
|
}
|
}
|
}
|
return true;
|
}
|
|
bool PrivateGenerator::PrintBetaStub(const grpc_generator::Service* service,
|
grpc_generator::Printer* out) {
|
StringMap service_dict;
|
service_dict["Service"] = service->name();
|
out->Print("\n\n");
|
out->Print(service_dict, "class Beta$Service$Stub(object):\n");
|
{
|
IndentScope raii_class_indent(out);
|
out->Print(
|
"\"\"\"The Beta API is deprecated for 0.15.0 and later.\n"
|
"\nIt is recommended to use the GA API (classes and functions in this\n"
|
"file not marked beta) for all further purposes. This class was "
|
"generated\n"
|
"only to ease transition from grpcio<0.15.0 to "
|
"grpcio>=0.15.0.\"\"\"\n");
|
StringVector service_comments = service->GetAllComments();
|
PrintAllComments(service_comments, out);
|
for (int i = 0; i < service->method_count(); ++i) {
|
auto method = service->method(i);
|
grpc::string arg_name =
|
method->ClientStreaming() ? "request_iterator" : "request";
|
StringMap method_dict;
|
method_dict["Method"] = method->name();
|
method_dict["ArgName"] = arg_name;
|
out->Print(method_dict,
|
"def $Method$(self, $ArgName$, timeout, metadata=None, "
|
"with_call=False, protocol_options=None):\n");
|
{
|
IndentScope raii_method_indent(out);
|
StringVector method_comments = method->GetAllComments();
|
PrintAllComments(method_comments, out);
|
out->Print("raise NotImplementedError()\n");
|
}
|
if (!method->ServerStreaming()) {
|
out->Print(method_dict, "$Method$.future = None\n");
|
}
|
}
|
}
|
return true;
|
}
|
|
bool PrivateGenerator::PrintBetaServerFactory(
|
const grpc::string& package_qualified_service_name,
|
const grpc_generator::Service* service, grpc_generator::Printer* out) {
|
StringMap service_dict;
|
service_dict["Service"] = service->name();
|
out->Print("\n\n");
|
out->Print(service_dict,
|
"def beta_create_$Service$_server(servicer, pool=None, "
|
"pool_size=None, default_timeout=None, maximum_timeout=None):\n");
|
{
|
IndentScope raii_create_server_indent(out);
|
out->Print(
|
"\"\"\"The Beta API is deprecated for 0.15.0 and later.\n"
|
"\nIt is recommended to use the GA API (classes and functions in this\n"
|
"file not marked beta) for all further purposes. This function was\n"
|
"generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0"
|
"\"\"\"\n");
|
StringMap method_implementation_constructors;
|
StringMap input_message_modules_and_classes;
|
StringMap output_message_modules_and_classes;
|
for (int i = 0; i < service->method_count(); ++i) {
|
auto method = service->method(i);
|
const grpc::string method_implementation_constructor =
|
grpc::string(method->ClientStreaming() ? "stream_" : "unary_") +
|
grpc::string(method->ServerStreaming() ? "stream_" : "unary_") +
|
"inline";
|
grpc::string input_message_module_and_class;
|
if (!method->get_module_and_message_path_input(
|
&input_message_module_and_class, generator_file_name,
|
generate_in_pb2_grpc, config.import_prefix)) {
|
return false;
|
}
|
grpc::string output_message_module_and_class;
|
if (!method->get_module_and_message_path_output(
|
&output_message_module_and_class, generator_file_name,
|
generate_in_pb2_grpc, config.import_prefix)) {
|
return false;
|
}
|
method_implementation_constructors.insert(
|
make_pair(method->name(), method_implementation_constructor));
|
input_message_modules_and_classes.insert(
|
make_pair(method->name(), input_message_module_and_class));
|
output_message_modules_and_classes.insert(
|
make_pair(method->name(), output_message_module_and_class));
|
}
|
StringMap method_dict;
|
method_dict["PackageQualifiedServiceName"] = package_qualified_service_name;
|
out->Print("request_deserializers = {\n");
|
for (StringMap::iterator name_and_input_module_class_pair =
|
input_message_modules_and_classes.begin();
|
name_and_input_module_class_pair !=
|
input_message_modules_and_classes.end();
|
name_and_input_module_class_pair++) {
|
method_dict["MethodName"] = name_and_input_module_class_pair->first;
|
method_dict["InputTypeModuleAndClass"] =
|
name_and_input_module_class_pair->second;
|
IndentScope raii_indent(out);
|
out->Print(method_dict,
|
"(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): "
|
"$InputTypeModuleAndClass$.FromString,\n");
|
}
|
out->Print("}\n");
|
out->Print("response_serializers = {\n");
|
for (StringMap::iterator name_and_output_module_class_pair =
|
output_message_modules_and_classes.begin();
|
name_and_output_module_class_pair !=
|
output_message_modules_and_classes.end();
|
name_and_output_module_class_pair++) {
|
method_dict["MethodName"] = name_and_output_module_class_pair->first;
|
method_dict["OutputTypeModuleAndClass"] =
|
name_and_output_module_class_pair->second;
|
IndentScope raii_indent(out);
|
out->Print(method_dict,
|
"(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): "
|
"$OutputTypeModuleAndClass$.SerializeToString,\n");
|
}
|
out->Print("}\n");
|
out->Print("method_implementations = {\n");
|
for (StringMap::iterator name_and_implementation_constructor =
|
method_implementation_constructors.begin();
|
name_and_implementation_constructor !=
|
method_implementation_constructors.end();
|
name_and_implementation_constructor++) {
|
method_dict["Method"] = name_and_implementation_constructor->first;
|
method_dict["Constructor"] = name_and_implementation_constructor->second;
|
IndentScope raii_descriptions_indent(out);
|
const grpc::string method_name =
|
name_and_implementation_constructor->first;
|
out->Print(method_dict,
|
"(\'$PackageQualifiedServiceName$\', \'$Method$\'): "
|
"face_utilities.$Constructor$(servicer.$Method$),\n");
|
}
|
out->Print("}\n");
|
out->Print(
|
"server_options = beta_implementations.server_options("
|
"request_deserializers=request_deserializers, "
|
"response_serializers=response_serializers, "
|
"thread_pool=pool, thread_pool_size=pool_size, "
|
"default_timeout=default_timeout, "
|
"maximum_timeout=maximum_timeout)\n");
|
out->Print(
|
"return beta_implementations.server(method_implementations, "
|
"options=server_options)\n");
|
}
|
return true;
|
}
|
|
bool PrivateGenerator::PrintBetaStubFactory(
|
const grpc::string& package_qualified_service_name,
|
const grpc_generator::Service* service, grpc_generator::Printer* out) {
|
StringMap dict;
|
dict["Service"] = service->name();
|
out->Print("\n\n");
|
out->Print(dict,
|
"def beta_create_$Service$_stub(channel, host=None,"
|
" metadata_transformer=None, pool=None, pool_size=None):\n");
|
{
|
IndentScope raii_create_server_indent(out);
|
out->Print(
|
"\"\"\"The Beta API is deprecated for 0.15.0 and later.\n"
|
"\nIt is recommended to use the GA API (classes and functions in this\n"
|
"file not marked beta) for all further purposes. This function was\n"
|
"generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0"
|
"\"\"\"\n");
|
StringMap method_cardinalities;
|
StringMap input_message_modules_and_classes;
|
StringMap output_message_modules_and_classes;
|
for (int i = 0; i < service->method_count(); ++i) {
|
auto method = service->method(i);
|
const grpc::string method_cardinality =
|
grpc::string(method->ClientStreaming() ? "STREAM" : "UNARY") + "_" +
|
grpc::string(method->ServerStreaming() ? "STREAM" : "UNARY");
|
grpc::string input_message_module_and_class;
|
if (!method->get_module_and_message_path_input(
|
&input_message_module_and_class, generator_file_name,
|
generate_in_pb2_grpc, config.import_prefix)) {
|
return false;
|
}
|
grpc::string output_message_module_and_class;
|
if (!method->get_module_and_message_path_output(
|
&output_message_module_and_class, generator_file_name,
|
generate_in_pb2_grpc, config.import_prefix)) {
|
return false;
|
}
|
method_cardinalities.insert(
|
make_pair(method->name(), method_cardinality));
|
input_message_modules_and_classes.insert(
|
make_pair(method->name(), input_message_module_and_class));
|
output_message_modules_and_classes.insert(
|
make_pair(method->name(), output_message_module_and_class));
|
}
|
StringMap method_dict;
|
method_dict["PackageQualifiedServiceName"] = package_qualified_service_name;
|
out->Print("request_serializers = {\n");
|
for (StringMap::iterator name_and_input_module_class_pair =
|
input_message_modules_and_classes.begin();
|
name_and_input_module_class_pair !=
|
input_message_modules_and_classes.end();
|
name_and_input_module_class_pair++) {
|
method_dict["MethodName"] = name_and_input_module_class_pair->first;
|
method_dict["InputTypeModuleAndClass"] =
|
name_and_input_module_class_pair->second;
|
IndentScope raii_indent(out);
|
out->Print(method_dict,
|
"(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): "
|
"$InputTypeModuleAndClass$.SerializeToString,\n");
|
}
|
out->Print("}\n");
|
out->Print("response_deserializers = {\n");
|
for (StringMap::iterator name_and_output_module_class_pair =
|
output_message_modules_and_classes.begin();
|
name_and_output_module_class_pair !=
|
output_message_modules_and_classes.end();
|
name_and_output_module_class_pair++) {
|
method_dict["MethodName"] = name_and_output_module_class_pair->first;
|
method_dict["OutputTypeModuleAndClass"] =
|
name_and_output_module_class_pair->second;
|
IndentScope raii_indent(out);
|
out->Print(method_dict,
|
"(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): "
|
"$OutputTypeModuleAndClass$.FromString,\n");
|
}
|
out->Print("}\n");
|
out->Print("cardinalities = {\n");
|
for (StringMap::iterator name_and_cardinality =
|
method_cardinalities.begin();
|
name_and_cardinality != method_cardinalities.end();
|
name_and_cardinality++) {
|
method_dict["Method"] = name_and_cardinality->first;
|
method_dict["Cardinality"] = name_and_cardinality->second;
|
IndentScope raii_descriptions_indent(out);
|
out->Print(method_dict,
|
"\'$Method$\': cardinality.Cardinality.$Cardinality$,\n");
|
}
|
out->Print("}\n");
|
out->Print(
|
"stub_options = beta_implementations.stub_options("
|
"host=host, metadata_transformer=metadata_transformer, "
|
"request_serializers=request_serializers, "
|
"response_deserializers=response_deserializers, "
|
"thread_pool=pool, thread_pool_size=pool_size)\n");
|
out->Print(method_dict,
|
"return beta_implementations.dynamic_stub(channel, "
|
"\'$PackageQualifiedServiceName$\', "
|
"cardinalities, options=stub_options)\n");
|
}
|
return true;
|
}
|
|
bool PrivateGenerator::PrintStub(
|
const grpc::string& package_qualified_service_name,
|
const grpc_generator::Service* service, grpc_generator::Printer* out) {
|
StringMap dict;
|
dict["Service"] = service->name();
|
out->Print("\n\n");
|
out->Print(dict, "class $Service$Stub(object):\n");
|
{
|
IndentScope raii_class_indent(out);
|
StringVector service_comments = service->GetAllComments();
|
PrintAllComments(service_comments, out);
|
out->Print("\n");
|
out->Print("def __init__(self, channel):\n");
|
{
|
IndentScope raii_init_indent(out);
|
out->Print("\"\"\"Constructor.\n");
|
out->Print("\n");
|
out->Print("Args:\n");
|
{
|
IndentScope raii_args_indent(out);
|
out->Print("channel: A grpc.Channel.\n");
|
}
|
out->Print("\"\"\"\n");
|
for (int i = 0; i < service->method_count(); ++i) {
|
auto method = service->method(i);
|
grpc::string multi_callable_constructor =
|
grpc::string(method->ClientStreaming() ? "stream" : "unary") + "_" +
|
grpc::string(method->ServerStreaming() ? "stream" : "unary");
|
grpc::string request_module_and_class;
|
if (!method->get_module_and_message_path_input(
|
&request_module_and_class, generator_file_name,
|
generate_in_pb2_grpc, config.import_prefix)) {
|
return false;
|
}
|
grpc::string response_module_and_class;
|
if (!method->get_module_and_message_path_output(
|
&response_module_and_class, generator_file_name,
|
generate_in_pb2_grpc, config.import_prefix)) {
|
return false;
|
}
|
StringMap method_dict;
|
method_dict["Method"] = method->name();
|
method_dict["MultiCallableConstructor"] = multi_callable_constructor;
|
out->Print(method_dict,
|
"self.$Method$ = channel.$MultiCallableConstructor$(\n");
|
{
|
method_dict["PackageQualifiedService"] =
|
package_qualified_service_name;
|
method_dict["RequestModuleAndClass"] = request_module_and_class;
|
method_dict["ResponseModuleAndClass"] = response_module_and_class;
|
IndentScope raii_first_attribute_indent(out);
|
IndentScope raii_second_attribute_indent(out);
|
out->Print(method_dict, "'/$PackageQualifiedService$/$Method$',\n");
|
out->Print(method_dict,
|
"request_serializer=$RequestModuleAndClass$."
|
"SerializeToString,\n");
|
out->Print(
|
method_dict,
|
"response_deserializer=$ResponseModuleAndClass$.FromString,\n");
|
out->Print(")\n");
|
}
|
}
|
}
|
}
|
return true;
|
}
|
|
bool PrivateGenerator::PrintServicer(const grpc_generator::Service* service,
|
grpc_generator::Printer* out) {
|
StringMap service_dict;
|
service_dict["Service"] = service->name();
|
out->Print("\n\n");
|
out->Print(service_dict, "class $Service$Servicer(object):\n");
|
{
|
IndentScope raii_class_indent(out);
|
StringVector service_comments = service->GetAllComments();
|
PrintAllComments(service_comments, out);
|
for (int i = 0; i < service->method_count(); ++i) {
|
auto method = service->method(i);
|
grpc::string arg_name =
|
method->ClientStreaming() ? "request_iterator" : "request";
|
StringMap method_dict;
|
method_dict["Method"] = method->name();
|
method_dict["ArgName"] = arg_name;
|
out->Print("\n");
|
out->Print(method_dict, "def $Method$(self, $ArgName$, context):\n");
|
{
|
IndentScope raii_method_indent(out);
|
StringVector method_comments = method->GetAllComments();
|
PrintAllComments(method_comments, out);
|
out->Print("context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n");
|
out->Print("context.set_details('Method not implemented!')\n");
|
out->Print("raise NotImplementedError('Method not implemented!')\n");
|
}
|
}
|
}
|
return true;
|
}
|
|
bool PrivateGenerator::PrintAddServicerToServer(
|
const grpc::string& package_qualified_service_name,
|
const grpc_generator::Service* service, grpc_generator::Printer* out) {
|
StringMap service_dict;
|
service_dict["Service"] = service->name();
|
out->Print("\n\n");
|
out->Print(service_dict,
|
"def add_$Service$Servicer_to_server(servicer, server):\n");
|
{
|
IndentScope raii_class_indent(out);
|
out->Print("rpc_method_handlers = {\n");
|
{
|
IndentScope raii_dict_first_indent(out);
|
IndentScope raii_dict_second_indent(out);
|
for (int i = 0; i < service->method_count(); ++i) {
|
auto method = service->method(i);
|
grpc::string method_handler_constructor =
|
grpc::string(method->ClientStreaming() ? "stream" : "unary") + "_" +
|
grpc::string(method->ServerStreaming() ? "stream" : "unary") +
|
"_rpc_method_handler";
|
grpc::string request_module_and_class;
|
if (!method->get_module_and_message_path_input(
|
&request_module_and_class, generator_file_name,
|
generate_in_pb2_grpc, config.import_prefix)) {
|
return false;
|
}
|
grpc::string response_module_and_class;
|
if (!method->get_module_and_message_path_output(
|
&response_module_and_class, generator_file_name,
|
generate_in_pb2_grpc, config.import_prefix)) {
|
return false;
|
}
|
StringMap method_dict;
|
method_dict["Method"] = method->name();
|
method_dict["MethodHandlerConstructor"] = method_handler_constructor;
|
method_dict["RequestModuleAndClass"] = request_module_and_class;
|
method_dict["ResponseModuleAndClass"] = response_module_and_class;
|
out->Print(method_dict,
|
"'$Method$': grpc.$MethodHandlerConstructor$(\n");
|
{
|
IndentScope raii_call_first_indent(out);
|
IndentScope raii_call_second_indent(out);
|
out->Print(method_dict, "servicer.$Method$,\n");
|
out->Print(
|
method_dict,
|
"request_deserializer=$RequestModuleAndClass$.FromString,\n");
|
out->Print(
|
method_dict,
|
"response_serializer=$ResponseModuleAndClass$.SerializeToString,"
|
"\n");
|
}
|
out->Print("),\n");
|
}
|
}
|
StringMap method_dict;
|
method_dict["PackageQualifiedServiceName"] = package_qualified_service_name;
|
out->Print("}\n");
|
out->Print("generic_handler = grpc.method_handlers_generic_handler(\n");
|
{
|
IndentScope raii_call_first_indent(out);
|
IndentScope raii_call_second_indent(out);
|
out->Print(method_dict,
|
"'$PackageQualifiedServiceName$', rpc_method_handlers)\n");
|
}
|
out->Print("server.add_generic_rpc_handlers((generic_handler,))\n");
|
}
|
return true;
|
}
|
|
bool PrivateGenerator::PrintBetaPreamble(grpc_generator::Printer* out) {
|
StringMap var;
|
var["Package"] = config.beta_package_root;
|
out->Print(var,
|
"from $Package$ import implementations as beta_implementations\n");
|
out->Print(var, "from $Package$ import interfaces as beta_interfaces\n");
|
out->Print("from grpc.framework.common import cardinality\n");
|
out->Print(
|
"from grpc.framework.interfaces.face import utilities as "
|
"face_utilities\n");
|
return true;
|
}
|
|
bool PrivateGenerator::PrintPreamble(grpc_generator::Printer* out) {
|
StringMap var;
|
var["Package"] = config.grpc_package_root;
|
out->Print(var, "import $Package$\n");
|
if (generate_in_pb2_grpc) {
|
out->Print("\n");
|
StringPairSet imports_set;
|
for (int i = 0; i < file->service_count(); ++i) {
|
auto service = file->service(i);
|
for (int j = 0; j < service->method_count(); ++j) {
|
auto method = service.get()->method(j);
|
|
grpc::string input_type_file_name = method->get_input_type_name();
|
grpc::string input_module_name =
|
ModuleName(input_type_file_name, config.import_prefix);
|
grpc::string input_module_alias =
|
ModuleAlias(input_type_file_name, config.import_prefix);
|
imports_set.insert(
|
std::make_tuple(input_module_name, input_module_alias));
|
|
grpc::string output_type_file_name = method->get_output_type_name();
|
grpc::string output_module_name =
|
ModuleName(output_type_file_name, config.import_prefix);
|
grpc::string output_module_alias =
|
ModuleAlias(output_type_file_name, config.import_prefix);
|
imports_set.insert(
|
std::make_tuple(output_module_name, output_module_alias));
|
}
|
}
|
|
for (StringPairSet::iterator it = imports_set.begin();
|
it != imports_set.end(); ++it) {
|
auto module_name = std::get<0>(*it);
|
var["ModuleAlias"] = std::get<1>(*it);
|
const size_t last_dot_pos = module_name.rfind('.');
|
if (last_dot_pos == grpc::string::npos) {
|
var["ImportStatement"] = "import " + module_name;
|
} else {
|
var["ImportStatement"] = "from " + module_name.substr(0, last_dot_pos) +
|
" import " +
|
module_name.substr(last_dot_pos + 1);
|
}
|
out->Print(var, "$ImportStatement$ as $ModuleAlias$\n");
|
}
|
}
|
return true;
|
}
|
|
bool PrivateGenerator::PrintGAServices(grpc_generator::Printer* out) {
|
grpc::string package = file->package();
|
if (!package.empty()) {
|
package = package.append(".");
|
}
|
for (int i = 0; i < file->service_count(); ++i) {
|
auto service = file->service(i);
|
grpc::string package_qualified_service_name = package + service->name();
|
if (!(PrintStub(package_qualified_service_name, service.get(), out) &&
|
PrintServicer(service.get(), out) &&
|
PrintAddServicerToServer(package_qualified_service_name,
|
service.get(), out))) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
bool PrivateGenerator::PrintBetaServices(grpc_generator::Printer* out) {
|
grpc::string package = file->package();
|
if (!package.empty()) {
|
package = package.append(".");
|
}
|
for (int i = 0; i < file->service_count(); ++i) {
|
auto service = file->service(i);
|
grpc::string package_qualified_service_name = package + service->name();
|
if (!(PrintBetaServicer(service.get(), out) &&
|
PrintBetaStub(service.get(), out) &&
|
PrintBetaServerFactory(package_qualified_service_name, service.get(),
|
out) &&
|
PrintBetaStubFactory(package_qualified_service_name, service.get(),
|
out))) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
pair<bool, grpc::string> PrivateGenerator::GetGrpcServices() {
|
grpc::string output;
|
{
|
// Scope the output stream so it closes and finalizes output to the string.
|
auto out = file->CreatePrinter(&output);
|
if (generate_in_pb2_grpc) {
|
out->Print(
|
"# Generated by the gRPC Python protocol compiler plugin. "
|
"DO NOT EDIT!\n");
|
if (!PrintPreamble(out.get())) {
|
return make_pair(false, "");
|
}
|
if (!PrintGAServices(out.get())) {
|
return make_pair(false, "");
|
}
|
} else {
|
out->Print("try:\n");
|
{
|
IndentScope raii_dict_try_indent(out.get());
|
out->Print(
|
"# THESE ELEMENTS WILL BE DEPRECATED.\n"
|
"# Please use the generated *_pb2_grpc.py files instead.\n");
|
if (!PrintPreamble(out.get())) {
|
return make_pair(false, "");
|
}
|
if (!PrintBetaPreamble(out.get())) {
|
return make_pair(false, "");
|
}
|
if (!PrintGAServices(out.get())) {
|
return make_pair(false, "");
|
}
|
if (!PrintBetaServices(out.get())) {
|
return make_pair(false, "");
|
}
|
}
|
out->Print("except ImportError:\n");
|
{
|
IndentScope raii_dict_except_indent(out.get());
|
out->Print("pass");
|
}
|
}
|
}
|
return make_pair(true, std::move(output));
|
}
|
|
} // namespace
|
|
GeneratorConfiguration::GeneratorConfiguration()
|
: grpc_package_root("grpc"),
|
beta_package_root("grpc.beta"),
|
import_prefix("") {}
|
|
PythonGrpcGenerator::PythonGrpcGenerator(const GeneratorConfiguration& config)
|
: config_(config) {}
|
|
PythonGrpcGenerator::~PythonGrpcGenerator() {}
|
|
static bool GenerateGrpc(GeneratorContext* context, PrivateGenerator& generator,
|
grpc::string file_name, bool generate_in_pb2_grpc) {
|
bool success;
|
std::unique_ptr<ZeroCopyOutputStream> output;
|
std::unique_ptr<CodedOutputStream> coded_output;
|
grpc::string grpc_code;
|
|
if (generate_in_pb2_grpc) {
|
output.reset(context->Open(file_name));
|
generator.generate_in_pb2_grpc = true;
|
} else {
|
output.reset(context->OpenForInsert(file_name, "module_scope"));
|
generator.generate_in_pb2_grpc = false;
|
}
|
|
coded_output.reset(new CodedOutputStream(output.get()));
|
tie(success, grpc_code) = generator.GetGrpcServices();
|
|
if (success) {
|
coded_output->WriteRaw(grpc_code.data(), grpc_code.size());
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
bool PythonGrpcGenerator::Generate(const FileDescriptor* file,
|
const grpc::string& parameter,
|
GeneratorContext* context,
|
grpc::string* error) const {
|
// Get output file name.
|
grpc::string pb2_file_name;
|
grpc::string pb2_grpc_file_name;
|
static const int proto_suffix_length = strlen(".proto");
|
if (file->name().size() > static_cast<size_t>(proto_suffix_length) &&
|
file->name().find_last_of(".proto") == file->name().size() - 1) {
|
grpc::string base =
|
file->name().substr(0, file->name().size() - proto_suffix_length);
|
std::replace(base.begin(), base.end(), '-', '_');
|
pb2_file_name = base + "_pb2.py";
|
pb2_grpc_file_name = base + "_pb2_grpc.py";
|
} else {
|
*error = "Invalid proto file name. Proto file must end with .proto";
|
return false;
|
}
|
generator_file_name = file->name();
|
|
ProtoBufFile pbfile(file);
|
PrivateGenerator generator(config_, &pbfile);
|
if (parameter == "" || parameter == "grpc_2_0") {
|
return GenerateGrpc(context, generator, pb2_grpc_file_name, true);
|
} else if (parameter == "grpc_1_0") {
|
return GenerateGrpc(context, generator, pb2_grpc_file_name, true) &&
|
GenerateGrpc(context, generator, pb2_file_name, false);
|
} else {
|
*error = "Invalid parameter '" + parameter + "'.";
|
return false;
|
}
|
}
|
|
} // namespace grpc_python_generator
|
