Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
Craig Tiller | 6169d5f | 2016-03-31 07:46:18 -0700 | [diff] [blame] | 3 | * Copyright 2015, Google Inc. |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions are |
| 8 | * met: |
| 9 | * |
| 10 | * * Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * * Redistributions in binary form must reproduce the above |
| 13 | * copyright notice, this list of conditions and the following disclaimer |
| 14 | * in the documentation and/or other materials provided with the |
| 15 | * distribution. |
| 16 | * * Neither the name of Google Inc. nor the names of its |
| 17 | * contributors may be used to endorse or promote products derived from |
| 18 | * this software without specific prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | * |
| 32 | */ |
| 33 | |
Masood Malekghassemi | 40e8cbd | 2015-02-26 08:39:50 -0800 | [diff] [blame] | 34 | #include <algorithm> |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 35 | #include <cassert> |
| 36 | #include <cctype> |
Masood Malekghassemi | 59d9ff4 | 2015-02-23 15:28:07 -0800 | [diff] [blame] | 37 | #include <cstring> |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 38 | #include <fstream> |
| 39 | #include <iostream> |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 40 | #include <map> |
Masood Malekghassemi | 3bb5215 | 2015-03-17 21:52:52 -0700 | [diff] [blame] | 41 | #include <memory> |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 42 | #include <ostream> |
Bryan Blanchard | c549a3e | 2016-12-13 07:46:28 -0500 | [diff] [blame] | 43 | #include <set> |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 44 | #include <sstream> |
Masood Malekghassemi | 3bb5215 | 2015-03-17 21:52:52 -0700 | [diff] [blame] | 45 | #include <tuple> |
Masood Malekghassemi | 59d9ff4 | 2015-02-23 15:28:07 -0800 | [diff] [blame] | 46 | #include <vector> |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 47 | |
Masood Malekghassemi | 65c803b | 2015-03-20 06:48:47 -0700 | [diff] [blame] | 48 | #include "src/compiler/config.h" |
Nicolas "Pixel" Noble | 93fa098 | 2015-02-27 21:50:58 +0100 | [diff] [blame] | 49 | #include "src/compiler/generator_helpers.h" |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 50 | #include "src/compiler/protobuf_plugin.h" |
Harsh Vardhan | 974f3d7 | 2017-03-03 14:19:32 +0530 | [diff] [blame] | 51 | #include "src/compiler/python_generator.h" |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 52 | #include "src/compiler/python_generator_helpers.h" |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 53 | #include "src/compiler/python_private_generator.h" |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 54 | |
Masood Malekghassemi | 65c803b | 2015-03-20 06:48:47 -0700 | [diff] [blame] | 55 | using grpc::protobuf::FileDescriptor; |
Masood Malekghassemi | 65c803b | 2015-03-20 06:48:47 -0700 | [diff] [blame] | 56 | using grpc::protobuf::compiler::GeneratorContext; |
| 57 | using grpc::protobuf::io::CodedOutputStream; |
Masood Malekghassemi | 65c803b | 2015-03-20 06:48:47 -0700 | [diff] [blame] | 58 | using grpc::protobuf::io::ZeroCopyOutputStream; |
Masood Malekghassemi | 59d9ff4 | 2015-02-23 15:28:07 -0800 | [diff] [blame] | 59 | using std::make_pair; |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 60 | using std::map; |
Masood Malekghassemi | 59d9ff4 | 2015-02-23 15:28:07 -0800 | [diff] [blame] | 61 | using std::pair; |
Masood Malekghassemi | 40e8cbd | 2015-02-26 08:39:50 -0800 | [diff] [blame] | 62 | using std::replace; |
Bryan Blanchard | c549a3e | 2016-12-13 07:46:28 -0500 | [diff] [blame] | 63 | using std::tuple; |
Masood Malekghassemi | 59d9ff4 | 2015-02-23 15:28:07 -0800 | [diff] [blame] | 64 | using std::vector; |
Bryan Blanchard | c549a3e | 2016-12-13 07:46:28 -0500 | [diff] [blame] | 65 | using std::set; |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 66 | |
| 67 | namespace grpc_python_generator { |
Masood Malekghassemi | 3bb5215 | 2015-03-17 21:52:52 -0700 | [diff] [blame] | 68 | |
Harsh Vardhan | 64741b2 | 2017-01-14 15:19:09 +0530 | [diff] [blame] | 69 | grpc::string generator_file_name; |
| 70 | |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 71 | namespace { |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 72 | |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 73 | typedef map<grpc::string, grpc::string> StringMap; |
| 74 | typedef vector<grpc::string> StringVector; |
Bryan Blanchard | c549a3e | 2016-12-13 07:46:28 -0500 | [diff] [blame] | 75 | typedef tuple<grpc::string, grpc::string> StringPair; |
| 76 | typedef set<StringPair> StringPairSet; |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 77 | |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 78 | // Provides RAII indentation handling. Use as: |
| 79 | // { |
| 80 | // IndentScope raii_my_indent_var_name_here(my_py_printer); |
| 81 | // // constructor indented my_py_printer |
| 82 | // ... |
| 83 | // // destructor called at end of scope, un-indenting my_py_printer |
| 84 | // } |
| 85 | class IndentScope { |
| 86 | public: |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 87 | explicit IndentScope(grpc_generator::Printer* printer) : printer_(printer) { |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 88 | printer_->Indent(); |
| 89 | } |
| 90 | |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 91 | ~IndentScope() { printer_->Outdent(); } |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 92 | |
| 93 | private: |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 94 | grpc_generator::Printer* printer_; |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 95 | }; |
| 96 | |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 97 | PrivateGenerator::PrivateGenerator(const GeneratorConfiguration& config, |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 98 | const grpc_generator::File* file) |
Masood Malekghassemi | 7780cc0 | 2016-10-24 15:30:05 -0700 | [diff] [blame] | 99 | : config(config), file(file) {} |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 100 | |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 101 | void PrivateGenerator::PrintAllComments(StringVector comments, |
| 102 | grpc_generator::Printer* out) { |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 103 | if (comments.empty()) { |
Mehrdad Afshari | 68f6a67 | 2017-04-12 14:19:49 -0700 | [diff] [blame] | 104 | // Python requires code structures like class and def to have |
| 105 | // a body, even if it is just "pass" or a docstring. We need |
| 106 | // to ensure not to generate empty bodies. We could do something |
| 107 | // smarter and more sophisticated, but at the moment, if there is |
| 108 | // no docstring to print, we simply emit "pass" to ensure validity |
| 109 | // of the generated code. |
| 110 | out->Print("# missing associated documentation comment in .proto file\n"); |
| 111 | out->Print("pass\n"); |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 112 | return; |
| 113 | } |
| 114 | out->Print("\"\"\""); |
| 115 | for (StringVector::iterator it = comments.begin(); it != comments.end(); |
| 116 | ++it) { |
| 117 | size_t start_pos = it->find_first_not_of(' '); |
| 118 | if (start_pos != grpc::string::npos) { |
| 119 | out->Print(it->c_str() + start_pos); |
yang-g | b0de716 | 2016-05-03 15:48:19 -0700 | [diff] [blame] | 120 | } |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 121 | out->Print("\n"); |
| 122 | } |
| 123 | out->Print("\"\"\"\n"); |
yang-g | b0de716 | 2016-05-03 15:48:19 -0700 | [diff] [blame] | 124 | } |
| 125 | |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 126 | bool PrivateGenerator::PrintBetaServicer(const grpc_generator::Service* service, |
| 127 | grpc_generator::Printer* out) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 128 | StringMap service_dict; |
| 129 | service_dict["Service"] = service->name(); |
Ken Payson | be187b0 | 2016-05-06 15:32:58 -0700 | [diff] [blame] | 130 | out->Print("\n\n"); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 131 | out->Print(service_dict, "class Beta$Service$Servicer(object):\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 132 | { |
| 133 | IndentScope raii_class_indent(out); |
Nicolas "Pixel" Noble | beeeddd | 2016-09-29 20:27:23 +0200 | [diff] [blame] | 134 | out->Print( |
| 135 | "\"\"\"The Beta API is deprecated for 0.15.0 and later.\n" |
| 136 | "\nIt is recommended to use the GA API (classes and functions in this\n" |
| 137 | "file not marked beta) for all further purposes. This class was " |
| 138 | "generated\n" |
| 139 | "only to ease transition from grpcio<0.15.0 to " |
| 140 | "grpcio>=0.15.0.\"\"\"\n"); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 141 | StringVector service_comments = service->GetAllComments(); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 142 | PrintAllComments(service_comments, out); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 143 | for (int i = 0; i < service->method_count(); ++i) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 144 | auto method = service->method(i); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 145 | grpc::string arg_name = |
Harsh Vardhan | 974f3d7 | 2017-03-03 14:19:32 +0530 | [diff] [blame] | 146 | method->ClientStreaming() ? "request_iterator" : "request"; |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 147 | StringMap method_dict; |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 148 | method_dict["Method"] = method->name(); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 149 | method_dict["ArgName"] = arg_name; |
| 150 | out->Print(method_dict, "def $Method$(self, $ArgName$, context):\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 151 | { |
| 152 | IndentScope raii_method_indent(out); |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 153 | StringVector method_comments = method->GetAllComments(); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 154 | PrintAllComments(method_comments, out); |
Masood Malekghassemi | 832ae81 | 2016-04-27 18:38:54 -0700 | [diff] [blame] | 155 | out->Print("context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 156 | } |
| 157 | } |
| 158 | } |
| 159 | return true; |
| 160 | } |
| 161 | |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 162 | bool PrivateGenerator::PrintBetaStub(const grpc_generator::Service* service, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 163 | grpc_generator::Printer* out) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 164 | StringMap service_dict; |
| 165 | service_dict["Service"] = service->name(); |
Ken Payson | be187b0 | 2016-05-06 15:32:58 -0700 | [diff] [blame] | 166 | out->Print("\n\n"); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 167 | out->Print(service_dict, "class Beta$Service$Stub(object):\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 168 | { |
| 169 | IndentScope raii_class_indent(out); |
Nicolas "Pixel" Noble | beeeddd | 2016-09-29 20:27:23 +0200 | [diff] [blame] | 170 | out->Print( |
| 171 | "\"\"\"The Beta API is deprecated for 0.15.0 and later.\n" |
| 172 | "\nIt is recommended to use the GA API (classes and functions in this\n" |
| 173 | "file not marked beta) for all further purposes. This class was " |
| 174 | "generated\n" |
| 175 | "only to ease transition from grpcio<0.15.0 to " |
| 176 | "grpcio>=0.15.0.\"\"\"\n"); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 177 | StringVector service_comments = service->GetAllComments(); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 178 | PrintAllComments(service_comments, out); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 179 | for (int i = 0; i < service->method_count(); ++i) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 180 | auto method = service->method(i); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 181 | grpc::string arg_name = |
Harsh Vardhan | 974f3d7 | 2017-03-03 14:19:32 +0530 | [diff] [blame] | 182 | method->ClientStreaming() ? "request_iterator" : "request"; |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 183 | StringMap method_dict; |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 184 | method_dict["Method"] = method->name(); |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 185 | method_dict["ArgName"] = arg_name; |
| 186 | out->Print(method_dict, |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 187 | "def $Method$(self, $ArgName$, timeout, metadata=None, " |
| 188 | "with_call=False, protocol_options=None):\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 189 | { |
| 190 | IndentScope raii_method_indent(out); |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 191 | StringVector method_comments = method->GetAllComments(); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 192 | PrintAllComments(method_comments, out); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 193 | out->Print("raise NotImplementedError()\n"); |
| 194 | } |
Harsh Vardhan | 974f3d7 | 2017-03-03 14:19:32 +0530 | [diff] [blame] | 195 | if (!method->ServerStreaming()) { |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 196 | out->Print(method_dict, "$Method$.future = None\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 197 | } |
| 198 | } |
| 199 | } |
| 200 | return true; |
| 201 | } |
| 202 | |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 203 | bool PrivateGenerator::PrintBetaServerFactory( |
| 204 | const grpc::string& package_qualified_service_name, |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 205 | const grpc_generator::Service* service, grpc_generator::Printer* out) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 206 | StringMap service_dict; |
| 207 | service_dict["Service"] = service->name(); |
Ken Payson | be187b0 | 2016-05-06 15:32:58 -0700 | [diff] [blame] | 208 | out->Print("\n\n"); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 209 | out->Print(service_dict, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 210 | "def beta_create_$Service$_server(servicer, pool=None, " |
| 211 | "pool_size=None, default_timeout=None, maximum_timeout=None):\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 212 | { |
| 213 | IndentScope raii_create_server_indent(out); |
Nicolas "Pixel" Noble | beeeddd | 2016-09-29 20:27:23 +0200 | [diff] [blame] | 214 | out->Print( |
| 215 | "\"\"\"The Beta API is deprecated for 0.15.0 and later.\n" |
| 216 | "\nIt is recommended to use the GA API (classes and functions in this\n" |
| 217 | "file not marked beta) for all further purposes. This function was\n" |
| 218 | "generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0" |
| 219 | "\"\"\"\n"); |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 220 | StringMap method_implementation_constructors; |
| 221 | StringMap input_message_modules_and_classes; |
| 222 | StringMap output_message_modules_and_classes; |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 223 | for (int i = 0; i < service->method_count(); ++i) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 224 | auto method = service->method(i); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 225 | const grpc::string method_implementation_constructor = |
Harsh Vardhan | 974f3d7 | 2017-03-03 14:19:32 +0530 | [diff] [blame] | 226 | grpc::string(method->ClientStreaming() ? "stream_" : "unary_") + |
| 227 | grpc::string(method->ServerStreaming() ? "stream_" : "unary_") + |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 228 | "inline"; |
Ken Payson | be187b0 | 2016-05-06 15:32:58 -0700 | [diff] [blame] | 229 | grpc::string input_message_module_and_class; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 230 | if (!method->get_module_and_message_path_input( |
| 231 | &input_message_module_and_class, generator_file_name, |
Harsh Vardhan | abf9ce2 | 2017-03-14 22:56:31 +0530 | [diff] [blame] | 232 | generate_in_pb2_grpc, config.import_prefix)) { |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 233 | return false; |
| 234 | } |
Ken Payson | be187b0 | 2016-05-06 15:32:58 -0700 | [diff] [blame] | 235 | grpc::string output_message_module_and_class; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 236 | if (!method->get_module_and_message_path_output( |
| 237 | &output_message_module_and_class, generator_file_name, |
Harsh Vardhan | abf9ce2 | 2017-03-14 22:56:31 +0530 | [diff] [blame] | 238 | generate_in_pb2_grpc, config.import_prefix)) { |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 239 | return false; |
| 240 | } |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 241 | method_implementation_constructors.insert( |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 242 | make_pair(method->name(), method_implementation_constructor)); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 243 | input_message_modules_and_classes.insert( |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 244 | make_pair(method->name(), input_message_module_and_class)); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 245 | output_message_modules_and_classes.insert( |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 246 | make_pair(method->name(), output_message_module_and_class)); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 247 | } |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 248 | StringMap method_dict; |
| 249 | method_dict["PackageQualifiedServiceName"] = package_qualified_service_name; |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 250 | out->Print("request_deserializers = {\n"); |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 251 | for (StringMap::iterator name_and_input_module_class_pair = |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 252 | input_message_modules_and_classes.begin(); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 253 | name_and_input_module_class_pair != |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 254 | input_message_modules_and_classes.end(); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 255 | name_and_input_module_class_pair++) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 256 | method_dict["MethodName"] = name_and_input_module_class_pair->first; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 257 | method_dict["InputTypeModuleAndClass"] = |
| 258 | name_and_input_module_class_pair->second; |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 259 | IndentScope raii_indent(out); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 260 | out->Print(method_dict, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 261 | "(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): " |
| 262 | "$InputTypeModuleAndClass$.FromString,\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 263 | } |
| 264 | out->Print("}\n"); |
| 265 | out->Print("response_serializers = {\n"); |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 266 | for (StringMap::iterator name_and_output_module_class_pair = |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 267 | output_message_modules_and_classes.begin(); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 268 | name_and_output_module_class_pair != |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 269 | output_message_modules_and_classes.end(); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 270 | name_and_output_module_class_pair++) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 271 | method_dict["MethodName"] = name_and_output_module_class_pair->first; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 272 | method_dict["OutputTypeModuleAndClass"] = |
| 273 | name_and_output_module_class_pair->second; |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 274 | IndentScope raii_indent(out); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 275 | out->Print(method_dict, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 276 | "(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): " |
| 277 | "$OutputTypeModuleAndClass$.SerializeToString,\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 278 | } |
| 279 | out->Print("}\n"); |
| 280 | out->Print("method_implementations = {\n"); |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 281 | for (StringMap::iterator name_and_implementation_constructor = |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 282 | method_implementation_constructors.begin(); |
| 283 | name_and_implementation_constructor != |
| 284 | method_implementation_constructors.end(); |
| 285 | name_and_implementation_constructor++) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 286 | method_dict["Method"] = name_and_implementation_constructor->first; |
| 287 | method_dict["Constructor"] = name_and_implementation_constructor->second; |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 288 | IndentScope raii_descriptions_indent(out); |
| 289 | const grpc::string method_name = |
| 290 | name_and_implementation_constructor->first; |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 291 | out->Print(method_dict, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 292 | "(\'$PackageQualifiedServiceName$\', \'$Method$\'): " |
| 293 | "face_utilities.$Constructor$(servicer.$Method$),\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 294 | } |
| 295 | out->Print("}\n"); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 296 | out->Print( |
| 297 | "server_options = beta_implementations.server_options(" |
| 298 | "request_deserializers=request_deserializers, " |
| 299 | "response_serializers=response_serializers, " |
| 300 | "thread_pool=pool, thread_pool_size=pool_size, " |
| 301 | "default_timeout=default_timeout, " |
| 302 | "maximum_timeout=maximum_timeout)\n"); |
| 303 | out->Print( |
| 304 | "return beta_implementations.server(method_implementations, " |
| 305 | "options=server_options)\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 306 | } |
| 307 | return true; |
| 308 | } |
| 309 | |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 310 | bool PrivateGenerator::PrintBetaStubFactory( |
| 311 | const grpc::string& package_qualified_service_name, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 312 | const grpc_generator::Service* service, grpc_generator::Printer* out) { |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 313 | StringMap dict; |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 314 | dict["Service"] = service->name(); |
Ken Payson | be187b0 | 2016-05-06 15:32:58 -0700 | [diff] [blame] | 315 | out->Print("\n\n"); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 316 | out->Print(dict, |
| 317 | "def beta_create_$Service$_stub(channel, host=None," |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 318 | " metadata_transformer=None, pool=None, pool_size=None):\n"); |
| 319 | { |
| 320 | IndentScope raii_create_server_indent(out); |
Nicolas "Pixel" Noble | beeeddd | 2016-09-29 20:27:23 +0200 | [diff] [blame] | 321 | out->Print( |
| 322 | "\"\"\"The Beta API is deprecated for 0.15.0 and later.\n" |
| 323 | "\nIt is recommended to use the GA API (classes and functions in this\n" |
| 324 | "file not marked beta) for all further purposes. This function was\n" |
| 325 | "generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0" |
| 326 | "\"\"\"\n"); |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 327 | StringMap method_cardinalities; |
| 328 | StringMap input_message_modules_and_classes; |
| 329 | StringMap output_message_modules_and_classes; |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 330 | for (int i = 0; i < service->method_count(); ++i) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 331 | auto method = service->method(i); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 332 | const grpc::string method_cardinality = |
Harsh Vardhan | 974f3d7 | 2017-03-03 14:19:32 +0530 | [diff] [blame] | 333 | grpc::string(method->ClientStreaming() ? "STREAM" : "UNARY") + "_" + |
| 334 | grpc::string(method->ServerStreaming() ? "STREAM" : "UNARY"); |
Ken Payson | be187b0 | 2016-05-06 15:32:58 -0700 | [diff] [blame] | 335 | grpc::string input_message_module_and_class; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 336 | if (!method->get_module_and_message_path_input( |
| 337 | &input_message_module_and_class, generator_file_name, |
Harsh Vardhan | abf9ce2 | 2017-03-14 22:56:31 +0530 | [diff] [blame] | 338 | generate_in_pb2_grpc, config.import_prefix)) { |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 339 | return false; |
| 340 | } |
Ken Payson | be187b0 | 2016-05-06 15:32:58 -0700 | [diff] [blame] | 341 | grpc::string output_message_module_and_class; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 342 | if (!method->get_module_and_message_path_output( |
| 343 | &output_message_module_and_class, generator_file_name, |
Harsh Vardhan | abf9ce2 | 2017-03-14 22:56:31 +0530 | [diff] [blame] | 344 | generate_in_pb2_grpc, config.import_prefix)) { |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 345 | return false; |
| 346 | } |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 347 | method_cardinalities.insert( |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 348 | make_pair(method->name(), method_cardinality)); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 349 | input_message_modules_and_classes.insert( |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 350 | make_pair(method->name(), input_message_module_and_class)); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 351 | output_message_modules_and_classes.insert( |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 352 | make_pair(method->name(), output_message_module_and_class)); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 353 | } |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 354 | StringMap method_dict; |
| 355 | method_dict["PackageQualifiedServiceName"] = package_qualified_service_name; |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 356 | out->Print("request_serializers = {\n"); |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 357 | for (StringMap::iterator name_and_input_module_class_pair = |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 358 | input_message_modules_and_classes.begin(); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 359 | name_and_input_module_class_pair != |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 360 | input_message_modules_and_classes.end(); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 361 | name_and_input_module_class_pair++) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 362 | method_dict["MethodName"] = name_and_input_module_class_pair->first; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 363 | method_dict["InputTypeModuleAndClass"] = |
| 364 | name_and_input_module_class_pair->second; |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 365 | IndentScope raii_indent(out); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 366 | out->Print(method_dict, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 367 | "(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): " |
| 368 | "$InputTypeModuleAndClass$.SerializeToString,\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 369 | } |
| 370 | out->Print("}\n"); |
| 371 | out->Print("response_deserializers = {\n"); |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 372 | for (StringMap::iterator name_and_output_module_class_pair = |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 373 | output_message_modules_and_classes.begin(); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 374 | name_and_output_module_class_pair != |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 375 | output_message_modules_and_classes.end(); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 376 | name_and_output_module_class_pair++) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 377 | method_dict["MethodName"] = name_and_output_module_class_pair->first; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 378 | method_dict["OutputTypeModuleAndClass"] = |
| 379 | name_and_output_module_class_pair->second; |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 380 | IndentScope raii_indent(out); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 381 | out->Print(method_dict, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 382 | "(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): " |
| 383 | "$OutputTypeModuleAndClass$.FromString,\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 384 | } |
| 385 | out->Print("}\n"); |
| 386 | out->Print("cardinalities = {\n"); |
Masood Malekghassemi | 7780cc0 | 2016-10-24 15:30:05 -0700 | [diff] [blame] | 387 | for (StringMap::iterator name_and_cardinality = |
| 388 | method_cardinalities.begin(); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 389 | name_and_cardinality != method_cardinalities.end(); |
| 390 | name_and_cardinality++) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 391 | method_dict["Method"] = name_and_cardinality->first; |
| 392 | method_dict["Cardinality"] = name_and_cardinality->second; |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 393 | IndentScope raii_descriptions_indent(out); |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 394 | out->Print(method_dict, |
| 395 | "\'$Method$\': cardinality.Cardinality.$Cardinality$,\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 396 | } |
| 397 | out->Print("}\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 398 | out->Print( |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 399 | "stub_options = beta_implementations.stub_options(" |
| 400 | "host=host, metadata_transformer=metadata_transformer, " |
| 401 | "request_serializers=request_serializers, " |
| 402 | "response_deserializers=response_deserializers, " |
| 403 | "thread_pool=pool, thread_pool_size=pool_size)\n"); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 404 | out->Print(method_dict, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 405 | "return beta_implementations.dynamic_stub(channel, " |
| 406 | "\'$PackageQualifiedServiceName$\', " |
| 407 | "cardinalities, options=stub_options)\n"); |
Nathaniel Manista | cd9ec0e | 2015-08-31 07:49:45 +0000 | [diff] [blame] | 408 | } |
| 409 | return true; |
| 410 | } |
| 411 | |
Masood Malekghassemi | 7780cc0 | 2016-10-24 15:30:05 -0700 | [diff] [blame] | 412 | bool PrivateGenerator::PrintStub( |
| 413 | const grpc::string& package_qualified_service_name, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 414 | const grpc_generator::Service* service, grpc_generator::Printer* out) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 415 | StringMap dict; |
| 416 | dict["Service"] = service->name(); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 417 | out->Print("\n\n"); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 418 | out->Print(dict, "class $Service$Stub(object):\n"); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 419 | { |
| 420 | IndentScope raii_class_indent(out); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 421 | StringVector service_comments = service->GetAllComments(); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 422 | PrintAllComments(service_comments, out); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 423 | out->Print("\n"); |
| 424 | out->Print("def __init__(self, channel):\n"); |
| 425 | { |
| 426 | IndentScope raii_init_indent(out); |
| 427 | out->Print("\"\"\"Constructor.\n"); |
| 428 | out->Print("\n"); |
| 429 | out->Print("Args:\n"); |
| 430 | { |
| 431 | IndentScope raii_args_indent(out); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 432 | out->Print("channel: A grpc.Channel.\n"); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 433 | } |
| 434 | out->Print("\"\"\"\n"); |
| 435 | for (int i = 0; i < service->method_count(); ++i) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 436 | auto method = service->method(i); |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 437 | grpc::string multi_callable_constructor = |
Harsh Vardhan | 974f3d7 | 2017-03-03 14:19:32 +0530 | [diff] [blame] | 438 | grpc::string(method->ClientStreaming() ? "stream" : "unary") + "_" + |
| 439 | grpc::string(method->ServerStreaming() ? "stream" : "unary"); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 440 | grpc::string request_module_and_class; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 441 | if (!method->get_module_and_message_path_input( |
| 442 | &request_module_and_class, generator_file_name, |
Harsh Vardhan | abf9ce2 | 2017-03-14 22:56:31 +0530 | [diff] [blame] | 443 | generate_in_pb2_grpc, config.import_prefix)) { |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 444 | return false; |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 445 | } |
| 446 | grpc::string response_module_and_class; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 447 | if (!method->get_module_and_message_path_output( |
| 448 | &response_module_and_class, generator_file_name, |
Harsh Vardhan | abf9ce2 | 2017-03-14 22:56:31 +0530 | [diff] [blame] | 449 | generate_in_pb2_grpc, config.import_prefix)) { |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 450 | return false; |
| 451 | } |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 452 | StringMap method_dict; |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 453 | method_dict["Method"] = method->name(); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 454 | method_dict["MultiCallableConstructor"] = multi_callable_constructor; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 455 | out->Print(method_dict, |
| 456 | "self.$Method$ = channel.$MultiCallableConstructor$(\n"); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 457 | { |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 458 | method_dict["PackageQualifiedService"] = |
| 459 | package_qualified_service_name; |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 460 | method_dict["RequestModuleAndClass"] = request_module_and_class; |
| 461 | method_dict["ResponseModuleAndClass"] = response_module_and_class; |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 462 | IndentScope raii_first_attribute_indent(out); |
| 463 | IndentScope raii_second_attribute_indent(out); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 464 | out->Print(method_dict, "'/$PackageQualifiedService$/$Method$',\n"); |
| 465 | out->Print(method_dict, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 466 | "request_serializer=$RequestModuleAndClass$." |
| 467 | "SerializeToString,\n"); |
| 468 | out->Print( |
| 469 | method_dict, |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 470 | "response_deserializer=$ResponseModuleAndClass$.FromString,\n"); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 471 | out->Print(")\n"); |
| 472 | } |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 473 | } |
| 474 | } |
| 475 | } |
| 476 | return true; |
| 477 | } |
| 478 | |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 479 | bool PrivateGenerator::PrintServicer(const grpc_generator::Service* service, |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 480 | grpc_generator::Printer* out) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 481 | StringMap service_dict; |
| 482 | service_dict["Service"] = service->name(); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 483 | out->Print("\n\n"); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 484 | out->Print(service_dict, "class $Service$Servicer(object):\n"); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 485 | { |
| 486 | IndentScope raii_class_indent(out); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 487 | StringVector service_comments = service->GetAllComments(); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 488 | PrintAllComments(service_comments, out); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 489 | for (int i = 0; i < service->method_count(); ++i) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 490 | auto method = service->method(i); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 491 | grpc::string arg_name = |
Harsh Vardhan | 974f3d7 | 2017-03-03 14:19:32 +0530 | [diff] [blame] | 492 | method->ClientStreaming() ? "request_iterator" : "request"; |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 493 | StringMap method_dict; |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 494 | method_dict["Method"] = method->name(); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 495 | method_dict["ArgName"] = arg_name; |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 496 | out->Print("\n"); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 497 | out->Print(method_dict, "def $Method$(self, $ArgName$, context):\n"); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 498 | { |
| 499 | IndentScope raii_method_indent(out); |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 500 | StringVector method_comments = method->GetAllComments(); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 501 | PrintAllComments(method_comments, out); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 502 | out->Print("context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n"); |
| 503 | out->Print("context.set_details('Method not implemented!')\n"); |
| 504 | out->Print("raise NotImplementedError('Method not implemented!')\n"); |
| 505 | } |
| 506 | } |
| 507 | } |
| 508 | return true; |
| 509 | } |
| 510 | |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 511 | bool PrivateGenerator::PrintAddServicerToServer( |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 512 | const grpc::string& package_qualified_service_name, |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 513 | const grpc_generator::Service* service, grpc_generator::Printer* out) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 514 | StringMap service_dict; |
| 515 | service_dict["Service"] = service->name(); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 516 | out->Print("\n\n"); |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 517 | out->Print(service_dict, |
| 518 | "def add_$Service$Servicer_to_server(servicer, server):\n"); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 519 | { |
| 520 | IndentScope raii_class_indent(out); |
| 521 | out->Print("rpc_method_handlers = {\n"); |
| 522 | { |
| 523 | IndentScope raii_dict_first_indent(out); |
| 524 | IndentScope raii_dict_second_indent(out); |
| 525 | for (int i = 0; i < service->method_count(); ++i) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 526 | auto method = service->method(i); |
Masood Malekghassemi | 4a051cc | 2016-10-20 14:50:49 -0700 | [diff] [blame] | 527 | grpc::string method_handler_constructor = |
Harsh Vardhan | 974f3d7 | 2017-03-03 14:19:32 +0530 | [diff] [blame] | 528 | grpc::string(method->ClientStreaming() ? "stream" : "unary") + "_" + |
| 529 | grpc::string(method->ServerStreaming() ? "stream" : "unary") + |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 530 | "_rpc_method_handler"; |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 531 | grpc::string request_module_and_class; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 532 | if (!method->get_module_and_message_path_input( |
| 533 | &request_module_and_class, generator_file_name, |
Harsh Vardhan | abf9ce2 | 2017-03-14 22:56:31 +0530 | [diff] [blame] | 534 | generate_in_pb2_grpc, config.import_prefix)) { |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 535 | return false; |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 536 | } |
| 537 | grpc::string response_module_and_class; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 538 | if (!method->get_module_and_message_path_output( |
| 539 | &response_module_and_class, generator_file_name, |
Harsh Vardhan | abf9ce2 | 2017-03-14 22:56:31 +0530 | [diff] [blame] | 540 | generate_in_pb2_grpc, config.import_prefix)) { |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 541 | return false; |
| 542 | } |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 543 | StringMap method_dict; |
Harsh Vardhan | 0f12cd9 | 2017-02-18 19:17:51 +0530 | [diff] [blame] | 544 | method_dict["Method"] = method->name(); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 545 | method_dict["MethodHandlerConstructor"] = method_handler_constructor; |
| 546 | method_dict["RequestModuleAndClass"] = request_module_and_class; |
| 547 | method_dict["ResponseModuleAndClass"] = response_module_and_class; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 548 | out->Print(method_dict, |
| 549 | "'$Method$': grpc.$MethodHandlerConstructor$(\n"); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 550 | { |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 551 | IndentScope raii_call_first_indent(out); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 552 | IndentScope raii_call_second_indent(out); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 553 | out->Print(method_dict, "servicer.$Method$,\n"); |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 554 | out->Print( |
| 555 | method_dict, |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 556 | "request_deserializer=$RequestModuleAndClass$.FromString,\n"); |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 557 | out->Print( |
| 558 | method_dict, |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 559 | "response_serializer=$ResponseModuleAndClass$.SerializeToString," |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 560 | "\n"); |
Masood Malekghassemi | ac59245 | 2016-07-01 11:58:04 -0700 | [diff] [blame] | 561 | } |
| 562 | out->Print("),\n"); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 563 | } |
| 564 | } |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 565 | StringMap method_dict; |
| 566 | method_dict["PackageQualifiedServiceName"] = package_qualified_service_name; |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 567 | out->Print("}\n"); |
| 568 | out->Print("generic_handler = grpc.method_handlers_generic_handler(\n"); |
| 569 | { |
| 570 | IndentScope raii_call_first_indent(out); |
| 571 | IndentScope raii_call_second_indent(out); |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 572 | out->Print(method_dict, |
| 573 | "'$PackageQualifiedServiceName$', rpc_method_handlers)\n"); |
Nathaniel Manista | 4547940 | 2016-06-13 20:14:18 +0000 | [diff] [blame] | 574 | } |
| 575 | out->Print("server.add_generic_rpc_handlers((generic_handler,))\n"); |
| 576 | } |
| 577 | return true; |
| 578 | } |
| 579 | |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 580 | bool PrivateGenerator::PrintBetaPreamble(grpc_generator::Printer* out) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 581 | StringMap var; |
| 582 | var["Package"] = config.beta_package_root; |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 583 | out->Print(var, |
| 584 | "from $Package$ import implementations as beta_implementations\n"); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 585 | out->Print(var, "from $Package$ import interfaces as beta_interfaces\n"); |
Nathaniel Manista | 2f390db | 2017-03-22 16:57:48 +0000 | [diff] [blame] | 586 | out->Print("from grpc.framework.common import cardinality\n"); |
| 587 | out->Print( |
| 588 | "from grpc.framework.interfaces.face import utilities as " |
| 589 | "face_utilities\n"); |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 590 | return true; |
| 591 | } |
| 592 | |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 593 | bool PrivateGenerator::PrintPreamble(grpc_generator::Printer* out) { |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 594 | StringMap var; |
| 595 | var["Package"] = config.grpc_package_root; |
| 596 | out->Print(var, "import $Package$\n"); |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 597 | if (generate_in_pb2_grpc) { |
| 598 | out->Print("\n"); |
Bryan Blanchard | c549a3e | 2016-12-13 07:46:28 -0500 | [diff] [blame] | 599 | StringPairSet imports_set; |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 600 | for (int i = 0; i < file->service_count(); ++i) { |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 601 | auto service = file->service(i); |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 602 | for (int j = 0; j < service->method_count(); ++j) { |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 603 | auto method = service.get()->method(j); |
| 604 | |
| 605 | grpc::string input_type_file_name = method->get_input_type_name(); |
Harsh Vardhan | abf9ce2 | 2017-03-14 22:56:31 +0530 | [diff] [blame] | 606 | grpc::string input_module_name = |
| 607 | ModuleName(input_type_file_name, config.import_prefix); |
| 608 | grpc::string input_module_alias = |
| 609 | ModuleAlias(input_type_file_name, config.import_prefix); |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 610 | imports_set.insert( |
| 611 | std::make_tuple(input_module_name, input_module_alias)); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 612 | |
| 613 | grpc::string output_type_file_name = method->get_output_type_name(); |
Harsh Vardhan | abf9ce2 | 2017-03-14 22:56:31 +0530 | [diff] [blame] | 614 | grpc::string output_module_name = |
| 615 | ModuleName(output_type_file_name, config.import_prefix); |
| 616 | grpc::string output_module_alias = |
| 617 | ModuleAlias(output_type_file_name, config.import_prefix); |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 618 | imports_set.insert( |
| 619 | std::make_tuple(output_module_name, output_module_alias)); |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 620 | } |
| 621 | } |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 622 | |
Bryan Blanchard | c549a3e | 2016-12-13 07:46:28 -0500 | [diff] [blame] | 623 | for (StringPairSet::iterator it = imports_set.begin(); |
| 624 | it != imports_set.end(); ++it) { |
Manuel Kroiss | 6580894 | 2017-04-26 17:36:56 +0100 | [diff] [blame^] | 625 | auto module_name = std::get<0>(*it); |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 626 | var["ModuleAlias"] = std::get<1>(*it); |
Manuel Kroiss | 6580894 | 2017-04-26 17:36:56 +0100 | [diff] [blame^] | 627 | const size_t last_dot_pos = module_name.rfind('.'); |
| 628 | if (last_dot_pos == grpc::string::npos) { |
| 629 | var["ImportStatement"] = "import " + module_name; |
| 630 | } else { |
| 631 | var["ImportStatement"] = "from " + module_name.substr(0, last_dot_pos) + |
| 632 | " import " + |
| 633 | module_name.substr(last_dot_pos + 1); |
| 634 | } |
| 635 | out->Print(var, "$ImportStatement$ as $ModuleAlias$\n"); |
Bryan Blanchard | c549a3e | 2016-12-13 07:46:28 -0500 | [diff] [blame] | 636 | } |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 637 | } |
Masood Malekghassemi | 59d9ff4 | 2015-02-23 15:28:07 -0800 | [diff] [blame] | 638 | return true; |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 639 | } |
| 640 | |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 641 | bool PrivateGenerator::PrintGAServices(grpc_generator::Printer* out) { |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 642 | grpc::string package = file->package(); |
| 643 | if (!package.empty()) { |
| 644 | package = package.append("."); |
| 645 | } |
| 646 | for (int i = 0; i < file->service_count(); ++i) { |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 647 | auto service = file->service(i); |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 648 | grpc::string package_qualified_service_name = package + service->name(); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 649 | if (!(PrintStub(package_qualified_service_name, service.get(), out) && |
| 650 | PrintServicer(service.get(), out) && |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 651 | PrintAddServicerToServer(package_qualified_service_name, |
| 652 | service.get(), out))) { |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 653 | return false; |
| 654 | } |
| 655 | } |
| 656 | return true; |
| 657 | } |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 658 | |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 659 | bool PrivateGenerator::PrintBetaServices(grpc_generator::Printer* out) { |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 660 | grpc::string package = file->package(); |
| 661 | if (!package.empty()) { |
| 662 | package = package.append("."); |
| 663 | } |
| 664 | for (int i = 0; i < file->service_count(); ++i) { |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 665 | auto service = file->service(i); |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 666 | grpc::string package_qualified_service_name = package + service->name(); |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 667 | if (!(PrintBetaServicer(service.get(), out) && |
| 668 | PrintBetaStub(service.get(), out) && |
| 669 | PrintBetaServerFactory(package_qualified_service_name, service.get(), |
| 670 | out) && |
| 671 | PrintBetaStubFactory(package_qualified_service_name, service.get(), |
| 672 | out))) { |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 673 | return false; |
| 674 | } |
| 675 | } |
| 676 | return true; |
| 677 | } |
Harsh Vardhan | 4b0ba1a | 2017-02-25 20:54:52 +0530 | [diff] [blame] | 678 | |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 679 | pair<bool, grpc::string> PrivateGenerator::GetGrpcServices() { |
Masood Malekghassemi | 65c803b | 2015-03-20 06:48:47 -0700 | [diff] [blame] | 680 | grpc::string output; |
Masood Malekghassemi | 59d9ff4 | 2015-02-23 15:28:07 -0800 | [diff] [blame] | 681 | { |
| 682 | // Scope the output stream so it closes and finalizes output to the string. |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 683 | auto out = file->CreatePrinter(&output); |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 684 | if (generate_in_pb2_grpc) { |
Masood Malekghassemi | 0d62d7e | 2016-12-28 14:28:44 -0800 | [diff] [blame] | 685 | out->Print( |
| 686 | "# Generated by the gRPC Python protocol compiler plugin. " |
| 687 | "DO NOT EDIT!\n"); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 688 | if (!PrintPreamble(out.get())) { |
Masood Malekghassemi | 59d9ff4 | 2015-02-23 15:28:07 -0800 | [diff] [blame] | 689 | return make_pair(false, ""); |
| 690 | } |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 691 | if (!PrintGAServices(out.get())) { |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 692 | return make_pair(false, ""); |
| 693 | } |
| 694 | } else { |
| 695 | out->Print("try:\n"); |
| 696 | { |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 697 | IndentScope raii_dict_try_indent(out.get()); |
Masood Malekghassemi | 7780cc0 | 2016-10-24 15:30:05 -0700 | [diff] [blame] | 698 | out->Print( |
| 699 | "# THESE ELEMENTS WILL BE DEPRECATED.\n" |
| 700 | "# Please use the generated *_pb2_grpc.py files instead.\n"); |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 701 | if (!PrintPreamble(out.get())) { |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 702 | return make_pair(false, ""); |
| 703 | } |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 704 | if (!PrintBetaPreamble(out.get())) { |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 705 | return make_pair(false, ""); |
| 706 | } |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 707 | if (!PrintGAServices(out.get())) { |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 708 | return make_pair(false, ""); |
| 709 | } |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 710 | if (!PrintBetaServices(out.get())) { |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 711 | return make_pair(false, ""); |
| 712 | } |
| 713 | } |
| 714 | out->Print("except ImportError:\n"); |
| 715 | { |
Harsh Vardhan | 6a9950d | 2017-02-07 12:01:44 +0530 | [diff] [blame] | 716 | IndentScope raii_dict_except_indent(out.get()); |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 717 | out->Print("pass"); |
| 718 | } |
Masood Malekghassemi | 59d9ff4 | 2015-02-23 15:28:07 -0800 | [diff] [blame] | 719 | } |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 720 | } |
Masood Malekghassemi | 59d9ff4 | 2015-02-23 15:28:07 -0800 | [diff] [blame] | 721 | return make_pair(true, std::move(output)); |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 722 | } |
| 723 | |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 724 | } // namespace |
| 725 | |
| 726 | GeneratorConfiguration::GeneratorConfiguration() |
Nathaniel Manista | 40d55f9 | 2017-03-14 00:01:35 +0000 | [diff] [blame] | 727 | : grpc_package_root("grpc"), |
| 728 | beta_package_root("grpc.beta"), |
| 729 | import_prefix("") {} |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 730 | |
| 731 | PythonGrpcGenerator::PythonGrpcGenerator(const GeneratorConfiguration& config) |
| 732 | : config_(config) {} |
| 733 | |
| 734 | PythonGrpcGenerator::~PythonGrpcGenerator() {} |
| 735 | |
Masood Malekghassemi | 561dce4 | 2016-11-30 20:20:32 -0800 | [diff] [blame] | 736 | static bool GenerateGrpc(GeneratorContext* context, PrivateGenerator& generator, |
| 737 | grpc::string file_name, bool generate_in_pb2_grpc) { |
| 738 | bool success; |
| 739 | std::unique_ptr<ZeroCopyOutputStream> output; |
| 740 | std::unique_ptr<CodedOutputStream> coded_output; |
| 741 | grpc::string grpc_code; |
| 742 | |
| 743 | if (generate_in_pb2_grpc) { |
| 744 | output.reset(context->Open(file_name)); |
| 745 | generator.generate_in_pb2_grpc = true; |
| 746 | } else { |
| 747 | output.reset(context->OpenForInsert(file_name, "module_scope")); |
| 748 | generator.generate_in_pb2_grpc = false; |
| 749 | } |
| 750 | |
| 751 | coded_output.reset(new CodedOutputStream(output.get())); |
| 752 | tie(success, grpc_code) = generator.GetGrpcServices(); |
| 753 | |
| 754 | if (success) { |
| 755 | coded_output->WriteRaw(grpc_code.data(), grpc_code.size()); |
| 756 | return true; |
| 757 | } else { |
| 758 | return false; |
| 759 | } |
| 760 | } |
| 761 | |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 762 | bool PythonGrpcGenerator::Generate(const FileDescriptor* file, |
| 763 | const grpc::string& parameter, |
| 764 | GeneratorContext* context, |
| 765 | grpc::string* error) const { |
| 766 | // Get output file name. |
| 767 | grpc::string pb2_file_name; |
| 768 | grpc::string pb2_grpc_file_name; |
| 769 | static const int proto_suffix_length = strlen(".proto"); |
| 770 | if (file->name().size() > static_cast<size_t>(proto_suffix_length) && |
| 771 | file->name().find_last_of(".proto") == file->name().size() - 1) { |
Masood Malekghassemi | 7780cc0 | 2016-10-24 15:30:05 -0700 | [diff] [blame] | 772 | grpc::string base = |
| 773 | file->name().substr(0, file->name().size() - proto_suffix_length); |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 774 | pb2_file_name = base + "_pb2.py"; |
| 775 | pb2_grpc_file_name = base + "_pb2_grpc.py"; |
| 776 | } else { |
| 777 | *error = "Invalid proto file name. Proto file must end with .proto"; |
| 778 | return false; |
| 779 | } |
Harsh Vardhan | 93077ae | 2016-12-26 18:23:45 +0530 | [diff] [blame] | 780 | generator_file_name = file->name(); |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 781 | |
Harsh Vardhan | 64741b2 | 2017-01-14 15:19:09 +0530 | [diff] [blame] | 782 | ProtoBufFile pbfile(file); |
| 783 | PrivateGenerator generator(config_, &pbfile); |
Masood Malekghassemi | 561dce4 | 2016-11-30 20:20:32 -0800 | [diff] [blame] | 784 | if (parameter == "grpc_2_0") { |
| 785 | return GenerateGrpc(context, generator, pb2_grpc_file_name, true); |
| 786 | } else if (parameter == "") { |
| 787 | return GenerateGrpc(context, generator, pb2_grpc_file_name, true) && |
| 788 | GenerateGrpc(context, generator, pb2_file_name, false); |
| 789 | } else { |
| 790 | *error = "Invalid parameter '" + parameter + "'."; |
| 791 | return false; |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 792 | } |
Masood Malekghassemi | d953959 | 2016-10-20 14:47:14 -0700 | [diff] [blame] | 793 | } |
| 794 | |
Masood Malekghassemi | f8e297a | 2015-02-19 15:39:32 -0800 | [diff] [blame] | 795 | } // namespace grpc_python_generator |