nodeset.py 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. ### This Source Code Form is subject to the terms of the Mozilla Public
  4. ### License, v. 2.0. If a copy of the MPL was not distributed with this
  5. ### file, You can obtain one at http://mozilla.org/MPL/2.0/.
  6. ### Copyright 2014-2015 (c) TU-Dresden (Author: Chris Iatrou)
  7. ### Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer)
  8. ### Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH
  9. from __future__ import print_function
  10. import sys
  11. import xml.dom.minidom as dom
  12. import logging
  13. import codecs
  14. import re
  15. from datatypes import *
  16. from nodes import *
  17. from opaque_type_mapping import opaque_type_mapping
  18. __all__ = ['NodeSet', 'getSubTypesOf']
  19. logger = logging.getLogger(__name__)
  20. if sys.version_info[0] >= 3:
  21. # strings are already parsed to unicode
  22. def unicode(s):
  23. return s
  24. string_types = str
  25. else:
  26. string_types = basestring
  27. ####################
  28. # Helper Functions #
  29. ####################
  30. hassubtype = NodeId("ns=0;i=45")
  31. def getSubTypesOf(nodeset, node, skipNodes=[]):
  32. if node in skipNodes:
  33. return []
  34. re = set()
  35. re.add(node)
  36. for ref in node.references:
  37. if (ref.referenceType == hassubtype):
  38. skipAll = set()
  39. skipAll.update(skipNodes)
  40. skipAll.update(re)
  41. if (ref.source == node.id and ref.isForward):
  42. re.update(getSubTypesOf(nodeset, nodeset.nodes[ref.target], skipNodes=skipAll))
  43. elif (ref.target == node.id and not ref.isForward):
  44. re.update(getSubTypesOf(nodeset, nodeset.nodes[ref.source], skipNodes=skipAll))
  45. return re
  46. def extractNamespaces(xmlfile):
  47. # Extract a list of namespaces used. The first namespace is always
  48. # "http://opcfoundation.org/UA/". minidom gobbles up
  49. # <NamespaceUris></NamespaceUris> elements, without a decent way to reliably
  50. # access this dom2 <uri></uri> elements (only attribute xmlns= are accessible
  51. # using minidom). We need them for dereferencing though... This function
  52. # attempts to do just that.
  53. namespaces = ["http://opcfoundation.org/UA/"]
  54. infile = codecs.open(xmlfile.name, encoding='utf-8')
  55. foundURIs = False
  56. nsline = ""
  57. for line in infile:
  58. if "<namespaceuris>" in line.lower():
  59. foundURIs = True
  60. elif "</namespaceuris>" in line.lower():
  61. nsline = nsline + line
  62. break
  63. if foundURIs:
  64. nsline = nsline + line
  65. if len(nsline) > 0:
  66. ns = dom.parseString(nsline).getElementsByTagName("NamespaceUris")
  67. for uri in ns[0].childNodes:
  68. if uri.nodeType != uri.ELEMENT_NODE:
  69. continue
  70. if uri.firstChild.data in namespaces:
  71. continue
  72. namespaces.append(uri.firstChild.data)
  73. infile.close()
  74. return namespaces
  75. def buildAliasList(xmlelement):
  76. """Parses the <Alias> XML Element present in must XML NodeSet definitions.
  77. Contents the Alias element are stored in a dictionary for further
  78. dereferencing during pointer linkage (see linkOpenPointer())."""
  79. aliases = {}
  80. for al in xmlelement.childNodes:
  81. if al.nodeType == al.ELEMENT_NODE:
  82. if al.hasAttribute("Alias"):
  83. aliasst = al.getAttribute("Alias")
  84. aliasnd = unicode(al.firstChild.data)
  85. aliases[aliasst] = aliasnd
  86. return aliases
  87. class NodeSet(object):
  88. """ This class handles parsing XML description of namespaces, instantiating
  89. nodes, linking references, graphing the namespace and compiling a binary
  90. representation.
  91. Note that nodes assigned to this class are not restricted to having a
  92. single namespace ID. This class represents the entire physical address
  93. space of the binary representation and all nodes that are to be included
  94. in that segment of memory.
  95. """
  96. def __init__(self):
  97. self.nodes = {}
  98. self.aliases = {}
  99. self.namespaces = ["http://opcfoundation.org/UA/"]
  100. self.namespaceMapping = {};
  101. def sanitize(self):
  102. for n in self.nodes.values():
  103. if n.sanitize() == False:
  104. raise Exception("Failed to sanitize node " + str(n))
  105. # Sanitize reference consistency
  106. for n in self.nodes.values():
  107. for ref in n.references:
  108. if not ref.source == n.id:
  109. raise Exception("Reference " + str(ref) + " has an invalid source")
  110. if not ref.referenceType in self.nodes:
  111. raise Exception("Reference " + str(ref) + " has an unknown reference type")
  112. if not ref.target in self.nodes:
  113. raise Exception("Reference " + str(ref) + " has an unknown target")
  114. def addNamespace(self, nsURL):
  115. if not nsURL in self.namespaces:
  116. self.namespaces.append(nsURL)
  117. def createNamespaceMapping(self, orig_namespaces):
  118. """Creates a dict that maps from the nsindex in the original nodeset to the
  119. nsindex in the combined nodeset"""
  120. m = {}
  121. for index, name in enumerate(orig_namespaces):
  122. m[index] = self.namespaces.index(name)
  123. return m
  124. def getNodeByBrowseName(self, idstring):
  125. return next((n for n in self.nodes.values() if idstring == n.browseName.name), None)
  126. def getNodeById(self, namespace, id):
  127. nodeId = NodeId()
  128. nodeId.ns = namespace
  129. nodeId.i = id
  130. return self.nodes[nodeId]
  131. def getRoot(self):
  132. return self.getNodeByBrowseName("Root")
  133. def createNode(self, xmlelement, modelUri, hidden=False):
  134. ndtype = xmlelement.localName.lower()
  135. if ndtype[:2] == "ua":
  136. ndtype = ndtype[2:]
  137. node = None
  138. if ndtype == 'variable':
  139. node = VariableNode(xmlelement)
  140. if ndtype == 'object':
  141. node = ObjectNode(xmlelement)
  142. if ndtype == 'method':
  143. node = MethodNode(xmlelement)
  144. if ndtype == 'objecttype':
  145. node = ObjectTypeNode(xmlelement)
  146. if ndtype == 'variabletype':
  147. node = VariableTypeNode(xmlelement)
  148. if ndtype == 'methodtype':
  149. node = MethodNode(xmlelement)
  150. if ndtype == 'datatype':
  151. node = DataTypeNode(xmlelement)
  152. if ndtype == 'referencetype':
  153. node = ReferenceTypeNode(xmlelement)
  154. if node is None:
  155. return None
  156. node.modelUri = modelUri
  157. node.hidden = hidden
  158. return node
  159. def hide_node(self, nodeId, hidden=True):
  160. if not nodeId in self.nodes:
  161. return False
  162. node = self.nodes[nodeId]
  163. node.hidden = hidden
  164. return True
  165. def merge_dicts(self, *dict_args):
  166. """
  167. Given any number of dicts, shallow copy and merge into a new dict,
  168. precedence goes to key value pairs in latter dicts.
  169. """
  170. result = {}
  171. for dictionary in dict_args:
  172. result.update(dictionary)
  173. return result
  174. def addNodeSet(self, xmlfile, hidden=False, typesArray="UA_TYPES"):
  175. # Extract NodeSet DOM
  176. fileContent = xmlfile.read()
  177. # Remove BOM since the dom parser cannot handle it on python 3 windows
  178. if fileContent.startswith( codecs.BOM_UTF8 ):
  179. fileContent = fileContent.lstrip( codecs.BOM_UTF8 )
  180. if (sys.version_info >= (3, 0)):
  181. fileContent = fileContent.decode("utf-8")
  182. # Remove the uax namespace from tags. UaModeler adds this namespace to some elements
  183. fileContent = re.sub(r"<([/]?)uax:(.+?)([/]?)>", "<\g<1>\g<2>\g<3>>", fileContent)
  184. nodesets = dom.parseString(fileContent).getElementsByTagName("UANodeSet")
  185. if len(nodesets) == 0 or len(nodesets) > 1:
  186. raise Exception(self, self.originXML + " contains no or more then 1 nodeset")
  187. nodeset = nodesets[0]
  188. # Extract the modelUri
  189. try:
  190. modelTag = nodeset.getElementsByTagName("Models")[0].getElementsByTagName("Model")[0]
  191. modelUri = modelTag.attributes["ModelUri"].nodeValue
  192. except Exception:
  193. # Ignore exception and try to use namespace array
  194. modelUri = None
  195. # Create the namespace mapping
  196. orig_namespaces = extractNamespaces(xmlfile) # List of namespaces used in the xml file
  197. if modelUri is None and len(orig_namespaces) > 1:
  198. modelUri = orig_namespaces[1]
  199. if modelUri is None:
  200. raise Exception(self, self.originXML + " does not define the nodeset URI in Models/Model/ModelUri or NamespaceUris array.")
  201. for ns in orig_namespaces:
  202. self.addNamespace(ns)
  203. self.namespaceMapping[modelUri] = self.createNamespaceMapping(orig_namespaces)
  204. # Extract the aliases
  205. for nd in nodeset.childNodes:
  206. if nd.nodeType != nd.ELEMENT_NODE:
  207. continue
  208. ndtype = nd.localName.lower()
  209. if 'aliases' in ndtype:
  210. self.aliases = self.merge_dicts(self.aliases, buildAliasList(nd))
  211. # Instantiate nodes
  212. newnodes = []
  213. for nd in nodeset.childNodes:
  214. if nd.nodeType != nd.ELEMENT_NODE:
  215. continue
  216. node = self.createNode(nd, modelUri, hidden)
  217. if not node:
  218. continue
  219. node.replaceAliases(self.aliases)
  220. node.replaceNamespaces(self.namespaceMapping[modelUri])
  221. node.typesArray = typesArray
  222. # Add the node the the global dict
  223. if node.id in self.nodes:
  224. raise Exception("XMLElement with duplicate ID " + str(node.id))
  225. self.nodes[node.id] = node
  226. newnodes.append(node)
  227. def getBinaryEncodingIdForNode(self, nodeId):
  228. """
  229. The node should have a 'HasEncoding' forward reference which points to the encoding ids.
  230. These can be XML Encoding or Binary Encoding. Therefore we also need to check if the SymbolicName
  231. of the target node is "DefaultBinary"
  232. """
  233. node = self.nodes[nodeId]
  234. for ref in node.references:
  235. if ref.referenceType.ns == 0 and ref.referenceType.i == 38:
  236. refNode = self.nodes[ref.target]
  237. if refNode.symbolicName.value == "DefaultBinary":
  238. return ref.target
  239. raise Exception("No DefaultBinary encoding defined for node " + str(nodeId))
  240. def buildEncodingRules(self):
  241. """ Calls buildEncoding() for all DataType nodes (opcua_node_dataType_t).
  242. No return value
  243. """
  244. stat = {True: 0, False: 0}
  245. for n in self.nodes.values():
  246. if isinstance(n, DataTypeNode):
  247. n.buildEncoding(self)
  248. stat[n.isEncodable()] = stat[n.isEncodable()] + 1
  249. logger.debug("Type definitions built/passed: " + str(stat))
  250. def allocateVariables(self):
  251. for n in self.nodes.values():
  252. if isinstance(n, VariableNode):
  253. n.allocateValue(self)
  254. def getBaseDataType(self, node):
  255. if node is None:
  256. return None
  257. if node.browseName.name not in opaque_type_mapping:
  258. return node
  259. for ref in node.references:
  260. if ref.isForward:
  261. continue
  262. if ref.referenceType.i == 45:
  263. return self.getBaseDataType(self.nodes[ref.target])
  264. return node
  265. def getNodeTypeDefinition(self, node):
  266. for ref in node.references:
  267. # 40 = HasTypeDefinition
  268. if ref.referenceType.i == 40 and ref.isForward:
  269. return self.nodes[ref.target]
  270. return None
  271. def getDataTypeNode(self, dataType):
  272. if isinstance(dataType, string_types):
  273. if not valueIsInternalType(dataType):
  274. logger.error("Not a valid dataType string: " + dataType)
  275. return None
  276. return self.nodes[NodeId(self.aliases[dataType])]
  277. if isinstance(dataType, NodeId):
  278. if dataType.i == 0:
  279. return None
  280. dataTypeNode = self.nodes[dataType]
  281. if not isinstance(dataTypeNode, DataTypeNode):
  282. logger.error("Node id " + str(dataType) + " is not reference a valid dataType.")
  283. return None
  284. if not dataTypeNode.isEncodable():
  285. logger.warn("DataType " + str(dataTypeNode.browseName) + " is not encodable.")
  286. return dataTypeNode
  287. return None
  288. def getRelevantOrderingReferences(self):
  289. relevant_types = set()
  290. relevant_types.update(getSubTypesOf(self, self.getNodeByBrowseName("HierarchicalReferences"), []))
  291. relevant_types.update(getSubTypesOf(self, self.getNodeByBrowseName("HasEncoding"), []))
  292. relevant_types.update(getSubTypesOf(self, self.getNodeByBrowseName("HasTypeDefinition"), []))
  293. return list(map(lambda x: x.id, relevant_types))
  294. def addInverseReferences(self):
  295. # Ensure that every reference has an inverse reference in the target
  296. for u in self.nodes.values():
  297. for ref in u.references:
  298. back = Reference(ref.target, ref.referenceType, ref.source, not ref.isForward)
  299. self.nodes[ref.target].references.add(back) # ref set does not make a duplicate entry
  300. def setNodeParent(self):
  301. parentreftypes = getSubTypesOf(self, self.getNodeByBrowseName("HierarchicalReferences"))
  302. parentreftypes = list(map(lambda x: x.id, parentreftypes))
  303. for node in self.nodes.values():
  304. parentref = node.getParentReference(parentreftypes)
  305. if parentref is not None:
  306. node.parent = self.nodes[parentref.target]
  307. node.parentReference = self.nodes[parentref.referenceType]