1 // 2 // 3 // Copyright 2018 gRPC authors. 4 // 5 // Licensed under the Apache License, Version 2.0 (the "License"); 6 // you may not use this file except in compliance with the License. 7 // You may obtain a copy of the License at 8 // 9 // http://www.apache.org/licenses/LICENSE-2.0 10 // 11 // Unless required by applicable law or agreed to in writing, software 12 // distributed under the License is distributed on an "AS IS" BASIS, 13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 // See the License for the specific language governing permissions and 15 // limitations under the License. 16 // 17 // 18 19 #ifndef GRPCPP_IMPL_INTERCEPTED_CHANNEL_H 20 #define GRPCPP_IMPL_INTERCEPTED_CHANNEL_H 21 22 #include <grpcpp/impl/channel_interface.h> 23 24 namespace grpc { 25 class CompletionQueue; 26 27 namespace internal { 28 29 class InterceptorBatchMethodsImpl; 30 31 /// An InterceptedChannel is available to client Interceptors. An 32 /// InterceptedChannel is unique to an interceptor, and when an RPC is started 33 /// on this channel, only those interceptors that come after this interceptor 34 /// see the RPC. 35 class InterceptedChannel : public ChannelInterface { 36 public: ~InterceptedChannel()37 ~InterceptedChannel() override { channel_ = nullptr; } 38 39 /// Get the current channel state. If the channel is in IDLE and 40 /// \a try_to_connect is set to true, try to connect. GetState(bool try_to_connect)41 grpc_connectivity_state GetState(bool try_to_connect) override { 42 return channel_->GetState(try_to_connect); 43 } 44 45 private: InterceptedChannel(ChannelInterface * channel,size_t pos)46 InterceptedChannel(ChannelInterface* channel, size_t pos) 47 : channel_(channel), interceptor_pos_(pos) {} 48 CreateCall(const RpcMethod & method,grpc::ClientContext * context,grpc::CompletionQueue * cq)49 Call CreateCall(const RpcMethod& method, grpc::ClientContext* context, 50 grpc::CompletionQueue* cq) override { 51 return channel_->CreateCallInternal(method, context, cq, interceptor_pos_); 52 } 53 PerformOpsOnCall(CallOpSetInterface * ops,Call * call)54 void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) override { 55 return channel_->PerformOpsOnCall(ops, call); 56 } RegisterMethod(const char * method)57 void* RegisterMethod(const char* method) override { 58 return channel_->RegisterMethod(method); 59 } 60 NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,gpr_timespec deadline,grpc::CompletionQueue * cq,void * tag)61 void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed, 62 gpr_timespec deadline, grpc::CompletionQueue* cq, 63 void* tag) override { 64 return channel_->NotifyOnStateChangeImpl(last_observed, deadline, cq, tag); 65 } WaitForStateChangeImpl(grpc_connectivity_state last_observed,gpr_timespec deadline)66 bool WaitForStateChangeImpl(grpc_connectivity_state last_observed, 67 gpr_timespec deadline) override { 68 return channel_->WaitForStateChangeImpl(last_observed, deadline); 69 } 70 CallbackCQ()71 grpc::CompletionQueue* CallbackCQ() override { 72 return channel_->CallbackCQ(); 73 } 74 75 ChannelInterface* channel_; 76 size_t interceptor_pos_; 77 78 friend class InterceptorBatchMethodsImpl; 79 }; 80 } // namespace internal 81 } // namespace grpc 82 83 #endif // GRPCPP_IMPL_INTERCEPTED_CHANNEL_H 84