Protocol Buffer Rules - Bazel Documentation

Rules

cc_proto_library
java_lite_proto_library
java_proto_library
proto_library
py_proto_library
proto_lang_toolchain
proto_toolchain

cc_proto_library

cc_proto_library(name, deps, aspect_hints, compatible_with, deprecation, exec_compatible_with, exec_group_compatible_with, exec_properties, features, package_metadata, restricted_to, tags, target_compatible_with, testonly, toolchains, visibility)

cc_proto_library generates C++ code from .proto files. deps must point to proto_library rules. Example:

cc_library(
    name = "lib",
    deps = [":foo_cc_proto"],
)

cc_proto_library(
    name = "foo_cc_proto",
    deps = [":foo_proto"],
)

proto_library(
    name = "foo_proto",
)

Arguments

Attributes
`name`	Name; required A unique name for this target.
`deps`	List of labels; default is `[]` The list of `proto_library` rules to generate C++ code for.

java_lite_proto_library

View rule sourceopen_in_new

java_lite_proto_library(name, deps, aspect_hints, compatible_with, deprecation, exec_compatible_with, exec_group_compatible_with, exec_properties, features, package_metadata, restricted_to, tags, target_compatible_with, testonly, toolchains, visibility)

java_lite_proto_library generates Java code from .proto files. deps must point to proto_library rules. Example:

java_library(
    name = "lib",
    runtime_deps = [":foo"],
)

java_lite_proto_library(
    name = "foo",
    deps = [":bar"],
)

proto_library(
    name = "bar",
)

Arguments

Attributes
`name`	Name; required A unique name for this target.
`deps`	List of labels; default is `[]` The list of `proto_library` rules to generate Java code for.

java_proto_library

View rule sourceopen_in_new

java_proto_library(name, deps, aspect_hints, compatible_with, deprecation, exec_compatible_with, exec_group_compatible_with, exec_properties, features, licenses, package_metadata, restricted_to, tags, target_compatible_with, testonly, toolchains, visibility)

java_proto_library generates Java code from .proto files. deps must point to proto_library rules. Example:

java_library(
    name = "lib",
    runtime_deps = [":foo_java_proto"],
)

java_proto_library(
    name = "foo_java_proto",
    deps = [":foo_proto"],
)

proto_library(
    name = "foo_proto",
)

Arguments

Attributes
`name`	Name; required A unique name for this target.
`deps`	List of labels; default is `[]` The list of `proto_library` rules to generate Java code for.

proto_library

View rule sourceopen_in_new

proto_library(name, deps, srcs, data, allow_exports, aspect_hints, compatible_with, deprecation, exec_compatible_with, exec_group_compatible_with, exec_properties, exports, extension_declarations, features, import_prefix, licenses, option_deps, package_metadata, restricted_to, strip_import_prefix, tags, target_compatible_with, testonly, toolchains, visibility)

Use proto_library to define libraries of protocol buffers which may be used from multiple languages. A proto_library may be listed in the deps clause of supported rules, such as java_proto_library. When compiled on the command-line, a proto_library creates a file named foo-descriptor-set.proto.bin, which is the descriptor set for the messages the rule srcs. The file is a serialized FileDescriptorSet, which is described in https://developers.google.com/protocol-buffers/docs/techniques#self-description. It only contains information about the .proto files directly mentioned by a proto_library rule; the collection of transitive descriptor sets is available through the [ProtoInfo].transitive_descriptor_sets Starlark provider. See documentation in proto_info.bzl. Recommended code organization:

One proto_library rule per .proto file.* A file named foo.proto will be in a rule named foo_proto, which is located in the same package.* A [language]_proto_library that wraps a proto_library named foo_proto should be called foo_[language]_proto, and be located in the same package.

Arguments

Attributes
`name`	Name; required A unique name for this target.
`deps`	List of labels; default is `[]` The list of other `proto_library` rules that the target depends upon. A `proto_library` may only depend on other `proto_library` targets. It may not depend on language-specific libraries.
`srcs`	List of labels; default is `[]` The list of `.proto` and `.protodevel` files that are processed to create the target. This is usually a non empty list. One usecase where `srcs` can be empty is an alias-library. This is a proto_library rule having one or more other proto_library in `deps`. This pattern can be used to e.g. export a public api under a persistent name.
`allow_exports`	Label; default is `None` An optional allowlist that prevents proto library to be reexported or used in lang_proto_library that is not in one of the listed packages.
`exports`	List of labels; default is `[]` List of proto_library targets that can be referenced via “import public” in the proto source. It’s an error if you use “import public” but do not list the corresponding library in the exports attribute. Note that you have list the library both in deps and exports since not all lang_proto_library implementations have been changed yet.
`extension_declarations`	List of labels; default is `[]` List of files containing extension declarations. This attribute is only allowed for use with MessageSet.
`import_prefix`	String; default is `""` The prefix to add to the paths of the .proto files in this rule. When set, the .proto source files in the `srcs` attribute of this rule are accessible at is the value of this attribute prepended to their repository-relative path. The prefix in the `strip_import_prefix` attribute is removed before this prefix is added.
`option_deps`	List of labels; default is `[]` The list of other `proto_library` rules that the target depends upon for options only. A `proto_library` may only depend on other `proto_library` targets. It may not depend on language-specific libraries.
`strip_import_prefix`	String; default is `"/"` The prefix to strip from the paths of the .proto files in this rule. When set, .proto source files in the `srcs` attribute of this rule are accessible at their path with this prefix cut off. If it’s a relative path (not starting with a slash), it’s taken as a package-relative one. If it’s an absolute one, it’s understood as a repository-relative path. The prefix in the `import_prefix` attribute is added after this prefix is stripped.

