1 // 2 // 3 // Copyright 2015 gRPC authors. 4 // 5 // Licensed under the Apache License, Version 2.0 (the "License"); 6 // you may not use this file except in compliance with the License. 7 // You may obtain a copy of the License at 8 // 9 // http://www.apache.org/licenses/LICENSE-2.0 10 // 11 // Unless required by applicable law or agreed to in writing, software 12 // distributed under the License is distributed on an "AS IS" BASIS, 13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 // See the License for the specific language governing permissions and 15 // limitations under the License. 16 // 17 // 18 19 #ifndef GRPCPP_SUPPORT_SERVER_INTERCEPTOR_H 20 #define GRPCPP_SUPPORT_SERVER_INTERCEPTOR_H 21 22 #include <grpcpp/impl/rpc_method.h> 23 #include <grpcpp/support/interceptor.h> 24 #include <grpcpp/support/string_ref.h> 25 26 #include <atomic> 27 #include <vector> 28 29 #include "absl/log/absl_check.h" 30 31 namespace grpc { 32 class ServerContextBase; 33 namespace internal { 34 class InterceptorBatchMethodsImpl; 35 } 36 37 namespace experimental { 38 class ServerRpcInfo; 39 40 // A factory interface for creation of server interceptors. A vector of 41 // factories can be provided to ServerBuilder which will be used to create a new 42 // vector of server interceptors per RPC. Server interceptor authors should 43 // create a subclass of ServerInterceptorFactorInterface which creates objects 44 // of their interceptors. 45 class ServerInterceptorFactoryInterface { 46 public: ~ServerInterceptorFactoryInterface()47 virtual ~ServerInterceptorFactoryInterface() {} 48 // Returns a pointer to an Interceptor object on successful creation, nullptr 49 // otherwise. If nullptr is returned, this server interceptor factory is 50 // ignored for the purposes of that RPC. 51 virtual Interceptor* CreateServerInterceptor(ServerRpcInfo* info) = 0; 52 }; 53 54 /// ServerRpcInfo represents the state of a particular RPC as it 55 /// appears to an interceptor. It is created and owned by the library and 56 /// passed to the CreateServerInterceptor method of the application's 57 /// ServerInterceptorFactoryInterface implementation 58 class ServerRpcInfo { 59 public: 60 /// Type categorizes RPCs by unary or streaming type 61 enum class Type { UNARY, CLIENT_STREAMING, SERVER_STREAMING, BIDI_STREAMING }; 62 ~ServerRpcInfo()63 ~ServerRpcInfo() {} 64 65 // Delete all copy and move constructors and assignments 66 ServerRpcInfo(const ServerRpcInfo&) = delete; 67 ServerRpcInfo& operator=(const ServerRpcInfo&) = delete; 68 ServerRpcInfo(ServerRpcInfo&&) = delete; 69 ServerRpcInfo& operator=(ServerRpcInfo&&) = delete; 70 71 // Getter methods 72 73 /// Return the fully-specified method name method()74 const char* method() const { return method_; } 75 76 /// Return the type of the RPC (unary or a streaming flavor) type()77 Type type() const { return type_; } 78 79 /// Return a pointer to the underlying ServerContext structure associated 80 /// with the RPC to support features that apply to it server_context()81 ServerContextBase* server_context() { return ctx_; } 82 83 private: 84 static_assert(Type::UNARY == 85 static_cast<Type>(internal::RpcMethod::NORMAL_RPC), 86 "violated expectation about Type enum"); 87 static_assert(Type::CLIENT_STREAMING == 88 static_cast<Type>(internal::RpcMethod::CLIENT_STREAMING), 89 "violated expectation about Type enum"); 90 static_assert(Type::SERVER_STREAMING == 91 static_cast<Type>(internal::RpcMethod::SERVER_STREAMING), 92 "violated expectation about Type enum"); 93 static_assert(Type::BIDI_STREAMING == 94 static_cast<Type>(internal::RpcMethod::BIDI_STREAMING), 95 "violated expectation about Type enum"); 96 ServerRpcInfo(ServerContextBase * ctx,const char * method,internal::RpcMethod::RpcType type)97 ServerRpcInfo(ServerContextBase* ctx, const char* method, 98 internal::RpcMethod::RpcType type) 99 : ctx_(ctx), method_(method), type_(static_cast<Type>(type)) {} 100 101 // Runs interceptor at pos \a pos. RunInterceptor(experimental::InterceptorBatchMethods * interceptor_methods,size_t pos)102 void RunInterceptor( 103 experimental::InterceptorBatchMethods* interceptor_methods, size_t pos) { 104 ABSL_CHECK_LT(pos, interceptors_.size()); 105 interceptors_[pos]->Intercept(interceptor_methods); 106 } 107 RegisterInterceptors(const std::vector<std::unique_ptr<experimental::ServerInterceptorFactoryInterface>> & creators)108 void RegisterInterceptors( 109 const std::vector< 110 std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>& 111 creators) { 112 for (const auto& creator : creators) { 113 auto* interceptor = creator->CreateServerInterceptor(this); 114 if (interceptor != nullptr) { 115 interceptors_.push_back( 116 std::unique_ptr<experimental::Interceptor>(interceptor)); 117 } 118 } 119 } 120 Ref()121 void Ref() { ref_.fetch_add(1, std::memory_order_relaxed); } Unref()122 void Unref() { 123 if (GPR_UNLIKELY(ref_.fetch_sub(1, std::memory_order_acq_rel) == 1)) { 124 delete this; 125 } 126 } 127 128 ServerContextBase* ctx_ = nullptr; 129 const char* method_ = nullptr; 130 const Type type_; 131 std::atomic<intptr_t> ref_{1}; 132 std::vector<std::unique_ptr<experimental::Interceptor>> interceptors_; 133 134 friend class internal::InterceptorBatchMethodsImpl; 135 friend class grpc::ServerContextBase; 136 }; 137 138 } // namespace experimental 139 } // namespace grpc 140 141 #endif // GRPCPP_SUPPORT_SERVER_INTERCEPTOR_H 142