Merge github.com:google/grpc into api

9 files changed, 382 insertions, 7 deletions

diff --git a/include/grpc++/async_server_context.h b/include/grpc++/async_server_context.h
index 237a6856a4..c038286ac1 100644
--- a/include/grpc++/async_server_context.h
+++ b/include/grpc++/async_server_context.h
@@ -87,7 +87,7 @@ class AsyncServerContext {
   system_clock::time_point absolute_deadline_;
 
   google::protobuf::Message* request_;  // not owned
-  grpc_call* call_;           // owned
+  grpc_call* call_;                     // owned
 };
 
 }  // namespace grpc
diff --git a/include/grpc++/channel_interface.h b/include/grpc++/channel_interface.h
index 4b9d76e0d1..9ed35422b8 100644
--- a/include/grpc++/channel_interface.h
+++ b/include/grpc++/channel_interface.h
@@ -57,10 +57,10 @@ class ChannelInterface {
                                   const google::protobuf::Message& request,
                                   google::protobuf::Message* result) = 0;
 
-  virtual StreamContextInterface* CreateStream(const RpcMethod& method,
-                                               ClientContext* context,
-                                               const google::protobuf::Message* request,
-                                               google::protobuf::Message* result) = 0;
+  virtual StreamContextInterface* CreateStream(
+      const RpcMethod& method, ClientContext* context,
+      const google::protobuf::Message* request,
+      google::protobuf::Message* result) = 0;
 };
 
 }  // namespace grpc
diff --git a/include/grpc++/config.h b/include/grpc++/config.h
index 153b288f0c..52913fbf0f 100644
--- a/include/grpc++/config.h
+++ b/include/grpc++/config.h
@@ -39,7 +39,6 @@
 namespace grpc {
 
 typedef std::string string;
-
 }
 
 #endif  // __GRPCPP_CONFIG_H__
diff --git a/include/grpc++/create_channel.h b/include/grpc++/create_channel.h
index 3253c9f180..a8ce8b8ec8 100644
--- a/include/grpc++/create_channel.h
+++ b/include/grpc++/create_channel.h
@@ -46,6 +46,7 @@ class ChannelInterface;
 std::shared_ptr<ChannelInterface> CreateChannel(const grpc::string& target,
                                                 const ChannelArguments& args);
 
+// If creds does not hold an object or is invalid, a lame channel is returned.
 std::shared_ptr<ChannelInterface> CreateChannel(
     const grpc::string& target, const std::unique_ptr<Credentials>& creds,
     const ChannelArguments& args);
diff --git a/include/grpc++/credentials.h b/include/grpc++/credentials.h
index 3ad12edaae..987d890b4f 100644
--- a/include/grpc++/credentials.h
+++ b/include/grpc++/credentials.h
@@ -34,6 +34,7 @@
 #ifndef __GRPCPP_CREDENTIALS_H_
 #define __GRPCPP_CREDENTIALS_H_
 
+#include <chrono>
 #include <memory>
 
 #include <grpc++/config.h>
