hce-node application  1.4.3
HCE Hierarchical Cluster Engine node application
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
DRCETaskRequestSetExecute.cpp
Go to the documentation of this file.
1 #include <Poco/JSON/Object.h>
2 #include <Poco/JSON/Array.h>
3 #include <Poco/JSON/JSON.h>
4 #include <Poco/JSON/Stringifier.h>
5 #include <Poco/JSON/Parser.h>
6 #include <Poco/JSON/JSONException.h>
7 #include <Poco/Dynamic/Var.h>
8 #include <utility>
9 
10 #include "DRCEError.hpp"
11 #include "DRCEMessageConst.hpp"
12 #include "DRCETaskRequestSetExecute.hpp"
13 
14 namespace HCE
15 {
16 namespace drce
17 {
18 //-----------------------------------------------------------------------------
19 DRCETaskRequestSetExecute::DRCETaskRequestSetExecute(const std::string& json)
20 : DRCETaskRequest(DRCETaskRequest::RequestType::rtSetTaskExecute), DRCEFilesList(), sessionOptions(), commandLine(""), inputStream(""), resourceLimits()
21 {
22  if (!json.empty())
23  unserialize(json);
24 }
25 //-----------------------------------------------------------------------------
26 DRCETaskRequestSetExecute::DRCETaskRequestSetExecute(const DRCETaskRequestSetExecute& rhs)
27 : DRCETaskRequest(DRCETaskRequest::RequestType::rtSetTaskExecute), DRCEFilesList(), sessionOptions(), commandLine(""), inputStream(""), resourceLimits()
28 {
29  (*this) = rhs;
30 }
31 //-----------------------------------------------------------------------------
32 DRCETaskRequestSetExecute::DRCETaskRequestSetExecute(DRCETaskRequestSetExecute&& rhs)
33 : DRCETaskRequest(DRCETaskRequest::RequestType::rtSetTaskExecute), DRCEFilesList(), sessionOptions(), commandLine(""), inputStream(""), resourceLimits()
34 {
35  (*this) = std::forward<DRCETaskRequestSetExecute>(rhs);
36 }
37 //-----------------------------------------------------------------------------
38 DRCETaskRequestSetExecute& DRCETaskRequestSetExecute::operator=(const DRCETaskRequestSetExecute& rhs)
39 {
40  if (this != &rhs)
41  {
42  sessionOptions = rhs.getSessionOptions();
43  commandLine = rhs.getCommandLine();
44  inputStream = rhs.getInputStream();
45  resourceLimits = rhs.getResourceLimits();
46  (*dynamic_cast<DRCEFilesList*>(this)) = static_cast<DRCEFilesList>(rhs);
47  taskId = rhs.getTaskId();
48  taskState = rhs.getTaskState();
49  }
50  return *this;
51 }
52 //-----------------------------------------------------------------------------
53 DRCETaskRequestSetExecute& DRCETaskRequestSetExecute::operator=(DRCETaskRequestSetExecute&& rhs)
54 {
55  if (this != &rhs)
56  {
57  sessionOptions = std::move(rhs.getSessionOptions());
58  commandLine = std::move(rhs.getCommandLine());
59  inputStream = std::move(rhs.getInputStream());
60  resourceLimits = std::move(rhs.getResourceLimits());
61  (*dynamic_cast<DRCEFilesList*>(this)) = std::move(static_cast<DRCEFilesList>(rhs));
62  taskId = std::move(rhs.getTaskId());
63  taskState = std::move(rhs.getTaskState());
64  }
65  return *this;
66 }
67 //-----------------------------------------------------------------------------
68 void DRCETaskRequestSetExecute::setSessionOptions(SessionOptions&& sessionOptions_)
69 {
70  sessionOptions = std::move(std::forward<SessionOptions>(sessionOptions_));
71 }
72 //-----------------------------------------------------------------------------
73 // cppcheck-suppress unusedFunction
74 void DRCETaskRequestSetExecute::setResourceLimits(ResourceLimits&& resourceLimits_)
75 {
76  resourceLimits = std::move(std::forward<ResourceLimits>(resourceLimits_));
77 }
78 //-----------------------------------------------------------------------------
79 void DRCETaskRequestSetExecute::clear(void)
80 {
81  sessionOptions.clear();
82  commandLine.clear();
83  inputStream.clear();
84  resourceLimits.clear();
85  files.clear();
86 }
87 //-----------------------------------------------------------------------------
88 bool DRCETaskRequestSetExecute::serialize(std::string& json)
89 {
90  errorCode = NO_ERROR;
91  errorMsg.clear();
92  try
93  {
94  Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
95 
96  Poco::JSON::Object::Ptr pSessionOptions = new Poco::JSON::Object();
97  pSessionOptions->set(drce_json_message_const::sessionType, static_cast<unsigned int>(sessionOptions.sessionType));
98  pSessionOptions->set(drce_json_message_const::port, sessionOptions.port);
99  pSessionOptions->set(drce_json_message_const::userName, sessionOptions.userName);
100  pSessionOptions->set(drce_json_message_const::userPassword, sessionOptions.userPassword);
101  pSessionOptions->set(drce_json_message_const::shellName, sessionOptions.shellName);
102  pSessionOptions->set(drce_json_message_const::homeDir, sessionOptions.homeDir);
103  pSessionOptions->set(drce_json_message_const::timeout, sessionOptions.timeout);
104  pSessionOptions->set(drce_json_message_const::tmode, static_cast<unsigned int>(sessionOptions.tmode));
105  pSessionOptions->set(drce_json_message_const::timeMax, sessionOptions.timeMax);
106  pSessionOptions->set(drce_json_message_const::cleanup, static_cast<unsigned int>(sessionOptions.cleanup));
107 
108  Poco::JSON::Array::Ptr pEnviroment = new Poco::JSON::Array();
109  for (size_t i=0;i<sessionOptions.environments.size();++i)
110  {
111  Poco::JSON::Object::Ptr pEnviromentElem = new Poco::JSON::Object();
112  pEnviromentElem->set(sessionOptions.environments[i].first, sessionOptions.environments[i].second);
113  pEnviroment->add(pEnviromentElem);
114  }
115  pSessionOptions->set(drce_json_message_const::environment, pEnviroment);
116 
117  obj->set(drce_json_message_const::sessionOptions, pSessionOptions);
118  obj->set(drce_json_message_const::commandLine, commandLine);
119  obj->set(drce_json_message_const::inputStream, inputStream);
120 
121  Poco::JSON::Object::Ptr pResourceLimits = new Poco::JSON::Object();
122  pResourceLimits->set(drce_json_message_const::procMax, resourceLimits.procMax);
123  pResourceLimits->set(drce_json_message_const::threadsMax, resourceLimits.threadsMax);
124  pResourceLimits->set(drce_json_message_const::cpuMax, resourceLimits.cpuMax);
125  pResourceLimits->set(drce_json_message_const::iowaitMax, resourceLimits.iowaitMax);
126  pResourceLimits->set(drce_json_message_const::vramFree, resourceLimits.vramFree);
127  pResourceLimits->set(drce_json_message_const::vramFreeMin, resourceLimits.vramFreeMin);
128  pResourceLimits->set(drce_json_message_const::rramFree, resourceLimits.rramFree);
129  pResourceLimits->set(drce_json_message_const::rramFreeMin, resourceLimits.rramFreeMin);
130  pResourceLimits->set(drce_json_message_const::diskFree, resourceLimits.diskFree);
131  pResourceLimits->set(drce_json_message_const::diskFreeMin, resourceLimits.diskFreeMin);
132  pResourceLimits->set(drce_json_message_const::iowaitUsageMax, resourceLimits.usageLimits.iowaitMax);
133  pResourceLimits->set(drce_json_message_const::vramUsageMax, resourceLimits.usageLimits.vramMax);
134  pResourceLimits->set(drce_json_message_const::rramUsageMax, resourceLimits.usageLimits.rramMax);
135  pResourceLimits->set(drce_json_message_const::diskUsageMax, resourceLimits.usageLimits.diskMax);
136  pResourceLimits->set(drce_json_message_const::diskUsageMaxBytes, resourceLimits.usageLimits.diskMaxBytes);
137 
138  obj->set(drce_json_message_const::resourceLimits, pResourceLimits);
139 
140  Poco::JSON::Array::Ptr pFiles = new Poco::JSON::Array();
141 
142  const size_t filesCount = getFilesCount();
143  for (size_t i=0;i<filesCount;++i)
144  {
145  Poco::JSON::Object::Ptr pFileElem = new Poco::JSON::Object();
146  pFileElem->set(drce_json_message_const::actionTypeMask, getFileItem(i).actionType);
147  pFileElem->set(drce_json_message_const::fileName, getFileItem(i).name);
148  pFileElem->set(drce_json_message_const::fileData, getFileItem(i).data);
149  pFiles->add(pFileElem);
150  }
151  obj->set(drce_json_message_const::filesArray, pFiles);
152 
153  std::stringstream ostr;
154  Poco::JSON::Stringifier::stringify(obj, ostr);
155  json = ostr.str();
156 
157  _isError = false;
158  }
159  catch(std::exception& e)
160  {
161  _isError = true;
162  errorMsg = e.what();
163  errorCode = ERROR_SERIALIZE;
164  }
165  return !_isError;
166 }
167 //-----------------------------------------------------------------------------
168 bool DRCETaskRequestSetExecute::unserialize(const std::string& json)
169 {
170  clear();
171  errorCode = NO_ERROR;
172  errorMsg.clear();
173 
174  try
175  {
176  Poco::JSON::Parser parser;
177  Poco::Dynamic::Var res = parser.parse(json);
178  Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();
179 
180  Poco::Dynamic::Var tmp;
181  Poco::JSON::Object::Ptr pSessionOptions = obj->getObject(drce_json_message_const::sessionOptions);
182  if (!pSessionOptions.isNull())
183  {
184  tmp = pSessionOptions->get(drce_json_message_const::sessionType);
185  if (tmp.isEmpty())
186  throw Poco::Exception(message_const::badJsonFormat+drce_json_message_const::sessionType, ERROR_BAD_JSON_FORMAT);
187  sessionOptions.sessionType = static_cast<SessionOptions::SessionType>(convertVarToNumeric<unsigned int>(tmp, 0));
188 
189  tmp = pSessionOptions->get(drce_json_message_const::port);
190  sessionOptions.port = convertVarToNumeric<unsigned int>(tmp, 0);
191 
192  tmp = pSessionOptions->get(drce_json_message_const::userName);
193  if (tmp.isString())
194  sessionOptions.userName = tmp.convert<std::string>();
195 
196  tmp = pSessionOptions->get(drce_json_message_const::userPassword);
197  if (tmp.isString())
198  sessionOptions.userPassword = tmp.convert<std::string>();
199 
200  tmp = pSessionOptions->get(drce_json_message_const::shellName);
201  if (tmp.isString())
202  sessionOptions.shellName = tmp.convert<std::string>();
203 
204  tmp = pSessionOptions->get(drce_json_message_const::homeDir);
205  if (tmp.isString())
206  sessionOptions.homeDir = tmp.convert<std::string>();
207 
208  tmp = pSessionOptions->get(drce_json_message_const::timeout);
209  sessionOptions.timeout = convertVarToNumeric<unsigned int>(tmp, 0);
210 
211  tmp = pSessionOptions->get(drce_json_message_const::tmode);
212  if (tmp.isEmpty())
213  throw Poco::Exception(message_const::badJsonFormat+drce_json_message_const::tmode, ERROR_BAD_JSON_FORMAT);
214  sessionOptions.tmode = static_cast<SessionOptions::ThreadMode>(convertVarToNumeric<unsigned int>(tmp, 0));
215 
216  tmp = pSessionOptions->get(drce_json_message_const::timeMax);
217  if (tmp.isEmpty())
218  throw Poco::Exception(message_const::badJsonFormat+drce_json_message_const::timeMax, ERROR_BAD_JSON_FORMAT);
219  sessionOptions.timeMax = convertVarToNumeric<unsigned int>(tmp, 0);
220 
221  tmp = pSessionOptions->get(drce_json_message_const::cleanup);
222  sessionOptions.cleanup = static_cast<SessionOptions::CleanupFlag>(convertVarToNumeric<unsigned int>(tmp, 0));
223 
224  Poco::JSON::Array::Ptr pEnviroment = pSessionOptions->getArray(drce_json_message_const::environment);
225  if (!pEnviroment.isNull())
226  {
227  for (size_t j=0;j<pEnviroment->size();++j)
228  {
229  Poco::JSON::Object::Ptr pEnviromentElem = pEnviroment->getObject(j);
230  if (!pEnviromentElem.isNull())
231  {
232  std::vector<std::string> names;
233  pEnviromentElem->getNames(names);
234  for (size_t k=0;k<names.size();++k)
235  {
236  tmp = pEnviromentElem->get(names[k]);
237  if (tmp.isString())
238  sessionOptions.environments.push_back(std::make_pair(names[k], tmp.convert<std::string>()));
239  }
240  }
241  }
242  }
243  }
244 
245  tmp = obj->get(drce_json_message_const::commandLine);
246  if (tmp.isString())
247  commandLine = tmp.convert<std::string>();
248 
249  tmp = obj->get(drce_json_message_const::inputStream);
250  if (tmp.isString())
251  inputStream = tmp.convert<std::string>();
252 
253  Poco::JSON::Object::Ptr pResourceLimits = obj->getObject(drce_json_message_const::resourceLimits);
254  if (!pResourceLimits.isNull())
255  {
256  tmp = pResourceLimits->get(drce_json_message_const::procMax);
257  resourceLimits.procMax = convertVarToNumeric<unsigned int>(tmp, 0);
258 
259  tmp = pResourceLimits->get(drce_json_message_const::threadsMax);
260  resourceLimits.threadsMax = convertVarToNumeric<unsigned int>(tmp, 0);
261 
262  tmp = pResourceLimits->get(drce_json_message_const::cpuMax);
263  resourceLimits.cpuMax = convertVarToNumeric<double>(tmp, 0);
264 
265  tmp = pResourceLimits->get(drce_json_message_const::iowaitMax);
266  resourceLimits.iowaitMax = convertVarToNumeric<double>(tmp, 0);
267 
268  tmp = pResourceLimits->get(drce_json_message_const::vramFree);
269  resourceLimits.vramFree = convertVarToNumeric<double>(tmp, 0);
270 
271  tmp = pResourceLimits->get(drce_json_message_const::vramFreeMin);
272  resourceLimits.vramFreeMin = convertVarToNumeric<size_t>(tmp, 0);
273 
274  tmp = pResourceLimits->get(drce_json_message_const::rramFree);
275  resourceLimits.rramFree = convertVarToNumeric<double>(tmp, 0);
276 
277  tmp = pResourceLimits->get(drce_json_message_const::rramFreeMin);
278  resourceLimits.rramFreeMin = convertVarToNumeric<size_t>(tmp, 0);
279 
280  tmp = pResourceLimits->get(drce_json_message_const::diskFree);
281  resourceLimits.diskFree = convertVarToNumeric<double>(tmp, 0);
282 
283  tmp = pResourceLimits->get(drce_json_message_const::diskFreeMin);
284  resourceLimits.diskFreeMin = convertVarToNumeric<size_t>(tmp, 0);
285 
286  tmp = pResourceLimits->get(drce_json_message_const::iowaitUsageMax);
287  resourceLimits.usageLimits.iowaitMax = convertVarToNumeric<double>(tmp, 0);
288 
289  tmp = pResourceLimits->get(drce_json_message_const::vramUsageMax);
290  resourceLimits.usageLimits.vramMax = convertVarToNumeric<double>(tmp, 0);
291 
292  tmp = pResourceLimits->get(drce_json_message_const::rramUsageMax);
293  resourceLimits.usageLimits.rramMax = convertVarToNumeric<double>(tmp, 0);
294 
295  tmp = pResourceLimits->get(drce_json_message_const::diskUsageMax);
296  resourceLimits.usageLimits.diskMax = convertVarToNumeric<double>(tmp, 0);
297 
298  tmp = pResourceLimits->get(drce_json_message_const::diskUsageMaxBytes);
299  resourceLimits.usageLimits.diskMaxBytes = convertVarToNumeric<size_t>(tmp, 0);
300  }
301 
302  Poco::JSON::Array::Ptr pFiles = obj->getArray(drce_json_message_const::filesArray);
303  if (!pFiles.isNull())
304  {
305  for (size_t i=0;i<pFiles->size();++i)
306  {
307  Poco::JSON::Object::Ptr pFileElem = pFiles->getObject(i);
308  if (!pFileElem.isNull())
309  {
310  FileItem fileItem;
311  fileItem.actionType = pFileElem->getValue<unsigned int>(drce_json_message_const::actionTypeMask);
312  fileItem.name = pFileElem->getValue<std::string>(drce_json_message_const::fileName);
313  fileItem.data = pFileElem->getValue<std::string>(drce_json_message_const::fileData);
314  addFileItem(std::forward<FileItem>(fileItem));
315  }
316  }
317  }
318 
319  _isError = false;
320  }
321  catch(Poco::JSON::JSONException& e)
322  {
323  _isError = true;
324  errorMsg = e.message();
325  errorCode = ERROR_UNSERIALIZE;
326  }
327  catch(Poco::Exception& e)
328  {
329  _isError = true;
330  errorMsg = e.message();
331  errorCode = ERROR_UNSERIALIZE;
332  }
333  return !_isError;
334 }
335 //-----------------------------------------------------------------------------
336 std::istream& operator>>(std::istream& is, DRCETaskRequestSetExecute& rhs)
337 {
338  std::string json;
339  is.seekg(0, std::ios::end);
340  json.resize(is.tellg());
341  is.seekg(0, std::ios::beg);
342  is.read(const_cast<char*>(json.c_str()), json.size());
343  rhs.unserialize(json);
344  return is;
345 }
346 //-----------------------------------------------------------------------------
347 std::ostream& operator<<(std::ostream& os, const DRCETaskRequestSetExecute& rhs)
348 {
349  std::string json;
350  const_cast<DRCETaskRequestSetExecute&>(rhs).serialize(json);
351  return os << json;
352 }
353 //-----------------------------------------------------------------------------
354 //-----------------------------------------------------------------------------
355 } // namespace drce
356 } // namespace HCE