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