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 "ArmarXCore/util/ScenarioManagerCommon/parser/DependenciesGenerator.h"
27 
28 #include <fstream>
29 #include <sstream>
30 
31 #include <ArmarXCore/core/rapidxml/wrapper/RapidXmlReader.h>
32 #include <ArmarXCore/core/rapidxml/wrapper/RapidXmlWriter.h>
33 #include <ArmarXCore/core/system/ArmarXDataPath.h>
34 #include <ArmarXCore/core/exceptions/local/ExpressionException.h>
35 #include <ArmarXCore/core/system/cmake/CMakePackageFinder.h>
36 #include <ArmarXCore/core/IceManager.h>
37 #include <ArmarXCore/core/system/ArmarXDataPath.h>
38 #include <ArmarXCore/core/IceGridAdmin.h>
39 #include <ArmarXCore/util/ScenarioManagerCommon/executor/IceStatusReader.h>
40 
41 using namespace ScenarioManager;
42 using namespace Generator;
43 using namespace armarx;
44 
45 void IceGridXmlGenerator::generateLocalApplication(Data_Structure::ScenarioPtr scenario)
46 {
47  RapidXmlWriter writer;
48  RapidXmlWriterNode rootNode = writer.createRootNode("icegrid");
49  CMakePackageFinder finder(scenario->getPackage()->getName());
50 
51  RapidXmlWriterNode applicationNode = rootNode.append_node("application");
52  applicationNode.append_attribute("name", scenario->getName());
53  applicationNode.append_attribute("import-default-templates", "true");
54 
55  RapidXmlWriterNode includeNode = applicationNode.append_node("include");
56  includeNode.append_attribute("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 : Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
81  {
82  CMakePackageFinder currentFinder(dep);
83  RapidXmlWriterNode binDirNode = applicationNode.append_node("variable");
84  binDirNode.append_attribute("name", dep + "_BIN_DIR");
85  binDirNode.append_attribute("value", currentFinder.getBinaryDir());
86  }
87 
88  std::map<std::string, RapidXmlWriterNode> existingNodes;
89 
90  for (auto app : *scenario->getApplications())
91  {
92  if (!existingNodes.count(app->getEffectiveNodeName()))
93  {
94  RapidXmlWriterNode node = applicationNode.append_node("node");
95  node.append_attribute("name", app->getEffectiveNodeName());
96  existingNodes.insert(make_pair(app->getEffectiveNodeName(), node));
97  }
98 
99  generateComponent(app);
100  RapidXmlWriterNode includeNode = existingNodes.find(app->getEffectiveNodeName())->second.append_node("include");
101  if (app->getInstanceName().empty())
102  {
103  includeNode.append_attribute("file", "icegrid/" + app->getName() + ".icegrid.xml");
104  }
105  else
106  {
107  includeNode.append_attribute("file", "icegrid/" + app->getName() + "." + app->getInstanceName() + ".icegrid.xml");
108  }
109  }
110 
111  writer.saveToFile(scenario->getFolder() + "/" + scenario->getName() + ".icegrid.xml", true);
112 }
113 
114 void IceGridXmlGenerator::generateRemoteApplication(Data_Structure::ScenarioPtr scenario)
115 {
116  RapidXmlWriter writer;
117  RapidXmlWriterNode rootNode = writer.createRootNode("icegrid");
118  CMakePackageFinder finder(scenario->getPackage()->getName());
119 
120  RapidXmlWriterNode applicationNode = rootNode.append_node("application");
121  applicationNode.append_attribute("name", scenario->getName());
122  applicationNode.append_attribute("import-default-templates", "true");
123 
124  RapidXmlWriterNode includeNode = applicationNode.append_node("include");
125  includeNode.append_attribute("file", ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml");
126 
127  RapidXmlWriterNode variableScenarioDirNode = applicationNode.append_node("variable");
128  variableScenarioDirNode.append_attribute("name", "ARMARX_SCENARIO_DIR");
129  variableScenarioDirNode.append_attribute("value", "${ARMARX_SYNC_DIR}/share/" + scenario->getPackage()->getName() + "/scenarios/" + scenario->getName());
130 
131  RapidXmlWriterNode variableScenarioDependencyNode = applicationNode.append_node("variable");
132  variableScenarioDependencyNode.append_attribute("name", "ARMARX_SCENARIO_DEPENDENCY_CONFIG");
133  variableScenarioDependencyNode.append_attribute("value", "dependencies.remote.cfg");
134 
135  RapidXmlWriterNode variablePackageConfigDir = applicationNode.append_node("variable");
136  variablePackageConfigDir.append_attribute("name", "ARMARX_PACKAGE_CONFIG_DIR");
137  variablePackageConfigDir.append_attribute("value", "${ARMARX_SYNC_DIR}/share/" + scenario->getPackage()->getName() + "/config");
138 
139  RapidXmlWriterNode variableArmarXLDPath = applicationNode.append_node("variable");
140  variableArmarXLDPath.append_attribute("name", "ArmarX_LD_LIB_PATH");
141  variableArmarXLDPath.append_attribute("value", "${ARMARX_SYNC_DIR}/lib");
142 
143  RapidXmlWriterNode variableArmarXPath = applicationNode.append_node("variable");
144  variableArmarXPath.append_attribute("name", "ArmarX_PATH");
145  variableArmarXPath.append_attribute("value", "");
146  // variableArmarXPath.append_attribute("value", "${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin");
147 
148  for (auto dep : Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
149  {
150  RapidXmlWriterNode binDirNode = applicationNode.append_node("variable");
151  binDirNode.append_attribute("name", dep + "_BIN_DIR");
152  binDirNode.append_attribute("value", "${ARMARX_SYNC_DIR}/bin");
153  }
154 
155  std::map<std::string, RapidXmlWriterNode> existingNodes;
156 
157  for (auto app : *scenario->getApplications())
158  {
159  if (!existingNodes.count(app->getEffectiveNodeName()))
160  {
161  RapidXmlWriterNode node = applicationNode.append_node("node");
162  node.append_attribute("name", app->getEffectiveNodeName());
163  existingNodes.insert(make_pair(app->getEffectiveNodeName(), node));
164  }
165 
166  generateComponent(app);
167  RapidXmlWriterNode includeNode = existingNodes.find(app->getEffectiveNodeName())->second.append_node("include");
168  if (app->getInstanceName().empty())
169  {
170  includeNode.append_attribute("file", "icegrid/" + app->getName() + ".icegrid.xml");
171  }
172  else
173  {
174  includeNode.append_attribute("file", "icegrid/" + app->getName() + "." + app->getInstanceName() + ".icegrid.xml");
175  }
176  }
177 
178  writer.saveToFile(scenario->getFolder() + "/" + scenario->getName() + ".remote.icegrid.xml", true);
179 }
180 
181 void IceGridXmlGenerator::generateComponent(Data_Structure::ApplicationInstancePtr app)
182 {
183  RapidXmlWriter writer;
184  RapidXmlWriterNode rootNode = writer.createRootNode("icegrid");
185 
186  RapidXmlWriterNode applicationNode = rootNode.append_node("server-instance");
187  applicationNode.append_attribute("template", "ArmarXComponentTemplate");
188  applicationNode.append_attribute("component", app->getName());
189  applicationNode.append_attribute("componentId", Exec::IceStatusReader::GetApplicationId(app));
190  applicationNode.append_attribute("componentExeDir", "${" + app->getPackageName() + "_BIN_DIR}");
191  applicationNode.append_attribute("configDomain", app->getConfigDomain());
192 
193  std::string armarXConfigValue = (app->getScenario()->isGlobalConfigFileexistent() ? app->getScenario()->getGlobalConfigPath() + "," : "")
194  + (app->getInstanceName().empty() ? "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + ".cfg" : "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + "." + app->getInstanceName() + ".cfg");
195 
196  applicationNode.append_attribute("ArmarXConfig", armarXConfigValue);
197 
198 
199  // if (app->getInstanceName().empty())
200  // {
201  // armarXConfigValue
202  // applicationNode.append_attribute("ArmarXConfig", "${ARMARX_SCENARIO_DIR}/config/global.cfg,${ARMARX_SCENARIO_DIR}/config/" + app->getName() + ".cfg");
203  // }
204  // else
205  // {
206  // applicationNode.append_attribute("ArmarXConfig", "${ARMARX_SCENARIO_DIR}/config/global.cfg,${ARMARX_SCENARIO_DIR}/config/" + app->getName() + "." + app->getInstanceName() + ".cfg");
207  // }
208 
209  applicationNode.append_attribute("ArmarXDependenciesConfig", "${ARMARX_PACKAGE_CONFIG_DIR}/${ARMARX_SCENARIO_DEPENDENCY_CONFIG}");
210  applicationNode.append_attribute("ArmarXLoggingGroup", app->getScenario()->getName());
211 
212  std::filesystem::create_directory(app->getScenario()->getFolder() + "/icegrid");
213  if (app->getInstanceName().empty())
214  {
215  writer.saveToFile(app->getScenario()->getFolder() + "/icegrid/" + app->getName() + ".icegrid.xml", true);
216  }
217  else
218  {
219  writer.saveToFile(app->getScenario()->getFolder() + "/icegrid/" + app->getName() + "." + app->getInstanceName() + ".icegrid.xml", true);
220  }
221 }
222 
223 IceGrid::ApplicationDescriptor IceGridXmlGenerator::generateEmptyLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
224 {
225  CMakePackageFinder finder(scenario->getPackage()->getName());
226 
227  IceGrid::ApplicationDescriptor result;
228  result.name = scenario->getName();
229 
230  IceGrid::StringStringDict variables;
231  variables["ARMARX_SYNC_DIR"] = getDefaultSyncFile();
232  variables["ARMARX_SCENARIO_DIR"] = scenario->getFolder();
233  variables["ARMARX_SCENARIO_DEPENDENCY_CONFIG"] = "dependencies.cfg";
234  variables["ARMARX_PACKAGE_CONFIG_DIR"] = finder.getConfigDir();
235  variables["ArmarX_LD_LIB_PATH"] = "";//"${ARMARX_SYNC_DIR}/lib:${ARMARX_SYNC_DIR}/usr/lib";
236  variables["ArmarX_PATH"] = "";//"${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin";
237  variables["ARMARX_LOGGING_GROUP"] = scenario->getName();
238 
239  for (auto dep : Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
240  {
241  CMakePackageFinder currentFinder(dep);
242  variables[dep + "_BIN_DIR"] = currentFinder.getBinaryDir();
243  }
244 
245  result.variables = variables;
246 
247  IceGrid::ApplicationDescriptor defaultDesc = iceAdmin->getDefaultApplicationDescriptor();
248  result.serverTemplates = defaultDesc.serverTemplates;
249  auto v = IceGrid::ServerDescriptorPtr::dynamicCast(result.serverTemplates["ArmarXComponentTemplate"].descriptor.get());
250  ARMARX_CHECK_EXPRESSION(v);
251  // v->activationTimeout = "10";
252  for (auto variable : scenario->getIceEnviromentVariables())
253  {
254  v->envs.push_back(variable.first + "=" + variable.second);
255  }
256 
257  result.serviceTemplates = defaultDesc.serviceTemplates;
258 
259  return result;
260 }
261 
262 IceGrid::ApplicationDescriptor IceGridXmlGenerator::generateLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
263 {
264  IceGrid::ApplicationDescriptor result = generateEmptyLocalApplicationDescriptor(scenario, iceAdmin);
265 
266  for (auto app : *scenario->getApplications())
267  {
268  if (!app->getEnabled())
269  {
270  continue;
271  }
272 
273  result.nodes[app->getEffectiveNodeName()].serverInstances.push_back(generateComponentNode(app));
274  }
275 
276  return result;
277 }
278 
279 IceGrid::ApplicationDescriptor IceGridXmlGenerator::generateEmptyRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
280 {
281  IceGrid::ApplicationDescriptor result;
282  result.name = scenario->getName();
283 
284  IceGrid::StringStringDict variables;
285  variables["ARMARX_SYNC_DIR"] = getDefaultSyncFile();
286  variables["ARMARX_SCENARIO_DIR"] = "${ARMARX_SYNC_DIR}/share/" + scenario->getPackage()->getName() + "/scenarios/" + scenario->getName();
287  variables["ARMARX_SCENARIO_DEPENDENCY_CONFIG"] = "dependencies.remote.cfg";
288  variables["ARMARX_PACKAGE_CONFIG_DIR"] = "${ARMARX_SYNC_DIR}/share/" + scenario->getPackage()->getName() + "/config";
289  variables["ArmarX_LD_LIB_PATH"] = "${ARMARX_SYNC_DIR}/lib:${ARMARX_SYNC_DIR}/usr/lib";
290  variables["ArmarX_PATH"] = "${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin";
291  variables["ARMARX_LOGGING_GROUP"] = scenario->getName();
292  // variables["CMAKE_PREFIX_PATH"] = "${ARMARX_SYNC_DIR}";
293 
294 
295  for (auto dep : Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
296  {
297  variables[dep + "_BIN_DIR"] = "${ARMARX_SYNC_DIR}/bin";
298  }
299 
300  result.variables = variables;
301 
302  IceGrid::ApplicationDescriptor defaultDesc = iceAdmin->getDefaultApplicationDescriptor();
303  result.serverTemplates = defaultDesc.serverTemplates;
304  auto v = IceGrid::ServerDescriptorPtr::dynamicCast(result.serverTemplates["ArmarXComponentTemplate"].descriptor.get());
305  ARMARX_CHECK_EXPRESSION(v);
306  // v->activationTimeout = "10";
307  for (auto variable : scenario->getIceEnviromentVariables())
308  {
309  v->envs.push_back(variable.first + "=" + variable.second);
310  }
311 
312  result.serviceTemplates = defaultDesc.serviceTemplates;
313 
314  return result;
315 }
316 
317 IceGrid::ApplicationDescriptor IceGridXmlGenerator::generateRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
318 {
319  //CMakePackageFinder finder(scenario->getPackage()->getName());
320 
321  IceGrid::ApplicationDescriptor result = generateEmptyRemoteApplicationDescriptor(scenario, iceAdmin);
322 
323  for (auto app : *scenario->getApplications())
324  {
325  if (!app->getEnabled())
326  {
327  continue;
328  }
329  result.nodes[app->getEffectiveNodeName()].serverInstances.push_back(generateComponentNode(app));
330  }
331 
332  return result;
333 }
334 
335 IceGrid::ServerInstanceDescriptor IceGridXmlGenerator::generateComponentNode(Data_Structure::ApplicationInstancePtr app)
336 {
337  IceGrid::ServerInstanceDescriptor result;
338  result._cpp_template = "ArmarXComponentTemplate";
339  result.parameterValues["component"] = app->getName();
340  result.parameterValues["componentId"] = Exec::IceStatusReader::GetApplicationId(app);
341  result.parameterValues["componentExeDir"] = "${" + app->getPackageName() + "_BIN_DIR}";
342 
343  std::string armarXConfigValue = (app->getScenario()->isGlobalConfigFileexistent() ? app->getScenario()->getGlobalConfigPath() + "," : "")
344  + (app->getInstanceName().empty() ? "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + ".cfg" : "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + "." + app->getInstanceName() + ".cfg");
345 
346  result.parameterValues["configDomain"] = app->getConfigDomain();
347  result.parameterValues["ArmarXConfig"] = armarXConfigValue;
348  result.parameterValues["ArmarXDependenciesConfig"] = "${ARMARX_PACKAGE_CONFIG_DIR}/${ARMARX_SCENARIO_DEPENDENCY_CONFIG}";
349  result.parameterValues["ArmarXLoggingGroup"] = app->getScenario()->getName();
350  result.parameterValues["activationType"] = app->getIceAutoRestart() ? "always" : "manual";
351  result.parameterValues["activationTimeout"] = "10";
352 
353 
354  return result;
355 }
356 
357 std::string IceGridXmlGenerator::getSyncDirFromFile(std::string path)
358 {
359  RapidXmlReaderPtr doc = RapidXmlReader::FromFile(path);
360  RapidXmlReaderNode rootNode = doc->getRoot();
361  try
362  {
363  return rootNode.first_node("variable").attribute_value("value");
364  }
365  catch (exceptions::local::RapidXmlReaderException& exception)
366  {
367  ARMARX_DEBUG_S << "Your icegrid-sync-variables file is ill formatted (Error: " << exception.what() << ")";
368  return "";
369  }
370 }
371 
372 void IceGridXmlGenerator::setDefaultSyncFileDir(std::string path)
373 {
374  RapidXmlWriter doc;
375  RapidXmlWriterNode root = doc.createRootNode("icegrid");
376  RapidXmlWriterNode variableNode = root.append_node("variable");
377  variableNode.append_attribute("name", "ARMARX_SYNC_DIR");
378  variableNode.append_attribute("value", path);
379 
380  doc.saveToFile(ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml", true);
381 }
382 
383 IceGrid::ApplicationUpdateDescriptor IceGridXmlGenerator::generateUpdateDescriptor(IceGrid::ApplicationDescriptor descriptor)
384 {
385  IceGrid::ApplicationUpdateDescriptor result;
386  result.name = descriptor.name;
387  //There is currently no simple way to deep copy these constructs so just reuse the needed ones
388  for (auto nodes : descriptor.nodes)
389  {
390  IceGrid::NodeUpdateDescriptor nodeUpdate;
391  nodeUpdate.name = nodes.first;
392  nodeUpdate.serverInstances = nodes.second.serverInstances;
393  //nodeUpdate.description = nodes.second.description;
394  nodeUpdate.propertySets = nodes.second.propertySets;
395  nodeUpdate.serverInstances = nodes.second.serverInstances;
396  nodeUpdate.servers = nodes.second.servers;
397  nodeUpdate.variables = nodes.second.variables;
398  result.nodes.push_back(nodeUpdate);
399  }
400 
401  result.serverTemplates = descriptor.serverTemplates;
402  result.serviceTemplates = descriptor.serviceTemplates;
403  result.variables = result.variables;
404 
405  return result;
406 }
407 
408 std::string IceGridXmlGenerator::getDefaultSyncFile()
409 {
410  return getSyncDirFromFile(ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml");
411 }
armarx::RapidXmlReaderPtr
std::shared_ptr< RapidXmlReader > RapidXmlReaderPtr
Definition: RapidXmlReader.h:66
IceStatusReader.h
ScenarioManager::Data_Structure::ApplicationInstancePtr
std::shared_ptr< ApplicationInstance > ApplicationInstancePtr
Definition: ApplicationInstance.h:33
armarx::RapidXmlWriter
Definition: RapidXmlWriter.h:99
ScenarioManager::Data_Structure::ScenarioPtr
std::shared_ptr< Scenario > ScenarioPtr
Definition: Scenario.h:36
ScenarioManager::Generator::IceGridXmlGenerator::generateLocalApplication
void generateLocalApplication(Data_Structure::ScenarioPtr scenario)
Definition: IceGridXmlGenerator.cpp:45
ScenarioManager::Parser::DependenciesGenerator::getDependencieTree
static DependencyTree getDependencieTree(std::string packageName)
Definition: DependenciesGenerator.cpp:46
armarx::exceptions::local::RapidXmlReaderException
Definition: RapidXmlReader.h:45
armarx::RapidXmlReaderNode::attribute_value
std::string attribute_value(const char *attrName) const
Definition: RapidXmlReader.h:198
armarx::CMakePackageFinder
The CMakePackageFinder class provides an interface to the CMake Package finder capabilities.
Definition: CMakePackageFinder.h:53
RapidXmlWriter.h
ScenarioManager::Generator::IceGridXmlGenerator::generateRemoteApplication
void generateRemoteApplication(Data_Structure::ScenarioPtr scenario)
Definition: IceGridXmlGenerator.cpp:114
ScenarioManager::Generator::IceGridXmlGenerator::setDefaultSyncFileDir
void setDefaultSyncFileDir(std::string path)
Definition: IceGridXmlGenerator.cpp:372
ScenarioManager::Generator::IceGridXmlGenerator::generateComponent
void generateComponent(Data_Structure::ApplicationInstancePtr app)
Definition: IceGridXmlGenerator.cpp:181
ScenarioManager::Generator::IceGridXmlGenerator::generateLocalApplicationDescriptor
IceGrid::ApplicationDescriptor generateLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition: IceGridXmlGenerator.cpp:262
ARMARX_DEBUG_S
#define ARMARX_DEBUG_S
Definition: Logging.h:198
armarx::CMakePackageFinder::getBinaryDir
std::string getBinaryDir() const
Definition: CMakePackageFinder.h:159
ScenarioManager::Generator::IceGridXmlGenerator::generateEmptyRemoteApplicationDescriptor
IceGrid::ApplicationDescriptor generateEmptyRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition: IceGridXmlGenerator.cpp:279
DependenciesGenerator.h
ScenarioManager::Generator::IceGridXmlGenerator::generateUpdateDescriptor
IceGrid::ApplicationUpdateDescriptor generateUpdateDescriptor(IceGrid::ApplicationDescriptor descriptor)
Definition: IceGridXmlGenerator.cpp:383
IceManager.h
armarx::RapidXmlReaderNode
Definition: RapidXmlReader.h:68
IceGridAdmin.h
IceGridXmlGenerator.h
armarx::RapidXmlWriterNode::append_attribute
RapidXmlWriterNode & append_attribute(const std::string &name, const std::string &value)
Definition: RapidXmlWriter.h:54
ScenarioManager::Generator::IceGridXmlGenerator::generateComponentNode
IceGrid::ServerInstanceDescriptor generateComponentNode(Data_Structure::ApplicationInstancePtr app)
Definition: IceGridXmlGenerator.cpp:335
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:102
ScenarioManager
Definition: Application.cpp:166
ScenarioManager::Generator::IceGridXmlGenerator::generateRemoteApplicationDescriptor
IceGrid::ApplicationDescriptor generateRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition: IceGridXmlGenerator.cpp:317
armarx::RapidXmlWriter::saveToFile
void saveToFile(const std::string &path, bool indent)
Definition: RapidXmlWriter.h:126
RapidXmlReader.h
ScenarioManager::Generator::IceGridXmlGenerator::generateEmptyLocalApplicationDescriptor
IceGrid::ApplicationDescriptor generateEmptyLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition: IceGridXmlGenerator.cpp:223
armarx::RapidXmlWriter::createRootNode
RapidXmlWriterNode createRootNode(const std::string &name)
Definition: RapidXmlWriter.h:113
armarx::RapidXmlWriterNode::append_node
RapidXmlWriterNode append_node(const std::string &name)
Definition: RapidXmlWriter.h:73
armarx::RapidXmlWriterNode
Definition: RapidXmlWriter.h:34
ScenarioManager::Exec::IceStatusReader::GetApplicationId
static std::string GetApplicationId(const ApplicationInstancePtr &application)
Definition: IceStatusReader.cpp:89
ArmarXDataPath.h
armarx::RapidXmlReaderNode::first_node
RapidXmlReaderNode first_node(const char *name=nullptr) const
Definition: RapidXmlReader.h:140
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition: ArmarXTimeserver.cpp:28
ScenarioManager::Generator::IceGridXmlGenerator::getDefaultSyncFile
std::string getDefaultSyncFile()
Definition: IceGridXmlGenerator.cpp:408