1 /* 2 * 3 * Copyright 2016 gRPC authors. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 */ 18 19 #ifndef GRPCPP_IMPL_CODEGEN_RPC_SERVICE_METHOD_H 20 #define GRPCPP_IMPL_CODEGEN_RPC_SERVICE_METHOD_H 21 22 #include <climits> 23 #include <functional> 24 #include <map> 25 #include <memory> 26 #include <vector> 27 28 #include <grpc/impl/codegen/log.h> 29 #include <grpcpp/impl/codegen/byte_buffer.h> 30 #include <grpcpp/impl/codegen/config.h> 31 #include <grpcpp/impl/codegen/rpc_method.h> 32 #include <grpcpp/impl/codegen/status.h> 33 34 namespace grpc { 35 class ServerContextBase; 36 namespace internal { 37 /// Base class for running an RPC handler. 38 class MethodHandler { 39 public: ~MethodHandler()40 virtual ~MethodHandler() {} 41 struct HandlerParameter { 42 /// Constructor for HandlerParameter 43 /// 44 /// \param c : the gRPC Call structure for this server call 45 /// \param context : the ServerContext structure for this server call 46 /// \param req : the request payload, if appropriate for this RPC 47 /// \param req_status : the request status after any interceptors have run 48 /// \param handler_data: internal data for the handler. 49 /// \param requester : used only by the callback API. It is a function 50 /// called by the RPC Controller to request another RPC (and also 51 /// to set up the state required to make that request possible) HandlerParameterHandlerParameter52 HandlerParameter(Call* c, ::grpc::ServerContextBase* context, void* req, 53 Status req_status, void* handler_data, 54 std::function<void()> requester) 55 : call(c), 56 server_context(context), 57 request(req), 58 status(req_status), 59 internal_data(handler_data), 60 call_requester(std::move(requester)) {} ~HandlerParameterHandlerParameter61 ~HandlerParameter() {} 62 Call* const call; 63 ::grpc::ServerContextBase* const server_context; 64 void* const request; 65 const Status status; 66 void* const internal_data; 67 const std::function<void()> call_requester; 68 }; 69 virtual void RunHandler(const HandlerParameter& param) = 0; 70 71 /* Returns a pointer to the deserialized request. \a status reflects the 72 result of deserialization. This pointer and the status should be filled in 73 a HandlerParameter and passed to RunHandler. It is illegal to access the 74 pointer after calling RunHandler. Ownership of the deserialized request is 75 retained by the handler. Returns nullptr if deserialization failed. */ Deserialize(grpc_call *,grpc_byte_buffer * req,Status *,void **)76 virtual void* Deserialize(grpc_call* /*call*/, grpc_byte_buffer* req, 77 Status* /*status*/, void** /*handler_data*/) { 78 GPR_CODEGEN_ASSERT(req == nullptr); 79 return nullptr; 80 } 81 }; 82 83 /// Server side rpc method class 84 class RpcServiceMethod : public RpcMethod { 85 public: 86 /// Takes ownership of the handler RpcServiceMethod(const char * name,RpcMethod::RpcType type,MethodHandler * handler)87 RpcServiceMethod(const char* name, RpcMethod::RpcType type, 88 MethodHandler* handler) 89 : RpcMethod(name, type), 90 server_tag_(nullptr), 91 api_type_(ApiType::SYNC), 92 handler_(handler) {} 93 94 enum class ApiType { 95 SYNC, 96 ASYNC, 97 RAW, 98 CALL_BACK, // not CALLBACK because that is reserved in Windows 99 RAW_CALL_BACK, 100 }; 101 set_server_tag(void * tag)102 void set_server_tag(void* tag) { server_tag_ = tag; } server_tag()103 void* server_tag() const { return server_tag_; } 104 /// if MethodHandler is nullptr, then this is an async method handler()105 MethodHandler* handler() const { return handler_.get(); } api_type()106 ApiType api_type() const { return api_type_; } SetHandler(MethodHandler * handler)107 void SetHandler(MethodHandler* handler) { handler_.reset(handler); } SetServerApiType(RpcServiceMethod::ApiType type)108 void SetServerApiType(RpcServiceMethod::ApiType type) { 109 if ((api_type_ == ApiType::SYNC) && 110 (type == ApiType::ASYNC || type == ApiType::RAW)) { 111 // this marks this method as async 112 handler_.reset(); 113 } else if (api_type_ != ApiType::SYNC) { 114 // this is not an error condition, as it allows users to declare a server 115 // like WithRawMethod_foo<AsyncService>. However since it 116 // overwrites behavior, it should be logged. 117 gpr_log( 118 GPR_INFO, 119 "You are marking method %s as '%s', even though it was " 120 "previously marked '%s'. This behavior will overwrite the original " 121 "behavior. If you expected this then ignore this message.", 122 name(), TypeToString(api_type_), TypeToString(type)); 123 } 124 api_type_ = type; 125 } 126 127 private: 128 void* server_tag_; 129 ApiType api_type_; 130 std::unique_ptr<MethodHandler> handler_; 131 TypeToString(RpcServiceMethod::ApiType type)132 const char* TypeToString(RpcServiceMethod::ApiType type) { 133 switch (type) { 134 case ApiType::SYNC: 135 return "sync"; 136 case ApiType::ASYNC: 137 return "async"; 138 case ApiType::RAW: 139 return "raw"; 140 case ApiType::CALL_BACK: 141 return "callback"; 142 case ApiType::RAW_CALL_BACK: 143 return "raw_callback"; 144 default: 145 GPR_UNREACHABLE_CODE(return "unknown"); 146 } 147 } 148 }; 149 } // namespace internal 150 151 } // namespace grpc 152 153 #endif // GRPCPP_IMPL_CODEGEN_RPC_SERVICE_METHOD_H 154