Merge branch 'master' into aio-server

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,7 +2,7 @@
 name: Report a bug
 about: Create a report to help us improve
 labels: kind/bug, priority/P2
-assignees: AspirinSJL
+assignees: yang-g
 
 ---
 

.github/ISSUE_TEMPLATE/cleanup_request.md

@@ -2,7 +2,7 @@
 name: Request a cleanup
 about: Suggest a cleanup in our repository
 labels: kind/internal cleanup
-assignees: AspirinSJL
+assignees: yang-g
 
 ---
 

.github/ISSUE_TEMPLATE/feature_request.md

@@ -2,7 +2,7 @@
 name: Request a feature
 about: Suggest an idea for this project
 labels: kind/enhancement
-assignees: AspirinSJL
+assignees: yang-g
 
 ---
 

.github/mergeable.yml

@@ -8,11 +8,11 @@ mergeable:
         - or:
           - and:
             - must_include:
-                regex: 'release notes: yes'
-                message: 'Please include release note: yes'
+                regex: '^release notes: yes'
+                message: 'Please add the label (release notes: yes)'
             - must_include:
                 regex: '^lang\/'
-                message: 'Please include a language label'
+                message: 'Please add a language label (lang/...)'
           - must_include:
-              regex: 'release notes: no'
-              message: 'Please include release note: no'
+              regex: '^release notes: no'
+              message: 'Please add the label (release notes: no)'

.github/pull_request_template.md

@@ -8,4 +8,4 @@ If you know who should review your pull request, please remove the mentioning be
 
 -->
 
-@AspirinSJL
+@yang-g

bazel/grpc_deps.bzl

@@ -1,6 +1,5 @@
 """Load dependencies needed to compile and test the grpc library as a 3rd-party consumer."""
 
-load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 load("@com_github_grpc_grpc//bazel:grpc_python_deps.bzl", "grpc_python_deps")
 
@@ -186,10 +185,13 @@ def grpc_deps():
         )
 
     if "bazel_skylib" not in native.existing_rules():
-        git_repository(
+        http_archive(
             name = "bazel_skylib",
-            remote = "https://github.com/bazelbuild/bazel-skylib",
-            tag = "0.9.0",
+            urls = [
+                "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.0.2/bazel-skylib-1.0.2.tar.gz",
+                "https://github.com/bazelbuild/bazel-skylib/releases/download/1.0.2/bazel-skylib-1.0.2.tar.gz",
+            ],
+            sha256 = "97e70364e9249702246c0e9444bccdc4b847bed1eb03c5a3ece4f83dfe6abc44",
         )
 
     if "io_opencensus_cpp" not in native.existing_rules():

bazel/grpc_python_deps.bzl

@@ -1,6 +1,5 @@
 """Load dependencies needed to compile and test the grpc python library as a 3rd-party consumer."""
 
-load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 load("@com_github_grpc_grpc//third_party/py:python_configure.bzl", "python_configure")
 
@@ -41,13 +40,12 @@ def grpc_python_deps():
         )
 
     if "io_bazel_rules_python" not in native.existing_rules():
