main_service_client.cpp
Go to the documentation of this file.
1 /*********************************************************************
2  *
3  * Software License Agreement
4  *
5  * Copyright (c) 2020,
6  * TU Dortmund - Institute of Control Theory and Systems Engineering.
7  * All rights reserved.
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program. If not, see <https://www.gnu.org/licenses/>.
21  *
22  * Authors: Christoph Rösmann
23  *********************************************************************/
24 
25 #ifdef RPC_SUPPORT
26 
27 #include <corbo-communication/main_service_client.h>
28 
29 #include <corbo-communication/messages/corbo_parameters.pb.h>
30 
31 #include <cmath>
32 #include <memory>
33 
34 namespace corbo {
35 
36 std::unique_ptr<google::protobuf::Message> MasterServiceClient::createParameterMsg() const
37 {
38  return std::unique_ptr<messages::corboParameters>(new messages::corboParameters);
39 }
40 
41 bool MasterServiceClient::setParameters(const google::protobuf::Message& parameters, messages::Status& status_msg, int timeout_ms)
42 {
43  const messages::corboParameters* params = dynamic_cast<const messages::corboParameters*>(&parameters);
44  if (!params)
45  {
46  status_msg.set_ok(false);
47  status_msg.set_text("Parameter message is not of type corbo::messages::corboParameters.");
48  return false;
49  }
50  bool ret_val = true;
51 
52  int timeout_individual = std::floor((double)timeout_ms / 4);
53 
54  messages::Status sub_status;
55  ret_val = setPlant(params->plant(), sub_status, timeout_individual);
56  status_msg.set_ok(status_msg.ok() && sub_status.ok());
57  if (!sub_status.text().empty()) status_msg.set_text(status_msg.text() + "\n" + sub_status.text());
58 
59  ret_val = setController(params->controller(), sub_status, timeout_individual);
60  status_msg.set_ok(status_msg.ok() && sub_status.ok());
61  if (!sub_status.text().empty()) status_msg.set_text(status_msg.text() + "\n" + sub_status.text());
62 
63  ret_val = setObserver(params->observer(), status_msg, timeout_individual);
64  status_msg.set_ok(status_msg.ok() && sub_status.ok());
65  if (!sub_status.text().empty()) status_msg.set_text(status_msg.text() + "\n" + sub_status.text());
66 
67  ret_val = setTask(params->task(), status_msg, timeout_individual);
68  status_msg.set_ok(status_msg.ok() && sub_status.ok());
69  if (!sub_status.text().empty()) status_msg.set_text(status_msg.text() + "\n" + sub_status.text());
70 
71  return ret_val;
72 }
73 
74 bool MasterServiceClient::getParameters(google::protobuf::Message& parameters, int timeout_ms)
75 {
76  parameters.Clear();
77 
78  messages::corboParameters* params = dynamic_cast<messages::corboParameters*>(&parameters);
79  if (!params)
80  {
81  PRINT_ERROR("MasterServiceClient::getParameters(): Message type is not compatible!");
82  return false;
83  }
84 
85  int timeout_individual = std::floor((double)timeout_ms / 4);
86 
87  bool ret_val = true;
88 
89  ret_val = getPlant(*params->mutable_plant(), timeout_individual);
90 
91  ret_val = getController(*params->mutable_controller(), timeout_individual);
92 
93  ret_val = getObserver(*params->mutable_observer(), timeout_individual);
94 
95  ret_val = getTask(*params->mutable_task(), timeout_individual);
96 
97  return ret_val;
98 }
99 
100 bool MasterServiceClient::setPlant(const messages::Plant& plant_msg, messages::Status& status_msg, int timeout_ms)
101 {
102  if (!_stub) return false;
103  grpc::ClientContext context;
104  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
105  context.set_deadline(deadline);
106  grpc::Status status = _stub->setPlant(&context, plant_msg, &status_msg);
107  if (!status.ok())
108  {
109  return false;
110  }
111  return true;
112 }
113 
114 bool MasterServiceClient::getPlant(messages::Plant& plant_msg, int timeout_ms)
115 {
116  if (!_stub) return false;
117  grpc::ClientContext context;
118  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
119  context.set_deadline(deadline);
120  messages::Void void_msg;
121  grpc::Status status = _stub->getPlant(&context, void_msg, &plant_msg);
122  if (!status.ok())
123  {
124  return false;
125  }
126  return true;
127 }
128 
129 bool MasterServiceClient::setController(const messages::Controller& ctrl_msg, messages::Status& status_msg, int timeout_ms)
130 {
131  if (!_stub) return false;
132  grpc::ClientContext context;
133  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
134  context.set_deadline(deadline);
135  grpc::Status status = _stub->setController(&context, ctrl_msg, &status_msg);
136  if (!status.ok())
137  {
138  return false;
139  }
140  return true;
141 }
142 
143 bool MasterServiceClient::getController(messages::Controller& ctrl_msg, int timeout_ms)
144 {
145  if (!_stub) return false;
146  grpc::ClientContext context;
147  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
148  context.set_deadline(deadline);
149  messages::Void void_msg;
150  grpc::Status status = _stub->getController(&context, void_msg, &ctrl_msg);
151  if (!status.ok())
152  {
153  return false;
154  }
155  return true;
156 }
157 
158 bool MasterServiceClient::setObserver(const messages::Observer& obs_msg, messages::Status& status_msg, int timeout_ms)
159 {
160  if (!_stub) return false;
161  grpc::ClientContext context;
162  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
163  context.set_deadline(deadline);
164  grpc::Status status = _stub->setObserver(&context, obs_msg, &status_msg);
165  if (!status.ok())
166  {
167  return false;
168  }
169  return true;
170 }
171 
172 bool MasterServiceClient::getObserver(messages::Observer& obs_msg, int timeout_ms)
173 {
174  if (!_stub) return false;
175  grpc::ClientContext context;
176  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
177  context.set_deadline(deadline);
178  messages::Void void_msg;
179  grpc::Status status = _stub->getObserver(&context, void_msg, &obs_msg);
180  if (!status.ok())
181  {
182  return false;
183  }
184  return true;
185 }
186 
187 bool MasterServiceClient::setTask(const messages::Task& task_msg, messages::Status& status_msg, int timeout_ms)
188 {
189  if (!_stub) return false;
190  grpc::ClientContext context;
191  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
192  context.set_deadline(deadline);
193  grpc::Status status = _stub->setTask(&context, task_msg, &status_msg);
194  if (!status.ok())
195  {
196  return false;
197  }
198  return true;
199 }
200 
201 bool MasterServiceClient::getTask(messages::Task& task_msg, int timeout_ms)
202 {
203  if (!_stub) return false;
204  grpc::ClientContext context;
205  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
206  context.set_deadline(deadline);
207  messages::Void void_msg;
208  grpc::Status status = _stub->getTask(&context, void_msg, &task_msg);
209  if (!status.ok())
210  {
211  return false;
212  }
213  return true;
214 }
215 
216 bool MasterServiceClient::getAvailableSignals(std::function<void(const messages::Signal& signal)> feedback, int timeout_ms)
217 {
218  if (!_stub) return false;
219  grpc::ClientContext context;
220  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
221  context.set_deadline(deadline);
222  messages::Void void_msg;
223  messages::Signal signal;
224  std::unique_ptr<grpc::ClientReader<messages::Signal>> reader(_stub->getAvailableSignals(&context, void_msg));
225  while (reader->Read(&signal))
226  {
227  feedback(signal);
228  }
229  grpc::Status status = reader->Finish();
230  if (!status.ok()) return false;
231  return true;
232 }
233 
234 bool MasterServiceClient::performTask(std::function<void(const messages::Signal& signal)> feedback, std::string* msg, int timeout_ms)
235 {
236  if (!_stub) return false;
237  grpc::ClientContext context;
238  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
239  context.set_deadline(deadline);
240 
241  messages::Void void_msg;
242  messages::Signal signal;
243 
244  std::unique_ptr<grpc::ClientReader<messages::Signal>> reader(_stub->performTask(&context, void_msg));
245  while (reader->Read(&signal))
246  {
247  feedback(signal);
248  }
249  grpc::Status status = reader->Finish();
250 
251  if (!status.ok())
252  {
253  if (msg) *msg = status.error_message();
254  return false;
255  }
256  return true;
257 }
258 
259 bool MasterServiceClient::verifyConfig(messages::Status& status_msg, int timeout_ms)
260 {
261  if (!_stub) return false;
262  grpc::ClientContext context;
263  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
264  context.set_deadline(deadline);
265  messages::Void void_msg;
266  grpc::Status status = _stub->verifyConfig(&context, void_msg, &status_msg);
267  if (!status.ok())
268  {
269  return false;
270  }
271  return true;
272 }
273 
274 bool MasterServiceClient::ping(int timeout_ms)
275 {
276  if (!_stub) return false;
277  grpc::ClientContext context;
278  // context.set_fail_fast(true);
279  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
280  context.set_deadline(deadline);
281  messages::Void void_msg;
282  messages::Status reponse;
283  grpc::Status status = _stub->ping(&context, void_msg, &reponse);
284  if (!status.ok())
285  {
286  return false;
287  }
288  return true;
289 }
290 
291 bool MasterServiceClient::stopTask(int timeout_ms)
292 {
293  if (!_stub) return false;
294  grpc::ClientContext context;
295  // context.set_fail_fast(true);
296  std::chrono::system_clock::time_point deadline = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout_ms);
297  context.set_deadline(deadline);
298  messages::Void void_msg;
299  messages::Void reponse;
300  grpc::Status status = _stub->stop(&context, void_msg, &reponse);
301  if (!status.ok())
302  {
303  return false;
304  }
305  return true;
306 }
307 
308 } // namespace corbo
309 
310 // RPC_SUPPORT
311 #endif
floor
EIGEN_DEVICE_FUNC const FloorReturnType floor() const
Definition: ArrayCwiseUnaryOps.h:388
main_service_client.h
PRINT_ERROR
#define PRINT_ERROR(msg)
Print msg-stream as error msg.
Definition: console.h:173

control_box_rst
Author(s): Christoph Rösmann
autogenerated on Mon Feb 28 2022 22:07:00