GRPC C++  1.53.0
client_interceptor.h
Go to the documentation of this file.
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_CLIENT_INTERCEPTOR_H
20 #define GRPCPP_SUPPORT_CLIENT_INTERCEPTOR_H
21 
22 #include <memory>
23 #include <vector>
24 
25 #include <grpc/support/log.h>
26 #include <grpcpp/impl/rpc_method.h>
29 
30 namespace grpc {
31 
32 class Channel;
33 class ClientContext;
34 
35 namespace internal {
36 class InterceptorBatchMethodsImpl;
37 }
38 
39 namespace experimental {
40 class ClientRpcInfo;
41 
42 // A factory interface for creation of client interceptors. A vector of
43 // factories can be provided at channel creation which will be used to create a
44 // new vector of client interceptors per RPC. Client interceptor authors should
45 // create a subclass of ClientInterceptorFactorInterface which creates objects
46 // of their interceptors.
48  public:
50  // Returns a pointer to an Interceptor object on successful creation, nullptr
51  // otherwise. If nullptr is returned, this server interceptor factory is
52  // ignored for the purposes of that RPC.
54 };
55 } // namespace experimental
56 
57 namespace internal {
58 extern experimental::ClientInterceptorFactoryInterface*
60 }
61 
66 namespace experimental {
68  public:
69  // TODO(yashykt): Stop default-constructing ClientRpcInfo and remove UNKNOWN
70  // from the list of possible Types.
72  enum class Type {
73  UNARY,
77  UNKNOWN // UNKNOWN is not API and will be removed later
78  };
79 
81 
82  // Delete copy constructor but allow default move constructor
83  ClientRpcInfo(const ClientRpcInfo&) = delete;
84  ClientRpcInfo(ClientRpcInfo&&) = default;
85 
86  // Getter methods
87 
89  const char* method() const { return method_; }
90 
93  const char* suffix_for_stats() const { return suffix_for_stats_; }
94 
96  ChannelInterface* channel() { return channel_; }
97 
101 
103  Type type() const { return type_; }
104 
105  private:
106  static_assert(Type::UNARY ==
108  "violated expectation about Type enum");
109  static_assert(Type::CLIENT_STREAMING ==
111  "violated expectation about Type enum");
112  static_assert(Type::SERVER_STREAMING ==
114  "violated expectation about Type enum");
115  static_assert(Type::BIDI_STREAMING ==
117  "violated expectation about Type enum");
118 
119  // Default constructor should only be used by ClientContext
120  ClientRpcInfo() = default;
121 
122  // Constructor will only be called from ClientContext
124  const char* method, const char* suffix_for_stats,
126  : ctx_(ctx),
127  type_(static_cast<Type>(type)),
128  method_(method),
129  suffix_for_stats_(suffix_for_stats),
130  channel_(channel) {}
131 
132  // Move assignment should only be used by ClientContext
133  // TODO(yashykt): Delete move assignment
134  ClientRpcInfo& operator=(ClientRpcInfo&&) = default;
135 
136  // Runs interceptor at pos \a pos.
137  void RunInterceptor(
138  experimental::InterceptorBatchMethods* interceptor_methods, size_t pos) {
139  GPR_ASSERT(pos < interceptors_.size());
140  interceptors_[pos]->Intercept(interceptor_methods);
141  }
142 
143  void RegisterInterceptors(
144  const std::vector<std::unique_ptr<
145  experimental::ClientInterceptorFactoryInterface>>& creators,
146  size_t interceptor_pos) {
147  if (interceptor_pos > creators.size()) {
148  // No interceptors to register
149  return;
150  }
151  // NOTE: The following is not a range-based for loop because it will only
152  // iterate over a portion of the creators vector.
153  for (auto it = creators.begin() + interceptor_pos; it != creators.end();
154  ++it) {
155  auto* interceptor = (*it)->CreateClientInterceptor(this);
156  if (interceptor != nullptr) {
157  interceptors_.push_back(
158  std::unique_ptr<experimental::Interceptor>(interceptor));
159  }
160  }
162  interceptors_.push_back(std::unique_ptr<experimental::Interceptor>(
164  ->CreateClientInterceptor(this)));
165  }
166  }
167 
168  grpc::ClientContext* ctx_ = nullptr;
169  // TODO(yashykt): make type_ const once move-assignment is deleted
170  Type type_{Type::UNKNOWN};
171  const char* method_ = nullptr;
172  const char* suffix_for_stats_ = nullptr;
173  grpc::ChannelInterface* channel_ = nullptr;
174  std::vector<std::unique_ptr<experimental::Interceptor>> interceptors_;
175  bool hijacked_ = false;
176  size_t hijacked_interceptor_ = 0;
177 
179  friend class grpc::ClientContext;
180 };
181 
182 // PLEASE DO NOT USE THIS. ALWAYS PREFER PER CHANNEL INTERCEPTORS OVER A GLOBAL
183 // INTERCEPTOR. IF USAGE IS ABSOLUTELY NECESSARY, PLEASE READ THE SAFETY NOTES.
184 // Registers a global client interceptor factory object, which is used for all
185 // RPCs made in this process. The application is responsible for maintaining the
186 // life of the object while gRPC operations are in progress. The global
187 // interceptor factory should only be registered once at the start of the
188 // process before any gRPC operations have begun.
191 
192 // For testing purposes only
194 
195 } // namespace experimental
196 } // namespace grpc
197 
198 #endif // GRPCPP_SUPPORT_CLIENT_INTERCEPTOR_H
grpc::experimental::ClientRpcInfo::type
Type type() const
Return the type of the RPC (unary or a streaming flavor)
Definition: client_interceptor.h:103
interceptor.h
grpc
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:32
grpc::experimental::ClientRpcInfo::method
const char * method() const
Return the fully-specified method name.
Definition: client_interceptor.h:89
GPR_ASSERT
#define GPR_ASSERT(x)
abort() the process if x is zero, having written a line to the log.
Definition: log.h:95
rpc_method.h
grpc::experimental::ClientRpcInfo::Type
Type
Type categorizes RPCs by unary or streaming type.
Definition: client_interceptor.h:72
grpc::internal::RpcMethod::CLIENT_STREAMING
@ CLIENT_STREAMING
Definition: rpc_method.h:33
grpc::experimental::ClientRpcInfo::suffix_for_stats
const char * suffix_for_stats() const
Return an identifying suffix for the client stub, or nullptr if one wasn't specified.
Definition: client_interceptor.h:93
grpc::experimental::ClientRpcInfo
Definition: client_interceptor.h:67
grpc::internal::g_global_client_interceptor_factory
experimental::ClientInterceptorFactoryInterface * g_global_client_interceptor_factory
log.h
grpc::internal::RpcMethod::BIDI_STREAMING
@ BIDI_STREAMING
Definition: rpc_method.h:35
grpc::experimental::ClientInterceptorFactoryInterface::~ClientInterceptorFactoryInterface
virtual ~ClientInterceptorFactoryInterface()
Definition: client_interceptor.h:49
grpc::ClientContext
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:193
grpc::experimental::RegisterGlobalClientInterceptorFactory
void RegisterGlobalClientInterceptorFactory(ClientInterceptorFactoryInterface *factory)
grpc::experimental::ClientRpcInfo::~ClientRpcInfo
~ClientRpcInfo()
Definition: client_interceptor.h:80
grpc::experimental::ClientRpcInfo::Type::SERVER_STREAMING
@ SERVER_STREAMING
grpc::experimental::ClientRpcInfo::Type::BIDI_STREAMING
@ BIDI_STREAMING
grpc::experimental::ClientRpcInfo::Type::UNARY
@ UNARY
grpc::experimental::ClientRpcInfo::client_context
grpc::ClientContext * client_context()
Return a pointer to the underlying ClientContext structure associated with the RPC to support feature...
Definition: client_interceptor.h:100
grpc::ChannelInterface
Codegen interface for grpc::Channel.
Definition: channel_interface.h:71
grpc::experimental::ClientRpcInfo::channel
ChannelInterface * channel()
Return a pointer to the channel on which the RPC is being sent.
Definition: client_interceptor.h:96
grpc::internal::RpcMethod::SERVER_STREAMING
@ SERVER_STREAMING
Definition: rpc_method.h:34
grpc::experimental::ClientInterceptorFactoryInterface::CreateClientInterceptor
virtual Interceptor * CreateClientInterceptor(ClientRpcInfo *info)=0
grpc::internal::RpcMethod::RpcType
RpcType
Definition: rpc_method.h:31
grpc::internal::RpcMethod::NORMAL_RPC
@ NORMAL_RPC
Definition: rpc_method.h:32
grpc::experimental::Interceptor
Interface for an interceptor.
Definition: interceptor.h:218
grpc::experimental::ClientInterceptorFactoryInterface
Definition: client_interceptor.h:47
grpc::experimental::InterceptorBatchMethods
Class that is passed as an argument to the Intercept method of the application's Interceptor interfac...
Definition: interceptor.h:95
grpc::experimental::ClientRpcInfo::Type::CLIENT_STREAMING
@ CLIENT_STREAMING
grpc::experimental::ClientRpcInfo::Type::UNKNOWN
@ UNKNOWN
grpc::internal::InterceptorBatchMethodsImpl
Definition: interceptor_common.h:36
string_ref.h
grpc::experimental::TestOnlyResetGlobalClientInterceptorFactory
void TestOnlyResetGlobalClientInterceptorFactory()