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 includeAppNode = existingNodes.find(app->getEffectiveNodeName())->second.append_node("include");
101  if (app->getInstanceName().empty())
102  {
103  includeAppNode.append_attribute("file", "icegrid/" + app->getName() + ".icegrid.xml");
104  }
105  else
106  {
107  includeAppNode.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 includeAppNode = existingNodes.find(app->getEffectiveNodeName())->second.append_node("include");
168  if (app->getInstanceName().empty())
169  {
170  includeAppNode.append_attribute("file", "icegrid/" + app->getName() + ".icegrid.xml");
171  }
172  else
173  {
174  includeAppNode.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 
252  result.serviceTemplates = defaultDesc.serviceTemplates;
253 
254  return result;
255 }
256 
257 IceGrid::ApplicationDescriptor IceGridXmlGenerator::generateLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
258 {
259  IceGrid::ApplicationDescriptor result = generateEmptyLocalApplicationDescriptor(scenario, iceAdmin);
260 
261  for (auto app : *scenario->getApplications())
262  {
263  if (!app->getEnabled())
264  {
265  continue;
266  }
267 
268  result.nodes[app->getEffectiveNodeName()].serverInstances.push_back(generateComponentNode(app));
269  }
270 
271  return result;
272 }
273 
274 IceGrid::ApplicationDescriptor IceGridXmlGenerator::generateEmptyRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
275 {
276  IceGrid::ApplicationDescriptor result;
277  result.name = scenario->getName();
278 
279  IceGrid::StringStringDict variables;
280  variables["ARMARX_SYNC_DIR"] = getDefaultSyncFile();
281  variables["ARMARX_SCENARIO_DIR"] = "${ARMARX_SYNC_DIR}/share/" + scenario->getPackage()->getName() + "/scenarios/" + scenario->getName();
282  variables["ARMARX_SCENARIO_DEPENDENCY_CONFIG"] = "dependencies.remote.cfg";
283  variables["ARMARX_PACKAGE_CONFIG_DIR"] = "${ARMARX_SYNC_DIR}/share/" + scenario->getPackage()->getName() + "/config";
284  variables["ArmarX_LD_LIB_PATH"] = "${ARMARX_SYNC_DIR}/lib:${ARMARX_SYNC_DIR}/usr/lib";
285  variables["ArmarX_PATH"] = "${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin";
286  variables["ARMARX_LOGGING_GROUP"] = scenario->getName();
287  // variables["CMAKE_PREFIX_PATH"] = "${ARMARX_SYNC_DIR}";
288 
289 
290  for (auto dep : Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
291  {
292  variables[dep + "_BIN_DIR"] = "${ARMARX_SYNC_DIR}/bin";
293  }
294 
295  result.variables = variables;
296 
297  IceGrid::ApplicationDescriptor defaultDesc = iceAdmin->getDefaultApplicationDescriptor();
298  result.serverTemplates = defaultDesc.serverTemplates;
299  auto v = IceGrid::ServerDescriptorPtr::dynamicCast(result.serverTemplates["ArmarXComponentTemplate"].descriptor.get());
300  ARMARX_CHECK_EXPRESSION(v);
301 
302 
303  result.serviceTemplates = defaultDesc.serviceTemplates;
304 
305  return result;
306 }
307 
308 IceGrid::ApplicationDescriptor IceGridXmlGenerator::generateRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
309 {
310  //CMakePackageFinder finder(scenario->getPackage()->getName());
311 
312  IceGrid::ApplicationDescriptor result = generateEmptyRemoteApplicationDescriptor(scenario, iceAdmin);
313 
314  for (auto app : *scenario->getApplications())
315  {
316  if (!app->getEnabled())
317  {
318  continue;
319  }
320  result.nodes[app->getEffectiveNodeName()].serverInstances.push_back(generateComponentNode(app));
321  }
322 
323  return result;
324 }
325 
326 IceGrid::ServerInstanceDescriptor IceGridXmlGenerator::generateComponentNode(Data_Structure::ApplicationInstancePtr app)
327 {
328  IceGrid::ServerInstanceDescriptor result;
329  result._cpp_template = "ArmarXComponentTemplate";
330  result.parameterValues["component"] = app->getName();
331  result.parameterValues["componentId"] = Exec::IceStatusReader::GetApplicationId(app);
332  result.parameterValues["componentExeDir"] = "${" + app->getPackageName() + "_BIN_DIR}";
333 
334  std::string armarXConfigValue = (app->getScenario()->isGlobalConfigFileexistent() ? app->getScenario()->getGlobalConfigPath() + "," : "")
335  + (app->getInstanceName().empty() ? "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + ".cfg" : "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + "." + app->getInstanceName() + ".cfg");
336 
337  result.parameterValues["configDomain"] = app->getConfigDomain();
338  result.parameterValues["ArmarXConfig"] = armarXConfigValue;
339  result.parameterValues["ArmarXDependenciesConfig"] = "${ARMARX_PACKAGE_CONFIG_DIR}/${ARMARX_SCENARIO_DEPENDENCY_CONFIG}";
340  result.parameterValues["ArmarXLoggingGroup"] = app->getScenario()->getName();
341  result.parameterValues["activationTimeout"] = "10";
342 
343 
344  return result;
345 }
346 
347 std::string IceGridXmlGenerator::getSyncDirFromFile(std::string path)
348 {
349  RapidXmlReaderPtr doc = RapidXmlReader::FromFile(path);
350  RapidXmlReaderNode rootNode = doc->getRoot();
351  try
352  {
353  return rootNode.first_node("variable").attribute_value("value");
354  }
355  catch (exceptions::local::RapidXmlReaderException& exception)
356  {
357  ARMARX_DEBUG_S << "Your icegrid-sync-variables file is ill formatted (Error: " << exception.what() << ")";
358  return "";
359  }
360 }
361 
362 void IceGridXmlGenerator::setDefaultSyncFileDir(std::string path)
363 {
364  RapidXmlWriter doc;
365  RapidXmlWriterNode root = doc.createRootNode("icegrid");
366  RapidXmlWriterNode variableNode = root.append_node("variable");
367  variableNode.append_attribute("name", "ARMARX_SYNC_DIR");
368  variableNode.append_attribute("value", path);
369 
370  doc.saveToFile(ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml", true);
371 }
372 
373 IceGrid::ApplicationUpdateDescriptor IceGridXmlGenerator::generateUpdateDescriptor(IceGrid::ApplicationDescriptor descriptor)
374 {
375  IceGrid::ApplicationUpdateDescriptor result;
376  result.name = descriptor.name;
377  //There is currently no simple way to deep copy these constructs so just reuse the needed ones
378  for (auto nodes : descriptor.nodes)
379  {
380  IceGrid::NodeUpdateDescriptor nodeUpdate;
381  nodeUpdate.name = nodes.first;
382  nodeUpdate.serverInstances = nodes.second.serverInstances;
383  //nodeUpdate.description = nodes.second.description;
384  nodeUpdate.propertySets = nodes.second.propertySets;
385  nodeUpdate.serverInstances = nodes.second.serverInstances;
386  nodeUpdate.servers = nodes.second.servers;
387  nodeUpdate.variables = nodes.second.variables;
388  result.nodes.push_back(nodeUpdate);
389  }
390 
391  result.serverTemplates = descriptor.serverTemplates;
392  result.serviceTemplates = descriptor.serviceTemplates;
393  result.variables = result.variables;
394 
395  return result;
396 }
397 
398 std::string IceGridXmlGenerator::getDefaultSyncFile()
399 {
400  return getSyncDirFromFile(ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml");
401 }
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:362
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:257
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:274
DependenciesGenerator.h
ScenarioManager::Generator::IceGridXmlGenerator::generateUpdateDescriptor
IceGrid::ApplicationUpdateDescriptor generateUpdateDescriptor(IceGrid::ApplicationDescriptor descriptor)
Definition: IceGridXmlGenerator.cpp:373
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:326
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:308
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:15
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:398