19 #ifndef GRPCPP_IMPL_CODEGEN_METHOD_HANDLER_H
20 #define GRPCPP_IMPL_CODEGEN_METHOD_HANDLER_H
38 template <
class Callable>
40 #if GRPC_ALLOW_EXCEPTIONS
45 "Unexpected error in RPC handling");
56 template <
class ResponseType>
70 status = ops.SendMessagePtr(rsp);
72 ops.ServerSendStatus(¶m.
server_context->trailing_metadata_, status);
74 param.
call->
cq()->Pluck(&ops);
79 template <
class RequestType>
81 RequestType* request) {
85 &buf,
static_cast<RequestType*
>(request));
90 request->~RequestType();
95 template <
class ServiceType,
class RequestType,
class ResponseType,
96 class BaseRequestType = RequestType,
97 class BaseResponseType = ResponseType>
102 const RequestType*, ResponseType*)>
104 ServiceType* service)
105 : func_(func), service_(service) {}
112 return func_(service_,
114 static_cast<RequestType*
>(param.request), &rsp);
116 static_cast<RequestType*
>(param.request)->~RequestType();
125 call,
sizeof(RequestType))) RequestType;
127 static_cast<BaseRequestType*
>(request));
133 const RequestType*, ResponseType*)>
136 ServiceType* service_;
140 template <
class ServiceType,
class RequestType,
class ResponseType>
147 ServiceType* service)
148 : func_(func), service_(service) {}
156 return func_(service_,
165 if (!param.server_context->sent_initial_metadata_) {
166 ops.SendInitialMetadata(¶m.server_context->initial_metadata_,
167 param.server_context->initial_metadata_flags());
168 if (param.server_context->compression_level_set()) {
169 ops.set_compression_level(param.server_context->compression_level());
173 status = ops.SendMessagePtr(&rsp);
175 ops.ServerSendStatus(¶m.server_context->trailing_metadata_, status);
176 param.call->PerformOps(&ops);
177 param.call->cq()->Pluck(&ops);
184 ServiceType* service_;
188 template <
class ServiceType,
class RequestType,
class ResponseType>
195 ServiceType* service)
196 : func_(func), service_(service) {}
205 return func_(service_,
207 static_cast<RequestType*
>(param.request), &writer);
209 static_cast<RequestType*
>(param.request)->~RequestType();
215 if (!param.server_context->sent_initial_metadata_) {
216 ops.SendInitialMetadata(¶m.server_context->initial_metadata_,
217 param.server_context->initial_metadata_flags());
218 if (param.server_context->compression_level_set()) {
219 ops.set_compression_level(param.server_context->compression_level());
223 param.call->PerformOps(&ops);
224 if (param.server_context->has_pending_ops_) {
225 param.call->cq()->Pluck(¶m.server_context->pending_ops_);
227 param.call->cq()->Pluck(&ops);
236 call,
sizeof(RequestType))) RequestType();
243 request->~RequestType();
251 ServiceType* service_;
261 template <
class Streamer,
bool WriteNeeded>
266 : func_(func), write_needed_(WriteNeeded) {}
269 Streamer stream(param.call,
279 if (!param.server_context->sent_initial_metadata_) {
280 ops.SendInitialMetadata(¶m.server_context->initial_metadata_,
281 param.server_context->initial_metadata_flags());
282 if (param.server_context->compression_level_set()) {
283 ops.set_compression_level(param.server_context->compression_level());
285 if (write_needed_ && status.
ok()) {
289 "Service did not provide response message");
292 ops.ServerSendStatus(¶m.server_context->trailing_metadata_, status);
293 param.call->PerformOps(&ops);
294 if (param.server_context->has_pending_ops_) {
295 param.call->cq()->Pluck(¶m.server_context->pending_ops_);
297 param.call->cq()->Pluck(&ops);
302 const bool write_needed_;
305 template <
class ServiceType,
class RequestType,
class ResponseType>
308 ServerReaderWriter<ResponseType, RequestType>, false> {
314 ServiceType* service)
321 return func(service, ctx, streamer);
325 template <
class RequestType,
class ResponseType>
328 ServerUnaryStreamer<RequestType, ResponseType>, true> {
340 template <
class RequestType,
class ResponseType>
343 ServerSplitStreamer<RequestType, ResponseType>, false> {
357 template <::grpc::StatusCode code>
364 const std::string& message, T* ops) {
366 if (!context->sent_initial_metadata_) {
367 ops->SendInitialMetadata(&context->initial_metadata_,
368 context->initial_metadata_flags());
372 context->sent_initial_metadata_ =
true;
374 ops->ServerSendStatus(&context->trailing_metadata_, status);
381 FillOps(param.server_context, message_, &ops);
382 param.call->PerformOps(&ops);
383 param.call->cq()->Pluck(&ops);
389 if (req !=
nullptr) {
396 const std::string message_;
399 typedef ErrorMethodHandler<::grpc::StatusCode::UNIMPLEMENTED>
A sequence of bytes.
Definition: byte_buffer.h:60
void Release()
Forget underlying byte buffer without destroying Use this only for un-owned byte buffers.
Definition: byte_buffer.h:146
virtual void * grpc_call_arena_alloc(grpc_call *call, size_t length)=0
virtual void grpc_byte_buffer_destroy(grpc_byte_buffer *bb)=0
Defines how to serialize and deserialize some type.
Definition: serialization_traits.h:58
Base class of ServerContext. Experimental until callback API is final.
Definition: server_context.h:126
bool compression_level_set() const
Return a bool indicating whether the compression level for this call has been set (either implicitly ...
Definition: server_context.h:243
grpc_compression_level compression_level() const
Return the compression algorithm to be used by the server call.
Definition: server_context.h:228
A ServerContext or CallbackServerContext allows the code implementing a service handler to:
Definition: server_context.h:538
Synchronous (blocking) server-side API for doing client-streaming RPCs, where the incoming message st...
Definition: sync_stream.h:580
Synchronous (blocking) server-side API for a bidirectional streaming call, where the incoming message...
Definition: sync_stream.h:779
A class to represent a flow-controlled server-side streaming call.
Definition: sync_stream.h:887
A class to represent a flow-controlled unary call.
Definition: sync_stream.h:821
Synchronous (blocking) server-side API for doing for doing a server-streaming RPCs,...
Definition: sync_stream.h:633
Did it work? If it didn't, why?
Definition: status.h:31
bool ok() const
Is the status OK?
Definition: status.h:118
Definition: method_handler.h:308
BidiStreamingHandler(std::function<::grpc::Status(ServiceType *, ::grpc::ServerContext *, ServerReaderWriter< ResponseType, RequestType > *)> func, ServiceType *service)
Definition: method_handler.h:310
void PerformOps(CallOpSetInterface *ops)
Definition: call.h:65
::grpc::CompletionQueue * cq() const
Definition: call.h:70
Definition: call_op_set.h:282
Definition: call_op_set.h:654
void ServerSendStatus(std::multimap< std::string, std::string > *trailing_metadata, const Status &status)
Definition: call_op_set.h:658
Primary implementation of CallOpSetInterface.
Definition: call_op_set.h:867
A wrapper class of an application provided client streaming handler.
Definition: method_handler.h:141
ClientStreamingHandler(std::function<::grpc::Status(ServiceType *, ::grpc::ServerContext *, ServerReader< RequestType > *, ResponseType *)> func, ServiceType *service)
Definition: method_handler.h:143
void RunHandler(const HandlerParameter ¶m) final
Definition: method_handler.h:150
General method handler class for errors that prevent real method use e.g., handle unknown method by r...
Definition: method_handler.h:358
static void FillOps(::grpc::ServerContextBase *context, const std::string &message, T *ops)
Definition: method_handler.h:363
ErrorMethodHandler(const std::string &message)
Definition: method_handler.h:360
void * Deserialize(grpc_call *, grpc_byte_buffer *req, ::grpc::Status *, void **) final
Definition: method_handler.h:386
void RunHandler(const HandlerParameter ¶m) final
Definition: method_handler.h:377
Base class for running an RPC handler.
Definition: rpc_service_method.h:38
A wrapper class of an application provided rpc method handler.
Definition: method_handler.h:98
RpcMethodHandler(std::function<::grpc::Status(ServiceType *, ::grpc::ServerContext *, const RequestType *, ResponseType *)> func, ServiceType *service)
Definition: method_handler.h:100
void * Deserialize(grpc_call *call, grpc_byte_buffer *req, ::grpc::Status *status, void **) final
Definition: method_handler.h:121
void RunHandler(const HandlerParameter ¶m) final
Definition: method_handler.h:107
A wrapper class of an application provided server streaming handler.
Definition: method_handler.h:189
void RunHandler(const HandlerParameter ¶m) final
Definition: method_handler.h:198
ServerStreamingHandler(std::function<::grpc::Status(ServiceType *, ::grpc::ServerContext *, const RequestType *, ServerWriter< ResponseType > *)> func, ServiceType *service)
Definition: method_handler.h:191
void * Deserialize(grpc_call *call, grpc_byte_buffer *req, ::grpc::Status *status, void **) final
Definition: method_handler.h:230
Definition: method_handler.h:343
SplitServerStreamingHandler(std::function< ::grpc::Status(::grpc::ServerContext *, ServerSplitStreamer< RequestType, ResponseType > *)> func)
Definition: method_handler.h:345
Definition: method_handler.h:328
StreamedUnaryHandler(std::function< ::grpc::Status(::grpc::ServerContext *, ServerUnaryStreamer< RequestType, ResponseType > *)> func)
Definition: method_handler.h:330
A wrapper class of an application provided bidi-streaming handler.
Definition: method_handler.h:262
void RunHandler(const HandlerParameter ¶m) final
Definition: method_handler.h:268
TemplatedBidiStreamingHandler(std::function<::grpc::Status(::grpc::ServerContext *, Streamer *)> func)
Definition: method_handler.h:264
struct grpc_call grpc_call
A Call represents an RPC.
Definition: grpc_types.h:70
#define GPR_CODEGEN_ASSERT(x)
Codegen specific version of GPR_ASSERT.
Definition: core_codegen_interface.h:146
ErrorMethodHandler<::grpc::StatusCode::RESOURCE_EXHAUSTED > ResourceExhaustedHandler
Definition: method_handler.h:402
ErrorMethodHandler<::grpc::StatusCode::UNIMPLEMENTED > UnknownMethodHandler
Definition: method_handler.h:400
::grpc::Status CatchingFunctionHandler(Callable &&handler)
Definition: method_handler.h:39
void UnaryRunHandlerHelper(const ::grpc::internal::MethodHandler::HandlerParameter &, ResponseType *, ::grpc::Status &)
void * UnaryDeserializeHelper(grpc_byte_buffer *, ::grpc::Status *, RequestType *)
A helper function with reduced templating to do deserializing.
Definition: method_handler.h:80
::google::protobuf::util::Status Status
Definition: config_protobuf.h:91
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:33
CoreCodegenInterface * g_core_codegen_interface
Definition: completion_queue.h:96
@ INTERNAL
Internal errors.
Definition: status_code_enum.h:119
@ UNKNOWN
Unknown error.
Definition: status_code_enum.h:35
Definition: async_unary_call.h:398
Definition: rpc_service_method.h:41
::grpc::ServerContextBase *const server_context
Definition: rpc_service_method.h:63
Call *const call
Definition: rpc_service_method.h:62
Definition: grpc_types.h:40