py_proto_library

View rule sourceopen_in_new

py_proto_library(name, deps, aspect_hints, compatible_with, deprecation, exec_compatible_with, exec_group_compatible_with, exec_properties, features, package_metadata, restricted_to, tags, target_compatible_with, testonly, toolchains, visibility)

Use py_proto_library to generate Python libraries from .proto files. The convention is to name the py_proto_library rule foo_py_pb2, when it is wrapping proto_library rule foo_proto. deps must point to a proto_library rule. Example:

py_library(
name = "lib",
deps = [":foo_py_pb2"],
)
py_proto_library(
name = "foo_py_pb2",
deps = [":foo_proto"],
)
proto_library(
name = "foo_proto",
srcs = ["foo.proto"],
)

Arguments

Attributes
`name`	Name; required A unique name for this target.
`deps`	List of labels; default is `[]` The list of `proto_library` rules to generate Python libraries for. Usually this is just the one target: the proto library of interest. It can be any target providing `ProtoInfo`.

proto_lang_toolchain

View rule sourceopen_in_new

proto_lang_toolchain(name, allowlist_different_package, aspect_hints, blacklisted_protos, command_line, compatible_with, denylisted_protos, deprecation, exec_compatible_with, exec_group_compatible_with, exec_properties, features, mnemonic, output_files, package_metadata, plugin, plugin_format_flag, progress_message, protoc_minimal_do_not_use, restricted_to, runtime, tags, target_compatible_with, testonly, toolchain_type, toolchains, visibility)

If using Bazel, please load the rule from https://github.com/bazelbuild/rules_proto. Specifies how a LANG_proto_library rule (e.g., java_proto_library) should invoke the proto-compiler. Some LANG_proto_library rules allow specifying which toolchain to use using command-line flags; consult their documentation. Normally you should not write those kind of rules unless you want to tune your Java compiler. There’s no compiler. The proto-compiler is taken from the proto_library rule we attach to. It is passed as a command-line flag to Blaze. Several features require a proto-compiler to be invoked on the proto_library rule itself. It’s beneficial to enforce the compiler that LANG_proto_library uses is the same as the one proto_library does.

Examples

A simple example would be:

proto_lang_toolchain(
    name = "javalite_toolchain",
    command_line = "--javalite_out=shared,immutable:$(OUT)",
    plugin = ":javalite_plugin",
    runtime = ":protobuf_lite",
)

Arguments

Attributes
`name`	Name; required A unique name for this target.
`allowlist_different_package`	Label; default is `None`
`blacklisted_protos`	List of labels; default is `[]` Deprecated. Alias for `denylisted_protos`. Will be removed in a future release.
`command_line`	String; required This value will be passed to proto-compiler to generate the code. Only include the parts specific to this code-generator/plugin (e.g., do not include -I parameters) * `$(OUT)` is LANG_proto_library-specific. The rules are expected to define how they interpret this variable. For Java, for example, $(OUT) will be replaced with the src-jar filename to create.
`denylisted_protos`	List of labels; default is `[]` No code will be generated for files in the `srcs` attribute of `denylisted_protos`. This is used for .proto files that are already linked into proto runtimes, such as `any.proto`.
`mnemonic`	String; default is `"GenProto"` This value will be set as the mnemonic on protoc action.
`output_files`	String; default is `"legacy"` Controls how `$(OUT)` in `command_line` is formatted, either by a path to a single file or output directory in case of multiple files. Possible values are: “single”, “multiple”.
`plugin`	Label; default is `None` If provided, will be made available to the action that calls the proto-compiler, and will be passed to the proto-compiler: `--plugin=protoc-gen-PLUGIN=<executable>.`
`plugin_format_flag`	String; default is `""` If provided, this value will be passed to proto-compiler to use the plugin. The value must contain a single %s which is replaced with plugin executable. `--plugin=protoc-gen-PLUGIN=<executable>.`
`progress_message`	String; default is `"Generating proto_library %{label}"` This value will be set as the progress message on protoc action.
`protoc_minimal_do_not_use`	Label; default is `None`
`runtime`	Label; default is `None` A language-specific library that the generated code is compiled against. The exact behavior is LANG_proto_library-specific. Java, for example, should compile against the runtime.
`toolchain_type`	Label; default is `None`

proto_toolchain

View rule sourceopen_in_new

proto_toolchain(name, aspect_hints, command_line, compatible_with, deprecation, exec_compatible_with, exec_group_compatible_with, exec_properties, features, mnemonic, output_files, package_metadata, progress_message, proto_compiler, restricted_to, tags, target_compatible_with, testonly, toolchains, visibility)

Arguments

Attributes
`name`	Name; required A unique name for this target.
`command_line`	String; default is `"--descriptor_set_out=%s"`
`mnemonic`	String; default is `"GenProtoDescriptorSet"`
`output_files`	String; default is `"single"`
`progress_message`	String; default is `"Generating Descriptor Set proto_library %{label}"`
`proto_compiler`	Label; default is `None`

​Rules

​cc_proto_library

​Arguments

​java_lite_proto_library

​Arguments

​java_proto_library

​Arguments

​proto_library

​Arguments

​py_proto_library

​Arguments

​proto_lang_toolchain

​Examples

​Arguments

​proto_toolchain

​Arguments

Rules

cc_proto_library

Arguments

java_lite_proto_library

Arguments

java_proto_library

Arguments

proto_library

Arguments

py_proto_library

Arguments

proto_lang_toolchain

Examples

Arguments

proto_toolchain

Arguments