|
|
|
# Copyright 2016 gRPC authors.
|
|
|
|
#
|
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
# you may not use this file except in compliance with the License.
|
|
|
|
# You may obtain a copy of the License at
|
|
|
|
#
|
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
#
|
|
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
# See the License for the specific language governing permissions and
|
|
|
|
# limitations under the License.
|
|
|
|
|
|
|
|
#
|
|
|
|
# This is for the gRPC build system. This isn't intended to be used outsite of
|
|
|
|
# the BUILD file for gRPC. It contains the mapping for the template system we
|
|
|
|
# use to generate other platform's build system files.
|
|
|
|
#
|
|
|
|
# Please consider that there should be a high bar for additions and changes to
|
|
|
|
# this file.
|
|
|
|
# Each rule listed must be re-written for Google's internal build system, and
|
|
|
|
# each change must be ported from one to the other.
|
|
|
|
#
|
|
|
|
|
|
|
|
"""
|
|
|
|
Contains macros used throughout the repo.
|
|
|
|
"""
|
|
|
|
|
|
|
|
load("//bazel:cc_grpc_library.bzl", "cc_grpc_library")
|
|
|
|
load("//bazel:copts.bzl", "GRPC_DEFAULT_COPTS")
|
|
|
|
load("//bazel:experiments.bzl", "EXPERIMENTS")
|
|
|
|
load("@upb//bazel:upb_proto_library.bzl", "upb_proto_library", "upb_proto_reflection_library")
|
|
|
|
load("@build_bazel_rules_apple//apple:ios.bzl", "ios_unit_test")
|
|
|
|
load("@build_bazel_rules_apple//apple/testing/default_runner:ios_test_runner.bzl", "ios_test_runner")
|
|
|
|
|
|
|
|
# The set of pollers to test against if a test exercises polling
|
|
|
|
POLLERS = ["epoll1", "poll"]
|
|
|
|
|
|
|
|
# The set of known EventEngines to test
|
|
|
|
EVENT_ENGINES = {"default": {"tags": []}}
|
|
|
|
|
|
|
|
def if_not_windows(a):
|
|
|
|
return select({
|
|
|
|
"//:windows": [],
|
|
|
|
"//:windows_msvc": [],
|
|
|
|
"//conditions:default": a,
|
|
|
|
})
|
|
|
|
|
|
|
|
def if_windows(a):
|
|
|
|
return select({
|
|
|
|
"//:windows": a,
|
|
|
|
"//:windows_msvc": a,
|
|
|
|
"//conditions:default": [],
|
|
|
|
})
|
|
|
|
|
|
|
|
def _get_external_deps(external_deps):
|
|
|
|
ret = []
|
|
|
|
for dep in external_deps:
|
|
|
|
if dep == "address_sorting":
|
|
|
|
ret.append("//third_party/address_sorting")
|
|
|
|
elif dep == "xxhash":
|
|
|
|
ret.append("//third_party/xxhash")
|
|
|
|
elif dep == "cares":
|
|
|
|
ret += select({
|
|
|
|
"//:grpc_no_ares": [],
|
|
|
|
"//conditions:default": ["//external:cares"],
|
|
|
|
})
|
|
|
|
elif dep == "cronet_c_for_grpc":
|
|
|
|
ret.append("//third_party/objective_c/Cronet:cronet_c_for_grpc")
|
|
|
|
elif dep.startswith("absl/"):
|
|
|
|
ret.append("@com_google_absl//" + dep)
|
|
|
|
elif dep.startswith("google/"):
|
|
|
|
ret.append("@com_google_googleapis//" + dep)
|
|
|
|
else:
|
|
|
|
ret.append("//external:" + dep)
|
|
|
|
return ret
|
|
|
|
|
|
|
|
def _update_visibility(visibility):
|
|
|
|
if visibility == None:
|
|
|
|
return None
|
|
|
|
|
|
|
|
# Visibility rules prefixed with '@grpc:' are used to flag different visibility rule
|
|
|
|
# classes upstream.
|
|
|
|
PUBLIC = ["//visibility:public"]
|
|
|
|
PRIVATE = ["//:__subpackages__"]
|
|
|
|
VISIBILITY_TARGETS = {
|
|
|
|
"alt_grpc++_base_legacy": PRIVATE,
|
|
|
|
"alt_grpc_base_legacy": PRIVATE,
|
|
|
|
"alt_grpc++_base_unsecure_legacy": PRIVATE,
|
|
|
|
"alts_frame_protector": PRIVATE,
|
|
|
|
"channelz": PRIVATE,
|
|
|
|
"client_channel": PRIVATE,
|
|
|
|
"cli": PRIVATE,
|
|
|
|
"debug_location": PRIVATE,
|
|
|
|
"endpoint_tests": PRIVATE,
|
|
|
|
"exec_ctx": PRIVATE,
|
|
|
|
"grpclb": PRIVATE,
|
|
|
|
"grpc_opencensus_plugin": PUBLIC,
|
|
|
|
"grpcpp_gcp_observability": PUBLIC,
|
|
|
|
"grpc_resolver_fake": PRIVATE,
|
|
|
|
"grpc++_test": PRIVATE,
|
|
|
|
"http": PRIVATE,
|
|
|
|
"httpcli": PRIVATE,
|
|
|
|
"iomgr_timer": PRIVATE,
|
|
|
|
"iomgr_internal_errqueue": PRIVATE,
|
|
|
|
"iomgr_buffer_list": PRIVATE,
|
|
|
|
"json_reader_legacy": PRIVATE,
|
|
|
|
"public": PUBLIC,
|
|
|
|
"ref_counted_ptr": PRIVATE,
|
|
|
|
"trace": PRIVATE,
|
|
|
|
"tsi_interface": PRIVATE,
|
|
|
|
"tsi": PRIVATE,
|
|
|
|
"xds": PRIVATE,
|
|
|
|
"xds_client_core": PRIVATE,
|
|
|
|
}
|
|
|
|
final_visibility = []
|
|
|
|
for rule in visibility:
|
|
|
|
if rule.startswith("@grpc:"):
|
|
|
|
for replacement in VISIBILITY_TARGETS[rule[len("@grpc:"):]]:
|
|
|
|
final_visibility.append(replacement)
|
|
|
|
else:
|
|
|
|
final_visibility.append(rule)
|
|
|
|
return [x for x in final_visibility]
|
|
|
|
|
|
|
|
def grpc_cc_library(
|
|
|
|
name,
|
|
|
|
srcs = [],
|
|
|
|
public_hdrs = [],
|
|
|
|
hdrs = [],
|
|
|
|
external_deps = [],
|
|
|
|
defines = [],
|
|
|
|
deps = [],
|
|
|
|
select_deps = None,
|
|
|
|
standalone = False,
|
|
|
|
language = "C++",
|
|
|
|
testonly = False,
|
|
|
|
visibility = None,
|
|
|
|
alwayslink = 0,
|
|
|
|
data = [],
|
|
|
|
tags = [],
|
|
|
|
linkopts = [],
|
|
|
|
linkstatic = False):
|
|
|
|
"""An internal wrapper around cc_library.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
name: The name of the library.
|
|
|
|
srcs: The source files.
|
|
|
|
public_hdrs: The public headers.
|
|
|
|
hdrs: The headers.
|
|
|
|
external_deps: External depdendencies to be resolved.
|
|
|
|
defines: Build defines to use.
|
|
|
|
deps: cc_library deps.
|
|
|
|
select_deps: deps included conditionally.
|
|
|
|
standalone: Unused.
|
|
|
|
language: The language of the library, e.g. C, C++.
|
|
|
|
testonly: Whether the target is for tests only.
|
|
|
|
visibility: The visibility of the target.
|
|
|
|
alwayslink: Whether to enable alwayslink on the cc_library.
|
|
|
|
data: Data dependencies.
|
|
|
|
tags: Tags to apply to the rule.
|
|
|
|
linkopts: Extra libraries to link.
|
|
|
|
linkstatic: Whether to enable linkstatic on the cc_library.
|
|
|
|
"""
|
|
|
|
visibility = _update_visibility(visibility)
|
|
|
|
copts = []
|
|
|
|
if language.upper() == "C":
|
|
|
|
copts = copts + if_not_windows(["-std=c11"])
|
|
|
|
linkopts = linkopts + if_not_windows(["-pthread"]) + if_windows(["-defaultlib:ws2_32.lib"])
|
|
|
|
if select_deps:
|
|
|
|
for select_deps_entry in select_deps:
|
|
|
|
deps += select(select_deps_entry)
|
|
|
|
native.cc_library(
|
|
|
|
name = name,
|
|
|
|
srcs = srcs,
|
|
|
|
defines = defines +
|
|
|
|
select({
|
|
|
|
"//:grpc_no_ares": ["GRPC_ARES=0"],
|
|
|
|
"//conditions:default": [],
|
|
|
|
}) +
|
|
|
|
select({
|
|
|
|
"//:remote_execution": ["GRPC_PORT_ISOLATED_RUNTIME=1"],
|
|
|
|
"//conditions:default": [],
|
|
|
|
}) +
|
|
|
|
select({
|
|
|
|
"//:grpc_allow_exceptions": ["GRPC_ALLOW_EXCEPTIONS=1"],
|
|
|
|
"//:grpc_disallow_exceptions": ["GRPC_ALLOW_EXCEPTIONS=0"],
|
|
|
|
"//conditions:default": [],
|
|
|
|
}),
|
|
|
|
hdrs = hdrs + public_hdrs,
|
|
|
|
deps = deps + _get_external_deps(external_deps),
|
|
|
|
copts = GRPC_DEFAULT_COPTS + copts,
|
|
|
|
visibility = visibility,
|
|
|
|
testonly = testonly,
|
|
|
|
linkopts = linkopts,
|
|
|
|
includes = [
|
|
|
|
"include",
|
|
|
|
"src/core/ext/upb-generated", # Once upb code-gen issue is resolved, remove this.
|
|
|
|
"src/core/ext/upbdefs-generated", # Once upb code-gen issue is resolved, remove this.
|
|
|
|
],
|
|
|
|
alwayslink = alwayslink,
|
|
|
|
data = data,
|
|
|
|
tags = tags,
|
|
|
|
linkstatic = linkstatic,
|
|
|
|
)
|
|
|
|
|
|
|
|
def grpc_proto_plugin(name, srcs = [], deps = []):
|
|
|
|
native.cc_binary(
|
|
|
|
name = name,
|
|
|
|
srcs = srcs,
|
|
|
|
deps = deps,
|
|
|
|
)
|
|
|
|
|
|
|
|
def grpc_proto_library(
|
|
|
|
name,
|
|
|
|
srcs = [],
|
|
|
|
deps = [],
|
|
|
|
well_known_protos = False,
|
|
|
|
has_services = True,
|
|
|
|
use_external = False,
|
|
|
|
generate_mocks = False):
|
|
|
|
cc_grpc_library(
|
|
|
|
name = name,
|
|
|
|
srcs = srcs,
|
|
|
|
deps = deps,
|
|
|
|
well_known_protos = well_known_protos,
|
|
|
|
proto_only = not has_services,
|
|
|
|
use_external = use_external,
|
|
|
|
generate_mocks = generate_mocks,
|
|
|
|
)
|
|
|
|
|
|
|
|
def ios_cc_test(
|
|
|
|
name,
|
|
|
|
tags = [],
|
|
|
|
**kwargs):
|
|
|
|
"""An ios C++ test target.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
name: The name of the test.
|
|
|
|
tags: The tags to apply to the test.
|
|
|
|
**kwargs: All other arguments to apply.
|
|
|
|
"""
|
|
|
|
test_lib_ios = name + "_test_lib_ios"
|
|
|
|
ios_tags = tags + ["manual", "ios_cc_test"]
|
|
|
|
test_runner = "ios_x86_64_sim_runner_" + name
|
|
|
|
ios_test_runner(
|
|
|
|
name = test_runner,
|
|
|
|
device_type = "iPhone X",
|
|
|
|
)
|
|
|
|
if not any([t for t in tags if t.startswith("no_test_ios")]):
|
|
|
|
native.objc_library(
|
|
|
|
name = test_lib_ios,
|
|
|
|
srcs = kwargs.get("srcs"),
|
|
|
|
deps = kwargs.get("deps"),
|
|
|
|
copts = kwargs.get("copts"),
|
|
|
|
data = kwargs.get("data"),
|
|
|
|
tags = ios_tags,
|
|
|
|
alwayslink = 1,
|
|
|
|
testonly = 1,
|
|
|
|
)
|
|
|
|
ios_test_deps = [":" + test_lib_ios]
|
|
|
|
ios_unit_test(
|
|
|
|
name = name + "_on_ios",
|
|
|
|
size = kwargs.get("size"),
|
|
|
|
data = kwargs.get("data"),
|
|
|
|
tags = ios_tags,
|
|
|
|
minimum_os_version = "9.0",
|
|
|
|
runner = test_runner,
|
|
|
|
deps = ios_test_deps,
|
|
|
|
)
|
|
|
|
|
|
|
|
def expand_tests(name, srcs, deps, tags, args, exclude_pollers, uses_polling, uses_event_engine):
|
|
|
|
"""Common logic used to parameterize tests for every poller and EventEngine and experiment.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
name: base name of the test
|
|
|
|
srcs: source files
|
|
|
|
deps: base deps
|
|
|
|
tags: base tags
|
|
|
|
args: base args
|
|
|
|
exclude_pollers: list of poller names to exclude for this set of tests.
|
|
|
|
uses_polling: set to False if the test is not sensitive to polling methodology.
|
|
|
|
uses_event_engine: set to False if the test is not sensitive to
|
|
|
|
EventEngine implementation differences
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
A list of dictionaries containing modified values of name, srcs, deps, tags, and args.
|
|
|
|
"""
|
|
|
|
poller_config = []
|
|
|
|
|
|
|
|
if not uses_polling:
|
|
|
|
tags = tags + ["no_uses_polling"]
|
|
|
|
|
|
|
|
poller_config.append({
|
|
|
|
"name": name,
|
|
|
|
"srcs": srcs,
|
|
|
|
"deps": deps,
|
|
|
|
"tags": tags,
|
|
|
|
"args": args,
|
|
|
|
"env": {},
|
|
|
|
})
|
|
|
|
else:
|
|
|
|
# On linux we run the same test with the default EventEngine, once for each
|
|
|
|
# poller
|
|
|
|
for poller in POLLERS:
|
|
|
|
if poller in exclude_pollers:
|
|
|
|
continue
|
|
|
|
poller_config.append({
|
|
|
|
"name": name + "@poller=" + poller,
|
|
|
|
"srcs": srcs,
|
|
|
|
"deps": deps,
|
|
|
|
"tags": (tags + EVENT_ENGINES["default"]["tags"] + [
|
|
|
|
"no_windows",
|
|
|
|
"no_mac",
|
|
|
|
"bazel_only",
|
|
|
|
]),
|
|
|
|
"args": args,
|
|
|
|
"env": {
|
|
|
|
"GRPC_POLL_STRATEGY": poller,
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
|
|
|
# Now generate one test for each subsequent EventEngine, all using the
|
|
|
|
# default poller. These tests will have `@engine=<name>` appended to the
|
|
|
|
# test target name. If a test target name has no `@engine=<name>` component,
|
|
|
|
# that indicates that the default EventEngine is being used.
|
|
|
|
if not uses_event_engine:
|
|
|
|
# The poller tests exercise the default engine on Linux. This test
|
|
|
|
# handles other platforms.
|
|
|
|
poller_config.append({
|
|
|
|
"name": name,
|
|
|
|
"srcs": srcs,
|
|
|
|
"deps": deps,
|
|
|
|
"tags": tags + ["no_linux"],
|
|
|
|
"args": args,
|
|
|
|
"env": {},
|
|
|
|
})
|
|
|
|
else:
|
|
|
|
for engine_name, engine in EVENT_ENGINES.items():
|
|
|
|
test_name = name + "@engine=" + engine_name
|
|
|
|
test_tags = tags + engine["tags"] + ["bazel_only"]
|
|
|
|
test_args = args + ["--engine=" + engine_name]
|
|
|
|
if engine_name == "default":
|
|
|
|
# The poller tests exercise the default engine on Linux.
|
|
|
|
# This test handles other platforms.
|
|
|
|
test_name = name
|
|
|
|
test_tags = tags + engine["tags"] + ["no_linux"]
|
|
|
|
test_args = args
|
|
|
|
poller_config.append({
|
|
|
|
"name": test_name,
|
|
|
|
"srcs": srcs,
|
|
|
|
"deps": deps,
|
|
|
|
"tags": test_tags,
|
|
|
|
"args": test_args,
|
|
|
|
"env": {},
|
|
|
|
})
|
|
|
|
|
|
|
|
experiments = {}
|
|
|
|
for mode, tag_to_experiments in EXPERIMENTS.items():
|
|
|
|
experiments[mode] = {}
|
|
|
|
for tag in tags:
|
|
|
|
if tag not in tag_to_experiments:
|
|
|
|
continue
|
|
|
|
for experiment in tag_to_experiments[tag]:
|
|
|
|
experiments[mode][experiment] = 1
|
|
|
|
experiments[mode] = list(experiments[mode].keys())
|
|
|
|
|
|
|
|
mode_config = {
|
|
|
|
# format: <mode>: (enabled_target_tags, disabled_target_tags)
|
|
|
|
"dbg": (["noopt"], ["nodbg"]),
|
|
|
|
"opt": (["nodbg"], ["noopt"]),
|
|
|
|
"on": (None, []),
|
|
|
|
"off": ([], None),
|
|
|
|
}
|
|
|
|
|
|
|
|
must_have_tags = [
|
|
|
|
# We don't run experiments on cmake builds
|
|
|
|
"bazel_only",
|
|
|
|
# Nor on windows
|
|
|
|
"no_windows",
|
|
|
|
# Nor on mac
|
|
|
|
"no_mac",
|
|
|
|
# Nor on arm64
|
|
|
|
"no_arm64",
|
|
|
|
]
|
|
|
|
experiment_config = list(poller_config)
|
|
|
|
for mode, config in mode_config.items():
|
|
|
|
enabled_tags, disabled_tags = config
|
|
|
|
if enabled_tags != None:
|
|
|
|
for experiment in experiments[mode]:
|
|
|
|
for config in poller_config:
|
|
|
|
config = dict(config)
|
|
|
|
config["name"] = config["name"] + "@experiment=" + experiment
|
|
|
|
env = dict(config["env"])
|
|
|
|
env["GRPC_EXPERIMENTS"] = experiment
|
|
|
|
config["env"] = env
|
|
|
|
tags = config["tags"]
|
|
|
|
for tag in must_have_tags + enabled_tags:
|
|
|
|
if tag not in tags:
|
|
|
|
tags = tags + [tag]
|
|
|
|
config["tags"] = tags
|
|
|
|
experiment_config.append(config)
|
|
|
|
if disabled_tags != None:
|
|
|
|
for experiment in experiments[mode]:
|
|
|
|
for config in poller_config:
|
|
|
|
config = dict(config)
|
|
|
|
config["name"] = config["name"] + "@experiment=no_" + experiment
|
|
|
|
env = dict(config["env"])
|
|
|
|
env["GRPC_EXPERIMENTS"] = "-" + experiment
|
|
|
|
config["env"] = env
|
|
|
|
tags = config["tags"]
|
|
|
|
for tag in must_have_tags + disabled_tags:
|
|
|
|
if tag not in tags:
|
|
|
|
tags = tags + [tag]
|
|
|
|
config["tags"] = tags
|
|
|
|
experiment_config.append(config)
|
|
|
|
return experiment_config
|
|
|
|
|
|
|
|
def grpc_cc_test(name, srcs = [], deps = [], external_deps = [], args = [], data = [], uses_polling = True, language = "C++", size = "medium", timeout = None, tags = [], exec_compatible_with = [], exec_properties = {}, shard_count = None, flaky = None, copts = [], linkstatic = None, exclude_pollers = [], uses_event_engine = True):
|
|
|
|
"""A cc_test target for use in the gRPC repo.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
name: The name of the test.
|
|
|
|
srcs: The source files.
|
|
|
|
deps: The target deps.
|
|
|
|
external_deps: The external deps.
|
|
|
|
args: The args to supply to the test binary.
|
|
|
|
data: Data dependencies.
|
|
|
|
uses_polling: Whether the test uses polling.
|
|
|
|
language: The language of the test, e.g C, C++.
|
|
|
|
size: The size of the test.
|
|
|
|
timeout: The test timeout.
|
|
|
|
tags: The tags for the test.
|
|
|
|
exec_compatible_with: A list of constraint values that must be
|
|
|
|
satisifed for the platform.
|
|
|
|
exec_properties: A dictionary of strings that will be added to the
|
|
|
|
exec_properties of a platform selected for this target.
|
|
|
|
shard_count: The number of shards for this test.
|
|
|
|
flaky: Whether this test is flaky.
|
|
|
|
copts: Add these to the compiler invocation.
|
|
|
|
linkstatic: link the binary in static mode
|
|
|
|
exclude_pollers: list of poller names to exclude for this set of tests.
|
|
|
|
uses_event_engine: set to False if the test is not sensitive to
|
|
|
|
EventEngine implementation differences
|
|
|
|
"""
|
|
|
|
if language.upper() == "C":
|
|
|
|
copts = copts + if_not_windows(["-std=c11"])
|
|
|
|
|
|
|
|
core_deps = deps + _get_external_deps(external_deps) + ["//test/core/util:grpc_suppressions"]
|
|
|
|
|
|
|
|
# Test args for all tests
|
|
|
|
test_args = {
|
|
|
|
"data": data,
|
|
|
|
"copts": GRPC_DEFAULT_COPTS + copts,
|
|
|
|
"linkopts": if_not_windows(["-pthread"]) + if_windows(["-defaultlib:ws2_32.lib"]),
|
|
|
|
"size": size,
|
|
|
|
"timeout": timeout,
|
|
|
|
"exec_compatible_with": exec_compatible_with,
|
|
|
|
"exec_properties": exec_properties,
|
|
|
|
"shard_count": shard_count,
|
|
|
|
"flaky": flaky,
|
|
|
|
"linkstatic": linkstatic,
|
|
|
|
}
|
|
|
|
|
|
|
|
if "grpc-fuzzer" not in tags and "no_test_ios" not in tags:
|
|
|
|
ios_cc_test(
|
|
|
|
name = name,
|
|
|
|
srcs = srcs,
|
|
|
|
tags = tags,
|
|
|
|
deps = core_deps,
|
|
|
|
args = args,
|
|
|
|
**test_args
|
|
|
|
)
|
|
|
|
|
|
|
|
for poller_config in expand_tests(name, srcs, core_deps, tags, args, exclude_pollers, uses_polling, uses_event_engine):
|
|
|
|
native.cc_test(
|
|
|
|
name = poller_config["name"],
|
|
|
|
srcs = poller_config["srcs"],
|
|
|
|
deps = poller_config["deps"],
|
|
|
|
tags = poller_config["tags"],
|
|
|
|
args = poller_config["args"],
|
|
|
|
env = poller_config["env"],
|
|
|
|
**test_args
|
|
|
|
)
|
|
|
|
|
|
|
|
def grpc_cc_binary(name, srcs = [], deps = [], external_deps = [], args = [], data = [], language = "C++", testonly = False, linkshared = False, linkopts = [], tags = [], features = [], visibility = None):
|
|
|
|
"""Generates a cc_binary for use in the gRPC repo.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
name: The name of the target.
|
|
|
|
srcs: The source files.
|
|
|
|
deps: The dependencies.
|
|
|
|
external_deps: The external dependencies.
|
|
|
|
args: The arguments to supply to the binary.
|
|
|
|
data: The data dependencies.
|
|
|
|
language: The language of the binary, e.g. C, C++.
|
|
|
|
testonly: Whether the binary is for tests only.
|
|
|
|
linkshared: Enables linkshared on the binary.
|
|
|
|
linkopts: linkopts to supply to the cc_binary.
|
|
|
|
tags: Tags to apply to the target.
|
|
|
|
features: features to be supplied to the cc_binary.
|
|
|
|
visibility: The visibility of the target.
|
|
|
|
"""
|
|
|
|
visibility = _update_visibility(visibility)
|
|
|
|
copts = []
|
|
|
|
if language.upper() == "C":
|
|
|
|
copts = ["-std=c11"]
|
|
|
|
native.cc_binary(
|
|
|
|
name = name,
|
|
|
|
srcs = srcs,
|
|
|
|
args = args,
|
|
|
|
data = data,
|
|
|
|
testonly = testonly,
|
|
|
|
linkshared = linkshared,
|
|
|
|
deps = deps + _get_external_deps(external_deps) + ["//test/core/util:grpc_suppressions"],
|
|
|
|
copts = GRPC_DEFAULT_COPTS + copts,
|
|
|
|
linkopts = if_not_windows(["-pthread"]) + linkopts,
|
|
|
|
tags = tags,
|
|
|
|
features = features,
|
|
|
|
)
|
|
|
|
|
|
|
|
# buildifier: disable=unnamed-macro
|
|
|
|
def grpc_generate_one_off_targets():
|
|
|
|
# In open-source, grpc_objc* libraries depend directly on //:grpc
|
|
|
|
native.alias(
|
|
|
|
name = "grpc_objc",
|
|
|
|
actual = "//:grpc",
|
|
|
|
)
|
|
|
|
native.config_setting(
|
|
|
|
name = "windows_other",
|
|
|
|
values = {"define": "GRPC_WINDOWS_OTHER=1"},
|
|
|
|
)
|
|
|
|
|
|
|
|
def grpc_generate_objc_one_off_targets():
|
|
|
|
pass
|
|
|
|
|
|
|
|
def grpc_sh_test(name, srcs = [], args = [], data = [], uses_polling = True, size = "medium", timeout = None, tags = [], exec_compatible_with = [], exec_properties = {}, shard_count = None, flaky = None, exclude_pollers = [], uses_event_engine = True):
|
|
|
|
"""Execute an sh_test for every <poller> x <EventEngine> combination
|
|
|
|
|
|
|
|
Args:
|
|
|
|
name: The name of the test.
|
|
|
|
srcs: The source files.
|
|
|
|
args: The args to supply to the test binary.
|
|
|
|
data: Data dependencies.
|
|
|
|
uses_polling: Whether the test uses polling.
|
|
|
|
size: The size of the test.
|
|
|
|
timeout: The test timeout.
|
|
|
|
tags: The tags for the test.
|
|
|
|
exec_compatible_with: A list of constraint values that must be
|
|
|
|
satisifed for the platform.
|
|
|
|
exec_properties: A dictionary of strings that will be added to the
|
|
|
|
exec_properties of a platform selected for this target.
|
|
|
|
shard_count: The number of shards for this test.
|
|
|
|
flaky: Whether this test is flaky.
|
|
|
|
exclude_pollers: list of poller names to exclude for this set of tests.
|
|
|
|
uses_event_engine: set to False if the test is not sensitive to
|
|
|
|
EventEngine implementation differences
|
|
|
|
"""
|
|
|
|
test_args = {
|
|
|
|
"data": data,
|
|
|
|
"size": size,
|
|
|
|
"timeout": timeout,
|
|
|
|
"exec_compatible_with": exec_compatible_with,
|
|
|
|
"exec_properties": exec_properties,
|
|
|
|
"shard_count": shard_count,
|
|
|
|
"flaky": flaky,
|
|
|
|
}
|
|
|
|
|
|
|
|
for poller_config in expand_tests(name, srcs, [], tags, args, exclude_pollers, uses_polling, uses_event_engine):
|
|
|
|
native.sh_test(
|
|
|
|
name = poller_config["name"],
|
|
|
|
srcs = poller_config["srcs"],
|
|
|
|
deps = poller_config["deps"],
|
|
|
|
tags = poller_config["tags"],
|
|
|
|
args = poller_config["args"],
|
|
|
|
env = poller_config["env"],
|
|
|
|
**test_args
|
|
|
|
)
|
|
|
|
|
|
|
|
def grpc_sh_binary(name, srcs, data = []):
|
|
|
|
native.sh_binary(
|
|
|
|
name = name,
|
|
|
|
srcs = srcs,
|
|
|
|
data = data,
|
|
|
|
)
|
|
|
|
|
|
|
|
def grpc_py_binary(
|
|
|
|
name,
|
|
|
|
srcs,
|
|
|
|
data = [],
|
|
|
|
deps = [],
|
|
|
|
external_deps = [],
|
|
|
|
testonly = False,
|
|
|
|
python_version = "PY2",
|
|
|
|
**kwargs):
|
|
|
|
native.py_binary(
|
|
|
|
name = name,
|
|
|
|
srcs = srcs,
|
|
|
|
testonly = testonly,
|
|
|
|
data = data,
|
|
|
|
deps = deps + _get_external_deps(external_deps),
|
|
|
|
python_version = python_version,
|
|
|
|
**kwargs
|
|
|
|
)
|
|
|
|
|
|
|
|
def grpc_package(name, visibility = "private", features = []):
|
|
|
|
"""Creates a package.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
name: The name of the target
|
|
|
|
visibility: The visibility of the target.
|
|
|
|
features: The features to enable.
|
|
|
|
"""
|
|
|
|
if visibility == "tests":
|
|
|
|
visibility = ["//test:__subpackages__"]
|
|
|
|
elif visibility == "public":
|
|
|
|
visibility = ["//visibility:public"]
|
|
|
|
elif visibility == "private":
|
|
|
|
visibility = []
|
|
|
|
else:
|
|
|
|
fail("Unknown visibility " + visibility)
|
|
|
|
|
|
|
|
if len(visibility) != 0:
|
|
|
|
# buildifier: disable=native-package
|
|
|
|
native.package(
|
|
|
|
default_visibility = visibility,
|
|
|
|
features = features,
|
|
|
|
)
|
|
|
|
|
|
|
|
def grpc_objc_library(
|
|
|
|
name,
|
|
|
|
srcs = [],
|
|
|
|
hdrs = [],
|
|
|
|
non_arc_srcs = [],
|
|
|
|
textual_hdrs = [],
|
|
|
|
testonly = False,
|
|
|
|
data = [],
|
|
|
|
deps = [],
|
|
|
|
defines = [],
|
|
|
|
sdk_frameworks = [],
|
|
|
|
includes = [],
|
|
|
|
visibility = ["//visibility:public"]):
|
|
|
|
"""The grpc version of objc_library, only used for the Objective-C library compilation
|
|
|
|
|
|
|
|
Args:
|
|
|
|
name: name of target
|
|
|
|
hdrs: public headers
|
|
|
|
srcs: all source files (.m)
|
|
|
|
non_arc_srcs: list of Objective-C files that DO NOT use ARC.
|
|
|
|
textual_hdrs: private headers
|
|
|
|
testonly: Whether the binary is for tests only.
|
|
|
|
data: any other bundle resources
|
|
|
|
defines: preprocessors
|
|
|
|
sdk_frameworks: sdks
|
|
|
|
includes: added to search path, always [the path to objc directory]
|
|
|
|
deps: dependencies
|
|
|
|
visibility: visibility, default to public
|
|
|
|
"""
|
|
|
|
|
|
|
|
native.objc_library(
|
|
|
|
name = name,
|
|
|
|
hdrs = hdrs,
|
|
|
|
srcs = srcs,
|
|
|
|
non_arc_srcs = non_arc_srcs,
|
|
|
|
textual_hdrs = textual_hdrs,
|
|
|
|
copts = GRPC_DEFAULT_COPTS + ["-ObjC++", "-std=gnu++14"],
|
|
|
|
testonly = testonly,
|
|
|
|
data = data,
|
|
|
|
deps = deps,
|
|
|
|
defines = defines,
|
|
|
|
includes = includes,
|
|
|
|
sdk_frameworks = sdk_frameworks,
|
|
|
|
visibility = visibility,
|
|
|
|
)
|
|
|
|
|
|
|
|
def grpc_upb_proto_library(name, deps):
|
|
|
|
upb_proto_library(name = name, deps = deps)
|
|
|
|
|
|
|
|
def grpc_upb_proto_reflection_library(name, deps):
|
|
|
|
upb_proto_reflection_library(name = name, deps = deps)
|
|
|
|
|
|
|
|
# buildifier: disable=unnamed-macro
|
|
|
|
def python_config_settings():
|
|
|
|
native.config_setting(
|
|
|
|
name = "python3",
|
|
|
|
flag_values = {"@bazel_tools//tools/python:python_version": "PY3"},
|
|
|
|
)
|