Merge branch 'master' into genericstub
diff --git a/include/grpc++/async_generic_service.h b/include/grpc++/async_generic_service.h
index d10a56c..911d31c 100644
--- a/include/grpc++/async_generic_service.h
+++ b/include/grpc++/async_generic_service.h
@@ -41,7 +41,8 @@
namespace grpc {
-typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer> GenericServerAsyncReaderWriter;
+typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer>
+ GenericServerAsyncReaderWriter;
class GenericServerContext GRPC_FINAL : public ServerContext {
public:
@@ -74,6 +75,6 @@
Server* server_;
};
-} // namespace grpc
+} // namespace grpc
#endif // GRPCXX_ASYNC_GENERIC_SERVICE_H
diff --git a/include/grpc++/async_unary_call.h b/include/grpc++/async_unary_call.h
index 658941b..d1d5be5 100644
--- a/include/grpc++/async_unary_call.h
+++ b/include/grpc++/async_unary_call.h
@@ -48,10 +48,9 @@
class ClientAsyncResponseReader GRPC_FINAL {
public:
ClientAsyncResponseReader(ChannelInterface* channel, CompletionQueue* cq,
- const RpcMethod& method, ClientContext* context,
- const grpc::protobuf::Message& request, void* tag)
- : context_(context),
- call_(channel->CreateCall(method, context, cq)) {
+ const RpcMethod& method, ClientContext* context,
+ 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_);
init_buf_.AddSendMessage(request);
diff --git a/include/grpc++/byte_buffer.h b/include/grpc++/byte_buffer.h
index e864ca3..ceb6262 100644
--- a/include/grpc++/byte_buffer.h
+++ b/include/grpc++/byte_buffer.h
@@ -72,9 +72,7 @@
buffer_ = buf;
}
- grpc_byte_buffer* buffer() const {
- return buffer_;
- }
+ grpc_byte_buffer* buffer() const { return buffer_; }
grpc_byte_buffer* buffer_;
};
diff --git a/include/grpc++/channel_interface.h b/include/grpc++/channel_interface.h
index 51260ae..7d50b45 100644
--- a/include/grpc++/channel_interface.h
+++ b/include/grpc++/channel_interface.h
@@ -51,8 +51,8 @@
public:
virtual ~ChannelInterface() {}
- virtual Call CreateCall(const RpcMethod &method, ClientContext *context,
- CompletionQueue *cq) = 0;
+ virtual Call CreateCall(const RpcMethod& method, ClientContext* context,
+ CompletionQueue* cq) = 0;
};
} // namespace grpc
diff --git a/include/grpc++/client_context.h b/include/grpc++/client_context.h
index c55d7c2..4e7f5a7 100644
--- a/include/grpc++/client_context.h
+++ b/include/grpc++/client_context.h
@@ -74,8 +74,8 @@
ClientContext();
~ClientContext();
- void AddMetadata(const grpc::string &meta_key,
- const grpc::string &meta_value);
+ void AddMetadata(const grpc::string& meta_key,
+ const grpc::string& meta_value);
const std::multimap<grpc::string, grpc::string>& GetServerInitialMetadata() {
GPR_ASSERT(initial_metadata_received_);
@@ -87,19 +87,17 @@
return trailing_metadata_;
}
- void set_absolute_deadline(const system_clock::time_point &deadline);
+ void set_absolute_deadline(const system_clock::time_point& deadline);
system_clock::time_point absolute_deadline();
- void set_authority(const grpc::string& authority) {
- authority_ = authority;
- }
+ void set_authority(const grpc::string& authority) { authority_ = authority; }
void TryCancel();
private:
// Disallow copy and assign.
- ClientContext(const ClientContext &);
- ClientContext &operator=(const ClientContext &);
+ ClientContext(const ClientContext&);
+ ClientContext& operator=(const ClientContext&);
friend class CallOpBuffer;
friend class Channel;
@@ -118,24 +116,22 @@
template <class R>
friend class ::grpc::ClientAsyncResponseReader;
- grpc_call *call() { return call_; }
- void set_call(grpc_call *call) {
+ grpc_call* call() { return call_; }
+ void set_call(grpc_call* call) {
GPR_ASSERT(call_ == nullptr);
call_ = call;
}
- grpc_completion_queue *cq() { return cq_; }
- void set_cq(grpc_completion_queue *cq) { cq_ = cq; }
+ grpc_completion_queue* cq() { return cq_; }
+ void set_cq(grpc_completion_queue* cq) { cq_ = cq; }
gpr_timespec RawDeadline() { return absolute_deadline_; }
- grpc::string authority() {
- return authority_;
- }
+ grpc::string authority() { return authority_; }
bool initial_metadata_received_;
- grpc_call *call_;
- grpc_completion_queue *cq_;
+ grpc_call* call_;
+ grpc_completion_queue* cq_;
gpr_timespec absolute_deadline_;
grpc::string authority_;
std::multimap<grpc::string, grpc::string> send_initial_metadata_;
diff --git a/include/grpc++/completion_queue.h b/include/grpc++/completion_queue.h
index d742d85..f4619a1 100644
--- a/include/grpc++/completion_queue.h
+++ b/include/grpc++/completion_queue.h
@@ -66,37 +66,38 @@
// to do)
// If this function returns false, the tag is dropped and not returned
// from the completion queue
- virtual bool FinalizeResult(void **tag, bool *status) = 0;
+ virtual bool FinalizeResult(void** tag, bool* status) = 0;
};
// grpc_completion_queue wrapper class
class CompletionQueue {
public:
CompletionQueue();
- explicit CompletionQueue(grpc_completion_queue *take);
+ explicit CompletionQueue(grpc_completion_queue* take);
~CompletionQueue();
// Tri-state return for AsyncNext: SHUTDOWN, GOT_EVENT, TIMEOUT
- enum NextStatus {SHUTDOWN, GOT_EVENT, TIMEOUT};
+ enum NextStatus { SHUTDOWN, GOT_EVENT, TIMEOUT };
// Nonblocking (until deadline) read from queue.
// Cannot rely on result of tag or ok if return is TIMEOUT
- NextStatus AsyncNext(void **tag, bool *ok,
- std::chrono::system_clock::time_point deadline);
+ NextStatus AsyncNext(void** tag, bool* ok,
+ std::chrono::system_clock::time_point deadline);
// Blocking (until deadline) read from queue.
// Returns false if the queue is ready for destruction, true if event
- bool Next(void **tag, bool *ok) {
- return (AsyncNext(tag,ok,
- std::chrono::system_clock::time_point::max()) !=
- SHUTDOWN);
+
+ bool Next(void** tag, bool* ok) {
+ return (
+ AsyncNext(tag, ok, (std::chrono::system_clock::time_point::max)()) !=
+ SHUTDOWN);
}
// Shutdown has to be called, and the CompletionQueue can only be
// destructed when false is returned from Next().
void Shutdown();
- grpc_completion_queue *cq() { return cq_; }
+ grpc_completion_queue* cq() { return cq_; }
private:
// Friend synchronous wrappers so that they can access Pluck(), which is
@@ -115,20 +116,20 @@
friend class ::grpc::ServerReaderWriter;
friend class ::grpc::Server;
friend class ::grpc::ServerContext;
- friend Status BlockingUnaryCall(ChannelInterface *channel,
- const RpcMethod &method,
- ClientContext *context,
- const grpc::protobuf::Message &request,
- grpc::protobuf::Message *result);
+ friend Status BlockingUnaryCall(ChannelInterface* channel,
+ const RpcMethod& method,
+ ClientContext* context,
+ const grpc::protobuf::Message& request,
+ grpc::protobuf::Message* result);
// Wraps grpc_completion_queue_pluck.
// Cannot be mixed with calls to Next().
- bool Pluck(CompletionQueueTag *tag);
+ bool Pluck(CompletionQueueTag* tag);
// Does a single polling pluck on tag
- void TryPluck(CompletionQueueTag *tag);
+ void TryPluck(CompletionQueueTag* tag);
- grpc_completion_queue *cq_; // owned
+ grpc_completion_queue* cq_; // owned
};
} // namespace grpc
diff --git a/include/grpc++/config.h b/include/grpc++/config.h
index 0267b85..35bf507 100644
--- a/include/grpc++/config.h
+++ b/include/grpc++/config.h
@@ -59,11 +59,12 @@
#ifndef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM
#include <google/protobuf/io/zero_copy_stream.h>
-#define GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM ::google::protobuf::io::ZeroCopyOutputStream
-#define GRPC_CUSTOM_ZEROCOPYINPUTSTREAM ::google::protobuf::io::ZeroCopyInputStream
+#define GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM \
+ ::google::protobuf::io::ZeroCopyOutputStream
+#define GRPC_CUSTOM_ZEROCOPYINPUTSTREAM \
+ ::google::protobuf::io::ZeroCopyInputStream
#endif
-
namespace grpc {
typedef GRPC_CUSTOM_STRING string;
diff --git a/include/grpc++/generic_stub.h b/include/grpc++/generic_stub.h
index 25361af..c34e1fc 100644
--- a/include/grpc++/generic_stub.h
+++ b/include/grpc++/generic_stub.h
@@ -59,6 +59,6 @@
std::shared_ptr<ChannelInterface> channel_;
};
-} // namespace grpc
+} // namespace grpc
#endif // GRPCXX_GENERIC_STUB_H
diff --git a/include/grpc++/impl/call.h b/include/grpc++/impl/call.h
index a8551ad..e117ac6 100644
--- a/include/grpc++/impl/call.h
+++ b/include/grpc++/impl/call.h
@@ -55,89 +55,89 @@
CallOpBuffer();
~CallOpBuffer();
- void Reset(void *next_return_tag);
+ void Reset(void* next_return_tag);
// Does not take ownership.
void AddSendInitialMetadata(
- std::multimap<grpc::string, grpc::string> *metadata);
- void AddSendInitialMetadata(ClientContext *ctx);
- void AddRecvInitialMetadata(ClientContext *ctx);
- void AddSendMessage(const grpc::protobuf::Message &message);
+ std::multimap<grpc::string, grpc::string>* metadata);
+ void AddSendInitialMetadata(ClientContext* ctx);
+ void AddRecvInitialMetadata(ClientContext* ctx);
+ void AddSendMessage(const grpc::protobuf::Message& message);
void AddSendMessage(const ByteBuffer& message);
- void AddRecvMessage(grpc::protobuf::Message *message);
- void AddRecvMessage(ByteBuffer *message);
+ void AddRecvMessage(grpc::protobuf::Message* message);
+ void AddRecvMessage(ByteBuffer* message);
void AddClientSendClose();
- void AddClientRecvStatus(ClientContext *ctx, Status *status);
- void AddServerSendStatus(std::multimap<grpc::string, grpc::string> *metadata,
- const Status &status);
- void AddServerRecvClose(bool *cancelled);
+ void AddClientRecvStatus(ClientContext* ctx, Status* status);
+ void AddServerSendStatus(std::multimap<grpc::string, grpc::string>* metadata,
+ const Status& status);
+ void AddServerRecvClose(bool* cancelled);
// INTERNAL API:
// Convert to an array of grpc_op elements
- void FillOps(grpc_op *ops, size_t *nops);
+ void FillOps(grpc_op* ops, size_t* nops);
// Called by completion queue just prior to returning from Next() or Pluck()
- bool FinalizeResult(void **tag, bool *status) GRPC_OVERRIDE;
+ bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE;
bool got_message;
private:
- void *return_tag_;
+ void* return_tag_;
// Send initial metadata
bool send_initial_metadata_;
size_t initial_metadata_count_;
- grpc_metadata *initial_metadata_;
+ grpc_metadata* initial_metadata_;
// Recv initial metadta
- std::multimap<grpc::string, grpc::string> *recv_initial_metadata_;
+ std::multimap<grpc::string, grpc::string>* recv_initial_metadata_;
grpc_metadata_array recv_initial_metadata_arr_;
// Send message
- const grpc::protobuf::Message *send_message_;
- const ByteBuffer *send_message_buffer_;
- grpc_byte_buffer *send_buf_;
+ const grpc::protobuf::Message* send_message_;
+ const ByteBuffer* send_message_buffer_;
+ grpc_byte_buffer* send_buf_;
// Recv message
- grpc::protobuf::Message *recv_message_;
- ByteBuffer *recv_message_buffer_;
- grpc_byte_buffer *recv_buf_;
+ grpc::protobuf::Message* recv_message_;
+ ByteBuffer* recv_message_buffer_;
+ grpc_byte_buffer* recv_buf_;
// Client send close
bool client_send_close_;
// Client recv status
- std::multimap<grpc::string, grpc::string> *recv_trailing_metadata_;
- Status *recv_status_;
+ std::multimap<grpc::string, grpc::string>* recv_trailing_metadata_;
+ Status* recv_status_;
grpc_metadata_array recv_trailing_metadata_arr_;
grpc_status_code status_code_;
- char *status_details_;
+ char* status_details_;
size_t status_details_capacity_;
// Server send status
- const Status *send_status_;
+ const Status* send_status_;
size_t trailing_metadata_count_;
- grpc_metadata *trailing_metadata_;
+ grpc_metadata* trailing_metadata_;
int cancelled_buf_;
- bool *recv_closed_;
+ bool* recv_closed_;
};
// Channel and Server implement this to allow them to hook performing ops
class CallHook {
public:
virtual ~CallHook() {}
- virtual void PerformOpsOnCall(CallOpBuffer *ops, Call *call) = 0;
+ virtual void PerformOpsOnCall(CallOpBuffer* ops, Call* call) = 0;
};
// Straightforward wrapping of the C call object
class Call GRPC_FINAL {
public:
/* call is owned by the caller */
- Call(grpc_call *call, CallHook *call_hook_, CompletionQueue *cq);
+ Call(grpc_call* call, CallHook* call_hook_, CompletionQueue* cq);
- void PerformOps(CallOpBuffer *buffer);
+ void PerformOps(CallOpBuffer* buffer);
- grpc_call *call() { return call_; }
- CompletionQueue *cq() { return cq_; }
+ grpc_call* call() { return call_; }
+ CompletionQueue* cq() { return cq_; }
private:
- CallHook *call_hook_;
- CompletionQueue *cq_;
- grpc_call *call_;
+ CallHook* call_hook_;
+ CompletionQueue* cq_;
+ grpc_call* call_;
};
} // namespace grpc
diff --git a/include/grpc++/impl/client_unary_call.h b/include/grpc++/impl/client_unary_call.h
index fd9715d..0e8aeed 100644
--- a/include/grpc++/impl/client_unary_call.h
+++ b/include/grpc++/impl/client_unary_call.h
@@ -45,10 +45,10 @@
class Status;
// Wrapper that performs a blocking unary call
-Status BlockingUnaryCall(ChannelInterface *channel, const RpcMethod &method,
- ClientContext *context,
- const grpc::protobuf::Message &request,
- grpc::protobuf::Message *result);
+Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method,
+ ClientContext* context,
+ const grpc::protobuf::Message& request,
+ grpc::protobuf::Message* result);
} // namespace grpc
diff --git a/include/grpc/support/atm.h b/include/grpc/support/atm.h
index feca6b3..ba8d7f5 100644
--- a/include/grpc/support/atm.h
+++ b/include/grpc/support/atm.h
@@ -83,7 +83,7 @@
#include <grpc/support/atm_gcc_atomic.h>
#elif defined(GPR_GCC_SYNC)
#include <grpc/support/atm_gcc_sync.h>
-#elif defined(GPR_WIN32)
+#elif defined(GPR_WIN32_ATOMIC)
#include <grpc/support/atm_win32.h>
#else
#error could not determine platform for atm
diff --git a/include/grpc/support/atm_win32.h b/include/grpc/support/atm_win32.h
index 18bf372..8b53224 100644
--- a/include/grpc/support/atm_win32.h
+++ b/include/grpc/support/atm_win32.h
@@ -51,7 +51,7 @@
static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm *p) {
/* TODO(dklempner): Can we implement something better here? */
- gpr_atm_acq_load(p);
+ return gpr_atm_acq_load(p);
}
static __inline void gpr_atm_rel_store(gpr_atm *p, gpr_atm value) {
diff --git a/include/grpc/support/port_platform.h b/include/grpc/support/port_platform.h
index f04c2e7..1b613dc 100644
--- a/include/grpc/support/port_platform.h
+++ b/include/grpc/support/port_platform.h
@@ -43,11 +43,21 @@
#define GPR_ARCH_64 1
#define GPR_GETPID_IN_PROCESS_H 1
#define GPR_WINSOCK_SOCKET 1
+#ifdef __GNUC__
+#define GPR_GCC_ATOMIC 1
+#else
+#define GPR_WIN32_ATOMIC 1
+#endif
#elif defined(_WIN32) || defined(WIN32)
#define GPR_ARCH_32 1
#define GPR_WIN32 1
#define GPR_GETPID_IN_PROCESS_H 1
#define GPR_WINSOCK_SOCKET 1
+#ifdef __GNUC__
+#define GPR_GCC_ATOMIC 1
+#else
+#define GPR_WIN32_ATOMIC 1
+#endif
#elif defined(ANDROID) || defined(__ANDROID__)
#define GPR_ANDROID 1
#define GPR_ARCH_32 1
@@ -167,8 +177,8 @@
#endif
/* Validate platform combinations */
-#if defined(GPR_GCC_ATOMIC) + defined(GPR_GCC_SYNC) + defined(GPR_WIN32) != 1
-#error Must define exactly one of GPR_GCC_ATOMIC, GPR_GCC_SYNC, GPR_WIN32
+#if defined(GPR_GCC_ATOMIC) + defined(GPR_GCC_SYNC) + defined(GPR_WIN32_ATOMIC) != 1
+#error Must define exactly one of GPR_GCC_ATOMIC, GPR_GCC_SYNC, GPR_WIN32_ATOMIC
#endif
#if defined(GPR_ARCH_32) + defined(GPR_ARCH_64) != 1
diff --git a/src/cpp/client/channel.h b/src/cpp/client/channel.h
index a1de381..3980eba 100644
--- a/src/cpp/client/channel.h
+++ b/src/cpp/client/channel.h
@@ -51,16 +51,16 @@
class Channel GRPC_FINAL : public ChannelInterface {
public:
- Channel(const grpc::string &target, grpc_channel *c_channel);
+ Channel(const grpc::string& target, grpc_channel* c_channel);
~Channel() GRPC_OVERRIDE;
- virtual Call CreateCall(const RpcMethod &method, ClientContext *context,
- CompletionQueue *cq) GRPC_OVERRIDE;
- virtual void PerformOpsOnCall(CallOpBuffer *ops, Call *call) GRPC_OVERRIDE;
+ virtual Call CreateCall(const RpcMethod& method, ClientContext* context,
+ CompletionQueue* cq) GRPC_OVERRIDE;
+ virtual void PerformOpsOnCall(CallOpBuffer* ops, Call* call) GRPC_OVERRIDE;
private:
const grpc::string target_;
- grpc_channel *const c_channel_; // owned
+ grpc_channel* const c_channel_; // owned
};
} // namespace grpc
diff --git a/src/cpp/client/channel_arguments.cc b/src/cpp/client/channel_arguments.cc
index abf0fc1..87f8349 100644
--- a/src/cpp/client/channel_arguments.cc
+++ b/src/cpp/client/channel_arguments.cc
@@ -37,7 +37,7 @@
namespace grpc {
-void ChannelArguments::SetSslTargetNameOverride(const grpc::string &name) {
+void ChannelArguments::SetSslTargetNameOverride(const grpc::string& name) {
SetString(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, name);
}
@@ -50,32 +50,32 @@
return "";
}
-void ChannelArguments::SetInt(const grpc::string &key, int value) {
+void ChannelArguments::SetInt(const grpc::string& key, int value) {
grpc_arg arg;
arg.type = GRPC_ARG_INTEGER;
strings_.push_back(key);
- arg.key = const_cast<char *>(strings_.back().c_str());
+ arg.key = const_cast<char*>(strings_.back().c_str());
arg.value.integer = value;
args_.push_back(arg);
}
-void ChannelArguments::SetString(const grpc::string &key,
- const grpc::string &value) {
+void ChannelArguments::SetString(const grpc::string& key,
+ const grpc::string& value) {
grpc_arg arg;
arg.type = GRPC_ARG_STRING;
strings_.push_back(key);
- arg.key = const_cast<char *>(strings_.back().c_str());
+ arg.key = const_cast<char*>(strings_.back().c_str());
strings_.push_back(value);
- arg.value.string = const_cast<char *>(strings_.back().c_str());
+ arg.value.string = const_cast<char*>(strings_.back().c_str());
args_.push_back(arg);
}
-void ChannelArguments::SetChannelArgs(grpc_channel_args *channel_args) const {
+void ChannelArguments::SetChannelArgs(grpc_channel_args* channel_args) const {
channel_args->num_args = args_.size();
if (channel_args->num_args > 0) {
- channel_args->args = const_cast<grpc_arg *>(&args_[0]);
+ channel_args->args = const_cast<grpc_arg*>(&args_[0]);
}
}
diff --git a/src/cpp/client/client_context.cc b/src/cpp/client/client_context.cc
index 9f99f7b..de9f8c7 100644
--- a/src/cpp/client/client_context.cc
+++ b/src/cpp/client/client_context.cc
@@ -53,7 +53,7 @@
if (cq_) {
grpc_completion_queue_shutdown(cq_);
// Drain cq_.
- grpc_event *ev;
+ grpc_event* ev;
grpc_completion_type t;
do {
ev = grpc_completion_queue_next(cq_, gpr_inf_future);
@@ -65,7 +65,7 @@
}
void ClientContext::set_absolute_deadline(
- const system_clock::time_point &deadline) {
+ const system_clock::time_point& deadline) {
Timepoint2Timespec(deadline, &absolute_deadline_);
}
@@ -73,8 +73,8 @@
return Timespec2Timepoint(absolute_deadline_);
}
-void ClientContext::AddMetadata(const grpc::string &meta_key,
- const grpc::string &meta_value) {
+void ClientContext::AddMetadata(const grpc::string& meta_key,
+ const grpc::string& meta_value) {
send_initial_metadata_.insert(std::make_pair(meta_key, meta_value));
}
diff --git a/src/cpp/client/client_unary_call.cc b/src/cpp/client/client_unary_call.cc
index 5c179de..7e7ea78 100644
--- a/src/cpp/client/client_unary_call.cc
+++ b/src/cpp/client/client_unary_call.cc
@@ -42,10 +42,10 @@
namespace grpc {
// Wrapper that performs a blocking unary call
-Status BlockingUnaryCall(ChannelInterface *channel, const RpcMethod &method,
- ClientContext *context,
- const grpc::protobuf::Message &request,
- grpc::protobuf::Message *result) {
+Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method,
+ ClientContext* context,
+ const grpc::protobuf::Message& request,
+ grpc::protobuf::Message* result) {
CompletionQueue cq;
Call call(channel->CreateCall(method, context, &cq));
CallOpBuffer buf;
diff --git a/src/cpp/client/create_channel.cc b/src/cpp/client/create_channel.cc
index 57d215d..3014305 100644
--- a/src/cpp/client/create_channel.cc
+++ b/src/cpp/client/create_channel.cc
@@ -41,9 +41,10 @@
class ChannelArguments;
std::shared_ptr<ChannelInterface> CreateChannel(
- const grpc::string &target, const std::unique_ptr<Credentials> &creds,
- const ChannelArguments &args) {
- return creds ? creds->CreateChannel(target, args) :
- std::shared_ptr<ChannelInterface>(new Channel(target, grpc_lame_client_channel_create()));
+ const grpc::string& target, const std::unique_ptr<Credentials>& creds,
+ const ChannelArguments& args) {
+ return creds ? creds->CreateChannel(target, args)
+ : std::shared_ptr<ChannelInterface>(
+ new Channel(target, grpc_lame_client_channel_create()));
}
} // namespace grpc
diff --git a/src/cpp/proto/proto_utils.cc b/src/cpp/proto/proto_utils.cc
index 9254e58..b8de2ea 100644
--- a/src/cpp/proto/proto_utils.cc
+++ b/src/cpp/proto/proto_utils.cc
@@ -45,7 +45,7 @@
class GrpcBufferWriter GRPC_FINAL
: public ::grpc::protobuf::io::ZeroCopyOutputStream {
public:
- explicit GrpcBufferWriter(grpc_byte_buffer **bp,
+ explicit GrpcBufferWriter(grpc_byte_buffer** bp,
int block_size = kMaxBufferLength)
: block_size_(block_size), byte_count_(0), have_backup_(false) {
*bp = grpc_byte_buffer_create(NULL, 0);
@@ -58,7 +58,7 @@
}
}
- bool Next(void **data, int *size) GRPC_OVERRIDE {
+ bool Next(void** data, int* size) GRPC_OVERRIDE {
if (have_backup_) {
slice_ = backup_slice_;
have_backup_ = false;
@@ -89,7 +89,7 @@
private:
const int block_size_;
gpr_int64 byte_count_;
- gpr_slice_buffer *slice_buffer_;
+ gpr_slice_buffer* slice_buffer_;
bool have_backup_;
gpr_slice backup_slice_;
gpr_slice slice_;
@@ -98,7 +98,7 @@
class GrpcBufferReader GRPC_FINAL
: public ::grpc::protobuf::io::ZeroCopyInputStream {
public:
- explicit GrpcBufferReader(grpc_byte_buffer *buffer)
+ explicit GrpcBufferReader(grpc_byte_buffer* buffer)
: byte_count_(0), backup_count_(0) {
reader_ = grpc_byte_buffer_reader_create(buffer);
}
@@ -106,7 +106,7 @@
grpc_byte_buffer_reader_destroy(reader_);
}
- bool Next(const void **data, int *size) GRPC_OVERRIDE {
+ bool Next(const void** data, int* size) GRPC_OVERRIDE {
if (backup_count_ > 0) {
*data = GPR_SLICE_START_PTR(slice_) + GPR_SLICE_LENGTH(slice_) -
backup_count_;
@@ -123,12 +123,10 @@
return true;
}
- void BackUp(int count) GRPC_OVERRIDE {
- backup_count_ = count;
- }
+ void BackUp(int count) GRPC_OVERRIDE { backup_count_ = count; }
bool Skip(int count) GRPC_OVERRIDE {
- const void *data;
+ const void* data;
int size;
while (Next(&data, &size)) {
if (size >= count) {
@@ -149,18 +147,18 @@
private:
gpr_int64 byte_count_;
gpr_int64 backup_count_;
- grpc_byte_buffer_reader *reader_;
+ grpc_byte_buffer_reader* reader_;
gpr_slice slice_;
};
namespace grpc {
-bool SerializeProto(const grpc::protobuf::Message &msg, grpc_byte_buffer **bp) {
+bool SerializeProto(const grpc::protobuf::Message& msg, grpc_byte_buffer** bp) {
GrpcBufferWriter writer(bp);
return msg.SerializeToZeroCopyStream(&writer);
}
-bool DeserializeProto(grpc_byte_buffer *buffer, grpc::protobuf::Message *msg) {
+bool DeserializeProto(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg) {
GrpcBufferReader reader(buffer);
return msg->ParseFromZeroCopyStream(&reader);
}
diff --git a/src/cpp/proto/proto_utils.h b/src/cpp/proto/proto_utils.h
index 7a1b1f8..bc60dc9 100644
--- a/src/cpp/proto/proto_utils.h
+++ b/src/cpp/proto/proto_utils.h
@@ -43,11 +43,11 @@
// 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 grpc::protobuf::Message &msg,
- grpc_byte_buffer **buffer);
+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, grpc::protobuf::Message *msg);
+bool DeserializeProto(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg);
} // namespace grpc
diff --git a/src/cpp/server/async_generic_service.cc b/src/cpp/server/async_generic_service.cc
index 2009af7..07cb933 100644
--- a/src/cpp/server/async_generic_service.cc
+++ b/src/cpp/server/async_generic_service.cc
@@ -47,5 +47,4 @@
return &server_->cq_;
}
-} // namespace grpc
-
+} // namespace grpc
diff --git a/src/cpp/server/async_server_context.cc b/src/cpp/server/async_server_context.cc
index f21efcf..628822a 100644
--- a/src/cpp/server/async_server_context.cc
+++ b/src/cpp/server/async_server_context.cc
@@ -42,7 +42,7 @@
namespace grpc {
AsyncServerContext::AsyncServerContext(
- grpc_call *call, const grpc::string &method, const grpc::string &host,
+ grpc_call* call, const grpc::string& method, const grpc::string& host,
system_clock::time_point absolute_deadline)
: method_(method),
host_(host),
@@ -52,22 +52,22 @@
AsyncServerContext::~AsyncServerContext() { grpc_call_destroy(call_); }
-void AsyncServerContext::Accept(grpc_completion_queue *cq) {
+void AsyncServerContext::Accept(grpc_completion_queue* cq) {
GPR_ASSERT(grpc_call_server_accept_old(call_, cq, this) == GRPC_CALL_OK);
GPR_ASSERT(grpc_call_server_end_initial_metadata_old(
call_, GRPC_WRITE_BUFFER_HINT) == GRPC_CALL_OK);
}
-bool AsyncServerContext::StartRead(grpc::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 grpc::protobuf::Message &response,
+bool AsyncServerContext::StartWrite(const grpc::protobuf::Message& response,
int flags) {
- grpc_byte_buffer *buffer = nullptr;
+ grpc_byte_buffer* buffer = nullptr;
if (!SerializeProto(response, &buffer)) {
return false;
}
@@ -76,16 +76,16 @@
return err == GRPC_CALL_OK;
}
-bool AsyncServerContext::StartWriteStatus(const Status &status) {
+bool AsyncServerContext::StartWriteStatus(const Status& status) {
grpc_call_error err = grpc_call_start_write_status_old(
call_, static_cast<grpc_status_code>(status.code()),
status.details().empty() ? nullptr
- : const_cast<char *>(status.details().c_str()),
+ : const_cast<char*>(status.details().c_str()),
this);
return err == GRPC_CALL_OK;
}
-bool AsyncServerContext::ParseRead(grpc_byte_buffer *read_buffer) {
+bool AsyncServerContext::ParseRead(grpc_byte_buffer* read_buffer) {
GPR_ASSERT(request_);
bool success = DeserializeProto(read_buffer, request_);
request_ = nullptr;
diff --git a/src/cpp/server/insecure_server_credentials.cc b/src/cpp/server/insecure_server_credentials.cc
index f5e4732..55dd90d 100644
--- a/src/cpp/server/insecure_server_credentials.cc
+++ b/src/cpp/server/insecure_server_credentials.cc
@@ -46,7 +46,8 @@
} // namespace
std::shared_ptr<ServerCredentials> InsecureServerCredentials() {
- return std::shared_ptr<ServerCredentials>(new InsecureServerCredentialsImpl());
+ return std::shared_ptr<ServerCredentials>(
+ new InsecureServerCredentialsImpl());
}
} // namespace grpc
diff --git a/src/cpp/server/secure_server_credentials.cc b/src/cpp/server/secure_server_credentials.cc
index ff35638..88f7a9b 100644
--- a/src/cpp/server/secure_server_credentials.cc
+++ b/src/cpp/server/secure_server_credentials.cc
@@ -40,7 +40,8 @@
namespace {
class SecureServerCredentials GRPC_FINAL : public ServerCredentials {
public:
- explicit SecureServerCredentials(grpc_server_credentials* creds) : creds_(creds) {}
+ explicit SecureServerCredentials(grpc_server_credentials* creds)
+ : creds_(creds) {}
~SecureServerCredentials() GRPC_OVERRIDE {
grpc_server_credentials_release(creds_);
}
@@ -56,16 +57,17 @@
} // namespace
std::shared_ptr<ServerCredentials> SslServerCredentials(
- const SslServerCredentialsOptions &options) {
+ const SslServerCredentialsOptions& options) {
std::vector<grpc_ssl_pem_key_cert_pair> pem_key_cert_pairs;
- for (const auto &key_cert_pair : options.pem_key_cert_pairs) {
+ for (const auto& key_cert_pair : options.pem_key_cert_pairs) {
pem_key_cert_pairs.push_back(
{key_cert_pair.private_key.c_str(), key_cert_pair.cert_chain.c_str()});
}
- grpc_server_credentials *c_creds = grpc_ssl_server_credentials_create(
+ grpc_server_credentials* c_creds = grpc_ssl_server_credentials_create(
options.pem_root_certs.empty() ? nullptr : options.pem_root_certs.c_str(),
&pem_key_cert_pairs[0], pem_key_cert_pairs.size());
- return std::shared_ptr<ServerCredentials>(new SecureServerCredentials(c_creds));
+ return std::shared_ptr<ServerCredentials>(
+ new SecureServerCredentials(c_creds));
}
} // namespace grpc
diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc
index 4d5e77e..4ed4c45 100644
--- a/src/cpp/server/server.cc
+++ b/src/cpp/server/server.cc
@@ -322,11 +322,10 @@
payload_(nullptr) {
memset(&array_, 0, sizeof(array_));
grpc_call_details_init(&call_details_);
- grpc_server_request_call(
- server->server_, &call_, &call_details_, &array_, cq->cq(), this);
+ grpc_server_request_call(server->server_, &call_, &call_details_, &array_,
+ cq->cq(), this);
}
-
~AsyncRequest() {
if (payload_) {
grpc_byte_buffer_destroy(payload_);
diff --git a/src/cpp/server/server_builder.cc b/src/cpp/server/server_builder.cc
index 835596d..2f5a0dc 100644
--- a/src/cpp/server/server_builder.cc
+++ b/src/cpp/server/server_builder.cc
@@ -56,7 +56,8 @@
if (generic_service_) {
gpr_log(GPR_ERROR,
"Adding multiple AsyncGenericService is unsupported for now. "
- "Dropping the service %p", service);
+ "Dropping the service %p",
+ service);
return;
}
generic_service_ = service;
diff --git a/src/cpp/server/thread_pool.cc b/src/cpp/server/thread_pool.cc
index 5dc9bcf..d3013b8 100644
--- a/src/cpp/server/thread_pool.cc
+++ b/src/cpp/server/thread_pool.cc
@@ -66,12 +66,12 @@
shutdown_ = true;
cv_.notify_all();
}
- for (auto &t : threads_) {
+ for (auto& t : threads_) {
t.join();
}
}
-void ThreadPool::ScheduleCallback(const std::function<void()> &callback) {
+void ThreadPool::ScheduleCallback(const std::function<void()>& callback) {
std::lock_guard<std::mutex> lock(mu_);
callbacks_.push(callback);
cv_.notify_one();
diff --git a/src/cpp/server/thread_pool.h b/src/cpp/server/thread_pool.h
index 6157e40..6225d82 100644
--- a/src/cpp/server/thread_pool.h
+++ b/src/cpp/server/thread_pool.h
@@ -50,7 +50,7 @@
explicit ThreadPool(int num_threads);
~ThreadPool();
- void ScheduleCallback(const std::function<void()> &callback) GRPC_OVERRIDE;
+ void ScheduleCallback(const std::function<void()>& callback) GRPC_OVERRIDE;
private:
std::mutex mu_;
diff --git a/src/cpp/util/slice.cc b/src/cpp/util/slice.cc
index a549c50..57370da 100644
--- a/src/cpp/util/slice.cc
+++ b/src/cpp/util/slice.cc
@@ -37,9 +37,7 @@
Slice::Slice() : slice_(gpr_empty_slice()) {}
-Slice::~Slice() {
- gpr_slice_unref(slice_);
-}
+Slice::~Slice() { gpr_slice_unref(slice_); }
Slice::Slice(gpr_slice slice, AddRef) : slice_(gpr_slice_ref(slice)) {}
diff --git a/src/cpp/util/status.cc b/src/cpp/util/status.cc
index bbf8030..b694a51 100644
--- a/src/cpp/util/status.cc
+++ b/src/cpp/util/status.cc
@@ -35,7 +35,7 @@
namespace grpc {
-const Status &Status::OK = Status();
-const Status &Status::Cancelled = Status(StatusCode::CANCELLED);
+const Status& Status::OK = Status();
+const Status& Status::Cancelled = Status(StatusCode::CANCELLED);
} // namespace grpc
diff --git a/src/cpp/util/time.cc b/src/cpp/util/time.cc
index 919e562..44d2283 100644
--- a/src/cpp/util/time.cc
+++ b/src/cpp/util/time.cc
@@ -43,8 +43,8 @@
namespace grpc {
// TODO(yangg) prevent potential overflow.
-void Timepoint2Timespec(const system_clock::time_point &from,
- gpr_timespec *to) {
+void Timepoint2Timespec(const system_clock::time_point& from,
+ gpr_timespec* to) {
system_clock::duration deadline = from.time_since_epoch();
seconds secs = duration_cast<seconds>(deadline);
nanoseconds nsecs = duration_cast<nanoseconds>(deadline - secs);
diff --git a/src/cpp/util/time.h b/src/cpp/util/time.h
index 1994848..8b7fcf5 100644
--- a/src/cpp/util/time.h
+++ b/src/cpp/util/time.h
@@ -41,8 +41,8 @@
namespace grpc {
// from and to should be absolute time.
-void Timepoint2Timespec(const std::chrono::system_clock::time_point &from,
- gpr_timespec *to);
+void Timepoint2Timespec(const std::chrono::system_clock::time_point& from,
+ gpr_timespec* to);
std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t);
diff --git a/src/node/ext/call.cc b/src/node/ext/call.cc
index afb6541..8cc3e38 100644
--- a/src/node/ext/call.cc
+++ b/src/node/ext/call.cc
@@ -75,6 +75,9 @@
NanCallback *Call::constructor;
Persistent<FunctionTemplate> Call::fun_tpl;
+bool EndsWith(const char *str, const char *substr) {
+ return strcmp(str+strlen(str)-strlen(substr), substr) == 0;
+}
bool CreateMetadataArray(Handle<Object> metadata, grpc_metadata_array *array,
shared_ptr<Resources> resources) {
@@ -99,14 +102,19 @@
Handle<Value> value = values->Get(j);
grpc_metadata *current = &array->metadata[array->count];
current->key = **utf8_key;
- if (::node::Buffer::HasInstance(value)) {
- current->value = ::node::Buffer::Data(value);
- current->value_length = ::node::Buffer::Length(value);
- Persistent<Value> *handle = new Persistent<Value>();
- NanAssignPersistent(*handle, value);
- resources->handles.push_back(unique_ptr<PersistentHolder>(
- new PersistentHolder(handle)));
- } else if (value->IsString()) {
+ // Only allow binary headers for "-bin" keys
+ if (EndsWith(current->key, "-bin")) {
+ if (::node::Buffer::HasInstance(value)) {
+ current->value = ::node::Buffer::Data(value);
+ current->value_length = ::node::Buffer::Length(value);
+ Persistent<Value> *handle = new Persistent<Value>();
+ NanAssignPersistent(*handle, value);
+ resources->handles.push_back(unique_ptr<PersistentHolder>(
+ new PersistentHolder(handle)));
+ continue;
+ }
+ }
+ if (value->IsString()) {
Handle<String> string_value = value->ToString();
NanUtf8String *utf8_value = new NanUtf8String(string_value);
resources->strings.push_back(unique_ptr<NanUtf8String>(utf8_value));
@@ -146,9 +154,13 @@
array = NanNew<Array>(size_map[elem->key]);
metadata_object->Set(key_string, array);
}
- array->Set(index_map[elem->key],
- MakeFastBuffer(
- NanNewBufferHandle(elem->value, elem->value_length)));
+ if (EndsWith(elem->key, "-bin")) {
+ array->Set(index_map[elem->key],
+ MakeFastBuffer(
+ NanNewBufferHandle(elem->value, elem->value_length)));
+ } else {
+ array->Set(index_map[elem->key], NanNew(elem->value));
+ }
index_map[elem->key] += 1;
}
return NanEscapeScope(metadata_object);
diff --git a/src/node/package.json b/src/node/package.json
index 1d0aa0e..9f52f8c 100644
--- a/src/node/package.json
+++ b/src/node/package.json
@@ -1,6 +1,6 @@
{
"name": "grpc",
- "version": "0.5.5",
+ "version": "0.6.0",
"author": "Google Inc.",
"description": "gRPC Library for Node",
"homepage": "http://www.grpc.io/",
diff --git a/src/node/test/call_test.js b/src/node/test/call_test.js
index 7b2b36a..98158ff 100644
--- a/src/node/test/call_test.js
+++ b/src/node/test/call_test.js
@@ -142,8 +142,8 @@
assert.doesNotThrow(function() {
var batch = {};
batch[grpc.opType.SEND_INITIAL_METADATA] = {
- 'key1': [new Buffer('value1')],
- 'key2': [new Buffer('value2')]
+ 'key1-bin': [new Buffer('value1')],
+ 'key2-bin': [new Buffer('value2')]
};
call.startBatch(batch, function(err, resp) {
assert.ifError(err);
diff --git a/src/node/test/end_to_end_test.js b/src/node/test/end_to_end_test.js
index c39364d..60e9861 100644
--- a/src/node/test/end_to_end_test.js
+++ b/src/node/test/end_to_end_test.js
@@ -138,21 +138,21 @@
client_batch[grpc.opType.RECV_STATUS_ON_CLIENT] = true;
call.startBatch(client_batch, function(err, response) {
assert.ifError(err);
- assert(response['send metadata']);
- assert(response['client close']);
- assert(response.hasOwnProperty('metadata'));
- assert.strictEqual(response.metadata.server_key[0].toString(),
- 'server_value');
- assert.deepEqual(response.status, {'code': grpc.status.OK,
- 'details': status_text,
- 'metadata': {}});
+ assert.deepEqual(response,{
+ 'send metadata': true,
+ 'client close': true,
+ metadata: {server_key: ['server_value']},
+ status: {'code': grpc.status.OK,
+ 'details': status_text,
+ 'metadata': {}}
+ });
done();
});
server.requestCall(function(err, call_details) {
var new_call = call_details['new call'];
assert.notEqual(new_call, null);
- assert.strictEqual(new_call.metadata.client_key[0].toString(),
+ assert.strictEqual(new_call.metadata.client_key[0],
'client_value');
var server_call = new_call.call;
assert.notEqual(server_call, null);
diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.c
index f345ceb..66b5407 100644
--- a/test/core/transport/metadata_test.c
+++ b/test/core/transport/metadata_test.c
@@ -178,7 +178,7 @@
grpc_mdctx *ctx;
int i, j;
char *buffer;
- int nstrs = 10000;
+ int nstrs = 1000;
grpc_mdstr **strs = gpr_malloc(sizeof(grpc_mdstr *) * nstrs);
int *shuf = gpr_malloc(sizeof(int) * nstrs);
grpc_mdstr *test;
diff --git a/test/cpp/client/credentials_test.cc b/test/cpp/client/credentials_test.cc
index 59ca33c..24251f2 100644
--- a/test/cpp/client/credentials_test.cc
+++ b/test/cpp/client/credentials_test.cc
@@ -54,7 +54,7 @@
} // namespace testing
} // namespace grpc
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
grpc_init();
int ret = RUN_ALL_TESTS();
diff --git a/test/cpp/end2end/async_end2end_test.cc b/test/cpp/end2end/async_end2end_test.cc
index e011b78..4a71a84 100644
--- a/test/cpp/end2end/async_end2end_test.cc
+++ b/test/cpp/end2end/async_end2end_test.cc
@@ -66,7 +66,7 @@
namespace {
-void* tag(int i) { return (void*)(gpr_intptr)i; }
+void* tag(int i) { return (void*)(gpr_intptr) i; }
void verify_ok(CompletionQueue* cq, int i, bool expect_ok) {
bool ok;
@@ -76,11 +76,11 @@
EXPECT_EQ(tag(i), got_tag);
}
-void verify_timed_ok(CompletionQueue* cq, int i, bool expect_ok,
- std::chrono::system_clock::time_point deadline =
- std::chrono::system_clock::time_point::max(),
- CompletionQueue::NextStatus expected_outcome =
- CompletionQueue::GOT_EVENT) {
+void verify_timed_ok(
+ CompletionQueue* cq, int i, bool expect_ok,
+ std::chrono::system_clock::time_point deadline =
+ std::chrono::system_clock::time_point::max(),
+ CompletionQueue::NextStatus expected_outcome = CompletionQueue::GOT_EVENT) {
bool ok;
void* got_tag;
EXPECT_EQ(cq->AsyncNext(&got_tag, &ok, deadline), expected_outcome);
@@ -195,18 +195,17 @@
grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx);
send_request.set_message("Hello");
- std::unique_ptr<ClientAsyncResponseReader<EchoResponse> >
- response_reader(stub_->AsyncEcho(&cli_ctx, send_request,
- &cli_cq_, tag(1)));
+ std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader(
+ stub_->AsyncEcho(&cli_ctx, send_request, &cli_cq_, tag(1)));
- std::chrono::system_clock::time_point
- time_now(std::chrono::system_clock::now()),
- time_limit(std::chrono::system_clock::now()+std::chrono::seconds(5));
+ std::chrono::system_clock::time_point time_now(
+ std::chrono::system_clock::now()),
+ time_limit(std::chrono::system_clock::now() + std::chrono::seconds(5));
verify_timed_ok(&srv_cq_, -1, true, time_now, CompletionQueue::TIMEOUT);
verify_timed_ok(&cli_cq_, -1, true, time_now, CompletionQueue::TIMEOUT);
service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, &srv_cq_,
- tag(2));
+ tag(2));
verify_timed_ok(&srv_cq_, 2, true, time_limit);
EXPECT_EQ(send_request.message(), recv_request.message());
@@ -221,9 +220,8 @@
EXPECT_EQ(send_response.message(), recv_response.message());
EXPECT_TRUE(recv_status.IsOk());
-
}
-
+
// Two pings and a final pong.
TEST_F(AsyncEnd2endTest, SimpleClientStreaming) {
ResetStub();
diff --git a/test/cpp/end2end/generic_end2end_test.cc b/test/cpp/end2end/generic_end2end_test.cc
index 4a0d2c5..a2faa62 100644
--- a/test/cpp/end2end/generic_end2end_test.cc
+++ b/test/cpp/end2end/generic_end2end_test.cc
@@ -68,7 +68,7 @@
namespace testing {
namespace {
-void* tag(int i) { return (void*)(gpr_intptr)i; }
+void* tag(int i) { return (void*)(gpr_intptr) i; }
void verify_ok(CompletionQueue* cq, int i, bool expect_ok) {
bool ok;
@@ -91,7 +91,7 @@
class GenericEnd2endTest : public ::testing::Test {
protected:
- GenericEnd2endTest() : generic_service_("*") {}
+ GenericEnd2endTest() : generic_service_("*") {}
void SetUp() GRPC_OVERRIDE {
int port = grpc_pick_unused_port_or_die();
@@ -116,8 +116,8 @@
}
void ResetStub() {
- std::shared_ptr<ChannelInterface> channel =
- CreateChannel(server_address_.str(), InsecureCredentials(), ChannelArguments());
+ std::shared_ptr<ChannelInterface> channel = CreateChannel(
+ server_address_.str(), InsecureCredentials(), ChannelArguments());
stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel));
}
@@ -238,7 +238,6 @@
client_ok(6);
EXPECT_EQ(send_response.message(), recv_response.message());
-
cli_stream->WritesDone(tag(7));
client_ok(7);
diff --git a/test/cpp/interop/client.cc b/test/cpp/interop/client.cc
index e5645e5..de6c6b7 100644
--- a/test/cpp/interop/client.cc
+++ b/test/cpp/interop/client.cc
@@ -161,6 +161,15 @@
}
}
+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 =
@@ -172,8 +181,8 @@
ClientContext context;
grpc::Status s = stub->EmptyCall(&context, request, &response);
+ AssertOkOrPrintErrorStatus(s);
- GPR_ASSERT(s.IsOk());
gpr_log(GPR_INFO, "Empty rpc done.");
}
@@ -190,7 +199,7 @@
grpc::Status s = stub->UnaryCall(&context, *request, response);
- GPR_ASSERT(s.IsOk());
+ AssertOkOrPrintErrorStatus(s);
GPR_ASSERT(response->payload().type() ==
grpc::testing::PayloadType::COMPRESSABLE);
GPR_ASSERT(response->payload().body() ==
@@ -237,8 +246,7 @@
}
void DoJwtTokenCreds() {
- gpr_log(GPR_INFO,
- "Sending a large unary rpc with JWT token credentials ...");
+ gpr_log(GPR_INFO, "Sending a large unary rpc with JWT token credentials ...");
std::shared_ptr<ChannelInterface> channel =
CreateChannelForTestCase("jwt_token_creds");
SimpleRequest request;
@@ -285,7 +293,7 @@
grpc::Status s = stream->Finish();
GPR_ASSERT(response.aggregated_payload_size() == aggregated_payload_size);
- GPR_ASSERT(s.IsOk());
+ AssertOkOrPrintErrorStatus(s);
gpr_log(GPR_INFO, "Request streaming done.");
}
@@ -314,7 +322,7 @@
GPR_ASSERT(response_stream_sizes.size() == i);
grpc::Status s = stream->Finish();
- GPR_ASSERT(s.IsOk());
+ AssertOkOrPrintErrorStatus(s);
gpr_log(GPR_INFO, "Response streaming done.");
}
@@ -346,7 +354,7 @@
GPR_ASSERT(kNumResponseMessages == i);
grpc::Status s = stream->Finish();
- GPR_ASSERT(s.IsOk());
+ AssertOkOrPrintErrorStatus(s);
gpr_log(GPR_INFO, "Response streaming done.");
}
@@ -379,7 +387,7 @@
}
GPR_ASSERT(response_stream_sizes.size() == i);
grpc::Status s = stream->Finish();
- GPR_ASSERT(s.IsOk());
+ AssertOkOrPrintErrorStatus(s);
gpr_log(GPR_INFO, "Half-duplex streaming rpc done.");
}
@@ -412,7 +420,7 @@
stream->WritesDone();
GPR_ASSERT(!stream->Read(&response));
grpc::Status s = stream->Finish();
- GPR_ASSERT(s.IsOk());
+ AssertOkOrPrintErrorStatus(s);
gpr_log(GPR_INFO, "Ping pong streaming done.");
}
diff --git a/test/cpp/interop/interop_test.cc b/test/cpp/interop/interop_test.cc
index 811e0eb..a7a5cc0 100644
--- a/test/cpp/interop/interop_test.cc
+++ b/test/cpp/interop/interop_test.cc
@@ -54,13 +54,13 @@
#include <grpc/support/log.h>
#include "test/core/util/port.h"
-int test_client(const char *root, const char *host, int port) {
+int test_client(const char* root, const char* host, int port) {
int status;
pid_t cli;
cli = fork();
if (cli == 0) {
- char *binary_path;
- char *port_arg;
+ char* binary_path;
+ char* port_arg;
gpr_asprintf(&binary_path, "%s/interop_client", root);
gpr_asprintf(&port_arg, "--server_port=%d", port);
@@ -78,9 +78,9 @@
return 0;
}
-int main(int argc, char **argv) {
- char *me = argv[0];
- char *lslash = strrchr(me, '/');
+int main(int argc, char** argv) {
+ char* me = argv[0];
+ char* lslash = strrchr(me, '/');
char root[1024];
int port = grpc_pick_unused_port_or_die();
int status;
@@ -104,8 +104,8 @@
/* start the server */
svr = fork();
if (svr == 0) {
- char *binary_path;
- char *port_arg;
+ char* binary_path;
+ char* port_arg;
gpr_asprintf(&binary_path, "%s/interop_server", root);
gpr_asprintf(&port_arg, "--port=%d", port);
diff --git a/test/cpp/qps/client_async.cc b/test/cpp/qps/client_async.cc
index c6535be..526f37a 100644
--- a/test/cpp/qps/client_async.cc
+++ b/test/cpp/qps/client_async.cc
@@ -61,23 +61,23 @@
virtual ~ClientRpcContext() {}
virtual bool RunNextState() = 0; // do next state, return false if steps done
virtual void StartNewClone() = 0;
- static void *tag(ClientRpcContext *c) { return reinterpret_cast<void *>(c); }
- static ClientRpcContext *detag(void *t) {
- return reinterpret_cast<ClientRpcContext *>(t);
+ static void* tag(ClientRpcContext* c) { return reinterpret_cast<void*>(c); }
+ static ClientRpcContext* detag(void* t) {
+ return reinterpret_cast<ClientRpcContext*>(t);
}
- virtual void report_stats(Histogram *hist) = 0;
+ virtual void report_stats(Histogram* hist) = 0;
};
template <class RequestType, class ResponseType>
class ClientRpcContextUnaryImpl : public ClientRpcContext {
public:
ClientRpcContextUnaryImpl(
- TestService::Stub *stub, const RequestType &req,
+ TestService::Stub* stub, const RequestType& req,
std::function<
std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>(
- TestService::Stub *, grpc::ClientContext *, const RequestType &,
- void *)> start_req,
- std::function<void(grpc::Status, ResponseType *)> on_done)
+ TestService::Stub*, grpc::ClientContext*, const RequestType&,
+ void*)> start_req,
+ std::function<void(grpc::Status, ResponseType*)> on_done)
: context_(),
stub_(stub),
req_(req),
@@ -90,7 +90,7 @@
start_req(stub_, &context_, req_, ClientRpcContext::tag(this))) {}
~ClientRpcContextUnaryImpl() GRPC_OVERRIDE {}
bool RunNextState() GRPC_OVERRIDE { return (this->*next_state_)(); }
- void report_stats(Histogram *hist) GRPC_OVERRIDE {
+ void report_stats(Histogram* hist) GRPC_OVERRIDE {
hist->Add((Timer::Now() - start_) * 1e9);
}
@@ -113,13 +113,13 @@
return false;
}
grpc::ClientContext context_;
- TestService::Stub *stub_;
+ TestService::Stub* stub_;
RequestType req_;
ResponseType response_;
bool (ClientRpcContextUnaryImpl::*next_state_)();
- std::function<void(grpc::Status, ResponseType *)> callback_;
+ std::function<void(grpc::Status, ResponseType*)> callback_;
std::function<std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>(
- TestService::Stub *, grpc::ClientContext *, const RequestType &, void *)>
+ TestService::Stub*, grpc::ClientContext*, const RequestType&, void*)>
start_req_;
grpc::Status status_;
double start_;
@@ -129,13 +129,13 @@
class AsyncClient GRPC_FINAL : public Client {
public:
- explicit AsyncClient(const ClientConfig &config) : Client(config) {
+ explicit AsyncClient(const ClientConfig& config) : Client(config) {
for (int i = 0; i < config.async_client_threads(); i++) {
cli_cqs_.emplace_back(new CompletionQueue);
}
auto payload_size = config.payload_size();
- auto check_done = [payload_size](grpc::Status s, SimpleResponse *response) {
+ 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() ==
@@ -144,16 +144,16 @@
int t = 0;
for (int i = 0; i < config.outstanding_rpcs_per_channel(); i++) {
- for (auto &channel : channels_) {
- auto *cq = cli_cqs_[t].get();
+ for (auto& channel : channels_) {
+ auto* cq = cli_cqs_[t].get();
t = (t + 1) % cli_cqs_.size();
- auto start_req = [cq](TestService::Stub *stub, grpc::ClientContext *ctx,
- const SimpleRequest &request, void *tag) {
+ auto start_req = [cq](TestService::Stub* stub, grpc::ClientContext* ctx,
+ const SimpleRequest& request, void* tag) {
return stub->AsyncUnaryCall(ctx, request, cq, tag);
};
- TestService::Stub *stub = channel.get_stub();
- const SimpleRequest &request = request_;
+ TestService::Stub* stub = channel.get_stub();
+ const SimpleRequest& request = request_;
new ClientRpcContextUnaryImpl<SimpleRequest, SimpleResponse>(
stub, request, start_req, check_done);
}
@@ -165,9 +165,9 @@
~AsyncClient() GRPC_OVERRIDE {
EndThreads();
- for (auto &cq : cli_cqs_) {
+ for (auto& cq : cli_cqs_) {
cq->Shutdown();
- void *got_tag;
+ void* got_tag;
bool ok;
while (cq->Next(&got_tag, &ok)) {
delete ClientRpcContext::detag(got_tag);
@@ -175,12 +175,12 @@
}
}
- void ThreadFunc(Histogram *histogram, size_t thread_idx) GRPC_OVERRIDE {
- void *got_tag;
+ void ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
+ void* got_tag;
bool ok;
cli_cqs_[thread_idx]->Next(&got_tag, &ok);
- ClientRpcContext *ctx = ClientRpcContext::detag(got_tag);
+ ClientRpcContext* ctx = ClientRpcContext::detag(got_tag);
if (ctx->RunNextState() == false) {
// call the callback and then delete it
ctx->report_stats(histogram);
@@ -193,7 +193,7 @@
std::vector<std::unique_ptr<CompletionQueue>> cli_cqs_;
};
-std::unique_ptr<Client> CreateAsyncClient(const ClientConfig &args) {
+std::unique_ptr<Client> CreateAsyncClient(const ClientConfig& args) {
return std::unique_ptr<Client>(new AsyncClient(args));
}
diff --git a/test/cpp/qps/qps_driver.cc b/test/cpp/qps/qps_driver.cc
index bf51e74..5e9a577 100644
--- a/test/cpp/qps/qps_driver.cc
+++ b/test/cpp/qps/qps_driver.cc
@@ -69,7 +69,7 @@
using namespace google;
using namespace gflags;
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_init();
ParseCommandLineFlags(&argc, &argv, true);
diff --git a/test/cpp/qps/server.cc b/test/cpp/qps/server.cc
index 005f0f9..6a207d8 100644
--- a/test/cpp/qps/server.cc
+++ b/test/cpp/qps/server.cc
@@ -73,8 +73,8 @@
// 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 { }
+namespace google {}
+namespace gflags {}
using namespace google;
using namespace gflags;
diff --git a/test/cpp/qps/server_async.cc b/test/cpp/qps/server_async.cc
index 19778e5..fcb5ac6 100644
--- a/test/cpp/qps/server_async.cc
+++ b/test/cpp/qps/server_async.cc
@@ -62,9 +62,9 @@
class AsyncQpsServerTest : public Server {
public:
- AsyncQpsServerTest(const ServerConfig &config, int port)
+ AsyncQpsServerTest(const ServerConfig& config, int port)
: srv_cq_(), async_service_(&srv_cq_), server_(nullptr) {
- char *server_address = NULL;
+ char* server_address = NULL;
gpr_join_host_port(&server_address, "::", port);
ServerBuilder builder;
@@ -87,10 +87,10 @@
threads_.push_back(std::thread([=]() {
// Wait until work is available or we are shutting down
bool ok;
- void *got_tag;
+ void* got_tag;
while (srv_cq_.Next(&got_tag, &ok)) {
if (ok) {
- ServerRpcContext *ctx = detag(got_tag);
+ 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
@@ -105,7 +105,7 @@
~AsyncQpsServerTest() {
server_->Shutdown();
srv_cq_.Shutdown();
- for (auto &thr : threads_) {
+ for (auto& thr : threads_) {
thr.join();
}
while (!contexts_.empty()) {
@@ -122,21 +122,21 @@
virtual bool RunNextState() = 0; // do next state, return false if all done
virtual void Reset() = 0; // start this back at a clean state
};
- static void *tag(ServerRpcContext *func) {
- return reinterpret_cast<void *>(func);
+ static void* tag(ServerRpcContext* func) {
+ return reinterpret_cast<void*>(func);
}
- static ServerRpcContext *detag(void *tag) {
- return reinterpret_cast<ServerRpcContext *>(tag);
+ static ServerRpcContext* detag(void* tag) {
+ return reinterpret_cast<ServerRpcContext*>(tag);
}
template <class RequestType, class ResponseType>
class ServerRpcContextUnaryImpl : public ServerRpcContext {
public:
ServerRpcContextUnaryImpl(
- std::function<void(ServerContext *, RequestType *,
- grpc::ServerAsyncResponseWriter<ResponseType> *,
- void *)> request_method,
- std::function<grpc::Status(const RequestType *, ResponseType *)>
+ std::function<void(ServerContext*, RequestType*,
+ grpc::ServerAsyncResponseWriter<ResponseType>*,
+ void*)> request_method,
+ std::function<grpc::Status(const RequestType*, ResponseType*)>
invoke_method)
: next_state_(&ServerRpcContextUnaryImpl::invoker),
request_method_(request_method),
@@ -175,16 +175,16 @@
ServerContext srv_ctx_;
RequestType req_;
bool (ServerRpcContextUnaryImpl::*next_state_)();
- std::function<void(ServerContext *, RequestType *,
- grpc::ServerAsyncResponseWriter<ResponseType> *, void *)>
+ std::function<void(ServerContext*, RequestType*,
+ grpc::ServerAsyncResponseWriter<ResponseType>*, void*)>
request_method_;
- std::function<grpc::Status(const RequestType *, ResponseType *)>
+ std::function<grpc::Status(const RequestType*, ResponseType*)>
invoke_method_;
grpc::ServerAsyncResponseWriter<ResponseType> response_writer_;
};
- static Status UnaryCall(const SimpleRequest *request,
- SimpleResponse *response) {
+ static Status UnaryCall(const SimpleRequest* request,
+ SimpleResponse* response) {
if (request->has_response_size() && request->response_size() > 0) {
if (!SetPayload(request->response_type(), request->response_size(),
response->mutable_payload())) {
@@ -197,13 +197,13 @@
TestService::AsyncService async_service_;
std::vector<std::thread> threads_;
std::unique_ptr<grpc::Server> server_;
- std::function<void(ServerContext *, SimpleRequest *,
- grpc::ServerAsyncResponseWriter<SimpleResponse> *, void *)>
+ std::function<void(ServerContext*, SimpleRequest*,
+ grpc::ServerAsyncResponseWriter<SimpleResponse>*, void*)>
request_unary_;
- std::forward_list<ServerRpcContext *> contexts_;
+ std::forward_list<ServerRpcContext*> contexts_;
};
-std::unique_ptr<Server> CreateAsyncServer(const ServerConfig &config,
+std::unique_ptr<Server> CreateAsyncServer(const ServerConfig& config,
int port) {
return std::unique_ptr<Server>(new AsyncQpsServerTest(config, port));
}
diff --git a/test/cpp/util/create_test_channel.cc b/test/cpp/util/create_test_channel.cc
index d3b84b2..f040acc 100644
--- a/test/cpp/util/create_test_channel.cc
+++ b/test/cpp/util/create_test_channel.cc
@@ -72,8 +72,7 @@
const grpc::string& connect_to =
server.empty() ? override_hostname : server;
if (creds.get()) {
- channel_creds =
- CompositeCredentials(creds, channel_creds);
+ channel_creds = CompositeCredentials(creds, channel_creds);
}
return CreateChannel(connect_to, channel_creds, channel_args);
} else {
diff --git a/test/cpp/util/status_test.cc b/test/cpp/util/status_test.cc
index 8c6a335..17b92ab 100644
--- a/test/cpp/util/status_test.cc
+++ b/test/cpp/util/status_test.cc
@@ -36,7 +36,7 @@
#include <grpc/support/log.h>
// Make sure the existing grpc_status_code match with grpc::Code.
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
GPR_ASSERT(grpc::StatusCode::OK ==
static_cast<grpc::StatusCode>(GRPC_STATUS_OK));
GPR_ASSERT(grpc::StatusCode::CANCELLED ==
diff --git a/tools/dockerfile/grpc_dist_proto/Dockerfile b/tools/dockerfile/grpc_dist_proto/Dockerfile
new file mode 100644
index 0000000..b4ed3b6
--- /dev/null
+++ b/tools/dockerfile/grpc_dist_proto/Dockerfile
@@ -0,0 +1,76 @@
+# 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.
+
+# Dockerfile to build protoc and plugins for inclusion in a release.
+FROM grpc/base
+
+# Add the file containing the gRPC version
+ADD version.txt version.txt
+
+# Install tools needed for building protoc.
+RUN apt-get update && apt-get -y install libgflags-dev libgtest-dev
+
+# Get the protobuf source from GitHub.
+RUN mkdir -p /var/local/git
+RUN git clone https://github.com/google/protobuf.git /var/local/git/protobuf
+
+# Build the protobuf library statically and install to /tmp/protoc_static.
+WORKDIR /var/local/git/protobuf
+RUN ./autogen.sh && \
+ ./configure --disable-shared --prefix=/tmp/protoc_static \
+ LDFLAGS="-lgcc_eh -static-libgcc -static-libstdc++" && \
+ make -j12 && make check && make install
+
+# Build the protobuf library dynamically and install to /usr/local.
+WORKDIR /var/local/git/protobuf
+RUN ./autogen.sh && \
+ ./configure --prefix=/usr/local && \
+ make -j12 && make check && make install
+
+# Build the grpc plugins.
+RUN git clone https://github.com/google/grpc.git /var/local/git/grpc
+WORKDIR /var/local/git/grpc
+RUN LDFLAGS=-static make plugins
+
+# Create an archive containing all the generated binaries.
+RUN mkdir /tmp/proto-bins_$(cat /version.txt)_linux-$(uname -m)
+RUN cp -v bins/opt/* /tmp/proto-bins_$(cat /version.txt)_linux-$(uname -m)
+RUN cp -v /tmp/protoc_static/bin/protoc /tmp/proto-bins_$(cat /version.txt)_linux-$(uname -m)
+RUN cd /tmp && \
+ tar -czf proto-bins_$(cat /version.txt)_linux-$(uname -m).tar.gz proto-bins_$(cat /version.txt)_linux-$(uname -m)
+
+# List the tar contents: provides a way to visually confirm that the contents
+# are correct.
+RUN echo 'proto-bins_$(cat /version.txt)_linux-tar-$(uname -m) contents:' && \
+ tar -ztf /tmp/proto-bins_$(cat /version.txt)_linux-$(uname -m).tar.gz
+
+
+
+
+
diff --git a/tools/dockerfile/grpc_dist_proto/version.txt b/tools/dockerfile/grpc_dist_proto/version.txt
new file mode 100644
index 0000000..8f0916f
--- /dev/null
+++ b/tools/dockerfile/grpc_dist_proto/version.txt
@@ -0,0 +1 @@
+0.5.0
diff --git a/tools/gce_setup/cloud_prod_runner.sh b/tools/gce_setup/cloud_prod_runner.sh
index 3a9ae51..e236c92 100755
--- a/tools/gce_setup/cloud_prod_runner.sh
+++ b/tools/gce_setup/cloud_prod_runner.sh
@@ -36,7 +36,7 @@
main() {
source grpc_docker.sh
test_cases=(large_unary empty_unary ping_pong client_streaming server_streaming cancel_after_begin cancel_after_first_response)
- auth_test_cases=(service_account_creds compute_engine_creds)
+ auth_test_cases=(service_account_creds compute_engine_creds jwt_token_creds)
clients=(cxx java go ruby node csharp_mono)
for test_case in "${test_cases[@]}"
do
diff --git a/tools/gce_setup/grpc_docker.sh b/tools/gce_setup/grpc_docker.sh
index 3deef05..497112c 100755
--- a/tools/gce_setup/grpc_docker.sh
+++ b/tools/gce_setup/grpc_docker.sh
@@ -560,7 +560,7 @@
_grpc_ensure_gcloud_ssh || return 1;
# declare vars local so that they don't pollute the shell environment
- # where they this func is used.
+ # where this func is used.
local grpc_zone grpc_project dry_run # set by _grpc_set_project_and_zone
local grpc_hosts grpc_gce_script_root
@@ -600,7 +600,7 @@
_grpc_ensure_gcloud_ssh || return 1;
# declare vars local so that they don't pollute the shell environment
- # where they this func is used.
+ # where this func is used.
local grpc_zone grpc_project dry_run # set by _grpc_set_project_and_zone
local grpc_hosts
@@ -645,7 +645,7 @@
# Shows the grpc servers on the GCE instance <server_name>
grpc_show_servers() {
# declare vars local so that they don't pollute the shell environment
- # where they this func is used.
+ # where this func is used.
local grpc_zone grpc_project dry_run # set by _grpc_set_project_and_zone
# set by _grpc_show_servers
local host
@@ -663,6 +663,58 @@
gcloud compute $project_opt ssh $zone_opt $host --command "$cmd"
}
+_grpc_build_proto_bins_args() {
+ [[ -n $1 ]] && { # host
+ host=$1
+ shift
+ } || {
+ host='grpc-docker-builder'
+ }
+}
+
+# grpc_build_proto_bins
+#
+# - rebuilds the dist_proto docker image
+# * doing this builds the protoc and the ruby, python and cpp bins statically
+#
+# - runs a docker command that copies the built protos to the GCE host
+# - copies the built protos to the local machine
+grpc_build_proto_bins() {
+ _grpc_ensure_gcloud_ssh || return 1;
+
+ # declare vars local so that they don't pollute the shell environment
+ # where this func is used.
+ local grpc_zone grpc_project dry_run # set by _grpc_set_project_and_zone
+ # set by _grpc_build_proto_bins_args
+ local host
+
+ # set the project zone and check that all necessary args are provided
+ _grpc_set_project_and_zone -f _grpc_build_proto_bins_args "$@" || return 1
+ gce_has_instance $grpc_project $host || return 1;
+ local project_opt="--project $grpc_project"
+ local zone_opt="--zone $grpc_zone"
+
+ # rebuild the dist_proto image
+ local label='dist_proto'
+ grpc_update_image -- -h $host $label || return 1
+
+ # run a command to copy the generated archive to the docker host
+ local docker_prefix='sudo docker run -v /tmp:/tmp/proto_bins_out'
+ local tar_name='proto-bins*.tar.gz'
+ local cp_cmd="/bin/bash -c 'cp -v /tmp/$tar_name /tmp/proto_bins_out'"
+ local cmd="$docker_prefix grpc/$label $cp_cmd"
+ local ssh_cmd="bash -l -c \"$cmd\""
+ echo "will run:"
+ echo " $ssh_cmd"
+ echo "on $host"
+ gcloud compute $project_opt ssh $zone_opt $host --command "$cmd" || return 1
+
+ # copy the tar.gz locally
+ local rmt_tar="$host:/tmp/$tar_name"
+ local local_copy="$(pwd)"
+ gcloud compute copy-files $rmt_tar $local_copy $project_opt $zone_opt || return 1
+}
+
_grpc_launch_servers_args() {
[[ -n $1 ]] && { # host
host=$1
@@ -690,7 +742,7 @@
# If no servers are specified, it launches all known servers
grpc_launch_servers() {
# declare vars local so that they don't pollute the shell environment
- # where they this func is used.
+ # where this func is used.
local grpc_zone grpc_project dry_run # set by _grpc_set_project_and_zone
# set by _grpc_launch_servers_args
local host servers
@@ -811,7 +863,7 @@
grpc_interop_test() {
_grpc_ensure_gcloud_ssh || return 1;
# declare vars local so that they don't pollute the shell environment
- # where they this func is used.
+ # where this func is used.
local grpc_zone grpc_project dry_run # set by _grpc_set_project_and_zone
# grpc_interop_test_args
@@ -853,7 +905,7 @@
grpc_cloud_prod_test() {
_grpc_ensure_gcloud_ssh || return 1;
# declare vars local so that they don't pollute the shell environment
- # where they this func is used.
+ # where this func is used.
local grpc_zone grpc_project dry_run # set by _grpc_set_project_and_zone
# grpc_cloud_prod_test_args
@@ -892,7 +944,7 @@
grpc_cloud_prod_auth_test() {
_grpc_ensure_gcloud_ssh || return 1;
# declare vars local so that they don't pollute the shell environment
- # where they this func is used.
+ # where this func is used.
local grpc_zone grpc_project dry_run # set by _grpc_set_project_and_zone
# grpc_cloud_prod_test_args
@@ -1192,6 +1244,20 @@
echo $the_cmd
}
+# constructs the full dockerized cpp jwt_token auth interop test cmd.
+#
+# call-seq:
+# flags= .... # generic flags to include the command
+# cmd=$($grpc_gen_test_cmd $flags)
+grpc_cloud_prod_auth_jwt_token_creds_gen_cxx_cmd() {
+ local cmd_prefix="sudo docker run grpc/cxx";
+ local test_script="/var/local/git/grpc/bins/opt/interop_client --enable_ssl --use_prod_roots";
+ local gfe_flags=$(_grpc_prod_gfe_flags)
+ local added_gfe_flags=$(_grpc_jwt_token_test_flags)
+ local the_cmd="$cmd_prefix $test_script $gfe_flags $added_gfe_flags $@";
+ echo $the_cmd
+}
+
# constructs the full dockerized csharp-mono interop test cmd.
#
# call-seq:
@@ -1230,6 +1296,11 @@
echo " --service_account_key_file=/service_account/stubbyCloudTestingTest-7dd63462c60c.json --oauth_scope=https://www.googleapis.com/auth/xapi.zoo"
}
+# outputs the flags passed to the service account auth tests
+_grpc_jwt_token_test_flags() {
+ echo " --service_account_key_file=/service_account/stubbyCloudTestingTest-7dd63462c60c.json"
+}
+
# default credentials test flag
_grpc_default_creds_test_flags() {
echo " --oauth_scope=https://www.googleapis.com/auth/xapi.zoo"