Merge remote-tracking branch 'upstream/master' into route_response

.gitignore

@@ -136,7 +136,7 @@ bm_diff_old/
 bm_*.json
 
 # cmake build files
-/cmake/build
+**/cmake/build/
 
 # Visual Studio Code artifacts
 .vscode/*

BUILD

@@ -726,6 +726,7 @@ grpc_cc_library(
         "src/core/lib/iomgr/endpoint_pair_windows.cc",
         "src/core/lib/iomgr/error.cc",
         "src/core/lib/iomgr/error_cfstream.cc",
+        "src/core/lib/iomgr/ev_apple.cc",
         "src/core/lib/iomgr/ev_epoll1_linux.cc",
         "src/core/lib/iomgr/ev_epollex_linux.cc",
         "src/core/lib/iomgr/ev_poll_posix.cc",
@@ -887,6 +888,7 @@ grpc_cc_library(
         "src/core/lib/iomgr/error.h",
         "src/core/lib/iomgr/error_cfstream.h",
         "src/core/lib/iomgr/error_internal.h",
+        "src/core/lib/iomgr/ev_apple.h",
         "src/core/lib/iomgr/ev_epoll1_linux.h",
         "src/core/lib/iomgr/ev_epollex_linux.h",
         "src/core/lib/iomgr/ev_poll_posix.h",
@@ -991,7 +993,6 @@ grpc_cc_library(
     ],
     language = "c++",
     public_hdrs = GRPC_PUBLIC_HDRS,
-    use_cfstream = True,
     deps = [
         "eventmanager_libuv",
         "gpr_base",

BUILD.gn

@@ -605,6 +605,8 @@ config("grpc_config") {
         "src/core/lib/iomgr/error_cfstream.cc",
         "src/core/lib/iomgr/error_cfstream.h",
         "src/core/lib/iomgr/error_internal.h",
+        "src/core/lib/iomgr/ev_apple.cc",
+        "src/core/lib/iomgr/ev_apple.h",
         "src/core/lib/iomgr/ev_epoll1_linux.cc",
         "src/core/lib/iomgr/ev_epoll1_linux.h",
         "src/core/lib/iomgr/ev_epollex_linux.cc",

CMakeLists.txt

@@ -1513,6 +1513,7 @@ add_library(grpc
   src/core/lib/iomgr/endpoint_pair_windows.cc
   src/core/lib/iomgr/error.cc
   src/core/lib/iomgr/error_cfstream.cc
+  src/core/lib/iomgr/ev_apple.cc
   src/core/lib/iomgr/ev_epoll1_linux.cc
   src/core/lib/iomgr/ev_epollex_linux.cc
   src/core/lib/iomgr/ev_poll_posix.cc
@@ -2167,6 +2168,7 @@ add_library(grpc_unsecure
   src/core/lib/iomgr/endpoint_pair_windows.cc
   src/core/lib/iomgr/error.cc
   src/core/lib/iomgr/error_cfstream.cc
+  src/core/lib/iomgr/ev_apple.cc
   src/core/lib/iomgr/ev_epoll1_linux.cc
   src/core/lib/iomgr/ev_epollex_linux.cc
   src/core/lib/iomgr/ev_poll_posix.cc
@@ -6346,10 +6348,6 @@ endif()
 if(gRPC_BUILD_TESTS)
 
 add_executable(num_external_connectivity_watchers_test
-  test/core/end2end/data/client_certs.cc
-  test/core/end2end/data/server1_cert.cc
-  test/core/end2end/data/server1_key.cc
-  test/core/end2end/data/test_root_cert.cc
   test/core/surface/num_external_connectivity_watchers_test.cc
 )
 

Makefile

@@ -3838,6 +3838,7 @@ LIBGRPC_SRC = \
     src/core/lib/iomgr/endpoint_pair_windows.cc \
     src/core/lib/iomgr/error.cc \
     src/core/lib/iomgr/error_cfstream.cc \
+    src/core/lib/iomgr/ev_apple.cc \
     src/core/lib/iomgr/ev_epoll1_linux.cc \
     src/core/lib/iomgr/ev_epollex_linux.cc \
     src/core/lib/iomgr/ev_poll_posix.cc \
@@ -4466,6 +4467,7 @@ LIBGRPC_UNSECURE_SRC = \
     src/core/lib/iomgr/endpoint_pair_windows.cc \
     src/core/lib/iomgr/error.cc \
     src/core/lib/iomgr/error_cfstream.cc \
+    src/core/lib/iomgr/ev_apple.cc \
     src/core/lib/iomgr/ev_epoll1_linux.cc \
     src/core/lib/iomgr/ev_epollex_linux.cc \
     src/core/lib/iomgr/ev_poll_posix.cc \
@@ -9540,10 +9542,6 @@ endif
 
 
 NUM_EXTERNAL_CONNECTIVITY_WATCHERS_TEST_SRC = \
-    test/core/end2end/data/client_certs.cc \
-    test/core/end2end/data/server1_cert.cc \
-    test/core/end2end/data/server1_key.cc \
-    test/core/end2end/data/test_root_cert.cc \
     test/core/surface/num_external_connectivity_watchers_test.cc \
 
 NUM_EXTERNAL_CONNECTIVITY_WATCHERS_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(NUM_EXTERNAL_CONNECTIVITY_WATCHERS_TEST_SRC))))
@@ -9564,14 +9562,6 @@ $(BINDIR)/$(CONFIG)/num_external_connectivity_watchers_test: $(NUM_EXTERNAL_CONN
 
 endif
 
-$(OBJDIR)/$(CONFIG)/test/core/end2end/data/client_certs.o:  $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libaddress_sorting.a $(LIBDIR)/$(CONFIG)/libupb.a
-
-$(OBJDIR)/$(CONFIG)/test/core/end2end/data/server1_cert.o:  $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libaddress_sorting.a $(LIBDIR)/$(CONFIG)/libupb.a
-
-$(OBJDIR)/$(CONFIG)/test/core/end2end/data/server1_key.o:  $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libaddress_sorting.a $(LIBDIR)/$(CONFIG)/libupb.a
-
-$(OBJDIR)/$(CONFIG)/test/core/end2end/data/test_root_cert.o:  $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libaddress_sorting.a $(LIBDIR)/$(CONFIG)/libupb.a
-
 $(OBJDIR)/$(CONFIG)/test/core/surface/num_external_connectivity_watchers_test.o:  $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libaddress_sorting.a $(LIBDIR)/$(CONFIG)/libupb.a
 
 deps_num_external_connectivity_watchers_test: $(NUM_EXTERNAL_CONNECTIVITY_WATCHERS_TEST_OBJS:.o=.dep)

build_autogenerated.yaml

@@ -566,6 +566,7 @@ libs:
   - src/core/lib/iomgr/error.h
   - src/core/lib/iomgr/error_cfstream.h
   - src/core/lib/iomgr/error_internal.h
+  - src/core/lib/iomgr/ev_apple.h
   - src/core/lib/iomgr/ev_epoll1_linux.h
   - src/core/lib/iomgr/ev_epollex_linux.h
   - src/core/lib/iomgr/ev_poll_posix.h
@@ -939,6 +940,7 @@ libs:
   - src/core/lib/iomgr/endpoint_pair_windows.cc
   - src/core/lib/iomgr/error.cc
   - src/core/lib/iomgr/error_cfstream.cc
+  - src/core/lib/iomgr/ev_apple.cc
   - src/core/lib/iomgr/ev_epoll1_linux.cc
   - src/core/lib/iomgr/ev_epollex_linux.cc
   - src/core/lib/iomgr/ev_poll_posix.cc
@@ -1466,6 +1468,7 @@ libs:
   - src/core/lib/iomgr/error.h
   - src/core/lib/iomgr/error_cfstream.h
   - src/core/lib/iomgr/error_internal.h
+  - src/core/lib/iomgr/ev_apple.h
   - src/core/lib/iomgr/ev_epoll1_linux.h
   - src/core/lib/iomgr/ev_epollex_linux.h
   - src/core/lib/iomgr/ev_poll_posix.h
@@ -1771,6 +1774,7 @@ libs:
   - src/core/lib/iomgr/endpoint_pair_windows.cc
   - src/core/lib/iomgr/error.cc
   - src/core/lib/iomgr/error_cfstream.cc
+  - src/core/lib/iomgr/ev_apple.cc
   - src/core/lib/iomgr/ev_epoll1_linux.cc
   - src/core/lib/iomgr/ev_epollex_linux.cc
   - src/core/lib/iomgr/ev_poll_posix.cc
@@ -3883,13 +3887,8 @@ targets:
 - name: num_external_connectivity_watchers_test
   build: test
   language: c
-  headers:
-  - test/core/end2end/data/ssl_test_data.h
+  headers: []
   src:
-  - test/core/end2end/data/client_certs.cc
-  - test/core/end2end/data/server1_cert.cc
-  - test/core/end2end/data/server1_key.cc
-  - test/core/end2end/data/test_root_cert.cc
   - test/core/surface/num_external_connectivity_watchers_test.cc
   deps:
   - grpc_test_util

config.m4

@@ -287,6 +287,7 @@ if test "$PHP_GRPC" != "no"; then
     src/core/lib/iomgr/endpoint_pair_windows.cc \
     src/core/lib/iomgr/error.cc \
     src/core/lib/iomgr/error_cfstream.cc \
+    src/core/lib/iomgr/ev_apple.cc \
     src/core/lib/iomgr/ev_epoll1_linux.cc \
     src/core/lib/iomgr/ev_epollex_linux.cc \
     src/core/lib/iomgr/ev_poll_posix.cc \

config.w32

@@ -256,6 +256,7 @@ if (PHP_GRPC != "no") {
     "src\\core\\lib\\iomgr\\endpoint_pair_windows.cc " +
     "src\\core\\lib\\iomgr\\error.cc " +
     "src\\core\\lib\\iomgr\\error_cfstream.cc " +
+    "src\\core\\lib\\iomgr\\ev_apple.cc " +
     "src\\core\\lib\\iomgr\\ev_epoll1_linux.cc " +
     "src\\core\\lib\\iomgr\\ev_epollex_linux.cc " +
     "src\\core\\lib\\iomgr\\ev_poll_posix.cc " +

doc/python/sphinx/glossary.rst

@@ -14,3 +14,16 @@ Glossary
 
   metadata
     A sequence of metadatum.
+
+  serializer
+    A callable function that encodes an object into bytes. Applications are
+    allowed to provide any customized serializer, so there isn't a restriction
+    for the input object (i.e. even ``None``). On the server-side, the
+    serializer is invoked with server handler's return value; on the
+    client-side, the serializer is invoked with outbound message objects.
+
+  deserializer
+    A callable function that decodes bytes into an object. Same as serializer,
+    the returned object doesn't have restrictions (i.e. ``None`` allowed). The
+    deserializer is invoked with inbound message bytes on both the server side
+    and the client-side.

examples/cpp/helloworld/README.md

@@ -1,264 +1,6 @@
-# gRPC C++ Hello World Tutorial
+# gRPC C++ Hello World Example
 
-### Install gRPC
-Make sure you have installed gRPC on your system. Follow the
-[BUILDING.md](../../../BUILDING.md) instructions.
+You can find a complete set of instructions for building gRPC and running the
+Hello World app in the [C++ Quick Start][].
 
-### Get the tutorial source code
-
-The example code for this and our other examples lives in the `examples`
-directory. Clone this repository at the [latest stable release tag](https://github.com/grpc/grpc/releases)
-to your local machine by running the following command:
-
-
-```sh
-$ git clone -b RELEASE_TAG_HERE https://github.com/grpc/grpc
-```
-
-Change your current directory to examples/cpp/helloworld
-
-```sh
-$ cd examples/cpp/helloworld/
-```
-
-### Defining a service
-
-The first step in creating our example is to define a *service*: an RPC
-service specifies the methods that can be called remotely with their parameters
-and return types. As you saw in the
-[overview](#protocolbuffers) above, gRPC does this using [protocol
-buffers](https://developers.google.com/protocol-buffers/docs/overview). We
-use the protocol buffers interface definition language (IDL) to define our
-service methods, and define the parameters and return
-types as protocol buffer message types. Both the client and the
-server use interface code generated from the service definition.
-
-Here's our example service definition, defined using protocol buffers IDL in
-[helloworld.proto](../../protos/helloworld.proto). The `Greeting`
-service has one method, `hello`, that lets the server receive a single
-`HelloRequest`
-message from the remote client containing the user's name, then send back
-a greeting in a single `HelloReply`. This is the simplest type of RPC you
-can specify in gRPC - we'll look at some other types later in this document.
-
-```protobuf
-syntax = "proto3";
-
-option java_package = "ex.grpc";
-
-package helloworld;
-
-// The greeting service definition.
-service Greeter {
-  // Sends a greeting
-  rpc SayHello (HelloRequest) returns (HelloReply) {}
-}
-
-// The request message containing the user's name.
-message HelloRequest {
-  string name = 1;
-}
-
-// The response message containing the greetings
-message HelloReply {
-  string message = 1;
-}
-
-```
-
-<a name="generating"></a>
-### Generating gRPC code
-
-Once we've defined our service, we use the protocol buffer compiler
-`protoc` to generate the special client and server code we need to create
-our application. The generated code contains both stub code for clients to
-use and an abstract interface for servers to implement, both with the method
-defined in our `Greeting` service.
-
-To generate the client and server side interfaces:
-
-```sh
-$ make helloworld.grpc.pb.cc helloworld.pb.cc
-```
-Which internally invokes the proto-compiler as:
-
-```sh
-$ protoc -I ../../protos/ --grpc_out=. --plugin=protoc-gen-grpc=grpc_cpp_plugin ../../protos/helloworld.proto
-$ protoc -I ../../protos/ --cpp_out=. ../../protos/helloworld.proto
-```
-
-### Writing a client
-
-- Create a channel. A channel is a logical connection to an endpoint. A gRPC
-  channel can be created with the target address, credentials to use and
-  arguments as follows
-
-    ```cpp
-    auto channel = CreateChannel("localhost:50051", InsecureChannelCredentials());
-    ```
-
-- Create a stub. A stub implements the rpc methods of a service and in the
-  generated code, a method is provided to create a stub with a channel:
-
-    ```cpp
-    auto stub = helloworld::Greeter::NewStub(channel);
-    ```
-
-- Make a unary rpc, with `ClientContext` and request/response proto messages.
-
-    ```cpp
-    ClientContext context;
-    HelloRequest request;
-    request.set_name("hello");
-    HelloReply reply;
-    Status status = stub->SayHello(&context, request, &reply);
-    ```
-
-- Check returned status and response.
-
-    ```cpp
-    if (status.ok()) {
-      // check reply.message()
-    } else {
-      // rpc failed.
-    }
-    ```
-
-For a working example, refer to [greeter_client.cc](greeter_client.cc).
-
-### Writing a server
-
-- Implement the service interface
-
-    ```cpp
-    class GreeterServiceImpl final : public Greeter::Service {
-      Status SayHello(ServerContext* context, const HelloRequest* request,
-          HelloReply* reply) override {
-        std::string prefix("Hello ");
-        reply->set_message(prefix + request->name());
-        return Status::OK;
-      }
-    };
-
-    ```
-
-- Build a server exporting the service
-
-    ```cpp
-    GreeterServiceImpl service;
-    ServerBuilder builder;
-    builder.AddListeningPort("0.0.0.0:50051", grpc::InsecureServerCredentials());
-    builder.RegisterService(&service);
-    std::unique_ptr<Server> server(builder.BuildAndStart());
-    ```
-
-For a working example, refer to [greeter_server.cc](greeter_server.cc).
-
-### Writing asynchronous client and server
-
-gRPC uses `CompletionQueue` API for asynchronous operations. The basic work flow
-is
-- bind a `CompletionQueue` to a rpc call
-- do something like a read or write, present with a unique `void*` tag
-- call `CompletionQueue::Next` to wait for operations to complete. If a tag
-  appears, it indicates that the corresponding operation is complete.
-
-#### Async client
-
-The channel and stub creation code is the same as the sync client.
-
-- Initiate the rpc and create a handle for the rpc. Bind the rpc to a
-  `CompletionQueue`.
-
-    ```cpp
-    CompletionQueue cq;
-    auto rpc = stub->AsyncSayHello(&context, request, &cq);
-    ```
-
-- Ask for reply and final status, with a unique tag
-
-    ```cpp
-    Status status;
-    rpc->Finish(&reply, &status, (void*)1);
-    ```
-
-- Wait for the completion queue to return the next tag. The reply and status are
-  ready once the tag passed into the corresponding `Finish()` call is returned.
-
-    ```cpp
-    void* got_tag;
-    bool ok = false;
-    cq.Next(&got_tag, &ok);
-    if (ok && got_tag == (void*)1) {
-      // check reply and status
-    }
-    ```
-
-For a working example, refer to [greeter_async_client.cc](greeter_async_client.cc).
-
-#### Async server
-
-The server implementation requests a rpc call with a tag and then wait for the
-completion queue to return the tag. The basic flow is
-
-- Build a server exporting the async service
-
-    ```cpp
-    helloworld::Greeter::AsyncService service;
-    ServerBuilder builder;
-    builder.AddListeningPort("0.0.0.0:50051", InsecureServerCredentials());
-    builder.RegisterService(&service);
-    auto cq = builder.AddCompletionQueue();
-    auto server = builder.BuildAndStart();
-    ```
-
-- Request one rpc
-
-    ```cpp
-    ServerContext context;
-    HelloRequest request;
-    ServerAsyncResponseWriter<HelloReply> responder;
-    service.RequestSayHello(&context, &request, &responder, &cq, &cq, (void*)1);
-    ```
-
-- Wait for the completion queue to return the tag. The context, request and
-  responder are ready once the tag is retrieved.
-
-    ```cpp
-    HelloReply reply;
-    Status status;
-    void* got_tag;
-    bool ok = false;
-    cq.Next(&got_tag, &ok);
-    if (ok && got_tag == (void*)1) {
-      // set reply and status
-      responder.Finish(reply, status, (void*)2);
-    }
-    ```
-
-- Wait for the completion queue to return the tag. The rpc is finished when the
-  tag is back.
-
-    ```cpp
-    void* got_tag;
-    bool ok = false;
-    cq.Next(&got_tag, &ok);
-    if (ok && got_tag == (void*)2) {
-      // clean up
-    }
-    ```
-
-To handle multiple rpcs, the async server creates an object `CallData` to
-maintain the state of each rpc and use the address of it as the unique tag. For
-simplicity the server only uses one completion queue for all events, and runs a
-main loop in `HandleRpcs` to query the queue.
-
-For a working example, refer to [greeter_async_server.cc](greeter_async_server.cc).
-
-#### Flags for the client
-
-```sh
-./greeter_client --target="a target string used to create a GRPC client channel"
-```
-
-The Default value for --target is "localhost:50051".
+[C++ Quick Start]: https://grpc.io/docs/quickstart/cpp

gRPC-C++.podspec

@@ -445,6 +445,7 @@ Pod::Spec.new do |s|
                       'src/core/lib/iomgr/error.h',
                       'src/core/lib/iomgr/error_cfstream.h',
                       'src/core/lib/iomgr/error_internal.h',
+                      'src/core/lib/iomgr/ev_apple.h',
                       'src/core/lib/iomgr/ev_epoll1_linux.h',
                       'src/core/lib/iomgr/ev_epollex_linux.h',
                       'src/core/lib/iomgr/ev_poll_posix.h',
@@ -896,6 +897,7 @@ Pod::Spec.new do |s|
                               'src/core/lib/iomgr/error.h',
                               'src/core/lib/iomgr/error_cfstream.h',
                               'src/core/lib/iomgr/error_internal.h',
+                              'src/core/lib/iomgr/ev_apple.h',
                               'src/core/lib/iomgr/ev_epoll1_linux.h',
                               'src/core/lib/iomgr/ev_epollex_linux.h',
                               'src/core/lib/iomgr/ev_poll_posix.h',

gRPC-Core.podspec

@@ -655,6 +655,8 @@ Pod::Spec.new do |s|
                       'src/core/lib/iomgr/error_cfstream.cc',
                       'src/core/lib/iomgr/error_cfstream.h',
                       'src/core/lib/iomgr/error_internal.h',
+                      'src/core/lib/iomgr/ev_apple.cc',
+                      'src/core/lib/iomgr/ev_apple.h',
                       'src/core/lib/iomgr/ev_epoll1_linux.cc',
                       'src/core/lib/iomgr/ev_epoll1_linux.h',
                       'src/core/lib/iomgr/ev_epollex_linux.cc',
@@ -1250,6 +1252,7 @@ Pod::Spec.new do |s|
                               'src/core/lib/iomgr/error.h',
                               'src/core/lib/iomgr/error_cfstream.h',
                               'src/core/lib/iomgr/error_internal.h',
+                              'src/core/lib/iomgr/ev_apple.h',
                               'src/core/lib/iomgr/ev_epoll1_linux.h',
                               'src/core/lib/iomgr/ev_epollex_linux.h',
                               'src/core/lib/iomgr/ev_poll_posix.h',

grpc.gemspec

@@ -577,6 +577,8 @@ Gem::Specification.new do |s|
   s.files += %w( src/core/lib/iomgr/error_cfstream.cc )
   s.files += %w( src/core/lib/iomgr/error_cfstream.h )
   s.files += %w( src/core/lib/iomgr/error_internal.h )
+  s.files += %w( src/core/lib/iomgr/ev_apple.cc )
+  s.files += %w( src/core/lib/iomgr/ev_apple.h )
   s.files += %w( src/core/lib/iomgr/ev_epoll1_linux.cc )
   s.files += %w( src/core/lib/iomgr/ev_epoll1_linux.h )
   s.files += %w( src/core/lib/iomgr/ev_epollex_linux.cc )

grpc.gyp

@@ -641,6 +641,7 @@
         'src/core/lib/iomgr/endpoint_pair_windows.cc',
         'src/core/lib/iomgr/error.cc',
         'src/core/lib/iomgr/error_cfstream.cc',
+        'src/core/lib/iomgr/ev_apple.cc',
         'src/core/lib/iomgr/ev_epoll1_linux.cc',
         'src/core/lib/iomgr/ev_epollex_linux.cc',
         'src/core/lib/iomgr/ev_poll_posix.cc',
@@ -1131,6 +1132,7 @@
         'src/core/lib/iomgr/endpoint_pair_windows.cc',
         'src/core/lib/iomgr/error.cc',
         'src/core/lib/iomgr/error_cfstream.cc',
+        'src/core/lib/iomgr/ev_apple.cc',
         'src/core/lib/iomgr/ev_epoll1_linux.cc',
         'src/core/lib/iomgr/ev_epollex_linux.cc',
         'src/core/lib/iomgr/ev_poll_posix.cc',

package.xml

@@ -557,6 +557,8 @@
     <file baseinstalldir="/" name="src/core/lib/iomgr/error_cfstream.cc" role="src" />
     <file baseinstalldir="/" name="src/core/lib/iomgr/error_cfstream.h" role="src" />
     <file baseinstalldir="/" name="src/core/lib/iomgr/error_internal.h" role="src" />
+    <file baseinstalldir="/" name="src/core/lib/iomgr/ev_apple.cc" role="src" />
+    <file baseinstalldir="/" name="src/core/lib/iomgr/ev_apple.h" role="src" />
     <file baseinstalldir="/" name="src/core/lib/iomgr/ev_epoll1_linux.cc" role="src" />
     <file baseinstalldir="/" name="src/core/lib/iomgr/ev_epoll1_linux.h" role="src" />
     <file baseinstalldir="/" name="src/core/lib/iomgr/ev_epollex_linux.cc" role="src" />

src/core/ext/filters/client_channel/xds/xds_api.cc

@@ -1023,7 +1023,14 @@ grpc_error* RouteConfigParse(
     XdsApi::RdsRoute rds_route;
     if (envoy_api_v2_route_RouteMatch_has_prefix(match)) {
       upb_strview prefix = envoy_api_v2_route_RouteMatch_prefix(match);
-      if (prefix.size > 0) {
+      // Empty prefix "" is accepted.
+      if (prefix.size == 1) {
+        //Prefix "/" is accepted.
+        if (prefix.data[0] != '/') {
+          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "Prefix is not empty and does starting with a /");
+        }
+      } else if (prefix.size > 1) {
         if (prefix.data[0] != '/') {
           return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "Prefix is not starting with a /");

src/core/lib/iomgr/cfstream_handle.cc

@@ -32,6 +32,7 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
+#include "src/core/lib/iomgr/ev_apple.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
@@ -147,8 +148,8 @@ CFStreamHandle::CFStreamHandle(CFReadStreamRef read_stream,
       kCFStreamEventOpenCompleted | kCFStreamEventCanAcceptBytes |
           kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered,
       CFStreamHandle::WriteCallback, &ctx);
-  CFReadStreamSetDispatchQueue(read_stream, dispatch_queue_);
-  CFWriteStreamSetDispatchQueue(write_stream, dispatch_queue_);
+  grpc_apple_register_read_stream(read_stream, dispatch_queue_);
+  grpc_apple_register_write_stream(write_stream, dispatch_queue_);
 }
 
 CFStreamHandle::~CFStreamHandle() {

src/core/lib/iomgr/ev_apple.cc

@@ -0,0 +1,356 @@
+/*
+ *
+ * Copyright 2020 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.
+ *
+ */
+
+/// Event engine based on Apple's CFRunLoop API family. If the CFRunLoop engine
+/// is enabled (see iomgr_posix_cfstream.cc), a global thread is started to
+/// handle and trigger all the CFStream events. The CFStream streams register
+/// themselves with the run loop with functions grpc_apple_register_read_stream
+/// and grpc_apple_register_read_stream. Pollsets are dummy and block on a
+/// condition variable in pollset_work().
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_APPLE_EV
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <list>
+
+#include "src/core/lib/gprpp/thd.h"
+#include "src/core/lib/iomgr/ev_apple.h"
+
+grpc_core::DebugOnlyTraceFlag grpc_apple_polling_trace(false, "apple_polling");
+
+#ifndef NDEBUG
+#define GRPC_POLLING_TRACE(format, ...)                    \
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_apple_polling_trace)) { \
+    gpr_log(GPR_DEBUG, "(polling) " format, __VA_ARGS__);  \
+  }
+#else
+#define GRPC_POLLING_TRACE(...)
+#endif  // NDEBUG
+
+#define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker*)1)
+
+struct GlobalRunLoopContext {
+  grpc_core::CondVar init_cv;
+  grpc_core::CondVar input_source_cv;
+
+  grpc_core::Mutex mu;
+
+  // Whether an input source registration is pending. Protected by mu.
+  bool input_source_registered = false;
+
+  // The reference to the global run loop object. Protected by mu.
+  CFRunLoopRef run_loop;
+
+  // Whether the pollset has been globally shut down. Protected by mu.
+  bool is_shutdown = false;
+};
+
+struct GrpcAppleWorker {
+  // The condition varible to kick the worker. Works with the pollset's lock
+  // (GrpcApplePollset.mu).
+  grpc_core::CondVar cv;
+
+  // Whether the worker is kicked. Protected by the pollset's lock
+  // (GrpcApplePollset.mu).
+  bool kicked = false;
+};
+
+struct GrpcApplePollset {
+  grpc_core::Mutex mu;
+
+  // Tracks the current workers in the pollset. Protected by mu.
+  std::list<GrpcAppleWorker*> workers;
+
+  // Whether the pollset is shut down. Protected by mu.
+  bool is_shutdown = false;
+
+  // Closure to call when shutdown is done. Protected by mu.
+  grpc_closure* shutdown_closure;
+
+  // Whether there's an outstanding kick that was not processed. Protected by
+  // mu.
+  bool kicked_without_poller = false;
+};
+
+static GlobalRunLoopContext* gGlobalRunLoopContext = nullptr;
+static grpc_core::Thread* gGlobalRunLoopThread = nullptr;
+
+/// Register the stream with the dispatch queue. Callbacks of the stream will be
+/// issued to the dispatch queue when a network event happens and will be
+/// managed by Grand Central Dispatch.
+static void grpc_apple_register_read_stream_queue(
+    CFReadStreamRef read_stream, dispatch_queue_t dispatch_queue) {
+  CFReadStreamSetDispatchQueue(read_stream, dispatch_queue);
+}
+
+/// Register the stream with the dispatch queue. Callbacks of the stream will be
+/// issued to the dispatch queue when a network event happens and will be
+/// managed by Grand Central Dispatch.
+static void grpc_apple_register_write_stream_queue(
+    CFWriteStreamRef write_stream, dispatch_queue_t dispatch_queue) {
+  CFWriteStreamSetDispatchQueue(write_stream, dispatch_queue);
+}
+
+/// Register the stream with the global run loop. Callbacks of the stream will
+/// be issued to the run loop when a network event happens and will be driven by
+/// the global run loop thread gGlobalRunLoopThread.
+static void grpc_apple_register_read_stream_run_loop(
+    CFReadStreamRef read_stream, dispatch_queue_t dispatch_queue) {
+  GRPC_POLLING_TRACE("Register read stream: %p", read_stream);
+  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
+  CFReadStreamScheduleWithRunLoop(read_stream, gGlobalRunLoopContext->run_loop,
+                                  kCFRunLoopDefaultMode);
+  gGlobalRunLoopContext->input_source_registered = true;
+  gGlobalRunLoopContext->input_source_cv.Signal();
+}
+
+/// Register the stream with the global run loop. Callbacks of the stream will
+/// be issued to the run loop when a network event happens, and will be driven
+/// by the global run loop thread gGlobalRunLoopThread.
+static void grpc_apple_register_write_stream_run_loop(
+    CFWriteStreamRef write_stream, dispatch_queue_t dispatch_queue) {
+  GRPC_POLLING_TRACE("Register write stream: %p", write_stream);
+  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
+  CFWriteStreamScheduleWithRunLoop(
+      write_stream, gGlobalRunLoopContext->run_loop, kCFRunLoopDefaultMode);
+  gGlobalRunLoopContext->input_source_registered = true;
+  gGlobalRunLoopContext->input_source_cv.Signal();
+}
+
+/// The default implementation of stream registration is to register the stream
+/// to a dispatch queue. However, if the CFRunLoop based pollset is enabled (by
+/// macro and environment variable, see docs in iomgr_posix_cfstream.cc), the
+/// CFStream streams are registered with the global run loop instead (see
+/// pollset_global_init below).
+static void (*grpc_apple_register_read_stream_impl)(
+    CFReadStreamRef, dispatch_queue_t) = grpc_apple_register_read_stream_queue;
+static void (*grpc_apple_register_write_stream_impl)(CFWriteStreamRef,
+                                                     dispatch_queue_t) =
+    grpc_apple_register_write_stream_queue;
+
+void grpc_apple_register_read_stream(CFReadStreamRef read_stream,
+                                     dispatch_queue_t dispatch_queue) {
+  grpc_apple_register_read_stream_impl(read_stream, dispatch_queue);
+}
+
+void grpc_apple_register_write_stream(CFWriteStreamRef write_stream,
+                                      dispatch_queue_t dispatch_queue) {
+  grpc_apple_register_write_stream_impl(write_stream, dispatch_queue);
+}
+
+/// Drive the run loop in a global singleton thread until the global run loop is
+/// shutdown.
+static void GlobalRunLoopFunc(void* arg) {
+  grpc_core::ReleasableMutexLock lock(&gGlobalRunLoopContext->mu);
+  gGlobalRunLoopContext->run_loop = CFRunLoopGetCurrent();
+  gGlobalRunLoopContext->init_cv.Signal();
+
+  while (!gGlobalRunLoopContext->is_shutdown) {
+    // CFRunLoopRun() will return immediately if no stream is registered on it.
+    // So we wait on a conditional variable until a stream is registered;
+    // otherwise we'll be running a spinning loop.
+    while (!gGlobalRunLoopContext->input_source_registered) {
+      gGlobalRunLoopContext->input_source_cv.Wait(&gGlobalRunLoopContext->mu);
+    }
+    gGlobalRunLoopContext->input_source_registered = false;
+    lock.Unlock();
+    CFRunLoopRun();
+    lock.Lock();
+  }
+  lock.Unlock();
+}
+
+// pollset implementation
+
+static void pollset_global_init(void) {
+  gGlobalRunLoopContext = new GlobalRunLoopContext;
+
+  grpc_apple_register_read_stream_impl =
+      grpc_apple_register_read_stream_run_loop;
+  grpc_apple_register_write_stream_impl =
+      grpc_apple_register_write_stream_run_loop;
+
+  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
+  gGlobalRunLoopThread =
+      new grpc_core::Thread("apple_ev", GlobalRunLoopFunc, nullptr);
+  gGlobalRunLoopThread->Start();
+  while (gGlobalRunLoopContext->run_loop == NULL)
+    gGlobalRunLoopContext->init_cv.Wait(&gGlobalRunLoopContext->mu);
+}
+
+static void pollset_global_shutdown(void) {
+  {
+    grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
+    gGlobalRunLoopContext->is_shutdown = true;
+    CFRunLoopStop(gGlobalRunLoopContext->run_loop);
+  }
+  gGlobalRunLoopThread->Join();
+  delete gGlobalRunLoopThread;
+  delete gGlobalRunLoopContext;
+}
+
+/// The caller must acquire the lock GrpcApplePollset.mu before calling this
+/// function. The lock may be temporarily released when waiting on the condition
+/// variable but will be re-acquired before the function returns.
+///
+/// The Apple pollset simply waits on a condition variable until it is kicked.
+/// The network events are handled in the global run loop thread. Processing of
+/// these events will eventually trigger the kick.
+static grpc_error* pollset_work(grpc_pollset* pollset,
+                                grpc_pollset_worker** worker,
+                                grpc_millis deadline) {
+  GRPC_POLLING_TRACE("pollset work: %p, worker: %p, deadline: %" PRIu64,
+                     pollset, worker, deadline);
+  GrpcApplePollset* apple_pollset =
+      reinterpret_cast<GrpcApplePollset*>(pollset);
+  GrpcAppleWorker actual_worker;
+  if (worker) {
+    *worker = reinterpret_cast<grpc_pollset_worker*>(&actual_worker);
+  }
+
+  if (apple_pollset->kicked_without_poller) {
+    // Process the outstanding kick and reset the flag. Do not block.
+    apple_pollset->kicked_without_poller = false;
+  } else {
+    // Block until kicked, timed out, or the pollset shuts down.
+    apple_pollset->workers.push_front(&actual_worker);
+    auto it = apple_pollset->workers.begin();
+
+    while (!actual_worker.kicked && !apple_pollset->is_shutdown) {
+      if (actual_worker.cv.Wait(
+              &apple_pollset->mu,
+              grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME))) {
+        // timed out
+        break;
+      }
+    }
+
+    apple_pollset->workers.erase(it);
+
+    // If the pollset is shut down asynchronously and this is the last pending
+    // worker, the shutdown process is complete at this moment and the shutdown
+    // callback will be called.
+    if (apple_pollset->is_shutdown && apple_pollset->workers.empty()) {
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, apple_pollset->shutdown_closure,
+                              GRPC_ERROR_NONE);
+    }
+  }
+
+  return GRPC_ERROR_NONE;
+}
+
+/// Kick a specific worker. The caller must acquire the lock GrpcApplePollset.mu
+/// before calling this function.
+static void kick_worker(GrpcAppleWorker* worker) {
+  worker->kicked = true;
+  worker->cv.Signal();
+}
+
+/// The caller must acquire the lock GrpcApplePollset.mu before calling this
+/// function. The kick action simply signals the condition variable of the
+/// worker.
+static grpc_error* pollset_kick(grpc_pollset* pollset,
+                                grpc_pollset_worker* specific_worker) {
+  GrpcApplePollset* apple_pollset =
+      reinterpret_cast<GrpcApplePollset*>(pollset);
+
+  GRPC_POLLING_TRACE("pollset kick: %p, worker:%p", pollset, specific_worker);
+
+  if (specific_worker == nullptr) {
+    if (apple_pollset->workers.empty()) {
+      apple_pollset->kicked_without_poller = true;
+    } else {
+      GrpcAppleWorker* actual_worker = apple_pollset->workers.front();
+      kick_worker(actual_worker);
+    }
+  } else if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
+    for (auto& actual_worker : apple_pollset->workers) {
+      kick_worker(actual_worker);
+    }
+  } else {
+    GrpcAppleWorker* actual_worker =
+        reinterpret_cast<GrpcAppleWorker*>(specific_worker);
+    kick_worker(actual_worker);
+  }
+
+  return GRPC_ERROR_NONE;
+}
+
+static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
+  GRPC_POLLING_TRACE("pollset init: %p", pollset);
+  GrpcApplePollset* apple_pollset = new (pollset) GrpcApplePollset();
+  *mu = apple_pollset->mu.get();
+}
+
+/// The caller must acquire the lock GrpcApplePollset.mu before calling this
+/// function.
+static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
+  GRPC_POLLING_TRACE("pollset shutdown: %p", pollset);
+
+  GrpcApplePollset* apple_pollset =
+      reinterpret_cast<GrpcApplePollset*>(pollset);
+  apple_pollset->is_shutdown = true;
+  pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
+
+  // If there is any worker blocked, shutdown will be done asynchronously.
+  if (apple_pollset->workers.empty()) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
+  } else {
+    apple_pollset->shutdown_closure = closure;
+  }
+}
+
+static void pollset_destroy(grpc_pollset* pollset) {
+  GRPC_POLLING_TRACE("pollset destroy: %p", pollset);
+  GrpcApplePollset* apple_pollset =
+      reinterpret_cast<GrpcApplePollset*>(pollset);
+  apple_pollset->~GrpcApplePollset();
+}
+
+size_t pollset_size(void) { return sizeof(GrpcApplePollset); }
+
+grpc_pollset_vtable grpc_apple_pollset_vtable = {
+    pollset_global_init, pollset_global_shutdown,
+    pollset_init,        pollset_shutdown,
+    pollset_destroy,     pollset_work,
+    pollset_kick,        pollset_size};
+
+// pollset_set implementation
+
+grpc_pollset_set* pollset_set_create(void) { return nullptr; }
+void pollset_set_destroy(grpc_pollset_set* pollset_set) {}
+void pollset_set_add_pollset(grpc_pollset_set* pollset_set,
+                             grpc_pollset* pollset) {}
+void pollset_set_del_pollset(grpc_pollset_set* pollset_set,
+                             grpc_pollset* pollset) {}
+void pollset_set_add_pollset_set(grpc_pollset_set* bag,
+                                 grpc_pollset_set* item) {}
+void pollset_set_del_pollset_set(grpc_pollset_set* bag,
+                                 grpc_pollset_set* item) {}
+
+grpc_pollset_set_vtable grpc_apple_pollset_set_vtable = {
+    pollset_set_create,          pollset_set_destroy,
+    pollset_set_add_pollset,     pollset_set_del_pollset,
+    pollset_set_add_pollset_set, pollset_set_del_pollset_set};
+
+#endif