@@ -49,6 +50,7 @@ namespace grpc {
 class Credentials final {
  public:
   ~Credentials();
+
   // TODO(abhikumar): Specify a plugin API here to be implemented by
   // credentials that do not have a corresponding implementation in C.
 
@@ -63,6 +65,15 @@ class Credentials final {
 };
 
 // Options used to build SslCredentials
+// pem_roots_cert is the buffer containing the PEM encoding of the server root
+// certificates. This parameter cannot be empty.
+// pem_private_key is the buffer containing the PEM encoding of the client's
+// private key. This parameter can be empty if the client does not have a
+// private key.
+// pem_cert_chain is the buffer containing the PEM encoding of the client's
+// certificate chain. This parameter can be empty if the client does not have
+// a certificate chain.
+// TODO(jboeuf) Change it to point to a file.
 struct SslCredentialsOptions {
   grpc::string pem_root_certs;
   grpc::string pem_private_key;
@@ -70,6 +81,10 @@ struct SslCredentialsOptions {
 };
 
 // Factory for building different types of Credentials
+// The methods may return empty unique_ptr when credentials cannot be created.
+// If a Credentials pointer is returned, it can still be invalid when used to
+// create a channel. A lame channel will be created then and all rpcs will
+// fail on it.
 class CredentialsFactory {
  public:
   // Builds credentials with reasonable defaults.
@@ -82,6 +97,20 @@ class CredentialsFactory {
   // Builds credentials for use when running in GCE
   static std::unique_ptr<Credentials> ComputeEngineCredentials();
 
+  // Builds service account credentials.
+  // json_key is the JSON key string containing the client's private key.
+  // scope is a space-delimited list of the requested permissions.
+  // token_lifetime is the lifetime of each token acquired through this service
+  // account credentials. It should be positive and should not exceed
+  // grpc_max_auth_token_lifetime or will be cropped to this value.
+  static std::unique_ptr<Credentials> ServiceAccountCredentials(
+      const grpc::string& json_key, const grpc::string& scope,
+      std::chrono::seconds token_lifetime);
+
+  // Builds IAM credentials.
+  static std::unique_ptr<Credentials> IAMCredentials(
+      const grpc::string& authorization_token,
+      const grpc::string& authority_selector);
 
   // Combines two credentials objects into a composite credentials
   static std::unique_ptr<Credentials> ComposeCredentials(
diff --git a/include/grpc++/impl/internal_stub.h b/include/grpc++/impl/internal_stub.h
new file mode 100644
index 0000000000..b32fb3a27c
--- /dev/null
+++ b/include/grpc++/impl/internal_stub.h
@@ -0,0 +1,60 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPCPP_IMPL_INTERNAL_STUB_H__
+#define __GRPCPP_IMPL_INTERNAL_STUB_H__
+
+#include <memory>
+
+#include <grpc++/channel_interface.h>
+
+namespace grpc {
+
+class InternalStub {
+ public:
+  InternalStub() {}
+  virtual ~InternalStub() {}
+
+  void set_channel(const std::shared_ptr<ChannelInterface>& channel) {
+    channel_ = channel;
+  }
+
+  ChannelInterface* channel() { return channel_.get(); }
+
+ private:
+  std::shared_ptr<ChannelInterface> channel_;
+};
+
+}  // namespace grpc
+
+#endif  // __GRPCPP_IMPL_INTERNAL_STUB_H__
diff --git a/include/grpc++/impl/rpc_method.h b/include/grpc++/impl/rpc_method.h
new file mode 100644
index 0000000000..75fec356dd
--- /dev/null
+++ b/include/grpc++/impl/rpc_method.h
@@ -0,0 +1,69 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPCPP_IMPL_RPC_METHOD_H__
+#define __GRPCPP_IMPL_RPC_METHOD_H__
+
+namespace google {
+namespace protobuf {
+class Message;
+}
+}
+
+namespace grpc {
+
+class RpcMethod {
+ public:
+  enum RpcType {
+    NORMAL_RPC = 0,
+    CLIENT_STREAMING,  // request streaming
+    SERVER_STREAMING,  // response streaming
+    BIDI_STREAMING
+  };
+
+  explicit RpcMethod(const char* name)
+      : name_(name), method_type_(NORMAL_RPC) {}
+  RpcMethod(const char* name, RpcType type) : name_(name), method_type_(type) {}
+
+  const char* name() const { return name_; }
+
+  RpcType method_type() const { return method_type_; }
+
+ private:
+  const char* name_;
+  const RpcType method_type_;
+};
+
+}  // namespace grpc
+
+#endif  // __GRPCPP_IMPL_RPC_METHOD_H__
diff --git a/include/grpc++/impl/rpc_service_method.h b/include/grpc++/impl/rpc_service_method.h
new file mode 100644
index 0000000000..620de5e67f
--- /dev/null
+++ b/include/grpc++/impl/rpc_service_method.h
@@ -0,0 +1,218 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPCPP_IMPL_RPC_SERVICE_METHOD_H__
+#define __GRPCPP_IMPL_RPC_SERVICE_METHOD_H__
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include <grpc++/impl/rpc_method.h>
+#include <grpc++/status.h>
+#include <grpc++/stream.h>
+#include <google/protobuf/message.h>
+
+namespace grpc {
+class ServerContext;
+class StreamContextInterface;
+
+// TODO(rocking): we might need to split this file into multiple ones.
+
+// Base class for running an RPC handler.
+class MethodHandler {
+ public:
+  virtual ~MethodHandler() {}
+  struct HandlerParameter {
+    HandlerParameter(ServerContext* context,
+                     const google::protobuf::Message* req,
+                     google::protobuf::Message* resp)
+        : server_context(context),
+          request(req),
+          response(resp),
+          stream_context(nullptr) {}
+    HandlerParameter(ServerContext* context,
+                     const google::protobuf::Message* req,
+                     google::protobuf::Message* resp,
+                     StreamContextInterface* stream)
+        : server_context(context),
+          request(req),
+          response(resp),
+          stream_context(stream) {}
+    ServerContext* server_context;
+    const google::protobuf::Message* request;
+    google::protobuf::Message* response;
+    StreamContextInterface* stream_context;
+  };
+  virtual Status RunHandler(const HandlerParameter& param) = 0;
+};
+
+// A wrapper class of an application provided rpc method handler.
+template <class ServiceType, class RequestType, class ResponseType>
+class RpcMethodHandler : public MethodHandler {
+ public:
+  RpcMethodHandler(
+      std::function<Status(ServiceType*, ServerContext*, const RequestType*,
+                           ResponseType*)> func,
+      ServiceType* service)
+      : func_(func), service_(service) {}
+
+  Status RunHandler(const HandlerParameter& param) final {
+    // Invoke application function, cast proto messages to their actual types.
+    return func_(service_, param.server_context,
+                 dynamic_cast<const RequestType*>(param.request),
+                 dynamic_cast<ResponseType*>(param.response));
+  }
+
+ private:
+  // Application provided rpc handler function.
+  std::function<Status(ServiceType*, ServerContext*, const RequestType*,
+                       ResponseType*)> func_;
+  // The class the above handler function lives in.
+  ServiceType* service_;
+};
+
+// A wrapper class of an application provided client streaming handler.
+template <class ServiceType, class RequestType, class ResponseType>
+class ClientStreamingHandler : public MethodHandler {
+ public:
+  ClientStreamingHandler(
+      std::function<Status(ServiceType*, ServerContext*,
+                           ServerReader<RequestType>*, ResponseType*)> func,
+      ServiceType* service)
+      : func_(func), service_(service) {}
+
+  Status RunHandler(const HandlerParameter& param) final {
+    ServerReader<RequestType> reader(param.stream_context);
+    return func_(service_, param.server_context, &reader,
+                 dynamic_cast<ResponseType*>(param.response));
+  }
+
+ private:
+  std::function<Status(ServiceType*, ServerContext*, ServerReader<RequestType>*,
+                       ResponseType*)> func_;
+  ServiceType* service_;
+};
+
+// A wrapper class of an application provided server streaming handler.
+template <class ServiceType, class RequestType, class ResponseType>
+class ServerStreamingHandler : public MethodHandler {
+ public:
+  ServerStreamingHandler(
+      std::function<Status(ServiceType*, ServerContext*, const RequestType*,
+                           ServerWriter<ResponseType>*)> func,
+      ServiceType* service)
+      : func_(func), service_(service) {}
+
+  Status RunHandler(const HandlerParameter& param) final {
+    ServerWriter<ResponseType> writer(param.stream_context);
+    return func_(service_, param.server_context,
+                 dynamic_cast<const RequestType*>(param.request), &writer);
+  }
+
+ private:
+  std::function<Status(ServiceType*, ServerContext*, const RequestType*,
+                       ServerWriter<ResponseType>*)> func_;
+  ServiceType* service_;
+};
+
+// A wrapper class of an application provided bidi-streaming handler.
+template <class ServiceType, class RequestType, class ResponseType>
+class BidiStreamingHandler : public MethodHandler {
+ public:
+  BidiStreamingHandler(
+      std::function<Status(ServiceType*, ServerContext*,
+                           ServerReaderWriter<ResponseType, RequestType>*)>
+          func,
+      ServiceType* service)
+      : func_(func), service_(service) {}
+
+  Status RunHandler(const HandlerParameter& param) final {
+    ServerReaderWriter<ResponseType, RequestType> stream(param.stream_context);
+    return func_(service_, param.server_context, &stream);
+  }
+
+ private:
+  std::function<Status(ServiceType*, ServerContext*,
+                       ServerReaderWriter<ResponseType, RequestType>*)> func_;
+  ServiceType* service_;
+};
+
+// Server side rpc method class
+class RpcServiceMethod : public RpcMethod {
+ public:
+  // 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)
+      : RpcMethod(name, type),
+        handler_(handler),
+        request_prototype_(request_prototype),
+        response_prototype_(response_prototype) {}
+
+  MethodHandler* handler() { return handler_.get(); }
+
+  google::protobuf::Message* AllocateRequestProto() {
+    return request_prototype_->New();
+  }
+  google::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_;
+};
+
+// This class contains all the method information for an rpc service. It is
+// used for registering a service on a grpc server.
+class RpcService {
+ public:
+  // Takes ownership.
+  void AddMethod(RpcServiceMethod* method) {
+    methods_.push_back(std::unique_ptr<RpcServiceMethod>(method));
+  }
+
+  RpcServiceMethod* GetMethod(int i) { return methods_[i].get(); }
+  int GetMethodCount() const { return methods_.size(); }
+
+ private:
+  std::vector<std::unique_ptr<RpcServiceMethod>> methods_;
+};
+
+}  // namespace grpc
+
+#endif  // __GRPCPP_IMPL_RPC_SERVICE_METHOD_H__
diff --git a/include/grpc++/status_code_enum.h b/include/grpc++/status_code_enum.h
index 964420dcc4..4e0fda13db 100644
--- a/include/grpc++/status_code_enum.h
+++ b/include/grpc++/status_code_enum.h
@@ -34,7 +34,6 @@
 #ifndef __GRPCPP_STATUS_CODE_ENUM_H__
 #define __GRPCPP_STATUS_CODE_ENUM_H__
 
-
 namespace grpc {
 
 enum StatusCode {