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_CHANNEL_H 20 #define GRPCPP_CHANNEL_H 21 22 #include <memory> 23 24 #include <grpc/grpc.h> 25 #include <grpcpp/completion_queue.h> 26 #include <grpcpp/impl/call.h> 27 #include <grpcpp/impl/channel_interface.h> 28 #include <grpcpp/impl/grpc_library.h> 29 #include <grpcpp/impl/sync.h> 30 #include <grpcpp/support/client_interceptor.h> 31 #include <grpcpp/support/config.h> 32 33 struct grpc_channel; 34 35 namespace grpc { 36 namespace testing { 37 class ChannelTestPeer; 38 } // namespace testing 39 40 std::shared_ptr<Channel> CreateChannelInternal( 41 const std::string& host, grpc_channel* c_channel, 42 std::vector< 43 std::unique_ptr<experimental::ClientInterceptorFactoryInterface>> 44 interceptor_creators); 45 46 namespace experimental { 47 /// Resets the channel's connection backoff. 48 /// TODO(roth): Once we see whether this proves useful, either create a gRFC 49 /// and change this to be a method of the Channel class, or remove it. 50 void ChannelResetConnectionBackoff(Channel* channel); 51 } // namespace experimental 52 53 /// Channels represent a connection to an endpoint. Created by \a CreateChannel. 54 class Channel final : public grpc::ChannelInterface, 55 public grpc::internal::CallHook, 56 public std::enable_shared_from_this<Channel>, 57 private grpc::internal::GrpcLibrary { 58 public: 59 ~Channel() override; 60 61 /// Get the current channel state. If the channel is in IDLE and 62 /// \a try_to_connect is set to true, try to connect. 63 grpc_connectivity_state GetState(bool try_to_connect) override; 64 65 /// Returns the LB policy name, or the empty string if not yet available. 66 std::string GetLoadBalancingPolicyName() const; 67 68 /// Returns the service config in JSON form, or the empty string if 69 /// not available. 70 std::string GetServiceConfigJSON() const; 71 72 private: 73 template <class InputMessage, class OutputMessage> 74 friend class grpc::internal::BlockingUnaryCallImpl; 75 friend class grpc::testing::ChannelTestPeer; 76 friend void experimental::ChannelResetConnectionBackoff(Channel* channel); 77 friend std::shared_ptr<Channel> grpc::CreateChannelInternal( 78 const std::string& host, grpc_channel* c_channel, 79 std::vector<std::unique_ptr< 80 grpc::experimental::ClientInterceptorFactoryInterface>> 81 interceptor_creators); 82 friend class grpc::internal::InterceptedChannel; 83 Channel(const std::string& host, grpc_channel* c_channel, 84 std::vector<std::unique_ptr< 85 grpc::experimental::ClientInterceptorFactoryInterface>> 86 interceptor_creators); 87 88 grpc::internal::Call CreateCall(const grpc::internal::RpcMethod& method, 89 grpc::ClientContext* context, 90 grpc::CompletionQueue* cq) override; 91 void PerformOpsOnCall(grpc::internal::CallOpSetInterface* ops, 92 grpc::internal::Call* call) override; 93 void* RegisterMethod(const char* method) override; 94 95 void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed, 96 gpr_timespec deadline, grpc::CompletionQueue* cq, 97 void* tag) override; 98 bool WaitForStateChangeImpl(grpc_connectivity_state last_observed, 99 gpr_timespec deadline) override; 100 101 grpc::CompletionQueue* CallbackCQ() override; 102 103 grpc::internal::Call CreateCallInternal( 104 const grpc::internal::RpcMethod& method, grpc::ClientContext* context, 105 grpc::CompletionQueue* cq, size_t interceptor_pos) override; 106 107 const std::string host_; 108 grpc_channel* const c_channel_; // owned 109 110 // mu_ protects callback_cq_ (the per-channel callbackable completion queue) 111 grpc::internal::Mutex mu_; 112 113 // callback_cq_ references the callbackable completion queue associated 114 // with this channel (if any). It is set on the first call to CallbackCQ(). 115 // It is _not owned_ by the channel; ownership belongs with its internal 116 // shutdown callback tag (invoked when the CQ is fully shutdown). 117 std::atomic<CompletionQueue*> callback_cq_{nullptr}; 118 119 std::vector< 120 std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>> 121 interceptor_creators_; 122 }; 123 124 } // namespace grpc 125 126 #endif // GRPCPP_CHANNEL_H 127