diff options
Diffstat (limited to 'include/grpc++')
| -rw-r--r-- | include/grpc++/async_server_context.h | 2 | ||||
| -rw-r--r-- | include/grpc++/channel_interface.h | 8 | ||||
| -rw-r--r-- | include/grpc++/config.h | 1 | ||||
| -rw-r--r-- | include/grpc++/create_channel.h | 1 | ||||
| -rw-r--r-- | include/grpc++/credentials.h | 29 | ||||
| -rw-r--r-- | include/grpc++/impl/internal_stub.h | 60 | ||||
| -rw-r--r-- | include/grpc++/impl/rpc_method.h | 69 | ||||
| -rw-r--r-- | include/grpc++/impl/rpc_service_method.h | 218 | ||||
| -rw-r--r-- | include/grpc++/status_code_enum.h | 1 |
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 { |