mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-03 12:21:23 +00:00
625 lines
24 KiB
C++
625 lines
24 KiB
C++
/*
|
|
*
|
|
* 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 "flatbuffers/util.h"
|
|
#include "src/compiler/python_generator.h"
|
|
#include "src/compiler/python_private_generator.h"
|
|
|
|
using std::make_pair;
|
|
using std::map;
|
|
using std::pair;
|
|
using std::replace;
|
|
using std::tuple;
|
|
using std::vector;
|
|
using std::set;
|
|
|
|
namespace grpc_python_generator {
|
|
|
|
grpc::string generator_file_name;
|
|
|
|
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_;
|
|
};
|
|
|
|
inline grpc::string StringReplace(grpc::string str, const grpc::string& from,
|
|
const grpc::string& to, bool replace_all) {
|
|
size_t pos = 0;
|
|
|
|
do {
|
|
pos = str.find(from, pos);
|
|
if (pos == grpc::string::npos) {
|
|
break;
|
|
}
|
|
str.replace(pos, from.length(), to);
|
|
pos += to.length();
|
|
} while (replace_all);
|
|
|
|
return str;
|
|
}
|
|
|
|
inline grpc::string StringReplace(grpc::string str, const grpc::string& from,
|
|
const grpc::string& to) {
|
|
return StringReplace(str, from, to, true);
|
|
}
|
|
|
|
grpc::string ModuleName(const grpc::string& filename,
|
|
const grpc::string& import_prefix) {
|
|
grpc::string basename = flatbuffers::StripExtension(filename);
|
|
basename = StringReplace(basename, "-", "_");
|
|
basename = StringReplace(basename, "/", ".");
|
|
return import_prefix + basename + "_fb";
|
|
}
|
|
|
|
grpc::string ModuleAlias(const grpc::string& filename,
|
|
const grpc::string& import_prefix) {
|
|
grpc::string module_name = ModuleName(filename, import_prefix);
|
|
// We can't have dots in the module name, so we replace each with _dot_.
|
|
// But that could lead to a collision between a.b and a_dot_b, so we also
|
|
// duplicate each underscore.
|
|
module_name = StringReplace(module_name, "_", "__");
|
|
module_name = StringReplace(module_name, ".", "_dot_");
|
|
return module_name;
|
|
}
|
|
|
|
PrivateGenerator::PrivateGenerator(const GeneratorConfiguration& config_,
|
|
const grpc_generator::File* file_)
|
|
: config(config_), file(file_) {}
|
|
|
|
void 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");
|
|
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);
|
|
out->Print("context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void 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");
|
|
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);
|
|
out->Print("raise NotImplementedError()\n");
|
|
}
|
|
if (!method->ServerStreaming()) {
|
|
out->Print(method_dict, "$Method$.future = None\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void 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 = method->get_fb_builder();
|
|
grpc::string output_message_module_and_class = method->get_fb_builder();
|
|
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("
|
|
"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");
|
|
//"request_deserializers=request_deserializers, "
|
|
//"response_serializers=response_serializers, "
|
|
}
|
|
}
|
|
|
|
void 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 = method->get_fb_builder();
|
|
grpc::string output_message_module_and_class = method->get_fb_builder();
|
|
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, "
|
|
"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");
|
|
// "request_serializers=request_serializers, "
|
|
//"response_deserializers=response_deserializers, "
|
|
}
|
|
}
|
|
|
|
void 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);
|
|
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 = method->get_fb_builder();
|
|
grpc::string response_module_and_class = method->get_fb_builder();
|
|
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,"\n");
|
|
out->Print(
|
|
method_dict,"\n");
|
|
out->Print(")\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void 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);
|
|
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);
|
|
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");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void 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 = method->get_fb_builder();
|
|
grpc::string response_module_and_class = method->get_fb_builder();
|
|
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,"\n");
|
|
out->Print(
|
|
method_dict,
|
|
"\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");
|
|
}
|
|
}
|
|
|
|
void 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");
|
|
}
|
|
|
|
void PrivateGenerator::PrintPreamble(grpc_generator::Printer* out) {
|
|
StringMap var;
|
|
var["Package"] = config.grpc_package_root;
|
|
out->Print(var, "import $Package$\n");
|
|
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_fb_builder();
|
|
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_fb_builder();
|
|
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) {
|
|
var["ModuleName"] = std::get<0>(*it);
|
|
var["ModuleAlias"] = std::get<1>(*it);
|
|
out->Print(var, "import $ModuleName$ as $ModuleAlias$\n");
|
|
}
|
|
}
|
|
|
|
void PrivateGenerator::PrintGAServices(grpc_generator::Printer* out) {
|
|
grpc::string package = file->package();
|
|
if (!package.empty()) {
|
|
package = package.append(".");
|
|
}
|
|
|
|
out->Print(file->additional_headers().c_str());
|
|
|
|
for (int i = 0; i < file->service_count(); ++i) {
|
|
auto service = file->service(i);
|
|
|
|
grpc::string package_qualified_service_name = package + service->name();
|
|
PrintStub(package_qualified_service_name, service.get(), out);
|
|
PrintServicer(service.get(), out);
|
|
PrintAddServicerToServer(package_qualified_service_name, service.get(),
|
|
out);
|
|
}
|
|
}
|
|
|
|
void 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();
|
|
PrintBetaServicer(service.get(), out);
|
|
PrintBetaStub(service.get(), out);
|
|
PrintBetaServerFactory(package_qualified_service_name, service.get(), out);
|
|
PrintBetaStubFactory(package_qualified_service_name, service.get(), out);
|
|
}
|
|
}
|
|
|
|
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);
|
|
out->Print(
|
|
"# Generated by the gRPC Python protocol compiler plugin. "
|
|
"DO NOT EDIT!\n");
|
|
StringMap var;
|
|
var["Package"] = config.grpc_package_root;
|
|
out->Print(var, "import $Package$\n");
|
|
PrintGAServices(out.get());
|
|
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");
|
|
out->Print(var, "import $Package$\n");
|
|
PrintBetaPreamble(out.get());
|
|
PrintGAServices(out.get());
|
|
PrintBetaServices(out.get());
|
|
}
|
|
out->Print("except ImportError:\n");
|
|
{
|
|
IndentScope raii_dict_except_indent(out.get());
|
|
out->Print("pass");
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
|
|
} // namespace grpc_python_generator
|