src/core/lib/iomgr/ev_apple.h

@@ -0,0 +1,43 @@
+/*
+ *
+ * Copyright 2020 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.
+ *
+ */
+
+#ifndef GRPC_CORE_LIB_IOMGR_EV_APPLE_H
+#define GRPC_CORE_LIB_IOMGR_EV_APPLE_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GRPC_APPLE_EV
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+
+void grpc_apple_register_read_stream(CFReadStreamRef read_stream,
+                                     dispatch_queue_t dispatch_queue);
+
+void grpc_apple_register_write_stream(CFWriteStreamRef write_stream,
+                                      dispatch_queue_t dispatch_queue);
+
+extern grpc_pollset_vtable grpc_apple_pollset_vtable;
+
+extern grpc_pollset_set_vtable grpc_apple_pollset_set_vtable;
+
+#endif
+
+#endif

src/core/lib/iomgr/iomgr_posix_cfstream.cc

@@ -16,6 +16,20 @@
  *
  */
 
+/// CFStream is build-enabled on iOS by default and disabled by default on other
+/// platforms (see port_platform.h). To enable CFStream build on another
+/// platform, the users need to define macro "GRPC_CFSTREAM=1" when building
+/// gRPC.
+///
+/// When CFStream is to be built (either by default on iOS or by macro on other
+/// platforms), the users can disable CFStream with environment variable
+/// "grpc_cfstream=0". This will let gRPC to fallback to use POSIX sockets. In
+/// addition, the users may choose to use an alternative CFRunLoop based pollset
+/// "ev_apple" by setting environment variable "grpc_cfstream_run_loop=1". This
+/// pollset resolves a bug from Apple when CFStream streams dispatch events to
+/// dispatch queues. The caveat of this pollset is that users may not be able to
+/// run a gRPC server in the same process.
+
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/port.h"
@@ -23,6 +37,7 @@
 #ifdef GRPC_CFSTREAM_IOMGR
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/iomgr/ev_apple.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/iomgr_posix.h"
@@ -33,6 +48,7 @@
 #include "src/core/lib/iomgr/timer.h"
 
 static const char* grpc_cfstream_env_var = "grpc_cfstream";
+static const char* grpc_cfstream_run_loop_env_var = "GRPC_CFSTREAM_RUN_LOOP";
 
 extern grpc_tcp_server_vtable grpc_posix_tcp_server_vtable;
 extern grpc_tcp_client_vtable grpc_posix_tcp_client_vtable;
@@ -42,6 +58,33 @@ extern grpc_pollset_vtable grpc_posix_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_posix_pollset_set_vtable;
 extern grpc_address_resolver_vtable grpc_posix_resolver_vtable;
 
