# -*- mode: python; -*- PYTHON-PREPROCESSING-REQUIRED def _GetPath(ctx, path): if ctx.label.workspace_root: return ctx.label.workspace_root + '/' + path else: return path def _GenDir(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 _CcOuts(srcs, use_grpc_plugin=False): ret = [s[:-len(".proto")] + ".pb.h" for s in srcs] + \ [s[:-len(".proto")] + ".pb.cc" for s in srcs] if use_grpc_plugin: ret += [s[:-len(".proto")] + ".grpc.pb.h" for s in srcs] + \ [s[:-len(".proto")] + ".grpc.pb.cc" for s in srcs] return ret def _PyOuts(srcs): return [s[:-len(".proto")] + "_pb2.py" for s in srcs] def _RelativeOutputPath(path, include): if include == None: return path if not path.startswith(include): fail("Include path %s isn't part of the path %s." % (include, path)) if include and include[-1] != '/': include = include + '/' path = path[len(include):] if not path.startswith(PACKAGE_NAME): fail("The package %s is not within the path %s" % (PACKAGE_NAME, path)) if not PACKAGE_NAME: return path return path[len(PACKAGE_NAME)+1:] def _proto_gen_impl(ctx): """General implementation for generating protos""" srcs = ctx.files.srcs deps = [] deps += ctx.files.srcs gen_dir = _GenDir(ctx) if gen_dir: import_flags = ["-I" + gen_dir] else: import_flags = ["-I."] for dep in ctx.attr.deps: import_flags += dep.proto.import_flags deps += dep.proto.deps args = [] if ctx.attr.gen_cc: args += ["--cpp_out=" + ctx.var["GENDIR"] + "/" + gen_dir] if ctx.attr.gen_py: args += ["--python_out=" + ctx.var["GENDIR"] + "/" + gen_dir] if ctx.executable.grpc_cpp_plugin: args += ["--plugin=protoc-gen-grpc=" + ctx.executable.grpc_cpp_plugin.path] args += ["--grpc_out=" + ctx.var["GENDIR"] + "/" + gen_dir] if args: ctx.action( inputs=srcs + deps, outputs=ctx.outputs.outs, arguments=args + import_flags + [s.path for s in srcs], executable=ctx.executable.protoc, ) return struct( proto=struct( srcs=srcs, import_flags=import_flags, deps=deps, ), ) _proto_gen = rule( attrs = { "srcs": attr.label_list(allow_files = True), "deps": attr.label_list(providers = ["proto"]), "includes": attr.string_list(), "protoc": attr.label( cfg = HOST_CFG, executable = True, single_file = True, mandatory = True, ), "grpc_cpp_plugin": attr.label( cfg = HOST_CFG, executable = True, single_file = True, ), "gen_cc": attr.bool(), "gen_py": attr.bool(), "outs": attr.output_list(), }, output_to_genfiles = True, implementation = _proto_gen_impl, ) def cc_proto_library( name, srcs=[], deps=[], cc_libs=[], include=None, protoc="//:protoc", internal_bootstrap_hack=False, use_grpc_plugin=False, default_runtime="//:protobuf", **kargs): """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: name: the name of the cc_proto_library. srcs: the .proto files of the cc_proto_library. deps: a list of dependency labels; must be cc_proto_library. cc_libs: a list of other cc_library targets depended by the generated cc_library. include: a string indicating the include path of the .proto files. protoc: the label of the protocol compiler to generate the sources. internal_bootstrap_hack: a flag indicate the cc_proto_library is used only for bootstraping. When it is set to True, no files will be generated. The rule will simply be a provider for .proto files, so that other cc_proto_library can depend on it. use_grpc_plugin: a flag to indicate whether to call the grpc C++ plugin when processing the proto files. default_runtime: the implicitly default runtime which will be depended on by the generated cc_library target. **kargs: other keyword arguments that are passed to cc_library. """ includes = [] if include != None: includes = [include] if internal_bootstrap_hack: # For pre-checked-in generated files, we add the internal_bootstrap_hack # which will skip the codegen action. _proto_gen( name=name + "_genproto", srcs=srcs, deps=[s + "_genproto" for s in deps], includes=includes, protoc=protoc, visibility=["//visibility:public"], ) # An empty cc_library to make rule dependency consistent. native.cc_library( name=name, **kargs) return grpc_cpp_plugin = None if use_grpc_plugin: grpc_cpp_plugin = "//external:grpc_cpp_plugin" outs = _CcOuts(srcs, use_grpc_plugin) _proto_gen( name=name + "_genproto", srcs=srcs, deps=[s + "_genproto" for s in deps], includes=includes, protoc=protoc, grpc_cpp_plugin=grpc_cpp_plugin, gen_cc=1, outs=outs, visibility=["//visibility:public"], ) if default_runtime and not default_runtime in cc_libs: cc_libs += [default_runtime] if use_grpc_plugin: cc_libs += ["//external:grpc_lib"] native.cc_library( name=name, srcs=outs, deps=cc_libs + deps, includes=includes, **kargs) def internal_gen_well_known_protos_java(srcs): """Bazel rule to generate the gen_well_known_protos_java genrule Args: srcs: the well known protos """ root = Label("%s//protobuf_java" % (REPOSITORY_NAME)).workspace_root if root == "": include = " -Isrc " else: include = " -I%s/src " % root native.genrule( name = "gen_well_known_protos_java", srcs = srcs, outs = [ "wellknown.srcjar", ], cmd = "$(location :protoc) --java_out=$(@D)/wellknown.jar" + " %s $(SRCS) " % include + " && mv $(@D)/wellknown.jar $(@D)/wellknown.srcjar", tools = [":protoc"], ) def py_proto_library( name, srcs=[], deps=[], py_libs=[], py_extra_srcs=[], include=None, default_runtime="//:protobuf_python", protoc="//:protoc", **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. **kargs: other keyword arguments that are passed to cc_library. """ outs = _PyOuts(srcs) includes = [] if include != None: includes = [include] _proto_gen( name=name + "_genproto", srcs=srcs, deps=[s + "_genproto" for s in deps], includes=includes, protoc=protoc, gen_py=1, outs=outs, visibility=["//visibility:public"], ) if default_runtime and not default_runtime in py_libs + deps: py_libs += [default_runtime] native.py_library( name=name, srcs=outs+py_extra_srcs, deps=py_libs+deps, imports=includes, **kargs) def internal_protobuf_py_tests( name, modules=[], **kargs): """Bazel rules to create batch tests for protobuf internal. Args: name: the name of the rule. modules: a list of modules for tests. The macro will create a py_test for each of the parameter with the source "google/protobuf/%s.py" kargs: extra parameters that will be passed into the py_test. """ for m in modules: s = "python/google/protobuf/internal/%s.py" % m native.py_test( name="py_%s" % m, srcs=[s], main=s, **kargs)