From b657c8d79c114dabb898d256bcfab56213fbd209 Mon Sep 17 00:00:00 2001 From: Karthik Ravi Shankar Date: Wed, 2 Sep 2020 10:17:00 -0700 Subject: [PATCH] Revert "Revert "Move ServerContext from ::grpc_impl to ::grpc"" --- BUILD | 1 - BUILD.gn | 1 - CMakeLists.txt | 2 - Makefile | 2 - build_autogenerated.yaml | 2 - gRPC-C++.podspec | 1 - .../impl/codegen/async_generic_service.h | 10 +- .../grpcpp/impl/codegen/async_stream_impl.h | 14 +- .../impl/codegen/async_unary_call_impl.h | 6 +- include/grpcpp/impl/codegen/client_context.h | 13 +- .../grpcpp/impl/codegen/completion_queue.h | 4 +- .../grpcpp/impl/codegen/method_handler_impl.h | 68 +- .../grpcpp/impl/codegen/rpc_service_method.h | 11 +- .../impl/codegen/server_callback_handlers.h | 61 +- include/grpcpp/impl/codegen/server_context.h | 594 ++++++++++++++++- .../grpcpp/impl/codegen/server_context_impl.h | 612 ------------------ .../grpcpp/impl/codegen/server_interceptor.h | 14 +- .../grpcpp/impl/codegen/server_interface.h | 18 +- include/grpcpp/impl/codegen/service_type.h | 10 +- .../grpcpp/impl/codegen/sync_stream_impl.h | 24 +- include/grpcpp/server.h | 4 +- src/compiler/cpp_generator.cc | 12 +- src/cpp/client/client_context.cc | 7 +- src/cpp/server/server_context.cc | 30 +- test/cpp/codegen/compiler_test_golden | 6 +- tools/doxygen/Doxyfile.c++ | 1 - tools/doxygen/Doxyfile.c++.internal | 1 - 27 files changed, 727 insertions(+), 802 deletions(-) delete mode 100644 include/grpcpp/impl/codegen/server_context_impl.h diff --git a/BUILD b/BUILD index 791d2c29c76..2fbc31236b6 100644 --- a/BUILD +++ b/BUILD @@ -2303,7 +2303,6 @@ grpc_cc_library( "include/grpcpp/impl/codegen/server_callback_handlers.h", "include/grpcpp/impl/codegen/server_callback_impl.h", "include/grpcpp/impl/codegen/server_context.h", - "include/grpcpp/impl/codegen/server_context_impl.h", "include/grpcpp/impl/codegen/server_interceptor.h", "include/grpcpp/impl/codegen/server_interface.h", "include/grpcpp/impl/codegen/service_type.h", diff --git a/BUILD.gn b/BUILD.gn index 320027a9057..7040bd6cf35 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -1169,7 +1169,6 @@ config("grpc_config") { "include/grpcpp/impl/codegen/server_callback_handlers.h", "include/grpcpp/impl/codegen/server_callback_impl.h", "include/grpcpp/impl/codegen/server_context.h", - "include/grpcpp/impl/codegen/server_context_impl.h", "include/grpcpp/impl/codegen/server_interceptor.h", "include/grpcpp/impl/codegen/server_interface.h", "include/grpcpp/impl/codegen/service_type.h", diff --git a/CMakeLists.txt b/CMakeLists.txt index 55325bcbfa0..d4ec279df0f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2827,7 +2827,6 @@ foreach(_hdr include/grpcpp/impl/codegen/server_callback_handlers.h include/grpcpp/impl/codegen/server_callback_impl.h include/grpcpp/impl/codegen/server_context.h - include/grpcpp/impl/codegen/server_context_impl.h include/grpcpp/impl/codegen/server_interceptor.h include/grpcpp/impl/codegen/server_interface.h include/grpcpp/impl/codegen/service_type.h @@ -3511,7 +3510,6 @@ foreach(_hdr include/grpcpp/impl/codegen/server_callback_handlers.h include/grpcpp/impl/codegen/server_callback_impl.h include/grpcpp/impl/codegen/server_context.h - include/grpcpp/impl/codegen/server_context_impl.h include/grpcpp/impl/codegen/server_interceptor.h include/grpcpp/impl/codegen/server_interface.h include/grpcpp/impl/codegen/service_type.h diff --git a/Makefile b/Makefile index 30be55f075b..26e44583631 100644 --- a/Makefile +++ b/Makefile @@ -2964,7 +2964,6 @@ PUBLIC_HEADERS_CXX += \ include/grpcpp/impl/codegen/server_callback_handlers.h \ include/grpcpp/impl/codegen/server_callback_impl.h \ include/grpcpp/impl/codegen/server_context.h \ - include/grpcpp/impl/codegen/server_context_impl.h \ include/grpcpp/impl/codegen/server_interceptor.h \ include/grpcpp/impl/codegen/server_interface.h \ include/grpcpp/impl/codegen/service_type.h \ @@ -3493,7 +3492,6 @@ PUBLIC_HEADERS_CXX += \ include/grpcpp/impl/codegen/server_callback_handlers.h \ include/grpcpp/impl/codegen/server_callback_impl.h \ include/grpcpp/impl/codegen/server_context.h \ - include/grpcpp/impl/codegen/server_context_impl.h \ include/grpcpp/impl/codegen/server_interceptor.h \ include/grpcpp/impl/codegen/server_interface.h \ include/grpcpp/impl/codegen/service_type.h \ diff --git a/build_autogenerated.yaml b/build_autogenerated.yaml index dbc7c81bc7a..bee232ad7a9 100644 --- a/build_autogenerated.yaml +++ b/build_autogenerated.yaml @@ -2162,7 +2162,6 @@ libs: - include/grpcpp/impl/codegen/server_callback_handlers.h - include/grpcpp/impl/codegen/server_callback_impl.h - include/grpcpp/impl/codegen/server_context.h - - include/grpcpp/impl/codegen/server_context_impl.h - include/grpcpp/impl/codegen/server_interceptor.h - include/grpcpp/impl/codegen/server_interface.h - include/grpcpp/impl/codegen/service_type.h @@ -2538,7 +2537,6 @@ libs: - include/grpcpp/impl/codegen/server_callback_handlers.h - include/grpcpp/impl/codegen/server_callback_impl.h - include/grpcpp/impl/codegen/server_context.h - - include/grpcpp/impl/codegen/server_context_impl.h - include/grpcpp/impl/codegen/server_interceptor.h - include/grpcpp/impl/codegen/server_interface.h - include/grpcpp/impl/codegen/service_type.h diff --git a/gRPC-C++.podspec b/gRPC-C++.podspec index fbfaeed8f6d..9bf5e7a790b 100644 --- a/gRPC-C++.podspec +++ b/gRPC-C++.podspec @@ -131,7 +131,6 @@ Pod::Spec.new do |s| 'include/grpcpp/impl/codegen/server_callback_handlers.h', 'include/grpcpp/impl/codegen/server_callback_impl.h', 'include/grpcpp/impl/codegen/server_context.h', - 'include/grpcpp/impl/codegen/server_context_impl.h', 'include/grpcpp/impl/codegen/server_interceptor.h', 'include/grpcpp/impl/codegen/server_interface.h', 'include/grpcpp/impl/codegen/service_type.h', diff --git a/include/grpcpp/impl/codegen/async_generic_service.h b/include/grpcpp/impl/codegen/async_generic_service.h index 8415c2cb458..56217c1e129 100644 --- a/include/grpcpp/impl/codegen/async_generic_service.h +++ b/include/grpcpp/impl/codegen/async_generic_service.h @@ -38,7 +38,7 @@ typedef ::grpc_impl::ServerAsyncReader GenericServerAsyncReader; typedef ::grpc_impl::ServerAsyncWriter GenericServerAsyncWriter; -class GenericServerContext final : public ::grpc_impl::ServerContext { +class GenericServerContext final : public ::grpc::ServerContext { public: const std::string& method() const { return method_; } const std::string& host() const { return host_; } @@ -50,7 +50,7 @@ class GenericServerContext final : public ::grpc_impl::ServerContext { void Clear() { method_.clear(); host_.clear(); - ::grpc_impl::ServerContext::Clear(); + ::grpc::ServerContext::Clear(); } std::string method_; @@ -99,7 +99,7 @@ using ServerGenericBidiReactor = ::grpc_impl::ServerBidiReactor; class GenericCallbackServerContext final - : public ::grpc_impl::CallbackServerContext { + : public ::grpc::CallbackServerContext { public: const std::string& method() const { return method_; } const std::string& host() const { return host_; } @@ -111,7 +111,7 @@ class GenericCallbackServerContext final void Clear() { method_.clear(); host_.clear(); - ::grpc_impl::CallbackServerContext::Clear(); + ::grpc::CallbackServerContext::Clear(); } std::string method_; @@ -146,7 +146,7 @@ class CallbackGenericService { Handler() { return new ::grpc_impl::internal::CallbackBidiHandler( - [this](::grpc_impl::CallbackServerContext* ctx) { + [this](::grpc::CallbackServerContext* ctx) { return CreateReactor(static_cast(ctx)); }); } diff --git a/include/grpcpp/impl/codegen/async_stream_impl.h b/include/grpcpp/impl/codegen/async_stream_impl.h index fc978dc5a08..bb1c2ef6fb3 100644 --- a/include/grpcpp/impl/codegen/async_stream_impl.h +++ b/include/grpcpp/impl/codegen/async_stream_impl.h @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include #include @@ -696,7 +696,7 @@ class ServerAsyncReaderInterface template class ServerAsyncReader final : public ServerAsyncReaderInterface { public: - explicit ServerAsyncReader(::grpc_impl::ServerContext* ctx) + explicit ServerAsyncReader(::grpc::ServerContext* ctx) : call_(nullptr, nullptr, nullptr), ctx_(ctx) {} /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics. @@ -782,7 +782,7 @@ class ServerAsyncReader final : public ServerAsyncReaderInterface { void BindCall(::grpc::internal::Call* call) override { call_ = *call; } ::grpc::internal::Call call_; - ::grpc_impl::ServerContext* ctx_; + ::grpc::ServerContext* ctx_; ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata> meta_ops_; ::grpc::internal::CallOpSet<::grpc::internal::CallOpRecvMessage> read_ops_; @@ -843,7 +843,7 @@ class ServerAsyncWriterInterface template class ServerAsyncWriter final : public ServerAsyncWriterInterface { public: - explicit ServerAsyncWriter(::grpc_impl::ServerContext* ctx) + explicit ServerAsyncWriter(::grpc::ServerContext* ctx) : call_(nullptr, nullptr, nullptr), ctx_(ctx) {} /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics. @@ -940,7 +940,7 @@ class ServerAsyncWriter final : public ServerAsyncWriterInterface { } ::grpc::internal::Call call_; - ::grpc_impl::ServerContext* ctx_; + ::grpc::ServerContext* ctx_; ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata> meta_ops_; ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata, @@ -1009,7 +1009,7 @@ template class ServerAsyncReaderWriter final : public ServerAsyncReaderWriterInterface { public: - explicit ServerAsyncReaderWriter(::grpc_impl::ServerContext* ctx) + explicit ServerAsyncReaderWriter(::grpc::ServerContext* ctx) : call_(nullptr, nullptr, nullptr), ctx_(ctx) {} /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics. @@ -1114,7 +1114,7 @@ class ServerAsyncReaderWriter final } ::grpc::internal::Call call_; - ::grpc_impl::ServerContext* ctx_; + ::grpc::ServerContext* ctx_; ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata> meta_ops_; ::grpc::internal::CallOpSet<::grpc::internal::CallOpRecvMessage> read_ops_; diff --git a/include/grpcpp/impl/codegen/async_unary_call_impl.h b/include/grpcpp/impl/codegen/async_unary_call_impl.h index 2abd5057081..68e783224da 100644 --- a/include/grpcpp/impl/codegen/async_unary_call_impl.h +++ b/include/grpcpp/impl/codegen/async_unary_call_impl.h @@ -22,7 +22,7 @@ #include #include #include -#include +#include #include #include @@ -197,7 +197,7 @@ template class ServerAsyncResponseWriter final : public ::grpc::internal::ServerAsyncStreamingInterface { public: - explicit ServerAsyncResponseWriter(::grpc_impl::ServerContext* ctx) + explicit ServerAsyncResponseWriter(::grpc::ServerContext* ctx) : call_(nullptr, nullptr, nullptr), ctx_(ctx) {} /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics. @@ -287,7 +287,7 @@ class ServerAsyncResponseWriter final void BindCall(::grpc::internal::Call* call) override { call_ = *call; } ::grpc::internal::Call call_; - ::grpc_impl::ServerContext* ctx_; + ::grpc::ServerContext* ctx_; ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata> meta_buf_; ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata, diff --git a/include/grpcpp/impl/codegen/client_context.h b/include/grpcpp/impl/codegen/client_context.h index dfcae0d3657..ce338720f2c 100644 --- a/include/grpcpp/impl/codegen/client_context.h +++ b/include/grpcpp/impl/codegen/client_context.h @@ -71,7 +71,6 @@ class ClientCallbackUnaryImpl; class ClientContextAccessor; } // namespace internal -class ServerContext; template class ClientReader; template @@ -87,12 +86,14 @@ class ClientAsyncReaderWriter; template class ClientAsyncResponseReader; -class ServerContextBase; -class CallbackServerContext; } // namespace grpc_impl namespace grpc { +class ServerContext; +class ServerContextBase; +class CallbackServerContext; + namespace testing { class InteropClientContextInspector; } // namespace testing @@ -208,10 +209,10 @@ class ClientContext { /// \return A newly constructed \a ClientContext instance based on \a /// server_context, with traits propagated (copied) according to \a options. static std::unique_ptr FromServerContext( - const grpc_impl::ServerContext& server_context, + const grpc::ServerContext& server_context, PropagationOptions options = PropagationOptions()); static std::unique_ptr FromCallbackServerContext( - const grpc_impl::CallbackServerContext& server_context, + const grpc::CallbackServerContext& server_context, PropagationOptions options = PropagationOptions()); /// Add the (\a meta_key, \a meta_value) pair to the metadata associated with @@ -491,7 +492,7 @@ class ClientContext { void SendCancelToInterceptors(); static std::unique_ptr FromInternalServerContext( - const grpc_impl::ServerContextBase& server_context, + const grpc::ServerContextBase& server_context, PropagationOptions options); bool initial_metadata_received_; diff --git a/include/grpcpp/impl/codegen/completion_queue.h b/include/grpcpp/impl/codegen/completion_queue.h index 1dd9bc9e2e4..4ed20411da6 100644 --- a/include/grpcpp/impl/codegen/completion_queue.h +++ b/include/grpcpp/impl/codegen/completion_queue.h @@ -56,7 +56,6 @@ template class ServerReader; template class ServerWriter; -class ServerContextBase; namespace internal { template class ServerReaderWriterBody; @@ -79,6 +78,7 @@ class Channel; class ChannelInterface; class Server; class ServerBuilder; +class ServerContextBase; class ServerInterface; namespace internal { @@ -278,7 +278,7 @@ class CompletionQueue : private ::grpc::GrpcLibraryCodegen { friend class ::grpc_impl::internal::TemplatedBidiStreamingHandler; template <::grpc::StatusCode code> friend class ::grpc_impl::internal::ErrorMethodHandler; - friend class ::grpc_impl::ServerContextBase; + friend class ::grpc::ServerContextBase; friend class ::grpc::ServerInterface; template friend class ::grpc::internal::BlockingUnaryCallImpl; diff --git a/include/grpcpp/impl/codegen/method_handler_impl.h b/include/grpcpp/impl/codegen/method_handler_impl.h index 2de193457a1..19f2eb22e13 100644 --- a/include/grpcpp/impl/codegen/method_handler_impl.h +++ b/include/grpcpp/impl/codegen/method_handler_impl.h @@ -54,7 +54,7 @@ template class RpcMethodHandler : public ::grpc::internal::MethodHandler { public: RpcMethodHandler( - std::function<::grpc::Status(ServiceType*, ::grpc_impl::ServerContext*, + std::function<::grpc::Status(ServiceType*, ::grpc::ServerContext*, const RequestType*, ResponseType*)> func, ServiceType* service) @@ -65,10 +65,9 @@ class RpcMethodHandler : public ::grpc::internal::MethodHandler { ::grpc::Status status = param.status; if (status.ok()) { status = CatchingFunctionHandler([this, ¶m, &rsp] { - return func_( - service_, - static_cast<::grpc_impl::ServerContext*>(param.server_context), - static_cast(param.request), &rsp); + return func_(service_, + static_cast<::grpc::ServerContext*>(param.server_context), + static_cast(param.request), &rsp); }); static_cast(param.request)->~RequestType(); } @@ -110,7 +109,7 @@ class RpcMethodHandler : public ::grpc::internal::MethodHandler { private: /// Application provided rpc handler function. - std::function<::grpc::Status(ServiceType*, ::grpc_impl::ServerContext*, + std::function<::grpc::Status(ServiceType*, ::grpc::ServerContext*, const RequestType*, ResponseType*)> func_; // The class the above handler function lives in. @@ -122,7 +121,7 @@ template class ClientStreamingHandler : public ::grpc::internal::MethodHandler { public: ClientStreamingHandler( - std::function<::grpc::Status(ServiceType*, ::grpc_impl::ServerContext*, + std::function<::grpc::Status(ServiceType*, ::grpc::ServerContext*, ::grpc_impl::ServerReader*, ResponseType*)> func, @@ -131,16 +130,14 @@ class ClientStreamingHandler : public ::grpc::internal::MethodHandler { void RunHandler(const HandlerParameter& param) final { ::grpc_impl::ServerReader reader( - param.call, - static_cast<::grpc_impl::ServerContext*>(param.server_context)); + param.call, static_cast<::grpc::ServerContext*>(param.server_context)); ResponseType rsp; - ::grpc::Status status = - CatchingFunctionHandler([this, ¶m, &reader, &rsp] { - return func_( - service_, - static_cast<::grpc_impl::ServerContext*>(param.server_context), - &reader, &rsp); - }); + ::grpc::Status status = CatchingFunctionHandler([this, ¶m, &reader, + &rsp] { + return func_(service_, + static_cast<::grpc::ServerContext*>(param.server_context), + &reader, &rsp); + }); ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata, ::grpc::internal::CallOpSendMessage, @@ -162,7 +159,7 @@ class ClientStreamingHandler : public ::grpc::internal::MethodHandler { } private: - std::function<::grpc::Status(ServiceType*, ::grpc_impl::ServerContext*, + std::function<::grpc::Status(ServiceType*, ::grpc::ServerContext*, ::grpc_impl::ServerReader*, ResponseType*)> func_; @@ -174,7 +171,7 @@ template class ServerStreamingHandler : public ::grpc::internal::MethodHandler { public: ServerStreamingHandler( - std::function<::grpc::Status(ServiceType*, ::grpc_impl::ServerContext*, + std::function<::grpc::Status(ServiceType*, ::grpc::ServerContext*, const RequestType*, ::grpc_impl::ServerWriter*)> func, @@ -186,12 +183,11 @@ class ServerStreamingHandler : public ::grpc::internal::MethodHandler { if (status.ok()) { ::grpc_impl::ServerWriter writer( param.call, - static_cast<::grpc_impl::ServerContext*>(param.server_context)); + static_cast<::grpc::ServerContext*>(param.server_context)); status = CatchingFunctionHandler([this, ¶m, &writer] { - return func_( - service_, - static_cast<::grpc_impl::ServerContext*>(param.server_context), - static_cast(param.request), &writer); + return func_(service_, + static_cast<::grpc::ServerContext*>(param.server_context), + static_cast(param.request), &writer); }); static_cast(param.request)->~RequestType(); } @@ -232,7 +228,7 @@ class ServerStreamingHandler : public ::grpc::internal::MethodHandler { } private: - std::function<::grpc::Status(ServiceType*, ::grpc_impl::ServerContext*, + std::function<::grpc::Status(ServiceType*, ::grpc::ServerContext*, const RequestType*, ::grpc_impl::ServerWriter*)> func_; @@ -250,17 +246,15 @@ template class TemplatedBidiStreamingHandler : public ::grpc::internal::MethodHandler { public: TemplatedBidiStreamingHandler( - std::function<::grpc::Status(::grpc_impl::ServerContext*, Streamer*)> - func) + std::function<::grpc::Status(::grpc::ServerContext*, Streamer*)> func) : func_(func), write_needed_(WriteNeeded) {} void RunHandler(const HandlerParameter& param) final { - Streamer stream(param.call, static_cast<::grpc_impl::ServerContext*>( - param.server_context)); + Streamer stream(param.call, + static_cast<::grpc::ServerContext*>(param.server_context)); ::grpc::Status status = CatchingFunctionHandler([this, ¶m, &stream] { - return func_( - static_cast<::grpc_impl::ServerContext*>(param.server_context), - &stream); + return func_(static_cast<::grpc::ServerContext*>(param.server_context), + &stream); }); ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata, @@ -288,7 +282,7 @@ class TemplatedBidiStreamingHandler : public ::grpc::internal::MethodHandler { } private: - std::function<::grpc::Status(::grpc_impl::ServerContext*, Streamer*)> func_; + std::function<::grpc::Status(::grpc::ServerContext*, Streamer*)> func_; const bool write_needed_; }; @@ -299,7 +293,7 @@ class BidiStreamingHandler public: BidiStreamingHandler( std::function<::grpc::Status( - ServiceType*, ::grpc_impl::ServerContext*, + ServiceType*, ::grpc::ServerContext*, ::grpc_impl::ServerReaderWriter*)> func, ServiceType* service) @@ -307,7 +301,7 @@ class BidiStreamingHandler : TemplatedBidiStreamingHandler< ::grpc_impl::ServerReaderWriter, false>( [func, service]( - ::grpc_impl::ServerContext* ctx, + ::grpc::ServerContext* ctx, ::grpc_impl::ServerReaderWriter* streamer) { return func(service, ctx, streamer); }) {} }; @@ -319,7 +313,7 @@ class StreamedUnaryHandler public: explicit StreamedUnaryHandler( std::function<::grpc::Status( - ::grpc_impl::ServerContext*, + ::grpc::ServerContext*, ::grpc_impl::ServerUnaryStreamer*)> func) : TemplatedBidiStreamingHandler< @@ -334,7 +328,7 @@ class SplitServerStreamingHandler public: explicit SplitServerStreamingHandler( std::function<::grpc::Status( - ::grpc_impl::ServerContext*, + ::grpc::ServerContext*, ::grpc_impl::ServerSplitStreamer*)> func) : TemplatedBidiStreamingHandler< @@ -348,7 +342,7 @@ template <::grpc::StatusCode code> class ErrorMethodHandler : public ::grpc::internal::MethodHandler { public: template - static void FillOps(::grpc_impl::ServerContextBase* context, T* ops) { + static void FillOps(::grpc::ServerContextBase* context, T* ops) { ::grpc::Status status(code, ""); if (!context->sent_initial_metadata_) { ops->SendInitialMetadata(&context->initial_metadata_, diff --git a/include/grpcpp/impl/codegen/rpc_service_method.h b/include/grpcpp/impl/codegen/rpc_service_method.h index da0e5b60b20..4fcc2112435 100644 --- a/include/grpcpp/impl/codegen/rpc_service_method.h +++ b/include/grpcpp/impl/codegen/rpc_service_method.h @@ -31,11 +31,8 @@ #include #include -namespace grpc_impl { -class ServerContextBase; -} // namespace grpc_impl - namespace grpc { +class ServerContextBase; namespace internal { /// Base class for running an RPC handler. class MethodHandler { @@ -52,8 +49,8 @@ class MethodHandler { /// \param requester : used only by the callback API. It is a function /// called by the RPC Controller to request another RPC (and also /// to set up the state required to make that request possible) - HandlerParameter(Call* c, ::grpc_impl::ServerContextBase* context, - void* req, Status req_status, void* handler_data, + HandlerParameter(Call* c, ::grpc::ServerContextBase* context, void* req, + Status req_status, void* handler_data, std::function requester) : call(c), server_context(context), @@ -63,7 +60,7 @@ class MethodHandler { call_requester(std::move(requester)) {} ~HandlerParameter() {} Call* const call; - ::grpc_impl::ServerContextBase* const server_context; + ::grpc::ServerContextBase* const server_context; void* const request; const Status status; void* const internal_data; diff --git a/include/grpcpp/impl/codegen/server_callback_handlers.h b/include/grpcpp/impl/codegen/server_callback_handlers.h index dff38a890d8..bd85e079f1b 100644 --- a/include/grpcpp/impl/codegen/server_callback_handlers.h +++ b/include/grpcpp/impl/codegen/server_callback_handlers.h @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include namespace grpc_impl { @@ -31,7 +31,7 @@ template class CallbackUnaryHandler : public ::grpc::internal::MethodHandler { public: explicit CallbackUnaryHandler( - std::function get_reactor) : get_reactor_(std::move(get_reactor)) {} @@ -52,8 +52,7 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler { auto* call = new (::grpc::g_core_codegen_interface->grpc_call_arena_alloc( param.call->call(), sizeof(ServerCallbackUnaryImpl))) ServerCallbackUnaryImpl( - static_cast<::grpc_impl::CallbackServerContext*>( - param.server_context), + static_cast<::grpc::CallbackServerContext*>(param.server_context), param.call, allocator_state, std::move(param.call_requester)); param.server_context->BeginCompletionOp( param.call, [call](bool) { call->MaybeDone(); }, call); @@ -62,8 +61,7 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler { if (param.status.ok()) { reactor = ::grpc::internal::CatchingReactorGetter( get_reactor_, - static_cast<::grpc_impl::CallbackServerContext*>( - param.server_context), + static_cast<::grpc::CallbackServerContext*>(param.server_context), call->request(), call->response()); } @@ -108,7 +106,7 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler { } private: - std::function get_reactor_; ::grpc::experimental::MessageAllocator* @@ -181,7 +179,7 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler { friend class CallbackUnaryHandler; ServerCallbackUnaryImpl( - ::grpc_impl::CallbackServerContext* ctx, ::grpc::internal::Call* call, + ::grpc::CallbackServerContext* ctx, ::grpc::internal::Call* call, ::grpc::experimental::MessageHolder* allocator_state, std::function call_requester) @@ -229,7 +227,7 @@ class CallbackUnaryHandler : public ::grpc::internal::MethodHandler { finish_ops_; ::grpc::internal::CallbackWithSuccessTag finish_tag_; - ::grpc_impl::CallbackServerContext* const ctx_; + ::grpc::CallbackServerContext* const ctx_; ::grpc::internal::Call call_; ::grpc::experimental::MessageHolder* const allocator_state_; @@ -256,7 +254,7 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler { public: explicit CallbackClientStreamingHandler( std::function*( - ::grpc_impl::CallbackServerContext*, ResponseType*)> + ::grpc::CallbackServerContext*, ResponseType*)> get_reactor) : get_reactor_(std::move(get_reactor)) {} void RunHandler(const HandlerParameter& param) final { @@ -266,8 +264,7 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler { auto* reader = new (::grpc::g_core_codegen_interface->grpc_call_arena_alloc( param.call->call(), sizeof(ServerCallbackReaderImpl))) ServerCallbackReaderImpl( - static_cast<::grpc_impl::CallbackServerContext*>( - param.server_context), + static_cast<::grpc::CallbackServerContext*>(param.server_context), param.call, std::move(param.call_requester)); // Inlineable OnDone can be false in the CompletionOp callback because there // is no read reactor that has an inlineable OnDone; this only applies to @@ -282,8 +279,7 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler { reactor = ::grpc::internal::CatchingReactorGetter< ServerReadReactor>( get_reactor_, - static_cast<::grpc_impl::CallbackServerContext*>( - param.server_context), + static_cast<::grpc::CallbackServerContext*>(param.server_context), reader->response()); } @@ -299,8 +295,8 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler { } private: - std::function*( - ::grpc_impl::CallbackServerContext*, ResponseType*)> + std::function*(::grpc::CallbackServerContext*, + ResponseType*)> get_reactor_; class ServerCallbackReaderImpl : public ServerCallbackReader { @@ -369,7 +365,7 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler { private: friend class CallbackClientStreamingHandler; - ServerCallbackReaderImpl(::grpc_impl::CallbackServerContext* ctx, + ServerCallbackReaderImpl(::grpc::CallbackServerContext* ctx, ::grpc::internal::Call* call, std::function call_requester) : ctx_(ctx), call_(*call), call_requester_(std::move(call_requester)) {} @@ -424,7 +420,7 @@ class CallbackClientStreamingHandler : public ::grpc::internal::MethodHandler { read_ops_; ::grpc::internal::CallbackWithSuccessTag read_tag_; - ::grpc_impl::CallbackServerContext* const ctx_; + ::grpc::CallbackServerContext* const ctx_; ::grpc::internal::Call call_; ResponseType resp_; std::function call_requester_; @@ -441,7 +437,7 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler { public: explicit CallbackServerStreamingHandler( std::function*( - ::grpc_impl::CallbackServerContext*, const RequestType*)> + ::grpc::CallbackServerContext*, const RequestType*)> get_reactor) : get_reactor_(std::move(get_reactor)) {} void RunHandler(const HandlerParameter& param) final { @@ -451,8 +447,7 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler { auto* writer = new (::grpc::g_core_codegen_interface->grpc_call_arena_alloc( param.call->call(), sizeof(ServerCallbackWriterImpl))) ServerCallbackWriterImpl( - static_cast<::grpc_impl::CallbackServerContext*>( - param.server_context), + static_cast<::grpc::CallbackServerContext*>(param.server_context), param.call, static_cast(param.request), std::move(param.call_requester)); // Inlineable OnDone can be false in the CompletionOp callback because there @@ -468,8 +463,7 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler { reactor = ::grpc::internal::CatchingReactorGetter< ServerWriteReactor>( get_reactor_, - static_cast<::grpc_impl::CallbackServerContext*>( - param.server_context), + static_cast<::grpc::CallbackServerContext*>(param.server_context), writer->request()); } if (reactor == nullptr) { @@ -502,7 +496,7 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler { private: std::function*( - ::grpc_impl::CallbackServerContext*, const RequestType*)> + ::grpc::CallbackServerContext*, const RequestType*)> get_reactor_; class ServerCallbackWriterImpl : public ServerCallbackWriter { @@ -587,7 +581,7 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler { private: friend class CallbackServerStreamingHandler; - ServerCallbackWriterImpl(::grpc_impl::CallbackServerContext* ctx, + ServerCallbackWriterImpl(::grpc::CallbackServerContext* ctx, ::grpc::internal::Call* call, const RequestType* req, std::function call_requester) @@ -645,7 +639,7 @@ class CallbackServerStreamingHandler : public ::grpc::internal::MethodHandler { write_ops_; ::grpc::internal::CallbackWithSuccessTag write_tag_; - ::grpc_impl::CallbackServerContext* const ctx_; + ::grpc::CallbackServerContext* const ctx_; ::grpc::internal::Call call_; const RequestType* req_; std::function call_requester_; @@ -662,7 +656,7 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler { public: explicit CallbackBidiHandler( std::function*( - ::grpc_impl::CallbackServerContext*)> + ::grpc::CallbackServerContext*)> get_reactor) : get_reactor_(std::move(get_reactor)) {} void RunHandler(const HandlerParameter& param) final { @@ -671,8 +665,7 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler { auto* stream = new (::grpc::g_core_codegen_interface->grpc_call_arena_alloc( param.call->call(), sizeof(ServerCallbackReaderWriterImpl))) ServerCallbackReaderWriterImpl( - static_cast<::grpc_impl::CallbackServerContext*>( - param.server_context), + static_cast<::grpc::CallbackServerContext*>(param.server_context), param.call, std::move(param.call_requester)); // Inlineable OnDone can be false in the CompletionOp callback because there // is no bidi reactor that has an inlineable OnDone; this only applies to @@ -686,8 +679,8 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler { if (param.status.ok()) { reactor = ::grpc::internal::CatchingReactorGetter< ServerBidiReactor>( - get_reactor_, static_cast<::grpc_impl::CallbackServerContext*>( - param.server_context)); + get_reactor_, + static_cast<::grpc::CallbackServerContext*>(param.server_context)); } if (reactor == nullptr) { @@ -704,7 +697,7 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler { private: std::function*( - ::grpc_impl::CallbackServerContext*)> + ::grpc::CallbackServerContext*)> get_reactor_; class ServerCallbackReaderWriterImpl @@ -795,7 +788,7 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler { private: friend class CallbackBidiHandler; - ServerCallbackReaderWriterImpl(::grpc_impl::CallbackServerContext* ctx, + ServerCallbackReaderWriterImpl(::grpc::CallbackServerContext* ctx, ::grpc::internal::Call* call, std::function call_requester) : ctx_(ctx), call_(*call), call_requester_(std::move(call_requester)) {} @@ -857,7 +850,7 @@ class CallbackBidiHandler : public ::grpc::internal::MethodHandler { read_ops_; ::grpc::internal::CallbackWithSuccessTag read_tag_; - ::grpc_impl::CallbackServerContext* const ctx_; + ::grpc::CallbackServerContext* const ctx_; ::grpc::internal::Call call_; std::function call_requester_; // The memory ordering of reactor_ follows ServerCallbackUnaryImpl. diff --git a/include/grpcpp/impl/codegen/server_context.h b/include/grpcpp/impl/codegen/server_context.h index 85b309e6d52..001e57dc536 100644 --- a/include/grpcpp/impl/codegen/server_context.h +++ b/include/grpcpp/impl/codegen/server_context.h @@ -1,6 +1,6 @@ /* * - * Copyright 2015 gRPC authors. + * Copyright 2019 gRPC authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,24 +19,598 @@ #ifndef GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_H #define GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_H -#include +#include +#include +#include +#include +#include +#include -namespace grpc { +#include -typedef ::grpc_impl::ServerContext ServerContext; +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include -#ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL -typedef ::grpc_impl::ServerContextBase ServerContextBase; -typedef ::grpc_impl::CallbackServerContext CallbackServerContext; -#endif +struct grpc_metadata; +struct grpc_call; +struct census_context; + +namespace grpc_impl { +template +class ServerAsyncReader; +template +class ServerAsyncWriter; +template +class ServerAsyncResponseWriter; +template +class ServerAsyncReaderWriter; +template +class ServerReader; +template +class ServerWriter; + +namespace internal { +template +class BidiStreamingHandler; +template +class CallbackUnaryHandler; +template +class CallbackClientStreamingHandler; +template +class CallbackServerStreamingHandler; +template +class CallbackBidiHandler; +template +class ClientStreamingHandler; +template +class RpcMethodHandler; +template +class FinishOnlyReactor; +template +class ServerReaderWriterBody; +template +class ServerStreamingHandler; +class ServerReactor; +template +class TemplatedBidiStreamingHandler; +template <::grpc::StatusCode code> +class ErrorMethodHandler; +} // namespace internal + +} // namespace grpc_impl +namespace grpc { +class ClientContext; +class CompletionQueue; +class GenericServerContext; +class Server; +class ServerInterface; // TODO(vjpai): Remove namespace experimental when de-experimentalized fully. namespace experimental { -typedef ::grpc_impl::ServerContextBase ServerContextBase; -typedef ::grpc_impl::CallbackServerContext CallbackServerContext; +typedef ::grpc::ServerContextBase ServerContextBase; +typedef ::grpc::CallbackServerContext CallbackServerContext; } // namespace experimental + +#ifndef GRPC_CALLBACK_API_NONEXPERIMENTAL +namespace experimental { +#endif +class GenericCallbackServerContext; +#ifndef GRPC_CALLBACK_API_NONEXPERIMENTAL +} // namespace experimental +#endif +namespace internal { +class Call; +} // namespace internal + +namespace testing { +class InteropServerContextInspector; +class ServerContextTestSpouse; +class DefaultReactorTestPeer; +} // namespace testing + +/// Base class of ServerContext. Experimental until callback API is final. +class ServerContextBase { + public: + virtual ~ServerContextBase(); + + /// Return the deadline for the server call. + std::chrono::system_clock::time_point deadline() const { + return ::grpc::Timespec2Timepoint(deadline_); + } + + /// Return a \a gpr_timespec representation of the server call's deadline. + gpr_timespec raw_deadline() const { return deadline_; } + + /// Add the (\a key, \a value) pair to the initial metadata + /// associated with a server call. These are made available at the client side + /// by the \a grpc::ClientContext::GetServerInitialMetadata() method. + /// + /// \warning This method should only be called before sending initial metadata + /// to the client (which can happen explicitly, or implicitly when sending a + /// a response message or status to the client). + /// + /// \param key The metadata key. If \a value is binary data, it must + /// end in "-bin". + /// \param value The metadata value. If its value is binary, the key name + /// must end in "-bin". + /// + /// Metadata must conform to the following format: + /// Custom-Metadata -> Binary-Header / ASCII-Header + /// Binary-Header -> {Header-Name "-bin" } {binary value} + /// ASCII-Header -> Header-Name ASCII-Value + /// Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - . + /// ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII + void AddInitialMetadata(const std::string& key, const std::string& value); + + /// Add the (\a key, \a value) pair to the initial metadata + /// associated with a server call. These are made available at the client + /// side by the \a grpc::ClientContext::GetServerTrailingMetadata() method. + /// + /// \warning This method should only be called before sending trailing + /// metadata to the client (which happens when the call is finished and a + /// status is sent to the client). + /// + /// \param key The metadata key. If \a value is binary data, + /// it must end in "-bin". + /// \param value The metadata value. If its value is binary, the key name + /// must end in "-bin". + /// + /// Metadata must conform to the following format: + /// Custom-Metadata -> Binary-Header / ASCII-Header + /// Binary-Header -> {Header-Name "-bin" } {binary value} + /// ASCII-Header -> Header-Name ASCII-Value + /// Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - . + /// ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII + void AddTrailingMetadata(const std::string& key, const std::string& value); + + /// Return whether this RPC failed before the server could provide its status + /// back to the client. This could be because of explicit API cancellation + /// from the client-side or server-side, because of deadline exceeded, network + /// connection reset, HTTP/2 parameter configuration (e.g., max message size, + /// max connection age), etc. It does NOT include failure due to a non-OK + /// status return from the server application's request handler, including + /// Status::CANCELLED. + /// + /// IsCancelled is always safe to call when using sync or callback API. + /// When using async API, it is only safe to call IsCancelled after + /// the AsyncNotifyWhenDone tag has been delivered. Thread-safe. + bool IsCancelled() const; + + /// Cancel the Call from the server. This is a best-effort API and + /// depending on when it is called, the RPC may still appear successful to + /// the client. For example, if TryCancel() is called on a separate thread, it + /// might race with the server handler which might return success to the + /// client before TryCancel() was even started by the thread. + /// + /// It is the caller's responsibility to prevent such races and ensure that if + /// TryCancel() is called, the serverhandler must return Status::CANCELLED. + /// The only exception is that if the serverhandler is already returning an + /// error status code, it is ok to not return Status::CANCELLED even if + /// TryCancel() was called. + /// + /// For reasons such as the above, it is generally preferred to explicitly + /// finish an RPC by returning Status::CANCELLED rather than using TryCancel. + /// + /// Note that TryCancel() does not change any of the tags that are pending + /// on the completion queue. All pending tags will still be delivered + /// (though their ok result may reflect the effect of cancellation). + void TryCancel() const; + + /// Return a collection of initial metadata key-value pairs sent from the + /// client. Note that keys may happen more than + /// once (ie, a \a std::multimap is returned). + /// + /// It is safe to use this method after initial metadata has been received, + /// Calls always begin with the client sending initial metadata, so this is + /// safe to access as soon as the call has begun on the server side. + /// + /// \return A multimap of initial metadata key-value pairs from the server. + const std::multimap& client_metadata() + const { + return *client_metadata_.map(); + } + + /// Return the compression algorithm to be used by the server call. + grpc_compression_level compression_level() const { + return compression_level_; + } + + /// Set \a level to be the compression level used for the server call. + /// + /// \param level The compression level used for the server call. + void set_compression_level(grpc_compression_level level) { + compression_level_set_ = true; + compression_level_ = level; + } + + /// Return a bool indicating whether the compression level for this call + /// has been set (either implicitly or through a previous call to + /// \a set_compression_level. + bool compression_level_set() const { return compression_level_set_; } + + /// Return the compression algorithm the server call will request be used. + /// Note that the gRPC runtime may decide to ignore this request, for example, + /// due to resource constraints, or if the server is aware the client doesn't + /// support the requested algorithm. + grpc_compression_algorithm compression_algorithm() const { + return compression_algorithm_; + } + /// Set \a algorithm to be the compression algorithm used for the server call. + /// + /// \param algorithm The compression algorithm used for the server call. + void set_compression_algorithm(grpc_compression_algorithm algorithm); + + /// Set the serialized load reporting costs in \a cost_data for the call. + void SetLoadReportingCosts(const std::vector& cost_data); + + /// Return the authentication context for this server call. + /// + /// \see grpc::AuthContext. + std::shared_ptr auth_context() const { + if (auth_context_.get() == nullptr) { + auth_context_ = ::grpc::CreateAuthContext(call_); + } + return auth_context_; + } + + /// Return the peer uri in a string. + /// WARNING: this value is never authenticated or subject to any security + /// related code. It must not be used for any authentication related + /// functionality. Instead, use auth_context. + std::string peer() const; + + /// Get the census context associated with this server call. + const struct census_context* census_context() const; + + /// Should be used for framework-level extensions only. + /// Applications never need to call this method. + grpc_call* c_call() { return call_; } + + protected: + /// Async only. Has to be called before the rpc starts. + /// Returns the tag in completion queue when the rpc finishes. + /// IsCancelled() can then be called to check whether the rpc was cancelled. + /// TODO(vjpai): Fix this so that the tag is returned even if the call never + /// starts (https://github.com/grpc/grpc/issues/10136). + void AsyncNotifyWhenDone(void* tag) { + has_notify_when_done_tag_ = true; + async_notify_when_done_tag_ = tag; + } + + /// NOTE: This is an API for advanced users who need custom allocators. + /// Get and maybe mutate the allocator state associated with the current RPC. + /// Currently only applicable for callback unary RPC methods. + /// WARNING: This is experimental API and could be changed or removed. + ::grpc::experimental::RpcAllocatorState* GetRpcAllocatorState() { + return message_allocator_state_; + } + + /// Get a library-owned default unary reactor for use in minimal reaction + /// cases. This supports typical unary RPC usage of providing a response and + /// status. It supports immediate Finish (finish from within the method + /// handler) or delayed Finish (finish called after the method handler + /// invocation). It does not support reacting to cancellation or completion, + /// or early sending of initial metadata. Since this is a library-owned + /// reactor, it should not be delete'd or freed in any way. This is more + /// efficient than creating a user-owned reactor both because of avoiding an + /// allocation and because its minimal reactions are optimized using a core + /// surface flag that allows their reactions to run inline without any + /// thread-hop. + /// + /// This method should not be called more than once or called after return + /// from the method handler. + /// + /// WARNING: This is experimental API and could be changed or removed. + ::grpc_impl::ServerUnaryReactor* DefaultReactor() { + // Short-circuit the case where a default reactor was already set up by + // the TestPeer. + if (test_unary_ != nullptr) { + return reinterpret_cast(&default_reactor_); + } + new (&default_reactor_) Reactor; +#ifndef NDEBUG + bool old = false; + assert(default_reactor_used_.compare_exchange_strong( + old, true, std::memory_order_relaxed)); +#else + default_reactor_used_.store(true, std::memory_order_relaxed); +#endif + return reinterpret_cast(&default_reactor_); + } + + /// Constructors for use by derived classes + ServerContextBase(); + ServerContextBase(gpr_timespec deadline, grpc_metadata_array* arr); + + private: + friend class ::grpc::testing::InteropServerContextInspector; + friend class ::grpc::testing::ServerContextTestSpouse; + friend class ::grpc::testing::DefaultReactorTestPeer; + friend class ::grpc::ServerInterface; + friend class ::grpc::Server; + template + friend class ::grpc_impl::ServerAsyncReader; + template + friend class ::grpc_impl::ServerAsyncWriter; + template + friend class ::grpc_impl::ServerAsyncResponseWriter; + template + friend class ::grpc_impl::ServerAsyncReaderWriter; + template + friend class ::grpc_impl::ServerReader; + template + friend class ::grpc_impl::ServerWriter; + template + friend class ::grpc_impl::internal::ServerReaderWriterBody; + template + friend class ::grpc_impl::internal::RpcMethodHandler; + template + friend class ::grpc_impl::internal::ClientStreamingHandler; + template + friend class ::grpc_impl::internal::ServerStreamingHandler; + template + friend class ::grpc_impl::internal::TemplatedBidiStreamingHandler; + template + friend class ::grpc_impl::internal::CallbackUnaryHandler; + template + friend class ::grpc_impl::internal::CallbackClientStreamingHandler; + template + friend class ::grpc_impl::internal::CallbackServerStreamingHandler; + template + friend class ::grpc_impl::internal::CallbackBidiHandler; + template <::grpc::StatusCode code> + friend class ::grpc_impl::internal::ErrorMethodHandler; + template + friend class ::grpc_impl::internal::FinishOnlyReactor; + friend class ::grpc::ClientContext; + friend class ::grpc::GenericServerContext; +#ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL + friend class ::grpc::GenericCallbackServerContext; +#else + friend class ::grpc::experimental::GenericCallbackServerContext; +#endif + + /// Prevent copying. + ServerContextBase(const ServerContextBase&); + ServerContextBase& operator=(const ServerContextBase&); + + class CompletionOp; + + void BeginCompletionOp( + ::grpc::internal::Call* call, std::function callback, + ::grpc_impl::internal::ServerCallbackCall* callback_controller); + /// Return the tag queued by BeginCompletionOp() + ::grpc::internal::CompletionQueueTag* GetCompletionOpTag(); + + void set_call(grpc_call* call) { call_ = call; } + + void BindDeadlineAndMetadata(gpr_timespec deadline, grpc_metadata_array* arr); + + void Clear(); + + void Setup(gpr_timespec deadline); + + uint32_t initial_metadata_flags() const { return 0; } + + ::grpc::experimental::ServerRpcInfo* set_server_rpc_info( + const char* method, ::grpc::internal::RpcMethod::RpcType type, + const std::vector>& creators) { + if (creators.size() != 0) { + rpc_info_ = new ::grpc::experimental::ServerRpcInfo(this, method, type); + rpc_info_->RegisterInterceptors(creators); + } + return rpc_info_; + } + + void set_message_allocator_state( + ::grpc::experimental::RpcAllocatorState* allocator_state) { + message_allocator_state_ = allocator_state; + } + + CompletionOp* completion_op_; + bool has_notify_when_done_tag_; + void* async_notify_when_done_tag_; + ::grpc::internal::CallbackWithSuccessTag completion_tag_; + + gpr_timespec deadline_; + grpc_call* call_; + ::grpc::CompletionQueue* cq_; + bool sent_initial_metadata_; + mutable std::shared_ptr auth_context_; + mutable ::grpc::internal::MetadataMap client_metadata_; + std::multimap initial_metadata_; + std::multimap trailing_metadata_; + + bool compression_level_set_; + grpc_compression_level compression_level_; + grpc_compression_algorithm compression_algorithm_; + + ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata, + ::grpc::internal::CallOpSendMessage> + pending_ops_; + bool has_pending_ops_; + + ::grpc::experimental::ServerRpcInfo* rpc_info_; + ::grpc::experimental::RpcAllocatorState* message_allocator_state_ = nullptr; + + class Reactor : public ::grpc_impl::ServerUnaryReactor { + public: + void OnCancel() override {} + void OnDone() override {} + // Override InternalInlineable for this class since its reactions are + // trivial and thus do not need to be run from the executor (triggering a + // thread hop). This should only be used by internal reactors (thus the + // name) and not by user application code. + bool InternalInlineable() override { return true; } + }; + + void SetupTestDefaultReactor(std::function func) { + test_unary_.reset(new TestServerCallbackUnary(this, std::move(func))); + } + bool test_status_set() const { + return (test_unary_ != nullptr) && test_unary_->status_set(); + } + ::grpc::Status test_status() const { return test_unary_->status(); } + + class TestServerCallbackUnary : public ::grpc_impl::ServerCallbackUnary { + public: + TestServerCallbackUnary(ServerContextBase* ctx, + std::function func) + : reactor_(ctx->DefaultReactor()), func_(std::move(func)) { + this->BindReactor(reactor_); + } + void Finish(::grpc::Status s) override { + status_ = s; + func_(std::move(s)); + status_set_.store(true, std::memory_order_release); + } + void SendInitialMetadata() override {} + + bool status_set() const { + return status_set_.load(std::memory_order_acquire); + } + ::grpc::Status status() const { return status_; } + + private: + void CallOnDone() override {} + ::grpc_impl::internal::ServerReactor* reactor() override { + return reactor_; + } + + ::grpc_impl::ServerUnaryReactor* const reactor_; + std::atomic_bool status_set_{false}; + ::grpc::Status status_; + const std::function func_; + }; + + typename std::aligned_storage::type + default_reactor_; + std::atomic_bool default_reactor_used_{false}; + std::unique_ptr test_unary_; +}; + +/// A ServerContext or CallbackServerContext allows the code implementing a +/// service handler to: +/// +/// - Add custom initial and trailing metadata key-value pairs that will +/// propagated to the client side. +/// - Control call settings such as compression and authentication. +/// - Access metadata coming from the client. +/// - Get performance metrics (ie, census). +/// +/// Context settings are only relevant to the call handler they are supplied to, +/// that is to say, they aren't sticky across multiple calls. Some of these +/// settings, such as the compression options, can be made persistent at server +/// construction time by specifying the appropriate \a ChannelArguments +/// to a \a grpc::ServerBuilder, via \a ServerBuilder::AddChannelArgument. +/// +/// \warning ServerContext instances should \em not be reused across rpcs. +class ServerContext : public ServerContextBase { + public: + ServerContext() {} // for async calls + + using ServerContextBase::AddInitialMetadata; + using ServerContextBase::AddTrailingMetadata; + using ServerContextBase::auth_context; + using ServerContextBase::c_call; + using ServerContextBase::census_context; + using ServerContextBase::client_metadata; + using ServerContextBase::compression_algorithm; + using ServerContextBase::compression_level; + using ServerContextBase::compression_level_set; + using ServerContextBase::deadline; + using ServerContextBase::IsCancelled; + using ServerContextBase::peer; + using ServerContextBase::raw_deadline; + using ServerContextBase::set_compression_algorithm; + using ServerContextBase::set_compression_level; + using ServerContextBase::SetLoadReportingCosts; + using ServerContextBase::TryCancel; + + // Sync/CQ-based Async ServerContext only + using ServerContextBase::AsyncNotifyWhenDone; + + private: + // Constructor for internal use by server only + friend class ::grpc::Server; + ServerContext(gpr_timespec deadline, grpc_metadata_array* arr) + : ServerContextBase(deadline, arr) {} + + // CallbackServerContext only + using ServerContextBase::DefaultReactor; + using ServerContextBase::GetRpcAllocatorState; + + /// Prevent copying. + ServerContext(const ServerContext&) = delete; + ServerContext& operator=(const ServerContext&) = delete; +}; + +class CallbackServerContext : public ServerContextBase { + public: + /// Public constructors are for direct use only by mocking tests. In practice, + /// these objects will be owned by the library. + CallbackServerContext() {} + + using ServerContextBase::AddInitialMetadata; + using ServerContextBase::AddTrailingMetadata; + using ServerContextBase::auth_context; + using ServerContextBase::c_call; + using ServerContextBase::census_context; + using ServerContextBase::client_metadata; + using ServerContextBase::compression_algorithm; + using ServerContextBase::compression_level; + using ServerContextBase::compression_level_set; + using ServerContextBase::deadline; + using ServerContextBase::IsCancelled; + using ServerContextBase::peer; + using ServerContextBase::raw_deadline; + using ServerContextBase::set_compression_algorithm; + using ServerContextBase::set_compression_level; + using ServerContextBase::SetLoadReportingCosts; + using ServerContextBase::TryCancel; + + // CallbackServerContext only + using ServerContextBase::DefaultReactor; + using ServerContextBase::GetRpcAllocatorState; + + private: + // Sync/CQ-based Async ServerContext only + using ServerContextBase::AsyncNotifyWhenDone; + + /// Prevent copying. + CallbackServerContext(const CallbackServerContext&) = delete; + CallbackServerContext& operator=(const CallbackServerContext&) = delete; +}; + } // namespace grpc +static_assert( + std::is_base_of<::grpc::ServerContextBase, ::grpc::ServerContext>::value, + "improper base class"); +static_assert(std::is_base_of<::grpc::ServerContextBase, + ::grpc::CallbackServerContext>::value, + "improper base class"); +static_assert(sizeof(::grpc::ServerContextBase) == + sizeof(::grpc::ServerContext), + "wrong size"); +static_assert(sizeof(::grpc::ServerContextBase) == + sizeof(::grpc::CallbackServerContext), + "wrong size"); + #endif // GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_H diff --git a/include/grpcpp/impl/codegen/server_context_impl.h b/include/grpcpp/impl/codegen/server_context_impl.h deleted file mode 100644 index 4312869925d..00000000000 --- a/include/grpcpp/impl/codegen/server_context_impl.h +++ /dev/null @@ -1,612 +0,0 @@ -/* - * - * Copyright 2019 gRPC authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -#ifndef GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_IMPL_H -#define GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_IMPL_H - -#include -#include -#include -#include -#include -#include - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -struct grpc_metadata; -struct grpc_call; -struct census_context; - -namespace grpc_impl { -template -class ServerAsyncReader; -template -class ServerAsyncWriter; -template -class ServerAsyncResponseWriter; -template -class ServerAsyncReaderWriter; -template -class ServerReader; -template -class ServerWriter; - -namespace internal { -template -class BidiStreamingHandler; -template -class CallbackUnaryHandler; -template -class CallbackClientStreamingHandler; -template -class CallbackServerStreamingHandler; -template -class CallbackBidiHandler; -template -class ClientStreamingHandler; -template -class RpcMethodHandler; -template -class FinishOnlyReactor; -template -class ServerReaderWriterBody; -template -class ServerStreamingHandler; -class ServerReactor; -template -class TemplatedBidiStreamingHandler; -template <::grpc::StatusCode code> -class ErrorMethodHandler; -} // namespace internal - -} // namespace grpc_impl -namespace grpc { -class ClientContext; -class CompletionQueue; -class GenericServerContext; -class Server; -class ServerInterface; - -#ifndef GRPC_CALLBACK_API_NONEXPERIMENTAL -namespace experimental { -#endif -class GenericCallbackServerContext; -#ifndef GRPC_CALLBACK_API_NONEXPERIMENTAL -} // namespace experimental -#endif -namespace internal { -class Call; -} // namespace internal - -namespace testing { -class InteropServerContextInspector; -class ServerContextTestSpouse; -class DefaultReactorTestPeer; -} // namespace testing - -} // namespace grpc - -namespace grpc_impl { - -/// Base class of ServerContext. Experimental until callback API is final. -class ServerContextBase { - public: - virtual ~ServerContextBase(); - - /// Return the deadline for the server call. - std::chrono::system_clock::time_point deadline() const { - return ::grpc::Timespec2Timepoint(deadline_); - } - - /// Return a \a gpr_timespec representation of the server call's deadline. - gpr_timespec raw_deadline() const { return deadline_; } - - /// Add the (\a key, \a value) pair to the initial metadata - /// associated with a server call. These are made available at the client side - /// by the \a grpc::ClientContext::GetServerInitialMetadata() method. - /// - /// \warning This method should only be called before sending initial metadata - /// to the client (which can happen explicitly, or implicitly when sending a - /// a response message or status to the client). - /// - /// \param key The metadata key. If \a value is binary data, it must - /// end in "-bin". - /// \param value The metadata value. If its value is binary, the key name - /// must end in "-bin". - /// - /// Metadata must conform to the following format: - /// Custom-Metadata -> Binary-Header / ASCII-Header - /// Binary-Header -> {Header-Name "-bin" } {binary value} - /// ASCII-Header -> Header-Name ASCII-Value - /// Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - . - /// ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII - void AddInitialMetadata(const std::string& key, const std::string& value); - - /// Add the (\a key, \a value) pair to the initial metadata - /// associated with a server call. These are made available at the client - /// side by the \a grpc::ClientContext::GetServerTrailingMetadata() method. - /// - /// \warning This method should only be called before sending trailing - /// metadata to the client (which happens when the call is finished and a - /// status is sent to the client). - /// - /// \param key The metadata key. If \a value is binary data, - /// it must end in "-bin". - /// \param value The metadata value. If its value is binary, the key name - /// must end in "-bin". - /// - /// Metadata must conform to the following format: - /// Custom-Metadata -> Binary-Header / ASCII-Header - /// Binary-Header -> {Header-Name "-bin" } {binary value} - /// ASCII-Header -> Header-Name ASCII-Value - /// Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - . - /// ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII - void AddTrailingMetadata(const std::string& key, const std::string& value); - - /// Return whether this RPC failed before the server could provide its status - /// back to the client. This could be because of explicit API cancellation - /// from the client-side or server-side, because of deadline exceeded, network - /// connection reset, HTTP/2 parameter configuration (e.g., max message size, - /// max connection age), etc. It does NOT include failure due to a non-OK - /// status return from the server application's request handler, including - /// Status::CANCELLED. - /// - /// IsCancelled is always safe to call when using sync or callback API. - /// When using async API, it is only safe to call IsCancelled after - /// the AsyncNotifyWhenDone tag has been delivered. Thread-safe. - bool IsCancelled() const; - - /// Cancel the Call from the server. This is a best-effort API and - /// depending on when it is called, the RPC may still appear successful to - /// the client. For example, if TryCancel() is called on a separate thread, it - /// might race with the server handler which might return success to the - /// client before TryCancel() was even started by the thread. - /// - /// It is the caller's responsibility to prevent such races and ensure that if - /// TryCancel() is called, the serverhandler must return Status::CANCELLED. - /// The only exception is that if the serverhandler is already returning an - /// error status code, it is ok to not return Status::CANCELLED even if - /// TryCancel() was called. - /// - /// For reasons such as the above, it is generally preferred to explicitly - /// finish an RPC by returning Status::CANCELLED rather than using TryCancel. - /// - /// Note that TryCancel() does not change any of the tags that are pending - /// on the completion queue. All pending tags will still be delivered - /// (though their ok result may reflect the effect of cancellation). - void TryCancel() const; - - /// Return a collection of initial metadata key-value pairs sent from the - /// client. Note that keys may happen more than - /// once (ie, a \a std::multimap is returned). - /// - /// It is safe to use this method after initial metadata has been received, - /// Calls always begin with the client sending initial metadata, so this is - /// safe to access as soon as the call has begun on the server side. - /// - /// \return A multimap of initial metadata key-value pairs from the server. - const std::multimap& client_metadata() - const { - return *client_metadata_.map(); - } - - /// Return the compression algorithm to be used by the server call. - grpc_compression_level compression_level() const { - return compression_level_; - } - - /// Set \a level to be the compression level used for the server call. - /// - /// \param level The compression level used for the server call. - void set_compression_level(grpc_compression_level level) { - compression_level_set_ = true; - compression_level_ = level; - } - - /// Return a bool indicating whether the compression level for this call - /// has been set (either implicitly or through a previous call to - /// \a set_compression_level. - bool compression_level_set() const { return compression_level_set_; } - - /// Return the compression algorithm the server call will request be used. - /// Note that the gRPC runtime may decide to ignore this request, for example, - /// due to resource constraints, or if the server is aware the client doesn't - /// support the requested algorithm. - grpc_compression_algorithm compression_algorithm() const { - return compression_algorithm_; - } - /// Set \a algorithm to be the compression algorithm used for the server call. - /// - /// \param algorithm The compression algorithm used for the server call. - void set_compression_algorithm(grpc_compression_algorithm algorithm); - - /// Set the serialized load reporting costs in \a cost_data for the call. - void SetLoadReportingCosts(const std::vector& cost_data); - - /// Return the authentication context for this server call. - /// - /// \see grpc::AuthContext. - std::shared_ptr auth_context() const { - if (auth_context_.get() == nullptr) { - auth_context_ = ::grpc::CreateAuthContext(call_); - } - return auth_context_; - } - - /// Return the peer uri in a string. - /// WARNING: this value is never authenticated or subject to any security - /// related code. It must not be used for any authentication related - /// functionality. Instead, use auth_context. - std::string peer() const; - - /// Get the census context associated with this server call. - const struct census_context* census_context() const; - - /// Should be used for framework-level extensions only. - /// Applications never need to call this method. - grpc_call* c_call() { return call_; } - - protected: - /// Async only. Has to be called before the rpc starts. - /// Returns the tag in completion queue when the rpc finishes. - /// IsCancelled() can then be called to check whether the rpc was cancelled. - /// TODO(vjpai): Fix this so that the tag is returned even if the call never - /// starts (https://github.com/grpc/grpc/issues/10136). - void AsyncNotifyWhenDone(void* tag) { - has_notify_when_done_tag_ = true; - async_notify_when_done_tag_ = tag; - } - - /// NOTE: This is an API for advanced users who need custom allocators. - /// Get and maybe mutate the allocator state associated with the current RPC. - /// Currently only applicable for callback unary RPC methods. - /// WARNING: This is experimental API and could be changed or removed. - ::grpc::experimental::RpcAllocatorState* GetRpcAllocatorState() { - return message_allocator_state_; - } - - /// Get a library-owned default unary reactor for use in minimal reaction - /// cases. This supports typical unary RPC usage of providing a response and - /// status. It supports immediate Finish (finish from within the method - /// handler) or delayed Finish (finish called after the method handler - /// invocation). It does not support reacting to cancellation or completion, - /// or early sending of initial metadata. Since this is a library-owned - /// reactor, it should not be delete'd or freed in any way. This is more - /// efficient than creating a user-owned reactor both because of avoiding an - /// allocation and because its minimal reactions are optimized using a core - /// surface flag that allows their reactions to run inline without any - /// thread-hop. - /// - /// This method should not be called more than once or called after return - /// from the method handler. - /// - /// WARNING: This is experimental API and could be changed or removed. - ::grpc_impl::ServerUnaryReactor* DefaultReactor() { - // Short-circuit the case where a default reactor was already set up by - // the TestPeer. - if (test_unary_ != nullptr) { - return reinterpret_cast(&default_reactor_); - } - new (&default_reactor_) Reactor; -#ifndef NDEBUG - bool old = false; - assert(default_reactor_used_.compare_exchange_strong( - old, true, std::memory_order_relaxed)); -#else - default_reactor_used_.store(true, std::memory_order_relaxed); -#endif - return reinterpret_cast(&default_reactor_); - } - - /// Constructors for use by derived classes - ServerContextBase(); - ServerContextBase(gpr_timespec deadline, grpc_metadata_array* arr); - - private: - friend class ::grpc::testing::InteropServerContextInspector; - friend class ::grpc::testing::ServerContextTestSpouse; - friend class ::grpc::testing::DefaultReactorTestPeer; - friend class ::grpc::ServerInterface; - friend class ::grpc::Server; - template - friend class ::grpc_impl::ServerAsyncReader; - template - friend class ::grpc_impl::ServerAsyncWriter; - template - friend class ::grpc_impl::ServerAsyncResponseWriter; - template - friend class ::grpc_impl::ServerAsyncReaderWriter; - template - friend class ::grpc_impl::ServerReader; - template - friend class ::grpc_impl::ServerWriter; - template - friend class ::grpc_impl::internal::ServerReaderWriterBody; - template - friend class ::grpc_impl::internal::RpcMethodHandler; - template - friend class ::grpc_impl::internal::ClientStreamingHandler; - template - friend class ::grpc_impl::internal::ServerStreamingHandler; - template - friend class ::grpc_impl::internal::TemplatedBidiStreamingHandler; - template - friend class ::grpc_impl::internal::CallbackUnaryHandler; - template - friend class ::grpc_impl::internal::CallbackClientStreamingHandler; - template - friend class ::grpc_impl::internal::CallbackServerStreamingHandler; - template - friend class ::grpc_impl::internal::CallbackBidiHandler; - template <::grpc::StatusCode code> - friend class ::grpc_impl::internal::ErrorMethodHandler; - template - friend class ::grpc_impl::internal::FinishOnlyReactor; - friend class ::grpc::ClientContext; - friend class ::grpc::GenericServerContext; -#ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL - friend class ::grpc::GenericCallbackServerContext; -#else - friend class ::grpc::experimental::GenericCallbackServerContext; -#endif - - /// Prevent copying. - ServerContextBase(const ServerContextBase&); - ServerContextBase& operator=(const ServerContextBase&); - - class CompletionOp; - - void BeginCompletionOp( - ::grpc::internal::Call* call, std::function callback, - ::grpc_impl::internal::ServerCallbackCall* callback_controller); - /// Return the tag queued by BeginCompletionOp() - ::grpc::internal::CompletionQueueTag* GetCompletionOpTag(); - - void set_call(grpc_call* call) { call_ = call; } - - void BindDeadlineAndMetadata(gpr_timespec deadline, grpc_metadata_array* arr); - - void Clear(); - - void Setup(gpr_timespec deadline); - - uint32_t initial_metadata_flags() const { return 0; } - - ::grpc::experimental::ServerRpcInfo* set_server_rpc_info( - const char* method, ::grpc::internal::RpcMethod::RpcType type, - const std::vector>& creators) { - if (creators.size() != 0) { - rpc_info_ = new ::grpc::experimental::ServerRpcInfo(this, method, type); - rpc_info_->RegisterInterceptors(creators); - } - return rpc_info_; - } - - void set_message_allocator_state( - ::grpc::experimental::RpcAllocatorState* allocator_state) { - message_allocator_state_ = allocator_state; - } - - CompletionOp* completion_op_; - bool has_notify_when_done_tag_; - void* async_notify_when_done_tag_; - ::grpc::internal::CallbackWithSuccessTag completion_tag_; - - gpr_timespec deadline_; - grpc_call* call_; - ::grpc::CompletionQueue* cq_; - bool sent_initial_metadata_; - mutable std::shared_ptr auth_context_; - mutable ::grpc::internal::MetadataMap client_metadata_; - std::multimap initial_metadata_; - std::multimap trailing_metadata_; - - bool compression_level_set_; - grpc_compression_level compression_level_; - grpc_compression_algorithm compression_algorithm_; - - ::grpc::internal::CallOpSet<::grpc::internal::CallOpSendInitialMetadata, - ::grpc::internal::CallOpSendMessage> - pending_ops_; - bool has_pending_ops_; - - ::grpc::experimental::ServerRpcInfo* rpc_info_; - ::grpc::experimental::RpcAllocatorState* message_allocator_state_ = nullptr; - - class Reactor : public ServerUnaryReactor { - public: - void OnCancel() override {} - void OnDone() override {} - // Override InternalInlineable for this class since its reactions are - // trivial and thus do not need to be run from the executor (triggering a - // thread hop). This should only be used by internal reactors (thus the - // name) and not by user application code. - bool InternalInlineable() override { return true; } - }; - - void SetupTestDefaultReactor(std::function func) { - test_unary_.reset(new TestServerCallbackUnary(this, std::move(func))); - } - bool test_status_set() const { - return (test_unary_ != nullptr) && test_unary_->status_set(); - } - ::grpc::Status test_status() const { return test_unary_->status(); } - - class TestServerCallbackUnary : public ::grpc_impl::ServerCallbackUnary { - public: - TestServerCallbackUnary(ServerContextBase* ctx, - std::function func) - : reactor_(ctx->DefaultReactor()), func_(std::move(func)) { - this->BindReactor(reactor_); - } - void Finish(::grpc::Status s) override { - status_ = s; - func_(std::move(s)); - status_set_.store(true, std::memory_order_release); - } - void SendInitialMetadata() override {} - - bool status_set() const { - return status_set_.load(std::memory_order_acquire); - } - ::grpc::Status status() const { return status_; } - - private: - void CallOnDone() override {} - ::grpc_impl::internal::ServerReactor* reactor() override { - return reactor_; - } - - ::grpc_impl::ServerUnaryReactor* const reactor_; - std::atomic_bool status_set_{false}; - ::grpc::Status status_; - const std::function func_; - }; - - typename std::aligned_storage::type - default_reactor_; - std::atomic_bool default_reactor_used_{false}; - std::unique_ptr test_unary_; -}; - -/// A ServerContext or CallbackServerContext allows the code implementing a -/// service handler to: -/// -/// - Add custom initial and trailing metadata key-value pairs that will -/// propagated to the client side. -/// - Control call settings such as compression and authentication. -/// - Access metadata coming from the client. -/// - Get performance metrics (ie, census). -/// -/// Context settings are only relevant to the call handler they are supplied to, -/// that is to say, they aren't sticky across multiple calls. Some of these -/// settings, such as the compression options, can be made persistent at server -/// construction time by specifying the appropriate \a ChannelArguments -/// to a \a grpc::ServerBuilder, via \a ServerBuilder::AddChannelArgument. -/// -/// \warning ServerContext instances should \em not be reused across rpcs. -class ServerContext : public ServerContextBase { - public: - ServerContext() {} // for async calls - - using ServerContextBase::AddInitialMetadata; - using ServerContextBase::AddTrailingMetadata; - using ServerContextBase::auth_context; - using ServerContextBase::c_call; - using ServerContextBase::census_context; - using ServerContextBase::client_metadata; - using ServerContextBase::compression_algorithm; - using ServerContextBase::compression_level; - using ServerContextBase::compression_level_set; - using ServerContextBase::deadline; - using ServerContextBase::IsCancelled; - using ServerContextBase::peer; - using ServerContextBase::raw_deadline; - using ServerContextBase::set_compression_algorithm; - using ServerContextBase::set_compression_level; - using ServerContextBase::SetLoadReportingCosts; - using ServerContextBase::TryCancel; - - // Sync/CQ-based Async ServerContext only - using ServerContextBase::AsyncNotifyWhenDone; - - private: - // Constructor for internal use by server only - friend class ::grpc::Server; - ServerContext(gpr_timespec deadline, grpc_metadata_array* arr) - : ServerContextBase(deadline, arr) {} - - // CallbackServerContext only - using ServerContextBase::DefaultReactor; - using ServerContextBase::GetRpcAllocatorState; - - /// Prevent copying. - ServerContext(const ServerContext&) = delete; - ServerContext& operator=(const ServerContext&) = delete; -}; - -class CallbackServerContext : public ServerContextBase { - public: - /// Public constructors are for direct use only by mocking tests. In practice, - /// these objects will be owned by the library. - CallbackServerContext() {} - - using ServerContextBase::AddInitialMetadata; - using ServerContextBase::AddTrailingMetadata; - using ServerContextBase::auth_context; - using ServerContextBase::c_call; - using ServerContextBase::census_context; - using ServerContextBase::client_metadata; - using ServerContextBase::compression_algorithm; - using ServerContextBase::compression_level; - using ServerContextBase::compression_level_set; - using ServerContextBase::deadline; - using ServerContextBase::IsCancelled; - using ServerContextBase::peer; - using ServerContextBase::raw_deadline; - using ServerContextBase::set_compression_algorithm; - using ServerContextBase::set_compression_level; - using ServerContextBase::SetLoadReportingCosts; - using ServerContextBase::TryCancel; - - // CallbackServerContext only - using ServerContextBase::DefaultReactor; - using ServerContextBase::GetRpcAllocatorState; - - private: - // Sync/CQ-based Async ServerContext only - using ServerContextBase::AsyncNotifyWhenDone; - - /// Prevent copying. - CallbackServerContext(const CallbackServerContext&) = delete; - CallbackServerContext& operator=(const CallbackServerContext&) = delete; -}; - -} // namespace grpc_impl - -static_assert(std::is_base_of<::grpc_impl::ServerContextBase, - ::grpc_impl::ServerContext>::value, - "improper base class"); -static_assert(std::is_base_of<::grpc_impl::ServerContextBase, - ::grpc_impl::CallbackServerContext>::value, - "improper base class"); -static_assert(sizeof(::grpc_impl::ServerContextBase) == - sizeof(::grpc_impl::ServerContext), - "wrong size"); -static_assert(sizeof(::grpc_impl::ServerContextBase) == - sizeof(::grpc_impl::CallbackServerContext), - "wrong size"); - -#endif // GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_IMPL_H diff --git a/include/grpcpp/impl/codegen/server_interceptor.h b/include/grpcpp/impl/codegen/server_interceptor.h index cee6869f208..7598e72a40e 100644 --- a/include/grpcpp/impl/codegen/server_interceptor.h +++ b/include/grpcpp/impl/codegen/server_interceptor.h @@ -26,12 +26,8 @@ #include #include -namespace grpc_impl { -class ServerContextBase; -} // namespace grpc_impl - namespace grpc { - +class ServerContextBase; namespace internal { class InterceptorBatchMethodsImpl; } @@ -80,7 +76,7 @@ class ServerRpcInfo { /// Return a pointer to the underlying ServerContext structure associated /// with the RPC to support features that apply to it - grpc_impl::ServerContextBase* server_context() { return ctx_; } + ServerContextBase* server_context() { return ctx_; } private: static_assert(Type::UNARY == @@ -96,7 +92,7 @@ class ServerRpcInfo { static_cast(internal::RpcMethod::BIDI_STREAMING), "violated expectation about Type enum"); - ServerRpcInfo(grpc_impl::ServerContextBase* ctx, const char* method, + ServerRpcInfo(ServerContextBase* ctx, const char* method, internal::RpcMethod::RpcType type) : ctx_(ctx), method_(method), type_(static_cast(type)) {} @@ -127,14 +123,14 @@ class ServerRpcInfo { } } - grpc_impl::ServerContextBase* ctx_ = nullptr; + ServerContextBase* ctx_ = nullptr; const char* method_ = nullptr; const Type type_; std::atomic ref_{1}; std::vector> interceptors_; friend class internal::InterceptorBatchMethodsImpl; - friend class grpc_impl::ServerContextBase; + friend class grpc::ServerContextBase; }; } // namespace experimental diff --git a/include/grpcpp/impl/codegen/server_interface.h b/include/grpcpp/impl/codegen/server_interface.h index ef5252b454f..fef2dc7edfa 100644 --- a/include/grpcpp/impl/codegen/server_interface.h +++ b/include/grpcpp/impl/codegen/server_interface.h @@ -29,7 +29,7 @@ #include #include #include -#include +#include namespace grpc { @@ -191,8 +191,7 @@ class ServerInterface : public internal::CallHook { class BaseAsyncRequest : public internal::CompletionQueueTag { public: - BaseAsyncRequest(ServerInterface* server, - ::grpc_impl::ServerContext* context, + BaseAsyncRequest(ServerInterface* server, ::grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, ::grpc::CompletionQueue* call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag, @@ -206,7 +205,7 @@ class ServerInterface : public internal::CallHook { protected: ServerInterface* const server_; - ::grpc_impl::ServerContext* const context_; + ::grpc::ServerContext* const context_; internal::ServerAsyncStreamingInterface* const stream_; ::grpc::CompletionQueue* const call_cq_; ::grpc::ServerCompletionQueue* const notification_cq_; @@ -222,7 +221,7 @@ class ServerInterface : public internal::CallHook { class RegisteredAsyncRequest : public BaseAsyncRequest { public: RegisteredAsyncRequest(ServerInterface* server, - ::grpc_impl::ServerContext* context, + ::grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, ::grpc::CompletionQueue* call_cq, ::grpc::ServerCompletionQueue* notification_cq, @@ -252,7 +251,7 @@ class ServerInterface : public internal::CallHook { public: NoPayloadAsyncRequest(internal::RpcServiceMethod* registered_method, ServerInterface* server, - ::grpc_impl::ServerContext* context, + ::grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, ::grpc::CompletionQueue* call_cq, ::grpc::ServerCompletionQueue* notification_cq, @@ -270,8 +269,7 @@ class ServerInterface : public internal::CallHook { class PayloadAsyncRequest final : public RegisteredAsyncRequest { public: PayloadAsyncRequest(internal::RpcServiceMethod* registered_method, - ServerInterface* server, - ::grpc_impl::ServerContext* context, + ServerInterface* server, ::grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, ::grpc::CompletionQueue* call_cq, ::grpc::ServerCompletionQueue* notification_cq, @@ -341,7 +339,7 @@ class ServerInterface : public internal::CallHook { template void RequestAsyncCall(internal::RpcServiceMethod* method, - ::grpc_impl::ServerContext* context, + ::grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, ::grpc::CompletionQueue* call_cq, ::grpc::ServerCompletionQueue* notification_cq, @@ -352,7 +350,7 @@ class ServerInterface : public internal::CallHook { } void RequestAsyncCall(internal::RpcServiceMethod* method, - ::grpc_impl::ServerContext* context, + ::grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, ::grpc::CompletionQueue* call_cq, ::grpc::ServerCompletionQueue* notification_cq, diff --git a/include/grpcpp/impl/codegen/service_type.h b/include/grpcpp/impl/codegen/service_type.h index 05b3b1b8c6d..b5b7ce73d64 100644 --- a/include/grpcpp/impl/codegen/service_type.h +++ b/include/grpcpp/impl/codegen/service_type.h @@ -29,11 +29,11 @@ namespace grpc_impl { class Server; -class ServerContext; } // namespace grpc_impl namespace grpc { class CompletionQueue; +class ServerContext; class ServerInterface; namespace internal { @@ -127,7 +127,7 @@ class Service { experimental_type experimental() { return experimental_type(this); } template - void RequestAsyncUnary(int index, ::grpc_impl::ServerContext* context, + void RequestAsyncUnary(int index, ::grpc::ServerContext* context, Message* request, internal::ServerAsyncStreamingInterface* stream, ::grpc::CompletionQueue* call_cq, @@ -141,7 +141,7 @@ class Service { notification_cq, tag, request); } void RequestAsyncClientStreaming( - int index, ::grpc_impl::ServerContext* context, + int index, ::grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, ::grpc::CompletionQueue* call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { @@ -151,7 +151,7 @@ class Service { } template void RequestAsyncServerStreaming( - int index, ::grpc_impl::ServerContext* context, Message* request, + int index, ::grpc::ServerContext* context, Message* request, internal::ServerAsyncStreamingInterface* stream, ::grpc::CompletionQueue* call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { @@ -160,7 +160,7 @@ class Service { notification_cq, tag, request); } void RequestAsyncBidiStreaming( - int index, ::grpc_impl::ServerContext* context, + int index, ::grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, ::grpc::CompletionQueue* call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { diff --git a/include/grpcpp/impl/codegen/sync_stream_impl.h b/include/grpcpp/impl/codegen/sync_stream_impl.h index 19a96dd318d..ce1ab11db19 100644 --- a/include/grpcpp/impl/codegen/sync_stream_impl.h +++ b/include/grpcpp/impl/codegen/sync_stream_impl.h @@ -23,7 +23,7 @@ #include #include #include -#include +#include #include #include @@ -612,12 +612,12 @@ class ServerReader final : public ServerReaderInterface { private: ::grpc::internal::Call* const call_; - ServerContext* const ctx_; + ::grpc::ServerContext* const ctx_; template friend class ::grpc_impl::internal::ClientStreamingHandler; - ServerReader(::grpc::internal::Call* call, ::grpc_impl::ServerContext* ctx) + ServerReader(::grpc::internal::Call* call, ::grpc::ServerContext* ctx) : call_(call), ctx_(ctx) {} }; @@ -687,12 +687,12 @@ class ServerWriter final : public ServerWriterInterface { private: ::grpc::internal::Call* const call_; - ::grpc_impl::ServerContext* const ctx_; + ::grpc::ServerContext* const ctx_; template friend class ::grpc_impl::internal::ServerStreamingHandler; - ServerWriter(::grpc::internal::Call* call, ::grpc_impl::ServerContext* ctx) + ServerWriter(::grpc::internal::Call* call, ::grpc::ServerContext* ctx) : call_(call), ctx_(ctx) {} }; @@ -707,8 +707,7 @@ namespace internal { template class ServerReaderWriterBody final { public: - ServerReaderWriterBody(grpc::internal::Call* call, - ::grpc_impl::ServerContext* ctx) + ServerReaderWriterBody(grpc::internal::Call* call, ::grpc::ServerContext* ctx) : call_(call), ctx_(ctx) {} void SendInitialMetadata() { @@ -767,7 +766,7 @@ class ServerReaderWriterBody final { private: grpc::internal::Call* const call_; - ::grpc_impl::ServerContext* const ctx_; + ::grpc::ServerContext* const ctx_; }; } // namespace internal @@ -805,8 +804,7 @@ class ServerReaderWriter final : public ServerReaderWriterInterface { friend class ::grpc_impl::internal::TemplatedBidiStreamingHandler< ServerReaderWriter, false>; - ServerReaderWriter(::grpc::internal::Call* call, - ::grpc_impl::ServerContext* ctx) + ServerReaderWriter(::grpc::internal::Call* call, ::grpc::ServerContext* ctx) : body_(call, ctx) {} }; @@ -875,8 +873,7 @@ class ServerUnaryStreamer final friend class ::grpc_impl::internal::TemplatedBidiStreamingHandler< ServerUnaryStreamer, true>; - ServerUnaryStreamer(::grpc::internal::Call* call, - ::grpc_impl::ServerContext* ctx) + ServerUnaryStreamer(::grpc::internal::Call* call, ::grpc::ServerContext* ctx) : body_(call, ctx), read_done_(false), write_done_(false) {} }; @@ -937,8 +934,7 @@ class ServerSplitStreamer final friend class ::grpc_impl::internal::TemplatedBidiStreamingHandler< ServerSplitStreamer, false>; - ServerSplitStreamer(::grpc::internal::Call* call, - ::grpc_impl::ServerContext* ctx) + ServerSplitStreamer(::grpc::internal::Call* call, ::grpc::ServerContext* ctx) : body_(call, ctx), read_done_(false) {} }; diff --git a/include/grpcpp/server.h b/include/grpcpp/server.h index 7437f85c383..38d9d404352 100644 --- a/include/grpcpp/server.h +++ b/include/grpcpp/server.h @@ -81,9 +81,9 @@ class Server : public ServerInterface, private GrpcLibraryCodegen { /// Called before server is created. virtual void UpdateArguments(ChannelArguments* /*args*/) {} /// Called before application callback for each synchronous server request - virtual void PreSynchronousRequest(grpc_impl::ServerContext* context) = 0; + virtual void PreSynchronousRequest(ServerContext* context) = 0; /// Called after application callback for each synchronous server request - virtual void PostSynchronousRequest(grpc_impl::ServerContext* context) = 0; + virtual void PostSynchronousRequest(ServerContext* context) = 0; /// Called before server is started. virtual void PreServerStart(Server* /*server*/) {} /// Called after a server port is added. diff --git a/src/compiler/cpp_generator.cc b/src/compiler/cpp_generator.cc index d2f672f5590..1fce393ba0f 100644 --- a/src/compiler/cpp_generator.cc +++ b/src/compiler/cpp_generator.cc @@ -1345,7 +1345,7 @@ void PrintHeaderServerMethodStreamedUnary( " ::grpc::Service::MarkMethodStreamed($Idx$,\n" " new ::grpc::internal::StreamedUnaryHandler<\n" " $Request$, $Response$>(\n" - " [this](::grpc_impl::ServerContext* context,\n" + " [this](::grpc::ServerContext* context,\n" " ::grpc_impl::ServerUnaryStreamer<\n" " $Request$, $Response$>* streamer) {\n" " return this->Streamed$Method$(context,\n" @@ -1399,7 +1399,7 @@ void PrintHeaderServerMethodSplitStreaming( " ::grpc::Service::MarkMethodStreamed($Idx$,\n" " new ::grpc::internal::SplitServerStreamingHandler<\n" " $Request$, $Response$>(\n" - " [this](::grpc_impl::ServerContext* context,\n" + " [this](::grpc::ServerContext* context,\n" " ::grpc_impl::ServerSplitStreamer<\n" " $Request$, $Response$>* streamer) {\n" " return this->Streamed$Method$(context,\n" @@ -2257,7 +2257,7 @@ void PrintSourceService(grpc_generator::Printer* printer, "$Request$, " "$Response$>(\n" " []($ns$$Service$::Service* service,\n" - " ::grpc_impl::ServerContext* ctx,\n" + " ::grpc::ServerContext* ctx,\n" " const $Request$* req,\n" " $Response$* resp) {\n" " return service->$Method$(ctx, req, resp);\n" @@ -2271,7 +2271,7 @@ void PrintSourceService(grpc_generator::Printer* printer, " new ::grpc::internal::ClientStreamingHandler< " "$ns$$Service$::Service, $Request$, $Response$>(\n" " []($ns$$Service$::Service* service,\n" - " ::grpc_impl::ServerContext* ctx,\n" + " ::grpc::ServerContext* ctx,\n" " ::grpc_impl::ServerReader<$Request$>* reader,\n" " $Response$* resp) {\n" " return service->$Method$(ctx, reader, resp);\n" @@ -2285,7 +2285,7 @@ void PrintSourceService(grpc_generator::Printer* printer, " new ::grpc::internal::ServerStreamingHandler< " "$ns$$Service$::Service, $Request$, $Response$>(\n" " []($ns$$Service$::Service* service,\n" - " ::grpc_impl::ServerContext* ctx,\n" + " ::grpc::ServerContext* ctx,\n" " const $Request$* req,\n" " ::grpc_impl::ServerWriter<$Response$>* writer) {\n" " return service->$Method$(ctx, req, writer);\n" @@ -2298,7 +2298,7 @@ void PrintSourceService(grpc_generator::Printer* printer, " new ::grpc::internal::BidiStreamingHandler< " "$ns$$Service$::Service, $Request$, $Response$>(\n" " []($ns$$Service$::Service* service,\n" - " ::grpc_impl::ServerContext* ctx,\n" + " ::grpc::ServerContext* ctx,\n" " ::grpc_impl::ServerReaderWriter<$Response$,\n" " $Request$>* stream) {\n" " return service->$Method$(ctx, stream);\n" diff --git a/src/cpp/client/client_context.cc b/src/cpp/client/client_context.cc index adf59741369..29e11200f5a 100644 --- a/src/cpp/client/client_context.cc +++ b/src/cpp/client/client_context.cc @@ -89,7 +89,7 @@ void ClientContext::set_credentials( } std::unique_ptr ClientContext::FromInternalServerContext( - const grpc_impl::ServerContextBase& context, PropagationOptions options) { + const grpc::ServerContextBase& context, PropagationOptions options) { std::unique_ptr ctx(new ClientContext); ctx->propagate_from_call_ = context.call_; ctx->propagation_options_ = options; @@ -97,13 +97,12 @@ std::unique_ptr ClientContext::FromInternalServerContext( } std::unique_ptr ClientContext::FromServerContext( - const grpc_impl::ServerContext& server_context, - PropagationOptions options) { + const grpc::ServerContext& server_context, PropagationOptions options) { return FromInternalServerContext(server_context, options); } std::unique_ptr ClientContext::FromCallbackServerContext( - const grpc_impl::CallbackServerContext& server_context, + const grpc::CallbackServerContext& server_context, PropagationOptions options) { return FromInternalServerContext(server_context, options); } diff --git a/src/cpp/server/server_context.cc b/src/cpp/server/server_context.cc index 4918e81fab9..f2e871be2b3 100644 --- a/src/cpp/server/server_context.cc +++ b/src/cpp/server/server_context.cc @@ -16,7 +16,7 @@ * */ -#include +#include #include #include @@ -35,16 +35,16 @@ #include "src/core/lib/gprpp/sync.h" #include "src/core/lib/surface/call.h" -namespace grpc_impl { +namespace grpc { // CompletionOp class ServerContextBase::CompletionOp final - : public ::grpc::internal::CallOpSetInterface { + : public internal::CallOpSetInterface { public: // initial refs: one in the server context, one in the cq // must ref the call before calling constructor and after deleting this - CompletionOp(::grpc::internal::Call* call, + CompletionOp(internal::Call* call, ::grpc_impl::internal::ServerCallbackCall* callback_controller) : call_(*call), callback_controller_(callback_controller), @@ -68,7 +68,7 @@ class ServerContextBase::CompletionOp final } } - void FillOps(::grpc::internal::Call* call) override; + void FillOps(internal::Call* call) override; // This should always be arena allocated in the call, so override delete. // But this class is not trivially destructible, so must actually call delete @@ -89,7 +89,7 @@ class ServerContextBase::CompletionOp final bool FinalizeResult(void** tag, bool* status) override; - bool CheckCancelled(grpc::CompletionQueue* cq) { + bool CheckCancelled(CompletionQueue* cq) { cq->TryPluck(this); return CheckCancelledNoPluck(); } @@ -136,7 +136,7 @@ class ServerContextBase::CompletionOp final return finalized_ ? (cancelled_ != 0) : false; } - ::grpc::internal::Call call_; + internal::Call call_; ::grpc_impl::internal::ServerCallbackCall* const callback_controller_; bool has_tag_; void* tag_; @@ -146,7 +146,7 @@ class ServerContextBase::CompletionOp final bool finalized_; int cancelled_; // This is an int (not bool) because it is passed to core bool done_intercepting_; - ::grpc::internal::InterceptorBatchMethodsImpl interceptor_methods_; + internal::InterceptorBatchMethodsImpl interceptor_methods_; }; void ServerContextBase::CompletionOp::Unref() { @@ -157,7 +157,7 @@ void ServerContextBase::CompletionOp::Unref() { } } -void ServerContextBase::CompletionOp::FillOps(::grpc::internal::Call* call) { +void ServerContextBase::CompletionOp::FillOps(internal::Call* call) { grpc_op ops; ops.op = GRPC_OP_RECV_CLOSE_ON_SERVER; ops.data.recv_close_on_server.cancelled = &cancelled_; @@ -206,7 +206,7 @@ bool ServerContextBase::CompletionOp::FinalizeResult(void** tag, bool* status) { } /* Add interception point and run through interceptors */ interceptor_methods_.AddInterceptionHookPoint( - ::grpc::experimental::InterceptionHookPoints::POST_RECV_CLOSE); + experimental::InterceptionHookPoints::POST_RECV_CLOSE); if (interceptor_methods_.RunInterceptors()) { // No interceptors were run bool has_tag = has_tag_; @@ -280,7 +280,7 @@ void ServerContextBase::Clear() { } void ServerContextBase::BeginCompletionOp( - ::grpc::internal::Call* call, std::function callback, + internal::Call* call, std::function callback, ::grpc_impl::internal::ServerCallbackCall* callback_controller) { GPR_ASSERT(!completion_op_); if (rpc_info_) { @@ -301,8 +301,8 @@ void ServerContextBase::BeginCompletionOp( call->PerformOps(completion_op_); } -::grpc::internal::CompletionQueueTag* ServerContextBase::GetCompletionOpTag() { - return static_cast<::grpc::internal::CompletionQueueTag*>(completion_op_); +internal::CompletionQueueTag* ServerContextBase::GetCompletionOpTag() { + return static_cast(completion_op_); } void ServerContextBase::AddInitialMetadata(const std::string& key, @@ -316,7 +316,7 @@ void ServerContextBase::AddTrailingMetadata(const std::string& key, } void ServerContextBase::TryCancel() const { - ::grpc::internal::CancelInterceptorBatchMethods cancel_methods; + internal::CancelInterceptorBatchMethods cancel_methods; if (rpc_info_) { for (size_t i = 0; i < rpc_info_->interceptors_.size(); i++) { rpc_info_->RunInterceptor(&cancel_methods, i); @@ -378,4 +378,4 @@ void ServerContextBase::SetLoadReportingCosts( } } -} // namespace grpc_impl +} // namespace grpc diff --git a/test/cpp/codegen/compiler_test_golden b/test/cpp/codegen/compiler_test_golden index 7ad954d6d9a..3e93a33f087 100644 --- a/test/cpp/codegen/compiler_test_golden +++ b/test/cpp/codegen/compiler_test_golden @@ -841,7 +841,7 @@ class ServiceA final { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>( - [this](::grpc_impl::ServerContext* context, + [this](::grpc::ServerContext* context, ::grpc_impl::ServerUnaryStreamer< ::grpc::testing::Request, ::grpc::testing::Response>* streamer) { return this->StreamedMethodA1(context, @@ -869,7 +869,7 @@ class ServiceA final { ::grpc::Service::MarkMethodStreamed(2, new ::grpc::internal::SplitServerStreamingHandler< ::grpc::testing::Request, ::grpc::testing::Response>( - [this](::grpc_impl::ServerContext* context, + [this](::grpc::ServerContext* context, ::grpc_impl::ServerSplitStreamer< ::grpc::testing::Request, ::grpc::testing::Response>* streamer) { return this->StreamedMethodA3(context, @@ -1145,7 +1145,7 @@ class ServiceB final { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::grpc::testing::Request, ::grpc::testing::Response>( - [this](::grpc_impl::ServerContext* context, + [this](::grpc::ServerContext* context, ::grpc_impl::ServerUnaryStreamer< ::grpc::testing::Request, ::grpc::testing::Response>* streamer) { return this->StreamedMethodB1(context, diff --git a/tools/doxygen/Doxyfile.c++ b/tools/doxygen/Doxyfile.c++ index c230de92839..8c6cbb0e2a4 100644 --- a/tools/doxygen/Doxyfile.c++ +++ b/tools/doxygen/Doxyfile.c++ @@ -991,7 +991,6 @@ include/grpcpp/impl/codegen/server_callback.h \ include/grpcpp/impl/codegen/server_callback_handlers.h \ include/grpcpp/impl/codegen/server_callback_impl.h \ include/grpcpp/impl/codegen/server_context.h \ -include/grpcpp/impl/codegen/server_context_impl.h \ include/grpcpp/impl/codegen/server_interceptor.h \ include/grpcpp/impl/codegen/server_interface.h \ include/grpcpp/impl/codegen/service_type.h \ diff --git a/tools/doxygen/Doxyfile.c++.internal b/tools/doxygen/Doxyfile.c++.internal index 38c9aad2d71..b51cb751cb6 100644 --- a/tools/doxygen/Doxyfile.c++.internal +++ b/tools/doxygen/Doxyfile.c++.internal @@ -991,7 +991,6 @@ include/grpcpp/impl/codegen/server_callback.h \ include/grpcpp/impl/codegen/server_callback_handlers.h \ include/grpcpp/impl/codegen/server_callback_impl.h \ include/grpcpp/impl/codegen/server_context.h \ -include/grpcpp/impl/codegen/server_context_impl.h \ include/grpcpp/impl/codegen/server_interceptor.h \ include/grpcpp/impl/codegen/server_interface.h \ include/grpcpp/impl/codegen/service_type.h \