Merge branch 'master' into fix/prefix

Conflicts:
	src/ruby/ext/grpc/rb_byte_buffer.c
	src/ruby/ext/grpc/rb_byte_buffer.h
	src/ruby/ext/grpc/rb_call.c
	src/ruby/ext/grpc/rb_call.h
	src/ruby/ext/grpc/rb_channel.c
	src/ruby/ext/grpc/rb_completion_queue.h
	src/ruby/ext/grpc/rb_event.c
	src/ruby/ext/grpc/rb_grpc.c
	src/ruby/ext/grpc/rb_metadata.c
	src/ruby/ext/grpc/rb_server.c
	test/cpp/interop/client_helper.h
	test/cpp/interop/server_helper.h

build.json

@@ -29,6 +29,12 @@
         "include/grpc++/impl/rpc_method.h",
         "include/grpc++/impl/rpc_service_method.h",
         "include/grpc++/impl/service_type.h",
+        "include/grpc++/impl/sync.h",
+        "include/grpc++/impl/sync_cxx11.h",
+        "include/grpc++/impl/sync_no_cxx11.h",
+        "include/grpc++/impl/thd.h",
+        "include/grpc++/impl/thd_cxx11.h",
+        "include/grpc++/impl/thd_no_cxx11.h",
         "include/grpc++/server.h",
         "include/grpc++/server_builder.h",
         "include/grpc++/server_context.h",
@@ -297,6 +303,10 @@
         "include/grpc/support/sync_win32.h",
         "include/grpc/support/thd.h",
         "include/grpc/support/time.h",
+        "include/grpc/support/tls.h",
+        "include/grpc/support/tls_gcc.h",
+        "include/grpc/support/tls_msvc.h",
+        "include/grpc/support/tls_pthread.h",
         "include/grpc/support/useful.h"
       ],
       "headers": [
@@ -464,6 +474,10 @@
       "name": "grpc++",
       "build": "all",
       "language": "c++",
+      "headers": [
+        "src/cpp/client/secure_credentials.h",
+        "src/cpp/server/secure_server_credentials.h"
+      ],
       "src": [
         "src/cpp/client/secure_credentials.cc",
         "src/cpp/server/secure_server_credentials.cc"
@@ -531,6 +545,39 @@
       "deps": [],
       "secure": "no"
     },
+    {
+      "name": "interop_client_lib",
+      "build": "private",
+      "language": "c++",
+      "src": [
+        "test/cpp/interop/empty.proto",
+        "test/cpp/interop/messages.proto",
+        "test/cpp/interop/test.proto",
+        "test/cpp/interop/client_helper.cc",
+        "test/cpp/interop/interop_client.cc"
+      ],
+      "deps": [
+        "grpc++_test_util",
+        "grpc_test_util",
+        "grpc++",
+        "grpc",
+        "gpr"
+      ]
+    },
+    {
+      "name": "interop_server_lib",
+      "build": "private",
+      "language": "c++",
+      "src": [
+        "test/cpp/interop/server_helper.cc"
+      ],
+      "deps": [
+        "grpc_test_util",
+        "grpc++",
+        "grpc",
+        "gpr"
+      ]
+    },
     {
       "name": "pubsub_client_lib",
       "build": "private",
@@ -554,11 +601,13 @@
       "language": "c++",
       "headers": [
         "test/cpp/qps/driver.h",
+        "test/cpp/qps/report.h",
         "test/cpp/qps/timer.h"
       ],
       "src": [
         "test/cpp/qps/qpstest.proto",
         "test/cpp/qps/driver.cc",
+        "test/cpp/qps/report.cc",
         "test/cpp/qps/timer.cc"
       ]
     },
@@ -1144,6 +1193,18 @@
         "gpr"
       ]
     },
+    {
+      "name": "gpr_tls_test",
+      "build": "test",
+      "language": "c",
+      "src": [
+        "test/core/support/tls_test.c"
+      ],
+      "deps": [
+        "gpr_test_util",
+        "gpr"
+      ]
+    },
     {
       "name": "gpr_useful_test",
       "build": "test",
@@ -1862,12 +1923,10 @@
       "run": false,
       "language": "c++",
       "src": [
-        "test/cpp/interop/empty.proto",
-        "test/cpp/interop/messages.proto",
-        "test/cpp/interop/test.proto",
         "test/cpp/interop/client.cc"
       ],
       "deps": [
+        "interop_client_lib",
         "grpc++_test_util",
         "grpc_test_util",
         "grpc++",
@@ -1888,6 +1947,7 @@
         "test/cpp/interop/server.cc"
       ],
       "deps": [
+        "interop_server_lib",
         "grpc++_test_util",
         "grpc_test_util",
         "grpc++",
@@ -1979,6 +2039,24 @@
         "gpr"
       ]
     },
