GRPC C++  1.46.2
channel_interface.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2016 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_CODEGEN_CHANNEL_INTERFACE_H
20 #define GRPCPP_IMPL_CODEGEN_CHANNEL_INTERFACE_H
21 
22 // IWYU pragma: private
23 
28 
29 namespace grpc {
30 template <class R>
32 template <class W>
34 template <class W, class R>
36 namespace internal {
37 template <class InputMessage, class OutputMessage>
39 template <class R>
41 template <class W>
43 template <class W, class R>
46 template <class W, class R>
48 template <class R>
50 template <class W>
53 } // namespace internal
54 
55 class ChannelInterface;
56 class ClientContext;
57 class CompletionQueue;
58 
59 namespace experimental {
60 class DelegatingChannel;
61 }
62 
63 namespace internal {
64 class Call;
65 class CallOpSetInterface;
66 class RpcMethod;
67 class InterceptedChannel;
68 template <class InputMessage, class OutputMessage>
70 } // namespace internal
71 
74  public:
75  virtual ~ChannelInterface() {}
78  virtual grpc_connectivity_state GetState(bool try_to_connect) = 0;
79 
82  template <typename T>
83  void NotifyOnStateChange(grpc_connectivity_state last_observed, T deadline,
84  grpc::CompletionQueue* cq, void* tag) {
85  TimePoint<T> deadline_tp(deadline);
86  NotifyOnStateChangeImpl(last_observed, deadline_tp.raw_time(), cq, tag);
87  }
88 
91  template <typename T>
92  bool WaitForStateChange(grpc_connectivity_state last_observed, T deadline) {
93  TimePoint<T> deadline_tp(deadline);
94  return WaitForStateChangeImpl(last_observed, deadline_tp.raw_time());
95  }
96 
98  template <typename T>
99  bool WaitForConnected(T deadline) {
101  while ((state = GetState(true)) != GRPC_CHANNEL_READY) {
102  if (!WaitForStateChange(state, deadline)) return false;
103  }
104  return true;
105  }
106 
107  private:
108  template <class R>
109  friend class grpc::ClientReader;
110  template <class W>
111  friend class grpc::ClientWriter;
112  template <class W, class R>
114  template <class R>
116  template <class W>
118  template <class W, class R>
121  template <class W, class R>
123  template <class R>
125  template <class W>
128  template <class InputMessage, class OutputMessage>
130  template <class InputMessage, class OutputMessage>
135  virtual internal::Call CreateCall(const internal::RpcMethod& method,
136  grpc::ClientContext* context,
137  grpc::CompletionQueue* cq) = 0;
138  virtual void PerformOpsOnCall(internal::CallOpSetInterface* ops,
139  internal::Call* call) = 0;
140  virtual void* RegisterMethod(const char* method) = 0;
141  virtual void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
142  gpr_timespec deadline,
144  void* tag) = 0;
145  virtual bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
146  gpr_timespec deadline) = 0;
147 
148  // EXPERIMENTAL
149  // This is needed to keep codegen_test_minimal happy. InterceptedChannel needs
150  // to make use of this but can't directly call Channel's implementation
151  // because of the test.
152  // Returns an empty Call object (rather than being pure) since this is a new
153  // method and adding a new pure method to an interface would be a breaking
154  // change (even though this is private and non-API)
155  virtual internal::Call CreateCallInternal(
156  const internal::RpcMethod& /*method*/, grpc::ClientContext* /*context*/,
157  grpc::CompletionQueue* /*cq*/, size_t /*interceptor_pos*/) {
158  return internal::Call();
159  }
160 
161  // A method to get the callbackable completion queue associated with this
162  // channel. If the return value is nullptr, this channel doesn't support
163  // callback operations.
164  // TODO(vjpai): Consider a better default like using a global CQ
165  // Returns nullptr (rather than being pure) since this is a post-1.0 method
166  // and adding a new pure method to an interface would be a breaking change
167  // (even though this is private and non-API)
168  virtual grpc::CompletionQueue* CallbackCQ() { return nullptr; }
169 };
170 } // namespace grpc
171 
172 #endif // GRPCPP_IMPL_CODEGEN_CHANNEL_INTERFACE_H
grpc::ClientWriter
Synchronous (blocking) client-side API for doing client-streaming RPCs, where the outgoing message st...
Definition: channel_interface.h:33
time.h
grpc
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:33
status.h
grpc::internal::ClientAsyncReaderWriterFactory
Definition: async_stream.h:486
grpc::internal::BlockingUnaryCallImpl
Definition: channel_interface.h:69
grpc::internal::Call
Straightforward wrapping of the C call object.
Definition: call.h:37
grpc::ChannelInterface::WaitForStateChange
bool WaitForStateChange(grpc_connectivity_state last_observed, T deadline)
Blocking wait for channel state change or deadline expiration.
Definition: channel_interface.h:92
grpc::internal::ClientAsyncReaderFactory
Definition: async_stream.h:172
grpc::ClientReader
Synchronous (blocking) client-side API for doing server-streaming RPCs, where the stream of messages ...
Definition: channel_interface.h:31
grpc::internal::ClientCallbackWriterFactory
Definition: channel_interface.h:51
grpc::ClientContext
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:195
grpc_connectivity_state
grpc_connectivity_state
Connectivity state of a channel.
Definition: connectivity_state.h:29
grpc::internal::ClientCallbackReaderWriterFactory
Definition: channel_interface.h:47
grpc::internal::CallOpSetInterface
An abstract collection of call ops, used to generate the grpc_call_op structure to pass down to the l...
Definition: call_op_set_interface.h:36
grpc::internal::CallbackUnaryCallImpl
Definition: channel_interface.h:38
connectivity_state.h
grpc::ChannelInterface::WaitForConnected
bool WaitForConnected(T deadline)
Wait for this channel to be connected.
Definition: channel_interface.h:99
grpc::TimePoint::raw_time
gpr_timespec raw_time()=delete
grpc::experimental::DelegatingChannel
Definition: delegating_channel.h:31
grpc::ChannelInterface
Codegen interface for grpc::Channel.
Definition: channel_interface.h:73
grpc::internal::ClientAsyncResponseReaderHelper
Definition: async_unary_call.h:78
grpc::internal::InterceptedChannel
An InterceptedChannel is available to client Interceptors.
Definition: intercepted_channel.h:37
grpc::internal::ClientCallbackUnaryFactory
Definition: client_callback.h:1206
grpc::ChannelInterface::~ChannelInterface
virtual ~ChannelInterface()
Definition: channel_interface.h:75
grpc::ChannelInterface::NotifyOnStateChange
void NotifyOnStateChange(grpc_connectivity_state last_observed, T deadline, grpc::CompletionQueue *cq, void *tag)
Return the tag on cq when the channel state is changed or deadline expires.
Definition: channel_interface.h:83
grpc::ClientReaderWriter
Synchronous (blocking) client-side API for bi-directional streaming RPCs, where the outgoing message ...
Definition: channel_interface.h:35
grpc::ChannelInterface::GetState
virtual grpc_connectivity_state GetState(bool try_to_connect)=0
Get the current channel state.
call.h
grpc::CompletionQueue
A thin wrapper around grpc_completion_queue (see src/core/lib/surface/completion_queue....
Definition: completion_queue.h:104
grpc::internal::ClientCallbackReaderFactory
Definition: channel_interface.h:49
grpc::internal::ClientAsyncWriterFactory
Definition: async_stream.h:316
grpc::internal::RpcMethod
Descriptor of an RPC method.
Definition: rpc_method.h:31
gpr_timespec
Analogous to struct timespec.
Definition: gpr_types.h:49
GRPC_CHANNEL_READY
@ GRPC_CHANNEL_READY
channel is ready for work
Definition: connectivity_state.h:35
grpc::TimePoint
If you are trying to use CompletionQueue::AsyncNext with a time class that isn't either gpr_timespec ...
Definition: time.h:42