load("@bazel_skylib//lib:versions.bzl", "versions") load("@rules_cc//cc:defs.bzl", "objc_library") load("@rules_python//python:defs.bzl", "py_library") load("//bazel/common:proto_info.bzl", "ProtoInfo") def _GetPath(ctx, path): if ctx.label.workspace_root: return ctx.label.workspace_root + "/" + path else: return path def _IsNewExternal(ctx): # Bazel 0.4.4 and older have genfiles paths that look like: # bazel-out/local-fastbuild/genfiles/external/repo/foo # After the exec root rearrangement, they look like: # ../repo/bazel-out/local-fastbuild/genfiles/foo return ctx.label.workspace_root.startswith("../") def _GenDir(ctx): if _IsNewExternal(ctx): # We are using the fact that Bazel 0.4.4+ provides repository-relative paths # for ctx.genfiles_dir. return ctx.genfiles_dir.path + ( "/" + ctx.attr.includes[0] if ctx.attr.includes and ctx.attr.includes[0] else "" ) # This means that we're either in the old version OR the new version in the local repo. # Either way, appending the source path to the genfiles dir works. return ctx.var["GENDIR"] + "/" + _SourceDir(ctx) def _SourceDir(ctx): if not ctx.attr.includes: return ctx.label.workspace_root if not ctx.attr.includes[0]: return _GetPath(ctx, ctx.label.package) if not ctx.label.package: return _GetPath(ctx, ctx.attr.includes[0]) return _GetPath(ctx, ctx.label.package + "/" + ctx.attr.includes[0]) def _ObjcBase(srcs): return [ "".join([token.capitalize() for token in src[:-len(".proto")].split("_")]) for src in srcs ] def _ObjcHdrs(srcs): return [src + ".pbobjc.h" for src in _ObjcBase(srcs)] def _ObjcSrcs(srcs): return [src + ".pbobjc.m" for src in _ObjcBase(srcs)] def _ObjcOuts(srcs, out_type): if out_type == "hdrs": return _ObjcHdrs(srcs) if out_type == "srcs": return _ObjcSrcs(srcs) return _ObjcHdrs(srcs) + _ObjcSrcs(srcs) def _PyOuts(srcs, use_grpc_plugin = False): ret = [s[:-len(".proto")] + "_pb2.py" for s in srcs] if use_grpc_plugin: ret += [s[:-len(".proto")] + "_pb2_grpc.py" for s in srcs] return ret def _RubyOuts(srcs): return [s[:-len(".proto")] + "_pb.rb" for s in srcs] def _CsharpOuts(srcs): return [ "".join([token.capitalize() for token in src[:-len(".proto")].split("_")]) + ".cs" for src in srcs ] ProtoGenInfo = provider( fields = ["srcs", "import_flags", "deps"], ) def _proto_gen_impl(ctx): """General implementation for generating protos""" srcs = ctx.files.srcs langs = ctx.attr.langs or [] out_type = ctx.attr.out_type enable_editions = ctx.attr.enable_editions deps = depset(direct = ctx.files.srcs) source_dir = _SourceDir(ctx) gen_dir = _GenDir(ctx).rstrip("/") import_flags = [] if source_dir: has_sources = any([src.is_source for src in srcs]) if has_sources: import_flags += ["-I" + source_dir] else: import_flags += ["-I."] has_generated = any([not src.is_source for src in srcs]) if has_generated: import_flags += ["-I" + gen_dir] if ctx.attr.includes: for include in ctx.attr.includes: import_flags += ["-I" + _GetPath(ctx, include)] import_flags = depset(direct = import_flags) for dep in ctx.attr.deps: dep_proto = dep[ProtoGenInfo] if type(dep_proto.import_flags) == "list": import_flags = depset( transitive = [import_flags], direct = dep_proto.import_flags, ) else: import_flags = depset( transitive = [import_flags, dep_proto.import_flags], ) if type(dep_proto.deps) == "list": deps = depset(transitive = [deps], direct = dep_proto.deps) else: deps = depset(transitive = [deps, dep_proto.deps]) if not langs and not ctx.executable.plugin: return [ ProtoGenInfo( srcs = srcs, import_flags = import_flags, deps = deps, ), ] generated_files = [] for src in srcs: args = [] if enable_editions: args.append("--experimental_editions") in_gen_dir = src.root.path == gen_dir if in_gen_dir: import_flags_real = [] for f in import_flags.to_list(): path = f.replace("-I", "") import_flags_real.append("-I$(realpath -s %s)" % path) use_grpc_plugin = (ctx.attr.plugin_language == "grpc" and ctx.attr.plugin) path_tpl = "$(realpath %s)" if in_gen_dir else "%s" outs = [] for lang in langs: if lang == "csharp": outs.extend(_CsharpOuts([src.basename])) elif lang == "objc": outs.extend(_ObjcOuts([src.basename], out_type = out_type)) elif lang == "python": outs.extend(_PyOuts([src.basename], use_grpc_plugin = use_grpc_plugin)) elif lang == "ruby": outs.extend(_RubyOuts([src.basename])) # Otherwise, rely on user-supplied outs. args += [("--%s_out=" + path_tpl) % (lang, gen_dir)] if ctx.attr.outs: outs.extend(ctx.attr.outs) outs = [ctx.actions.declare_file(out, sibling = src) for out in outs] generated_files.extend(outs) inputs = [src] + deps.to_list() tools = [ctx.executable.protoc] if ctx.executable.plugin: plugin = ctx.executable.plugin lang = ctx.attr.plugin_language if not lang and plugin.basename.startswith("protoc-gen-"): lang = plugin.basename[len("protoc-gen-"):] if not lang: fail("cannot infer the target language of plugin", "plugin_language") outdir = "." if in_gen_dir else gen_dir if ctx.attr.plugin_options: outdir = ",".join(ctx.attr.plugin_options) + ":" + outdir args += [("--plugin=protoc-gen-%s=" + path_tpl) % (lang, plugin.path)] args += ["--%s_out=%s" % (lang, outdir)] tools.append(plugin) if not in_gen_dir: ctx.actions.run( inputs = inputs, tools = tools, outputs = outs, arguments = args + import_flags.to_list() + [src.path], executable = ctx.executable.protoc, mnemonic = "ProtoCompile", use_default_shell_env = True, ) else: for out in outs: orig_command = " ".join( ["$(realpath %s)" % ctx.executable.protoc.path] + args + import_flags_real + [src.basename], ) command = ";".join([ 'CMD="%s"' % orig_command, "cd %s" % src.dirname, "${CMD}", "cd -", ]) generated_out = "/".join([gen_dir, out.basename]) if generated_out != out.path: command += ";mv %s %s" % (generated_out, out.path) ctx.actions.run_shell( inputs = inputs, outputs = [out], command = command, mnemonic = "ProtoCompile", tools = tools, use_default_shell_env = True, ) return [ ProtoGenInfo( srcs = srcs, import_flags = import_flags, deps = deps, ), DefaultInfo(files = depset(generated_files)), ] """Generates codes from Protocol Buffers definitions. This rule helps you to implement Skylark macros specific to the target language. You should prefer more specific `cc_proto_library `, `py_proto_library` and others unless you are adding such wrapper macros. Args: srcs: Protocol Buffers definition files (.proto) to run the protocol compiler against. deps: a list of dependency labels; must be other proto libraries. enable_editions: if true, sets the --experimental_editions flag. includes: a list of include paths to .proto files. protoc: the label of the protocol compiler to generate the sources. plugin: the label of the protocol compiler plugin to be passed to the protocol compiler. plugin_language: the language of the generated sources plugin_options: a list of options to be passed to the plugin langs: generates sources in addition to the ones from the plugin for each specified language. outs: a list of labels of the expected outputs from the protocol compiler. out_type: only generated a single type of source file for languages that have split sources (e.g. *.h and *.cc in C++) """ _proto_gen = rule( attrs = { "srcs": attr.label_list(allow_files = True), "deps": attr.label_list(providers = [ProtoGenInfo]), "enable_editions": attr.bool(), "includes": attr.string_list(), "protoc": attr.label( cfg = "exec", executable = True, allow_single_file = True, mandatory = True, ), "plugin": attr.label( cfg = "exec", allow_files = True, executable = True, ), "plugin_language": attr.string(), "plugin_options": attr.string_list(), "langs": attr.string_list(), "outs": attr.string_list(), "out_type": attr.string( default = "all", ), }, implementation = _proto_gen_impl, ) def _internal_gen_well_known_protos_java_impl(ctx): args = ctx.actions.args() deps = [d[ProtoInfo] for d in ctx.attr.deps] srcjar = ctx.actions.declare_file("{}.srcjar".format(ctx.attr.name)) if ctx.attr.javalite: java_out = "lite:%s" % srcjar.path else: java_out = srcjar args.add("--java_out", java_out) descriptors = depset( transitive = [dep.transitive_descriptor_sets for dep in deps], ) args.add_joined( "--descriptor_set_in", descriptors, join_with = ctx.configuration.host_path_separator, ) for dep in deps: if "." == dep.proto_source_root: args.add_all([src.path for src in dep.direct_sources]) else: source_root = dep.proto_source_root offset = len(source_root) + 1 # + '/'. args.add_all([src.path[offset:] for src in dep.direct_sources]) ctx.actions.run( executable = ctx.executable._protoc, inputs = descriptors, outputs = [srcjar], arguments = [args], mnemonic = "ProtoCompile", use_default_shell_env = True, ) return [ DefaultInfo( files = depset([srcjar]), ), ] internal_gen_well_known_protos_java = rule( implementation = _internal_gen_well_known_protos_java_impl, attrs = { "deps": attr.label_list( mandatory = True, providers = [ProtoInfo], ), "javalite": attr.bool( default = False, ), "_protoc": attr.label( executable = True, cfg = "exec", default = "//:protoc", ), }, ) def _internal_gen_kt_protos(ctx): args = ctx.actions.args() deps = [d[ProtoInfo] for d in ctx.attr.deps] srcjar = ctx.actions.declare_file("{}.srcjar".format(ctx.attr.name)) if ctx.attr.lite: out = "lite:%s" % srcjar.path else: out = srcjar args.add("--kotlin_out", out) descriptors = depset( transitive = [dep.transitive_descriptor_sets for dep in deps], ) args.add_joined( "--descriptor_set_in", descriptors, join_with = ctx.configuration.host_path_separator, ) for dep in deps: if "." == dep.proto_source_root: args.add_all([src.path for src in dep.direct_sources]) else: source_root = dep.proto_source_root offset = len(source_root) + 1 # + '/'. args.add_all([src.path[offset:] for src in dep.direct_sources]) ctx.actions.run( executable = ctx.executable._protoc, inputs = descriptors, outputs = [srcjar], arguments = [args], mnemonic = "ProtoCompile", use_default_shell_env = True, ) return [ DefaultInfo( files = depset([srcjar]), ), ] internal_gen_kt_protos = rule( implementation = _internal_gen_kt_protos, attrs = { "deps": attr.label_list( mandatory = True, providers = [ProtoInfo], ), "lite": attr.bool( default = False, ), "_protoc": attr.label( executable = True, cfg = "exec", default = "//:protoc", ), }, ) def internal_objc_proto_library( name, srcs = [], deps = [], outs = [], proto_deps = [], includes = ["."], default_runtime = Label("//:protobuf_objc"), protoc = Label("//:protoc"), testonly = None, visibility = ["//visibility:public"], **kwargs): """Bazel rule to create a Objective-C protobuf library from proto sources NOTE: the rule is only an internal workaround to generate protos. The interface may change and the rule may be removed when bazel has introduced the native rule. Args: name: the name of the objc_proto_library. srcs: the .proto files to compile. deps: a list of dependency labels; must be objc_proto_library. outs: a list of expected output files. proto_deps: a list of proto file dependencies that don't have a objc_proto_library rule. includes: a string indicating the include path of the .proto files. default_runtime: the Objective-C Protobuf runtime protoc: the label of the protocol compiler to generate the sources. testonly: common rule attribute (see: https://bazel.build/reference/be/common-definitions#common-attributes) visibility: the visibility of the generated files. **kwargs: other keyword arguments that are passed to py_library. """ full_deps = [d + "_genproto" for d in deps] if proto_deps: _proto_gen( name = name + "_deps_genproto", testonly = testonly, srcs = proto_deps, protoc = protoc, includes = includes, ) full_deps.append(":%s_deps_genproto" % name) # Note: we need to run the protoc build twice to get separate targets for # the generated header and the source files. _proto_gen( name = name + "_genproto_hdrs", srcs = srcs, deps = full_deps, langs = ["objc"], out_type = "hdrs", includes = includes, protoc = protoc, testonly = testonly, visibility = visibility, tags = ["manual"], ) _proto_gen( name = name + "_genproto", srcs = srcs, deps = full_deps, langs = ["objc"], out_type = "srcs", includes = includes, protoc = protoc, testonly = testonly, visibility = visibility, tags = ["manual"], ) objc_library( name = name, hdrs = [name + "_genproto_hdrs"], non_arc_srcs = [name + "_genproto"], deps = [default_runtime], includes = includes, testonly = testonly, visibility = visibility, # Don't auto-expand these targets until target_compatible_with # works. See https://github.com/bazelbuild/bazel/issues/12897. tags = ["manual"], target_compatible_with = ["@platforms//os:osx"], **kwargs ) def internal_ruby_proto_library( name, ruby_library, srcs = [], deps = [], includes = ["."], default_runtime = "@com_google_protobuf//ruby:protobuf", protoc = "@com_google_protobuf//:protoc", testonly = None, visibility = ["//visibility:public"], **kwargs): """Bazel rule to create a Ruby protobuf library from proto source files NOTE: the rule is only an internal workaround to generate protos. The interface may change and the rule may be removed when bazel has introduced the native rule. Args: name: the name of the ruby_proto_library. ruby_library: the ruby library rules to use. srcs: the .proto files to compile. deps: a list of dependency labels; must be a internal_ruby_proto_library. includes: a string indicating the include path of the .proto files. default_runtime: the RubyProtobuf runtime protoc: the label of the protocol compiler to generate the sources. testonly: common rule attribute (see: https://bazel.build/reference/be/common-definitions#common-attributes) visibility: the visibility of the generated files. **kwargs: other keyword arguments that are passed to ruby_library. """ # Note: we need to run the protoc build twice to get separate targets for # the generated header and the source files. _proto_gen( name = name + "_genproto", srcs = srcs, deps = [s + "_genproto" for s in deps], langs = ["ruby"], includes = includes, protoc = protoc, testonly = testonly, visibility = visibility, tags = ["manual"], ) deps = [] if default_runtime: deps.append(default_runtime) ruby_library( name = name, srcs = [name + "_genproto"], deps = deps, testonly = testonly, visibility = visibility, includes = includes, **kwargs ) # When canonical labels are in use, use additional "@" prefix _canonical_label_prefix = "@" if str(Label("//:protoc")).startswith("@@") else "" def _to_label(label_str): """Converts a string to a label using the repository of the calling thread""" if type(label_str) == type(Label("//:foo")): return label_str return Label(_canonical_label_prefix + native.repository_name() + "//" + native.package_name() + ":foo").relative(label_str) def internal_py_proto_library( name, srcs = [], deps = [], py_libs = [], py_extra_srcs = [], include = None, default_runtime = Label("//:protobuf_python"), protoc = Label("//:protoc"), use_grpc_plugin = False, testonly = None, **kargs): """Bazel rule to create a Python protobuf library from proto source files NOTE: the rule is only an internal workaround to generate protos. The interface may change and the rule may be removed when bazel has introduced the native rule. Args: name: the name of the py_proto_library. srcs: the .proto files of the py_proto_library. deps: a list of dependency labels; must be py_proto_library. py_libs: a list of other py_library targets depended by the generated py_library. py_extra_srcs: extra source files that will be added to the output py_library. This attribute is used for internal bootstrapping. include: a string indicating the include path of the .proto files. default_runtime: the implicitly default runtime which will be depended on by the generated py_library target. protoc: the label of the protocol compiler to generate the sources. use_grpc_plugin: a flag to indicate whether to call the Python C++ plugin when processing the proto files. testonly: common rule attribute (see: https://bazel.build/reference/be/common-definitions#common-attributes) **kargs: other keyword arguments that are passed to py_library. """ includes = [] if include != None: includes = [include] grpc_python_plugin = None if use_grpc_plugin: grpc_python_plugin = "//external:grpc_python_plugin" # Note: Generated grpc code depends on Python grpc module. This dependency # is not explicitly listed in py_libs. Instead, host system is assumed to # have grpc installed. _proto_gen( name = name + "_genproto", testonly = testonly, srcs = srcs, deps = [s + "_genproto" for s in deps], includes = includes, protoc = protoc, langs = ["python"], visibility = ["//visibility:public"], plugin = grpc_python_plugin, plugin_language = "grpc", ) if default_runtime: # Resolve non-local labels labels = [_to_label(lib) for lib in py_libs + deps] if not _to_label(default_runtime) in labels: py_libs = py_libs + [default_runtime] py_library( name = name, testonly = testonly, srcs = [name + "_genproto"] + py_extra_srcs, deps = py_libs + deps, imports = includes, **kargs ) def py_proto_library( *args, **kwargs): """Deprecated alias for use before Bazel 5.3. Args: *args: the name of the py_proto_library. **kwargs: other keyword arguments that are passed to py_library. Deprecated: This is provided for backwards compatibility only. Bazel 5.3 will introduce support for py_proto_library, which should be used instead. """ internal_py_proto_library(*args, **kwargs) def _source_proto_library( name, srcs = [], deps = [], proto_deps = [], outs = [], lang = None, includes = ["."], protoc = Label("//:protoc"), testonly = None, visibility = ["//visibility:public"], enable_editions = False, **kwargs): """Bazel rule to create generated protobuf code from proto source files for languages not well supported by Bazel yet. This will output the generated code as-is without any compilation. This is most useful for interpreted languages that don't require it. NOTE: the rule is only an internal workaround to generate protos. The interface may change and the rule may be removed when bazel has introduced the native rule. Args: name: the name of the unsupported_proto_library. srcs: the .proto files to compile. Note, that for languages where out needs to be provided, only a single source file is allowed. deps: a list of dependency labels; must be unsupported_proto_library. proto_deps: a list of proto file dependencies that don't have a unsupported_proto_library rule. lang: the language to (optionally) generate code for. outs: a list of expected output files. This is only required for languages where we can't predict the outputs. includes: strings indicating the include path of the .proto files. protoc: the label of the protocol compiler to generate the sources. testonly: common rule attribute (see: https://bazel.build/reference/be/common-definitions#common-attributes) visibility: the visibility of the generated files. **kwargs: other keyword arguments that are passed to py_library. """ if outs and len(srcs) != 1: fail("Custom outputs only allowed for single proto targets.") langs = [] if lang != None: langs = [lang] full_deps = [d + "_genproto" for d in deps] if proto_deps: _proto_gen( name = name + "_deps_genproto", testonly = testonly, srcs = proto_deps, protoc = protoc, includes = includes, enable_editions = enable_editions, ) full_deps.append(":%s_deps_genproto" % name) _proto_gen( name = name + "_genproto", srcs = srcs, deps = full_deps, langs = langs, outs = outs, includes = includes, protoc = protoc, testonly = testonly, visibility = visibility, enable_editions = enable_editions, ) native.filegroup( name = name, srcs = [":%s_genproto" % name], testonly = testonly, visibility = visibility, **kwargs ) def internal_csharp_proto_library(**kwargs): """Bazel rule to create a C# protobuf library from proto source files NOTE: the rule is only an internal workaround to generate protos. The interface may change and the rule may be removed when bazel has introduced the native rule. Args: **kwargs: arguments that are passed to unsupported_proto_library. """ _source_proto_library( lang = "csharp", **kwargs ) def internal_php_proto_library(**kwargs): """Bazel rule to create a PHP protobuf library from proto source files NOTE: the rule is only an internal workaround to generate protos. The interface may change and the rule may be removed when bazel has introduced the native rule. Args: **kwargs: arguments that are passed to unsupported_proto_library. """ if not kwargs.get("outs"): fail("Unable to predict the outputs for php_proto_library. Please specify them via `outs`.") _source_proto_library( lang = "php", **kwargs ) def check_protobuf_required_bazel_version(): """For WORKSPACE files, to check the installed version of bazel. This ensures bazel supports our approach to proto_library() depending on a copied filegroup. (Fixed in bazel 0.5.4) """ versions.check(minimum_bazel_version = "0.5.4")