GRPC C++  1.26.0
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 
26 
27 namespace grpc_impl {
28 class ClientContext;
29 class CompletionQueue;
30 template <class R>
31 class ClientReader;
32 template <class W>
33 class ClientWriter;
34 template <class W, class R>
35 class ClientReaderWriter;
36 namespace internal {
37 template <class InputMessage, class OutputMessage>
38 class CallbackUnaryCallImpl;
39 template <class R>
41 template <class W>
43 template <class W, class R>
45 template <class R>
47 template <class W, class R>
48 class ClientCallbackReaderWriterFactory;
49 template <class R>
50 class ClientCallbackReaderFactory;
51 template <class W>
52 class ClientCallbackWriterFactory;
53 class ClientCallbackUnaryFactory;
54 } // namespace internal
55 } // namespace grpc_impl
56 
57 namespace grpc {
58 class ChannelInterface;
59 
60 namespace experimental {
61 class DelegatingChannel;
62 }
63 
64 namespace internal {
65 class Call;
66 class CallOpSetInterface;
67 class RpcMethod;
68 class InterceptedChannel;
69 template <class InputMessage, class OutputMessage>
70 class BlockingUnaryCallImpl;
71 } // namespace internal
72 
75  public:
76  virtual ~ChannelInterface() {}
79  virtual grpc_connectivity_state GetState(bool try_to_connect) = 0;
80 
83  template <typename T>
84  void NotifyOnStateChange(grpc_connectivity_state last_observed, T deadline,
85  ::grpc_impl::CompletionQueue* cq, void* tag) {
86  TimePoint<T> deadline_tp(deadline);
87  NotifyOnStateChangeImpl(last_observed, deadline_tp.raw_time(), cq, tag);
88  }
89 
92  template <typename T>
93  bool WaitForStateChange(grpc_connectivity_state last_observed, T deadline) {
94  TimePoint<T> deadline_tp(deadline);
95  return WaitForStateChangeImpl(last_observed, deadline_tp.raw_time());
96  }
97 
99  template <typename T>
100  bool WaitForConnected(T deadline) {
102  while ((state = GetState(true)) != GRPC_CHANNEL_READY) {
103  if (!WaitForStateChange(state, deadline)) return false;
104  }
105  return true;
106  }
107 
108  private:
109  template <class R>
111  template <class W>
113  template <class W, class R>
115  template <class R>
117  template <class W>
119  template <class W, class R>
121  template <class R>
123  template <class W, class R>
124  friend class ::grpc_impl::internal::ClientCallbackReaderWriterFactory;
125  template <class R>
126  friend class ::grpc_impl::internal::ClientCallbackReaderFactory;
127  template <class W>
128  friend class ::grpc_impl::internal::ClientCallbackWriterFactory;
129  friend class ::grpc_impl::internal::ClientCallbackUnaryFactory;
130  template <class InputMessage, class OutputMessage>
131  friend class ::grpc::internal::BlockingUnaryCallImpl;
132  template <class InputMessage, class OutputMessage>
133  friend class ::grpc_impl::internal::CallbackUnaryCallImpl;
134  friend class ::grpc::internal::RpcMethod;
135  friend class ::grpc::experimental::DelegatingChannel;
136  friend class ::grpc::internal::InterceptedChannel;
137  virtual internal::Call CreateCall(const internal::RpcMethod& method,
138  ::grpc_impl::ClientContext* context,
139  ::grpc_impl::CompletionQueue* cq) = 0;
140  virtual void PerformOpsOnCall(internal::CallOpSetInterface* ops,
141  internal::Call* call) = 0;
142  virtual void* RegisterMethod(const char* method) = 0;
143  virtual void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
144  gpr_timespec deadline,
146  void* tag) = 0;
147  virtual bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
148  gpr_timespec deadline) = 0;
149 
150  // EXPERIMENTAL
151  // This is needed to keep codegen_test_minimal happy. InterceptedChannel needs
152  // to make use of this but can't directly call Channel's implementation
153  // because of the test.
154  // Returns an empty Call object (rather than being pure) since this is a new
155  // method and adding a new pure method to an interface would be a breaking
156  // change (even though this is private and non-API)
157  virtual internal::Call CreateCallInternal(
158  const internal::RpcMethod& /*method*/,
159  ::grpc_impl::ClientContext* /*context*/,
160  ::grpc_impl::CompletionQueue* /*cq*/, size_t /*interceptor_pos*/) {
161  return internal::Call();
162  }
163 
164  // EXPERIMENTAL
165  // A method to get the callbackable completion queue associated with this
166  // channel. If the return value is nullptr, this channel doesn't support
167  // callback operations.
168  // TODO(vjpai): Consider a better default like using a global CQ
169  // Returns nullptr (rather than being pure) since this is a post-1.0 method
170  // and adding a new pure method to an interface would be a breaking change
171  // (even though this is private and non-API)
172  virtual ::grpc_impl::CompletionQueue* CallbackCQ() { return nullptr; }
173 };
174 } // namespace grpc
175 
176 #endif // GRPCPP_IMPL_CODEGEN_CHANNEL_INTERFACE_H
Codegen interface for grpc::Channel.
Definition: channel_interface.h:74
void NotifyOnStateChange(grpc_connectivity_state last_observed, T deadline, ::grpc_impl::CompletionQueue *cq, void *tag)
Return the tag on cq when the channel state is changed or deadline expires.
Definition: channel_interface.h:84
bool WaitForConnected(T deadline)
Wait for this channel to be connected.
Definition: channel_interface.h:100
virtual ~ChannelInterface()
Definition: channel_interface.h:76
virtual grpc_connectivity_state GetState(bool try_to_connect)=0
Get the current channel state.
bool WaitForStateChange(grpc_connectivity_state last_observed, T deadline)
Blocking wait for channel state change or deadline expiration.
Definition: channel_interface.h:93
If you are trying to use CompletionQueue::AsyncNext with a time class that isn't either gpr_timespec ...
Definition: time.h:40
gpr_timespec raw_time()
Definition: time.h:43
Straightforward wrapping of the C call object.
Definition: call.h:38
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:34
Descriptor of an RPC method.
Definition: rpc_method.h:29
A ClientContext allows the person implementing a service client to:
Definition: client_context_impl.h:184
A thin wrapper around grpc_completion_queue (see src/core/lib/surface/completion_queue....
Definition: completion_queue_impl.h:100
grpc_connectivity_state
Connectivity state of a channel.
Definition: connectivity_state.h:27
@ GRPC_CHANNEL_READY
channel is ready for work
Definition: connectivity_state.h:33
::grpc_impl::internal::ClientAsyncResponseReaderFactory< R > ClientAsyncResponseReaderFactory
Definition: async_unary_call.h:40
::grpc_impl::internal::ClientAsyncReaderFactory< R > ClientAsyncReaderFactory
Definition: async_stream.h:81
::grpc_impl::internal::ClientAsyncReaderWriterFactory< W, R > ClientAsyncReaderWriterFactory
Definition: async_stream.h:89
::grpc_impl::internal::ClientAsyncWriterFactory< W > ClientAsyncWriterFactory
Definition: async_stream.h:85
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm_impl.h:33
This header provides an object that reads bytes directly from a grpc::ByteBuffer, via the ZeroCopyInp...
Definition: alarm.h:24
::grpc_impl::ClientContext ClientContext
Definition: client_context.h:26
::grpc_impl::ClientReader< R > ClientReader
Definition: sync_stream.h:56
::grpc_impl::ClientWriter< W > ClientWriter
Definition: sync_stream.h:62
::grpc_impl::CompletionQueue CompletionQueue
Definition: completion_queue.h:26
::grpc_impl::ClientReaderWriter< W, R > ClientReaderWriter
Definition: sync_stream.h:69
Analogous to struct timespec.
Definition: gpr_types.h:47