Merge github.com:grpc/grpc into credit

include/grpc++/async_unary_call.h

@@ -49,7 +49,7 @@ class ClientAsyncResponseReader GRPC_FINAL {
  public:
   ClientAsyncResponseReader(ChannelInterface* channel, CompletionQueue* cq,
                     const RpcMethod& method, ClientContext* context,
-                    const google::protobuf::Message& request, void* tag)
+                    const grpc::protobuf::Message& request, void* tag)
       : context_(context),
         call_(channel->CreateCall(method, context, cq)) {
     init_buf_.Reset(tag);
@@ -77,7 +77,6 @@ class ClientAsyncResponseReader GRPC_FINAL {
     call_.PerformOps(&finish_buf_);
   }
 
-
  private:
   ClientContext* context_;
   Call call_;

include/grpc++/channel_interface.h

@@ -37,12 +37,6 @@
 #include <grpc++/status.h>
 #include <grpc++/impl/call.h>
 
-namespace google {
-namespace protobuf {
-class Message;
-}  // namespace protobuf
-}  // namespace google
-
 struct grpc_call;
 
 namespace grpc {

include/grpc++/client_context.h

@@ -47,12 +47,6 @@ using std::chrono::system_clock;
 struct grpc_call;
 struct grpc_completion_queue;
 
-namespace google {
-namespace protobuf {
-class Message;
-}  // namespace protobuf
-}  // namespace google
-
 namespace grpc {
 
 class CallOpBuffer;

include/grpc++/completion_queue.h

@@ -106,8 +106,8 @@ class CompletionQueue {
   friend Status BlockingUnaryCall(ChannelInterface *channel,
                                   const RpcMethod &method,
                                   ClientContext *context,
-                                  const google::protobuf::Message &request,
-                                  google::protobuf::Message *result);
+                                  const grpc::protobuf::Message &request,
+                                  grpc::protobuf::Message *result);
 
   // Wraps grpc_completion_queue_pluck.
   // Cannot be mixed with calls to Next().

include/grpc++/config.h

@@ -34,8 +34,6 @@
 #ifndef GRPCXX_CONFIG_H
 #define GRPCXX_CONFIG_H
 
-#include <string>
-
 #ifdef GRPC_OLD_CXX
 #define GRPC_FINAL
 #define GRPC_OVERRIDE
@@ -44,9 +42,23 @@
 #define GRPC_OVERRIDE override
 #endif
 
+#ifndef GRPC_CUSTOM_STRING
+#include <string>
+#define GRPC_CUSTOM_STRING std::string
+#endif
+
+#ifndef GRPC_CUSTOM_MESSAGE
+#include <google/protobuf/message.h>
+#define GRPC_CUSTOM_MESSAGE ::google::protobuf::Message
+#endif
+
 namespace grpc {
 
-typedef std::string string;
+typedef GRPC_CUSTOM_STRING string;
+
+namespace protobuf {
+typedef GRPC_CUSTOM_MESSAGE Message;
+}  // namespace protobuf
 
 }  // namespace grpc
 

include/grpc++/impl/call.h

@@ -42,12 +42,6 @@
 #include <memory>
 #include <map>
 
-namespace google {
-namespace protobuf {
-class Message;
-}  // namespace protobuf
-}  // namespace google
-
 struct grpc_call;
 struct grpc_op;
 
@@ -67,8 +61,8 @@ class CallOpBuffer : public CompletionQueueTag {
       std::multimap<grpc::string, grpc::string> *metadata);
   void AddSendInitialMetadata(ClientContext *ctx);
   void AddRecvInitialMetadata(ClientContext *ctx);
-  void AddSendMessage(const google::protobuf::Message &message);
-  void AddRecvMessage(google::protobuf::Message *message);
+  void AddSendMessage(const grpc::protobuf::Message &message);
+  void AddRecvMessage(grpc::protobuf::Message *message);
   void AddClientSendClose();
   void AddClientRecvStatus(ClientContext *ctx, Status *status);
   void AddServerSendStatus(std::multimap<grpc::string, grpc::string> *metadata,
@@ -95,10 +89,10 @@ class CallOpBuffer : public CompletionQueueTag {
   std::multimap<grpc::string, grpc::string> *recv_initial_metadata_;
   grpc_metadata_array recv_initial_metadata_arr_;
   // Send message
-  const google::protobuf::Message *send_message_;
+  const grpc::protobuf::Message *send_message_;
   grpc_byte_buffer *send_message_buf_;
   // Recv message
-  google::protobuf::Message *recv_message_;
+  grpc::protobuf::Message *recv_message_;
   grpc_byte_buffer *recv_message_buf_;
   // Client send close
   bool client_send_close_;

include/grpc++/impl/client_unary_call.h

@@ -34,11 +34,7 @@
 #ifndef GRPCXX_IMPL_CLIENT_UNARY_CALL_H
 #define GRPCXX_IMPL_CLIENT_UNARY_CALL_H
 
-namespace google {
-namespace protobuf {
-class Message;
-}  // namespace protobuf
-}  // namespace google
+#include <grpc++/config.h>
 
 namespace grpc {
 
@@ -51,8 +47,8 @@ class Status;
 // Wrapper that performs a blocking unary call
 Status BlockingUnaryCall(ChannelInterface *channel, const RpcMethod &method,
                          ClientContext *context,
-                         const google::protobuf::Message &request,
-                         google::protobuf::Message *result);
+                         const grpc::protobuf::Message &request,
+                         grpc::protobuf::Message *result);
 
 }  // namespace grpc
 

include/grpc++/impl/rpc_method.h

@@ -34,12 +34,6 @@
 #ifndef GRPCXX_IMPL_RPC_METHOD_H
 #define GRPCXX_IMPL_RPC_METHOD_H
 
-namespace google {
-namespace protobuf {
-class Message;
-}  // namespace protobuf
-}  // namespace google
-
 namespace grpc {
 
 class RpcMethod {

include/grpc++/impl/rpc_service_method.h

@@ -56,13 +56,13 @@ class MethodHandler {
   virtual ~MethodHandler() {}
   struct HandlerParameter {
     HandlerParameter(Call* c, ServerContext* context,
-                     const google::protobuf::Message* req,
-                     google::protobuf::Message* resp)
+                     const grpc::protobuf::Message* req,
+                     grpc::protobuf::Message* resp)
         : call(c), server_context(context), request(req), response(resp) {}
     Call* call;
     ServerContext* server_context;
-    const google::protobuf::Message* request;
-    google::protobuf::Message* response;
+    const grpc::protobuf::Message* request;
+    grpc::protobuf::Message* response;
   };
   virtual Status RunHandler(const HandlerParameter& param) = 0;
 };
@@ -165,8 +165,8 @@ class RpcServiceMethod : public RpcMethod {
   // Takes ownership of the handler and two prototype objects.
   RpcServiceMethod(const char* name, RpcMethod::RpcType type,
                    MethodHandler* handler,
-                   google::protobuf::Message* request_prototype,
-                   google::protobuf::Message* response_prototype)
+                   grpc::protobuf::Message* request_prototype,
+                   grpc::protobuf::Message* response_prototype)
       : RpcMethod(name, type),
         handler_(handler),
         request_prototype_(request_prototype),
@@ -174,17 +174,17 @@ class RpcServiceMethod : public RpcMethod {
 
   MethodHandler* handler() { return handler_.get(); }
 
-  google::protobuf::Message* AllocateRequestProto() {
+  grpc::protobuf::Message* AllocateRequestProto() {
     return request_prototype_->New();
   }
-  google::protobuf::Message* AllocateResponseProto() {
+  grpc::protobuf::Message* AllocateResponseProto() {
     return response_prototype_->New();
   }
 
  private:
   std::unique_ptr<MethodHandler> handler_;
-  std::unique_ptr<google::protobuf::Message> request_prototype_;
-  std::unique_ptr<google::protobuf::Message> response_prototype_;
+  std::unique_ptr<grpc::protobuf::Message> request_prototype_;
+  std::unique_ptr<grpc::protobuf::Message> response_prototype_;
 };
 
 // This class contains all the method information for an rpc service. It is

include/grpc++/impl/service_type.h

@@ -34,11 +34,7 @@
 #ifndef GRPCXX_IMPL_SERVICE_TYPE_H
 #define GRPCXX_IMPL_SERVICE_TYPE_H
 
-namespace google {
-namespace protobuf {
-class Message;
-}  // namespace protobuf
-}  // namespace google
+#include <grpc++/config.h>
 
 namespace grpc {
 
@@ -72,7 +68,7 @@ class AsynchronousService {
    public:
     virtual void RequestAsyncCall(void* registered_method,
                                   ServerContext* context,
-                                  ::google::protobuf::Message* request,
+                                  ::grpc::protobuf::Message* request,
                                   ServerAsyncStreamingInterface* stream,
                                   CompletionQueue* cq, void* tag) = 0;
   };
@@ -91,7 +87,7 @@ class AsynchronousService {
 
  protected:
   void RequestAsyncUnary(int index, ServerContext* context,
-                         ::google::protobuf::Message* request,
+                         grpc::protobuf::Message* request,
                          ServerAsyncStreamingInterface* stream,
                          CompletionQueue* cq, void* tag) {
     dispatch_impl_->RequestAsyncCall(request_args_[index], context, request,
@@ -104,7 +100,7 @@ class AsynchronousService {
                                      stream, cq, tag);
   }
   void RequestServerStreaming(int index, ServerContext* context,
-                              ::google::protobuf::Message* request,
+                              grpc::protobuf::Message* request,
                               ServerAsyncStreamingInterface* stream,
                               CompletionQueue* cq, void* tag) {
     dispatch_impl_->RequestAsyncCall(request_args_[index], context, request,

include/grpc++/server.h

@@ -47,12 +47,6 @@
 
 struct grpc_server;
 
-namespace google {
-namespace protobuf {
-class Message;
-}  // namespace protobuf
-}  // namespace google
-
 namespace grpc {
 class AsynchronousService;
 class RpcService;
@@ -100,7 +94,7 @@ class Server GRPC_FINAL : private CallHook,
 
   // DispatchImpl
   void RequestAsyncCall(void* registered_method, ServerContext* context,
-                        ::google::protobuf::Message* request,
+                        grpc::protobuf::Message* request,
                         ServerAsyncStreamingInterface* stream,
                         CompletionQueue* cq, void* tag);
 

include/grpc++/stream.h

@@ -88,7 +88,7 @@ class ClientReader GRPC_FINAL : public ClientStreamingInterface,
  public:
   // Blocking create a stream and write the first request out.
   ClientReader(ChannelInterface* channel, const RpcMethod& method,
-               ClientContext* context, const google::protobuf::Message& request)
+               ClientContext* context, const grpc::protobuf::Message& request)
       : context_(context), call_(channel->CreateCall(method, context, &cq_)) {
     CallOpBuffer buf;
     buf.AddSendInitialMetadata(&context->send_initial_metadata_);
@@ -142,7 +142,7 @@ class ClientWriter GRPC_FINAL : public ClientStreamingInterface,
  public:
   // Blocking create a stream.
   ClientWriter(ChannelInterface* channel, const RpcMethod& method,
-               ClientContext* context, google::protobuf::Message* response)
+               ClientContext* context, grpc::protobuf::Message* response)
       : context_(context),
         response_(response),
         call_(channel->CreateCall(method, context, &cq_)) {
@@ -179,7 +179,7 @@ class ClientWriter GRPC_FINAL : public ClientStreamingInterface,
 
  private:
   ClientContext* context_;
-  google::protobuf::Message* const response_;
+  grpc::protobuf::Message* const response_;
   CompletionQueue cq_;
   Call call_;
 };
@@ -386,7 +386,7 @@ class ClientAsyncReader GRPC_FINAL : public ClientAsyncStreamingInterface,
   // Create a stream and write the first request out.
   ClientAsyncReader(ChannelInterface* channel, CompletionQueue* cq,
                     const RpcMethod& method, ClientContext* context,
-                    const google::protobuf::Message& request, void* tag)
+                    const grpc::protobuf::Message& request, void* tag)
       : context_(context), call_(channel->CreateCall(method, context, cq)) {
     init_buf_.Reset(tag);
     init_buf_.AddSendInitialMetadata(&context->send_initial_metadata_);
@@ -436,7 +436,7 @@ class ClientAsyncWriter GRPC_FINAL : public ClientAsyncStreamingInterface,
  public:
   ClientAsyncWriter(ChannelInterface* channel, CompletionQueue* cq,
                     const RpcMethod& method, ClientContext* context,
-                    google::protobuf::Message* response, void* tag)
+                    grpc::protobuf::Message* response, void* tag)
       : context_(context),
         response_(response),
         call_(channel->CreateCall(method, context, cq)) {
@@ -477,7 +477,7 @@ class ClientAsyncWriter GRPC_FINAL : public ClientAsyncStreamingInterface,
 
  private:
   ClientContext* context_;
-  google::protobuf::Message* const response_;
+  grpc::protobuf::Message* const response_;
   Call call_;
   CallOpBuffer init_buf_;
   CallOpBuffer meta_buf_;

src/core/surface/call.c

@@ -140,6 +140,8 @@ struct grpc_call {
   gpr_uint8 have_alarm;
   /* are we currently performing a send operation */
   gpr_uint8 sending;
+  /* are we currently completing requests */
+  gpr_uint8 completing;
   /* pairs with completed_requests */
   gpr_uint8 num_completed_requests;
   /* flag that we need to request more data */
@@ -357,7 +359,7 @@ static void lock(grpc_call *call) { gpr_mu_lock(&call->mu); }
 static void unlock(grpc_call *call) {
   send_action sa = SEND_NOTHING;
   completed_request completed_requests[GRPC_IOREQ_OP_COUNT];
-  int num_completed_requests = call->num_completed_requests;
+  int completing_requests = 0;
   int need_more_data =
       call->need_more_data &&
       (call->write_state >= WRITE_STATE_STARTED || !call->is_client);
@@ -367,10 +369,12 @@ static void unlock(grpc_call *call) {
     call->need_more_data = 0;
   }
 
-  if (num_completed_requests != 0) {
+  if (!call->completing && call->num_completed_requests != 0) {
+    completing_requests = call->num_completed_requests;
     memcpy(completed_requests, call->completed_requests,
            sizeof(completed_requests));
     call->num_completed_requests = 0;
+    call->completing = 1;
   }
 
   if (!call->sending) {
@@ -391,9 +395,14 @@ static void unlock(grpc_call *call) {
     enact_send_action(call, sa);
   }
 
-  for (i = 0; i < num_completed_requests; i++) {
-    completed_requests[i].on_complete(call, completed_requests[i].status,
-                                      completed_requests[i].user_data);
+  if (completing_requests > 0) {
+    for (i = 0; i < completing_requests; i++) {
+      completed_requests[i].on_complete(call, completed_requests[i].status,
+                                        completed_requests[i].user_data);
+    }
+    lock(call);
+    call->completing = 0;
+    unlock(call);
   }
 }
 

src/cpp/client/client_unary_call.cc

@@ -44,8 +44,8 @@ namespace grpc {
 // Wrapper that performs a blocking unary call
 Status BlockingUnaryCall(ChannelInterface *channel, const RpcMethod &method,
                          ClientContext *context,
-                         const google::protobuf::Message &request,
-                         google::protobuf::Message *result) {
+                         const grpc::protobuf::Message &request,
+                         grpc::protobuf::Message *result) {
   CompletionQueue cq;
   Call call(channel->CreateCall(method, context, &cq));
   CallOpBuffer buf;

src/cpp/common/call.cc

@@ -163,11 +163,11 @@ void CallOpBuffer::AddSendInitialMetadata(ClientContext* ctx) {
   AddSendInitialMetadata(&ctx->send_initial_metadata_);
 }
 
-void CallOpBuffer::AddSendMessage(const google::protobuf::Message& message) {
+void CallOpBuffer::AddSendMessage(const grpc::protobuf::Message& message) {
   send_message_ = &message;
 }
 
-void CallOpBuffer::AddRecvMessage(google::protobuf::Message* message) {
+void CallOpBuffer::AddRecvMessage(grpc::protobuf::Message* message) {
   recv_message_ = message;
   recv_message_->Clear();
 }

src/cpp/proto/proto_utils.cc

@@ -40,7 +40,7 @@
 
 namespace grpc {
 
-bool SerializeProto(const google::protobuf::Message &msg,
+bool SerializeProto(const grpc::protobuf::Message &msg,
                     grpc_byte_buffer **bp) {
   grpc::string msg_str;
   bool success = msg.SerializeToString(&msg_str);
@@ -54,7 +54,7 @@ bool SerializeProto(const google::protobuf::Message &msg,
 }
 
 bool DeserializeProto(grpc_byte_buffer *buffer,
-                      google::protobuf::Message *msg) {
+                      grpc::protobuf::Message *msg) {
   grpc::string msg_string;
   grpc_byte_buffer_reader *reader = grpc_byte_buffer_reader_create(buffer);
   gpr_slice slice;

src/cpp/proto/proto_utils.h

@@ -34,23 +34,20 @@
 #ifndef GRPC_INTERNAL_CPP_PROTO_PROTO_UTILS_H
 #define GRPC_INTERNAL_CPP_PROTO_PROTO_UTILS_H
 
+#include <grpc++/config.h>
+
 struct grpc_byte_buffer;
-namespace google {
-namespace protobuf {
-class Message;
-}
-}
 
 namespace grpc {
 
 // Serialize the msg into a buffer created inside the function. The caller
 // should destroy the returned buffer when done with it. If serialization fails,
 // false is returned and buffer is left unchanged.
-bool SerializeProto(const google::protobuf::Message &msg,
+bool SerializeProto(const grpc::protobuf::Message &msg,
                     grpc_byte_buffer **buffer);
 
 // The caller keeps ownership of buffer and msg.
-bool DeserializeProto(grpc_byte_buffer *buffer, google::protobuf::Message *msg);
+bool DeserializeProto(grpc_byte_buffer *buffer, grpc::protobuf::Message *msg);
 
 }  // namespace grpc
 

src/cpp/server/async_server_context.cc

@@ -58,14 +58,14 @@ void AsyncServerContext::Accept(grpc_completion_queue *cq) {
                  call_, GRPC_WRITE_BUFFER_HINT) == GRPC_CALL_OK);
 }
 
-bool AsyncServerContext::StartRead(google::protobuf::Message *request) {
+bool AsyncServerContext::StartRead(grpc::protobuf::Message *request) {
   GPR_ASSERT(request);
   request_ = request;
   grpc_call_error err = grpc_call_start_read_old(call_, this);
   return err == GRPC_CALL_OK;
 }
 
-bool AsyncServerContext::StartWrite(const google::protobuf::Message &response,
+bool AsyncServerContext::StartWrite(const grpc::protobuf::Message &response,
                                     int flags) {
   grpc_byte_buffer *buffer = nullptr;
   if (!SerializeProto(response, &buffer)) {

src/cpp/server/server.cc

@@ -117,8 +117,8 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
     }
 
     void Run() {
-      std::unique_ptr<google::protobuf::Message> req;
-      std::unique_ptr<google::protobuf::Message> res;
+      std::unique_ptr<grpc::protobuf::Message> req;
+      std::unique_ptr<grpc::protobuf::Message> res;
       if (has_request_payload_) {
         req.reset(method_->AllocateRequestProto());
         if (!DeserializeProto(request_payload_, req.get())) {
@@ -281,7 +281,7 @@ void Server::PerformOpsOnCall(CallOpBuffer* buf, Call* call) {
 class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag {
  public:
   AsyncRequest(Server* server, void* registered_method, ServerContext* ctx,
-               ::google::protobuf::Message* request,
+               grpc::protobuf::Message* request,
                ServerAsyncStreamingInterface* stream, CompletionQueue* cq,
                void* tag)
       : tag_(tag),
@@ -307,6 +307,7 @@ class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag {
 
   bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE {
     *tag = tag_;
+    bool orig_status = *status;
     if (*status && request_) {
       if (payload_) {
         *status = DeserializeProto(payload_, request_);
@@ -326,7 +327,9 @@ class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag {
     }
     ctx_->call_ = call_;
     Call call(call_, server_, cq_);
-    ctx_->BeginCompletionOp(&call);
+    if (orig_status && call_) {
+      ctx_->BeginCompletionOp(&call);
+    }
     // just the pointers inside call are copied here
     stream_->BindCall(&call);
     delete this;
@@ -335,7 +338,7 @@ class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag {
 
  private:
   void* const tag_;
-  ::google::protobuf::Message* const request_;
+  grpc::protobuf::Message* const request_;
   ServerAsyncStreamingInterface* const stream_;
   CompletionQueue* const cq_;
   ServerContext* const ctx_;
@@ -347,7 +350,7 @@ class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag {
 };
 
 void Server::RequestAsyncCall(void* registered_method, ServerContext* context,
-                              ::google::protobuf::Message* request,
+                              grpc::protobuf::Message* request,
                               ServerAsyncStreamingInterface* stream,
                               CompletionQueue* cq, void* tag) {
   new AsyncRequest(this, registered_method, context, request, stream, cq, tag);

test/cpp/qps/server_async.cc

@@ -145,21 +145,24 @@ class AsyncQpsServerTest {
       delete contexts_.front();
       contexts_.pop_front();
     }
+    for (auto& thr: threads_) {
+      thr.join();
+    }
   }
   void ServeRpcs(int num_threads) {
-    std::vector<std::thread> threads;
     for (int i = 0; i < num_threads; i++) {
-      threads.push_back(std::thread([=]() {
+      threads_.push_back(std::thread([=]() {
         // Wait until work is available or we are shutting down
         bool ok;
         void *got_tag;
         while (srv_cq_.Next(&got_tag, &ok)) {
-          EXPECT_EQ(ok, true);
-          ServerRpcContext *ctx = detag(got_tag);
-          // The tag is a pointer to an RPC context to invoke
-          if (ctx->RunNextState() == false) {
-            // this RPC context is done, so refresh it
-            ctx->Reset();
+          if (ok) {
+            ServerRpcContext *ctx = detag(got_tag);
+            // The tag is a pointer to an RPC context to invoke
+            if (ctx->RunNextState() == false) {
+              // this RPC context is done, so refresh it
+              ctx->Reset();
+            }
           }
         }
         return;
@@ -262,6 +265,7 @@ class AsyncQpsServerTest {
   }
   CompletionQueue srv_cq_;
   TestService::AsyncService async_service_;
+  std::vector<std::thread> threads_;
   std::unique_ptr<Server> server_;
   std::function<void(ServerContext *, SimpleRequest *,
                      grpc::ServerAsyncResponseWriter<SimpleResponse> *, void *)>

tools/dockerfile/grpc_csharp_mono/Dockerfile

@@ -38,12 +38,8 @@ RUN cd /var/local/git/grpc \
 # Install the gRPC C# extension library
 RUN make install_grpc_csharp_ext -j12 -C /var/local/git/grpc
 
-# TODO: download NuGet from web. The problem is there seems to be no direct link
-# we could use :-)
-ADD NuGet.exe NuGet.exe
-
 # Restore the NuGet dependencies
-RUN cd /var/local/git/grpc/src/csharp && mono /NuGet.exe restore Grpc.sln
+RUN cd /var/local/git/grpc/src/csharp && mono /var/local/NuGet.exe restore Grpc.sln
 
 # Build gRPC solution
 RUN cd /var/local/git/grpc/src/csharp && xbuild Grpc.sln

tools/dockerfile/grpc_csharp_mono_base/Dockerfile

@@ -43,6 +43,9 @@ RUN apt-get update && apt-get install -y \
     nunit-console \
     monodevelop
 
+# Download NuGet
+RUN cd /var/local && wget www.nuget.org/NuGet.exe
+
 # Get the source from GitHub
 RUN git clone git@github.com:grpc/grpc.git /var/local/git/grpc
 RUN cd /var/local/git/grpc && \

tools/dockerfile/grpc_python/Dockerfile

@@ -44,21 +44,21 @@ RUN cd /var/local/git/grpc \
   && pip install src/python/interop
 
 # Run Python GRPC's tests
+# TODO(nathaniel): It would be nice for these to be auto-discoverable?
 RUN cd /var/local/git/grpc \
-  # TODO(nathaniel): It would be nice for these to be auto-discoverable?
-  && python2.7 -B -m grpc._adapter._blocking_invocation_inline_service_test
-  && python2.7 -B -m grpc._adapter._c_test
-  && python2.7 -B -m grpc._adapter._event_invocation_synchronous_event_service_test
-  && python2.7 -B -m grpc._adapter._future_invocation_asynchronous_event_service_test
-  && python2.7 -B -m grpc._adapter._links_test
-  && python2.7 -B -m grpc._adapter._lonely_rear_link_test
-  && python2.7 -B -m grpc._adapter._low_test
-  && python2.7 -B -m grpc.framework.assembly.implementations_test
-  && python2.7 -B -m grpc.framework.base.packets.implementations_test
-  && python2.7 -B -m grpc.framework.face.blocking_invocation_inline_service_test
-  && python2.7 -B -m grpc.framework.face.event_invocation_synchronous_event_service_test
-  && python2.7 -B -m grpc.framework.face.future_invocation_asynchronous_event_service_test
-  && python2.7 -B -m grpc.framework.foundation._later_test
+  && python2.7 -B -m grpc._adapter._blocking_invocation_inline_service_test \
+  && python2.7 -B -m grpc._adapter._c_test \
+  && python2.7 -B -m grpc._adapter._event_invocation_synchronous_event_service_test \
+  && python2.7 -B -m grpc._adapter._future_invocation_asynchronous_event_service_test \
+  && python2.7 -B -m grpc._adapter._links_test \
+  && python2.7 -B -m grpc._adapter._lonely_rear_link_test \
+  && python2.7 -B -m grpc._adapter._low_test \
+  && python2.7 -B -m grpc.framework.assembly.implementations_test \
+  && python2.7 -B -m grpc.framework.base.packets.implementations_test \
+  && python2.7 -B -m grpc.framework.face.blocking_invocation_inline_service_test \
+  && python2.7 -B -m grpc.framework.face.event_invocation_synchronous_event_service_test \
+  && python2.7 -B -m grpc.framework.face.future_invocation_asynchronous_event_service_test \
+  && python2.7 -B -m grpc.framework.foundation._later_test \
   && python2.7 -B -m grpc.framework.foundation._logging_pool_test
 
 # Add a cacerts directory containing the Google root pem file, allowing the interop client to access the production test instance

tools/gce_setup/build_images.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+# 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.
+
+
+main() {
+  # rebuild images on all languages on existing builder vm. 
+  source grpc_docker.sh
+  cd ../../
+
+  # build images for all languages
+  languages=(cxx java go ruby node python)
+  for lan in "${languages[@]}"
+  do
+    grpc_update_image $lan
+  done
+}
+
+set -x
+main "$@"

tools/gce_setup/cloud_prod_runner.sh

@@ -31,7 +31,8 @@
 
 main() {
   source grpc_docker.sh
-  test_cases=(large_unary empty_unary ping_pong client_streaming server_streaming cancel_after_begin cancel_after_first_response)
+  # temporarily remove ping_pong and cancel_after_first_response while investigating timeout
+  test_cases=(large_unary empty_unary client_streaming server_streaming cancel_after_begin)
   auth_test_cases=(service_account_creds compute_engine_creds)
   clients=(cxx java go ruby node)
   for test_case in "${test_cases[@]}"