2 # -*- coding: utf-8 -*-
4 from nepi.core.attributes import Attribute
5 from nepi.util.parser.base import ExperimentData, ExperimentParser
6 from xml.dom import minidom
8 class XmlExperimentParser(ExperimentParser):
9 def to_xml(self, experiment_description):
10 data = self.to_data(experiment_description)
11 doc = minidom.Document()
12 exp_tag = doc.createElement("experiment")
13 testbeds_tag = doc.createElement("testbeds")
14 exp_tag.appendChild(testbeds_tag)
16 elements_tags = dict()
17 for guid in data.guids:
18 if data.is_testbed_data(guid):
19 elements_tag = self.testbed_data_to_xml(doc, testbeds_tag, guid, data)
20 elements_tags[guid] = elements_tag
22 self.box_data_to_xml(doc, elements_tags, guid, data)
23 doc.appendChild(exp_tag)
24 xml = doc.toprettyxml(indent=" ", encoding="UTF-8")
27 def testbed_data_to_xml(self, doc, parent_tag, guid, data):
28 testbed_tag = doc.createElement("testbed")
29 testbed_tag.setAttribute("guid", str(guid))
30 (testbed_id, testbed_version) = data.get_testbed_data(guid)
31 testbed_tag.setAttribute("testbed_id", str(testbed_id))
32 testbed_tag.setAttribute("testbed_version", str(testbed_version))
33 parent_tag.appendChild(testbed_tag)
34 self.attributes_data_to_xml(doc, testbed_tag, guid, data)
35 elements_tag = doc.createElement("elements")
36 testbed_tag.appendChild(elements_tag)
39 def box_data_to_xml(self, doc, elements_tags, guid, data):
40 (testbed_guid, factory_id) = data.get_box_data(guid)
41 element_tag = doc.createElement("element")
42 parent_tag = elements_tags[testbed_guid]
43 parent_tag.appendChild(element_tag)
44 element_tag.setAttribute("factory_id", factory_id)
45 element_tag.setAttribute("guid", str(guid))
46 self.factory_attributes_data_to_xml(doc, element_tag, guid, data)
47 self.attributes_data_to_xml(doc, element_tag, guid, data)
48 self.traces_data_to_xml(doc, element_tag, guid, data)
49 self.addresses_data_to_xml(doc, element_tag, guid, data)
50 self.routes_data_to_xml(doc, element_tag, guid, data)
51 self.connections_data_to_xml(doc, element_tag, guid, data)
53 def factory_attributes_data_to_xml(self, doc, parent_tag, guid, data):
54 factory_attributes_tag = doc.createElement("factory_attributes")
55 parent_tag.appendChild(factory_attributes_tag)
56 for (name, value) in data.get_factory_attribute_data(guid):
57 factory_attribute_tag = doc.createElement("factory_attribute")
58 factory_attributes_tag.appendChild(factory_attribute_tag)
59 factory_attribute_tag.setAttribute("name", name)
60 factory_attribute_tag.setAttribute("value", str(value))
61 factory_attribute_tag.setAttribute("type", self.type_to_standard(value))
63 def attributes_data_to_xml(self, doc, parent_tag, guid, data):
64 attributes_tag = doc.createElement("attributes")
65 parent_tag.appendChild(attributes_tag)
66 for name, value in data.get_attribute_data(guid):
67 attribute_tag = doc.createElement("attribute")
68 attributes_tag.appendChild(attribute_tag)
69 attribute_tag.setAttribute("name", name)
70 attribute_tag.setAttribute("value", str(value))
71 attribute_tag.setAttribute("type", self.type_to_standard(value))
73 def traces_data_to_xml(self, doc, parent_tag, guid, data):
74 traces_tag = doc.createElement("traces")
75 parent_tag.appendChild(traces_tag)
76 for name in data.get_trace_data(guid):
77 trace_tag = doc.createElement("trace")
78 traces_tag.appendChild(trace_tag)
79 trace_tag.setAttribute("name", name)
81 def addresses_data_to_xml(self, doc, parent_tag, guid, data):
82 addresses_tag = doc.createElement("addresses")
83 parent_tag.appendChild(addresses_tag)
84 for (autoconfigure, address, family, netprefix, broadcast) \
85 in data.get_address_data(guid):
86 address_tag = doc.createElement("address")
87 addresses_tag.appendChild(address_tag)
89 address_tag.setAttribute("AutoConfigure", str(autoconf))
91 address_tag.setAttribute("Address", str(address))
93 address_tag.setAttribute("Family", str(family))
95 address_tag.setAttribute("NetPrefix", str(netprefix))
97 address_tag.setAttribute("Broadcast", str(broadcast))
99 def routes_data_to_xml(self, doc, parent_tag, guid, data):
100 routes_tag = doc.createElement("routes")
101 parent_tag.appendChild(routes_tag)
102 for (family, destination, netprefix, nexthop, interface) \
103 in data.get_route_data(guid):
104 route_tag = doc.createElement("route")
105 routes_tag.appendChild(route_tag)
106 route_tag.setAttribute("Family", str(family))
107 route_tag.setAttribute("Destination", str(destination))
108 route_tag.setAttribute("NetPrefix", str(netprefix))
109 route_tag.setAttribute("NextHop", str(nexthop))
110 route_tag.setAttribute("Interface", str(interface))
112 def connections_data_to_xml(self, doc, parent_tag, guid, data):
113 connections_tag = doc.createElement("connections")
114 parent_tag.appendChild(connections_tag)
115 for (connector_type_name, other_guid, other_connector_type_name) \
116 in data.get_connection_data(guid):
117 connection_tag = doc.createElement("connection")
118 connections_tag.appendChild(connection_tag)
119 connection_tag.setAttribute("connector", connector_type_name)
120 connection_tag.setAttribute("other_guid", str(other_guid))
121 connection_tag.setAttribute("other_connector",
122 other_connector_type_name)
124 def from_xml(self, experiment_description, xml):
125 data = ExperimentData()
126 doc = minidom.parseString(xml)
127 testbeds_tag = doc.getElementsByTagName("testbeds")[0]
128 testbed_tag_list = testbeds_tag.getElementsByTagName("testbed")
129 for testbed_tag in testbed_tag_list:
130 if testbed_tag.nodeType == doc.ELEMENT_NODE:
131 testbed_guid = int(testbed_tag.getAttribute("guid"))
132 self.testbed_data_from_xml(testbed_tag, data)
133 elements_tag = testbed_tag.getElementsByTagName("elements")[0]
134 element_tag_list = elements_tag.getElementsByTagName("element")
135 for element_tag in element_tag_list:
136 if element_tag.nodeType == doc.ELEMENT_NODE:
137 self.box_data_from_xml(element_tag, testbed_guid, data)
138 self.from_data(experiment_description, data)
140 def testbed_data_from_xml(self, tag, data):
141 testbed_guid = int(tag.getAttribute("guid"))
142 testbed_id = str(tag.getAttribute("testbed_id"))
143 testbed_version = str(tag.getAttribute("testbed_version"))
144 data.add_testbed_data(testbed_guid, testbed_id, testbed_version)
145 self.attributes_data_from_xml(tag, testbed_guid, data)
147 def box_data_from_xml(self, tag, testbed_guid, data):
148 guid = int(tag.getAttribute("guid"))
149 factory_id = str(tag.getAttribute("factory_id"))
150 data.add_box_data(guid, testbed_guid, factory_id)
151 self.factory_attributes_data_from_xml(tag, guid, data)
152 self.attributes_data_from_xml(tag, guid, data)
153 self.traces_data_from_xml(tag, guid, data)
154 self.addresses_data_from_xml(tag, guid, data)
155 self.routes_data_from_xml(tag, guid, data)
156 self.connections_data_from_xml(tag, guid, data)
158 def factory_attributes_data_from_xml(self, tag, guid, data):
159 factory_attributes_tag_list = tag.getElementsByTagName(
160 "factory_attributes")
161 if len(factory_attributes_tag_list) == 0:
164 factory_attribute_tag_list = factory_attributes_tag_list[0].\
165 getElementsByTagName("factory_attribute")
166 for factory_attribute_tag in factory_attribute_tag_list:
167 if factory_attribute_tag.nodeType == tag.ELEMENT_NODE:
168 name = str(factory_attribute_tag.getAttribute("name"))
169 value = factory_attribute_tag.getAttribute("value")
170 std_type = factory_attribute_tag.getAttribute("type")
171 value = self.type_from_standard(std_type, value)
172 data.add_factory_attribute_data(guid, name, value)
174 def attributes_data_from_xml(self, tag, guid, data):
175 attributes_tag_list= tag.getElementsByTagName("attributes")
176 if len(attributes_tag_list) == 0:
179 attribute_tag_list = attributes_tag_list[0].\
180 getElementsByTagName("attribute")
181 for attribute_tag in attribute_tag_list:
182 if attribute_tag.nodeType == tag.ELEMENT_NODE:
183 name = str(attribute_tag.getAttribute("name"))
184 value = attribute_tag.getAttribute("value")
185 std_type = attribute_tag.getAttribute("type")
186 value = self.type_from_standard(std_type, value)
187 data.add_attribute_data(guid, name, value)
189 def traces_data_from_xml(self, tag, guid, data):
190 traces_tag_list = tag.getElementsByTagName("traces")
191 if len(traces_tag_list) == 0:
194 trace_tag_list = traces_tag_list[0].getElementsByTagName(
196 for trace_tag in trace_tag_list:
197 if trace_tag.nodeType == tag.ELEMENT_NODE:
198 name = str(trace_tag.getAttribute("name"))
199 data.add_trace_data(guid, name)
201 def addresses_data_from_xml(self, tag, guid, data):
202 addresses_tag_list = tag.getElementsByTagName("addresses")
203 if len(addresses_tag_list) == 0:
206 address_tag_list = addresses_tag_list[0].\
207 getElementsByTagName("address")
208 for address_tag in address_tag_list:
209 if address_tag.nodeType == tag.ELEMENT_NODE:
210 autoconf = bool(address_tag.getAttribute("AutoConfigure")) \
211 if address_tag.hasAttribute("AutoConfigure") else None
212 address = str(address_tag.getAttribute("Address")) \
213 if address_tag.hasAttribute("Address") else None
214 family = int(address_tag.getAttribute("Family")) \
215 if address_tag.hasAttribute("Family") else None
216 netprefix = int(address_tag.getAttribute("NetPrefix")) \
217 if address_tag.hasAttribute("NetPrefix") else None
218 broadcast = str(address_tag.getAttribute("Broadcast")) \
219 if address_tag.hasAttribute("Broadcast") else None
220 data.add_address_data(guid, autoconf, address, family,
221 netprefix, broadcast)
223 def routes_data_from_xml(self, tag, guid, data):
224 routes_tag_list = tag.getElementsByTagName("routes")
225 if len(routes_tag_list) == 0:
228 route_tag_list = routes_tag_list[0].getElementsByTagName("route")
229 for route_tag in route_tag_list:
230 if route_tag.nodeType == tag.ELEMENT_NODE:
231 family = int(route_tag.getAttribute("Family"))
232 destination = str(route_tag.getAttribute("Destination"))
233 netprefix = int(route_tag.getAttribute("NetPrefix"))
234 nexthop = str(route_tag.getAttribute("NextHop"))
235 interface = str(route_tag.getAttribute("Interface"))
236 data.add_route_data(guid, family, destination, netprefix,
239 def connections_data_from_xml(self, tag, guid, data):
240 connections_tag_list = tag.getElementsByTagName("connections")
241 if len(connections_tag_list) == 0:
244 connection_tag_list = connections_tag_list[0].getElementsByTagName(
246 for connection_tag in connection_tag_list:
247 if connection_tag.nodeType == tag.ELEMENT_NODE:
248 connector_type_name = str(connection_tag.getAttribute(
250 other_connector_type_name = str(connection_tag.getAttribute(
252 other_guid = int(connection_tag.getAttribute("other_guid"))
253 data.add_connection_data(guid, connector_type_name,
254 other_guid, other_connector_type_name)
256 def type_to_standard(self, value):
257 if type(value) == str:
258 return Attribute.STRING
259 if type(value) == bool:
260 return Attribute.BOOL
261 if type(value) == int:
262 return Attribute.INTEGER
263 if type(value) == float:
264 return Attribute.DOUBLE
266 def type_from_standard(self, type, value):
267 if type == Attribute.STRING:
269 if type == Attribute.BOOL:
271 if type == Attribute.INTEGER:
273 if type == Attribute.DOUBLE: