fork/rules_rust
git clone https://git.julia.blue/fork/rules_rust
14f48e7a
0.7.0
1# Copyright 2018 The Bazel Authors. All rights reserved. 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 15"""Rust Protobuf Rules 16 17These build rules are used for building [protobufs][protobuf]/[gRPC][grpc] in [Rust][rust] with Bazel. 18 19[rust]: http://www.rust-lang.org/ 20[protobuf]: https://developers.google.com/protocol-buffers/ 21[grpc]: https://grpc.io 22 23### Setup 24 25To use the Rust proto rules, add the following to your `WORKSPACE` file to add the 26external repositories for the Rust proto toolchain (in addition to the [rust rules setup](..)): 27 28```python 29load("//proto:repositories.bzl", "rust_proto_repositories") 30 31rust_proto_repositories() 32``` 33""" 34 35load ( "@rules_proto//proto:defs.bzl" , "ProtoInfo" ) 36load ( 37"//proto:toolchain.bzl" , 38_generate_proto = "rust_generate_proto" , 39_generated_file_stem = "generated_file_stem" , 40) 41load ( "//rust:defs.bzl" , "rust_common" ) 42 43# buildifier: disable=bzl-visibility 44load ( "//rust/private:rustc.bzl" , "rustc_compile_action" ) 45 46# buildifier: disable=bzl-visibility 47load ( "//rust/private:utils.bzl" , "compute_crate_name" , "determine_output_hash" , "find_toolchain" , "transform_deps" ) 48 49RustProtoInfo = provider ( 50doc = "Rust protobuf provider info" , 51fields = { 52"proto_sources" : "List[string]: list of source paths of protos" , 53"transitive_proto_sources" : "depset[string]" , 54}, 55) 56 57def _compute_proto_source_path ( file , source_root_attr ): 58"""Take the short path of file and make it suitable for protoc. 59 60Args: 61file (File): The target source file. 62source_root_attr (str): The directory relative to which the `.proto` \ 63files defined in the proto_library are defined. 64 65Returns: 66str: The protoc suitible path of `file` 67""" 68 69# Bazel creates symlinks to the .proto files under a directory called 70# "_virtual_imports/<rule name>" if we do any sort of munging of import 71# paths (e.g. using strip_import_prefix / import_prefix attributes) 72virtual_imports = "/_virtual_imports/" 73if virtual_imports in file . path : 74return file . path . split ( virtual_imports )[ 1 ]. split ( "/" , 1 )[ 1 ] 75 76# For proto, they need to be requested with their absolute name to be 77# compatible with the descriptor_set passed by proto_library. 78# I.e. if you compile a protobuf at @repo1//package:file.proto, the proto 79# compiler would generate a file descriptor with the path 80# `package/file.proto`. Since we compile from the proto descriptor, we need 81# to pass the list of descriptors and the list of path to compile. 82# For the precedent example, the file (noted `f`) would have 83# `f.short_path` returns `external/repo1/package/file.proto`. 84# In addition, proto_library can provide a proto_source_path to change the base 85# path, which should a be a prefix. 86path = file . short_path 87 88# Strip external prefix. 89path = path . split ( "/" , 2 )[ 2 ] if path . startswith ( "../" ) else path 90 91# Strip source_root. 92if path . startswith ( source_root_attr ): 93return path [ len ( source_root_attr ):] 94else : 95return path 96 97def _rust_proto_aspect_impl ( target , ctx ): 98"""The implementation of the `rust_proto_aspect` aspect 99 100Args: 101target (Target): The target to which the aspect is applied 102ctx (ctx): The rule context which the targetis created from 103 104Returns: 105list: A list containg a `RustProtoInfo` provider 106""" 107if ProtoInfo not in target : 108return None 109 110if hasattr ( ctx . rule . attr , "proto_source_root" ): 111source_root = ctx . rule . attr . proto_source_root 112else : 113source_root = "" 114 115if source_root and source_root [ - 1 ] != "/" : 116source_root += "/" 117 118sources = [ 119_compute_proto_source_path ( f , source_root ) 120for f in target [ ProtoInfo ]. direct_sources 121] 122transitive_sources = [ 123f [ RustProtoInfo ]. transitive_proto_sources 124for f in ctx . rule . attr . deps 125if RustProtoInfo in f 126] 127return [ RustProtoInfo ( 128proto_sources = sources , 129transitive_proto_sources = depset ( transitive = transitive_sources , direct = sources ), 130)] 131 132_rust_proto_aspect = aspect ( 133doc = "An aspect that gathers rust proto direct and transitive sources" , 134implementation = _rust_proto_aspect_impl , 135attr_aspects = [ "deps" ], 136) 137 138def _gen_lib ( ctx , grpc , srcs , lib ): 139"""Generate a lib.rs file for the crates. 140 141Args: 142ctx (ctx): The current rule's context object 143grpc (bool): True if the current rule is a `gRPC` rule. 144srcs (list): A list of protoc suitible file paths (str). 145lib (File): The File object where the rust source file should be written 146""" 147content = [ "extern crate protobuf;" ] 148if grpc : 149content . append ( "extern crate grpc;" ) 150content . append ( "extern crate tls_api;" ) 151for f in srcs . to_list (): 152content . append ( "pub mod %s;" % _generated_file_stem ( f )) 153content . append ( "pub use %s::*;" % _generated_file_stem ( f )) 154if grpc : 155content . append ( "pub mod %s_grpc;" % _generated_file_stem ( f )) 156content . append ( "pub use %s_grpc::*;" % _generated_file_stem ( f )) 157ctx . actions . write ( lib , "\n ". join ( content )) 158 159def _expand_provider ( lst , provider ): 160"""Gathers a list of a specific provider from a list of targets. 161 162Args: 163lst (list): A list of Targets 164provider (Provider): The target provider type to extract `lst` 165 166Returns: 167list: A list of providers of the type from `provider`. 168""" 169return [ el [ provider ] for el in lst if provider in el ] 170 171def _rust_proto_compile ( protos , descriptor_sets , imports , crate_name , ctx , is_grpc , compile_deps , toolchain ): 172"""Create and run a rustc compile action based on the current rule's attributes 173 174Args: 175protos (depset): Paths of protos to compile. 176descriptor_sets (depset): A set of transitive protobuf `FileDescriptorSet`s 177imports (depset): A set of transitive protobuf Imports. 178crate_name (str): The name of the Crate for the current target 179ctx (ctx): The current rule's context object 180is_grpc (bool): True if the current rule is a `gRPC` rule. 181compile_deps (list): A list of Rust dependencies (`List[Target]`) 182toolchain (rust_toolchain): the current `rust_toolchain`. 183 184Returns: 185list: A list of providers, see `rustc_compile_action` 186""" 187 188# Create all the source in a specific folder 189proto_toolchain = ctx . toolchains [ Label ( "//proto:toolchain" )] 190output_dir = "%s.%s.rust" % ( crate_name , "grpc" if is_grpc else "proto" ) 191 192# Generate the proto stubs 193srcs = _generate_proto ( 194ctx , 195descriptor_sets , 196protos = protos , 197imports = imports , 198output_dir = output_dir , 199proto_toolchain = proto_toolchain , 200is_grpc = is_grpc , 201) 202 203# and lib.rs 204lib_rs = ctx . actions . declare_file ( "%s/lib.rs" % output_dir ) 205_gen_lib ( ctx , is_grpc , protos , lib_rs ) 206srcs . append ( lib_rs ) 207 208# And simulate rust_library behavior 209output_hash = determine_output_hash ( lib_rs , ctx . label ) 210rust_lib = ctx . actions . declare_file ( "%s/lib%s-%s.rlib" % ( 211output_dir , 212crate_name , 213output_hash , 214)) 215 216# Gather all dependencies for compilation 217compile_action_deps = depset ( 218transform_deps ( 219compile_deps + 220proto_toolchain . grpc_compile_deps if is_grpc else proto_toolchain . proto_compile_deps , 221), 222) 223 224return rustc_compile_action ( 225ctx = ctx , 226attr = ctx . attr , 227toolchain = toolchain , 228crate_info = rust_common . create_crate_info ( 229name = crate_name , 230type = "rlib" , 231root = lib_rs , 232srcs = depset ( srcs ), 233deps = compile_action_deps , 234proc_macro_deps = depset ([]), 235aliases = {}, 236output = rust_lib , 237edition = proto_toolchain . edition , 238rustc_env = {}, 239is_test = False , 240compile_data = depset ([ target . files for target in getattr ( ctx . attr , "compile_data" , [])]), 241wrapped_crate_type = None , 242owner = ctx . label , 243), 244output_hash = output_hash , 245) 246 247def _rust_protogrpc_library_impl ( ctx , is_grpc ): 248"""Implementation of the rust_(proto|grpc)_library. 249 250Args: 251ctx (ctx): The current rule's context object 252is_grpc (bool): True if the current rule is a `gRPC` rule. 253 254Returns: 255list: A list of providers, see `_rust_proto_compile` 256""" 257proto = _expand_provider ( ctx . attr . deps , ProtoInfo ) 258transitive_sources = [ 259f [ RustProtoInfo ]. transitive_proto_sources 260for f in ctx . attr . deps 261if RustProtoInfo in f 262] 263 264toolchain = find_toolchain ( ctx ) 265crate_name = compute_crate_name ( ctx . workspace_name , ctx . label , toolchain ) 266 267return _rust_proto_compile ( 268protos = depset ( transitive = transitive_sources ), 269descriptor_sets = depset ( transitive = [ p . transitive_descriptor_sets for p in proto ]), 270imports = depset ( transitive = [ p . transitive_imports for p in proto ]), 271crate_name = crate_name , 272ctx = ctx , 273is_grpc = is_grpc , 274compile_deps = ctx . attr . rust_deps , 275toolchain = toolchain , 276) 277 278def _rust_proto_library_impl ( ctx ): 279"""The implementation of the `rust_proto_library` rule 280 281Args: 282ctx (ctx): The rule's context object. 283 284Returns: 285list: A list of providers, see `_rust_protogrpc_library_impl` 286""" 287return _rust_protogrpc_library_impl ( ctx , False ) 288 289rust_proto_library = rule ( 290implementation = _rust_proto_library_impl , 291attrs = { 292"deps" : attr . label_list ( 293doc = ( 294"List of proto_library dependencies that will be built. " + 295"One crate for each proto_library will be created with the corresponding stubs." 296), 297mandatory = True , 298providers = [ ProtoInfo ], 299aspects = [ _rust_proto_aspect ], 300), 301"rust_deps" : attr . label_list ( 302doc = "The crates the generated library depends on." , 303), 304"_cc_toolchain" : attr . label ( 305default = Label ( "@bazel_tools//tools/cpp:current_cc_toolchain" ), 306), 307"_optional_output_wrapper" : attr . label ( 308executable = True , 309cfg = "exec" , 310default = Label ( "//proto:optional_output_wrapper" ), 311), 312"_process_wrapper" : attr . label ( 313default = Label ( "//util/process_wrapper" ), 314executable = True , 315allow_single_file = True , 316cfg = "exec" , 317), 318}, 319fragments = [ "cpp" ], 320host_fragments = [ "cpp" ], 321toolchains = [ 322str ( Label ( "//proto:toolchain" )), 323str ( Label ( "//rust:toolchain" )), 324"@bazel_tools//tools/cpp:toolchain_type" , 325], 326# TODO: Remove once (bazelbuild/bazel#11584) is closed and the rules use 327# the version of Bazel that issue was closed on as the min supported version 328incompatible_use_toolchain_transition = True , 329doc = """\ 330Builds a Rust library crate from a set of `proto_library`s. 331 332Example: 333 334```python 335load("@rules_rust//proto:proto.bzl", "rust_proto_library") 336 337proto_library( 338name = "my_proto", 339srcs = ["my.proto"] 340) 341 342rust_proto_library( 343name = "rust", 344deps = [":my_proto"], 345) 346 347rust_binary( 348name = "my_proto_binary", 349srcs = ["my_proto_binary.rs"], 350deps = [":rust"], 351) 352``` 353""" , 354) 355 356def _rust_grpc_library_impl ( ctx ): 357"""The implementation of the `rust_grpc_library` rule 358 359Args: 360ctx (ctx): The rule's context object 361 362Returns: 363list: A list of providers. See `_rust_protogrpc_library_impl` 364""" 365return _rust_protogrpc_library_impl ( ctx , True ) 366 367rust_grpc_library = rule ( 368implementation = _rust_grpc_library_impl , 369attrs = { 370"deps" : attr . label_list ( 371doc = ( 372"List of proto_library dependencies that will be built. " + 373"One crate for each proto_library will be created with the corresponding gRPC stubs." 374), 375mandatory = True , 376providers = [ ProtoInfo ], 377aspects = [ _rust_proto_aspect ], 378), 379"rust_deps" : attr . label_list ( 380doc = "The crates the generated library depends on." , 381), 382"_cc_toolchain" : attr . label ( 383default = "@bazel_tools//tools/cpp:current_cc_toolchain" , 384), 385"_optional_output_wrapper" : attr . label ( 386executable = True , 387cfg = "exec" , 388default = Label ( "//proto:optional_output_wrapper" ), 389), 390"_process_wrapper" : attr . label ( 391default = Label ( "//util/process_wrapper" ), 392executable = True , 393allow_single_file = True , 394cfg = "exec" , 395), 396}, 397fragments = [ "cpp" ], 398host_fragments = [ "cpp" ], 399toolchains = [ 400str ( Label ( "//proto:toolchain" )), 401str ( Label ( "//rust:toolchain" )), 402"@bazel_tools//tools/cpp:toolchain_type" , 403], 404# TODO: Remove once (bazelbuild/bazel#11584) is closed and the rules use 405# the version of Bazel that issue was closed on as the min supported version 406incompatible_use_toolchain_transition = True , 407doc = """\ 408Builds a Rust library crate from a set of `proto_library`s suitable for gRPC. 409 410Example: 411 412```python 413load("//proto:proto.bzl", "rust_grpc_library") 414 415proto_library( 416name = "my_proto", 417srcs = ["my.proto"] 418) 419 420rust_grpc_library( 421name = "rust", 422deps = [":my_proto"], 423) 424 425rust_binary( 426name = "my_service", 427srcs = ["my_service.rs"], 428deps = [":rust"], 429) 430``` 431""" , 432)