+    {
+      "name": "qps_smoke_test",
+      "build": "test",
+      "run": false,
+      "language": "c++",
+      "src": [
+        "test/cpp/qps/smoke_test.cc"
+      ],
+      "deps": [
+        "qps",
+        "grpc++_test_util",
+        "grpc_test_util",
+        "grpc++",
+        "grpc",
+        "gpr_test_util",
+        "gpr"
+      ]
+    },
     {
       "name": "qps_worker",
       "build": "test",

include/grpc/support/port_platform.h

@@ -55,14 +55,17 @@
 #define GPR_WINSOCK_SOCKET 1
 #ifdef __GNUC__
 #define GPR_GCC_ATOMIC 1
+#define GPR_GCC_TLS 1
 #else
 #define GPR_WIN32_ATOMIC 1
+#define GPR_MSVC_TLS 1
 #endif
 #elif defined(ANDROID) || defined(__ANDROID__)
 #define GPR_ANDROID 1
 #define GPR_ARCH_32 1
 #define GPR_CPU_LINUX 1
 #define GPR_GCC_SYNC 1
+#define GPR_GCC_TLS 1
 #define GPR_POSIX_MULTIPOLL_WITH_POLL 1
 #define GPR_POSIX_WAKEUP_FD 1
 #define GPR_LINUX_EVENTFD 1
@@ -88,6 +91,7 @@
 #include <features.h>
 #define GPR_CPU_LINUX 1
 #define GPR_GCC_ATOMIC 1
+#define GPR_GCC_TLS 1
 #define GPR_LINUX 1
 #define GPR_LINUX_MULTIPOLL_WITH_EPOLL 1
 #define GPR_POSIX_WAKEUP_FD 1
@@ -134,6 +138,31 @@
 #define GPR_CPU_POSIX 1
 #endif
 #define GPR_GCC_ATOMIC 1
+#define GPR_GCC_TLS 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_MULTIPOLL_WITH_POLL 1
+#define GPR_POSIX_WAKEUP_FD 1
+#define GPR_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GPR_POSIX_SOCKET 1
+#define GPR_POSIX_SOCKETADDR 1
+#define GPR_POSIX_SOCKETUTILS 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_FILE 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#elif defined(__FreeBSD__)
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+#define GPR_CPU_POSIX 1
+#define GPR_GCC_ATOMIC 1
 #define GPR_POSIX_LOG 1
 #define GPR_POSIX_MULTIPOLL_WITH_POLL 1
 #define GPR_POSIX_WAKEUP_FD 1
@@ -202,6 +231,10 @@
 #error Must define exactly one of GPR_POSIX_SOCKET, GPR_WIN32
 #endif
 
+#if defined(GPR_MSVC_TLS) + defined(GPR_GCC_TLS) + defined(GPR_PTHREAD_TLS) != 1
+#error Must define exactly one of GPR_MSVC_TLS, GPR_GCC_TLS, GPR_PTHREAD_TLS
+#endif
+
 typedef int16_t gpr_int16;
 typedef int32_t gpr_int32;
 typedef int64_t gpr_int64;

include/grpc/support/tls.h

@@ -0,0 +1,77 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_TLS_H
+#define GRPC_SUPPORT_TLS_H
+
+#include "port_platform.h"
+
+/* Thread local storage.
+
+   A minimal wrapper that should be implementable across many compilers,
+   and implementable efficiently across most modern compilers.
+
+   Thread locals have type gpr_intptr.
+
+   Declaring a thread local variable 'foo':
+     GPR_TLS_DECL(foo, initial_value);
+   Thread locals always have static scope.
+
+   Initializing a thread local (must be done at library initialization 
+   time):
+     gpr_tls_init(&foo);
+
+   Destroying a thread local:
+     gpr_tls_destroy(&foo);
+
+   Setting a thread local:
+     gpr_tls_set(&foo, new_value);
+
+   Accessing a thread local:
+     current_value = gpr_tls_get(&foo, value); 
+
+   ALL functions here may be implemented as macros. */
+
+#ifdef GPR_GCC_TLS
+#include "tls_gcc.h"
+#endif
+
+#ifdef GPR_MSVC_TLS
+#include "tls_msvc.h"
+#endif
+
+#ifdef GPR_PTHREAD_TLS
+#include "tls_pthread.h"
+#endif
+
+#endif

include/grpc/support/tls_gcc.h

@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_TLS_GCC_H
+#define GRPC_SUPPORT_TLS_GCC_H
+
+/* Thread local storage based on gcc compiler primitives.
+   #include tls.h to use this - and see that file for documentation */
+
+struct gpr_gcc_thread_local {
+  gpr_intptr value;
+};
+
+#define GPR_TLS_DECL(name) \
+    static __thread struct gpr_gcc_thread_local name = {0}
+
+#define gpr_tls_init(tls) do {} while (0)
+#define gpr_tls_destroy(tls) do {} while (0)
+#define gpr_tls_set(tls, new_value) (((tls)->value) = (new_value))
+#define gpr_tls_get(tls) ((tls)->value)
+
+#endif

include/grpc/support/tls_msvc.h

@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_TLS_GCC_H
+#define GRPC_SUPPORT_TLS_GCC_H
+
+/* Thread local storage based on ms visual c compiler primitives.
+   #include tls.h to use this - and see that file for documentation */
+
+struct gpr_msvc_thread_local {
+  gpr_intptr value;
+};
+
+#define GPR_TLS_DECL(name) \
+    static __thread struct gpr_msvc_thread_local name = {0}
+
+#define gpr_tls_init(tls) do {} while (0)
+#define gpr_tls_destroy(tls) do {} while (0)
+#define gpr_tls_set(tls, new_value) (((tls)->value) = (new_value))
+#define gpr_tls_get(tls) ((tls)->value)
+
+#endif

include/grpc/support/tls_pthread.h

@@ -0,0 +1,53 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_TLS_PTHREAD_H
+#define GRPC_SUPPORT_TLS_PTHREAD_H
+
+/* Thread local storage based on pthread library calls.
+   #include tls.h to use this - and see that file for documentation */
+
+struct gpr_pthread_thread_local {
+  pthread_key_t key;
+};
+
+#define GPR_TLS_DECL(name) \
+    static struct gpr_pthread_thread_local name = {0}
+
+#define gpr_tls_init(tls) GPR_ASSERT(0 == pthread_key_create(&(tls)->key, NULL))
+#define gpr_tls_destroy(tls) pthread_key_delete((tls)->key)
+#define gpr_tls_set(tls, new_value) \
+    GPR_ASSERT(pthread_setspecific((tls)->key, (void*)(new_value)) == 0)
+#define gpr_tls_get(tls) ((gpr_intptr)pthread_getspecific((tls)->key))
+
+#endif

src/compiler/cpp_generator.cc

@@ -198,17 +198,18 @@ grpc::string GetHeaderIncludes(const grpc::protobuf::FileDescriptor *file,
 
   temp.append("\n");
 
-  std::vector<grpc::string> parts =
-    grpc_generator::tokenize(file->package(), ".");
+  if (!file->package().empty()) {
+    std::vector<grpc::string> parts =
+        grpc_generator::tokenize(file->package(), ".");
 
-  for (auto part = parts.begin(); part != parts.end(); part++) {
-    temp.append("namespace ");
-    temp.append(*part);
-    temp.append(" {\n");
+    for (auto part = parts.begin(); part != parts.end(); part++) {
+      temp.append("namespace ");
+      temp.append(*part);
+      temp.append(" {\n");
+    }
+    temp.append("\n");
   }
 
-  temp.append("\n");
-
   return temp;
 }
 
@@ -431,15 +432,18 @@ grpc::string GetHeaderEpilogue(const grpc::protobuf::FileDescriptor *file,
   vars["filename"] = file->name();
   vars["filename_identifier"] = FilenameIdentifier(file->name());
 
-  std::vector<grpc::string> parts =
-    grpc_generator::tokenize(file->package(), ".");
+  if (!file->package().empty()) {
+    std::vector<grpc::string> parts =
+        grpc_generator::tokenize(file->package(), ".");
 
-  for (auto part = parts.rbegin(); part != parts.rend(); part++) {
-    vars["part"] = *part;
-    printer.Print(vars, "}  // namespace $part$\n");
+    for (auto part = parts.rbegin(); part != parts.rend(); part++) {
+      vars["part"] = *part;
+      printer.Print(vars, "}  // namespace $part$\n");
+    }
+    printer.Print(vars, "\n");
   }
 
-  printer.Print(vars, "\n\n");
+  printer.Print(vars, "\n");
   printer.Print(vars, "#endif  // GRPC_$filename_identifier$__INCLUDED\n");
 
   return output;
@@ -480,12 +484,14 @@ grpc::string GetSourceIncludes(const grpc::protobuf::FileDescriptor *file,
   printer.Print(vars, "#include <grpc++/impl/service_type.h>\n");
   printer.Print(vars, "#include <grpc++/stream.h>\n");
 
-  std::vector<grpc::string> parts =
-    grpc_generator::tokenize(file->package(), ".");
+  if (!file->package().empty()) {
+    std::vector<grpc::string> parts =
+        grpc_generator::tokenize(file->package(), ".");
 
-  for (auto part = parts.begin(); part != parts.end(); part++) {
-    vars["part"] = *part;
-    printer.Print(vars, "namespace $part$ {\n");
+    for (auto part = parts.begin(); part != parts.end(); part++) {
+      vars["part"] = *part;
+      printer.Print(vars, "namespace $part$ {\n");
+    }
   }
 
   printer.Print(vars, "\n");
@@ -860,17 +866,18 @@ grpc::string GetSourceEpilogue(const grpc::protobuf::FileDescriptor *file,
                                const Parameters &params) {
   grpc::string temp;
 
-  std::vector<grpc::string> parts =
-    grpc_generator::tokenize(file->package(), ".");
+  if (!file->package().empty()) {
+    std::vector<grpc::string> parts =
+        grpc_generator::tokenize(file->package(), ".");
 
-  for (auto part = parts.begin(); part != parts.end(); part++) {
-    temp.append("}  // namespace ");
-    temp.append(*part);
+    for (auto part = parts.begin(); part != parts.end(); part++) {
+      temp.append("}  // namespace ");
+      temp.append(*part);
+      temp.append("\n");
+    }
     temp.append("\n");
   }
 
-  temp.append("\n");
-
   return temp;
 }
 

src/core/iomgr/pollset_multipoller_with_poll_posix.c

@@ -172,6 +172,9 @@ static int multipoll_with_poll_pollset_maybe_work(
   }
 
   r = poll(h->pfds, h->pfd_count, timeout);
+
+  end_polling(pollset);
+
   if (r < 0) {
     if (errno != EINTR) {
       gpr_log(GPR_ERROR, "poll() failed: %s", strerror(errno));
@@ -192,7 +195,6 @@ static int multipoll_with_poll_pollset_maybe_work(
     }
   }
   grpc_pollset_kick_post_poll(&pollset->kick_state);
-  end_polling(pollset);
 
   gpr_mu_lock(&pollset->mu);
   pollset->counter = 0;

src/core/iomgr/pollset_posix.c

@@ -396,6 +396,9 @@ static int unary_poll_pollset_maybe_work(grpc_pollset *pollset,
   pfd[1].events = grpc_fd_begin_poll(fd, pollset, POLLIN, POLLOUT, &fd_watcher);
 
   r = poll(pfd, GPR_ARRAY_SIZE(pfd), timeout);
+
+  grpc_fd_end_poll(&fd_watcher);
+
   if (r < 0) {
     if (errno != EINTR) {
       gpr_log(GPR_ERROR, "poll() failed: %s", strerror(errno));
@@ -415,7 +418,6 @@ static int unary_poll_pollset_maybe_work(grpc_pollset *pollset,
   }
 
   grpc_pollset_kick_post_poll(&pollset->kick_state);
-  grpc_fd_end_poll(&fd_watcher);
 
   gpr_mu_lock(&pollset->mu);
   pollset->counter = 0;

src/cpp/client/secure_credentials.cc

@@ -31,38 +31,23 @@
  *
  */
 
-#include <grpc/grpc_security.h>
 #include <grpc/support/log.h>
 
 #include <grpc++/channel_arguments.h>
-#include <grpc++/config.h>
-#include <grpc++/credentials.h>
 #include "src/cpp/client/channel.h"
+#include "src/cpp/client/secure_credentials.h"
 
 namespace grpc {
 
-class SecureCredentials GRPC_FINAL : public Credentials {
- public:
-  explicit SecureCredentials(grpc_credentials* c_creds) : c_creds_(c_creds) {}
-  ~SecureCredentials() GRPC_OVERRIDE { grpc_credentials_release(c_creds_); }
-  grpc_credentials* GetRawCreds() { return c_creds_; }
-
-  std::shared_ptr<grpc::ChannelInterface> CreateChannel(
-      const string& target, const grpc::ChannelArguments& args) GRPC_OVERRIDE {
-    grpc_channel_args channel_args;
-    args.SetChannelArgs(&channel_args);
-    return std::shared_ptr<ChannelInterface>(new Channel(
-        args.GetSslTargetNameOverride().empty()
-            ? target
-            : args.GetSslTargetNameOverride(),
-        grpc_secure_channel_create(c_creds_, target.c_str(), &channel_args)));
-  }
-
-  SecureCredentials* AsSecureCredentials() GRPC_OVERRIDE { return this; }
-
- private:
-  grpc_credentials* const c_creds_;
-};
+std::shared_ptr<grpc::ChannelInterface> SecureCredentials::CreateChannel(
+    const string& target, const grpc::ChannelArguments& args) {
+  grpc_channel_args channel_args;
+  args.SetChannelArgs(&channel_args);
+  return std::shared_ptr<ChannelInterface>(new Channel(
+      args.GetSslTargetNameOverride().empty() ? target
+                                              : args.GetSslTargetNameOverride(),
+      grpc_secure_channel_create(c_creds_, target.c_str(), &channel_args)));
+}
 
 namespace {
 std::unique_ptr<Credentials> WrapCredentials(grpc_credentials* creds) {

src/cpp/client/secure_credentials.h

@@ -0,0 +1,61 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_INTERNAL_CPP_CLIENT_SECURE_CREDENTIALS_H
+#define GRPC_INTERNAL_CPP_CLIENT_SECURE_CREDENTIALS_H
+
+#include <grpc/grpc_security.h>
+
+#include <grpc++/config.h>
+#include <grpc++/credentials.h>
+
+namespace grpc {
+
+class SecureCredentials GRPC_FINAL : public Credentials {
+ public:
+  explicit SecureCredentials(grpc_credentials* c_creds) : c_creds_(c_creds) {}
+  ~SecureCredentials() GRPC_OVERRIDE { grpc_credentials_release(c_creds_); }
+  grpc_credentials* GetRawCreds() { return c_creds_; }
+
+  std::shared_ptr<grpc::ChannelInterface> CreateChannel(
+      const string& target, const grpc::ChannelArguments& args) GRPC_OVERRIDE;
+  SecureCredentials* AsSecureCredentials() GRPC_OVERRIDE { return this; }
+
+ private:
+  grpc_credentials* const c_creds_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPC_INTERNAL_CPP_CLIENT_SECURE_CREDENTIALS_H
+

src/cpp/server/secure_server_credentials.cc

@@ -31,39 +31,22 @@
  *
  */
 
-#include <grpc/grpc_security.h>
-
-#include <grpc++/server_credentials.h>
+#include "src/cpp/server/secure_server_credentials.h"
 
 namespace grpc {
 
-namespace {
-class SecureServerCredentials GRPC_FINAL : public ServerCredentials {
- public:
-  explicit SecureServerCredentials(grpc_server_credentials* creds)
-      : creds_(creds) {}
-  ~SecureServerCredentials() GRPC_OVERRIDE {
-    grpc_server_credentials_release(creds_);
-  }
-
-  int AddPortToServer(const grpc::string& addr,
-                      grpc_server* server) GRPC_OVERRIDE {
-    return grpc_server_add_secure_http2_port(server, addr.c_str(), creds_);
-  }
-
- private:
-  grpc_server_credentials* const creds_;
-};
-}  // namespace
+int SecureServerCredentials::AddPortToServer(
+    const grpc::string& addr, grpc_server* server) {
+  return grpc_server_add_secure_http2_port(server, addr.c_str(), creds_);
+}
 
 std::shared_ptr<ServerCredentials> SslServerCredentials(
     const SslServerCredentialsOptions& options) {
   std::vector<grpc_ssl_pem_key_cert_pair> pem_key_cert_pairs;
   for (auto key_cert_pair = options.pem_key_cert_pairs.begin();
-       key_cert_pair != options.pem_key_cert_pairs.end();
-       key_cert_pair++) {
+       key_cert_pair != options.pem_key_cert_pairs.end(); key_cert_pair++) {
     grpc_ssl_pem_key_cert_pair p = {key_cert_pair->private_key.c_str(),
-				    key_cert_pair->cert_chain.c_str()};
+                                    key_cert_pair->cert_chain.c_str()};
     pem_key_cert_pairs.push_back(p);
   }
   grpc_server_credentials* c_creds = grpc_ssl_server_credentials_create(

src/cpp/server/secure_server_credentials.h

@@ -0,0 +1,60 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_INTERNAL_CPP_SERVER_SECURE_SERVER_CREDENTIALS_H
+#define GRPC_INTERNAL_CPP_SERVER_SECURE_SERVER_CREDENTIALS_H
+
+#include <grpc/grpc_security.h>
+
+#include <grpc++/server_credentials.h>
+
+namespace grpc {
+
+class SecureServerCredentials GRPC_FINAL : public ServerCredentials {
+ public:
+  explicit SecureServerCredentials(grpc_server_credentials* creds)
+      : creds_(creds) {}
+  ~SecureServerCredentials() GRPC_OVERRIDE {
+    grpc_server_credentials_release(creds_);
+  }
+
+  int AddPortToServer(const grpc::string& addr,
+                      grpc_server* server) GRPC_OVERRIDE;
+
+ private:
+  grpc_server_credentials* const creds_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPC_INTERNAL_CPP_SERVER_SECURE_SERVER_CREDENTIALS_H

src/ruby/ext/grpc/rb_byte_buffer.c

@@ -39,203 +39,29 @@
 #include <grpc/support/slice.h>
 #include "rb_grpc.h"
 
-/* grpc_rb_byte_buffer wraps a grpc_byte_buffer.  It provides a peer ruby
- * object, 'mark' to minimize copying when a byte_buffer is created from
- * ruby. */
-typedef struct grpc_rb_byte_buffer {
-  /* Holder of ruby objects involved in constructing the status */
-  VALUE mark;
-  /* The actual status */
-  grpc_byte_buffer *wrapped;
-} grpc_rb_byte_buffer;
-
-/* Destroys ByteBuffer instances. */
-static void grpc_rb_byte_buffer_free(void *p) {
-  grpc_rb_byte_buffer *bb = NULL;
-  if (p == NULL) {
-    return;
-  };
-  bb = (grpc_rb_byte_buffer *)p;
-
-  /* Deletes the wrapped object if the mark object is Qnil, which indicates
-   * that no other object is the actual owner. */
-  if (bb->wrapped != NULL && bb->mark == Qnil) {
-    grpc_byte_buffer_destroy(bb->wrapped);
-  }
-
-  xfree(p);
-}
-
-/* Protects the mark object from GC */
-static void grpc_rb_byte_buffer_mark(void *p) {
-  grpc_rb_byte_buffer *bb = NULL;
-  if (p == NULL) {
-    return;
-  }
-  bb = (grpc_rb_byte_buffer *)p;
-
-  /* If it's not already cleaned up, mark the mark object */
-  if (bb->mark != Qnil && BUILTIN_TYPE(bb->mark) != T_NONE) {
-    rb_gc_mark(bb->mark);
-  }
+grpc_byte_buffer* grpc_rb_s_to_byte_buffer(char *string, size_t length) {
+  gpr_slice slice = gpr_slice_from_copied_buffer(string, length);
+  grpc_byte_buffer *buffer = grpc_byte_buffer_create(&slice, 1);
+  gpr_slice_unref(slice);
+  return buffer;
 }
 
-/* id_source is the name of the hidden ivar the preserves the original
- * byte_buffer source string */
-static ID id_source;
-
-/* Allocates ByteBuffer instances.
-
-   Provides safe default values for the byte_buffer fields. */
-static VALUE grpc_rb_byte_buffer_alloc(VALUE cls) {
-  grpc_rb_byte_buffer *wrapper = ALLOC(grpc_rb_byte_buffer);
-  wrapper->wrapped = NULL;
-  wrapper->mark = Qnil;
-  return Data_Wrap_Struct(cls, grpc_rb_byte_buffer_mark,
-                          grpc_rb_byte_buffer_free, wrapper);
-}
-
-/* Clones ByteBuffer instances.
-
-   Gives ByteBuffer a consistent implementation of Ruby's object copy/dup
-   protocol. */
-static VALUE grpc_rb_byte_buffer_init_copy(VALUE copy, VALUE orig) {
-  grpc_rb_byte_buffer *orig_bb = NULL;
-  grpc_rb_byte_buffer *copy_bb = NULL;
-
-  if (copy == orig) {
-    return copy;
-  }
-
-  /* Raise an error if orig is not a metadata object or a subclass. */
-  if (TYPE(orig) != T_DATA ||
-      RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_byte_buffer_free) {
-    rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(grpc_cByteBuffer));
-  }
-
-  Data_Get_Struct(orig, grpc_rb_byte_buffer, orig_bb);
-  Data_Get_Struct(copy, grpc_rb_byte_buffer, copy_bb);
-
-  /* use ruby's MEMCPY to make a byte-for-byte copy of the metadata wrapper
-   * object. */
-  MEMCPY(copy_bb, orig_bb, grpc_rb_byte_buffer, 1);
-  return copy;
-}
-
-/* id_empty is used to return the empty string from to_s when necessary. */
-static ID id_empty;
-
-static VALUE grpc_rb_byte_buffer_to_s(VALUE self) {
-  grpc_rb_byte_buffer *wrapper = NULL;
-  grpc_byte_buffer *bb = NULL;
-  grpc_byte_buffer_reader *reader = NULL;
-  char *output = NULL;
+VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer *buffer) {
   size_t length = 0;
+  char *string = NULL;
   size_t offset = 0;
-  VALUE output_obj = Qnil;
+  grpc_byte_buffer_reader *reader = NULL;
   gpr_slice next;
+  if (buffer == NULL) {
+    return Qnil;
 
-  Data_Get_Struct(self, grpc_rb_byte_buffer, wrapper);
-  output_obj = rb_ivar_get(wrapper->mark, id_source);
-  if (output_obj != Qnil) {
-    /* From ruby, ByteBuffers are immutable so if a source is set, return that
-     * as the to_s value */
-    return output_obj;
-  }
-
-  /* Read the bytes. */
-  bb = wrapper->wrapped;
-  if (bb == NULL) {
-    return rb_id2str(id_empty);
-  }
-  length = grpc_byte_buffer_length(bb);
-  if (length == 0) {
-    return rb_id2str(id_empty);
   }
-  reader = grpc_byte_buffer_reader_create(bb);
-  output = xmalloc(length);
+  length = grpc_byte_buffer_length(buffer);
+  string = xmalloc(length + 1);
+  reader = grpc_byte_buffer_reader_create(buffer);
   while (grpc_byte_buffer_reader_next(reader, &next) != 0) {
-    memcpy(output + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
+    memcpy(string + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
     offset += GPR_SLICE_LENGTH(next);
   }
-  output_obj = rb_str_new(output, length);
-
-  /* Save a references to the computed string in the mark object so that the
-   * calling to_s does not do any allocations. */
-  wrapper->mark = rb_class_new_instance(0, NULL, rb_cObject);
-  rb_ivar_set(wrapper->mark, id_source, output_obj);
-
-  return output_obj;
-}
-
-/* Initializes ByteBuffer instances. */
-static VALUE grpc_rb_byte_buffer_init(VALUE self, VALUE src) {
-  gpr_slice a_slice;
-  grpc_rb_byte_buffer *wrapper = NULL;
-  grpc_byte_buffer *byte_buffer = NULL;
-
-  if (TYPE(src) != T_STRING) {
-    rb_raise(rb_eTypeError, "bad byte_buffer arg: got <%s>, want <String>",
-             rb_obj_classname(src));
-    return Qnil;
-  }
-  Data_Get_Struct(self, grpc_rb_byte_buffer, wrapper);
-  a_slice = gpr_slice_malloc(RSTRING_LEN(src));
-  memcpy(GPR_SLICE_START_PTR(a_slice), RSTRING_PTR(src), RSTRING_LEN(src));
-  byte_buffer = grpc_byte_buffer_create(&a_slice, 1);
-  gpr_slice_unref(a_slice);
-
-  if (byte_buffer == NULL) {
-    rb_raise(rb_eArgError, "could not create a byte_buffer, not sure why");
-    return Qnil;
-  }
-  wrapper->wrapped = byte_buffer;
-
-  /* Save a references to the original string in the mark object so that the
-   * pointers used there is valid for the lifetime of the object. */
-  wrapper->mark = rb_class_new_instance(0, NULL, rb_cObject);
-  rb_ivar_set(wrapper->mark, id_source, src);
-
-  return self;
-}
-
-/* grpc_cByteBuffer is the ruby class that proxies grpc_byte_buffer. */
-VALUE grpc_cByteBuffer = Qnil;
-
-void Init_grpc_byte_buffer() {
-  grpc_cByteBuffer =
-      rb_define_class_under(grpc_mGrpcCore, "ByteBuffer", rb_cObject);
-
-  /* Allocates an object managed by the ruby runtime */
-  rb_define_alloc_func(grpc_cByteBuffer, grpc_rb_byte_buffer_alloc);
-
-  /* Provides a ruby constructor and support for dup/clone. */
-  rb_define_method(grpc_cByteBuffer, "initialize", grpc_rb_byte_buffer_init, 1);
-  rb_define_method(grpc_cByteBuffer, "initialize_copy",
-                   grpc_rb_byte_buffer_init_copy, 1);
-
-  /* Provides a to_s method that returns the buffer value */
-  rb_define_method(grpc_cByteBuffer, "to_s", grpc_rb_byte_buffer_to_s, 0);
-
-  id_source = rb_intern("__source");
-  id_empty = rb_intern("");
-}
-
-VALUE grpc_rb_byte_buffer_create_with_mark(VALUE mark, grpc_byte_buffer *bb) {
-  grpc_rb_byte_buffer *byte_buffer = NULL;
-  if (bb == NULL) {
-    return Qnil;
-  }
-  byte_buffer = ALLOC(grpc_rb_byte_buffer);
-  byte_buffer->wrapped = bb;
-  byte_buffer->mark = mark;
-  return Data_Wrap_Struct(grpc_cByteBuffer, grpc_rb_byte_buffer_mark,
-                          grpc_rb_byte_buffer_free, byte_buffer);
-}
-
-/* Gets the wrapped byte_buffer from the ruby wrapper */
-grpc_byte_buffer *grpc_rb_get_wrapped_byte_buffer(VALUE v) {
-  grpc_rb_byte_buffer *wrapper = NULL;
-  Data_Get_Struct(v, grpc_rb_byte_buffer, wrapper);
-  return wrapper->wrapped;
+  return rb_str_new(string, length);
 }

src/ruby/ext/grpc/rb_byte_buffer.h

@@ -37,18 +37,10 @@
 #include <grpc/grpc.h>
 #include <ruby.h>
 
-/* grpc_cByteBuffer is the ByteBuffer class whose instances proxy
-   grpc_byte_buffer. */
-extern VALUE grpc_cByteBuffer;
+/* Converts a char* with a length to a grpc_byte_buffer */
+grpc_byte_buffer *grpc_rb_s_to_byte_buffer(char *string, size_t length);
 
-/* Initializes the ByteBuffer class. */
-void Init_grpc_byte_buffer();
-
-/* grpc_rb_byte_buffer_create_with_mark creates a grpc_rb_byte_buffer with a
- * ruby mark object that will be kept alive while the byte_buffer is alive. */
-VALUE grpc_rb_byte_buffer_create_with_mark(VALUE mark, grpc_byte_buffer* bb);
-
-/* Gets the wrapped byte_buffer from its ruby object. */
-grpc_byte_buffer* grpc_rb_get_wrapped_byte_buffer(VALUE v);
+/* Converts a grpc_byte_buffer to a ruby string */
+VALUE grpc_rb_byte_buffer_to_s(grpc_byte_buffer *buffer);
 
 #endif /* GRPC_RB_BYTE_BUFFER_H_ */

src/ruby/ext/grpc/rb_call.c

@@ -36,11 +36,19 @@
 #include <ruby.h>
 
 #include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+
 #include "rb_byte_buffer.h"
 #include "rb_completion_queue.h"
-#include "rb_metadata.h"
 #include "rb_grpc.h"
 
+/* grpc_sBatchResult is struct class used to hold the results of a batch call */
+static VALUE grpc_sBatchResult;
+
+/* grpc_cMdAry is the MetadataArray class whose instances proxy
+ * grpc_metadata_array. */
+static VALUE grpc_cMdAry;
+
 /* id_cq is the name of the hidden ivar that preserves a reference to a
  * completion queue */
 static ID id_cq;
@@ -62,6 +70,15 @@ static ID id_metadata;
  * received by the call and subsequently saved on it. */
 static ID id_status;
 
+/* sym_* are the symbol for attributes of grpc_sBatchResult. */
+static VALUE sym_send_message;
+static VALUE sym_send_metadata;
+static VALUE sym_send_close;
+static VALUE sym_send_status;
+static VALUE sym_message;
+static VALUE sym_status;
+static VALUE sym_cancelled;
+
 /* hash_all_calls is a hash of Call address -> reference count that is used to
  * track the creation and destruction of rb_call instances.
  */
@@ -101,84 +118,6 @@ const char *grpc_call_error_detail_of(grpc_call_error err) {
   return detail;
 }
 
-/* grpc_rb_call_add_metadata_hash_cb is the hash iteration callback used by
-   grpc_rb_call_add_metadata.
-*/
-int grpc_rb_call_add_metadata_hash_cb(VALUE key, VALUE val, VALUE call_obj) {
-  grpc_call *call = NULL;
-  grpc_metadata *md = NULL;
-  VALUE md_obj = Qnil;
-  VALUE md_obj_args[2];
-  VALUE flags = rb_ivar_get(call_obj, id_flags);
-  grpc_call_error err;
-  int array_length;
-  int i;
-
-  /* Construct a metadata object from key and value and add it */
-  Data_Get_Struct(call_obj, grpc_call, call);
-  md_obj_args[0] = key;
-
-  if (TYPE(val) == T_ARRAY) {
-    /* If the value is an array, add each value in the array separately */
-    array_length = RARRAY_LEN(val);
-    for (i = 0; i < array_length; i++) {
-      md_obj_args[1] = rb_ary_entry(val, i);
-      md_obj = rb_class_new_instance(2, md_obj_args, grpc_cMetadata);
-      md = grpc_rb_get_wrapped_metadata(md_obj);
-      err = grpc_call_add_metadata_old(call, md, NUM2UINT(flags));
-      if (err != GRPC_CALL_OK) {
-        rb_raise(grpc_eCallError, "add metadata failed: %s (code=%d)",
-                 grpc_call_error_detail_of(err), err);
-        return ST_STOP;
-      }
-    }
-  } else {
-    md_obj_args[1] = val;
-    md_obj = rb_class_new_instance(2, md_obj_args, grpc_cMetadata);
-    md = grpc_rb_get_wrapped_metadata(md_obj);
-    err = grpc_call_add_metadata_old(call, md, NUM2UINT(flags));
-    if (err != GRPC_CALL_OK) {
-      rb_raise(grpc_eCallError, "add metadata failed: %s (code=%d)",
-               grpc_call_error_detail_of(err), err);
-      return ST_STOP;
-    }
-  }
-
-  return ST_CONTINUE;
-}
-
-/*
-  call-seq:
-     call.add_metadata(completion_queue, hash_elements, flags=nil)
-
-  Add metadata elements to the call from a ruby hash, to be sent upon
-  invocation. flags is a bit-field combination of the write flags defined
-  above.  REQUIRES: grpc_call_invoke/grpc_call_accept have not been
-  called on this call.  Produces no events. */
-
-static VALUE grpc_rb_call_add_metadata(int argc, VALUE *argv, VALUE self) {
-  VALUE metadata;
-  VALUE flags = Qnil;
-  ID id_size = rb_intern("size");
-
-  /* "11" == 1 mandatory args, 1 (flags) is optional */
-  rb_scan_args(argc, argv, "11", &metadata, &flags);
-  if (NIL_P(flags)) {
-    flags = UINT2NUM(0); /* Default to no flags */
-  }
-  if (TYPE(metadata) != T_HASH) {
-    rb_raise(rb_eTypeError, "add metadata failed: metadata should be a hash");
-    return Qnil;
-  }
-  if (NUM2UINT(rb_funcall(metadata, id_size, 0)) == 0) {
-    return Qnil;
-  }
-  rb_ivar_set(self, id_flags, flags);
-  rb_ivar_set(self, id_input_md, metadata);
-  rb_hash_foreach(metadata, grpc_rb_call_add_metadata_hash_cb, self);
-  return Qnil;
-}
-
 /* Called by clients to cancel an RPC on the server.
    Can be called multiple times, from any thread. */
 static VALUE grpc_rb_call_cancel(VALUE self) {
@@ -196,75 +135,18 @@ static VALUE grpc_rb_call_cancel(VALUE self) {
 
 /*
   call-seq:
-     call.invoke(completion_queue, tag, flags=nil)
-
-   Invoke the RPC. Starts sending metadata and request headers on the wire.
-   flags is a bit-field combination of the write flags defined above.
-   REQUIRES: Can be called at most once per call.
-             Can only be called on the client.
-   Produces a GRPC_INVOKE_ACCEPTED event on completion. */
-static VALUE grpc_rb_call_invoke(int argc, VALUE *argv, VALUE self) {
-  VALUE cqueue = Qnil;
-  VALUE metadata_read_tag = Qnil;
-  VALUE finished_tag = Qnil;
-  VALUE flags = Qnil;
-  grpc_call *call = NULL;
-  grpc_completion_queue *cq = NULL;
-  grpc_call_error err;
+  status = call.status
 
-  /* "31" == 3 mandatory args, 1 (flags) is optional */
-  rb_scan_args(argc, argv, "31", &cqueue, &metadata_read_tag, &finished_tag,
-               &flags);
-  if (NIL_P(flags)) {
-    flags = UINT2NUM(0); /* Default to no flags */
-  }
-  cq = grpc_rb_get_wrapped_completion_queue(cqueue);
-  Data_Get_Struct(self, grpc_call, call);
-  err = grpc_call_invoke_old(call, cq, ROBJECT(metadata_read_tag),
-                             ROBJECT(finished_tag), NUM2UINT(flags));
-  if (err != GRPC_CALL_OK) {
-    rb_raise(grpc_eCallError, "invoke failed: %s (code=%d)",
-             grpc_call_error_detail_of(err), err);
-  }
-
-  /* Add the completion queue as an instance attribute, prevents it from being
-   * GCed until this call object is GCed */
-  rb_ivar_set(self, id_cq, cqueue);
-
-  return Qnil;
-}
-
-/* Initiate a read on a call. Output event contains a byte buffer with the
-   result of the read.
-   REQUIRES: No other reads are pending on the call. It is only safe to start
-   the next read after the corresponding read event is received. */
-static VALUE grpc_rb_call_start_read(VALUE self, VALUE tag) {
-  grpc_call *call = NULL;
-  grpc_call_error err;
-  Data_Get_Struct(self, grpc_call, call);
-  err = grpc_call_start_read_old(call, ROBJECT(tag));
-  if (err != GRPC_CALL_OK) {
-    rb_raise(grpc_eCallError, "start read failed: %s (code=%d)",
-             grpc_call_error_detail_of(err), err);
-  }
-
-  return Qnil;
-}
-
-/*
-  call-seq:
-    status = call.status
-
-    Gets the status object saved the call.  */
+  Gets the status object saved the call.  */
 static VALUE grpc_rb_call_get_status(VALUE self) {
   return rb_ivar_get(self, id_status);
 }
 
 /*
   call-seq:
-    call.status = status
+  call.status = status
 
-    Saves a status object on the call.  */
+  Saves a status object on the call.  */
 static VALUE grpc_rb_call_set_status(VALUE self, VALUE status) {
   if (!NIL_P(status) && rb_obj_class(status) != grpc_sStatus) {
     rb_raise(rb_eTypeError, "bad status: got:<%s> want: <Struct::Status>",
@@ -277,18 +159,18 @@ static VALUE grpc_rb_call_set_status(VALUE self, VALUE status) {
 
 /*
   call-seq:
-    metadata = call.metadata
+  metadata = call.metadata
 
-    Gets the metadata object saved the call.  */
+  Gets the metadata object saved the call.  */
 static VALUE grpc_rb_call_get_metadata(VALUE self) {
   return rb_ivar_get(self, id_metadata);
 }
 
 /*
   call-seq:
-    call.metadata = metadata
+  call.metadata = metadata
 
-    Saves the metadata hash on the call.  */
+  Saves the metadata hash on the call.  */
 static VALUE grpc_rb_call_set_metadata(VALUE self, VALUE metadata) {
   if (!NIL_P(metadata) && TYPE(metadata) != T_HASH) {
     rb_raise(rb_eTypeError, "bad metadata: got:<%s> want: <Hash>",
@@ -299,147 +181,402 @@ static VALUE grpc_rb_call_set_metadata(VALUE self, VALUE metadata) {
   return rb_ivar_set(self, id_metadata, metadata);
 }
 
-/*
-  call-seq:
-     call.start_write(byte_buffer, tag, flags=nil)
-
-   Queue a byte buffer for writing.
-   flags is a bit-field combination of the write flags defined above.
-   A write with byte_buffer null is allowed, and will not send any bytes on the
-   wire. If this is performed without GRPC_WRITE_BUFFER_HINT flag it provides
-   a mechanism to flush any previously buffered writes to outgoing flow control.
-   REQUIRES: No other writes are pending on the call. It is only safe to
-             start the next write after the corresponding write_accepted event
-             is received.
-             GRPC_INVOKE_ACCEPTED must have been received by the application
-             prior to calling this on the client. On the server,
-             grpc_call_accept must have been called successfully.
-   Produces a GRPC_WRITE_ACCEPTED event. */
-static VALUE grpc_rb_call_start_write(int argc, VALUE *argv, VALUE self) {
-  VALUE byte_buffer = Qnil;
-  VALUE tag = Qnil;
-  VALUE flags = Qnil;
-  grpc_call *call = NULL;
-  grpc_byte_buffer *bfr = NULL;
-  grpc_call_error err;
+/* grpc_rb_md_ary_fill_hash_cb is the hash iteration callback used
+   to fill grpc_metadata_array.
+
+   it's capacity should have been computed via a prior call to
+   grpc_rb_md_ary_fill_hash_cb
+*/
+int grpc_rb_md_ary_fill_hash_cb(VALUE key, VALUE val, VALUE md_ary_obj) {
+  grpc_metadata_array *md_ary = NULL;
+  int array_length;
+  int i;
+
+  /* Construct a metadata object from key and value and add it */
+  Data_Get_Struct(md_ary_obj, grpc_metadata_array, md_ary);
 
-  /* "21" == 2 mandatory args, 1 (flags) is optional */
-  rb_scan_args(argc, argv, "21", &byte_buffer, &tag, &flags);
-  if (NIL_P(flags)) {
-    flags = UINT2NUM(0); /* Default to no flags */
+  if (TYPE(val) == T_ARRAY) {
+    /* If the value is an array, add capacity for each value in the array */
+    array_length = RARRAY_LEN(val);
+    for (i = 0; i < array_length; i++) {
+      if (TYPE(key) == T_SYMBOL) {
+        md_ary->metadata[md_ary->count].key = (char *)rb_id2name(SYM2ID(key));
+      } else { /* StringValueCStr does all other type exclusions for us */
+        md_ary->metadata[md_ary->count].key = StringValueCStr(key);
+      }
+      md_ary->metadata[md_ary->count].value = RSTRING_PTR(rb_ary_entry(val, i));
+      md_ary->metadata[md_ary->count].value_length =
+        RSTRING_LEN(rb_ary_entry(val, i));
+      md_ary->count += 1;
+    }
+  } else {
+    if (TYPE(key) == T_SYMBOL) {
+      md_ary->metadata[md_ary->count].key = (char *)rb_id2name(SYM2ID(key));
+    } else { /* StringValueCStr does all other type exclusions for us */
+      md_ary->metadata[md_ary->count].key = StringValueCStr(key);
+    }
+    md_ary->metadata[md_ary->count].value = RSTRING_PTR(val);
+    md_ary->metadata[md_ary->count].value_length = RSTRING_LEN(val);
+    md_ary->count += 1;
   }
-  bfr = grpc_rb_get_wrapped_byte_buffer(byte_buffer);
-  Data_Get_Struct(self, grpc_call, call);
-  err = grpc_call_start_write_old(call, bfr, ROBJECT(tag), NUM2UINT(flags));
-  if (err != GRPC_CALL_OK) {
-    rb_raise(grpc_eCallError, "start write failed: %s (code=%d)",
-             grpc_call_error_detail_of(err), err);
+
+  return ST_CONTINUE;
+}
+
+/* grpc_rb_md_ary_capacity_hash_cb is the hash iteration callback used
+   to pre-compute the capacity a grpc_metadata_array.
+*/
+int grpc_rb_md_ary_capacity_hash_cb(VALUE key, VALUE val, VALUE md_ary_obj) {
+  grpc_metadata_array *md_ary = NULL;
+
+  /* Construct a metadata object from key and value and add it */
+  Data_Get_Struct(md_ary_obj, grpc_metadata_array, md_ary);
+
+  if (TYPE(val) == T_ARRAY) {
+    /* If the value is an array, add capacity for each value in the array */
+    md_ary->capacity += RARRAY_LEN(val);
+  } else {
+    md_ary->capacity += 1;
+  }
+  return ST_CONTINUE;
+}
+
+/* grpc_rb_md_ary_convert converts a ruby metadata hash into
+   a grpc_metadata_array.
+*/
+void grpc_rb_md_ary_convert(VALUE md_ary_hash, grpc_metadata_array *md_ary) {
+  VALUE md_ary_obj = Qnil;
+  if (md_ary_hash == Qnil) {
+    return;  /* Do nothing if the expected has value is nil */
+  }
+  if (TYPE(md_ary_hash) != T_HASH) {
+    rb_raise(rb_eTypeError, "md_ary_convert: got <%s>, want <Hash>",
+             rb_obj_classname(md_ary_hash));
+    return;
   }
 
-  return Qnil;
+  /* Initialize the array, compute it's capacity, then fill it. */
+  grpc_metadata_array_init(md_ary);
+  md_ary_obj = Data_Wrap_Struct(grpc_cMdAry, GC_NOT_MARKED, GC_DONT_FREE, md_ary);
+  rb_hash_foreach(md_ary_hash, grpc_rb_md_ary_capacity_hash_cb, md_ary_obj);
+  md_ary->metadata = gpr_malloc(md_ary->capacity * sizeof(grpc_metadata));
+  rb_hash_foreach(md_ary_hash, grpc_rb_md_ary_fill_hash_cb, md_ary_obj);
 }
 
-/* Queue a status for writing.
-
-   call-seq:
-      tag = Object.new
-      call.write_status(200, "OK", tag)
-
-   REQUIRES: No other writes are pending on the call. It is only safe to
-   start the next write after the corresponding write_accepted event
-   is received.
-   GRPC_INVOKE_ACCEPTED must have been received by the application
-   prior to calling this.
-   Only callable on the server.
-   Produces a GRPC_FINISHED event when the status is sent and the stream is
-   fully closed */
-static VALUE grpc_rb_call_start_write_status(VALUE self, VALUE code,
-                                             VALUE status, VALUE tag) {
-  grpc_call *call = NULL;
-  grpc_call_error err;
-  Data_Get_Struct(self, grpc_call, call);
-  err = grpc_call_start_write_status_old(call, NUM2UINT(code),
-                                         StringValueCStr(status), ROBJECT(tag));
-  if (err != GRPC_CALL_OK) {
-    rb_raise(grpc_eCallError, "start write status: %s (code=%d)",
-             grpc_call_error_detail_of(err), err);
+/* Converts a metadata array to a hash. */
+VALUE grpc_rb_md_ary_to_h(grpc_metadata_array *md_ary) {
+  VALUE key = Qnil;
+  VALUE new_ary = Qnil;
+  VALUE value = Qnil;
+  VALUE result = rb_hash_new();
+  size_t i;
+
+  for (i = 0; i < md_ary->count; i++) {
+    key = rb_str_new2(md_ary->metadata[i].key);
+    value = rb_hash_aref(result, key);
+    if (value == Qnil) {
+      value = rb_str_new(md_ary->metadata[i].value,
+                         md_ary->metadata[i].value_length);
+      rb_hash_aset(result, key, value);
+    } else if (TYPE(value) == T_ARRAY) {
+      /* Add the string to the returned array */
+      rb_ary_push(value,
+                  rb_str_new(md_ary->metadata[i].value,
+                             md_ary->metadata[i].value_length));
+    } else {
+      /* Add the current value with this key and the new one to an array */
+      new_ary = rb_ary_new();
+      rb_ary_push(new_ary, value);
+      rb_ary_push(new_ary,
+                  rb_str_new(md_ary->metadata[i].value,
+                             md_ary->metadata[i].value_length));
+      rb_hash_aset(result, key, new_ary);
+    }
   }
+  return result;
+}
 
-  return Qnil;
+/* grpc_rb_call_check_op_keys_hash_cb is a hash iteration func that checks
+   each key of an ops hash is valid.
+*/
+int grpc_rb_call_check_op_keys_hash_cb(VALUE key, VALUE val, VALUE ops_ary) {
+  /* Update the capacity; the value is an array, add capacity for each value in
+   * the array */
+  if (TYPE(key) != T_FIXNUM) {
+    rb_raise(rb_eTypeError, "invalid operation : got <%s>, want <Fixnum>",
+             rb_obj_classname(key));
+    return ST_STOP;
+  }
+  switch(NUM2INT(key)) {
+    case GRPC_OP_SEND_INITIAL_METADATA:
+    case GRPC_OP_SEND_MESSAGE:
+    case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+    case GRPC_OP_SEND_STATUS_FROM_SERVER:
+    case GRPC_OP_RECV_INITIAL_METADATA:
+    case GRPC_OP_RECV_MESSAGE:
+    case GRPC_OP_RECV_STATUS_ON_CLIENT:
+    case GRPC_OP_RECV_CLOSE_ON_SERVER:
+      rb_ary_push(ops_ary, key);
+      return ST_CONTINUE;
+    default:
+      rb_raise(rb_eTypeError, "invalid operation : bad value %d",
+               NUM2INT(key));
+  };
+  return ST_STOP;
 }
 
-/* No more messages to send.
-   REQUIRES: No other writes are pending on the call. */
-static VALUE grpc_rb_call_writes_done(VALUE self, VALUE tag) {
-  grpc_call *call = NULL;
-  grpc_call_error err;
-  Data_Get_Struct(self, grpc_call, call);
-  err = grpc_call_writes_done_old(call, ROBJECT(tag));
-  if (err != GRPC_CALL_OK) {
-    rb_raise(grpc_eCallError, "writes done: %s (code=%d)",
-             grpc_call_error_detail_of(err), err);
+/* grpc_rb_op_update_status_from_server adds the values in a ruby status
+   struct to the 'send_status_from_server' portion of an op.
+*/
+void grpc_rb_op_update_status_from_server(grpc_op *op,
+                                          grpc_metadata_array* md_ary,
+                                          VALUE status) {
+  VALUE code = rb_struct_aref(status, sym_code);
+  VALUE details = rb_struct_aref(status, sym_details);
+  VALUE metadata_hash = rb_struct_aref(status, sym_metadata);
+
+  /* TODO: add check to ensure status is the correct struct type */
+  if (TYPE(code) != T_FIXNUM) {
+    rb_raise(rb_eTypeError, "invalid code : got <%s>, want <Fixnum>",
+             rb_obj_classname(code));
+    return;
+  }
+  if (TYPE(details) != T_STRING) {
+    rb_raise(rb_eTypeError, "invalid details : got <%s>, want <String>",
+             rb_obj_classname(code));
+    return;
   }
+  op->data.send_status_from_server.status = NUM2INT(code);
+  op->data.send_status_from_server.status_details = StringValueCStr(details);
+  grpc_rb_md_ary_convert(metadata_hash, md_ary);
+  op->data.send_status_from_server.trailing_metadata_count = md_ary->count;
+  op->data.send_status_from_server.trailing_metadata = md_ary->metadata;
+}
 
-  return Qnil;
+/* run_batch_stack holds various values used by the
+ * grpc_rb_call_run_batch function */
+typedef struct run_batch_stack {
+  /* The batch ops */
+  grpc_op ops[8];  /* 8 is the maximum number of operations */
+  size_t op_num;   /* tracks the last added operation */
+
+  /* Data being sent */
+  grpc_metadata_array send_metadata;
+  grpc_metadata_array send_trailing_metadata;
+
+  /* Data being received */
+  grpc_byte_buffer *recv_message;
+  grpc_metadata_array recv_metadata;
+  grpc_metadata_array recv_trailing_metadata;
+  int recv_cancelled;
+  grpc_status_code recv_status;
+  char *recv_status_details;
+  size_t recv_status_details_capacity;
+} run_batch_stack;
+
+/* grpc_run_batch_stack_init ensures the run_batch_stack is properly
+ * initialized */
+static void grpc_run_batch_stack_init(run_batch_stack* st) {
+  MEMZERO(st, run_batch_stack, 1);
+  grpc_metadata_array_init(&st->send_metadata);
+  grpc_metadata_array_init(&st->send_trailing_metadata);
+  grpc_metadata_array_init(&st->recv_metadata);
+  grpc_metadata_array_init(&st->recv_trailing_metadata);
+  st->op_num = 0;
 }
 
-/* call-seq:
-     call.server_end_initial_metadata(flag)
-
-   Only to be called on servers, before sending messages.
-   flags is a bit-field combination of the write flags defined above.
-
-   REQUIRES: Can be called at most once per call.
-             Can only be called on the server, must be called after
-             grpc_call_server_accept
-   Produces no events */
-static VALUE grpc_rb_call_server_end_initial_metadata(int argc, VALUE *argv,
-                                                      VALUE self) {
-  VALUE flags = Qnil;
-  grpc_call *call = NULL;
-  grpc_call_error err;
+/* grpc_run_batch_stack_cleanup ensures the run_batch_stack is properly
+ * cleaned up */
+static void grpc_run_batch_stack_cleanup(run_batch_stack* st) {
+  grpc_metadata_array_destroy(&st->send_metadata);
+  grpc_metadata_array_destroy(&st->send_trailing_metadata);
+  grpc_metadata_array_destroy(&st->recv_metadata);
+  grpc_metadata_array_destroy(&st->recv_trailing_metadata);
+  if (st->recv_status_details != NULL) {
+    gpr_free(st->recv_status_details);
+  }
+}
 
-  /* "01" == 1 (flags) is optional */
-  rb_scan_args(argc, argv, "01", &flags);
-  if (NIL_P(flags)) {
-    flags = UINT2NUM(0); /* Default to no flags */
+/* grpc_run_batch_stack_fill_ops fills the run_batch_stack ops array from
+ * ops_hash */
+static void grpc_run_batch_stack_fill_ops(run_batch_stack* st, VALUE ops_hash) {
+  VALUE this_op = Qnil;
+  VALUE this_value = Qnil;
+  VALUE ops_ary = rb_ary_new();
+  size_t i = 0;
+
+  /* Create a ruby array with just the operation keys */
+  rb_hash_foreach(ops_hash, grpc_rb_call_check_op_keys_hash_cb, ops_ary);
+
+  /* Fill the ops array */
+  for (i = 0; i < (size_t)RARRAY_LEN(ops_ary); i++) {
+    this_op = rb_ary_entry(ops_ary, i);
+    this_value = rb_hash_aref(ops_hash, this_op);
+    switch(NUM2INT(this_op)) {
+      case GRPC_OP_SEND_INITIAL_METADATA:
+        /* N.B. later there is no need to explicitly delete the metadata keys
+         * and values, they are references to data in ruby objects. */
+        grpc_rb_md_ary_convert(this_value, &st->send_metadata);
+        st->ops[st->op_num].data.send_initial_metadata.count =
+            st->send_metadata.count;
+        st->ops[st->op_num].data.send_initial_metadata.metadata =
+            st->send_metadata.metadata;
+        break;
+      case GRPC_OP_SEND_MESSAGE:
+        st->ops[st->op_num].data.send_message =
+            grpc_rb_s_to_byte_buffer(RSTRING_PTR(this_value),
+                                     RSTRING_LEN(this_value));
+        break;
+      case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+        break;
+      case GRPC_OP_SEND_STATUS_FROM_SERVER:
+        /* N.B. later there is no need to explicitly delete the metadata keys
+         * and values, they are references to data in ruby objects. */
+        grpc_rb_op_update_status_from_server(&st->ops[st->op_num],
+                                             &st->send_trailing_metadata,
+                                             this_value);
+        break;
+      case GRPC_OP_RECV_INITIAL_METADATA:
+        st->ops[st->op_num].data.recv_initial_metadata = &st->recv_metadata;
+        break;
+      case GRPC_OP_RECV_MESSAGE:
+        st->ops[st->op_num].data.recv_message = &st->recv_message;
+        break;
+      case GRPC_OP_RECV_STATUS_ON_CLIENT:
+        st->ops[st->op_num].data.recv_status_on_client.trailing_metadata =
+            &st->recv_trailing_metadata;
+        st->ops[st->op_num].data.recv_status_on_client.status =
+            &st->recv_status;
+        st->ops[st->op_num].data.recv_status_on_client.status_details =
+            &st->recv_status_details;
+        st->ops[st->op_num].data.recv_status_on_client.status_details_capacity =
+            &st->recv_status_details_capacity;
+        break;
+      case GRPC_OP_RECV_CLOSE_ON_SERVER:
+        st->ops[st->op_num].data.recv_close_on_server.cancelled =
+            &st->recv_cancelled;
+        break;
+      default:
+        grpc_run_batch_stack_cleanup(st);
+        rb_raise(rb_eTypeError, "invalid operation : bad value %d",
+                 NUM2INT(this_op));
+    };
+    st->ops[st->op_num].op = (grpc_op_type)NUM2INT(this_op);
+    st->op_num++;
   }
-  Data_Get_Struct(self, grpc_call, call);
-  err = grpc_call_server_end_initial_metadata_old(call, NUM2UINT(flags));
-  if (err != GRPC_CALL_OK) {
-    rb_raise(grpc_eCallError, "end_initial_metadata failed: %s (code=%d)",
-             grpc_call_error_detail_of(err), err);
+}
+
+/* grpc_run_batch_stack_build_result fills constructs a ruby BatchResult struct
+   after the results have run */
+static VALUE grpc_run_batch_stack_build_result(run_batch_stack* st) {
+  size_t i = 0;
+  VALUE result = rb_struct_new(grpc_sBatchResult, Qnil, Qnil, Qnil, Qnil, Qnil,
+                               Qnil, Qnil, Qnil, NULL);
+  for (i = 0; i < st->op_num; i++) {
+    switch(st->ops[i].op) {
+      case GRPC_OP_SEND_INITIAL_METADATA:
+        rb_struct_aset(result, sym_send_metadata, Qtrue);
+        break;
+      case GRPC_OP_SEND_MESSAGE:
+        rb_struct_aset(result, sym_send_message, Qtrue);
+        grpc_byte_buffer_destroy(st->ops[i].data.send_message);
+        break;
+      case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+        rb_struct_aset(result, sym_send_close, Qtrue);
+        break;
+      case GRPC_OP_SEND_STATUS_FROM_SERVER:
+        rb_struct_aset(result, sym_send_status, Qtrue);
+        break;
+      case GRPC_OP_RECV_INITIAL_METADATA:
+        rb_struct_aset(result, sym_metadata,
+                       grpc_rb_md_ary_to_h(&st->recv_metadata));
+      case GRPC_OP_RECV_MESSAGE:
+        rb_struct_aset(result, sym_message,
+                       grpc_rb_byte_buffer_to_s(st->recv_message));
+        break;
+      case GRPC_OP_RECV_STATUS_ON_CLIENT:
+        rb_struct_aset(
+            result,
+            sym_status,
+            rb_struct_new(grpc_sStatus,
+                          UINT2NUM(st->recv_status),
+                          (st->recv_status_details == NULL
+                           ? Qnil
+                           : rb_str_new2(st->recv_status_details)),
+                          grpc_rb_md_ary_to_h(&st->recv_trailing_metadata),
+                          NULL));
+        break;
+      case GRPC_OP_RECV_CLOSE_ON_SERVER:
+        rb_struct_aset(result, sym_send_close, Qtrue);
+        break;
+      default:
+        break;
+    }
   }
-  return Qnil;
+  return result;
 }
 
 /* call-seq:
-     call.server_accept(completion_queue, finished_tag)
-
-   Accept an incoming RPC, binding a completion queue to it.
-   To be called before sending or receiving messages.
-
-   REQUIRES: Can be called at most once per call.
-             Can only be called on the server.
-   Produces a GRPC_FINISHED event with finished_tag when the call has been
-       completed (there may be other events for the call pending at this
-       time) */
-static VALUE grpc_rb_call_server_accept(VALUE self, VALUE cqueue,
-                                        VALUE finished_tag) {
+   cq = CompletionQueue.new
+   ops = {
+     GRPC::Core::CallOps::SEND_INITIAL_METADATA => <op_value>,
+     GRPC::Core::CallOps::SEND_MESSAGE => <op_value>,
+     ...
+   }
+   tag = Object.new
+   timeout = 10
+   call.start_batch(cqueue, tag, timeout, ops)
+
+   Start a batch of operations defined in the array ops; when complete, post a
+   completion of type 'tag' to the completion queue bound to the call.
+
+   Also waits for the batch to complete, until timeout is reached.
+   The order of ops specified in the batch has no significance.
+   Only one operation of each type can be active at once in any given
+   batch */
+static VALUE grpc_rb_call_run_batch(VALUE self, VALUE cqueue, VALUE tag,
+                                    VALUE timeout, VALUE ops_hash) {
+  run_batch_stack st;
   grpc_call *call = NULL;
-  grpc_completion_queue *cq = grpc_rb_get_wrapped_completion_queue(cqueue);
+  grpc_event *ev = NULL;
   grpc_call_error err;
+  VALUE result = Qnil;
   Data_Get_Struct(self, grpc_call, call);
-  err = grpc_call_server_accept_old(call, cq, ROBJECT(finished_tag));
+
+  /* Validate the ops args, adding them to a ruby array */
+  if (TYPE(ops_hash) != T_HASH) {
+    rb_raise(rb_eTypeError, "call#run_batch: ops hash should be a hash");
+    return Qnil;
+  }
+  grpc_run_batch_stack_init(&st);
+  grpc_run_batch_stack_fill_ops(&st, ops_hash);
+
+  /* call grpc_call_start_batch, then wait for it to complete using
+   * pluck_event */
+  err = grpc_call_start_batch(call, st.ops, st.op_num, ROBJECT(tag));
   if (err != GRPC_CALL_OK) {
-    rb_raise(grpc_eCallError, "server_accept failed: %s (code=%d)",
+    grpc_run_batch_stack_cleanup(&st);
+    rb_raise(grpc_eCallError, "grpc_call_start_batch failed with %s (code=%d)",
              grpc_call_error_detail_of(err), err);
+    return;
+  }
+  ev = grpc_rb_completion_queue_pluck_event(cqueue, tag, timeout);
+  if (ev == NULL) {
+    grpc_run_batch_stack_cleanup(&st);
+    rb_raise(grpc_eOutOfTime, "grpc_call_start_batch timed out");
+    return;
+  }
+  if (ev->data.op_complete != GRPC_OP_OK) {
+    grpc_run_batch_stack_cleanup(&st);
+    rb_raise(grpc_eCallError, "start_batch completion failed, (code=%d)",
+             ev->data.op_complete);
+    return;
   }
 
-  /* Add the completion queue as an instance attribute, prevents it from being
-   * GCed until this call object is GCed */
-  rb_ivar_set(self, id_cq, cqueue);
-  return Qnil;
+  /* Build and return the BatchResult struct result */
+  result = grpc_run_batch_stack_build_result(&st);
+  grpc_run_batch_stack_cleanup(&st);
+  return result;
 }
 
 /* grpc_cCall is the ruby class that proxies grpc_call. */
@@ -449,26 +586,30 @@ VALUE grpc_cCall = Qnil;
    operations; */
 VALUE grpc_eCallError = Qnil;
 
+/* grpc_eOutOfTime is the ruby class of the exception thrown to indicate
+   a timeout. */
+VALUE grpc_eOutOfTime = Qnil;
+
 void Init_grpc_error_codes() {
   /* Constants representing the error codes of grpc_call_error in grpc.h */
-  VALUE rb_RpcErrors = rb_define_module_under(grpc_mGrpcCore, "RpcErrors");
-  rb_define_const(rb_RpcErrors, "OK", UINT2NUM(GRPC_CALL_OK));
-  rb_define_const(rb_RpcErrors, "ERROR", UINT2NUM(GRPC_CALL_ERROR));
-  rb_define_const(rb_RpcErrors, "NOT_ON_SERVER",
+  VALUE grpc_mRpcErrors = rb_define_module_under(grpc_mGrpcCore, "RpcErrors");
+  rb_define_const(grpc_mRpcErrors, "OK", UINT2NUM(GRPC_CALL_OK));
+  rb_define_const(grpc_mRpcErrors, "ERROR", UINT2NUM(GRPC_CALL_ERROR));
+  rb_define_const(grpc_mRpcErrors, "NOT_ON_SERVER",
                   UINT2NUM(GRPC_CALL_ERROR_NOT_ON_SERVER));
-  rb_define_const(rb_RpcErrors, "NOT_ON_CLIENT",
+  rb_define_const(grpc_mRpcErrors, "NOT_ON_CLIENT",
                   UINT2NUM(GRPC_CALL_ERROR_NOT_ON_CLIENT));
-  rb_define_const(rb_RpcErrors, "ALREADY_ACCEPTED",
+  rb_define_const(grpc_mRpcErrors, "ALREADY_ACCEPTED",
                   UINT2NUM(GRPC_CALL_ERROR_ALREADY_ACCEPTED));
-  rb_define_const(rb_RpcErrors, "ALREADY_INVOKED",
+  rb_define_const(grpc_mRpcErrors, "ALREADY_INVOKED",
                   UINT2NUM(GRPC_CALL_ERROR_ALREADY_INVOKED));
-  rb_define_const(rb_RpcErrors, "NOT_INVOKED",
+  rb_define_const(grpc_mRpcErrors, "NOT_INVOKED",
                   UINT2NUM(GRPC_CALL_ERROR_NOT_INVOKED));
-  rb_define_const(rb_RpcErrors, "ALREADY_FINISHED",
+  rb_define_const(grpc_mRpcErrors, "ALREADY_FINISHED",
                   UINT2NUM(GRPC_CALL_ERROR_ALREADY_FINISHED));
-  rb_define_const(rb_RpcErrors, "TOO_MANY_OPERATIONS",
+  rb_define_const(grpc_mRpcErrors, "TOO_MANY_OPERATIONS",
                   UINT2NUM(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS));
-  rb_define_const(rb_RpcErrors, "INVALID_FLAGS",
+  rb_define_const(grpc_mRpcErrors, "INVALID_FLAGS",
                   UINT2NUM(GRPC_CALL_ERROR_INVALID_FLAGS));
 
   /* Add the detail strings to a Hash */
@@ -496,15 +637,39 @@ void Init_grpc_error_codes() {
                rb_str_new2("outstanding read or write present"));
   rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_ERROR_INVALID_FLAGS),
                rb_str_new2("a bad flag was given"));
-  rb_define_const(rb_RpcErrors, "ErrorMessages", rb_error_code_details);
+  rb_define_const(grpc_mRpcErrors, "ErrorMessages", rb_error_code_details);
   rb_obj_freeze(rb_error_code_details);
 }
 
+void Init_grpc_op_codes() {
+  /* Constants representing operation type codes in grpc.h */
+  VALUE rb_CallOps = rb_define_module_under(grpc_mGrpcCore, "CallOps");
+  rb_define_const(rb_CallOps, "SEND_INITIAL_METADATA",
+                  UINT2NUM(GRPC_OP_SEND_INITIAL_METADATA));
+  rb_define_const(rb_CallOps, "SEND_MESSAGE", UINT2NUM(GRPC_OP_SEND_MESSAGE));
+  rb_define_const(rb_CallOps, "SEND_CLOSE_FROM_CLIENT",
+                  UINT2NUM(GRPC_OP_SEND_CLOSE_FROM_CLIENT));
+  rb_define_const(rb_CallOps, "SEND_STATUS_FROM_SERVER",
+                  UINT2NUM(GRPC_OP_SEND_STATUS_FROM_SERVER));
+  rb_define_const(rb_CallOps, "RECV_INITIAL_METADATA",
+                  UINT2NUM(GRPC_OP_RECV_INITIAL_METADATA));
+  rb_define_const(rb_CallOps, "RECV_MESSAGE",
+                  UINT2NUM(GRPC_OP_RECV_MESSAGE));
+  rb_define_const(rb_CallOps, "RECV_STATUS_ON_CLIENT",
+                  UINT2NUM(GRPC_OP_RECV_STATUS_ON_CLIENT));
+  rb_define_const(rb_CallOps, "RECV_CLOSE_ON_SERVER",
+                  UINT2NUM(GRPC_OP_RECV_CLOSE_ON_SERVER));
+}
+
 void Init_grpc_call() {
   /* CallError inherits from Exception to signal that it is non-recoverable */
   grpc_eCallError =
       rb_define_class_under(grpc_mGrpcCore, "CallError", rb_eException);
+  grpc_eOutOfTime =
+      rb_define_class_under(grpc_mGrpcCore, "OutOfTime", rb_eException);
   grpc_cCall = rb_define_class_under(grpc_mGrpcCore, "Call", rb_cObject);
+  grpc_cMdAry = rb_define_class_under(grpc_mGrpcCore, "MetadataArray",
+                                      rb_cObject);
 
   /* Prevent allocation or inialization of the Call class */
   rb_define_alloc_func(grpc_cCall, grpc_rb_cannot_alloc);
@@ -512,17 +677,8 @@ void Init_grpc_call() {
   rb_define_method(grpc_cCall, "initialize_copy", grpc_rb_cannot_init_copy, 1);
 
   /* Add ruby analogues of the Call methods. */
-  rb_define_method(grpc_cCall, "server_accept", grpc_rb_call_server_accept, 2);
-  rb_define_method(grpc_cCall, "server_end_initial_metadata",
-                   grpc_rb_call_server_end_initial_metadata, -1);
-  rb_define_method(grpc_cCall, "add_metadata", grpc_rb_call_add_metadata, -1);
+  rb_define_method(grpc_cCall, "run_batch", grpc_rb_call_run_batch, 4);
   rb_define_method(grpc_cCall, "cancel", grpc_rb_call_cancel, 0);
-  rb_define_method(grpc_cCall, "invoke", grpc_rb_call_invoke, -1);
-  rb_define_method(grpc_cCall, "start_read", grpc_rb_call_start_read, 1);
-  rb_define_method(grpc_cCall, "start_write", grpc_rb_call_start_write, -1);
-  rb_define_method(grpc_cCall, "start_write_status",
-                   grpc_rb_call_start_write_status, 3);
-  rb_define_method(grpc_cCall, "writes_done", grpc_rb_call_writes_done, 1);
   rb_define_method(grpc_cCall, "status", grpc_rb_call_get_status, 0);
   rb_define_method(grpc_cCall, "status=", grpc_rb_call_set_status, 1);
   rb_define_method(grpc_cCall, "metadata", grpc_rb_call_get_metadata, 0);
@@ -537,12 +693,35 @@ void Init_grpc_call() {
   id_flags = rb_intern("__flags");
   id_input_md = rb_intern("__input_md");
 
+  /* Ids used in constructing the batch result. */
+  sym_send_message = ID2SYM(rb_intern("send_message"));
+  sym_send_metadata = ID2SYM(rb_intern("send_metadata"));
+  sym_send_close = ID2SYM(rb_intern("send_close"));
+  sym_send_status = ID2SYM(rb_intern("send_status"));
+  sym_message = ID2SYM(rb_intern("message"));
+  sym_status = ID2SYM(rb_intern("status"));
+  sym_cancelled = ID2SYM(rb_intern("cancelled"));
+
+  /* The Struct used to return the run_batch result. */
+  grpc_sBatchResult = rb_struct_define(
+      "BatchResult",
+      "send_message",
+      "send_metadata",
+      "send_close",
+      "send_status",
+      "message",
+      "metadata",
+      "status",
+      "cancelled",
+      NULL);
+
   /* The hash for reference counting calls, to ensure they can't be destroyed
    * more than once */
   hash_all_calls = rb_hash_new();
   rb_define_const(grpc_cCall, "INTERNAL_ALL_CALLs", hash_all_calls);
 
   Init_grpc_error_codes();
+  Init_grpc_op_codes();
 }
 
 /* Gets the call from the ruby object */

src/ruby/ext/grpc/rb_call.h

@@ -46,13 +46,20 @@ VALUE grpc_rb_wrap_call(grpc_call* c);
 /* Provides the details of an call error */
 const char* grpc_call_error_detail_of(grpc_call_error err);
 
+/* Converts a metadata array to a hash. */
+VALUE grpc_rb_md_ary_to_h(grpc_metadata_array *md_ary);
+
 /* grpc_cCall is the Call class whose instances proxy grpc_call. */
 extern VALUE grpc_cCall;
 
-/* grpc_cCallError is the ruby class of the exception thrown during call
+/* grpc_eCallError is the ruby class of the exception thrown during call
    operations. */
 extern VALUE grpc_eCallError;
 
+/* grpc_eOutOfTime is the ruby class of the exception thrown to indicate
+   a timeout. */
+extern VALUE grpc_eOutOfTime;
+
 /* Initializes the Call class. */
 void Init_grpc_call();
 

src/ruby/ext/grpc/rb_channel.c

@@ -49,10 +49,16 @@
 static ID id_channel;
 
 /* id_target is the name of the hidden ivar that preserves a reference to the
- * target string used to create the call, preserved so that is does not get
+ * target string used to create the call, preserved so that it does not get
  * GCed before the channel */
 static ID id_target;
 
+/* id_cqueue is the name of the hidden ivar that preserves a reference to the
+ * completion queue used to create the call, preserved so that it does not get
+ * GCed before the channel */
+static ID id_cqueue;
+
+
 /* Used during the conversion of a hash to channel args during channel setup */
 static VALUE grpc_cChannelArgs;
 
@@ -142,6 +148,7 @@ static VALUE grpc_rb_channel_init(int argc, VALUE *argv, VALUE self) {
   if (ch == NULL) {
     rb_raise(rb_eRuntimeError, "could not create an rpc channel to target:%s",
              target_chars);
+    return Qnil;
   }
   rb_ivar_set(self, id_target, target);
   wrapper->wrapped = ch;
@@ -164,6 +171,7 @@ static VALUE grpc_rb_channel_init_copy(VALUE copy, VALUE orig) {
   if (TYPE(orig) != T_DATA ||
       RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_channel_free) {
     rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(grpc_cChannel));
+    return Qnil;
   }
 
   Data_Get_Struct(orig, grpc_rb_channel, orig_ch);
@@ -177,34 +185,42 @@ static VALUE grpc_rb_channel_init_copy(VALUE copy, VALUE orig) {
 
 /* Create a call given a grpc_channel, in order to call method. The request
    is not sent until grpc_call_invoke is called. */
-static VALUE grpc_rb_channel_create_call(VALUE self, VALUE method, VALUE host,
-                                         VALUE deadline) {
+static VALUE grpc_rb_channel_create_call(VALUE self, VALUE cqueue, VALUE method,
+                                         VALUE host, VALUE deadline) {
   VALUE res = Qnil;
   grpc_rb_channel *wrapper = NULL;
-  grpc_channel *ch = NULL;
   grpc_call *call = NULL;
+  grpc_channel *ch = NULL;
+  grpc_completion_queue *cq = NULL;
   char *method_chars = StringValueCStr(method);
   char *host_chars = StringValueCStr(host);
 
+  cq = grpc_rb_get_wrapped_completion_queue(cqueue);
   Data_Get_Struct(self, grpc_rb_channel, wrapper);
   ch = wrapper->wrapped;
   if (ch == NULL) {
     rb_raise(rb_eRuntimeError, "closed!");
+    return Qnil;
   }
 
   call =
-      grpc_channel_create_call_old(ch, method_chars, host_chars,
-                                   grpc_rb_time_timeval(deadline,
-                                                        /* absolute time */ 0));
+      grpc_channel_create_call(ch, cq, method_chars, host_chars,
+                               grpc_rb_time_timeval(deadline,
+                                                    /* absolute time */ 0));
   if (call == NULL) {
     rb_raise(rb_eRuntimeError, "cannot create call with method %s",
              method_chars);
+    return Qnil;
   }
   res = grpc_rb_wrap_call(call);
 
-  /* Make this channel an instance attribute of the call so that is is not GCed
+  /* Make this channel an instance attribute of the call so that it is not GCed
    * before the call. */
   rb_ivar_set(res, id_channel, self);
+
+  /* Make the completion queue an instance attribute of the call so that it is
+   * not GCed before the call. */
+  rb_ivar_set(res, id_cqueue, cqueue);
   return res;
 }
 
@@ -240,11 +256,12 @@ void Init_grpc_channel() {
                    1);
 
   /* Add ruby analogues of the Channel methods. */
-  rb_define_method(grpc_cChannel, "create_call", grpc_rb_channel_create_call, 3);
+  rb_define_method(grpc_cChannel, "create_call", grpc_rb_channel_create_call, 4);
   rb_define_method(grpc_cChannel, "destroy", grpc_rb_channel_destroy, 0);
   rb_define_alias(grpc_cChannel, "close", "destroy");
 
   id_channel = rb_intern("__channel");
+  id_cqueue = rb_intern("__cqueue");
   id_target = rb_intern("__target");
   rb_define_const(grpc_cChannel, "SSL_TARGET",
                   ID2SYM(rb_intern(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG)));

src/ruby/ext/grpc/rb_completion_queue.c

@@ -38,7 +38,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/time.h>
 #include "rb_grpc.h"
-#include "rb_event.h"
 
 /* Used to allow grpc_completion_queue_next call to release the GIL */
 typedef struct next_call_stack {
@@ -140,8 +139,19 @@ static VALUE grpc_rb_completion_queue_next(VALUE self, VALUE timeout) {
 
 /* Blocks until the next event for given tag is available, and returns the
  * event. */
-static VALUE grpc_rb_completion_queue_pluck(VALUE self, VALUE tag,
-                                            VALUE timeout) {
+VALUE grpc_rb_completion_queue_pluck(VALUE self, VALUE tag,
+                                     VALUE timeout) {
+  grpc_event *ev = grpc_rb_completion_queue_pluck_event(self, tag, timeout);
+  if (ev == NULL) {
+    return Qnil;
+  }
+  return grpc_rb_new_event(ev);
+}
+
+/* Blocks until the next event for given tag is available, and returns the
+ * event. */
+grpc_event* grpc_rb_completion_queue_pluck_event(VALUE self, VALUE tag,
+                                                 VALUE timeout) {
   next_call_stack next_call;
   MEMZERO(&next_call, next_call_stack, 1);
   Data_Get_Struct(self, grpc_completion_queue, next_call.cq);
@@ -151,9 +161,9 @@ static VALUE grpc_rb_completion_queue_pluck(VALUE self, VALUE tag,
   rb_thread_call_without_gvl(grpc_rb_completion_queue_pluck_no_gil,
                              (void *)&next_call, NULL, NULL);
   if (next_call.event == NULL) {
-    return Qnil;
+    return NULL;
   }
-  return grpc_rb_new_event(next_call.event);
+  return next_call.event;
 }
 
 /* grpc_cCompletionQueue is the ruby class that proxies grpc_completion_queue. */

src/ruby/ext/grpc/rb_completion_queue.h

@@ -40,6 +40,14 @@
 /* Gets the wrapped completion queue from the ruby wrapper */
 grpc_completion_queue *grpc_rb_get_wrapped_completion_queue(VALUE v);
 
+/**
+ * Makes the implementation of CompletionQueue#pluck available in other files
+ *
+ * This avoids having code that holds the GIL repeated at multiple sites.
+ */
+grpc_event* grpc_rb_completion_queue_pluck_event(VALUE cqueue, VALUE tag,
+                                                 VALUE timeout);
+
 /* grpc_cCompletionQueue is the CompletionQueue class whose instances proxy
    grpc_completion_queue. */
 extern VALUE grpc_cCompletionQueue;

src/ruby/ext/grpc/rb_event.c

@@ -1,361 +0,0 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include "rb_event.h"
-
-#include <ruby.h>
-
-#include <grpc/grpc.h>
-#include "rb_grpc.h"
-#include "rb_byte_buffer.h"
-#include "rb_call.h"
-#include "rb_metadata.h"
-
-/* grpc_rb_event wraps a grpc_event.  It provides a peer ruby object,
- * 'mark' to minimize copying when an event is created from ruby. */
-typedef struct grpc_rb_event {
-  /* Holder of ruby objects involved in constructing the channel */
-  VALUE mark;
-  /* The actual event */
-  grpc_event *wrapped;
-} grpc_rb_event;
-
-/* grpc_mCompletionType is a ruby module that holds the completion type values */
-VALUE grpc_mCompletionType = Qnil;
-
-/* Destroys Event instances. */
-static void grpc_rb_event_free(void *p) {
-  grpc_rb_event *ev = NULL;
-  if (p == NULL) {
-    return;
-  };
-  ev = (grpc_rb_event *)p;
-
-  /* Deletes the wrapped object if the mark object is Qnil, which indicates
-   * that no other object is the actual owner. */
-  if (ev->wrapped != NULL && ev->mark == Qnil) {
-    grpc_event_finish(ev->wrapped);
-    rb_warning("event gc: destroyed the c event");
-  } else {
-    rb_warning("event gc: did not destroy the c event");
-  }
-
-  xfree(p);
-}
-
-/* Protects the mark object from GC */
-static void grpc_rb_event_mark(void *p) {
-  grpc_rb_event *event = NULL;
-  if (p == NULL) {
-    return;
-  }
-  event = (grpc_rb_event *)p;
-  if (event->mark != Qnil) {
-    rb_gc_mark(event->mark);
-  }
-}
-
-static VALUE grpc_rb_event_result(VALUE self);
-
-/* Obtains the type of an event. */
-static VALUE grpc_rb_event_type(VALUE self) {
-  grpc_event *event = NULL;
-  grpc_rb_event *wrapper = NULL;
-  Data_Get_Struct(self, grpc_rb_event, wrapper);
-  if (wrapper->wrapped == NULL) {
-    rb_raise(rb_eRuntimeError, "finished!");
-    return Qnil;
-  }
-
-  event = wrapper->wrapped;
-  switch (event->type) {
-    case GRPC_QUEUE_SHUTDOWN:
-      return rb_const_get(grpc_mCompletionType, rb_intern("QUEUE_SHUTDOWN"));
-
-    case GRPC_READ:
-      return rb_const_get(grpc_mCompletionType, rb_intern("READ"));
-
-    case GRPC_WRITE_ACCEPTED:
-      grpc_rb_event_result(self); /* validates the result */
-      return rb_const_get(grpc_mCompletionType, rb_intern("WRITE_ACCEPTED"));
-
-    case GRPC_FINISH_ACCEPTED:
-      grpc_rb_event_result(self); /* validates the result */
-      return rb_const_get(grpc_mCompletionType, rb_intern("FINISH_ACCEPTED"));
-
-    case GRPC_CLIENT_METADATA_READ:
-      return rb_const_get(grpc_mCompletionType,
-                          rb_intern("CLIENT_METADATA_READ"));
-
-    case GRPC_FINISHED:
-      return rb_const_get(grpc_mCompletionType, rb_intern("FINISHED"));
-
-    case GRPC_SERVER_RPC_NEW:
-      return rb_const_get(grpc_mCompletionType, rb_intern("SERVER_RPC_NEW"));
-
-    default:
-      rb_raise(rb_eRuntimeError, "unrecognized event code for an rpc event:%d",
-               event->type);
-  }
-  return Qnil; /* should not be reached */
-}
-
-/* Obtains the tag associated with an event. */
-static VALUE grpc_rb_event_tag(VALUE self) {
-  grpc_event *event = NULL;
-  grpc_rb_event *wrapper = NULL;
-  Data_Get_Struct(self, grpc_rb_event, wrapper);
-  if (wrapper->wrapped == NULL) {
-    rb_raise(rb_eRuntimeError, "finished!");
-    return Qnil;
-  }
-
-  event = wrapper->wrapped;
-  if (event->tag == NULL) {
-    return Qnil;
-  }
-  return (VALUE)event->tag;
-}
-
-/* Obtains the call associated with an event. */
-static VALUE grpc_rb_event_call(VALUE self) {
-  grpc_event *event = NULL;
-  grpc_rb_event *wrapper = NULL;
-  Data_Get_Struct(self, grpc_rb_event, wrapper);
-  if (wrapper->wrapped == NULL) {
-    rb_raise(rb_eRuntimeError, "finished!");
-    return Qnil;
-  }
-
-  event = wrapper->wrapped;
-  if (event->call != NULL) {
-    return grpc_rb_wrap_call(event->call);
-  }
-  return Qnil;
-}
-
-/* Obtains the metadata associated with an event. */
-static VALUE grpc_rb_event_metadata(VALUE self) {
-  grpc_event *event = NULL;
-  grpc_rb_event *wrapper = NULL;
-  grpc_metadata *metadata = NULL;
-  VALUE key = Qnil;
-  VALUE new_ary = Qnil;
-  VALUE result = Qnil;
-  VALUE value = Qnil;
-  size_t count = 0;
-  size_t i = 0;
-  Data_Get_Struct(self, grpc_rb_event, wrapper);
-  if (wrapper->wrapped == NULL) {
-    rb_raise(rb_eRuntimeError, "finished!");
-    return Qnil;
-  }
-
-  /* Figure out which metadata to read. */
-  event = wrapper->wrapped;
-  switch (event->type) {
-    case GRPC_CLIENT_METADATA_READ:
-      count = event->data.client_metadata_read.count;
-      metadata = event->data.client_metadata_read.elements;
-      break;
-
-    case GRPC_FINISHED:
-      count = event->data.finished.metadata_count;
-      metadata = event->data.finished.metadata_elements;
-      break;
-
-    case GRPC_SERVER_RPC_NEW:
-      count = event->data.server_rpc_new.metadata_count;
-      metadata = event->data.server_rpc_new.metadata_elements;
-      break;
-
-    default:
-      rb_raise(rb_eRuntimeError,
-               "bug: bad event type metadata. got %d; want %d|%d:%d",
-               event->type, GRPC_CLIENT_METADATA_READ, GRPC_FINISHED,
-               GRPC_SERVER_RPC_NEW);
-      return Qnil;
-  }
-
-  result = rb_hash_new();
-  for (i = 0; i < count; i++) {
-    key = rb_str_new2(metadata[i].key);
-    value = rb_hash_aref(result, key);
-    if (value == Qnil) {
-      value = rb_str_new(metadata[i].value, metadata[i].value_length);
-      rb_hash_aset(result, key, value);
-    } else if (TYPE(value) == T_ARRAY) {
-      /* Add the string to the returned array */
-      rb_ary_push(value,
-                  rb_str_new(metadata[i].value, metadata[i].value_length));
-    } else {
-      /* Add the current value with this key and the new one to an array */
-      new_ary = rb_ary_new();
-      rb_ary_push(new_ary, value);
-      rb_ary_push(new_ary,
-                  rb_str_new(metadata[i].value, metadata[i].value_length));
-      rb_hash_aset(result, key, new_ary);
-    }
-  }
-  return result;
-}
-
-/* Obtains the data associated with an event. */
-static VALUE grpc_rb_event_result(VALUE self) {
-  grpc_event *event = NULL;
-  grpc_rb_event *wrapper = NULL;
-  Data_Get_Struct(self, grpc_rb_event, wrapper);
-  if (wrapper->wrapped == NULL) {
-    rb_raise(rb_eRuntimeError, "finished!");
-    return Qnil;
-  }
-  event = wrapper->wrapped;
-
-  switch (event->type) {
-    case GRPC_QUEUE_SHUTDOWN:
-      return Qnil;
-
-    case GRPC_READ:
-      return grpc_rb_byte_buffer_create_with_mark(self, event->data.read);
-
-    case GRPC_FINISH_ACCEPTED:
-      if (event->data.finish_accepted == GRPC_OP_OK) {
-        return Qnil;
-      }
-      rb_raise(grpc_eEventError, "finish failed, not sure why (code=%d)",
-               event->data.finish_accepted);
-      break;
-
-    case GRPC_WRITE_ACCEPTED:
-      if (event->data.write_accepted == GRPC_OP_OK) {
-        return Qnil;
-      }
-      rb_raise(grpc_eEventError, "write failed, not sure why (code=%d)",
-               event->data.write_accepted);
-      break;
-
-    case GRPC_CLIENT_METADATA_READ:
-      return grpc_rb_event_metadata(self);
-
-    case GRPC_FINISHED:
-      return rb_struct_new(grpc_sStatus, UINT2NUM(event->data.finished.status),
-                           (event->data.finished.details == NULL
-                                ? Qnil
-                                : rb_str_new2(event->data.finished.details)),
-                           grpc_rb_event_metadata(self), NULL);
-      break;
-
-    case GRPC_SERVER_RPC_NEW:
-      return rb_struct_new(
-          grpc_sNewServerRpc, rb_str_new2(event->data.server_rpc_new.method),
-          rb_str_new2(event->data.server_rpc_new.host),
-          Data_Wrap_Struct(grpc_cTimeVal, GC_NOT_MARKED, GC_DONT_FREE,
-                           (void *)&event->data.server_rpc_new.deadline),
-          grpc_rb_event_metadata(self), NULL);
-
-    default:
-      rb_raise(rb_eRuntimeError, "unrecognized event code for an rpc event:%d",
-               event->type);
-  }
-
-  return Qfalse;
-}
-
-static VALUE grpc_rb_event_finish(VALUE self) {
-  grpc_event *event = NULL;
-  grpc_rb_event *wrapper = NULL;
-  Data_Get_Struct(self, grpc_rb_event, wrapper);
-  if (wrapper->wrapped == NULL) { /* already closed  */
-    return Qnil;
-  }
-  event = wrapper->wrapped;
-  grpc_event_finish(event);
-  wrapper->wrapped = NULL;
-  wrapper->mark = Qnil;
-  return Qnil;
-}
-
-/* grpc_cEvent is the Event class whose instances proxy grpc_event */
-VALUE grpc_cEvent = Qnil;
-
-/* grpc_eEventError is the ruby class of the exception thrown on failures during
-   rpc event processing. */
-VALUE grpc_eEventError = Qnil;
-
-void Init_grpc_event() {
-  grpc_eEventError =
-      rb_define_class_under(grpc_mGrpcCore, "EventError", rb_eStandardError);
-  grpc_cEvent = rb_define_class_under(grpc_mGrpcCore, "Event", rb_cObject);
-
-  /* Prevent allocation or inialization from ruby. */
-  rb_define_alloc_func(grpc_cEvent, grpc_rb_cannot_alloc);
-  rb_define_method(grpc_cEvent, "initialize", grpc_rb_cannot_init, 0);
-  rb_define_method(grpc_cEvent, "initialize_copy", grpc_rb_cannot_init_copy, 1);
-
-  /* Accessors for the data available in an event. */
-  rb_define_method(grpc_cEvent, "call", grpc_rb_event_call, 0);
-  rb_define_method(grpc_cEvent, "result", grpc_rb_event_result, 0);
-  rb_define_method(grpc_cEvent, "tag", grpc_rb_event_tag, 0);
-  rb_define_method(grpc_cEvent, "type", grpc_rb_event_type, 0);
-  rb_define_method(grpc_cEvent, "finish", grpc_rb_event_finish, 0);
-  rb_define_alias(grpc_cEvent, "close", "finish");
-
-  /* Constants representing the completion types */
-  grpc_mCompletionType =
-      rb_define_module_under(grpc_mGrpcCore, "CompletionType");
-  rb_define_const(grpc_mCompletionType, "QUEUE_SHUTDOWN",
-                  INT2NUM(GRPC_QUEUE_SHUTDOWN));
-  rb_define_const(grpc_mCompletionType, "OP_COMPLETE", INT2NUM(GRPC_OP_COMPLETE));
-  rb_define_const(grpc_mCompletionType, "READ", INT2NUM(GRPC_READ));
-  rb_define_const(grpc_mCompletionType, "WRITE_ACCEPTED",
-                  INT2NUM(GRPC_WRITE_ACCEPTED));
-  rb_define_const(grpc_mCompletionType, "FINISH_ACCEPTED",
-                  INT2NUM(GRPC_FINISH_ACCEPTED));
-  rb_define_const(grpc_mCompletionType, "CLIENT_METADATA_READ",
-                  INT2NUM(GRPC_CLIENT_METADATA_READ));
-  rb_define_const(grpc_mCompletionType, "FINISHED", INT2NUM(GRPC_FINISHED));
-  rb_define_const(grpc_mCompletionType, "SERVER_RPC_NEW",
-                  INT2NUM(GRPC_SERVER_RPC_NEW));
-  rb_define_const(grpc_mCompletionType, "SERVER_SHUTDOWN",
-                  INT2NUM(GRPC_SERVER_SHUTDOWN));
-  rb_define_const(grpc_mCompletionType, "RESERVED",
-                  INT2NUM(GRPC_COMPLETION_DO_NOT_USE));
-}
-
-VALUE grpc_rb_new_event(grpc_event *ev) {
-  grpc_rb_event *wrapper = ALLOC(grpc_rb_event);
-  wrapper->wrapped = ev;
-  wrapper->mark = Qnil;
-  return Data_Wrap_Struct(grpc_cEvent, grpc_rb_event_mark, grpc_rb_event_free,
-                          wrapper);
-}

src/ruby/ext/grpc/rb_grpc.c

@@ -39,12 +39,9 @@
 
 #include <grpc/grpc.h>
 #include <grpc/support/time.h>
-#include "rb_byte_buffer.h"
 #include "rb_call.h"
 #include "rb_channel.h"
 #include "rb_completion_queue.h"
-#include "rb_event.h"
-#include "rb_metadata.h"
 #include "rb_server.h"
 #include "rb_credentials.h"
 #include "rb_server_credentials.h"
@@ -195,7 +192,7 @@ static ID id_inspect;
 /* id_to_s is the to_s method found on various ruby objects. */
 static ID id_to_s;
 
-/* Converts `a wrapped time constant to a standard time. */
+/* Converts a wrapped time constant to a standard time. */
 VALUE grpc_rb_time_val_to_time(VALUE self) {
   gpr_timespec *time_const = NULL;
   Data_Get_Struct(self, gpr_timespec, time_const);
@@ -257,16 +254,16 @@ void Init_grpc() {
   grpc_mGRPC = rb_define_module("GRPC");
   grpc_mGrpcCore = rb_define_module_under(grpc_mGRPC, "Core");
   grpc_sNewServerRpc = rb_struct_define("NewServerRpc", "method", "host",
-                                        "deadline", "metadata", NULL);
+                                        "deadline", "metadata", "call", NULL);
   grpc_sStatus = rb_struct_define("Status", "code", "details", "metadata", NULL);
+  sym_code = ID2SYM(rb_intern("code"));
+  sym_details = ID2SYM(rb_intern("details"));
+  sym_metadata = ID2SYM(rb_intern("metadata"));
 
-  Init_grpc_byte_buffer();
-  Init_grpc_event();
   Init_grpc_channel();
   Init_grpc_completion_queue();
   Init_grpc_call();
   Init_grpc_credentials();
-  Init_grpc_metadata();
   Init_grpc_server();
   Init_grpc_server_credentials();
   Init_grpc_status_codes();

src/ruby/ext/grpc/rb_grpc.h

@@ -50,6 +50,15 @@ extern VALUE grpc_sNewServerRpc;
 /* grpc_sStruct is the struct that holds status details. */
 extern VALUE grpc_sStatus;
 
+/* sym_code is the symbol for the code attribute of grpc_sStatus. */
+VALUE sym_code;
+
+/* sym_details is the symbol for the details attribute of grpc_sStatus. */
+VALUE sym_details;
+
+/* sym_metadata is the symbol for the metadata attribute of grpc_sStatus. */
+VALUE sym_metadata;
+
 /* GC_NOT_MARKED is used in calls to Data_Wrap_Struct to indicate that the
    wrapped struct does not need to participate in ruby gc. */
 extern const RUBY_DATA_FUNC GC_NOT_MARKED;

src/ruby/ext/grpc/rb_metadata.c

@@ -1,215 +0,0 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include "rb_metadata.h"
-
-#include <ruby.h>
-#include <string.h>
-
-#include <grpc/grpc.h>
-#include "rb_grpc.h"
-
-/* grpc_rb_metadata wraps a grpc_metadata.  It provides a peer ruby object,
- * 'mark' to minimize copying when a metadata is created from ruby. */
-typedef struct grpc_rb_metadata {
-  /* Holder of ruby objects involved in constructing the metadata */
-  VALUE mark;
-  /* The actual metadata */
-  grpc_metadata *wrapped;
-} grpc_rb_metadata;
-
-/* Destroys Metadata instances. */
-static void grpc_rb_metadata_free(void *p) {
-  if (p == NULL) {
-    return;
-  };
-
-  /* Because metadata is only created during a call to grpc_call_add_metadata,
-   * and the call takes ownership of the metadata, this does not free the
-   * wrapped struct, only the wrapper */
-  xfree(p);
-}
-
-/* Protects the mark object from GC */
-static void grpc_rb_metadata_mark(void *p) {
-  grpc_rb_metadata *md = NULL;
-  if (p == NULL) {
-    return;
-  }
-
-  md = (grpc_rb_metadata *)p;
-  /* If it's not already cleaned up, mark the mark object */
-  if (md->mark != Qnil && BUILTIN_TYPE(md->mark) != T_NONE) {
-    rb_gc_mark(md->mark);
-  }
-}
-
-/* Allocates Metadata instances.
-
-   Provides safe default values for the Metadata fields. */
-static VALUE grpc_rb_metadata_alloc(VALUE cls) {
-  grpc_rb_metadata *wrapper = ALLOC(grpc_rb_metadata);
-  wrapper->wrapped = NULL;
-  wrapper->mark = Qnil;
-  return Data_Wrap_Struct(cls, grpc_rb_metadata_mark, grpc_rb_metadata_free,
-                          wrapper);
-}
-
-/* id_key and id_value are the names of the hidden ivars that preserve the
- * original byte_buffer source string */
-static ID id_key;
-static ID id_value;
-
-/* Initializes Metadata instances. */
-static VALUE grpc_rb_metadata_init(VALUE self, VALUE key, VALUE value) {
-  grpc_rb_metadata *wrapper = NULL;
-  grpc_metadata *md = ALLOC(grpc_metadata);
-
-  /* Use direct pointers to the strings wrapped by the ruby object to avoid
-   * copying */
-  Data_Get_Struct(self, grpc_rb_metadata, wrapper);
-  wrapper->wrapped = md;
-  if (TYPE(key) == T_SYMBOL) {
-    md->key = (char *)rb_id2name(SYM2ID(key));
-  } else { /* StringValueCStr does all other type exclusions for us */
-    md->key = StringValueCStr(key);
-  }
-  md->value = RSTRING_PTR(value);
-  md->value_length = RSTRING_LEN(value);
-
-  /* Save references to the original values on the mark object so that the
-   * pointers used there are valid for the lifetime of the object. */
-  wrapper->mark = rb_class_new_instance(0, NULL, rb_cObject);
-  rb_ivar_set(wrapper->mark, id_key, key);
-  rb_ivar_set(wrapper->mark, id_value, value);
-
-  return self;
-}
-
-/* Clones Metadata instances.
-
-   Gives Metadata a consistent implementation of Ruby's object copy/dup
-   protocol. */
-static VALUE grpc_rb_metadata_init_copy(VALUE copy, VALUE orig) {
-  grpc_rb_metadata *orig_md = NULL;
-  grpc_rb_metadata *copy_md = NULL;
-
-  if (copy == orig) {
-    return copy;
-  }
-
-  /* Raise an error if orig is not a metadata object or a subclass. */
-  if (TYPE(orig) != T_DATA ||
-      RDATA(orig)->dfree != (RUBY_DATA_FUNC)grpc_rb_metadata_free) {
-    rb_raise(rb_eTypeError, "not a %s", rb_obj_classname(grpc_cMetadata));
-  }
-
-  Data_Get_Struct(orig, grpc_rb_metadata, orig_md);
-  Data_Get_Struct(copy, grpc_rb_metadata, copy_md);
-
-  /* use ruby's MEMCPY to make a byte-for-byte copy of the metadata wrapper
-   * object. */
-  MEMCPY(copy_md, orig_md, grpc_rb_metadata, 1);
-  return copy;
-}
-
-/* Gets the key from a metadata instance. */
-static VALUE grpc_rb_metadata_key(VALUE self) {
-  VALUE key = Qnil;
-  grpc_rb_metadata *wrapper = NULL;
-  grpc_metadata *md = NULL;
-
-  Data_Get_Struct(self, grpc_rb_metadata, wrapper);
-  if (wrapper->mark != Qnil) {
-    key = rb_ivar_get(wrapper->mark, id_key);
-    if (key != Qnil) {
-      return key;
-    }
-  }
-
-  md = wrapper->wrapped;
-  if (md == NULL || md->key == NULL) {
-    return Qnil;
-  }
-  return rb_str_new2(md->key);
-}
-
-/* Gets the value from a metadata instance. */
-static VALUE grpc_rb_metadata_value(VALUE self) {
-  VALUE val = Qnil;
-  grpc_rb_metadata *wrapper = NULL;
-  grpc_metadata *md = NULL;
-
-  Data_Get_Struct(self, grpc_rb_metadata, wrapper);
-  if (wrapper->mark != Qnil) {
-    val = rb_ivar_get(wrapper->mark, id_value);
-    if (val != Qnil) {
-      return val;
-    }
-  }
-
-  md = wrapper->wrapped;
-  if (md == NULL || md->value == NULL) {
-    return Qnil;
-  }
-  return rb_str_new2(md->value);
-}
-
-/* grpc_cMetadata is the Metadata class whose instances proxy grpc_metadata. */
-VALUE grpc_cMetadata = Qnil;
-void Init_grpc_metadata() {
-  grpc_cMetadata =
-      rb_define_class_under(grpc_mGrpcCore, "Metadata", rb_cObject);
-
-  /* Allocates an object managed by the ruby runtime */
-  rb_define_alloc_func(grpc_cMetadata, grpc_rb_metadata_alloc);
-
-  /* Provides a ruby constructor and support for dup/clone. */
-  rb_define_method(grpc_cMetadata, "initialize", grpc_rb_metadata_init, 2);
-  rb_define_method(grpc_cMetadata, "initialize_copy", grpc_rb_metadata_init_copy,
-                   1);
-
-  /* Provides accessors for the code and details. */
-  rb_define_method(grpc_cMetadata, "key", grpc_rb_metadata_key, 0);
-  rb_define_method(grpc_cMetadata, "value", grpc_rb_metadata_value, 0);
-
-  id_key = rb_intern("__key");
-  id_value = rb_intern("__value");
-}
-
-/* Gets the wrapped metadata from the ruby wrapper */
-grpc_metadata *grpc_rb_get_wrapped_metadata(VALUE v) {
-  grpc_rb_metadata *wrapper = NULL;
-  Data_Get_Struct(v, grpc_rb_metadata, wrapper);
-  return wrapper->wrapped;
-}

src/ruby/ext/grpc/rb_server.c

@@ -46,6 +46,9 @@
 /* grpc_cServer is the ruby class that proxies grpc_server. */
 VALUE grpc_cServer = Qnil;
 
+/* id_at is the constructor method of the ruby standard Time class. */
+static ID id_at;
+
 /* grpc_rb_server wraps a grpc_server.  It provides a peer ruby object,
   'mark' to minimize copying when a server is created from ruby. */
 typedef struct grpc_rb_server {
@@ -152,18 +155,89 @@ static VALUE grpc_rb_server_init_copy(VALUE copy, VALUE orig) {
   return copy;
 }
 
-static VALUE grpc_rb_server_request_call(VALUE self, VALUE tag_new) {
-  grpc_call_error err;
+/* request_call_stack holds various values used by the
+ * grpc_rb_server_request_call function */
+typedef struct request_call_stack {
+  grpc_call_details details;
+  grpc_metadata_array md_ary;
+} request_call_stack;
+
+/* grpc_request_call_stack_init ensures the request_call_stack is properly
+ * initialized */
+static void grpc_request_call_stack_init(request_call_stack* st) {
+  MEMZERO(st, request_call_stack, 1);
+  grpc_metadata_array_init(&st->md_ary);
+  grpc_call_details_init(&st->details);
+  st->details.method = NULL;
+  st->details.host = NULL;
+}
+
+/* grpc_request_call_stack_cleanup ensures the request_call_stack is properly
+ * cleaned up */
+static void grpc_request_call_stack_cleanup(request_call_stack* st) {
+  grpc_metadata_array_destroy(&st->md_ary);
+  grpc_call_details_destroy(&st->details);
+}
+
+/* call-seq:
+   cq = CompletionQueue.new
+   tag = Object.new
+   timeout = 10
+   server.request_call(cqueue, tag, timeout)
+
+   Requests notification of a new call on a server. */
+static VALUE grpc_rb_server_request_call(VALUE self, VALUE cqueue,
+                                         VALUE tag_new, VALUE timeout) {
   grpc_rb_server *s = NULL;
+  grpc_call *call = NULL;
+  grpc_event *ev = NULL;
+  grpc_call_error err;
+  request_call_stack st;
+  VALUE result;
   Data_Get_Struct(self, grpc_rb_server, s);
   if (s->wrapped == NULL) {
     rb_raise(rb_eRuntimeError, "closed!");
+    return Qnil;
   } else {
-    err = grpc_server_request_call_old(s->wrapped, ROBJECT(tag_new));
+    grpc_request_call_stack_init(&st);
+    /* call grpc_server_request_call, then wait for it to complete using
+     * pluck_event */
+    err = grpc_server_request_call(
+        s->wrapped, &call, &st.details, &st.md_ary,
+        grpc_rb_get_wrapped_completion_queue(cqueue),
+        ROBJECT(tag_new));
     if (err != GRPC_CALL_OK) {
-      rb_raise(grpc_eCallError, "server request failed: %s (code=%d)",
+      grpc_request_call_stack_cleanup(&st);
+      rb_raise(grpc_eCallError, "grpc_server_request_call failed: %s (code=%d)",
                grpc_call_error_detail_of(err), err);
+      return Qnil;
     }
+    ev = grpc_rb_completion_queue_pluck_event(cqueue, tag_new, timeout);
+    if (ev == NULL) {
+      grpc_request_call_stack_cleanup(&st);
+      return Qnil;
+    }
+    if (ev->data.op_complete != GRPC_OP_OK) {
+      grpc_request_call_stack_cleanup(&st);
+      grpc_event_finish(ev);
+      rb_raise(grpc_eCallError, "request_call completion failed: (code=%d)",
+               ev->data.op_complete);
+      return Qnil;
+    }
+
+    /* build the NewServerRpc struct result */
+    result = rb_struct_new(
+        grpc_sNewServerRpc,
+        rb_str_new2(st.details.method),
+        rb_str_new2(st.details.host),
+        rb_funcall(rb_cTime, id_at, 2, INT2NUM(st.details.deadline.tv_sec),
+                   INT2NUM(st.details.deadline.tv_nsec)),
+        grpc_rb_md_ary_to_h(&st.md_ary),
+        grpc_rb_wrap_call(call),
+        NULL);
+    grpc_event_finish(ev);
+    grpc_request_call_stack_cleanup(&st);
+    return result;
   }
   return Qnil;
 }
@@ -249,12 +323,13 @@ void Init_grpc_server() {
   rb_define_method(grpc_cServer, "initialize_copy", grpc_rb_server_init_copy, 1);
 
   /* Add the server methods. */
-  rb_define_method(grpc_cServer, "request_call", grpc_rb_server_request_call, 1);
+  rb_define_method(grpc_cServer, "request_call", grpc_rb_server_request_call, 3);
   rb_define_method(grpc_cServer, "start", grpc_rb_server_start, 0);
   rb_define_method(grpc_cServer, "destroy", grpc_rb_server_destroy, 0);
   rb_define_alias(grpc_cServer, "close", "destroy");
   rb_define_method(grpc_cServer, "add_http2_port", grpc_rb_server_add_http2_port,
                    -1);
+  id_at = rb_intern("at");
 }
 
 /* Gets the wrapped server from the ruby wrapper */

src/ruby/lib/grpc.rb

@@ -31,7 +31,6 @@ require 'grpc/errors'
 require 'grpc/grpc'
 require 'grpc/logconfig'
 require 'grpc/version'
-require 'grpc/core/event'
 require 'grpc/core/time_consts'
 require 'grpc/generic/active_call'
 require 'grpc/generic/client_stub'

src/ruby/lib/grpc/core/event.rb

@@ -1,44 +0,0 @@
-# Copyright 2015, Google Inc.
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-require 'grpc'
-
-# GRPC contains the General RPC module.
-module GRPC
-  module Core
-    # Event is a class defined in the c extension
-    #
-    # Here, we add an inspect method.
-    class Event
-      def inspect
-        "<#{self.class}: type:#{type}, tag:#{tag} result:#{result}>"
-      end
-    end
-  end
-end

src/ruby/lib/grpc/errors.rb

@@ -31,10 +31,6 @@ require 'grpc'
 
 # GRPC contains the General RPC module.
 module GRPC
-  # OutOfTime is an exception class that indicates that an RPC exceeded its
-  # deadline.
-  OutOfTime = Class.new(StandardError)
-
   # BadStatus is an exception class that indicates that an error occurred at
   # either end of a GRPC connection.  When raised, it indicates that a status
   # error should be returned to the other end of a GRPC connection; when

src/ruby/lib/grpc/generic/active_call.rb

@@ -30,20 +30,14 @@
 require 'forwardable'
 require 'grpc/generic/bidi_call'
 
-def assert_event_type(ev, want)
-  fail OutOfTime if ev.nil?
-  got = ev.type
-  fail "Unexpected rpc event: got #{got}, want #{want}" unless got == want
-end
-
 # GRPC contains the General RPC module.
 module GRPC
   # The ActiveCall class provides simple methods for sending marshallable
   # data to a call
   class ActiveCall
-    include Core::CompletionType
     include Core::StatusCodes
     include Core::TimeConsts
+    include Core::CallOps
     attr_reader(:deadline)
 
     # client_invoke begins a client invocation.
@@ -61,15 +55,14 @@ module GRPC
     # @param q [CompletionQueue] the completion queue
     # @param deadline [Fixnum,TimeSpec] the deadline
     def self.client_invoke(call, q, _deadline, **kw)
-      fail(ArgumentError, 'not a call') unless call.is_a? Core::Call
+      fail(TypeError, '!Core::Call') unless call.is_a? Core::Call
       unless q.is_a? Core::CompletionQueue
-        fail(ArgumentError, 'not a CompletionQueue')
+        fail(TypeError, '!Core::CompletionQueue')
       end
-      call.add_metadata(kw) if kw.length > 0
-      client_metadata_read = Object.new
-      finished_tag = Object.new
-      call.invoke(q, client_metadata_read, finished_tag)
-      [finished_tag, client_metadata_read]
+      metadata_tag = Object.new
+      call.run_batch(q, metadata_tag, INFINITE_FUTURE,
+                     SEND_INITIAL_METADATA => kw)
+      metadata_tag
     end
 
     # Creates an ActiveCall.
@@ -91,25 +84,21 @@ module GRPC
     # @param marshal [Function] f(obj)->string that marshal requests
     # @param unmarshal [Function] f(string)->obj that unmarshals responses
     # @param deadline [Fixnum] the deadline for the call to complete
-    # @param finished_tag [Object] the object used as the call's finish tag,
-    #                              if the call has begun
-    # @param read_metadata_tag [Object] the object used as the call's finish
-    #                                   tag, if the call has begun
+    # @param metadata_tag [Object] the object use obtain metadata for clients
     # @param started [true|false] indicates if the call has begun
-    def initialize(call, q, marshal, unmarshal, deadline, finished_tag: nil,
-                   read_metadata_tag: nil, started: true)
-      fail(ArgumentError, 'not a call') unless call.is_a? Core::Call
+    def initialize(call, q, marshal, unmarshal, deadline, started: true,
+                   metadata_tag: nil)
+      fail(TypeError, '!Core::Call') unless call.is_a? Core::Call
       unless q.is_a? Core::CompletionQueue
-        fail(ArgumentError, 'not a CompletionQueue')
+        fail(TypeError, '!Core::CompletionQueue')
       end
       @call = call
       @cq = q
       @deadline = deadline
-      @finished_tag = finished_tag
-      @read_metadata_tag = read_metadata_tag
       @marshal = marshal
       @started = started
       @unmarshal = unmarshal
+      @metadata_tag = metadata_tag
     end
 
     # Obtains the status of the call.
@@ -176,51 +165,38 @@ module GRPC
 
     # writes_done indicates that all writes are completed.
     #
-    # It blocks until the remote endpoint acknowledges by sending a FINISHED
-    # event, unless assert_finished is set to false.  Any calls to
-    # #remote_send after this call will fail.
+    # It blocks until the remote endpoint acknowledges with at status unless
+    # assert_finished is set to false.  Any calls to #remote_send after this
+    # call will fail.
     #
     # @param assert_finished [true, false] when true(default), waits for
     # FINISHED.
     def writes_done(assert_finished = true)
-      @call.writes_done(self)
-      ev = @cq.pluck(self, INFINITE_FUTURE)
-      begin
-        assert_event_type(ev, FINISH_ACCEPTED)
-        logger.debug("Writes done: waiting for finish? #{assert_finished}")
-      ensure
-        ev.close
-      end
-
+      ops = {
+        SEND_CLOSE_FROM_CLIENT => nil
+      }
+      ops[RECV_STATUS_ON_CLIENT] = nil if assert_finished
+      @call.run_batch(@cq, self, INFINITE_FUTURE, ops)
       return unless assert_finished
-      ev = @cq.pluck(@finished_tag, INFINITE_FUTURE)
-      fail 'unexpected nil event' if ev.nil?
-      ev.close
       @call.status
     end
 
-    # finished waits until the call is completed.
+    # finished waits until a client call is completed.
     #
-    # It blocks until the remote endpoint acknowledges by sending a FINISHED
-    # event.
+    # It blocks until the remote endpoint acknowledges by sending a status.
     def finished
-      ev = @cq.pluck(@finished_tag, INFINITE_FUTURE)
-      begin
-        fail "unexpected event: #{ev.inspect}" unless ev.type == FINISHED
-        if @call.metadata.nil?
-          @call.metadata = ev.result.metadata
-        else
-          @call.metadata.merge!(ev.result.metadata)
-        end
-
-        if ev.result.code != Core::StatusCodes::OK
-          fail BadStatus.new(ev.result.code, ev.result.details)
-        end
-        res = ev.result
-      ensure
-        ev.close
+      batch_result = @call.run_batch(@cq, self, INFINITE_FUTURE,
+                                     RECV_STATUS_ON_CLIENT => nil)
+      if @call.metadata.nil?
+        @call.metadata = batch_result.metadata
+      elsif !batch_result.metadata.nil?
+        @call.metadata.merge!(batch_result.metadata)
       end
-      res
+      if batch_result.status.code != Core::StatusCodes::OK
+        fail BadStatus.new(batch_result.status.code,
+                           batch_result.status.details)
+      end
+      batch_result
     end
 
     # remote_send sends a request to the remote endpoint.
@@ -232,72 +208,50 @@ module GRPC
     # @param marshalled [false, true] indicates if the object is already
     # marshalled.
     def remote_send(req, marshalled = false)
-      assert_queue_is_ready
       logger.debug("sending #{req.inspect}, marshalled? #{marshalled}")
       if marshalled
         payload = req
       else
         payload = @marshal.call(req)
       end
-      @call.start_write(Core::ByteBuffer.new(payload), self)
-
-      # call queue#pluck, and wait for WRITE_ACCEPTED, so as not to return
-      # until the flow control allows another send on this call.
-      ev = @cq.pluck(self, INFINITE_FUTURE)
-      begin
-        assert_event_type(ev, WRITE_ACCEPTED)
-      ensure
-        ev.close
-      end
+      @call.run_batch(@cq, self, INFINITE_FUTURE, SEND_MESSAGE => payload)
     end
 
-    # send_status sends a status to the remote endpoint
+    # send_status sends a status to the remote endpoint.
     #
     # @param code [int] the status code to send
     # @param details [String] details
     # @param assert_finished [true, false] when true(default), waits for
     # FINISHED.
     def send_status(code = OK, details = '', assert_finished = false)
-      assert_queue_is_ready
-      @call.start_write_status(code, details, self)
-      ev = @cq.pluck(self, INFINITE_FUTURE)
-      begin
-        assert_event_type(ev, FINISH_ACCEPTED)
-      ensure
-        ev.close
-      end
-      logger.debug("Status sent: #{code}:'#{details}'")
-      return finished if assert_finished
+      ops = {
+        SEND_STATUS_FROM_SERVER => Struct::Status.new(code, details)
+      }
+      ops[RECV_CLOSE_ON_SERVER] = nil if assert_finished
+      @call.run_batch(@cq, self, INFINITE_FUTURE, ops)
       nil
     end
 
     # remote_read reads a response from the remote endpoint.
     #
-    # It blocks until the remote endpoint sends a READ or FINISHED event.  On
-    # a READ, it returns the response after unmarshalling it. On
-    # FINISHED, it returns nil if the status is OK, otherwise raising
-    # BadStatus
+    # It blocks until the remote endpoint replies with a message or status.
+    # On receiving a message, it returns the response after unmarshalling it.
+    # On receiving a status, it returns nil if the status is OK, otherwise
+    # raising BadStatus
     def remote_read
-      if @call.metadata.nil? && !@read_metadata_tag.nil?
-        ev = @cq.pluck(@read_metadata_tag, INFINITE_FUTURE)
-        assert_event_type(ev, CLIENT_METADATA_READ)
-        @call.metadata = ev.result
-        @read_metadata_tag = nil
+      ops = { RECV_MESSAGE => nil }
+      ops[RECV_INITIAL_METADATA] = nil unless @metadata_tag.nil?
+      batch_result = @call.run_batch(@cq, self, INFINITE_FUTURE, ops)
+      unless @metadata_tag.nil?
+        @call.metadata = batch_result.metadata
+        @metadata_tag = nil
       end
-
-      @call.start_read(self)
-      ev = @cq.pluck(self, INFINITE_FUTURE)
-      begin
-        assert_event_type(ev, READ)
-        logger.debug("received req: #{ev.result.inspect}")
-        unless ev.result.nil?
-          logger.debug("received req.to_s: #{ev.result}")
-          res = @unmarshal.call(ev.result.to_s)
-          logger.debug("received_req (unmarshalled): #{res.inspect}")
-          return res
-        end
-      ensure
-        ev.close
+      logger.debug("received req: #{batch_result}")
+      unless batch_result.nil? || batch_result.message.nil?
+        logger.debug("received req.to_s: #{batch_result.message}")
+        res = @unmarshal.call(batch_result.message)
+        logger.debug("received_req (unmarshalled): #{res.inspect}")
+        return res
       end
       logger.debug('found nil; the final response has been sent')
       nil
@@ -324,7 +278,6 @@ module GRPC
       return enum_for(:each_remote_read) unless block_given?
       loop do
         resp = remote_read
-        break if resp.is_a? Struct::Status  # is an OK status
         break if resp.nil?  # the last response was received
         yield resp
       end
@@ -461,8 +414,7 @@ module GRPC
     # @return [Enumerator, nil] a response Enumerator
     def bidi_streamer(requests, **kw, &blk)
       start_call(**kw) unless @started
-      bd = BidiCall.new(@call, @cq, @marshal, @unmarshal, @deadline,
-                        @finished_tag)
+      bd = BidiCall.new(@call, @cq, @marshal, @unmarshal, @deadline)
       bd.run_on_client(requests, &blk)
     end
 
@@ -478,8 +430,7 @@ module GRPC
     #
     # @param gen_each_reply [Proc] generates the BiDi stream replies
     def run_server_bidi(gen_each_reply)
-      bd = BidiCall.new(@call, @cq, @marshal, @unmarshal, @deadline,
-                        @finished_tag)
+      bd = BidiCall.new(@call, @cq, @marshal, @unmarshal, @deadline)
       bd.run_on_server(gen_each_reply)
     end
 
@@ -516,21 +467,5 @@ module GRPC
     # a Operation on the client.
     Operation = view_class(:cancel, :cancelled, :deadline, :execute,
                            :metadata, :status)
-
-    # confirms that no events are enqueued, and that the queue is not
-    # shutdown.
-    def assert_queue_is_ready
-      ev = nil
-      begin
-        ev = @cq.pluck(self, ZERO)
-        fail "unexpected event #{ev.inspect}" unless ev.nil?
-      rescue OutOfTime
-        logging.debug('timed out waiting for next event')
-        # expected, nothing should be on the queue and the deadline was ZERO,
-        # except things using another tag
-      ensure
-        ev.close unless ev.nil?
-      end
-    end
   end
 end

src/ruby/lib/grpc/generic/bidi_call.rb

@@ -30,18 +30,12 @@
 require 'forwardable'
 require 'grpc/grpc'
 
-def assert_event_type(ev, want)
-  fail OutOfTime if ev.nil?
-  got = ev.type
-  fail("Unexpected rpc event: got #{got}, want #{want}") unless got == want
-end
-
 # GRPC contains the General RPC module.
 module GRPC
   # The BiDiCall class orchestrates exection of a BiDi stream on a client or
   # server.
   class BidiCall
-    include Core::CompletionType
+    include Core::CallOps
     include Core::StatusCodes
     include Core::TimeConsts
 
@@ -63,8 +57,7 @@ module GRPC
     # @param marshal [Function] f(obj)->string that marshal requests
     # @param unmarshal [Function] f(string)->obj that unmarshals responses
     # @param deadline [Fixnum] the deadline for the call to complete
-    # @param finished_tag [Object] the object used as the call's finish tag,
-    def initialize(call, q, marshal, unmarshal, deadline, finished_tag)
+    def initialize(call, q, marshal, unmarshal, deadline)
       fail(ArgumentError, 'not a call') unless call.is_a? Core::Call
       unless q.is_a? Core::CompletionQueue
         fail(ArgumentError, 'not a CompletionQueue')
@@ -72,7 +65,6 @@ module GRPC
       @call = call
       @cq = q
       @deadline = deadline
-      @finished_tag = finished_tag
       @marshal = marshal
       @readq = Queue.new
       @unmarshal = unmarshal
@@ -146,30 +138,14 @@ module GRPC
           requests.each do |req|
             count += 1
             payload = @marshal.call(req)
-            @call.start_write(Core::ByteBuffer.new(payload), write_tag)
-            ev = @cq.pluck(write_tag, INFINITE_FUTURE)
-            begin
-              assert_event_type(ev, WRITE_ACCEPTED)
-            ensure
-              ev.close
-            end
+            @call.run_batch(@cq, write_tag, INFINITE_FUTURE,
+                            SEND_MESSAGE => payload)
           end
           if is_client
-            @call.writes_done(write_tag)
-            ev = @cq.pluck(write_tag, INFINITE_FUTURE)
-            begin
-              assert_event_type(ev, FINISH_ACCEPTED)
-            ensure
-              ev.close
-            end
             logger.debug("bidi-client: sent #{count} reqs, waiting to finish")
-            ev = @cq.pluck(@finished_tag, INFINITE_FUTURE)
-            begin
-              assert_event_type(ev, FINISHED)
-            ensure
-              ev.close
-            end
-            logger.debug('bidi-client: finished received')
+            @call.run_batch(@cq, write_tag, INFINITE_FUTURE,
+                            SEND_CLOSE_FROM_CLIENT => nil,
+                            RECV_STATUS_ON_CLIENT => nil)
           end
         rescue StandardError => e
           logger.warn('bidi: write_loop failed')
@@ -189,25 +165,20 @@ module GRPC
           loop do
             logger.debug("waiting for read #{count}")
             count += 1
-            @call.start_read(read_tag)
-            ev = @cq.pluck(read_tag, INFINITE_FUTURE)
-            begin
-              assert_event_type(ev, READ)
-
-              # handle the next event.
-              if ev.result.nil?
-                @readq.push(END_OF_READS)
-                logger.debug('done reading!')
-                break
-              end
-
-              # push the latest read onto the queue and continue reading
-              logger.debug("received req: #{ev.result}")
-              res = @unmarshal.call(ev.result.to_s)
-              @readq.push(res)
-            ensure
-              ev.close
+            # TODO: ensure metadata is read if available, currently it's not
+            batch_result = @call.run_batch(@cq, read_tag, INFINITE_FUTURE,
+                                           RECV_MESSAGE => nil)
+            # handle the next message
+            if batch_result.message.nil?
+              @readq.push(END_OF_READS)
+              logger.debug('done reading!')
+              break
             end
+
+            # push the latest read onto the queue and continue reading
+            logger.debug("received req: #{batch_result.message}")
+            res = @unmarshal.call(batch_result.message)
+            @readq.push(res)
           end
 
         rescue StandardError => e

src/ruby/lib/grpc/generic/client_stub.rb

@@ -35,9 +35,10 @@ module GRPC
   # ClientStub represents an endpoint used to send requests to GRPC servers.
   class ClientStub
     include Core::StatusCodes
+    include Core::TimeConsts
 
-    # Default deadline is 5 seconds.
-    DEFAULT_DEADLINE = 5
+    # Default timeout is 5 seconds.
+    DEFAULT_TIMEOUT = 5
 
     # setup_channel is used by #initialize to constuct a channel from its
     # arguments.
@@ -76,8 +77,8 @@ module GRPC
     # present the host and arbitrary keyword arg areignored, and the RPC
     # connection uses this channel.
     #
-    # - :deadline
-    # when present, this is the default deadline used for calls
+    # - :timeout
+    # when present, this is the default timeout used for calls
     #
     # - :update_metadata
     # when present, this a func that takes a hash and returns a hash
@@ -87,13 +88,13 @@ module GRPC
     # @param host [String] the host the stub connects to
     # @param q [Core::CompletionQueue] used to wait for events
     # @param channel_override [Core::Channel] a pre-created channel
-    # @param deadline [Number] the default deadline to use in requests
+    # @param timeout [Number] the default timeout to use in requests
     # @param creds [Core::Credentials] the channel
     # @param update_metadata a func that updates metadata as described above
     # @param kw [KeywordArgs]the channel arguments
     def initialize(host, q,
                    channel_override: nil,
-                   deadline: DEFAULT_DEADLINE,
+                   timeout: nil,
                    creds: nil,
                    update_metadata: nil,
                    **kw)
@@ -103,7 +104,7 @@ module GRPC
       @update_metadata = ClientStub.check_update_metadata(update_metadata)
       alt_host = kw[Core::Channel::SSL_TARGET]
       @host = alt_host.nil? ? host : alt_host
-      @deadline = deadline
+      @timeout = timeout.nil? ? DEFAULT_TIMEOUT : timeout
     end
 
     # request_response sends a request to a GRPC server, and returns the
@@ -140,12 +141,12 @@ module GRPC
     # @param req [Object] the request sent to the server
     # @param marshal [Function] f(obj)->string that marshals requests
     # @param unmarshal [Function] f(string)->obj that unmarshals responses
-    # @param deadline [Numeric] (optional) the max completion time in seconds
+    # @param timeout [Numeric] (optional) the max completion time in seconds
     # @param return_op [true|false] return an Operation if true
     # @return [Object] the response received from the server
-    def request_response(method, req, marshal, unmarshal, deadline = nil,
+    def request_response(method, req, marshal, unmarshal, timeout = nil,
                          return_op: false, **kw)
-      c = new_active_call(method, marshal, unmarshal, deadline || @deadline)
+      c = new_active_call(method, marshal, unmarshal, timeout)
       md = @update_metadata.nil? ? kw : @update_metadata.call(kw.clone)
       return c.request_response(req, **md) unless return_op
 
@@ -197,12 +198,12 @@ module GRPC
     # @param requests [Object] an Enumerable of requests to send
     # @param marshal [Function] f(obj)->string that marshals requests
     # @param unmarshal [Function] f(string)->obj that unmarshals responses
-    # @param deadline [Numeric] the max completion time in seconds
+    # @param timeout [Numeric] the max completion time in seconds
     # @param return_op [true|false] return an Operation if true
     # @return [Object|Operation] the response received from the server
-    def client_streamer(method, requests, marshal, unmarshal, deadline = nil,
+    def client_streamer(method, requests, marshal, unmarshal, timeout = nil,
                         return_op: false, **kw)
-      c = new_active_call(method, marshal, unmarshal, deadline || @deadline)
+      c = new_active_call(method, marshal, unmarshal, timeout)
       md = @update_metadata.nil? ? kw : @update_metadata.call(kw.clone)
       return c.client_streamer(requests, **md) unless return_op
 
@@ -262,13 +263,13 @@ module GRPC
     # @param req [Object] the request sent to the server
     # @param marshal [Function] f(obj)->string that marshals requests
     # @param unmarshal [Function] f(string)->obj that unmarshals responses
-    # @param deadline [Numeric] the max completion time in seconds
+    # @param timeout [Numeric] the max completion time in seconds
     # @param return_op [true|false]return an Operation if true
     # @param blk [Block] when provided, is executed for each response
     # @return [Enumerator|Operation|nil] as discussed above
-    def server_streamer(method, req, marshal, unmarshal, deadline = nil,
+    def server_streamer(method, req, marshal, unmarshal, timeout = nil,
                         return_op: false, **kw, &blk)
-      c = new_active_call(method, marshal, unmarshal, deadline || @deadline)
+      c = new_active_call(method, marshal, unmarshal, timeout)
       md = @update_metadata.nil? ? kw : @update_metadata.call(kw.clone)
       return c.server_streamer(req, **md, &blk) unless return_op
 
@@ -367,13 +368,13 @@ module GRPC
     # @param requests [Object] an Enumerable of requests to send
     # @param marshal [Function] f(obj)->string that marshals requests
     # @param unmarshal [Function] f(string)->obj that unmarshals responses
-    # @param deadline [Numeric] (optional) the max completion time in seconds
+    # @param timeout [Numeric] (optional) the max completion time in seconds
     # @param blk [Block] when provided, is executed for each response
     # @param return_op [true|false] return an Operation if true
     # @return [Enumerator|nil|Operation] as discussed above
-    def bidi_streamer(method, requests, marshal, unmarshal, deadline = nil,
+    def bidi_streamer(method, requests, marshal, unmarshal, timeout = nil,
                       return_op: false, **kw, &blk)
-      c = new_active_call(method, marshal, unmarshal, deadline || @deadline)
+      c = new_active_call(method, marshal, unmarshal, timeout)
       md = @update_metadata.nil? ? kw : @update_metadata.call(kw.clone)
       return c.bidi_streamer(requests, **md, &blk) unless return_op
 
@@ -390,15 +391,14 @@ module GRPC
 
     # Creates a new active stub
     #
-    # @param ch [GRPC::Channel] the channel used to create the stub.
+    # @param method [string] the method being called.
     # @param marshal [Function] f(obj)->string that marshals requests
     # @param unmarshal [Function] f(string)->obj that unmarshals responses
-    # @param deadline [TimeConst]
-    def new_active_call(ch, marshal, unmarshal, deadline = nil)
-      absolute_deadline = Core::TimeConsts.from_relative_time(deadline)
-      call = @ch.create_call(ch, @host, absolute_deadline)
-      ActiveCall.new(call, @queue, marshal, unmarshal, absolute_deadline,
-                     started: false)
+    # @param timeout [TimeConst]
+    def new_active_call(method, marshal, unmarshal, timeout = nil)
+      deadline = from_relative_time(timeout.nil? ? @timeout : timeout)
+      call = @ch.create_call(@queue, method, @host, deadline)
+      ActiveCall.new(call, @queue, marshal, unmarshal, deadline, started: false)
     end
   end
 end

src/ruby/lib/grpc/generic/rpc_desc.rb

@@ -81,7 +81,6 @@ module GRPC
         active_call.run_server_bidi(mth)
       end
       send_status(active_call, OK, 'OK')
-      active_call.finished
     rescue BadStatus => e
       # this is raised by handlers that want GRPC to send an application
       # error code and detail message.
@@ -91,15 +90,11 @@ module GRPC
       # This is raised by GRPC internals but should rarely, if ever happen.
       # Log it, but don't notify the other endpoint..
       logger.warn("failed call: #{active_call}\n#{e}")
-    rescue OutOfTime
+    rescue Core::OutOfTime
       # This is raised when active_call#method.call exceeeds the deadline
       # event.  Send a status of deadline exceeded
       logger.warn("late call: #{active_call}")
       send_status(active_call, DEADLINE_EXCEEDED, 'late')
-    rescue Core::EventError => e
-      # This is raised by GRPC internals but should rarely, if ever happen.
-      # Log it, but don't notify the other endpoint..
-      logger.warn("failed call: #{active_call}\n#{e}")
     rescue StandardError => e
       # This will usuaally be an unhandled error in the handling code.
       # Send back a UNKNOWN status to the client
@@ -142,7 +137,7 @@ module GRPC
 
     def send_status(active_client, code, details)
       details = 'Not sure why' if details.nil?
-      active_client.send_status(code, details)
+      active_client.send_status(code, details, code == OK)
     rescue StandardError => e
       logger.warn("Could not send status #{code}:#{details}")
       logger.warn(e)

src/ruby/lib/grpc/generic/rpc_server.rb

@@ -38,7 +38,7 @@ module GRPC
   # RpcServer hosts a number of services and makes them available on the
   # network.
   class RpcServer
-    include Core::CompletionType
+    include Core::CallOps
     include Core::TimeConsts
     extend ::Forwardable
 
@@ -202,20 +202,14 @@ module GRPC
       end
       @pool.start
       @server.start
-      server_tag = Object.new
+      request_call_tag = Object.new
       until stopped?
-        @server.request_call(server_tag)
-        ev = @cq.pluck(server_tag, @poll_period)
-        next if ev.nil?
-        if ev.type != SERVER_RPC_NEW
-          logger.warn("bad evt: got:#{ev.type}, want:#{SERVER_RPC_NEW}")
-          ev.close
-          next
-        end
-        c = new_active_server_call(ev.call, ev.result)
+        deadline = from_relative_time(@poll_period)
+        an_rpc = @server.request_call(@cq, request_call_tag, deadline)
+        next if an_rpc.nil?
+        c = new_active_server_call(an_rpc)
         unless c.nil?
-          mth = ev.result.method.to_sym
-          ev.close
+          mth = an_rpc.method.to_sym
           @pool.schedule(c) do |call|
             rpc_descs[mth].run_server_method(call, rpc_handlers[mth])
           end
@@ -224,46 +218,49 @@ module GRPC
       @running = false
     end
 
-    def new_active_server_call(call, new_server_rpc)
-      # Accept the call.  This is necessary even if a status is to be sent
-      # back immediately
-      finished_tag = Object.new
-      call_queue = Core::CompletionQueue.new
-      call.metadata = new_server_rpc.metadata  # store the metadata
-      call.server_accept(call_queue, finished_tag)
-      call.server_end_initial_metadata
-
-      # Send UNAVAILABLE if there are too many unprocessed jobs
+    # Sends UNAVAILABLE if there are too many unprocessed jobs
+    def available?(an_rpc)
       jobs_count, max = @pool.jobs_waiting, @max_waiting_requests
       logger.info("waiting: #{jobs_count}, max: #{max}")
-      if @pool.jobs_waiting > @max_waiting_requests
-        logger.warn("NOT AVAILABLE: too many jobs_waiting: #{new_server_rpc}")
-        noop = proc { |x| x }
-        c = ActiveCall.new(call, call_queue, noop, noop,
-                           new_server_rpc.deadline,
-                           finished_tag: finished_tag)
-        c.send_status(StatusCodes::UNAVAILABLE, '')
-        return nil
-      end
+      return an_rpc if @pool.jobs_waiting <= @max_waiting_requests
+      logger.warn("NOT AVAILABLE: too many jobs_waiting: #{an_rpc}")
+      noop = proc { |x| x }
+      c = ActiveCall.new(an_rpc.call, @cq, noop, noop, an_rpc.deadline)
+      c.send_status(StatusCodes::UNAVAILABLE, '')
+      nil
+    end
 
-      # Send NOT_FOUND if the method does not exist
-      mth = new_server_rpc.method.to_sym
-      unless rpc_descs.key?(mth)
-        logger.warn("NOT_FOUND: #{new_server_rpc}")
-        noop = proc { |x| x }
-        c = ActiveCall.new(call, call_queue, noop, noop,
-                           new_server_rpc.deadline,
-                           finished_tag: finished_tag)
-        c.send_status(StatusCodes::NOT_FOUND, '')
-        return nil
-      end
+    # Sends NOT_FOUND if the method can't be found
+    def found?(an_rpc)
+      mth = an_rpc.method.to_sym
+      return an_rpc if rpc_descs.key?(mth)
+      logger.warn("NOT_FOUND: #{an_rpc}")
+      noop = proc { |x| x }
+      c = ActiveCall.new(an_rpc.call, @cq, noop, noop, an_rpc.deadline)
+      c.send_status(StatusCodes::NOT_FOUND, '')
+      nil
+    end
+
+    def new_active_server_call(an_rpc)
+      # Accept the call.  This is necessary even if a status is to be sent
+      # back immediately
+      return nil if an_rpc.nil? || an_rpc.call.nil?
+
+      # allow the metadata to be accessed from the call
+      handle_call_tag = Object.new
+      an_rpc.call.metadata = an_rpc.metadata
+      # TODO: add a hook to send md
+      an_rpc.call.run_batch(@cq, handle_call_tag, INFINITE_FUTURE,
+                            SEND_INITIAL_METADATA => nil)
+      return nil unless available?(an_rpc)
+      return nil unless found?(an_rpc)
 
       # Create the ActiveCall
-      rpc_desc = rpc_descs[mth]
-      logger.info("deadline is #{new_server_rpc.deadline}; (now=#{Time.now})")
-      ActiveCall.new(call, call_queue,
+      logger.info("deadline is #{an_rpc.deadline}; (now=#{Time.now})")
+      rpc_desc = rpc_descs[an_rpc.method.to_sym]
+      ActiveCall.new(an_rpc.call, @cq,
                      rpc_desc.marshal_proc, rpc_desc.unmarshal_proc(:input),
-                     new_server_rpc.deadline, finished_tag: finished_tag)
+                     an_rpc.deadline)
     end
 
     # Pool is a simple thread pool for running server requests.

src/ruby/spec/alloc_spec.rb

@@ -1,44 +0,0 @@
-# Copyright 2015, Google Inc.
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-require 'grpc'
-
-describe 'Wrapped classes where .new cannot create an instance' do
-  describe GRPC::Core::Event do
-    it 'should fail .new fail with a runtime error' do
-      expect { GRPC::Core::Event.new }.to raise_error(TypeError)
-    end
-  end
-
-  describe GRPC::Core::Call do
-    it 'should fail .new fail with a runtime error' do
-      expect { GRPC::Core::Event.new }.to raise_error(TypeError)
-    end
-  end
-end

src/ruby/spec/byte_buffer_spec.rb

@@ -1,67 +0,0 @@
-# Copyright 2015, Google Inc.
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-require 'grpc'
-
-describe GRPC::Core::ByteBuffer do
-  describe '#new' do
-    it 'is constructed from a string' do
-      expect { GRPC::Core::ByteBuffer.new('#new') }.not_to raise_error
-    end
-
-    it 'can be constructed from the empty string' do
-      expect { GRPC::Core::ByteBuffer.new('') }.not_to raise_error
-    end
-
-    it 'cannot be constructed from nil' do
-      expect { GRPC::Core::ByteBuffer.new(nil) }.to raise_error TypeError
-    end
-
-    it 'cannot be constructed from non-strings' do
-      [1, Object.new, :a_symbol].each do |x|
-        expect { GRPC::Core::ByteBuffer.new(x) }.to raise_error TypeError
-      end
-    end
-  end
-
-  describe '#to_s' do
-    it 'is the string value the ByteBuffer was constructed with' do
-      expect(GRPC::Core::ByteBuffer.new('#to_s').to_s).to eq('#to_s')
-    end
-  end
-
-  describe '#dup' do
-    it 'makes an instance whose #to_s is the original string value' do
-      bb = GRPC::Core::ByteBuffer.new('#dup')
-      a_copy = bb.dup
-      expect(a_copy.to_s).to eq('#dup')
-      expect(a_copy.dup.to_s).to eq('#dup')
-    end
-  end
-end

src/ruby/spec/call_spec.rb

@@ -66,51 +66,34 @@ describe GRPC::Core::RpcErrors do
   end
 end
 
-describe GRPC::Core::Call do
+describe GRPC::Core::CallOps do
   before(:each) do
-    @tag = Object.new
-    @client_queue = GRPC::Core::CompletionQueue.new
-    fake_host = 'localhost:10101'
-    @ch = GRPC::Core::Channel.new(fake_host, nil)
-  end
-
-  describe '#start_read' do
-    xit 'should fail if called immediately' do
-      blk = proc { make_test_call.start_read(@tag) }
-      expect(&blk).to raise_error GRPC::Core::CallError
-    end
-  end
-
-  describe '#start_write' do
-    xit 'should fail if called immediately' do
-      bytes = GRPC::Core::ByteBuffer.new('test string')
-      blk = proc { make_test_call.start_write(bytes, @tag) }
-      expect(&blk).to raise_error GRPC::Core::CallError
-    end
+    @known_types = {
+      SEND_INITIAL_METADATA: 0,
+      SEND_MESSAGE: 1,
+      SEND_CLOSE_FROM_CLIENT: 2,
+      SEND_STATUS_FROM_SERVER: 3,
+      RECV_INITIAL_METADATA: 4,
+      RECV_MESSAGE: 5,
+      RECV_STATUS_ON_CLIENT: 6,
+      RECV_CLOSE_ON_SERVER: 7
+    }
   end
 
-  describe '#start_write_status' do
-    xit 'should fail if called immediately' do
-      blk = proc { make_test_call.start_write_status(153, 'x', @tag) }
-      expect(&blk).to raise_error GRPC::Core::CallError
-    end
+  it 'should have symbols for all the known operation types' do
+    m = GRPC::Core::CallOps
+    syms_and_codes = m.constants.collect { |c| [c, m.const_get(c)] }
+    expect(Hash[syms_and_codes]).to eq(@known_types)
   end
+end
 
-  describe '#writes_done' do
-    xit 'should fail if called immediately' do
-      blk = proc { make_test_call.writes_done(Object.new) }
-      expect(&blk).to raise_error GRPC::Core::CallError
-    end
-  end
+describe GRPC::Core::Call do
+  let(:client_queue) { GRPC::Core::CompletionQueue.new }
+  let(:test_tag)  { Object.new }
+  let(:fake_host) { 'localhost:10101' }
 
-  describe '#add_metadata' do
-    it 'adds metadata to a call without fail' do
-      call = make_test_call
-      n = 37
-      one_md = proc { |x| [sprintf('key%d', x), sprintf('value%d', x)] }
-      metadata = Hash[n.times.collect { |i| one_md.call i }]
-      expect { call.add_metadata(metadata) }.to_not raise_error
-    end
+  before(:each) do
+    @ch = GRPC::Core::Channel.new(fake_host, nil)
   end
 
   describe '#status' do
@@ -154,7 +137,7 @@ describe GRPC::Core::Call do
   end
 
   def make_test_call
-    @ch.create_call('dummy_method', 'dummy_host', deadline)
+    @ch.create_call(client_queue, 'dummy_method', 'dummy_host', deadline)
   end
 
   def deadline

src/ruby/spec/channel_spec.rb

@@ -36,16 +36,13 @@ def load_test_certs
 end
 
 describe GRPC::Core::Channel do
-  FAKE_HOST = 'localhost:0'
+  let(:fake_host) { 'localhost:0' }
+  let(:cq) { GRPC::Core::CompletionQueue.new }
 
   def create_test_cert
     GRPC::Core::Credentials.new(load_test_certs[0])
   end
 
-  before(:each) do
-    @cq = GRPC::Core::CompletionQueue.new
-  end
-
   shared_examples '#new' do
     it 'take a host name without channel args' do
       expect { GRPC::Core::Channel.new('dummy_host', nil) }.not_to raise_error
@@ -115,25 +112,23 @@ describe GRPC::Core::Channel do
 
   describe '#create_call' do
     it 'creates a call OK' do
-      host = FAKE_HOST
-      ch = GRPC::Core::Channel.new(host, nil)
+      ch = GRPC::Core::Channel.new(fake_host, nil)
 
       deadline = Time.now + 5
 
       blk = proc do
-        ch.create_call('dummy_method', 'dummy_host', deadline)
+        ch.create_call(cq, 'dummy_method', 'dummy_host', deadline)
       end
       expect(&blk).to_not raise_error
     end
 
     it 'raises an error if called on a closed channel' do
-      host = FAKE_HOST
-      ch = GRPC::Core::Channel.new(host, nil)
+      ch = GRPC::Core::Channel.new(fake_host, nil)
       ch.close
 
       deadline = Time.now + 5
       blk = proc do
-        ch.create_call('dummy_method', 'dummy_host', deadline)
+        ch.create_call(cq, 'dummy_method', 'dummy_host', deadline)
       end
       expect(&blk).to raise_error(RuntimeError)
     end
@@ -141,15 +136,13 @@ describe GRPC::Core::Channel do
 
   describe '#destroy' do
     it 'destroys a channel ok' do
-      host = FAKE_HOST
-      ch = GRPC::Core::Channel.new(host, nil)
+      ch = GRPC::Core::Channel.new(fake_host, nil)
       blk = proc { ch.destroy }
       expect(&blk).to_not raise_error
     end
 
     it 'can be called more than once without error' do
-      host = FAKE_HOST
-      ch = GRPC::Core::Channel.new(host, nil)
+      ch = GRPC::Core::Channel.new(fake_host, nil)
       blk = proc { ch.destroy }
       blk.call
       expect(&blk).to_not raise_error
@@ -164,15 +157,13 @@ describe GRPC::Core::Channel do
 
   describe '#close' do
     it 'closes a channel ok' do
-      host = FAKE_HOST
-      ch = GRPC::Core::Channel.new(host, nil)
+      ch = GRPC::Core::Channel.new(fake_host, nil)
       blk = proc { ch.close }
       expect(&blk).to_not raise_error
     end
 
     it 'can be called more than once without error' do
-      host = FAKE_HOST
-      ch = GRPC::Core::Channel.new(host, nil)
+      ch = GRPC::Core::Channel.new(fake_host, nil)
       blk = proc { ch.close }
       blk.call
       expect(&blk).to_not raise_error

src/ruby/spec/client_server_spec.rb

@@ -30,7 +30,6 @@
 require 'grpc'
 require 'spec_helper'
 
-include GRPC::Core::CompletionType
 include GRPC::Core
 
 def load_test_certs
@@ -40,6 +39,8 @@ def load_test_certs
 end
 
 shared_context 'setup: tags' do
+  let(:sent_message) { 'sent message' }
+  let(:reply_text) { 'the reply' }
   before(:example) do
     @server_finished_tag = Object.new
     @client_finished_tag = Object.new
@@ -52,153 +53,136 @@ shared_context 'setup: tags' do
     Time.now + 2
   end
 
-  def expect_next_event_on(queue, type, tag)
-    ev = queue.pluck(tag, deadline)
-    if type.nil?
-      expect(ev).to be_nil
-    else
-      expect(ev).to_not be_nil
-      expect(ev.type).to be(type)
-    end
-    ev
-  end
-
   def server_allows_client_to_proceed
-    @server.request_call(@server_tag)
-    ev = @server_queue.pluck(@server_tag, deadline)
-    expect(ev).not_to be_nil
-    expect(ev.type).to be(SERVER_RPC_NEW)
-    server_call = ev.call
-    server_call.server_accept(@server_queue, @server_finished_tag)
-    server_call.server_end_initial_metadata
+    recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+    expect(recvd_rpc).to_not eq nil
+    server_call = recvd_rpc.call
+    ops = { CallOps::SEND_INITIAL_METADATA => {} }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline, ops)
+    expect(svr_batch.send_metadata).to be true
     server_call
   end
 
-  def server_responds_with(server_call, reply_text)
-    reply = ByteBuffer.new(reply_text)
-    server_call.start_read(@server_tag)
-    ev = @server_queue.pluck(@server_tag, TimeConsts::INFINITE_FUTURE)
-    expect(ev.type).to be(READ)
-    server_call.start_write(reply, @server_tag)
-    ev = @server_queue.pluck(@server_tag, TimeConsts::INFINITE_FUTURE)
-    expect(ev).not_to be_nil
-    expect(ev.type).to be(WRITE_ACCEPTED)
-  end
-
-  def client_sends(call, sent = 'a message')
-    req = ByteBuffer.new(sent)
-    call.start_write(req, @tag)
-    ev = @client_queue.pluck(@tag, TimeConsts::INFINITE_FUTURE)
-    expect(ev).not_to be_nil
-    expect(ev.type).to be(WRITE_ACCEPTED)
-    sent
-  end
-
   def new_client_call
-    @ch.create_call('/method', 'foo.test.google.fr', deadline)
+    @ch.create_call(@client_queue, '/method', 'foo.test.google.fr', deadline)
   end
 end
 
 shared_examples 'basic GRPC message delivery is OK' do
+  include GRPC::Core
   include_context 'setup: tags'
 
-  it 'servers receive requests from clients and start responding' do
-    reply = ByteBuffer.new('the server payload')
+  it 'servers receive requests from clients and can respond' do
     call = new_client_call
-    call.invoke(@client_queue, @client_metadata_tag, @client_finished_tag)
-
-    # check the server rpc new was received
-    # @server.request_call(@server_tag)
-    # ev = expect_next_event_on(@server_queue, SERVER_RPC_NEW, @server_tag)
-
-    # accept the call
-    # server_call = ev.call
-    # server_call.server_accept(@server_queue, @server_finished_tag)
-    # server_call.server_end_initial_metadata
-    server_call = server_allows_client_to_proceed
-
-    # client sends a message
-    msg = client_sends(call)
+    client_ops = {
+      CallOps::SEND_INITIAL_METADATA => {},
+      CallOps::SEND_MESSAGE => sent_message
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_metadata).to be true
+    expect(batch_result.send_message).to be true
 
     # confirm the server can read the inbound message
-    server_call.start_read(@server_tag)
-    ev = expect_next_event_on(@server_queue, READ, @server_tag)
-    expect(ev.result.to_s).to eq(msg)
-
-    #  the server response
-    server_call.start_write(reply, @server_tag)
-    expect_next_event_on(@server_queue, WRITE_ACCEPTED, @server_tag)
+    server_call = server_allows_client_to_proceed
+    server_ops = {
+      CallOps::RECV_MESSAGE => nil
+    }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline,
+                                      server_ops)
+    expect(svr_batch.message).to eq(sent_message)
   end
 
   it 'responses written by servers are received by the client' do
     call = new_client_call
-    call.invoke(@client_queue, @client_metadata_tag, @client_finished_tag)
-    server_call = server_allows_client_to_proceed
-    client_sends(call)
-    server_responds_with(server_call, 'server_response')
+    client_ops = {
+      CallOps::SEND_INITIAL_METADATA => {},
+      CallOps::SEND_MESSAGE => sent_message
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_metadata).to be true
+    expect(batch_result.send_message).to be true
 
-    call.start_read(@tag)
-    ev = expect_next_event_on(@client_queue, READ, @tag)
-    expect(ev.result.to_s).to eq('server_response')
+    # confirm the server can read the inbound message
+    server_call = server_allows_client_to_proceed
+    server_ops = {
+      CallOps::RECV_MESSAGE => nil,
+      CallOps::SEND_MESSAGE => reply_text
+    }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline,
+                                      server_ops)
+    expect(svr_batch.message).to eq(sent_message)
+    expect(svr_batch.send_message).to be true
   end
 
   it 'servers can ignore a client write and send a status' do
     call = new_client_call
-    call.invoke(@client_queue, @client_metadata_tag, @client_finished_tag)
-
-    # check the server rpc new was received
-    @server.request_call(@server_tag)
-    ev = expect_next_event_on(@server_queue, SERVER_RPC_NEW, @server_tag)
-    expect(ev.tag).to be(@server_tag)
-
-    # accept the call - need to do this to sent status.
-    server_call = ev.call
-    server_call.server_accept(@server_queue, @server_finished_tag)
-    server_call.server_end_initial_metadata
-    server_call.start_write_status(StatusCodes::NOT_FOUND, 'not found',
-                                   @server_tag)
-
-    # Client sends some data
-    client_sends(call)
-
-    # client gets an empty response for the read, preceeded by some metadata.
-    call.start_read(@tag)
-    expect_next_event_on(@client_queue, CLIENT_METADATA_READ,
-                         @client_metadata_tag)
-    ev = expect_next_event_on(@client_queue, READ, @tag)
-    expect(ev.tag).to be(@tag)
-    expect(ev.result.to_s).to eq('')
-
-    # finally, after client sends writes_done, they get the finished.
-    call.writes_done(@tag)
-    expect_next_event_on(@client_queue, FINISH_ACCEPTED, @tag)
-    ev = expect_next_event_on(@client_queue, FINISHED, @client_finished_tag)
-    expect(ev.result.code).to eq(StatusCodes::NOT_FOUND)
+    client_ops = {
+      CallOps::SEND_INITIAL_METADATA => {},
+      CallOps::SEND_MESSAGE => sent_message
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_metadata).to be true
+    expect(batch_result.send_message).to be true
+
+    # confirm the server can read the inbound message
+    the_status = Struct::Status.new(StatusCodes::OK, 'OK')
+    server_call = server_allows_client_to_proceed
+    server_ops = {
+      CallOps::SEND_STATUS_FROM_SERVER => the_status
+    }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline,
+                                      server_ops)
+    expect(svr_batch.message).to eq nil
+    expect(svr_batch.send_status).to be true
   end
 
   it 'completes calls by sending status to client and server' do
     call = new_client_call
-    call.invoke(@client_queue, @client_metadata_tag, @client_finished_tag)
+    client_ops = {
+      CallOps::SEND_INITIAL_METADATA => {},
+      CallOps::SEND_MESSAGE => sent_message
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_metadata).to be true
+    expect(batch_result.send_message).to be true
+
+    # confirm the server can read the inbound message and respond
+    the_status = Struct::Status.new(StatusCodes::OK, 'OK', {})
     server_call = server_allows_client_to_proceed
-    client_sends(call)
-    server_responds_with(server_call, 'server_response')
-    server_call.start_write_status(10_101, 'status code is 10101', @server_tag)
-
-    # first the client says writes are done
-    call.start_read(@tag)
-    expect_next_event_on(@client_queue, READ, @tag)
-    call.writes_done(@tag)
-
-    # but nothing happens until the server sends a status
-    expect_next_event_on(@server_queue, FINISH_ACCEPTED, @server_tag)
-    ev = expect_next_event_on(@server_queue, FINISHED, @server_finished_tag)
-    expect(ev.result).to be_a(Struct::Status)
-
-    # client gets FINISHED
-    expect_next_event_on(@client_queue, FINISH_ACCEPTED, @tag)
-    ev = expect_next_event_on(@client_queue, FINISHED, @client_finished_tag)
-    expect(ev.result.details).to eq('status code is 10101')
-    expect(ev.result.code).to eq(10_101)
+    server_ops = {
+      CallOps::RECV_MESSAGE => nil,
+      CallOps::SEND_MESSAGE => reply_text,
+      CallOps::SEND_STATUS_FROM_SERVER => the_status
+    }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline,
+                                      server_ops)
+    expect(svr_batch.message).to eq sent_message
+    expect(svr_batch.send_status).to be true
+    expect(svr_batch.send_message).to be true
+
+    # confirm the client can receive the server response and status.
+    client_ops = {
+      CallOps::SEND_CLOSE_FROM_CLIENT => nil,
+      CallOps::RECV_MESSAGE => nil,
+      CallOps::RECV_STATUS_ON_CLIENT => nil
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_close).to be true
+    expect(batch_result.message).to eq reply_text
+    expect(batch_result.status).to eq the_status
+
+    # confirm the server can receive the client close.
+    server_ops = {
+      CallOps::RECV_CLOSE_ON_SERVER => nil
+    }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline,
+                                      server_ops)
+    expect(svr_batch.send_close).to be true
   end
 end
 
@@ -224,25 +208,33 @@ shared_examples 'GRPC metadata delivery works OK' do
     it 'raises an exception if a metadata key is invalid' do
       @bad_keys.each do |md|
         call = new_client_call
-        expect { call.add_metadata(md) }.to raise_error
+        client_ops = {
+          CallOps::SEND_INITIAL_METADATA => md
+        }
+        blk = proc do
+          call.run_batch(@client_queue, @client_tag, deadline,
+                         client_ops)
+        end
+        expect(&blk).to raise_error
       end
     end
 
     it 'sends all the metadata pairs when keys and values are valid' do
       @valid_metadata.each do |md|
         call = new_client_call
-        call.add_metadata(md)
-
-        # Client begins a call OK
-        call.invoke(@client_queue, @client_metadata_tag, @client_finished_tag)
-
-        # ... server has all metadata available even though the client did not
-        # send a write
-        @server.request_call(@server_tag)
-        ev = expect_next_event_on(@server_queue, SERVER_RPC_NEW, @server_tag)
+        client_ops = {
+          CallOps::SEND_INITIAL_METADATA => md
+        }
+        batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                      client_ops)
+        expect(batch_result.send_metadata).to be true
+
+        # confirm the server can receive the client metadata
+        recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+        expect(recvd_rpc).to_not eq nil
+        recvd_md = recvd_rpc.metadata
         replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }]
-        result = ev.result.metadata
-        expect(result.merge(replace_symbols)).to eq(result)
+        expect(recvd_md).to eq(recvd_md.merge(replace_symbols))
       end
     end
   end
@@ -266,55 +258,81 @@ shared_examples 'GRPC metadata delivery works OK' do
     it 'raises an exception if a metadata key is invalid' do
       @bad_keys.each do |md|
         call = new_client_call
-        call.invoke(@client_queue, @client_metadata_tag, @client_finished_tag)
+        # client signals that it's done sending metadata to allow server to
+        # respond
+        client_ops = {
+          CallOps::SEND_INITIAL_METADATA => nil
+        }
+        call.run_batch(@client_queue, @client_tag, deadline, client_ops)
 
         # server gets the invocation
-        @server.request_call(@server_tag)
-        ev = expect_next_event_on(@server_queue, SERVER_RPC_NEW, @server_tag)
-        expect { ev.call.add_metadata(md) }.to raise_error
+        recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+        expect(recvd_rpc).to_not eq nil
+        server_ops = {
+          CallOps::SEND_INITIAL_METADATA => md
+        }
+        blk = proc do
+          recvd_rpc.call.run_batch(@server_queue, @server_tag, deadline,
+                                   server_ops)
+        end
+        expect(&blk).to raise_error
       end
     end
 
-    it 'sends a hash that contains the status when no metadata is added' do
+    it 'sends an empty hash if no metadata is added' do
       call = new_client_call
-      call.invoke(@client_queue, @client_metadata_tag, @client_finished_tag)
-
-      # server gets the invocation
-      @server.request_call(@server_tag)
-      ev = expect_next_event_on(@server_queue, SERVER_RPC_NEW, @server_tag)
-      server_call = ev.call
-
-      # ... server accepts the call without adding metadata
-      server_call.server_accept(@server_queue, @server_finished_tag)
-      server_call.server_end_initial_metadata
-
-      # there is the HTTP status metadata, though there should not be any
-      # TODO: update this with the bug number to be resolved
-      ev = expect_next_event_on(@client_queue, CLIENT_METADATA_READ,
-                                @client_metadata_tag)
-      expect(ev.result).to eq({})
+      # client signals that it's done sending metadata to allow server to
+      # respond
+      client_ops = {
+        CallOps::SEND_INITIAL_METADATA => nil
+      }
+      call.run_batch(@client_queue, @client_tag, deadline, client_ops)
+
+      # server gets the invocation but sends no metadata back
+      recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+      expect(recvd_rpc).to_not eq nil
+      server_call = recvd_rpc.call
+      server_ops = {
+        CallOps::SEND_INITIAL_METADATA => nil
+      }
+      server_call.run_batch(@server_queue, @server_tag, deadline, server_ops)
+
+      # client receives nothing as expected
+      client_ops = {
+        CallOps::RECV_INITIAL_METADATA => nil
+      }
+      batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                    client_ops)
+      expect(batch_result.metadata).to eq({})
     end
 
     it 'sends all the pairs when keys and values are valid' do
       @valid_metadata.each do |md|
         call = new_client_call
-        call.invoke(@client_queue, @client_metadata_tag, @client_finished_tag)
-
-        # server gets the invocation
-        @server.request_call(@server_tag)
-        ev = expect_next_event_on(@server_queue, SERVER_RPC_NEW, @server_tag)
-        server_call = ev.call
-
-        # ... server adds metadata and accepts the call
-        server_call.add_metadata(md)
-        server_call.server_accept(@server_queue, @server_finished_tag)
-        server_call.server_end_initial_metadata
-
-        # Now the client can read the metadata
-        ev = expect_next_event_on(@client_queue, CLIENT_METADATA_READ,
-                                  @client_metadata_tag)
+        # client signals that it's done sending metadata to allow server to
+        # respond
+        client_ops = {
+          CallOps::SEND_INITIAL_METADATA => nil
+        }
+        call.run_batch(@client_queue, @client_tag, deadline, client_ops)
+
+        # server gets the invocation but sends no metadata back
+        recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+        expect(recvd_rpc).to_not eq nil
+        server_call = recvd_rpc.call
+        server_ops = {
+          CallOps::SEND_INITIAL_METADATA => md
+        }
+        server_call.run_batch(@server_queue, @server_tag, deadline, server_ops)
+
+        # client receives nothing as expected
+        client_ops = {
+          CallOps::RECV_INITIAL_METADATA => nil
+        }
+        batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                      client_ops)
         replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }]
-        expect(ev.result).to eq(replace_symbols)
+        expect(batch_result.metadata).to eq(replace_symbols)
       end
     end
   end

src/ruby/spec/event_spec.rb

@@ -1,53 +0,0 @@
-# Copyright 2015, Google Inc.
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-require 'grpc'
-
-describe GRPC::Core::CompletionType do
-  before(:each) do
-    @known_types = {
-      QUEUE_SHUTDOWN: 0,
-      OP_COMPLETE: 1,
-      READ: 2,
-      WRITE_ACCEPTED: 3,
-      FINISH_ACCEPTED: 4,
-      CLIENT_METADATA_READ: 5,
-      FINISHED: 6,
-      SERVER_RPC_NEW: 7,
-      SERVER_SHUTDOWN: 8,
-      RESERVED: 9
-    }
-  end
-
-  it 'should have all the known types' do
-    mod = GRPC::Core::CompletionType
-    blk = proc { Hash[mod.constants.collect { |c| [c, mod.const_get(c)] }] }
-    expect(blk.call).to eq(@known_types)
-  end
-end

src/ruby/spec/generic/active_call_spec.rb

@@ -34,12 +34,11 @@ include GRPC::Core::StatusCodes
 describe GRPC::ActiveCall do
   ActiveCall = GRPC::ActiveCall
   Call = GRPC::Core::Call
-  CompletionType = GRPC::Core::CompletionType
+  CallOps = GRPC::Core::CallOps
 
   before(:each) do
     @pass_through = proc { |x| x }
     @server_tag = Object.new
-    @server_done_tag = Object.new
     @tag = Object.new
 
     @client_queue = GRPC::Core::CompletionQueue.new
@@ -48,7 +47,7 @@ describe GRPC::ActiveCall do
     @server = GRPC::Core::Server.new(@server_queue, nil)
     server_port = @server.add_http2_port(host)
     @server.start
-    @ch = GRPC::Core::Channel.new("localhost:#{server_port}", nil)
+    @ch = GRPC::Core::Channel.new("0.0.0.0:#{server_port}", nil)
   end
 
   after(:each) do
@@ -58,12 +57,10 @@ describe GRPC::ActiveCall do
   describe 'restricted view methods' do
     before(:each) do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       @client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                     @pass_through, deadline,
-                                    finished_tag: done_tag,
-                                    read_metadata_tag: meta_tag)
+                                    metadata_tag: md_tag)
     end
 
     describe '#multi_req_view' do
@@ -90,48 +87,45 @@ describe GRPC::ActiveCall do
   describe '#remote_send' do
     it 'allows a client to send a payload to the server' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       @client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                     @pass_through, deadline,
-                                    finished_tag: done_tag,
-                                    read_metadata_tag: meta_tag)
+                                    metadata_tag: md_tag)
       msg = 'message is a string'
       @client_call.remote_send(msg)
 
       # check that server rpc new was received
-      @server.request_call(@server_tag)
-      ev = @server_queue.next(deadline)
-      expect(ev.type).to be(CompletionType::SERVER_RPC_NEW)
-      expect(ev.call).to be_a(Call)
-      expect(ev.tag).to be(@server_tag)
+      recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+      expect(recvd_rpc).to_not eq nil
+      recvd_call = recvd_rpc.call
 
       # Accept the call, and verify that the server reads the response ok.
-      ev.call.server_accept(@client_queue, @server_tag)
-      ev.call.server_end_initial_metadata
-      server_call = ActiveCall.new(ev.call, @client_queue, @pass_through,
+      server_ops = {
+        CallOps::SEND_INITIAL_METADATA => {}
+      }
+      recvd_call.run_batch(@server_queue, @server_tag, deadline, server_ops)
+      server_call = ActiveCall.new(recvd_call, @server_queue, @pass_through,
                                    @pass_through, deadline)
       expect(server_call.remote_read).to eq(msg)
     end
 
     it 'marshals the payload using the marshal func' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      ActiveCall.client_invoke(call, @client_queue, deadline)
       marshal = proc { |x| 'marshalled:' + x }
       client_call = ActiveCall.new(call, @client_queue, marshal,
-                                   @pass_through, deadline,
-                                   finished_tag: done_tag,
-                                   read_metadata_tag: meta_tag)
+                                   @pass_through, deadline)
       msg = 'message is a string'
       client_call.remote_send(msg)
 
       # confirm that the message was marshalled
-      @server.request_call(@server_tag)
-      ev = @server_queue.next(deadline)
-      ev.call.server_accept(@client_queue, @server_tag)
-      ev.call.server_end_initial_metadata
-      server_call = ActiveCall.new(ev.call, @client_queue, @pass_through,
+      recvd_rpc =  @server.request_call(@server_queue, @server_tag, deadline)
+      recvd_call = recvd_rpc.call
+      server_ops = {
+        CallOps::SEND_INITIAL_METADATA => nil
+      }
+      recvd_call.run_batch(@server_queue, @server_tag, deadline, server_ops)
+      server_call = ActiveCall.new(recvd_call, @server_queue, @pass_through,
                                    @pass_through, deadline)
       expect(server_call.remote_read).to eq('marshalled:' + msg)
     end
@@ -142,23 +136,22 @@ describe GRPC::ActiveCall do
       call = make_test_call
       ActiveCall.client_invoke(call, @client_queue, deadline,
                                k1: 'v1', k2: 'v2')
-      @server.request_call(@server_tag)
-      ev = @server_queue.next(deadline)
-      expect(ev).to_not be_nil
-      expect(ev.result.metadata['k1']).to eq('v1')
-      expect(ev.result.metadata['k2']).to eq('v2')
+      recvd_rpc =  @server.request_call(@server_queue, @server_tag, deadline)
+      recvd_call = recvd_rpc.call
+      expect(recvd_call).to_not be_nil
+      expect(recvd_rpc.metadata).to_not be_nil
+      expect(recvd_rpc.metadata['k1']).to eq('v1')
+      expect(recvd_rpc.metadata['k2']).to eq('v2')
     end
   end
 
   describe '#remote_read' do
     it 'reads the response sent by a server' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: done_tag,
-                                   read_metadata_tag: meta_tag)
+                                   metadata_tag: md_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       server_call = expect_server_to_receive(msg)
@@ -168,12 +161,10 @@ describe GRPC::ActiveCall do
 
     it 'saves no metadata when the server adds no metadata' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: done_tag,
-                                   read_metadata_tag: meta_tag)
+                                   metadata_tag: md_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       server_call = expect_server_to_receive(msg)
@@ -185,12 +176,10 @@ describe GRPC::ActiveCall do
 
     it 'saves metadata add by the server' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: done_tag,
-                                   read_metadata_tag: meta_tag)
+                                   metadata_tag: md_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       server_call = expect_server_to_receive(msg, k1: 'v1', k2: 'v2')
@@ -203,12 +192,10 @@ describe GRPC::ActiveCall do
 
     it 'get a nil msg before a status when an OK status is sent' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: done_tag,
-                                   read_metadata_tag: meta_tag)
+                                   metadata_tag: md_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       client_call.writes_done(false)
@@ -222,13 +209,11 @@ describe GRPC::ActiveCall do
 
     it 'unmarshals the response using the unmarshal func' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       unmarshal = proc { |x| 'unmarshalled:' + x }
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    unmarshal, deadline,
-                                   finished_tag: done_tag,
-                                   read_metadata_tag: meta_tag)
+                                   metadata_tag: md_tag)
 
       # confirm the client receives the unmarshalled message
       msg = 'message is a string'
@@ -249,13 +234,11 @@ describe GRPC::ActiveCall do
 
     it 'the returns an enumerator that can read n responses' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: done_tag,
-                                   read_metadata_tag: meta_tag)
-      msg = 'message is 4a string'
+                                   metadata_tag: md_tag)
+      msg = 'message is a string'
       reply = 'server_response'
       client_call.remote_send(msg)
       server_call = expect_server_to_receive(msg)
@@ -269,12 +252,10 @@ describe GRPC::ActiveCall do
 
     it 'the returns an enumerator that stops after an OK Status' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   read_metadata_tag: meta_tag,
-                                   finished_tag: done_tag)
+                                   metadata_tag: md_tag)
       msg = 'message is a string'
       reply = 'server_response'
       client_call.remote_send(msg)
@@ -294,12 +275,10 @@ describe GRPC::ActiveCall do
   describe '#writes_done' do
     it 'finishes ok if the server sends a status response' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: done_tag,
-                                   read_metadata_tag: meta_tag)
+                                   metadata_tag: md_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       expect { client_call.writes_done(false) }.to_not raise_error
@@ -312,12 +291,10 @@ describe GRPC::ActiveCall do
 
     it 'finishes ok if the server sends an early status response' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   read_metadata_tag: meta_tag,
-                                   finished_tag: done_tag)
+                                   metadata_tag: md_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       server_call = expect_server_to_receive(msg)
@@ -330,12 +307,10 @@ describe GRPC::ActiveCall do
 
     it 'finishes ok if writes_done is true' do
       call = make_test_call
-      done_tag, meta_tag = ActiveCall.client_invoke(call, @client_queue,
-                                                    deadline)
+      md_tag = ActiveCall.client_invoke(call, @client_queue, deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   read_metadata_tag: meta_tag,
-                                   finished_tag: done_tag)
+                                   metadata_tag: md_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       server_call = expect_server_to_receive(msg)
@@ -353,21 +328,20 @@ describe GRPC::ActiveCall do
   end
 
   def expect_server_to_be_invoked(**kw)
-    @server.request_call(@server_tag)
-    ev = @server_queue.next(deadline)
-    ev.call.add_metadata(kw)
-    ev.call.server_accept(@client_queue, @server_done_tag)
-    ev.call.server_end_initial_metadata
-    ActiveCall.new(ev.call, @client_queue, @pass_through,
-                   @pass_through, deadline,
-                   finished_tag: @server_done_tag)
+    recvd_rpc =  @server.request_call(@server_queue, @server_tag, deadline)
+    expect(recvd_rpc).to_not eq nil
+    recvd_call = recvd_rpc.call
+    recvd_call.run_batch(@server_queue, @server_tag, deadline,
+                         CallOps::SEND_INITIAL_METADATA => kw)
+    ActiveCall.new(recvd_call, @server_queue, @pass_through,
+                   @pass_through, deadline)
   end
 
   def make_test_call
-    @ch.create_call('dummy_method', 'dummy_host', deadline)
+    @ch.create_call(@client_queue, '/method', 'a.dummy.host', deadline)
   end
 
   def deadline
-    Time.now + 1  # in 1 second; arbitrary
+    Time.now + 2  # in 2 seconds; arbitrary
   end
 end

src/ruby/spec/generic/client_stub_spec.rb

@@ -30,15 +30,41 @@
 require 'grpc'
 require 'xray/thread_dump_signal_handler'
 
-NOOP = proc { |x| x }
-FAKE_HOST = 'localhost:0'
+# Notifier is useful high-level synchronization primitive.
+class Notifier
+  attr_reader :payload, :notified
+  alias_method :notified?, :notified
+
+  def initialize
+    @mutex    = Mutex.new
+    @cvar     = ConditionVariable.new
+    @notified = false
+    @payload  = nil
+  end
+
+  def wait
+    @mutex.synchronize do
+      @cvar.wait(@mutex) until notified?
+    end
+  end
+
+  def notify(payload)
+    @mutex.synchronize do
+      return Error.new('already notified') if notified?
+      @payload  = payload
+      @notified = true
+      @cvar.signal
+      return nil
+    end
+  end
+end
 
 def wakey_thread(&blk)
-  awake_mutex, awake_cond = Mutex.new, ConditionVariable.new
+  n = Notifier.new
   t = Thread.new do
-    blk.call(awake_mutex, awake_cond)
+    blk.call(n)
   end
-  awake_mutex.synchronize { awake_cond.wait(awake_mutex) }
+  n.wait
   t
 end
 
@@ -50,8 +76,11 @@ end
 
 include GRPC::Core::StatusCodes
 include GRPC::Core::TimeConsts
+include GRPC::Core::CallOps
 
 describe 'ClientStub' do
+  let(:noop) { proc { |x| x } }
+
   before(:each) do
     Thread.abort_on_exception = true
     @server = nil
@@ -66,61 +95,56 @@ describe 'ClientStub' do
   end
 
   describe '#new' do
+    let(:fake_host) { 'localhost:0' }
     it 'can be created from a host and args' do
-      host = FAKE_HOST
       opts = { a_channel_arg: 'an_arg' }
       blk = proc do
-        GRPC::ClientStub.new(host, @cq, **opts)
+        GRPC::ClientStub.new(fake_host, @cq, **opts)
       end
       expect(&blk).not_to raise_error
     end
 
     it 'can be created with a default deadline' do
-      host = FAKE_HOST
       opts = { a_channel_arg: 'an_arg', deadline: 5 }
       blk = proc do
-        GRPC::ClientStub.new(host, @cq, **opts)
+        GRPC::ClientStub.new(fake_host, @cq, **opts)
       end
       expect(&blk).not_to raise_error
     end
 
     it 'can be created with an channel override' do
-      host = FAKE_HOST
       opts = { a_channel_arg: 'an_arg', channel_override: @ch }
       blk = proc do
-        GRPC::ClientStub.new(host, @cq, **opts)
+        GRPC::ClientStub.new(fake_host, @cq, **opts)
       end
       expect(&blk).not_to raise_error
     end
 
     it 'cannot be created with a bad channel override' do
-      host = FAKE_HOST
       blk = proc do
         opts = { a_channel_arg: 'an_arg', channel_override: Object.new }
-        GRPC::ClientStub.new(host, @cq, **opts)
+        GRPC::ClientStub.new(fake_host, @cq, **opts)
       end
       expect(&blk).to raise_error
     end
 
     it 'cannot be created with bad credentials' do
-      host = FAKE_HOST
       blk = proc do
         opts = { a_channel_arg: 'an_arg', creds: Object.new }
-        GRPC::ClientStub.new(host, @cq, **opts)
+        GRPC::ClientStub.new(fake_host, @cq, **opts)
       end
       expect(&blk).to raise_error
     end
 
     it 'can be created with test test credentials' do
       certs = load_test_certs
-      host = FAKE_HOST
       blk = proc do
         opts = {
           GRPC::Core::Channel::SSL_TARGET => 'foo.test.google.fr',
           a_channel_arg: 'an_arg',
           creds: GRPC::Core::Credentials.new(certs[0], nil, nil)
         }
-        GRPC::ClientStub.new(host, @cq, **opts)
+        GRPC::ClientStub.new(fake_host, @cq, **opts)
       end
       expect(&blk).to_not raise_error
     end
@@ -187,7 +211,7 @@ describe 'ClientStub' do
 
     describe 'without a call operation' do
       def get_response(stub)
-        stub.request_response(@method, @sent_msg, NOOP, NOOP,
+        stub.request_response(@method, @sent_msg, noop, noop,
                               k1: 'v1', k2: 'v2')
       end
 
@@ -196,7 +220,7 @@ describe 'ClientStub' do
 
     describe 'via a call operation' do
       def get_response(stub)
-        op = stub.request_response(@method, @sent_msg, NOOP, NOOP,
+        op = stub.request_response(@method, @sent_msg, noop, noop,
                                    return_op: true, k1: 'v1', k2: 'v2')
         expect(op).to be_a(GRPC::ActiveCall::Operation)
         op.execute
@@ -259,7 +283,7 @@ describe 'ClientStub' do
 
     describe 'without a call operation' do
       def get_response(stub)
-        stub.client_streamer(@method, @sent_msgs, NOOP, NOOP,
+        stub.client_streamer(@method, @sent_msgs, noop, noop,
                              k1: 'v1', k2: 'v2')
       end
 
@@ -268,7 +292,7 @@ describe 'ClientStub' do
 
     describe 'via a call operation' do
       def get_response(stub)
-        op = stub.client_streamer(@method, @sent_msgs, NOOP, NOOP,
+        op = stub.client_streamer(@method, @sent_msgs, noop, noop,
                                   return_op: true, k1: 'v1', k2: 'v2')
         expect(op).to be_a(GRPC::ActiveCall::Operation)
         op.execute
@@ -333,7 +357,7 @@ describe 'ClientStub' do
 
     describe 'without a call operation' do
       def get_responses(stub)
-        e = stub.server_streamer(@method, @sent_msg, NOOP, NOOP,
+        e = stub.server_streamer(@method, @sent_msg, noop, noop,
                                  k1: 'v1', k2: 'v2')
         expect(e).to be_a(Enumerator)
         e
@@ -344,7 +368,7 @@ describe 'ClientStub' do
 
     describe 'via a call operation' do
       def get_responses(stub)
-        op = stub.server_streamer(@method, @sent_msg, NOOP, NOOP,
+        op = stub.server_streamer(@method, @sent_msg, noop, noop,
                                   return_op: true, k1: 'v1', k2: 'v2')
         expect(op).to be_a(GRPC::ActiveCall::Operation)
         e = op.execute
@@ -361,34 +385,30 @@ describe 'ClientStub' do
       before(:each) do
         @sent_msgs = Array.new(3) { |i| 'msg_' + (i + 1).to_s }
         @replys = Array.new(3) { |i| 'reply_' + (i + 1).to_s }
+        server_port = create_test_server
+        @host = "localhost:#{server_port}"
       end
 
       it 'supports sending all the requests first', bidi: true do
-        server_port = create_test_server
-        host = "localhost:#{server_port}"
         th = run_bidi_streamer_handle_inputs_first(@sent_msgs, @replys,
                                                    @pass)
-        stub = GRPC::ClientStub.new(host, @cq)
+        stub = GRPC::ClientStub.new(@host, @cq)
         e = get_responses(stub)
         expect(e.collect { |r| r }).to eq(@replys)
         th.join
       end
 
       it 'supports client-initiated ping pong', bidi: true do
-        server_port = create_test_server
-        host = "localhost:#{server_port}"
         th = run_bidi_streamer_echo_ping_pong(@sent_msgs, @pass, true)
-        stub = GRPC::ClientStub.new(host, @cq)
+        stub = GRPC::ClientStub.new(@host, @cq)
         e = get_responses(stub)
         expect(e.collect { |r| r }).to eq(@sent_msgs)
         th.join
       end
 
       it 'supports a server-initiated ping pong', bidi: true do
-        server_port = create_test_server
-        host = "localhost:#{server_port}"
         th = run_bidi_streamer_echo_ping_pong(@sent_msgs, @pass, false)
-        stub = GRPC::ClientStub.new(host, @cq)
+        stub = GRPC::ClientStub.new(@host, @cq)
         e = get_responses(stub)
         expect(e.collect { |r| r }).to eq(@sent_msgs)
         th.join
@@ -397,7 +417,7 @@ describe 'ClientStub' do
 
     describe 'without a call operation' do
       def get_responses(stub)
-        e = stub.bidi_streamer(@method, @sent_msgs, NOOP, NOOP)
+        e = stub.bidi_streamer(@method, @sent_msgs, noop, noop)
         expect(e).to be_a(Enumerator)
         e
       end
@@ -407,7 +427,7 @@ describe 'ClientStub' do
 
     describe 'via a call operation' do
       def get_responses(stub)
-        op = stub.bidi_streamer(@method, @sent_msgs, NOOP, NOOP,
+        op = stub.bidi_streamer(@method, @sent_msgs, noop, noop,
                                 return_op: true)
         expect(op).to be_a(GRPC::ActiveCall::Operation)
         e = op.execute
@@ -421,8 +441,8 @@ describe 'ClientStub' do
 
   def run_server_streamer(expected_input, replys, status, **kw)
     wanted_metadata = kw.clone
-    wakey_thread do |mtx, cnd|
-      c = expect_server_to_be_invoked(mtx, cnd)
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
       wanted_metadata.each do |k, v|
         expect(c.metadata[k.to_s]).to eq(v)
       end
@@ -434,8 +454,8 @@ describe 'ClientStub' do
 
   def run_bidi_streamer_handle_inputs_first(expected_inputs, replys,
                                             status)
-    wakey_thread do |mtx, cnd|
-      c = expect_server_to_be_invoked(mtx, cnd)
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
       expected_inputs.each { |i| expect(c.remote_read).to eq(i) }
       replys.each { |r| c.remote_send(r) }
       c.send_status(status, status == @pass ? 'OK' : 'NOK', true)
@@ -443,8 +463,8 @@ describe 'ClientStub' do
   end
 
   def run_bidi_streamer_echo_ping_pong(expected_inputs, status, client_starts)
-    wakey_thread do |mtx, cnd|
-      c = expect_server_to_be_invoked(mtx, cnd)
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
       expected_inputs.each do |i|
         if client_starts
           expect(c.remote_read).to eq(i)
@@ -460,8 +480,8 @@ describe 'ClientStub' do
 
   def run_client_streamer(expected_inputs, resp, status, **kw)
     wanted_metadata = kw.clone
-    wakey_thread do |mtx, cnd|
-      c = expect_server_to_be_invoked(mtx, cnd)
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
       expected_inputs.each { |i| expect(c.remote_read).to eq(i) }
       wanted_metadata.each do |k, v|
         expect(c.metadata[k.to_s]).to eq(v)
@@ -473,8 +493,8 @@ describe 'ClientStub' do
 
   def run_request_response(expected_input, resp, status, **kw)
     wanted_metadata = kw.clone
-    wakey_thread do |mtx, cnd|
-      c = expect_server_to_be_invoked(mtx, cnd)
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
       expect(c.remote_read).to eq(expected_input)
       wanted_metadata.each do |k, v|
         expect(c.metadata[k.to_s]).to eq(v)
@@ -490,24 +510,16 @@ describe 'ClientStub' do
     @server.add_http2_port('0.0.0.0:0')
   end
 
-  def start_test_server(awake_mutex, awake_cond)
+  def expect_server_to_be_invoked(notifier)
     @server.start
-    @server_tag = Object.new
-    @server.request_call(@server_tag)
-    awake_mutex.synchronize { awake_cond.signal }
-  end
-
-  def expect_server_to_be_invoked(awake_mutex, awake_cond)
-    start_test_server(awake_mutex, awake_cond)
-    ev = @server_queue.pluck(@server_tag, INFINITE_FUTURE)
-    fail OutOfTime if ev.nil?
-    server_call = ev.call
-    server_call.metadata = ev.result.metadata
-    finished_tag = Object.new
-    server_call.server_accept(@server_queue, finished_tag)
-    server_call.server_end_initial_metadata
-    GRPC::ActiveCall.new(server_call, @server_queue, NOOP, NOOP,
-                         INFINITE_FUTURE,
-                         finished_tag: finished_tag)
+    notifier.notify(nil)
+    server_tag = Object.new
+    recvd_rpc = @server.request_call(@server_queue, server_tag,
+                                     INFINITE_FUTURE)
+    recvd_call = recvd_rpc.call
+    recvd_call.metadata = recvd_rpc.metadata
+    recvd_call.run_batch(@server_queue, server_tag, Time.now + 2,
+                         SEND_INITIAL_METADATA => nil)
+    GRPC::ActiveCall.new(recvd_call, @server_queue, noop, noop, INFINITE_FUTURE)
   end
 end

src/ruby/spec/generic/rpc_desc_spec.rb

@@ -37,7 +37,6 @@ describe GRPC::RpcDesc do
   INTERNAL = GRPC::Core::StatusCodes::INTERNAL
   UNKNOWN = GRPC::Core::StatusCodes::UNKNOWN
   CallError = GRPC::Core::CallError
-  EventError = GRPC::Core::EventError
 
   before(:each) do
     @request_response = RpcDesc.new('rr', Object.new, Object.new, 'encode',
@@ -63,24 +62,17 @@ describe GRPC::RpcDesc do
 
       it 'sends the specified status if BadStatus is raised' do
         expect(@call).to receive(:remote_read).once.and_return(Object.new)
-        expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK')
+        expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK', false)
         @request_response.run_server_method(@call, method(:bad_status))
       end
 
       it 'sends status UNKNOWN if other StandardErrors are raised' do
         expect(@call).to receive(:remote_read).once.and_return(Object.new)
-        expect(@call).to receive(:send_status) .once.with(UNKNOWN, @no_reason)
+        expect(@call).to receive(:send_status) .once.with(UNKNOWN, @no_reason,
+                                                          false)
         @request_response.run_server_method(@call, method(:other_error))
       end
 
-      it 'absorbs EventError  with no further action' do
-        expect(@call).to receive(:remote_read).once.and_raise(EventError)
-        blk = proc do
-          @request_response.run_server_method(@call, method(:fake_reqresp))
-        end
-        expect(&blk).to_not raise_error
-      end
-
       it 'absorbs CallError with no further action' do
         expect(@call).to receive(:remote_read).once.and_raise(CallError)
         blk = proc do
@@ -93,8 +85,7 @@ describe GRPC::RpcDesc do
         req = Object.new
         expect(@call).to receive(:remote_read).once.and_return(req)
         expect(@call).to receive(:remote_send).once.with(@ok_response)
-        expect(@call).to receive(:send_status).once.with(OK, 'OK')
-        expect(@call).to receive(:finished).once
+        expect(@call).to receive(:send_status).once.with(OK, 'OK', true)
         @request_response.run_server_method(@call, method(:fake_reqresp))
       end
     end
@@ -107,23 +98,16 @@ describe GRPC::RpcDesc do
       end
 
       it 'sends the specified status if BadStatus is raised' do
-        expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK')
+        expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK', false)
         @client_streamer.run_server_method(@call, method(:bad_status_alt))
       end
 
       it 'sends status UNKNOWN if other StandardErrors are raised' do
-        expect(@call).to receive(:send_status) .once.with(UNKNOWN, @no_reason)
+        expect(@call).to receive(:send_status) .once.with(UNKNOWN, @no_reason,
+                                                          false)
         @client_streamer.run_server_method(@call, method(:other_error_alt))
       end
 
-      it 'absorbs EventError  with no further action' do
-        expect(@call).to receive(:remote_send).once.and_raise(EventError)
-        blk = proc do
-          @client_streamer.run_server_method(@call, method(:fake_clstream))
-        end
-        expect(&blk).to_not raise_error
-      end
-
       it 'absorbs CallError with no further action' do
         expect(@call).to receive(:remote_send).once.and_raise(CallError)
         blk = proc do
@@ -134,8 +118,7 @@ describe GRPC::RpcDesc do
 
       it 'sends a response and closes the stream if there no errors' do
         expect(@call).to receive(:remote_send).once.with(@ok_response)
-        expect(@call).to receive(:send_status).once.with(OK, 'OK')
-        expect(@call).to receive(:finished).once
+        expect(@call).to receive(:send_status).once.with(OK, 'OK', true)
         @client_streamer.run_server_method(@call, method(:fake_clstream))
       end
     end
@@ -149,24 +132,17 @@ describe GRPC::RpcDesc do
 
       it 'sends the specified status if BadStatus is raised' do
         expect(@call).to receive(:remote_read).once.and_return(Object.new)
-        expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK')
+        expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK', false)
         @server_streamer.run_server_method(@call, method(:bad_status))
       end
 
       it 'sends status UNKNOWN if other StandardErrors are raised' do
         expect(@call).to receive(:remote_read).once.and_return(Object.new)
-        expect(@call).to receive(:send_status) .once.with(UNKNOWN, @no_reason)
+        expect(@call).to receive(:send_status) .once.with(UNKNOWN, @no_reason,
+                                                          false)
         @server_streamer.run_server_method(@call, method(:other_error))
       end
 
-      it 'absorbs EventError  with no further action' do
-        expect(@call).to receive(:remote_read).once.and_raise(EventError)
-        blk = proc do
-          @server_streamer.run_server_method(@call, method(:fake_svstream))
-        end
-        expect(&blk).to_not raise_error
-      end
-
       it 'absorbs CallError with no further action' do
         expect(@call).to receive(:remote_read).once.and_raise(CallError)
         blk = proc do
@@ -179,8 +155,7 @@ describe GRPC::RpcDesc do
         req = Object.new
         expect(@call).to receive(:remote_read).once.and_return(req)
         expect(@call).to receive(:remote_send).twice.with(@ok_response)
-        expect(@call).to receive(:send_status).once.with(OK, 'OK')
-        expect(@call).to receive(:finished).once
+        expect(@call).to receive(:send_status).once.with(OK, 'OK', true)
         @server_streamer.run_server_method(@call, method(:fake_svstream))
       end
     end
@@ -197,20 +172,20 @@ describe GRPC::RpcDesc do
       it 'sends the specified status if BadStatus is raised' do
         e = GRPC::BadStatus.new(@bs_code, 'NOK')
         expect(@call).to receive(:run_server_bidi).and_raise(e)
-        expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK')
+        expect(@call).to receive(:send_status).once.with(@bs_code, 'NOK', false)
         @bidi_streamer.run_server_method(@call, method(:bad_status_alt))
       end
 
       it 'sends status UNKNOWN if other StandardErrors are raised' do
         expect(@call).to receive(:run_server_bidi).and_raise(StandardError)
-        expect(@call).to receive(:send_status).once.with(UNKNOWN, @no_reason)
+        expect(@call).to receive(:send_status).once.with(UNKNOWN, @no_reason,
+                                                         false)
         @bidi_streamer.run_server_method(@call, method(:other_error_alt))
       end
 
       it 'closes the stream if there no errors' do
         expect(@call).to receive(:run_server_bidi)
-        expect(@call).to receive(:send_status).once.with(OK, 'OK')
-        expect(@call).to receive(:finished).once
+        expect(@call).to receive(:send_status).once.with(OK, 'OK', true)
         @bidi_streamer.run_server_method(@call, method(:fake_bidistream))
       end
     end

src/ruby/spec/generic/rpc_server_spec.rb

@@ -364,7 +364,7 @@ describe GRPC::RpcServer do
         @srv.wait_till_running
         req = EchoMsg.new
         stub = SlowStub.new(@host, **@client_opts)
-        deadline = service.delay + 0.5 # wait for long enough
+        deadline = service.delay + 1.0 # wait for long enough
         expect(stub.an_rpc(req, deadline, k1: 'v1', k2: 'v2')).to be_a(EchoMsg)
         wanted_md = [{ 'k1' => 'v1', 'k2' => 'v2' }]
         expect(service.received_md).to eq(wanted_md)

src/ruby/spec/metadata_spec.rb

@@ -1,64 +0,0 @@
-# Copyright 2015, Google Inc.
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-require 'grpc'
-
-describe GRPC::Core::Metadata do
-  describe '#new' do
-    it 'should create instances' do
-      expect { GRPC::Core::Metadata.new('a key', 'a value') }.to_not raise_error
-    end
-  end
-
-  describe '#key' do
-    md = GRPC::Core::Metadata.new('a key', 'a value')
-    it 'should be the constructor value' do
-      expect(md.key).to eq('a key')
-    end
-  end
-
-  describe '#value' do
-    md = GRPC::Core::Metadata.new('a key', 'a value')
-    it 'should be the constuctor value' do
-      expect(md.value).to eq('a value')
-    end
-  end
-
-  describe '#dup' do
-    it 'should create a copy that returns the correct key' do
-      md = GRPC::Core::Metadata.new('a key', 'a value')
-      expect(md.dup.key).to eq('a key')
-    end
-
-    it 'should create a copy that returns the correct value' do
-      md = GRPC::Core::Metadata.new('a key', 'a value')
-      expect(md.dup.value).to eq('a value')
-    end
-  end
-end

templates/BUILD.template

@@ -32,38 +32,79 @@
 
 licenses(["notice"])  # 3-clause BSD
 
+package(default_visibility = ["//visibility:public"])
+
+<%!
+def get_deps(target_dict):
+  deps = []
+  if target_dict.get('secure', 'no') == 'yes':
+    deps = [
+      "//external:libssl",
+    ]
+  if target_dict.get('build', None) == 'protoc':
+    deps.append("//external:protobuf_compiler")
+  if target_dict['name'] == 'grpc++_unsecure' or target_dict['name'] == 'grpc++':
+    deps.append("//external:protobuf_clib")
+  for d in target_dict.get('deps', []):
+    if d.find('//') == 0 or d[0] == ':':
+      deps.append(d)
+    else:
+      deps.append(':%s' % (d))
+  return deps
+%>
+
 % for lib in libs:
-% if lib.build == "all" and lib.language == 'c':
-${makelib(lib)}
+% if lib.build != "private":
+${cc_library(lib)}
 % endif
 % endfor
 
-<%def name="makelib(lib)">
+% for tgt in targets:
+% if tgt.build == 'protoc':
+${cc_binary(tgt)}
+% endif
+% endfor
 
+<%def name="cc_library(lib)">
 cc_library(
-    name = "${lib.name}",
-    srcs = [
+  name = "${lib.name}",
+  srcs = [
 % for hdr in lib.get("headers", []):
-        "${hdr}",
+    "${hdr}",
 % endfor
 % for src in lib.src:
-        "${src}",
+    "${src}",
 % endfor
-    ],
-    hdrs = [
+  ],
+  hdrs = [
 % for hdr in lib.get("public_headers", []):
-        "${hdr}",
+    "${hdr}",
 % endfor
-    ],
-    includes = [
-        "include",
-        ".",
-    ],
-    deps = [
-% for dep in lib.get("deps", []):
-        ":${dep}",
+  ],
+  includes = [
+    "include",
+    ".",
+  ],
+  deps = [
+% for dep in get_deps(lib):
+    "${dep}",
 % endfor
-    ],
+  ],
 )
+</%def>
 
+<%def name="cc_binary(tgt)">
+cc_binary(
+  name = "${tgt.name}",
+  srcs = [
+% for src in tgt.src:
+    "${src}",
+% endfor
+  ],
+  deps = [
+% for dep in get_deps(tgt):
+    "${dep}",
+% endfor
+  ],
+)
 </%def>

templates/Makefile.template

@@ -930,6 +930,7 @@ else
 	$(Q) $(INSTALL) -d $(prefix)/lib
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/lib${lib.name}.$(SHARED_EXT) $(prefix)/lib/lib${lib.name}.$(SHARED_EXT)
 ifneq ($(SYSTEM),Darwin)
+	$(Q) ln -sf lib${lib.name}.$(SHARED_EXT) $(prefix)/lib/lib${lib.name}.so.${settings.version.major}
 	$(Q) ln -sf lib${lib.name}.$(SHARED_EXT) $(prefix)/lib/lib${lib.name}.so
 endif
 endif

test/core/iomgr/tcp_server_posix_test.c

@@ -38,6 +38,7 @@
 #include <grpc/support/time.h>
 #include "test/core/util/test_config.h"
 
+#include <sys/socket.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <unistd.h>

test/core/support/tls_test.c

@@ -0,0 +1,82 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/* Test of gpr thread local storage support. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/tls.h>
+#include "test/core/util/test_config.h"
+
+#define NUM_THREADS 100
+
+GPR_TLS_DECL(test_var);
+
+static void thd_body(void *arg) {
+  gpr_intptr i;
+
+  GPR_ASSERT(gpr_tls_get(&test_var) == 0);
+
+  for (i = 0; i < 10000000; i++) {
+    gpr_tls_set(&test_var, i);
+    GPR_ASSERT(gpr_tls_get(&test_var) == i);
+  }
+}
+
+/* ------------------------------------------------- */
+
+int main(int argc, char *argv[]) {
+  gpr_thd_options opt = gpr_thd_options_default();
+  int i;
+  gpr_thd_id threads[NUM_THREADS];
+
+  grpc_test_init(argc, argv);
+
+  gpr_tls_init(&test_var);
+
+  gpr_thd_options_set_joinable(&opt);
+
+  for (i = 0; i < NUM_THREADS; i++) {
+    gpr_thd_new(&threads[i], thd_body, NULL, &opt);
+  }
+  for (i = 0; i < NUM_THREADS; i++) {
+    gpr_thd_join(threads[i]);
+  }
+
+  gpr_tls_destroy(&test_var);
+
+  return 0;
+}

test/cpp/interop/client.cc

@@ -31,29 +31,19 @@
  *
  */
 
-#include <chrono>
-#include <fstream>
 #include <memory>
-#include <sstream>
-#include <string>
-#include <thread>
 
 #include <unistd.h>
 
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <gflags/gflags.h>
-#include <grpc++/channel_arguments.h>
 #include <grpc++/channel_interface.h>
 #include <grpc++/client_context.h>
-#include <grpc++/create_channel.h>
-#include <grpc++/credentials.h>
 #include <grpc++/status.h>
 #include <grpc++/stream.h>
-#include "test/cpp/util/create_test_channel.h"
-#include "test/cpp/interop/test.grpc.pb.h"
-#include "test/cpp/interop/empty.grpc.pb.h"
-#include "test/cpp/interop/messages.grpc.pb.h"
+#include "test/cpp/interop/client_helper.h"
+#include "test/cpp/interop/interop_client.h"
 
 DEFINE_bool(enable_ssl, false, "Whether to use ssl/tls.");
 DEFINE_bool(use_prod_roots, false, "True to use SSL roots for google");
@@ -81,21 +71,8 @@ DEFINE_string(service_account_key_file, "",
               "Path to service account json key file.");
 DEFINE_string(oauth_scope, "", "Scope for OAuth tokens.");
 
-using grpc::ChannelInterface;
-using grpc::ClientContext;
-using grpc::ComputeEngineCredentials;
-using grpc::CreateTestChannel;
-using grpc::Credentials;
-using grpc::JWTCredentials;
-using grpc::ServiceAccountCredentials;
-using grpc::testing::ResponseParameters;
-using grpc::testing::SimpleRequest;
-using grpc::testing::SimpleResponse;
-using grpc::testing::StreamingInputCallRequest;
-using grpc::testing::StreamingInputCallResponse;
-using grpc::testing::StreamingOutputCallRequest;
-using grpc::testing::StreamingOutputCallResponse;
-using grpc::testing::TestService;
+using grpc::testing::CreateChannelForTestCase;
+using grpc::testing::GetServiceAccountJsonKey;
 
 // In some distros, gflags is in the namespace google, and in some others,
 // in gflags. This hack is enabling us to find both.
@@ -104,362 +81,48 @@ namespace gflags {}
 using namespace google;
 using namespace gflags;
 
-namespace {
-// The same value is defined by the Java client.
-const std::vector<int> request_stream_sizes = {27182, 8, 1828, 45904};
-const std::vector<int> response_stream_sizes = {31415, 9, 2653, 58979};
-const int kNumResponseMessages = 2000;
-const int kResponseMessageSize = 1030;
-const int kReceiveDelayMilliSeconds = 20;
-const int kLargeRequestSize = 314159;
-const int kLargeResponseSize = 271812;
-}  // namespace
-
-grpc::string GetServiceAccountJsonKey() {
-  static grpc::string json_key;
-  if (json_key.empty()) {
-    std::ifstream json_key_file(FLAGS_service_account_key_file);
-    std::stringstream key_stream;
-    key_stream << json_key_file.rdbuf();
-    json_key = key_stream.str();
-  }
-  return json_key;
-}
-
-std::shared_ptr<ChannelInterface> CreateChannelForTestCase(
-    const grpc::string& test_case) {
-  GPR_ASSERT(FLAGS_server_port);
-  const int host_port_buf_size = 1024;
-  char host_port[host_port_buf_size];
-  snprintf(host_port, host_port_buf_size, "%s:%d", FLAGS_server_host.c_str(),
-           FLAGS_server_port);
-
-  if (test_case == "service_account_creds") {
-    std::unique_ptr<Credentials> creds;
-    GPR_ASSERT(FLAGS_enable_ssl);
-    grpc::string json_key = GetServiceAccountJsonKey();
-    creds = ServiceAccountCredentials(json_key, FLAGS_oauth_scope,
-                                      std::chrono::hours(1));
-    return CreateTestChannel(host_port, FLAGS_server_host_override,
-                             FLAGS_enable_ssl, FLAGS_use_prod_roots, creds);
-  } else if (test_case == "compute_engine_creds") {
-    std::unique_ptr<Credentials> creds;
-    GPR_ASSERT(FLAGS_enable_ssl);
-    creds = ComputeEngineCredentials();
-    return CreateTestChannel(host_port, FLAGS_server_host_override,
-                             FLAGS_enable_ssl, FLAGS_use_prod_roots, creds);
-  } else if (test_case == "jwt_token_creds") {
-    std::unique_ptr<Credentials> creds;
-    GPR_ASSERT(FLAGS_enable_ssl);
-    grpc::string json_key = GetServiceAccountJsonKey();
-    creds = JWTCredentials(json_key, std::chrono::hours(1));
-    return CreateTestChannel(host_port, FLAGS_server_host_override,
-                             FLAGS_enable_ssl, FLAGS_use_prod_roots, creds);
-  } else {
-    return CreateTestChannel(host_port, FLAGS_server_host_override,
-                             FLAGS_enable_ssl, FLAGS_use_prod_roots);
-  }
-}
-
-void AssertOkOrPrintErrorStatus(const grpc::Status& s) {
-  if (s.IsOk()) {
-    return;
-  }
-  gpr_log(GPR_INFO, "Error status code: %d, message: %s", s.code(),
-          s.details().c_str());
-  GPR_ASSERT(0);
-}
-
-void DoEmpty() {
-  gpr_log(GPR_INFO, "Sending an empty rpc...");
-  std::shared_ptr<ChannelInterface> channel =
-      CreateChannelForTestCase("empty_unary");
-  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel));
-
-  grpc::testing::Empty request = grpc::testing::Empty::default_instance();
-  grpc::testing::Empty response = grpc::testing::Empty::default_instance();
-  ClientContext context;
-
-  grpc::Status s = stub->EmptyCall(&context, request, &response);
-  AssertOkOrPrintErrorStatus(s);
-
-  gpr_log(GPR_INFO, "Empty rpc done.");
-}
-
-// Shared code to set large payload, make rpc and check response payload.
-void PerformLargeUnary(std::shared_ptr<ChannelInterface> channel,
-                       SimpleRequest* request, SimpleResponse* response) {
-  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel));
-
-  ClientContext context;
-  request->set_response_type(grpc::testing::PayloadType::COMPRESSABLE);
-  request->set_response_size(kLargeResponseSize);
-  grpc::string payload(kLargeRequestSize, '\0');
-  request->mutable_payload()->set_body(payload.c_str(), kLargeRequestSize);
-
-  grpc::Status s = stub->UnaryCall(&context, *request, response);
-
-  AssertOkOrPrintErrorStatus(s);
-  GPR_ASSERT(response->payload().type() ==
-             grpc::testing::PayloadType::COMPRESSABLE);
-  GPR_ASSERT(response->payload().body() ==
-             grpc::string(kLargeResponseSize, '\0'));
-}
-
-void DoComputeEngineCreds() {
-  gpr_log(GPR_INFO,
-          "Sending a large unary rpc with compute engine credentials ...");
-  std::shared_ptr<ChannelInterface> channel =
-      CreateChannelForTestCase("compute_engine_creds");
-  SimpleRequest request;
-  SimpleResponse response;
-  request.set_fill_username(true);
-  request.set_fill_oauth_scope(true);
-  PerformLargeUnary(channel, &request, &response);
-  gpr_log(GPR_INFO, "Got username %s", response.username().c_str());
-  gpr_log(GPR_INFO, "Got oauth_scope %s", response.oauth_scope().c_str());
-  GPR_ASSERT(!response.username().empty());
-  GPR_ASSERT(response.username().c_str() == FLAGS_default_service_account);
-  GPR_ASSERT(!response.oauth_scope().empty());
-  const char* oauth_scope_str = response.oauth_scope().c_str();
-  GPR_ASSERT(FLAGS_oauth_scope.find(oauth_scope_str) != grpc::string::npos);
-  gpr_log(GPR_INFO, "Large unary with compute engine creds done.");
-}
-
-void DoServiceAccountCreds() {
-  gpr_log(GPR_INFO,
-          "Sending a large unary rpc with service account credentials ...");
-  std::shared_ptr<ChannelInterface> channel =
-      CreateChannelForTestCase("service_account_creds");
-  SimpleRequest request;
-  SimpleResponse response;
-  request.set_fill_username(true);
-  request.set_fill_oauth_scope(true);
-  PerformLargeUnary(channel, &request, &response);
-  GPR_ASSERT(!response.username().empty());
-  GPR_ASSERT(!response.oauth_scope().empty());
-  grpc::string json_key = GetServiceAccountJsonKey();
-  GPR_ASSERT(json_key.find(response.username()) != grpc::string::npos);
-  const char* oauth_scope_str = response.oauth_scope().c_str();
-  GPR_ASSERT(FLAGS_oauth_scope.find(oauth_scope_str) != grpc::string::npos);
-  gpr_log(GPR_INFO, "Large unary with service account creds done.");
-}
-
-void DoJwtTokenCreds() {
-  gpr_log(GPR_INFO, "Sending a large unary rpc with JWT token credentials ...");
-  std::shared_ptr<ChannelInterface> channel =
-      CreateChannelForTestCase("jwt_token_creds");
-  SimpleRequest request;
-  SimpleResponse response;
-  request.set_fill_username(true);
-  PerformLargeUnary(channel, &request, &response);
-  GPR_ASSERT(!response.username().empty());
-  grpc::string json_key = GetServiceAccountJsonKey();
-  GPR_ASSERT(json_key.find(response.username()) != grpc::string::npos);
-  gpr_log(GPR_INFO, "Large unary with JWT token creds done.");
-}
-
-void DoLargeUnary() {
-  gpr_log(GPR_INFO, "Sending a large unary rpc...");
-  std::shared_ptr<ChannelInterface> channel =
-      CreateChannelForTestCase("large_unary");
-  SimpleRequest request;
-  SimpleResponse response;
-  PerformLargeUnary(channel, &request, &response);
-  gpr_log(GPR_INFO, "Large unary done.");
-}
-
-void DoRequestStreaming() {
-  gpr_log(GPR_INFO, "Sending request steaming rpc ...");
-  std::shared_ptr<ChannelInterface> channel =
-      CreateChannelForTestCase("client_streaming");
-  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel));
-
-  grpc::ClientContext context;
-  StreamingInputCallRequest request;
-  StreamingInputCallResponse response;
-
-  std::unique_ptr<grpc::ClientWriter<StreamingInputCallRequest>> stream(
-      stub->StreamingInputCall(&context, &response));
-
-  int aggregated_payload_size = 0;
-  for (unsigned int i = 0; i < request_stream_sizes.size(); ++i) {
-    grpc::testing::Payload* payload = request.mutable_payload();
-    payload->set_body(grpc::string(request_stream_sizes[i], '\0'));
-    GPR_ASSERT(stream->Write(request));
-    aggregated_payload_size += request_stream_sizes[i];
-  }
-  stream->WritesDone();
-  grpc::Status s = stream->Finish();
-
-  GPR_ASSERT(response.aggregated_payload_size() == aggregated_payload_size);
-  AssertOkOrPrintErrorStatus(s);
-  gpr_log(GPR_INFO, "Request streaming done.");
-}
-
-void DoResponseStreaming() {
-  gpr_log(GPR_INFO, "Receiving response steaming rpc ...");
-  std::shared_ptr<ChannelInterface> channel =
-      CreateChannelForTestCase("server_streaming");
-  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel));
-
-  grpc::ClientContext context;
-  StreamingOutputCallRequest request;
-  for (unsigned int i = 0; i < response_stream_sizes.size(); ++i) {
-    ResponseParameters* response_parameter = request.add_response_parameters();
-    response_parameter->set_size(response_stream_sizes[i]);
-  }
-  StreamingOutputCallResponse response;
-  std::unique_ptr<grpc::ClientReader<StreamingOutputCallResponse>> stream(
-      stub->StreamingOutputCall(&context, request));
-
-  unsigned int i = 0;
-  while (stream->Read(&response)) {
-    GPR_ASSERT(response.payload().body() ==
-               grpc::string(response_stream_sizes[i], '\0'));
-    ++i;
-  }
-  GPR_ASSERT(response_stream_sizes.size() == i);
-  grpc::Status s = stream->Finish();
-
-  AssertOkOrPrintErrorStatus(s);
-  gpr_log(GPR_INFO, "Response streaming done.");
-}
-
-void DoResponseStreamingWithSlowConsumer() {
-  gpr_log(GPR_INFO, "Receiving response steaming rpc with slow consumer ...");
-  std::shared_ptr<ChannelInterface> channel =
-      CreateChannelForTestCase("slow_consumer");
-  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel));
-
-  grpc::ClientContext context;
-  StreamingOutputCallRequest request;
-
-  for (int i = 0; i < kNumResponseMessages; ++i) {
-    ResponseParameters* response_parameter = request.add_response_parameters();
-    response_parameter->set_size(kResponseMessageSize);
-  }
-  StreamingOutputCallResponse response;
-  std::unique_ptr<grpc::ClientReader<StreamingOutputCallResponse>> stream(
-      stub->StreamingOutputCall(&context, request));
-
-  int i = 0;
-  while (stream->Read(&response)) {
-    GPR_ASSERT(response.payload().body() ==
-               grpc::string(kResponseMessageSize, '\0'));
-    gpr_log(GPR_INFO, "received message %d", i);
-    usleep(kReceiveDelayMilliSeconds * 1000);
-    ++i;
-  }
-  GPR_ASSERT(kNumResponseMessages == i);
-  grpc::Status s = stream->Finish();
-
-  AssertOkOrPrintErrorStatus(s);
-  gpr_log(GPR_INFO, "Response streaming done.");
-}
-
-void DoHalfDuplex() {
-  gpr_log(GPR_INFO, "Sending half-duplex streaming rpc ...");
-  std::shared_ptr<ChannelInterface> channel =
-      CreateChannelForTestCase("half_duplex");
-  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel));
-
-  grpc::ClientContext context;
-  std::unique_ptr<grpc::ClientReaderWriter<StreamingOutputCallRequest,
-                                           StreamingOutputCallResponse>>
-      stream(stub->HalfDuplexCall(&context));
-
-  StreamingOutputCallRequest request;
-  ResponseParameters* response_parameter = request.add_response_parameters();
-  for (unsigned int i = 0; i < response_stream_sizes.size(); ++i) {
-    response_parameter->set_size(response_stream_sizes[i]);
-    GPR_ASSERT(stream->Write(request));
-  }
-  stream->WritesDone();
-
-  unsigned int i = 0;
-  StreamingOutputCallResponse response;
-  while (stream->Read(&response)) {
-    GPR_ASSERT(response.payload().has_body());
-    GPR_ASSERT(response.payload().body() ==
-               grpc::string(response_stream_sizes[i], '\0'));
-    ++i;
-  }
-  GPR_ASSERT(response_stream_sizes.size() == i);
-  grpc::Status s = stream->Finish();
-  AssertOkOrPrintErrorStatus(s);
-  gpr_log(GPR_INFO, "Half-duplex streaming rpc done.");
-}
-
-void DoPingPong() {
-  gpr_log(GPR_INFO, "Sending Ping Pong streaming rpc ...");
-  std::shared_ptr<ChannelInterface> channel =
-      CreateChannelForTestCase("ping_pong");
-  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel));
-
-  grpc::ClientContext context;
-  std::unique_ptr<grpc::ClientReaderWriter<StreamingOutputCallRequest,
-                                           StreamingOutputCallResponse>>
-      stream(stub->FullDuplexCall(&context));
-
-  StreamingOutputCallRequest request;
-  request.set_response_type(grpc::testing::PayloadType::COMPRESSABLE);
-  ResponseParameters* response_parameter = request.add_response_parameters();
-  grpc::testing::Payload* payload = request.mutable_payload();
-  StreamingOutputCallResponse response;
-  for (unsigned int i = 0; i < request_stream_sizes.size(); ++i) {
-    response_parameter->set_size(response_stream_sizes[i]);
-    payload->set_body(grpc::string(request_stream_sizes[i], '\0'));
-    GPR_ASSERT(stream->Write(request));
-    GPR_ASSERT(stream->Read(&response));
-    GPR_ASSERT(response.payload().has_body());
-    GPR_ASSERT(response.payload().body() ==
-               grpc::string(response_stream_sizes[i], '\0'));
-  }
-
-  stream->WritesDone();
-  GPR_ASSERT(!stream->Read(&response));
-  grpc::Status s = stream->Finish();
-  AssertOkOrPrintErrorStatus(s);
-  gpr_log(GPR_INFO, "Ping pong streaming done.");
-}
-
 int main(int argc, char** argv) {
   grpc_init();
 
   ParseCommandLineFlags(&argc, &argv, true);
 
+  grpc::testing::InteropClient client(
+      CreateChannelForTestCase(FLAGS_test_case));
   if (FLAGS_test_case == "empty_unary") {
-    DoEmpty();
+    client.DoEmpty();
   } else if (FLAGS_test_case == "large_unary") {
-    DoLargeUnary();
+    client.DoLargeUnary();
   } else if (FLAGS_test_case == "client_streaming") {
-    DoRequestStreaming();
+    client.DoRequestStreaming();
   } else if (FLAGS_test_case == "server_streaming") {
-    DoResponseStreaming();
+    client.DoResponseStreaming();
   } else if (FLAGS_test_case == "slow_consumer") {
-    DoResponseStreamingWithSlowConsumer();
+    client.DoResponseStreamingWithSlowConsumer();
   } else if (FLAGS_test_case == "half_duplex") {
-    DoHalfDuplex();
+    client.DoHalfDuplex();
   } else if (FLAGS_test_case == "ping_pong") {
-    DoPingPong();
+    client.DoPingPong();
   } else if (FLAGS_test_case == "service_account_creds") {
-    DoServiceAccountCreds();
+    grpc::string json_key = GetServiceAccountJsonKey();
+    client.DoServiceAccountCreds(json_key, FLAGS_oauth_scope);
   } else if (FLAGS_test_case == "compute_engine_creds") {
-    DoComputeEngineCreds();
+    client.DoComputeEngineCreds(FLAGS_default_service_account,
+                                FLAGS_oauth_scope);
   } else if (FLAGS_test_case == "jwt_token_creds") {
-    DoJwtTokenCreds();
+    grpc::string json_key = GetServiceAccountJsonKey();
+    client.DoJwtTokenCreds(json_key);
   } else if (FLAGS_test_case == "all") {
-    DoEmpty();
-    DoLargeUnary();
-    DoRequestStreaming();
-    DoResponseStreaming();
-    DoHalfDuplex();
-    DoPingPong();
+    client.DoEmpty();
+    client.DoLargeUnary();
+    client.DoRequestStreaming();
+    client.DoResponseStreaming();
+    client.DoHalfDuplex();
+    client.DoPingPong();
     // service_account_creds and jwt_token_creds can only run with ssl.
     if (FLAGS_enable_ssl) {
-      DoServiceAccountCreds();
-      DoJwtTokenCreds();
+      grpc::string json_key = GetServiceAccountJsonKey();
+      client.DoServiceAccountCreds(json_key, FLAGS_oauth_scope);
+      client.DoJwtTokenCreds(json_key);
     }
     // compute_engine_creds only runs in GCE.
   } else {
@@ -470,6 +133,7 @@ int main(int argc, char** argv) {
         "service_account_creds|compute_engine_creds|jwt_token_creds",
         FLAGS_test_case.c_str());
   }
+  client.Reset(nullptr);
 
   grpc_shutdown();
   return 0;

test/cpp/interop/client_helper.cc

@@ -0,0 +1,119 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/cpp/interop/client_helper.h"
+
+#include <fstream>
+#include <memory>
+#include <sstream>
+
+#include <unistd.h>
+
+#include <grpc/grpc.h>
+#include <grpc/support/log.h>
+#include <gflags/gflags.h>
+#include <grpc++/channel_arguments.h>
+#include <grpc++/channel_interface.h>
+#include <grpc++/create_channel.h>
+#include <grpc++/credentials.h>
+#include <grpc++/stream.h>
+#include "test/cpp/util/create_test_channel.h"
+
+DECLARE_bool(enable_ssl);
+DECLARE_bool(use_prod_roots);
+DECLARE_int32(server_port);
+DECLARE_string(server_host);
+DECLARE_string(server_host_override);
+DECLARE_string(test_case);
+DECLARE_string(default_service_account);
+DECLARE_string(service_account_key_file);
+DECLARE_string(oauth_scope);
+
+// In some distros, gflags is in the namespace google, and in some others,
+// in gflags. This hack is enabling us to find both.
+namespace google {}
+namespace gflags {}
+using namespace google;
+using namespace gflags;
+
+namespace grpc {
+namespace testing {
+
+grpc::string GetServiceAccountJsonKey() {
+  static grpc::string json_key;
+  if (json_key.empty()) {
+    std::ifstream json_key_file(FLAGS_service_account_key_file);
+    std::stringstream key_stream;
+    key_stream << json_key_file.rdbuf();
+    json_key = key_stream.str();
+  }
+  return json_key;
+}
+
+std::shared_ptr<ChannelInterface> CreateChannelForTestCase(
+    const grpc::string& test_case) {
+  GPR_ASSERT(FLAGS_server_port);
+  const int host_port_buf_size = 1024;
+  char host_port[host_port_buf_size];
+  snprintf(host_port, host_port_buf_size, "%s:%d", FLAGS_server_host.c_str(),
+           FLAGS_server_port);
+
+  if (test_case == "service_account_creds") {
+    std::unique_ptr<Credentials> creds;
+    GPR_ASSERT(FLAGS_enable_ssl);
+    grpc::string json_key = GetServiceAccountJsonKey();
+    creds = ServiceAccountCredentials(json_key, FLAGS_oauth_scope,
+                                      std::chrono::hours(1));
+    return CreateTestChannel(host_port, FLAGS_server_host_override,
+                             FLAGS_enable_ssl, FLAGS_use_prod_roots, creds);
+  } else if (test_case == "compute_engine_creds") {
+    std::unique_ptr<Credentials> creds;
+    GPR_ASSERT(FLAGS_enable_ssl);
+    creds = ComputeEngineCredentials();
+    return CreateTestChannel(host_port, FLAGS_server_host_override,
+                             FLAGS_enable_ssl, FLAGS_use_prod_roots, creds);
+  } else if (test_case == "jwt_token_creds") {
+    std::unique_ptr<Credentials> creds;
+    GPR_ASSERT(FLAGS_enable_ssl);
+    grpc::string json_key = GetServiceAccountJsonKey();
+    creds = JWTCredentials(json_key, std::chrono::hours(1));
+    return CreateTestChannel(host_port, FLAGS_server_host_override,
+                             FLAGS_enable_ssl, FLAGS_use_prod_roots, creds);
+  } else {
+    return CreateTestChannel(host_port, FLAGS_server_host_override,
+                             FLAGS_enable_ssl, FLAGS_use_prod_roots);
+  }
+}
+
+}  // namespace testing
+}  // namespace grpc

test/cpp/interop/client_helper.h

@@ -31,23 +31,23 @@
  *
  */
 
-#ifndef GRPC_RB_EVENT_H_
-#define GRPC_RB_EVENT_H_
+#ifndef GRPC_TEST_CPP_INTEROP_CLIENT_HELPER_H
+#define GRPC_TEST_CPP_INTEROP_CLIENT_HELPER_H
 
-#include <ruby.h>
-#include <grpc/grpc.h>
+#include <memory>
 
-/* grpc_cEvent is the Event class whose instances proxy grpc_event. */
-extern VALUE grpc_cEvent;
+#include <grpc++/config.h>
+#include <grpc++/channel_interface.h>
 
-/* grpc_eEventError is the ruby class that acts the exception thrown during rpc
-   event processing. */
-extern VALUE grpc_eEventError;
+namespace grpc {
+namespace testing {
 
-/* Used to create new ruby event objects */
-VALUE grpc_rb_new_event(grpc_event *ev);
+grpc::string GetServiceAccountJsonKey();
 
-/* Initializes the Event and EventError classes. */
-void Init_grpc_event();
+std::shared_ptr<ChannelInterface> CreateChannelForTestCase(
+    const grpc::string& test_case);
 
-#endif /* GRPC_RB_EVENT_H_ */
+}  // namespace testing
+}  // namespace grpc
+
+#endif  // GRPC_TEST_CPP_INTEROP_CLIENT_HELPER_H

test/cpp/interop/interop_client.cc

@@ -0,0 +1,311 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/cpp/interop/interop_client.h"
+
+#include <memory>
+
+#include <unistd.h>
+
+#include <grpc/grpc.h>
+#include <grpc/support/log.h>
+#include <grpc++/channel_interface.h>
+#include <grpc++/client_context.h>
+#include <grpc++/status.h>
+#include <grpc++/stream.h>
+#include "test/cpp/interop/test.grpc.pb.h"
+#include "test/cpp/interop/empty.grpc.pb.h"
+#include "test/cpp/interop/messages.grpc.pb.h"
+
+namespace grpc {
+namespace testing {
+
+namespace {
+// The same value is defined by the Java client.
+const std::vector<int> request_stream_sizes = {27182, 8, 1828, 45904};
+const std::vector<int> response_stream_sizes = {31415, 9, 2653, 58979};
+const int kNumResponseMessages = 2000;
+const int kResponseMessageSize = 1030;
+const int kReceiveDelayMilliSeconds = 20;
+const int kLargeRequestSize = 314159;
+const int kLargeResponseSize = 271812;
+}  // namespace
+
+InteropClient::InteropClient(std::shared_ptr<ChannelInterface> channel)
+    : channel_(channel) {}
+
+void InteropClient::AssertOkOrPrintErrorStatus(const Status& s) {
+  if (s.IsOk()) {
+    return;
+  }
+  gpr_log(GPR_INFO, "Error status code: %d, message: %s", s.code(),
+          s.details().c_str());
+  GPR_ASSERT(0);
+}
+
+void InteropClient::DoEmpty() {
+  gpr_log(GPR_INFO, "Sending an empty rpc...");
+  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_));
+
+  Empty request = Empty::default_instance();
+  Empty response = Empty::default_instance();
+  ClientContext context;
+
+  Status s = stub->EmptyCall(&context, request, &response);
+  AssertOkOrPrintErrorStatus(s);
+
+  gpr_log(GPR_INFO, "Empty rpc done.");
+}
+
+// Shared code to set large payload, make rpc and check response payload.
+void InteropClient::PerformLargeUnary(SimpleRequest* request,
+                                      SimpleResponse* response) {
+  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_));
+
+  ClientContext context;
+  request->set_response_type(PayloadType::COMPRESSABLE);
+  request->set_response_size(kLargeResponseSize);
+  grpc::string payload(kLargeRequestSize, '\0');
+  request->mutable_payload()->set_body(payload.c_str(), kLargeRequestSize);
+
+  Status s = stub->UnaryCall(&context, *request, response);
+
+  AssertOkOrPrintErrorStatus(s);
+  GPR_ASSERT(response->payload().type() == PayloadType::COMPRESSABLE);
+  GPR_ASSERT(response->payload().body() ==
+             grpc::string(kLargeResponseSize, '\0'));
+}
+
+void InteropClient::DoComputeEngineCreds(
+    const grpc::string& default_service_account,
+    const grpc::string& oauth_scope) {
+  gpr_log(GPR_INFO,
+          "Sending a large unary rpc with compute engine credentials ...");
+  SimpleRequest request;
+  SimpleResponse response;
+  request.set_fill_username(true);
+  request.set_fill_oauth_scope(true);
+  PerformLargeUnary(&request, &response);
+  gpr_log(GPR_INFO, "Got username %s", response.username().c_str());
+  gpr_log(GPR_INFO, "Got oauth_scope %s", response.oauth_scope().c_str());
+  GPR_ASSERT(!response.username().empty());
+  GPR_ASSERT(response.username().c_str() == default_service_account);
+  GPR_ASSERT(!response.oauth_scope().empty());
+  const char* oauth_scope_str = response.oauth_scope().c_str();
+  GPR_ASSERT(oauth_scope.find(oauth_scope_str) != grpc::string::npos);
+  gpr_log(GPR_INFO, "Large unary with compute engine creds done.");
+}
+
+void InteropClient::DoServiceAccountCreds(const grpc::string& username,
+                                          const grpc::string& oauth_scope) {
+  gpr_log(GPR_INFO,
+          "Sending a large unary rpc with service account credentials ...");
+  SimpleRequest request;
+  SimpleResponse response;
+  request.set_fill_username(true);
+  request.set_fill_oauth_scope(true);
+  PerformLargeUnary(&request, &response);
+  GPR_ASSERT(!response.username().empty());
+  GPR_ASSERT(!response.oauth_scope().empty());
+  GPR_ASSERT(username.find(response.username()) != grpc::string::npos);
+  const char* oauth_scope_str = response.oauth_scope().c_str();
+  GPR_ASSERT(oauth_scope.find(oauth_scope_str) != grpc::string::npos);
+  gpr_log(GPR_INFO, "Large unary with service account creds done.");
+}
+
+void InteropClient::DoJwtTokenCreds(const grpc::string& username) {
+  gpr_log(GPR_INFO, "Sending a large unary rpc with JWT token credentials ...");
+  SimpleRequest request;
+  SimpleResponse response;
+  request.set_fill_username(true);
+  PerformLargeUnary(&request, &response);
+  GPR_ASSERT(!response.username().empty());
+  GPR_ASSERT(username.find(response.username()) != grpc::string::npos);
+  gpr_log(GPR_INFO, "Large unary with JWT token creds done.");
+}
+
+void InteropClient::DoLargeUnary() {
+  gpr_log(GPR_INFO, "Sending a large unary rpc...");
+  SimpleRequest request;
+  SimpleResponse response;
+  PerformLargeUnary(&request, &response);
+  gpr_log(GPR_INFO, "Large unary done.");
+}
+
+void InteropClient::DoRequestStreaming() {
+  gpr_log(GPR_INFO, "Sending request steaming rpc ...");
+  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_));
+
+  ClientContext context;
+  StreamingInputCallRequest request;
+  StreamingInputCallResponse response;
+
+  std::unique_ptr<ClientWriter<StreamingInputCallRequest>> stream(
+      stub->StreamingInputCall(&context, &response));
+
+  int aggregated_payload_size = 0;
+  for (unsigned int i = 0; i < request_stream_sizes.size(); ++i) {
+    Payload* payload = request.mutable_payload();
+    payload->set_body(grpc::string(request_stream_sizes[i], '\0'));
+    GPR_ASSERT(stream->Write(request));
+    aggregated_payload_size += request_stream_sizes[i];
+  }
+  stream->WritesDone();
+  Status s = stream->Finish();
+
+  GPR_ASSERT(response.aggregated_payload_size() == aggregated_payload_size);
+  AssertOkOrPrintErrorStatus(s);
+  gpr_log(GPR_INFO, "Request streaming done.");
+}
+
+void InteropClient::DoResponseStreaming() {
+  gpr_log(GPR_INFO, "Receiving response steaming rpc ...");
+  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_));
+
+  ClientContext context;
+  StreamingOutputCallRequest request;
+  for (unsigned int i = 0; i < response_stream_sizes.size(); ++i) {
+    ResponseParameters* response_parameter = request.add_response_parameters();
+    response_parameter->set_size(response_stream_sizes[i]);
+  }
+  StreamingOutputCallResponse response;
+  std::unique_ptr<ClientReader<StreamingOutputCallResponse>> stream(
+      stub->StreamingOutputCall(&context, request));
+
+  unsigned int i = 0;
+  while (stream->Read(&response)) {
+    GPR_ASSERT(response.payload().body() ==
+               grpc::string(response_stream_sizes[i], '\0'));
+    ++i;
+  }
+  GPR_ASSERT(response_stream_sizes.size() == i);
+  Status s = stream->Finish();
+
+  AssertOkOrPrintErrorStatus(s);
+  gpr_log(GPR_INFO, "Response streaming done.");
+}
+
+void InteropClient::DoResponseStreamingWithSlowConsumer() {
+  gpr_log(GPR_INFO, "Receiving response steaming rpc with slow consumer ...");
+  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_));
+
+  ClientContext context;
+  StreamingOutputCallRequest request;
+
+  for (int i = 0; i < kNumResponseMessages; ++i) {
+    ResponseParameters* response_parameter = request.add_response_parameters();
+    response_parameter->set_size(kResponseMessageSize);
+  }
+  StreamingOutputCallResponse response;
+  std::unique_ptr<ClientReader<StreamingOutputCallResponse>> stream(
+      stub->StreamingOutputCall(&context, request));
+
+  int i = 0;
+  while (stream->Read(&response)) {
+    GPR_ASSERT(response.payload().body() ==
+               grpc::string(kResponseMessageSize, '\0'));
+    gpr_log(GPR_INFO, "received message %d", i);
+    usleep(kReceiveDelayMilliSeconds * 1000);
+    ++i;
+  }
+  GPR_ASSERT(kNumResponseMessages == i);
+  Status s = stream->Finish();
+
+  AssertOkOrPrintErrorStatus(s);
+  gpr_log(GPR_INFO, "Response streaming done.");
+}
+
+void InteropClient::DoHalfDuplex() {
+  gpr_log(GPR_INFO, "Sending half-duplex streaming rpc ...");
+  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_));
+
+  ClientContext context;
+  std::unique_ptr<ClientReaderWriter<StreamingOutputCallRequest,
+                                     StreamingOutputCallResponse>>
+      stream(stub->HalfDuplexCall(&context));
+
+  StreamingOutputCallRequest request;
+  ResponseParameters* response_parameter = request.add_response_parameters();
+  for (unsigned int i = 0; i < response_stream_sizes.size(); ++i) {
+    response_parameter->set_size(response_stream_sizes[i]);
+    GPR_ASSERT(stream->Write(request));
+  }
+  stream->WritesDone();
+
+  unsigned int i = 0;
+  StreamingOutputCallResponse response;
+  while (stream->Read(&response)) {
+    GPR_ASSERT(response.payload().has_body());
+    GPR_ASSERT(response.payload().body() ==
+               grpc::string(response_stream_sizes[i], '\0'));
+    ++i;
+  }
+  GPR_ASSERT(response_stream_sizes.size() == i);
+  Status s = stream->Finish();
+  AssertOkOrPrintErrorStatus(s);
+  gpr_log(GPR_INFO, "Half-duplex streaming rpc done.");
+}
+
+void InteropClient::DoPingPong() {
+  gpr_log(GPR_INFO, "Sending Ping Pong streaming rpc ...");
+  std::unique_ptr<TestService::Stub> stub(TestService::NewStub(channel_));
+
+  ClientContext context;
+  std::unique_ptr<ClientReaderWriter<StreamingOutputCallRequest,
+                                     StreamingOutputCallResponse>>
+      stream(stub->FullDuplexCall(&context));
+
+  StreamingOutputCallRequest request;
+  request.set_response_type(PayloadType::COMPRESSABLE);
+  ResponseParameters* response_parameter = request.add_response_parameters();
+  Payload* payload = request.mutable_payload();
+  StreamingOutputCallResponse response;
+  for (unsigned int i = 0; i < request_stream_sizes.size(); ++i) {
+    response_parameter->set_size(response_stream_sizes[i]);
+    payload->set_body(grpc::string(request_stream_sizes[i], '\0'));
+    GPR_ASSERT(stream->Write(request));
+    GPR_ASSERT(stream->Read(&response));
+    GPR_ASSERT(response.payload().has_body());
+    GPR_ASSERT(response.payload().body() ==
+               grpc::string(response_stream_sizes[i], '\0'));
+  }
+
+  stream->WritesDone();
+  GPR_ASSERT(!stream->Read(&response));
+  Status s = stream->Finish();
+  AssertOkOrPrintErrorStatus(s);
+  gpr_log(GPR_INFO, "Ping pong streaming done.");
+}
+
+}  // namespace testing
+}  // namespace grpc

test/cpp/interop/interop_client.h

@@ -0,0 +1,79 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_TEST_CPP_INTEROP_INTEROP_CLIENT_H
+#define GRPC_TEST_CPP_INTEROP_INTEROP_CLIENT_H
+#include <memory>
+
+#include <grpc/grpc.h>
+#include <grpc++/channel_interface.h>
+#include <grpc++/status.h>
+#include "test/cpp/interop/messages.grpc.pb.h"
+
+namespace grpc {
+namespace testing {
+
+class InteropClient {
+ public:
+  explicit InteropClient(std::shared_ptr<ChannelInterface> channel);
+  ~InteropClient() {}
+
+  void Reset(std::shared_ptr<ChannelInterface> channel) { channel_ = channel; }
+
+  void DoEmpty();
+  void DoLargeUnary();
+  void DoPingPong();
+  void DoHalfDuplex();
+  void DoRequestStreaming();
+  void DoResponseStreaming();
+  void DoResponseStreamingWithSlowConsumer();
+  // Auth tests.
+  // username is a string containing the user email
+  void DoJwtTokenCreds(const grpc::string& username);
+  void DoComputeEngineCreds(const grpc::string& default_service_account,
+                            const grpc::string& oauth_scope);
+  // username is a string containing the user email
+  void DoServiceAccountCreds(const grpc::string& username,
+                             const grpc::string& oauth_scope);
+
+ private:
+  void PerformLargeUnary(SimpleRequest* request, SimpleResponse* response);
+  void AssertOkOrPrintErrorStatus(const Status& s);
+
+  std::shared_ptr<ChannelInterface> channel_;
+};
+
+}  // namespace testing
+}  // namespace grpc
+
+#endif  // GRPC_TEST_CPP_INTEROP_INTEROP_CLIENT_H

test/cpp/interop/server.cc

@@ -41,7 +41,6 @@
 #include <gflags/gflags.h>
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
-#include "test/core/end2end/data/ssl_test_data.h"
 #include <grpc++/config.h>
 #include <grpc++/server.h>
 #include <grpc++/server_builder.h>
@@ -52,6 +51,7 @@
 #include "test/cpp/interop/test.grpc.pb.h"
 #include "test/cpp/interop/empty.grpc.pb.h"
 #include "test/cpp/interop/messages.grpc.pb.h"
+#include "test/cpp/interop/server_helper.h"
 
 DEFINE_bool(enable_ssl, false, "Whether to use ssl/tls.");
 DEFINE_int32(port, 0, "Server port.");
@@ -211,15 +211,8 @@ void RunServer() {
 
   ServerBuilder builder;
   builder.RegisterService(&service);
-  std::shared_ptr<ServerCredentials> creds = grpc::InsecureServerCredentials();
-  if (FLAGS_enable_ssl) {
-    SslServerCredentialsOptions::PemKeyCertPair pkcp = {test_server1_key,
-							test_server1_cert};
-    SslServerCredentialsOptions ssl_opts;
-    ssl_opts.pem_root_certs = "";
-    ssl_opts.pem_key_cert_pairs.push_back(pkcp);
-    creds = grpc::SslServerCredentials(ssl_opts);
-  }
+  std::shared_ptr<ServerCredentials> creds =
+      grpc::testing::CreateInteropServerCredentials();
   builder.AddListeningPort(server_address.str(), creds);
   std::unique_ptr<Server> server(builder.BuildAndStart());
   gpr_log(GPR_INFO, "Server listening on %s", server_address.str().c_str());

test/cpp/interop/server_helper.cc

@@ -0,0 +1,69 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/cpp/interop/server_helper.h"
+
+#include <memory>
+
+#include <gflags/gflags.h>
+#include "test/core/end2end/data/ssl_test_data.h"
+#include <grpc++/config.h>
+#include <grpc++/server_credentials.h>
+
+DECLARE_bool(enable_ssl);
+
+// In some distros, gflags is in the namespace google, and in some others,
+// in gflags. This hack is enabling us to find both.
+namespace google {}
+namespace gflags {}
+using namespace google;
+using namespace gflags;
+
+namespace grpc {
+namespace testing {
+
+std::shared_ptr<ServerCredentials> CreateInteropServerCredentials() {
+  if (FLAGS_enable_ssl) {
+    SslServerCredentialsOptions::PemKeyCertPair pkcp = {test_server1_key,
+                                                        test_server1_cert};
+    SslServerCredentialsOptions ssl_opts;
+    ssl_opts.pem_root_certs = "";
+    ssl_opts.pem_key_cert_pairs.push_back(pkcp);
+    return SslServerCredentials(ssl_opts);
+  } else {
+    return InsecureServerCredentials();
+  }
+}
+
+}  // namespace testing
+}  // namespace grpc

test/cpp/interop/server_helper.h

@@ -31,23 +31,19 @@
  *
  */
 
-#ifndef GRPC_RB_METADATA_H_
-#define GRPC_RB_METADATA_H_
+#ifndef GRPC_TEST_CPP_INTEROP_SERVER_HELPER_H
+#define GRPC_TEST_CPP_INTEROP_SERVER_HELPER_H
 
-#include <grpc/grpc.h>
-#include <ruby.h>
+#include <memory>
 
-/* grpc_cMetadata is the Metadata class whose instances proxy grpc_metadata. */
-extern VALUE grpc_cMetadata;
+#include <grpc++/server_credentials.h>
 
-/* grpc_rb_metadata_create_with_mark creates a grpc_rb_metadata with a ruby mark
- * object that will be kept alive while the metadata is alive. */
-extern VALUE grpc_rb_metadata_create_with_mark(VALUE mark, grpc_metadata* md);
+namespace grpc {
+namespace testing {
 
-/* Gets the wrapped metadata from the ruby wrapper */
-grpc_metadata* grpc_rb_get_wrapped_metadata(VALUE v);
+std::shared_ptr<ServerCredentials> CreateInteropServerCredentials();
 
-/* Initializes the Metadata class. */
-void Init_grpc_metadata();
+}  // namespace testing
+}  // namespace grpc
 
-#endif /* GRPC_RB_METADATA_H_ */
+#endif  // GRPC_TEST_CPP_INTEROP_SERVER_HELPER_H

test/cpp/qps/client.h

@@ -104,7 +104,7 @@ class Client {
 
   void EndThreads() { threads_.clear(); }
 
-  virtual void ThreadFunc(Histogram* histogram, size_t thread_idx) = 0;
+  virtual bool ThreadFunc(Histogram* histogram, size_t thread_idx) = 0;
 
  private:
   class Thread {
@@ -113,20 +113,24 @@ class Client {
         : done_(false),
           new_(nullptr),
           impl_([this, idx, client]() {
-            for (;;) {
-              // run the loop body
-	      client->ThreadFunc(&histogram_, idx);
-              // lock, see if we're done
-              std::lock_guard<std::mutex> g(mu_);
-              if (done_) {return;}
-	      // check if we're marking, swap out the histogram if so
-	      if (new_) {
-                new_->Swap(&histogram_);
-                new_ = nullptr;
-                cv_.notify_one();
+              for (;;) {
+                // run the loop body
+        	      bool thread_still_ok = client->ThreadFunc(&histogram_, idx);
+                // lock, see if we're done
+                std::lock_guard<std::mutex> g(mu_);
+                if (!thread_still_ok) {
+                  gpr_log(GPR_ERROR, "Finishing client thread due to RPC error");
+                  done_ = true;
+                }
+                if (done_) {return;}
+        	      // check if we're marking, swap out the histogram if so
+        	      if (new_) {
+                        new_->Swap(&histogram_);
+                        new_ = nullptr;
+                        cv_.notify_one();
+                }
               }
-            }
-          }) {}
+            }) {}
 
     ~Thread() {
       {

test/cpp/qps/client_async.cc

@@ -137,13 +137,7 @@ class AsyncUnaryClient GRPC_FINAL : public Client {
       cli_cqs_.emplace_back(new CompletionQueue);
     }
 
-    auto payload_size = config.payload_size();
-    auto check_done = [payload_size](grpc::Status s, SimpleResponse* response) {
-      GPR_ASSERT(s.IsOk() && (response->payload().type() ==
-                              grpc::testing::PayloadType::COMPRESSABLE) &&
-                 (response->payload().body().length() ==
-                  static_cast<size_t>(payload_size)));
-    };
+    auto check_done = [](grpc::Status s, SimpleResponse* response) {};
 
     int t = 0;
     for (int i = 0; i < config.outstanding_rpcs_per_channel(); i++) {
@@ -179,10 +173,14 @@ class AsyncUnaryClient GRPC_FINAL : public Client {
     }
   }
 
-  void ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
+  bool ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
     void* got_tag;
     bool ok;
-    cli_cqs_[thread_idx]->Next(&got_tag, &ok);
+    switch (cli_cqs_[thread_idx]->AsyncNext(&got_tag, &ok, std::chrono::system_clock::now() + std::chrono::seconds(1))) {
+      case CompletionQueue::SHUTDOWN: return false;
+      case CompletionQueue::TIMEOUT: return true;
+      case CompletionQueue::GOT_EVENT: break;
+    }
 
     ClientRpcContext* ctx = ClientRpcContext::detag(got_tag);
     if (ctx->RunNextState(ok, histogram) == false) {
@@ -191,6 +189,8 @@ class AsyncUnaryClient GRPC_FINAL : public Client {
       ctx->StartNewClone();
       delete ctx;
     }
+
+    return true;
   }
 
   std::vector<std::unique_ptr<CompletionQueue>> cli_cqs_;
@@ -270,13 +270,7 @@ class AsyncStreamingClient GRPC_FINAL : public Client {
       cli_cqs_.emplace_back(new CompletionQueue);
     }
 
-    auto payload_size = config.payload_size();
-    auto check_done = [payload_size](grpc::Status s, SimpleResponse *response) {
-      GPR_ASSERT(s.IsOk() && (response->payload().type() ==
-                              grpc::testing::PayloadType::COMPRESSABLE) &&
-                 (response->payload().body().length() ==
-                  static_cast<size_t>(payload_size)));
-    };
+    auto check_done = [](grpc::Status s, SimpleResponse* response) {};
 
     int t = 0;
     for (int i = 0; i < config.outstanding_rpcs_per_channel(); i++) {
@@ -313,10 +307,14 @@ class AsyncStreamingClient GRPC_FINAL : public Client {
     }
   }
 
-  void ThreadFunc(Histogram *histogram, size_t thread_idx) GRPC_OVERRIDE {
+  bool ThreadFunc(Histogram *histogram, size_t thread_idx) GRPC_OVERRIDE {
     void *got_tag;
     bool ok;
-    cli_cqs_[thread_idx]->Next(&got_tag, &ok);
+    switch (cli_cqs_[thread_idx]->AsyncNext(&got_tag, &ok, std::chrono::system_clock::now() + std::chrono::seconds(1))) {
+      case CompletionQueue::SHUTDOWN: return false;
+      case CompletionQueue::TIMEOUT: return true;
+      case CompletionQueue::GOT_EVENT: break;
+    }
 
     ClientRpcContext *ctx = ClientRpcContext::detag(got_tag);
     if (ctx->RunNextState(ok, histogram) == false) {
@@ -325,6 +323,8 @@ class AsyncStreamingClient GRPC_FINAL : public Client {
       ctx->StartNewClone();
       delete ctx;
     }
+
+    return true;
   }
 
   std::vector<std::unique_ptr<CompletionQueue>> cli_cqs_;

test/cpp/qps/client_sync.cc

@@ -83,13 +83,14 @@ class SynchronousUnaryClient GRPC_FINAL : public SynchronousClient {
     SynchronousClient(config) {StartThreads(num_threads_);}
   ~SynchronousUnaryClient() {}
   
-  void ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
+  bool ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
     auto* stub = channels_[thread_idx % channels_.size()].get_stub();
     double start = Timer::Now();
     grpc::ClientContext context;
     grpc::Status s =
         stub->UnaryCall(&context, request_, &responses_[thread_idx]);
     histogram->Add((Timer::Now() - start) * 1e9);
+    return s.IsOk();
   }
 };
 
@@ -111,11 +112,13 @@ class SynchronousStreamingClient GRPC_FINAL : public SynchronousClient {
     }
   }
 
-  void ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
+  bool ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
     double start = Timer::Now();
-    EXPECT_TRUE(stream_->Write(request_));
-    EXPECT_TRUE(stream_->Read(&responses_[thread_idx]));
-    histogram->Add((Timer::Now() - start) * 1e9);
+    if (stream_->Write(request_) && stream_->Read(&responses_[thread_idx])) {
+      histogram->Add((Timer::Now() - start) * 1e9);
+      return true;
+    }
+    return false;
   }
   private:
     grpc::ClientContext context_;

test/cpp/qps/histogram.h

@@ -50,10 +50,10 @@ class Histogram {
 
   void Merge(Histogram* h) { gpr_histogram_merge(impl_, h->impl_); }
   void Add(double value) { gpr_histogram_add(impl_, value); }
-  double Percentile(double pctile) {
+  double Percentile(double pctile) const {
     return gpr_histogram_percentile(impl_, pctile);
   }
-  double Count() { return gpr_histogram_count(impl_); }
+  double Count() const { return gpr_histogram_count(impl_); }
   void Swap(Histogram* other) { std::swap(impl_, other->impl_); }
   void FillProto(HistogramData* p) {
     size_t n;

test/cpp/qps/qps_driver.cc

@@ -35,7 +35,7 @@
 #include <grpc/support/log.h>
 
 #include "test/cpp/qps/driver.h"
-#include "test/cpp/qps/stats.h"
+#include "test/cpp/qps/report.h"
 
 DEFINE_int32(num_clients, 1, "Number of client binaries");
 DEFINE_int32(num_servers, 1, "Number of server binaries");
@@ -65,7 +65,6 @@ using grpc::testing::ClientType;
 using grpc::testing::ServerType;
 using grpc::testing::RpcType;
 using grpc::testing::ResourceUsage;
-using grpc::testing::sum;
 
 // In some distros, gflags is in the namespace google, and in some others,
 // in gflags. This hack is enabling us to find both.
@@ -105,37 +104,9 @@ int main(int argc, char** argv) {
                             server_config, FLAGS_num_servers,
                             FLAGS_warmup_seconds, FLAGS_benchmark_seconds);
 
-  gpr_log(GPR_INFO, "QPS: %.1f",
-          result.latencies.Count() /
-              average(result.client_resources,
-                      [](ResourceUsage u) { return u.wall_time; }));
-
-  gpr_log(GPR_INFO, "Latencies (50/95/99/99.9%%-ile): %.1f/%.1f/%.1f/%.1f us",
-          result.latencies.Percentile(50) / 1000,
-          result.latencies.Percentile(95) / 1000,
-          result.latencies.Percentile(99) / 1000,
-          result.latencies.Percentile(99.9) / 1000);
-
-  gpr_log(GPR_INFO, "Server system time: %.2f%%",
-          100.0 * sum(result.server_resources,
-                      [](ResourceUsage u) { return u.system_time; }) /
-              sum(result.server_resources,
-                  [](ResourceUsage u) { return u.wall_time; }));
-  gpr_log(GPR_INFO, "Server user time:   %.2f%%",
-          100.0 * sum(result.server_resources,
-                      [](ResourceUsage u) { return u.user_time; }) /
-              sum(result.server_resources,
-                  [](ResourceUsage u) { return u.wall_time; }));
-  gpr_log(GPR_INFO, "Client system time: %.2f%%",
-          100.0 * sum(result.client_resources,
-                      [](ResourceUsage u) { return u.system_time; }) /
-              sum(result.client_resources,
-                  [](ResourceUsage u) { return u.wall_time; }));
-  gpr_log(GPR_INFO, "Client user time:   %.2f%%",
-          100.0 * sum(result.client_resources,
-                      [](ResourceUsage u) { return u.user_time; }) /
-              sum(result.client_resources,
-                  [](ResourceUsage u) { return u.wall_time; }));
+  ReportQPSPerCore(result, server_config);
+  ReportLatency(result);
+  ReportTimes(result);
 
   grpc_shutdown();
   return 0;

test/cpp/qps/report.cc

@@ -0,0 +1,94 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/cpp/qps/report.h"
+
+#include <grpc/support/log.h>
+#include "test/cpp/qps/stats.h"
+
+namespace grpc {
+namespace testing {
+
+// QPS: XXX
+void ReportQPS(const ScenarioResult& result) {
+  gpr_log(GPR_INFO, "QPS: %.1f",
+          result.latencies.Count() /
+              average(result.client_resources,
+                      [](ResourceUsage u) { return u.wall_time; }));
+}
+
+// QPS: XXX (YYY/server core)
+void ReportQPSPerCore(const ScenarioResult& result, const ServerConfig& server_config) {
+  auto qps = 
+      result.latencies.Count() /
+      average(result.client_resources,
+          [](ResourceUsage u) { return u.wall_time; });
+
+  gpr_log(GPR_INFO, "QPS: %.1f (%.1f/server core)", qps, qps/server_config.threads());
+}
+
+// Latency (50/90/95/99/99.9%-ile): AA/BB/CC/DD/EE us
+void ReportLatency(const ScenarioResult& result) {
+  gpr_log(GPR_INFO, "Latencies (50/90/95/99/99.9%%-ile): %.1f/%.1f/%.1f/%.1f/%.1f us",
+          result.latencies.Percentile(50) / 1000,
+          result.latencies.Percentile(90) / 1000,
+          result.latencies.Percentile(95) / 1000,
+          result.latencies.Percentile(99) / 1000,
+          result.latencies.Percentile(99.9) / 1000);
+}
+
+void ReportTimes(const ScenarioResult& result) {
+  gpr_log(GPR_INFO, "Server system time: %.2f%%",
+          100.0 * sum(result.server_resources,
+                      [](ResourceUsage u) { return u.system_time; }) /
+              sum(result.server_resources,
+                  [](ResourceUsage u) { return u.wall_time; }));
+  gpr_log(GPR_INFO, "Server user time:   %.2f%%",
+          100.0 * sum(result.server_resources,
+                      [](ResourceUsage u) { return u.user_time; }) /
+              sum(result.server_resources,
+                  [](ResourceUsage u) { return u.wall_time; }));
+  gpr_log(GPR_INFO, "Client system time: %.2f%%",
+          100.0 * sum(result.client_resources,
+                      [](ResourceUsage u) { return u.system_time; }) /
+              sum(result.client_resources,
+                  [](ResourceUsage u) { return u.wall_time; }));
+  gpr_log(GPR_INFO, "Client user time:   %.2f%%",
+          100.0 * sum(result.client_resources,
+                      [](ResourceUsage u) { return u.user_time; }) /
+              sum(result.client_resources,
+                  [](ResourceUsage u) { return u.wall_time; }));
+}
+
+}  // namespace testing
+}  // namespace grpc

test/cpp/qps/report.h

@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef TEST_QPS_REPORT_H
+#define TEST_QPS_REPORT_H
+
+#include "test/cpp/qps/driver.h"
+
+namespace grpc {
+namespace testing {
+
+// QPS: XXX
+void ReportQPS(const ScenarioResult& result);
+// QPS: XXX (YYY/server core)
+void ReportQPSPerCore(const ScenarioResult& result, const ServerConfig& config);
+// Latency (50/90/95/99/99.9%-ile): AA/BB/CC/DD/EE us
+void ReportLatency(const ScenarioResult& result);
+// Server system time: XX%
+// Server user time: XX%
+// Client system time: XX%
+// Client user time: XX%
+void ReportTimes(const ScenarioResult& result);
+
+}  // namespace testing
+}  // namespace grpc
+
+#endif

test/cpp/qps/server_async.cc

@@ -97,15 +97,15 @@ class AsyncQpsServerTest : public Server {
         bool ok;
         void* got_tag;
         while (srv_cq_.Next(&got_tag, &ok)) {
-	  ServerRpcContext* ctx = detag(got_tag);
-	  // The tag is a pointer to an RPC context to invoke
-	  if (ctx->RunNextState(ok) == false) {
-	    // this RPC context is done, so refresh it
+          ServerRpcContext* ctx = detag(got_tag);
+          // The tag is a pointer to an RPC context to invoke
+          if (ctx->RunNextState(ok) == false) {
+            // this RPC context is done, so refresh it
             std::lock_guard<std::mutex> g(shutdown_mutex_);
             if (!shutdown_) {
               ctx->Reset();
             }
-	  }
+          }
         }
         return;
       }));
@@ -175,8 +175,9 @@ class AsyncQpsServerTest : public Server {
    private:
     bool finisher(bool) { return false; }
     bool invoker(bool ok) {
-      if (!ok)
-	return false;
+      if (!ok) {
+        return false;
+      }
 
       ResponseType response;
 
@@ -230,8 +231,9 @@ class AsyncQpsServerTest : public Server {
 
    private:
     bool request_done(bool ok) {
-      if (!ok)
-	return false;
+      if (!ok) {
+        return false;
+      }
       stream_.Read(&req_, AsyncQpsServerTest::tag(this));
       next_state_ = &ServerRpcContextStreamingImpl::read_done;
       return true;

test/cpp/qps/smoke_test.cc

@@ -0,0 +1,149 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/support/log.h>
+
+#include "test/cpp/qps/driver.h"
+#include "test/cpp/qps/report.h"
+
+namespace grpc {
+namespace testing {
+
+static const int WARMUP = 5;
+static const int BENCHMARK = 10;
+
+static void RunSynchronousUnaryPingPong() {
+  gpr_log(GPR_INFO, "Running Synchronous Unary Ping Pong");
+
+  ClientConfig client_config;
+  client_config.set_client_type(SYNCHRONOUS_CLIENT);
+  client_config.set_enable_ssl(false);
+  client_config.set_outstanding_rpcs_per_channel(1);
+  client_config.set_client_channels(1);
+  client_config.set_payload_size(1);
+  client_config.set_rpc_type(UNARY);
+
+  ServerConfig server_config;
+  server_config.set_server_type(SYNCHRONOUS_SERVER);
+  server_config.set_enable_ssl(false);
+  server_config.set_threads(1);
+
+  auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK);
+
+  ReportQPS(result);
+  ReportLatency(result);
+}
+
+static void RunSynchronousStreamingPingPong() {
+  gpr_log(GPR_INFO, "Running Synchronous Streaming Ping Pong");
+
+  ClientConfig client_config;
+  client_config.set_client_type(SYNCHRONOUS_CLIENT);
+  client_config.set_enable_ssl(false);
+  client_config.set_outstanding_rpcs_per_channel(1);
+  client_config.set_client_channels(1);
+  client_config.set_payload_size(1);
+  client_config.set_rpc_type(STREAMING);
+
+  ServerConfig server_config;
+  server_config.set_server_type(SYNCHRONOUS_SERVER);
+  server_config.set_enable_ssl(false);
+  server_config.set_threads(1);
+
+  auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK);
+
+  ReportQPS(result);
+  ReportLatency(result);
+}
+
+static void RunAsyncUnaryPingPong() {
+  gpr_log(GPR_INFO, "Running Async Unary Ping Pong");
+
+  ClientConfig client_config;
+  client_config.set_client_type(ASYNC_CLIENT);
+  client_config.set_enable_ssl(false);
+  client_config.set_outstanding_rpcs_per_channel(1);
+  client_config.set_client_channels(1);
+  client_config.set_payload_size(1);
+  client_config.set_async_client_threads(1);
+  client_config.set_rpc_type(UNARY);
+
+  ServerConfig server_config;
+  server_config.set_server_type(ASYNC_SERVER);
+  server_config.set_enable_ssl(false);
+  server_config.set_threads(1);
+
+  auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK);
+
+  ReportQPS(result);
+  ReportLatency(result);
+}
+
+static void RunQPS() {
+  gpr_log(GPR_INFO, "Running QPS test");
+
+  ClientConfig client_config;
+  client_config.set_client_type(ASYNC_CLIENT);
+  client_config.set_enable_ssl(false);
+  client_config.set_outstanding_rpcs_per_channel(1000);
+  client_config.set_client_channels(8);
+  client_config.set_payload_size(1);
+  client_config.set_async_client_threads(8);
+  client_config.set_rpc_type(UNARY);
+
+  ServerConfig server_config;
+  server_config.set_server_type(ASYNC_SERVER);
+  server_config.set_enable_ssl(false);
+  server_config.set_threads(4);
+
+  auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK);
+
+  ReportQPSPerCore(result, server_config);
+  ReportLatency(result);
+}
+
+}  // namespace testing
+}  // namespace grpc
+
+int main(int argc, char** argv) {
+  grpc_init();
+
+  using namespace grpc::testing;
+  RunSynchronousStreamingPingPong();
+  RunSynchronousUnaryPingPong();
+  RunAsyncUnaryPingPong();
+  RunQPS();
+
+  grpc_shutdown();
+  return 0;
+}

test/cpp/qps/smoke_test.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+
+# performs a single qps run with one client and one server
+
+set -ex
+
+cd $(dirname $0)/../../..
+
+killall qps_worker || true
+
+config=opt
+
+NUMCPUS=`python2.7 -c 'import multiprocessing; print multiprocessing.cpu_count()'`
+
+make CONFIG=$config qps_worker qps_smoke_test -j$NUMCPUS
+
+bins/$config/qps_worker -driver_port 10000 -server_port 10001 &
+PID1=$!
+bins/$config/qps_worker -driver_port 10010 -server_port 10011 &
+PID2=$!
+
+export QPS_WORKERS="localhost:10000,localhost:10010"
+
+bins/$config/qps_smoke_test $*
+
+kill -2 $PID1 $PID2
+wait
+

tools/buildgen/generate_projects.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 # Copyright 2015, Google Inc.
 # All rights reserved.
 #
@@ -31,7 +31,7 @@
 
 set -e
 
-if [ "x$TEST" == "x" ] ; then
+if [ "x$TEST" = "x" ] ; then
   TEST=false
 fi
 
@@ -61,12 +61,12 @@ for dir in . ; do
     out=${out%.*}  # strip template extension
     json_files="build.json $end2end_test_build"
     data=`for i in $json_files; do echo -n "-d $i "; done`
-    if [ $TEST == true ] ; then
+    if [ "x$TEST" = "xtrue" ] ; then
       actual_out=$out
       out=`mktemp /tmp/gentXXXXXX`
     fi
     $mako_renderer $plugins $data -o $out $file
-    if [ $TEST == true ] ; then
+    if [ "x$TEST" = "xtrue" ] ; then
       diff -q $out $actual_out
       rm $out
     fi

tools/dockerfile/grpc_python/Dockerfile

@@ -66,5 +66,8 @@ RUN cd /var/local/git/grpc \
 # Add a cacerts directory containing the Google root pem file, allowing the interop client to access the production test instance
 ADD cacerts cacerts
 
+# Add a service_account directory containing the auth creds file
+ADD service_account service_account
+
 # Specify the default command such that the interop server runs on its known testing port
 CMD ["/bin/bash", "-l", "-c", "python2.7 -m interop.server --use_tls --port 8050"]

tools/gce_setup/grpc_docker.sh

@@ -1047,7 +1047,7 @@ grpc_interop_gen_python_cmd() {
 #   flags= .... # generic flags to include the command
 #   cmd=$($grpc_gen_test_cmd $flags)
 grpc_cloud_prod_auth_service_account_creds_gen_python_cmd() {
-  local cmd_prefix="sudo docker run grpc/ruby bin/bash -l -c";
+  local cmd_prefix="sudo docker run grpc/python bin/bash -l -c";
   local gfe_flags=$(_grpc_prod_gfe_flags)
   local added_gfe_flags=$(_grpc_default_creds_test_flags)
   local env_prefix="SSL_CERT_FILE=/cacerts/roots.pem"
@@ -1062,7 +1062,7 @@ grpc_cloud_prod_auth_service_account_creds_gen_python_cmd() {
 #   flags= .... # generic flags to include the command
 #   cmd=$($grpc_gen_test_cmd $flags)
 grpc_cloud_prod_auth_compute_engine_creds_gen_python_cmd() {
-  local cmd_prefix="sudo docker run grpc/ruby bin/bash -l -c";
+  local cmd_prefix="sudo docker run grpc/python bin/bash -l -c";
   local gfe_flags=$(_grpc_prod_gfe_flags)
   local added_gfe_flags=$(_grpc_gce_test_flags)
   local env_prefix="SSL_CERT_FILE=/cacerts/roots.pem"

tools/gce_setup/interop_test_runner.sh

@@ -36,7 +36,7 @@ echo $result_file_name
 main() {
   source grpc_docker.sh
   test_cases=(large_unary empty_unary ping_pong client_streaming server_streaming cancel_after_begin cancel_after_first_response)
-  clients=(cxx java go ruby node python csharp_mono)
+  clients=(cxx java go ruby node python csharp_mono php)
   servers=(cxx java go ruby node python csharp_mono)
   for test_case in "${test_cases[@]}"
   do

tools/run_tests/run_tests.py

@@ -1,4 +1,4 @@
-#!/usr/bin/python2.7
+#!/usr/bin/env python
 # Copyright 2015, Google Inc.
 # All rights reserved.
 #

tools/run_tests/tests.json

@@ -176,6 +176,11 @@
     "language": "c", 
     "name": "gpr_time_test"
   }, 
+  {
+    "flaky": false, 
+    "language": "c", 
+    "name": "gpr_tls_test"
+  }, 
   {
     "flaky": false, 
     "language": "c", 

vsprojects/vs2010/Grpc.mak

@@ -53,13 +53,13 @@ grpc_test_util:
 $(OUT_DIR):
 	mkdir $(OUT_DIR)
 
-buildtests: alarm_heap_test.exe alarm_list_test.exe alarm_test.exe alpn_test.exe bin_encoder_test.exe census_hash_table_test.exe census_statistics_multiple_writers_circular_buffer_test.exe census_statistics_multiple_writers_test.exe census_statistics_performance_test.exe census_statistics_quick_test.exe census_statistics_small_log_test.exe census_stats_store_test.exe census_stub_test.exe census_trace_store_test.exe census_window_stats_test.exe chttp2_status_conversion_test.exe chttp2_stream_encoder_test.exe chttp2_stream_map_test.exe chttp2_transport_end2end_test.exe dualstack_socket_test.exe echo_test.exe fd_posix_test.exe fling_stream_test.exe fling_test.exe gpr_cancellable_test.exe gpr_cmdline_test.exe gpr_env_test.exe gpr_file_test.exe gpr_histogram_test.exe gpr_host_port_test.exe gpr_log_test.exe gpr_slice_buffer_test.exe gpr_slice_test.exe gpr_string_test.exe gpr_sync_test.exe gpr_thd_test.exe gpr_time_test.exe gpr_useful_test.exe grpc_base64_test.exe grpc_byte_buffer_reader_test.exe grpc_channel_stack_test.exe grpc_completion_queue_test.exe grpc_credentials_test.exe grpc_json_token_test.exe grpc_stream_op_test.exe hpack_parser_test.exe hpack_table_test.exe httpcli_format_request_test.exe httpcli_parser_test.exe httpcli_test.exe json_rewrite_test.exe json_test.exe lame_client_test.exe message_compress_test.exe metadata_buffer_test.exe multi_init_test.exe murmur_hash_test.exe no_server_test.exe poll_kick_posix_test.exe resolve_address_test.exe secure_endpoint_test.exe sockaddr_utils_test.exe tcp_client_posix_test.exe tcp_posix_test.exe tcp_server_posix_test.exe time_averaged_stats_test.exe time_test.exe timeout_encoding_test.exe transport_metadata_test.exe transport_security_test.exe 
+buildtests: alarm_heap_test.exe alarm_list_test.exe alarm_test.exe alpn_test.exe bin_encoder_test.exe census_hash_table_test.exe census_statistics_multiple_writers_circular_buffer_test.exe census_statistics_multiple_writers_test.exe census_statistics_performance_test.exe census_statistics_quick_test.exe census_statistics_small_log_test.exe census_stats_store_test.exe census_stub_test.exe census_trace_store_test.exe census_window_stats_test.exe chttp2_status_conversion_test.exe chttp2_stream_encoder_test.exe chttp2_stream_map_test.exe chttp2_transport_end2end_test.exe dualstack_socket_test.exe echo_test.exe fd_posix_test.exe fling_stream_test.exe fling_test.exe gpr_cancellable_test.exe gpr_cmdline_test.exe gpr_env_test.exe gpr_file_test.exe gpr_histogram_test.exe gpr_host_port_test.exe gpr_log_test.exe gpr_slice_buffer_test.exe gpr_slice_test.exe gpr_string_test.exe gpr_sync_test.exe gpr_thd_test.exe gpr_time_test.exe gpr_tls_test.exe gpr_useful_test.exe grpc_base64_test.exe grpc_byte_buffer_reader_test.exe grpc_channel_stack_test.exe grpc_completion_queue_test.exe grpc_credentials_test.exe grpc_json_token_test.exe grpc_stream_op_test.exe hpack_parser_test.exe hpack_table_test.exe httpcli_format_request_test.exe httpcli_parser_test.exe httpcli_test.exe json_rewrite_test.exe json_test.exe lame_client_test.exe message_compress_test.exe metadata_buffer_test.exe multi_init_test.exe murmur_hash_test.exe no_server_test.exe poll_kick_posix_test.exe resolve_address_test.exe secure_endpoint_test.exe sockaddr_utils_test.exe tcp_client_posix_test.exe tcp_posix_test.exe tcp_server_posix_test.exe time_averaged_stats_test.exe time_test.exe timeout_encoding_test.exe transport_metadata_test.exe transport_security_test.exe 
 	echo All tests built.
 
-test: alarm_heap_test alarm_list_test alarm_test alpn_test bin_encoder_test census_hash_table_test census_statistics_multiple_writers_circular_buffer_test census_statistics_multiple_writers_test census_statistics_performance_test census_statistics_quick_test census_statistics_small_log_test census_stats_store_test census_stub_test census_trace_store_test census_window_stats_test chttp2_status_conversion_test chttp2_stream_encoder_test chttp2_stream_map_test chttp2_transport_end2end_test dualstack_socket_test echo_test fd_posix_test fling_stream_test fling_test gpr_cancellable_test gpr_cmdline_test gpr_env_test gpr_file_test gpr_histogram_test gpr_host_port_test gpr_log_test gpr_slice_buffer_test gpr_slice_test gpr_string_test gpr_sync_test gpr_thd_test gpr_time_test gpr_useful_test grpc_base64_test grpc_byte_buffer_reader_test grpc_channel_stack_test grpc_completion_queue_test grpc_credentials_test grpc_json_token_test grpc_stream_op_test hpack_parser_test hpack_table_test httpcli_format_request_test httpcli_parser_test httpcli_test json_rewrite_test json_test lame_client_test message_compress_test metadata_buffer_test multi_init_test murmur_hash_test no_server_test poll_kick_posix_test resolve_address_test secure_endpoint_test sockaddr_utils_test tcp_client_posix_test tcp_posix_test tcp_server_posix_test time_averaged_stats_test time_test timeout_encoding_test transport_metadata_test transport_security_test 
+test: alarm_heap_test alarm_list_test alarm_test alpn_test bin_encoder_test census_hash_table_test census_statistics_multiple_writers_circular_buffer_test census_statistics_multiple_writers_test census_statistics_performance_test census_statistics_quick_test census_statistics_small_log_test census_stats_store_test census_stub_test census_trace_store_test census_window_stats_test chttp2_status_conversion_test chttp2_stream_encoder_test chttp2_stream_map_test chttp2_transport_end2end_test dualstack_socket_test echo_test fd_posix_test fling_stream_test fling_test gpr_cancellable_test gpr_cmdline_test gpr_env_test gpr_file_test gpr_histogram_test gpr_host_port_test gpr_log_test gpr_slice_buffer_test gpr_slice_test gpr_string_test gpr_sync_test gpr_thd_test gpr_time_test gpr_tls_test gpr_useful_test grpc_base64_test grpc_byte_buffer_reader_test grpc_channel_stack_test grpc_completion_queue_test grpc_credentials_test grpc_json_token_test grpc_stream_op_test hpack_parser_test hpack_table_test httpcli_format_request_test httpcli_parser_test httpcli_test json_rewrite_test json_test lame_client_test message_compress_test metadata_buffer_test multi_init_test murmur_hash_test no_server_test poll_kick_posix_test resolve_address_test secure_endpoint_test sockaddr_utils_test tcp_client_posix_test tcp_posix_test tcp_server_posix_test time_averaged_stats_test time_test timeout_encoding_test transport_metadata_test transport_security_test 
 	echo All tests ran.
 
-test_gpr: gpr_cancellable_test gpr_cmdline_test gpr_env_test gpr_file_test gpr_histogram_test gpr_host_port_test gpr_log_test gpr_slice_buffer_test gpr_slice_test gpr_string_test gpr_sync_test gpr_thd_test gpr_time_test gpr_useful_test 
+test_gpr: gpr_cancellable_test gpr_cmdline_test gpr_env_test gpr_file_test gpr_histogram_test gpr_host_port_test gpr_log_test gpr_slice_buffer_test gpr_slice_test gpr_string_test gpr_sync_test gpr_thd_test gpr_time_test gpr_tls_test gpr_useful_test 
 	echo All tests ran.
 
 alarm_heap_test.exe: grpc_test_util
@@ -398,6 +398,14 @@ gpr_time_test: gpr_time_test.exe
 	echo Running gpr_time_test
 	$(OUT_DIR)\gpr_time_test.exe
 
+gpr_tls_test.exe: grpc_test_util
+	echo Building gpr_tls_test
+	$(CC) $(CFLAGS) /Fo:$(OUT_DIR)\ ..\..\test\core\support\tls_test.c 
+	$(LINK) $(LFLAGS) /OUT:"$(OUT_DIR)\gpr_tls_test.exe" Debug\gpr_test_util.lib Debug\gpr.lib $(LIBS) $(OUT_DIR)\tls_test.obj 
+gpr_tls_test: gpr_tls_test.exe
+	echo Running gpr_tls_test
+	$(OUT_DIR)\gpr_tls_test.exe
+
 gpr_useful_test.exe: grpc_test_util
 	echo Building gpr_useful_test
 	$(CC) $(CFLAGS) /Fo:$(OUT_DIR)\ ..\..\test\core\support\useful_test.c 

vsprojects/vs2010/gpr.vcxproj

@@ -97,6 +97,10 @@
     <ClInclude Include="..\..\include\grpc\support\sync_win32.h" />
     <ClInclude Include="..\..\include\grpc\support\thd.h" />
     <ClInclude Include="..\..\include\grpc\support\time.h" />
+    <ClInclude Include="..\..\include\grpc\support\tls.h" />
+    <ClInclude Include="..\..\include\grpc\support\tls_gcc.h" />
+    <ClInclude Include="..\..\include\grpc\support\tls_msvc.h" />
+    <ClInclude Include="..\..\include\grpc\support\tls_pthread.h" />
     <ClInclude Include="..\..\include\grpc\support\useful.h" />
   </ItemGroup>
   <ItemGroup>

vsprojects/vs2010/gpr.vcxproj.filters

@@ -171,6 +171,18 @@
     <ClInclude Include="..\..\include\grpc\support\time.h">
       <Filter>include\grpc\support</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\include\grpc\support\tls.h">
+      <Filter>include\grpc\support</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc\support\tls_gcc.h">
+      <Filter>include\grpc\support</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc\support\tls_msvc.h">
+      <Filter>include\grpc\support</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc\support\tls_pthread.h">
+      <Filter>include\grpc\support</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\include\grpc\support\useful.h">
       <Filter>include\grpc\support</Filter>
     </ClInclude>

vsprojects/vs2010/grpc++.vcxproj

@@ -93,6 +93,12 @@
     <ClInclude Include="..\..\include\grpc++\impl\rpc_method.h" />
     <ClInclude Include="..\..\include\grpc++\impl\rpc_service_method.h" />
     <ClInclude Include="..\..\include\grpc++\impl\service_type.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\sync.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\sync_cxx11.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\sync_no_cxx11.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\thd.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\thd_cxx11.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\thd_no_cxx11.h" />
     <ClInclude Include="..\..\include\grpc++\server.h" />
     <ClInclude Include="..\..\include\grpc++\server_builder.h" />
     <ClInclude Include="..\..\include\grpc++\server_context.h" />
@@ -104,6 +110,8 @@
     <ClInclude Include="..\..\include\grpc++\thread_pool_interface.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="..\..\src\cpp\client\secure_credentials.h" />
+    <ClInclude Include="..\..\src\cpp\server\secure_server_credentials.h" />
     <ClInclude Include="..\..\src\cpp\client\channel.h" />
     <ClInclude Include="..\..\src\cpp\proto\proto_utils.h" />
     <ClInclude Include="..\..\src\cpp\server\thread_pool.h" />

vsprojects/vs2010/grpc++.vcxproj.filters

@@ -132,6 +132,24 @@
     <ClInclude Include="..\..\include\grpc++\impl\service_type.h">
       <Filter>include\grpc++\impl</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\sync.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\sync_cxx11.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\sync_no_cxx11.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\thd.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\thd_cxx11.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\thd_no_cxx11.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\include\grpc++\server.h">
       <Filter>include\grpc++</Filter>
     </ClInclude>
@@ -161,6 +179,12 @@
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="..\..\src\cpp\client\secure_credentials.h">
+      <Filter>src\cpp\client</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\cpp\server\secure_server_credentials.h">
+      <Filter>src\cpp\server</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\src\cpp\client\channel.h">
       <Filter>src\cpp\client</Filter>
     </ClInclude>

vsprojects/vs2013/Grpc.mak

@@ -53,13 +53,13 @@ grpc_test_util:
 $(OUT_DIR):
 	mkdir $(OUT_DIR)
 
-buildtests: alarm_heap_test.exe alarm_list_test.exe alarm_test.exe alpn_test.exe bin_encoder_test.exe census_hash_table_test.exe census_statistics_multiple_writers_circular_buffer_test.exe census_statistics_multiple_writers_test.exe census_statistics_performance_test.exe census_statistics_quick_test.exe census_statistics_small_log_test.exe census_stats_store_test.exe census_stub_test.exe census_trace_store_test.exe census_window_stats_test.exe chttp2_status_conversion_test.exe chttp2_stream_encoder_test.exe chttp2_stream_map_test.exe chttp2_transport_end2end_test.exe dualstack_socket_test.exe echo_test.exe fd_posix_test.exe fling_stream_test.exe fling_test.exe gpr_cancellable_test.exe gpr_cmdline_test.exe gpr_env_test.exe gpr_file_test.exe gpr_histogram_test.exe gpr_host_port_test.exe gpr_log_test.exe gpr_slice_buffer_test.exe gpr_slice_test.exe gpr_string_test.exe gpr_sync_test.exe gpr_thd_test.exe gpr_time_test.exe gpr_useful_test.exe grpc_base64_test.exe grpc_byte_buffer_reader_test.exe grpc_channel_stack_test.exe grpc_completion_queue_test.exe grpc_credentials_test.exe grpc_json_token_test.exe grpc_stream_op_test.exe hpack_parser_test.exe hpack_table_test.exe httpcli_format_request_test.exe httpcli_parser_test.exe httpcli_test.exe json_rewrite_test.exe json_test.exe lame_client_test.exe message_compress_test.exe metadata_buffer_test.exe multi_init_test.exe murmur_hash_test.exe no_server_test.exe poll_kick_posix_test.exe resolve_address_test.exe secure_endpoint_test.exe sockaddr_utils_test.exe tcp_client_posix_test.exe tcp_posix_test.exe tcp_server_posix_test.exe time_averaged_stats_test.exe time_test.exe timeout_encoding_test.exe transport_metadata_test.exe transport_security_test.exe 
+buildtests: alarm_heap_test.exe alarm_list_test.exe alarm_test.exe alpn_test.exe bin_encoder_test.exe census_hash_table_test.exe census_statistics_multiple_writers_circular_buffer_test.exe census_statistics_multiple_writers_test.exe census_statistics_performance_test.exe census_statistics_quick_test.exe census_statistics_small_log_test.exe census_stats_store_test.exe census_stub_test.exe census_trace_store_test.exe census_window_stats_test.exe chttp2_status_conversion_test.exe chttp2_stream_encoder_test.exe chttp2_stream_map_test.exe chttp2_transport_end2end_test.exe dualstack_socket_test.exe echo_test.exe fd_posix_test.exe fling_stream_test.exe fling_test.exe gpr_cancellable_test.exe gpr_cmdline_test.exe gpr_env_test.exe gpr_file_test.exe gpr_histogram_test.exe gpr_host_port_test.exe gpr_log_test.exe gpr_slice_buffer_test.exe gpr_slice_test.exe gpr_string_test.exe gpr_sync_test.exe gpr_thd_test.exe gpr_time_test.exe gpr_tls_test.exe gpr_useful_test.exe grpc_base64_test.exe grpc_byte_buffer_reader_test.exe grpc_channel_stack_test.exe grpc_completion_queue_test.exe grpc_credentials_test.exe grpc_json_token_test.exe grpc_stream_op_test.exe hpack_parser_test.exe hpack_table_test.exe httpcli_format_request_test.exe httpcli_parser_test.exe httpcli_test.exe json_rewrite_test.exe json_test.exe lame_client_test.exe message_compress_test.exe metadata_buffer_test.exe multi_init_test.exe murmur_hash_test.exe no_server_test.exe poll_kick_posix_test.exe resolve_address_test.exe secure_endpoint_test.exe sockaddr_utils_test.exe tcp_client_posix_test.exe tcp_posix_test.exe tcp_server_posix_test.exe time_averaged_stats_test.exe time_test.exe timeout_encoding_test.exe transport_metadata_test.exe transport_security_test.exe 
 	echo All tests built.
 
-test: alarm_heap_test alarm_list_test alarm_test alpn_test bin_encoder_test census_hash_table_test census_statistics_multiple_writers_circular_buffer_test census_statistics_multiple_writers_test census_statistics_performance_test census_statistics_quick_test census_statistics_small_log_test census_stats_store_test census_stub_test census_trace_store_test census_window_stats_test chttp2_status_conversion_test chttp2_stream_encoder_test chttp2_stream_map_test chttp2_transport_end2end_test dualstack_socket_test echo_test fd_posix_test fling_stream_test fling_test gpr_cancellable_test gpr_cmdline_test gpr_env_test gpr_file_test gpr_histogram_test gpr_host_port_test gpr_log_test gpr_slice_buffer_test gpr_slice_test gpr_string_test gpr_sync_test gpr_thd_test gpr_time_test gpr_useful_test grpc_base64_test grpc_byte_buffer_reader_test grpc_channel_stack_test grpc_completion_queue_test grpc_credentials_test grpc_json_token_test grpc_stream_op_test hpack_parser_test hpack_table_test httpcli_format_request_test httpcli_parser_test httpcli_test json_rewrite_test json_test lame_client_test message_compress_test metadata_buffer_test multi_init_test murmur_hash_test no_server_test poll_kick_posix_test resolve_address_test secure_endpoint_test sockaddr_utils_test tcp_client_posix_test tcp_posix_test tcp_server_posix_test time_averaged_stats_test time_test timeout_encoding_test transport_metadata_test transport_security_test 
+test: alarm_heap_test alarm_list_test alarm_test alpn_test bin_encoder_test census_hash_table_test census_statistics_multiple_writers_circular_buffer_test census_statistics_multiple_writers_test census_statistics_performance_test census_statistics_quick_test census_statistics_small_log_test census_stats_store_test census_stub_test census_trace_store_test census_window_stats_test chttp2_status_conversion_test chttp2_stream_encoder_test chttp2_stream_map_test chttp2_transport_end2end_test dualstack_socket_test echo_test fd_posix_test fling_stream_test fling_test gpr_cancellable_test gpr_cmdline_test gpr_env_test gpr_file_test gpr_histogram_test gpr_host_port_test gpr_log_test gpr_slice_buffer_test gpr_slice_test gpr_string_test gpr_sync_test gpr_thd_test gpr_time_test gpr_tls_test gpr_useful_test grpc_base64_test grpc_byte_buffer_reader_test grpc_channel_stack_test grpc_completion_queue_test grpc_credentials_test grpc_json_token_test grpc_stream_op_test hpack_parser_test hpack_table_test httpcli_format_request_test httpcli_parser_test httpcli_test json_rewrite_test json_test lame_client_test message_compress_test metadata_buffer_test multi_init_test murmur_hash_test no_server_test poll_kick_posix_test resolve_address_test secure_endpoint_test sockaddr_utils_test tcp_client_posix_test tcp_posix_test tcp_server_posix_test time_averaged_stats_test time_test timeout_encoding_test transport_metadata_test transport_security_test 
 	echo All tests ran.
 
-test_gpr: gpr_cancellable_test gpr_cmdline_test gpr_env_test gpr_file_test gpr_histogram_test gpr_host_port_test gpr_log_test gpr_slice_buffer_test gpr_slice_test gpr_string_test gpr_sync_test gpr_thd_test gpr_time_test gpr_useful_test 
+test_gpr: gpr_cancellable_test gpr_cmdline_test gpr_env_test gpr_file_test gpr_histogram_test gpr_host_port_test gpr_log_test gpr_slice_buffer_test gpr_slice_test gpr_string_test gpr_sync_test gpr_thd_test gpr_time_test gpr_tls_test gpr_useful_test 
 	echo All tests ran.
 
 alarm_heap_test.exe: grpc_test_util
@@ -398,6 +398,14 @@ gpr_time_test: gpr_time_test.exe
 	echo Running gpr_time_test
 	$(OUT_DIR)\gpr_time_test.exe
 
+gpr_tls_test.exe: grpc_test_util
+	echo Building gpr_tls_test
+	$(CC) $(CFLAGS) /Fo:$(OUT_DIR)\ ..\..\test\core\support\tls_test.c 
+	$(LINK) $(LFLAGS) /OUT:"$(OUT_DIR)\gpr_tls_test.exe" Debug\gpr_test_util.lib Debug\gpr.lib $(LIBS) $(OUT_DIR)\tls_test.obj 
+gpr_tls_test: gpr_tls_test.exe
+	echo Running gpr_tls_test
+	$(OUT_DIR)\gpr_tls_test.exe
+
 gpr_useful_test.exe: grpc_test_util
 	echo Building gpr_useful_test
 	$(CC) $(CFLAGS) /Fo:$(OUT_DIR)\ ..\..\test\core\support\useful_test.c 

vsprojects/vs2013/gpr.vcxproj

@@ -99,6 +99,10 @@
     <ClInclude Include="..\..\include\grpc\support\sync_win32.h" />
     <ClInclude Include="..\..\include\grpc\support\thd.h" />
     <ClInclude Include="..\..\include\grpc\support\time.h" />
+    <ClInclude Include="..\..\include\grpc\support\tls.h" />
+    <ClInclude Include="..\..\include\grpc\support\tls_gcc.h" />
+    <ClInclude Include="..\..\include\grpc\support\tls_msvc.h" />
+    <ClInclude Include="..\..\include\grpc\support\tls_pthread.h" />
     <ClInclude Include="..\..\include\grpc\support\useful.h" />
   </ItemGroup>
   <ItemGroup>

vsprojects/vs2013/gpr.vcxproj.filters

@@ -171,6 +171,18 @@
     <ClInclude Include="..\..\include\grpc\support\time.h">
       <Filter>include\grpc\support</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\include\grpc\support\tls.h">
+      <Filter>include\grpc\support</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc\support\tls_gcc.h">
+      <Filter>include\grpc\support</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc\support\tls_msvc.h">
+      <Filter>include\grpc\support</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc\support\tls_pthread.h">
+      <Filter>include\grpc\support</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\include\grpc\support\useful.h">
       <Filter>include\grpc\support</Filter>
     </ClInclude>

vsprojects/vs2013/grpc++.vcxproj

@@ -95,6 +95,12 @@
     <ClInclude Include="..\..\include\grpc++\impl\rpc_method.h" />
     <ClInclude Include="..\..\include\grpc++\impl\rpc_service_method.h" />
     <ClInclude Include="..\..\include\grpc++\impl\service_type.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\sync.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\sync_cxx11.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\sync_no_cxx11.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\thd.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\thd_cxx11.h" />
+    <ClInclude Include="..\..\include\grpc++\impl\thd_no_cxx11.h" />
     <ClInclude Include="..\..\include\grpc++\server.h" />
     <ClInclude Include="..\..\include\grpc++\server_builder.h" />
     <ClInclude Include="..\..\include\grpc++\server_context.h" />
@@ -106,6 +112,8 @@
     <ClInclude Include="..\..\include\grpc++\thread_pool_interface.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="..\..\src\cpp\client\secure_credentials.h" />
+    <ClInclude Include="..\..\src\cpp\server\secure_server_credentials.h" />
     <ClInclude Include="..\..\src\cpp\client\channel.h" />
     <ClInclude Include="..\..\src\cpp\proto\proto_utils.h" />
     <ClInclude Include="..\..\src\cpp\server\thread_pool.h" />

vsprojects/vs2013/grpc++.vcxproj.filters

@@ -132,6 +132,24 @@
     <ClInclude Include="..\..\include\grpc++\impl\service_type.h">
       <Filter>include\grpc++\impl</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\sync.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\sync_cxx11.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\sync_no_cxx11.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\thd.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\thd_cxx11.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\grpc++\impl\thd_no_cxx11.h">
+      <Filter>include\grpc++\impl</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\include\grpc++\server.h">
       <Filter>include\grpc++</Filter>
     </ClInclude>
@@ -161,6 +179,12 @@
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="..\..\src\cpp\client\secure_credentials.h">
+      <Filter>src\cpp\client</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\cpp\server\secure_server_credentials.h">
+      <Filter>src\cpp\server</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\src\cpp\client\channel.h">
       <Filter>src\cpp\client</Filter>
     </ClInclude>