+static void apple_iomgr_platform_init(void) { grpc_pollset_global_init(); }
+
+static void apple_iomgr_platform_flush(void) {}
+
+static void apple_iomgr_platform_shutdown(void) {
+  grpc_pollset_global_shutdown();
+}
+
+static void apple_iomgr_platform_shutdown_background_closure(void) {}
+
+static bool apple_iomgr_platform_is_any_background_poller_thread(void) {
+  return false;
+}
+
+static bool apple_iomgr_platform_add_closure_to_background_poller(
+    grpc_closure* closure, grpc_error* error) {
+  return false;
+}
+
+static grpc_iomgr_platform_vtable apple_vtable = {
+    apple_iomgr_platform_init,
+    apple_iomgr_platform_flush,
+    apple_iomgr_platform_shutdown,
+    apple_iomgr_platform_shutdown_background_closure,
+    apple_iomgr_platform_is_any_background_poller_thread,
+    apple_iomgr_platform_add_closure_to_background_poller};
+
 static void iomgr_platform_init(void) {
   grpc_wakeup_fd_global_init();
   grpc_event_engine_init();
@@ -76,32 +119,53 @@ static grpc_iomgr_platform_vtable vtable = {
     iomgr_platform_add_closure_to_background_poller};
 
 void grpc_set_default_iomgr_platform() {
-  char* enable_cfstream = getenv(grpc_cfstream_env_var);
-  grpc_tcp_client_vtable* client_vtable = &grpc_posix_tcp_client_vtable;
-  // CFStream is enabled by default on iOS, and disabled by default on other
-  // platforms. Defaults can be overriden by setting the grpc_cfstream
-  // environment variable.
-#if TARGET_OS_IPHONE
-  if (enable_cfstream == nullptr || enable_cfstream[0] == '1') {
-    client_vtable = &grpc_cfstream_client_vtable;
+  char* enable_cfstream_str = getenv(grpc_cfstream_env_var);
+  bool enable_cfstream =
+      enable_cfstream_str == nullptr || enable_cfstream_str[0] != '0';
+  char* enable_cfstream_run_loop_str = getenv(grpc_cfstream_run_loop_env_var);
+  // CFStream run-loop is disabled by default. The user has to enable it
+  // explicitly with environment variable.
+  bool enable_cfstream_run_loop = enable_cfstream_run_loop_str != nullptr &&
+                                  enable_cfstream_run_loop_str[0] == '1';
+  if (!enable_cfstream) {
+    // Use POSIX sockets for both client and server
+    grpc_set_tcp_client_impl(&grpc_posix_tcp_client_vtable);
+    grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);
+    grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
+    grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
+    grpc_set_iomgr_platform_vtable(&vtable);
+  } else if (enable_cfstream && !enable_cfstream_run_loop) {
+    // Use CFStream with dispatch queue for client; use POSIX sockets for server
+    grpc_set_tcp_client_impl(&grpc_cfstream_client_vtable);
+    grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);
+    grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
+    grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
+    grpc_set_iomgr_platform_vtable(&vtable);
+  } else {
+    // Use CFStream with CFRunLoop for client; server not supported
+    grpc_set_tcp_client_impl(&grpc_cfstream_client_vtable);
+    grpc_set_pollset_vtable(&grpc_apple_pollset_vtable);
+    grpc_set_pollset_set_vtable(&grpc_apple_pollset_set_vtable);
+    grpc_set_iomgr_platform_vtable(&apple_vtable);
   }
-#else
-  if (enable_cfstream != nullptr && enable_cfstream[0] == '1') {
-    client_vtable = &grpc_cfstream_client_vtable;
-  }
-#endif
-
-  grpc_set_tcp_client_impl(client_vtable);
-  grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
-  grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
-  grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
   grpc_set_resolver_impl(&grpc_posix_resolver_vtable);
-  grpc_set_iomgr_platform_vtable(&vtable);
 }
 
 bool grpc_iomgr_run_in_background() {
-  return grpc_event_engine_run_in_background();
+  char* enable_cfstream_str = getenv(grpc_cfstream_env_var);
+  bool enable_cfstream =
+      enable_cfstream_str == nullptr || enable_cfstream_str[0] != '0';
+  char* enable_cfstream_run_loop_str = getenv(grpc_cfstream_run_loop_env_var);
+  // CFStream run-loop is disabled by default. The user has to enable it
+  // explicitly with environment variable.
+  bool enable_cfstream_run_loop = enable_cfstream_run_loop_str != nullptr &&
+                                  enable_cfstream_run_loop_str[0] == '1';
+  if (enable_cfstream && enable_cfstream_run_loop) {
+    return false;
+  } else {
+    return grpc_event_engine_run_in_background();
+  }
 }
 
 #endif /* GRPC_CFSTREAM_IOMGR */

src/core/lib/iomgr/pollset_set_custom.cc

@@ -22,23 +22,23 @@
 
 #include "src/core/lib/iomgr/pollset_set.h"
 