-        git_repository(
+        http_archive(
             name = "io_bazel_rules_python",
-            commit = "fdbb17a4118a1728d19e638a5291b4c4266ea5b8",
-            remote = "https://github.com/bazelbuild/rules_python.git",
+            url = "https://github.com/bazelbuild/rules_python/releases/download/0.0.1/rules_python-0.0.1.tar.gz",
+            sha256 = "aa96a691d3a8177f3215b14b0edc9641787abaaa30363a080165d06ab65e1161",
         )
 
-
     if "rules_python" not in native.existing_rules():
         http_archive(
             name = "rules_python",

src/cpp/ext/proto_server_reflection.cc

@@ -102,9 +102,9 @@ Status ProtoServerReflection::ListService(ServerContext* context,
   if (services_ == nullptr) {
     return Status(StatusCode::NOT_FOUND, "Services not found.");
   }
-  for (auto it = services_->begin(); it != services_->end(); ++it) {
+  for (const auto& value : *services_) {
     ServiceResponse* service_response = response->add_service();
-    service_response->set_name(*it);
+    service_response->set_name(value);
   }
   return Status::OK;
 }
@@ -182,8 +182,8 @@ Status ProtoServerReflection::GetAllExtensionNumbers(
 
   std::vector<const protobuf::FieldDescriptor*> extensions;
   descriptor_pool_->FindAllExtensions(desc, &extensions);
-  for (auto it = extensions.begin(); it != extensions.end(); it++) {
-    response->add_extension_number((*it)->number());
+  for (const auto& value : extensions) {
+    response->add_extension_number(value->number());
   }
   response->set_base_type_name(type);
   return Status::OK;

src/cpp/server/server_builder.cc

@@ -48,10 +48,8 @@ ServerBuilder::ServerBuilder()
       sync_server_settings_(SyncServerSettings()),
       resource_quota_(nullptr) {
   gpr_once_init(&once_init_plugin_list, do_plugin_list_init);
-  for (auto it = g_plugin_factory_list->begin();
-       it != g_plugin_factory_list->end(); it++) {
-    auto& factory = *it;
-    plugins_.emplace_back(factory());
+  for (const auto& value : *g_plugin_factory_list) {
+    plugins_.emplace_back(value());
   }
 
   // all compression algorithms enabled by default.
@@ -205,14 +203,14 @@ ServerBuilder& ServerBuilder::AddListeningPort(
 
 std::unique_ptr<grpc::Server> ServerBuilder::BuildAndStart() {
   grpc::ChannelArguments args;
-  for (auto option = options_.begin(); option != options_.end(); ++option) {
-    (*option)->UpdateArguments(&args);
-    (*option)->UpdatePlugins(&plugins_);
+  for (const auto& option : options_) {
+    option->UpdateArguments(&args);
+    option->UpdatePlugins(&plugins_);
   }
 
-  for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) {
-    (*plugin)->UpdateServerBuilder(this);
-    (*plugin)->UpdateChannelArguments(&args);
+  for (const auto& plugin : plugins_) {
+    plugin->UpdateServerBuilder(this);
+    plugin->UpdateChannelArguments(&args);
   }
 
   if (max_receive_message_size_ >= -1) {
@@ -243,16 +241,16 @@ std::unique_ptr<grpc::Server> ServerBuilder::BuildAndStart() {
 
   // == Determine if the server has any syncrhonous methods ==
   bool has_sync_methods = false;
-  for (auto it = services_.begin(); it != services_.end(); ++it) {
-    if ((*it)->service->has_synchronous_methods()) {
+  for (const auto& value : services_) {
+    if (value->service->has_synchronous_methods()) {
       has_sync_methods = true;
       break;
     }
   }
 
   if (!has_sync_methods) {
-    for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) {
-      if ((*plugin)->has_sync_methods()) {
+    for (const auto& value : plugins_) {
+      if (value->has_sync_methods()) {
         has_sync_methods = true;
         break;
       }
@@ -331,8 +329,8 @@ std::unique_ptr<grpc::Server> ServerBuilder::BuildAndStart() {
   //     server
   //  2. cqs_: Completion queues added via AddCompletionQueue() call
 
-  for (auto it = sync_server_cqs->begin(); it != sync_server_cqs->end(); ++it) {
-    grpc_server_register_completion_queue(server->server_, (*it)->cq(),
+  for (const auto& value : *sync_server_cqs) {
+    grpc_server_register_completion_queue(server->server_, value->cq(),
                                           nullptr);
     has_frequently_polled_cqs = true;
   }
@@ -347,8 +345,8 @@ std::unique_ptr<grpc::Server> ServerBuilder::BuildAndStart() {
   // calling Next() or AsyncNext()) and hence are not safe to be used for
   // listening to incoming channels. Such completion queues must be registered
   // as non-listening queues
-  for (auto it = cqs_.begin(); it != cqs_.end(); ++it) {
-    grpc_server_register_completion_queue(server->server_, (*it)->cq(),
+  for (const auto& value : cqs_) {
+    grpc_server_register_completion_queue(server->server_, value->cq(),
                                           nullptr);
   }
 
@@ -358,15 +356,14 @@ std::unique_ptr<grpc::Server> ServerBuilder::BuildAndStart() {
     return nullptr;
   }
 
-  for (auto service = services_.begin(); service != services_.end();
-       service++) {
-    if (!server->RegisterService((*service)->host.get(), (*service)->service)) {
+  for (const auto& value : services_) {
+    if (!server->RegisterService(value->host.get(), value->service)) {
       return nullptr;
     }
   }
 
-  for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) {
-    (*plugin)->InitServer(initializer);
+  for (const auto& value : plugins_) {
+    value->InitServer(initializer);
   }
 
   if (generic_service_) {
@@ -374,8 +371,8 @@ std::unique_ptr<grpc::Server> ServerBuilder::BuildAndStart() {
   } else if (callback_generic_service_) {
     server->RegisterCallbackGenericService(callback_generic_service_);
   } else {
-    for (auto it = services_.begin(); it != services_.end(); ++it) {
-      if ((*it)->service->has_generic_methods()) {
+    for (const auto& value : services_) {
+      if (value->service->has_generic_methods()) {
         gpr_log(GPR_ERROR,
                 "Some methods were marked generic but there is no "
                 "generic service registered.");
@@ -400,8 +397,8 @@ std::unique_ptr<grpc::Server> ServerBuilder::BuildAndStart() {
   auto cqs_data = cqs_.empty() ? nullptr : &cqs_[0];
   server->Start(cqs_data, cqs_.size());
 
-  for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) {
-    (*plugin)->Finish(initializer);
+  for (const auto& value : plugins_) {
+    value->Finish(initializer);
   }
 
   return server;

src/cpp/server/server_cc.cc

@@ -914,9 +914,9 @@ class Server::SyncRequestThreadManager : public grpc::ThreadManager {
 
   void Start() {
     if (!sync_requests_.empty()) {
-      for (auto m = sync_requests_.begin(); m != sync_requests_.end(); m++) {
-        (*m)->SetupRequest();
-        (*m)->Request(server_->c_server(), server_cq_->cq());
+      for (const auto& value : sync_requests_) {
+        value->SetupRequest();
+        value->Request(server_->c_server(), server_cq_->cq());
       }
 
       Initialize();  // ThreadManager's Initialize()
@@ -1014,8 +1014,8 @@ Server::~Server() {
       Shutdown();
     } else if (!started_) {
       // Shutdown the completion queues
-      for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
-        (*it)->Shutdown();
+      for (const auto& value : sync_req_mgrs_) {
+        value->Shutdown();
       }
     }
   }
@@ -1103,8 +1103,8 @@ bool Server::RegisterService(const grpc::string* host, grpc::Service* service) {
       method->set_server_tag(method_registration_tag);
     } else if (method->api_type() ==
                grpc::internal::RpcServiceMethod::ApiType::SYNC) {
-      for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
-        (*it)->AddSyncMethod(method, method_registration_tag);
+      for (const auto& value : sync_req_mgrs_) {
+        value->AddSyncMethod(method, method_registration_tag);
       }
     } else {
       // a callback method. Register at least some callback requests
@@ -1213,8 +1213,8 @@ void Server::Start(grpc::ServerCompletionQueue** cqs, size_t num_cqs) {
   grpc_server_start(server_);
 
   if (!has_async_generic_service_ && !has_callback_generic_service_) {
-    for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
-      (*it)->AddUnknownSyncMethod();
+    for (const auto& value : sync_req_mgrs_) {
+      value->AddUnknownSyncMethod();
     }
 
     for (size_t i = 0; i < num_cqs; i++) {
@@ -1235,8 +1235,8 @@ void Server::Start(grpc::ServerCompletionQueue** cqs, size_t num_cqs) {
         new grpc::internal::ResourceExhaustedHandler);
   }
 
-  for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
-    (*it)->Start();
+  for (const auto& value : sync_req_mgrs_) {
+    value->Start();
   }
 
   for (auto* cbreq : callback_reqs_to_start_) {
@@ -1287,13 +1287,13 @@ void Server::ShutdownInternal(gpr_timespec deadline) {
 
   // Shutdown all ThreadManagers. This will try to gracefully stop all the
   // threads in the ThreadManagers (once they process any inflight requests)
-  for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
-    (*it)->Shutdown();  // ThreadManager's Shutdown()
+  for (const auto& value : sync_req_mgrs_) {
+    value->Shutdown();  // ThreadManager's Shutdown()
   }
 
   // Wait for threads in all ThreadManagers to terminate
-  for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
-    (*it)->Wait();
+  for (const auto& value : sync_req_mgrs_) {
+    value->Wait();
   }
 
   // Wait for all outstanding callback requests to complete

src/python/grpcio/grpc/_cython/BUILD.bazel

@@ -10,8 +10,6 @@ pyx_library(
         "_cygrpc/_hooks.pyx.pxi",
         "_cygrpc/aio/call.pxd.pxi",
         "_cygrpc/aio/call.pyx.pxi",
-        "_cygrpc/aio/rpc_error.pxd.pxi",
-        "_cygrpc/aio/rpc_error.pyx.pxi",
         "_cygrpc/aio/callbackcontext.pxd.pxi",
         "_cygrpc/aio/channel.pxd.pxi",
         "_cygrpc/aio/channel.pyx.pxi",

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

@@ -13,15 +13,15 @@
 # limitations under the License.
 
 cimport cpython
-import grpc
 
 _EMPTY_FLAGS = 0
-_EMPTY_METADATA = None
+_EMPTY_METADATA = ()
 _OP_ARRAY_LENGTH = 6
 
 
 cdef class _AioCall:
 
+
     def __cinit__(self, AioChannel channel):
         self._channel = channel
         self._functor.functor_run = _AioCall.functor_run
@@ -59,7 +59,7 @@ cdef class _AioCall:
         else:
             call._waiter_call.set_result(None)
 
-    async def unary_unary(self, method, request, timeout):
+    async def unary_unary(self, method, request):
         cdef grpc_call * call
         cdef grpc_slice method_slice
         cdef grpc_op * ops
@@ -72,7 +72,7 @@ cdef class _AioCall:
         cdef Operation receive_status_on_client_operation
 
         cdef grpc_call_error call_status
-        cdef gpr_timespec deadline = _timespec_from_time(timeout)
+
 
         method_slice = grpc_slice_from_copied_buffer(
             <const char *> method,
@@ -86,7 +86,7 @@ cdef class _AioCall:
             self._cq,
             method_slice,
             NULL,
-            deadline,
+            _timespec_from_time(None),
             NULL
         )
 
@@ -146,12 +146,4 @@ cdef class _AioCall:
             grpc_call_unref(call)
             gpr_free(ops)
 
-        if receive_status_on_client_operation.code() == grpc._cygrpc.StatusCode.ok:
-            return receive_message_operation.message()
-
-        raise grpc.experimental.aio.AioRpcError(
-            receive_initial_metadata_operation.initial_metadata(),
-            receive_status_on_client_operation.code(),
-            receive_status_on_client_operation.details(),
-            receive_status_on_client_operation.trailing_metadata(),
-        )
+        return receive_message_operation.message()

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

@@ -18,13 +18,13 @@ cdef class AioChannel:
         self._target = target
 
     def __repr__(self):
-        class_name = self.__class__.__name__
+        class_name = self.__class__.__name__ 
         id_ = id(self)
         return f"<{class_name} {id_}>"
 
     def close(self):
         grpc_channel_destroy(self.channel)
 
-    async def unary_unary(self, method, request, timeout):
+    async def unary_unary(self, method, request):
         call = _AioCall(self)
-        return await call.unary_unary(method, request, timeout)
+        return await call.unary_unary(method, request)

src/python/grpcio/grpc/_cython/_cygrpc/aio/rpc_error.pxd.pxi

@@ -1,27 +0,0 @@
-# Copyright 2019 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.
-"""Exceptions for the aio version of the RPC calls."""
-
-
-cdef class _AioRpcError(Exception):
-    cdef readonly:
-        tuple _initial_metadata
-        int _code
-        str _details
-        tuple _trailing_metadata
-
-    cpdef tuple initial_metadata(self)
-    cpdef int code(self)
-    cpdef str details(self)
-    cpdef tuple trailing_metadata(self)

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

@@ -1,35 +0,0 @@
-# Copyright 2019 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.
-"""Exceptions for the aio version of the RPC calls."""
-
-
-cdef class _AioRpcError(Exception):
-
-    def __cinit__(self, tuple initial_metadata, int code, str details, tuple trailing_metadata):
-        self._initial_metadata = initial_metadata
-        self._code = code
-        self._details = details
-        self._trailing_metadata = trailing_metadata
-
-    cpdef tuple initial_metadata(self):
-        return self._initial_metadata
-
-    cpdef int code(self):
-        return self._code
-
-    cpdef str details(self):
-        return self._details
-
-    cpdef tuple trailing_metadata(self):
-        return self._trailing_metadata

src/python/grpcio/grpc/_cython/cygrpc.pyx

@@ -63,7 +63,6 @@ include "_cygrpc/aio/iomgr/resolver.pyx.pxi"
 include "_cygrpc/aio/grpc_aio.pyx.pxi"
 include "_cygrpc/aio/call.pyx.pxi"
 include "_cygrpc/aio/channel.pyx.pxi"
-include "_cygrpc/aio/rpc_error.pyx.pxi"
 include "_cygrpc/aio/server.pyx.pxi"
 
 

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

@@ -14,11 +14,8 @@
 """gRPC's Asynchronous Python API."""
 
 import abc
-import types
 import six
 
-import grpc
-from grpc._cython import cygrpc
 from grpc._cython.cygrpc import init_grpc_aio
 from ._server import server
 
@@ -78,7 +75,6 @@ class UnaryUnaryMultiCallable(six.with_metaclass(abc.ABCMeta)):
     @abc.abstractmethod
     async def __call__(self,
                        request,
-                       *,
                        timeout=None,
                        metadata=None,
                        credentials=None,
@@ -126,25 +122,3 @@ def insecure_channel(target, options=None, compression=None):
     from grpc.experimental.aio import _channel  # pylint: disable=cyclic-import
     return _channel.Channel(target, ()
                             if options is None else options, None, compression)
-
-
-class _AioRpcError:
-    """Private implementation of AioRpcError"""
-
-
-class AioRpcError:
-    """An RpcError to be used by the asynchronous API.
-
-    Parent classes: (cygrpc._AioRpcError, RpcError)
-    """
-    # Dynamically registered as subclass of _AioRpcError and RpcError, because the former one is
-    # only available after the cython code has been compiled.
-    _class_built = _AioRpcError
-
-    def __new__(cls, *args, **kwargs):
-        if cls._class_built is _AioRpcError:
-            cls._class_built = types.new_class(
-                "AioRpcError", (cygrpc._AioRpcError, grpc.RpcError))
-            cls._class_built.__doc__ = cls.__doc__
-
-        return cls._class_built(*args, **kwargs)

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

@@ -12,42 +12,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Invocation-side implementation of gRPC Asyncio Python."""
-import asyncio
-from typing import Callable, Optional
 
 from grpc import _common
 from grpc._cython import cygrpc
 from grpc.experimental import aio
 
-SerializingFunction = Callable[[str], bytes]
-DeserializingFunction = Callable[[bytes], str]
-
 
 class UnaryUnaryMultiCallable(aio.UnaryUnaryMultiCallable):
 
-    def __init__(self, channel: cygrpc.AioChannel, method: bytes,
-                 request_serializer: SerializingFunction,
-                 response_deserializer: DeserializingFunction) -> None:
+    def __init__(self, channel, method, request_serializer,
+                 response_deserializer):
         self._channel = channel
         self._method = method
         self._request_serializer = request_serializer
         self._response_deserializer = response_deserializer
-        self._loop = asyncio.get_event_loop()
-
-    def _timeout_to_deadline(self, timeout: int) -> Optional[int]:
-        if timeout is None:
-            return None
-        return self._loop.time() + timeout
 
     async def __call__(self,
                        request,
-                       *,
                        timeout=None,
                        metadata=None,
                        credentials=None,
                        wait_for_ready=None,
                        compression=None):
 
+        if timeout:
+            raise NotImplementedError("TODO: timeout not implemented yet")
+
         if metadata:
             raise NotImplementedError("TODO: metadata not implemented yet")
 
@@ -61,11 +51,9 @@ class UnaryUnaryMultiCallable(aio.UnaryUnaryMultiCallable):
         if compression:
             raise NotImplementedError("TODO: compression not implemented yet")
 
-        serialized_request = _common.serialize(request,
-                                               self._request_serializer)
-        timeout = self._timeout_to_deadline(timeout)
-        response = await self._channel.unary_unary(self._method,
-                                                   serialized_request, timeout)
+        response = await self._channel.unary_unary(
+            self._method, _common.serialize(request, self._request_serializer))
+
         return _common.deserialize(response, self._response_deserializer)
 
 

src/python/grpcio_tests/tests_aio/tests.json

@@ -1,6 +1,5 @@
 [
   "_sanity._sanity_test.AioSanityTest",
   "unit.channel_test.TestChannel",
-  "unit.init_test.TestAioRpcError",
   "unit.init_test.TestInsecureChannel"
 ]

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

@@ -15,12 +15,9 @@
 import logging
 import unittest
 
-import grpc
-
 from grpc.experimental import aio
 from tests_aio.unit import test_base
 from src.proto.grpc.testing import messages_pb2
-from tests.unit.framework.common import test_constants
 
 
 class TestChannel(test_base.AioTestBase):
@@ -55,36 +52,6 @@ class TestChannel(test_base.AioTestBase):
 
         self.loop.run_until_complete(coro())
 
-    def test_unary_call_times_out(self):
-
-        async def coro():
-            async with aio.insecure_channel(self.server_target) as channel:
-                empty_call_with_sleep = channel.unary_unary(
-                    "/grpc.testing.TestService/EmptyCall",
-                    request_serializer=messages_pb2.SimpleRequest.
-                    SerializeToString,
-                    response_deserializer=messages_pb2.SimpleResponse.
-                    FromString,
-                )
-                timeout = test_constants.SHORT_TIMEOUT / 2
-                # TODO: Update once the async server is ready, change the synchronization mechanism by removing the
-                # sleep(<timeout>) as both components (client & server) will be on the same process.
-                with self.assertRaises(grpc.RpcError) as exception_context:
-                    await empty_call_with_sleep(
-                        messages_pb2.SimpleRequest(), timeout=timeout)
-
-                status_code, details = grpc.StatusCode.DEADLINE_EXCEEDED.value
-                self.assertEqual(exception_context.exception.code(),
-                                 status_code)
-                self.assertEqual(exception_context.exception.details(),
-                                 details.title())
-                self.assertIsNotNone(
-                    exception_context.exception.initial_metadata())
-                self.assertIsNotNone(
-                    exception_context.exception.trailing_metadata())
-
-        self.loop.run_until_complete(coro())
-
 
 if __name__ == '__main__':
     logging.basicConfig()

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

@@ -15,50 +15,10 @@
 import logging
 import unittest
 
-import grpc
 from grpc.experimental import aio
 from tests_aio.unit import test_base
 
 
-class TestAioRpcError(unittest.TestCase):
-    _TEST_INITIAL_METADATA = ("initial metadata",)
-    _TEST_TRAILING_METADATA = ("trailing metadata",)
-
-    def test_attributes(self):
-        aio_rpc_error = aio.AioRpcError(self._TEST_INITIAL_METADATA, 0,
-                                        "details", self._TEST_TRAILING_METADATA)
-        self.assertEqual(aio_rpc_error.initial_metadata(),
-                         self._TEST_INITIAL_METADATA)
-        self.assertEqual(aio_rpc_error.code(), 0)
-        self.assertEqual(aio_rpc_error.details(), "details")
-        self.assertEqual(aio_rpc_error.trailing_metadata(),
-                         self._TEST_TRAILING_METADATA)
-
-    def test_class_hierarchy(self):
-        aio_rpc_error = aio.AioRpcError(self._TEST_INITIAL_METADATA, 0,
-                                        "details", self._TEST_TRAILING_METADATA)
-
-        self.assertIsInstance(aio_rpc_error, grpc.RpcError)
-
-    def test_class_attributes(self):
-        aio_rpc_error = aio.AioRpcError(self._TEST_INITIAL_METADATA, 0,
-                                        "details", self._TEST_TRAILING_METADATA)
-        self.assertEqual(aio_rpc_error.__class__.__name__, "AioRpcError")
-        self.assertEqual(aio_rpc_error.__class__.__doc__,
-                         aio.AioRpcError.__doc__)
-
-    def test_class_singleton(self):
-        first_aio_rpc_error = aio.AioRpcError(self._TEST_INITIAL_METADATA, 0,
-                                              "details",
-                                              self._TEST_TRAILING_METADATA)
-        second_aio_rpc_error = aio.AioRpcError(self._TEST_INITIAL_METADATA, 0,
-                                               "details",
-                                               self._TEST_TRAILING_METADATA)
-
-        self.assertIs(first_aio_rpc_error.__class__,
-                      second_aio_rpc_error.__class__)
-
-
 class TestInsecureChannel(test_base.AioTestBase):
 
     def test_insecure_channel(self):

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

@@ -20,7 +20,6 @@ from time import sleep
 import grpc
 from src.proto.grpc.testing import messages_pb2
 from src.proto.grpc.testing import test_pb2_grpc
-from tests.unit.framework.common import test_constants
 
 
 # TODO (https://github.com/grpc/grpc/issues/19762)
@@ -30,10 +29,6 @@ class TestServiceServicer(test_pb2_grpc.TestServiceServicer):
     def UnaryCall(self, request, context):
         return messages_pb2.SimpleResponse()
 
-    def EmptyCall(self, request, context):
-        while True:
-            sleep(test_constants.LONG_TIMEOUT)
-
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description='Synchronous gRPC server.')