IceGridXmlGenerator.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of ArmarX.
3  *
4  * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
5  *
6  * ArmarX is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * ArmarX is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  *
18  * @package ArmarXCore::core
19  * @author Cedric Seehausen
20  * @date 2016
21  * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
22  * GNU General Public License
23  */
24 #include "ArmarXCore/util/ScenarioManagerCommon/generator/IceGridXmlGenerator.h"
25 
26 #include <fstream>
27 #include <sstream>
28 
29 #include "ArmarXCore/util/ScenarioManagerCommon/parser/DependenciesGenerator.h"
30 #include <ArmarXCore/core/IceGridAdmin.h>
31 #include <ArmarXCore/core/IceManager.h>
32 #include <ArmarXCore/core/exceptions/local/ExpressionException.h>
33 #include <ArmarXCore/core/rapidxml/wrapper/RapidXmlReader.h>
34 #include <ArmarXCore/core/rapidxml/wrapper/RapidXmlWriter.h>
35 #include <ArmarXCore/core/system/ArmarXDataPath.h>
36 #include <ArmarXCore/core/system/cmake/CMakePackageFinder.h>
37 #include <ArmarXCore/util/ScenarioManagerCommon/executor/IceStatusReader.h>
38 
39 using namespace ScenarioManager;
40 using namespace Generator;
41 using namespace armarx;
42 
43 void
44 IceGridXmlGenerator::generateLocalApplication(Data_Structure::ScenarioPtr scenario)
45 {
46  RapidXmlWriter writer;
47  RapidXmlWriterNode rootNode = writer.createRootNode("icegrid");
48  CMakePackageFinder finder(scenario->getPackage()->getName());
49 
50  RapidXmlWriterNode applicationNode = rootNode.append_node("application");
51  applicationNode.append_attribute("name", scenario->getName());
52  applicationNode.append_attribute("import-default-templates", "true");
53 
54  RapidXmlWriterNode includeNode = applicationNode.append_node("include");
55  includeNode.append_attribute(
56  "file", ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml");
57 
58  RapidXmlWriterNode variableScenarioDirNode = applicationNode.append_node("variable");
59  variableScenarioDirNode.append_attribute("name", "ARMARX_SCENARIO_DIR");
60  variableScenarioDirNode.append_attribute("value", scenario->getFolder());
61 
62  RapidXmlWriterNode variableScenarioDependencyNode = applicationNode.append_node("variable");
63  variableScenarioDependencyNode.append_attribute("name", "ARMARX_SCENARIO_DEPENDENCY_CONFIG");
64  variableScenarioDependencyNode.append_attribute("value", "dependencies.cfg");
65 
66  RapidXmlWriterNode variablePackageConfigDir = applicationNode.append_node("variable");
67  variablePackageConfigDir.append_attribute("name", "ARMARX_PACKAGE_CONFIG_DIR");
68  variablePackageConfigDir.append_attribute("value", finder.getConfigDir());
69 
70  RapidXmlWriterNode variableArmarXLDPath = applicationNode.append_node("variable");
71  variableArmarXLDPath.append_attribute("name", "ArmarX_LD_LIB_PATH");
72  variableArmarXLDPath.append_attribute("value", "");
73  // variableArmarXLDPath.append_attribute("value", "${ARMARX_SYNC_DIR}/lib:${ARMARX_SYNC_DIR}/usr/lib");
74 
75  RapidXmlWriterNode variableArmarXPath = applicationNode.append_node("variable");
76  variableArmarXPath.append_attribute("name", "ArmarX_PATH");
77  variableArmarXPath.append_attribute("value", "");
78  // variableArmarXPath.append_attribute("value", "${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin");
79 
80  for (auto dep :
81  Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
82  {
83  CMakePackageFinder currentFinder(dep);
84  RapidXmlWriterNode binDirNode = applicationNode.append_node("variable");
85  binDirNode.append_attribute("name", dep + "_BIN_DIR");
86  binDirNode.append_attribute("value", currentFinder.getBinaryDir());
87  }
88 
89  std::map<std::string, RapidXmlWriterNode> existingNodes;
90 
91  for (auto app : *scenario->getApplications())
92  {
93  if (!existingNodes.count(app->getEffectiveNodeName()))
94  {
95  RapidXmlWriterNode node = applicationNode.append_node("node");
96  node.append_attribute("name", app->getEffectiveNodeName());
97  existingNodes.insert(make_pair(app->getEffectiveNodeName(), node));
98  }
99 
100  generateComponent(app);
101  RapidXmlWriterNode includeAppNode =
102  existingNodes.find(app->getEffectiveNodeName())->second.append_node("include");
103  if (app->getInstanceName().empty())
104  {
105  includeAppNode.append_attribute("file", "icegrid/" + app->getName() + ".icegrid.xml");
106  }
107  else
108  {
109  includeAppNode.append_attribute("file",
110  "icegrid/" + app->getName() + "." +
111  app->getInstanceName() + ".icegrid.xml");
112  }
113  }
114 
115  writer.saveToFile(scenario->getFolder() + "/" + scenario->getName() + ".icegrid.xml", true);
116 }
117 
118 void
119 IceGridXmlGenerator::generateRemoteApplication(Data_Structure::ScenarioPtr scenario)
120 {
121  RapidXmlWriter writer;
122  RapidXmlWriterNode rootNode = writer.createRootNode("icegrid");
123  CMakePackageFinder finder(scenario->getPackage()->getName());
124 
125  RapidXmlWriterNode applicationNode = rootNode.append_node("application");
126  applicationNode.append_attribute("name", scenario->getName());
127  applicationNode.append_attribute("import-default-templates", "true");
128 
129  RapidXmlWriterNode includeNode = applicationNode.append_node("include");
130  includeNode.append_attribute(
131  "file", ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml");
132 
133  RapidXmlWriterNode variableScenarioDirNode = applicationNode.append_node("variable");
134  variableScenarioDirNode.append_attribute("name", "ARMARX_SCENARIO_DIR");
135  variableScenarioDirNode.append_attribute("value",
136  "${ARMARX_SYNC_DIR}/share/" +
137  scenario->getPackage()->getName() + "/scenarios/" +
138  scenario->getName());
139 
140  RapidXmlWriterNode variableScenarioDependencyNode = applicationNode.append_node("variable");
141  variableScenarioDependencyNode.append_attribute("name", "ARMARX_SCENARIO_DEPENDENCY_CONFIG");
142  variableScenarioDependencyNode.append_attribute("value", "dependencies.remote.cfg");
143 
144  RapidXmlWriterNode variablePackageConfigDir = applicationNode.append_node("variable");
145  variablePackageConfigDir.append_attribute("name", "ARMARX_PACKAGE_CONFIG_DIR");
146  variablePackageConfigDir.append_attribute(
147  "value", "${ARMARX_SYNC_DIR}/share/" + scenario->getPackage()->getName() + "/config");
148 
149  RapidXmlWriterNode variableArmarXLDPath = applicationNode.append_node("variable");
150  variableArmarXLDPath.append_attribute("name", "ArmarX_LD_LIB_PATH");
151  variableArmarXLDPath.append_attribute("value", "${ARMARX_SYNC_DIR}/lib");
152 
153  RapidXmlWriterNode variableArmarXPath = applicationNode.append_node("variable");
154  variableArmarXPath.append_attribute("name", "ArmarX_PATH");
155  variableArmarXPath.append_attribute("value", "");
156  // variableArmarXPath.append_attribute("value", "${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin");
157 
158  for (auto dep :
159  Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
160  {
161  RapidXmlWriterNode binDirNode = applicationNode.append_node("variable");
162  binDirNode.append_attribute("name", dep + "_BIN_DIR");
163  binDirNode.append_attribute("value", "${ARMARX_SYNC_DIR}/bin");
164  }
165 
166  std::map<std::string, RapidXmlWriterNode> existingNodes;
167 
168  for (auto app : *scenario->getApplications())
169  {
170  if (!existingNodes.count(app->getEffectiveNodeName()))
171  {
172  RapidXmlWriterNode node = applicationNode.append_node("node");
173  node.append_attribute("name", app->getEffectiveNodeName());
174  existingNodes.insert(make_pair(app->getEffectiveNodeName(), node));
175  }
176 
177  generateComponent(app);
178  RapidXmlWriterNode includeAppNode =
179  existingNodes.find(app->getEffectiveNodeName())->second.append_node("include");
180  if (app->getInstanceName().empty())
181  {
182  includeAppNode.append_attribute("file", "icegrid/" + app->getName() + ".icegrid.xml");
183  }
184  else
185  {
186  includeAppNode.append_attribute("file",
187  "icegrid/" + app->getName() + "." +
188  app->getInstanceName() + ".icegrid.xml");
189  }
190  }
191 
192  writer.saveToFile(scenario->getFolder() + "/" + scenario->getName() + ".remote.icegrid.xml",
193  true);
194 }
195 
196 void
197 IceGridXmlGenerator::generateComponent(Data_Structure::ApplicationInstancePtr app)
198 {
199  RapidXmlWriter writer;
200  RapidXmlWriterNode rootNode = writer.createRootNode("icegrid");
201 
202  RapidXmlWriterNode applicationNode = rootNode.append_node("server-instance");
203  applicationNode.append_attribute("template", "ArmarXComponentTemplate");
204  applicationNode.append_attribute("component", app->getName());
205  applicationNode.append_attribute("componentId", Exec::IceStatusReader::GetApplicationId(app));
206  applicationNode.append_attribute("componentExeDir", "${" + app->getPackageName() + "_BIN_DIR}");
207  applicationNode.append_attribute("configDomain", app->getConfigDomain());
208 
209  std::string armarXConfigValue =
210  (app->getScenario()->isGlobalConfigFileexistent()
211  ? app->getScenario()->getGlobalConfigPath() + ","
212  : "") +
213  (app->getInstanceName().empty() ? "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + ".cfg"
214  : "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + "." +
215  app->getInstanceName() + ".cfg");
216 
217  applicationNode.append_attribute("ArmarXConfig", armarXConfigValue);
218 
219 
220  // if (app->getInstanceName().empty())
221  // {
222  // armarXConfigValue
223  // applicationNode.append_attribute("ArmarXConfig", "${ARMARX_SCENARIO_DIR}/config/global.cfg,${ARMARX_SCENARIO_DIR}/config/" + app->getName() + ".cfg");
224  // }
225  // else
226  // {
227  // applicationNode.append_attribute("ArmarXConfig", "${ARMARX_SCENARIO_DIR}/config/global.cfg,${ARMARX_SCENARIO_DIR}/config/" + app->getName() + "." + app->getInstanceName() + ".cfg");
228  // }
229 
230  applicationNode.append_attribute(
231  "ArmarXDependenciesConfig",
232  "${ARMARX_PACKAGE_CONFIG_DIR}/${ARMARX_SCENARIO_DEPENDENCY_CONFIG}");
233  applicationNode.append_attribute("ArmarXLoggingGroup", app->getScenario()->getName());
234 
235  std::filesystem::create_directory(app->getScenario()->getFolder() + "/icegrid");
236  if (app->getInstanceName().empty())
237  {
238  writer.saveToFile(
239  app->getScenario()->getFolder() + "/icegrid/" + app->getName() + ".icegrid.xml", true);
240  }
241  else
242  {
243  writer.saveToFile(app->getScenario()->getFolder() + "/icegrid/" + app->getName() + "." +
244  app->getInstanceName() + ".icegrid.xml",
245  true);
246  }
247 }
248 
249 IceGrid::ApplicationDescriptor
250 IceGridXmlGenerator::generateEmptyLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario,
251  const IceGrid::AdminPrx iceAdmin)
252 {
253  CMakePackageFinder finder(scenario->getPackage()->getName());
254 
255  IceGrid::ApplicationDescriptor result;
256  result.name = scenario->getName();
257 
258  IceGrid::StringStringDict variables;
259  variables["ARMARX_SYNC_DIR"] = getDefaultSyncFile();
260  variables["ARMARX_SCENARIO_DIR"] = scenario->getFolder();
261  variables["ARMARX_SCENARIO_DEPENDENCY_CONFIG"] = "dependencies.cfg";
262  variables["ARMARX_PACKAGE_CONFIG_DIR"] = finder.getConfigDir();
263  variables["ArmarX_LD_LIB_PATH"] = ""; //"${ARMARX_SYNC_DIR}/lib:${ARMARX_SYNC_DIR}/usr/lib";
264  variables["ArmarX_PATH"] = ""; //"${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin";
265  variables["ARMARX_LOGGING_GROUP"] = scenario->getName();
266 
267  for (auto dep :
268  Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
269  {
270  CMakePackageFinder currentFinder(dep);
271  variables[dep + "_BIN_DIR"] = currentFinder.getBinaryDir();
272  }
273 
274  result.variables = variables;
275 
276  IceGrid::ApplicationDescriptor defaultDesc = iceAdmin->getDefaultApplicationDescriptor();
277  result.serverTemplates = defaultDesc.serverTemplates;
278  auto v = IceGrid::ServerDescriptorPtr::dynamicCast(
279  result.serverTemplates["ArmarXComponentTemplate"].descriptor.get());
280  ARMARX_CHECK_EXPRESSION(v);
281 
282  result.serviceTemplates = defaultDesc.serviceTemplates;
283 
284  return result;
285 }
286 
287 IceGrid::ApplicationDescriptor
288 IceGridXmlGenerator::generateLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario,
289  const IceGrid::AdminPrx iceAdmin)
290 {
291  IceGrid::ApplicationDescriptor result =
292  generateEmptyLocalApplicationDescriptor(scenario, iceAdmin);
293 
294  for (auto app : *scenario->getApplications())
295  {
296  if (!app->getEnabled())
297  {
298  continue;
299  }
300 
301  result.nodes[app->getEffectiveNodeName()].serverInstances.push_back(
302  generateComponentNode(app));
303  }
304 
305  return result;
306 }
307 
308 IceGrid::ApplicationDescriptor
309 IceGridXmlGenerator::generateEmptyRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario,
310  const IceGrid::AdminPrx iceAdmin)
311 {
312  IceGrid::ApplicationDescriptor result;
313  result.name = scenario->getName();
314 
315  IceGrid::StringStringDict variables;
316  variables["ARMARX_SYNC_DIR"] = getDefaultSyncFile();
317  variables["ARMARX_SCENARIO_DIR"] = "${ARMARX_SYNC_DIR}/share/" +
318  scenario->getPackage()->getName() + "/scenarios/" +
319  scenario->getName();
320  variables["ARMARX_SCENARIO_DEPENDENCY_CONFIG"] = "dependencies.remote.cfg";
321  variables["ARMARX_PACKAGE_CONFIG_DIR"] =
322  "${ARMARX_SYNC_DIR}/share/" + scenario->getPackage()->getName() + "/config";
323  variables["ArmarX_LD_LIB_PATH"] = "${ARMARX_SYNC_DIR}/lib:${ARMARX_SYNC_DIR}/usr/lib";
324  variables["ArmarX_PATH"] = "${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin";
325  variables["ARMARX_LOGGING_GROUP"] = scenario->getName();
326  // variables["CMAKE_PREFIX_PATH"] = "${ARMARX_SYNC_DIR}";
327 
328 
329  for (auto dep :
330  Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
331  {
332  variables[dep + "_BIN_DIR"] = "${ARMARX_SYNC_DIR}/bin";
333  }
334 
335  result.variables = variables;
336 
337  IceGrid::ApplicationDescriptor defaultDesc = iceAdmin->getDefaultApplicationDescriptor();
338  result.serverTemplates = defaultDesc.serverTemplates;
339  auto v = IceGrid::ServerDescriptorPtr::dynamicCast(
340  result.serverTemplates["ArmarXComponentTemplate"].descriptor.get());
341  ARMARX_CHECK_EXPRESSION(v);
342 
343 
344  result.serviceTemplates = defaultDesc.serviceTemplates;
345 
346  return result;
347 }
348 
349 IceGrid::ApplicationDescriptor
350 IceGridXmlGenerator::generateRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario,
351  const IceGrid::AdminPrx iceAdmin)
352 {
353  //CMakePackageFinder finder(scenario->getPackage()->getName());
354 
355  IceGrid::ApplicationDescriptor result =
356  generateEmptyRemoteApplicationDescriptor(scenario, iceAdmin);
357 
358  for (auto app : *scenario->getApplications())
359  {
360  if (!app->getEnabled())
361  {
362  continue;
363  }
364  result.nodes[app->getEffectiveNodeName()].serverInstances.push_back(
365  generateComponentNode(app));
366  }
367 
368  return result;
369 }
370 
371 IceGrid::ServerInstanceDescriptor
372 IceGridXmlGenerator::generateComponentNode(Data_Structure::ApplicationInstancePtr app)
373 {
374  IceGrid::ServerInstanceDescriptor result;
375  result._cpp_template = "ArmarXComponentTemplate";
376  result.parameterValues["component"] = app->getName();
377  result.parameterValues["componentId"] = Exec::IceStatusReader::GetApplicationId(app);
378  result.parameterValues["componentExeDir"] = "${" + app->getPackageName() + "_BIN_DIR}";
379 
380  std::string armarXConfigValue =
381  (app->getScenario()->isGlobalConfigFileexistent()
382  ? app->getScenario()->getGlobalConfigPath() + ","
383  : "") +
384  (app->getInstanceName().empty() ? "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + ".cfg"
385  : "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + "." +
386  app->getInstanceName() + ".cfg");
387 
388  result.parameterValues["configDomain"] = app->getConfigDomain();
389  result.parameterValues["ArmarXConfig"] = armarXConfigValue;
390  result.parameterValues["ArmarXDependenciesConfig"] =
391  "${ARMARX_PACKAGE_CONFIG_DIR}/${ARMARX_SCENARIO_DEPENDENCY_CONFIG}";
392  result.parameterValues["ArmarXLoggingGroup"] = app->getScenario()->getName();
393  result.parameterValues["activationTimeout"] = "10";
394 
395 
396  return result;
397 }
398 
399 std::string
400 IceGridXmlGenerator::getSyncDirFromFile(std::string path)
401 {
402  RapidXmlReaderPtr doc = RapidXmlReader::FromFile(path);
403  RapidXmlReaderNode rootNode = doc->getRoot();
404  try
405  {
406  return rootNode.first_node("variable").attribute_value("value");
407  }
408  catch (exceptions::local::RapidXmlReaderException& exception)
409  {
410  ARMARX_DEBUG_S << "Your icegrid-sync-variables file is ill formatted (Error: "
411  << exception.what() << ")";
412  return "";
413  }
414 }
415 
416 void
417 IceGridXmlGenerator::setDefaultSyncFileDir(std::string path)
418 {
419  RapidXmlWriter doc;
420  RapidXmlWriterNode root = doc.createRootNode("icegrid");
421  RapidXmlWriterNode variableNode = root.append_node("variable");
422  variableNode.append_attribute("name", "ARMARX_SYNC_DIR");
423  variableNode.append_attribute("value", path);
424 
425  doc.saveToFile(
426  ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml", true);
427 }
428 
429 IceGrid::ApplicationUpdateDescriptor
430 IceGridXmlGenerator::generateUpdateDescriptor(IceGrid::ApplicationDescriptor descriptor)
431 {
432  IceGrid::ApplicationUpdateDescriptor result;
433  result.name = descriptor.name;
434  //There is currently no simple way to deep copy these constructs so just reuse the needed ones
435  for (auto nodes : descriptor.nodes)
436  {
437  IceGrid::NodeUpdateDescriptor nodeUpdate;
438  nodeUpdate.name = nodes.first;
439  nodeUpdate.serverInstances = nodes.second.serverInstances;
440  //nodeUpdate.description = nodes.second.description;
441  nodeUpdate.propertySets = nodes.second.propertySets;
442  nodeUpdate.serverInstances = nodes.second.serverInstances;
443  nodeUpdate.servers = nodes.second.servers;
444  nodeUpdate.variables = nodes.second.variables;
445  result.nodes.push_back(nodeUpdate);
446  }
447 
448  result.serverTemplates = descriptor.serverTemplates;
449  result.serviceTemplates = descriptor.serviceTemplates;
450  result.variables = result.variables;
451 
452  return result;
453 }
454 
455 std::string
456 IceGridXmlGenerator::getDefaultSyncFile()
457 {
458  return getSyncDirFromFile(ArmarXDataPath::GetDefaultUserConfigPath() +
459  "/icegrid-sync-variables.icegrid.xml");
460 }
armarx::RapidXmlReaderPtr
std::shared_ptr< RapidXmlReader > RapidXmlReaderPtr
Definition: RapidXmlReader.h:67
IceStatusReader.h
ScenarioManager::Data_Structure::ApplicationInstancePtr
std::shared_ptr< ApplicationInstance > ApplicationInstancePtr
Definition: ApplicationInstance.h:33
armarx::RapidXmlWriter
Definition: RapidXmlWriter.h:122
ScenarioManager::Data_Structure::ScenarioPtr
std::shared_ptr< Scenario > ScenarioPtr
Definition: Scenario.h:35
ScenarioManager::Generator::IceGridXmlGenerator::generateLocalApplication
void generateLocalApplication(Data_Structure::ScenarioPtr scenario)
Definition: IceGridXmlGenerator.cpp:44
ScenarioManager::Parser::DependenciesGenerator::getDependencieTree
static DependencyTree getDependencieTree(std::string packageName)
Definition: DependenciesGenerator.cpp:48
armarx::exceptions::local::RapidXmlReaderException
Definition: RapidXmlReader.h:44
armarx::RapidXmlReaderNode::attribute_value
std::string attribute_value(const char *attrName) const
Definition: RapidXmlReader.h:230
armarx::CMakePackageFinder
The CMakePackageFinder class provides an interface to the CMake Package finder capabilities.
Definition: CMakePackageFinder.h:52
RapidXmlWriter.h
ScenarioManager::Generator::IceGridXmlGenerator::generateRemoteApplication
void generateRemoteApplication(Data_Structure::ScenarioPtr scenario)
Definition: IceGridXmlGenerator.cpp:119
ScenarioManager::Generator::IceGridXmlGenerator::setDefaultSyncFileDir
void setDefaultSyncFileDir(std::string path)
Definition: IceGridXmlGenerator.cpp:417
ScenarioManager::Generator::IceGridXmlGenerator::generateComponent
void generateComponent(Data_Structure::ApplicationInstancePtr app)
Definition: IceGridXmlGenerator.cpp:197
ScenarioManager::Generator::IceGridXmlGenerator::generateLocalApplicationDescriptor
IceGrid::ApplicationDescriptor generateLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition: IceGridXmlGenerator.cpp:288
ARMARX_DEBUG_S
#define ARMARX_DEBUG_S
Definition: Logging.h:205
armarx::CMakePackageFinder::getBinaryDir
std::string getBinaryDir() const
Definition: CMakePackageFinder.h:174
ScenarioManager::Generator::IceGridXmlGenerator::generateEmptyRemoteApplicationDescriptor
IceGrid::ApplicationDescriptor generateEmptyRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition: IceGridXmlGenerator.cpp:309
DependenciesGenerator.h
ScenarioManager::Generator::IceGridXmlGenerator::generateUpdateDescriptor
IceGrid::ApplicationUpdateDescriptor generateUpdateDescriptor(IceGrid::ApplicationDescriptor descriptor)
Definition: IceGridXmlGenerator.cpp:430
IceManager.h
armarx::RapidXmlReaderNode
Definition: RapidXmlReader.h:69
IceGridAdmin.h
IceGridXmlGenerator.h
armarx::RapidXmlWriterNode::append_attribute
RapidXmlWriterNode & append_attribute(const std::string &name, const std::string &value)
Definition: RapidXmlWriter.h:59
ScenarioManager::Generator::IceGridXmlGenerator::generateComponentNode
IceGrid::ServerInstanceDescriptor generateComponentNode(Data_Structure::ApplicationInstancePtr app)
Definition: IceGridXmlGenerator.cpp:372
ExpressionException.h
CMakePackageFinder.h
armarx::ctrlutil::v
double v(double t, double v0, double a0, double j)
Definition: CtrlUtil.h:39
ARMARX_CHECK_EXPRESSION
#define ARMARX_CHECK_EXPRESSION(expression)
This macro evaluates the expression and if it turns out to be false it will throw an ExpressionExcept...
Definition: ExpressionException.h:73
armarx::CMakePackageFinder::getConfigDir
std::string getConfigDir() const
Returns the path needed to find this package with cmake, i.e.
Definition: CMakePackageFinder.h:105
ScenarioManager
Definition: Application.cpp:180
ScenarioManager::Generator::IceGridXmlGenerator::generateRemoteApplicationDescriptor
IceGrid::ApplicationDescriptor generateRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition: IceGridXmlGenerator.cpp:350
armarx::RapidXmlWriter::saveToFile
void saveToFile(const std::string &path, bool indent)
Definition: RapidXmlWriter.h:154
RapidXmlReader.h
ScenarioManager::Generator::IceGridXmlGenerator::generateEmptyLocalApplicationDescriptor
IceGrid::ApplicationDescriptor generateEmptyLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition: IceGridXmlGenerator.cpp:250
armarx::RapidXmlWriter::createRootNode
RapidXmlWriterNode createRootNode(const std::string &name)
Definition: RapidXmlWriter.h:137
armarx::RapidXmlWriterNode::append_node
RapidXmlWriterNode append_node(const std::string &name)
Definition: RapidXmlWriter.h:91
armarx::RapidXmlWriterNode
Definition: RapidXmlWriter.h:35
ScenarioManager::Exec::IceStatusReader::GetApplicationId
static std::string GetApplicationId(const ApplicationInstancePtr &application)
Definition: IceStatusReader.cpp:15
ArmarXDataPath.h
armarx::RapidXmlReaderNode::first_node
RapidXmlReaderNode first_node(const char *name=nullptr) const
Definition: RapidXmlReader.h:156
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition: ArmarXTimeserver.cpp:27
ScenarioManager::Generator::IceGridXmlGenerator::getDefaultSyncFile
std::string getDefaultSyncFile()
Definition: IceGridXmlGenerator.cpp:456