-grpc_pollset_set* pollset_set_create(void) {
+static grpc_pollset_set* pollset_set_create(void) {
   return (grpc_pollset_set*)((intptr_t)0xdeafbeef);
 }
 
-void pollset_set_destroy(grpc_pollset_set* /*pollset_set*/) {}
+static void pollset_set_destroy(grpc_pollset_set* /*pollset_set*/) {}
 
-void pollset_set_add_pollset(grpc_pollset_set* /*pollset_set*/,
-                             grpc_pollset* /*pollset*/) {}
+static void pollset_set_add_pollset(grpc_pollset_set* /*pollset_set*/,
+                                    grpc_pollset* /*pollset*/) {}
 
-void pollset_set_del_pollset(grpc_pollset_set* /*pollset_set*/,
-                             grpc_pollset* /*pollset*/) {}
+static void pollset_set_del_pollset(grpc_pollset_set* /*pollset_set*/,
+                                    grpc_pollset* /*pollset*/) {}
 
-void pollset_set_add_pollset_set(grpc_pollset_set* /*bag*/,
-                                 grpc_pollset_set* /*item*/) {}
+static void pollset_set_add_pollset_set(grpc_pollset_set* /*bag*/,
+                                        grpc_pollset_set* /*item*/) {}
 
-void pollset_set_del_pollset_set(grpc_pollset_set* /*bag*/,
-                                 grpc_pollset_set* /*item*/) {}
+static void pollset_set_del_pollset_set(grpc_pollset_set* /*bag*/,
+                                        grpc_pollset_set* /*item*/) {}
 
 static grpc_pollset_set_vtable vtable = {
     pollset_set_create,          pollset_set_destroy,

src/core/lib/iomgr/port.h

@@ -129,6 +129,7 @@
 #define GRPC_CFSTREAM_IOMGR 1
 #define GRPC_CFSTREAM_CLIENT 1
 #define GRPC_CFSTREAM_ENDPOINT 1
+#define GRPC_APPLE_EV 1
 #define GRPC_POSIX_SOCKET_ARES_EV_DRIVER 1
 #define GRPC_POSIX_SOCKET_EV 1
 #define GRPC_POSIX_SOCKET_EV_EPOLL1 1

src/core/lib/surface/server.cc

@@ -52,11 +52,11 @@ grpc_core::TraceFlag grpc_server_channel_trace(false, "server_channel");
 
 using grpc_core::LockedMultiProducerSingleConsumerQueue;
 
-static void server_on_recv_initial_metadata(void* ptr, grpc_error* error);
-static void server_recv_trailing_metadata_ready(void* user_data,
-                                                grpc_error* error);
-
 namespace {
+
+void server_on_recv_initial_metadata(void* ptr, grpc_error* error);
+void server_recv_trailing_metadata_ready(void* user_data, grpc_error* error);
+
 struct listener {
   void* arg;
   void (*start)(grpc_server* server, void* arg, grpc_pollset** pollsets,
@@ -76,9 +76,7 @@ struct requested_call {
       grpc_core::MultiProducerSingleConsumerQueue::Node>
       mpscq_node;
   requested_call_type type;
-  size_t cq_idx;
   void* tag;
-  grpc_server* server;
   grpc_completion_queue* cq_bound_to_call;
   grpc_call** call;
   grpc_cq_completion completion;
@@ -117,13 +115,13 @@ struct channel_data {
   intptr_t channelz_socket_uuid;
 };
 
-typedef struct shutdown_tag {
+struct shutdown_tag {
   void* tag;
   grpc_completion_queue* cq;
   grpc_cq_completion completion;
-} shutdown_tag;
+};
 
-typedef enum {
+enum call_state {
   /* waiting for metadata */
   NOT_STARTED,
   /* initial metadata read, not flow controlled in yet */
@@ -132,9 +130,9 @@ typedef enum {
   ACTIVATED,
   /* cancelled before being queued */
   ZOMBIED
-} call_state;
+};
 
-typedef struct request_matcher request_matcher;
+struct request_matcher;
 
 struct call_data {
   call_data(grpc_call_element* elem, const grpc_call_element_args& args)
@@ -144,7 +142,7 @@ struct call_data {
                       ::server_on_recv_initial_metadata, elem,
                       grpc_schedule_on_exec_ctx);
     GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready,
-                      server_recv_trailing_metadata_ready, elem,
+                      ::server_recv_trailing_metadata_ready, elem,
                       grpc_schedule_on_exec_ctx);
   }
   ~call_data() {
@@ -213,10 +211,10 @@ struct registered_method {
   registered_method* next;
 };
 
-typedef struct {
+struct channel_broadcaster {
   grpc_channel** channels;
   size_t num_channels;
-} channel_broadcaster;
+};
 }  // namespace
 
 struct grpc_server {
@@ -269,19 +267,20 @@ struct grpc_server {
 #define SERVER_FROM_CALL_ELEM(elem) \
   (((channel_data*)(elem)->channel_data)->server)
 
-static void publish_new_rpc(void* calld, grpc_error* error);
-static void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
-                      grpc_error* error);
+namespace {
+void publish_new_rpc(void* calld, grpc_error* error);
+void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
+               grpc_error* error);
 /* Before calling maybe_finish_shutdown, we must hold mu_global and not
    hold mu_call */
-static void maybe_finish_shutdown(grpc_server* server);
+void maybe_finish_shutdown(grpc_server* server);
 
 /*
  * channel broadcaster
  */
 
 /* assumes server locked */
-static void channel_broadcaster_init(grpc_server* s, channel_broadcaster* cb) {
+void channel_broadcaster_init(grpc_server* s, channel_broadcaster* cb) {
   channel_data* c;
   size_t count = 0;
   for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next) {
@@ -302,15 +301,15 @@ struct shutdown_cleanup_args {
   grpc_slice slice;
 };
 
-static void shutdown_cleanup(void* arg, grpc_error* /*error*/) {
+void shutdown_cleanup(void* arg, grpc_error* /*error*/) {
   struct shutdown_cleanup_args* a =
       static_cast<struct shutdown_cleanup_args*>(arg);
   grpc_slice_unref_internal(a->slice);
   gpr_free(a);
 }
 
-static void send_shutdown(grpc_channel* channel, bool send_goaway,
-                          grpc_error* send_disconnect) {
+void send_shutdown(grpc_channel* channel, bool send_goaway,
+                   grpc_error* send_disconnect) {
   struct shutdown_cleanup_args* sc =
       static_cast<struct shutdown_cleanup_args*>(gpr_malloc(sizeof(*sc)));
   GRPC_CLOSURE_INIT(&sc->closure, shutdown_cleanup, sc,
@@ -331,9 +330,8 @@ static void send_shutdown(grpc_channel* channel, bool send_goaway,
   elem->filter->start_transport_op(elem, op);
 }
 
-static void channel_broadcaster_shutdown(channel_broadcaster* cb,
-                                         bool send_goaway,
-                                         grpc_error* force_disconnect) {
+void channel_broadcaster_shutdown(channel_broadcaster* cb, bool send_goaway,
+                                  grpc_error* force_disconnect) {
   size_t i;
 
   for (i = 0; i < cb->num_channels; i++) {
@@ -349,7 +347,7 @@ static void channel_broadcaster_shutdown(channel_broadcaster* cb,
  * request_matcher
  */
 
-static void request_matcher_init(request_matcher* rm, grpc_server* server) {
+void request_matcher_init(request_matcher* rm, grpc_server* server) {
   rm->server = server;
   rm->pending_head = rm->pending_tail = nullptr;
   rm->requests_per_cq = static_cast<LockedMultiProducerSingleConsumerQueue*>(
@@ -359,7 +357,7 @@ static void request_matcher_init(request_matcher* rm, grpc_server* server) {
   }
 }
 
-static void request_matcher_destroy(request_matcher* rm) {
+void request_matcher_destroy(request_matcher* rm) {
   for (size_t i = 0; i < rm->server->cq_count; i++) {
     GPR_ASSERT(rm->requests_per_cq[i].Pop() == nullptr);
     rm->requests_per_cq[i].~LockedMultiProducerSingleConsumerQueue();
@@ -367,12 +365,12 @@ static void request_matcher_destroy(request_matcher* rm) {
   gpr_free(rm->requests_per_cq);
 }
 
-static void kill_zombie(void* elem, grpc_error* /*error*/) {
+void kill_zombie(void* elem, grpc_error* /*error*/) {
   grpc_call_unref(
       grpc_call_from_top_element(static_cast<grpc_call_element*>(elem)));
 }
 
-static void request_matcher_zombify_all_pending_calls(request_matcher* rm) {
+void request_matcher_zombify_all_pending_calls(request_matcher* rm) {
   while (rm->pending_head) {
     call_data* calld = rm->pending_head;
     rm->pending_head = calld->pending_next;
@@ -386,9 +384,8 @@ static void request_matcher_zombify_all_pending_calls(request_matcher* rm) {
   }
 }
 
-static void request_matcher_kill_requests(grpc_server* server,
-                                          request_matcher* rm,
-                                          grpc_error* error) {
+void request_matcher_kill_requests(grpc_server* server, request_matcher* rm,
+                                   grpc_error* error) {
   requested_call* rc;
   for (size_t i = 0; i < server->cq_count; i++) {
     while ((rc = reinterpret_cast<requested_call*>(
@@ -403,9 +400,9 @@ static void request_matcher_kill_requests(grpc_server* server,
  * server proper
  */
 
-static void server_ref(grpc_server* server) { server->internal_refcount.Ref(); }
+void server_ref(grpc_server* server) { server->internal_refcount.Ref(); }
 
-static void server_delete(grpc_server* server) {
+void server_delete(grpc_server* server) {
   registered_method* rm;
   size_t i;
   server->channelz_server.reset();
@@ -434,30 +431,28 @@ static void server_delete(grpc_server* server) {
   gpr_free(server);
 }
 
-static void server_unref(grpc_server* server) {
+void server_unref(grpc_server* server) {
   if (GPR_UNLIKELY(server->internal_refcount.Unref())) {
     server_delete(server);
   }
 }
 
-static int is_channel_orphaned(channel_data* chand) {
-  return chand->next == chand;
-}
+int is_channel_orphaned(channel_data* chand) { return chand->next == chand; }
 
-static void orphan_channel(channel_data* chand) {
+void orphan_channel(channel_data* chand) {
   chand->next->prev = chand->prev;
   chand->prev->next = chand->next;
   chand->next = chand->prev = chand;
 }
 
-static void finish_destroy_channel(void* cd, grpc_error* /*error*/) {
+void finish_destroy_channel(void* cd, grpc_error* /*error*/) {
   channel_data* chand = static_cast<channel_data*>(cd);
   grpc_server* server = chand->server;
   GRPC_CHANNEL_INTERNAL_UNREF(chand->channel, "server");
   server_unref(server);
 }
 
-static void destroy_channel(channel_data* chand) {
+void destroy_channel(channel_data* chand) {
   if (is_channel_orphaned(chand)) return;
   GPR_ASSERT(chand->server != nullptr);
   orphan_channel(chand);
@@ -478,12 +473,10 @@ static void destroy_channel(channel_data* chand) {
                        op);
 }
 
-static void done_request_event(void* req, grpc_cq_completion* /*c*/) {
-  gpr_free(req);
-}
+void done_request_event(void* req, grpc_cq_completion* /*c*/) { gpr_free(req); }
 
-static void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
-                         requested_call* rc) {
+void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
+                  requested_call* rc) {
   grpc_call_set_completion_queue(calld->call, rc->cq_bound_to_call);
   grpc_call* call = calld->call;
   *rc->call = call;
@@ -515,7 +508,7 @@ static void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
                  rc, &rc->completion, true);
 }
 
-static void publish_new_rpc(void* arg, grpc_error* error) {
+void publish_new_rpc(void* arg, grpc_error* error) {
   grpc_call_element* call_elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(call_elem->call_data);
   channel_data* chand = static_cast<channel_data*>(call_elem->channel_data);
@@ -577,11 +570,10 @@ static void publish_new_rpc(void* arg, grpc_error* error) {
     rm->pending_tail->pending_next = calld;
     rm->pending_tail = calld;
   }
-  calld->pending_next = nullptr;
   gpr_mu_unlock(&server->mu_call);
 }
 
-static void finish_start_new_rpc(
+void finish_start_new_rpc(
     grpc_server* server, grpc_call_element* elem, request_matcher* rm,
     grpc_server_register_method_payload_handling payload_handling) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
@@ -615,7 +607,7 @@ static void finish_start_new_rpc(
   }
 }
 
-static void start_new_rpc(grpc_call_element* elem) {
+void start_new_rpc(grpc_call_element* elem) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_server* server = chand->server;
@@ -666,7 +658,7 @@ static void start_new_rpc(grpc_call_element* elem) {
                        GRPC_SRM_PAYLOAD_NONE);
 }
 
-static int num_listeners(grpc_server* server) {
+int num_listeners(grpc_server* server) {
   listener* l;
   int n = 0;
   for (l = server->listeners; l; l = l->next) {
@@ -675,12 +667,11 @@ static int num_listeners(grpc_server* server) {
   return n;
 }
 
-static void done_shutdown_event(void* server,
-                                grpc_cq_completion* /*completion*/) {
+void done_shutdown_event(void* server, grpc_cq_completion* /*completion*/) {
   server_unref(static_cast<grpc_server*>(server));
 }
 
-static int num_channels(grpc_server* server) {
+int num_channels(grpc_server* server) {
   channel_data* chand;
   int n = 0;
   for (chand = server->root_channel_data.next;
@@ -690,7 +681,7 @@ static int num_channels(grpc_server* server) {
   return n;
 }
 
-static void kill_pending_work_locked(grpc_server* server, grpc_error* error) {
+void kill_pending_work_locked(grpc_server* server, grpc_error* error) {
   if (server->started) {
     request_matcher_kill_requests(server, &server->unregistered_request_matcher,
                                   GRPC_ERROR_REF(error));
@@ -706,7 +697,7 @@ static void kill_pending_work_locked(grpc_server* server, grpc_error* error) {
   GRPC_ERROR_UNREF(error);
 }
 
-static void maybe_finish_shutdown(grpc_server* server) {
+void maybe_finish_shutdown(grpc_server* server) {
   size_t i;
   if (!gpr_atm_acq_load(&server->shutdown_flag) || server->shutdown_published) {
     return;
@@ -741,7 +732,7 @@ static void maybe_finish_shutdown(grpc_server* server) {
   }
 }
 
-static void server_on_recv_initial_metadata(void* ptr, grpc_error* error) {
+void server_on_recv_initial_metadata(void* ptr, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(ptr);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_millis op_deadline;
@@ -787,8 +778,7 @@ static void server_on_recv_initial_metadata(void* ptr, grpc_error* error) {
   grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
-static void server_recv_trailing_metadata_ready(void* user_data,
-                                                grpc_error* error) {
+void server_recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (calld->on_done_recv_initial_metadata != nullptr) {
@@ -809,8 +799,8 @@ static void server_recv_trailing_metadata_ready(void* user_data,
                           calld->original_recv_trailing_metadata_ready, error);
 }
 
-static void server_mutate_op(grpc_call_element* elem,
-                             grpc_transport_stream_op_batch* op) {
+void server_mutate_op(grpc_call_element* elem,
+                      grpc_transport_stream_op_batch* op) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
 
   if (op->recv_initial_metadata) {
@@ -832,13 +822,13 @@ static void server_mutate_op(grpc_call_element* elem,
   }
 }
 
-static void server_start_transport_stream_op_batch(
+void server_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
   server_mutate_op(elem, op);
   grpc_call_next_op(elem, op);
 }
 
-static void got_initial_metadata(void* ptr, grpc_error* error) {
+void got_initial_metadata(void* ptr, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(ptr);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (error == GRPC_ERROR_NONE) {
@@ -856,8 +846,8 @@ static void got_initial_metadata(void* ptr, grpc_error* error) {
   }
 }
 
-static void accept_stream(void* cd, grpc_transport* /*transport*/,
-                          const void* transport_server_data) {
+void accept_stream(void* cd, grpc_transport* /*transport*/,
+                   const void* transport_server_data) {
   channel_data* chand = static_cast<channel_data*>(cd);
   /* create a call */
   grpc_call_create_args args;
@@ -892,25 +882,25 @@ static void accept_stream(void* cd, grpc_transport* /*transport*/,
   grpc_call_start_batch_and_execute(call, &op, 1, &calld->got_initial_metadata);
 }
 
-static grpc_error* server_init_call_elem(grpc_call_element* elem,
-                                         const grpc_call_element_args* args) {
+grpc_error* server_init_call_elem(grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   server_ref(chand->server);
   new (elem->call_data) call_data(elem, *args);
   return GRPC_ERROR_NONE;
 }
 
-static void server_destroy_call_elem(grpc_call_element* elem,
-                                     const grpc_call_final_info* /*final_info*/,
-                                     grpc_closure* /*ignored*/) {
+void server_destroy_call_elem(grpc_call_element* elem,
+                              const grpc_call_final_info* /*final_info*/,
+                              grpc_closure* /*ignored*/) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->~call_data();
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   server_unref(chand->server);
 }
 
-static grpc_error* server_init_channel_elem(grpc_channel_element* elem,
-                                            grpc_channel_element_args* args) {
+grpc_error* server_init_channel_elem(grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(args->is_first);
   GPR_ASSERT(!args->is_last);
@@ -921,7 +911,7 @@ static grpc_error* server_init_channel_elem(grpc_channel_element* elem,
   return GRPC_ERROR_NONE;
 }
 
-static void server_destroy_channel_elem(grpc_channel_element* elem) {
+void server_destroy_channel_elem(grpc_channel_element* elem) {
   size_t i;
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   if (chand->registered_methods) {
@@ -955,6 +945,121 @@ static void server_destroy_channel_elem(grpc_channel_element* elem) {
   }
 }
 
+void register_completion_queue(grpc_server* server, grpc_completion_queue* cq,
+                               void* reserved) {
+  size_t i, n;
+  GPR_ASSERT(!reserved);
+  for (i = 0; i < server->cq_count; i++) {
+    if (server->cqs[i] == cq) return;
+  }
+
+  GRPC_CQ_INTERNAL_REF(cq, "server");
+  n = server->cq_count++;
+  server->cqs = static_cast<grpc_completion_queue**>(gpr_realloc(
+      server->cqs, server->cq_count * sizeof(grpc_completion_queue*)));
+  server->cqs[n] = cq;
+}
+
+int streq(const char* a, const char* b) {
+  if (a == nullptr && b == nullptr) return 1;
+  if (a == nullptr) return 0;
+  if (b == nullptr) return 0;
+  return 0 == strcmp(a, b);
+}
+
+class ConnectivityWatcher
+    : public grpc_core::AsyncConnectivityStateWatcherInterface {
+ public:
+  explicit ConnectivityWatcher(channel_data* chand) : chand_(chand) {
+    GRPC_CHANNEL_INTERNAL_REF(chand_->channel, "connectivity");
+  }
+
+  ~ConnectivityWatcher() {
+    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel, "connectivity");
+  }
+
+ private:
+  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
+    // Don't do anything until we are being shut down.
+    if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
+    // Shut down channel.
+    grpc_server* server = chand_->server;
+    gpr_mu_lock(&server->mu_global);
+    destroy_channel(chand_);
+    gpr_mu_unlock(&server->mu_global);
+  }
+
+  channel_data* chand_;
+};
+
+void done_published_shutdown(void* done_arg, grpc_cq_completion* storage) {
+  (void)done_arg;
+  gpr_free(storage);
+}
+
+void listener_destroy_done(void* s, grpc_error* /*error*/) {
+  grpc_server* server = static_cast<grpc_server*>(s);
+  gpr_mu_lock(&server->mu_global);
+  server->listeners_destroyed++;
+  maybe_finish_shutdown(server);
+  gpr_mu_unlock(&server->mu_global);
+}
+
+grpc_call_error queue_call_request(grpc_server* server, size_t cq_idx,
+                                   requested_call* rc) {
+  call_data* calld = nullptr;
+  request_matcher* rm = nullptr;
+  if (gpr_atm_acq_load(&server->shutdown_flag)) {
+    fail_call(server, cq_idx, rc,
+              GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
+    return GRPC_CALL_OK;
+  }
+  switch (rc->type) {
+    case BATCH_CALL:
+      rm = &server->unregistered_request_matcher;
+      break;
+    case REGISTERED_CALL:
+      rm = &rc->data.registered.method->matcher;
+      break;
+  }
+  if (rm->requests_per_cq[cq_idx].Push(rc->mpscq_node.get())) {
+    /* this was the first queued request: we need to lock and start
+       matching calls */
+    gpr_mu_lock(&server->mu_call);
+    while ((calld = rm->pending_head) != nullptr) {
+      rc = reinterpret_cast<requested_call*>(rm->requests_per_cq[cq_idx].Pop());
+      if (rc == nullptr) break;
+      rm->pending_head = calld->pending_next;
+      gpr_mu_unlock(&server->mu_call);
+      if (!gpr_atm_full_cas(&calld->state, PENDING, ACTIVATED)) {
+        // Zombied Call
+        GRPC_CLOSURE_INIT(
+            &calld->kill_zombie_closure, kill_zombie,
+            grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0),
+            grpc_schedule_on_exec_ctx);
+        grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
+                                GRPC_ERROR_NONE);
+      } else {
+        publish_call(server, calld, cq_idx, rc);
+      }
+      gpr_mu_lock(&server->mu_call);
+    }
+    gpr_mu_unlock(&server->mu_call);
+  }
+  return GRPC_CALL_OK;
+}
+
+void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
+               grpc_error* error) {
+  *rc->call = nullptr;
+  rc->initial_metadata->count = 0;
+  GPR_ASSERT(error != GRPC_ERROR_NONE);
+
+  grpc_cq_end_op(server->cqs[cq_idx], rc->tag, error, done_request_event, rc,
+                 &rc->completion);
+}
+}  // namespace
+
 const grpc_channel_filter grpc_server_top_filter = {
     server_start_transport_stream_op_batch,
     grpc_channel_next_op,
@@ -969,22 +1074,6 @@ const grpc_channel_filter grpc_server_top_filter = {
     "server",
 };
 
-static void register_completion_queue(grpc_server* server,
-                                      grpc_completion_queue* cq,
-                                      void* reserved) {
-  size_t i, n;
-  GPR_ASSERT(!reserved);
-  for (i = 0; i < server->cq_count; i++) {
-    if (server->cqs[i] == cq) return;
-  }
-
-  GRPC_CQ_INTERNAL_REF(cq, "server");
-  n = server->cq_count++;
-  server->cqs = static_cast<grpc_completion_queue**>(gpr_realloc(
-      server->cqs, server->cq_count * sizeof(grpc_completion_queue*)));
-  server->cqs[n] = cq;
-}
-
 void grpc_server_register_completion_queue(grpc_server* server,
                                            grpc_completion_queue* cq,
                                            void* reserved) {
@@ -1050,13 +1139,6 @@ grpc_server* grpc_server_create(const grpc_channel_args* args, void* reserved) {
   return server;
 }
 
-static int streq(const char* a, const char* b) {
-  if (a == nullptr && b == nullptr) return 1;
-  if (a == nullptr) return 0;
-  if (b == nullptr) return 0;
-  return 0 == strcmp(a, b);
-}
-
 void* grpc_server_register_method(
     grpc_server* server, const char* method, const char* host,
     grpc_server_register_method_payload_handling payload_handling,
@@ -1134,31 +1216,6 @@ void grpc_server_get_pollsets(grpc_server* server, grpc_pollset*** pollsets,
   *pollsets = server->pollsets;
 }
 
-class ConnectivityWatcher
-    : public grpc_core::AsyncConnectivityStateWatcherInterface {
- public:
-  explicit ConnectivityWatcher(channel_data* chand) : chand_(chand) {
-    GRPC_CHANNEL_INTERNAL_REF(chand_->channel, "connectivity");
-  }
-
-  ~ConnectivityWatcher() {
-    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel, "connectivity");
-  }
-
- private:
-  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
-    // Don't do anything until we are being shut down.
-    if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
-    // Shut down channel.
-    grpc_server* server = chand_->server;
-    gpr_mu_lock(&server->mu_global);
-    destroy_channel(chand_);
-    gpr_mu_unlock(&server->mu_global);
-  }
-
-  channel_data* chand_;
-};
-
 void grpc_server_setup_transport(
     grpc_server* s, grpc_transport* transport, grpc_pollset* accepting_pollset,
     const grpc_channel_args* args,
@@ -1258,19 +1315,6 @@ void grpc_server_setup_transport(
   grpc_transport_perform_op(transport, op);
 }
 
-void done_published_shutdown(void* done_arg, grpc_cq_completion* storage) {
-  (void)done_arg;
-  gpr_free(storage);
-}
-
-static void listener_destroy_done(void* s, grpc_error* /*error*/) {
-  grpc_server* server = static_cast<grpc_server*>(s);
-  gpr_mu_lock(&server->mu_global);
-  server->listeners_destroyed++;
-  maybe_finish_shutdown(server);
-  gpr_mu_unlock(&server->mu_global);
-}
-
 /*
   - Kills all pending requests-for-incoming-RPC-calls (i.e the requests made via
     grpc_server_request_call and grpc_server_request_registered call will now be
@@ -1420,50 +1464,6 @@ void grpc_server_add_listener(
   server->listeners = l;
 }
 
-static grpc_call_error queue_call_request(grpc_server* server, size_t cq_idx,
-                                          requested_call* rc) {
-  call_data* calld = nullptr;
-  request_matcher* rm = nullptr;
-  if (gpr_atm_acq_load(&server->shutdown_flag)) {
-    fail_call(server, cq_idx, rc,
-              GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
-    return GRPC_CALL_OK;
-  }
-  switch (rc->type) {
-    case BATCH_CALL:
-      rm = &server->unregistered_request_matcher;
-      break;
-    case REGISTERED_CALL:
-      rm = &rc->data.registered.method->matcher;
-      break;
-  }
-  if (rm->requests_per_cq[cq_idx].Push(rc->mpscq_node.get())) {
-    /* this was the first queued request: we need to lock and start
-       matching calls */
-    gpr_mu_lock(&server->mu_call);
-    while ((calld = rm->pending_head) != nullptr) {
-      rc = reinterpret_cast<requested_call*>(rm->requests_per_cq[cq_idx].Pop());
-      if (rc == nullptr) break;
-      rm->pending_head = calld->pending_next;
-      gpr_mu_unlock(&server->mu_call);
-      if (!gpr_atm_full_cas(&calld->state, PENDING, ACTIVATED)) {
-        // Zombied Call
-        GRPC_CLOSURE_INIT(
-            &calld->kill_zombie_closure, kill_zombie,
-            grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0),
-            grpc_schedule_on_exec_ctx);
-        grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
-                                GRPC_ERROR_NONE);
-      } else {
-        publish_call(server, calld, cq_idx, rc);
-      }
-      gpr_mu_lock(&server->mu_call);
-    }
-    gpr_mu_unlock(&server->mu_call);
-  }
-  return GRPC_CALL_OK;
-}
-
 grpc_call_error grpc_server_request_call(
     grpc_server* server, grpc_call** call, grpc_call_details* details,
     grpc_metadata_array* initial_metadata,
@@ -1498,9 +1498,7 @@ grpc_call_error grpc_server_request_call(
     goto done;
   }
   details->reserved = nullptr;
-  rc->cq_idx = cq_idx;
   rc->type = BATCH_CALL;
-  rc->server = server;
   rc->tag = tag;
   rc->cq_bound_to_call = cq_bound_to_call;
   rc->call = call;
@@ -1551,9 +1549,7 @@ grpc_call_error grpc_server_request_registered_call(
     gpr_free(rc);
     return GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN;
   }
-  rc->cq_idx = cq_idx;
   rc->type = REGISTERED_CALL;
-  rc->server = server;
   rc->tag = tag;
   rc->cq_bound_to_call = cq_bound_to_call;
   rc->call = call;
@@ -1564,16 +1560,6 @@ grpc_call_error grpc_server_request_registered_call(
   return queue_call_request(server, cq_idx, rc);
 }
 
-static void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
-                      grpc_error* error) {
-  *rc->call = nullptr;
-  rc->initial_metadata->count = 0;
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
-
-  grpc_cq_end_op(server->cqs[cq_idx], rc->tag, error, done_request_event, rc,
-                 &rc->completion);
-}
-
 const grpc_channel_args* grpc_server_get_channel_args(grpc_server* server) {
   return server->channel_args;
 }

src/objective-c/tests/Tests.xcodeproj/xcshareddata/xcschemes/InteropTests.xcscheme

@@ -66,8 +66,13 @@
             ReferencedContainer = "container:Tests.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
-      <AdditionalOptions>
-      </AdditionalOptions>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "GRPC_CFSTREAM_RUN_LOOP"
+            value = "1"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+      </EnvironmentVariables>
    </LaunchAction>
    <ProfileAction
       buildConfiguration = "Test"

src/objective-c/tests/Tests.xcodeproj/xcshareddata/xcschemes/MacTests.xcscheme

@@ -69,8 +69,13 @@
             ReferencedContainer = "container:Tests.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
-      <AdditionalOptions>
-      </AdditionalOptions>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "GRPC_CFSTREAM_RUN_LOOP"
+            value = "1"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+      </EnvironmentVariables>
    </LaunchAction>
    <ProfileAction
       buildConfiguration = "Release"

src/objective-c/tests/Tests.xcodeproj/xcshareddata/xcschemes/PerfTests.xcscheme

@@ -96,8 +96,13 @@
             ReferencedContainer = "container:Tests.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
-      <AdditionalOptions>
-      </AdditionalOptions>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "GRPC_CFSTREAM_RUN_LOOP"
+            value = "1"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+      </EnvironmentVariables>
    </LaunchAction>
    <ProfileAction
       buildConfiguration = "Release"

src/objective-c/tests/Tests.xcodeproj/xcshareddata/xcschemes/TvTests.xcscheme

@@ -66,8 +66,13 @@
             ReferencedContainer = "container:Tests.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
-      <AdditionalOptions>
-      </AdditionalOptions>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "GRPC_CFSTREAM_RUN_LOOP"
+            value = "1"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+      </EnvironmentVariables>
    </LaunchAction>
    <ProfileAction
       buildConfiguration = "Release"

src/objective-c/tests/Tests.xcodeproj/xcshareddata/xcschemes/UnitTests.xcscheme

@@ -61,8 +61,13 @@
             ReferencedContainer = "container:Tests.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
-      <AdditionalOptions>
-      </AdditionalOptions>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "GRPC_CFSTREAM_RUN_LOOP"
+            value = "1"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+      </EnvironmentVariables>
    </LaunchAction>
    <ProfileAction
       buildConfiguration = "Release"

src/python/grpcio/grpc/__init__.py

@@ -994,9 +994,9 @@ class Channel(six.with_metaclass(abc.ABCMeta)):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional behaviour for serializing the request
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional behaviour for deserializing the
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None
             is passed.
 
@@ -1014,9 +1014,9 @@ class Channel(six.with_metaclass(abc.ABCMeta)):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional behaviour for serializing the request
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional behaviour for deserializing the
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None is
             passed.
 
@@ -1034,9 +1034,9 @@ class Channel(six.with_metaclass(abc.ABCMeta)):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional behaviour for serializing the request
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional behaviour for deserializing the
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None is
             passed.
 
@@ -1054,9 +1054,9 @@ class Channel(six.with_metaclass(abc.ABCMeta)):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional behaviour for serializing the request
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional behaviour for deserializing the
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None
             is passed.
 
@@ -1271,11 +1271,11 @@ class RpcMethodHandler(six.with_metaclass(abc.ABCMeta)):
         or any arbitrary number of request messages.
       response_streaming: Whether the RPC supports exactly one response message
         or any arbitrary number of response messages.
-      request_deserializer: A callable behavior that accepts a byte string and
+      request_deserializer: A callable :term:`deserializer` that accepts a byte string and
         returns an object suitable to be passed to this object's business
         logic, or None to indicate that this object's business logic should be
         passed the raw request bytes.
-      response_serializer: A callable behavior that accepts an object produced
+      response_serializer: A callable :term:`serializer` that accepts an object produced
         by this object's business logic and returns a byte string, or None to
         indicate that the byte strings produced by this object's business logic
         should be transmitted on the wire as they are.
@@ -1496,8 +1496,8 @@ def unary_unary_rpc_method_handler(behavior,
     Args:
       behavior: The implementation of an RPC that accepts one request
         and returns one response.
-      request_deserializer: An optional behavior for request deserialization.
-      response_serializer: An optional behavior for response serialization.
+      request_deserializer: An optional :term:`deserializer` for request deserialization.
+      response_serializer: An optional :term:`serializer` for response serialization.
 
     Returns:
       An RpcMethodHandler object that is typically used by grpc.Server.
@@ -1516,8 +1516,8 @@ def unary_stream_rpc_method_handler(behavior,
     Args:
       behavior: The implementation of an RPC that accepts one request
         and returns an iterator of response values.
-      request_deserializer: An optional behavior for request deserialization.
-      response_serializer: An optional behavior for response serialization.
+      request_deserializer: An optional :term:`deserializer` for request deserialization.
+      response_serializer: An optional :term:`serializer` for response serialization.
 
     Returns:
       An RpcMethodHandler object that is typically used by grpc.Server.
@@ -1536,8 +1536,8 @@ def stream_unary_rpc_method_handler(behavior,
     Args:
       behavior: The implementation of an RPC that accepts an iterator of
         request values and returns a single response value.
-      request_deserializer: An optional behavior for request deserialization.
-      response_serializer: An optional behavior for response serialization.
+      request_deserializer: An optional :term:`deserializer` for request deserialization.
+      response_serializer: An optional :term:`serializer` for response serialization.
 
     Returns:
       An RpcMethodHandler object that is typically used by grpc.Server.
@@ -1556,8 +1556,8 @@ def stream_stream_rpc_method_handler(behavior,
     Args:
       behavior: The implementation of an RPC that accepts an iterator of
         request values and returns an iterator of response values.
-      request_deserializer: An optional behavior for request deserialization.
-      response_serializer: An optional behavior for response serialization.
+      request_deserializer: An optional :term:`deserializer` for request deserialization.
+      response_serializer: An optional :term:`serializer` for response serialization.
 
     Returns:
       An RpcMethodHandler object that is typically used by grpc.Server.

src/python/grpcio/grpc/_cython/_cygrpc/aio/server.pyx.pxi

@@ -264,10 +264,15 @@ async def _finish_handler_with_unary_response(RPCState rpc_state,
     rpc_state.raise_for_termination()
 
     # Serializes the response message
-    cdef bytes response_raw = serialize(
-        response_serializer,
-        response_message,
-    )
+    cdef bytes response_raw
+    if rpc_state.status_code == StatusCode.ok:
+        response_raw = serialize(
+            response_serializer,
+            response_message,
+        )
+    else:
+        # Discards the response message if the status code is non-OK.
+        response_raw = b''
 
     # Assembles the batch operations
     cdef tuple finish_ops
@@ -541,7 +546,10 @@ async def _handle_cancellation_from_core(object rpc_task,
     # Awaits cancellation from peer.
     await execute_batch(rpc_state, ops, loop)
     rpc_state.client_closed = True
-    if op.cancelled() and not rpc_task.done():
+    # If 1) received cancel signal; 2) the Task is not finished; 3) the server
+    # wasn't replying final status. For condition 3, it might cause inaccurate
+    # log that an RPC is both aborted and cancelled.
+    if op.cancelled() and not rpc_task.done() and not rpc_state.status_sent:
         # Injects `CancelledError` to halt the RPC coroutine
         rpc_task.cancel()
 

src/python/grpcio/grpc/_cython/_cygrpc/operation.pyx.pxi

@@ -49,7 +49,10 @@ cdef class SendInitialMetadataOperation(Operation):
 cdef class SendMessageOperation(Operation):
 
   def __cinit__(self, bytes message, int flags):
-    self._message = message
+    if message is None:
+      self._message = b''
+    else:
+      self._message = message
     self._flags = flags
 
   def type(self):

src/python/grpcio/grpc/_simple_stubs.py

@@ -192,9 +192,9 @@ def unary_unary(
       request: An iterator that yields request values for the RPC.
       target: The server address.
       method: The name of the RPC method.
-      request_serializer: Optional behaviour for serializing the request
+      request_serializer: Optional :term:`serializer` for serializing the request
         message. Request goes unserialized in case None is passed.
-      response_deserializer: Optional behaviour for deserializing the response
+      response_deserializer: Optional :term:`deserializer` for deserializing the response
         message. Response goes undeserialized in case None is passed.
       options: An optional list of key-value pairs (channel args in gRPC Core
         runtime) to configure the channel.
@@ -263,9 +263,9 @@ def unary_stream(
       request: An iterator that yields request values for the RPC.
       target: The server address.
       method: The name of the RPC method.
-      request_serializer: Optional behaviour for serializing the request
+      request_serializer: Optional :term:`serializer` for serializing the request
         message. Request goes unserialized in case None is passed.
-      response_deserializer: Optional behaviour for deserializing the response
+      response_deserializer: Optional :term:`deserializer` for deserializing the response
         message. Response goes undeserialized in case None is passed.
       options: An optional list of key-value pairs (channel args in gRPC Core
         runtime) to configure the channel.
@@ -333,9 +333,9 @@ def stream_unary(
       request_iterator: An iterator that yields request values for the RPC.
       target: The server address.
       method: The name of the RPC method.
-      request_serializer: Optional behaviour for serializing the request
+      request_serializer: Optional :term:`serializer` for serializing the request
         message. Request goes unserialized in case None is passed.
-      response_deserializer: Optional behaviour for deserializing the response
+      response_deserializer: Optional :term:`deserializer` for deserializing the response
         message. Response goes undeserialized in case None is passed.
       options: An optional list of key-value pairs (channel args in gRPC Core
         runtime) to configure the channel.
@@ -403,9 +403,9 @@ def stream_stream(
       request_iterator: An iterator that yields request values for the RPC.
       target: The server address.
       method: The name of the RPC method.
-      request_serializer: Optional behaviour for serializing the request
+      request_serializer: Optional :term:`serializer` for serializing the request
         message. Request goes unserialized in case None is passed.
-      response_deserializer: Optional behaviour for deserializing the response
+      response_deserializer: Optional :term:`deserializer` for deserializing the response
         message. Response goes undeserialized in case None is passed.
       options: An optional list of key-value pairs (channel args in gRPC Core
         runtime) to configure the channel.

src/python/grpcio/grpc/experimental/aio/_base_channel.py

@@ -274,9 +274,9 @@ class Channel(abc.ABC):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional behaviour for serializing the request
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional behaviour for deserializing the
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None
             is passed.
 
@@ -295,9 +295,9 @@ class Channel(abc.ABC):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional behaviour for serializing the request
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional behaviour for deserializing the
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None
             is passed.
 
@@ -316,9 +316,9 @@ class Channel(abc.ABC):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional behaviour for serializing the request
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional behaviour for deserializing the
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None
             is passed.
 
@@ -337,9 +337,9 @@ class Channel(abc.ABC):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional behaviour for serializing the request
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional behaviour for deserializing the
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None
             is passed.
 

src/python/grpcio/grpc_core_dependencies.py

@@ -265,6 +265,7 @@ CORE_SOURCE_FILES = [
     'src/core/lib/iomgr/endpoint_pair_windows.cc',
     'src/core/lib/iomgr/error.cc',
     'src/core/lib/iomgr/error_cfstream.cc',
+    'src/core/lib/iomgr/ev_apple.cc',
     'src/core/lib/iomgr/ev_epoll1_linux.cc',
     'src/core/lib/iomgr/ev_epollex_linux.cc',
     'src/core/lib/iomgr/ev_poll_posix.cc',

src/python/grpcio_reflection/grpc_reflection/v1alpha/BUILD.bazel

@@ -17,7 +17,7 @@ py_grpc_library(
 
 py_library(
     name = "grpc_reflection",
-    srcs = ["reflection.py"],
+    srcs = glob(["*.py"]),
     imports = ["../../"],
     deps = [
         ":reflection_py_pb2",

src/python/grpcio_reflection/grpc_reflection/v1alpha/_async.py

@@ -0,0 +1,57 @@
+# Copyright 2020 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.
+"""The AsyncIO version of the reflection servicer."""
+
+from typing import AsyncIterable
+
+import grpc
+
+from grpc_reflection.v1alpha import reflection_pb2 as _reflection_pb2
+from grpc_reflection.v1alpha._base import BaseReflectionServicer
+
+
+class ReflectionServicer(BaseReflectionServicer):
+    """Servicer handling RPCs for service statuses."""
+
+    async def ServerReflectionInfo(
+            self, request_iterator: AsyncIterable[
+                _reflection_pb2.ServerReflectionRequest], unused_context
+    ) -> AsyncIterable[_reflection_pb2.ServerReflectionResponse]:
+        async for request in request_iterator:
+            if request.HasField('file_by_filename'):
+                yield self._file_by_filename(request.file_by_filename)
+            elif request.HasField('file_containing_symbol'):
+                yield self._file_containing_symbol(
+                    request.file_containing_symbol)
+            elif request.HasField('file_containing_extension'):
+                yield self._file_containing_extension(
+                    request.file_containing_extension.containing_type,
+                    request.file_containing_extension.extension_number)
+            elif request.HasField('all_extension_numbers_of_type'):
+                yield self._all_extension_numbers_of_type(
+                    request.all_extension_numbers_of_type)
+            elif request.HasField('list_services'):
+                yield self._list_services()
+            else:
+                yield _reflection_pb2.ServerReflectionResponse(
+                    error_response=_reflection_pb2.ErrorResponse(
+                        error_code=grpc.StatusCode.INVALID_ARGUMENT.value[0],
+                        error_message=grpc.StatusCode.INVALID_ARGUMENT.value[1].
+                        encode(),
+                    ))
+
+
+__all__ = [
+    "ReflectionServicer",
+]

src/python/grpcio_reflection/grpc_reflection/v1alpha/_base.py

@@ -0,0 +1,110 @@
+# Copyright 2020 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.
+"""Base implementation of reflection servicer."""
+
+import grpc
+from google.protobuf import descriptor_pb2
+from google.protobuf import descriptor_pool
+
+from grpc_reflection.v1alpha import reflection_pb2 as _reflection_pb2
+from grpc_reflection.v1alpha import reflection_pb2_grpc as _reflection_pb2_grpc
+
+_POOL = descriptor_pool.Default()
+
+
+def _not_found_error():
+    return _reflection_pb2.ServerReflectionResponse(
+        error_response=_reflection_pb2.ErrorResponse(
+            error_code=grpc.StatusCode.NOT_FOUND.value[0],
+            error_message=grpc.StatusCode.NOT_FOUND.value[1].encode(),
+        ))
+
+
+def _file_descriptor_response(descriptor):
+    proto = descriptor_pb2.FileDescriptorProto()
+    descriptor.CopyToProto(proto)
+    serialized_proto = proto.SerializeToString()
+    return _reflection_pb2.ServerReflectionResponse(
+        file_descriptor_response=_reflection_pb2.FileDescriptorResponse(
+            file_descriptor_proto=(serialized_proto,)),)
+
+
+class BaseReflectionServicer(_reflection_pb2_grpc.ServerReflectionServicer):
+    """Base class for reflection servicer."""
+
+    def __init__(self, service_names, pool=None):
+        """Constructor.
+
+        Args:
+            service_names: Iterable of fully-qualified service names available.
+            pool: An optional DescriptorPool instance.
+        """
+        self._service_names = tuple(sorted(service_names))
+        self._pool = _POOL if pool is None else pool
+
+    def _file_by_filename(self, filename):
+        try:
+            descriptor = self._pool.FindFileByName(filename)
+        except KeyError:
+            return _not_found_error()
+        else:
+            return _file_descriptor_response(descriptor)
+
+    def _file_containing_symbol(self, fully_qualified_name):
+        try:
+            descriptor = self._pool.FindFileContainingSymbol(
+                fully_qualified_name)
+        except KeyError:
+            return _not_found_error()
+        else:
+            return _file_descriptor_response(descriptor)
+
+    def _file_containing_extension(self, containing_type, extension_number):
+        try:
+            message_descriptor = self._pool.FindMessageTypeByName(
+                containing_type)
+            extension_descriptor = self._pool.FindExtensionByNumber(
+                message_descriptor, extension_number)
+            descriptor = self._pool.FindFileContainingSymbol(
+                extension_descriptor.full_name)
+        except KeyError:
+            return _not_found_error()
+        else:
+            return _file_descriptor_response(descriptor)
+
+    def _all_extension_numbers_of_type(self, containing_type):
+        try:
+            message_descriptor = self._pool.FindMessageTypeByName(
+                containing_type)
+            extension_numbers = tuple(
+                sorted(extension.number for extension in
+                       self._pool.FindAllExtensions(message_descriptor)))
+        except KeyError:
+            return _not_found_error()
+        else:
+            return _reflection_pb2.ServerReflectionResponse(
+                all_extension_numbers_response=_reflection_pb2.
+                ExtensionNumberResponse(
+                    base_type_name=message_descriptor.full_name,
+                    extension_number=extension_numbers))
+
+    def _list_services(self):
+        return _reflection_pb2.ServerReflectionResponse(
+            list_services_response=_reflection_pb2.ListServiceResponse(service=[
+                _reflection_pb2.ServiceResponse(name=service_name)
+                for service_name in self._service_names
+            ]))
+
+
+__all__ = ['BaseReflectionServicer']

src/python/grpcio_reflection/grpc_reflection/v1alpha/reflection.py

@@ -13,100 +13,21 @@
 # limitations under the License.
 """Reference implementation for reflection in gRPC Python."""
 
+import sys
 import grpc
-from google.protobuf import descriptor_pb2
-from google.protobuf import descriptor_pool
 
 from grpc_reflection.v1alpha import reflection_pb2 as _reflection_pb2
 from grpc_reflection.v1alpha import reflection_pb2_grpc as _reflection_pb2_grpc
 
-_POOL = descriptor_pool.Default()
+from grpc_reflection.v1alpha._base import BaseReflectionServicer
+
 SERVICE_NAME = _reflection_pb2.DESCRIPTOR.services_by_name[
     'ServerReflection'].full_name
 
 
-def _not_found_error():
-    return _reflection_pb2.ServerReflectionResponse(
-        error_response=_reflection_pb2.ErrorResponse(
-            error_code=grpc.StatusCode.NOT_FOUND.value[0],
-            error_message=grpc.StatusCode.NOT_FOUND.value[1].encode(),
-        ))
-
-
-def _file_descriptor_response(descriptor):
-    proto = descriptor_pb2.FileDescriptorProto()
-    descriptor.CopyToProto(proto)
-    serialized_proto = proto.SerializeToString()
-    return _reflection_pb2.ServerReflectionResponse(
-        file_descriptor_response=_reflection_pb2.FileDescriptorResponse(
-            file_descriptor_proto=(serialized_proto,)),)
-
-
-class ReflectionServicer(_reflection_pb2_grpc.ServerReflectionServicer):
+class ReflectionServicer(BaseReflectionServicer):
     """Servicer handling RPCs for service statuses."""
 
-    def __init__(self, service_names, pool=None):
-        """Constructor.
-
-    Args:
-      service_names: Iterable of fully-qualified service names available.
-    """
-        self._service_names = tuple(sorted(service_names))
-        self._pool = _POOL if pool is None else pool
-
-    def _file_by_filename(self, filename):
-        try:
-            descriptor = self._pool.FindFileByName(filename)
-        except KeyError:
-            return _not_found_error()
-        else:
-            return _file_descriptor_response(descriptor)
-
-    def _file_containing_symbol(self, fully_qualified_name):
-        try:
-            descriptor = self._pool.FindFileContainingSymbol(
-                fully_qualified_name)
-        except KeyError:
-            return _not_found_error()
-        else:
-            return _file_descriptor_response(descriptor)
-
-    def _file_containing_extension(self, containing_type, extension_number):
-        try:
-            message_descriptor = self._pool.FindMessageTypeByName(
-                containing_type)
-            extension_descriptor = self._pool.FindExtensionByNumber(
-                message_descriptor, extension_number)
-            descriptor = self._pool.FindFileContainingSymbol(
-                extension_descriptor.full_name)
-        except KeyError:
-            return _not_found_error()
-        else:
-            return _file_descriptor_response(descriptor)
-
-    def _all_extension_numbers_of_type(self, containing_type):
-        try:
-            message_descriptor = self._pool.FindMessageTypeByName(
-                containing_type)
-            extension_numbers = tuple(
-                sorted(extension.number for extension in
-                       self._pool.FindAllExtensions(message_descriptor)))
-        except KeyError:
-            return _not_found_error()
-        else:
-            return _reflection_pb2.ServerReflectionResponse(
-                all_extension_numbers_response=_reflection_pb2.
-                ExtensionNumberResponse(
-                    base_type_name=message_descriptor.full_name,
-                    extension_number=extension_numbers))
-
-    def _list_services(self):
-        return _reflection_pb2.ServerReflectionResponse(
-            list_services_response=_reflection_pb2.ListServiceResponse(service=[
-                _reflection_pb2.ServiceResponse(name=service_name)
-                for service_name in self._service_names
-            ]))
-
     def ServerReflectionInfo(self, request_iterator, context):
         # pylint: disable=unused-argument
         for request in request_iterator:
@@ -133,13 +54,45 @@ class ReflectionServicer(_reflection_pb2_grpc.ServerReflectionServicer):
                     ))
 
 
-def enable_server_reflection(service_names, server, pool=None):
-    """Enables server reflection on a server.
+_enable_server_reflection_doc = """Enables server reflection on a server.
 
-    Args:
-      service_names: Iterable of fully-qualified service names available.
-      server: grpc.Server to which reflection service will be added.
-      pool: DescriptorPool object to use (descriptor_pool.Default() if None).
-    """
-    _reflection_pb2_grpc.add_ServerReflectionServicer_to_server(
-        ReflectionServicer(service_names, pool=pool), server)
+Args:
+    service_names: Iterable of fully-qualified service names available.
+    server: grpc.Server to which reflection service will be added.
+    pool: DescriptorPool object to use (descriptor_pool.Default() if None).
+"""
+
+if sys.version_info[0] >= 3 and sys.version_info[1] >= 6:
+    # Exposes AsyncReflectionServicer as public API.
+    from . import _async as aio
+    from grpc.experimental import aio as grpc_aio  # pylint: disable=ungrouped-imports
+
+    def enable_server_reflection(service_names, server, pool=None):
+        if isinstance(server, grpc_aio.Server):
+            _reflection_pb2_grpc.add_ServerReflectionServicer_to_server(
+                aio.ReflectionServicer(service_names, pool=pool), server)
+        else:
+            _reflection_pb2_grpc.add_ServerReflectionServicer_to_server(
+                ReflectionServicer(service_names, pool=pool), server)
+
+    enable_server_reflection.__doc__ = _enable_server_reflection_doc
+
+    __all__ = [
+        "SERVICE_NAME",
+        "ReflectionServicer",
+        "enable_server_reflection",
+        "aio",
+    ]
+else:
+
+    def enable_server_reflection(service_names, server, pool=None):
+        _reflection_pb2_grpc.add_ServerReflectionServicer_to_server(
+            ReflectionServicer(service_names, pool=pool), server)
+
+    enable_server_reflection.__doc__ = _enable_server_reflection_doc
+
+    __all__ = [
+        "SERVICE_NAME",
+        "ReflectionServicer",
+        "enable_server_reflection",
+    ]

src/python/grpcio_tests/tests_aio/reflection/BUILD.bazel

@@ -0,0 +1,30 @@
+# Copyright 2020 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.
+
+package(default_testonly = 1)
+
+py_test(
+    name = "reflection_servicer_test",
+    srcs = ["reflection_servicer_test.py"],
+    imports = ["../../"],
+    python_version = "PY3",
+    deps = [
+        "//src/proto/grpc/testing:empty_py_pb2",
+        "//src/proto/grpc/testing/proto2:empty2_extensions_proto",
+        "//src/proto/grpc/testing/proto2:empty2_proto",
+        "//src/python/grpcio/grpc:grpcio",
+        "//src/python/grpcio_reflection/grpc_reflection/v1alpha:grpc_reflection",
+        "//src/python/grpcio_tests/tests_aio/unit:_test_base",
+    ],
+)

src/python/grpcio_tests/tests_aio/reflection/__init__.py

@@ -0,0 +1,13 @@
+# 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.

src/python/grpcio_tests/tests_aio/reflection/reflection_servicer_test.py

@@ -0,0 +1,193 @@
+# 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.
+"""Tests of grpc_reflection.v1alpha.reflection."""
+
+import logging
+import unittest
+
+import grpc
+from google.protobuf import descriptor_pb2, descriptor_pool
+from grpc.experimental import aio
+
+from grpc_reflection.v1alpha import (reflection, reflection_pb2,
+                                     reflection_pb2_grpc)
+from src.proto.grpc.testing import empty_pb2
+from src.proto.grpc.testing.proto2 import empty2_extensions_pb2
+from tests_aio.unit._test_base import AioTestBase
+
+_EMPTY_PROTO_FILE_NAME = 'src/proto/grpc/testing/empty.proto'
+_EMPTY_PROTO_SYMBOL_NAME = 'grpc.testing.Empty'
+_SERVICE_NAMES = ('Angstrom', 'Bohr', 'Curie', 'Dyson', 'Einstein', 'Feynman',
+                  'Galilei')
+_EMPTY_EXTENSIONS_SYMBOL_NAME = 'grpc.testing.proto2.EmptyWithExtensions'
+_EMPTY_EXTENSIONS_NUMBERS = (
+    124,
+    125,
+    126,
+    127,
+    128,
+)
+
+
+def _file_descriptor_to_proto(descriptor):
+    proto = descriptor_pb2.FileDescriptorProto()
+    descriptor.CopyToProto(proto)
+    return proto.SerializeToString()
+
+
+class ReflectionServicerTest(AioTestBase):
+
+    async def setUp(self):
+        self._server = aio.server()
+        reflection.enable_server_reflection(_SERVICE_NAMES, self._server)
+        port = self._server.add_insecure_port('[::]:0')
+        await self._server.start()
+
+        self._channel = aio.insecure_channel('localhost:%d' % port)
+        self._stub = reflection_pb2_grpc.ServerReflectionStub(self._channel)
+
+    async def tearDown(self):
+        await self._server.stop(None)
+        await self._channel.close()
+
+    async def test_file_by_name(self):
+        requests = (
+            reflection_pb2.ServerReflectionRequest(
+                file_by_filename=_EMPTY_PROTO_FILE_NAME),
+            reflection_pb2.ServerReflectionRequest(
+                file_by_filename='i-donut-exist'),
+        )
+        responses = []
+        async for response in self._stub.ServerReflectionInfo(iter(requests)):
+            responses.append(response)
+        expected_responses = (
+            reflection_pb2.ServerReflectionResponse(
+                valid_host='',
+                file_descriptor_response=reflection_pb2.FileDescriptorResponse(
+                    file_descriptor_proto=(
+                        _file_descriptor_to_proto(empty_pb2.DESCRIPTOR),))),
+            reflection_pb2.ServerReflectionResponse(
+                valid_host='',
+                error_response=reflection_pb2.ErrorResponse(
+                    error_code=grpc.StatusCode.NOT_FOUND.value[0],
+                    error_message=grpc.StatusCode.NOT_FOUND.value[1].encode(),
+                )),
+        )
+        self.assertSequenceEqual(expected_responses, responses)
+
+    async def test_file_by_symbol(self):
+        requests = (
+            reflection_pb2.ServerReflectionRequest(
+                file_containing_symbol=_EMPTY_PROTO_SYMBOL_NAME),
+            reflection_pb2.ServerReflectionRequest(
+                file_containing_symbol='i.donut.exist.co.uk.org.net.me.name.foo'
+            ),
+        )
+        responses = []
+        async for response in self._stub.ServerReflectionInfo(iter(requests)):
+            responses.append(response)
+        expected_responses = (
+            reflection_pb2.ServerReflectionResponse(
+                valid_host='',
+                file_descriptor_response=reflection_pb2.FileDescriptorResponse(
+                    file_descriptor_proto=(
+                        _file_descriptor_to_proto(empty_pb2.DESCRIPTOR),))),
+            reflection_pb2.ServerReflectionResponse(
+                valid_host='',
+                error_response=reflection_pb2.ErrorResponse(
+                    error_code=grpc.StatusCode.NOT_FOUND.value[0],
+                    error_message=grpc.StatusCode.NOT_FOUND.value[1].encode(),
+                )),
+        )
+        self.assertSequenceEqual(expected_responses, responses)
+
+    async def test_file_containing_extension(self):
+        requests = (
+            reflection_pb2.ServerReflectionRequest(
+                file_containing_extension=reflection_pb2.ExtensionRequest(
+                    containing_type=_EMPTY_EXTENSIONS_SYMBOL_NAME,
+                    extension_number=125,
+                ),),
+            reflection_pb2.ServerReflectionRequest(
+                file_containing_extension=reflection_pb2.ExtensionRequest(
+                    containing_type='i.donut.exist.co.uk.org.net.me.name.foo',
+                    extension_number=55,
+                ),),
+        )
+        responses = []
+        async for response in self._stub.ServerReflectionInfo(iter(requests)):
+            responses.append(response)
+        expected_responses = (
+            reflection_pb2.ServerReflectionResponse(
+                valid_host='',
+                file_descriptor_response=reflection_pb2.FileDescriptorResponse(
+                    file_descriptor_proto=(_file_descriptor_to_proto(
+                        empty2_extensions_pb2.DESCRIPTOR),))),
+            reflection_pb2.ServerReflectionResponse(
+                valid_host='',
+                error_response=reflection_pb2.ErrorResponse(
+                    error_code=grpc.StatusCode.NOT_FOUND.value[0],
+                    error_message=grpc.StatusCode.NOT_FOUND.value[1].encode(),
+                )),
+        )
+        self.assertSequenceEqual(expected_responses, responses)
+
+    async def test_extension_numbers_of_type(self):
+        requests = (
+            reflection_pb2.ServerReflectionRequest(
+                all_extension_numbers_of_type=_EMPTY_EXTENSIONS_SYMBOL_NAME),
+            reflection_pb2.ServerReflectionRequest(
+                all_extension_numbers_of_type='i.donut.exist.co.uk.net.name.foo'
+            ),
+        )
+        responses = []
+        async for response in self._stub.ServerReflectionInfo(iter(requests)):
+            responses.append(response)
+        expected_responses = (
+            reflection_pb2.ServerReflectionResponse(
+                valid_host='',
+                all_extension_numbers_response=reflection_pb2.
+                ExtensionNumberResponse(
+                    base_type_name=_EMPTY_EXTENSIONS_SYMBOL_NAME,
+                    extension_number=_EMPTY_EXTENSIONS_NUMBERS)),
+            reflection_pb2.ServerReflectionResponse(
+                valid_host='',
+                error_response=reflection_pb2.ErrorResponse(
+                    error_code=grpc.StatusCode.NOT_FOUND.value[0],
+                    error_message=grpc.StatusCode.NOT_FOUND.value[1].encode(),
+                )),
+        )
+        self.assertSequenceEqual(expected_responses, responses)
+
+    async def test_list_services(self):
+        requests = (reflection_pb2.ServerReflectionRequest(list_services='',),)
+        responses = []
+        async for response in self._stub.ServerReflectionInfo(iter(requests)):
+            responses.append(response)
+        expected_responses = (reflection_pb2.ServerReflectionResponse(
+            valid_host='',
+            list_services_response=reflection_pb2.ListServiceResponse(
+                service=tuple(
+                    reflection_pb2.ServiceResponse(name=name)
+                    for name in _SERVICE_NAMES))),)
+        self.assertSequenceEqual(expected_responses, responses)
+
+    def test_reflection_service_name(self):
+        self.assertEqual(reflection.SERVICE_NAME,
+                         'grpc.reflection.v1alpha.ServerReflection')
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.DEBUG)
+    unittest.main(verbosity=2)

src/python/grpcio_tests/tests_aio/tests.json

@@ -3,6 +3,7 @@
   "health_check.health_servicer_test.HealthServicerTest",
   "interop.local_interop_test.InsecureLocalInteropTest",
   "interop.local_interop_test.SecureLocalInteropTest",
+  "reflection.reflection_servicer_test.ReflectionServicerTest",
   "unit._metadata_test.TestTypeMetadata",
   "unit.abort_test.TestAbort",
   "unit.aio_rpc_error_test.TestAioRpcError",

src/python/grpcio_tests/tests_aio/unit/server_test.py

@@ -38,6 +38,8 @@ _STREAM_STREAM_READER_WRITER = '/test/StreamStreamReaderWriter'
 _STREAM_STREAM_EVILLY_MIXED = '/test/StreamStreamEvillyMixed'
 _UNIMPLEMENTED_METHOD = '/test/UnimplementedMethod'
 _ERROR_IN_STREAM_STREAM = '/test/ErrorInStreamStream'
+_ERROR_WITHOUT_RAISE_IN_UNARY_UNARY = '/test/ErrorWithoutRaiseInUnaryUnary'
+_ERROR_WITHOUT_RAISE_IN_STREAM_STREAM = '/test/ErrorWithoutRaiseInStreamStream'
 
 _REQUEST = b'\x00\x00\x00'
 _RESPONSE = b'\x01\x01\x01'
@@ -86,6 +88,12 @@ class _GenericHandler(grpc.GenericRpcHandler):
             _ERROR_IN_STREAM_STREAM:
                 grpc.stream_stream_rpc_method_handler(
                     self._error_in_stream_stream),
+            _ERROR_WITHOUT_RAISE_IN_UNARY_UNARY:
+                grpc.unary_unary_rpc_method_handler(
+                    self._error_without_raise_in_unary_unary),
+            _ERROR_WITHOUT_RAISE_IN_STREAM_STREAM:
+                grpc.stream_stream_rpc_method_handler(
+                    self._error_without_raise_in_stream_stream),
         }
 
     @staticmethod
@@ -168,6 +176,16 @@ class _GenericHandler(grpc.GenericRpcHandler):
             raise RuntimeError('A testing RuntimeError!')
         yield _RESPONSE
 
+    async def _error_without_raise_in_unary_unary(self, request, context):
+        assert _REQUEST == request
+        context.set_code(grpc.StatusCode.INTERNAL)
+
+    async def _error_without_raise_in_stream_stream(self, request_iterator,
+                                                    context):
+        async for request in request_iterator:
+            assert _REQUEST == request
+        context.set_code(grpc.StatusCode.INTERNAL)
+
     def service(self, handler_details):
         self._called.set_result(None)
         return self._routing_table.get(handler_details.method)
@@ -426,6 +444,26 @@ class TestServer(AioTestBase):
         # Don't segfault here
         self.assertEqual(grpc.StatusCode.UNKNOWN, await call.code())
 
+    async def test_error_without_raise_in_unary_unary(self):
+        call = self._channel.unary_unary(_ERROR_WITHOUT_RAISE_IN_UNARY_UNARY)(
+            _REQUEST)
+
+        with self.assertRaises(aio.AioRpcError) as exception_context:
+            await call
+
+        rpc_error = exception_context.exception
+        self.assertEqual(grpc.StatusCode.INTERNAL, rpc_error.code())
+
+    async def test_error_without_raise_in_stream_stream(self):
+        call = self._channel.stream_stream(
+            _ERROR_WITHOUT_RAISE_IN_STREAM_STREAM)()
+
+        for _ in range(_NUM_STREAM_REQUESTS):
+            await call.write(_REQUEST)
+        await call.done_writing()
+
+        self.assertEqual(grpc.StatusCode.INTERNAL, await call.code())
+
 
 if __name__ == '__main__':
     logging.basicConfig(level=logging.DEBUG)

test/core/end2end/fixtures/h2_oauth2.cc

@@ -31,8 +31,6 @@
 #include "test/core/util/test_config.h"
 
 #define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
-#define CLIENT_CERT_PATH "src/core/tsi/test_creds/client.pem"
-#define CLIENT_KEY_PATH "src/core/tsi/test_creds/client.key"
 #define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
 #define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
 

test/core/end2end/fixtures/h2_ssl.cc

@@ -31,9 +31,8 @@
 #include "test/core/end2end/end2end_tests.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
+
 #define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
-#define CLIENT_CERT_PATH "src/core/tsi/test_creds/client.pem"
-#define CLIENT_KEY_PATH "src/core/tsi/test_creds/client.key"
 #define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
 #define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
 

test/core/end2end/fixtures/h2_ssl_cred_reload.cc

@@ -16,24 +16,26 @@
  *
  */
 
-#include "test/core/end2end/end2end_tests.h"
-
-#include <stdio.h>
-#include <string.h>
-
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <stdio.h>
+#include <string.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/tmpfile.h"
 #include "src/core/lib/gprpp/host_port.h"
+#include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/ssl_utils_config.h"
-#include "test/core/end2end/data/ssl_test_data.h"
+#include "test/core/end2end/end2end_tests.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
+#define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
+#define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
+#define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
+
 struct fullstack_secure_fixture_data {
   grpc_core::UniquePtr<char> localaddr;
   bool server_credential_reloaded = false;
@@ -48,10 +50,25 @@ ssl_server_certificate_config_callback(
   fullstack_secure_fixture_data* ffd =
       static_cast<fullstack_secure_fixture_data*>(user_data);
   if (!ffd->server_credential_reloaded) {
-    grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {test_server1_key,
-                                                    test_server1_cert};
-    *config = grpc_ssl_server_certificate_config_create(test_root_cert,
+    grpc_slice ca_slice, cert_slice, key_slice;
+    GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                                 grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
+    GPR_ASSERT(GRPC_LOG_IF_ERROR(
+        "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
+    GPR_ASSERT(GRPC_LOG_IF_ERROR(
+        "load_file", grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
+    const char* ca_cert =
+        reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
+    const char* server_cert =
+        reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+    const char* server_key =
+        reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+    grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {server_key, server_cert};
+    *config = grpc_ssl_server_certificate_config_create(ca_cert,
                                                         &pem_key_cert_pair, 1);
+    grpc_slice_unref(cert_slice);
+    grpc_slice_unref(key_slice);
+    grpc_slice_unref(ca_slice);
     ffd->server_credential_reloaded = true;
     return GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW;
   } else {
@@ -175,20 +192,10 @@ static grpc_end2end_test_config configs[] = {
 
 int main(int argc, char** argv) {
   size_t i;
-  FILE* roots_file;
-  size_t roots_size = strlen(test_root_cert);
-  char* roots_filename;
 
   grpc::testing::TestEnvironment env(argc, argv);
   grpc_end2end_tests_pre_init();
-
-  /* Set the SSL roots env var. */
-  roots_file = gpr_tmpfile("chttp2_simple_ssl_fullstack_test", &roots_filename);
-  GPR_ASSERT(roots_filename != nullptr);
-  GPR_ASSERT(roots_file != nullptr);
-  GPR_ASSERT(fwrite(test_root_cert, 1, roots_size, roots_file) == roots_size);
-  fclose(roots_file);
-  GPR_GLOBAL_CONFIG_SET(grpc_default_ssl_roots_file_path, roots_filename);
+  GPR_GLOBAL_CONFIG_SET(grpc_default_ssl_roots_file_path, CA_CERT_PATH);
 
   grpc_init();
 
@@ -198,9 +205,5 @@ int main(int argc, char** argv) {
 
   grpc_shutdown();
 
-  /* Cleanup. */
-  remove(roots_filename);
-  gpr_free(roots_filename);
-
   return 0;
 }

test/core/end2end/fixtures/h2_ssl_proxy.cc

@@ -16,24 +16,26 @@
  *
  */
 
-#include "test/core/end2end/end2end_tests.h"
-
-#include <stdio.h>
-#include <string.h>
-
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <stdio.h>
+#include <string.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/tmpfile.h"
+#include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/ssl_utils_config.h"
-#include "test/core/end2end/data/ssl_test_data.h"
+#include "test/core/end2end/end2end_tests.h"
 #include "test/core/end2end/fixtures/proxy.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
+#define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
+#define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
+#define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
+
 typedef struct fullstack_secure_fixture_data {
   grpc_end2end_proxy* proxy;
 } fullstack_secure_fixture_data;
@@ -41,10 +43,20 @@ typedef struct fullstack_secure_fixture_data {
 static grpc_server* create_proxy_server(const char* port,
                                         grpc_channel_args* server_args) {
   grpc_server* s = grpc_server_create(server_args, nullptr);
-  grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
-                                                  test_server1_cert};
+  grpc_slice cert_slice, key_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
+  const char* server_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+  const char* server_key =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+  grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {server_key, server_cert};
   grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
-      nullptr, &pem_cert_key_pair, 1, 0, nullptr);
+      nullptr, &pem_key_cert_pair, 1, 0, nullptr);
+  grpc_slice_unref(cert_slice);
+  grpc_slice_unref(key_slice);
   GPR_ASSERT(grpc_server_add_secure_http2_port(s, port, ssl_creds));
   grpc_server_credentials_release(ssl_creds);
   return s;
@@ -166,10 +178,20 @@ static int fail_server_auth_check(grpc_channel_args* server_args) {
 
 static void chttp2_init_server_simple_ssl_secure_fullstack(
     grpc_end2end_test_fixture* f, grpc_channel_args* server_args) {
-  grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
-                                                  test_server1_cert};
+  grpc_slice cert_slice, key_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
+  const char* server_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+  const char* server_key =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+  grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {server_key, server_cert};
   grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
-      nullptr, &pem_cert_key_pair, 1, 0, nullptr);
+      nullptr, &pem_key_cert_pair, 1, 0, nullptr);
+  grpc_slice_unref(cert_slice);
+  grpc_slice_unref(key_slice);
   if (fail_server_auth_check(server_args)) {
     grpc_auth_metadata_processor processor = {process_auth_failure, nullptr,
                                               nullptr};
@@ -195,20 +217,10 @@ static grpc_end2end_test_config configs[] = {
 
 int main(int argc, char** argv) {
   size_t i;
-  FILE* roots_file;
-  size_t roots_size = strlen(test_root_cert);
-  char* roots_filename;
 
   grpc::testing::TestEnvironment env(argc, argv);
   grpc_end2end_tests_pre_init();
-
-  /* Set the SSL roots env var. */
-  roots_file = gpr_tmpfile("chttp2_simple_ssl_fullstack_test", &roots_filename);
-  GPR_ASSERT(roots_filename != nullptr);
-  GPR_ASSERT(roots_file != nullptr);
-  GPR_ASSERT(fwrite(test_root_cert, 1, roots_size, roots_file) == roots_size);
-  fclose(roots_file);
-  GPR_GLOBAL_CONFIG_SET(grpc_default_ssl_roots_file_path, roots_filename);
+  GPR_GLOBAL_CONFIG_SET(grpc_default_ssl_roots_file_path, CA_CERT_PATH);
 
   grpc_init();
 
@@ -218,9 +230,5 @@ int main(int argc, char** argv) {
 
   grpc_shutdown();
 
-  /* Cleanup. */
-  remove(roots_filename);
-  gpr_free(roots_filename);
-
   return 0;
 }

test/core/end2end/fixtures/h2_tls.cc

@@ -30,14 +30,18 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/thd.h"
+#include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"
 #include "src/core/lib/security/security_connector/ssl_utils_config.h"
-#include "test/core/end2end/data/ssl_test_data.h"
 #include "test/core/end2end/end2end_tests.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
+#define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
+#define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
+#define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
+
 typedef grpc_core::InlinedVector<grpc_core::Thread, 1> ThreadList;
 
 struct fullstack_secure_fixture_data {
@@ -140,17 +144,30 @@ static int client_cred_reload_sync(void* /*config_user_data*/,
     arg->status = GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED;
     return 0;
   }
-  const grpc_ssl_pem_key_cert_pair pem_key_pair = {
-      test_server1_key,
-      test_server1_cert,
-  };
+  grpc_slice ca_slice, cert_slice, key_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
+  const char* ca_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
+  const char* server_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+  const char* server_key =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+  grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {server_key, server_cert};
   if (arg->key_materials_config->pem_key_cert_pair_list().empty()) {
-    const auto* pem_key_pair_ptr = &pem_key_pair;
+    const auto* pem_key_cert_pair_ptr = &pem_key_cert_pair;
     grpc_tls_key_materials_config_set_key_materials(
-        arg->key_materials_config, test_root_cert, &pem_key_pair_ptr, 1);
+        arg->key_materials_config, ca_cert, &pem_key_cert_pair_ptr, 1);
   }
   // new credential has been reloaded.
   arg->status = GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW;
+  grpc_slice_unref(cert_slice);
+  grpc_slice_unref(key_slice);
+  grpc_slice_unref(ca_slice);
   return 0;
 }
 
@@ -163,21 +180,34 @@ static int server_cred_reload_sync(void* /*config_user_data*/,
     arg->status = GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED;
     return 0;
   }
-  const grpc_ssl_pem_key_cert_pair pem_key_pair = {
-      test_server1_key,
-      test_server1_cert,
-  };
+  grpc_slice ca_slice, cert_slice, key_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
+  const char* ca_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
+  const char* server_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+  const char* server_key =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+  grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {server_key, server_cert};
   GPR_ASSERT(arg != nullptr);
   GPR_ASSERT(arg->key_materials_config != nullptr);
   GPR_ASSERT(arg->key_materials_config->pem_key_cert_pair_list().data() !=
              nullptr);
   if (arg->key_materials_config->pem_key_cert_pair_list().empty()) {
-    const auto* pem_key_pair_ptr = &pem_key_pair;
+    const auto* pem_key_cert_pair_ptr = &pem_key_cert_pair;
     grpc_tls_key_materials_config_set_key_materials(
-        arg->key_materials_config, test_root_cert, &pem_key_pair_ptr, 1);
+        arg->key_materials_config, ca_cert, &pem_key_cert_pair_ptr, 1);
   }
   // new credential has been reloaded.
   arg->status = GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW;
+  grpc_slice_unref(cert_slice);
+  grpc_slice_unref(key_slice);
+  grpc_slice_unref(ca_slice);
   return 0;
 }
 
@@ -268,25 +298,13 @@ static grpc_end2end_test_config configs[] = {
 };
 
 int main(int argc, char** argv) {
-  FILE* roots_file;
-  size_t roots_size = strlen(test_root_cert);
-  char* roots_filename;
   grpc::testing::TestEnvironment env(argc, argv);
   grpc_end2end_tests_pre_init();
-  /* Set the SSL roots env var. */
-  roots_file = gpr_tmpfile("chttp2_simple_ssl_fullstack_test", &roots_filename);
-  GPR_ASSERT(roots_filename != nullptr);
-  GPR_ASSERT(roots_file != nullptr);
-  GPR_ASSERT(fwrite(test_root_cert, 1, roots_size, roots_file) == roots_size);
-  fclose(roots_file);
-  GPR_GLOBAL_CONFIG_SET(grpc_default_ssl_roots_file_path, roots_filename);
+  GPR_GLOBAL_CONFIG_SET(grpc_default_ssl_roots_file_path, CA_CERT_PATH);
   grpc_init();
   for (size_t ind = 0; ind < sizeof(configs) / sizeof(*configs); ind++) {
     grpc_end2end_tests(argc, argv, configs[ind]);
   }
   grpc_shutdown();
-  /* Cleanup. */
-  remove(roots_filename);
-  gpr_free(roots_filename);
   return 0;
 }

test/core/end2end/generate_tests.bzl

@@ -434,8 +434,6 @@ def grpc_end2end_tests():
             language = "C++",
             data = [
                 "//src/core/tsi/test_creds:ca.pem",
-                "//src/core/tsi/test_creds:client.key",
-                "//src/core/tsi/test_creds:client.pem",
                 "//src/core/tsi/test_creds:server1.key",
                 "//src/core/tsi/test_creds:server1.pem",
             ],
@@ -511,8 +509,6 @@ def grpc_end2end_nosec_tests():
             language = "C++",
             data = [
                 "//src/core/tsi/test_creds:ca.pem",
-                "//src/core/tsi/test_creds:client.key",
-                "//src/core/tsi/test_creds:client.pem",
                 "//src/core/tsi/test_creds:server1.key",
                 "//src/core/tsi/test_creds:server1.pem",
             ],

test/core/security/BUILD

@@ -37,6 +37,11 @@ grpc_fuzzer(
     name = "ssl_server_fuzzer",
     srcs = ["ssl_server_fuzzer.cc"],
     corpus = "corpus/ssl_server_corpus",
+    data = [
+        "//src/core/tsi/test_creds:ca.pem",
+        "//src/core/tsi/test_creds:server1.key",
+        "//src/core/tsi/test_creds:server1.pem",
+    ],
     language = "C++",
     tags = ["no_windows"],
     deps = [
@@ -248,6 +253,11 @@ grpc_cc_test(
 grpc_cc_test(
     name = "tls_security_connector_test",
     srcs = ["tls_security_connector_test.cc"],
+    data = [
+        "//src/core/tsi/test_creds:ca.pem",
+        "//src/core/tsi/test_creds:server1.key",
+        "//src/core/tsi/test_creds:server1.pem",
+    ],
     external_deps = [
         "gtest",
     ],
@@ -266,6 +276,11 @@ grpc_cc_test(
 grpc_cc_test(
     name = "grpc_tls_credentials_options_test",
     srcs = ["grpc_tls_credentials_options_test.cc"],
+    data = [
+        "//src/core/tsi/test_creds:ca.pem",
+        "//src/core/tsi/test_creds:server1.key",
+        "//src/core/tsi/test_creds:server1.pem",
+    ],
     external_deps = ["gtest"],
     language = "C++",
     deps = [

test/core/security/grpc_tls_credentials_options_test.cc

@@ -17,7 +17,6 @@
  */
 
 #include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"
-#include "test/core/end2end/data/ssl_test_data.h"
 
 #include <gmock/gmock.h>
 #include <grpc/support/alloc.h>
@@ -25,28 +24,61 @@
 #include <grpc/support/string_util.h>
 #include <gtest/gtest.h>
 
+#include "src/core/lib/iomgr/load_file.h"
+
+#define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
+#define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
+#define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
+
 namespace testing {
 
 static void SetKeyMaterials(grpc_tls_key_materials_config* config) {
-  const grpc_ssl_pem_key_cert_pair pem_key_pair = {
-      test_server1_key,
-      test_server1_cert,
-  };
-  const auto* pem_key_pair_ptr = &pem_key_pair;
-  grpc_tls_key_materials_config_set_key_materials(config, test_root_cert,
-                                                  &pem_key_pair_ptr, 1);
+  grpc_slice ca_slice, cert_slice, key_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
+  const char* ca_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
+  const char* server_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+  const char* server_key =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+  grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {server_key, server_cert};
+  const auto* pem_key_cert_pair_ptr = &pem_key_cert_pair;
+  grpc_tls_key_materials_config_set_key_materials(config, ca_cert,
+                                                  &pem_key_cert_pair_ptr, 1);
+  grpc_slice_unref(cert_slice);
+  grpc_slice_unref(key_slice);
+  grpc_slice_unref(ca_slice);
 }
 
 TEST(GrpcTlsCredentialsOptionsTest, SetKeyMaterials) {
   grpc_tls_key_materials_config* config =
       grpc_tls_key_materials_config_create();
   SetKeyMaterials(config);
-  EXPECT_STREQ(config->pem_root_certs(), test_root_cert);
+  grpc_slice ca_slice, cert_slice, key_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
+  const char* ca_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
+  const char* server_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+  const char* server_key =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+  EXPECT_STREQ(config->pem_root_certs(), ca_cert);
   EXPECT_EQ(config->pem_key_cert_pair_list().size(), 1);
-  EXPECT_STREQ(config->pem_key_cert_pair_list()[0].private_key(),
-               test_server1_key);
-  EXPECT_STREQ(config->pem_key_cert_pair_list()[0].cert_chain(),
-               test_server1_cert);
+  EXPECT_STREQ(config->pem_key_cert_pair_list()[0].private_key(), server_key);
+  EXPECT_STREQ(config->pem_key_cert_pair_list()[0].cert_chain(), server_cert);
+  grpc_slice_unref(cert_slice);
+  grpc_slice_unref(key_slice);
+  grpc_slice_unref(ca_slice);
   delete config;
 }
 

test/core/security/ssl_server_fuzzer.cc

@@ -23,9 +23,12 @@
 #include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
-#include "test/core/end2end/data/ssl_test_data.h"
 #include "test/core/util/mock_endpoint.h"
 
+#define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
+#define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
+#define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
+
 bool squelch = true;
 // ssl has an array of global gpr_mu's that are never released.
 // Turning this on will fail the leak check.
@@ -66,18 +69,25 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
         mock_endpoint, grpc_slice_from_copied_buffer((const char*)data, size));
 
     // Load key pair and establish server SSL credentials.
-    grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
     grpc_slice ca_slice, cert_slice, key_slice;
-    ca_slice = grpc_slice_from_static_string(test_root_cert);
-    cert_slice = grpc_slice_from_static_string(test_server1_cert);
-    key_slice = grpc_slice_from_static_string(test_server1_key);
-    const char* ca_cert = (const char*)GRPC_SLICE_START_PTR(ca_slice);
-    pem_key_cert_pair.private_key =
-        (const char*)GRPC_SLICE_START_PTR(key_slice);
-    pem_key_cert_pair.cert_chain =
-        (const char*)GRPC_SLICE_START_PTR(cert_slice);
+    GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                                 grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
+    GPR_ASSERT(GRPC_LOG_IF_ERROR(
+        "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
+    GPR_ASSERT(GRPC_LOG_IF_ERROR(
+        "load_file", grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
+    const char* ca_cert =
+        reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
+    const char* server_cert =
+        reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+    const char* server_key =
+        reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+    grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {server_key, server_cert};
     grpc_server_credentials* creds = grpc_ssl_server_credentials_create(
         ca_cert, &pem_key_cert_pair, 1, 0, nullptr);
+    grpc_slice_unref(cert_slice);
+    grpc_slice_unref(key_slice);
+    grpc_slice_unref(ca_slice);
 
     // Create security connector
     grpc_core::RefCountedPtr<grpc_server_security_connector> sc =
@@ -109,9 +119,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
 
     sc.reset(DEBUG_LOCATION, "test");
     grpc_server_credentials_release(creds);
-    grpc_slice_unref(cert_slice);
-    grpc_slice_unref(key_slice);
-    grpc_slice_unref(ca_slice);
     grpc_core::ExecCtx::Get()->Flush();
   }
 

test/core/security/tls_security_connector_test.cc

@@ -26,22 +26,39 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "src/core/lib/iomgr/load_file.h"
 #include "src/core/tsi/transport_security.h"
-#include "test/core/end2end/data/ssl_test_data.h"
 #include "test/core/util/test_config.h"
 
+#define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
+#define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
+#define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
+
 namespace {
 
 enum CredReloadResult { FAIL, SUCCESS, UNCHANGED, ASYNC };
 
 void SetKeyMaterials(grpc_tls_key_materials_config* config) {
-  const grpc_ssl_pem_key_cert_pair pem_key_pair = {
-      test_server1_key,
-      test_server1_cert,
-  };
-  const auto* pem_key_pair_ptr = &pem_key_pair;
-  grpc_tls_key_materials_config_set_key_materials(config, test_root_cert,
-                                                  &pem_key_pair_ptr, 1);
+  grpc_slice ca_slice, cert_slice, key_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
+  const char* ca_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
+  const char* server_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+  const char* server_key =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+  grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {server_key, server_cert};
+  const auto* pem_key_cert_pair_ptr = &pem_key_cert_pair;
+  grpc_tls_key_materials_config_set_key_materials(config, ca_cert,
+                                                  &pem_key_cert_pair_ptr, 1);
+  grpc_slice_unref(cert_slice);
+  grpc_slice_unref(key_slice);
+  grpc_slice_unref(ca_slice);
 }
 
 int CredReloadSuccess(void* /*config_user_data*/,

test/core/surface/BUILD

@@ -102,11 +102,13 @@ grpc_cc_test(
 grpc_cc_test(
     name = "num_external_connectivity_watchers_test",
     srcs = ["num_external_connectivity_watchers_test.cc"],
+    data = [
+        "//src/core/tsi/test_creds:ca.pem",
+    ],
     language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
-        "//test/core/end2end:ssl_test_data",
         "//test/core/util:grpc_test_util",
     ],
 )
@@ -136,6 +138,11 @@ grpc_cc_test(
 grpc_cc_test(
     name = "sequential_connectivity_test",
     srcs = ["sequential_connectivity_test.cc"],
+    data = [
+        "//src/core/tsi/test_creds:ca.pem",
+        "//src/core/tsi/test_creds:server1.key",
+        "//src/core/tsi/test_creds:server1.pem",
+    ],
     flaky = True,  # TODO(b/151696318)
     language = "C++",
     deps = [

test/core/surface/num_external_connectivity_watchers_test.cc

@@ -26,10 +26,12 @@
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "test/core/end2end/data/ssl_test_data.h"
+#include "src/core/lib/iomgr/load_file.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
+#define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
+
 typedef struct test_fixture {
   const char* name;
   grpc_channel* (*create_channel)(const char* addr);
@@ -162,8 +164,14 @@ static const test_fixture insecure_test = {
 };
 
 static grpc_channel* secure_test_create_channel(const char* addr) {
+  grpc_slice ca_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
+  const char* test_root_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
   grpc_channel_credentials* ssl_creds =
       grpc_ssl_credentials_create(test_root_cert, nullptr, nullptr, nullptr);
+  grpc_slice_unref(ca_slice);
   grpc_arg ssl_name_override = {
       GRPC_ARG_STRING,
       const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),

test/core/surface/sequential_connectivity_test.cc

@@ -25,10 +25,14 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "test/core/end2end/data/ssl_test_data.h"
+#include "src/core/lib/iomgr/load_file.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
+#define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
+#define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
+#define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
+
 typedef struct test_fixture {
   const char* name;
   void (*add_server_port)(grpc_server* server, const char* addr);
@@ -139,17 +143,33 @@ static const test_fixture insecure_test = {
 };
 
 static void secure_test_add_port(grpc_server* server, const char* addr) {
-  grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
-                                                  test_server1_cert};
+  grpc_slice cert_slice, key_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
+  const char* server_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+  const char* server_key =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+  grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {server_key, server_cert};
   grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
-      nullptr, &pem_cert_key_pair, 1, 0, nullptr);
+      nullptr, &pem_key_cert_pair, 1, 0, nullptr);
+  grpc_slice_unref(cert_slice);
+  grpc_slice_unref(key_slice);
   grpc_server_add_secure_http2_port(server, addr, ssl_creds);
   grpc_server_credentials_release(ssl_creds);
 }
 
 static grpc_channel* secure_test_create_channel(const char* addr) {
+  grpc_slice ca_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
+  const char* test_root_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
   grpc_channel_credentials* ssl_creds =
       grpc_ssl_credentials_create(test_root_cert, nullptr, nullptr, nullptr);
+  grpc_slice_unref(ca_slice);
   grpc_arg ssl_name_override = {
       GRPC_ARG_STRING,
       const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),

test/core/util/grpc_fuzzer.bzl

@@ -14,12 +14,12 @@
 
 load("//bazel:grpc_build_system.bzl", "grpc_cc_test")
 
-def grpc_fuzzer(name, corpus, srcs = [], deps = [], size = "large", **kwargs):
+def grpc_fuzzer(name, corpus, srcs = [], deps = [], data = [], size = "large", **kwargs):
     grpc_cc_test(
         name = name,
         srcs = srcs,
         deps = deps + ["//test/core/util:fuzzer_corpus_test"],
-        data = native.glob([corpus + "/**"]),
+        data = data + native.glob([corpus + "/**"]),
         external_deps = [
             "gtest",
         ],

test/cpp/end2end/xds_end2end_test.cc

@@ -1920,6 +1920,26 @@ TEST_P(XdsResolverOnlyTest, RestartsRequestsUponReconnection) {
   EXPECT_EQ(0, std::get<1>(counts));
 }
 
+TEST_P(XdsResolverOnlyTest, DefaultRouteSpecifiesSlashPrefix) {
+  RouteConfiguration route_config =
+      balancers_[0]->ads_service()->default_route_config();
+  route_config.mutable_virtual_hosts(0)
+      ->mutable_routes(0)
+      ->mutable_match()
+      ->set_prefix("/");
+  balancers_[0]->ads_service()->SetLdsResource(
+      AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
+  SetNextResolution({});
+  SetNextResolutionForLbChannelAllBalancers();
+  AdsServiceImpl::EdsResourceArgs args({
+      {"locality0", GetBackendPorts()},
+  });
+  balancers_[0]->ads_service()->SetEdsResource(
+      AdsServiceImpl::BuildEdsResource(args), kDefaultResourceName);
+  // We need to wait for all backends to come online.
+  WaitForAllBackends();
+}
+
 class XdsResolverLoadReportingOnlyTest : public XdsEnd2endTest {
  public:
   XdsResolverLoadReportingOnlyTest() : XdsEnd2endTest(4, 1, 3) {}

test/cpp/ios/Podfile

@@ -72,7 +72,7 @@ post_install do |installer|
         # GPR_UNREACHABLE_CODE causes "Control may reach end of non-void
         # function" warning
         config.build_settings['GCC_WARN_ABOUT_RETURN_TYPE'] = 'NO'
-        config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] = '$(inherited) COCOAPODS=1 GRPC_CRONET_WITH_PACKET_COALESCING=1 GRPC_CFSTREAM=1'
+        config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] = '$(inherited) COCOAPODS=1 GRPC_CRONET_WITH_PACKET_COALESCING=1'
       end
     end
 

tools/doxygen/Doxyfile.c++.internal

@@ -1540,6 +1540,8 @@ src/core/lib/iomgr/error.h \
 src/core/lib/iomgr/error_cfstream.cc \
 src/core/lib/iomgr/error_cfstream.h \
 src/core/lib/iomgr/error_internal.h \
+src/core/lib/iomgr/ev_apple.cc \
+src/core/lib/iomgr/ev_apple.h \
 src/core/lib/iomgr/ev_epoll1_linux.cc \
 src/core/lib/iomgr/ev_epoll1_linux.h \
 src/core/lib/iomgr/ev_epollex_linux.cc \

tools/doxygen/Doxyfile.core.internal

@@ -1352,6 +1352,8 @@ src/core/lib/iomgr/error.h \
 src/core/lib/iomgr/error_cfstream.cc \
 src/core/lib/iomgr/error_cfstream.h \
 src/core/lib/iomgr/error_internal.h \
+src/core/lib/iomgr/ev_apple.cc \
+src/core/lib/iomgr/ev_apple.h \
 src/core/lib/iomgr/ev_epoll1_linux.cc \
 src/core/lib/iomgr/ev_epoll1_linux.h \
 src/core/lib/iomgr/ev_epollex_linux.cc \

tools/run_tests/run_xds_tests.py

@@ -58,6 +58,8 @@ _TEST_CASES = [
 def parse_test_cases(arg):
     if arg == 'all':
         return _TEST_CASES
+    if arg == '':
+        return []
     test_cases = arg.split(',')
     if all([test_case in _TEST_CASES for test_case in test_cases]):
         return test_cases
@@ -108,6 +110,13 @@ argp.add_argument(
     type=int,
     help='Time limit for waiting for created backend services to report '
     'healthy when launching or updated GCP resources')
+argp.add_argument(
+    '--use_existing_gcp_resources',
+    default=False,
+    action='store_true',
+    help=
+    'If set, find and use already created GCP resources instead of creating new'
+    ' ones.')
 argp.add_argument(
     '--keep_gcp_resources',
     default=False,
@@ -164,14 +173,6 @@ argp.add_argument(
     help='Number of VMs to create per instance group. Certain test cases (e.g., '
     'round_robin) may not give meaningful results if this is set to a value '
     'less than 2.')
-argp.add_argument(
-    '--tolerate_gcp_errors',
-    default=False,
-    action='store_true',
-    help=
-    'Continue with test even when an error occurs during setup. Intended for '
-    'manual testing, where attempts to recreate any GCP resources already '
-    'existing will result in an error')
 argp.add_argument('--verbose',
                   help='verbose log output',
                   default=False,
@@ -198,6 +199,7 @@ _INSTANCE_GROUP_SIZE = args.instance_group_size
 _NUM_TEST_RPCS = 10 * args.qps
 _WAIT_FOR_STATS_SEC = 180
 _WAIT_FOR_URL_MAP_PATCH_SEC = 300
+_GCP_API_RETRIES = 5
 _BOOTSTRAP_TEMPLATE = """
 {{
   "node": {{
@@ -255,7 +257,7 @@ def get_client_stats(num_rpcs, timeout_sec):
             logger.debug('Invoked GetClientStats RPC: %s', response)
             return response
         except grpc.RpcError as rpc_error:
-            raise Exception('GetClientStats RPC failed')
+            logger.exception('GetClientStats RPC failed')
 
 
 def _verify_rpcs_to_given_backends(backends, timeout_sec, num_rpcs,
@@ -549,8 +551,8 @@ def create_instance_template(gcp, name, network, source_image, machine_type,
     }
 
     logger.debug('Sending GCP request with body=%s', config)
-    result = gcp.compute.instanceTemplates().insert(project=gcp.project,
-                                                    body=config).execute()
+    result = gcp.compute.instanceTemplates().insert(
+        project=gcp.project, body=config).execute(num_retries=_GCP_API_RETRIES)
     wait_for_global_operation(gcp, result['name'])
     gcp.instance_template = GcpResource(config['name'], result['targetLink'])
 
@@ -567,13 +569,14 @@ def add_instance_group(gcp, zone, name, size):
     }
 
     logger.debug('Sending GCP request with body=%s', config)
-    result = gcp.compute.instanceGroupManagers().insert(project=gcp.project,
-                                                        zone=zone,
-                                                        body=config).execute()
+    result = gcp.compute.instanceGroupManagers().insert(
+        project=gcp.project, zone=zone,
+        body=config).execute(num_retries=_GCP_API_RETRIES)
     wait_for_zone_operation(gcp, zone, result['name'])
     result = gcp.compute.instanceGroupManagers().get(
         project=gcp.project, zone=zone,
-        instanceGroupManager=config['name']).execute()
+        instanceGroupManager=config['name']).execute(
+            num_retries=_GCP_API_RETRIES)
     instance_group = InstanceGroup(config['name'], result['instanceGroup'],
                                    zone)
     gcp.instance_groups.append(instance_group)
@@ -600,8 +603,8 @@ def create_health_check(gcp, name):
         }
         compute_to_use = gcp.compute
     logger.debug('Sending GCP request with body=%s', config)
-    result = compute_to_use.healthChecks().insert(project=gcp.project,
-                                                  body=config).execute()
+    result = compute_to_use.healthChecks().insert(
+        project=gcp.project, body=config).execute(num_retries=_GCP_API_RETRIES)
     wait_for_global_operation(gcp, result['name'])
     gcp.health_check = GcpResource(config['name'], result['targetLink'])
 
@@ -617,8 +620,8 @@ def create_health_check_firewall_rule(gcp, name):
         'targetTags': ['allow-health-checks'],
     }
     logger.debug('Sending GCP request with body=%s', config)
-    result = gcp.compute.firewalls().insert(project=gcp.project,
-                                            body=config).execute()
+    result = gcp.compute.firewalls().insert(
+        project=gcp.project, body=config).execute(num_retries=_GCP_API_RETRIES)
     wait_for_global_operation(gcp, result['name'])
     gcp.health_check_firewall_rule = GcpResource(config['name'],
                                                  result['targetLink'])
@@ -639,8 +642,8 @@ def add_backend_service(gcp, name):
         'protocol': protocol
     }
     logger.debug('Sending GCP request with body=%s', config)
-    result = compute_to_use.backendServices().insert(project=gcp.project,
-                                                     body=config).execute()
+    result = compute_to_use.backendServices().insert(
+        project=gcp.project, body=config).execute(num_retries=_GCP_API_RETRIES)
     wait_for_global_operation(gcp, result['name'])
     backend_service = GcpResource(config['name'], result['targetLink'])
     gcp.backend_services.append(backend_service)
@@ -661,8 +664,8 @@ def create_url_map(gcp, name, backend_service, host_name):
         }]
     }
     logger.debug('Sending GCP request with body=%s', config)
-    result = gcp.compute.urlMaps().insert(project=gcp.project,
-                                          body=config).execute()
+    result = gcp.compute.urlMaps().insert(
+        project=gcp.project, body=config).execute(num_retries=_GCP_API_RETRIES)
     wait_for_global_operation(gcp, result['name'])
     gcp.url_map = GcpResource(config['name'], result['targetLink'])
 
@@ -675,9 +678,9 @@ def patch_url_map_host_rule_with_port(gcp, name, backend_service, host_name):
         }]
     }
     logger.debug('Sending GCP request with body=%s', config)
-    result = gcp.compute.urlMaps().patch(project=gcp.project,
-                                         urlMap=name,
-                                         body=config).execute()
+    result = gcp.compute.urlMaps().patch(
+        project=gcp.project, urlMap=name,
+        body=config).execute(num_retries=_GCP_API_RETRIES)
     wait_for_global_operation(gcp, result['name'])
 
 
@@ -690,15 +693,17 @@ def create_target_proxy(gcp, name):
         }
         logger.debug('Sending GCP request with body=%s', config)
         result = gcp.alpha_compute.targetGrpcProxies().insert(
-            project=gcp.project, body=config).execute()
+            project=gcp.project,
+            body=config).execute(num_retries=_GCP_API_RETRIES)
     else:
         config = {
             'name': name,
             'url_map': gcp.url_map.url,
         }
         logger.debug('Sending GCP request with body=%s', config)
-        result = gcp.compute.targetHttpProxies().insert(project=gcp.project,
-                                                        body=config).execute()
+        result = gcp.compute.targetHttpProxies().insert(
+            project=gcp.project,
+            body=config).execute(num_retries=_GCP_API_RETRIES)
     wait_for_global_operation(gcp, result['name'])
     gcp.target_proxy = GcpResource(config['name'], result['targetLink'])
 
@@ -720,7 +725,8 @@ def create_global_forwarding_rule(gcp, name, potential_ports):
             }
             logger.debug('Sending GCP request with body=%s', config)
             result = compute_to_use.globalForwardingRules().insert(
-                project=gcp.project, body=config).execute()
+                project=gcp.project,
+                body=config).execute(num_retries=_GCP_API_RETRIES)
             wait_for_global_operation(gcp, result['name'])
             gcp.global_forwarding_rule = GcpResource(config['name'],
                                                      result['targetLink'])
@@ -732,11 +738,73 @@ def create_global_forwarding_rule(gcp, name, potential_ports):
                 '0.0.0.0:%d. Retrying with another port.' % (http_error, port))
 
 
+def get_health_check(gcp, health_check_name):
+    result = gcp.compute.healthChecks().get(
+        project=gcp.project, healthCheck=health_check_name).execute()
+    gcp.health_check = GcpResource(health_check_name, result['selfLink'])
+
+
+def get_health_check_firewall_rule(gcp, firewall_name):
+    result = gcp.compute.firewalls().get(project=gcp.project,
+                                         firewall=firewall_name).execute()
+    gcp.health_check_firewall_rule = GcpResource(firewall_name,
+                                                 result['selfLink'])
+
+
+def get_backend_service(gcp, backend_service_name):
+    result = gcp.compute.backendServices().get(
+        project=gcp.project, backendService=backend_service_name).execute()
+    backend_service = GcpResource(backend_service_name, result['selfLink'])
+    gcp.backend_services.append(backend_service)
+    return backend_service
+
+
+def get_url_map(gcp, url_map_name):
+    result = gcp.compute.urlMaps().get(project=gcp.project,
+                                       urlMap=url_map_name).execute()
+    gcp.url_map = GcpResource(url_map_name, result['selfLink'])
+
+
+def get_target_proxy(gcp, target_proxy_name):
+    if gcp.alpha_compute:
+        result = gcp.alpha_compute.targetGrpcProxies().get(
+            project=gcp.project, targetGrpcProxy=target_proxy_name).execute()
+    else:
+        result = gcp.compute.targetHttpProxies().get(
+            project=gcp.project, targetHttpProxy=target_proxy_name).execute()
+    gcp.target_proxy = GcpResource(target_proxy_name, result['selfLink'])
+
+
+def get_global_forwarding_rule(gcp, forwarding_rule_name):
+    result = gcp.compute.globalForwardingRules().get(
+        project=gcp.project, forwardingRule=forwarding_rule_name).execute()
+    gcp.global_forwarding_rule = GcpResource(forwarding_rule_name,
+                                             result['selfLink'])
+
+
+def get_instance_template(gcp, template_name):
+    result = gcp.compute.instanceTemplates().get(
+        project=gcp.project, instanceTemplate=template_name).execute()
+    gcp.instance_template = GcpResource(template_name, result['selfLink'])
+
+
+def get_instance_group(gcp, zone, instance_group_name):
+    result = gcp.compute.instanceGroups().get(
+        project=gcp.project, zone=zone,
+        instanceGroup=instance_group_name).execute()
+    gcp.service_port = result['namedPorts'][0]['port']
+    instance_group = InstanceGroup(instance_group_name, result['selfLink'],
+                                   zone)
+    gcp.instance_groups.append(instance_group)
+    return instance_group
+
+
 def delete_global_forwarding_rule(gcp):
     try:
         result = gcp.compute.globalForwardingRules().delete(
             project=gcp.project,
-            forwardingRule=gcp.global_forwarding_rule.name).execute()
+            forwardingRule=gcp.global_forwarding_rule.name).execute(
+                num_retries=_GCP_API_RETRIES)
         wait_for_global_operation(gcp, result['name'])
     except googleapiclient.errors.HttpError as http_error:
         logger.info('Delete failed: %s', http_error)
@@ -747,11 +815,13 @@ def delete_target_proxy(gcp):
         if gcp.alpha_compute:
             result = gcp.alpha_compute.targetGrpcProxies().delete(
                 project=gcp.project,
-                targetGrpcProxy=gcp.target_proxy.name).execute()
+                targetGrpcProxy=gcp.target_proxy.name).execute(
+                    num_retries=_GCP_API_RETRIES)
         else:
             result = gcp.compute.targetHttpProxies().delete(
                 project=gcp.project,
-                targetHttpProxy=gcp.target_proxy.name).execute()
+                targetHttpProxy=gcp.target_proxy.name).execute(
+                    num_retries=_GCP_API_RETRIES)
         wait_for_global_operation(gcp, result['name'])
     except googleapiclient.errors.HttpError as http_error:
         logger.info('Delete failed: %s', http_error)
@@ -760,7 +830,8 @@ def delete_target_proxy(gcp):
 def delete_url_map(gcp):
     try:
         result = gcp.compute.urlMaps().delete(
-            project=gcp.project, urlMap=gcp.url_map.name).execute()
+            project=gcp.project,
+            urlMap=gcp.url_map.name).execute(num_retries=_GCP_API_RETRIES)
         wait_for_global_operation(gcp, result['name'])
     except googleapiclient.errors.HttpError as http_error:
         logger.info('Delete failed: %s', http_error)
@@ -771,7 +842,8 @@ def delete_backend_services(gcp):
         try:
             result = gcp.compute.backendServices().delete(
                 project=gcp.project,
-                backendService=backend_service.name).execute()
+                backendService=backend_service.name).execute(
+                    num_retries=_GCP_API_RETRIES)
             wait_for_global_operation(gcp, result['name'])
         except googleapiclient.errors.HttpError as http_error:
             logger.info('Delete failed: %s', http_error)
@@ -781,7 +853,8 @@ def delete_firewall(gcp):
     try:
         result = gcp.compute.firewalls().delete(
             project=gcp.project,
-            firewall=gcp.health_check_firewall_rule.name).execute()
+            firewall=gcp.health_check_firewall_rule.name).execute(
+                num_retries=_GCP_API_RETRIES)
         wait_for_global_operation(gcp, result['name'])
     except googleapiclient.errors.HttpError as http_error:
         logger.info('Delete failed: %s', http_error)
@@ -790,7 +863,8 @@ def delete_firewall(gcp):
 def delete_health_check(gcp):
     try:
         result = gcp.compute.healthChecks().delete(
-            project=gcp.project, healthCheck=gcp.health_check.name).execute()
+            project=gcp.project, healthCheck=gcp.health_check.name).execute(
+                num_retries=_GCP_API_RETRIES)
         wait_for_global_operation(gcp, result['name'])
     except googleapiclient.errors.HttpError as http_error:
         logger.info('Delete failed: %s', http_error)
@@ -802,7 +876,8 @@ def delete_instance_groups(gcp):
             result = gcp.compute.instanceGroupManagers().delete(
                 project=gcp.project,
                 zone=instance_group.zone,
-                instanceGroupManager=instance_group.name).execute()
+                instanceGroupManager=instance_group.name).execute(
+                    num_retries=_GCP_API_RETRIES)
             wait_for_zone_operation(gcp,
                                     instance_group.zone,
                                     result['name'],
@@ -815,7 +890,8 @@ def delete_instance_template(gcp):
     try:
         result = gcp.compute.instanceTemplates().delete(
             project=gcp.project,
-            instanceTemplate=gcp.instance_template.name).execute()
+            instanceTemplate=gcp.instance_template.name).execute(
+                num_retries=_GCP_API_RETRIES)
         wait_for_global_operation(gcp, result['name'])
     except googleapiclient.errors.HttpError as http_error:
         logger.info('Delete failed: %s', http_error)
@@ -839,7 +915,7 @@ def patch_backend_instances(gcp,
     logger.debug('Sending GCP request with body=%s', config)
     result = compute_to_use.backendServices().patch(
         project=gcp.project, backendService=backend_service.name,
-        body=config).execute()
+        body=config).execute(num_retries=_GCP_API_RETRIES)
     wait_for_global_operation(gcp,
                               result['name'],
                               timeout_sec=_WAIT_FOR_BACKEND_SEC)
@@ -853,7 +929,7 @@ def resize_instance_group(gcp,
         project=gcp.project,
         zone=instance_group.zone,
         instanceGroupManager=instance_group.name,
-        size=new_size).execute()
+        size=new_size).execute(num_retries=_GCP_API_RETRIES)
     wait_for_zone_operation(gcp,
                             instance_group.zone,
                             result['name'],
@@ -865,7 +941,7 @@ def resize_instance_group(gcp,
             break
         if time.time() - start_time > timeout_sec:
             raise Exception('Failed to resize primary instance group')
-        time.sleep(1)
+        time.sleep(2)
 
 
 def patch_url_map_backend_service(gcp, backend_service):
@@ -878,9 +954,9 @@ def patch_url_map_backend_service(gcp, backend_service):
         }]
     }
     logger.debug('Sending GCP request with body=%s', config)
-    result = gcp.compute.urlMaps().patch(project=gcp.project,
-                                         urlMap=gcp.url_map.name,
-                                         body=config).execute()
+    result = gcp.compute.urlMaps().patch(
+        project=gcp.project, urlMap=gcp.url_map.name,
+        body=config).execute(num_retries=_GCP_API_RETRIES)
     wait_for_global_operation(gcp, result['name'])
 
 
@@ -890,12 +966,13 @@ def wait_for_global_operation(gcp,
     start_time = time.time()
     while time.time() - start_time <= timeout_sec:
         result = gcp.compute.globalOperations().get(
-            project=gcp.project, operation=operation).execute()
+            project=gcp.project,
+            operation=operation).execute(num_retries=_GCP_API_RETRIES)
         if result['status'] == 'DONE':
             if 'error' in result:
                 raise Exception(result['error'])
             return
-        time.sleep(1)
+        time.sleep(2)
     raise Exception('Operation %s did not complete within %d', operation,
                     timeout_sec)
 
@@ -907,12 +984,13 @@ def wait_for_zone_operation(gcp,
     start_time = time.time()
     while time.time() - start_time <= timeout_sec:
         result = gcp.compute.zoneOperations().get(
-            project=gcp.project, zone=zone, operation=operation).execute()
+            project=gcp.project, zone=zone,
+            operation=operation).execute(num_retries=_GCP_API_RETRIES)
         if result['status'] == 'DONE':
             if 'error' in result:
                 raise Exception(result['error'])
             return
-        time.sleep(1)
+        time.sleep(2)
     raise Exception('Operation %s did not complete within %d', operation,
                     timeout_sec)
 
@@ -927,7 +1005,7 @@ def wait_for_healthy_backends(gcp,
         result = gcp.compute.backendServices().getHealth(
             project=gcp.project,
             backendService=backend_service.name,
-            body=config).execute()
+            body=config).execute(num_retries=_GCP_API_RETRIES)
         if 'healthStatus' in result:
             healthy = True
             for instance in result['healthStatus']:
@@ -936,7 +1014,7 @@ def wait_for_healthy_backends(gcp,
                     break
             if healthy:
                 return
-        time.sleep(1)
+        time.sleep(2)
     raise Exception('Not all backends became healthy within %d seconds: %s' %
                     (timeout_sec, result))
 
@@ -949,7 +1027,7 @@ def get_instance_names(gcp, instance_group):
         instanceGroup=instance_group.name,
         body={
             'instanceState': 'ALL'
-        }).execute()
+        }).execute(num_retries=_GCP_API_RETRIES)
     if 'items' not in result:
         return []
     for item in result['items']:
@@ -1040,7 +1118,30 @@ try:
     same_zone_instance_group_name = _BASE_INSTANCE_GROUP_NAME + '-same-zone' + args.gcp_suffix
     if _USE_SECONDARY_IG:
         secondary_zone_instance_group_name = _BASE_INSTANCE_GROUP_NAME + '-secondary-zone' + args.gcp_suffix
-    try:
+    if args.use_existing_gcp_resources:
+        logger.info('Reusing existing GCP resources')
+        get_health_check(gcp, health_check_name)
+        try:
+            get_health_check_firewall_rule(gcp, firewall_name)
+        except googleapiclient.errors.HttpError as http_error:
+            # Firewall rule may be auto-deleted periodically depending on GCP
+            # project settings.
+            logger.exception('Failed to find firewall rule, recreating')
+            create_health_check_firewall_rule(gcp, firewall_name)
+        backend_service = get_backend_service(gcp, backend_service_name)
+        alternate_backend_service = get_backend_service(
+            gcp, alternate_backend_service_name)
+        get_url_map(gcp, url_map_name)
+        get_target_proxy(gcp, target_proxy_name)
+        get_global_forwarding_rule(gcp, forwarding_rule_name)
+        get_instance_template(gcp, template_name)
+        instance_group = get_instance_group(gcp, args.zone, instance_group_name)
+        same_zone_instance_group = get_instance_group(
+            gcp, args.zone, same_zone_instance_group_name)
+        if _USE_SECONDARY_IG:
+            secondary_zone_instance_group = get_instance_group(
+                gcp, args.secondary_zone, secondary_zone_instance_group_name)
+    else:
         create_health_check(gcp, health_check_name)
         create_health_check_firewall_rule(gcp, firewall_name)
         backend_service = add_backend_service(gcp, backend_service_name)
@@ -1073,166 +1174,104 @@ try:
             secondary_zone_instance_group = add_instance_group(
                 gcp, args.secondary_zone, secondary_zone_instance_group_name,
                 _INSTANCE_GROUP_SIZE)
-    except googleapiclient.errors.HttpError as http_error:
-        if args.tolerate_gcp_errors:
-            logger.warning(
-                'Failed to set up backends: %s. Attempting to continue since '
-                '--tolerate_gcp_errors=true', http_error)
-            if not gcp.instance_template:
-                result = compute.instanceTemplates().get(
-                    project=args.project_id,
-                    instanceTemplate=template_name).execute()
-                gcp.instance_template = GcpResource(template_name,
-                                                    result['selfLink'])
-            if not gcp.backend_services:
-                result = compute.backendServices().get(
-                    project=args.project_id,
-                    backendService=backend_service_name).execute()
-                backend_service = GcpResource(backend_service_name,
-                                              result['selfLink'])
-                gcp.backend_services.append(backend_service)
-                result = compute.backendServices().get(
-                    project=args.project_id,
-                    backendService=alternate_backend_service_name).execute()
-                alternate_backend_service = GcpResource(
-                    alternate_backend_service_name, result['selfLink'])
-                gcp.backend_services.append(alternate_backend_service)
-            if not gcp.instance_groups:
-                result = compute.instanceGroups().get(
-                    project=args.project_id,
-                    zone=args.zone,
-                    instanceGroup=instance_group_name).execute()
-                instance_group = InstanceGroup(instance_group_name,
-                                               result['selfLink'], args.zone)
-                gcp.instance_groups.append(instance_group)
-                result = compute.instanceGroups().get(
-                    project=args.project_id,
-                    zone=args.zone,
-                    instanceGroup=same_zone_instance_group_name).execute()
-                same_zone_instance_group = InstanceGroup(
-                    same_zone_instance_group_name, result['selfLink'],
-                    args.zone)
-                gcp.instance_groups.append(same_zone_instance_group)
-                if _USE_SECONDARY_IG:
-                    result = compute.instanceGroups().get(
-                        project=args.project_id,
-                        zone=args.secondary_zone,
-                        instanceGroup=secondary_zone_instance_group_name
-                    ).execute()
-                    secondary_zone_instance_group = InstanceGroup(
-                        secondary_zone_instance_group_name, result['selfLink'],
-                        args.secondary_zone)
-                    gcp.instance_groups.append(secondary_zone_instance_group)
-            if not gcp.health_check:
-                result = compute.healthChecks().get(
-                    project=args.project_id,
-                    healthCheck=health_check_name).execute()
-                gcp.health_check = GcpResource(health_check_name,
-                                               result['selfLink'])
-            if not gcp.url_map:
-                result = compute.urlMaps().get(project=args.project_id,
-                                               urlMap=url_map_name).execute()
-                gcp.url_map = GcpResource(url_map_name, result['selfLink'])
-            if not gcp.service_port:
-                gcp.service_port = args.service_port_range[0]
-                logger.warning('Using arbitrary service port in range: %d' %
-                               gcp.service_port)
-        else:
-            raise http_error
 
     wait_for_healthy_backends(gcp, backend_service, instance_group)
 
-    if gcp.service_port == _DEFAULT_SERVICE_PORT:
-        server_uri = service_host_name
-    else:
-        server_uri = service_host_name + ':' + str(gcp.service_port)
-    if args.bootstrap_file:
-        bootstrap_path = os.path.abspath(args.bootstrap_file)
-    else:
-        with tempfile.NamedTemporaryFile(delete=False) as bootstrap_file:
-            bootstrap_file.write(
-                _BOOTSTRAP_TEMPLATE.format(
-                    node_id=socket.gethostname()).encode('utf-8'))
-            bootstrap_path = bootstrap_file.name
-    client_env = dict(os.environ, GRPC_XDS_BOOTSTRAP=bootstrap_path)
-    client_cmd = shlex.split(
-        args.client_cmd.format(server_uri=server_uri,
-                               stats_port=args.stats_port,
-                               qps=args.qps))
-
-    test_results = {}
-    failed_tests = []
-    for test_case in args.test_case:
-        result = jobset.JobResult()
-        log_dir = os.path.join(_TEST_LOG_BASE_DIR, test_case)
-        if not os.path.exists(log_dir):
-            os.makedirs(log_dir)
-        test_log_filename = os.path.join(log_dir, _SPONGE_LOG_NAME)
-        test_log_file = open(test_log_filename, 'w+')
-        client_process = None
-        try:
-            client_process = subprocess.Popen(client_cmd,
-                                              env=client_env,
-                                              stderr=subprocess.STDOUT,
-                                              stdout=test_log_file)
-            if test_case == 'backends_restart':
-                test_backends_restart(gcp, backend_service, instance_group)
-            elif test_case == 'change_backend_service':
-                test_change_backend_service(gcp, backend_service,
-                                            instance_group,
-                                            alternate_backend_service,
-                                            same_zone_instance_group)
-            elif test_case == 'new_instance_group_receives_traffic':
-                test_new_instance_group_receives_traffic(
-                    gcp, backend_service, instance_group,
-                    same_zone_instance_group)
-            elif test_case == 'ping_pong':
-                test_ping_pong(gcp, backend_service, instance_group)
-            elif test_case == 'remove_instance_group':
-                test_remove_instance_group(gcp, backend_service, instance_group,
-                                           same_zone_instance_group)
-            elif test_case == 'round_robin':
-                test_round_robin(gcp, backend_service, instance_group)
-            elif test_case == 'secondary_locality_gets_no_requests_on_partial_primary_failure':
-                test_secondary_locality_gets_no_requests_on_partial_primary_failure(
-                    gcp, backend_service, instance_group,
-                    secondary_zone_instance_group)
-            elif test_case == 'secondary_locality_gets_requests_on_primary_failure':
-                test_secondary_locality_gets_requests_on_primary_failure(
-                    gcp, backend_service, instance_group,
-                    secondary_zone_instance_group)
-            else:
-                logger.error('Unknown test case: %s', test_case)
-                sys.exit(1)
-            result.state = 'PASSED'
-            result.returncode = 0
-        except Exception as e:
-            logger.error('Test case %s failed: %s', test_case, e)
-            failed_tests.append(test_case)
-            result.state = 'FAILED'
-            result.message = str(e)
-        finally:
-            if client_process:
-                client_process.terminate()
-            test_log_file.close()
-            # Workaround for Python 3, as report_utils will invoke decode() on
-            # result.message, which has a default value of ''.
-            result.message = result.message.encode('UTF-8')
-            test_results[test_case] = [result]
-            if args.log_client_output:
-                logger.info('Client output:')
-                with open(test_log_filename, 'r') as client_output:
-                    logger.info(client_output.read())
-    if not os.path.exists(_TEST_LOG_BASE_DIR):
-        os.makedirs(_TEST_LOG_BASE_DIR)
-    report_utils.render_junit_xml_report(test_results,
-                                         os.path.join(_TEST_LOG_BASE_DIR,
-                                                      _SPONGE_XML_NAME),
-                                         suite_name='xds_tests',
-                                         multi_target=True)
-    if failed_tests:
-        logger.error('Test case(s) %s failed', failed_tests)
-        sys.exit(1)
+    if args.test_case:
+
+        if gcp.service_port == _DEFAULT_SERVICE_PORT:
+            server_uri = service_host_name
+        else:
+            server_uri = service_host_name + ':' + str(gcp.service_port)
+        if args.bootstrap_file:
+            bootstrap_path = os.path.abspath(args.bootstrap_file)
+        else:
+            with tempfile.NamedTemporaryFile(delete=False) as bootstrap_file:
+                bootstrap_file.write(
+                    _BOOTSTRAP_TEMPLATE.format(
+                        node_id=socket.gethostname()).encode('utf-8'))
+                bootstrap_path = bootstrap_file.name
+        client_env = dict(os.environ, GRPC_XDS_BOOTSTRAP=bootstrap_path)
+        client_cmd = shlex.split(
+            args.client_cmd.format(server_uri=server_uri,
+                                   stats_port=args.stats_port,
+                                   qps=args.qps))
+
+        test_results = {}
+        failed_tests = []
+        for test_case in args.test_case:
+            result = jobset.JobResult()
+            log_dir = os.path.join(_TEST_LOG_BASE_DIR, test_case)
+            if not os.path.exists(log_dir):
+                os.makedirs(log_dir)
+            test_log_filename = os.path.join(log_dir, _SPONGE_LOG_NAME)
+            test_log_file = open(test_log_filename, 'w+')
+            client_process = None
+            try:
+                client_process = subprocess.Popen(client_cmd,
+                                                  env=client_env,
+                                                  stderr=subprocess.STDOUT,
+                                                  stdout=test_log_file)
+                if test_case == 'backends_restart':
+                    test_backends_restart(gcp, backend_service, instance_group)
+                elif test_case == 'change_backend_service':
+                    test_change_backend_service(gcp, backend_service,
+                                                instance_group,
+                                                alternate_backend_service,
+                                                same_zone_instance_group)
+                elif test_case == 'new_instance_group_receives_traffic':
+                    test_new_instance_group_receives_traffic(
+                        gcp, backend_service, instance_group,
+                        same_zone_instance_group)
+                elif test_case == 'ping_pong':
+                    test_ping_pong(gcp, backend_service, instance_group)
+                elif test_case == 'remove_instance_group':
+                    test_remove_instance_group(gcp, backend_service,
+                                               instance_group,
+                                               same_zone_instance_group)
+                elif test_case == 'round_robin':
+                    test_round_robin(gcp, backend_service, instance_group)
+                elif test_case == 'secondary_locality_gets_no_requests_on_partial_primary_failure':
+                    test_secondary_locality_gets_no_requests_on_partial_primary_failure(
+                        gcp, backend_service, instance_group,
+                        secondary_zone_instance_group)
+                elif test_case == 'secondary_locality_gets_requests_on_primary_failure':
+                    test_secondary_locality_gets_requests_on_primary_failure(
+                        gcp, backend_service, instance_group,
+                        secondary_zone_instance_group)
+                else:
+                    logger.error('Unknown test case: %s', test_case)
+                    sys.exit(1)
+                result.state = 'PASSED'
+                result.returncode = 0
+            except Exception as e:
+                logger.exception('Test case %s failed', test_case)
+                failed_tests.append(test_case)
+                result.state = 'FAILED'
+                result.message = str(e)
+            finally:
+                if client_process:
+                    client_process.terminate()
+                test_log_file.close()
+                # Workaround for Python 3, as report_utils will invoke decode() on
+                # result.message, which has a default value of ''.
+                result.message = result.message.encode('UTF-8')
+                test_results[test_case] = [result]
+                if args.log_client_output:
+                    logger.info('Client output:')
+                    with open(test_log_filename, 'r') as client_output:
+                        logger.info(client_output.read())
+        if not os.path.exists(_TEST_LOG_BASE_DIR):
+            os.makedirs(_TEST_LOG_BASE_DIR)
+        report_utils.render_junit_xml_report(test_results,
+                                             os.path.join(
+                                                 _TEST_LOG_BASE_DIR,
+                                                 _SPONGE_XML_NAME),
+                                             suite_name='xds_tests',
+                                             multi_target=True)
+        if failed_tests:
+            logger.error('Test case(s) %s failed', failed_tests)
+            sys.exit(1)
 finally:
     if not args.keep_gcp_resources:
         logger.info('Cleaning up GCP resources. This may take some time.')