1 /*
2  *
3  * Copyright 2019 gRPC authors.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *     http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  */
18 
19 #ifndef GRPC_INTERNAL_COMPILER_CPP_PLUGIN_H
20 #define GRPC_INTERNAL_COMPILER_CPP_PLUGIN_H
21 
22 #include <memory>
23 #include <sstream>
24 
25 #include "src/compiler/config.h"
26 #include "src/compiler/cpp_generator.h"
27 #include "src/compiler/generator_helpers.h"
28 #include "src/compiler/protobuf_plugin.h"
29 
30 // Cpp Generator for Protobug IDL
31 class CppGrpcGenerator : public grpc::protobuf::compiler::CodeGenerator {
32  public:
CppGrpcGenerator()33   CppGrpcGenerator() {}
~CppGrpcGenerator()34   virtual ~CppGrpcGenerator() {}
35 
GetSupportedFeatures()36   uint64_t GetSupportedFeatures() const override {
37     return FEATURE_PROTO3_OPTIONAL;
38   }
39 
Generate(const grpc::protobuf::FileDescriptor * file,const std::string & parameter,grpc::protobuf::compiler::GeneratorContext * context,std::string * error)40   virtual bool Generate(const grpc::protobuf::FileDescriptor* file,
41                         const std::string& parameter,
42                         grpc::protobuf::compiler::GeneratorContext* context,
43                         std::string* error) const override {
44     if (file->options().cc_generic_services()) {
45       *error =
46           "cpp grpc proto compiler plugin does not work with generic "
47           "services. To generate cpp grpc APIs, please set \""
48           "cc_generic_service = false\".";
49       return false;
50     }
51 
52     grpc_cpp_generator::Parameters generator_parameters;
53     generator_parameters.use_system_headers = true;
54     generator_parameters.generate_mock_code = false;
55     generator_parameters.include_import_headers = false;
56 
57     ProtoBufFile pbfile(file);
58 
59     if (!parameter.empty()) {
60       std::vector<std::string> parameters_list =
61           grpc_generator::tokenize(parameter, ",");
62       for (auto parameter_string = parameters_list.begin();
63            parameter_string != parameters_list.end(); parameter_string++) {
64         std::vector<std::string> param =
65             grpc_generator::tokenize(*parameter_string, "=");
66         if (param[0] == "services_namespace") {
67           generator_parameters.services_namespace = param[1];
68         } else if (param[0] == "use_system_headers") {
69           if (param[1] == "true") {
70             generator_parameters.use_system_headers = true;
71           } else if (param[1] == "false") {
72             generator_parameters.use_system_headers = false;
73           } else {
74             *error = std::string("Invalid parameter: ") + *parameter_string;
75             return false;
76           }
77         } else if (param[0] == "grpc_search_path") {
78           generator_parameters.grpc_search_path = param[1];
79         } else if (param[0] == "generate_mock_code") {
80           if (param[1] == "true") {
81             generator_parameters.generate_mock_code = true;
82           } else if (param[1] != "false") {
83             *error = std::string("Invalid parameter: ") + *parameter_string;
84             return false;
85           }
86         } else if (param[0] == "gmock_search_path") {
87           generator_parameters.gmock_search_path = param[1];
88         } else if (param[0] == "additional_header_includes") {
89           generator_parameters.additional_header_includes =
90               grpc_generator::tokenize(param[1], ":");
91         } else if (param[0] == "message_header_extension") {
92           generator_parameters.message_header_extension = param[1];
93         } else if (param[0] == "include_import_headers") {
94           if (param[1] == "true") {
95             generator_parameters.include_import_headers = true;
96           } else if (param[1] != "false") {
97             *error = std::string("Invalid parameter: ") + *parameter_string;
98             return false;
99           }
100         } else {
101           *error = std::string("Unknown parameter: ") + *parameter_string;
102           return false;
103         }
104       }
105     }
106 
107     std::string file_name = grpc_generator::StripProto(file->name());
108 
109     std::string header_code =
110         grpc_cpp_generator::GetHeaderPrologue(&pbfile, generator_parameters) +
111         grpc_cpp_generator::GetHeaderIncludes(&pbfile, generator_parameters) +
112         grpc_cpp_generator::GetHeaderServices(&pbfile, generator_parameters) +
113         grpc_cpp_generator::GetHeaderEpilogue(&pbfile, generator_parameters);
114     std::unique_ptr<grpc::protobuf::io::ZeroCopyOutputStream> header_output(
115         context->Open(file_name + ".grpc.pb.h"));
116     grpc::protobuf::io::CodedOutputStream header_coded_out(header_output.get());
117     header_coded_out.WriteRaw(header_code.data(), header_code.size());
118 
119     std::string source_code =
120         grpc_cpp_generator::GetSourcePrologue(&pbfile, generator_parameters) +
121         grpc_cpp_generator::GetSourceIncludes(&pbfile, generator_parameters) +
122         grpc_cpp_generator::GetSourceServices(&pbfile, generator_parameters) +
123         grpc_cpp_generator::GetSourceEpilogue(&pbfile, generator_parameters);
124     std::unique_ptr<grpc::protobuf::io::ZeroCopyOutputStream> source_output(
125         context->Open(file_name + ".grpc.pb.cc"));
126     grpc::protobuf::io::CodedOutputStream source_coded_out(source_output.get());
127     source_coded_out.WriteRaw(source_code.data(), source_code.size());
128 
129     if (!generator_parameters.generate_mock_code) {
130       return true;
131     }
132     std::string mock_code =
133         grpc_cpp_generator::GetMockPrologue(&pbfile, generator_parameters) +
134         grpc_cpp_generator::GetMockIncludes(&pbfile, generator_parameters) +
135         grpc_cpp_generator::GetMockServices(&pbfile, generator_parameters) +
136         grpc_cpp_generator::GetMockEpilogue(&pbfile, generator_parameters);
137     std::unique_ptr<grpc::protobuf::io::ZeroCopyOutputStream> mock_output(
138         context->Open(file_name + "_mock.grpc.pb.h"));
139     grpc::protobuf::io::CodedOutputStream mock_coded_out(mock_output.get());
140     mock_coded_out.WriteRaw(mock_code.data(), mock_code.size());
141 
142     return true;
143   }
144 
145  private:
146   // Insert the given code into the given file at the given insertion point.
Insert(grpc::protobuf::compiler::GeneratorContext * context,const std::string & filename,const std::string & insertion_point,const std::string & code)147   void Insert(grpc::protobuf::compiler::GeneratorContext* context,
148               const std::string& filename, const std::string& insertion_point,
149               const std::string& code) const {
150     std::unique_ptr<grpc::protobuf::io::ZeroCopyOutputStream> output(
151         context->OpenForInsert(filename, insertion_point));
152     grpc::protobuf::io::CodedOutputStream coded_out(output.get());
153     coded_out.WriteRaw(code.data(), code.size());
154   }
155 };
156 
157 #endif  // GRPC_INTERNAL_COMPILER_CPP_PLUGIN_H
158