1// Copyright 2020 The Android Open Source Project
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package rust
16
17import (
18	"fmt"
19	"strconv"
20	"strings"
21
22	"android/soong/android"
23	"android/soong/cc"
24)
25
26var (
27	defaultProtobufFlags = []string{""}
28)
29
30const (
31	grpcSuffix = "_grpc"
32)
33
34type PluginType int
35
36func init() {
37	android.RegisterModuleType("rust_protobuf", RustProtobufFactory)
38	android.RegisterModuleType("rust_protobuf_host", RustProtobufHostFactory)
39}
40
41var _ SourceProvider = (*protobufDecorator)(nil)
42
43type ProtobufProperties struct {
44	// List of relative paths to proto files that will be used to generate the source.
45	// Either this or grpc_protos must be defined.
46	Protos []string `android:"path,arch_variant"`
47
48	// List of relative paths to GRPC-containing proto files that will be used to generate the source.
49	// Either this or protos must be defined.
50	Grpc_protos []string `android:"path,arch_variant"`
51
52	// List of additional flags to pass to aprotoc
53	Proto_flags []string `android:"arch_variant"`
54
55	// List of libraries which export include paths required for this module
56	Header_libs []string `android:"arch_variant,variant_prepend"`
57
58	// List of exported include paths containing proto files for dependent rust_protobuf modules.
59	Exported_include_dirs []string
60}
61
62type protobufDecorator struct {
63	*BaseSourceProvider
64
65	Properties       ProtobufProperties
66	protoNames       []string
67	additionalCrates []string
68	grpcNames        []string
69
70	grpcProtoFlags android.ProtoFlags
71	protoFlags     android.ProtoFlags
72}
73
74func (proto *protobufDecorator) GenerateSource(ctx ModuleContext, deps PathDeps) android.Path {
75	var protoFlags android.ProtoFlags
76	var grpcProtoFlags android.ProtoFlags
77	var commonProtoFlags []string
78
79	outDir := android.PathForModuleOut(ctx)
80	protoFiles := android.PathsForModuleSrc(ctx, proto.Properties.Protos)
81	grpcFiles := android.PathsForModuleSrc(ctx, proto.Properties.Grpc_protos)
82
83	protoPluginPath := ctx.Config().HostToolPath(ctx, "protoc-gen-rust")
84
85	commonProtoFlags = append(commonProtoFlags, defaultProtobufFlags...)
86	commonProtoFlags = append(commonProtoFlags, proto.Properties.Proto_flags...)
87	commonProtoFlags = append(commonProtoFlags, "--plugin=protoc-gen-rust="+protoPluginPath.String())
88
89	if len(protoFiles) > 0 {
90		protoFlags.OutTypeFlag = "--rust_out"
91		protoFlags.Flags = append(protoFlags.Flags, commonProtoFlags...)
92
93		protoFlags.Deps = append(protoFlags.Deps, protoPluginPath)
94	}
95
96	if len(grpcFiles) > 0 {
97		grpcPath := ctx.Config().HostToolPath(ctx, "grpc_rust_plugin")
98
99		grpcProtoFlags.OutTypeFlag = "--rust_out"
100		grpcProtoFlags.Flags = append(grpcProtoFlags.Flags, "--grpc_out="+outDir.String())
101		grpcProtoFlags.Flags = append(grpcProtoFlags.Flags, "--plugin=protoc-gen-grpc="+grpcPath.String())
102		grpcProtoFlags.Flags = append(grpcProtoFlags.Flags, commonProtoFlags...)
103
104		grpcProtoFlags.Deps = append(grpcProtoFlags.Deps, grpcPath, protoPluginPath)
105	}
106
107	if len(protoFiles) == 0 && len(grpcFiles) == 0 {
108		ctx.PropertyErrorf("protos",
109			"at least one protobuf must be defined in either protos or grpc_protos.")
110	}
111
112	// Add exported dependency include paths
113	for _, include := range deps.depIncludePaths {
114		protoFlags.Flags = append(protoFlags.Flags, "-I"+include.String())
115		grpcProtoFlags.Flags = append(grpcProtoFlags.Flags, "-I"+include.String())
116	}
117
118	stem := proto.BaseSourceProvider.getStem(ctx)
119
120	// The mod_stem.rs file is used to avoid collisions if this is not included as a crate.
121	stemFile := android.PathForModuleOut(ctx, "mod_"+stem+".rs")
122
123	// stemFile must be first here as the first path in BaseSourceProvider.OutputFiles is the library entry-point.
124	var outputs android.WritablePaths
125
126	for i, shard := range android.ShardPaths(protoFiles, 50) {
127		rule := android.NewRuleBuilder(pctx, ctx)
128
129		for _, protoFile := range shard {
130			// Since we're iterating over the protoFiles already, make sure they're not redeclared in grpcFiles
131			if android.InList(protoFile.String(), grpcFiles.Strings()) {
132				ctx.PropertyErrorf("protos",
133					"A proto can only be added once to either grpc_protos or protos. %q is declared in both properties",
134					protoFile.String())
135			}
136
137			protoName := strings.TrimSuffix(protoFile.Base(), ".proto")
138			proto.protoNames = append(proto.protoNames, protoName)
139
140			protoOut := android.PathForModuleOut(ctx, protoName+".rs")
141			depFile := android.PathForModuleOut(ctx, protoName+".d")
142
143			ruleOutputs := android.WritablePaths{protoOut, depFile}
144
145			android.ProtoRule(rule, protoFile, protoFlags, protoFlags.Deps, outDir, depFile, ruleOutputs)
146			outputs = append(outputs, ruleOutputs...)
147		}
148
149		ruleName := "protoc"
150		ruleDesc := "protoc"
151		if i > 0 {
152			ruleName += "_" + strconv.Itoa(i+1)
153			ruleDesc += " " + strconv.Itoa(i+1)
154		}
155
156		rule.Build(ruleName, ruleDesc)
157	}
158
159	for i, shard := range android.ShardPaths(grpcFiles, 50) {
160		rule := android.NewRuleBuilder(pctx, ctx)
161
162		for _, grpcFile := range shard {
163			grpcName := strings.TrimSuffix(grpcFile.Base(), ".proto")
164			proto.grpcNames = append(proto.grpcNames, grpcName)
165
166			// GRPC protos produce two files, a proto.rs and a proto_grpc.rs
167			protoOut := android.WritablePath(android.PathForModuleOut(ctx, grpcName+".rs"))
168			grpcOut := android.WritablePath(android.PathForModuleOut(ctx, grpcName+grpcSuffix+".rs"))
169			depFile := android.PathForModuleOut(ctx, grpcName+".d")
170
171			ruleOutputs := android.WritablePaths{protoOut, grpcOut, depFile}
172
173			android.ProtoRule(rule, grpcFile, grpcProtoFlags, grpcProtoFlags.Deps, outDir, depFile, ruleOutputs)
174			outputs = append(outputs, ruleOutputs...)
175		}
176
177		ruleName := "protoc_grpc"
178		ruleDesc := "protoc grpc"
179		if i > 0 {
180			ruleName += "_" + strconv.Itoa(i+1)
181			ruleDesc += " " + strconv.Itoa(i+1)
182		}
183
184		rule.Build(ruleName, ruleDesc)
185	}
186
187	// Check that all proto base filenames are unique as outputs are written to the same directory.
188	baseFilenames := append(proto.protoNames, proto.grpcNames...)
189	if len(baseFilenames) != len(android.FirstUniqueStrings(baseFilenames)) {
190		ctx.PropertyErrorf("protos", "proto filenames must be unique across  'protos' and 'grpc_protos' "+
191			"to be used in the same rust_protobuf module. For example, foo.proto and src/foo.proto will conflict.")
192	}
193
194	android.WriteFileRule(ctx, stemFile, proto.genModFileContents())
195
196	// stemFile must be first here as the first path in BaseSourceProvider.OutputFiles is the library entry-point.
197	proto.BaseSourceProvider.OutputFiles = append(android.Paths{stemFile}, outputs.Paths()...)
198
199	android.SetProvider(ctx, cc.FlagExporterInfoProvider, cc.FlagExporterInfo{
200		IncludeDirs: android.PathsForModuleSrc(ctx, proto.Properties.Exported_include_dirs),
201	})
202
203	// mod_stem.rs is the entry-point for our library modules, so this is what we return.
204	return stemFile
205}
206
207func (proto *protobufDecorator) genModFileContents() string {
208	lines := []string{
209		"// @Soong generated Source",
210	}
211
212	for _, protoName := range proto.protoNames {
213		lines = append(lines, fmt.Sprintf("pub mod %s;", protoName))
214	}
215
216	for _, crate := range proto.additionalCrates {
217		lines = append(lines, fmt.Sprintf("pub use %s::*;", crate))
218
219	}
220
221	for _, grpcName := range proto.grpcNames {
222		lines = append(lines, fmt.Sprintf("pub mod %s;", grpcName))
223		lines = append(lines, fmt.Sprintf("pub mod %s%s;", grpcName, grpcSuffix))
224	}
225	if len(proto.grpcNames) > 0 {
226		lines = append(
227			lines,
228			"pub mod empty {",
229			"    pub use protobuf::well_known_types::empty::Empty;",
230			"}")
231	}
232
233	return strings.Join(lines, "\n")
234}
235
236func (proto *protobufDecorator) SourceProviderProps() []interface{} {
237	return append(proto.BaseSourceProvider.SourceProviderProps(), &proto.Properties)
238}
239
240func (proto *protobufDecorator) SourceProviderDeps(ctx DepsContext, deps Deps) Deps {
241	deps = proto.BaseSourceProvider.SourceProviderDeps(ctx, deps)
242	deps.Rustlibs = append(deps.Rustlibs, "libprotobuf")
243	deps.HeaderLibs = append(deps.SharedLibs, proto.Properties.Header_libs...)
244
245	if len(proto.Properties.Grpc_protos) > 0 {
246		deps.Rustlibs = append(deps.Rustlibs, "libgrpcio", "libfutures")
247		deps.HeaderLibs = append(deps.HeaderLibs, "libprotobuf-cpp-full")
248	}
249
250	return deps
251}
252
253// rust_protobuf generates protobuf rust code from the provided proto file. This uses the protoc-gen-rust plugin for
254// protoc. Additional flags to the protoc command can be passed via the proto_flags property. This module type will
255// create library variants that can be used as a crate dependency by adding it to the rlibs and rustlibs
256// properties of other modules.
257func RustProtobufFactory() android.Module {
258	module, _ := NewRustProtobuf(android.HostAndDeviceSupported)
259	return module.Init()
260}
261
262// A host-only variant of rust_protobuf. Refer to rust_protobuf for more details.
263func RustProtobufHostFactory() android.Module {
264	module, _ := NewRustProtobuf(android.HostSupported)
265	return module.Init()
266}
267
268func NewRustProtobuf(hod android.HostOrDeviceSupported) (*Module, *protobufDecorator) {
269	protobuf := &protobufDecorator{
270		BaseSourceProvider: NewSourceProvider(),
271		Properties:         ProtobufProperties{},
272	}
273
274	module := NewSourceProviderModule(hod, protobuf, false, false)
275
276	return module, protobuf
277}
278